使用torch.autograd自动微分
- 张量、函数和计算图
- 计算梯度
- 禁用梯度追踪
- 关于计算图的更多信息
- 张量梯度和雅可比乘积
在训练神经网络时，最常用的算法是反向传播。在该算法中，参数（模型权重）根据损失函数的梯度相对于给定参数进行调整。
为了计算这些梯度，PyTorch有一个内置的微分引擎，名为torch.autograd。它支持为任何计算图自动计算梯度。
考虑最简单的一层神经网络，具有输入x、参数w和b以及一些损失函数。它可以通过以下方式在PyTorch中定义：
import torchx = 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)`方法。
在 PyTorch 中，用于构建计算图的张量操作函数实际上是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 0x7fdf8cca1c30>
Gradient function for loss = <BinaryCrossEntropyWithLogitsBackward0 object at 0x7fdf8cca2c20>
计算梯度
为了优化神经网络中参数的权重，我们需要计算损失函数关于参数的导数。也就是说，在输入值 x 和目标值 y 的固定取值下，我们需要计算 ∂ l o s s ∂ w \frac{\partial loss}{\partial w} ∂w∂loss 和 ∂ l o s s ∂ b \frac{\partial loss}{\partial b} ∂b∂loss。要计算这些导数，我们只需调用 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调用，我们需要将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
可能想要禁用渐变跟踪的原因如下：
- 将神经网络中的某些参数标记为冻结参数。
- 当您只进行前向传递时，要加快计算速度，因为不跟踪梯度的张量上的计算会更有效。
关于计算图的更多信息
从概念上讲，自动微分在由Function对象组成的有向无环图（DAG）中记录数据（张量）和所有执行的操作（以及生成的新张量）。
在这个有向无环图（DAG）中，叶是输入张量，根是输出张量。通过从根到叶跟踪这个图，您可以使用链式规则自动计算梯度。
在向前传播中，自动微分同时做两件事：
- 运行请求的操作以计算生成的张量
- 在有向无环图中维护操作的梯度函数。
当在有向无环图（DAG）的根节点上调用 .backward() 方法时，反向传播过程就启动了。随后，自动求导系统会进行以下操作：
- 计算每个
.grad_fn的梯度。 - 将它们累加到相应张量的
.grad属性中 - 使用链式规则，一直传播到图的叶张量（叶节点）。
在 PyTorch 中，有向无环图（DAG）是动态的。需要重点理解的是：图会 从头重新构建；每次调用 .backward() 后，自动求导机制（autograd）都会开始生成一幅新图。而这正是模型中能使用控制流语句（如循环、条件判断）的关键——如果有需求，你完全可以在每次迭代时调整图的形状、规模以及具体操作。
张量梯度和雅可比乘积
在许多场景中，我们会用到标量损失函数，此时需要计算损失函数关于某些参数的梯度。但也存在输出函数是任意张量的情况。这时，PyTorch 支持计算所谓的 雅可比积，而非直接计算实际的梯度。
对于向量函数 y ⃗ = f ( x ⃗ ) \vec{y} = f(\vec{x}) y=f(x)（其中 x ⃗ = ⟨ x 1 , . . . , x n ⟩ \vec{x} = \langle x_1, ..., x_n \rangle x=⟨x1,...,xn⟩， y ⃗ = ⟨ y 1 , . . . , y m ⟩ \vec{y} = \langle y_1, ..., y_m \rangle y=⟨y1,...,ym⟩）， y ⃗ \vec{y} y 关于 x ⃗ \vec{x} x 的梯度由雅可比矩阵表示：
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
PyTorch 并不直接计算雅可比矩阵本身，而是允许针对给定的输入向量 v = ( v 1 , . . . , v m ) v = (v_1, ..., v_m) v=(v1,...,vm) 计算雅可比积 v T ⋅ J v^T \cdot J vT⋅J。这一过程通过将 v v v 作为参数调用 backward 实现。需要注意的是， v 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.]])
请注意，当我们使用sameargument第二次调用backward时，梯度的值是不同的。发生这种情况是因为在进行backward传播时，PyTorch累积梯度，即计算梯度的值被添加到计算图所有叶节点的grad属性中。
如果你想计算正确的梯度，你需要先将grad属性归零。在实际训练中，优化器能帮助我们做到这一点。
注：之前我们调用 backward() 函数时没有传入参数。实际上，这等同于调用 backward(torch.tensor(1.0))。在处理标量值函数时，这样做是一种很实用的计算梯度的方法，比如在神经网络训练过程中计算损失函数的梯度就可以用这种方式。
更多内容请看：自动求导机制
)
