o I hD@s<ddlZddlZddlZddlZddlZddlZddlZddlmZm Z ddl m Z ddl m Z mZmZmZddlmZmZmZmZmZmZddlZddlmZddlmZddlmm Z!ddlm"Z"m#Z#ddlm$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8ddl9m:Z:m;Z;mZ>m?Z?gd Z@ejAZAejBjCZCejDjEjFZFd d ZGd d ZHddZIddddZJddlKmLZLeMZNeNddddefddZOddZPddZQeOe*jRdddd ZSeOe*jTd!d"ZUeOe*jTd#d$ZVeOe*jTd%d&ZWeOe*jTd'd(ZXeOe*jTd)d*ZYeOe*jTd+d,ZZeOe*j[d-d.Z\eOe*j[ddd/d0Z]eLeFj^d1e6fd2d3Z^eLeFj_e?d1e6fd4d5Z_eOe*jTd6d7Z`eOe*jTd8d9ZaeOe*jTd:d;ZbeOe*jTdd?ZdeOe*jTd@dAZeeOe*jTdBdCZfeOe*jTdDdEZgeOe*jTdFdGZhe?e=dHe*jidIdJe6dKe0de6fdLdMZjdJe6dKe0de6fdNdOZkeLeFjle?d1e6de6fdPdQZleOe*j[dddRdSZmeOe*j[dddTe6de6fdUdVZndJe6de6fdWdXZoeOe*jpddYdJe6de6fdZd[ZqeOe*jpdJe6de6fd\d]ZreOe*jpdddJe6de6fd^d_ZseOe*jpdddJe6de6fd`daZteOe*jpdJe6de6fdbdcZuePejvjwddZxeOe*jpddYdJe6de6fdedfZyeOe*jTeFjzdYdgdhZzeOe*jTdidjZ{eOe*jTdkdlZ|eOe*jTdmdnZ}eOe*jTdodpZ~eOe*jTdqdrZe? ddJe6dsedteejde6fdudvZeLeFje?e=dwe*jTdI ddxe6dse(dyede6fdzd{ZeLeFje? |  ddJe6d}ee0d~ee0dee0de6f ddZdJe6fddZeOe*j[edddZdJe6de6fddZdJe6de6fddZeOe*jTddZeLeFje?e=de*j[dIdddJe6dede6fddZeOe*jTddZeOe*jTdJe6de6fddZeOe*j[ddddZeOe*j[ddddZeOe*jpddddZeOe*jTddZeOe*jTddZeOe*jTddZeOe*jTddZeOe*jddYdJe6de6fddZeOe*jTddZeOe*jTddZeOe*j[ddddZdxe6de6fddZeNddddddfdefddZeLeFje?e=de*j[dIdddJee6e0fdee6e0fdee0fddZee*jTdddddZee*j[ddJe6de6de6fddZee*j[ddJe6de6de6fddZee*j[ddJe6de6de6fddZee*j[ddJe6de6de6fddZee*j[ddJe6de6de6fddÄZee*jTddčdJee6e0fdee6e0ffddƄZeLeFje?ddǜdJee6e0fdee6e0fdeefddʄZee*jpddčdJe6de6de6fdd̄Zee*jddJee6e0fdee6e0fde6fdd΄Ze?dJee6e0fdee6e0fdeAfddЄZeej*j[dddэdJee6e0fdee6e0ffddӄZdJeAdeAdeAfddՄZdJeAdeAdeAfddׄZee*j[ddddJe6de6de6fddلZee*j[ddddJe6de6de6fddۄZee*j[ddddJe6de6de6fdd݄ZeLeFje?dd߃dxe6dee6e6ffddZee*j[ddddJe6de6de6fddZee*jpddčdJe6de6de6fddZee*jpddčdJe6de6de6fddZee*j[dddd1e6de6de6fddZee*j[ddddJe6de6de6fddZee*jTddddJe6de6de6fddZee*jTddddJe6de6de6fddZdedJe6de6dededdf ddZ ddJe6de6dededede6f ddZee*j[ddddJe6de6fddZee*jpddčdJe6de6de6fddZee*j[ddddJe6de6de6fddZee*j[ddddJe6de6de6fddZee*jpddJe6de6fddZeOe*jpdJe6fddZee*jpddJe6de6fddZee*jpddJe6de6fd d Zee*jpddčdJe6de6de6fd d Zee*j[ddJe6de6de6fd dZee*j[ddJe6de6de6fddZee*j[dddJe6de6de6fddZee*jpddčdJe6de6de6fddZee*jiddddJe6de6de6fddZee*j[ddJe6de6de6fddZeLeFjʃe? ddJee6e0fdee6e0fde0fddZeLeFj˃e?e=de*j[dIdddJee6e0fdee6e0fde0fddZee*jTdddd dJe6de6de6fd!dZeLeFj̓e?e=de*jTdIdJee6e0fdee6e0ffd"d#Zeej*j[ddd$dJee6e0fdee6e0ffd%d&ZeLeFjσe?e=d'e*jTdIdd(dxe6d)e6d*e6dKe0de6f d+d,ZeLeFjЃe?e=d'e*j[dIdd(dxe6d)e6d*e6dKe0de6f d-d.ZeLeFjуe?e=d/e*j[dI  ddJe6d0ee7d1ee7de6fd2d3ZeLeFj҃e? ddxe6d0ee7de6fd4d5ZeLeFjӃe? ddxe6d1ee7de6fd6d7ZeLeFjԃe?e=de*jidI  dd8eAdJee7dee7fd9d:ZeLeFjՃe?ej֐d;dJe6dZdd?dJeAdeAfd@dAZeLeFjكdJe6de0fdBdCZ       ddJe6dDee%dteejdEeedFeejde? ddxe6d>ede6fd?d@Z=eLeFj?e?  d d1e6de6d>edAedBede6f dCdDZ?eLeFj@  d dxe6d>edAedBede6f dEdFZ@eLeFjAe?  G d!de6d>edAedBede6f dHdIZAeLeFjBe?dee6de6fdJdKZCdee6de6fdLdMZBdJe6dNe(de8fdOdPZDeLeFjEjdJe6fdQdZEdJe6de6fdRdSZFeLeFjGdJe6de6fdTdUZGeLeFjHdJe6dVedAede6fdWdXZHeHZIeLeFjJdxe6dededede6f dYdZZJeLeFjKe?dxe6dededefd[d\ZKdddkdJe6dsedteejdaeeAde6f d]d^ZLeLeFjMdddkdJe6dsedteejdaeeAde6f d_d`ZMeLeFjNdddkdJe6dsedteejdaeeAde6f dadbZNeLeFjOdJe6dsede6fdcddZOeLeFjPjdJe6de3de6fdedfZPdxe6dSe6de6fdgdhZQdJe6de6fdidjZRe? ddJejAdkejAdseedejAfdldmZSe?dejTdddej dndteejdFejڐdDee%doedGedge?dejTddddyde3de0dteejdFejڐdDee%dGedoede6fddZidddddej֐ddJe6de0dteejdFeejdDee%dGedoededeeeeffdАdфZ|dedededtejdFejڐdGef dҐdӄZ}eLeFj~e? dejejTdddtdeded>edtejdFejڐdDe%dGede6fdՐdքZ~deded>edeeeeffdאd؄ZeLeFje? dejejTdddtdeded>edtejdFejڐdDe%dGede6fdِdڄZeLeFje?dddddۜdJe7de6dedefdߐdZeLeFje?e=dwe*j[dId&ddZeLeFje?e=dwe*j[dId'ddZeLeFje?e=dwe*j[dIdddZeLeFje?e=dwe*j[dId(ddZeLeFje?e=de*j[dI   d&ddddddddZeLeFjd ddddZeOe*jTdxe6fddZeOe*jTdxe6fddZeLeFje?ddsee(fddZddZddZeLeFje?ee=de*j[dIddZeLeFje?ee=de*j[dIddZeLeFje?dTe6de6dsed!efddZeQeSZeQeUZeQeVZeQeZeQeЃZeQeσZeQeWZeQeXZeQeYZeQeZZeQeZeQeZeQeZeQe\ZeQeZeQeZeQeZeQe]ZeQeуZeQe҃ZeQeӃZeQe_ZeQeZeQe`ZeQeaZeQeMZeQeNZeQeZeQebZeQeZeQeZeQecZeQeeZeQedZeQefZeQehZeQegZeQeZeQemZeQeZeQeZeQenZeQeZeQeZeQeZeQeZeQeZeQeZeQeZeQezZeQeZeQeZeQebZeQe{ZeQeZeQe}ZeQe~ZeQe|ZeQeZeQeZeQeZeQeƒZeQeÃZeQeƃZeQexZeQeZeQeǃZeQeZeQeȃZeQeZeQeZeQeZeQeɃZeQeZeQeZeQeZeQeZeQeZeQeZeQeZeQeZeQeZeQe˃ZeQeZeQeZeQe{ZeQezZeQẽZeQeZeQe̓ZeQeZeQeZeQeZeQeZeQelZeeFjGZeeFjZeeFj@ZeeFj ZeeFjZeeFj7ZeeFjZeeFjEZeeFjHZeeFj/ZeeFjOZeeFjPZddZddZddZdejd ee7e8ffd d Z dd d Zddddddd"ZddlZddlZddlZddlZddlZdS()N)IterableSequence)Enum)partialreducesingledispatchwraps)AnyCallablecastOptionaloverloadUnion) sym_floatsym_int)BoolLikeDeviceLikeTypeDimDimsSequenceTypeDimsType dtype_to_typeELEMENTWISE_TYPE_PROMOTION_KIND FloatLikeFloatWithoutSymFloatIntLikeis_weakly_lesser_typeNumber NumberTypeRealNumberTypeREDUCTION_OUTPUT_TYPE_KIND ShapeType StrideType TensorLikeTensorLikeTypeTensorOrNumberLikeTypeTensorSequenceType)_maybe_convert_to_dtype_maybe_resize_out_safe_copy_out"elementwise_type_promotion_wrapper elementwise_unary_scalar_wrapper out_wrapper(absacosacoshasinhasinatanatanh bitwise_notceil conj_physicalcoscosh count_nonzerodeg2raddigammaerferfinverfcexpexpm1 exponentialexp2fillfill_floorfrac geometric index_add index_copy index_copy_ index_select index_fill index_fill_isfiniteisinfisposinfisneginfisnanisreali0lerplgammaloglog1plog2log10 log_normal log_softmaxmvlgammanormnormal nan_to_numnegpositiverad2deg reciprocalroundsigmoidsgnsignsignbitsinsincsinhsoftmaxsqrtsquaretantanhtracetruncaddatan2 bitwise_andbitwise_left_shift bitwise_orbitwise_right_shift bitwise_xor clamp_min clamp_maxcopysigndiveq float_power floor_dividefmaxfminfmodgcdgegt heavisidehypotigammaigammacimagiscloselcmle logaddexp logaddexp2 logical_and logical_not logical_or logical_xor logsumexpltmaximumminimummulne nextafterpowrealrpow remainderrsubrtruediv rfloordivsub true_divide trunc_dividexlogyaddcdivaddcmulclamp masked_fill masked_fill_whereclonecopy_toitemtoallamaxaminanycumsumcumprodmeandotvdotstdstd_meansum sum_to_sizeprodvarvar_meanaddralias alias_copy atleast_1d atleast_2d atleast_3d as_stridedas_strided_copyas_strided_scatter block_diagbroadcast_shapesbroadcast_tensors broadcast_tocatchunk column_stackconjconstant_pad_nd contiguous diag_embeddiagdiagonal diagonal_copydiagonal_scatterdsplitdstackexpand expand_as expand_copyflattenflipfliplrflipudhsplithstackmeshgridmovedimnarrow narrow_copynative_group_normnative_layer_normpermute permute_copyravelrepeatreshape reshape_asrollrot90rsqrtsplit_with_sizesstack swap_axessqueeze squeeze_copytt_copyTtake_along_dim tensor_split transposetranspose_copy unbind_copyunfold unfold_copy unsqueezeunsqueeze_copyviewview_as view_copyvsplitvstackview_as_complex unflattenunbindtriutril triu_indices tril_indicesarangecauchyempty empty_likeempty_permuted empty_stridedeyefull full_likelinspacelogspace new_emptynew_empty_stridednew_fullnew_ones new_zerosones ones_likerandn scalar_tensorzerozeros zeros_likeallcloseequal bucketize is_complexrenormstftistftcCs|dup|jdkS)Nhputypedevicer3H/var/www/vscode/kcb/lib/python3.10/site-packages/torch/_refs/__init__.pyis_noncontiguous_supportednr5cCsBd}ddlm}|D] }t||r|j}nq t|s|}|S)Nr) FakeTensor)torch._subclasses.fake_tensorr7 isinstance fake_devicer5r) input_tlistoutputr2r7rr3r3r4handle_noncontiguous_outputsrs  r=c sddlm}tddtdd|D}t|dkrdS|D] tts'Jqdgttdd|Dt |D]E\t d d td D]6|dkrbdkr[t d <qG|dkr}t kfd dqGq9S) Nrguard_size_obliviouscss$|] }t|tr |fn|VqdSNr9r.0xr3r3r4 s  z$_broadcast_shapes..cSs|duSr@r3rDr3r3r4sz#_broadcast_shapes..css|]}t|VqdSr@len)rCshaper3r3r4rEz9Attempting to broadcast a dimension with negative length!c s&ddddd S)Nz.Attempting to broadcast a dimension of length z at z ! Mismatching argument at index z had z0; but expected shape should be broadcastable to r3r3arg_idx common_shapeidxrKr3r4rGs)%torch.fx.experimental.symbolic_shapesr?tuplefilterrJr9rrmax enumeraterange ValueErrortorch_check)_shapesr?shapesr3rNr4_broadcast_shapess8    r]T)preserve_cpu_scalar_tensorscs8tdd|Dfddtfdd|DS)Ncss$|] }t|tr |jndVqdSr@)r9r"rKrCrr3r3r4rEs"z#_maybe_broadcast..csj|durdSt|tr |St|tr)rt|r|St|js'|S|Stdt t |d)Nz#Unexpected type when broadcasting: !) r9rr"utilsis_cpu_scalar_tensor same_shaperKr RuntimeErrorstrr0)rDrK)rPr^r3r4__maybe_broadcasts   z+_maybe_broadcast..__maybe_broadcastc3s|]}|VqdSr@r3rB)rfrPr3r4rE)r]rS)r^argsr3)rfrPr^r4_maybe_broadcasts  ri)register_decompositionF)aten_op extra_meta exact_dtypereturncsdtffdd }|S)Nprimcshttdttdddtdtffdd }tur(tjdur2t ||S)Nrmatype_promoting_argstype_promotion_kindrrrncs$dur||}t|g|Sr@)r=)rrr<)rlror3r4_refs z>_make_elementwise_unary_reference..inner.._ref) rr+r*r)r# infer_aten_opra get_aten_op__name__rjrorvrkrmrlruror4inners  z0_make_elementwise_unary_reference..innerr )rurkrlrmr}r3r{r4!_make_elementwise_unary_referencesrcs(fdd}||_tjjd|_|S)a% This function defines an alias of another function and sets its __name__ argument. It also sets its __module__ argument to the module of the caller. Note that when naively doing `alias = fn`, we have that `alias.__name__ == "fn"`, and `alias.__module__ == fn.__module__`. cs|i|Sr@r3rhkwargsfnr3r4_fnz_make_alias.._fnry)ryinspect currentframef_back f_globals __module__)rnamerr3rr4 _make_aliass rcsdtfdd}jd}||_ttt||}ddlm}|j}||vr0|||S)z Given a function with out variant (i.e. using `out_wrapper()), it returns its in-place variant See https://github.com/pytorch/pytorch/wiki/Developer-FAQ#how-do-in-place-operations-work-in-pytorch cs|g|Rd|i|S)Noutr3)rrrhrrr3r4r sz_make_inplace.._fn_r) getmodule) rryrjgetattratenrr__all__append)rr inplace_namer_allr3rr4 _make_inplaces    rrpcC t|Sr@)primsr,rqr3r3r4r, r,cCrr@)rr-rqr3r3r4r-# r-cCrr@)rr.rqr3r3r4r.(rr.cCrr@)rr0rqr3r3r4r0-rr0cCrr@)rr/rqr3r3r4r/2rr/cCrr@)rr1rqr3r3r4r17rr1cCrr@)rr2rqr3r3r4r2<rr2cCrr@)rr3rqr3r3r4r3Arr3cCrr@)rr4rqr3r3r4r4Frr4inputcCs t|jSr@)rais_complex_dtypedtyperr3r3r4r*N r*cCst|js|St|Sr@)rarrrr5rr3r3r4r5Ss  r5cCrr@)rr6rqr3r3r4r6[rr6cCrr@)rr7rqr3r3r4r7`rr7cCrr@)rr:rqr3r3r4r:err:cCrr@)rr;rqr3r3r4r;jrr;cCrr@)rerf_invrqr3r3r4r<orr<cCrr@)rr=rqr3r3r4r=trr=cCrr@)rr>rqr3r3r4r>yrr>cCrr@)rr?rqr3r3r4r?~rr?cCrr@)rrArqr3r3r4rArrAza,rsrrvaluecCsbt|tsJt|tsJt|j}tt||s+dt|d|d}t|t ||SNzvalue argument of type  cannot be safely cast to type r`) r9r"rrarrrr0rXrrB)rrr python_typemsgr3r3r4rBs  rBcCst||}t|||Sr@)rrBr)rrrrr3r3r4rCs  rCcCrr@)rYr&rr3r3r4r$s r$cCrr@)rrDrqr3r3r4rDrrDrDcCs*ttt|t|}t||Sr@)rYrrDr,rgr)rDtrunc_xr3r3r4rEs rEcCs0t|tsJtt|jddt|S)NcSdS)Nz#imag only supports complex tensors.r3r3r3r3r4rGzimag..) r9r"rYrZrarrrrrqr3r3r4rs  r)rkcCs0t|js t|jrt|St|tjdS)Nr) rais_float_dtyperrrrMr!rYboolrqr3r3r4rMs rMcCsZt|jrttt|tt|St|jr%t |t dkStj |tj dS)Ninfr) rarrrYrrNrrrr,floatr&rrqr3r3r4rNs   rNcFttj fddtjrtdkStjtjdS)Nc djS)Nz7Complex dtype is not supported for isposinf, got dtype rr3rqr3r4rG zisposinf..rr rYrZrarrrrr&rrqr3rqr4rO    rOcr)Ncr)Nz7Complex dtype is not supported for isneginf, got dtype rr3rqr3r4rGrzisneginf..z-infrrrqr3rqr4rPrrPcCs t||Sr@rrrqr3r3r4rQrrQr\cCs*t|jr t|dkStj|tjdS)Nrr)rarrrYrr!rrqr3r3r4rRs rRcCrr@)r bessel_i0rqr3r3r4rS rScCrr@)rrUrqr3r3r4rU rrUcCrr@)rrVrqr3r3r4rVrrVcCrr@)rrWrqr3r3r4rWrrWcCrr@)rrXrqr3r3r4rXrrXcCrr@)rrYrqr3r3r4rY rrYdimrcCs6|p|j}t|}t||}t|t||dd|S)NTkeepdim)rraget_computation_dtyper&r)rrrr result_dtypecomputation_dtypea_r3r3r4r[&s   r[selfrrcCst|ts|f}|dkrtt|||Stjt||dd}t || t dkd}|r6|nt ||}tt||||}| |S)NrTrr)r9rnumelrYrr>rVrrrr,rrrs)rrrmaxesmaxes_squeezedresultr3r3r4r2s  rnanposinfneginfcCst|tsJt|jst|jr|S|durd}|dur(t|jj }|dur3t|jj }t t |||}t t |||}t t|||}|S)Nr)r9r"rais_boolean_dtyperis_integer_dtyperrYfinforUminrrQrPrO)rrrrrrr3r3r4r_Fsr_cCst|jtjudddS)NcSr)NzNegation, the `-` operator, on a bool tensor is not supported. If you are trying to invert a mask, use the `~` or `logical_not()` operator instead.r3r3r3r3r4rGez_neg_meta..)rYrZrrrqr3r3r4 _neg_metabs r)rlcCrr@)rr`rqr3r3r4r`mrr`cCs*t|tsJ|jtjurd}t||S)Nz'positive does not support bool tensors.)r9r"rrYrrd)rrrr3r3r4ravs  racCs(t|tsJt|jrt|S|Sr@)r9r"rarrrrrqr3r3r4rs  rcCrr@)rrcrqr3r3r4rcrrcrq)decimalsrcCs>|dkr t|Sd|}d| }ttt|||S)Nr )rrdr)rrrten_pow ten_neg_powr3r3r4rds   rdcCrr@)rrrqr3r3r4rrrcCstdtdtt|S)NrH)rrsr>r`rqr3r3r4resrecCs2t|jr|}t|dkd||S|SNr)rarrr,rYrrg)rra_absr3r3r4rfs rfcCrr@)rrgrqr3r3r4rgrrgcCrr@)rrhrqr3r3r4rhrrhcCrr@)rrirqr3r3r4rirricCs&tj|}t|dkdt||SNrrH)mathpirYrrirqr3r3r4rjs rjcCrr@)rrkrqr3r3r4rkrrkcCrr@)rrmrqr3r3r4rmrrmcCs t||Sr@)rrqr3r3r4rnrrncCrr@)rrorqr3r3r4rorrocCrr@)rrprqr3r3r4rprrpcCrr@)rrrrqr3r3r4rrrrrcs|jttfdd|}tt|dkddt|ddkdd|}t|ddkd d|dd}tt d d |Dd dt| ddkd dt |t dS)Nc dS)Nz^view_as_complex is only supported for floating pointtensors, but got a tensor of scalar type: r3r3 input_dtyper3r4rGsz!view_as_complex..rcSr)Nz-Input tensor must have one or more dimensionsr3r3r3r3r4rGrrMcSr)Nz+Tensor must have a last dimension of size 2r3r3r3r3r4rGrrHcSr)Nz/Tensor must have a last dimension with stride 1r3r3r3r3r4rGrcss|] }|ddkVqdS)rrNr3)rCstrider3r3r4rE sz"view_as_complex..cSr)NzCTensor must have a stride divisible by 2 for all but last dimensionr3r3r3r3r4rG rcSr)Nz0Tensor must have a storage_offset divisible by 2r3r3r3r3r4rGr)rrYrZrarsizerJrbuiltinsrstorage_offsetrview_element_typecorresponding_complex_dtyper)rsizes old_stridesdimsr3rr4r sB      r c s$dtffdd }|S)Nrocsdurjttdddtttfdtttfdtffdd }r1t|}|_tur>t durJrJt ||S)Nrrbrsrrrrncstp t|t fddtpt|t fddtp.t|to-t|t fddt||\}}||}t||g|S)Nc dS)Nzc: Received a lhs Python scalar to an elementwise binary operation that does not accept lhs scalars!r3r3rr3r4rG0 zQ_make_elementwise_binary_reference..inner.._ref..cr)Nzc: Received a rhs Python scalar to an elementwise binary operation that does not accept rhs scalars!r3r3rr3r4rG5rcr)Nz?: Receive two Number inputs to an elementwise binary operation!r3r3rr3r4rG;r)rY _check_valuer9rrir=)rrrr<)rrosupports_lhs_python_scalarsupports_rhs_python_scalarsupports_two_python_scalarsr3r4rv%s      z?_make_elementwise_binary_reference..inner.._ref) ryrr)rTensorrr+rwrarxrjrzrkhas_outrshould_register_decompositionrrrrur|r4r} s,      z1_make_elementwise_binary_reference..innerr~) rurkrrrrrrr}r3rr4"_make_elementwise_binary_references ,rralpharrcCst||\}}|durFt|tr|jn|j}t|}|tkr6tt||s6dt|d|d}t |t|trBt ||}n||}t ||}t ||g|S)z/ Reference implementation of torch.add Nalpha argument of type rr`)rir9r"rrarrrr0rXrrrsr=rrrrrrrr<r3r3r4rsPs    rs)rurrcC t||Sr@)rrtrr3r3r4rts rt)rucCrr@)rrurr3r3r4ru| rucCrr@)r shift_leftrr3r3r4rvrrvcCrr@)rrwrr3r3r4rwrrwcCrr@)rshift_right_arithmeticrr3r3r4rxrrxcCrr@)rryrr3r3r4ryrry)rurcCst|trt|trt||j|jd}nt|tr3t|tr3|j|jkr3d|jd|jd}t|tt|t t |t |S)Nrr2/Expected divisor (b) to be on the same device (&) as dividend (a), but it is found on r`) r9rrr#rr2rdrrhr`r,rrrrr3r3r4r|s  r|) rounding_modercCsJ|dur t||S|dkrt||S|dkrt||Sd|d}t|)z/ Reference implementation of torch.div NrrrDzLdiv expected rounding_mode to be one of None, 'trunc', or 'floor' but found .)rrrrX)rrrrrr3r3r4r}s    r}cCrr@)rr~rr3r3r4r~ r~cCst|ts t|ts Jt|tr+|dkr|S|dkr!||S|dkr*t|Sn$t|trO|dkr:t|dS|dkrOt|j sJt |j rOt |St ||S)N?g@?T)r9r#rrrYrmrBrarrrrArrrr3r3r4rs&        rcCsxt|trt|trtdt||}|dusJt|r#tj}ntj}t ||}t ||}t ||\}}t ||S)Nz=Receive two Number inputs to an elementwise binary operation!) r9rrXraget_higher_dtyperrY complex128float64r&rirrrrrr3r3r4rs      r)rurrcs2t|trt|trt|}t|}nWt|tr't|tr't||j|jd}nCt|tr;t|tr;t||j|jd}n/t|trjt|trj|j|jkrj|jtdkrbd|jd|jd}t|tj ||jd}t|trtt|tsvJ|jt rt ||St rt||Stdfdd dS) Nrcpurrr`r1Fcr)Nz not supported for floor_divider3r3rr3r4rGArzfloor_divide..)r9rr#rrr2rYrdr device_putrar_floor_divide_floatr_floor_divide_integerrZrr3rr4r#s&       rcCs`t||\}}|jjst||St|t|kt||dk}t||t ||jSr) rir is_signedrr}rYrhrrr&)rrroffsetr3r3r4r Ds  &r c Cst||}tt|||}tt|dt|d}t|d}t||}t|t|d|}t|}t t||d}t|t |d|}t||}t d|j |j d} tt|d|t| |}tt|d||S)NrrHrr)rrrryrrrurrDrrsr#rr2r|) rrrmodr}different_signed_inputsnon_zero_remaindermask floor_div basic_div zero_tensorr3r3r4r Os    r cCrr@)rrrr3r3r4rhrrcCrr@)rrrr3r3r4rqrrcCrr@)rrrr3r3r4rzrrmantissaexponentcCstjt|Sr@)rY return_typesfrexprrr3r3r4rsrcCrr@)rrrr3r3r4rrrcCrr@)rrrr3r3r4rrrcCrr@)rrrr3r3r4rrrvaluescCsFt|d}tt|dt|}t|dd}t|||}|Sr)rYr~rrrQr)rr input_eq_zero input_lt_zerozeros_and_onesr<r3r3r4rs rcCrr@)rrrr3r3r4rrrcCrr@)rrrr3r3r4rrrcCrr@)rrrr3r3r4rrrrrtolatolcsXtjjkfddtdkfddtdkfdddS)NcsdjdjdS)Nz4: Attempting to compare tensors of different dtypes  and r`rr3)rrrrr3r4rGz#_check_close_args..rcsddS)Nz6: rtol must be greater than or equal to zero, but got r`r3r3)rrr3r4rGcsddS)Nz6: atol must be greater than or equal to zero, but got r`r3r3)rrr3r4rGr!)rYrrrZrrrrrrr3)rrrrrrr4_check_close_argss   r#h㈵>:0yE> equal_nanc Cstd||||dt||}|r(t|jst|jr(t|tt|t|}|dkr2|dkr2|St|jsNt|jsNt |t }t |t }t |tt||}tt||}t|tt|t||}|S)Nz torch.iscloser"r)r#r~rarrrrrrQrconvert_element_typerYget_default_dtypersr,rrrMr) rrrrrr&close allowed_error actual_errorrr3r3r4rs  rcCs~|j}|tjtjfv}|rt|tj}t|tj}t||}t|dkd|}t t |||}|s9|St||Sr) rrYint8int16rr'int32rrr,r})rrrrpromote_to_intgresr3r3r4r s rcCrr@)rrrr3r3r4r rrc Cst|t|k}t|||}t|||}tttt|t|t|k}t|js;t|jrxt|dk}t||t t |t |}t|||t t ||}t |} t| t tdtd|St|||t t ||S)Nrr)rYrrrrrMrarrrVr>rWrQcomplexr) rrrrmax_min_inf_mask neg_min_maskinf_vals non_nan_valsnan_maskr3r3r4r(s"& "rcCstt|jp t|j dd||k}t|||}t|||}tt|||k}dt d}|t t |||}t|||S)NcSr)Nz)logaddexp2 doesn't support complex dtypesr3r3r3r3r4rGMrzlogaddexp2..rr) rYrZrarrrrrNrrVrWrA)rrrrr3r4r5 inv_log_2rr3r3r4rEsrcCs0t|js |dk}t|js|dk}||@Srrarrrr3r3r4rY  rcCst|js |dkS|Srr;rqr3r3r4rds rcCs2t|js |dk}t|js|dk}t||Sr)rarrrwrr3r3r4rks   rcCs0t|js |dk}t|js|dk}||ASrr;rr3r3r4rwr<rcCrr@)rrrr3r3r4rrrcCrr@)rrrr3r3r4rrrcCrr@)rrrr3r3r4rrr)rurcCrr@)rrrr3r3r4rrrcCrr@rrr3r3r4rrrcCrr@)rrrr3r3r4rrrcCrr@)rrrr3r3r4rrrrHcCs&t|tr d}t|tj|||dS)Nz?Received a Number for the first argument, but expected a Tensorr)r9rrXrYr)rrrrrr3r3r4rs rcCst||\}}t|tr%t|tr%tt|j o t|j dd|dkrat|tr1|jn|j}t|}t t ||sPdt |d|d}t |t|tj r]t ||}n||}t ||}t||g|S)z/ Reference implementation of torch.sub cSr)NzwSubtraction, the `-` operator, with two bool tensors is not supported. Use the `^` or `logical_xor()` operator instead.r3r3r3r3r4rGrzsub..rHrrr`)rir9r"rYrZrarrrrr0rXrrrrr=rr3r3r4rs"   rr)rurrkrcCrr@)rr}rr3r3r4rs c Cstt|tp t|tddt|tr$t|tr$t||j|jd}nt|tr7t|tr7t||j|jd}t|ts>Jt|tsEJtt |ddt |t |}tt |t d|S)NcSr)Nz/Expected either argument a or b to be a Tensor"r3r3r3r3r4rG rzxlogy..rrr)rYrZr9r"rr#rr2rr~rrVrQr)rrrrhsr3r3r4rs$r)rurkrcCs0t|}t|rt||Stt||Sr@)ra get_dtyperrr}rrrr3r3r4rs   r)rtensor1tensor2rr?r@csJdur|j}t|tttfdd|||S)z3 Reference implementation of torch.addcdiv NcdtddSrr/r3rrr3r4rGBzaddcdiv..rrarrYrrr0rr?r@rrr3rCr4r-  rcsJdur|j}t|tttfdd|||S)z3 Reference implementation of torch.addcmul NcrBrr/r3rCr3r4rG]rDzaddcmul..rErFr3rCr4rHrGr)rrrrUrrUcCs|dur|durd}t||dur(t|}tt|||}t|||}|durBt|}tt|||}t|||}|S)Nz+clamp called but both min and max are none!)rXrYrQrwrrr)rrrrUra_isnan conditionr3r3r4rcs   rcCtj||dS)N)rrYr)rrr3r3r4rzrzcCrJ)N)rUrK)rrUr3r3r4r{rLr{predcsb|dus|dur ttj||ddtjtjufddt||\}}t ||S) NTallow_cpu_scalar_tensorscr)Nz#expected predicate to be bool, got rr3rMr3r4rGrzwhere..) NotImplementedErrorracheck_same_devicerYrZrrrirr)rMrrrr3rQr4rs   r memory_formatrUcCstj||d}|SNrT)rr)rrrUrr3r3r4rsr)allow_cross_devicecCs:|s|j|jkrd|jd|jd}t|t||S)NzAttempting to copy from device z to device z*, but cross-device copies are not allowed!)r2rdrr)rrrrWrr3r3r4rs rcCs>|dkrd|d}t|t|j}|t|S)NrHzCan't convert a tensor with z elements to a number!)rrXrarrrr)rrr number_typer3r3r4rs  rr2copylayout pin_memory non_blockingcCs\| o-|dup |j|ko-|dup|j|ko-|dup|j|ko-|dup-|tjkp-tj||dSrV)r2rrZrYpreserve_formatrais_contiguous_for_memory_format)rrr2rrYrZrUr[r\r3r3r4_to_will_aliass  r_cOstr@)rRrr3r3r4 _to_dispatchr`cCs|||||d}|SN)r2rr\rYrUr3r2rr\rYrUrr3r3r4 _to_devices rdcCst|||||d}|Srb)rYr2rcr3r3r4_to_device_strs recCs||||d}|S)N)rr\rYrUr3)rr\rYrUrr3r3r4 _to_dtypes rfothercCs(|j}|j}|j}||||||d}|S)N)r2rrZr\rYrU)r2rrZ)rgr\rYrUr2rrZrr3r3r4 _to_other)srh to_kwargscCsgd}d|vrt|dtrt|d|d<|D];}||vrU|dkr+||tjusP|dkrF||j|jjkrF||jrP||j|jjksPt||d||krU||qdS)N)rr2rZrUr2rU) r9rerYr2r]r0indexrpop)rrrioptions_to_checkkwr3r3r4_canonicalize_to_argumentsAs rncOst|dkr t|i|}d|vsJt||t|fi|r"|Sd|vr+|dnd}d|vr6|dnd}|sD|d|j|jkr]|s]d|vr]d|vr]d |vr]t||d|jSt j |fi|}t |||S) Nrr[rYFr\rrUr2rZ) rJr`rnr_rkgetrrr'rYrr)rrrhrrYr\rr3r3r4rYs(    r) has_identityaccepts_dim_tuplerkeepdimsrrrorprqrrrroutput_dtype_kindcsttsJjdkrtdjd|dur-t|ts J|dur-||jkr-td|s:dus:tts:JttrBftj|sbjdkp[t fddD} | sbtdt ||\} } t | |} |rfd d t jD} fd d t jD}t| | |} |dur| dusJ|dur| |jkrtd t|| j}t| |d S| j| kr| durt| | } | S)N@zReceived a tensor with z? dimensions, but only tensors with up to 64 dims are supported!z4dtype argument and out dtype must match in reductionrc3|]}j|VqdSr@rKrCirqr3r4rErgz_reduction..zJreducing over zero-size dimension for reduction operation without identitycs"g|] }|vr j|ndqSrHrvrwrrrr3r4 s"z_reduction..csg|]}|vr|qSr3r3rw)rr3r4r{z7Expected the dtype of reduction result and out to match copy_fromr)r9r"ndimrdrrrareduction_dimsrKrrreduction_dtypesr&rWrbroadcast_in_dimr'r(r')rrrorprqrrrrrrs valid_shaperrr output_shapebroadcast_dimsr3rzr4 _reductionsV    "      rcspttj}tdi}t|tddfdd }jd}||_|j|ttt|||S)zk Given a view function (e.g. torch.diagonal) generates its copy variant (e.g. torch.diagonal_copy) __annotations__Nrcs.|d|i|}|dur|Stdd|S)NrcSs|jtjdSrV)rrYcontiguous_formatrFr3r3r4rGz3_make_copy_from_view.._fn..)pytreetree_map)rrhrrrr3r4rsz!_make_copy_from_view.._fn_copy)rrryr+rrupdaterj)raten_fn annotationsr copy_namer3rr4_make_copy_from_views     rcCs:ttjt|||d}|jtjkr|jtjd}|S)Nrr)rYrrruint8r)rrrrrr3r3r4rs rcCsbt|tj}t|ttfrt|dkr|}n |j||d d}|j tj ur/t |tj S|S)Nr)rrF)r&rYrr9listrSrJrrrrrrr')rrrrrrr3r3r4rs   r)rrc Cl|dur|dur |j}nt|jst|jrtj}n|j}|dks'|gkr)d}t|tj||||t j dSNr3rrrrrrs) rrarrrYint64rrrrSAMErrrrrrr3r3r4r" rcstjddttjfddtjr)tdkr)t Sj tt t t fddt tD}tj |ddd S) NFvalidatecsddjdS)Nzsum_to_size: size "z" is not expandable to size ""rvr3rrrKr3r4rG! szsum_to_size..rc3s2|]}|dkrj|dkr|VqdSrHNrvrwrr leading_dimsrKr3r4rE( szsum_to_size..T)rrr)raextract_shape_from_varargsrYrZis_expandable_torK is_same_shaperJrview_ofrrSrWr)rrrK reduce_dimsr3rr4r s     rc Crr) rrarrrYrrrrrrrr3r3r4r0 rrrc C0|dks|gkr d}t|tj||d|dtjdSNr3Frrrrrrprs)rrrrrrrrrrr3r3r4rN  rc Crr)rrrrrrr3r3r4rf rrcCs"|dur t|tr |}d}||fSr@)r9r)runbiasedr3r3r4_dim_var_dispatch~ sr correctionrrc CsVt||\}}t||}|dks|gkrd}t|ttj|d||dddtjd}|S)Nr3rTr) rraset_correctionrrrrrCOMPLEX_TO_FLOAT)rrrrrrrr3r3r4r s   rc Csht||\}}t||}t|tj\}}t||}tj||||d}t |}|dus/Jt||SN)rr) rrarrrrr&rYrrm) rrrrrr opmath_dtypera_vara_stdr3r3r4r s     rc s|dks|gkr d}durjttj||dtjd}tt p+t fddt |t r;|f}t j|}jdkrIdn ttjfdd|Dd}t||}durcjn}t||}|durt |tsuJt||j}t||d S|S) Nr3rcsddurdnddS)Nz&mean(): could not infer output dtype. Inputr z> dtype must be either a floating point or complex dtype. Got: r3r3)r orig_dtyper3r4rG s zmean..rrHc3rur@rvrwrqr3r4rE rgzmean..r})rrrrrKEEP_PROMOTED_TYPErYrZrarrr9rrrKrroperatorrrr&r"r'r() rrrrrrrrnelemrr3)rrrrr4r s<    *    rout0out1)rrrc Cs|t||\}}t||}t|tj\}}|j}t||}tj ||||d\}} t |} |dus4Jt| |t| |fSr) rrarrrrrr&rYrrm) rrrrrrrroriginal_dtypera_meanrr3r3r4r s    rcCs4t||\}}t|||||d}t|||}||fS)Nr)rrr)rrrrrrvmr3r3r4r s  r)rvec1vec2)betarrrrcstjdkfddtjdkfdddfdffD]#\}t|trEttjo>tjo>tjfddq"j dj dtjrtt t t fd dtt t t fd dsrt Std Strt Std Stt t tjfd dtt t tjfd ddkrˈt St S)NrHcdjdS)Nz*addr: Expected 1-D argument vec1, but got -Drr3)rr3r4rG$ rzaddr..cr)Nz*addr: Expected 1-D argument vec2, but got rrr3)rr3r4rG( rrrc ddS)NzBoolean z$ only supported for Boolean results.r3r3)arg_namer3r4rG0 rrcdtS)Nzexpected bool/int beta but got r/r3rr3r4rG7 rcr)Nz expected bool/int alpha but got r/r3rr3r4rG; rFcdtdjSNzcannot safely convert z to r0rr3)rrr3r4rGG rDcrrrr3)rrr3r4rGK rD)rYrZrr9rrarrrrKrr0intouterrrr)rrrrrargr3)rrrrrrr4r s^               rrrh.cGs^|s t|tjjr |}nt|tjjrJ|f|}tdd|D}t|dkr+|S|dS)z5Reference implementation of :func:`torch.atleast_1d`.css(|]}|jdkr |nt|dVqdS)rHrN)rrrCrrr3r3r4rE^ s&zatleast_1d..rHr)r9 collectionsabcrrSrJrrhargs_r1r3r3r4rU s  r at_least_fncCs ||}t|ts Jt||Sr@)r9r"r)rrrarg_r3r3r4_unsqueeze_atleastd s rcsn|s t|tjjr |}nt|tjjrJ|f|}tttdtfdd|D}t|dkr3|S|dS)z5Reference implementation of :func:`torch.atleast_2d`.rc3&|]}|jdkr |n|VqdS)rNrrunsqueeze_atleast_1dr3r4rEw $zatleast_2d..rH) r9rrrrrrrSrJrr3rr4rm   rcsn|s t|tjjr |}nt|tjjrJ|f|}tttdtfdd|D}t|dkr3|S|dS)z5Reference implementation of :func:`torch.atleast_3d`.rMc3r)Nrrunsqueeze_atleast_2dr3r4rE rzatleast_3d..rHr) r9rrrrrrrSrJrr3rr4r| rrrrrcCs$|dur|n|}t||||Sr@)rrr)rrrrrstorage_offset_intr3r3r4r srsrccCs"|durdn|}t|||||Sr)rr)rrrrrrr3r3r4r s rcGstt|Sr@)rYSizer])r\r3r3r4r rrcGs4t|dkrt|dts|d}tt|ddiS)NrHrr^F)rJr9rrritensorsr3r3r4r srcCs8t|t|j}tt|t|j|}t|||Sr@)rJrKrSrWrr)rrrstartrr3r3r4r srrrc sdd}t|dkrd}t||D] }t|tsJqtj|ddiddlm}dt|D]%\dur@j dkr?q0j dkrUt j j kfd d q0dur^|dj }g}t|D];\}t|t|j kr|j dks{Jt ||j ddkfd d qg|j dkr||j ddkrqg| |qg||}t|dkr|dz ttd d |D} Wn tyd} Ynwtdjj| |dSt|dj |}t|dj |t||j|dS)NcSsXd}|D]}t|}|tjkr|S|dur!||kr!tjS|}q|dus*J|Sr@)rasuggest_memory_formatrYr)inputsformatrfr3r3r4 cat_compute_output_memory_format s    z-cat..cat_compute_output_memory_formatrz3cat expects at least one tensor, but received zero!rPFr>rHcsdjdjddS)N6Number of dimensions of tensors must match. Expected z-D tensors, but got z-D for tensor number in the listrr3)examplerxrr3r4rG szcat..csdjddS)Nrz*-D tensors, but got 1-D for tensor number rrr3)r tensor_idxr3r4rG s cs|]}|jVqdSr@) requires_gradrBr3r3r4rE zcat..rrr2rrUrT)rJrXr9r"rarSrRr?rVrrYrZrKrrr Exceptionrrr2canonicalize_dim validate_idxrrr) rrrrtensorr?rKfilteredrUrr3)rrxrrr4r sh         rcCstdd|D}t|dS)Ncss0|]}|jdkr |n||dfVqdSr)rrrrBr3r3r4rE5 s  zcolumn_stack..rH)rSrraligned_tensorsr3r3r4r3 s rcCs*t|js|S|jrt|St|Sr@)rarr is_sparserYr5rrrr3r3r4r; s   rpadc sRttddkfdd|jttd}|t|kfdd|}tD]9dddkrV| |j}ddkrn|d|jd}q5tddDr}|St d}t|D]1tddd}t|dkfd d| |qt |}tj ||j|j|j|d }|dkr|jtjkrd }t||}|} tD]:dddkr| | j} ddkr | d| jd} qt| ||S) Nrrcr)Nz1Length of pad must be even but instead it equals rIr3)rr3r4rGK rz!constant_pad_nd..crB)Nz`Length of pad should be no more than twice the number of dimensions of the input. Pad length is z while the input has dimensions.rIr3)l_inprr3r4rGV s rHcss|]}|dkVqdS)rNr3)rCpr3r3r4rEm rLz"constant_pad_nd..c s6dddddd S)NzThe input size z, plus negative padding rrHzG resulted in a negative output size, which is invalid. Check dimension z of your input.r3r3)rx input_sizesl_diffrpad_idxr3r4rGw s rF)rYrZrJrKrWrrrrrrrarrrr2rrrBrr) rrrl_padc_input new_shapenew_dimrUr<c_outputr3)rxrrrrrr4rD sl    "         rcCs6t|tjkddtj||dr|Stj||dS)NcSr)Nz@preserve memory format is unsupported by the contiguous operatorr3r3r3r3r4rG rzcontiguous..rT)rYrZr]rar^r)rrrUr3r3r4r srcCs*tt|dkddt|}t|dS)NrcSr)Nz%dstack expects a non-empty TensorListr3r3r3r3r4rG rzdstack..r)rYrZrJrrrr3r3r4r  rc sddlm}t|dkrt|dtrt|d}tt|t|jkddt|t|j}t |}t |jD].\}||}||}t||kpW|dkpW|dkfdd|dkrd|n||<q:t |t ||tt|t|j|S)Nrr>rHcSr)Nz3expand: the requested shape has too few dimensions!r3r3r3r3r4rG rzexpand..rMcr)Nz3expand: attempting to expand a dimension of length r`r3r3rFr3r4rG r)rRr?rJr9rrSrYrZrKrrVravalidate_shaperrrW)rrrKr?r shape_rQ offset_idxrequested_lengthr3rFr4r s0      rcCs ||jSr@)rrKrr3r3r4r s rchunkscs|dkrd|d}t|tjj}t||t|}|}fddt|D}|dkrI| t ||t |S)Nrz%Expected at least one chunk, but got r`csg|] }t|qSr3)rrwrr chunk_sizerr3r4r{ szchunk..) rXrarrrKrr4rDrWrrrS)rrrrrlength full_chunkstail_chunk_sizerr3rr4r s  rrM start_dimend_dimcCsht|j|}t|j|}||kr|jdkr|St|||\}}|dur-t|||St|||Sr)rarrr_collapse_view_helper collapse_viewcollapse)rrrrr _new_stridesr3r3r4r srcCs@t|tst|tstdt|j|}t|t ||S)Nz!dims has to be a sequence of ints) r9rSrrXracanonicalize_dimsrvalidate_no_repeating_dimsrrevrzr3r3r4r s   rcC|jdkr tdt|dS)NrzInput must be >= 2-d.ryrrdrrqr3r3r4r   rcCr)NrHzInput must be >= 1-d.rrrqr3r3r4r r rrrcsttrtdkotjddt t t|dkddtdkddt |j |}| |tt koMkfdddkr]tkfddt|j}||<||||||S)NrcSr)Nz'start must be an 0-dim integral Tensor.r3r3r3r3r4rG# rznarrow..cSr)Nz-narrow() cannot be applied to a 0-dim tensor.r3r3r3r3r4rG' rcSr)Nz&narrow(): length must be non-negative.r3r3r3r3r4rG( rcsd dddS)Nz0start out of range (expected to be in range of [, z ], but got )r3r3) dim_lengthrr3r4rG. r csddddS)Nzstart (z ) + length (z) exceeds dimension size (z).r3r3r#rrr3r4rG4 r|)r9r"rYrZrrarrrr rrrr _check_with IndexErrorrrKrrr)rrrrrrr3r$r4r s6      r norm_dimsepsc Cslt|j|}t|j}t||}t|tsJtj ||ddd\}}t ||}|||}|||fS)aComputes mean and 1/std of a tensor along norm_dims. Used as a helper function for normalization layers. Args: a (Tensor): input tensor norm_dims (DimsType): dimensions to normalize over eps (float): epsilon for numerical stability Returns: out (Tensor): normalized tensor. mean (Tensor): mean of the tensor along norm_dims. rstd (Tensor): 1/std of the tensor along norm_dims. FT)rrr) rarrrrr&r9r"rYrr) rrr'r(ra_acc biased_varrrstdrr3r3r4 _normalize= s     r, dimensionscCst|D]}t||}q|Sr@)sortedrYr)rDr-rr3r3r4_unsqueeze_multiple[ s r/weightbias batch_size num_channelsflattened_inner_size num_groupscstjdkfddt|dkfddddg}t|||g} t| ||\} } } | j} dgttdj} d}|durQt || }d}|dur\t || }|durd| |} |durl| |} t | j } t | j } t | j } t | |} t | |} | | | fS)Nrcr)Nz=Expected at least 2 dimensions for input tensor but received rr3rr3r4rGn rz#native_group_norm..rcsddjdS)NzDExpected number of channels in input to be divisible by num_groups, zbut got input of shape z and num_groups = rvr3rr5r3r4rGr sr) rYrZrrr,rrKrrWr/r&rr)rr0r1r2r3r4r5r(rinput_reshapedrrr+runsqueeze_biasunsqueeze_weightr3r6r4ra s@             rout2normalized_shapec st}t|dkfddtdupjtkfddtdup0jtkfddtj|koLjj|dtkfdddur`durhj|}tt|j}t ||\}} } durdur|}ndurdur|}ndurdur|}t |j }j j dvrt | j } t | j } || | fS)NrHcs dtS)NzzExpected normalized_shape to be at least 1-dimensional, i.e., containing at least one element, but got normalized_shape = )rer3)r;r3r4rG sz#native_layer_norm..csdtjdtS)NzQExpected weight to be of same shape as normalized_shape, but got weight of shape  and normalized_shape = rerKr3)r;r0r3r4rG csdtjdtS)NzMExpected bias to be of same shape as normalized_shape, but got bias of shape r<r=r3)r1r;r3r4rG r>cs&dtdtdtjS)NzGiven normalized_shape=z, expected input with shape z, but got input of size r=r3)rr;r3r4rG s)rmtia)rJrYrZrKrSrrrrWr,r&rr2r0) rr;r0r1r(normalized_ndimaxisrrrr+r3)r1rr;r0r4r sJ                 rcOst|Sr@)r) fake_modefuncrhrr3r3r4native_layer_norm_fake srDcGs t|jt|}t||Sr@)rarrextract_dims_from_varargsrr)rrr _permutationr3r3r4r s  rrmaxnormc stt|t ddt|dkddttt ddtdkfdd|jtdkfddt|}tt}||=t |j }||j krctj j |||d |d }n tj j |||d d }d }t |k||d }||j krt||j }||S)NcSr)Nzrenorm: p must be real-valuedr3r3r3r3r4rG rzrenorm..rcSr)Nz'renorm: non-positive norm not supportedr3r3r3r3r4rG rcSr)Nz#renorm: maxnorm must be real-valuedr3r3r3r3r4rG rcr)Nz,renorm: expected maxnorm to be >= 0 but got r3r3)rGr3r4rG rrHcr)Nz/renorm: input needs at least 2 dimensions, got dimensionsr3r3rr3r4rG rT)rrrgHz>r)rYrZr9r2rrarrrWrrlinalg vector_normrrr'r) rrrrGracc_typer]r( norm_factorr3)rGrr4r+ s6        r+reflectn_fft hop_length win_lengthwindowcenterpad_mode normalizedonesidedreturn_complexalign_to_windowc s$tdup jjkfddt| p| dud|dur$|nd|dur.|n| durIpAduoAtj} t| dn| } ttjpXtjddtdjkoidknd dj} | dkr| d |rd j} d}gt d| j }t |||g|| ddtd koknfd dtd kfd dtd koڈknfddtdupj fkfddkrdur tjjjdd}t ||gjdd|s9| r9d}t ||g|durBtj}|durO|n| }|rWdnd}|rot| ddtjjd|d}n tjjd|d}|dd| dkr|d }| r|St|S)NcdjdjS)NzAstft input and window must be on the same device but got self on  and window on r1r3rrQr3r4rG$   zstft..z6stft only supports align_to_window for center = False.zstft requires the return_complex parameter be given for real inputs, and will further require that return_complex=True in a future PyTorch release.cSr)Nz:stft expected a tensor of floating point or complex valuesr3r3r3r3r4rGA rrHrcSr)Nzstft expected a 1D or 2D tensorr3r3r3r3r4rGC rrrcddS)Nzstft expected 0 < n_fft <= z, but got n_fft=r3r3)rrNr3r4rGS r!cr)Nz0stft expected hop_length > 0 but got hop_length=r3r3) hop_length_r3r4rGW rcr)Nz9stft expected 0 < win_length <= n_fft but got win_length=r3r3) win_length_r3r4rG[ rcsdddjS)Nz8expected a 1D window tensor of size equal to win_length=r!zbut got window with size rvr3)r_rQr3r4rG_ r[rrM) dimensionrsteporthocSr)Nz9Cannot have onesided output if window or input is complexr3r3r3r3r4rGx rrr])rYrZr2r*rarrrrr itertoolsrrKrrrrr rrfftrfft transpose_squeeze_ view_as_real)rrNrOrPrQrRrSrTrUrVrWreturn_complex_ original_ndim extra_dims pad_amountextended_shapeleftinput_pad_amount complex_fftr]rr3)r^rrrNr_rQr4r, s  &                 r,c stdup jjkfdd|dur|n|d} |dur#|n|} ttjfddd} d} || | d}tdkd dtd jko^d knfd d|durm|n| |k}|rt|d d| kd dn t|| kddtd| ko| knddtd| ko|knddtdupj | fkdddurt j}tj | |jd}n}| |kr|| d }t |||| |fd}j}jd krddd |rdnd}| rt| ddtjjd|dn*tdup*tj dd|s>jdd|d ddtjjd|dd |ksQJ|dd|g}t j||d|fd|| d}t j|d d| |f|d|fd|| d}||dksJ||dksJ|r|d nd}|dur||}n |r||d }n|}td||}|jd||d}|jd||d}||}|d kr|d}||krtdt |d||fd}|S)NcrXNzBistft input and window must be on the same device but got self on rYr1r3rZr3r4rG r[zistft..r\csdjdjSrrr1r3rZr3r4rG srMrHrcSr)Nz"istft input tensor cannot be emptyr3r3r3r3r4rG rrrcr)Nz8istft expected a tensor with 2 or 3 dimensions, but got rr3rr3r4rG rcSr)Nzistft expected the frequency dimension (3rd to the last) of the input tensor to match n_fft / 2 + 1 when onesided=True, but got {fft_size}r3r3r3r3r4rG rcSr)N)zistft expected the frequency dimension (3rd to the last) of the input tensor to match n_fft when onesided=False, but got {fft_size}r3r3r3r3r4rG rcSr)Nz+istft expected 0 < hop_length <= win_lengthr3r3r3r3r4rG rcSr)Nz&istft expected 0 < win_length <= n_fftr3r3r3r3r4rG rcSr)NzDInvalid window shape. window has to be 1D and length of `win_length`r3r3r3r3r4rG rrrbcSr)Nz9cannot have onesided output if window or input is complexr3r3r3r3r4rG rrccSr)Nz:Complex windows are incompatible with return_complex=Falser3r3r3r3r4rG r)rrr)rrrrazThe length of signal is shorter than the length parameter. Result is being padded with zeros in the tail. Please check your center and hop_length settings)rYrZr2rarrrrrrKcorresponding_real_dtyper rrrrreifftrirfftrunfold_backwardrrrUrwarningswarn)rrNrOrPrQrRrTrUrrVr^r_n_framesfft_sizeexpected_output_signal_len onesided_ real_dtypewindow_rorkr]y_tmpywindow_enveloprendr3rZr4r- s                   r-a_shapea_strider`rac st|}tj||dd|dkrdn||dkrdn|}tkfddtdkfddt|}t|}||||krd|d|<|9<||fS)NT) wrap_scalarrrHcsdddS)Nz%Maximum size for tensor at dimension z is z but size is r3r3)rmax_sizerr3r4rG&rDz*_get_unfold_shape_stride..cr)NzStep is z but must be > 0r3r3rar3r4rG+r)rJrarrYrZrr) rrr`rraa_ndim last_striderKstridesr3)rrrrar4_get_unfold_shape_strides(   rc Gs>tj|dd}tt|t|jkddt|dkr!t|St||j}dg|}|jD]}||q0t ddt ||D}d|vrXtj ||j |j |jt|d S|}t|}t|D]\}}t||||t|d\}}qctt|} | jtdd d t | \} } ||} t| } | | }||S) NFrcSr)Nzbrepeat: Number of dimensions of repeat dims can not be smaller than number of dimensions of tensorr3r3r3r3r4rG>rzrepeat..rrHcss|] \}}||VqdSr@r3)rC padded_size repeat_sizer3r3r4rEIs  zrepeat..rT)keyreverse)rarrYrZrJrKrrrrSziprrr2rrmake_contiguous_strides_forrVrrUrsortr itemgetterrrr)rr repeat_shapenum_new_dimensions padded_shapedim_size target_shapeurtensor_shapeurtensor_striderenumerated_stride permute_order_sorted_striderepeat_xtensor cloned_resultpermuted_resultr3r3r4r8sF            r allow_copycsddlm}m}tj|dd}t||}||dkr(t||t|S|j dkrJ|}|D] }|dks9Jt |d}q1||urHt |S|St |dkrn|}|jD] }|dks]Jt|d}qU||urlt |S|S|rt |dkr|j dkrt||gdgSt |dkr|j dkr|d}|d}t|||g|dgSd||D]}j kr|dksJj d} t | j| dq||jkrۈdqj} } || |dkr| d} | j| } || |dks| kr4t | \} } | dur.|rt ||Sd|jd |d |d }t|t| || |krBt |dqj krhtjdkfd d tj ksM|urrt |SS)Nr)r?sym_eqFrrHrMrz Cannot view a tensor with shape z and strides z as a tensor with shape r`csddjS)Nza.size(z) expected to be 1 but got rvr3rrQr3r4rGrDz&_reshape_view_helper..)rRr?rrar infer_sizerrrrrrrrJrKr is_contiguousrY split_dimrrrrXrrZ)rrrrKr?r_ardim0dim1last_dimaccumrrrrr3rr4_reshape_view_helperrs                       rrKcGt|g|RddiS)NrTrrr3r3r4rrcC||Sr@)rrrrgr3r3r4rrrr3shiftsc Cszt|j|}t|ts|f}t|ts|f}|dkr!|S|dkr7t|dkr7t d|ddt|}t|}|dksG|dkr|dkrOt d|dkre|dkret t ||d|jS||krst d|d||dksyJ|dd}|dd}t ||df|d}t |||S|d}|j|} | |d| } t j| |jd } ||t | | | S) z/Reference implementation of :func:`torch.roll`.rzDimension specified as z but tensor has no dimensionsrHz`shifts` requiredz*shifts and dimensions must align. shifts: z, dims: Nr1)rarrr9rrrrrJr&rdrYrrrrKrr2rJr) rrrr len_shiftslen_dims tail_shifts tail_dimsfirst_dim_rolledrrrrQr3r3r4rs@       rrrHkcCst|dkrtdt||jdkrtd|jt|j|}|d|dkr9td|dd|d|d}|dkrStt||df|d|dS|dkr]t||S|d krstt||df|d|dS|jtj d S) z0Reference implementation of :func:`torch.rot90`.rz2expected total rotation dims == 2, but got dims = z/expected total dims >= 2, but got total dims = rrHz7expected rotation dims to be different, but got dim0 = z and dim1 = r\rrT) rJrdrrarrYrrrr)rrrrr3r3r4r.s&   $ $rcCsP|dj}tdt|D]}||j|ks%Jd|d||jd|q dS)NrrHz4stack expects each tensor to be equal size, but got z at entry 0 and z at entry )rKrWrJ)r entry_shaperxr3r3r4_check_stack_inputsNs rcst|dks Jdt|djd||djkr:t|t|dj}|t|t |}| |St fdd|D|S)Nrz$stack expects a non-empty TensorListrHcsg|]}|qSr3)rr_ wrapped_dimr3r4r{erDzstack..) rJrarrrrrKinsertrYrr)rr result_sizesrr3rr4rWs  rcCsh|p|j}t|}t||}|dkrt|}n t||dd}t||}tt|t||dd|S)NrTr) rrarr&rr>rrr)rrrrrrra_expa_maxr3r3r4rlis      rlcCsBtt|dkddt|}|djdkrt|dSt|dS)NrcSr)Nz%hstack expects a non-empty TensorListr3r3r3r3r4rGrzhstack..rH)rYrZrJrrrrr3r3r4r}s   rcCs*tt|dkddt|}t|dS)NrcSr)Nz%vstack expects a non-empty TensorListr3r3r3r3r4rGrzvstack..)rYrZrJrrrr3r3r4rr rrcCs\t|j|}tt|dkdd|t|jd|t|t|j|ddS)NrcSr)Nz"unflatten: sizes must be non-emptyr3r3r3r3r4rGrzunflatten..rH) rarrrYrZrJrrSrK)rrrrr3r3r4r s6r rcspddlm}t|jtt|jdkdd||jdkr%dSt fddt ||jDS)Nrr>cSr)Nz5Dimension specified as 0 but tensor has no dimensionsr3r3r3r3r4rGrzunbind..r3c3s|] }t|VqdSr@)rYr)rCsrr3r4rEs  zunbind..) rRr?rarrrY _check_indexrJrKrSr)rrr?r3rr4r s   r rjrcCs|jtjd|||SrV)rrYrrI)rDrrjrr3r3r4rHsrHcs`t|j|}tjdkfdd|jdkr|dn|}tdf|f}|||<|S)NrHcrNz(Index should have dimension 1 or 0 (got r"rr3rjr3r4rGrzindex_copy_..r)rarrrYrZrslice)rDrrjrrrQr3rr4rIs rIcCt||||ddS)NFinplace _index_fillrDrrjrr3r3r4rKsrKcCr)NTrrrr3r3r4rLsrLrc stjdkfddttr tjdkfddn tj|j|j|jd|jdk}|r8| dn|}t |j } ||< ||rOtjntj}|||} |r]|S|rf| d} | |krzt|} | | | } | S)NrHcrrrr3rr3r4rGrz_index_fill..rcr)Nz         rcCs|jtjdj||||dS)NrTr)rrYr index_add_)rDrrjrrr3r3r4rGs  rGcs|t|j|}tjdkfddjdkrd|jdkr0t|d|St df|f}||S)NrHcrrrr3rr3r4rGrzindex_select..r) rarrrYrZrrrHrr)rDrrjrQr3rr4rJ s    rJcsddlm|dur#tddtjD}|rt|StSj}t ||}t |t r4|fn|}|dkrKt |dksF|dksFJtStfdd|D}t |dkrbtSt |dkrnt|St|}t|dd }|D]}t|qzS) Nrr>css |] \}}|dkr|VqdSrr3)rCrQrr3r3r4rE$szsqueeze..rc3s&|]}j|dkr|VqdSrrv)rCdrrr?r3r4rE0rrHT)r)rRr?rSrVrKrrrrrarr9rrJrr.)rrrrr dims_listrxr3rr4rs(         r split_sizescsttD] }t|ddqtttjkfddg} }D]!}t j}||<|  | || |}q0|S)NcSr)NzCsplit_with_sizes expects split_sizes have only non-negative entriesr3r3r3r3r4rGErz"split_with_sizes..csdtdjS)NzSplit sizes add up to z but got the tensor's size of )rrrKr3rrrr3r4rGJs)rWrJrY_check_is_sizer%rXrrrKrrrrr)rrrrxsplitsr  split_sizerr3rr4r<s$ rindices_or_sectionsc st|j|}|jdkrd}t|t|tr7|jjdks'd|j}t||jt j kr7d|j}t|t|t sFt|tr|jdkrt|t rM|n| }|dkr^d|}t||j|}t||}||}g} t|D]} | |kr~|dn|} | | qtttj|| |dS|t|tr|jdkrd |jd }t||dgt|j|gfd d ttdD} ttj|| |dS) NrzXtensor_split: received a rank zero tensor, but expected a tensor of rank one or greater!rz\tensor_split: if indices_or_sections is a tensor it must be on the CPU, but received one on zgtensor_split: if indices_or_sections is a tensor it must have long dtype, but received one with dtype zAtensor_split: number of sections must be greater than 0, but was rHrzntensor_split: non-scalar indices_or_sections tensors must have only one dimension, but received a tensor with rHcs g|] }|d|qSryr3rwindicesr3r4r{ z tensor_split..)rarrrXr9r"r2r0rrYlongrrrrKrrDrWrrSrrtolistrrJ) rrrr_dimrsectionsrmin_split_sizenum_splits_one_extrar split_idxrr3rr4r\sf            rcstjdkfddjdkrdndttr:tdko+jdkfddtStttt ffdd}t|S)NrHcdtjdS)NzPtorch.hsplit requires a tensor with at least 1 dimension, but got a tensor with dimensions!rerr3rqr3r4rG zhsplit..rcs.dtdtjdtdS)Nz0torch.hsplit attempted to split along dimension z , but the size of the dimension $ is not divisible by the split_size r`r=r3)rrrrr3r4rGs cr)Nzhsplit(): received an invalid combination of arguments. Expected indices_or_sections to be of type int, list of ints or tuple of ints but got type r/r3rr3r4rG rYrZrr9rrKr _check_typerrSrrrrr3)rrrrrr4rs$      rcstjdkfddttr0tdko"jddkfddtdStttt ffdd}t|dS)Nrcr)NzPtorch.vsplit requires a tensor with at least 2 dimension, but got a tensor with rrr3rqr3r4rGrzvsplit..rcsdjdddS)NzQtorch.vsplit attempted to split along dimension 0, but the size of the dimension rrr`rvr3)rrrr3r4rGs cr)Nzvsplit(): received an invalid combination of arguments. Expected indices_or_sections to be of type int, list of ints or tuple of ints but got type r/r3rr3r4rGrrrr3)rrrrr4rs"       rr cs@|tdvfdddkrt||St||S)N)rHrcr)Nz'diag(): Supports 1D or 2D tensors. Got Dr3r3rr3r4rGrzdiag..rH)rrYrZrr)rr r3rr4rs  rrdim2csDt|}||||tjjkfddt|S)NcdjdjS)NzCexpected src to have a size equal to the diagonal of the input.Got z for a diagonal of shape rvr3rrr3r4rG z"diagonal_scatter..)raclone_preserve_stridesrrYrZrKr)rrr rrrr3rr4rs    rc sF|}tj|dtj|dtkfdd|}|dkr:tt|||d}ntt|||d}|dkri|dkr_||| 7}n ||| 8}fddt |D}| |fddt | D}| | | |j |||d} | S) z4 Reference implementation of torch.diagonal )rQrankcr]Nz(diagonal dimensions cannot be identical r!r3r3rrr3r4rG(r!zdiagonal..rc g|] \}}|fvr|qSr3r3rCrxrrr3r4r{8rzdiagonal..crr3r3rrr3r4r{;r)rrr) rrarrYrZrrUrrrrVrr) rr rrnum_dimsr diag_sizerrrr3rr4rs( &$ rrsc sT|jd}tj|dtj|dkr| }tkfdd|d|dkrft|j}t ||d<tj ||j |j dd}|dkrT||fn||f}tj |dd }t |7|d}tj|j tjd }tj|||j tjd } || dk} fd d tt|jD} | | } t| |S) z6 Reference implementation of torch.diag_embed rH)rrQcr]rr3r3rr3r4rGZr!zdiag_embed..rMrFrr2rrr2rcs g|] }|fvr ndqSryr3rwrrrr3r4r{urzdiag_embed..)rrarrYrZrrrKrr,r%rr2rrrrrrWrJr mask_tensorr) rr rrrt_shapezpaira_rangeb_rangecond cond_shaper3rr4rCs4      rc sdd|D}tdd|D}|djg}d}t|D]R\tdkfddtjkfd dj\}}tj||fj d }tj||||fj d }|tj ||fd d g7}||7}qtj |dd S) z6 Reference implementation of torch.block_diag cSs(g|]}|dkr|ddn|qS)rHrM)rrrCrr3r3r4r{sz(_block_diag_iterable..css|]}|jdVqdSrrvrr3r3r4rErgz'_block_diag_iterable..rrcsdddS)Nz5Input tensors must have 2 or fewer dimensions. Input z has rHrr3)rxrr3r4rGs z&_block_diag_iterable..csdddjdS)NzCInput tensors must all be on the same device. Input 0 is on device z and input z is on device rr1r3r2rxrr3r4rGsrrHr) rrr2rVrYrZrrKr%rr) r tensors_2dncolsr col_startrowcolrorightr3r r4_block_diag_iterable}s0     rcGst|S)z This is used as an input to PythonRefInfo. `torch.block_diag` expects arguments splatted, but `aten.block_diag` expects only one argument that is a list of Tensors. )rrr3r3r4rsrrcCsl|jdkrtd|jdt|tr0|dks |jd|dkr0tdd|jdd|d t||dS) NrzPtorch.dsplit requires a tensor with at least 3 dimension, but got a tensor with rrrz3torch.dsplit attempted to split along dimension 2, zbut the size of the dimension rr`)rrdr9rrKr)rrrr3r3r4rs  $ rcCs:|jdkrtd|jdt|d|jdkrdSdS)Nrz7t() expects a tensor with <= 2 dimensions, but self is rrrH)rrdrYrrqr3r3r4rs  cCst|jdvdd|S)N)rrcSr)NzcThe use of `x.T` on tensors of dimension other than 0 or 2 to reverse their shape is not supported.r3r3r3r3r4rGrzT..)rYrZrrrqr3r3r4rs rcCrr@)rrrqr3r3r4rrrrcCs`t|j||f\}}|jdks||krtj|Sttd|j}|||<|||<t ||S)NrHr) rarrrrdefaultrrWrYr)rrrr_dim0_dim1rFr3r3r4rs  rcCs&t|j||||\}}|||Sr@)rrKrr)rr`rrarKrr3r3r4rs rcCs||||jtjdSrV)rrrYr)rr`rrar3r3r4rsrc Cs|j}t||}|dkr||dd||dS||d}tj|j||jd}|d|k}t||dD]} |d}q9t |||} || |||dS)Nr)rrrrHr1rM) rrarrrYrrKr2rWr) rCinitrrrrrrrgrrmasked_ar3r3r4_cumsumprod_commons  rcCttd||||dS)NrrCrrrrrr)rrrrrrrr3r3r4rrcCr)NrHr)rrrr3r3r4r$rrcCs(|jd}t||}tj||f|dS)NrHr)rrarr expand_dims)rrrrr3r3r4r0s  rcGr)NrFrrr3r3r4r=srcCrr@)rrrr3r3r4rCrrcCs t|dS)N)rM)rrqr3r3r4rHs rrcstjjkfddttjfdd|dur.tdddStj } |||<t | }t |}tj } |||<t | }t |}t|||S)NcsdjdjdS)Nz]torch.take_along_dim(): input and indices should have the same number of dimensions, but got z dimensions for input, and z dimensions for indicesrr3rrrr3r4rGTs z take_along_dim..cr)Nz?torch.take_along_dim(): dtype of indices should be int but got z insteadrr3rr3r4rG]srMr) rYrZrrarrgatherrrrKrinfer_size_shapesr)rrrr self_sizesbroadcast_shapeindices_broadcast indices_sizesself_broadcastr3rr4rNs&        rrrZr2rr[rUrc sttjkddt|}tjkrt|}ntjkr&t|}nttj kfddt |}tj |||||||dS)NcSr)Nz8torch.empty: the Preserve memory format is not supportedr3r3r3r3r4rGrzempty..cr)Nz/torch.empty: received an unknown memory format r`r3r3rTr3r4rGrrrZr2r[r) rYrZr]rarrrchannels_last_3d!make_channels_last_3d_strides_for channels_last!make_channels_last_2d_strides_forr)rrZr2rr[rUrKrr3rTr4rss.        rcCstj|||||dS)Nr)rr)rKphysical_layoutrrZr2rr[r3r3r4rs rrrZr2r[cCsJ|dur|jn|}|dur|jn|}|dur|jn|}tj|||||dS)Nrr2r[rZ)rrZr2rYr)rrrrrZr2r[r3r3r4rs rcCsL|dur|jn|}|dur|jn|}|dur|jn|}tj||||||dS)zD Reference implementation of torch.Tensor.new_empty_strided Nr-)rrZr2rYr)rrrrrrZr2r[r3r3r4rsrr&c G@t|}|dur t}tj||tjkrdnd|||||dSNFrr&rarrYr(rrrrZr2r[rrr3r3r4r% r%c Cb|dur|jn|}|dur|jn|}|dur|jn|}tj||p"|jtjkr(dnd|||||dSr/rrZr2rYrrrrrrrZr2r[rr3r3r4r rc Gr.NTrHr&r0r1r3r3r4r r2r c Cr3r7r4r5r3r3r4r2r6r fill_valuecCsL|dur|jn|}|dur|jn|}|dur|jn|}tj||||||dS)Nr,)rrZr2rYr)rrrr8rrZr2r[r3r3r4rMs r)rr2rZr[rrUc Cs~|dur|jn|}|dur|jn|}|dur|jn|}|tjkr-tj|j||||||dSt|}tj |j||||||dS)Nr%r&) rrZr2rYr]rrKra3compute_elementwise_output_logical_to_physical_permr)rrrr2rZr[rrUlogical_to_physical_permr3r3r4rgs0   rrcst|t|tt|}ttrJttr Jttr'Jdur/dtdkdddkrHtkddndkrVtkdddd}t|oc|fddt|fd df} t d d | D} |dur| rtj nt }t |} | s| rt} t} t}|tj ks| rt|dkt|dk}| | |||}n t}| rtj|| ||||d Stj|dd tj |dd }| rtjnt||}t||}|}t||}|r |d|S)NrcSr)Nzstep must be nonzeror3r3r3r3r4rGrzarange..cSrNz7upper bound and lower bound inconsistent with step signr3r3r3r3r4rGrcSrr;r3r3r3r3r4rGrcSst|t p t|Sr@)r9rrrMrFr3r3r4 is_finiterzarange..is_finitecsddS)Nzunsupported range: z -> r3r3)rrr3r4rGr!cr)Nzstep must be finite but got r3r3rr3r4rGrcs|]}t|tVqdSr@rArCrr3r3r4rErgzarange..)rrarr2rrHFT)ra check_layoutcheck_pin_memoryrYr2device_or_defaultr9r2rZrrrr(rrrrr4riotar get_acc_typer&requires_grad_)rrrarrZr2r[rr<rh integer_args is_integerxstartxendxsteprfrrjrrr3)rrrar4rs           r)rrr0c Cs||g}t|tr|d|}n||t|tsJ|dk}t||d|}t|||}||||}tj t |}| |krMt ||}t||S)Nr3rrH)r9rrrrr,rYrra"compute_elementwise_output_stridesrirr copy_stridedr=) rrr0rrcoeffbaser<rr3r3r4rTs      rT)rr2rZr[rstepsc s.ttrtdkddttjttr.tdkddttjtddfDrXt t durIntt fddnp]t ttj sfJtttfddtts|Jtdkd d||||d }dkrtjdd i|Sd krttrtjffd i|} tjjj| Stjffd i|Stjdfi|} t st rtjn} t | tj| \} } tt| d}d }t| dk||| ||d | }t|S)NrcSrNz:linspace only supports 0-dimensional start and end tensorsr3r3r3r3r4rG&rzlinspace..cSrrOr3r3r3r3r4rG,rcsr=r@r9r2r>r3r3r4rE0rgzlinspace..cr])Nzlinspace(): inferred dtype z& can't be safely cast to passed dtype r3r3)default_complex_dtyperr3r4rG9r!cs*dtjdtjdtjdS)Nz4received an invalid combination of arguments - got (r!r")r0ryr3)rrrNr3r4rGBscSr)Nz$number of steps must be non-negativer3r3r3r3r4rGFr)rZr2r[rrrrHrr)rr)r9r#rYrZrr&rrrrarr(rrrrrropsrrYrrrrrrrrrr)rrrNrr2rZr[rfactory_kwargs empty_tensorr dtype_redrrcast_rgrarr3)rQrrrrNr4rsx            rrrMc Cs|durt}tj|rNt|trt|}nt|tr.t | dkddt ||}t|tr8t|}nt|trNt | dkddt ||}t dd|||fDrgtt} | }d} ntj} t|trqJ|dkrwttj|||| ||||d} t t|| |S)NrcSrNz:logspace only supports 0-dimensional start and end tensorsr3r3r3r3r4rGrzlogspace..cSrrWr3r3r3r3r4rGrcsr=r@rPr>r3r3r4rErgzlogspace..r&)rYr(rrarr9rrr#rZrr&rrrrr2rRrr) rrrNrMrr2rZr[rrQ_dtyperetr3r3r4rpsP            rindexingcCdSr@r3)rrZr3r3r4rrarcGr[r@r3)rZrr3r3r4rracst|dttfrt|dksJt|d}ttdd|Dddtt|dkddtt|dD]&}t||j ||dj kddt||j ||dj kd dq;d }d krt|d k}|r|d|dg|d dR}n td kfddg}|D]"tt sJtj dkpj dkfdd| qg}t|D] \}tt sJj dkrΈd| t||fq|r|d|d|d<|d<|S)NrrHcsr=r@r9r"rr3r3r4rErgzmeshgrid..cSr)Nz)meshgrid expects its inputs to be tensorsr3r3r3r3r4rGrzmeshgrid..cSr)Nz'meshgrid expects a non-empty TensorListr3r3r3r3r4rGrcSr)Nz3meshgrid expects all tensors to have the same dtyper3r3r3r3r4rGrcSr)Nz4meshgrid expects all tensors to have the same devicer3r3r3r3r4rGrFxyrijcr)NzDtorch.meshgrid: indexing must be one of "xy" or "ij", but received: r3r3)rZr3r4rGscr)NzEtorch.meshgrid: Expected 0D or 1D tensor in the tensor list but got: r3r3)rr3r4rGrry)r9rrSrJrYrZrrrWrr2r"rrrrVrrr)rZrrxswap_first_and_second_tensors result_shapegridsr3)rZrr4rsX      source destinationcs@ttur ftturftttkfdd|j}ttj|d}ttj|d}t |}t |}tt|t|kfddtt|t|kfddt t ||}g} d} t |D]&} | | } | dur| | qo| |vr| d7} | |vs| | | d7} qot|t| } | S) z3 Reference implementation of torch.movedim csdtdtdS)Nz5movedim: Invalid source or destination dims: source (z> dims) should contain the same number of dims as destination (z dims)rr3rcrbr3r4rG s zmovedim..)rrcdtdS)Nz#movedim: repeated dim in `source` (r"rdr3)rbr3r4rGr!crf)Nz(movedim: repeated dim in `destination` (r"rdr3)rcr3r4rG r!rNrH)r0rrYrZrJrrSrarsetdictrrWrorr)rrbrcrssdssssdssrrsidirrr3rer4rsF           r)rr2rZrr[rcCs\t|t|t|}|durtn|}|dur"tdn|}tj|||||dS)Nrr) rar?r@rrYr(r2rr)rKrrr2rZrr[r3r3r4r9s  rnrc sdurtdkfddtdkfddtjtj|dd}tjtj|dd}|d|k} |tjur@| Stjd ||||dd } t| | dS) z/ Reference implementation of torch.eye Nrcr)Nz%n must be greater or equal to 0, got r3r3)ror3r4rGhrzeye..cr)Nz%m must be greater or equal to 0, got r3r3)rr3r4rGirFrrMryr&)rYrZrrrrr r) rorrrZr2r[rrange_nrange_mroner3)rror4rVs$ rcCsdt|t||dur|ntt|}|dur|ntd}t||||||d}t||S)Nrr&) rar?r@ type_to_dtyper0rYr2rrB)rKr8rrZr2r[rer3r3r4rs  rrrZr2r[rrUc Cs"tj|||||||d}t||S)Nru)rYrrB) rrr8rrZr2r[rrUrtr3r3r4rs  rc C.tj||p|jtjkr dnd||||||dS)NFrrurYrrrrrrrZr2r[rrUr3r3r4r& r&c Crv)NTrHrurwrxr3r3r4r!ryr!cGs>t|t|}t|}t|}tj|dd|||dS)Nrr)rrrr2r)rar@rdtype_or_defaultrArr^)rr2rZrr[rKr r3r3r4r"s   r"cCsTt|t||dur|ntt|}|dur|ntd}tj|||dS)Nrr) rar?r@rsr0rYr2rr#)rrrrZr2r[r3r3r4r#s  r#rlowhighcCsdt|t|ts Jt|tsJt|}t|}t|tjs#Jt|}tj |||||dS)N)r{r|rr2) rar r9rrrYrcanonicalize_devicer_uniform_helper)rKr{r|rr2r3r3r4r~s  r~rcst|jt|trt|}n6|jtdkfdd|j jddtj dfvo1|j jdk}t|p;|j |j kddt|j}|t urXtt |fd dt||j}t|||}|S) Nrcr)Nz@only supports a 0-dimensional value tensor, but got tensor with z dimensionr3r3) value_ndimr3r4rG4rzmasked_fill..cudaxpur.rcSr)Nz,Expected `value` to be on same device as `a`r3r3r3r3r4rG>rcr)Nzcould not convert to type z without overflowr3r3)rr3r4rGIr)rarrr9rr0rrYrZr2_C_get_privateuse1_backend_namer2rr&rr)rrrr value_type is_cpu_scalarrr3)rrr4r(s4         rcCst|||}|||Sr@)rYrr)rrrrrr3r3r4rVs rc Cs4td||||dtttj|||||dS)z4 Reference implementation of torch.allclose ztorch.allcloser")rrr&)r#rrYrrr)rrrrrr&r3r3r4r'`s r'cCsttj||ddt|||j|jkrdSt|j|jD] \}}||kr(dSq|dkr1dSttt ||S)NFrOrT) rarScheck_same_dtyperrrKrrrr~)rrrrDrr3r3r4r(qs   r(frorcCs|dkr|dust|tst|dks|durd}t|tr!|g}t|tr<|dur1tt|j}tjj |||||dStjj |||||dS)Nrrr) r9rrJrerSrWrrYrI matrix_normrJ)rrrrrr3r3r4r]s&   r]cCs(t|jdkddtt|dS)NrcSr)Nz6expected a matrix, but got tensor with dim {self.ndim}r3r3r3r3r4rGrztrace..r)rYrZrrrrr3r3r4rqsrqcs.dtttfdtttfdtffdd }|S)Nrrrrncs ||Sr@r3rbase_opr3r4roprz_make_r_binary_op..rop)rr#r)rrr3rr4_make_r_binary_ops  rcCsht|jdkdd|jdd\}}tj||jddtj||jdd|k}t|| S)NrcSr)Nz2triu: input tensor must have at least 2 dimensionsr3r3r3r3r4rGrztriu..rsr1rM rYrZrrKrr2rrarrrrrhwrr3r3r4r r cCsht|jdkdd|jdd\}}tj||jddtj||jdd|k}t|| S)NrcSr)Nz2tril: input tensor must have at least 2 dimensionsr3r3r3r3r4rGrztril..rsr1rMrrr3r3r4r rr r rc Cs|dks|dkr dS|dkrt|d|nt||dk}tdt|||}tdt|||}||d}|||d}||}td||} || |fS)NrrrrrHr)rrrU) r rr  m_first_row m_last_row n_row_alln_row_trapezoidtrapezoid_sizediff_rowrectangle_sizer3r3r4_get_tril_sizess&  rcsVtdkfddtdkfddttjtjfvfdddS)Nrcr)Nzrow must be non-negative, got r3r3)r r3r4rGrz_trilu_checks..cr)Nzcol must be non-negative, got r3r3)rr3r4rGrcsdddS)Nrz" not implemented for ''r3r3)rrr3r4rGs)rYrZr.r)rr rrrZr[r3)rrrr r4 _trilu_checkss  rrcCstd|||||t|||\}}} td| } ttj|||d} | d|tjd} | d} t| t| | d| }t| d| d||d}t || |}t ||}| d||d}|||| d| }||}t t ||ft ||ffS)NrrrZr2r[rrrrH) rrrUrrYrrrDrmr&rr)r rr rrZr2r[rrr row_offset arange_kwxs1r row_inds1 col_inds1xs2 row_inds2 col_inds2r3r3r4rs$   "" rc Cs||dks|dkr dS|dkrtd||n|}tdt|| |}t|||d\}}}||||}||} | ||fS)NrrrH)rUrr) r rr rrtrapezoid_size_trilrectangle_size_trilr triu_sizerr3r3r4_get_triu_sizes,s rcCstd|||||t|||\}}} td|} ttj|||d} | d||d} | |} | |}| d|tjd}d| }t| t||d|}t|d| d||d}t ||}t ||}|ro|||}|| }t t | |ft ||ffS) NrrrrgrrHr) rrrUrrYrrrDrmr&rr)r rr rrZr2r[rrr col_offsetrrrrrrrrr3r3r4r=s*   ""   r) out_int32r boundariesrrcsjtdkfddt|tjr|nt|}|r tjntj}jd}|dkr1t |Stj |j|j tjd}||}|||d}|} |rS| |k} n| |k} t | ||d}|dkrtj |tjd} tt|} t| D]7} t | | @||}||k} t | |||dd}|} |r| |k} n| |k} t | | @|d|}qw|j|dS) NrHcsddS)Nz2boundaries tensor must be 1 dimension but got dim(r"rr3rr3r4rGsr!zbucketize..rMrrrr)rYrZrr9rrr.rrKr&r%r2rr!rrrrXrWr)rrrrr out_dtype n_boundariesrrmidmid_valcond_mid cond_updatenitersrr3rr4r)hs<        r)cs|dusJttj otj otj fddtdkfdd|ttj t dS)Ncr)NzwCauchy distribution is a continuous probability distribution. dtype must be a floating point but you specified rr3rr3r4rGzcauchy..rcr)Nz-cauchy_ expects sigma > 0.0, but found sigma=r3r3)sigmar3r4rGrr) rYrZrarrrrrorr rand_like)rmedianr generatorr3)rrr4rs     "rcs|dusJttj otj otj fddtdkfddt}t|jj d}|d|k}t || t |}d|S)Ncr)Nz|Exponential distribution is a continuous probability distribution. dtype must be a floating point but you specified rr3rr3r4rGrzexponential..rcr)Nz4exponential_ expects lambda > 0.0, but found lambda=r3r3)rater3r4rGrrrrM) rYrZrarrrrrrr(rrV)rrr uniform_valepsilonrI log_uniformr3)rrr4r@s"        r@cs|dusJttj otj fddtdko%dkfddttt t  dS)Ncr)Nzgeometric not implemented for rr3rr3r4rGrzgeometric..rrHcr)Nz0geometric_ expects p to be in (0, 1), but got p=r3r3)rr3r4rGr) rYrZrarrrrDrWrr)rrrr3)rrr4rFs    (rFrcsv|dusJttj otj otj fddtdkfddtt|S)Ncr)Nzlog_normal not implemented for rr3rr3r4rGrzlog_normal..rcr)Nz-log_normal_ expects std > 0.0, but found std=r3r3rr3r4rGr) rYrZrarrrrr> randn_likerrrrr3)rrr4rZs     rZ)rr)rrrZr2r[c s$|dus |tjks Jttstdkfdd|durYtdd|fD}tt|dkddt|duo@|duddtdd|D}|dj}|dj }n'tt|t oftt d d|durst n|}|dur~t d n|}t j |d d ||d |d} | |S)Nrcr)Nz)normal expects std >= 0.0, but found std r3r3rr3r4rGrznormal..css|] }t|tr|VqdSr@r\r_r3r3r4rE#sznormal..cSr)NzFnormal expects that either mean or std is a tensor, or size is definedr3r3r3r3r4rG&rcSr)Nz.Cannot pass layout, or pin_memory without sizer3r3r3r3r4rG*rcsrr@rvr_r3r3r4rE-rcSr)Nz>normal expects mean and std to be scalars when size is definedr3r3r3r3r4rG3rrrrF)rrrr2rr) rYstridedr9r"rZrSrJr]rr2r(rr^) rrrrrrZr2r[rnormal_samplesr3rr4r^sD     r^)rcCst|||j||dS)N)rr)r^rKrr3r3r4normal_DsrcC&tt|j ddd}||S)NcSr)Nz-rad2deg is not supported for complex tensors.r3r3r3r3r4rGMrzrad2deg..gcܥL@rYrZrarr)rM_180_PIr3r3r4rbI  rbcCr)NcSr)Nz-deg2rad is not supported for complex tensors.r3r3r3r3r4rGWrzdeg2rad..g9RFߑ?r)rM_PI_180r3r3r4r9Srr9cCs|dk|Sr)r)rrr3r3r4r8]sr8csrtdko dkfddtjjkfddfdd}tk|dS)NrHcsdddS)Nz1D tensors expected, but got zD and z D tensorsrr3rgrr3r4rGfr z_dot_check..cr)Nz:dot : expected both vectors to have same dtype, but found rrr3rr3r4rGkrc s.ddddd S)Nz+inconsistent tensor size, expected tensor [z ] and src [z.] to have thesame number of elements, but got rz elements respectively)rr3rr3r4 numel_erroros z_dot_check..numel_error)rYrZrrr)rrgrr3rr4 _dot_checkcs   rcstfdd}|S)Ncst||||Sr@)rrrr3r4wrapperys  z#_dot_check_wrapper..wrapper)r)rrr3rr4_dot_check_wrapperxsrrcCsd|r,|r |rt||St||S|r,t||S||Sr@)r*is_conjrYrrrrrr3r3r4rs rcCst|s t||S|r$|rt||St||S|r2t||S||Sr@)r*rYrrrrr5rrr3r3r4rs rcCszt|j|}dg|j}d||<|dkr||j|}tj|j||jd||k}t|| |j}t |||S)NrHrMrr1) rarrrKrYrr2rrrr)rDrrrj mask_shaperr3r3r4select_scatters  rcCst|tjtjfSr@)r9rY TypedStorageUntypedStorage)objr3r3r4 _isStorage+r6rcCsd}t|}g}t|ttfrYt|}|r||j}||t||kr0tdt|j d|dkr7 |Sz|d}Wnt yOtdt|j dw|}t|ttfs|S)Nztoo many dimensions 'rrz.could not determine the shape of object type ') rr9rrSrJitemsizerrXr0ryr)seq scalar_typeMAX_DIMS is_storagerrhandler3r3r4_compute_sizes0s.      rcCsFt|tr tSt|trt|tstjSt|trtjSt|trCt}|tj ur/tj S|tj ur7tj S|tj ur?tjStdt|tjrL|jSt|tr\tdt|jdt|ttfrd}t|}|dkrqtSt|D]!}||} t|}|durt||}n|}|tj ur|Squ|Stdt|j)Nz'invalid default scalar type for complexznew(): invalid data type 'rrzCould not infer dtype of )r9rrYr(rrrrr2rcfloatdoublecdoublehalfchalfrdrrre TypeErrorr0ryrrSrJrW_infer_scalar_type promote_types)r default_dtype scalarTyperrxcur_itemitem_scalarTyper3r3r4rJsH          rrrcst|tr|dkr|jddddSt|tr'|jdddSt|tr3tj|dS|}|s.) r9rrdetachrrrrYr#rr)rrrr3rr4r}s   rc Cst|tjr0t| dd|}|r|}|r|jn|} |dur$|n|j} |j| | d|dSt|dr7t S|dur=|n|d} |rGt |n|} t |rOt St| j dkrYt St | |} | j| | ddd} | S) NcSr)Nz,Can't pin tensor constructed from a variabler3r3r3r3r4rGrz)_internal_new_from_data..F)r2rr\rY__cuda_array_interface__r2meta)r\rY)r9rYrrZrrr2rhasattrNotImplementedrrr0r) optionsr device_optdatacopy_variables copy_numpytype_inferencer[rinferred_scalar_typer2rr3r3r4_internal_new_from_datas4    r)rr2r[rc Csjt|tjrtjdtdd|du}tddi|dur|nt||dd||d}||r3| ||S)NzTo copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor)r) stacklevelr2rT)rrrr[) r9rYrrxry UserWarningrr(detach_rD)rrr2r[rr new_tensorr3r3r4rs*   r@)F)rNN)r$r%Fry)NN)NNNNNFF)FFN)NF)NNFr)rrM) NNNTrMFNNN)NNNTFNNF)r3)rHr)rrrH)rrsrM)rNrH)r)rr)rNF)rrHNr)rHrN(rrrrdrrrxcollections.abcrrenumr functoolsrrrrtypingr r r r r rrY torch._prims_primsrtorch._prims_common _prims_commonratorch.utils._pytree_pytreerrrrrrrrrrrrrrrrrrr r!r"r#r$r%torch._prims_common.wrappersr&r'r(r)r*r+rrr DispatchKey_opsrRrr5r=r]ri torch._decomprjobjectrwrrrrr, INT_TO_FLOATr-r.r0r/r1r2DEFAULTr3r4r*r5r6r7r:r;r<r=r>r?rA NO_OPMATHrBrCr$rDrEr ALWAYS_BOOLrMrNrOrPrQspecial multigammalnr\rRrSrUrVrWrXrYrrr[rrr_rr`rarrcrdrrerfrgrhrirjrkrm BOOL_TO_LONGrnrorprrr rrsrtrurvrwrxryr|r}rer~rrrr r rrrrrSrrrrrrrrr#rrrrrrrrrrrrrrrrrrrrrrrrrzr{rrr]rUrrrZr_r`registerr2rhrdrerfrhrnrrrrrr dim_IntList IntList_outrrrrrrrrrrrrrrrrrrrrrpy_implCompositeImplicitAutogradMetarrrrrrrrrrrrrrrrr,r/rr _subclasses fake_implsregister_op_implrDrr+r,rRr-rrrrrrrrrrlrrr r rHrIrKrLrrGrJrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr%rr rrrr start_step start_outrTrrrrrrrrr&r!r"r#r~rrr'r(r]rqrrrrr r rrrrrrr)rr@rFrZr^rrbr9r8rrrrrabs_acos_acosh_add_addcmul_addcdiv_asin_asinh_atan_atanh_atan2_ bitwise_and_bitwise_left_shift_ bitwise_not_ bitwise_or_bitwise_right_shift_ bitwise_xor_ceil_clamp_ clamp_min_ clamp_max_conj_physical_ copysign_cos_cosh_cumsum_cumprod_deg2rad_digamma_div_eq_erf_erfc_erfinv_exp_exp2_expm1_ float_power_floor_ floor_divide_fmod_frac_gcd_ge_gt_ heaviside_hypot_igamma_igammac_i0_lcm_le_lerp_lgamma_log10_log1p_log2_log_ logical_and_ logical_not_ logical_or_ logical_xor_lt_mul_ mvlgamma_ nan_to_num_ne_neg_ nextafter_pow_rad2deg_ reciprocal_ remainder_rsqrt_sgn_sigmoid_sign_sin_sinc_sinh_sqrt_square_sub_tan_tanh_tril_triu_ true_divide_trunc_xlogy_cauchy_ exponential_ geometric_ log_normal_zero_rrrrrrrrrrrrrrrrrrtorch._refs._conversionstorch._refs.ffttorch._refs.linalgtorch._refs.nn.functionaltorch._refs.specialr3r3r3r4s    \  0 (  "                                  "           & :              6      +     ',         +    ?  -   ;    (w T %0( "  " "  4 D  '    r   8 , / & " $&$     1 "& "  H * '   ) 8"$    &  *     $&           )    c0      X     ;" B   ?     (           " ,      & &0   0)    ) :     4      (                                                                                               3 #9 &