U dh @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 F/tmp/pip-unpacked-wheel-ua33x9lu/caffe2/python/hypothesis_test_util.py is_sandcastle8srcCs dtjkS)NZTRAVIS)r environr r r r is_travis<srcCstdtdt|dS)Nfr)structunpackpackfloatxr r r to_float32@srcOs~d|krtjjdkr|dd|krztensor..r-listsr;flatmap)min_dimmax_dimrGrJrKr&dims_r rRr tensorsr[r=cCstdd||||dSNr0r9)r[)min_lenmax_lenrGrJr r r tensor1dsr_cCsh|dkr ttjdgtjdS|rDt|gtjtdddSt|gtjtjdd|ddSdS)NrshaperGrGrJcSstj|tjd|dS)NrGr)r>ZcumsumrArr r r rSrTzsegment_ids..r9) r-justr>emptyrArNrDmapr:)size is_sortedr r r segment_idssrjc s|dkr d}|dkr}|dks$t||ks0tdkrX|dkrXttjdgtjdS|dkshtdtjt|dd|ddfdd fdd t  tj S) Nrr`z(size is not 0, need at least one segmentr0r9cs tjjjtj|tjdddS)Nrr9)rJ)r rLrMrNr>rAr-r:)Z num_bordersrhr r rSszlengths..cst|tjdgtjdS)Nrrc)r>appendarrayrArrkr r rSrT) AssertionErrorr-rer>rfrAr:maxrWrgsortedZdiff)rh min_segments max_segmentsr&r rkr lengthss*       rsc  sZ|r tntd}tjtf|||d} t|| dd} | fddS)NFrOcSs|drdgng|dS)Nrr0r pairr r r rSrTz"segmented_tensor..cs tt||ddS)Nrri)r-tuplesrN)Z data_dimsrGrJrisegment_generatorr r rSs )r-rDrerVr;rwrgrW) rXrYrGrirJry allow_emptyr& gen_empty data_dims_r rxr segmented_tensors r}cOs"tjt||d}t|d|i|S)N)rqrrry) functoolspartialrsr})rqrrr%r&genr r r lengths_tensors rc  s\|r tntd} tjtf|||d} t| | dd} | fddS)NFrOcSs:tt|d|ds.tjd|dddntdS)Nr0rr9)r-rwrer:rtr r r rSs z)sparse_segmented_tensor..c sJtt|dt|dtjd|ddddd|ddS)Nrr0r9rbrv)r-rwrNr:rQrGrJriityperyr r rS s)r-rDrerVr;rwrW) rXrYrGrirJrzryrr&r{r|Z all_dims_r rr sparse_segmented_tensors  rcKstfdti|S)Nry)rrs)r&r r r sparse_lengths_tensorsrc s,tjtf|||d}|fddS)NrOcstjt|dS)NrO)r-rVrNrQrGrJnr r rSs ztensors..rU)rrXrYrGrJr&rZr rr tensorssrc Cst|dd||||dSr\)r)rr]r^rGrJr r r tensors1d"sr) device_typecCsg|]}tjtj|dqS))rZ device_id)r DeviceOptionr GpuDeviceType).0ir r r 5srcCs ttSN)r-redevice_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 b|pVt |d}t |j |D] \}}tj|||||dqdt|t|jd|d} W5QRX| S)Ntestr device_optionr0T)copydeepcopyrCopyFromrZNetDefopextendrrrInferOpBlobDevicesAsDictzipinputrFeedBlobr,Z CreateNetZ BenchmarkNet) rrinputsinput_device_optionsZ iterationsnet_input_device_optionsrbretr r r runOpBenchmarkVs$     rc Cst|}|j|tt|jt|krBtd|j|f|pRt |d}t |j|D] \}}t j ||| ||dq`t |ttt|j}g}|D]"} |j| } t | } || q|W5QRSQRXdS)N7must supply an input for each input on the op: %s vs %srr)rrrrrlenrrErrrrrr,RunOperatorOncelistrangeoutput FetchBlobrl) 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 assertEqualrarr)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|dk rrtt|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_indicesZval_namevalsrr r r _assertGradReferenceCheckssH        z-HypothesisTestCase._assertGradReferenceChecksc Cs|| p||kd|||kr(dSt|}t|tjkr|jtdkrZtj j }q|jtdkrttj j }q|jtdkrtj j }q|jtdkrtj j }qdtj}n tt|}ztjjt||tjt|jtjd||||jd|tj j krWdStjj|||d ||||dWnLtk r}z,tt|td d ksz|r~|W5d}~XYnXdS) NzShape for {0} was not inferredr@r?rArBz unknown {}zShape {} mismatch: {} vs. {})rzType {} mismatch: {} vs. {}CAFFE2_ASSERT_SHAPEINFERENCEr)rrrrtyper>ZndarrayrGrZ TensorProtoZDOUBLEFLOATZINT32ZINT64rrassert_array_equalrmZastyperAraZ assert_equalrnloggingwarningr r )rrshapestypesrensure_output_is_inferredZ correct_typeer r r _assertInferTensorCheckssV        z+HypothesisTestCase._assertInferTensorChecksc  Csbt|}|j|t:t|jt|krDtd|j|f|pTt |d} t |j|D] \} }t j | || | |dqbtd}|j|gd}zt |g\}}d}WnHtk r}z(tt|tddks| r|W5d }~XYnXt |||}t|ts8t|ts8td | sf|t|t|jttt|j} g}t | |D]\}}|j|}t |}|j!j"d krt#j$%||n*| d kr|} t#j$j&||| |d '|d |r|j(||||| d|)|qt|d k rH|d k st*dt+||j,||||||dW5QRX|W5QRSQRXd 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)-rrrrrrrrErrrrrr,ZNetZProtorrZInferShapesAndTypes RuntimeErrorrrrr r RunNetOncertuplerrrrrrGkindr>rrrrrrlrnZ DeviceScoper)rrrr referencerrrrrrrrrrrZtest_shape_inferencerrrZreference_outputsrrrrrr r r assertReferenceChecksGs#              z(HypothesisTestCase.assertReferenceChecksTc Cs |r.)routputs)rsetrrrrnrrrrrrrrrrr,rrdict) rrrrZ validatorrZ as_kwargsZinit_netrrrrr r r assertValidationCheckss8        z)HypothesisTestCase.assertValidationChecksc Cst|}|j|tr|p.t|d}t|j|D] \}} t j || | ||dq<|dkrx| |t j |n|||t j |W5QRXdS)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 contextlibrr~r Zhypothesis.extra.numpyZhypothesis.strategiesZ strategiesr-rrMr>r rrrrr$r.Zregister_profileZ HealthCheckZtoo_slowZ VerbosityverboseZ load_profiler r;r?rIrNr[r_rjrsr}rrBrrrrrZcpu_doZCUDAZcuda_doZHIPZhip_dorZgpu_doZhas_cuda_supportZ _cuda_do_listZhas_hip_supportZ _hip_do_listZhas_gpu_supportZ _gpu_do_listZ_device_options_no_hiprrZ NumGpuDevicesZexpanded_device_optionsrrrZgcsrreZ gcs_cpu_onlyZ gcs_cuda_onlyZ gcs_gpu_onlyZ gcs_no_hipcontextmanagerrrrZTestCaserr r r r s&