torch.autograd.grad_mode 源代码
# mypy: 允许未类型化定义
来自
打字
导入
任何,
联合
导入
火炬
来自 torch.utils._contextlib
导入 (
装饰器上下文管理器,
_NoParamDecoratorContextManager,
F,
)
全部 = [
"关闭梯度",
"启用梯度",
set_grad_enabled,
"推理模式",
set_multithreading_enabled,
]
[文档]
类
不梯度(_NoParamDecoratorContextManager):
r"""上下文管理器，用于禁用梯度计算。
禁用梯度计算对于推理很有用，当你确定
你不会调用 :meth:`Tensor.backward()` 方法时。这将减少内存
消耗原本需要 `requires_grad=True` 的计算。
在此模式下，每次计算的输出都将
`requires_grad=False`，即使输入有 `requires_grad=True`。
存在一个例外！所有工厂函数，或者创建
新的 Tensor 和带 requires_grad 参数，将不会受到影响。
这种模式。
此上下文管理器是线程局部；它不会影响其他线程的计算。
。
也可用作装饰器。
.. 注意::
No-grad 是能够启用或禁用局部梯度的几种机制之一，
有关它们如何比较的更多信息，请参阅：:ref:`locally-disable-grad-doc`。
有关它们如何比较的更多信息，请参阅：:ref:`locally-disable-grad-doc`。
.. 注意::
此 API 不适用于：ref:`正向模式 AD `.
如果您想禁用计算中的正向 AD，您可以解包您的双张量。
您的双张量。
示例::
>>> # xdoctest: +SKIP
>>> x = torch.tensor([1.], requires_grad=True)
>>> with torch.no_grad():
... y = x * 2
>>> y.requires_grad
False
>>> @torch.no_grad()
... def 双倍器(x):
... 返回 x * 2
>>> z = 双倍器(x)
>>> z.requires_grad
False
>>> @torch.no_grad()
... def tripler(x):
... return x * 3
>>> z = tripler(x)
>>> z.requires_grad
False
>>> # 工厂函数异常
>>> with torch.no_grad():
... a = torch.nn.Parameter(torch.rand(10))
>>> a 需要梯度
True
"""
def __init__(self) -> 无:
如果
不
PyTorch._jit_internal.
是否正在脚本化():
超级().__init__()
self.上一个 =
假
def __进入__(self) ->
无:
self.上一个 =
PyTorch.
梯度是否启用()
PyTorch.
设置梯度启用(False)
def __退出__(self,
异常类型:
任何, exc_value:
任何,
跟踪回溯:
任何) ->
无:
PyTorch.
设置梯度启用(self.
上一页)
[文档]
类
启用梯度(_NoParamDecoratorContextManager):
r上下文管理器，用于启用梯度计算。
如果通过 :class:`~no_grad` 或 :class:`~set_grad_enabled` 禁用了梯度计算，则启用梯度计算。
。
这个上下文管理器是线程局部的；它不会影响其他线程的计算
。
它还充当装饰器。
.. 注意::
enable_grad 是可以启用或禁用梯度的几种机制之一。
本地禁用渐变，请参阅：:ref:`locally-disable-grad-doc` 了解更多信息。
了解它们如何比较的更多信息。
.. 注意::
此 API 不适用于：ref:`forward-mode AD 》。
示例::
>>> # xdoctest: +SKIP
>>> 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
tensor([2.])
>>> @torch.enable_grad()
... def 双倍器(x):
... 返回 x * 2
>>> with torch.no_grad():
... z = 双倍器(x)
>>> z.requires_grad
True
>>> @torch.enable_grad()
... def tripler(x):
... return x * 3
>>> with torch.no_grad():
... z = tripler(x)
>>> z.requires_grad
True
"""
def __进入__(self) ->
无:
self.上一个 =
PyTorch.
梯度是否启用()
PyTorch._C._set_grad_enabled(True)
def __退出__(self,
异常类型:
任何, exc_value:
任何,
跟踪回溯:
任何) ->
无:
PyTorch._C._set_grad_enabled(self.
上一页)
[文档]
类
设置梯度启用(
装饰器上下文管理器):
r上下文管理器，用于开启或关闭梯度计算。
``set_grad_enabled`` 根据其参数 :attr:`mode` 来启用或禁用梯度。
它可以用作上下文管理器或函数。
此上下文管理器是线程局部变量；它不会影响计算
在其他线程中。
参数：
模式（布尔值）：启用 grad（``True``）或禁用
（``False``）。这可以用来有条件地启用
渐变。
.. 注意::
set_grad_enabled 是可以启用或禁用局部梯度的几种机制之一，有关它们如何比较的更多信息，请参阅 :ref:`locally-disable-grad-doc`。
更多信息，请参阅 :ref:`locally-disable-grad-doc`。
更多信息，请参阅 :ref:`locally-disable-grad-doc`。
.. 注意::
此 API 不适用于：ref:`正向模式 AD `.
示例::
>>> # xdoctest: +SKIP
>>> 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
"""
def __init__(self, 模式: bool) ->
无:
self.上一个 =
PyTorch.
梯度是否启用()
self.模式 =
模式
PyTorch._C.
设置梯度启用(
模式)
def __调用__(self,
原始函数: F) -> F:
PyTorch._C.
设置梯度启用(self.
上一页)
返回
超级().
__调用__(
原始函数)
def __进入__(self) ->
无:
PyTorch._C.
_设置梯度启用(self.
模式)
def __退出__(self,
异常类型:
任何, exc_value:
任何,
跟踪回溯:
任何) ->
无:
PyTorch._C.
_设置梯度启用(self.
上一页)
[文档] def clone(self) -> "设置梯度启用":
r"""
创建此类的副本
"""
返回 self.__class__(self.mode)
[文档]
类 inference_mode(
装饰器上下文管理器):
r上下文管理器，用于启用或禁用推理模式。
推理模式是一个类似于 :class:`~no_grad` 的上下文管理器
用于您确定您的操作不会产生交互时
使用自动微分（例如，模型训练）。在此模式下运行的代码性能更佳
通过禁用视图跟踪和版本计数器更新来提高性能。注意
与一些其他本地启用或禁用 grad 的机制不同，
进入推理模式也会禁用到：ref:`前向模式 AD `.
此上下文管理器是线程局部；它不会影响其他线程的计算
。
也可用作装饰器。
.. 注意::
推理模式是多种机制之一，可以启用或禁用局部梯度，有关它们如何比较的更多信息，请参阅：:ref:`局部禁用梯度文档`。
禁用局部梯度，有关它们如何比较的更多信息，请参阅：:ref:`局部禁用梯度文档`。
更多信息，请参阅：:ref:`局部禁用梯度文档`。
参数：
模式（bool 或函数）：启用或禁用该模式的布尔标志或函数
禁用推理模式或用于装饰的 Python 函数
推理模式已启用
示例::
>>> # xdoctest: +REQUIRES(环境:TORCH_DOCTEST_AUTOGRAD)
>>> 导入 torch
>>> x = torch.ones(1, 2, 3, requires_grad=True)
>>> with torch.inference_mode():
... y = x * x
>>> y.requires_grad
False
>>> # xdoctest: +SKIP("想要字符串并不完全正确")
>>> y._version
Traceback (most recent call last):
文件 "", 行 1，在 中
RuntimeError: 推理张量不跟踪版本计数器。
>>> @torch.inference_mode()
... def func(x):
... return x * x
>>> out = func(x)
>>> out.requires_grad
False
>>> @torch.inference_mode()
... def doubler(x):
... return x * 2
>>> out = doubler(x)
>>> out.requires_grad
False
"""
def __init__(self, 模式:
布尔值 = True) ->
无:
如果
不
PyTorch._jit_internal.
是否正在脚本化():
超级().__init__()
self.模式 =
模式
def __new__(类,
模式=True):
如果 isinstance(
模式, bool):
返回
超级().__new__(
类)
返回
类()(
模式)
def __进入__(self) ->
无:
self._inference_mode_context = PyTorch._C._InferenceMode(self.
模式)
self._inference_mode_context.__进入__()
def __退出__(self,
异常类型:
任何, exc_value:
任何,
跟踪回溯:
任何) ->
无:
self._inference_mode_context.__退出__(
异常类型, exc_value,
跟踪回溯)
[文档] def clone(self) -> "推理模式":
r"""
创建本类的副本
"""
返回当前类的实例(self.__class__(self.mode))
def _进入推理模式(
模式):
模式上下文 =
PyTorch._C.
推理模式(
模式)
模式上下文.
__进入__()
返回
模式上下文
def 退出推理模式(
模式):
模式.
__退出__(
无,
无,
无)
[文档]class set_multithreading_enabled(_DecoratorContextManager):
r"""多线程回溯开启或关闭的上下文管理器。
``set_multithreading_enabled`` 将根据其参数 :attr:`mode` 启用或禁用多线程回溯。
它可以用作上下文管理器或函数。
这个上下文管理器是线程局部的；它不会影响其他线程的计算
在其他线程中。
参数：
模式（布尔值）：标志是否启用多线程反向（``True``），或禁用
（``False``）.
.. 注意::
该 API 不适用于：ref:`前向模式 AD `.
"""
def __init__(self, mode: bool) -> None:
self.prev = torch._C._is_multithreading_enabled()
torch._C._set_multithreading_enabled(mode)
self.mode = mode
def __enter__(self) -> None:
pass
def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
torch._C._set_multithreading_enabled(self.prev)
[文档] def clone(self) -> "启用多线程":
r"""
创建本类的副本
"""
return self.__class__(self.mode)
_强制原始视图跟踪(
装饰器上下文管理器):
r上下文管理器，用于设置是否在 autograd 中始终启用视图回放。
`set_view_replay_enabled` 方法将根据其参数 :attr:`mode` 启用或禁用视图回放。
它可以作为上下文管理器或函数使用。
此上下文管理器是线程局部变量；它不会影响计算
在其他线程中。
当张量视图被修改时，自动微分引擎需要决定是否
通过重新播放从更新后的基础视图链来重新生成“更新视图”
或通过一次调用 as_strided。
如果将 set_view_replay_enabled 设置为 True，则 autograd 将始终使用视图重放。
否则，它将回退到现有的逻辑。
参数：
模式（布尔值）：标志是否启用视图重放（``True``），或禁用
(``False``)
"""
def __init__(self, 模式: bool) ->
无:
self.上一个 =
PyTorch._C._is_view_replay_enabled()
PyTorch._C._set_view_replay_enabled(
模式)
self.模式 =
模式
def __进入__(self) ->
无:
通过
def __退出__(self,
异常类型:
任何, exc_value:
任何,
跟踪回溯:
任何) ->
无:
PyTorch._C._set_view_replay_enabled(self.
上一页)
def 克隆(self):
返回 self.
类(self.
模式)
类
_不安全保留版本计数器(
装饰器上下文管理器):
r除非你确切知道你在做什么，否则不要使用此功能。
此上下文管理器可能导致代码其他部分的任意静默正确性问题。
（即使这些部分没有直接受到上下文管理器的直接影响）！
通常，autograd 会通过递增其 `._version` 属性来跟踪对张量的修改。
这通常对正确性很重要，例如，对于反向传播过程中保存的 tensor 进行修改可能会导致梯度不正确，而 autograd 使用版本计数器来检测这种情况并报错。
然而，在极少数情况下，可能需要隐藏对 autograd 的修改。例如：
和错误。
但是，在极少数情况下，可能需要隐藏对 autograd 的修改。例如：
如果一个张量非常大，并且您想将其存储在其他地方以释放其内存，并在需要时重新填充
该张量，以便在 autograd 之前使用。
参数：
张量（torch.Tensor）：您想要保留版本计数器的张量。
.. 注意::
此 API 不适用于：ref：`forward-mode AD `。
"""
def __init__(self, 张量:
联合[
PyTorch.
张量,
元组[
PyTorch.
张量, ...]]) ->
无:
self.张量 = (
张量,)
如果 isinstance(
张量,
PyTorch.
张量)
否则
张量
断言 isinstance(self.
张量,
元组)
self.前版本 =
元组(t._version for t
在 self.
张量)
def __进入__(self) ->
无:
通过
def __退出__(self, *
参数) ->
无:
PyTorch._C.
_自动微分.
_不安全设置版本计数器(self.
张量, self.
前版本)
