a 7Sico•ã@s€ UdZddlZddlZddlZddlZddlZddlZddlZejdkrPe dƒ‚ddl m Z m Z ddl mZmZmZmZejdkrˆd Zn dd lmZdd lmZdd lmZmZmZmZmZddlZgd ¢Zejdkrþ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!d d!d"e3¡Z8ej" #e  e7e8¡d¡Z9ndZ9e. :e,ej"j-e0e9gƒ¡ej;d#d$d%Ze< ?d¡Z@ejAerZejAer^e< DeF¡ZHeHdur^e Ie J¡¡ZKeKjLd(eF›d)7_LeK‚q^z"e Md*¡e Md+¡e Md,¡WneNyþeOd-ƒYn0e4 4ej" #e(d.¡¡ZPd/ZQePD]ÖZRd/ZSe>rˆe< EeRdd0¡ZHe J¡ZTeHdurzeTd1krze IeT¡ZKeKjLd2eR›d37_LeK‚neHdurˆd$ZSeSseQs´d4 #e.ejUd5g¡ejUd5<d$ZQe< BeR¡ZHeHdure Ie J¡¡ZKeKjLd2eR›d37_LeK‚qe< ?e@¡d6d7„ZVese  d8¡r¦e W¡d9kr¦ddlZXe=eXd:ƒrFe=eXd;ƒstz ddlYZXWn eZyrddl[m\ZXYn0e ]¡Z^e _eXj`eXjaB¡ddkr$eej'dur$eZe fd?¡ g¡ƒd‚‚Yn0ehecƒD]hZieiddkr4ei jd@¡s4e kei¡eleceiƒZmenemeƒs~e oem¡r4emjpdAkr4eidBvr4dAem_pq4esòehecƒD]DZqeleceqƒZreserƒesecƒur¬dCeq›ejtvr¬erejtdCeq›<q¬dDdE„ZudFdG„ZvdHdI„ZwdJdK„ZxdLdM„Zyd/dNœdOdP„ZzdQdR„Z{dSdT„Z|eej}e~fddUœdVdW„Zej}dXœdYdZ„Z€ej~dXœd[d\„Zd]d^„Z‚d_d`„Zƒdadb„Z„ddcl…m†Z†m‡Z‡mˆZˆm‰Z‰e :gdd¢¡ddelŠm‹Z‹ddflŒmZmŽZŽmZmZGdgdh„dheƒZ‘Gdidj„djeƒZ’Gdkdl„dleƒZ“Gdmdn„dneƒZ”Gdodp„dpeƒZ•Gdqdr„dreƒZ–Gdsdt„dteƒZ—Gdudv„dveƒZ˜Gdwdx„dxeƒZ™Gdydz„dzeƒZšGd{d|„d|eƒZ›Gd}d~„d~eƒZœGdd€„d€eƒZGdd‚„d‚eƒZžGdƒd„„d„eƒZŸGd…d†„d†eƒZ Gd‡dˆ„dˆeƒZ¡ee’e“e•e–e—e˜e‘e”e™eež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°ddŽ„Z±ddl²m³Z³ec de±ƒ¡[±erˆdd= 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__)Ústring_classes)ÚSetÚTypeÚ TYPE_CHECKINGÚUnionÚCallable)1ÚtypenameÚ is_tensorÚ is_storageÚset_default_tensor_typeÚ 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Ú _TypedStorageZ 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Úwin32Z ProgramFileszC:\Program FilesÚLibraryÚbinÚlibÚcCs$g|]}tj tj |d¡¡ ‘qS)znvToolsExt64_1.dll)ÚosÚpathÚexistsÚjoin©Ú.0Úp©rEúJ/var/www/html/django/DPS/env/lib/python3.9/site-packages/torch/__init__.pyÚ JórGZNVTOOLSEXT_PATHzNVIDIA CorporationZ NvToolsExtZx64)ÚcudacCs"g|]}t tj |d¡¡ ‘qS)z cudart64*.dll)Úglobr>r?rArBrErErFrGRrHÚ.Ú_Z CUDA_PATH_VzNVIDIA GPU Computing ToolkitÚCUDAÚvz kernel32.dllT)Úuse_last_errorÚAddDllDirectory)réz Error adding "z" to the DLL directories.zvcruntime140.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.ú;ÚPATHcCsjt ¡dkstjdkrdSdt ¡dkr,dnd}tj t¡}tj tj  |¡d|¡}t j |t j ddS) NÚWindowsr Zlibtorch_global_depsÚDarwinz.dylibz.sor<)Úmode) ÚplatformÚsystemÚsysÚ executabler>r?ÚabspathÚ__file__rAÚdirnameÚctypesÚCDLLÚ RTLD_GLOBAL)Zlib_nameÚhereZlib_pathrErErFÚ_load_global_deps’s  rcZTORCH_USE_RTLD_GLOBALrUraÚ RTLD_LAZY)Ú*)Ú_initExtension)réa’ 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)ZDisableTorchFunctionÚ 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)Nr=Ú __module__ÚbuiltinsÚ __builtin__rKÚ __qualname__Ú__name__) Ú isinstancerhr.ÚtypeÚhasattrrjrmrnÚ __class__)ÚoÚmoduleÚ class_namerErErFrs  ÿÿ   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 )rorhr.©ÚobjrErErFrsrcCs t|ƒtvS)zgReturns True if `obj` is a PyTorch storage object. Args: obj (Object): Object to test )rpÚ_storage_classesrvrErErFr-srcCs 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:: >>> 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)roÚ_string_classesrÚ_CZ_set_default_tensor_type)ÚtrErErFr6s rcCst |¡dS)aj 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: >>> # 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)rzZ_set_default_dtype)ÚdrErErFÚset_default_dtypeNs+r}©Ú warn_onlycCstj||ddS)aR 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:: :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 ``input`` dimension is one and called on a CUDA tensor * :func:`torch.gather` when ``input`` dimension is one and 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 * :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.scatter_add_` when ``input`` dimension is larger than one and called on a CUDA tensor * :func:`torch.gather` when ``input`` dimension is larger than one and called on a CUDA tensor that requires grad * :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 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:: >>> torch.use_deterministic_algorithms(True) # Forward mode nondeterministic error >>> torch.randn(10).index_copy(0, torch.tensor([0]), torch.randn(1)) ... RuntimeError: index_copy does not have a deterministic implementation... # Backward mode nondeterministic error >>> torch.randn(10, requires_grad=True, device='cuda').index_select(0, torch.tensor([0], device='cuda')).backward() ... RuntimeError: index_add_cuda_ does not have a deterministic implementation... r~N)rzÚ_set_deterministic_algorithms)rWrrErErFr0{s{r0cCst ¡S)z˜Returns True if the global deterministic flag is turned on. Refer to :func:`torch.use_deterministic_algorithms` documentation for more details. )rzÚ_get_deterministic_algorithmsrErErErFr1øsr1cCst ¡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. )rzÚ'_get_deterministic_algorithms_warn_onlyrErErErFr2þsr2)Ú debug_modeÚreturncCs¶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) rorkÚintÚstrÚ TypeErrorrpÚ RuntimeErrorrzr€)rƒrErErFr3s2 ÿÿ  ÿÿr3)r„cCs"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)rzrr‚rErErErFr4/s r4cCst ¡S)z¢Returns the current value of float32 matrix multiplication precision. Refer to :func:`torch.set_float32_matmul_precision` documentation for more details. )rzZ_get_float32_matmul_precisionrErErErFr6=sr6cCst |¡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)rzZ_set_float32_matmul_precision)Ú precisionrErErFr5Cs+r5cCst |¡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)rzZ_set_warnAlways)ÚbrErErFr7ps r7cCst ¡S)z‰Returns True if the global warn_always flag is turned on. Refer to :func:`torch.set_warn_always` documentation for more details. )rzZ_get_warnAlwaysrErErErFr8|sr8)ÚeÚnanÚinfÚpi)rr’rr‘)r.)Ú _StorageBaser-Ú_LegacyStorageÚ_UntypedStoragec@seZdZedd„ƒZdS)r+cCstjS©N)rhZuint8©ÚselfrErErFÚdtype–szByteStorage.dtypeN©rnrjrmrr™rErErErFr+•sr+c@seZdZedd„ƒZdS)r%cCstjSr–)rhÚdoubler—rErErFr™›szDoubleStorage.dtypeNršrErErErFr%šsr%c@seZdZedd„ƒZdS)r&cCstjSr–)rhÚfloatr—rErErFr™ szFloatStorage.dtypeNršrErErErFr&Ÿsr&c@seZdZedd„ƒZdS)Ú HalfStoragecCstjSr–)rhZhalfr—rErErFr™¥szHalfStorage.dtypeNršrErErErFr¤src@seZdZedd„ƒZdS)r'cCstjSr–)rhÚlongr—rErErFr™ªszLongStorage.dtypeNršrErErErFr'©sr'c@seZdZedd„ƒZdS)r(cCstjSr–)rhr‰r—rErErFr™¯szIntStorage.dtypeNršrErErErFr(®sr(c@seZdZedd„ƒZdS)r)cCstjSr–)rhÚshortr—rErErFr™´szShortStorage.dtypeNršrErErErFr)³sr)c@seZdZedd„ƒZdS)r*cCstjSr–)rhZint8r—rErErFr™¹szCharStorage.dtypeNršrErErErFr*¸sr*c@seZdZedd„ƒZdS)r,cCstjSr–)rhÚboolr—rErErFr™¾szBoolStorage.dtypeNršrErErErFr,½sr,c@seZdZedd„ƒZdS)ÚBFloat16StoragecCstjSr–)rhZbfloat16r—rErErFr™ÃszBFloat16Storage.dtypeNršrErErErFr¡Âsr¡c@seZdZedd„ƒZdS)ÚComplexDoubleStoragecCstjSr–)rhZcdoubler—rErErFr™ÈszComplexDoubleStorage.dtypeNršrErErErFr¢Çsr¢c@seZdZedd„ƒZdS)ÚComplexFloatStoragecCstjSr–)rhZcfloatr—rErErFr™ÍszComplexFloatStorage.dtypeNršrErErErFr£Ìsr£c@seZdZedd„ƒZdS)Ú QUInt8StoragecCstjSr–)rhZquint8r—rErErFr™ÒszQUInt8Storage.dtypeNršrErErErFr¤Ñsr¤c@seZdZedd„ƒZdS)Ú QInt8StoragecCstjSr–)rhZqint8r—rErErFr™×szQInt8Storage.dtypeNršrErErErFr¥Ösr¥c@seZdZedd„ƒZdS)Ú QInt32StoragecCstjSr–)rhZqint32r—rErErFr™ÜszQInt32Storage.dtypeNršrErErErFr¦Ûsr¦c@seZdZedd„ƒZdS)ÚQUInt4x2StoragecCstjSr–)rhZquint4x2r—rErErFr™ászQUInt4x2Storage.dtypeNršrErErErFr§àsr§c@seZdZedd„ƒZdS)ÚQUInt2x4StoragecCstjSr–)rhZquint2x4r—rErErFr™æszQUInt2x4Storage.dtypeNršrErErErFr¨åsr¨Ú_tensor_classes)rrrrr)rr)rcCsTt ¡dkstjdkrdStdddƒ}ttdƒƒtj |¡sJt d|ƒ‚|  d¡S) NrUr rHrhr;Ztorch_shm_managerz$Unable to find torch_shm_manager at zutf-8) rXrYrZr[rrr>r?r@rŒÚencode)r?rErErFÚ manager_pathþs    r«)Úautocast)Z unique_dimÚ__cCsHddlm}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)Ú overridesr®r¯rprhr.Ú_assert)Ú conditionÚmessager®r¯rErErFr±:sr±)Úcpu)Úautograd)r"r#Úset_grad_enabledr$)Úfft)Úfutures)Únn)Ú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)rzZ_GLIBCXX_USE_CXX11_ABIrErErErFÚcompiled_with_cxx11_abi~srÌ)Úops)Úclasses)Ú quantization)Ú quasirandom)Úregister_after_fork)r/)Ú from_dlpackÚ to_dlpack)Ú_masked)ÚsolvecCsFt |¡j}tjt}t||ƒr6td |t ||ƒ¡ƒ‚t |||ƒ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 '{}'N) rhÚdevicerprZÚmodulesrnrqrŒÚformatÚgetattrÚsetattr)Z device_typertÚmrErErFÚ_register_device_module­s    ÿrÜ)Ú return_types)Úlibrary)Ú_meta_registrations(Ú__doc__r>rZrXÚtextwrapr_ÚwarningsÚinspectÚ version_infoÚ ExceptionZ_utilsrrZ_utils_internalrrrr r[r Z torch_versionZ_sixr ryÚtypingr rrrrrkÚ__all__ÚgetenvZ pfiles_pathr?rAÚ exec_prefixZ py_dll_pathr^r]Z th_dll_pathÚbase_exec_prefixZbase_py_dll_pathÚlistÚfilterr@Z dll_pathsÚallZnvtoolsext_dll_pathÚversionrIZ cuda_versionrJÚreplaceZcuda_version_1Z cuda_path_varZ default_pathZ cuda_pathÚextendZWinDLLÚkernel32rqZwith_load_library_flagsZ SetErrorModeZprev_error_modeÚc_void_pZ LoadLibraryWÚrestyperPZLoadLibraryExWZdll_pathZadd_dll_directoryÚresZWinErrorZget_last_errorÚerrÚstrerrorr`ÚOSErrorÚprintZdllsZ path_patchedÚdllZ is_loadedZ last_errorÚenvironrcrYZ _dl_flagsZDLFCNÚ ImportErrorZ torch._dlZ_dlÚgetdlopenflagsZ old_flagsÚsetdlopenflagsrardZtorch._CrzrfZ_C_for_compiled_checkÚdedentÚstripÚdirÚnameÚendswithÚappendrÙrwroÚisclassrjÚattrÚ candidaterpr×rrrrr}r0r1r2r‰rŠr3r4r6r5r7r8Úmathrrr‘r’Z_tensorr.Ústorager“r-r”r•r+r%r&rr'r(r)r*r,r¡r¢r£r¤r¥r¦r§r¨rxÚsetr©Ú__annotations__rÂrrrrrZ serializationrrZ _tensor_strrr«Z torch.ampr¬Ztorch._C._VariableFunctionsZ PRIVATE_OPSZ_VariableFunctionsÚ startswithÚglobalsÚ functionalr±rhr´rµZtorch.autogradr"r#r¶r$r·r¸r¹rºZtorch.optim._multi_tensorr»r¼r½Ztorch.utils.backcompatr¾r¿rÀrÁrÃrÄZtorch.backends.cudaZtorch.backends.mpsZtorch.backends.cudnnZtorch.backends.mklZtorch.backends.mkldnnZtorch.backends.openmpZtorch.backends.quantizedZtorch.utils.datarÅrÆrÇZtorch.nn.intrinsicZtorch.nn.quantizableZtorch.nn.quantizedrÈZ _init_namesr=rÉrÊrËrÌZ torch._opsrÍZtorch._classesrÎrÏrÐZcontiguous_formatZlegacy_contiguous_formatZtorch.multiprocessing._atforkrÑZget_num_threadsZ_lobpcgr/ZatenZquantized_lstmZ quantized_gruZtorch.utils.dlpackrÒrÓrÔZ _linalg_utilsrÕrÜrÝrÞrßrErErErFÚsö       ÿ                    ÿ      õ          -}*-     û