注意

点击这里下载完整的示例代码

介绍 || 张量 || 自动求导 || 构建模型 || TensorBoard 支持 || 训练模型 || 模型理解

自动求导基础

创建于：2021年11月30日 | 最后更新：2024年2月26日 | 最后验证：2024年11月5日

跟随下面的视频或在youtube上观看。

PyTorch的Autograd功能是使PyTorch在构建机器学习项目时灵活且快速的部分原因。它允许在复杂计算中快速且轻松地计算多个偏导数（也称为梯度）。这一操作是基于反向传播的神经网络学习的核心。

自动求导的强大之处在于它在运行时动态地跟踪你的计算，这意味着如果你的模型有决策分支，或者循环的长度在运行时才知道，计算仍然会被正确跟踪，你将得到正确的梯度来驱动学习。这一点，再加上你的模型是用Python构建的，提供了比依赖对更严格结构模型进行静态分析来计算梯度的框架更大的灵活性。

我们为什么需要自动求导？

机器学习模型是一个函数，有输入和输出。在这个讨论中，我们将输入视为一个i维向量 $\vec{x}$ ，其元素为 $x_{i}$ 。然后我们可以将模型M表示为输入的向量值函数： $\vec{y} = \vec{M}(\vec{x})$ 。（我们将M的输出值视为向量，因为通常模型可能有任意数量的输出。）

由于我们主要在训练的背景下讨论自动梯度计算，我们关注的输出将是模型的损失。损失函数 L( $\vec{y}$ ) = L( $\vec{M}$ ( $\vec{x}$ )) 是模型输出的单值标量函数。这个函数表达了模型预测与特定输入的理想输出之间的差距。注意：从这一点开始，我们将在上下文明确的情况下省略向量符号 - 例如， $y$ 而不是 $\vec y$ 。

在训练模型时，我们希望最小化损失。在理想情况下，一个完美的模型意味着调整其学习权重——即函数的可调参数——使得所有输入的损失为零。在现实世界中，这意味着一个迭代过程，逐步调整学习权重，直到我们看到对于各种输入都能获得可容忍的损失。

我们如何决定权重调整的幅度和方向？我们希望最小化损失，这意味着使其对输入的导数等于0： $\frac{\partial L}{\partial x} = 0$ 。

回想一下，损失并不是直接从输入中得出的，而是模型输出的函数（模型输出是输入的直接函数）， $\frac{\partial L}{\partial x}$ = $\frac{\partial {L({\vec y})}}{\partial x}$ 。根据微积分的链式法则，我们有 $\frac{\partial {L({\vec y})}}{\partial x}$ = $\frac{\partial L}{\partial y}\frac{\partial y}{\partial x}$ = $\frac{\partial L}{\partial y}\frac{\partial M(x)}{\partial x}$ 。

$\frac{\partial M(x)}{\partial x}$ 是事情变得复杂的地方。模型的输出相对于其输入的偏导数，如果我们再次使用链式法则展开表达式，将涉及每个相乘的学习权重、每个激活函数以及模型中每个其他数学变换的许多局部偏导数。每个这样的偏导数的完整表达式是通过计算图的每条可能路径的局部梯度的乘积之和，这些路径以我们试图测量梯度的变量结束。

特别是，我们对学习权重的梯度感兴趣——它们告诉我们改变每个权重的方向以使损失函数更接近零。

由于这种局部导数的数量（每个都对应于模型计算图中的一条独立路径）会随着神经网络的深度呈指数级增长，计算它们的复杂性也会随之增加。这就是自动求导（autograd）发挥作用的地方：它会跟踪每个计算的历史。在您的PyTorch模型中，每个计算出的张量都携带了其输入张量的历史以及用于创建它的函数。结合PyTorch函数旨在作用于张量的事实，每个函数都有一个内置的实现来计算它们自己的导数，这大大加快了学习所需的局部导数的计算速度。

一个简单的例子

那是很多理论 - 但在实践中使用autograd是什么样子呢？

让我们从一个简单的例子开始。首先，我们将进行一些导入，以便能够绘制我们的结果：

# %matplotlib inline

import torch

import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import math

接下来，我们将在区间 $[0, 2{\pi}]$ 上创建一个充满均匀间隔值的输入张量，并指定requires_grad=True。（与大多数创建张量的函数一样，torch.linspace()接受一个可选的requires_grad选项。）设置此标志意味着在随后的每次计算中，autograd将在该计算的输出张量中累积计算的历史记录。

