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

使用 torch.autograd ¶ 自动微分

创建于：2025 年 4 月 1 日 | 最后更新：2025 年 4 月 1 日 | 最后验证：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}")

计算梯度 ¶

为了优化神经网络中参数的权重，我们需要计算损失函数相对于参数的导数，即我们需要在 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)

备注

• 我们只能获取计算图叶子节点的 grad 属性，这些节点的 requires_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)

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

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

你可能想要禁用梯度跟踪的原因有以下几点：

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

• 当你只进行前向传递时，为了加快计算速度，因为对不跟踪梯度的张量进行计算会更高效。

关于计算图的更多内容

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

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

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

• 在 DAG 中维护操作的梯度函数。

当在 DAG 根节点上调用 .backward() 时，反向传播开始。然后 autograd ：

• 计算每个 .grad_fn 的梯度，

• 将它们累加到相应张量的 .grad 属性中。

• 使用链式法则，一直传播到叶张量。

备注

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

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

在许多情况下，我们有一个标量损失函数，需要计算相对于某些参数的梯度。然而，在某些情况下，输出函数是一个任意的张量。在这种情况下，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)\]

而不是直接计算雅可比矩阵本身，PyTorch 允许你计算给定输入向量 \(v=(v_1 \dots v_m)\) 的雅可比积 \(v^T\cdot J\)。\(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}")

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

备注

之前我们调用 backward() 函数时没有参数。这本质上等同于调用 backward(torch.tensor(1.0)) ，这在计算标量值函数的梯度时非常有用，例如神经网络训练中的损失。

---

进一步阅读

• Autograd 机制