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

使用 `torch.autograd` 进行自动微分

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

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

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

importtorch

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 0x7feeee8dff70>
Gradient function for loss = <BinaryCrossEntropyWithLogitsBackward0 object at 0x7feeee8dff40>

计算梯度

为了优化神经网络中参数的权重，我们需要计算损失函数相对于参数的导数，即在固定的 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 属性，这些节点的 requires_grad 属性被设置为 True。对于图中所有其他节点，梯度将不可用。

出于性能考虑，我们只能在给定图上使用 backward 进行一次梯度计算。如果需要在同一图上多次调用 backward，则需要在 backward 调用中传递 retain_graph=True。

禁用梯度跟踪

默认情况下，所有 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

在某些情况下，您可能需要禁用梯度跟踪：

将神经网络中的某些参数标记为冻结参数。
当仅进行前向传播时，加速计算，因为对不跟踪梯度的张量进行计算会更加高效。

深入理解计算图

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

在前向传播过程中，autograd 会同时执行两件事：

运行请求的操作以计算结果张量
在DAG中维护操作的梯度函数。

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

从每个 .grad_fn 计算梯度,
将它们累积到相应张量的 .grad 属性中,
使用链式法则，一直传播到叶子张量。

DAG 在 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)$

PyTorch 允许您为给定的输入向量 $v=(v_1 \dots v_m)$ 计算 Jacobian 乘积 $v^T\cdot J$ ，而不需要直接计算 Jacobian 矩阵本身。这是通过将 $v$ 作为参数调用 backward 来实现的。 $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 时，梯度的值会有所不同。这是因为在执行反向传播时，PyTorch 会累积梯度，即计算出的梯度值会加到计算图中所有叶子节点的 grad 属性中。如果你想要计算正确的梯度，需要在之前将 grad 属性清零。在实际训练中，优化器 会帮助我们完成这一操作。

之前我们在调用 backward() 函数时没有传递参数。这实际上等同于调用 backward(torch.tensor(1.0))，这是一种在标量值函数（例如神经网络训练中的损失函数）情况下计算梯度的有效方法。

使用 torch.autograd 进行自动微分