a ==ic<@stddlZddlZddlmZmZmZddlmZddZ ddZ dd Z dd d Z Gd dde ZGdddZdS)N)core workspace net_drawer) caffe2_pb2cCstj|dd|jDS)NcSsg|] }|dqS)_grad).0srro/home/droni/.local/share/virtualenvs/DPS-5Je3_V2c/lib/python3.9/site-packages/caffe2/python/gradient_checker.py z$getGradientForOp..)rZGradientRegistryZGetGradientForOpoutput)oprrr getGradientForOpsrcCs^||}t|tjrtj|St|tjs.Jd}td|j|j|g|}t |tj|S)NZtmp_dense_gradZ SparseToDense) isinstancerZ BlobReferencerblobs GradientSliceCreateOperatorindicesvaluesRunOperatorOnce)grad_mapinput_to_checkZ grad_blobZ dense_gradsparse_to_dense_oprrr _get_grad_blobs    rc s||d}|||p"iD]\}}|tj|<q(|D],}|vsZJd|t|tjvs@Jq@t|dd|D} fdd|D} | | |fS)NZ_copyz.{} has no gradient, cannot check net gradient.cSsg|]}|tj|fqSrrrrr rrr r 6r z_get_grad..csi|]}|t|qSr)r)rrrrr 7sz_get_grad..) ZCloneNameZAddGradientOperatorsitemsrrformatstr RunNetOnce) netoutputsoutputs_with_grad input_valuesinputs_with_gradsZgrad_netnamevaluerZforward_resultsZgradsrrr _get_grad(s"     r+cCs:tjj|||||dt||}t|t|fS)N)atolrtolerr_msg)nptestingZassert_allcloseabsflattenmeanmax)Zvalue1value2 thresholdr/deltarrr _assert_close=sr9c@s(eZdZed ddZed d d ZdS) NetGradientCheckerNHz>Fc sfdd|rxt|D]^\}}t|} tdt||dd} | | Wdq1sl0Yqfddt||D} |rt| \} } } t| D]`\}}t|} tdt||dd} | | Wdq1s0Yq| d \}}} | d dD]\}}} t |t |ksLJtt||D]0\}\\}}\}}t |||d |||d qZ| | ksJ| D]$\}}t ||||d |d qq,dS)NcsfddDS)Ncsg|] }|qSrr)ri net_outputsrr r Nr zWNetGradientChecker.CompareNets.._get_output_with_grad_names..rr=)outputs_with_grad_idsr=r _get_output_with_grad_namesMszCNetGradientChecker.CompareNets.._get_output_with_grad_namesZcaffe2_net_forward_z.pngwbcs$g|]\}}t|||qSr)r+)rr$r>)r@r'r(rr r Xs z2NetGradientChecker.CompareNets..Z caffe2_net_rzVDifferent forward pass results for output id {}. Corresponding output blobs: {} and {})r/z Different gradients for input {}) enumeraterZ GetPydotGraphZ create_pngopenr"rwriteziplenr9r!keysr )netsr%r?r(r'r7Zprint_net_imagesr<r$Zpngfresults_Z backward_netsZfirst_net_resultsZfirst_net_grads net_results net_gradsidxZblob1Z blob_value1Zblob2Z blob_value2blobZblob_grad_valuer)r@r'r(r?r CompareNetsIsJ *,  zNetGradientChecker.CompareNets-C6?皙?Tcst|gg\}}|} fdd} fdd} t} tjD]8} | | | |}| | | | }|||d| j| <qZd|}|r|d|7}t | | ||S)Ncs*|tj<ttddDS)NcSsg|]}tj|qSrrrrrr r sz=NetGradientChecker.Check..GetLoss..)rrr#sum) new_value)full_netrr&rr GetLosss   z)NetGradientChecker.Check..GetLosscs"}|j||7<|SN)copyflat)dimr8Z input_value)rr'rr GetValues z*NetGradientChecker.Check..GetValuez'Error in gradient check for net_copy {}z: {}) r+r0 zeros_likerangesizerZr!rZProtor9)r$r&r'rZ step_sizer7Z print_netrMrNZ analytic_gradrWr\ grad_estimater[pos_lossneg_lossr/r)rVrr'r&r Checkxs" zNetGradientChecker.Check)Nr;F)rRrST)__name__ __module__ __qualname__ staticmethodrQrdrrrr r:Hs .r:c@s4eZdZdZd ddZddZdd d Zd d ZdS)GradientCheckerzA gradient checker in Python. This is not the most efficient way to check gradients, as the Python interface will involve a lot of copies back and forth operations. Use at your own risk. Ngradient_checkcCs:||_||_|pt|_||_|dur0i|_n||_dSrX) _stepsize _thresholdrZ DeviceOption_device_option_workspace_name_input_device_options)selfZstepsizer7 device_optionZworkspace_nameinput_device_optionsrrr __init__szGradientChecker.__init__c Csxtt|D]*}t|||||j|||jq ||} t|d} |D]<} |j| } t | } | | d 7} t| d| |jqR| d} t |t |t jrftdtj| tjdtdtjdtjdt jd |j|jd |jd }t jd |j|jd |jd }t d dd|jd |jd dgd}t|t|t|t d}n t |}| |fS) Ngr]rg@Zzeros)dtypeonesrBZEnsureCPUOutputZ_cpu)rqZScatterWeightedSum)r_rGrFeedBlobrogetrmrr FetchBlobrTZRunOperatorsOncerrrr0r^float32rurrr)rprgrad_opsinputsZ input_namesr grad_nameoutputs_with_gradsr<xlossrOr)arrZ gv_cpu_opZ gi_cpu_oprgradrrr GetLossAndGradsP            zGradientChecker.GetLossAndGradFc Cslt}|j|kr t|jd|j|j|durBt|\}} |pRt |d} t |D],\} } t |j | | | |j | |jq\| |} |||||j || |\}}t||}|j|jkrtd|j|j|r|||tddk}||j}t|D]}|sB|dkrB|d|krB|j||j|<q ||j||j7<|||||j || |\}}||j||jd8<|||||j || |\}}||j||j7<|||jd|j|<q tj|||j|jd }t|r@t|}td tt ||j||j|gj!d }nd}|j|krbt"t||||fS) aChecks the operator in a very simple fashion by stacking a sum of squares on the top. Inputs: op: the operator to be checked. inputs: the input data in numpy arrays. input_to_check: an index specifying which input blob we should check. outputs_with_grads: indices specifying which output blobs will we need to check gradients with. For these outputs, we will collect a squared sum and also feed in their gradients. grad_operator: the gradient operator. If not given, we will get the gradient operator from the gradient registry. input_device_options: an optional mapping from input names to DeviceOptions (to override the default DeviceOption) ensure_outputs_are_inferred: if set will assert that the gradient output shapes matches the inferred shapes Outputs: boolean: True if it passes, False if it does not pass. TNrz5Mismatched gradient shapes: estimated ({}), grad ({})ZCAFFE2_FULL_GRAD_CHECK1r])r-r.z'Failed. [idx, grad, grad_estimate] are:F)#rZCurrentWorkspacernZSwitchWorkspacerqZCopyFromrmrrZInferOpBlobDevicesAsDictrCrvinputrwrr0r^shape Exceptionr!_assertInferTensorChecksosgetenvr`r_rZrkiscloserlanyZ flatnonzeroprintZvstackTZResetWorkspace)rprr{rr}rzrrZensure_outputs_are_inferredZ old_ws_nameZg_inputror<rr|rrraZfull_grad_checkZ dims_to_checkZ current_dimrbrLrcZfail_matrOretrrr CheckSimples              "  zGradientChecker.CheckSimplecCsft}|j|g|j|tj|gdd\}}t}|D]}||jq@|D]}||vrrt d |t |} t | j } t ||} | | krt d | | t| tjur4| jtdkrtjj} n^| jtdkrtjj} nD| jtdkr tjj} n(| jtdkr&tjj} n d tj} n tt| } ||} | | krVt d | | qVdS) NT)Z nets_protoz!expected output {} to be inferredz,Mismatched inferred shape: want({}), got({})float64ryint32int64z unknown {}z+Mismatched inferred type: want({}), got({}))rZNetDefrextendrZInferShapesAndTypessetupdater rr!rxlistrtyper0ZndarrayrtZ TensorProtoDOUBLEFLOATZINT32ZINT64r")rprrzZtmp_netZinferred_shapesZinferred_typesr%Zgrad_opr rPZ correct_shapeZinferred_shapeZ correct_typeZ inferred_typerrr rYsT           z(GradientChecker._assertInferTensorChecks)NrjN)NNF)rerfrg__doc__rsrrrrrrr ris  7 sri)r,)rnumpyr0Z caffe2.pythonrrrZ caffe2.protorrrr+r9objectr:rirrrr s  T