原文： PyTorch 自动差分包-Torch.Autograd

torch.autograd提供了实现自动区分任意标量值函数的类和函数。 它需要对现有代码进行最小的更改-您只需要声明Tensor，应使用requires_grad=True关键字为其计算梯度。

torch.autograd.backward(tensors, grad_tensors=None, retain_graph=None, create_graph=False, grad_variables=None)¶

计算给定张量的梯度总和 w.r.t. 图叶。

该图使用链规则进行区分。 如果tensors中的任何一个都是非标量的(即，其数据具有多个元素）并且需要梯度，则将计算雅可比矢量积，在这种情况下，该函数还需要指定grad_tensors。 它应该是长度匹配的序列，其中包含雅可比向量积中的“向量”，通常是微分函数 w.r.t 的梯度。 相应的张量(对于不需要梯度张量的所有张量，None是可接受的值）。

此函数在树叶中累积渐变-调用它之前可能需要将它们归零。

参数

• 张量(张量的序列）–将计算其导数的张量。
• grad_tensors (( tensor 或 无的序列 ））–雅可比向量积中的“向量”，通常是梯度 wrt 相应张量的每个元素。 无法为标量张量或不需要等级的张量指定任何值。 如果所有 grad_tensor 都可接受 None 值，则此参数是可选的。
• keep_graph (bool ， 可选）–如果False，则用于计算等级的图形将被释放。 请注意，几乎在所有情况下都不需要将此选项设置为True，并且通常可以以更有效的方式解决它。 默认为create_graph的值。
• create_graph (bool ， 可选）–如果True，则将构造导数图，从而允许计算高阶导数 产品。 默认为False。

torch.autograd.grad(outputs, inputs, grad_outputs=None, retain_graph=None, create_graph=False, only_inputs=True, allow_unused=False)¶

计算并返回输出 w.r.t 的梯度总和。 输入。

grad_outputs应该是长度匹配的序列output，其中包含 Jacobian 向量积中的“向量”，通常是预先计算的梯度 w.r.t。 每个输出。 如果输出不是 require_grad，则渐变可以为None。

如果only_inputs为True，则该函数将仅返回指定输入的渐变列表。 如果是False，则渐变 w.r.t. 所有剩余的叶子仍将被计算，并将被累积到其.grad属性中。

Parameters

• 输出(张量的序列）–微分功能的输出。
• 输入(张量的序列）–输入 w.r.t. 梯度将被返回(而不是累积到.grad中）。
• grad_outputs (张量的序列）–雅可比向量积中的“向量”。 通常是渐变色 每个输出。 无法为标量张量或不需要等级的张量指定任何值。 如果所有 grad_tensor 都可接受 None 值，则此参数是可选的。 默认值：无。
• retain_graph (bool__, optional) – If False, the graph used to compute the grad will be freed. Note that in nearly all cases setting this option to True is not needed and often can be worked around in a much more efficient way. Defaults to the value of create_graph.
• create_graph (bool ， 可选）–如果True，则将构造导数图，从而允许计算高阶导数 产品。 默认值：False。
• allow_unused (bool ， 可选）–如果为False，则指定在计算输出时未使用的输入(及其等级） 始终为零）是错误。 默认为False。

局部禁用梯度计算

class torch.autograd.no_grad¶

禁用梯度计算的上下文管理器。

当您确定不会调用Tensor.backward()时，禁用梯度计算对于推断很有用。 它将减少用于具有 <cite>require_grad = True</cite> 的计算的内存消耗。

在这种模式下，即使输入具有 <cite>require_grad = True</cite> ，每个计算的结果也将具有 <cite>require_grad = False</cite> 。

使用 enable_grad 上下文管理器时，此模式无效。

该上下文管理器是线程本地的； 它不会影响其他线程中的计算。

还用作装饰器。

例：

>>> 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

class torch.autograd.enable_grad¶

启用梯度计算的上下文管理器。

如果已通过 no_grad 或 set_grad_enabled 禁用了梯度计算，则启用梯度计算。

This context manager is thread local; it will not affect computation in other threads.

Also functions as a decorator.

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

class torch.autograd.set_grad_enabled(mode)¶

将渐变计算设置为开或关的上下文管理器。

set_grad_enabled将根据其参数mode启用或禁用 grads。 它可以用作上下文管理器或功能。

使用 enable_grad 上下文管理器时，set_grad_enabled(False)不起作用。

This context manager is thread local; it will not affect computation in other threads.

Parameters

模式 (bool )–标记是启用 Grad(True）还是禁用(False）。 这可用于有条件地启用渐变。

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

张量的就地操作

在 autograd 中支持就地操作很困难，并且在大多数情况下，我们不鼓励使用它们。 Autograd 积极的缓冲区释放和重用使其非常高效，就地操作实际上很少显着降低内存使用量的情况很少。 除非您在高内存压力下进行操作，否则可能永远不需要使用它们。

就地正确性检查

所有Tensor都跟踪对其应用的就地操作，并且如果实现检测到在其中一个函数中保存了一个张量以用于后退，但此后对其进行了修改，则一旦向后进行修改，就会引发错误 通行证开始。 这样可以确保，如果您使用的是就地函数并且没有看到任何错误，则可以确保计算出的梯度是正确的。

变量(不建议使用）

警告

不推荐使用 Variable API：不再需要将变量用于带有张量的 autograd。 Autograd 自动将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.Tensor


grad¶

此属性默认为None，并在首次调用 backward() 计算self的梯度时成为张量。 然后，该属性将包含计算出的梯度，将来对 backward() 的调用将在其中累积(添加）梯度。

requires_grad¶

如果需要为此张量计算梯度，则为True，否则为False。

注意

需要为张量计算梯度的事实并不意味着将填充 grad 属性，有关更多详细信息， is_leaf 。

is_leaf¶

按照惯例，所有具有 requires_grad 即False的张量将是叶张量。

对于具有 requires_grad (即True）的张量，如果它们是由用户创建的，则它们将是叶张量。 这意味着它们不是运算的结果，因此grad_fn为“无”。

在调用 backward() 期间，仅叶子张量会填充其 grad 。 要为非叶张量填充 grad ，可以使用 retain_grad() 。

Example:

>>> a = torch.rand(10, requires_grad=True)
>>> a.is_leaf
True
>>> b = torch.rand(10, requires_grad=True).cuda()
>>> b.is_leaf
False
## b was created by the operation that cast a cpu Tensor into a cuda Tensor
>>> c = torch.rand(10, requires_grad=True) + 2
>>> c.is_leaf
False
## c was created by the addition operation
>>> d = torch.rand(10).cuda()
>>> d.is_leaf
True
## d does not require gradients and so has no operation creating it (that is tracked by the autograd engine)
>>> e = torch.rand(10).cuda().requires_grad_()
>>> e.is_leaf
True
## e requires gradients and has no operations creating it
>>> f = torch.rand(10, requires_grad=True, device="cuda")
>>> f.is_leaf
True
## f requires grad, has no operation creating it

backward(gradient=None, retain_graph=None, create_graph=False)¶

计算电流张量 w.r.t. 图叶。

该图使用链规则进行区分。 如果张量是非标量的(即其数据具有多个元素）并且需要梯度，则该函数还需要指定gradient。 它应该是匹配类型和位置的张量，其中包含微分函数 w.r.t 的梯度。 self。

此函数在树叶中累积渐变-调用它之前可能需要将它们归零。

Parameters

• 梯度 (tensor 或 无）–梯度 w.r.t. 张量。 如果它是张量，除非create_graph为 True，否则它将自动转换为不需要 grad 的张量。 无法为标量张量或不需要等级的张量指定任何值。 如果 None 值可以接受，那么此参数是可选的。
• keep_graph (bool ， 可选）–如果False，则用于计算等级的图形将被释放。 请注意，几乎在所有情况下都不需要将此选项设置为 True，并且通常可以以更有效的方式解决它。 默认为create_graph的值。
• create_graph (bool ， 可选）–如果True，则将构造导数图，从而允许计算高阶导数 产品。 默认为False。

detach()¶

返回与当前图形分离的新 Tensor。

结果将永远不需要渐变。

Note

返回的 Tensor 与原始 Tensor 共享相同的存储。 可以看到对它们中的任何一个的就地修改，并且可能触发正确性检查中的错误。 重要说明：以前，就地大小/步幅/存储更改(例如 <cite>resize</cite> / <cite>resizeas</cite> / <cite>set</cite> / <cite>transpose</cite> ) 返回的张量也会更新原始张量。 现在，这些就地更改将不再更新原始张量，而将触发错误。 对于稀疏张量：原位索引/值更改(例如 <cite>zero</cite> / <cite>copy</cite> / <cite>add</cite> )将不会再更新原始张量， 而是触发错误。

detach_()¶

从创建它的图形中分离张量，使其成为一片叶子。 视图不能就地分离。

register_hook(hook)¶

注册一个倒钩。

每当计算相对于张量的梯度时，都会调用该挂钩。 挂钩应具有以下签名：

hook(grad) -> Tensor or None

挂钩不应修改其自变量，但可以选择返回一个新的渐变，该渐变将代替 grad 使用。

此函数返回带有方法handle.remove()的句柄，该方法可将钩子从模块中移除。

Example:

>>> v = torch.tensor([0., 0., 0.], requires_grad=True)
>>> h = v.register_hook(lambda grad: grad * 2)  # double the gradient
>>> v.backward(torch.tensor([1., 2., 3.]))
>>> v.grad


 2
 4
 6
[torch.FloatTensor of size (3,)]


>>> h.remove()  # removes the hook

retain_grad()¶

为非叶张量启用.grad 属性。

功能

class torch.autograd.Function¶

记录操作历史并定义用于区分操作的公式。

在Tensor上执行的每个操作都会创建一个新的函数对象，该对象执行计算并记录其发生。 历史记录以 DAG 函数的形式保留，其边缘表示数据依赖性(input <- output）。 然后，当调用向后时，通过调用每个 Function 对象的 backward() 方法，并将返回的梯度传递到下一个，以拓扑顺序处理图形 ] Function s。

通常，用户与函数交互的唯一方法是创建子类并定义新操作。 这是扩展 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

static backward(ctx, *grad_outputs)¶

定义用于区分操作的公式。

该功能将被所有子类覆盖。

它必须接受上下文ctx作为第一个参数，然后返回 forward() 返回的输出数量，并且它应该返回与 [forward()的输入一样多的张量 。 每个参数都是给定输出的梯度 w.r.t，每个返回值都应该是梯度 w.r.t。 相应的输入。

上下文可用于检索在前向传递过程中保存的张量。 它还具有属性ctx.needs_input_grad，它是一个布尔元组，表示每个输入是否需要渐变。 例如，如果 forward() 的第一个输入需要进行 w.r.t.的梯度计算，则 backward() 将具有ctx.needs_input_grad[0] = True。 输出。

static forward(ctx, *args, **kwargs)¶

执行操作。

This function is to be overridden by all subclasses.

它必须接受上下文 ctx 作为第一个参数，后跟任意数量的参数(张量或其他类型）。

上下文可用于存储张量，然后可以在向后传递过程中检索这些张量。

上下文方法混合

创建新的 Function 时， <cite>ctx</cite> 可使用以下方法。

class torch.autograd.function._ContextMethodMixin¶

mark_dirty(*args)¶

将给定张量标记为在就地操作中已修改。

仅应从 forward() 方法内部调用一次，并且所有自变量均应为输入。

在调用forward()时在原位修改的每个张量都应提供给此函数，以确保检查的正确性。 在修改之前或之后调用该函数都没有关系。

mark_non_differentiable(*args)¶

将输出标记为不可微分。

仅应从 forward() 方法内部调用一次，并且所有自变量均应为输出。

这会将输出标记为不需要梯度，从而提高了向后计算的效率。 您仍然需要为backward()中的每个输出接受一个渐变，但是它始终将是零张量，其形状与相应输出的形状相同。

例如使用 用于从最大值Function返回的索引。

save_for_backward(*tensors)¶

保存给定的张量以供将来调用backward()。

最多只能调用一次，并且只能从 forward() 方法内部调用。

以后，可以通过saved_tensors属性访问已保存的张量。 在将它们退还给用户之前，应进行检查以确保未在修改其内容的任何就地操作中使用它们。

参数也可以是None。

数值梯度检查

torch.autograd.gradcheck(func, inputs, eps=1e-06, atol=1e-05, rtol=0.001, raise_exception=True, check_sparse_nnz=False, nondet_tol=0.0)¶

检查相对于分析梯度 w.r.t 的小有限差分计算出的梯度。 inputs中的浮点类型为requires_grad=True的张量。

在数值梯度和解析梯度之间的检查使用 allclose() 。

Note

默认值是为双精度的input设计的。 如果input的精度较低，例如FloatTensor，则此检查可能会失败。

Warning

如果input中的任何已检查张量具有重叠的内存，即，不同的索引指向相同的内存地址(例如，来自torch.expand()的索引），则此检查可能会失败，因为在这些索引处通过点扰动计算出的数值梯度将改变值 共享相同内存地址的所有其他索引。

Parameters

• 函数(函数）–一个 Python 函数，接受 Tensor 输入并返回 Tensor 或 Tensors 元组
• 输入(张量 或 tensor 的元组）–该功能的输入
• eps (python：float ， 可选）–有限差分摄动
• atol (python：float ， 可选）–绝对公差
• rtol (python：float ， 可选）–相对公差
• raise_exception (bool ， 可选）–指示如果检查失败，是否引发异常。 该异常提供有关故障确切性质的更多信息。 这在调试 gradchecks 时很有用。
• check_sparse_nnz (bool ， 可选）–如果为 True，则 gradcheck 允许输入 SparseTensor，对于输入的任何 SparseTensor，gradcheck 将执行 仅在 nnz 位置检查。
• nondet_tol (python：float ， 可选）–对不确定性的容忍度。 通过微分运行相同的输入时，结果必须完全匹配(默认值为 0.0）或在此公差范围内。

退货

如果所有差异均满足全封闭条件，则为真

torch.autograd.gradgradcheck(func, inputs, grad_outputs=None, eps=1e-06, atol=1e-05, rtol=0.001, gen_non_contig_grad_outputs=False, raise_exception=True, nondet_tol=0.0)¶

检查相对于分析梯度 w.r.t 的，通过小的有限差分计算出的梯度的梯度。 inputs和grad_outputs中的张量是浮点型且带有requires_grad=True的张量。

此函数检查通过向给定grad_outputs计算的梯度进行反向传播是否正确。

The check between numerical and analytical gradients uses allclose().

Note

默认值是为双精度的input和grad_outputs设计的。 如果它们的精度较低，例如FloatTensor，则此检查可能会失败。

Warning

如果input和grad_outputs中的任何已检查张量具有重叠的内存，即指向同一内存地址的不同索引(例如，来自torch.expand()的索引），则此检查可能会失败，因为在这种情况下通过点摄动计算出的数值梯度 索引将更改共享同一内存地址的所有其他索引的值。

Parameters

• func (function) – a Python function that takes Tensor inputs and returns a Tensor or a tuple of Tensors
• inputs (tuple of Tensor or Tensor) – inputs to the function
• grad_outputs (张量元组 或 tensor ， 可选）–相对于函数输出的渐变。
• eps (python:float__, optional) – perturbation for finite differences
• atol (python:float__, optional) – absolute tolerance
• rtol (python:float__, optional) – relative tolerance
• gen_non_contig_grad_outputs (bool ， 可选））–如果grad_outputs为None，gen_non_contig_grad_outputs为True，则随机 使生成的梯度输出不连续
• raise_exception (bool__, optional) – indicating whether to raise an exception if the check fails. The exception gives more information about the exact nature of the failure. This is helpful when debugging gradchecks.
• nondet_tol (python：float ， 可选）–对不确定性的容忍度。 通过微分运行相同的输入时，结果必须完全匹配(默认值为 0.0）或在此公差范围内。 注意，梯度中的少量不确定性将导致二阶导数的较大误差。

Returns

True if all differences satisfy allclose condition

探查器

Autograd 包括一个探查器，可让您检查模型中不同运算符的成本-包括 CPU 和 GPU。 目前有两种模式-仅使用 profile 的 CPU。 并使用 emit_nvtx 基于 nvprof(注册 CPU 和 GPU 活动）。

class torch.autograd.profiler.profile(enabled=True, use_cuda=False, record_shapes=False)¶

上下文管理器，用于管理 autograd profiler 状态并保存结果摘要。 在后台，它仅记录正在 C ++中执行的函数的事件，并将这些事件公开给 Python。 您可以将任何代码包装到其中，并且它只会报告 PyTorch 函数的运行时。

Parameters

• 启用的 (bool ， 可选）–将其设置为 False 会使此上下文管理器变为无操作。 默认值：True。
• use_cuda (bool ， 可选）–以及使用 cudaEvent API 启用 CUDA 事件的计时。 每个张量操作会增加大约 4us 的开销。 默认值：False
• record_shapes (bool ， 可选）–如果设置了形状记录，将收集有关输入尺寸的信息。 这样一来，您可以查看引擎盖下使用了哪些尺寸，并使用 prof.key_averages(group_by_input_shape = True）将它们进一步分组。 请注意，形状记录可能会歪曲您的轮廓数据。 建议使用带有和不带有形状记录的单独运行来验证计时。 对于最底层的事件(在嵌套函数调用的情况下），偏斜很可能会忽略不计。 但是对于较高级别的功能，由于形状收集，可能会人为地增加总的自体 cpu 时间。

例

>>> 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
-----------------------------------  ---------------  ---------------  ---------------

export_chrome_trace(path)¶

将 EventList 导出为 Chrome 跟踪工具文件。

稍后可以在chrome://tracing URL 下加载和检查检查点。

Parameters

路径 (str )–将写入跟踪的路径。

key_averages(group_by_input_shape=False)¶

平均所有功能事件的键。

@param group_by_input_shapes 该键将变为(事件名称，输入维度），而不仅仅是事件名称。 这对于查看哪个维度对运行时间的贡献最大是很有用的，并且可以帮助进行特定于维度的优化或选择最佳的量化候选对象(也就是拟合屋顶线）

Returns

一个包含 FunctionEventAvg 对象的 EventList。

property self_cpu_time_total¶

返回花费在 CPU 上的总时间，作为所有事件中所有自身时间的总和。

table(sort_by=None, row_limit=100, header=None)¶

将 EventList 打印为格式正确的表。

Parameters

sort_by (str ， 可选）–用于对条目进行排序的属性。 默认情况下，它们以与注册时相同的顺序打印。 有效密钥包括：cpu_time，cuda_time，cpu_time_total，cuda_time_total，count。

Returns

包含表的字符串。

total_average()¶

平均所有事件。

Returns

FunctionEventAvg 对象。

class torch.autograd.profiler.record_function(name)¶

上下文管理器，在运行 autograd profiler 时将标签添加到 Python 代码块中。 在跟踪代码配置文件时很有用。

Parameters

名称 (str )–分配给代码块的标签。

Example

>>> x = torch.randn((1, 1), requires_grad=True)
>>> with torch.autograd.profiler.profile() as prof:
...     y = x ** 2
...     with torch.autograd.profiler.record_function("label-z"): # label the block
...         z = y ** 3
...     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
-----------------------------------  ---------------  ---------------  ---------------
pow                                  60.77%           47.470us         3
mul                                  21.73%           25.465us         2
PowBackward0                         12.03%           121.891us        1
torch::autograd::AccumulateGrad      2.70%            6.324us          1
label-z                              2.13%            12.421us         1
torch::autograd::GraphRoot           0.64%            1.503us          1
-----------------------------------  ---------------  ---------------  ---------------
Self CPU time total: 234.344us
CUDA time total: 0.000us

class torch.autograd.profiler.emit_nvtx(enabled=True, record_shapes=False)¶

使每个自动分级操作发出 NXTX 范围的上下文管理器。

在 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 中。

Parameters

• 启用 (bool ， 可选 ， 默认= True )–设置enabled=False使此上下文管理器成为禁止操作。 默认值：True。
• record_shapes (bool ， 可选 ， 默认=假）–如果record_shapes=True，包装每个 autograd 操作的 nvtx 范围将以以下格式附加有关该操作接收的 Tensor 参数的大小的信息：[[arg0.size(0), arg0.size(1), ...], [arg1.size(0), arg1.size(1), ...], ...]非张量参数将由[]表示。 参数将按照后端操作接收到的顺序列出。 请注意，此顺序可能与在 Python 端传递这些参数的顺序不匹配。 还要注意，形状记录可能会增加 nvtx 范围创建的开销。

Example

>>> 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是一个运行计数器，每次创建一个新的向后功能对象时都将递增并存放以用于向后。 因此，与每个前向功能范围相关联的seq=<N>注释告诉您，如果通过此前向功能创建后向功能对象，则后向对象将接收序列号 N。在后向传递过程中，包装每个 C ++的顶级范围 向后函数的apply()调用装饰有stashed seq=<M>。 M是创建反向对象的序列号。 通过比较后向的stashed seq数字和正向的seq数字，您可以跟踪哪个正向运算符创建了每个向后功能。

向后传递过程中执行的所有功能也都用seq=<N>装饰。 在默认向后(使用create_graph=False）期间，此信息无关紧要，实际上，对于所有此类功能，N可能只是 0。 只有与向后功能对象的apply()方法关联的顶级范围才有用，可以将这些功能对象与更早的向前传递相关联。

双向

另一方面，如果正在进行create_graph=True的向后传递(换句话说，如果您要进行双向后退），则向后执行过程中每个函数的执行都将被赋予非零且有用的seq=<N>。 这些函数本身可以创建 Function 对象，以便稍后在双向后执行时，就像向前传递中的原始函数一样。 向后和双向后之间的关系在概念上与向前和向后之间的关系相同：这些函数仍会发出带有当前序列号标记的范围，它们创建的 Function 对象仍会存储这些序列号，并且在最终 double- 向后，功能对象的apply()范围仍标记有stashed seq数字，可以将其与从后向传递的 <cite>seq</cite> 数字进行比较。

torch.autograd.profiler.load_nvprof(path)¶

打开 nvprof 跟踪文件并解析 autograd 批注。

Parameters

路径 (str )– nvprof 跟踪的路径

异常检测

class torch.autograd.detect_anomaly¶

上下文管理器，可为 autograd 引擎启用异常检测。

这有两件事：-在启用检测的情况下运行正向传递，将允许反向传递打印创建失败的反向函数的正向操作的回溯。 -任何产生“ nan”值的向后计算都会引发错误。

Warning

仅在调试时才应启用此模式，因为不同的测试会减慢程序的执行速度。

Example

>>> 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)¶

上下文管理器，用于打开或关闭 autograd 引擎的异常检测。

set_detect_anomaly将基于其参数mode启用或禁用自动求导异常检测。 它可以用作上下文管理器或功能。

有关异常检测行为的详细信息，请参见上面的detect_anomaly。

Parameters

模式 (bool )–标记是启用异常检测(True）还是禁用(False）。