【PyTorch简介】5.Automatic Differentiation with `torch.autograd` 自动微分与`torch.autograd`

Automatic Differentiation with torch.autograd 自动微分与torch.autograd

在训练神经网络时，最常用的算法是 back propagation 反向传播。在该算法中，根据损失函数相对于给定参数的 gradient 梯度 来调整参数（模型权重） 。损失函数计算神经网络产生的预期输出和实际输出之间的差异。目标是使损失函数的结果尽可能接近于零。该算法通过神经网络向后遍历来调整权重和偏差来重新训练模型。这就是为什么它被称为反向传播。随着时间的推移重新训练模型以将损失减少到 0 的这种前后过程称为梯度下降。

为了计算这些梯度，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)

Tensors, Functions and Computational graph 张量、函数和计算图

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

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

笔记
您可以在创建张量时设置requires_grad的值，也可以稍后使用x.requires_grad_(True)方法设置。

实际上，我们应用于张量来构造计算图的函数是类Function的对象。该对象知道如何计算 forward direction 前向函数，以及如何在 backward propagation 向后传播 步骤中计算其导数。对反向传播函数的引用存储在张量的grad_fn属性中。您可以在Function 文档中找到更多信息。

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

Out:

Gradient function for z = <AddBackward0 object at 0x7f083264cd60>
Gradient function for loss = <BinaryCrossEntropyWithLogitsBackward0 object at 0x7f083264eec0>

Computing Gradients 计算梯度

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

Out:

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

Note 笔记:
我们只能获取计算图的叶节点的grad属性，其requires_grad属性设置为True。对于我们图中的其他节点，梯度将不可用。
出于性能原因，我们只能在给定图上使用 backward执行一次梯度计算。如果我们需要在同一个图上进行多次backward调用，我们需要将retain_graph=True传递给backward调用。

Disabling Gradient Tracking 禁用梯度跟踪

默认情况下，所有张量都会设置requires_grad=True，来跟踪其计算历史并支持梯度计算。然而，在某些情况下，我们不需要这样做。例如，当我们训练完模型，并且只想将其应用于某些输入数据时，即我们只想通过网络进行 forward computation *前向计算。*我们可以通过使用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)

Out:

True
False

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

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

Out:

False

您可能想要禁用梯度跟踪的原因有：

• 将神经网络中的某些参数标记为 frozen parameters 冻结参数。
• 当您仅进行前向传递时， speed up computations 加快计算速度，因为对不跟踪梯度的张量进行计算会更有效。

More on Computational Graphs 有关计算图的更多信息

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

在前向传递中，autograd 同时执行两件事：

• 运行请求的操作，来计算结果张量
• 在 DAG 中，维护操作的 gradient function 梯度函数。

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

• 计算每个.grad_fn的梯度，
• 在各自张量的.grad属性中，将累积它们
• 使用链式法则，一直传播到叶张量。

Note 笔记

在 PyTorch 中，DAG 是动态的

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

Optional Reading: Tensor Gradients and Jacobian Products 可选阅读：张量梯度和雅可比积

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

对于向量函数 $y=f(x)$ ，当 $x=<x_1,\dots ,x_n>$ 和 $y=<y_1,\dots ,y_m>$ 时，相对于 $x$ 的 $y$ 的梯度，是由Jacobian matrix 雅可比矩阵 计算的，它的元素 $J_{ij}$ 包含 $\frac{\partial y_i}{\partial x_i}$ ：

J = ( ∂ y 1 ∂ x 1 ⋯ ∂ y 1 ∂ x n ⋮ ⋱ ⋮ ∂ y m ∂ x 1 ⋯ ∂ y m ∂ x n ) J= \begin{pmatrix} \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{pmatrix} J= ​∂x1​∂y1​​⋮∂x1​∂ym​​​⋯⋱⋯​∂xn​∂y1​​⋮∂xn​∂ym​​​ ​

对于一个给定的输入向量 $v=(v_1\dots v_m)$ ，PyTorch 允许您计算 Jacobian product 雅可比积 $v^T\cdot J$，而不是计算雅可比矩阵本身。这是通过把 $v$ 作为参数，调用backward，来实现的。 $v$ 的大小应与原始张量的大小相同，我们要计算其乘积：

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

Out:

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

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

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.],
        [2., 2., 2., 2., 4.]])

请注意，当我们使用相同的参数第二次调用backward时，梯度的值是不同的。发生这种情况是因为在进行backward传播时，PyTorch会 accumulates the gradients, 累积梯度。即，将计算出的梯度值添加到计算图所有叶节点的grad属性中。如果你想计算正确的梯度，你需要先将grad属性归零 。在实际训练中， optimizer 优化器可以帮助我们做到这一点。

Note 笔记

以前，我们调用不带参数的backward()函数。这本质上相当于调用 backward(torch.tensor(1.0))，这是在标量值函数（例如，神经网络训练期间的损失）的情况下，计算梯度的有用方法。

知识检查

torch.autograd 引擎的用途是：在模型优化期间自动计算梯度。

Further Reading 进一步阅读

• Autograd Mechanics

References 参考资料

使用 PyTorch 进行机器学习的简介 - Training | Microsoft Learn

使用 PyTorch 进行机器学习的简介 - Training | Microsoft Learn

Github

storm-ice/PyTorch_Fundamentals

storm-ice/PyTorch_Fundamentals