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

为了计算这些梯度，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 的固定取值下，我们需要计算 $\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调用，我们需要将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 支持计算所谓的 雅可比积，而非直接计算实际的梯度。

对于向量函数 $\vec{y}=f(\vec{x})$（其中 $\vec{x}=⟨x_1,...,x_n⟩$，$\vec{y}=⟨y_1,...,y_m⟩$），$\vec{y}$ 关于 $\vec{x}$ 的梯度由雅可比矩阵表示：
$$J=\left(\begin{array}{ccc}\frac{\partial y_1}{\partial x_1}& \cdots & \frac{\partial y_1}{\partial x_n}\\ ⋮& \ddots & ⋮\\ \frac{\partial y_m}{\partial x_1}& \cdots & \frac{\partial y_m}{\partial x_n}\end{array}\right)$$

PyTorch 并不直接计算雅可比矩阵本身，而是允许针对给定的输入向量 $v=(v_1,...,v_m)$ 计算雅可比积 $v^T\cdot J$。这一过程通过将 $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.]])

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

注：之前我们调用 backward() 函数时没有传入参数。实际上，这等同于调用 backward(torch.tensor(1.0))。在处理标量值函数时，这样做是一种很实用的计算梯度的方法，比如在神经网络训练过程中计算损失函数的梯度就可以用这种方式。

更多内容请看：自动求导机制