自动微分包 - torch.autograd¶
torch.autograd
提供用于实现任意标量值函数的自动微分的类和函数。
它需要对现有代码进行最少的更改 - 您只需要使用 Tensor
s 来声明需要计算梯度的 requires_grad=True
关键字。到目前为止,我们只支持浮点类型 Tensor
s (half, float, double 和 bfloat16) 以及复数类型 Tensor
s (cfloat, cdouble) 的 autograd。
计算给定张量相对于图叶的梯度之和。 |
|
计算并返回输出相对于输入的梯度之和。 |
前向模式自动微分¶
警告
此 API 处于测试阶段。即使函数签名不太可能改变,在我们将此 API 视为稳定之前,我们也计划改进运算符覆盖率。
请参阅 前向模式自动微分教程,了解有关如何使用此 API 的详细步骤。
用于前向自动微分的上下文管理器,所有前向自动微分计算必须在 |
|
将张量值与其切线相关联,以创建一个用于前向自动微分梯度计算的“双重张量”。 |
|
解包“双重张量”以获取其张量值和前向自动微分梯度。 |
|
进入新的前向梯度级别。 |
|
退出前向梯度级别。 |
|
由 |
功能性更高级别的 API¶
警告
此 API 处于测试阶段。即使函数签名不太可能改变,在我们将此 API 视为稳定之前,我们也计划大幅度改进性能。
本节包含 autograd 的更高级别的 API,它建立在上面的基本 API 之上,并允许您计算雅可比矩阵、海森矩阵等等。
此 API 与仅使用张量作为输入并仅返回张量的用户提供的函数一起使用。如果您的函数使用其他参数,这些参数不是张量或没有设置 requires_grad 的张量,则可以使用 lambda 来捕获它们。例如,对于一个名为 f
的函数,它接受三个输入,一个我们想要计算其雅可比矩阵的张量、另一个应视为常量的张量以及一个布尔标志,如下所示 f(input, constant, flag=flag)
,您可以将其用作 functional.jacobian(lambda x: f(x, constant, flag=flag), input)
。
计算给定函数的雅可比矩阵。 |
|
计算给定标量函数的海森矩阵。 |
|
计算向量 |
|
计算给定函数在输入给出的点处的雅可比矩阵与向量 |
|
计算向量 |
|
计算标量函数的海森矩阵与向量 |
局部禁用梯度计算¶
有关 no-grad 和推理模式之间的区别以及可能与这两个模式相混淆的其他相关机制的更多信息,请参阅 局部禁用梯度计算。此外,请参阅 局部禁用梯度计算,了解可用于局部禁用梯度的函数列表。
默认梯度布局¶
当非稀疏 param
在 torch.autograd.backward()
或 torch.Tensor.backward()
期间接收到非稀疏梯度时,param.grad
将按以下方式累加。
如果 param.grad
最初为 None
如果
param
的内存是非重叠且密集的,则.grad
将使用与param
匹配的步幅创建(因此与param
的布局匹配)。否则,
.grad
将使用行主序连续步幅创建。
如果 param
已经具有非稀疏 .grad
属性
如果
create_graph=False
,backward()
会将梯度累积到.grad
中,并保留其步长。如果
create_graph=True
,backward()
会用一个新的张量.grad + new grad
替换.grad
,并尝试(但不保证)匹配现有.grad
的步长。
建议使用默认行为(在第一次调用 backward()
之前,.grad
为 None
,因此它们的布局根据 1 或 2 创建,并根据 3 或 4 保持一段时间),以获得最佳性能。调用 model.zero_grad()
或 optimizer.zero_grad()
不会影响 .grad
布局。
实际上,在每次累积阶段之前将所有 .grad
重置为 None
,例如:
for iterations...
...
for param in model.parameters():
param.grad = None
loss.backward()
这样它们每次都根据 1 或 2 重新创建,是 model.zero_grad()
或 optimizer.zero_grad()
的有效替代方案,可能可以提高某些网络的性能。
手动梯度布局¶
如果您需要手动控制 .grad
的步长,在第一次调用 backward()
之前,将 param.grad =
赋值为一个具有所需步长的零值张量,并且不要将其重置为 None
。3 保证您的布局在 create_graph=False
的情况下被保留。4 表明您的布局很可能被保留,即使 create_graph=True
。
张量上的就地操作¶
在自动微分中支持就地操作是一个难题,在大多数情况下我们不建议使用它们。自动微分的积极缓冲区释放和重用使其非常高效,在极少数情况下,就地操作实际上可以显着降低内存使用量。除非您在巨大的内存压力下操作,否则您可能永远不需要使用它们。
就地正确性检查¶
所有 Tensor
都跟踪对它们应用的就地操作,如果实现检测到一个张量在某个函数中被保存以供反向传播,但之后被就地修改,则在启动反向传播时会引发错误。这确保了,如果您使用就地函数且没有看到任何错误,您可以确信计算的梯度是正确的。
变量(已弃用)¶
警告
Variable API 已弃用:不再需要变量来使用自动微分与张量。自动微分自动支持将 requires_grad
设置为 True
的张量。下面请找到关于更改内容的简要指南。
Variable(tensor)
和Variable(tensor, requires_grad)
仍然按预期工作,但它们返回的是张量,而不是变量。var.data
与tensor.data
相同。诸如
var.backward(), var.detach(), var.register_hook()
之类的方法现在可以使用相同的名称在张量上使用。
此外,现在可以使用诸如 torch.randn()
、torch.zeros()
、torch.ones()
等等工厂方法来创建 requires_grad=True
的张量,如下所示:
autograd_tensor = torch.randn((2, 3, 4), requires_grad=True)
张量自动微分函数¶
|
此属性默认情况下为 |
|
如果需要为该张量计算梯度,则为 |
|
根据惯例,所有 |
|
计算当前张量相对于图叶的梯度。 |
|
返回一个新的张量,与当前图分离。 |
|
将张量与创建它的图分离,使其成为一个叶。 |
|
注册反向钩子。 |
|
注册一个在梯度累积后运行的反向钩子。 |
|
使该张量能够在调用 |
函数¶
- class torch.autograd.Function(*args, **kwargs)[source]¶
用于创建自定义 autograd.Function 的基类。
要创建自定义 autograd.Function,请继承此类并实现
forward()
和backward()
静态方法。然后,要将您的自定义操作用于前向传播,请调用类方法apply
。不要直接调用forward()
。为了确保正确性和最佳性能,请确保您在
ctx
上调用了正确的方法,并使用torch.autograd.gradcheck()
验证您的反向函数。有关如何使用此类的更多详细信息,请参阅 扩展 torch.autograd。
示例
>>> class Exp(Function): >>> @staticmethod >>> def forward(ctx, i): >>> result = i.exp() >>> ctx.save_for_backward(result) >>> return result >>> >>> @staticmethod >>> def backward(ctx, grad_output): >>> result, = ctx.saved_tensors >>> return grad_output * result >>> >>> # Use it by calling the apply method: >>> output = Exp.apply(input)
定义自定义自动微分函数的前向传播。 |
|
定义使用反向模式自动微分来区分操作的公式。 |
|
定义使用前向模式自动微分来区分操作的公式。 |
|
定义此 autograd.Function 在 |
上下文方法混合¶
在创建新的 Function
时,以下方法可用于 ctx。
将给定的张量标记为在就地操作中被修改。 |
|
将输出标记为不可微分。 |
|
为将来对 |
|
设置是否实现梯度张量。 |
自定义函数实用程序¶
反向方法的装饰器。
用于构建 PyTorch 实用程序的自定义 Function
基类
此类用于内部自动微分工作。 |
|
此类仅出于向后兼容的原因而存在。 |
|
此类仅出于向后兼容的原因而存在。 |
数值梯度检查¶
使用小有限差分检查通过分析梯度计算的梯度,这些梯度与 |
|
使用小有限差分检查通过分析梯度计算的梯度的梯度,这些梯度与 |
|
由 |
分析器¶
Autograd 包含一个分析器,可用于检查模型中不同运算符的成本,包括 CPU 和 GPU。目前已实现三种模式:仅 CPU 模式,使用 profile
。基于 nvprof 的模式(注册 CPU 和 GPU 活动),使用 emit_nvtx
。以及基于 vtune 分析器的模式,使用 emit_itt
。
- class torch.autograd.profiler.profile(enabled=True, *, use_cuda=False, use_device=None, record_shapes=False, with_flops=False, profile_memory=False, with_stack=False, with_modules=False, use_kineto=False, use_cpu=True, experimental_config=None, acc_events=False)[source]¶
管理 autograd 分析器状态并保存结果摘要的上下文管理器。
在底层,它只记录 C++ 中执行的函数的事件,并将这些事件暴露给 Python。您可以将任何代码包装到其中,它只报告 PyTorch 函数的运行时间。注意:分析器是线程本地的,并自动传播到异步任务中。
- 参数
enabled (bool, 可选) – 将此设置为 False 使此上下文管理器成为无操作。
use_cuda (bool, 可选) – 使用 cudaEvent API 启用 CUDA 事件的计时。(将被弃用)
use_device (str, 可选) – 启用设备事件的计时。当使用 cuda 时,为每个张量操作添加大约 4us 的开销。有效的设备选项为 'cuda'、'xpu'、'mtia' 和 'privateuseone'。
record_shapes (bool, 可选) – 如果设置了形状记录,将收集有关输入维度的信息。这使您能够查看哪些维度已在底层使用,并使用 prof.key_averages(group_by_input_shape=True) 对其进行进一步分组。请注意,形状记录可能会扭曲您的分析数据。建议使用单独的运行(有无形状记录)来验证计时。最有可能的是,对于最底层的事件(在嵌套函数调用情况下),扭曲将可以忽略不计。但是,对于更高级别的函数,由于形状收集,总的 self cpu 时间可能会被人工增加。
with_flops (bool, 可选) – 如果设置了 with_flops,分析器将使用运算符的输入形状估计 FLOPs(浮点运算)值。这使您能够估计硬件性能。目前,此选项仅适用于矩阵乘法和 2D 卷积运算符。
profile_memory (bool, 可选) – 跟踪张量内存分配/释放。
with_stack (bool, 可选) – 记录操作的源信息(文件和行号)。
with_modules (bool) – 记录对应于操作调用栈的模块层次结构(包括函数名称)。例如,如果模块 A 的 forward 调用模块 B 的 forward,而该 forward 包含一个 aten::add 操作,则 aten::add 的模块层次结构为 A.B。请注意,这种支持目前仅适用于 TorchScript 模型,而不适用于急切模式模型。
use_kineto (bool, 可选) – 实验性功能,使用 Kineto 分析器启用分析。
use_cpu (bool, 可选) – 分析 CPU 事件;设置为
False
需要use_kineto=True
,可用于降低仅 GPU 分析的开销。experimental_config (_ExperimentalConfig) – Kineto 等分析器库使用的一组实验性选项。注意,不保证向后兼容性。
acc_events (bool) – 启用跨多个分析周期的 FunctionEvents 的累积
示例
>>> x = torch.randn((1, 1), requires_grad=True) >>> with torch.autograd.profiler.profile() as prof: >>> for _ in range(100): # any normal python code, really! >>> y = x ** 2 >>> y.backward() >>> # NOTE: some columns were removed for brevity >>> print(prof.key_averages().table(sort_by="self_cpu_time_total")) ----------------------------------- --------------- --------------- --------------- Name Self CPU total CPU time avg Number of Calls ----------------------------------- --------------- --------------- --------------- mul 32.048ms 32.048ms 200 pow 27.041ms 27.041ms 200 PowBackward0 9.727ms 55.483ms 100 torch::autograd::AccumulateGrad 9.148ms 9.148ms 100 torch::autograd::GraphRoot 691.816us 691.816us 100 ----------------------------------- --------------- --------------- ---------------
将 EventList 导出为 Chrome 跟踪工具文件。 |
|
对所有函数事件在其键上的平均值。 |
|
返回在 CPU 上花费的总时间。 |
|
对所有事件的平均值。 |
|
如果键出现超过一次,则引发错误。 |
|
提供了一个抽象,用于在全局范围内递增步数。 |
|
上下文管理器/函数装饰器,在运行 autograd 分析器时向代码块/函数添加标签。 |
|
用于访问区间中的 mem_records 的加速结构。 |
|
- class torch.autograd.profiler.emit_nvtx(enabled=True, record_shapes=False)[source]¶
上下文管理器,使每个 autograd 操作都发出一个 NVTX 范围。
在 nvprof 下运行程序时非常有用
nvprof --profile-from-start off -o trace_name.prof -- <regular command here>
不幸的是,没有办法强制 nvprof 将其收集的数据刷新到磁盘,因此对于 CUDA 分析,必须使用此上下文管理器来注释 nvprof 跟踪,并在检查跟踪之前等待进程退出。然后,可以使用 NVIDIA Visual Profiler (nvvp) 来可视化时间线,或者可以使用
torch.autograd.profiler.load_nvprof()
加载结果以进行检查(例如,在 Python REPL 中)。- 参数
enabled (bool, 可选) – 将
enabled=False
设置为使此上下文管理器成为无操作。默认值:True
。record_shapes (bool, 可选) – 如果
record_shapes=True
,则包装每个 autograd 操作的 nvtx 范围将以以下格式追加有关该操作接收的张量参数大小的信息:[[arg0.size(0), arg0.size(1), ...], [arg1.size(0), arg1.size(1), ...], ...]
非张量参数将用[]
表示。参数将按它们被后端操作接收的顺序列出。请注意,此顺序可能与这些参数在 Python 端传递时的顺序不匹配。另请注意,形状记录可能会增加 nvtx 范围创建的开销。默认值:False
示例
>>> with torch.cuda.profiler.profile(): ... model(x) # Warmup CUDA memory allocator and profiler ... with torch.autograd.profiler.emit_nvtx(): ... model(x)
前向-反向相关性
在 Nvidia Visual Profiler 中查看使用
emit_nvtx
创建的配置文件时,将每个反向传递操作与对应的正向传递操作相关联可能很困难。为了简化此任务,emit_nvtx
将序列号信息追加到其生成的范围中。在正向传递期间,每个函数范围都用
seq=<N>
装饰。seq
是一个运行计数器,每次创建一个新的反向 Function 对象时都会递增,并为反向传递存储起来。因此,与每个正向函数范围关联的seq=<N>
注释告诉您,如果由此正向函数创建了一个反向 Function 对象,则该反向对象将接收序列号 N。在反向传递期间,包装每个 C++ 反向 Function 的apply()
调用的顶层范围用stashed seq=<M>
装饰。M
是反向对象创建时的序列号。通过比较反向传递中的stashed seq
数字和正向传递中的seq
数字,您可以跟踪哪个正向操作创建了每个反向 Function。在反向传播期间执行的任何函数也都用
seq=<N>
装饰。在默认的反向传播(使用create_graph=False
)中,此信息无关紧要,实际上,所有此类函数的N
可能只是 0。只有与反向函数对象的apply()
方法相关的顶级范围才有用,作为将这些函数对象与之前的正向传播相关联的一种方式。双向反向传播
另一方面,如果正在进行使用
create_graph=True
的反向传播(换句话说,如果你正在为双向反向传播做准备),则反向传播期间每个函数的执行都将获得一个非零的、有用的seq=<N>
。这些函数本身可能会创建要在稍后的双向反向传播期间执行的函数对象,就像正向传播中的原始函数一样。反向传播和双向反向传播之间的关系在概念上与正向传播和反向传播之间的关系相同:函数仍然会发出带有当前序列号标签的范围,它们创建的函数对象仍然会存储这些序列号,并且在最终的双向反向传播期间,函数对象的apply()
范围仍然带有stashed seq
号码,可以与来自反向传播的 seq 号码进行比较。
- class torch.autograd.profiler.emit_itt(enabled=True, record_shapes=False)[source]¶
上下文管理器,它使每个自动微分操作都发出一个 ITT 范围。
在使用 Intel(R) VTune 分析器运行程序时,它很有用
vtune <--vtune-flags> <regular command here>
仪器和跟踪技术 (ITT) API 使您的应用程序能够在其执行期间跨不同的 Intel 工具生成和控制跟踪数据的收集。此上下文管理器用于注释 Intel(R) VTune 分析器跟踪。借助此上下文管理器,您将能够在 Intel(R) VTune 分析器 GUI 中看到带标签的范围。
- 参数
enabled (bool, 可选) – 将
enabled=False
设置为使此上下文管理器成为无操作。默认值:True
。record_shapes (bool, optional) – 如果
record_shapes=True
,则包装每个自动微分操作的 itt 范围将以以下格式追加有关该操作接收的张量参数大小的信息:[[arg0.size(0), arg0.size(1), ...], [arg1.size(0), arg1.size(1), ...], ...]
非张量参数将用[]
表示。参数将按它们被后端操作接收的顺序列出。请注意,此顺序可能与在 Python 端传递这些参数的顺序不匹配。还要注意,形状记录可能会增加 itt 范围创建的开销。默认值:False
示例
>>> with torch.autograd.profiler.emit_itt(): ... model(x)
打开一个 nvprof 跟踪文件并解析自动微分注释。 |
调试和异常检测¶
- class torch.autograd.detect_anomaly(check_nan=True)[source]¶
上下文管理器,用于为自动微分引擎启用异常检测。
这将做两件事
使用启用的检测运行正向传播将允许反向传播打印创建失败的反向函数的正向操作的回溯。
如果
check_nan
为True
,则任何生成“nan”值的反向计算都将引发错误。默认值True
。
警告
此模式应该仅在调试时启用,因为不同的测试会降低程序执行速度。
示例
>>> import torch >>> from torch import autograd >>> class MyFunc(autograd.Function): ... @staticmethod ... def forward(ctx, inp): ... return inp.clone() ... @staticmethod ... def backward(ctx, gO): ... # Error during the backward pass ... raise RuntimeError("Some error in backward") ... return gO.clone() >>> def run_fn(a): ... out = MyFunc.apply(a) ... return out.sum() >>> inp = torch.rand(10, 10, requires_grad=True) >>> out = run_fn(inp) >>> out.backward() Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/your/pytorch/install/torch/_tensor.py", line 93, in backward torch.autograd.backward(self, gradient, retain_graph, create_graph) File "/your/pytorch/install/torch/autograd/__init__.py", line 90, in backward allow_unreachable=True) # allow_unreachable flag File "/your/pytorch/install/torch/autograd/function.py", line 76, in apply return self._forward_cls.backward(self, *args) File "<stdin>", line 8, in backward RuntimeError: Some error in backward >>> with autograd.detect_anomaly(): ... inp = torch.rand(10, 10, requires_grad=True) ... out = run_fn(inp) ... out.backward() Traceback of forward call that caused the error: File "tmp.py", line 53, in <module> out = run_fn(inp) File "tmp.py", line 44, in run_fn out = MyFunc.apply(a) Traceback (most recent call last): File "<stdin>", line 4, in <module> File "/your/pytorch/install/torch/_tensor.py", line 93, in backward torch.autograd.backward(self, gradient, retain_graph, create_graph) File "/your/pytorch/install/torch/autograd/__init__.py", line 90, in backward allow_unreachable=True) # allow_unreachable flag File "/your/pytorch/install/torch/autograd/function.py", line 76, in apply return self._forward_cls.backward(self, *args) File "<stdin>", line 8, in backward RuntimeError: Some error in backward
- class torch.autograd.set_detect_anomaly(mode, check_nan=True)[source]¶
上下文管理器,用于打开或关闭自动微分引擎的异常检测。
set_detect_anomaly
将根据其参数mode
启用或禁用自动微分异常检测。它可以用作上下文管理器或函数。有关异常检测行为的详细信息,请参阅上面的
detect_anomaly
。
上下文管理器,用于打开或关闭多线程反向传播。 |
自动微分图¶
自动微分公开了一些方法,允许人们检查图并在反向传播期间插入行为。
的 grad_fn
属性 torch.Tensor
持有一个 torch.autograd.graph.Node
如果张量是自动微分记录的操作的输出(即,grad_mode 已启用,并且至少一个输入需要梯度),否则为 None
。
返回名称。 |
|
返回元数据。 |
|
注册一个反向钩子。 |
|
注册一个反向预钩子。 |
|
更新自动微分元数据,跟踪给定张量是否已就地修改。 |
某些操作需要在正向传播期间保存中间结果才能执行反向传播。这些中间结果将作为属性保存在 grad_fn
中,并且可以访问。例如
>>> a = torch.tensor([0., 0., 0.], requires_grad=True)
>>> b = a.exp()
>>> print(isinstance(b.grad_fn, torch.autograd.graph.Node))
True
>>> print(dir(b.grad_fn))
['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_raw_saved_result', '_register_hook_dict', '_saved_result', 'metadata', 'name', 'next_functions', 'register_hook', 'register_prehook', 'requires_grad']
>>> print(torch.allclose(b.grad_fn._saved_result, b))
True
您还可以使用钩子定义如何打包/解包这些保存的张量。一个常见的应用是通过将这些中间结果保存到磁盘或 CPU 而不是留在 GPU 上来用计算换取内存。如果您发现您的模型在评估期间适合 GPU,但在训练期间不适合,这将特别有用。另请参阅 保存的张量钩子。
- class torch.autograd.graph.saved_tensors_hooks(pack_hook, unpack_hook)[source]¶
上下文管理器,为保存的张量设置一对打包/解包钩子。
使用此上下文管理器来定义在保存之前如何打包操作的中间结果,以及在检索时如何解包。
在此上下文中,
pack_hook
函数将在每次操作保存张量以进行反向传播时调用(这包括使用save_for_backward()
保存的中间结果,但也包括由 PyTorch 定义的操作记录的结果)。pack_hook
的输出将存储在计算图中,而不是原始张量。当需要访问保存的张量时,即在执行
torch.Tensor.backward()
或torch.autograd.grad()
时,将调用unpack_hook
。它将pack_hook
返回的打包对象作为参数,并且应该返回一个张量,该张量与原始张量(作为输入传递给相应的pack_hook
)具有相同的内容。钩子应具有以下签名
pack_hook(tensor: Tensor) -> Any
unpack_hook(Any) -> Tensor
其中
pack_hook
的返回值是unpack_hook
的有效输入。通常,您希望
unpack_hook(pack_hook(t))
在值、大小、dtype 和设备方面等于t
。示例
>>> def pack_hook(x): ... print("Packing", x) ... return x >>> >>> def unpack_hook(x): ... print("Unpacking", x) ... return x >>> >>> a = torch.ones(5, requires_grad=True) >>> b = torch.ones(5, requires_grad=True) * 2 >>> with torch.autograd.graph.saved_tensors_hooks(pack_hook, unpack_hook): ... y = a * b Packing tensor([1., 1., 1., 1., 1.], requires_grad=True) Packing tensor([2., 2., 2., 2., 2.], grad_fn=<MulBackward0>) >>> y.sum().backward() Unpacking tensor([1., 1., 1., 1., 1.], requires_grad=True) Unpacking tensor([2., 2., 2., 2., 2.], grad_fn=<MulBackward0>)
警告
对任何钩子的输入执行就地操作都可能导致未定义的行为。
警告
一次只允许一对钩子。当递归嵌套此上下文管理器时,只应用最里面的那对钩子。
- class torch.autograd.graph.save_on_cpu(pin_memory=False, device_type='cuda')[source]¶
在该上下文管理器中,前向传递保存的张量将存储在 CPU 上,然后在反向传递时检索。
在该上下文管理器中执行操作时,前向传递过程中图中保存的中间结果将被移至 CPU,然后在反向传递需要时复制回原始设备。如果图已在 CPU 上,则不会执行张量复制。
使用此上下文管理器可以将计算量换取 GPU 内存使用量(例如,当您的模型在训练期间无法放入 GPU 内存中时)。
示例
>>> a = torch.randn(5, requires_grad=True, device="cuda") >>> b = torch.randn(5, requires_grad=True, device="cuda") >>> c = torch.randn(5, requires_grad=True, device="cuda") >>> >>> def f(a, b, c): ... prod_1 = a * b # a and b are saved on GPU ... with torch.autograd.graph.save_on_cpu(): ... prod_2 = prod_1 * c # prod_1 and c are saved on CPU ... y = prod_2 * a # prod_2 and a are saved on GPU ... return y >>> >>> y = f(a, b, c) >>> del a, b, c # for illustration only >>> # the content of a, b, and prod_2 are still alive on GPU >>> # the content of prod_1 and c only live on CPU >>> y.sum().backward() # all CPU tensors are moved back to GPU, for backward >>> # all intermediary tensors are released (deleted) after the call to backward
- class torch.autograd.graph.disable_saved_tensors_hooks(error_message)[source]¶
上下文管理器,它会禁用保存的张量的默认钩子功能。
如果您正在创建不支持保存的张量默认钩子的功能,则此功能很有用。
- 参数
error_message (str) – 当在禁用保存的张量默认钩子后使用它们时,将引发带有此错误消息的 RuntimeError。
- 返回值类型
Generator[None, None, None]
示例
>>> message = "saved tensors default hooks are disabled" >>> with torch.autograd.graph.disable_saved_tensors_hooks(message): ... # Raises RuntimeError: saved tensors default hooks are disabled ... with torch.autograd.graph.save_on_cpu(): ... pass
- class torch.autograd.graph.register_multi_grad_hook(tensors, fn, *, mode='all')[source]¶
注册一个多梯度反向钩子。
支持两种模式:
"all"
和"any"
。在
"all"
模式下,在计算tensors
中每个张量的梯度后,将调用该钩子。如果张量在tensors
中,但不是图的一部分,或者如果不需要该张量来计算当前.backward()
或.grad()
调用指定的任何inputs
的梯度,则将忽略该张量,并且该钩子将不会等待计算其梯度。在每个未被忽略的张量的梯度计算完毕后,将使用这些梯度调用
fn
。对于没有计算梯度的张量,将传递None
。在
"any"
模式下,在计算tensors
中张量的第一个梯度后,将调用该钩子。该钩子将使用该梯度作为其参数进行调用。该钩子不应修改其参数。
此函数返回一个带有方法
handle.remove()
的句柄,该方法将移除钩子。注意
有关此钩子何时执行以及如何相对于其他钩子执行的更多信息,请参见 反向钩子执行。
示例
>>> import torch >>> >>> a = torch.rand(2, 3, requires_grad=True) >>> b = torch.rand(2, 3, requires_grad=True) >>> c = a * b >>> d = a * b >>> >>> def fn(grads): ... print([g is not None for g in grads]) ... >>> torch.autograd.graph.register_multi_grad_hook((a, b, c, d), fn) >>> >>> c.sum().backward(retain_graph=True) [True, True, True, False] >>> c.sum().backward(inputs=(a,), retain_graph=True) [True, False, True, False] >>>
- 返回值类型
可移除句柄
- class torch.autograd.graph.allow_mutation_on_saved_tensors[source]¶
上下文管理器,在该管理器中允许对保存以进行反向的张量进行变异。
在该上下文管理器中,保存以进行反向的张量将在变异时被克隆,因此原始版本仍可在反向过程中使用。通常,对保存以进行反向的张量进行变异会导致在反向过程中使用它时引发错误。
为了确保正确行为,前向和反向都应在同一个上下文管理器下运行。
- 返回值
一个 _AllowMutationOnSavedContext 对象,用于存储此上下文管理器管理的状态。此对象可用于调试目的。上下文管理器管理的状态将在退出时自动清除。
- 返回值类型
Generator[_AllowMutationOnSavedContext, None, None]
示例
>>> import torch >>> with torch.autograd.graph.allow_mutation_on_saved_tensors(): ... # forward ... a = torch.ones(2, 3, requires_grad=True) ... b = a.clone() ... out = (b**2).sum() ... b.sin_() ... # backward ... out.sum().backward() ... tensor([[0.8415, 0.8415, 0.8415], [0.8415, 0.8415, 0.8415]], grad_fn=<SinBackward0>)
- class torch.autograd.graph.GradientEdge(node, output_nr)[source]¶
表示自动梯度图中给定梯度边的对象。
要获取将计算给定张量梯度的梯度边,您可以执行
edge = autograd.graph.get_gradient_edge(tensor)
。