a ==ich @spdZddlmZddlmZmZmZmZmZddl Z ddl Z ddl Z ddl Z ddl Z ddlmZddlZddlZddlZddlZddZddZd d Zd d Zd dZe jdede jjgddde jjdde jdee jjgddde jjdde jdee jjgddde jjdde j er4dn e!dddKddZ"ej#dfdd Z$ej#dd!fd"d#Z%dd$ej#dd!fd%d&Z&dd'ej#dfd(d)Z'd*d+Z(dLd,d-Z)dd$ej#dde(d!fd.d/Z*dMd0d1Z+dd$ej#ddd!e(ej,fd2d3Z-d4d5Z.dd$ej#dfd6d7Z/dd'ej#dfd8d9Z0e1Z2ej1ej3d:Z4ej1ej5d:Z6ej1ej7d:Z8ej9r\e4gngZ:ej;rne6gngZe2ge:Z?e?e<Z@e2gd;d<eAeBDZCd=d>ZDd?d@ZEeFeEeDdAZGeFeHe2geIe2gdAZJeFeHe:eIe:dAZKeFeHe>eIe>dAZLeFeHe?eIe?dAZMe jNdNdCdDZOdOdEdFZPdPdGdHZQGdIdJdJejRZSdS)Qaq The Hypothesis library uses *property-based testing* to check invariants about the code under test under a variety of random inputs. The key idea here is to express properties of the code under test (e.g. that it passes a gradient check, that it implements a reference function, etc), and then generate random instances and verify they satisfy these properties. The main functions of interest are exposed on `HypothesisTestCase`. You can usually just add a short function in this to generate an arbitrary number of test cases for your operator. The key functions are: - `assertDeviceChecks(devices, op, inputs, outputs)`. This asserts that the operator computes the same outputs, regardless of which device it is executed on. - `assertGradientChecks(device, op, inputs, output_, outputs_with_grads)`. This implements a standard numerical gradient checker for the operator in question. - `assertReferenceChecks(device, op, inputs, reference)`. This runs the reference function (effectively calling `reference(*inputs)`, and comparing that to the output of output. `hypothesis_test_util.py` exposes some useful pre-built samplers. - `hu.gcs` - a gradient checker device (`gc`) and device checker devices (`dc`) - `hu.gcs_cpu_only` - a CPU-only gradient checker device (`gc`) and device checker devices (`dc`). Used for when your operator is only implemented on the CPU. ) caffe2_pb2) workspacedevice_checkergradient_checker test_utilcoreNcCstddkptddkS)NZ SANDCASTLE1Z TW_JOB_USER sandcastle)osgetenvr r s/home/droni/.local/share/virtualenvs/DPS-5Je3_V2c/lib/python3.9/site-packages/caffe2/python/hypothesis_test_util.py is_sandcastle8srcCs dtjvS)NZTRAVIS)r environr r r r is_travis<srcCstdtdt|dS)Nfr)structunpackpackfloatxr r r to_float32@srcOsd|vrtjjdkr|dd|vrztensor..r-listsr;flatmap)min_dimmax_dimrHrLrMr&dims_r rTr tensorsr]r=cCstdd||||dSNr0r9)r])min_lenmax_lenrHrLr r r tensor1dsracCsh|dkr ttjdgtjdS|rDt|gtjtdddSt|gtjtjdd|ddSdS)NrshaperHrHrLcSstj|tjd|dS)NrHr)r>ZcumsumrBrr r r rUrVzsegment_ids..r9) r-justr>emptyrBrPrEmapr:)size is_sortedr r r segment_idssrlc s|dur d}|dur}|dks$J||ks0JdkrX|dkrXttjdgtjdS|dkshJdtjt|dd|ddfddfddt tj S) Nrrbz(size is not 0, need at least one segmentr0r9cs tjjjtj|tjdddS)Nrr9)rL)r rNrOrPr>rBr-r:)Z num_bordersrjr r rUs  zlengths..cst|tjdgtjdS)Nrre)r>appendarrayrBrrmr r rUrV) r-rgr>rhrBr:maxrYrisorteddiff)rj min_segments max_segmentsr&r rmr lengthss(      ruc  s^|r tntd}tjtfi|||d} t|| dd} | fddS)NFrQcSs|drdgng|dS)Nrr0r pairr r r rUrVz"segmented_tensor..cs tt||ddS)Nrrk)r-tuplesrP)Z data_dimsrHrLrksegment_generatorr r rUs )r-rErgrXr;ryrirY) rZr[rHrkrLr{ allow_emptyr& gen_empty data_dims_r rzr segmented_tensors rcOs"tjt||d}t|d|i|S)N)rsrtr{) functoolspartialrur)rsrtr%r&genr r r lengths_tensorsrc  s`|r tntd} tjtfi|||d} t| | dd} | fddS)NFrQcSs:tt|d|ds.tjd|dddntdS)Nr0rr9)r-ryrgr:rvr r r rUs z)sparse_segmented_tensor..c sJtt|dt|dtjd|ddddd|ddS)Nrr0r9rdrx)r-ryrPr:rSrHrLrkityper{r r rU s )r-rErgrXr;ryrY) rZr[rHrkrLr|r{rr&r}r~Z all_dims_r rr sparse_segmented_tensors  rcKstfdti|S)Nr{)rru)r&r r r sparse_lengths_tensorsrc s0tjtfi|||d}|fddS)NrQcstjt|dS)NrQ)r-rXrPrSrHrLnr r rUs ztensors..rW)rrZr[rHrLr&r\r rr tensorssrc Cst|dd||||dSr^)r)rr_r`rHrLr r r tensors1d"sr) device_typecCsg|]}tjtj|dqS))rZ device_id)r DeviceOptionr GpuDeviceType).0ir r r 5srcCs ttSN)r-rgdevice_optionsr r r r device_checker_device_options:srcCs ttSr)r- sampled_fromrr r r r gradient_checker_device_option>sr)gcdctemp_wsccs0t}t|ddVtt|dS)NT)rZCurrentWorkspaceZSwitchWorkspaceZResetWorkspace)nameZ old_ws_namer r r temp_workspaceMs  rc Cst|}|j|t}|j|g|jr8|jnd|_t l|pVt |d}t |j |D] \}}tj|||||dqdt|t|jd|d} Wdn1s0Y| S)Ntestr device_optionr0T)copydeepcopyrCopyFromrZNetDefopextendrrrInferOpBlobDevicesAsDictzipinputrFeedBlobr,Z CreateNetZ BenchmarkNet) rrinputsinput_device_optionsZ iterationsnet_input_device_optionsrbretr r r runOpBenchmarkVs$     0rc Cst|}|j|tt|jt|krBtd|j|f|pRt |d}t |j|D] \}}t j ||| ||dq`t |ttt|j}g}|D]"} |j| } t | } || q|WdS1s0YdS)N7must supply an input for each input on the op: %s vs %srr)rrrrrlenrrFrrrrrr,RunOperatorOncelistrangeoutput FetchBlobrn) rrrrrrroutputs_to_checkouts output_indexoutput_blob_namerr r r runOpOnInputqs4        rc@s^eZdZdZdddZdd d Zdd d ZdddZdddZdddZ de fdfddZ dS)HypothesisTestCasez A unittest.TestCase subclass with some helper functions for utilizing the `hypothesis` (hypothesis.readthedocs.io) library. N{Gz?cCs(tj||d}||||||dS)al Asserts that the operator computes the same outputs, regardless of which device it is executed on. Useful for checking the consistency of GPU and CPU implementations of operators. Usage example: @given(inputs=hu.tensors(n=2), in_place=st.booleans(), **hu.gcs) def test_sum(self, inputs, in_place, gc, dc): op = core.CreateOperator("Sum", ["X1", "X2"], ["Y" if not in_place else "X1"]) X1, X2 = inputs self.assertDeviceChecks(dc, op, [X1, X2], [0]) )rN)rZ DeviceChecker assertTrue CheckSimple)selfrrrrr thresholdrr r r assertDeviceCheckssz%HypothesisTestCase.assertDeviceChecks{Gzt?皙?Fc  Csdtj|||t|| d} | j|||||| | d\} } }|| j|j|| dt|j|dS)aj Implements a standard numerical gradient checker for the operator in question. Useful for checking the consistency of the forward and backward implementations of operators. Usage example: @given(inputs=hu.tensors(n=2), in_place=st.booleans(), **hu.gcs) def test_sum(self, inputs, in_place, gc, dc): op = core.CreateOperator("Sum", ["X1", "X2"], ["Y" if not in_place else "X1"]) X1, X2 = inputs self.assertGradientChecks(gc, op, [X1, X2], 0, [0]) )stepsizerrZworkspace_namer)grad_opsrensure_outputs_are_inferredz Gradient check failed for input N)rZGradientCheckerstrr assertEqualrcrr)rrrrrZoutputs_with_gradsrrrrrrresZgradZgrad_estimatedr r r assertGradientCheckss$ z'HypothesisTestCase.assertGradientChecks-C6?c Cs|d}tj|g||i\}} t|} || ||} t|t|t||t| t|t |j | D]\} } | | }|s| | qrt |tjr| }d}|}n| \}}|j}tt|}tjj||||d|d|durrtt|j}tjj||dddqrdS)NZ_gradz2Gradient {0} (x) is not matching the reference (y)atolrtolerr_msgr)rr)rZGradientRegistryZGetBackwardPassrrrZRunOperatorsOncerrrrr,Z assertIsNone isinstanceZ BlobReferencevaluesrr>testingassert_allcloseformatindices)rrrZ ref_outputsoutput_to_gradgrad_referencerZgrad_blob_namerZgrad_mapZ output_gradZgrad_ref_outputsrrefZ grad_namesZref_valsZ ref_indicesval_namevalsrr r r _assertGradReferenceCheckssD         z-HypothesisTestCase._assertGradReferenceChecksc Cs|| p||vd|||vr(dSt|}t|tjur|jtdkrZtj j }q|jtdkrttj j }q|jtdkrtj j }q|jtdkrtj j }qdtj}n tt|}ztjjt||tjt|jtjd||||jd|tj j krWdStjj|||d ||||dWnNty}z4tt|td d ksx|r||WYd}~n d}~00dS) NzShape for {0} was not inferredrAr@rBrCz unknown {}zShape {} mismatch: {} vs. {})rzType {} mismatch: {} vs. {}CAFFE2_ASSERT_SHAPEINFERENCEr)rrrrtyper>ZndarrayrHrZ TensorProtoDOUBLEFLOATZINT32ZINT64rrassert_array_equalroZastyperBrcZ assert_equalAssertionErrorloggingwarningr r )rrshapestypesrensure_output_is_inferredZ correct_typeer r r _assertInferTensorCheckssR         z+HypothesisTestCase._assertInferTensorChecksc  Cst|}|j|tTt|jt|krDtd|j|f|pTt |d} t |j|D] \} }t j | || | |dqbtd}|j|gd}zt |g\}}d}WnJty}z0tt|tddks| r|WYd }~n d }~00t |||}t|ts:t|ts:td | sh|t|t|jttt|j} g}t | |D]\}}|j|}t |}|j!j"d vrt#j$%||n*| d ur|} t#j$j&||| |d '|d |r|j(||||| d|)|qv|d ur`|d usJdt*|&|j+||||||dWd n1sV0Y|Wd S1sz0Yd S)a This runs the reference Python function implementation (effectively calling `reference(*inputs)`, and compares that to the output of output, with an absolute/relative tolerance given by the `threshold` parameter. Useful for checking the implementation matches the Python (typically NumPy) implementation of the same functionality. Usage example: @given(X=hu.tensor(), inplace=st.booleans(), **hu.gcs) def test_softsign(self, X, inplace, gc, dc): op = core.CreateOperator( "Softsign", ["X"], ["X" if inplace else "Y"]) def softsign(X): return (X / (1 + np.abs(X)),) self.assertReferenceChecks(gc, op, [X], softsign) rrrZopnetFTrrNzlYou are providing a wrong reference implementation. A proper one should return a tuple/list of numpy arrays.)SOz(Output {0} is not matching the referencer)rz=If grad_reference is set,output_to_grad has to be set as well)r),rrrrrrrrFrrrrrr,ZNetZProtorrZInferShapesAndTypes RuntimeErrorrrrr r RunNetOncertuplerrrrrrHkindr>rrrrrrnZ DeviceScoper)rrrr referencerrrrrrrrrrrZtest_shape_inferencerrrZreference_outputsrrrrrr r r assertReferenceChecksGs#              &z(HypothesisTestCase.assertReferenceChecksTc Cs$|r.)routputs)rsetrrrrrrrrrrrrrr,rrdict) rrrr validatorrZ as_kwargsZinit_netrrrrr r r assertValidationCheckss6         z)HypothesisTestCase.assertValidationChecksc Cst|}|j|t||p.t|d}t|j|D] \}} t j || | ||dq<|durx| |t j |n|||t j |Wdn1s0YdS)Nrr)rrrrrrrrrrrr, assertRaisesrassertRaisesRegex) rrrrr exceptionregexprrrr r r assertRunOpRaisess"     z$HypothesisTestCase.assertRunOpRaises)Nr)NrrNF)r)F)NrNNNNF)NTN) __name__ __module__ __qualname____doc__rrrrrr Exceptionrr r r r rs<  ( 7 0 6 q )r)r0r8)NN)NN)r)Nr6)N)TrZ caffe2.protorZ caffe2.pythonrrrrr contextlibrrr Zhypothesis.extra.numpyZhypothesis.strategies strategiesr-rrOr>r rrrrr$r.Zregister_profileZ HealthCheckZtoo_slowZ VerbosityverboseZ load_profiler r;r@rKrPr]rarlrurrrCrrrrrZcpu_doCUDAZcuda_doZHIPZhip_dorZgpu_doZhas_cuda_supportZ _cuda_do_listZhas_hip_supportZ _hip_do_listZhas_gpu_supportZ _gpu_do_listZ_device_options_no_hiprrZ NumGpuDevicesZexpanded_device_optionsrrrZgcsrrgZ gcs_cpu_onlyZ gcs_cuda_onlyZ gcs_gpu_onlyZ gcs_no_hipcontextmanagerrrrZTestCaserr r r r s&