a = torch.linspace(0., 2. * math.pi, steps=25, requires_grad=True)
print(a)

tensor([0.0000, 0.2618, 0.5236, 0.7854, 1.0472, 1.3090, 1.5708, 1.8326, 2.0944,
        2.3562, 2.6180, 2.8798, 3.1416, 3.4034, 3.6652, 3.9270, 4.1888, 4.4506,
        4.7124, 4.9742, 5.2360, 5.4978, 5.7596, 6.0214, 6.2832],
       requires_grad=True)

接下来，我们将执行一个计算，并根据其输入绘制输出：

b = torch.sin(a)
plt.plot(a.detach(), b.detach())

[<matplotlib.lines.Line2D object at 0x7f6a9b8e2980>]

让我们更仔细地看一下张量 b。当我们打印它时，我们会看到一个指示器，表明它正在跟踪其计算历史：

print(b)

tensor([ 0.0000e+00,  2.5882e-01,  5.0000e-01,  7.0711e-01,  8.6603e-01,
         9.6593e-01,  1.0000e+00,  9.6593e-01,  8.6603e-01,  7.0711e-01,
         5.0000e-01,  2.5882e-01, -8.7423e-08, -2.5882e-01, -5.0000e-01,
        -7.0711e-01, -8.6603e-01, -9.6593e-01, -1.0000e+00, -9.6593e-01,
        -8.6603e-01, -7.0711e-01, -5.0000e-01, -2.5882e-01,  1.7485e-07],
       grad_fn=<SinBackward0>)

这个grad_fn给了我们一个提示，当我们执行反向传播步骤并计算梯度时，我们需要为这个张量的所有输入计算 $\sin(x)$ 的导数。

让我们执行更多的计算：

c = 2 * b
print(c)

d = c + 1
print(d)

tensor([ 0.0000e+00,  5.1764e-01,  1.0000e+00,  1.4142e+00,  1.7321e+00,
         1.9319e+00,  2.0000e+00,  1.9319e+00,  1.7321e+00,  1.4142e+00,
         1.0000e+00,  5.1764e-01, -1.7485e-07, -5.1764e-01, -1.0000e+00,
        -1.4142e+00, -1.7321e+00, -1.9319e+00, -2.0000e+00, -1.9319e+00,
        -1.7321e+00, -1.4142e+00, -1.0000e+00, -5.1764e-01,  3.4969e-07],
       grad_fn=<MulBackward0>)
tensor([ 1.0000e+00,  1.5176e+00,  2.0000e+00,  2.4142e+00,  2.7321e+00,
         2.9319e+00,  3.0000e+00,  2.9319e+00,  2.7321e+00,  2.4142e+00,
         2.0000e+00,  1.5176e+00,  1.0000e+00,  4.8236e-01, -3.5763e-07,
        -4.1421e-01, -7.3205e-01, -9.3185e-01, -1.0000e+00, -9.3185e-01,
        -7.3205e-01, -4.1421e-01,  4.7684e-07,  4.8236e-01,  1.0000e+00],
       grad_fn=<AddBackward0>)

最后，让我们计算一个单元素输出。当你在没有参数的情况下调用.backward()时，它期望调用张量只包含一个元素，就像计算损失函数时的情况一样。

out = d.sum()
print(out)

tensor(25., grad_fn=<SumBackward0>)

每个与我们的张量一起存储的grad_fn允许您通过其next_functions属性一直追溯到其输入。我们可以在下面看到，在d上深入挖掘此属性会显示所有先前张量的梯度函数。请注意，a.grad_fn被报告为None，表示这是函数的输入，没有自己的历史记录。

print('d:')
print(d.grad_fn)
print(d.grad_fn.next_functions)
print(d.grad_fn.next_functions[0][0].next_functions)
print(d.grad_fn.next_functions[0][0].next_functions[0][0].next_functions)
print(d.grad_fn.next_functions[0][0].next_functions[0][0].next_functions[0][0].next_functions)
print('\nc:')
print(c.grad_fn)
print('\nb:')
print(b.grad_fn)
print('\na:')
print(a.grad_fn)

d:
<AddBackward0 object at 0x7f6a9b88c100>
((<MulBackward0 object at 0x7f6acaa42b00>, 0), (None, 0))
((<SinBackward0 object at 0x7f6a9b88c100>, 0), (None, 0))
((<AccumulateGrad object at 0x7f6acaa42b00>, 0),)
()

