a €þdøÛã@sÖ UdZddlZddlZddlZddlZddlZddlZddlZejdkrPe dƒ‚ddl m Z m Z ddl mZmZmZmZejdkrˆd Zn dd lmZdd lmZmZmZmZmZmZmZmZddlZgd ¢Zejd kr¤e  dd¡Z!ej" #ej$dd¡Z%ej" #ej" &e'¡d¡Z(ej$ej)kr.ej" #ej)dd¡Z*ndZ*e+e,ej"j-e(e%e*gƒƒZ.e/dd„e.Dƒƒr„ej" #e  dej" #e!dd¡¡dd¡Z0ndZ0ddl1m2Z3ddl4Z4e3røe/dd„e.Dƒƒrøe3 5dd¡Z6de6Z7ej" #e!dd d!e3¡Z8ej" #e  e7e8¡d¡Z9ndZ9e. :e,ej"j-e0e9gƒ¡ej;d"d#d$Ze< ?d¡Z@ejAerPejAer.e< DeLdd,¡ZNe O¡ZPeNdur ePd-kr e QeP¡ZReRjSd.eL›d/7_SeR‚neNdur.d#ZMeMsÂeKsZd0 #e.ejTd1g¡ejTd1<d#ZKe< BeL¡ZNeNdurÂe Qe O¡¡ZReRjSd.eL›d/7_SeR‚qÂe< ?e@¡d2d3„ZUd4d5„ZVesÆe  d6¡rejdksàe W¡d7kre X¡ZYe Zej[ej\B¡dd8l]Te ZeY¡[YnereVƒdd8l]Ter6ddl]m^Z^Gd9d:„d:ƒZ_Gd;d<„d<ƒZ`Gd=d>„d>ƒZad?d@„ZbdAdB„ZcdCdD„ZddEdF„ZedGdH„ZfzddIl]mgZgWnBehyÚddl]m^Zieij'durÔehe jdJ¡ k¡ƒd‚‚Yn0ele^ƒD]hZmemddkräem ndK¡säe oem¡epe^emƒZqereqeƒs.e seq¡räeqjtdLkräemdMvrädLeq_tqäes¢ele^ƒD]DZuepe^euƒZvewevƒewe^ƒur\dNeu›ejxvr\evejxdNeu›<q\dOdP„ZydQdR„ZzdSdT„Z{da|dUdV„Z}dWdX„Z~dYdZ„Zd+d[œd\d]„Z€d^d_„Zd`da„Z‚eejƒe„fddbœdcdd„Z…ejƒdeœdfdg„Z†ej„deœdhdi„Z‡djdk„Zˆdldm„Z‰dndo„ZŠddplm‹Z‹mŒZŒmZmŽZŽe :gdq¢¡ddrlmZddsl‘m’Z’m“Z“m”Z”m•Z•m–Z–Gdtdu„due”ƒZ—Gdvdw„dwe”ƒZ˜Gdxdy„dye”ƒZ™Gdzd{„d{e”ƒZšGd|d}„d}e”ƒZ›Gd~d„de”ƒZœGd€d„de”ƒZGd‚dƒ„dƒe”ƒZžGd„d…„d…e”ƒZŸGd†d‡„d‡e”ƒZ Gdˆd‰„d‰e”ƒZ¡GdŠd‹„d‹e”ƒZ¢GdŒd„de”ƒZ£GdŽd„de”ƒZ¤Gdd‘„d‘e”ƒZ¥Gd’d“„d“e”ƒZ¦Gd”d•„d•e”ƒZ§e•e˜e™e›eœeeže—ešeŸe£e¤e¥e e¢e¡e¦e§e“hZ¨e©ƒZªeee«d–<dd—l¬m­Z­m®Z®m¯Z¯m°Z°m±Z±dd˜l²m³Z³m´Z´dd™lµm¶Z¶dšd›„Z·ddœl¸m¹Z¹eºZ»eƒZ¼e^ ge·ƒ¡[·erVdd8l½Te¾Z¿[¾dZÀele^jÁƒD]nZmem Âdž¡sdemeÀvr‚qdepe^jÁemƒZqdLeq_temdŸkr°eqeÃem<demZmeqeÃem<em Âd¡sde oem¡qddd8lÄT[’[”d d¡„ZÅddlÆm2Z2dd¢lÆmÇZÇdd£lÆmÈZÈdd¤lÉmÊZÊmËZËmÌZÌmÍZÍdd¥lÆmÎZÎdd¦lÆmÏZÏdd§lÆmÐZÐdd¨lÆmÑZÑdd©lÆmÒZÒddªlÓmÔZÔdd«lÆmÕZÕddlÖZÆdd¬lÆm×Z×dd­lÆmØZØdd®lÆmÙZÙddlÚZÆdd¯lÆmÛZÛdd°lÆmÜZÜdd±lÆmÝZÝdd²lÆmÞZÞdd³lÆm¬Z¬dd´lÆmßZßddµlÆmàZàddláZÆddlâZÆddlãZÆddläZÆddlåZÆddlæZÆddlçZÆddlèZÆdd¶lÆméZédd·lÆmêZêdd¸lÆmëZëdd¹lÆmìZìddlíZÆddlîZÆddlïZÆddlðZÆe^ ñe+eÆj¨ƒ¡ddºlòmóZómôZômõZõ[ó[ô[õd»d¼„Zödd½l÷møZødd¾lùmúZúdd¿lÆmûZûddÀlÆmüZüeýZþddÁlÿmZeeÆjƒ[ddÂlmZeÆjøjjZeÆjøjjZddÃlmZm Z ddÄlòm Z ddÅl m Z m Z mZmZddÆl mZGdÇdÈ„dȃZdØd+d+dÉddd+dÊœeeejejee„efee„dfeee„ee„ejƒejffejedËœdÌdÍ„ZdÎdÏ„ZddÐlòmZddÑlòmZe slddÒlòmZdÓejTv rœddlm2mZe ¡ddlZÆddÔlÆmZddÕlm Z dÖdׄZ!dS)Ù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)ézGPython 2 has reached end-of-life and is no longer supported by PyTorch.é)Ú_import_dotted_nameÚ classproperty)Ú get_file_pathÚ#prepare_multiprocessing_environmentÚUSE_RTLD_GLOBAL_WITH_LIBTORCHÚUSE_GLOBAL_DEPSÚ torch_deployztorch-deploy-1.8)Ú __version__)ÚAnyÚCallableÚDictÚOptionalÚSetÚTypeÚ TYPE_CHECKINGÚUnion)=ÚtypenameÚ is_tensorÚ is_storageÚset_default_tensor_typeÚset_default_deviceÚ set_rng_stateÚ get_rng_stateÚ manual_seedÚ initial_seedÚseedÚsaveÚloadÚset_printoptionsÚchunkÚsplitÚstackÚmatmulÚno_gradÚ enable_gradZrandZrandnÚinference_modeÚ DoubleStorageÚ FloatStorageÚ LongStorageÚ IntStorageÚ ShortStorageÚ CharStorageÚ ByteStorageÚ BoolStorageÚ TypedStorageÚUntypedStorageZ DoubleTensorZ FloatTensorZ LongTensorZ IntTensorZ ShortTensorZ CharTensorZ ByteTensorZ BoolTensorÚTensorÚlobpcgÚuse_deterministic_algorithmsÚ$are_deterministic_algorithms_enabledÚ-is_deterministic_algorithms_warn_only_enabledÚset_deterministic_debug_modeÚget_deterministic_debug_modeÚset_float32_matmul_precisionÚget_float32_matmul_precisionÚset_warn_alwaysÚis_warn_always_enabledÚSymIntÚSymFloatÚSymBoolÚsym_notÚsym_intÚ sym_floatÚsym_maxÚsym_minÚcompileÚvmapÚwin32Z ProgramFileszC:\Program FilesÚLibraryÚbinÚlibÚcCs$g|]}tj tj |d¡¡ ‘qS)znvToolsExt64_1.dll)ÚosÚpathÚexistsÚjoin©Ú.0Úp©rSúW/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/torch/__init__.pyÚ KórUZNVTOOLSEXT_PATHzNVIDIA CorporationZ NvToolsExtÚx64)ÚcudacCs"g|]}t tj |d¡¡ ‘qS)z cudart64*.dll)ÚglobrLrMrOrPrSrSrTrUSrVÚ.Ú_Z CUDA_PATH_VzNVIDIA GPU Computing ToolkitZCUDAÚvz kernel32.dllT)Úuse_last_errorZAddDllDirectoryzvcruntime140.dllz msvcp140.dllzvcruntime140_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/16/release/vc_redist.x64.exez*.dllFié~z Error loading "z" or one of its dependencies.ú;ÚPATHc Csžt ¡dksJdƒ‚ddl}d}tjD]P}tj |d¡}tj |¡sFq&| tj ||d|¡¡}|rn|sn|d}|r&qxq&|st|›dtj›ƒ‚t   |¡dS)z8Preloads cuda deps if they could not be found otherwise.ÚLinuxzShould only be called on LinuxrNZnvidiarJz not found in the system path ) ÚplatformÚsystemrYÚsysrMrLrOrNÚ ValueErrorÚctypesÚCDLL)Ú lib_folderÚlib_namerYÚlib_pathrMZ nvidia_pathZcandidate_lib_pathsrSrSrTÚ_preload_cuda_depsŠs  rkcsútjdkst ¡dkrdSdt ¡dkr,dnd}tj t¡}tj tj  |¡d|¡}zt j |t j dWnŠt yô‰zrd d d d d dddddddœ }‡fdd„| ¡Dƒ}|s´ˆ‚| ¡D]\}}t||ƒq¼t j |t j dWYd‰Šn d‰Š00dS)Nr ÚWindowsZlibtorch_global_depsÚDarwinz.dylibz.sorJ©Úmodezlibcublas.so.*[0-9]zlibcudnn.so.*[0-9]zlibnvrtc.so.*[0-9].*[0-9]zlibcudart.so.*[0-9].*[0-9]zlibcupti.so.*[0-9].*[0-9]zlibcufft.so.*[0-9]zlibcurand.so.*[0-9]zlibcusolver.so.*[0-9]zlibcusparse.so.*[0-9]zlibnccl.so.*[0-9]zlibnvToolsExt.so.*[0-9]) ZcublasZcudnnZ cuda_nvrtcZ cuda_runtimeZ cuda_cuptiZcufftZcurandZcusolverZcusparseZncclZnvtxcs(g|] }| d¡dˆjdvr|‘qS)rZr)r"Úargs)rQrJ©ÚerrrSrTrU¹rVz%_load_global_deps..)rdÚ executablerbrcrLrMÚabspathÚ__file__rOÚdirnamerfrgÚ RTLD_GLOBALÚOSErrorÚvaluesÚitemsrk)riÚhererjZ cuda_libsZis_cuda_lib_errrhrSrqrTÚ_load_global_depsŸs4 õ  r|ZTORCH_USE_RTLD_GLOBALrl)Ú*c@sšeZdZdZdd„Zdd„Zdd„Zeej dœd d „Z ej d œd d „Z ej d œdd„Z ej d œdd„Z ej d œdd„Zdd„Zdd„Zdd„Zdd„ZdS)r=zÇ 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. cCs ||_dS©N)Únode)ÚselfrrSrSrTÚ__init__ószSymInt.__init__cCs |j ¡Sr~©rZbool_©r€rSrSrTÚ__bool__øszSymInt.__bool__cCs |j ¡Sr~)rÚint_rƒrSrSrTÚ__int__ûszSymInt.__int__©ÚotherÚreturncCs tdƒ‚dS©Nztype stub not overridden©ÚAssertionError©r€rˆrSrSrTÚ__eq__sz SymInt.__eq__©r‰cCs tdƒ‚dSrŠr‹rrSrSrTÚ__lt__sz SymInt.__lt__cCs tdƒ‚dSrŠr‹rrSrSrTÚ__gt__sz SymInt.__gt__cCs tdƒ‚dSrŠr‹rrSrSrTÚ__le__ sz SymInt.__le__cCs tdƒ‚dSrŠr‹rrSrSrTÚ__ge__ sz SymInt.__ge__cCs tdƒ‚dSrŠr‹rrSrSrTÚ __sym_max__szSymInt.__sym_max__cCs tdƒ‚dSrŠr‹rrSrSrTÚ __sym_min__szSymInt.__sym_min__cCs tdƒ‚dSrŠr‹rƒrSrSrTÚ __sym_float__szSymInt.__sym_float__cCs t|jƒSr~)ÚstrrrƒrSrSrTÚ__repr__szSymInt.__repr__N)Ú__name__Ú __module__Ú __qualname__Ú__doc__rr„r†ÚobjectÚbuiltinsÚboolrŽrr‘r’r“r”r•r–r˜rSrSrSrTr=ìsr=c@s’eZdZdZdd„Zdd„Zeejdœdd„Z ejd œd d „Z ejd œd d „Z ejd œdd„Z ejd œdd„Z dd„Zdd„Zdd„Zdd„ZdS)r>zÉ Like an 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. cCs$ddlm}t||ƒsJ‚||_dS©Nr)ÚSymNode©Ú%torch.fx.experimental.symbolic_shapesr¡Ú isinstancer©r€rr¡rSrSrTr"s zSymFloat.__init__cCs |j ¡Sr~r‚rƒrSrSrTr„)szSymFloat.__bool__r‡cCs tdƒ‚dSrŠr‹rrSrSrTrŽ.szSymFloat.__eq__rcCs tdƒ‚dSrŠr‹rrSrSrTr1szSymFloat.__lt__cCs tdƒ‚dSrŠr‹rrSrSrTr‘4szSymFloat.__gt__cCs tdƒ‚dSrŠr‹rrSrSrTr’7szSymFloat.__le__cCs tdƒ‚dSrŠr‹rrSrSrTr“:szSymFloat.__ge__cCs tdƒ‚dSrŠr‹rrSrSrTr”=szSymFloat.__sym_max__cCs tdƒ‚dSrŠr‹rrSrSrTr•@szSymFloat.__sym_min__cCs tdƒ‚dSrŠr‹rƒrSrSrTÚ __sym_int__CszSymFloat.__sym_int__cCs |j ¡Sr~©rr—rƒrSrSrTr˜FszSymFloat.__repr__N)r™ršr›rœrr„rržrŸrŽrr‘r’r“r”r•r¦r˜rSrSrSrTr>sr>c@sReZdZdZdd„Zdd„Zddœdd„Zddœd d „Zddœd d „Zd d„Z dS)r?an Like an 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. cCs$ddlm}t||ƒsJ‚||_dSr r¢r¥rSrSrTrSs zSymBool.__init__cCs |j ¡Sr~r‚rƒrSrSrTr„ZszSymBool.__bool__rcCs tdƒ‚dSrŠr‹rrSrSrTÚ__and__^szSymBool.__and__cCs tdƒ‚dSrŠr‹rrSrSrTÚ__or__aszSymBool.__or__cCs tdƒ‚dSrŠr‹rƒrSrSrTÚ __sym_not__uszSymBool.__sym_not__cCs |j ¡Sr~r§rƒrSrSrTr˜xszSymBool.__repr__N) r™ršr›rœrr„r¨r©rªr˜rSrSrSrTr?Is r?cCst|dƒr| ¡S| S)zi SymInt-aware utility for logical negation. Args: a (SymBool or bool): Object to negate rª)Úhasattrrª©ÚarSrSrTr@{s r@cCs(t|tƒr|St|dƒr | ¡St|ƒS)zp SymInt-aware utility for float casting. Args: a (SymInt, SymFloat, or object): Object to cast r–)r¤r>r«r–Úpy_floatr¬rSrSrTrB…s   rBcCs<t|tƒr|St|tƒr4|dkr*t |¡St |¡St|ƒS)zn SymInt-aware utility for int casting. Args: a (SymInt, SymFloat, or object): Object to cast r)r¤r=r>ÚmathÚfloorÚceilÚpy_intr¬rSrSrTrA’s   rAcCs<t|ttfƒr| |¡St|ttfƒr0| |¡St ||¡S©z SymInt-aware utility for max().)r¤r=r>r”ržÚmax©r­ÚbrSrSrTrCžs   rCcCs<t|ttfƒr| |¡St|ttfƒr0| |¡St ||¡Sr³)r¤r=r>r•ržÚminrµrSrSrTrD©s   rD)Ú_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 setup.py install && python -c "import torch" This error can generally be solved using the `develop` workflow $ python setup.py develop && python -c "import torch" # This should succeed or by running Python from a different directory. ZBaseÚtorch)ZDisableTorchFunctionSubclassZDisableTorchFunctionÚ Generatorz torch._C.cCs‚t|tjƒr| ¡Sd}d}t|dƒrN|jdkrN|jdkrN|jdurN|jd}t|dƒr`|j}nt|dƒrr|j}n|jj}||S)NrKršržÚ __builtin__rZr›r™) r¤r¹r2Útyper«ršr›r™Ú __class__)ÚoÚmoduleÚ class_namerSrSrTrås  ÿÿ   rcCs t|tjƒS)a­Returns True if `obj` is a PyTorch tensor. Note that this function is simply doing ``isinstance(obj, Tensor)``. Using that ``isinstance`` check is better for typechecking with mypy, and more explicit - so it's recommended to use that instead of ``is_tensor``. Args: obj (Object): Object to test Example:: >>> x = torch.tensor([1, 2, 3]) >>> torch.is_tensor(x) True )r¤r¹r2©ÚobjrSrSrTrùsrcCs t|ƒtvS)zgReturns True if `obj` is a PyTorch storage object. Args: obj (Object): Object to test )r¼Ú_storage_classesrÁrSrSrTr srcCsFtdurt ddd¡|dur&dadSddlm}||ƒat ¡dS)a®Sets 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 Args: device (device or string): the device to set as default Example:: >>> # xdoctest: +SKIP("requires cuda, changes global state") >>> torch.tensor([1.2, 3]).device device(type='cpu') >>> torch.set_default_device('cuda') # current device is 0 >>> torch.tensor([1.2, 3]).device device(type='cuda', index=0) >>> torch.set_default_device('cuda:1') >>> torch.tensor([1.2, 3]).device device(type='cuda', index=1) Nr)Ú DeviceContext)Ú_GLOBAL_DEVICE_CONTEXTÚ__exit__Ztorch.utils._devicerÄÚ __enter__)ÚdevicerÄrSrSrTrs& rcCs t|tƒrt|ƒ}t |¡dS)aé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)r¤r—rÚ_CZ_set_default_tensor_type)ÚtrSrSrTrHs rcCst |¡dS)aË Sets the default floating point dtype to :attr:`d`. Supports torch.float32 and torch.float64 as inputs. Other dtypes may be accepted without complaint but are not supported and are unlikely to work as expected. 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 point type is float32 the default complex dtype is complex64, and when the default floating point type is float64 the default complex type is complex128. 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. Either torch.float32 or torch.float64. 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 N)rÉZ_set_default_dtype)ÚdrSrSrTÚset_default_dtypeas,rÌ©Ú warn_onlycCstj||ddS)as Sets 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 * :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 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.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 * :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 * :func:`torch.kthvalue` with called on a CUDA tensor * :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 A handful of CUDA operations are nondeterministic if the CUDA version is 10.2 or greater, unless the environment variable ``CUBLAS_WORKSPACE_CONFIG=:4096:8`` or ``CUBLAS_WORKSPACE_CONFIG=:16:8`` is set. See the CUDA documentation for more details: ``_ If one of these environment variable configurations is not set, a :class:`RuntimeError` will be raised from these operations when called with CUDA tensors: * :func:`torch.mm` * :func:`torch.mv` * :func:`torch.bmm` Note that deterministic operations tend to have worse performance than nondeterministic operations. .. 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) # Forward mode nondeterministic error >>> torch.randn(10, device='cuda').kthvalue(0) ... RuntimeError: kthvalue CUDA does not have a deterministic implementation... # 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... rÍN)rÉÚ_set_deterministic_algorithms)rorÎrSrSrTr4s}r4cCst ¡S)z˜Returns True if the global deterministic flag is turned on. Refer to :func:`torch.use_deterministic_algorithms` documentation for more details. )rÉÚ_get_deterministic_algorithmsrSrSrSrTr5sr5cCst ¡S)z£Returns True if the global deterministic flag is set to warn only. Refer to :func:`torch.use_deterministic_algorithms` documentation for more details. )rÉÚ'_get_deterministic_algorithms_warn_onlyrSrSrSrTr6sr6)Ú debug_moder‰cCs¶t|tjtfƒs"tdt|ƒ›ƒ‚t|tƒrd|dkr:d}n*|dkrHd}n|dkrVd}ntd|›ƒ‚|dkrxt d ¡n:|dkrtjd d d n"|dkr¤t d ¡ntd |›ƒ‚d S)aöSets 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 ÚdefaultrÚwarnrÚerrorézQinvalid value of debug_mode, expected one of `default`, `warn`, `error`, but got FTrÍz:invalid value of debug_mode, expected 0, 1, or 2, but got N) r¤ržÚintr—Ú TypeErrorr¼Ú RuntimeErrorrÉrÏ)rÒrSrSrTr7s2 ÿÿ  ÿÿr7rcCs"t ¡rt ¡rdSdSndSdS)zªReturns the current value of the debug mode for deterministic operations. Refer to :func:`torch.set_deterministic_debug_mode` documentation for more details. rrÖrN)rÉrÐrÑrSrSrSrTr8Es r8cCst ¡S)z¢Returns the current value of float32 matrix multiplication precision. Refer to :func:`torch.set_float32_matmul_precision` documentation for more details. )rÉZ_get_float32_matmul_precisionrSrSrSrTr:Ssr:cCst |¡dS)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 for internal computations. * "high", float32 matrix multiplications use the TensorFloat32 or bfloat16_3x datatypes for internal computations, if fast matrix multiplication algorithms using those datatypes internally are available. Otherwise float32 matrix multiplications are computed as if the precision is "highest". * "medium", float32 matrix multiplications use the bfloat16 datatype 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". .. 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)rÉZ_set_float32_matmul_precision)Z precisionrSrSrTr9Ys+r9cCst |¡dS)a”When 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)rÉZ_set_warnAlways)r¶rSrSrTr;†s r;cCst ¡S)z‰Returns True if the global warn_always flag is turned on. Refer to :func:`torch.set_warn_always` documentation for more details. )rÉZ_get_warnAlwaysrSrSrSrTr<’sr<)ÚeÚnanÚinfÚpi)rÚrÝrÛrÜ)r2)Ú _StorageBaser0Ú_LegacyStorager1Ú_warn_typed_storage_removalc@s$eZdZedd„ƒZedd„ƒZdS)r.cCs tƒ|jSr~©ràÚ_dtyperƒrSrSrTÚdtype¬szByteStorage.dtypecCstjSr~)r¹Zuint8rƒrSrSrTrâ±szByteStorage._dtypeN©r™ršr›rrãrârSrSrSrTr.«s r.c@s$eZdZedd„ƒZedd„ƒZdS)r(cCs tƒ|jSr~rárƒrSrSrTrã¶szDoubleStorage.dtypecCstjSr~)r¹ÚdoublerƒrSrSrTrâ»szDoubleStorage._dtypeNrärSrSrSrTr(µs r(c@s$eZdZedd„ƒZedd„ƒZdS)r)cCs tƒ|jSr~rárƒrSrSrTrãÀszFloatStorage.dtypecCstjSr~)r¹ÚfloatrƒrSrSrTrâÅszFloatStorage._dtypeNrärSrSrSrTr)¿s r)c@s$eZdZedd„ƒZedd„ƒZdS)Ú HalfStoragecCs tƒ|jSr~rárƒrSrSrTrãÊszHalfStorage.dtypecCstjSr~)r¹ZhalfrƒrSrSrTrâÏszHalfStorage._dtypeNrärSrSrSrTrçÉs rçc@s$eZdZedd„ƒZedd„ƒZdS)r*cCs tƒ|jSr~rárƒrSrSrTrãÔszLongStorage.dtypecCstjSr~)r¹ÚlongrƒrSrSrTrâÙszLongStorage._dtypeNrärSrSrSrTr*Ós r*c@s$eZdZedd„ƒZedd„ƒZdS)r+cCs tƒ|jSr~rárƒrSrSrTrãÞszIntStorage.dtypecCstjSr~)r¹r×rƒrSrSrTrâãszIntStorage._dtypeNrärSrSrSrTr+Ýs r+c@s$eZdZedd„ƒZedd„ƒZdS)r,cCs tƒ|jSr~rárƒrSrSrTrãèszShortStorage.dtypecCstjSr~)r¹ÚshortrƒrSrSrTrâíszShortStorage._dtypeNrärSrSrSrTr,çs r,c@s$eZdZedd„ƒZedd„ƒZdS)r-cCs tƒ|jSr~rárƒrSrSrTrãòszCharStorage.dtypecCstjSr~)r¹Zint8rƒrSrSrTrâ÷szCharStorage._dtypeNrärSrSrSrTr-ñs r-c@s$eZdZedd„ƒZedd„ƒZdS)r/cCs tƒ|jSr~rárƒrSrSrTrãüszBoolStorage.dtypecCstjSr~)r¹rŸrƒrSrSrTrâszBoolStorage._dtypeNrärSrSrSrTr/ûs r/c@s$eZdZedd„ƒZedd„ƒZdS)ÚBFloat16StoragecCs tƒ|jSr~rárƒrSrSrTrãszBFloat16Storage.dtypecCstjSr~)r¹Zbfloat16rƒrSrSrTrâ szBFloat16Storage._dtypeNrärSrSrSrTrês rêc@s$eZdZedd„ƒZedd„ƒZdS)ÚComplexDoubleStoragecCs tƒ|jSr~rárƒrSrSrTrãszComplexDoubleStorage.dtypecCstjSr~)r¹ZcdoublerƒrSrSrTrâszComplexDoubleStorage._dtypeNrärSrSrSrTrës rëc@s$eZdZedd„ƒZedd„ƒZdS)ÚComplexFloatStoragecCs tƒ|jSr~rárƒrSrSrTrãszComplexFloatStorage.dtypecCstjSr~)r¹ZcfloatrƒrSrSrTrâszComplexFloatStorage._dtypeNrärSrSrSrTrìs rìc@s$eZdZedd„ƒZedd„ƒZdS)Ú QUInt8StoragecCs tƒ|jSr~rárƒrSrSrTrã$szQUInt8Storage.dtypecCstjSr~)r¹Zquint8rƒrSrSrTrâ)szQUInt8Storage._dtypeNrärSrSrSrTrí#s ríc@s$eZdZedd„ƒZedd„ƒZdS)Ú QInt8StoragecCs tƒ|jSr~rárƒrSrSrTrã.szQInt8Storage.dtypecCstjSr~)r¹Zqint8rƒrSrSrTrâ3szQInt8Storage._dtypeNrärSrSrSrTrî-s rîc@s$eZdZedd„ƒZedd„ƒZdS)Ú QInt32StoragecCs tƒ|jSr~rárƒrSrSrTrã8szQInt32Storage.dtypecCstjSr~)r¹Zqint32rƒrSrSrTrâ=szQInt32Storage._dtypeNrärSrSrSrTrï7s rïc@s$eZdZedd„ƒZedd„ƒZdS)ÚQUInt4x2StoragecCs tƒ|jSr~rárƒrSrSrTrãBszQUInt4x2Storage.dtypecCstjSr~)r¹Zquint4x2rƒrSrSrTrâGszQUInt4x2Storage._dtypeNrärSrSrSrTrðAs rðc@s$eZdZedd„ƒZedd„ƒZdS)ÚQUInt2x4StoragecCs tƒ|jSr~rárƒrSrSrTrãLszQUInt2x4Storage.dtypecCstjSr~)r¹Zquint2x4rƒrSrSrTrâQszQUInt2x4Storage._dtypeNrärSrSrSrTrñKs rñÚ_tensor_classes)rrrrr)rr)r cCsTtjdkst ¡dkrdStdddƒ}ttdƒƒtj |¡sJt d|ƒ‚|  d¡S) Nr rlrVr¹rIZtorch_shm_managerz$Unable to find torch_shm_manager at zutf-8) rdrsrbrcrrrLrMrNrÙÚencode)rMrSrSrTÚ manager_pathis    rô)Úautocast)Z unique_dimÚ__Úsegment_reducecCsHddlm}m}t|ƒtjur8||fƒr8|t|f||ƒS|sDJ|ƒ‚dS)zFA wrapper around Python's assert which is symbolically traceable. r)Úhas_torch_functionÚhandle_torch_functionN)Z overridesrørùr¼r¹r2Ú_assert)Ú conditionÚmessagerørùrSrSrTrú²srú)Úcpu)Úautograd)r%r&Úset_grad_enabledr')Úfft)Úfutures)Ú_awaits)Únested)Únn)Úwindows)Úoptim)Úmultiprocessing)Úsparse)Úspecial)Úonnx)Újit)Úlinalg)Úhub)Úrandom)Ú distributions)Útesting)Ú __config__)Ú __future__)Úprofiler)Úao)Ú _torch_docsÚ _tensor_docsÚ _storage_docscCstjS)z?Returns whether PyTorch was built with _GLIBCXX_USE_CXX11_ABI=1)rÉZ_GLIBCXX_USE_CXX11_ABIrSrSrSrTÚcompiled_with_cxx11_abiúsr)Úops)Úclasses)Ú quantization)Ú quasirandom)Úregister_after_fork)r3)Ú from_dlpackÚ to_dlpack)Úmasked)Ú matrix_rankÚeigÚsolveÚlstsq)Ú_symeigc@sTeZdZdZdd„Zdd„Zeedœdd„Zee ee fd œd d „Z d d „Z dS)Ú_TorchCompileInductorWrapperÚinductorcCsHtƒ|_||_| |¡| |¡|rDd|jd<d|p8dvsDJdƒ‚dS)NFútriton.cudagraphsrSz1triton.cudagraphs does not support dynamic shapes)ÚdictÚconfigÚdynamicÚ apply_modeÚ apply_options)r€roÚoptionsr+rSrSrTr2s   ÿþz%_TorchCompileInductorWrapper.__init__cCs"t|tƒo |j|jko |j|jkSr~)r¤r&r*r+rrSrSrTrŽ>s   ÿ þz#_TorchCompileInductorWrapper.__eq__rncCs\|dusX|dkrnF|dkr,| dddœ¡n,|dkrH| ddddœ¡ntd|›d ƒ‚dS) NrÓzreduce-overheadTF)r(Z size_assertsz max-autotune)Zepilogue_fusionZ max_autotuner(zUnrecognized mode=z:, should be one of: default, reduce-overhead, max-autotune)r-rÙ)r€rorSrSrTr,Cs þ ý  ÿz'_TorchCompileInductorWrapper.apply_mode)r.c Cs²|sdSddlm}| ¡}| ¡D]ˆ\}}| dd¡}||vr\td|›dt| ¡ƒ›ƒ‚t|ƒt||ƒur¢t|ƒj }t||ƒj }td|›d|›d |›ƒ‚||j|<q$dS) Nr)r*ú-r[zUnexpected optimization option z, known options are zUnexpected type of attr z, got z should be ) Ztorch._inductorr*Úto_dictrzÚreplacerÙÚlistÚkeysr¼r™) r€r.r*Zcurrent_configÚkeyÚvalÚ attr_nameZ val_type_strZexpected_type_strrSrSrTr-Vs"  ÿ ÿz*_TorchCompileInductorWrapper.apply_optionscCsddlm}||||jdS)Nr)Ú compile_fx)Zconfig_patches)Ztorch._inductor.compile_fxr7r*)r€Zmodel_Zinputs_r7rSrSrTÚ__call__ks z%_TorchCompileInductorWrapper.__call__N) r™ršr›Z compiler_namerrŽrr—r,rr r-r8rSrSrSrTr&/s  r&r'©Ú fullgraphr+Úbackendror.Údisable)Úmodelr:r+r;ror.r<r‰c s’t d¡|dur2tdœ‡‡‡‡‡‡fdd„ }|Sddl}ˆdurRˆdurRtdƒ‚ˆdurfˆdurfd‰ˆd krztˆˆˆƒ‰|jjˆˆˆˆd |ƒS) aÀ Optimizes given model/function using TorchDynamo and specified backend. Args: model (Callable): Module/function to optimize fullgraph (bool): Whether it is ok to break model into several subgraphs dynamic (bool): Use dynamic shape tracing backend (str or Callable): backend to be used mode (str): Can be either "default", "reduce-overhead" or "max-autotune" options (dict): A dictionary of options to pass to the backend. disable (bool): Turn torch.compile() into a no-op for testing Example:: @torch.compile(options={"matmul-padding": True}, fullgraph=True) def foo(x): return torch.sin(x) + torch.cos(x) z torch.compileN©r=c s&|durtdƒ‚t|ˆˆˆˆˆˆdS)NzModel can't be Noner9)rÙrEr>©r;r<r+r:ror.rSrTÚfnŽsúzcompile..fnrzVEither mode or options can be specified, but both can't be specified at the same time.rÓr')r;Znopythonr+r<)rÉZ_log_api_usage_oncer Z torch._dynamorÙr&Z_dynamoÚoptimize) r=r:r+r;ror.r<r@r¹rSr?rTrEqs   rEcCs^t |¡j}tjt}t||ƒr6td |t ||ƒ¡ƒ‚t |||ƒd  t|g¡}|tj|<dS)zùRegister 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. z@The runtime module of '{}' has already been registered with '{}'rZN) r¹rÈr¼rdÚmodulesr™r«rÙÚformatÚgetattrÚsetattrrO)Z device_typer¿ÚmZtorch_module_namerSrSrTÚ_register_device_module¤s    ÿ rG)Ú return_types)Úlibrary)Ú_meta_registrationsZTORCH_CUDA_SANITIZER)Úfunc)rFcOs*ddl}| d¡d|d<tj|i|¤ŽS)Nrzptorch._sparse_coo_tensor_unsafe is deprecated, use torch.sparse_coo_tensor(..., check_invariants=False) instead.FZcheck_invariants)ÚwarningsrÔr¹Zsparse_coo_tensor)rpÚkwargsrLrSrSrTÚ_sparse_coo_tensor_unsafeËs rN)N("rœr¯rLrdrbÚtextwraprfÚinspectÚ version_infoÚ ExceptionÚ_utilsrrZ_utils_internalrrrr rsr Z torch_versionÚtypingr r rrrrrrržÚ__all__ÚgetenvZ pfiles_pathrMrOÚ exec_prefixZ py_dll_pathrvruZ th_dll_pathÚbase_exec_prefixZbase_py_dll_pathr2ÚfilterrNZ dll_pathsÚallZnvtoolsext_dll_pathÚversionrXZ cuda_versionrYr1Zcuda_version_1Z cuda_path_varZ default_pathZ cuda_pathÚextendZWinDLLÚkernel32r«Zwith_load_library_flagsZ SetErrorModeZprev_error_modeÚc_void_pZ LoadLibraryWÚrestypeZLoadLibraryExWZdll_pathZadd_dll_directoryrgrxÚprintZdllsZ path_patchedÚdllZ is_loadedÚresZget_last_errorZ last_errorZWinErrorrrÚstrerrorÚenvironrkr|rcÚgetdlopenflagsZ old_flagsÚsetdlopenflagsrwÚ RTLD_LAZYZtorch._CrÉr=r>r?r@rBrArCrDr¸Ú ImportErrorZ_C_for_compiled_checkÚdedentÚstripÚdirÚnameÚendswithÚappendrDrÂr¤ÚisclassršÚattrÚ candidater¼rBrrrrÅrrrÌr4r5r6r×r—r7r8r:r9r;r<rÚrÛrÜrÝZ_tensorr2ZstoragerÞr0rßr1ràr.r(r)rçr*r+r,r-r/rêrërìrírîrïrðrñrÃÚsetròÚ__annotations__rrrrrrZ serializationrrZ _tensor_strr rôZ torch.amprõrær®r²Ztorch._C._VariableFunctionsr÷Z_segment_reduceZ PRIVATE_OPSZ_VariableFunctionsÚ startswithÚglobalsZ functionalrúr¹rýrþZtorch.autogradr%r&rÿr'rrrrrZ torch.signalrrZtorch.optim._multi_tensorrrr Ztorch.utils.backcompatr r r r rrZtorch.backends.cudaZtorch.backends.mpsZtorch.backends.cudnnZtorch.backends.mklZtorch.backends.mkldnnZtorch.backends.openmpZtorch.backends.quantizedZtorch.utils.datarrrrZtorch.nn.quantizableZtorch.nn.quantizedZ torch.nn.qatZtorch.nn.intrinsicZ _init_namesrKrrrrZ torch._opsrZtorch._classesrrrZcontiguous_formatZlegacy_contiguous_formatZtorch.multiprocessing._atforkrZget_num_threadsZ_lobpcgr3ZatenZquantized_lstmZ quantized_gruZtorch.utils.dlpackrrr Z _linalg_utilsr!r"r#r$r%Zsymeigr&rŸrErGrHrIrJZtorch.cuda._sanitizerZ _sanitizerZcsanZenable_cuda_sanitizerr£rKZ torch.funcrFrNrSrSrSrTÚs6    (  ÿ             "ÿ ÿ   /.2        õ          0.*-                     û                                     *Bú   ú3