EiE%SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK r SSK r SSK r SSKJr SSKJrJrJrJrJr SSKJrJrJ r! S\RD4Sjr#SSK$J%r&J'r'J(r( SS K)J*r*J+r+J,r,J-r-J.r. SS K/J0r0 \(aSS K1J2r2J3r3 /S Qr4\4\5"\45:wa\6"S 5eSSK7J8r8 \8Rr"5 C8\ RS:Xa SSjr;\;"5 C;S\SS\jrsS=\S\!S?4S@jrtS=\S\RD4SAjru\ R"5qwSSBjrxSSDjrySE\SS?\<-SS4SFjrzSSGjr{SHSI.SJ\RDSK\RDSS4SLjjr|S\RD4SMjr}S\RD4SNjr~SO\R\<-SS4SPjrS\R4SQjrS\<4SRjrSS\\hGRGRGR~\hGRGRGR~\hGRGRGR\hGRGRGRS.GrC\(aSSKhGJDGrDGJEGrEGJFGrFGJGGrG O 1SkGrHSGrI\GRSSC\hGR\<-S-4Sjj5GrLSS\RS-S\RS-4SjjGrMSSKhGJNGrN G\NGR"5 SGrPS\RD4SjGrQSGrRG\Q"5(a G\P"5 gg!\:a G Nf=f!\:a< SSKJJcrd \dRc'\:"\ R"S55R55Seef=f)a The torch package contains data structures for multi-dimensional tensors and defines mathematical operations over these tensors. Additionally, it provides many utilities for efficient serialization of Tensors and arbitrary types, and other useful utilities. It has a CUDA counterpart, that enables you to run your tensor computations on an NVIDIA GPU with compute capability >= 3.0. N)Callable)Any get_originoverload TYPE_CHECKINGTypeVar) deprecated ParamSpecTypeIsreturncg)NFrK/home/mande/repo/quber/.venv/lib/python3.13/site-packages/torch/__init__.py_running_with_deployr,s r)_functionalize_sync_import_dotted_name classproperty) get_file_path#prepare_multiprocessing_environment1profiler_allow_cudagraph_cupti_lazy_reinit_cuda12USE_GLOBAL_DEPSUSE_RTLD_GLOBAL_WITH_LIBTORCH) __version__)Device IntLikeType)G BoolStorage BoolTensor ByteStorage ByteTensor CharStorage CharTensor DoubleStorage DoubleTensor FloatStorage FloatTensor GradScaler IntStorage IntTensor LongStorage LongTensor ShortStorage ShortTensorSymBoolSymFloatSymIntTensor TypedStorageUntypedStorage$are_deterministic_algorithms_enabledautocastchunkcompilecond enable_gradexportget_default_deviceget_deterministic_debug_modeget_device_moduleget_float32_matmul_precision get_rng_stateinference_mode initial_seed-is_deterministic_algorithms_warn_only_enabled is_storage is_tensoris_warn_always_enabledloadlobpcg manual_seedmatmulno_gradrandrandnsaveseedset_default_deviceset_default_tensor_typeset_deterministic_debug_modeset_float32_matmul_precisionset_printoptions set_rng_stateset_warn_alwayssplitstack sym_floatsym_fresh_sizesym_intsym_itesym_maxsym_minsym_notsym_sumtypename unravel_indexuse_deterministic_algorithmsvmapz__all__ must be kept sorted) _rocm_initwin32c  SSKnSSKJn [R"SS5n[R R [RSS5n[R R [R R[5S5n[R R URS5SS5n[R R [RS5n[R[R:wa0[R R [RSS5nOS nUUUUU4Vs/sH+n[R RU5(dM)UPM- n n[R"S U 55(dV[R R [R"S [R R US S 55SS5n OS n U(a[R "SU 55(aqUR#SS5n SU -n [R R USSSU35n [R R [R"X5S5nOS nU R%SX455 [&R("SSS9n[+US5nUR-S5n[&R.UR0lU(a[&R.UR4lU Hn[R6"U5 M [&R8"S5 [&R8"S5 [:R<"5S:wa[&R8"S5 [HRH"[R R US!55nS"nUGHnS"nU(agUR5USS#5n[&RJ"5nUc7US$:wa1[&RL"U5nU=RNS%US&3- sl'UeUbSnU(aM}U(d9S'R U [RPS(/-5[RPS('SnUR1U5nUbM[&RL"[&RJ"55nU=RNS%US&3- sl'Ue UR-U5 gs snf![>a1 [A[BRD"S 5RG55 GNf=f))Nrcuda ProgramFileszC:\Program FilesLibrarybinlibuserbasec3# UHBn[RR[RRUS55v MD g7f)znvToolsExt64_1.dllN)ospathexistsjoin.0ps r &_load_dll_libraries..s3 KTaBGGNN277<<+?@ A A9sA A NVTOOLSEXT_PATHzNVIDIA Corporation NvToolsExtx64c3# UH>n[R"[RRUS55(+v M@ g7f)z cudart64*.dllN)globrqrrrtrus rrxrys1) EN "'',,q/:; ; ;YsAA._ CUDA_PATH_VzNVIDIA GPU Computing ToolkitCUDAvc3r# UH-n[RRU5(dM)Uv M/ g7fN)rqrrrsrus rrxrys% 7!277>>!;LAA7s(7 7z kernel32.dllT)use_last_errorAddDllDirectoryrdzvcruntime140.dllz msvcp140.dllARM64zvcruntime140_1.dllz Microsoft Visual C++ Redistributable is not installed, this may lead to the DLL load failure. It can be downloaded at https://aka.ms/vs/17/release/vc_redist.x64.exe z*.dllFi~z Error loading "z" or one of its dependencies.;PATH)) sysconfig torch.versionrirqgetenvrrrtsys exec_prefixdirname__file__get_config_varbase_exec_prefixrsbuiltinsanyallreplaceextendctypesWinDLLhasattr SetErrorModec_void_p LoadLibraryWrestypeLoadLibraryExWadd_dll_directoryCDLLplatformmachineOSErrorprinttextwrapdedentstripr~get_last_errorWinErrorstrerrorenviron)r cuda_version pfiles_path py_dll_path th_dll_path usebase_pathpy_root_bin_pathbase_py_dll_pathrw dll_pathsnvtoolsext_dll_pathcuda_version_1 cuda_path_var default_path cuda_pathkernel32with_load_library_flagsprev_error_modedll_pathdlls path_patcheddll is_loadedres last_errorerrs r_load_dll_librariesrs56ii0CD ggll3??IuE ggll277??8#R2R)SBJJv&#'L++C0; //&*?*?*ABCLL*3%/LMLI/2 o.  t   %'   s (T9TAT 7UUrr lib_folderlib_namec SSKJn [R"[RR USUSU55nUbQUR S5SnU[R"[RR USSU3SU55- n[R"[RR XSU55nXF-$)Nrrhnvidiarmrcu)rrir~rqrrrtrV)rrrrrnvidia_lib_pathsmaj_cuda_version lib_pathss r_get_cuda_dep_pathsr!s 3yy  T8ZA'--c215DII GGLLx2.>-?)@% R   "'',,tIJI  ''rrequiredcr[R"5S:wa![S[R"535eSn[RHn[ X@U5nU(dMUSn O U(d%U(a[ US[R35eU(a[R"U5 gg)z9Preloads cuda library if it could not be found otherwise.Linuxz$Should only be called on Linux, got Nrz not found in the system path ) rsystemAssertionErrorrrrr ValueErrorrr)rrrlib_pathrrcandidate_lib_pathss r_preload_cuda_libr5sG#CHOODUCVWXXH1$HM  *1-H   H:%CCHH:NOO Hrrc/SQnUbFUVVs/sH/up#URSS5SURS;dM-UPM1 snn(dUeUHupE[XE5 M [SSSS9 gs snnf) N))cublaszlibcublasLt.so.*[0-9])rzlibcublas.so.*[0-9])cudnnzlibcudnn.so.*[0-9]) cuda_nvrtczlibnvrtc.so.*[0-9])rzlibnvrtc-builtins.so.*[0-9]) cuda_runtimezlibcudart.so.*[0-9]) cuda_cuptizlibcupti.so.*[0-9])cufftzlibcufft.so.*[0-9])curandzlibcurand.so.*[0-9]) nvjitlinkzlibnvJitLink.so.*[0-9])cusparsezlibcusparse.so.*[0-9]) cusparseltzlibcusparseLt.so.*[0-9])cusolverzlibcusolver.so.*[0-9])ncclzlibnccl.so.*[0-9])nvshmemzlibnvshmem_host.so.*[0-9])cufilezlibcufile.so.*[0-9]rrdrnvtxzlibnvToolsExt.so.*[0-9]F)r)rVargsr)r cuda_libsrrmrrs r_preload_cuda_depsrGs(I0 # #syya'8';sxx{'J)   !* */!*f7%H s ,A0A0c[R"5S:Xag[R"5S:XaSOSnSU3n[RR [ 5n[RR [RRU5SU5n[R"U[RS9 [S5nUR5nSSS5 S W;ag[5 g!,(df  N =f![a gf=f![a8n[U5 [R"U[RS9 SnAgSnAff=f) NWindowsDarwinz.dylibz.solibtorch_global_depsrm)modez/proc/self/mapsz libcudart.so)rrrqrrabspathrrtrrr RTLD_GLOBALopenreadr Exceptionr)lib_extrhereglobal_deps_lib_pathf_mapsrs r_load_global_depsrns I%#//+x7hUG%gY/H 77??8 $D77<<(=uhOC (v/A/AB '(A)U*  )(    C 3 (v/A/AB CsT#D D C9D . D 9 DD DDDD E$.EETORCH_USE_RTLD_GLOBALr)*c@\rSrSrSrSrSrSrSrS0Sjr S r S r S r S r S rSrS\S\R$4SjrS\R$4SjrS\R$4SjrS\R$4SjrS\R$4SjrS1SjrS1SjrS1SjrS2SjrS1SjrS1SjrS1SjrS3SjrS3Sjr S3Sjr!S3S jr"S!r#S"r$S#r%S$r&S2S%jr'S2S&jr(S1S'jr)S1S(jr*S)r+S*r,S\RZ4S+jr.S\/S\RZ44S,jr0S\RZ4S-jr1S1S.jr2S/r3g)4r0iz Like an int (including magic methods), but redirects all operations on the wrapped node. This is used in particular to symbolically record operations in the symbolic shape workflow. cXlgrnodeselfrs r__init__SymInt.__init__  rc4[R"US:g5$Nr)rboolrs r__bool__SymInt.__bool__s}}TQY''rc6URR5$rrint_r s r__int__SymInt.__int__yy~~rc6URR5$rrr s r __index__SymInt.__index__rrNcU$rr)rndigitss r __round__SymInt.__round__ rc[U[R[45(a[ U5R U5$[U[R [45(d[$URU5$r) isinstancerfloatr/rX__float_truediv__intr0NotImplemented__int_truediv__rothers r __truediv__SymInt.__truediv__sZ ehnnh7 8 8T?44U; ;%(,,!788! !##E**rc[U[R[45(a[ U5R U5$[U[R [45(d[$URU5$r) rrrr/rX__rfloat_truediv__r r0r!__rint_truediv__r#s r __rtruediv__SymInt.__rtruediv__sZ ehnnh7 8 8T?55e< <%(,,!788! !$$U++rc[U[R[45(a+[ [ R "[ U5U- 55$[U[R[45(d[$URU5$r) rrrr/rXmathfloorr r0r!__int_floordiv__r#s r __floordiv__SymInt.__floordiv__sb ehnnh7 8 8TZZ $%(?@A A%(,,!788! !$$U++rc[U[R[45(a+[ [ R "U[ U5- 55$[U[R[45(d[$URU5$r) rrrr/rXr-r.r r0r!__rint_floordiv__r#s r __rfloordiv__SymInt.__rfloordiv__sb ehnnh7 8 8TZZ $(?@A A%(,,!788! !%%e,,rcJ[U[R[45(a[ U5R U5$[U[R [45(d[$US:aURU5$[ U5R [ U55$r ) rrrr/rX__pow__r r0r!__pow_by_natural__r#s rr7SymInt.__pow__s ehnnh7 8 8T?**51 1%(,,!788! ! A:**51 1T?**9U+;< 4F4x}}44x}}44x}}44x}}44x}}44444444444444444444'B(,,B%(,,(>"?/HLL/rr0c\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS \S\R"4SjrS\R"4SjrS\R"4SjrS\R"4SjrS\R"4SjrS%SjrS%SjrS%SjrS%SjrSrSrSrSrSrS\ \RB\RB44Sjr"Sr#Sr$S r%S%S!jr&S\'4S"jr(S#r)g$)&r/iz Like a float (including magic methods), but redirects all operations on the wrapped node. This is used in particular to symbolically record operations in the symbolic shape workflow. cXlgrrrs rrSymFloat.__init__rrc[U[R[R[[ 45(d[ $UR[U55$r) rrr rr0r/r!rrXr#s rr%SymFloat.__truediv__s<%(,,!QRR! !%%i&677rc[U[R[R[[ 45(d[ $UR[U55$r) rrr rr0r/r!r(rXr#s rr*SymFloat.__rtruediv__s<%(,,!QRR! !&&y'788rc[U[R[R[[ 45(d[ $[[R"U[U5- 55$r rrr rr0r/r!rXr-r.r#s rr0SymFloat.__floordiv__sD%(,,!QRR! !D9U+;$;<==rc[U[R[R[[ 45(d[ $[[R"[U5U- 55$rrr#s rr4SymFloat.__rfloordiv__sD%(,,!QRR! !Ie$4t$;<==rc6URR5$rrbool_r s rr SymFloat.__bool__yy  rc:URRSS5$)Nror)r guard_floatr s r __float__SymFloat.__float__syy$$R++rc>UR5R5$r) __trunc__rr s rrSymFloat.__int__s~~''))rc[U[R[R[[ 45(d[ $[R"US:5 URU5$r ) rrr rr0r/r!torch_check __float_pow__r#s rr7SymFloat.__pow__sG%(,,!QRR! ! TQY!!%((rc[U[R[R[[ 45(d[ $[R"US:5 URU5$r ) rrr rr0r/r!rr__rfloat_pow__r#s rr;SymFloat.__rpow__sG%(,,!QRR! ! UaZ ""5))rr$r c[S5er?rAr#s rrCSymFloat.__eq__rErc[S5er?rAr#s rrGSymFloat.__lt__rErc[S5er?rAr#s rrJSymFloat.__gt__rErc[S5er?rAr#s rrMSymFloat.__le__rErc[S5er?rAr#s rrPSymFloat.__ge__rErc[S5er?rAr#s rrSymFloat.__float_pow__rErc[S5er?rAr#s rrSymFloat.__rfloat_pow__rErc[S5er?rAr#s rrSymFloat.__float_truediv__rErc[S5er?rAr#s rr(SymFloat.__rfloat_truediv__rErc[S5er?rAr s rrSymFloat.__trunc__rErc[S5er?rAr#s rrnSymFloat.__sym_max__rErc[S5er?rAr#s rrqSymFloat.__sym_min__rErc[S5er?rAr s r __sym_int__SymFloat.__sym_int__rErc[S5e)z'Return True if the float is an integer.r@rAr s r is_integerSymFloat.is_integers233rcJ[R"U5R5$)z.Represent this float as an exact integer ratio)rrrr s rrSymFloat.as_integer_ratios~~d#4466rc6URR5$rrr s rrSymFloat.__repr__rrc.URR$rrr s rrSymFloat._sympy_rrc@[[R"U55$r)rrrr s rrSymFloat.__hash__sHNN4())rcU$)z+Returns the complex conjugate of the float.rr s rrSymFloat.conjugates rcVURRSS5R5$)z4Returns the hexadecimal representation of the float.ror)rrhexr s rr SymFloat.hexs"yy$$R+//11rrNr)*rrrrrrr%r*r0r4r rrr7r;rrr rCrGrJrMrPrrrr(rrnrqrrrr rrrrrstrrrrrrr/r/s  8 9 > > !,* ) *4F4x}}44x}}44x}}44x}}44x}}44444444447% hll(B"C7'*2S2rr/c\rSrSrSrSrSrSrSSjrSSjr SS jr S r S\ R4S jrS rS rSrSrSrg)r.iaU Like a bool (including magic methods), but redirects all operations on the wrapped node. This is used in particular to symbolically record operations in the symbolic shape workflow. Unlike regular bools, regular boolean operators will force extra guards instead of symbolically evaluate. Use the bitwise operators instead to handle this. cXlgrrrs rrSymBool.__init__rrc6URR5$rrr s rr SymBool.__bool__ rrc^[R"URR55$r)rr rrr s rrSymBool.__int__s||DIIOO-..rr c[S5er?rAr#s rrSymBool.__and__rErc[S5er?rAr#s rrSymBool.__or__rErc[S5er?rAr s r __sym_not__SymBool.__sym_not__)rErc[S5er?rA)rthen_valelse_vals r __sym_ite__SymBool.__sym_ite__,rErc[S5er?rAr#s rrCSymBool.__eq__/rErc6URR5$rrr s rrSymBool.__repr__2rrc.URR$rrr s rrSymBool._sympy_5rrcURR5(a#[URR55$[[R "U55$r)r is_constantrrrr r s rrSymBool.__hash__8sA 99 " " )* * d+, ,rcNSSKJn U"URR55$)z~ Provides a SymFloat representation (0.0 or 1.0) for this SymBool. Called by torch.sym_float() when casting SymBool to float. r) wrap_node)torch.fx.experimental.sym_noderrrX)rrs rrtSymBool.__sym_float__?s =,,.//rrN)r r.)rrrrrrr rrrrrrr rCrrrrtrrrrr.r.sN !/44(444x}}4'-0rr.cSSKn[R"U5(a[R"[U4U5$[ US5(aUR 5$[XR5(aU)$U(+$)z\SymInt-aware utility for logical negation. Args: a (SymBool or bool): Object to negate rNr) sympy overrideshas_torch_function_unaryhandle_torch_functionr^rrrBasic)ars rr^r^Ise ))!,,..wa@@q-  }}![[!!r 5Lrc[R"U5(a[R"[U4U5$[ U[ 5(aU$[ US5(aUR5$[R"U5$)zcSymInt-aware utility for float casting. Args: a (SymInt, SymFloat, or object): Object to cast rt) rrrrXrr/rrtrrrs rrXrXZsg ))!,,..y1$BB!X O $ $  >>! rc"[R"U5(a[R"[U4U5$[ U[ 5(aU$[ U[ 5(a[R"U5$[R"U5$)zaSymInt-aware utility for int casting. Args: a (SymInt, SymFloat, or object): Object to cast ) rrrrZrr0r/r-truncrr rs rrZrZisg ))!,,..wa@@!V Ax zz!} <<?rc[R"X45(a[R"[X4X5$[ U[ [ 45(aURU5$[ U[ [ 45(aURU5$[5up#[ X5(d[SUS[U535e[ X5(d[SUS[U535e[ X5(d[ X5(a*[R"[R"X55$[R"X5$)a SymInt-aware utility for max which avoids branching on a < b. Unlike builtins.max(), this only works for int/float, and it always promotes to float if any argument is float (unlike builtins.max, which will faithfully preserve the type of the input argument). expected , got )rhas_torch_functionrr\rr0r/rn__all_and_float_typesrtyperrmaxrb all_types float_typess rr\r\xs ##QF++..wEE!fh'((}}Q A) * *}}Q34I a # #y 6$q'CDD a # #y 6$q'CDD!!!Z%?%?~~hll1011||A!!r.c<SSKnURUR[R[R 4nUR[R 4nX4$![ a6 [R[R 4n[R 4nX4$f=fr )numpyintegerfloatingrr rModuleNotFoundError)npr)r*s rr$r$s ( JJ KK LL NN ' *,hnn(E  !! (\\8>>2 ~~'  !! (sAA;BBc[R"X45(a[R"[X4X5$[ U[ [ 45(aURU5$[ U[ [ 45(aURU5$[5up#[ X5(d[SUS[U535e[ X5(d[SUS[U535e[ X5(d[ X5(a*[R"[R"X55$[R"X5$)zSymInt-aware utility for min().r!r")rr#rr]rr0r/rqr$rr%rrminr's rr]r]s##QF++..wEE!fh'((}}Q A) * *}}Q24I a # #y 6$q'CDD a # #y 6$q'CDD!!!Z%?%?~~hll1011||A!!rc^^[R"U5(a"[X5$SmUHcn[ U[ [ R45(d[ R"U5s $[ U[ 5(dMWURmMe Tc[ R"U5$SSK J mJ n U"TR[UU4SjU5555$)z N-ary add which is faster to compute for long lists than iterated binary addition. Only does something special for integers. Nr)to_noderc36># UHnT"TU5v M g7frr)rvrfoundr4s rrxsym_sum..s(IDq):):Ds)rr#rr_rr0rr sumrrr4rr)rrrr6r4s @@rr_r_s ##D))..wCC E !fhll344<<% % a FFE   }||D!!A U]]5(ID(I#IJ KKrc^^UU4SjmT$)NcB>[R"U5(a[R"TU4U5$[U[5(a[ R "U5n[USTS35(a[USTS35"5$[[T5"U5$)N__sym___) rrrrr0rrXrgetattrr-)rfnnames rr>_get_sym_math_fn..fns  - -a 0 0222tQ? ? a "A 1tfB' ( (1tfB/02 2tT"1%%rr)r?r>s`@r_get_sym_math_fnrAs& Ir)Nroro) sqrtcoscoshsinsinhtantanhasinacosatanlog2_sym_ _sym_sqrtsym_sqrtc[R"XU45(a[R"[XU4XU5$[ U[ [ R45(d[S[U535e[U5[U5La#[S[U5S[U535e[ U[ 5(aURX5$U(aU$U$)z>SymInt-aware utility for ternary operator (``t if b else f``.)zexpected SymBool or bool, got ztype mismatch: z vs ) rr#rr[rr.rr rr%r)r(trs rr[r[s##Q1I....wq 1KK a'8==1 2 2=d1gYGHH Awd1gtAwitDG9EFF!W}}Q""1qrcJ[R"U5R5$r)rtensoritem)rs rrYrY s <<  " " $$r)_initExtensiona Failed to load PyTorch C extensions: It appears that PyTorch has loaded the `torch/_C` folder of the PyTorch repository rather than the C extensions which are expected in the `torch._C` namespace. This can occur when using the `install` workflow. e.g. $ python -m pip install --no-build-isolation -v . && python -c "import torch" This error can generally be solved using the `develop` workflow $ python -m pip install --no-build-isolation -v -e . && python -c "import torch" # This should succeed or by running Python from a different directory. )_C)roNrBase> GeneratorDisableTorchFunctionDisableTorchFunctionSubclass TensorBasecvUc [5nX;agURU5 URn[U5Hzn[ X5n[ USS5n[ R "U5(dM8URU5(dMP[RRXT5 [XA5 M| g)Nrro) setaddrdirr=inspectismodule startswithrmodules setdefault _import_extension_to_sys_modules)modulememo module_namer?member member_names rrereFs <5D >  oo KDV*F!&*b9K''K,B,B;,O,O &&{;0>  robjc[U[R5(aUR5$[ USS5=(d SnSn[ US5(a UR nOS[ US5(a URnO5URR=(d SnURR nUS;aU$USU3$)a String representation of the type of an object. This function returns a fully qualified string representation of an object's type. Args: obj (object): The object whose type to represent Returns: str: the type of the object `o` Example: >>> x = torch.tensor([1, 2, 3]) >>> torch.typename(x) 'torch.LongTensor' >>> torch.typename(torch.nn.Parameter) 'torch.nn.parameter.Parameter' rrorr>rorr) rrr1r%r=rrr __class__r)rkrfqualnames rr`r`]s #u||$$xxz S, + 1rFHsN#### j ! !<<))/R==-- !!XQxj !!rz torch.Tensorc6[U[R5$)zReturns True if `obj` is a PyTorch tensor. Args: obj (object): Object to test Example:: >>> x = torch.tensor([1, 2, 3]) >>> torch.is_tensor(x) True )rrr1rks rrDrDs c5<< ((rc&[U5[;$)arReturns True if `obj` is a PyTorch storage object. Args: obj (Object): Object to test Example:: >>> import torch >>> # UntypedStorage (recommended) >>> tensor = torch.tensor([1, 2, 3]) >>> storage = tensor.untyped_storage() >>> torch.is_storage(storage) True >>> >>> # TypedStorage (legacy) >>> typed_storage = torch.TypedStorage(5, dtype=torch.float32) >>> torch.is_storage(typed_storage) True >>> >>> # regular tensor (should return False) >>> torch.is_storage(tensor) False >>> >>> # non-storage object >>> torch.is_storage([1, 2, 3]) False )r%_storage_classesrps rrCrCs6 9( ((rc  ^SSKJn SSKJm Sn[ [ U4Sj[ U"555S5nU(aURnU"U5$[[SS5nUbU"UR5$[R"S5$) z?Gets the default ``torch.Tensor`` to be allocated on ``device``r) _get_current_function_mode_stack DeviceContextc`URbU$[R"/5R$r)indexrrSdevice)rys r_get_device_with_index2get_default_device.._get_device_with_indexs( << #M<<#** *rc>[UT5$r)r)rrvs r$get_default_device..s D-8rNdevice_contextcpu) torch.overridesrttorch.utils._devicervnextfilterreversedryr=_GLOBAL_DEVICE_CONTEXTr)rtrz device_moderyrrvs @rr;r;sA1+ 8 57 8  K##%f--35EtLN!%n&;&;<< << rryc[[S5(a&[RnUbURSSS5 UcSnOSSKJn U"U5nUR 5 U[lg)aSets the default ``torch.Tensor`` to be allocated on ``device``. This does not affect factory function calls which are called with an explicit ``device`` argument. Factory calls will be performed as if they were passed ``device`` as an argument. To only temporarily change the default device instead of setting it globally, use ``with torch.device(device):`` instead. The default device is initially ``cpu``. If you set the default tensor device to another device (e.g., ``cuda``) without a device index, tensors will be allocated on whatever the current device for the device type, even after :func:`torch.cuda.set_device` is called. .. warning:: This function imposes a slight performance cost on every Python call to the torch API (not just factory functions). If this is causing problems for you, please comment on https://github.com/pytorch/pytorch/issues/92701 .. note:: This doesn't affect functions that create tensors that share the same memory as the input, like: :func:`torch.from_numpy` and :func:`torch.frombuffer` Args: device (device or string): the device to set as default Example:: >>> # xdoctest: +SKIP("requires cuda, changes global state") >>> torch.get_default_device() device(type='cpu') >>> torch.set_default_device('cuda') # current device is 0 >>> torch.get_default_device() device(type='cuda', index=0) >>> torch.set_default_device('cuda') >>> torch.cuda.set_device('cuda:1') # current device is 1 >>> torch.get_default_device() device(type='cuda', index=1) >>> torch.set_default_device('cuda:1') >>> torch.get_default_device() device(type='cuda', index=1) rNrru)rrr__exit__rrv __enter__)ryrrvs rrOrOsc^%'788/>>  %  # #D$ 5 ~5&v.  ",:)rrQcp[U[5(a [U5n[R"U5 g)aa .. warning:: This function is deprecated as of PyTorch 2.1, please use :func:`torch.set_default_dtype()` and :func:`torch.set_default_device()` as alternatives. Sets the default ``torch.Tensor`` type to floating point tensor type ``t``. This type will also be used as default floating point type for type inference in :func:`torch.tensor`. The default floating point tensor type is initially ``torch.FloatTensor``. Args: t (type or string): the floating point tensor type or its name Example:: >>> # xdoctest: +SKIP("Other tests may have changed the default type. Can we reset it?") >>> torch.tensor([1.2, 3]).dtype # initial default for floating point is torch.float32 torch.float32 >>> torch.set_default_tensor_type(torch.DoubleTensor) >>> torch.tensor([1.2, 3]).dtype # a new floating point tensor torch.float64 N)rrrrV_set_default_tensor_type)rQs rrPrPs)4!S  ""rc0[R"U5 g)ah Sets the default floating point dtype to :attr:`d`. Supports floating point dtype as inputs. Other dtypes will cause torch to raise an exception. When PyTorch is initialized its default floating point dtype is torch.float32, and the intent of set_default_dtype(torch.float64) is to facilitate NumPy-like type inference. The default floating point dtype is used to: 1. Implicitly determine the default complex dtype. When the default floating type is float16, the default complex dtype is complex32. For float32, the default complex dtype is complex64. For float64, it is complex128. For bfloat16, an exception will be raised because there is no corresponding complex type for bfloat16. 2. Infer the dtype for tensors constructed using Python floats or complex Python numbers. See examples below. 3. Determine the result of type promotion between bool and integer tensors and Python floats and complex Python numbers. Args: d (:class:`torch.dtype`): the floating point dtype to make the default. Example: >>> # xdoctest: +SKIP("Other tests may have changed the default type. Can we reset it?") >>> # initial default for floating point is torch.float32 >>> # Python floats are interpreted as float32 >>> torch.tensor([1.2, 3]).dtype torch.float32 >>> # initial default for floating point is torch.complex64 >>> # Complex Python numbers are interpreted as complex64 >>> torch.tensor([1.2, 3j]).dtype torch.complex64 >>> torch.set_default_dtype(torch.float64) >>> # Python floats are now interpreted as float64 >>> torch.tensor([1.2, 3]).dtype # a new floating point tensor torch.float64 >>> # Complex Python numbers are now interpreted as complex128 >>> torch.tensor([1.2, 3j]).dtype # a new complex tensor torch.complex128 >>> torch.set_default_dtype(torch.float16) >>> # Python floats are now interpreted as float16 >>> torch.tensor([1.2, 3]).dtype # a new floating point tensor torch.float16 >>> # Complex Python numbers are now interpreted as complex128 >>> torch.tensor([1.2, 3j]).dtype # a new complex tensor torch.complex32 N)rV_set_default_dtype)ds rset_default_dtyper.sd!rF warn_onlyrrcJSSKJs Jn Xl[R "XS9 g)aSets whether PyTorch operations must use "deterministic" algorithms. That is, algorithms which, given the same input, and when run on the same software and hardware, always produce the same output. When enabled, operations will use deterministic algorithms when available, and if only nondeterministic algorithms are available they will throw a :class:`RuntimeError` when called. .. note:: This setting alone is not always enough to make an application reproducible. Refer to :ref:`reproducibility` for more information. .. note:: :func:`torch.set_deterministic_debug_mode` offers an alternative interface for this feature. The following normally-nondeterministic operations will act deterministically when ``mode=True``: * :class:`torch.nn.Conv1d` when called on CUDA tensor * :class:`torch.nn.Conv2d` when called on CUDA tensor * :class:`torch.nn.Conv3d` when called on CUDA tensor * :class:`torch.nn.ConvTranspose1d` when called on CUDA tensor * :class:`torch.nn.ConvTranspose2d` when called on CUDA tensor * :class:`torch.nn.ConvTranspose3d` when called on CUDA tensor * :class:`torch.nn.ReplicationPad1d` when attempting to differentiate a CUDA tensor * :class:`torch.nn.ReplicationPad2d` when attempting to differentiate a CUDA tensor * :class:`torch.nn.ReplicationPad3d` when attempting to differentiate a CUDA tensor * :func:`torch.bmm` when called on sparse-dense CUDA tensors * :func:`torch.Tensor.__getitem__` when attempting to differentiate a CPU tensor and the index is a list of tensors * :func:`torch.Tensor.index_put` with ``accumulate=False`` * :func:`torch.Tensor.index_put` with ``accumulate=True`` when called on a CPU tensor * :func:`torch.Tensor.put_` with ``accumulate=True`` when called on a CPU tensor * :func:`torch.Tensor.scatter_add_` when called on a CUDA tensor * :func:`torch.gather` when called on a CUDA tensor that requires grad * :func:`torch.index_add` when called on CUDA tensor * :func:`torch.index_select` when attempting to differentiate a CUDA tensor * :func:`torch.repeat_interleave` when attempting to differentiate a CUDA tensor * :func:`torch.Tensor.index_copy` when called on a CPU or CUDA tensor * :func:`torch.Tensor.scatter` when `src` type is Tensor and called on CUDA tensor * :func:`torch.Tensor.scatter_reduce` when ``reduce='sum'`` or ``reduce='mean'`` and called on CUDA tensor The following normally-nondeterministic operations will throw a :class:`RuntimeError` when ``mode=True``: * :class:`torch.nn.AvgPool3d` when attempting to differentiate a CUDA tensor * :class:`torch.nn.AdaptiveAvgPool2d` when attempting to differentiate a CUDA tensor * :class:`torch.nn.AdaptiveAvgPool3d` when attempting to differentiate a CUDA tensor * :class:`torch.nn.MaxPool3d` when attempting to differentiate a CUDA tensor * :class:`torch.nn.AdaptiveMaxPool2d` when attempting to differentiate a CUDA tensor * :class:`torch.nn.FractionalMaxPool2d` when attempting to differentiate a CUDA tensor * :class:`torch.nn.FractionalMaxPool3d` when attempting to differentiate a CUDA tensor * :class:`torch.nn.MaxUnpool1d` * :class:`torch.nn.MaxUnpool2d` * :class:`torch.nn.MaxUnpool3d` * :func:`torch.nn.functional.interpolate` when attempting to differentiate a CUDA tensor and one of the following modes is used: - ``linear`` - ``bilinear`` - ``bicubic`` - ``trilinear`` * :class:`torch.nn.ReflectionPad1d` when attempting to differentiate a CUDA tensor * :class:`torch.nn.ReflectionPad2d` when attempting to differentiate a CUDA tensor * :class:`torch.nn.ReflectionPad3d` when attempting to differentiate a CUDA tensor * :class:`torch.nn.NLLLoss` when called on a CUDA tensor * :class:`torch.nn.CTCLoss` when attempting to differentiate a CUDA tensor * :class:`torch.nn.EmbeddingBag` when attempting to differentiate a CUDA tensor when ``mode='max'`` * :func:`torch.Tensor.put_` when ``accumulate=False`` * :func:`torch.Tensor.put_` when ``accumulate=True`` and called on a CUDA tensor * :func:`torch.histc` when called on a CUDA tensor * :func:`torch.bincount` when called on a CUDA tensor and ``weights`` tensor is given * :func:`torch.median` with indices output when called on a CUDA tensor * :func:`torch.nn.functional.grid_sample` when attempting to differentiate a CUDA tensor * :func:`torch.cumsum` when called on a CUDA tensor when dtype is floating point or complex * :func:`torch.Tensor.scatter_reduce` when ``reduce='prod'`` and called on CUDA tensor * :func:`torch.Tensor.resize_` when called with a quantized tensor In addition, several operations fill uninitialized memory when this setting is turned on and when :attr:`torch.utils.deterministic.fill_uninitialized_memory` is turned on. See the documentation for that attribute for more information. Note that deterministic operations tend to have worse performance than nondeterministic operations. When this setting is turned on, the Inductor deterministic mode is also tuned on automatically. In deterministic mode, Inductor would avoid doing on device benchmarking that affect numerics. This includes: - don't pad matmul input shapes. Without enabling deterministic mode, Inductor would do benchmarking to check if padding matmul shape is beneficial. - don't autotune templates. Inductor has templates for kernels like matmul/conv/attention. Without enabling deterministic mode, Inductor would do autotuning to pick the best configs for those templates and adopt it if it's faster than the kernel in eager mode. In deterministic mode, we pick the eager kernel. - don't autotune triton configs for reduction. Reduction numerics are very sensitive to triton configs. In deterministic mode, Inductor will use some heuristics to pick the most promising configs rather than do autotuning. - Skip autotuning for reduction in coordinate descent tuning. - Don't benchmarking for the computation/communication reordering pass - Disable the feature that dynamically scale down RBLOCK triton config for higher occupancy. .. note:: This flag does not detect or prevent nondeterministic behavior caused by calling an inplace operation on a tensor with an internal memory overlap or by giving such a tensor as the :attr:`out` argument for an operation. In these cases, multiple writes of different data may target a single memory location, and the order of writes is not guaranteed. Args: mode (:class:`bool`): If True, makes potentially nondeterministic operations switch to a deterministic algorithm or throw a runtime error. If False, allows nondeterministic operations. Keyword args: warn_only (:class:`bool`, optional): If True, operations that do not have a deterministic implementation will throw a warning instead of an error. Default: ``False`` Example:: >>> # xdoctest: +SKIP >>> torch.use_deterministic_algorithms(True) # Backward mode nondeterministic error >>> torch.nn.AvgPool3d(1)(torch.randn(3, 4, 5, 6, requires_grad=True).cuda()).sum().backward() ... RuntimeError: avg_pool3d_backward_cuda does not have a deterministic implementation... rNr)torch._inductor.config _inductorconfig deterministicrV_set_deterministic_algorithms)rrinductor_configs rrbrbcs^54$(!$$T?rc,[R"5$)zReturns True if the global deterministic flag is turned on. Refer to :func:`torch.use_deterministic_algorithms` documentation for more details. )rV_get_deterministic_algorithmsrrrr4r4  + + --rc,[R"5$)zReturns True if the global deterministic flag is set to warn only. Refer to :func:`torch.use_deterministic_algorithms` documentation for more details. )rV'_get_deterministic_algorithms_warn_onlyrrrrBrBs  5 5 77r debug_modec[U[R[45(d[ S[ U535e[U[5(a)US:XaSnO US:XaSnOUS:XaSnO[ SU35eUS:Xa[R"S 5 g US:Xa[R"S S S 9 g US:Xa[R"S 5 g [ S U35e)aSets the debug mode for deterministic operations. .. note:: This is an alternative interface for :func:`torch.use_deterministic_algorithms`. Refer to that function's documentation for details about affected operations. Args: debug_mode(str or int): If "default" or 0, don't error or warn on nondeterministic operations. If "warn" or 1, warn on nondeterministic operations. If "error" or 2, error on nondeterministic operations. z'debug_mode must be str or int, but got defaultrwarnrderrorzQinvalid value of debug_mode, expected one of `default`, `warn`, `error`, but got FTrz:invalid value of debug_mode, expected 0, 1, or 2, but got N) rrr rrBr% RuntimeErrorrVr)rs rrQrQs j8<<"5 6 6A$zBRASTUU*c""  "J 6 !J 7 "J,,6<9  Q ((/ q ((> q ((.H U  rcp[R"5(a[R"5(aggg)zReturns the current value of the debug mode for deterministic operations. Refer to :func:`torch.set_deterministic_debug_mode` documentation for more details. rdrr)rVrrrrrr<r<3s+  '')) 5 5 7 7rc,[R"5$)zReturns the current value of float32 matrix multiplication precision. Refer to :func:`torch.set_float32_matmul_precision` documentation for more details. )rV_get_float32_matmul_precisionrrrr>r>Brr precisionc0[R"U5 g)a Sets the internal precision of float32 matrix multiplications. Running float32 matrix multiplications in lower precision may significantly increase performance, and in some programs the loss of precision has a negligible impact. Supports three settings: * "highest", float32 matrix multiplications use the float32 datatype (24 mantissa bits with 23 bits explicitly stored) for internal computations. * "high", float32 matrix multiplications either use the TensorFloat32 datatype (10 mantissa bits explicitly stored) or treat each float32 number as the sum of two bfloat16 numbers (approximately 16 mantissa bits with 14 bits explicitly stored), if the appropriate fast matrix multiplication algorithms are available. Otherwise float32 matrix multiplications are computed as if the precision is "highest". See below for more information on the bfloat16 approach. * "medium", float32 matrix multiplications use the bfloat16 datatype (8 mantissa bits with 7 bits explicitly stored) for internal computations, if a fast matrix multiplication algorithm using that datatype internally is available. Otherwise float32 matrix multiplications are computed as if the precision is "high". When using "high" precision, float32 multiplications may use a bfloat16-based algorithm that is more complicated than simply truncating to some smaller number mantissa bits (e.g. 10 for TensorFloat32, 7 for bfloat16 explicitly stored). Refer to [Henry2019]_ for a complete description of this algorithm. To briefly explain here, the first step is to realize that we can perfectly encode a single float32 number as the sum of three bfloat16 numbers (because float32 has 23 mantissa bits while bfloat16 has 7 explicitly stored, and both have the same number of exponent bits). This means that the product of two float32 numbers can be exactly given by the sum of nine products of bfloat16 numbers. We can then trade accuracy for speed by dropping some of these products. The "high" precision algorithm specifically keeps only the three most significant products, which conveniently excludes all of the products involving the last 8 mantissa bits of either input. This means that we can represent our inputs as the sum of two bfloat16 numbers rather than three. Because bfloat16 fused-multiply-add (FMA) instructions are typically >10x faster than float32 ones, it's faster to do three multiplications and 2 additions with bfloat16 precision than it is to do a single multiplication with float32 precision. .. [Henry2019] http://arxiv.org/abs/1904.06376 .. note:: This does not change the output dtype of float32 matrix multiplications, it controls how the internal computation of the matrix multiplication is performed. .. note:: This does not change the precision of convolution operations. Other flags, like `torch.backends.cudnn.allow_tf32`, may control the precision of convolution operations. .. note:: This flag currently only affects one native device type: CUDA. If "high" or "medium" are set then the TensorFloat32 datatype will be used when computing float32 matrix multiplications, equivalent to setting `torch.backends.cuda.matmul.allow_tf32 = True`. When "highest" (the default) is set then the float32 datatype is used for internal computations, equivalent to setting `torch.backends.cuda.matmul.allow_tf32 = False`. Args: precision(str): can be set to "highest" (default), "high", or "medium" (see above). N)rV_set_float32_matmul_precision)rs rrRrRIs~$$Y/rr(c0[R"U5 g)axWhen this flag is False (default) then some PyTorch warnings may only appear once per process. This helps avoid excessive warning information. Setting it to True causes these warnings to always appear, which may be helpful when debugging. Args: b (:class:`bool`): If True, force warnings to always be emitted If False, set to the default behaviour N)rV_set_warnAlways)r(s rrUrUsqrc,[R"5$)zReturns True if the global warn_always flag is turned on. Refer to :func:`torch.set_warn_always` documentation for more details. )rV_get_warnAlwaysrrrrErEs    rr8messagec[U[R[45(d[ S[ U535eSSKJn U"U5(ag[U[5(a[U[5(a[SU35eUcSnO+[U5(d [ S5e[U"55nU"U5e)Nzcond must be a bool, but got r) expect_truez@error_type must be a subclass of Exception but not Warning, got zExpected cond to be True, but got False. (Could this error message be improved? If so, please report an enhancement request to PyTorch.)zmessage must be a callable)rrr r.rBr%%torch.fx.experimental.symbolic_shapesr issubclassrWarningrcallabler) error_typer8rrmessage_evaluateds r _check_withrs dX]]G4 5 57T |DEEA4 j) , , :w0O0ONzl [      89 9 N & ''rc$[[X5 g)aThrows error containing an optional message if the specified condition is False. Error type: ``RuntimeError`` C++ equivalent: ``TORCH_CHECK`` Args: cond (:class:`bool`): If False, throw error message (Callable, optional): Callable that returns either a string or an object that has a ``__str__()`` method to be used as the error message. Default: ``None`` N)rrr8rs rrrs d,rz{_check_is_size will be removed in a future PyTorch release along with guard_size_oblivious. Use _check(i >= 0) instead.)category)r&c~[US:U5 SSKJn U"U5 Ub[X:*U5 SSKJn U"X5 gg)aGChecks that a given integer is a valid size (i.e., is non-negative). You should use this over ``_check(i >= 0)`` because it can prevent ``GuardOnDataDependentSymNode`` exceptions by opting yourself into alternate semantics for ``guard_size_oblivious`` tests that treat values 0 and 1 equivalently to all other values. When max is not None, this specifies an upper bound equivalent to ``_check(i <= max)``. This bound is also subject to alternate semantics: in ``guard_size_oblivious`` tests, we assume that a constant max bound is treated equivalently to all other values. Symbolic max bounds are not yet supported. NB: Do NOT use this in contexts where a -1 size would be valid (indicating to infer the size from context, or if you should wrap-around or truncate). Only use this if the only valid value is an honest to goodness size. r)_advise_is_sizeN)_advise_is_bounded)rrrr)irr&rrs r_check_is_sizers>. 167EA qx!L1" rc$[[X5 g)aThrows error containing an optional message if the specified condition is False. Error type: ``IndexError`` C++ equivalent: ``TORCH_CHECK_INDEX`` Args: cond (:class:`bool`): If False, throw error message (Callable, optional): Callable that returns either a string or an object that has a ``__str__()`` method to be used as the error message. Default: ``None`` N)r IndexErrorrs r _check_indexr D*rc$[[X5 g)aThrows error containing an optional message if the specified condition is False. Error type: ``ValueError`` C++ equivalent: ``TORCH_CHECK_VALUE`` Args: cond (:class:`bool`): If False, throw error message (Callable, optional): Callable that returns either a string or an object that has a ``__str__()`` method to be used as the error message. Default: ``None`` N)rrrs r _check_valuerrrc$[[X5 g)aThrows error containing an optional message if the specified condition is False. Error type: ``TypeError`` C++ equivalent: ``TORCH_CHECK_TYPE`` Args: cond (:class:`bool`): If False, throw error message (Callable, optional): Callable that returns either a string or an object that has a ``__str__()`` method to be used as the error message. Default: ``None`` N)rrBrs r _check_typer$s 4)rc&[[UU5 g)aThrows error containing an optional message if the specified condition is False. Error type: ``NotImplementedError`` C++ equivalent: ``TORCH_CHECK_NOT_IMPLEMENTED`` Args: cond (:class:`bool`): If False, throw error message (Callable, optional): Callable that returns either a string or an object that has a ``__str__()`` method to be used as the error message. Default: ``None`` N)rNotImplementedErrorrs r_check_not_implementedr6s  rc[U5(d[S[U535eUR[R :Xd[SUR35e[ XR"5R5U5 g)Nzcond must be a tensor, but got z0cond tensor must have dtype torch.bool, but got ) rDrBr%dtyperr r _is_all_truerT)rr8rs r_check_tensor_all_withrMse T??9$t*FGG :: #J4::,WXX --/446@rc$[[X5 g)aThrows error containing an optional message if the specified condition is False. Error type: ``RuntimeError`` C++ equivalent: ``TORCH_CHECK_TENSOR_ALL`` Args: cond (:class:`torch.Tensor`): Tensor of dtype ``torch.bool``. If any element is ``False``, throw error message (Callable, optional): Callable that returns either a string or an object that has a ``__str__()`` method to be used as the error message. Default: ``None`` N)rrrs r_check_tensor_allrXs <7r)einfnanpinewaxis)rrrrr)r1)storage)_LegacyStorage _StorageBase_warn_typed_storage_removalr2r3c4\rSrSr\S5r\S5rSrg)ric,[SS9 UR$N stacklevelr_dtyper s rrByteStorage.dtype#q1{{rc"[R$r)ruint8r s rrByteStorage._dtype {{rrNrrrrrrrrrrrrr(rrc4\rSrSr\S5r\S5rSrg)r#ic,[SS9 UR$rrr s rrDoubleStorage.dtyperrc"[R$r)rdoubler s rrDoubleStorage._dtype ||rrNrrrrr#r#(rr#c4\rSrSr\S5r\S5rSrg)r%ic,[SS9 UR$rrr s rrFloatStorage.dtyperrc"[R$r)rrr s rrFloatStorage._dtyperrrNrrrrr%r%rrr%c4\rSrSr\S5r\S5rSrg) HalfStorageic,[SS9 UR$rrr s rrHalfStorage.dtyperrc"[R$r)rhalfr s rrHalfStorage._dtype zzrrNrrrrrr(rrc4\rSrSr\S5r\S5rSrg)r*ic,[SS9 UR$rrr s rrLongStorage.dtyperrc"[R$r)rlongr s rrLongStorage._dtyperrrNrrrrr*r*rrr*c4\rSrSr\S5r\S5rSrg)r(ic,[SS9 UR$rrr s rrIntStorage.dtyperrc"[R$r)rr r s rrIntStorage._dtypes yyrrNrrrrr(r(s(rr(c4\rSrSr\S5r\S5rSrg)r,ic,[SS9 UR$rrr s rrShortStorage.dtyperrc"[R$r)rshortr s rrShortStorage._dtyperrrNrrrrr,r,rrr,c4\rSrSr\S5r\S5rSrg)r!ic,[SS9 UR$rrr s rrCharStorage.dtyperrc"[R$r)rint8r s rrCharStorage._dtyperrrNrrrrr!r!rrr!c4\rSrSr\S5r\S5rSrg)ric,[SS9 UR$rrr s rrBoolStorage.dtyperrc"[R$r)rr r s rrBoolStorage._dtyperrrNrrrrrrrrrc4\rSrSr\S5r\S5rSrg)BFloat16Storageic,[SS9 UR$rrr s rrBFloat16Storage.dtyperrc"[R$r)rbfloat16r s rrBFloat16Storage._dtype ~~rrNrrrrrr(rrc4\rSrSr\S5r\S5rSrg)ComplexDoubleStorageic,[SS9 UR$rrr s rrComplexDoubleStorage.dtyperrc"[R$r)rcdoubler s rrComplexDoubleStorage._dtypes }}rrNrrrrr(r(s(rr(c4\rSrSr\S5r\S5rSrg)ComplexFloatStorageic,[SS9 UR$rrr s rrComplexFloatStorage.dtyperrc"[R$r)rcfloatr s rrComplexFloatStorage._dtype rrrNrrrrr/r/rrr/c4\rSrSr\S5r\S5rSrg) QUInt8Storageic,[SS9 UR$rrr s rrQUInt8Storage.dtyperrc"[R$r)rquint8r s rrQUInt8Storage._dtyperrrNrrrrr6r6rrr6c4\rSrSr\S5r\S5rSrg) QInt8Storageic,[SS9 UR$rrr s rrQInt8Storage.dtyperrc"[R$r)rqint8r s rrQInt8Storage._dtype rrrNrrrrr=r=rrr=c4\rSrSr\S5r\S5rSrg) QInt32Storagei%c,[SS9 UR$rrr s rrQInt32Storage.dtype&rrc"[R$r)rqint32r s rrQInt32Storage._dtype+rrrNrrrrrDrD%rrrDc4\rSrSr\S5r\S5rSrg)QUInt4x2Storagei0c,[SS9 UR$rrr s rrQUInt4x2Storage.dtype1rrc"[R$r)rquint4x2r s rrQUInt4x2Storage._dtype6r%rrNrrrrrKrK0r&rrKc4\rSrSr\S5r\S5rSrg)QUInt2x4Storagei;c,[SS9 UR$rrr s rrQUInt2x4Storage.dtype<rrc"[R$r)rquint2x4r s rrQUInt2x4Storage._dtypeAr%rrNrrrrrRrR;r&rrRrr_tensor_classes)amprandom serialization)rS)r5r')r?rArHrNrT)rFrMc[R"5S:Xag[SSS5n[[S55 [R R U5(d[SU-5eURS5$)Nrrrrltorch_shm_managerz$Unable to find torch_shm_manager at zutf-8) rrrrrqrrrsrencode)rrs r _manager_pathr_mscI% %)< =D' g(>? 77>>$  ADHII ;;w r) unique_dimr<segment_reducec## UH6n[[[U5[R5(dM2Uv M8 g7fr)rr=rr)rvr?s rrxrxs)T:geT.BEKK#PDDZs 1A A)_disable_dynamo)_VF functionalc[U5[RLa9[R"U45(a[R "[ U4X5$U(d [U5eg)zAA wrapper around Python's assert which is symbolically traceable.N)r%rr1rr#r_assertr) conditionrs rrgrgs\ Iell*y/K/K  00.. i\9   W%% r)r9r@rJset_grad_enabled) __config__ __future___awaits acceleratorautogradbackendsrri distributed distributionsfftfutureshubjitlinalgmpsmtiamultiprocessingnestednnoptimrprofilersparsespecialtestingtypesutilsversionxpu)windows)ao) _size_docs _storage_docs _tensor_docs _torch_docscg)z?Returns whether PyTorch was built with _GLIBCXX_USE_CXX11_ABI=1Trrrrcompiled_with_cxx11_abir s r)_library_ops)ops)classesz.opsz.classes) quantization) quasirandom)register_after_fork)rG)masked)_symeigeiglstsq matrix_ranksolve) from_dlpack to_dlpackch\rSrSrSrSrSrS\S-4SjrS\ \\ 4S-4S jr S r S r S rS rg)_TorchCompileInductorWrapperiU inductorcSSKJn 0UlX0lUR U5 UR U5 UR UR S55 Sn[[S5(a'SSK J n U"[[RSS55nURRSS 5(aDU(aUS :d[5(d'S [R S 'S [R S'ggg)NrCompilerBisectorrr) TorchVersionriz0.0triton.cudagraphsFz12.61DISABLE_CUPTI_LAZY_REINIT0TEARDOWN_CUPTI)!torch._inductor.compiler_bisectorrrdynamic apply_mode apply_optionsget_config_changerrtorch.torch_versionrr=rgetrrqr)rroptionsrrrrs rr%_TorchCompileInductorWrapper.__init__X sF')    7# +==jIJ 5) $ $ 8' vu(MNL ;;??. 6 6 lV3DFF69BJJ2 3 ,/BJJ' (G 7rc[U[5=(a9 URUR:H=(a URUR:H$r)rrrrr#s rrC#_TorchCompileInductorWrapper.__eq__r s< u: ; . u||+ .  - rrNcpU(a/US:wa(SSKJn URU"XR55 ggg)Nrr)list_mode_options)torch._inductorrrr)rrrs rr'_TorchCompileInductorWrapper.apply_modey s. DI% 9   0||D E&4rrc U(dgSSKJn UR5nUR5HupEUR SS5nXc;a([ SUS[ UR5535eURU5n[U5cP[XW5(d@[U5Rn[X65Rn [ SUSUS U 35eXPRU'M g) Nrr-rzUnexpected optimization option z, known options are zUnexpected type of attr r"z should be ) rrget_config_copyitemsrrlistkeysget_type _get_originrr%r) rrrcurrent_configkeyval attr_name attr_type val_type_strexpected_type_strs rr*_TorchCompileInductorWrapper.apply_options s **0*@*@*B HC C-I."5cU:NtTbTgTgTiOjNkl 2I9%-!#11#'9#5#5L(,^-F(G(P(P%&23%vl^;WhVij&)KK "#(rc0SSKJn U"XURS9$)Nr) compile_fxconfig_patches)torch._inductor.compile_fxrr)rmodel_inputs_rs r__call__%_TorchCompileInductorWrapper.__call__ s9&$++FFrc.SSKJn U"URS9$)Nr)get_patched_config_dictr)rrr)rrs rget_compiler_config0_TorchCompileInductorWrapper.get_compiler_config sF&dkkBBrcSSKJn SUR;dURR(a0URR SS5(aSSKJn U"5 ggg)NrrrT)reset_cudagraph_trees)rrtriton cudagraphsrtorch._inductor.cudagraph_treesr)rrrs rreset"_TorchCompileInductorWrapper.reset sG* $++ -1I1I{{2D99Q%':2Jr)rr)rrrr compiler_namerrCrrdict_AnyrrrrrrrrrrU sMM/4 FsTzF )T#t)_t%;)6G C (rrc8^\rSrSrSrU4SjrU4SjrSrU=r$)_TorchCompileAOTInductorWrapperi aotinductorcr>[TU]XU5 URSS05 URSS05 g)N cpp_wrapperTzaot_inductor.package)superrr)rrrrrms rr(_TorchCompileAOTInductorWrapper.__init__ s9 0 M401 2D9:rc>SSKJn SSKJn SSKJn SSKJn U"U5nU(aURRUSS5OU"5nURS5 U [RRRSS5 [T U]=X5sSSS5 sSSS5 sSSS5 $!,(df  O=fSSS5 O!,(df  O=fSSS5 g!,(df  g=f) Nr) nullcontext)mock)detect_fake_mode)Vallow_non_fake_inputsTenable_autograd_for_aot) contextlibrunittestr torch._guardsrtorch._inductor.virtualizedrpatchrset_aot_compilationrrrrr) rrrrrrr fake_modectxrms rr(_TorchCompileAOTInductorWrapper.__call__ s*!21$W-  JJ  i)@$ G  ! !$ '  OO " " ( ()BD I7#F4 J I C ( ' I I I CC ( ' 'sBC,!+C B7 C$ C,7 C C C, C C,, C:r) rrrrrrrr __classcell__)rms@rrr s!M; 55rrc,\rSrSrSrSrSrSrSrg)_TorchCompileWrapperi cDSSKJn [U[5(aXlO3[ US5(aUR UlO[U5UlX@lU"U5Ul0Ul U(aUS:waX RS'U(aX0RS'gg)Nr)lookup_backendrrrr) torch._dynamo.backends.registryrrrrrrr compiler_fnkwargs)rbackendrrrrs rr_TorchCompileWrapper.__init__ sB gs # #!(  Wj ) )!(!1!1D !$WD  )'2 DI%"&KK  %,KK " rc[U[5=(aY URUR:H=(a9 URUR:H=(a URUR:H$r)rrrrrr#s rrC_TorchCompileWrapper.__eq__ sW u2 3 .  E$5$55 . u||+ .  -  rc<UR"X40URD6$r)rr)rrrs rr_TorchCompileWrapper.__call__ s?4;;??rcp[URS5(aURR5 gg)Nr)rrrr s rr_TorchCompileWrapper.reset s, 4##W - -    " " $ .r)rrrrN) rrrrrrCrrrrrrrr s-$ @%rr_InputT_RetTr fullgraphrrrrdisablemodelr rrrr cgrrr r rrrrr s rr7r7 s!$rcgrrr s rr7r7 s ILrc"^^^^^^SSKn[R"S5 [RS:a [ S5eUR S5S:Xa[RS:a [ S 5eUc5S [[[4S [[[44UUUUUU4S jjnU$TbTb [ S 5eTcTcSmSSK J n U R5=n (aASSK Js Jn U R R"(aU S:Xa[%T[&5(aU mSn Sn T(a9[%T[(5(a$TR+SS5n TR+SS5n [,R.R15(a)SSKJn U"5(d[6R8"SSS9 U$TS:Xa#U (a[;TTT5mO[=TTT5mO[?TTTT5m[,R@RCTTTTU S9"U5$)a Optimizes given model/function using TorchDynamo and specified backend. If you are compiling an :class:`torch.nn.Module`, you can also use :meth:`torch.nn.Module.compile` to compile the module inplace without changing its structure. Concretely, for every frame executed within the compiled region, we will attempt to compile it and cache the compiled result on the code object for future use. A single frame may be compiled multiple times if previous compiled results are not applicable for subsequent calls (this is called a "guard failure"), you can use TORCH_LOGS=guards to debug these situations. Multiple compiled results can be associated with a frame up to ``torch._dynamo.config.recompile_limit``, which defaults to 8; at which point we will fall back to eager. Note that compile caches are per *code object*, not frame; if you dynamically create multiple copies of a function, they will all share the same code cache. Args: model (Callable or None): Module/function to optimize fullgraph (bool): If False (default), torch.compile attempts to discover compilable regions in the function that it will optimize. If True, then we require that the entire function be capturable into a single graph. If this is not possible (that is, if there are graph breaks), then this will raise an error. This also opts into unbacked semantics, notably it will turn on capture_scalar_outputs and capture_dynamic_output_shape_ops on by default. dynamic (bool or None): Use dynamic shape tracing. When this is True, we will up-front attempt to generate a kernel that is as dynamic as possible to avoid recompilations when sizes change. This may not always work as some operations/optimizations will force specialization; use TORCH_LOGS=dynamic to debug overspecialization. When this is False, we will NEVER generate dynamic kernels, we will always specialize. By default (None), we automatically detect if dynamism has occurred and compile a more dynamic kernel upon recompile. backend (str or Callable): backend to be used - "inductor" is the default backend, which is a good balance between performance and overhead - Non experimental in-tree backends can be seen with `torch._dynamo.list_backends()` - Experimental or debug in-tree backends can be seen with `torch._dynamo.list_backends(None)` - To register an out-of-tree custom backend: https://docs.pytorch.org/docs/main/user_guide/torch_compiler/torch.compiler_custom_backends.html#registering-custom-backends mode (str): Can be either "default", "reduce-overhead", "max-autotune" or "max-autotune-no-cudagraphs" - "default" is the default mode, which is a good balance between performance and overhead - "reduce-overhead" is a mode that reduces the overhead of python with CUDA graphs, useful for small batches. Reduction of overhead can come at the cost of more memory usage, as we will cache the workspace memory required for the invocation so that we do not have to reallocate it on subsequent runs. Reduction of overhead is not guaranteed to work; today, we only reduce overhead for CUDA only graphs which do not mutate inputs. There are other circumstances where CUDA graphs are not applicable; use TORCH_LOGS=perf_hints to debug. - "max-autotune" is a mode that leverages Triton or template based matrix multiplications on supported devices and Triton based convolutions on GPU. It enables CUDA graphs by default on GPU. - "max-autotune-no-cudagraphs" is a mode similar to "max-autotune" but without CUDA graphs - To see the exact configs that each mode sets you can call `torch._inductor.list_mode_options()` options (dict): A dictionary of options to pass to the backend. Some notable ones to try out are - `epilogue_fusion` which fuses pointwise ops into templates. Requires `max_autotune` to also be set - `max_autotune` which will profile to pick the best matmul configuration - `fallback_random` which is useful when debugging accuracy issues - `shape_padding` which pads matrix shapes to better align loads on GPUs especially for tensor cores - `triton.cudagraphs` which will reduce the overhead of python with CUDA graphs - `trace.enabled` which is the most useful debugging flag to turn on - `trace.graph_diagram` which will show you a picture of your graph after fusion - `guard_filter_fn` that controls which dynamo guards are saved with compilations. This is an unsafe feature and there is no backward compatibility guarantee provided for dynamo guards as data types. For stable helper functions to use, see the documentations in `torch.compiler`, for example: - `torch.compiler.skip_guard_on_inbuilt_nn_modules_unsafe` - `torch.compiler.skip_guard_on_all_nn_modules_unsafe` - `torch.compiler.keep_tensor_guards_unsafe` - For inductor you can see the full list of configs that it supports by calling `torch._inductor.list_options()` disable (bool): Turn torch.compile() into a no-op for testing Example:: @torch.compile(options={"triton.cudagraphs": True}, fullgraph=True) def foo(x): return torch.sin(x) + torch.cos(x) rNz torch.compile)rz.torch.compile is not supported on Python 3.15+Py_GIL_DISABLEDrd)r rzetorch.compile is not supported on Python < 3.13.3 built with GIL disabled. Please use Python 3.13.3+.r r c >>Uc [S5e[UTTTTTTS9$)NzModel can't be Noner)rr7)r rr rr rrs rr>compile..fn s6}"#899# rzVEither mode or options can be specified, but both can't be specified at the same time.rrrFguard_filter_fnuse_aoti)_in_hop_compilez?torch.compile is ignored when called inside torch.export regionrr)rnopythonrr r)"rrV_log_api_usage_oncer version_inforr _Callablerrrr get_backendrrr test_configs'bisect_keep_custom_backend_for_inductorrrrpoprcompiler is_exportingtorch._higher_order_ops.utilsrwarningsrrrr_dynamooptimize)r r rrrrr rr>rbisect_backendrrrrs `````` rr7r7 sV?+ 7"KLL  ! !"3 4 9c>N>NR?  )   } i/ Igun4M    G/ d   |B)5577~788  ( ( P P*,w,,$GOH:gt,,!++&7>;;z51 ~~""$$A  MMQ  L* 5dGWMG24'JG&wgwG == ! !' "     rc 4[R"U5Rn[R[ n[ X 5(a[SUS[X 5S35e[X U5 SR[ U/5nU[RU'g)zRegister an external runtime module of the specific :attr:`device_type` supported by torch. After the :attr:`module` is registered correctly, the user can refer the external runtime module as part of torch with attribute torch.xxx. zThe runtime module of 'z$' has already been registered with ''rN) rryr%rrcrrrr=setattrrt) device_typerfmtorch_module_names r_register_device_moduler- s,,{+00K HAq%k]3%%,Q%<$=Q @   AF#(K!89%+CKK!"r)r:funclibrary return_types)r8 while_loop)rc _c10d_init)_meta_registrationsTORCH_CUDA_SANITIZER)fx)r c\rSrSr%\R R SS5r0r\ \ \ \ 4\ 4\ S'\S5rSrg)_TritonLibraryi rDEF ops_tablecX4UR;aIURRU5 URRSU-X45 X0RX4'URX4$)Nztriton::)r9rmdefineimpl)clsop_key full_schemaop_impl dispatch_keys r registerOp_TritonLibrary.registerOp sY  ! 6 GGNN; ' GGLLf,g D4;MM60 1}}f344rrN)rrrrrr/rkrmr9rrrr__annotations__ classmethodrBrrrrr7r7 sF --  % 0C24ItE#s(OY./455rr7)has_mpshas_cuda has_cudnn has_mkldnn)r$r _subclassesonnx>rKr$_exportrc "[RU5nUb:SSKnUR"SUSURSUR S3SS9 U"5$U[ ;a[R"SU3[ 5$[S[ S US35e) Nrr(z' is deprecated, please use 'rz()'rrzmodule 'z' has no attribute ') _deprecated_attrsrr#rrr _lazy_modules importlib import_moduleAttributeError)r? replacementr#s r __getattr__rT1 s'++D1  "  MMD66{7M7M6NaP[PdPdOeehi =  = **Qtf:x@ @xz1EdV1MNNrc[U[R5(a URnOq[U[5(a![R"U5RnO;Uc)[R R 5RnO[SUS35e[[US5nUc[SUSUS35eU$)z Returns the module associated with a given device(e.g., torch.device('cuda'), "mtia:0", "xpu", ...). If no device is given, return the module for the current accelerator or CPU if none is present. NzInvalid value of device 'z$', expect torch.device, str, or NonezDevice 'z<' does not have a corresponding module registered as 'torch.z'.) rrryr%rrV_get_acceleratorrr=)rydevice_module_name device_modules rr=r=D s &%,,''#[[ FC "\\&166 "XX668=='x/S T  E#5t= 2 (when we do a size-oblivious guard). This makes it easier to use the unbacked int in size contexts, as we will often attempt to guard on a size being zero/one (e.g., when computing the contiguity of a tensor, or testing if broadcasting can occur), which will not work on unbacked SymInts. However, if we conservatively assume that the size is not zero/one, we will end up with a graph that will still work even if the size is zero/one. For more details, see https://docs.google.com/document/d/1HSuTTVvYH1pTew89Rtpeu84Ht3nQEFTYhAX3Ypa_xJs/edit ``` )r2r&N)rsym_constrain_range_for_size)symbolr2r&s r_constrain_as_sizer\] s. &&vC@r)_loggingcSSKJn SnU"US9nUHnUR5nU"5 M g![an[ SUR S35UeSnAff=f)z Leverage the Python plugin mechanism to load out-of-the-tree device extensions. See this RFC: https://github.com/pytorch/pytorch/issues/122468 r) entry_pointsztorch.backends)groupz&Failed to load the backend extension: zN. You can disable extension auto-loading with TORCH_DEVICE_BACKEND_AUTOLOAD=0.N)importlib.metadatar_rFrrr?)r_ group_namebackend_extensionsbackend_extension entrypointrs r_import_device_backendsrf} sz 0!J%J7/ *//1J L 0  89J9O9O8PQ_`  s1 AAAc6[R"SS5S:H$)a> Whether autoloading out-of-the-tree device extensions is enabled. The switch depends on the value of the environment variable `TORCH_DEVICE_BACKEND_AUTOLOAD`. Returns: bool: Whether to enable autoloading the extensions. Enabled by default. Examples: >>> torch._is_device_backend_autoload_enabled() True TORCH_DEVICE_BACKEND_AUTOLOADr)rqrrrr#_is_device_backend_autoload_enabledri s 994c :c AArc [U5nU[RLa$[R"U[R SS9$U[R La$[R"U[RSS9$[R"U5$)z Like torch.as_tensor, but when given Python data types it will keep them in full precision. Used for calling convention for Dynamo. Python scalars (float, int) are always created on CPU to avoid being affected by DeviceContext. r)rry)r%rrr as_tensorfloat64r int64)rQtys r_as_tensor_fullprecro sb aB X^^q eDD x|| q EBBq!!r)r N)Tr)r z torch.device)ryrr N)rz torch.dtyper N)NN(Srrr functoolsr~rPr`r-rqrrr threadingr#collections.abcrrtypingrrrrr _overloadrr_TypeVartyping_extensionsr _deprecatedr _ParamSpecr _TypeIsr r torch._utilsr_syncrrtorch._utils_internalrrrrrrr torch.typesrr__all__sortedrrore initialize ImportErrorrrrrrrrrrrgetdlopenflags old_flagssetdlopenflagsr RTLD_LAZYtorch._Cr0r/r.r^rXrZr\rr%r$r]r_rA__fn__name __sym_namerrglobalsrOappendr[rYrUrV_C_for_compiled_checkrrrr__objr_endswithr=risclassrdelattrrcrer`rDrClocalrr;rOrPrrbr4rBr rQr<r>rRrUrErr FutureWarningrrrrrrrrrrrrrDr torch._tensorr1r torch.storagerrrr2r3rr#r%rr*r(r,r!rrr(r/r6r=rDrKrRrrr]rXrYrZr[torch._tensor_strrS torch.ampr5r' torch.randomr?rArHrNrTtorch.serializationrFrMr_torch._C._VariableFunctionsra_segment_reduce PRIVATE_OPS_VariableFunctionsrbtorch._compilercrdretorch.functionalrgtorch.autogradr9r@rJrirjrkrlrmrnrorrirprqrrrsrtrurvrwrxryrzr{r|rr}r~rrrrrr torch.signalrrtorch.nn.intrinsic torch.nn.qattorch.nn.quantizabletorch.nn.quantized _init_namesrrrrrrr torch._opsrtorch._classesrrdrrcontiguous_formatlegacy_contiguous_formattorch.multiprocessing._atforkrget_num_threads torch._lobpcgrGatenquantized_lstm quantized_grurtorch._linalg_utilsrsymeigrrrrtorch.utils.dlpackrrrrrrrrr7r-r:r.r/r0torch._higher_order_opsr8r1 torch.funcrcr%torch.distributed._meta_registrationsr3coll_meta_registrationsrtorch.cuda._sanitizer _sanitizercsanenable_cuda_sanitizerrr5_initr r7is_builtr is_availablemkldnnrNr$rrJrKrOrTcacheryr=r\r] _init_logsrfrirorrrrs    1hmm ;/H V fWo 6 77<<7u/n(c(s(c(d3i((#PT$#IGdN#Id#IN"CJ"RYY/F%G%G OO"$""$Ir~~ 45y!BBJw2w2tJ0J0Z"  ":"uU49%5uT3Y7G%GH"$"*L. (fj F!J F #D(22D  GIj! & &*. 9[ !z %  '2 "gF ayC 7 7vF# E??gooe448+" (0E$ ,5 <  H%v." E ?%R(( "$ "c "F )4 )w~6 ))D) )<#*B;;|#tN3c9##>2p %R@ --R@}}R@ R@j.hmm.8x}}8) X\\C-?) D) X hll .c.?0C?0D?0D x}} D     ( --' ! (r3w  (F-$ !  #4#  #>+$+$*$.A82! 34 !%.N>..>..n>.N>Nnn'>#d<.89:..1UT.)*2ON.*VV* -/" .%O  "''(F &K"7 B))6 2EE !!! &vGIf   S ! !v) E  Z+7  &*@, t$%&GF}j 54"!-- (4(#. (8,g6/- ->=E))*+* ((&& #65V(V(r5&B5: % %F Y   %$()PT" $ We^ $ $}} $]]T ! $ 9_ $ * $#sX\\)HMM9IEE F M $]] $w~ $  $  L %$()PT" L  L}} L]]T ! L 9_ L * L#sX\\)HMM9IEE F M L]] L '5.)*Igun,EEF L  L/3@  %$()PT"@ We^ $t +@ }}@ ]]T ! @ 9_ @ * @ #sX\\)HMM9IEE F M@ ]]@ y%()9We^+DDE @ F,( KJ##uxx&&OO #)RZZ'(( && 5 5 ~~!!**##,,%%22..''44 MO& ellS0474 $#A  A  A4 .BX]]B" "&'(()wX  j ,%%- OO  eg    ) s-q;r;rrAs