c:
<MulBackward0 object at 0x7f6a9b88c100>

b:
<SinBackward0 object at 0x7f6a9b88c100>

a:
None

有了所有这些机制，我们如何得到导数呢？你可以在输出上调用backward()方法，并检查输入的grad属性来查看梯度：

out.backward()
print(a.grad)
plt.plot(a.detach(), a.grad.detach())

tensor([ 2.0000e+00,  1.9319e+00,  1.7321e+00,  1.4142e+00,  1.0000e+00,
         5.1764e-01, -8.7423e-08, -5.1764e-01, -1.0000e+00, -1.4142e+00,
        -1.7321e+00, -1.9319e+00, -2.0000e+00, -1.9319e+00, -1.7321e+00,
        -1.4142e+00, -1.0000e+00, -5.1764e-01,  2.3850e-08,  5.1764e-01,
         1.0000e+00,  1.4142e+00,  1.7321e+00,  1.9319e+00,  2.0000e+00])

[<matplotlib.lines.Line2D object at 0x7f6a9b911870>]

回想一下我们为了达到这里所采取的计算步骤：

a = torch.linspace(0., 2. * math.pi, steps=25, requires_grad=True)
b = torch.sin(a)
c = 2 * b
d = c + 1
out = d.sum()

添加一个常数，就像我们计算d时所做的那样，不会改变导数。这就剩下 $c = 2 * b = 2 * \sin(a)$ ，其导数应该是 $2 * \cos(a)$ 。看看上面的图表，这正是我们所看到的。

请注意，只有计算的叶节点才会计算其梯度。例如，如果你尝试print(c.grad)，你会得到None。在这个简单的例子中，只有输入是叶节点，因此只有它计算了梯度。

训练中的自动求导

我们已经简要了解了autograd的工作原理，但当它用于其预期目的时，情况如何呢？让我们定义一个小模型，并检查在单个训练批次后它如何变化。首先，定义一些常量、我们的模型以及一些输入和输出的占位符：

BATCH_SIZE = 16
DIM_IN = 1000
HIDDEN_SIZE = 100
DIM_OUT = 10

class TinyModel(torch.nn.Module):

    def __init__(self):
        super(TinyModel, self).__init__()

        self.layer1 = torch.nn.Linear(DIM_IN, HIDDEN_SIZE)
        self.relu = torch.nn.ReLU()
        self.layer2 = torch.nn.Linear(HIDDEN_SIZE, DIM_OUT)

    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        return x

some_input = torch.randn(BATCH_SIZE, DIM_IN, requires_grad=False)
ideal_output = torch.randn(BATCH_SIZE, DIM_OUT, requires_grad=False)

model = TinyModel()

你可能会注意到的一件事是，我们从未为模型的层指定 requires_grad=True。在 torch.nn.Module 的子类中，假定我们希望跟踪层权重的梯度以进行学习。

如果我们查看模型的层次，我们可以检查权重的值，并验证尚未计算任何梯度：

print(model.layer2.weight[0][0:10]) # just a small slice
print(model.layer2.weight.grad)

tensor([ 0.0920,  0.0916,  0.0121,  0.0083, -0.0055,  0.0367,  0.0221, -0.0276,
        -0.0086,  0.0157], grad_fn=<SliceBackward0>)
None

让我们看看当我们运行一个训练批次时，这会如何变化。对于损失函数，我们将仅使用我们的prediction和ideal_output之间的欧几里得距离的平方，并且我们将使用一个基本的随机梯度下降优化器。

optimizer = torch.optim.SGD(model.parameters(), lr=0.001)

prediction = model(some_input)

loss = (ideal_output - prediction).pow(2).sum()
print(loss)

tensor(211.2634, grad_fn=<SumBackward0>)

现在，让我们调用 loss.backward() 看看会发生什么：

loss.backward()
print(model.layer2.weight[0][0:10])
print(model.layer2.weight.grad[0][0:10])

tensor([ 0.0920,  0.0916,  0.0121,  0.0083, -0.0055,  0.0367,  0.0221, -0.0276,
        -0.0086,  0.0157], grad_fn=<SliceBackward0>)
tensor([12.8997,  2.9572,  2.3021,  1.8887,  5.0710,  7.3192,  3.5169,  2.4319,
         0.1732, -5.3835])

