U <c@sddlZddlZddlZddlZddlZddlmZmZddlm Z ddl m Z ddl m Z ddlmZmZmZmZmZmZddlmZddlZddlmZdd lmZmZmZdd lmZm Z m!Z!m"Z"dd l#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)d Z*dZ+dZ,dZ-e.Z/e/fddZ0Gddde.Z1Gddde.Z2e3dddgZ4Gddde.Z5Gddde.Z6eGddde.Z7d d!Z8d~d#d$Z9d%d&Z:Gd'd(d(e7Z;d)d*Zd/d/d0d1d2Z?d/d/d0d3d4Z@d/dd0d5d6ZAd/d7d8d9ZBd/d7d:d;ZCd/d/d0dd?ZEd/d7d@dAZFd/d/d0dBdCZGdDdEZHGdFdGdGe7ZIddHdIZJdJdKZKdLdMZLdNdOZMdPdQZNd/d7dRdSZOd/d7dTdUZPd/d7dVdWZQd/d7dXdYZRd/d7dZd[ZSd\d]ZTd^d_ZUGd`dadae7ZVddbdcZWe dddeZXGdfdgdge7ZYGdhdidie7ZZd/d/dddjdkdlZ[dmdnZ\Gdodpdpe7Z]dqdrZ^d/ddsdtduZ_d/ddsdvdwZ`dxdyZadzd{Zbd|d}ZcdS)N)asdict dataclass)Enum)partial)product)AnyCallableIterableListOptionalTupledataclass_repr make_tensor)skipCPUIfNoFFTtoltoleranceOverride)_dispatch_dtypesfloating_and_complex_typesfloating_and_complex_types_andfloating_types)is_iterable_of_tensorsnoncontiguous_likeTEST_WITH_ROCMtorch_to_numpy_dtype_dict)utils cCsLz |dD]}t||}q |WStk rF|tk r@|YSYnXdS)N.)splitgetattrAttributeError_NOTHING)objnamedefaultpathr*G/tmp/pip-unpacked-wheel-gikjz4vx/torch/testing/_internal/opinfo/core.py _getattr_qual/s r,c@s<eZdZdZddddddgZdddd d d d Zd dZdS) DecorateInfozDescribes which test, or type of tests, should be wrapped in the given decorators when testing an operator. Any test that matches all provided arguments will be decorated. The decorators will only be applied if the active_if argument is True. decoratorscls_name test_name device_typedtypes active_ifNT)r1r2r3cCsft|tjjrt|n|g|_||_||_||_||_ ||_ |j dk rb|j D]}t|t j sLt qLdSN) isinstance collectionsabcSequencelistr.r/r0r1r2r3torchdtypeAssertionError)selfr.r/r0r1r2r3r;r*r*r+__init__Js   zDecorateInfo.__init__cCsV|joT|jdks|j|koT|jdks.|j|koT|jdksB|j|koT|jdkpT||jkSr4)r3r/r0r1r2)r=r/r0r1r;r*r*r+ is_activedszDecorateInfo.is_active)NN)__name__ __module__ __qualname____doc__ __slots__r>r?r*r*r*r+r-;s   r-c@sxeZdZdZddddddgZdddddd d d Zdddd d dZddZddZddZ ddZ ddZ ddZ dS) SampleInputz'Represents sample inputs to a function.inputargskwargsoutput_process_fn_gradbroadcasts_inputr'NrGrHrIrJr'c Os||_|dk s|dk r(|s|rXtdn0t|s8t|rX|dkrP|dkrP|dksXtd|dk rd|n||_t|jtszt|dk r|n||_t|jtst|dk r|ndd|_|dk r|nd|_ |dk r|nd|_ dS)Nz A SampleInput can be constructed "naturally" with *args and **kwargs or by explicitly setting the "args" and "kwargs" paremeters, but the two methods of construction cannot be mixed!zv A SampleInput constructed "naturally" with *args and **kwargs cannot specify additional metadata in keyword argumentscSs|Sr4r*xr*r*r+z&SampleInput.__init__..F) rFr<lenrGr5tuplerHdictrIr'rJ) r=rFrGrHrIrJr'Zvar_argsZ var_kwargsr*r*r+r>~s8  zSampleInput.__init__rIrJr'cCs.|dk r||_|dk r||_|dk r*||_|Sr4rT)r=rIrJr'r*r*r+ with_metadataszSampleInput.with_metadatacCsld||jd||jd||jd|jd|jdt|jg}ddd d |Dd S) Nzinput=zargs=zkwargs=zoutput_process_fn_grad=zbroadcasts_input=zname=z SampleInput(, css|]}|dk r|VqdSr4r*.0ar*r*r+ sz+SampleInput._repr_helper..))rFrGrHrIrJreprr'join)r= formatter argumentsr*r*r+ _repr_helpers   zSampleInput._repr_helpercCs|ddS)NcSs|Sr4r*rLr*r*r+rNrOz&SampleInput.__repr__..r`r=r*r*r+__repr__szSampleInput.__repr__csfdd|S)Ncst|tjr6tt|jdddd}d|dSt|trVfdd|DSt |rvdd t |dSt|t tfrdd t |dSt |S) N(rPr[zTensor[]csi|]\}}||qSr*r*rXkvr^r*r+ sz:SampleInput.summary..formatter..z TensorList[rV,)r5r:TensorstrrRshapereplacerSitemsrr]mapr9r\)argrnrir*r+r^s   z&SampleInput.summary..formatterrarbr*rir+summarys zSampleInput.summarycsNfdd|j|j|j}}}t||||j|j|jddS)Ncsfdd}t|tjr ||St|tjr4||St|trLtt|St|trdtt|St|trfdd|DS|SdS)Nc s(t|W5QRSQRXdSr4)r:no_gradt)fr*r+_tts z.SampleInput.transform..tt.._ttcsi|]\}}||qSr*r*rf)ttr*r+rjsz5SampleInput.transform..tt..) r5r:rlr;r9rqrRrSrp)rvrxrwryr*r+rys      z!SampleInput.transform..ttZ _transformedrK)rFrGrHrErIrJr')r=rwZsample_tt_inputZtt_argsZ tt_kwargsr*rzr+ transforms zSampleInput.transformcCsdd}||S)NcSs|t|tjrd|jtjkr0|tj S|jtj krT|tj  S| St|tjrxt |S|Sr4) r5r:rlr;bfloat16detachcputoZfloat32numpychalfZcfloatrrur*r*r+to_numpys    z#SampleInput.numpy..to_numpyr{)r=rr*r*r+rs zSampleInput.numpycCsdd}||S)NcSs(t|tjrt|St|tjr$|S|Sr4)r5r:rlrr;rur*r*r+to_noncontiguous$s   z3SampleInput.noncontiguous..to_noncontiguousr)r=rr*r*r+ noncontiguous#szSampleInput.noncontiguous) r@rArBrCrDr>rUr`rcrsr{rrr*r*r*r+rErs0  : &rENumericsFilter conditionZsafe_valc@s(eZdZdZdddgZedddZdS) ErrorInputzw A SampleInput that will cause the operation to throw an error plus information about the resulting error. sample_input error_type error_regex)rcCs||_||_||_dSr4)rrr)r=rrrr*r*r+r>:szErrorInput.__init__N)r@rArBrCrD RuntimeErrorr>r*r*r*r+r2s rc@s eZdZdZddZddZdS) AliasInfozClass holds alias information. For example, torch.abs -> torch.absolute, torch.Tensor.absolute, torch.Tensor.absolute_ cCs:||_tt||_ttj|d|_ttj|dd|_dS)N_)r'r,r:opr#rlmethod_variantinplace_variant)r=Z alias_namer*r*r+r>Es zAliasInfo.__init__cOs |j||Sr4rr=rGrHr*r*r+__call__KszAliasInfo.__call__N)r@rArBrCr>rr*r*r*r+r@src@seZdZUdZeed<dZeeed<dZ e ed<dZ eed<dZ eed<e Zeed <e Zeed <e Zeed <e Zeed <eZeed <eZeed<dZeed<dZeed<dZeed<dZeed<dZeed<dZeed<dZeed<dZeed<dZeed<dZ eed<dZ!eed<dZ"eed<dZ#eed<dZ$eed<dZ%e&ed<dZ'e&ed<dZ(e&ed <d!Z)e&ed"<dZ*e&ed#<d!Z+e&ed$<d!Z,e&ed%<d&d'Z-eed(<dZ.e&ed)<dZ/e&ed*<dZ0e&ed+<dZ1e&ed,<d-Z2e3ed.<dZ4e&ed/<dZ5eed0<dZ6eeed1<dZ7eeed2<d!Z8e&ed3<dZ9e:eed4<dZ;e:eed5<d!Ze&ed8<d!Z?e&ed9<d!Z@e&ed:<d!ZAe&ed;<d!ZBe&ed<<dZCe&ed=<dZDe&ed><d!ZEe&ed?<d!ZFe&ed@<d!ZGe&edA<dBdCZHdDdEZIdFdGZJdHdIZKdJdKZLdLdMZMdNdOZNdPdQZOdndRdSZPdodTdUZQdpdVdWZRdXdYZSdqdZd[ZTdrd\d]ZUdsd^d_ZVdtd`daZWdudbdcZXdddeZYdfdgZZdhdiZ[djdkZ\e]dldmZ^dS)vOpInfoz;Operator information and helper functions for acquiring it.r'NrefaliasesrPvariant_test_namerrroperator_variantinplace_operator_variantskipsr.sample_inputs_funcreference_inputs_funcerror_inputs_funcsample_inputs_sparse_coo_funcsample_inputs_sparse_csr_funcsample_inputs_sparse_csc_funcsample_inputs_sparse_bsr_funcsample_inputs_sparse_bsc_funcr2 dtypesIfCUDA dtypesIfROCMbackward_dtypesbackward_dtypesIfCUDAbackward_dtypesIfROCMT supports_outsupports_autogradsupports_gradgradFsupports_fwgrad_bwgradsupports_inplace_autogradsupports_forward_adsupports_varargscOs |||Sr4r*)rrGrHr*r*r+rNrOzOpInfo.gradcheck_wrappercheck_batched_gradcheck_batched_gradgradcheck_batched_forward_grad"check_inplace_batched_forward_gradgradcheck_nondet_tolgradcheck_fast_mode aten_namedecomp_aten_nameaten_backward_nameassert_autodiffedautodiff_nonfusible_nodesautodiff_fusible_nodessupports_sparsesupports_scriptingsupports_tracingsupports_sparse_csrsupports_sparse_cscsupports_sparse_bsrsupports_sparse_bsctest_conjugated_samples test_neg_viewassert_jit_shape_analysissupports_expanded_weightis_factory_functioncCst||_|jdk s(td|j|j|j|jf}|D]}t |t t dfs.z"To use dynamic dypes for operator z, acquire the dtypes dynamically for argument `dtypesIfCUDA`.This is to ensure that CUDA dtypes are acquired correctly as theydiffer from CPU dtypes occasionallyrizaten::zrsupports_gradgrad refines the part of autograd is supported, so it should not be set if supports_autograd is Falsezcheck_batched_grad refines the part of autograd that will be checked (by gradcheck), so it should not be set if supports_autograd is Falsezcheck_batched_gradgrad refines the part of autograd that will be checked (by gradgradcheck), so it should not be set if either supports_gradgrad or supports_autograd is False.zcheck_batched_forward_grad should only be used when supports_forward_ad is True. It is used to disable the test in the specific cases where the op supports forward ad but fails to compute batched forward grad.acheck_batched_forward_grad should only be used when check_batched_forward_grad is True. It is used to disable the test in the specific cases where the op supports batched forward grad but fails to compute batched forward grad for the inplace variant of the op.zsupports_fwgrad_bwgrad enables forward-over-backward gradgrad checks and should only be True if backward ad is also checked, i.e., supports_forward_ad should be True.zsupports_inplace_autograd refines the part of autograd that is supported, so it should not be set if both supports_autograd and supports_forward_ad are Falsecss|]}t|VqdSr4)rrWr*r*r+rZ&sz'OpInfo.__post_init__..r*)9rcopyZ_original_opinfo_argsr2r<formatr'rrr5rtyperanyrqZdynamic_dtypesrrsetrrrrr,r:rr%r#rlcallablerroperatorrr.rrtrrrrrrrrrrrrrrrrrrrrR)r=Z dtypes_argsZ dtype_listZ inplace_nameZinplace_operator_namer*r*r+ __post_init__Os&                               zOpInfo.__post_init__cOs |j||S)z+Calls the function variant of the operator.rrr*r*r+r*szOpInfo.__call__cCst|Sr4r rbr*r*r+__str__.szOpInfo.__str__cCs|jS)z>Returns the function variant of the operator, torch..rrbr*r*r+get_op1sz OpInfo.get_opcCs|jS)zReturns the method variant of the operator, torch.Tensor.. Returns None if the operator has no method variant. )rrbr*r*r+ get_method5szOpInfo.get_methodcCs|jS)zReturns the inplace variant of the operator, torch.Tensor._. Returns None if the operator has no inplace variant. )rrbr*r*r+ get_inplace;szOpInfo.get_inplacecCs|jS)zReturns operator variant of the operator, e.g. operator.neg Returns None if the operator has no operator variant. )rrbr*r*r+ get_operatorAszOpInfo.get_operatorcCs|jS)zReturns the inplace operator variant of the operator, e.g operator.iadd Returns None if the operator has no inplace operator variant)rrbr*r*r+get_inplace_operatorGszOpInfo.get_inplace_operatorc Ksv|j||||f|}t|}dd}t|D]@\}} ||} t| jtjrX|| j| _q,|| jd| jd<q,t|S)z~Returns an iterable of SampleInputs but with the tensor input or first tensor in a sequence input conjugated. cSs|j}|}||Sr4) requires_gradZconjrequires_grad_)tensorZ_requires_gradr*r*r+ conjugateTsz1OpInfo.conjugate_sample_inputs..conjugater)rr9 enumerater5rFr:rlrR) r=devicer;rrHsamples conj_samplesrrsampler*r*r+conjugate_sample_inputsLszOpInfo.conjugate_sample_inputscKsP|j||||f|}|ddrL|j|||f|}t|}||t|}|S)z Returns an iterable of SampleInputs. These samples should be sufficient to test the function works correctly with autograd, TorchScript, etc. include_conjugated_inputsF)rgetrr9extendrR)r=rr;rrHrrZ samples_listr*r*r+ sample_inputscs  zOpInfo.sample_inputscKsB|jdkr|j||||f|S|ddr.t|j||||f|S)z Returns an iterable of SampleInputs. Distinct from sample_inputs() above because this returns an expanded set of inputs when reference_inputs_func is defined. If undefined this returns the sample inputs. NrF)rrrNotImplementedErrorr=rr;rrHr*r*r+reference_inputsvs   zOpInfo.reference_inputscKs|j||f|S)z5 Returns an iterable of ErrorInputs. r)r=rrHr*r*r+ error_inputsszOpInfo.error_inputscKs|j||||f|S)z`Returns an iterable of SampleInputs that contain inputs with sparse coo layout. )rrr*r*r+sample_inputs_sparse_cooszOpInfo.sample_inputs_sparse_coocKs|j||||f|S)z`Returns an iterable of SampleInputs that contain inputs with sparse csr layout. )rrr*r*r+sample_inputs_sparse_csrszOpInfo.sample_inputs_sparse_csrcKs|j||||f|S)z`Returns an iterable of SampleInputs that contain inputs with sparse csc layout. )rrr*r*r+sample_inputs_sparse_cscszOpInfo.sample_inputs_sparse_csccKs|j||||f|S)z`Returns an iterable of SampleInputs that contain inputs with sparse bsr layout. )rrr*r*r+sample_inputs_sparse_bsrszOpInfo.sample_inputs_sparse_bsrcKs|j||||f|S)z`Returns an iterable of SampleInputs that contain inputs with sparse bsc layout. )rrr*r*r+sample_inputs_sparse_bscszOpInfo.sample_inputs_sparse_bsccCsFg}|jD]6}t|tr6|||||r@||jq ||q |S)z0Returns the decorators targeting the given test.)r.r5r-r?rappend)r=Z test_classr0rr;result decoratorr*r*r+get_decoratorss   zOpInfo.get_decoratorscCs0|dkr|jS|dkr&tr |jS|jS|jSdSNr~Zcuda)r2rrr)r=r1r*r*r+supported_dtypess zOpInfo.supported_dtypescCs`|js tSd}|dkr |j}n |dkr:tr2|jn|j}n|j}ttjtj tj }t| |Sr) rrrrrrrr:r|float16 complex32 intersection)r=r1rZallowed_backward_dtypesr*r*r+supported_backward_dtypess"z OpInfo.supported_backward_dtypescCs|||kSr4)r)r=r;r1r*r*r+supports_dtypeszOpInfo.supports_dtypecCs2|jrd|jddnd}d|jdd|S)zMReturns a formatted full name for this OpInfo that can be used in test names.rr!rPz{}{})rrorr')r=variantr*r*r+formatted_names zOpInfo.formatted_name)F)F)F)F)F)F)F)F)_r@rArBrCrm__annotations__rr rrr rrr%rrrrrRrr r.rrrrrrrrr2rrrrrrrboolrrrrrrrrrrrrfloatrrrrrrr rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrpropertyrr*r*r*r+res                                                 \         rcksZtg|||dVtdg|||dVtddg|||dVtddddg|||dVdS)z7Generates input tensors for testing reduction operators)r;rrr rNr)rr;rrHr*r*r+_generate_reduction_inputss rTccsiVdddVdddV|dkr6|dddV|rtt|ddV|dkrbdddV|d krttd|dddVd S) zGenerates a subset of all valid dim and keepdim kwargs given ndim that is appropriate for testing reduction operators. rT)dimkeepdimFrrrrr N)rRrange)ndimsupports_multiple_dimsr*r*r+_generate_reduction_kwargss   r c ks~|dd}|ddd}t|||D]P}t|j|D]>}||f|D],\} }||t||| |dVqHq8q(dS)z&Sample inputs for reduction operators.r Tgenerate_args_kwargscs tifVSr4rRrGrHr*r*r+rNrOz)sample_inputs_reduction..rN)rrr r updaterEr}r) op_inforr;rrHr rrvZreduction_kwargsrGr*r*r+sample_inputs_reductions"   rc s\eZdZdZdddddddd dddeeeeeeeeej ee dfdd Z Z S) ReductionOpInfoaReduction operator information. An operator is a reduction operator if it reduces one or more dimensions of the input tensor to a single value. Reduction operators must implement the following signature: - `op(input, *args, *, dim=None, keepdim=False, **kwargs) -> Tensor` ReductionOpInfo tests that reduction operators implement a consistent API. Optional features such as reducing over multiple dimensions are captured in the optional keyword parameters of the ReductionOpInfo constructor. If a reduction operator does not yet implement the full required API of reduction operators, this should be documented by xfailing the failing tests rather than adding optional parameters to ReductionOpInfo. NOTE The API for reduction operators has not yet been finalized and some requirements may change. See tests in test/test_reductions.py NTFccs tifVSr4r)rvrrr*r*r+rNjszReductionOpInfo.)identity nan_policyr promotes_int_to_floatpromotes_int_to_int64 result_dtypecomplex_to_realrc  st|_|dkst|r$|r$t|r0|r0t|r<|r.sample_inputs_funcrr)localsrZ_original_reduction_argsr< setdefaultsuperr>rrr rrrrr) r=r'rrr rrrrrrHr __class__rr+r>Ps$!        zReductionOpInfo.__init__)NF) r@rArBrCr rrmrr:r;rr> __classcell__r*r*r r+r8s&rcks|j||||f|EdHt|||||dEdH|tjk rRt||||dEdH|tjtjtjfkr|t||||dEdHt|||||dEdHt ||||dEdHt ||||dEdH|j s|j rt ||||dEdHdS)Nrr;r exclude_zerorr;r)r#generate_elementwise_binary_tensorsr:r/generate_elementwise_binary_small_value_tensorsuint8int8/generate_elementwise_binary_large_value_tensors0generate_elementwise_binary_broadcasting_tensors/generate_elementwise_binary_with_scalar_samplesBgenerate_elementwise_binary_with_scalar_and_type_promotion_samplesis_floating_point is_complex2generate_elementwise_binary_extremal_value_tensors)rrr;rr$rHr*r*r+$_reference_inputs_elementwise_binarys`        r1ckst|dr|jdd}tt|||||f|}|EdH|D]}|Vq@t|||||dEdHt|||||dEdHdS)Nrhs_make_tensor_kwargsr$Fr#)hasattrr2rrr1r1generate_elementwise_binary_noncontiguous_tensors7generate_elementwise_binary_arbitrarily_strided_tensors)rrr;rrHr$genrr*r*r+#reference_inputs_elementwise_binarys:     r7csfdd}|S)Nc;sdk r||f|EdH|jsHttjd|ddd}t|tddV|jsvtdtjd|dfd}t|tddV|dd s|jstdd d}t|tddVdS) N)rrr rrrGrP)rrrZskip_two_python_scalarsFr ) supports_rhs_python_scalarrEr:rr Exceptionsupports_one_python_scalarrsupports_two_python_scalars)rrrHsirr*r+error_inputs_func_wrappers  zGmake_error_inputs_elementwise_binary..error_inputs_func_wrapperr*)rrAr*rr+$make_error_inputs_elementwise_binarys rBF)rr$c csPd}tt||||d}|D]0}||f|j}||f|j} t|| fdVqdS)N)rrrr r*)ri,iir#r:)rrlhs_make_tensor_kwargsr2rE) rrr;rr$shapesmake_argrnlhsrhsr*r*r+r&sr&c csTd}tt||||d}|D]4\}}} |d||| } ||} t| | fdVqdS)N))rrrrr))rrrNr)rrr)rPrrOr )rQ)rrrOr )rQ)rrrr )) rr)rrrOr r#r:)rr as_stridedrE) rrr;rr$ strided_casesrIrnstridesoffsetrYbr*r*r+r5%s$ r5ccs~|dkr t|dr |jdd}d}d}dddd d d d d tj dtjdtj dtjdtj tjtj dtjdf}g}g} |jrt||} np|jrt||} tt dd| } t| | } nB|t j t j t j t jfkrt||} n|t jkrt||} ntd| D]:\} } || | dkr8|r8| dn | | q t j||||d}t j| |||d}t||fdVdS)Nr2r$F) rr7)rrrirYirZirggMbPgMbP?gпg??rh㈵>cSst|Sr4complexrLr*r*r+rNkrOzAgenerate_elementwise_binary_small_value_tensors..Unsupported dtype!rrr%r:)r3r2rmathpir.rr/r9rqr:r)int16int32int64r( ValueErrorrrrE)rrr;rr$Z_unsigned_int_valsZ _int_valsZ _float_valsl_valsr_valsprod complex_valslrrJrKr*r*r+r'EsV             r')rccsd}d}|d}g}g}|tjkr.t||} nh|jr@t||} nV|jrnt||} ttdd| } t| | } n(|tjtjtj fkrt||} nt d| D]\} } | | | | qtj ||||d} tj ||||d}t | |fdVdS) N)iiYi3i))i igIgI@g>g>@)gLSgLSAg@xg@xDcSst|Sr4rcrLr*r*r+rNrOzAgenerate_elementwise_binary_large_value_tensors..rer%r:)r:rrr.r/r9rqrhrirjrkrrrE)rrr;rZ_large_int_valsZ_large_float16_valsZ_large_float_valsrlrmrnrorprqrJrKr*r*r+r*s,         r*ccs4tdtdtdf}g}g}|jr0t||}n6|jr^t||}ttdd|}t||}ntd|D]\} } || || qjtj ||||d} tj ||||d} t | | fdV|jrtdnt tdtd} t d |||d} | | ddd <t d |||d} | | ddd <t | | fdVdS) Ninfz-infnancSst|Sr4rcrLr*r*r+rNrOzDgenerate_elementwise_binary_extremal_value_tensors..rer%r:)r[r[r )rr.rr/r9rqrkrr:rrErdrflatten)rrr;rZ_float_extremalsrlrmrnrorprqrJrKrsr*r*r+r0sB      r0c csxd}tt||||d}t|ddgD]N\}}|\} } || fd|i|j} || fd|i|j} t| | fddVq$dS)N) )rr*)r9r*)rur9))rrr9)rrr9)r rr9)rr rr9)rxrw)r rrrw))rr rr*)ryrxr#TFr)rGrJ)rrrrGr2rE) rrr;rr$rHrIrnr shape_lhs shape_rhsrJrKr*r*r+r+s2r+c cstt|||d}d}|jr|D]P}||f|j}||f|j}|d|j} |d|j} t|| fdVq|jrt| |fdV|jr|d|j} |d|j} t| | fdVdS) Nr%)r*r;)rr )rrr )rrr*r:)r*)r*)r*)r*) rrr<rGr2itemrEr>r?) rrr;rrIrHrnrJrKZ lhs_scalarZ rhs_scalarr*r*r+r,s(r,c cs|jdkrtt|||d}d}tdtdtd f}tdd|D}|jr||f|j}||f|j} ||D]*} t|| fdV|j rrt| | fdVqrdS) N) eqnegtgeltle logical_and logical_or logical_xorr%)rsrrcss|]}t|VqdSr4)r:r)rXvalr*r*r+rZ*szUgenerate_elementwise_binary_with_scalar_and_type_promotion_samples..r:) r'rrrrRr<rGr2rEr>) rrr;rrIrnvaluesZscalar_tensorsrJrKZscalarr*r*r+r-s"  r-c cstt||||d}|dddi|j}|dddi|j}t||fdVt||fdV|d|j}|d|j}t|j|jfdVd}|D]} || f|j}|| f|j}tj | d||d d } | |tj | d||d d } | |t| | fdVt| | fdVqd } || f|j}|| f|j}|ddd d f} |ddd d f} t| | fdVt| | fdVd}|D]N} || f|j}|| f|j}| ddd} | ddd} t| | fdVqdS)Nr#irTr:iie)rrO)r9rr;).r)rrrrr.)rr )rrOrr r)r)r)r)r) rrrGr2rEclone contiguousTr:emptyZcopy_expand) rrr;rr$rIrJrKrHrnZlhs_non_contigZrhs_non_contigr*r*r+r46sL     r4c ks*|ddrtnt}|ddr$tnt}t|dr@|jdd}tt||||d}d|fdf|df|ff||fdf|||f||ff|||f|||ff|d|f||ff|d|fd||ffd dtfd |tfff } |d i} | D]H\} } || f|j} || f|j}| t | | k}t | |f| |d VqdS) Nsmall_inputs_onlyFr2r$r#)r*r*r*rr sample_kwargs)rGrHrJ) rSMXSr3r2rrrGr:Zbroadcast_shapesrE)rrr;rrHZ_MZ_Sr$rIrHrrzr{rJrKrJr*r*r+ sample_inputs_elementwise_binaryws@      rc s8eZdZdZeeddddddddd fdd ZZS)BinaryUfuncInfoa'Operator information for 'universal binary functions (binary ufuncs).' These are functions of two tensors with common properties like: - they are elementwise functions - the output shape is determined by the input shape - they typically have method and inplace variants - they typically support the out kwarg - they typically have NumPy or SciPy references See NumPy's universal function documentation (https://numpy.org/doc/stable/reference/ufuncs.html) for more details about the concept of ufuncs. NFT) rrrrGr2ralways_returns_boolr<r>r?c  st|_ttdddf} | dt| | d<tt |j |f||t |d| |dkrfi}||_ |dkrxi}||_ ||_||_| |_| |_| |_|jrd|_|jr| stddS)NzSkipping redundant test. TestCommonZtest_numpy_refsr)rrrTz=Can't support lhs and rhs Python scalars but not rhs scalars!)rrZ_original_binary_ufunc_argsr-unittestskiprrRrrr>rBrGr2rrr<r>r?r<)r=r'rrrrGr2rrr<r>r?rHZ common_skipsr r*r+r>sF   zBinaryUfuncInfo.__init__)r@rArBrCrr7r>r"r*r*r r+rsrc ks|si}|ddrtnt}|j\}}|dkr2|n||j}|dkrH|n||j}|jsj|jsj|jsj|jrt t ||f|||||d|dVn0|fddfD]"} t t | |||||d|dVqdS)NrF)rr;lowhighrrHrDr*) rrLdomain _domain_epsrrrrrEr) rrr;rZ op_kwargsrH_Lrrrnr*r*r+sample_inputs_elementwise_unarysJ  rcCs||}|||dSr4)Z masked_fill_)rr safe_valuemaskr*r*r+_replace_values_in_tensorsrc Ks||j\}}|dkr|n||j}|dkr,|n||j}t|f|||d|}|jdk rx|tjk rx|j\}}t||||S)N)rrr;)rrrreference_numerics_filterr:rr) rnrr;rHrrrYrrr*r*r+_make_unary_elementwise_tensor!s   rcCs |jtjkr|S|j\}}|dkr&|n||j}|dkr<|n||j}|jtjkrd|dk rdt|d}|jjs|jjs|dk rt |nd}|dk rt |nd}|j dk r|j \}}t ||||dk s|dk r|jjr|j|||j||n|j||d|S)Nr)minmax)r;r:rrrr(rr.r/rfceilfloorrrrealZclamp_imag)rYrrrrrr*r*r+ _filter_unary_elementwise_tensor1s&      rc ks|tjkrtjd|tjdtjd|dtjd|dtjd|dtd||dtd||df}|D] }t|||||dd Vq^d }tt||||d }|D](} || }t|||||dd VqdS) NrrTr8F)TFrErFr)rFrErC)rr r )rrr)rMrrr)r rrrrrr;r) r:rrrrrErrr) rrr;rrHZtensorsrYrHrIrnr*r*r+"generate_elementwise_unary_tensorsOs*       rccsDt||||dD].}t|j|d}t|||||ddVqdSNr%rrr)r'rrFrErrrr;rrrYr*r*r+.generate_elementwise_unary_small_value_tensorsus rccsFt||||dD]0}t|j|d}t|j||||ddVqdSr)r*rrFrErrr*r*r+.generate_elementwise_unary_large_value_tensorss rccs:t||||dD]$}t|j||||jddVqdS)Nr%rr)r0rErFr)rrr;rrr*r*r+1generate_elementwise_unary_extremal_value_tensorss rc cs|j\}}|dkr|n||j}|dkr,|n||j}tt||||d}|ddd}t|||||ddV|dj}t|||||ddVd}|D]6} || }|d d d } t| |||| ddVqdS) NrrT)rrr)rrrr r)rrrrrErrr) rrr;rrrrIrvrHrnZ t_non_contigr*r*r+0generate_elementwise_unary_noncontiguous_tensorss,   rc csVd}tt|||d}|D]8\}}}|d|||} t| |||| ddVqdS)NrLr%rSrr)rrrTrEr) rrr;rrUrIrnrVrWrYr*r*r+6generate_elementwise_unary_arbitrarily_strided_tensorss  rcks|j||||f|EdHt|f|||d|EdH|tjk r`t|f|||d|EdH|tjtjtjfkr|js|js|j st |f|||d|EdH|js|j r|j rt |f|||d|EdHdSNr%) rrr:rrr(r)handles_large_floatsr.r/rhandles_complex_extremal_valuesr)rrr;rrHr*r*r+#_reference_inputs_elementwise_unarysd    rcksvtt||||f|}|EdH|D]}|Vq&t|f|||d|EdHt|f|||d|EdHdSr)rrrrr)rrr;rrHr6rr*r*r+"reference_inputs_elementwise_unarys<    rc s<eZdZdZeddddeedddd fd d ZZS) UnaryUfuncInfoaOperator information for 'universal unary functions (unary ufuncs).' These are functions of a single tensor with common properties like: - they are elementwise functions - the input shape is the output shape - they typically have method and inplace variants - they typically support the out kwarg - they typically have NumPy or SciPy references See NumPy's universal function documentation (https://numpy.org/doc/1.18/reference/ufuncs.html) for more details about the concept of ufuncs. )NNTFcCsiifSr4r*)rr;rFr*r*r+rN rOzUnaryUfuncInfo.N) r2rrrsupports_complex_to_floatrrrrc  sVt|_tj|f|||d| ||_||_||_||_| |_ | |_ d|_ dS)N)r2rrrb) rrZ_original_unary_ufunc_argsrr>rrrrrrr) r=r'r2rrrrrrrrrHr r*r+r> s" zUnaryUfuncInfo.__init__) r@rArBrCrrrr>r"r*r*r r+r src s8|tjkp|tjk}|sLttttdtdf|||dttd|||d}nxd}d}|jdkrdd} n,|jdkrtd} n|jd krd } d }d }nd } tt| d|||||dtt| d|||||d}|jtj kr2t t |sdndddddt t dddt t dddt |ffdddDS|jtj krt t |sRdndddddt t dddt t |sdndddt t dddt t dddt t dddgSt t |sd nd!ddd"dt t dddt t |s d#nd!d$dt |ffd%dd&DSdS)'Nrrr%))zfft.hfftz fft.irfftz_refs.fft.hfftz_refs.fft.irfft))rrRrR!)z fft.hfft2z fft.irfft2z_refs.fft.hfft2z_refs.fft.irfft2))rrRr)z fft.hfftnz fft.irfftnz_refs.fft.hfftnz_refs.fft.irfftn))rrrrr`ra))rr) r)rrrr;r)r r)rPrrvZortho)srnormr)r)r)rc3s"|]}tt|ddVqdSrrNrErSrXrZ nd_tensorr*r+rZ sz-sample_inputs_spectral_ops..)rr )rMrrr )rrrrr)nrrrO)rc3s"|]}tt|ddVqdSrrrrr*r+rZ s)rrr) r:rhalfrrrr' ndimensionalSpectralFuncTypeNDrErSTwoD) r=rr;rrHZis_fp16_or_chalfZ oned_tensorrrrHr*rr+sample_inputs_spectral_ops9 s        rr)ZOneDrrcs4eZdZdZdeeddedfddZZS)SpectralFuncInfoz.Operator information for torch.fft transforms.N)rr2rr.)rc stt|_|j||dk r,t|ng}|tttt j t ddiddg7}t j f||||d|||_||_dS)Ng{Gz?rZ#test_complex_half_reference_testing)r'r2r.r)rSrrZ_original_spectral_func_argsrr9rr-rr:rrrr>rr)r=r'rr2rrr.rHr r*r+r> s*   zSpectralFuncInfo.__init__) r@rArBrCrrrr>r"r*r*r r+r srcs.eZdZdZeddddfdd ZZS) ShapeFuncInfozZEarly version of a specialized OpInfo for Shape manipulating operations like tile and rollNr2rrrc s,tt|j|f||||d|||_dS)Nr)rrr>r)r=r'rr2rrrrHr r*r+r> s zShapeFuncInfo.__init__)r@rArBrCrr>r"r*r*r r+r s r)r same_sizerrcs@|r fddtDSfddtDSdS)Ncs g|]}tfdqS)r;rrr)rXrNrr;rr*r+ sz)sample_inputs_foreach..cs(g|] }t||fdqSrr)rXrrr*r+r s)r )r=rr;rrrrrr*rr+sample_inputs_foreach srcCsRd|}|d}tt|d}tt|d}tt|d}ttj|dd}||||fS)N _foreach_r)r#r:rl)r'Zop_nameZinplace_op_namerZ inplace_opr ref_inplacer*r*r+get_foreach_method_names s   rcs4eZdZdZeeejddeffdd Z Z S)ForeachFuncInfoz;Early version of a specialized OpInfo for foreach functionsNFc  sftjd|f||||d|t|\}} } } ||_| |_| |_| |_||_|dkrbtj j |_dS)Nrrr) rr>rrrrrsupports_alpha_paramr:ZlinalgZ vector_norm) r=r'r2rrrrrHZforeach_methodZforeach_method_inplaceZtorch_ref_methodZtorch_ref_inplacer r*r+r> s. zForeachFuncInfo.__init__) r@rArBrCrrr:rrr>r"r*r*r r+r srcOs|||jf||S)zGradcheck wrapper for functions that take Hermitian matrices as input. They require a modified function because the finite-difference algorithm for calculating derivatives does not preserve the Hermitian property of the input. )ZmH)rrFrGrHr*r*r+!gradcheck_wrapper_hermitian_input. srupperidxcOsF|r||n ||}||d||f||dd|f|S)aJGradcheck wrapper for functions that take lower or upper triangular matrices as input. They require a modified function because the finite-difference algorithm for calculating derivatives does not preserve the triangular property of the input. `idx` is used to specific which `args[idx]` is to be triangularized. Nr)ZtriuZtril)rrrrGrHZtriangular_argr*r*r+"gradcheck_wrapper_triangular_input7 src Ost||}|ddd}t|}t|}t|} ||| } t|f|d|| f||dd||d|S)zGradcheck wrapper for functions that take lower/upper triangular matrices with real and positive diagonals, for example, cholesky-like operations. rrrNrr)Zdiagonalr:Z diag_embedZ ones_liker) rrrrGrHrrZarg_diagZarg_diag_embedZid_diag_tensorZ id_tensorZnew_argr*r*r+9gradcheck_wrapper_triangular_input_real_positive_diagonalB s&     rcOsP||f||}|d}|dk rLtjj||f||}t|||g}|S)zGradcheck wrapper for masked operations. When mask is specified, replaces masked-out elements with zeros. Use for operations that produce non-finite masked-out elements, for instance, for minimum and maximum reductions. rN)rr:maskedZ _output_maskwhere new_zeros)rrFrGrHoutputr output_maskr*r*r+"gradcheck_wrapper_masked_operationT s  rc Os~||f||}|d}|d}|dk rz|dk rzt||}tfd|i|}tjj|f||} t| ||g}|S)aSGradcheck wrapper for masked pointwise operations. Assumes that the result will be masked iff both tensors are masked at a specific index When mask is specified, replaces masked-out elements with zeros. Use for operations that produce non-finite masked-out elements, for instance, for minimum and maximum reductions. input_mask other_maskNr)rr:rrSrZ _input_maskrr) rrFrGrHrrrZ combined_maskZ new_kwargsrr*r*r+,gradcheck_wrapper_masked_pointwise_operationd s    rc sLdd|r|n|j}t|jtt|jtfdd|DdS)z Given a SampleInput, this function analyzes its input, args and kwargs, and produces a copy with each non-Tensor entry being copied by reference, and with each Tensor entry cloned with `t.clone().requires_grad_(t.requires_grad)` cSs(t|tjr ||jS|SdSr4)r5r:rlr}rrrrur*r*r+ clone_tensor s z"clone_sample..clone_tensorc3s|]\}}||fVqdSr4r*rfrr*r+rZ szclone_sample..r)rHrErFrRrqrGrSrp)rrHrr*rr+ clone_samplex sr)T)N)F)dr6collections.abcrfrrZ dataclassesrrenumr functoolsr itertoolsrtypingrrr r r r Ztorchgen.utilsrr:Z torch.testingrZ*torch.testing._internal.common_device_typerrrZ$torch.testing._internal.common_dtyperrrrZ$torch.testing._internal.common_utilsrrrrZtorch.testing._internal.opinforrrrrobjectr%r,r-rE namedtuplerrrrrr rrr1r7rBr&r5r'r*r0r+r,r-r4rrrrrrrrrrrrrrrrrrrrrrrrrrrrr*r*r*r+s        7>'  'Z*($  ! = $ / &  # A)M /'    # 8 m '  &