学习基础知识 || 快速入门 || 张量 || 数据集和数据加载器 || 转换 || 构建模型 || 自动求导 || 优化 || 保存和加载模型

自动微分与 torch.autograd

创建时间：2021年2月10日 | 最后更新：2024年1月16日 | 最后验证：2024年11月5日

在训练神经网络时，最常用的算法是 反向传播。在这个算法中，参数（模型权重）会根据给定参数相对于损失函数的 梯度 进行调整。

要计算这些梯度，PyTorch 具有一个内置的微分引擎torch.autograd。它支持任意计算图的自动梯度计算。

考虑最简单的单层神经网络，输入为x， 参数为w和b，以及一些损失函数。它可以用以下方式在PyTorch中定义：

import torch

x = torch.ones(5)  # input tensor
y = torch.zeros(3)  # expected output
w = torch.randn(5, 3, requires_grad=True)
b = torch.randn(3, requires_grad=True)
z = torch.matmul(x, w)+b
loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)

张量、函数和计算图

此代码定义了以下计算图：

在该网络中，w 和 b 是参数，我们需要优化它们。因此，我们需要能够计算损失函数关于这些变量的梯度。为了做到这一点，我们设置了这些张量的requires_grad 属性。

注意

您可以在创建张量时设置requires_grad的值，或者稍后通过使用x.requires_grad_(True)方法来设置。

应用于张量以构建计算图的函数实际上是一个Function类的对象。该对象知道如何在前向方向上计算函数，并且也知道如何在反向传播步骤中计算其导数。反向传播函数的引用存储在张量的grad_fn属性中。你可以在Function文档中找到更多信息。

print(f"Gradient function for z = {z.grad_fn}")
print(f"Gradient function for loss = {loss.grad_fn}")

Gradient function for z = <AddBackward0 object at 0x7f9c83065180>
Gradient function for loss = <BinaryCrossEntropyWithLogitsBackward0 object at 0x7f9c8118fca0>

计算梯度

为了优化神经网络中参数的权重，我们需要计算损失函数对参数的导数，即在某些固定值的 x 和 y 下，我们需计算 \(\frac{\partial loss}{\partial w}\) 和 \(\frac{\partial loss}{\partial b}\) 的导数。为了计算这些导数，我们调用 loss.backward()，然后从 w.grad 和 b.grad 中检索值：

loss.backward()
print(w.grad)
print(b.grad)

tensor([[0.3313, 0.0626, 0.2530],
        [0.3313, 0.0626, 0.2530],
        [0.3313, 0.0626, 0.2530],
        [0.3313, 0.0626, 0.2530],
        [0.3313, 0.0626, 0.2530]])
tensor([0.3313, 0.0626, 0.2530])

注意

• 我们只能获得计算图中的叶节点的 grad 个属性，这些叶节点的属性集被设置为 True。对于我们图中的其他所有节点，梯度将不可用。

• 我们只能在给定的图上执行一次梯度计算， backward 由于性能原因。如果我们需要 在同一张图上进行多次 backward 调用，我们需要传递 retain_graph=True 到 backward 调用。

禁用梯度跟踪

默认情况下，所有带有 requires_grad=True 的张量都会跟踪其计算历史并支持梯度计算。然而，在某些情况下我们不需要这样做，例如当我们训练好模型只想对一些输入数据进行应用，即我们只想通过网络进行 前向 计算。我们可以通过用 torch.no_grad() 块包围我们的计算代码来停止跟踪计算：

z = torch.matmul(x, w)+b
print(z.requires_grad)

with torch.no_grad():
    z = torch.matmul(x, w)+b
print(z.requires_grad)

True
False

另一种实现相同结果的方法是在张量上使用 detach() 方法：

z = torch.matmul(x, w)+b
z_det = z.detach()
print(z_det.requires_grad)

False

There are reasons you might want to disable gradient tracking:

• 要将您的神经网络中的某些参数标记为冻结参数。

• 要在进行前向传播时加快计算速度，因为不跟踪梯度的张量上的计算会更高效。

更多关于计算图

概念上，autograd 会记录数据（张量）和执行的所有操作（以及由此产生的新张量）在一个有向无环图（DAG）中， 由 Function 对象组成。在这个 DAG 中，叶子节点是输入张量，根节点是输出张量。通过从根节点追踪到叶子节点， 您可以自动使用链式法则计算梯度。

在前向传播过程中，autograd 同时执行两项操作：

• 执行请求的操作以计算结果张量

• 保持操作的梯度函数在DAG中。

The backward pass kicks off when .backward() 被调用在DAG根节点上。autograd 然后：

• 计算每个.grad_fn的梯度，

• 将其累积在相应的张量的.grad属性中

• 使用链式规则，误差会传播到所有叶子张量。

注意

DAGs在PyTorch中是动态的 需要注意的是，图是从头开始重新创建的；在每次 .backward() 调用之后，autograd都会开始填充一个新的图。这正是允许你在模型中使用控制流语句的原因； 你可以根据需要在每一迭代中改变形状、大小和操作。

可选阅读：张量梯度和雅可比乘积

在许多情况下，我们有一个标量损失函数，并且需要计算某些参数的梯度。然而，在输出函数为任意张量的情况下，PyTorch 允许你计算所谓的雅可比乘积，而不是实际的梯度。

对于一个向量函数\(\vec{y}=f(\vec{x})\)，其中 \(\vec{x}=\langle x_1,\dots,x_n\rangle\) 和 \(\vec{y}=\langle y_1,\dots,y_m\rangle\)，\(\vec{y}\) 对 \(\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)\]

Instead of 计算雅可比矩阵本身，PyTorch 允许你 为给定的输入向量 计算 雅可比乘积 \(v^T\cdot J\)。这通过调用 backward 并 将 \(v\) 作为参数来实现。\(v\) 的大小应与我们想要计算乘积的原始张量的大小相同：

inp = torch.eye(4, 5, requires_grad=True)
out = (inp+1).pow(2).t()
out.backward(torch.ones_like(out), retain_graph=True)
print(f"First call\n{inp.grad}")
out.backward(torch.ones_like(out), retain_graph=True)
print(f"\nSecond call\n{inp.grad}")
inp.grad.zero_()
out.backward(torch.ones_like(out), retain_graph=True)
print(f"\nCall after zeroing gradients\n{inp.grad}")

First call
tensor([[4., 2., 2., 2., 2.],
        [2., 4., 2., 2., 2.],
        [2., 2., 4., 2., 2.],
        [2., 2., 2., 4., 2.]])

Second call
tensor([[8., 4., 4., 4., 4.],
        [4., 8., 4., 4., 4.],
        [4., 4., 8., 4., 4.],
        [4., 4., 4., 8., 4.]])

Call after zeroing gradients
tensor([[4., 2., 2., 2., 2.],
        [2., 4., 2., 2., 2.],
        [2., 2., 4., 2., 2.],
        [2., 2., 2., 4., 2.]])

注意，当我们第二次以相同的参数调用 backward 时，梯度的值是不同的。这是因为当进行 backward 反向传播时，PyTorch 会累积梯度，即计算得到的梯度值会被添加到计算图的所有叶子节点的 grad 属性中。如果你想正确地计算梯度，你需要在调用前清零 grad 属性。在实际训练中，一个优化器可以帮助我们完成这个操作。

注意

Previously 我们调用的是 backward() 无参数的函数。这本质上等价于调用 backward(torch.tensor(1.0))，这是一种在标量函数（例如神经网络训练中的损失）的情况下计算梯度的有效方式。

---

进一步阅读

• 自动求导机制