我们可以看到，已经为每个学习权重计算了梯度，但权重保持不变，因为我们还没有运行优化器。优化器负责根据计算的梯度更新模型权重。

optimizer.step()
print(model.layer2.weight[0][0:10])
print(model.layer2.weight.grad[0][0:10])

tensor([ 0.0791,  0.0886,  0.0098,  0.0064, -0.0106,  0.0293,  0.0186, -0.0300,
        -0.0088,  0.0211], grad_fn=<SliceBackward0>)
tensor([12.8997,  2.9572,  2.3021,  1.8887,  5.0710,  7.3192,  3.5169,  2.4319,
         0.1732, -5.3835])

你应该看到layer2的权重已经改变了。

关于这个过程的一个重要事项：在调用optimizer.step()之后，你需要调用optimizer.zero_grad()，否则每次运行loss.backward()时，学习权重的梯度将会累积：

print(model.layer2.weight.grad[0][0:10])

for i in range(0, 5):
    prediction = model(some_input)
    loss = (ideal_output - prediction).pow(2).sum()
    loss.backward()

print(model.layer2.weight.grad[0][0:10])

optimizer.zero_grad(set_to_none=False)

print(model.layer2.weight.grad[0][0:10])

tensor([12.8997,  2.9572,  2.3021,  1.8887,  5.0710,  7.3192,  3.5169,  2.4319,
         0.1732, -5.3835])
tensor([ 19.2095, -15.9459,   8.3306,  11.5096,   9.5471,   0.5391,  -0.3370,
          8.6386,  -2.5141, -30.1419])
tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

在运行上面的单元格后，你应该会看到在多次运行loss.backward()后，大多数梯度的大小会变得更大。在运行下一个训练批次之前未能将梯度清零，会导致梯度以这种方式爆炸，从而导致不正确和不可预测的学习结果。

关闭和开启自动求导

在某些情况下，您需要对是否启用自动求导进行细粒度的控制。根据具体情况，有几种方法可以实现这一点。

最简单的方法是直接在张量上更改requires_grad标志：

a = torch.ones(2, 3, requires_grad=True)
print(a)

b1 = 2 * a
print(b1)

a.requires_grad = False
b2 = 2 * a
print(b2)

tensor([[1., 1., 1.],
        [1., 1., 1.]], requires_grad=True)
tensor([[2., 2., 2.],
        [2., 2., 2.]], grad_fn=<MulBackward0>)
tensor([[2., 2., 2.],
        [2., 2., 2.]])

在上面的单元格中，我们看到b1有一个grad_fn（即一个追踪的计算历史），这是我们预期的，因为它是由一个启用了自动求导的张量a派生出来的。当我们显式地关闭自动求导，使用a.requires_grad = False时，计算历史不再被追踪，正如我们在计算b2时所看到的。

如果你只需要暂时关闭自动求导，更好的方法是使用 torch.no_grad()：

a = torch.ones(2, 3, requires_grad=True) * 2
b = torch.ones(2, 3, requires_grad=True) * 3

c1 = a + b
print(c1)

with torch.no_grad():
    c2 = a + b

print(c2)

c3 = a * b
print(c3)

tensor([[5., 5., 5.],
        [5., 5., 5.]], grad_fn=<AddBackward0>)
tensor([[5., 5., 5.],
        [5., 5., 5.]])
tensor([[6., 6., 6.],
        [6., 6., 6.]], grad_fn=<MulBackward0>)

torch.no_grad() 也可以用作函数或方法装饰器：

def add_tensors1(x, y):
    return x + y

@torch.no_grad()
def add_tensors2(x, y):
    return x + y


a = torch.ones(2, 3, requires_grad=True) * 2
b = torch.ones(2, 3, requires_grad=True) * 3

c1 = add_tensors1(a, b)
print(c1)

c2 = add_tensors2(a, b)
print(c2)

tensor([[5., 5., 5.],
        [5., 5., 5.]], grad_fn=<AddBackward0>)
tensor([[5., 5., 5.],
        [5., 5., 5.]])

有一个相应的上下文管理器，torch.enable_grad()，用于在未启用自动求导时启用它。它也可以用作装饰器。

最后，你可能有一个需要梯度跟踪的张量，但你想要一个不需要的副本。为此，我们有Tensor对象的detach()方法 - 它创建了一个与计算历史分离的张量副本：

x = torch.rand(5, requires_grad=True)
y = x.detach()

