o ZhD@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)Nhputypedevicer3C/var/www/auris/lib/python3.10/site-packages/torch/_refs/__init__.pyis_noncontiguous_supportednr5cCsBd}ddlm}|D] }t||r|j}nq t|s|}|S)Nr) FakeTensor)Ztorch._subclasses.fake_tensorr7 isinstanceZ fake_devicer5r)Z 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|VqdSNr8r.0xr3r3r4 s  z$_broadcast_shapes..cSs|duSr=r3rAr3r3r4sz#_broadcast_shapes..css|]}t|VqdSr=len)r@shaper3r3r4rBz9Attempting 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 r3r3Zarg_idx common_shapeidxrHr3r4rDs)%torch.fx.experimental.symbolic_shapesr<tuplefilterrGr8rrmax enumeraterange ValueErrortorch_check)Z_shapesr<shapesr3rKr4_broadcast_shapess8    rXT)preserve_cpu_scalar_tensorscs8tdd|Dfddtfdd|DS)Ncss$|] }t|tr |jndVqdSr=)r8r"rHr@rr3r3r4rBs"z#_maybe_broadcast..csj|durdSt|tr |St|tr)rt|r|St|js'|S|Stdt t |d)Nz#Unexpected type when broadcasting: !) r8rr"utilsZis_cpu_scalar_tensorZ same_shaperHr RuntimeErrorstrr0)rArH)rLrYr3r4__maybe_broadcasts   z+_maybe_broadcast..__maybe_broadcastc3s|]}|VqdSr=r3r?)r_rLr3r4rB)rXrO)rYargsr3)r_rLrYr4_maybe_broadcasts  rb)register_decompositionF)aten_op extra_meta exact_dtypereturncsdtffdd }|S)Nprimcshttdttdddtdtffdd }tur(tjdur2t ||S)NrfaZtype_promoting_argstype_promotion_kindrkrgcs$dur||}t|g|Sr=)r:)rkr9)rerhr3r4_refs z>_make_elementwise_unary_reference..inner.._ref) rr+r*r)r# infer_aten_opr\ get_aten_op__name__rcrhrnrdrfrermrhr4inners  z0_make_elementwise_unary_reference..innerr )rmrdrerfrur3rsr4!_make_elementwise_unary_referencesrwcs(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=r3rakwargsfnr3r4_fnz_make_alias.._fnrq)rqinspect currentframef_back f_globals __module__)r{namer|r3rzr4 _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)rkraryrzr3r4r| sz_make_inplace.._fn_r) getmodule) rrqrcgetattratenr~r__all__append)r{r|Z inplace_namerZ_allr3rzr4 _make_inplaces    rricC t|Sr=)primsr,rjr3r3r4r, r,cCrr=)rr-rjr3r3r4r-# r-cCrr=)rr.rjr3r3r4r.(rr.cCrr=)rr0rjr3r3r4r0-rr0cCrr=)rr/rjr3r3r4r/2rr/cCrr=)rr1rjr3r3r4r17rr1cCrr=)rr2rjr3r3r4r2<rr2cCrr=)rr3rjr3r3r4r3Arr3cCrr=)rr4rjr3r3r4r4Frr4inputcCs t|jSr=)r\is_complex_dtypedtyperr3r3r4r*N r*cCst|js|St|Sr=)r\rrrr5rr3r3r4r5Ss  r5cCrr=)rr6rjr3r3r4r6[rr6cCrr=)rr7rjr3r3r4r7`rr7cCrr=)rr:rjr3r3r4r:err:cCrr=)rr;rjr3r3r4r;jrr;cCrr=)rZerf_invrjr3r3r4r<orr<cCrr=)rr=rjr3r3r4r=trr=cCrr=)rr>rjr3r3r4r>yrr>cCrr=)rr?rjr3r3r4r?~rr?cCrr=)rrArjr3r3r4rArrAza,rlrkvaluecCsbt|tsJt|tsJt|j}tt||s+dt|d|d}t|t ||SNzvalue argument of type  cannot be safely cast to type r[) r8r"rr\rrrr0rTrrB)rkr python_typemsgr3r3r4rBs  rBcCst||}t|||Sr=)rrBr)rkrrr3r3r4rCs  rCcCrr=)rUr&rr3r3r4r$s r$cCrr=)rrDrjr3r3r4rDrrDrAcCs*ttt|t|}t||Sr=)rUrrDr,rgr)rAZtrunc_xr3r3r4rEs rEcCs0t|tsJtt|jddt|S)NcSdS)Nz#imag only supports complex tensors.r3r3r3r3r4rDzimag..) r8r"rUrVr\rrrrrjr3r3r4rs  r)rdcCs0t|js t|jrt|St|tjdS)Nr) r\is_float_dtyperrrrMr!rUboolrjr3r3r4rMs rMcCsZt|jrttt|tt|St|jr%t |t dkStj |tj dS)Ninfr) r\rrrUrrNrrrr,floatr&rrjr3r3r4rNs   rNcFttj fddtjrtdkStjtjdS)Nc djS)Nz7Complex dtype is not supported for isposinf, got dtype rr3rjr3r4rD zisposinf..rr rUrVr\rrrrr&rrjr3rjr4rO    rOcr)Ncr)Nz7Complex dtype is not supported for isneginf, got dtype rr3rjr3r4rDrzisneginf..z-infrrrjr3rjr4rPrrPcCs t||Sr=rrrjr3r3r4rQrrQr\cCs*t|jr t|dkStj|tjdS)Nrr)r\rrrUrr!rrjr3r3r4rRs rRcCrr=)rZ bessel_i0rjr3r3r4rS rScCrr=)rrUrjr3r3r4rU rrUcCrr=)rrVrjr3r3r4rVrrVcCrr=)rrWrjr3r3r4rWrrWcCrr=)rrXrjr3r3r4rXrrXcCrr=)rrYrjr3r3r4rY rrYdimrcCs6|p|j}t|}t||}t|t||dd|S)NTkeepdim)rr\get_computation_dtyper&r)rkrr result_dtypecomputation_dtypea_r3r3r4r[&s   r[selfrrcCst|ts|f}|dkrtt|||Stjt||dd}t || t dkd}|r6|nt ||}tt||||}| |S)NrTrr)r8rnumelrUrr>rVrrrr,rrrs)rrrZmaxesZmaxes_squeezedresultr3r3r4r2s  rnanposinfneginfcCst|tsJt|jst|jr|S|durd}|dur(t|jj }|dur3t|jj }t t |||}t t |||}t t|||}|S)Nr)r8r"r\is_boolean_dtyperis_integer_dtyperrUfinforQminrrQrPrO)rkrrrrr3r3r4r_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.r3r3r3r3r4rDez_neg_meta..)rUrVrrrjr3r3r4 _neg_metabs r)recCrr=)rr`rjr3r3r4r`mrr`cCs*t|tsJ|jtjurd}t||S)Nz'positive does not support bool tensors.)r8r"rrUrr])rkrr3r3r4ravs  racCs(t|tsJt|jrt|S|Sr=)r8r"r\rrrrrjr3r3r4rs  rcCrr=)rrcrjr3r3r4rcrrcrj)decimalsrcCs>|dkr t|Sd|}d| }ttt|||S)Nr )rrdr)rkrZten_powZ ten_neg_powr3r3r4rds   rdcCrr=)rrrjr3r3r4rrrcCstdtdtt|S)NrE)rrsr>r`rjr3r3r4resrecCs2t|jr|}t|dkd||S|SNr)r\rrr,rUrrg)rkZa_absr3r3r4rfs rfcCrr=)rrgrjr3r3r4rgrrgcCrr=)rrhrjr3r3r4rhrrhcCrr=)rrirjr3r3r4rirricCs&tj|}t|dkdt||SNrrE)mathpirUrrirjr3r3r4rjs rjcCrr=)rrkrjr3r3r4rkrrkcCrr=)rrmrjr3r3r4rmrrmcCs t||Sr=)rrjr3r3r4rnrrncCrr=)rrorjr3r3r4rorrocCrr=)rrprjr3r3r4rprrpcCrr=)rrrrjr3r3r4rrrrrcs|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: r3r3Z input_dtyper3r4rDsz!view_as_complex..rcSr)Nz-Input tensor must have one or more dimensionsr3r3r3r3r4rDrrJcSr)Nz+Tensor must have a last dimension of size 2r3r3r3r3r4rDrrEcSr)Nz/Tensor must have a last dimension with stride 1r3r3r3r3r4rDrcss|] }|ddkVqdS)rrNr3)r@strider3r3r4rB sz"view_as_complex..cSr)NzCTensor must have a stride divisible by 2 for all but last dimensionr3r3r3r3r4rD rcSr)Nz0Tensor must have a storage_offset divisible by 2r3r3r3r3r4rDr)rrUrVr\rsizerGrbuiltinsrstorage_offsetrZview_element_typecorresponding_complex_dtyper)rsizesZ old_stridesdimsr3rr4r sB      r c s$dtffdd }|S)Nrhcsdurjttdddtttfdtttfdtffdd }r1t|}|_tur>t durJrJt ||S)Nrkbrlrkrrgcstp 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!r3r3rr3r4rD0 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!r3r3rr3r4rD5rcr)Nz?: Receive two Number inputs to an elementwise binary operation!r3r3rr3r4rD;r)rU _check_valuer8rrbr:)rkrr9)rrhsupports_lhs_python_scalarsupports_rhs_python_scalarsupports_two_python_scalarsr3r4rn%s      z?_make_elementwise_binary_reference..inner.._ref) rqrr)rTensorrr+ror\rprcrrrdhas_outrshould_register_decompositionrrrrmrtr4ru s,      z1_make_elementwise_binary_reference..innerrv) rmrdrrrrrrrur3rr4"_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[)rbr8r"rr\rrrr0rTrrrsr:rkrrrrrr9r3r3r4rsPs    rs)rmrrcC t||Sr=)rrtrr3r3r4rts rt)rmcCrr=)rrurr3r3r4ru| rucCrr=)rZ shift_leftrr3r3r4rvrrvcCrr=)rrwrr3r3r4rwrrwcCrr=)rZshift_right_arithmeticrr3r3r4rxrrxcCrr=)rryrr3r3r4ryrry)rmrcCst|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[) r8rrr#rr2r]rrhr`r,rkrrr3r3r4r|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 .)rrrrT)rkrrrr3r3r4r}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)r8r#rrrUrmrBr\rrrrArrrr3r3r4rs&        rcCsxt|trt|trtdt||}|dusJt|r#tj}ntj}t ||}t ||}t ||\}}t ||S)Nz=Receive two Number inputs to an elementwise binary operation!) r8rrTr\Zget_higher_dtyperrUZ complex128float64r&rbrrkrrr3r3r4rs      r)rmrrcs2t|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_divider3r3rr3r4rDArzfloor_divide..)r8rr#rrr2rUr]rZ device_putr\r_floor_divide_floatr_floor_divide_integerrVrr3rr4r#s&       rcCs`t||\}}|jjst||St|t|kt||dk}t||t ||jSr) rbr is_signedrr}rUrhrrr&)rkroffsetr3r3r4rDs  &rc 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)NrrErr)rrrryrrrurrDrrsr#rr2r|) rkrmodr}Zdifferent_signed_inputsZnon_zero_remaindermaskZ floor_divZ basic_divZ zero_tensorr3r3r4rOs    rcCrr=)rrrr3r3r4rhrrcCrr=)rrrr3r3r4rqrrcCrr=)rrrr3r3r4rzrrZmantissaexponentcCstjt|Sr=)rUZ return_typesfrexprrr3r3r4rsrcCrr=)rrrr3r3r4rrrcCrr=)rrrr3r3r4rrrcCrr=)rrrr3r3r4rrrvaluescCsFt|d}tt|dt|}t|dd}t|||}|Sr)rUr~rrrQr)rrZ input_eq_zeroZ input_lt_zeroZzeros_and_onesr9r3r3r4rs rcCrr=)rrrr3r3r4rrrcCrr=)rrrr3r3r4rrrcCrr=)rrrr3r3r4rrrrrtolatolcsXtjjkfddtdkfddtdkfdddS)NcsdjdjdS)Nz4: Attempting to compare tensors of different dtypes  and r[rr3)rkrrr3r4rDz#_check_close_args..rcsddS)Nz6: rtol must be greater than or equal to zero, but got r[r3r3)rrr3r4rDcsddS)Nz6: atol must be greater than or equal to zero, but got r[r3r3)rrr3r4rDr)rUrrrVrrkrrrr3)rkrrrrr4_check_close_argss   rh㈵>: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.iscloserr)rr~r\rrrrrrQrconvert_element_typerUget_default_dtypersr,rrrMr) rkrrrrcloseZ allowed_errorZ actual_errorrr3r3r4rs  rcCs~|j}|tjtjfv}|rt|tj}t|tj}t||}t|dkd|}t t |||}|s9|St||Sr) rrUZint8Zint16rrint32rrr,r})rkrrZpromote_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)rUrrrrrMr\rrrVr>rWrQcomplexr) rkrrmax_min_inf_maskZ neg_min_maskZinf_valsZ non_nan_valsZnan_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 dtypesr3r3r3r3r4rDMrzlogaddexp2..rr) rUrVr\rrrrrNrrVrWrA)rkrrr r r Z inv_log_2rr3r3r4rEsrcCs0t|js |dk}t|js|dk}||@Srr\rrrr3r3r4rY  rcCst|js |dkS|Srr rjr3r3r4rds rcCs2t|js |dk}t|js|dk}t||Sr)r\rrrwrr3r3r4rks   rcCs0t|js |dk}t|js|dk}||ASrr rr3r3r4rwrrcCrr=)rrrr3r3r4rrrcCrr=)rrrr3r3r4rrrcCrr=)rrrr3r3r4rrr)rmrcCrr=)rrrr3r3r4rrrcCrr=rrr3r3r4rrrcCrr=)rrrr3r3r4rrrcCrr=)rrrr3r3r4rrrrEcCs&t|tr d}t|tj|||dS)Nz?Received a Number for the first argument, but expected a Tensorr)r8rrTrUr)rkrrrr3r3r4rs 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.r3r3r3r3r4rDrzsub..rErrr[)rbr8r"rUrVr\rrrrr0rTrrrrr:rr3r3r4rs"   rr)rmrrdrcCrr=)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"r3r3r3r3r4rD rzxlogy..rrr)rUrVr8r"rr#rr2rr~rrVrQr)rkrrhsr3r3r4rs$r)rmrdrcCs0t|}t|rt||Stt||Sr=)r\Z get_dtyperrr}rrrr3r3r4rs   r)rtensor1tensor2rrrcsJdur|j}t|tttfdd|||S)z3 Reference implementation of torch.addcdiv NcdtddSrr/r3rrr3r4rDBzaddcdiv..rr\rrUrrr0rrrrrr3rr4r-  rcsJdur|j}t|tttfdd|||S)z3 Reference implementation of torch.addcmul Ncrrr/r3rr3r4rD]rzaddcmul..rrr3rr4rHrr)rkrrQrrQcCs|dur|durd}t||dur(t|}tt|||}t|||}|durBt|}tt|||}t|||}|S)Nz+clamp called but both min and max are none!)rTrUrQrwrrr)rkrrQrZa_isnan conditionr3r3r4rcs   rcCtj||dS)N)rrUr)rrr3r3r4rzrzcCr)N)rQr)rrQr3r3r4r{rr{predcsb|dus|dur ttj||ddtjtjufddt||\}}t ||S) NTallow_cpu_scalar_tensorscr)Nz#expected predicate to be bool, got rr3rr3r4rDrzwhere..) NotImplementedErrorr\check_same_devicerUrVrrrbrr)rrkrr3r!r4rs   r memory_formatr%cCstj||d}|SNr$)rr)rkr%rr3r3r4rsr)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!)r2r]rr)rkrr'rr3r3r4rs rcCs>|dkrd|d}t|t|j}|t|S)NrEzCan't convert a tensor with z elements to a number!)rrTr\rrrr)rkr number_typer3r3r4rs  rr2copylayout pin_memory non_blockingcCs\| o-|dup |j|ko-|dup|j|ko-|dup|j|ko-|dup-|tjkp-tj||dSr&)r2rr*rUpreserve_formatr\is_contiguous_for_memory_format)rkr2rr)r*r%r+r,r3r3r4_to_will_aliass  r/cOstr=)r"rxr3r3r4 _to_dispatchr0cCs|||||d}|SN)r2rr,r)r%r3r2rr,r)r%ryr3r3r4 _to_devices r4cCst|||||d}|Sr2)rUr2r3r3r3r4_to_device_strs r5cCs||||d}|S)N)rr,r)r%r3)rr,r)r%ryr3r3r4 _to_dtypes r6othercCs(|j}|j}|j}||||||d}|S)N)r2rr*r,r)r%)r2rr*)r7r,r)r%r2rr*ryr3r3r4 _to_other)sr8 to_kwargscCsgd}d|vrt|dtrt|d|d<|D];}||vrU|dkr+||tjusP|dkrF||j|jjkrF||jrP||j|jjksPt||d||krU||qdS)N)rr2r*r%r2r%) r8r^rUr2r-r0indexrpop)rkr9Zoptions_to_checkkwr3r3r4_canonicalize_to_argumentsAs r=cOst|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+r)Fr,rr%r2r*) rGr0r=r/r;getrrrrUrr)rkraryr)r,rr3r3r4rYs(    r) has_identityaccepts_dim_tuplerkeepdimsrrrhr?r@rrAroutput_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=rHr@irjr3r4rBr`z_reduction..zJreducing over zero-size dimension for reduction operation without identitycs"g|] }|vr j|ndqSrErErFrkrr3r4 s"z_reduction..csg|]}|vr|qSr3r3rF)rr3r4rJz7Expected the dtype of reduction result and out to matchZ copy_fromr)r8r"ndimr]rrr\reduction_dimsrHrrreduction_dtypesr&rSrbroadcast_in_dimr'r(r)rkrhr?r@rrArrrBZ valid_shaperrrZ output_shapebroadcast_dimsr3rIr4 _reductionsV    "      rRcspttj}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|jtjdSr&)rrUcontiguous_formatrCr3r3r4rDz3_make_copy_from_view.._fn..)pytreeZtree_map)rraryrrzr3r4r|sz!_make_copy_from_view.._fnZ_copy)rrrqr+rrSupdaterc)r{Zaten_fn annotationsr|Z copy_namer3rzr4_make_copy_from_views     rZcCs:ttjt|||d}|jtjkr|jtjd}|S)Nrr)rUrrruint8r)rkrrrr3r3r4rs rcCsbt|tj}t|ttfrt|dkr|}n |j||d d}|j tj ur/t |tj S|S)Nr)rrF)r&rUrr8listrOrGrrrrr[rr)rkrrrrr3r3r4rs   r)rrc Cl|dur|dur |j}nt|jst|jrtj}n|j}|dks'|gkr)d}t|tj||||t j dSNr3rrArrrB) rr\rrrUint64rRrrrSAMErkrrrrr3r3r4r" rcstjddttjfddtjr)tdkr)t Sj tt t t fddt tD}tj |ddd S) NFvalidatecsddjdS)Nzsum_to_size: size "z" is not expandable to size ""rEr3rkrHr3r4rD! szsum_to_size..rc3s2|]}|dkrj|dkr|VqdSrENrErFrkZ leading_dimsrHr3r4rB( szsum_to_size..T)rrr)r\extract_shape_from_varargsrUrVZis_expandable_torHZ is_same_shaperGrview_ofrMrOrSr)rkrH reduce_dimsr3rir4r s     rc Cr]r^) rr\rrrUr`rRrrrrarbr3r3r4r0 rcrrTc C0|dks|gkr d}t|tj||d|dtjdSNr3FrrArrr?rB)rRrrrrarkrrrr3r3r4rN  rc Crmrn)rRrrrrarpr3r3r4rf rqrcCs"|dur t|tr |}d}||fSr=)r8r)runbiasedr3r3r4_dim_var_dispatch~ srs correctionrrruc CsVt||\}}t||}|dks|gkrd}t|ttj|d||dddtjd}|S)Nr3rtTro) rsr\set_correctionrRrrrrCOMPLEX_TO_FLOAT)rkrrrrrurr3r3r4r s   rc Csht||\}}t||}t|tj\}}t||}tj||||d}t |}|dus/Jt||SN)rur) rsr\rvrOrrwr&rUrrm) rkrrrrru 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) Nr3r_csddurdnddS)Nz&mean(): could not infer output dtype. ZInputr z> dtype must be either a floating point or complex dtype. Got: r3r3)r orig_dtyper3r4rD s zmean..rrEc3rDr=rErFrjr3r4rB r`zmean..rL)rrRrrrZKEEP_PROMOTED_TYPErUrVr\rrr8rrNrHrMroperatorrrr&r"r'r() rkrrrrrrZnelemrr3)rkrr|r4r s<    *    rZout0Zout1)rrrruc Cs|t||\}}t||}t|tj\}}|j}t||}tj ||||d\}} t |} |dus4Jt| |t| |fSrx) rsr\rvrOrrwrr&rUrrm) rkrrrrruryrZoriginal_dtyperzZa_meanr{r3r3r4r s    rcCs4t||\}}t|||||d}t|||}||fS)Nrt)rsrr)rkrrrrruvmr3r3r4r 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)NrEcdjdS)Nz*addr: Expected 1-D argument vec1, but got -DrMr3)rr3r4rD$ rVzaddr..cr)Nz*addr: Expected 1-D argument vec2, but got rrr3)rr3r4rD( rVrrc ddS)NzBoolean z$ only supported for Boolean results.r3r3)arg_namer3r4rD0 rrcdtS)Nzexpected bool/int beta but got r/r3rr3r4rD7 rVcr)Nz expected bool/int alpha but got r/r3rr3r4rD; rVFcdtdjSNzcannot safely convert z to r0rr3)rrr3r4rDG rcrrrr3)rrr3r4rDK r)rUrVrMr8rr\rrrrHrr0intouterrrr)rrrrrargr3)rrrrrrr4r s^               rrra.cGs^|s t|tjjr |}nt|tjjrJ|f|}tdd|D}t|dkr+|S|dS)z5Reference implementation of :func:`torch.atleast_1d`.css(|]}|jdkr |nt|dVqdS)rErN)rMrr@rkr3r3r4rB^ s&zatleast_1d..rEr)r8 collectionsabcrrOrGrraargs_rr3r3r4rU s  r at_least_fncCs ||}t|ts Jt||Sr=)r8r"r)rrrZarg_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)rNrrZunsqueeze_atleast_1dr3r4rBw $zatleast_2d..rE) r8rrrrrrrOrGrr3rr4rm   rcsn|s t|tjjr |}nt|tjjrJ|f|}tttdtfdd|D}t|dkr3|S|dS)z5Reference implementation of :func:`torch.atleast_3d`.rJc3r)NrrZunsqueeze_atleast_2dr3r4rB rzatleast_3d..rEr) r8rrrrrrrOrGrr3rr4r| rrrrrcCs$|dur|n|}t||||Sr=)rrr)rkrrrstorage_offset_intr3r3r4r srsrccCs"|durdn|}t|||||Sr)rr)rrrrrrr3r3r4r s rcGstt|Sr=)rUSizerX)rWr3r3r4r r}rcGs4t|dkrt|dts|d}tt|ddiS)NrErrYF)rGr8rr\rbtensorsr3r3r4r srcCs8t|t|j}tt|t|j|}t|||Sr=)rGrHrOrSrrP)rkrstartrr3r3r4r 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=)r\suggest_memory_formatrUrU)inputsformatrfr3r3r4 cat_compute_output_memory_format s    z-cat..cat_compute_output_memory_formatrz3cat expects at least one tensor, but received zero!r Fr;rEcsdjdjddS)N6Number of dimensions of tensors must match. Expected z-D tensors, but got z-D for tensor number in the listrr3)examplerGrr3r4rD szcat..csdjddS)Nrz*-D tensors, but got 1-D for tensor number rrr3)r tensor_idxr3r4rD s cs|]}|jVqdSr=) requires_gradr?r3r3r4rB zcat..rrr2rr%r$)rGrTr8r"r\r#rNr<rRrMrUrVrHrrr Exceptionrrr2canonicalize_dimZ validate_idxrrr) rrrrtensorr<rHfilteredr%rr3)rrGrrr4r sh         rcCstdd|D}t|dS)Ncss0|]}|jdkr |n||dfVqdSrh)rMrrr?r3r3r4rB5 s  zcolumn_stack..rE)rOrrZaligned_tensorsr3r3r4r3 s rcCs*t|js|S|jrt|St|Sr=)r\rrZ is_sparserUr5rrrr3r3r4r; 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 rFr3)rr3r4rDK rVz!constant_pad_nd..cr)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.rFr3)l_inprr3r4rDV s rEcss|]}|dkVqdS)rNr3)r@pr3r3r4rBm rIz"constant_pad_nd..c s6dddddd S)NzThe input size z, plus negative padding rrEzG resulted in a negative output size, which is invalid. Check dimension z of your input.r3r3)rG input_sizesl_diffrpad_idxr3r4rDw s rF)rUrVrGrHrSrrrrr\rr\rrrr2rrrBrr) rrrZl_padZc_input new_shapeZnew_dimr%r9Zc_outputr3)rGrrrrrr4rD sl    "         rcCs6t|tjkddtj||dr|Stj||dS)NcSr)Nz@preserve memory format is unsupported by the contiguous operatorr3r3r3r3r4rD rzcontiguous..r$)rUrVr-r\r.r)rkr%r3r3r4r srcCs*tt|dkddt|}t|dS)NrcSr)Nz%dstack expects a non-empty TensorListr3r3r3r3r4rD rzdstack..r)rUrVrGrrrr3r3r4r  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;rEcSr)Nz3expand: the requested shape has too few dimensions!r3r3r3r3r4rD rzexpand..rJcr)Nz3expand: attempting to expand a dimension of length r[r3r3rCr3r4rD r)rNr<rGr8rrOrUrVrHr\rRr\validate_shaperrPrS)rkrHr<rshape_rMZ offset_idxZrequested_lengthr3rCr4r s0      rcCs ||jSr=)rrHrr3r3r4r 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)rrFrk chunk_sizerr3r4rJ szchunk..) rTr\rrMrHrr4rDrSrrrO)rkrrrlengthZ full_chunksZtail_chunk_sizerr3rr4r s  rrJ start_dimend_dimcCsht|j|}t|j|}||kr|jdkr|St|||\}}|dur-t|||St|||Sr)r\rrMr_collapse_view_helperZ collapse_viewZcollapse)rkrrr _new_stridesr3r3r4r srcCs@t|tst|tstdt|j|}t|t ||S)Nz!dims has to be a sequence of ints) r8rOr\rTr\canonicalize_dimsrMZvalidate_no_repeating_dimsrrevrIr3r3r4r s   rcC|jdkr tdt|dS)NrzInput must be >= 2-d.rHrMr]rrjr3r3r4r   rcCr)NrEzInput must be >= 1-d.rrrjr3r3r4r rrrrcsttrtdkotjddt t t|dkddtdkddt |j |}| |tt koMkfdddkr]tkfddt|j}||<||||||S)NrcSr)Nz'start must be an 0-dim integral Tensor.r3r3r3r3r4rD# rznarrow..cSr)Nz-narrow() cannot be applied to a 0-dim tensor.r3r3r3r3r4rD' rcSr)Nz&narrow(): length must be non-negative.r3r3r3r3r4rD( rcsd dddS)Nz0start out of range (expected to be in range of [, z ], but got )r3r3) dim_lengthrr3r4rD. rcsddddS)Nzstart (z ) + length (z) exceeds dimension size (z).r3r3rrrr3r4rD4 rK)r8r"rUrVrr\rrrr rrrMr _check_with IndexErrorr\rHrrr)rkrrrrr3rr4r 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)rrrr) r\rrMrrr&r8r"rUrr) rkrrrZa_accZ biased_varrrstdrr3r3r4 _normalize= s     r dimensionscCst|D]}t||}q|Sr=)sortedrUr)rArrr3r3r4_unsqueeze_multiple[ s rweightbias 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 rr3rr3r4rDn 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 = rEr3rrr3r4rDr sr) rUrVrMrrrrHr\rSrr&rr)rrrrrrrrrNZinput_reshapedrrrrQZunsqueeze_biasZunsqueeze_weightr3rr4ra s@             rZout2normalized_shapec st}t|dkfddtdupjtkfddtdup0jtkfddtj|koLjj|dtkfdddur`durhj|}tt|j}t ||\}} } durdur|}ndurdur|}ndurdur|}t |j }j j dvrt | j } t | j } || | fS)NrEcs dtS)NzzExpected normalized_shape to be at least 1-dimensional, i.e., containing at least one element, but got normalized_shape = )r^r3)rr3r4rD sz#native_layer_norm..csdtjdtS)NzQExpected weight to be of same shape as normalized_shape, but got weight of shape  and normalized_shape = r^rHr3)rrr3r4rD csdtjdtS)NzMExpected bias to be of same shape as normalized_shape, but got bias of shape rrr3)rrr3r4rD rcs&dtdtdtjS)NzGiven normalized_shape=z, expected input with shape z, but got input of size rr3)rrr3r4rD s)rZmtia)rGrUrVrHrOrMrr\rSrr&rr2r0) rrrrrZnormalized_ndimZaxisrNrrrr3)rrrrr4r sJ                 rcOst|Sr=)r)Z fake_modefuncraryr3r3r4native_layer_norm_fake srcGs t|jt|}t||Sr=)r\rrMZextract_dims_from_varargsrr)rkr _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-valuedr3r3r3r3r4rD rzrenorm..rcSr)Nz'renorm: non-positive norm not supportedr3r3r3r3r4rD rcSr)Nz#renorm: maxnorm must be real-valuedr3r3r3r3r4rD rcr)Nz,renorm: expected maxnorm to be >= 0 but got r3r3)rr3r4rD rrEcr)Nz/renorm: input needs at least 2 dimensions, got dimensionsr3r3rr3r4rD rT)rrrgHz>r)rUrVr8r rMr\rr\rSrrlinalg vector_normrrrr) rrrrrlZacc_typer]rZ norm_factorr3)rrMr4r+ 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 r1r3rrr3r4rD$   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 valuesr3r3r3r3r4rDA rrErcSr)Nzstft expected a 1D or 2D tensorr3r3r3r3r4rDC rrrcddS)Nzstft expected 0 < n_fft <= z, but got n_fft=r3r3)rrr3r4rDS rcr)Nz0stft expected hop_length > 0 but got hop_length=r3r3) hop_length_r3r4rDW rcr)Nz9stft expected 0 < win_length <= n_fft but got win_length=r3r3) win_length_r3r4rD[ rcsdddjS)Nz8expected a 1D window tensor of size equal to win_length=rzbut got window with size rEr3)rrr3r4rD_ rrrJ) dimensionrsteporthocSr)Nz9Cannot have onesided output if window or input is complexr3r3r3r3r4rDx rrr])rUrVr2r*r\rrrrMr itertoolsrrHrrrrr rrfftZrfftZ transpose_Zsqueeze_Z view_as_real)rrrrrrrrrrrZreturn_complex_ original_ndimZ extra_dimsZ pad_amountZextended_shapeleftZinput_pad_amountZ complex_fftr]rr3)rrrrrrr4r, 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)NcrNzBistft input and window must be on the same device but got self on rr1r3rr3r4rD rzistft..rcsdjdjSrr1r3rr3r4rD srJrErcSr)Nz"istft input tensor cannot be emptyr3r3r3r3r4rD rrrcr)Nz8istft expected a tensor with 2 or 3 dimensions, but got rr3rr3r4rD 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}r3r3r3r3r4rD 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}r3r3r3r3r4rD rcSr)Nz+istft expected 0 < hop_length <= win_lengthr3r3r3r3r4rD rcSr)Nz&istft expected 0 < win_length <= n_fftr3r3r3r3r4rD rcSr)NzDInvalid window shape. window has to be 1D and length of `win_length`r3r3r3r3r4rD rrrcSr)Nz9cannot have onesided output if window or input is complexr3r3r3r3r4rD rrcSr)Nz:Complex windows are incompatible with return_complex=Falser3r3r3r3r4rD r)rrr)rrrrzThe 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)rUrVr2r\rrrrrMrHZcorresponding_real_dtyper rrrrrZifftrZirfftrZunfold_backwardrrrQrwarningswarn)rrrrrrrrrrrrZn_framesZfft_sizeZexpected_output_signal_lenZ onesided_Z real_dtypeZwindow_rrr]Zy_tmpyZwindow_enveloprendr3rr4r- s                   r-a_shapea_striderrc st|}tj||dd|dkrdn||dkrdn|}tkfddtdkfddt|}t|}||||krd|d|<|9<||fS)NT)Z wrap_scalarrrEcsdddS)Nz%Maximum size for tensor at dimension z is z but size is r3r3)rmax_sizerr3r4rD&rz*_get_unfold_shape_stride..cr)NzStep is z but must be > 0r3r3rr3r4rD+r)rGr\rrUrVr\r) rrrrrZa_ndimZ last_striderHstridesr3)rrrrr4_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) NFrdcSr)Nzbrepeat: Number of dimensions of repeat dims can not be smaller than number of dimensions of tensorr3r3r3r3r4rD>rzrepeat..rrEcss|] \}}||VqdSr=r3)r@Z padded_sizeZ repeat_sizer3r3r4rBIs  zrepeat..rT)keyreverse)r\rjrUrVrGrHrrMrrOziprrr2rrmake_contiguous_strides_forrRrrQr\sortr} itemgetterrrr)rkZ repeat_shapeZnum_new_dimensionsZ padded_shapedim_sizeZ target_shapeZurtensor_shapeZurtensor_striderZenumerated_strideZ permute_orderZ_sorted_strideZrepeat_xtensorZ cloned_resultZpermuted_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_eqFrdrErJrz 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 rEr3rrMr3r4rDrz&_reshape_view_helper..)rNr<rr\rjZ infer_sizerrrrMrrrkrGrHrZ is_contiguousrUZ split_dimrrrrTrrV)rkrrHr<rZ_ardim0dim1last_dimaccumr rrrr3rr4_reshape_view_helperrs                       r"rHcGt|g|RddiS)NrTr"rgr3r3r4rrcC||Sr=)rrrr7r3r3r4rr}rr3shiftsc 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 dimensionsrEz`shifts` requiredz*shifts and dimensions must align. shifts: z, dims: Nr1)r\rrMr8rrrrrGrr]rUrrrrHrr2rJr) rkr(rZ len_shiftsZlen_dimsZ tail_shiftsZ tail_dimsZfirst_dim_rolledrrrrMr3r3r4rs@       rrrEkcCst|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 = rrEz7expected rotation dims to be different, but got dim0 = z and dim1 = rrr$) rGr]rMr\rrUrrrrU)rkr*rr3r3r4r.s&   $ $rcCsP|dj}tdt|D]}||j|ks%Jd|d||jd|q dS)NrrEz4stack expects each tensor to be equal size, but got z at entry 0 and z at entry )rHrSrG)rZ entry_shaperGr3r3r4_check_stack_inputsNs r+cst|dks Jdt|djd||djkr:t|t|dj}|t|t |}| |St fdd|D|S)Nrz$stack expects a non-empty TensorListrEcsg|]}|qSr3)rrZZ wrapped_dimr3r4rJerzstack..) rGr\rrMr+r\rHinsertrUrr)rrZ result_sizesrr3r,r4rWs  rcCsh|p|j}t|}t||}|dkrt|}n t||dd}t||}tt|t||dd|S)NrTr) rr\rr&rr>rrr)rkrrrrrZa_expZa_maxr3r3r4rlis      rlcCsBtt|dkddt|}|djdkrt|dSt|dS)NrcSr)Nz%hstack expects a non-empty TensorListr3r3r3r3r4rDrzhstack..rE)rUrVrGrrMrrr3r3r4r}s   rcCs*tt|dkddt|}t|dS)NrcSr)Nz%vstack expects a non-empty TensorListr3r3r3r3r4rDrzvstack..)rUrVrGrrrr3r3r4rrrrcCs\t|j|}tt|dkdd|t|jd|t|t|j|ddS)NrcSr)Nz"unflatten: sizes must be non-emptyr3r3r3r3r4rDrzunflatten..rE) r\rrMrUrVrGrrOrH)rkrrr3r3r4r s6r rcspddlm}t|jtt|jdkdd||jdkr%dSt fddt ||jDS)Nrr;cSr)Nz5Dimension specified as 0 but tensor has no dimensionsr3r3r3r3r4rDrzunbind..r3c3s|] }t|VqdSr=)rUr)r@srr3r4rBs  zunbind..) rNr<r\rrMrUZ _check_indexrGrHrOr)rrr<r3r/r4r s   r r:rcCs|jtjd|||Sr&)rrUrUrI)rArr:rr3r3r4rHsrHcs`t|j|}tjdkfdd|jdkr|dn|}tdf|f}|||<|S)NrEcrNz(Index should have dimension 1 or 0 (got rrr3r:r3r4rDrVzindex_copy_..r)r\rrMrUrVrslice)rArr:rr rMr3r1r4rIs rIcCt||||ddS)NFinplace _index_fillrArr:rr3r3r4rKsrKcCr3)NTr4r6r8r3r3r4rLsrLr5c stjdkfddttr tjdkfddn tj|j|j|jd|jdk}|r8| dn|}t |j } ||< ||rOtjntj}|||} |r]|S|rf| d} | |krzt|} | | | } | S)NrEcrr0rr3r1r3r4rDrVz_index_fill..rcr)Nz         r7cCs|jtjdj||||dS)Nr$r)rrUrUZ index_add_)rArr:rrr3r3r4rGs  rGcs|t|j|}tjdkfddjdkrd|jdkr0t|d|St df|f}||S)NrEcrr0rr3r1r3r4rDrVzindex_select..r) r\rrMrUrVrrrHrr2)rArr:rMr3r1r4rJ 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|VqdSrhr3)r@rMrr3r3r4rB$szsqueeze..rc3s&|]}j|dkr|VqdSrhrE)r@drkr<r3r4rB0rrET)r)rNr<rOrRrHrrrkrMr\rr8rrGr\r)rkrrrMZ dims_listrGr3r;r4rs(         r split_sizescsttD] }t|ddqtttjkfddg} }D]!}t j}||<|  | || |}q0|S)NcSr)NzCsplit_with_sizes expects split_sizes have only non-negative entriesr3r3r3r3r4rDErz"split_with_sizes..csdtdjS)NzSplit sizes add up to z but got the tensor's size of )rrrHr3rrr<r3r4rDJs)rSrGrUZ_check_is_sizerrTrrrHrr\rrr)rr<rrGZsplitsr split_sizerr3r=r4r<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 rEr/zntensor_split: non-scalar indices_or_sections tensors must have only one dimension, but received a tensor with rcs g|] }|d|qSrHr3rFindicesr3r4rJ z tensor_split..)r\rrMrTr8r"r2r0rrUlongrrrrHrrDrSrrOrrtolistr\rG) rkr?rZ_dimrsectionsrZmin_split_sizeZnum_splits_one_extrar<Z split_idxr>r3r@r4r\sf            rcstjdkfddjdkrdndttr:tdko+jdkfddtStttt ffdd}t|S)NrEcdtjdS)NzPtorch.hsplit requires a tensor with at least 1 dimension, but got a tensor with dimensions!r^rMr3rjr3r4rD 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[rr3)rkrr>r3r4rDs 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/r3r?r3r4rD rUrVrMr8rrHr _check_typer\rOrkr?r<r3)rkrr?r>r4rs$      rcstjdkfddttr0tdko"jddkfddtdStttt ffdd}t|dS)NrcrF)NzPtorch.vsplit requires a tensor with at least 2 dimension, but got a tensor with rGrHr3rjr3r4rDrIzvsplit..rcsdjdddS)NzQtorch.vsplit attempted to split along dimension 0, but the size of the dimension rrJr[rEr3)rkr>r3r4rDs 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/r3rKr3r4rDrLrMrOr3)rkr?r>r4rs"       rrcs@|tdvfdddkrt||St||S)N)rErcr)Nz'diag(): Supports 1D or 2D tensors. Got Dr3r3rr3r4rDrzdiag..rE)rrUrVrr)rrr3rr4rs  rrdim2csDt|}||||tjjkfddt|S)NcdjdjS)NzCexpected src to have a size equal to the diagonal of the input.Got z for a diagonal of shape rEr3rrr3r4rD z"diagonal_scatter..)r\Zclone_preserve_stridesrrUrVrHr)rrrrrQrr3rSr4rs    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 )rMrankcrNz(diagonal dimensions cannot be identical rr3r3rrQr3r4rD(rzdiagonal..rc g|] \}}|fvr|qSr3r3r@rGr.rWr3r4rJ8rBzdiagonal..crXr3r3rYrWr3r4rJ;rB)rrr) rr\rrUrVrrQrrrrRrr) rrrrQZnum_dimsrZ diag_sizerrrr3rWr4rs( &$ rr c 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 rE)rUrMcrrVr3r3rWr3r4rDZrzdiag_embed..rJrFrr2rr/r2rcs g|] }|fvr ndqSrHr3rFrrQr r3r4rJurBzdiag_embed..)rMr\rrUrVrr\rHrr,r%rr2rrrrr`rSrGr mask_tensorr) rrrrQrUZt_shapezpairZa_rangeZb_rangecondZ cond_shaper3r\r4rCs4      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)rErJ)rrr@rr3r3r4rJsz(_block_diag_iterable..css|]}|jdVqdSrhrErar3r3r4rBr`z'_block_diag_iterable..rrcsdddS)Nz5Input tensors must have 2 or fewer dimensions. Input z has rr/r3)rGrr3r4rDs 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 rr1r3r2rGrr3r4rDsr[rEr/) rrr2rRrUrVrrHr%rr) rZ tensors_2dZncolsrZ col_startrowcolrrightr3rbr4_block_diag_iterable}s0     rfcGst|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. )rfrr3r3r4rsrrEcCsl|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 rGrrz3torch.dsplit attempted to split along dimension 2, zbut the size of the dimension rJr[)rMr]r8rrHr)rkrEr3r3r4rs  $ rcCs:|jdkrtd|jdt|d|jdkrdSdS)Nrz7t() expects a tensor with <= 2 dimensions, but self is rPrrE)rMr]rUrrjr3r3r4rs  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.r3r3r3r3r4rDrzT..)rUrVrMrrjr3r3r4rs rcCrr=)rrkrjr3r3r4rrrrcCs`t|j||f\}}|jdks||krtj|Sttd|j}|||<|||<t ||S)NrEr) r\rrMrrdefaultr\rSrUr)rkrrZ_dim0Z_dim1rr3r3r4rs  rcCs&t|j||||\}}|||Sr=)rrHrr)rrrrrHrr3r3r4rs rcCs||||jtjdSr&)rrrUrU)rrrrr3r3r4rsrc Cs|j}t||}|dkr||dd||dS||d}tj|j||jd}|d|k}t||dD]} |d}q9t |||} || |||dS)Nr)rrrrEr1rJ) rMr\rrrUrrHr2rSr) rinitrkrrrrMrgrrZmasked_ar3r3r4_cumsumprod_commons  rjcCttd||||dS)Nrrrhrkrrr)rjrrkrrrr3r3r4rrcCrk)NrErl)rjrrmr3r3r4r$rnrcCs(|jd}t||}tj||f|dS)NrEr)rMr\rrZ expand_dims)rkrrMr3r3r4r0s  rcGr#)NrFr$rgr3r3r4r=srcCr&r=)rrr'r3r3r4rCr}rcCs t|dS)N)rJ)rrjr3r3r4rHs rrAcstjjkfddttjfdd|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 indicesrr3rkrAr3r4rDTs z take_along_dim..cr)Nz?torch.take_along_dim(): dtype of indices should be int but got z insteadrr3r@r3r4rD]srJr) rUrVrMr\rrgatherrr\rHrZinfer_size_shapesr)rkrArZ self_sizesZbroadcast_shapeZindices_broadcastZ indices_sizesZself_broadcastr3ror4rNs&        rrr*r2rr+r%rc sttjkddt|}tjkrt|}ntjkr&t|}nttj kfddt |}tj |||||||dS)NcSr)Nz8torch.empty: the Preserve memory format is not supportedr3r3r3r3r4rDrzempty..cr)Nz/torch.empty: received an unknown memory format r[r3r3r$r3r4rDrrr*r2r+r) rUrVr-r\rjrUrZchannels_last_3dZ!make_channels_last_3d_strides_forZ channels_lastZ!make_channels_last_2d_strides_forr)rr*r2rr+r%rHrr3r$r4rss.        rcCstj|||||dS)NrZ)rr)rHZphysical_layoutrr*r2rr+r3r3r4rs rrr*r2r+cCsJ|dur|jn|}|dur|jn|}|dur|jn|}tj|||||dS)Nrr2r+r*)rr*r2rUr)rkrrr*r2r+r3r3r4rs rcCsL|dur|jn|}|dur|jn|}|dur|jn|}tj||||||dS)zD Reference implementation of torch.Tensor.new_empty_strided Nrt)rr*r2rUr)rkrrrr*r2r+r3r3r4rsrrrc G@t|}|dur t}tj||tjkrdnd|||||dSNFrrrr\rjrUrrrrr*r2r+rrr3r3r4r% r%c Cb|dur|jn|}|dur|jn|}|dur|jn|}tj||p"|jtjkr(dnd|||||dSrvrr*r2rUrrrkrrr*r2r+rr3r3r4r rc GruNTrErrrwrxr3r3r4r ryr c Crzr~r{r|r3r3r4r2r}r fill_valuecCsL|dur|jn|}|dur|jn|}|dur|jn|}tj||||||dS)Nrs)rr*r2rUr)rkrrrr*r2r+r3r3r4rMs r)rr2r*r+rr%c Cs~|dur|jn|}|dur|jn|}|dur|jn|}|tjkr-tj|j||||||dSt|}tj |j||||||dS)Nrqrr) rr*r2rUr-rrHr\Z3compute_elementwise_output_logical_to_physical_permr)rkrr2r*r+rr%Zlogical_to_physical_permr3r3r4rgs0   rr cst|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 nonzeror3r3r3r3r4rDrzarange..cSrNz7upper bound and lower bound inconsistent with step signr3r3r3r3r4rDrcSrrr3r3r3r3r4rDrcSst|t p t|Sr=)r8rrrMrCr3r3r4 is_finiter%zarange..is_finitecsddS)Nzunsupported range: z -> r3r3)r rr3r4rDrcr)Nzstep must be finite but got r3r3rr3r4rDrcs|]}t|tVqdSr=r>r@rr3r3r4rBr`zarange..)rrrr2rrEFT)r\ check_layoutcheck_pin_memoryrUr2device_or_defaultr8r rVrrr`rrrrrr4riotarCZ get_acc_typer&requires_grad_)rr rrr*r2r+rrraZ integer_args is_integerZxstartZxendZxsteprfrr:rrr3)r rrr4rs           r)rr rc Cs||g}t|tr|d|}n||t|tsJ|dk}t||d|}t|||}||||}tj t |}| |krMt ||}t||S)Nr3rrE)r8rrrrr,rUrr\Z"compute_elementwise_output_stridesrbrrZ copy_stridedr:) rr rrrZcoeffbaser9rr3r3r4rTs      rT)rr2r*r+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 tensorsr3r3r3r3r4rD&rzlinspace..cSrrr3r3r3r3r4rD,rcsrr=r8r rr3r3r4rB0r`zlinspace..cr)Nzlinspace(): inferred dtype z& can't be safely cast to passed dtype r3r3)default_complex_dtyperr3r4rD9rcs*dtjdtjdtjdS)Nz4received an invalid combination of arguments - got (rr)r0rqr3)r rrr3r4rDBscSr)Nz$number of steps must be non-negativer3r3r3r3r4rDFr)r*r2r+rrrrErr)rr)r8r#rUrVrr&rrrr\rrrrrNrrropsrr)rgrrrr`rOrrarr)rr rrr2r*r+rZfactory_kwargsZ empty_tensorriZ dtype_redrrZcast_rgrrr3)rrr rrr4rsx            rrrc 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 tensorsr3r3r3r3r4rDrzlogspace..cSrrr3r3r3r3r4rDrcsrr=rrr3r3r4rBr`zlogspace..rr)rUrrr\rr8rrr#rVrr&rrrrr r"rr) rr rrrr2r*r+rrZ_dtyperetr3r3r4rpsP            rindexingcCdSr=r3)rrr3r3r4rr1rcGrr=r3)rrr3r3r4rr1cst|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)NrrEcsrr=r8r"rr3r3r4rBr`zmeshgrid..cSr)Nz)meshgrid expects its inputs to be tensorsr3r3r3r3r4rDrzmeshgrid..cSr)Nz'meshgrid expects a non-empty TensorListr3r3r3r3r4rDrcSr)Nz3meshgrid expects all tensors to have the same dtyper3r3r3r3r4rDrcSr)Nz4meshgrid expects all tensors to have the same devicer3r3r3r3r4rDrFZxyrZijcr)NzDtorch.meshgrid: indexing must be one of "xy" or "ij", but received: r3r3)rr3r4rDscr)NzEtorch.meshgrid: Expected 0D or 1D tensor in the tensor list but got: r3r3)rr3r4rDrrH)r8r\rOrGrUrVrrrSrr2r"rMrrrRrrrP)rrrGZswap_first_and_second_tensorsZ result_shapeZgridsr3)rrr4rsX      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)r\r3rrr3r4rD s zmovedim..)rUrAcdtdS)Nz#movedim: repeated dim in `source` (rrr3)rr3r4rDrcr)Nz(movedim: repeated dim in `destination` (rrr3)rr3r4rD rrNrE)r0rrUrVrGrMrOr\rsetdictrrSr>rr)rrrrUssZdsZsssZdssrrsiZdir.rr3rr4rsF           r)rr2r*rr+rcCs\t|t|t|}|durtn|}|dur"tdn|}tj|||||dS)NrrZ) r\rrrjrUrr2rr)rHrrr2r*rr+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)rr3r4rDhrzeye..cr)Nz%m must be greater or equal to 0, got r3r3)rr3r4rDirFrZrJrHrr)rUrVrr`rrr r) rrrr*r2r+rZrange_nZrange_mr`oner3)rrr4rVs$ rcCsdt|t||dur|ntt|}|dur|ntd}t||||||d}t||S)Nrrr) r\rr type_to_dtyper0rUr2rrB)rHrrr*r2r+rer3r3r4rs  rrr*r2r+rr%c Cs"tj|||||||d}t||S)Nr)rUrrB) rkrrr*r2r+rr%rr3r3r4rs  rc C.tj||p|jtjkr dnd||||||dS)NFrrrUrrrrkrr*r2r+rr%r3r3r4r& r&c Cr)NTrErrrr3r3r4r!rr!cGs>t|t|}t|}t|}tj|dd|||dS)Nrr)rrrr2r)r\rrjZdtype_or_defaultrrr^)rr2r*rr+rHrr3r3r4r"s   r"cCsTt|t||dur|ntt|}|dur|ntd}tj|||dS)Nrr) r\rrrr0rUr2rr#)rkrr*r2r+r3r3r4r#s  r#rlowhighcCsdt|t|ts Jt|tsJt|}t|}t|tjs#Jt|}tj |||||dS)N)rrrr2) r\rr8rrrUrZcanonicalize_devicer_uniform_helper)rHrrrr2r3r3r4rs  rrcst|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_ndimr3r4rD4rzmasked_fill..cudaZxpur.rcSr)Nz,Expected `value` to be on same device as `a`r3r3r3r3r4rD>rcr)Nzcould not convert to type z without overflowr3r3)rr3r4rDIr)r\rrr8rr0rMrUrVr2_CZ_get_privateuse1_backend_namer rr&rr)rkrrZ value_typeZ is_cpu_scalarrr3)rrr4r(s4         rcCst|||}|||Sr=)rUrr9)rkrrrr3r3r4rVs rc Cs4td||||dtttj|||||dS)z4 Reference implementation of torch.allclose ztorch.allcloser)rrr)rrrUrrr)rkrrrrr3r3r4r'`s r'cCsttj||ddt|||j|jkrdSt|j|jD] \}}||kr(dSq|dkr1dSttt ||S)NFrrT) r\r#Zcheck_same_dtyperMrrHrrrr~)rkrrAr r3r3r4r(qs   r(frorcCs|dkr|dust|tst|dks|durd}t|tr!|g}t|tr<|dur1tt|j}tjj |||||dStjj |||||dS)Nrrr) r8rrGr^rOrSrMrUrZ matrix_normr)rrrrrr3r3r4r]s&   r]cCs(t|jdkddtt|dS)NrcSr)Nz6expected a matrix, but got tensor with dim {self.ndim}r3r3r3r3r4rDrztrace..r)rUrVrMrrrr3r3r4rqsrqcs.dtttfdtttfdtffdd }|S)Nrkrrgcs ||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 dimensionsr3r3r3r3r4rDrztriu..r r1rJ rUrVrMrHrr2rr\r]rrkrhwrr3r3r4r r cCsht|jdkdd|jdd\}}tj||jddtj||jdd|k}t|| S)NrcSr)Nz2tril: input tensor must have at least 2 dimensionsr3r3r3r3r4rDrztril..r r1rJrrr3r3r4r rr rcrdc Cs|dks|dkr dS|dkrt|d|nt||dk}tdt|||}tdt|||}||d}|||d}||}td||} || |fS)NrrrrrEr)rrrQ) rcrdr m_first_rowZ m_last_rowZ n_row_allZn_row_trapezoidtrapezoid_sizeZdiff_rowrectangle_sizer3r3r4_get_tril_sizess&  rcsVtdkfddtdkfddttjtjfvfdddS)Nrcr)Nzrow must be non-negative, got r3r3)rcr3r4rDrz_trilu_checks..cr)Nzcol must be non-negative, got r3r3)rdr3r4rDrcsdddS)Nrfz" not implemented for ''r3r3)rrr3r4rDs)rUrVrr`)rrcrdrr*r+r3)rdrrrcr4 _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)Nrrr*r2r+rrrrE) rrrQrrUrrrDrmr&rr)rcrdrrr*r2r+rrr row_offset arange_kwxs1r row_inds1 col_inds1xs2 row_inds2 col_inds2r3r3r4rs$   "" rc Cs||dks|dkr dS|dkrtd||n|}tdt|| |}t|||d\}}}||||}||} | ||fS)NrrrE)rQrr) rcrdrrrZtrapezoid_size_trilZrectangle_size_trilrZ 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) NrrrrgrrEr) rrrQrrUrrrDrmr&rr)rcrdrrr*r2r+rrr col_offsetrrrrrrrrr3r3r4r=s*   ""   r) out_int32re boundariesrrecsjtdkfddt|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) NrEcsddS)Nz2boundaries tensor must be 1 dimension but got dim(rr/r3rr3r4rDsrzbucketize..rJrr[rr)rUrVrr8rrrr`rHr&r%r2rr!rrrrXrSr)rkrrreZ out_dtypeZ n_boundariesrr midZmid_valZcond_midZ cond_updateZnitersrr3rr4r)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 rr3rr3r4rDzcauchy..rcr)Nz-cauchy_ expects sigma > 0.0, but found sigma=r3r3)sigmar3r4rDrr) rUrVr\rrrrrorr rand_like)rZmedianr 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 rr3rr3r4rDrzexponential..rcr)Nz4exponential_ expects lambda > 0.0, but found lambda=r3r3)rater3r4rDrrrrJ) rUrVr\rrrrrrrrrV)rrrZ uniform_valepsilonrZ log_uniformr3)rrr4r@s"        r@cs|dusJttj otj fddtdko%dkfddttt t  dS)Ncr)Nzgeometric not implemented for rr3rr3r4rDrzgeometric..rrEcr)Nz0geometric_ expects p to be in (0, 1), but got p=r3r3)rr3r4rDr) rUrVr\rrrrDrWrr)rrrr3)rrr4rFs    (rFrcsv|dusJttj otj otj fddtdkfddtt|S)Ncr)Nzlog_normal not implemented for rr3rr3r4rDrzlog_normal..rcr)Nz-log_normal_ expects std > 0.0, but found std=r3r3rr3r4rDr) rUrVr\rrrrr>Z randn_likerrrrr3)rrr4rZs     rZ)rr)rrr*r2r+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 r3r3rr3r4rDrznormal..css|] }t|tr|VqdSr=rrZr3r3r4rB#sznormal..cSr)NzFnormal expects that either mean or std is a tensor, or size is definedr3r3r3r3r4rD&rcSr)Nz.Cannot pass layout, or pin_memory without sizer3r3r3r3r4rD*rcsrr=rErZr3r3r4rB-rcSr)Nz>normal expects mean and std to be scalars when size is definedr3r3r3r3r4rD3rrrrF)rrrr2rr) rUstridedr8r"rVrOrGrXrr2rrr^) rrrrrr*r2r+rZnormal_samplesr3rr4r^sD     r^)rcCst|||j||dS)N)rr)r^rHrr3r3r4normal_DsrcC&tt|j ddd}||S)NcSr)Nz-rad2deg is not supported for complex tensors.r3r3r3r3r4rDMrzrad2deg..gcܥL@rUrVr\rr)rZM_180_PIr3r3r4rbI  rbcCr)NcSr)Nz-deg2rad is not supported for complex tensors.r3r3r3r3r4rDWrzdeg2rad..g9RFߑ?r)rZM_PI_180r3r3r4r9Srr9cCs|dk|Sr)r)rrr3r3r4r8]sr8csrtdko dkfddtjjkfddfdd}tk|dS)NrEcsdddS)Nz1D tensors expected, but got zD and z D tensorsr/r3r7rr3r4rDfrz_dot_check..crR)Nz:dot : expected both vectors to have same dtype, but found rrr3rr3r4rDkrTc 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)rUrVrrr)rr7rr3rr4 _dot_checkcs   rcstfdd}|S)Ncst||||Sr=)rr'rzr3r4wrapperys  z#_dot_check_wrapper..wrapper)r)r{rr3rzr4_dot_check_wrapperxsrr'cCsd|r,|r |rt||St||S|r,t||S||Sr=)r*is_conjrUrrrrr'r3r3r4rs rcCst|s t||S|r$|rt||St||S|r2t||S||Sr=)r*rUrrrrr5rr'r3r3r4rs rcCszt|j|}dg|j}d||<|dkr||j|}tj|j||jd||k}t|| |j}t |||S)NrErJrr1) r\rrMrHrUrr2rrrr)rArrr:Z mask_shaperr3r3r4select_scatters  rcCst|tjtjfSr=)r8rUZ TypedStorageZUntypedStorage)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 ') rr8r\rOrGitemsizerrTr0rqr)seq scalar_typeZMAX_DIMSZ 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 )r8rrUrrrr`rr rZcfloatdoubleZcdoubleZhalfZchalfr]rrr^ TypeErrorr0rqr\rOrGrS_infer_scalar_typeZ promote_types)rZ default_dtype scalarTyperrGZcur_itemZitem_scalarTyper3r3r4rJsH          rrrcst|tr|dkr|jddddSt|tr'|jdddSt|tr3tj|dS|}|s.) r8rrdetachrrrrUr#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 variabler3r3r3r3r4rDrz)_internal_new_from_data..F)r2rr,r)Z__cuda_array_interface__r2meta)r,r))r8rUrrVrrr2rhasattrNotImplementedrrr0r) optionsrZ device_optdatacopy_variables copy_numpytype_inferencer+rZinferred_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+) r8rUrr r  UserWarningrrZdetach_r)rrr2r+rrZ new_tensorr3r3r4rs*   r=)F)rNN)rrFrH)NN)NNNNNFF)FFN)NF)NNFr)rrJ) NNNTrFNNN)NNNTFNNF)r3)rEr))rrrE)rr rJ)rNrE)r)rr)rNF)rrENrh)rErN(rrr~rrr}r collections.abcrrenumr functoolsrrrrtypingr r r r r rrUZ torch._primsZ_primsrZtorch._prims_commonZ _prims_commonr\Ztorch.utils._pytreeZ_pytreerWrrrrrrrrrrrrrrrrrr r!r"r#r$r%Ztorch._prims_common.wrappersr&r'r(r)r*r+rrrZ DispatchKeyZ_opsrrr5r:rXrbZ torch._decomprcobjectrorwrrrwr,Z INT_TO_FLOATr-r.r0r/r1r2DEFAULTr3r4r*r5r6r7r:r;r<r=r>r?rAZ NO_OPMATHrBrCr$rDrErZ ALWAYS_BOOLrMrNrOrPrQZspecialZ multigammalnr\rRrSrUrVrWrXrYrrr[rrr_rr`rarrcrdrrerfrgrhrirjrkrmZ BOOL_TO_LONGrnrorprrr rrsrtrurvrwrxryr|r}r^r~rrrrrrrrrrOrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrzr{rrr-r%rrr*r/r0registerr2rr4r5r6r8r=rrRrZrrrZ dim_IntListZ IntList_outr\rrrrrsrrrrrrrrrrrrrrrgZpy_implZCompositeImplicitAutogradZMetarrrrrrUrrrrrrrrrrrrrrZ _subclassesZ fake_implsZregister_op_implrrr+r,rr-rrr"rrrrr+rrlrrr r rHrIrKrLr7rGrJrrrrrrrrrrrrrfrrrrrrrrrjrrrrrrrrrrrrr%rr rrrrZ start_stepZ start_outrTrrrrrrrrr&r!r"r#rrrr'r(r]rqrrrrr r rrrrCrrr)rr@rFrZr^rrbr9r8rrrrrZabs_Zacos_Zacosh_Zadd_Zaddcmul_Zaddcdiv_Zasin_Zasinh_Zatan_Zatanh_Zatan2_Z bitwise_and_Zbitwise_left_shift_Z bitwise_not_Z bitwise_or_Zbitwise_right_shift_Z bitwise_xor_Zceil_Zclamp_Z clamp_min_Z clamp_max_Zconj_physical_Z copysign_Zcos_Zcosh_Zcumsum_Zcumprod_Zdeg2rad_Zdigamma_Zdiv_Zeq_Zerf_Zerfc_Zerfinv_Zexp_Zexp2_Zexpm1_Z float_power_Zfloor_Z floor_divide_Zfmod_Zfrac_Zgcd_Zge_Zgt_Z heaviside_Zhypot_Zigamma_Zigammac_Zi0_Zlcm_Zle_Zlerp_Zlgamma_Zlog10_Zlog1p_Zlog2_Zlog_Z logical_and_Z logical_not_Z logical_or_Z logical_xor_Zlt_Zmul_Z mvlgamma_Z nan_to_num_Zne_Zneg_Z nextafter_Zpow_Zrad2deg_Z reciprocal_Z remainder_Zrsqrt_Zsgn_Zsigmoid_Zsign_Zsin_Zsinc_Zsinh_Zsqrt_Zsquare_Zsub_Ztan_Ztanh_Ztril_Ztriu_Z true_divide_Ztrunc_Zxlogy_Zcauchy_Z exponential_Z geometric_Z log_normal_Zzero_rrrrrrrrrrrrrrrrrrZtorch._refs._conversionsZtorch._refs.fftZtorch._refs.linalgZtorch._refs.nn.functionalZtorch._refs.specialr3r3r3r4s    \  0 (  "                                  "           & :              6      +     ',         +    ?  -   ;    (w T %0( "  " "  4 D  '    r   8 , / & " $&$     1 "& "  H * '   ) 8"$    &  *     $&           )    c0      X     ;" B   ?     (           " ,      & &0   0)    ) :     4      (                                                                                               3 #9 &