a OSic'@sddlZddlZddlZddlZddlmZmZmZmZgdZ edefZ ede dZ GdddZ Gd d d e Z Gd d d e ZGd dde ZGddde ZdS)N)AnyCallableTypeVarcast)no_grad enable_gradset_grad_enabledinference_mode.F)boundc@sReZdZdZeedddZddZddd d Zeeedd d d Z ddZ dS)_DecoratorContextManagerz1Allow a context manager to be used as a decorator)funcreturncs6trStfdd}tt|S)Ncs:|i|WdS1s,0YdSN)clone)argskwargsr selfT/var/www/html/django/DPS/env/lib/python3.9/site-packages/torch/autograd/grad_mode.pydecorate_contexts z;_DecoratorContextManager.__call__..decorate_context)inspectisgeneratorfunction_wrap_generator functoolswrapsrr )rr rrrr__call__s   z!_DecoratorContextManager.__call__cstfdd}|S)z7Wrap each generator invocation with the context managerc ?sD|i|}z|d}Wdn1s:0Yz |V}Wnty|Wdn1s0YYqDty|jt}Wdn1s0YYqD0||}WdqD1s0YqDWn,ty>}z|j WYd}~Sd}~00dSr) rsend GeneratorExitclose BaseExceptionthrowsysexc_info StopIterationvalue)rrgenresponserequesterrrgenerator_context s" (   &  2 0zC_DecoratorContextManager._wrap_generator..generator_context)rr)rr r+rrrrs)z(_DecoratorContextManager._wrap_generatorNrcCstdSrNotImplementedErrorrrrr __enter__Lsz"_DecoratorContextManager.__enter__exc_type exc_value tracebackrcCstdSrr-rr2r3r4rrr__exit__Osz!_DecoratorContextManager.__exit__cCs|Sr __class__r/rrrrRsz_DecoratorContextManager.clone) __name__ __module__ __qualname____doc__r rrr0rr6rrrrrr s  .r csHeZdZdZddfdd ZddddZeeeddd d ZZS) ra-Context-manager that disabled gradient calculation. Disabling gradient calculation is useful for inference, when you are sure that you will not call :meth:`Tensor.backward()`. It will reduce memory consumption for computations that would otherwise have `requires_grad=True`. In this mode, the result of every computation will have `requires_grad=False`, even when the inputs have `requires_grad=True`. This context manager is thread local; it will not affect computation in other threads. Also functions as a decorator. (Make sure to instantiate with parenthesis.) .. note:: No-grad is one of several mechanisms that can enable or disable gradients locally see :ref:`locally-disable-grad-doc` for more information on how they compare. .. note:: This API does not apply to :ref:`forward-mode AD `. If you want to disable forward AD for a computation, you can unpack your dual tensors. Example:: >>> x = torch.tensor([1.], requires_grad=True) >>> with torch.no_grad(): ... y = x * 2 >>> y.requires_grad False >>> @torch.no_grad() ... def doubler(x): ... return x * 2 >>> z = doubler(x) >>> z.requires_grad False Nr,cstjstd|_dSNF)torch _jit_internal is_scriptingsuper__init__prevr/r7rrrB~s  zno_grad.__init__cCst|_tddSr=)r>is_grad_enabledrCrr/rrrr0s zno_grad.__enter__r1cCst|jdSr)r>rrCr5rrrr6szno_grad.__exit__) r9r:r;r<rBr0rr6 __classcell__rrr7rrWs&rc@s2eZdZdZddddZeeeddddZdS) raHContext-manager that enables gradient calculation. Enables gradient calculation, if it has been disabled via :class:`~no_grad` or :class:`~set_grad_enabled`. This context manager is thread local; it will not affect computation in other threads. Also functions as a decorator. (Make sure to instantiate with parenthesis.) .. note:: enable_grad is one of several mechanisms that can enable or disable gradients locally see :ref:`locally-disable-grad-doc` for more information on how they compare. .. note:: This API does not apply to :ref:`forward-mode AD `. Example:: >>> x = torch.tensor([1.], requires_grad=True) >>> with torch.no_grad(): ... with torch.enable_grad(): ... y = x * 2 >>> y.requires_grad True >>> y.backward() >>> x.grad >>> @torch.enable_grad() ... def doubler(x): ... return x * 2 >>> with torch.no_grad(): ... z = doubler(x) >>> z.requires_grad True Nr,cCst|_tjddS)NT)r>rDrC_C_set_grad_enabledr/rrrr0s zenable_grad.__enter__r1cCstj|jdSrr>rFrGrCr5rrrr6szenable_grad.__exit__)r9r:r;r<r0rr6rrrrrs%rc@sJeZdZdZeddddZddddZeeedd d d Zd d Z dS)raContext-manager that sets gradient calculation to on or off. ``set_grad_enabled`` will enable or disable grads based on its argument :attr:`mode`. It can be used as a context-manager or as a function. This context manager is thread local; it will not affect computation in other threads. Args: mode (bool): Flag whether to enable grad (``True``), or disable (``False``). This can be used to conditionally enable gradients. .. note:: set_grad_enabled is one of several mechanisms that can enable or disable gradients locally see :ref:`locally-disable-grad-doc` for more information on how they compare. .. note:: This API does not apply to :ref:`forward-mode AD `. Example:: >>> x = torch.tensor([1.], requires_grad=True) >>> is_train = False >>> with torch.set_grad_enabled(is_train): ... y = x * 2 >>> y.requires_grad False >>> torch.set_grad_enabled(True) >>> y = x * 2 >>> y.requires_grad True >>> torch.set_grad_enabled(False) >>> y = x * 2 >>> y.requires_grad False N)modercCs t|_tj|||_dSr)r>rDrCrFrGrIrrIrrrrBs  zset_grad_enabled.__init__r,cCsdSrrr/rrrr0szset_grad_enabled.__enter__r1cCstj|jdSrrHr5rrrr6szset_grad_enabled.__exit__cCs ||jSrr8rIr/rrrrszset_grad_enabled.clone) r9r:r;r<boolrBr0rr6rrrrrrs (rcsFeZdZdZd fdd ZddZeeeddd d Zd d ZZ S)r aContext-manager that enables or disables inference mode InferenceMode is a new context manager analogous to :class:`~no_grad` to be used when you are certain your operations will have no interactions with autograd (e.g., model training). Code run under this mode gets better performance by disabling view tracking and version counter bumps. Note that unlike some other mechanisms that locally enable or disable grad, entering inference_mode also disables to :ref:`forward-mode AD `. This context manager is thread local; it will not affect computation in other threads. Also functions as a decorator. (Make sure to instantiate with parenthesis.) .. note:: Inference mode is one of several mechanisms that can enable or disable gradients locally see :ref:`locally-disable-grad-doc` for more information on how they compare. Args: mode (bool): Flag whether to enable or disable inference mode Example:: >>> import torch >>> x = torch.ones(1, 2, 3, requires_grad=True) >>> with torch.inference_mode(): ... y = x * x >>> y.requires_grad False >>> y._version Traceback (most recent call last): File "", line 1, in RuntimeError: Inference tensors do not track version counter. >>> @torch.inference_mode() ... def func(x): ... return x * x >>> out = func(x) >>> out.requires_grad False Tcs$tjstd|_||_dSr)r>r?r@rArB_inference_mode_raii_guardrIrJr7rrrBs  zinference_mode.__init__cCstj|j|_dSr)r>rFZ_InferenceModerIrMr/rrrr0#szinference_mode.__enter__Nr1cCs|`dSr)rMr5rrrr6&szinference_mode.__exit__cCs ||jSrrKr/rrrr)szinference_mode.clone)T) r9r:r;r<rBr0rr6rrErrr7rr s )r )r#r>rrtypingrrrr__all__ZFuncTyper r rrrr rrrrs  F4.8