print(x)
print(y)

tensor([0.0670, 0.3890, 0.7264, 0.3559, 0.6584], requires_grad=True)
tensor([0.0670, 0.3890, 0.7264, 0.3559, 0.6584])

我们在上面想要绘制一些张量时这样做了。这是因为matplotlib期望输入一个NumPy数组，而对于requires_grad=True的张量，从PyTorch张量到NumPy数组的隐式转换是未启用的。制作一个分离的副本让我们可以继续前进。

自动求导和原地操作

在本笔记本的每个示例中，我们使用变量来捕获计算的中间值。Autograd需要这些中间值来执行梯度计算。因此，在使用autograd时，您必须小心使用就地操作。这样做可能会破坏您在backward()调用中计算导数所需的信息。如果您尝试对需要autograd的叶变量执行就地操作，PyTorch甚至会阻止您，如下所示。

注意

以下代码单元会抛出运行时错误。这是预期的。

a = torch.linspace(0., 2. * math.pi, steps=25, requires_grad=True)
torch.sin_(a)

自动梯度分析器

Autograd 详细跟踪您的计算每一步。这样的计算历史，结合时间信息，将成为一个方便的分析器 - 而 autograd 已经内置了这一功能。这里有一个快速的使用示例：

device = torch.device('cpu')
run_on_gpu = False
if torch.cuda.is_available():
    device = torch.device('cuda')
    run_on_gpu = True

x = torch.randn(2, 3, requires_grad=True)
y = torch.rand(2, 3, requires_grad=True)
z = torch.ones(2, 3, requires_grad=True)

with torch.autograd.profiler.profile(use_cuda=run_on_gpu) as prf:
    for _ in range(1000):
        z = (z / x) * y

print(prf.key_averages().table(sort_by='self_cpu_time_total'))

/var/lib/workspace/beginner_source/introyt/autogradyt_tutorial.py:485: FutureWarning:

The attribute `use_cuda` will be deprecated soon, please use ``use_device = 'cuda'`` instead.

-------------------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------
                     Name    Self CPU %      Self CPU   CPU total %     CPU total  CPU time avg     Self CUDA   Self CUDA %    CUDA total  CUDA time avg    # of Calls
-------------------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------
          cudaEventRecord        43.35%       8.486ms        43.35%       8.486ms       2.122us       0.000us         0.00%       0.000us       0.000us          4000
                aten::div        28.94%       5.665ms        28.94%       5.665ms       5.665us       9.991ms        50.69%       9.991ms       9.991us          1000
                aten::mul        27.65%       5.412ms        27.65%       5.412ms       5.412us       9.719ms        49.31%       9.719ms       9.719us          1000
    cudaDeviceSynchronize         0.06%      12.618us         0.06%      12.618us      12.618us       0.000us         0.00%       0.000us       0.000us             1
-------------------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------
Self CPU time total: 19.576ms
Self CUDA time total: 19.710ms

分析器还可以标记代码的各个子块，按输入张量形状分解数据，并将数据导出为Chrome跟踪工具文件。有关API的完整详细信息，请参阅文档。

高级主题：更多Autograd细节和高级API

如果你有一个具有n维输入和m维输出的函数， $\vec{y}=f(\vec{x})$ ，完整的梯度是一个矩阵，表示每个输出相对于每个输入的导数，称为雅可比矩阵：

J = \left(\begin{array}{ccc} \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{1}}{\partial x_{n}}\\ \vdots & \ddots & \vdots\\ \frac{\partial y_{m}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}} \end{array}\right)

如果你有第二个函数， $l=g\left(\vec{y}\right)$ ，它接受m维输入（即与上述输出相同的维度），并返回标量输出，你可以将其关于 $\vec{y}$ 的梯度表示为一个列向量， $v=\left(\begin{array}{ccc}\frac{\partial l}{\partial y_{1}} & \cdots & \frac{\partial l}{\partial y_{m}}\end{array}\right)^{T}$ - 这实际上只是一个单列的雅可比矩阵。

更具体地说，想象第一个函数是你的PyTorch模型（可能有多个输入和多个输出），第二个函数是一个损失函数（以模型的输出作为输入，损失值作为标量输出）。

如果我们将第一个函数的雅可比矩阵乘以第二个函数的梯度，并应用链式法则，我们得到：

J^{T}\cdot v=\left(\begin{array}{ccc} \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{1}}\\ \vdots & \ddots & \vdots\\ \frac{\partial y_{1}}{\partial x_{n}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}} \end{array}\right)\left(\begin{array}{c} \frac{\partial l}{\partial y_{1}}\\ \vdots\\ \frac{\partial l}{\partial y_{m}} \end{array}\right)=\left(\begin{array}{c} \frac{\partial l}{\partial x_{1}}\\ \vdots\\ \frac{\partial l}{\partial x_{n}} \end{array}\right)

注意：你也可以使用等效操作 $v^{T}\cdot J$ ，并返回一个行向量。

结果列向量是第二个函数相对于第一个函数输入的梯度 - 或者在我们的模型和损失函数的情况下，是损失相对于模型输入的梯度。

``torch.autograd`` 是一个用于计算这些乘积的引擎。 这就是我们在反向传播过程中如何累积学习权重的梯度。

因此，backward() 调用也可以接受一个可选的向量输入。这个向量表示张量上的一组梯度，这些梯度会与自动微分跟踪的张量的雅可比矩阵相乘。让我们尝试一个带有小向量的具体示例：

x = torch.randn(3, requires_grad=True)

y = x * 2
while y.data.norm() < 1000:
    y = y * 2

print(y)

tensor([  299.4868,   425.4009, -1082.9885], grad_fn=<MulBackward0>)

如果我们现在尝试调用 y.backward()，我们会得到一个运行时错误，并且会收到一条消息，说明梯度只能为标量输出隐式计算。对于多维输出，autograd 期望我们为这三个输出提供梯度，以便它可以将其乘以雅可比矩阵：

v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float) # stand-in for gradients
y.backward(v)

print(x.grad)

tensor([1.0240e+02, 1.0240e+03, 1.0240e-01])

（请注意，输出梯度都与2的幂相关——这是我们从一个重复的加倍操作中所期望的。）

高级API

autograd 上有一个 API，可以直接访问重要的微分矩阵和向量操作。特别是，它允许你为特定输入计算特定函数的雅可比矩阵和海森矩阵。（海森矩阵类似于雅可比矩阵，但表示所有偏二阶导数。）它还提供了与这些矩阵进行向量乘积的方法。

让我们以一个简单的函数的雅可比矩阵为例，针对两个单元素输入进行评估：

def exp_adder(x, y):
    return 2 * x.exp() + 3 * y

inputs = (torch.rand(1), torch.rand(1)) # arguments for the function
print(inputs)
torch.autograd.functional.jacobian(exp_adder, inputs)

(tensor([0.7212]), tensor([0.2079]))

(tensor([[4.1137]]), tensor([[3.]]))

如果你仔细观察，第一个输出应该等于 $2e^x$ （因为 $e^x$ 的导数是 $e^x$ ），第二个值应该是3。

当然，你可以使用高阶张量来实现这一点：

inputs = (torch.rand(3), torch.rand(3)) # arguments for the function
print(inputs)
torch.autograd.functional.jacobian(exp_adder, inputs)

(tensor([0.2080, 0.2604, 0.4415]), tensor([0.5220, 0.9867, 0.4288]))

(tensor([[2.4623, 0.0000, 0.0000],
        [0.0000, 2.5950, 0.0000],
        [0.0000, 0.0000, 3.1102]]), tensor([[3., 0., 0.],
        [0., 3., 0.],
        [0., 0., 3.]]))

torch.autograd.functional.hessian() 方法的工作原理相同（假设你的函数是二次可微的），但返回一个包含所有二阶导数的矩阵。

还有一个函数可以直接计算向量-雅可比积，如果你提供了向量：

def do_some_doubling(x):
    y = x * 2
    while y.data.norm() < 1000:
        y = y * 2
    return y

inputs = torch.randn(3)
my_gradients = torch.tensor([0.1, 1.0, 0.0001])
torch.autograd.functional.vjp(do_some_doubling, inputs, v=my_gradients)

(tensor([-665.7186, -866.7054,  -58.4194]), tensor([1.0240e+02, 1.0240e+03, 1.0240e-01]))

torch.autograd.functional.jvp() 方法执行与 vjp() 相同的矩阵乘法，但操作数的顺序相反。vhp() 和 hvp() 方法对向量-海森积执行相同的操作。

有关更多信息，包括关于功能API文档的性能说明

脚本总运行时间： ( 0 分钟 0.766 秒)

Gallery generated by Sphinx-Gallery