训练神经网络时，最常用的算法是反向传播。在该算法中，参数（模型权重）会根据损失函数相对于给定参数的梯度进行调整。
为了计算这些梯度，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}")Gradient function for z = <AddBackward0 object at 0x7f50d55cc4f0> Gradient function for loss = <BinaryCrossEntropyWithLogitsBackward0 object at 0x7f50d55ce320>
计算梯度
为了优化神经网络中的参数权重，我们需要计算损失函数相对于参数的导数，即在 x 和 y 的某些固定值下，我们需要 ∂loss/∂w 和 ∂loss/∂b。为了计算这些导数，我们调用 loss.backward()，然后从 w.grad 和 b.grad 中获取值：
loss.backward() print(w.grad) print(b.grad)
tensor([[0.2033, 0.0070, 0.0284], [0.2033, 0.0070, 0.0284], [0.2033, 0.0070, 0.0284], [0.2033, 0.0070, 0.0284], [0.2033, 0.0070, 0.0284]]) tensor([0.2033, 0.0070, 0.0284])
注意：
我们只能获取计算图叶节点的 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 属性中
使用链式法则，一直传播到叶张量
注意：PyTorch 中的 DAG 是动态的 需要注意的重要一点是，图是从头开始重新创建的；在每次 .backward() 调用后，autograd 开始填充一个新图。这正是允许你在模型中使用控制流语句的原因；如果需要，你可以在每次迭代中更改形状、大小和操作。
可选阅读：张量梯度与雅可比积
在许多情况下，我们有一个标量损失函数，并且需要计算相对于某些参数的梯度。但是，在某些情况下，输出函数是任意张量。在这种情况下，PyTorch 允许你计算所谓的雅可比积，而不是实际的梯度。
对于向量函数 y⃗=f(x⃗)，其中 x⃗=⟨x₁,…,xₙ⟩ 且 y⃗=⟨y₁,…,yₘ⟩，y⃗ 相对于 x⃗ 的梯度由雅可比矩阵给出：
PyTorch 不是直接计算雅可比矩阵本身，而是允许你为给定的输入向量 v=(v₁…vₘ) 计算雅可比积 vᵀ⋅J。这是通过调用 backward 并将 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.]])
请注意，当我们第二次使用相同的参数调用 backward 时，梯度的值是不同的。发生这种情况是因为在进行 backward 传播时，PyTorch 会累积梯度，即计算出的梯度值会添加到计算图所有叶节点的 grad 属性中。如果你想计算正确的梯度，需要在此之前将 grad 属性清零。在实际训练中，优化器会帮助我们完成这项工作。
注意：之前我们在没有参数的情况下调用 backward() 函数。这本质上等同于调用 backward(torch.tensor(1.0))，这是在标量值函数（如神经网络训练期间的损失）的情况下计算梯度的一种有用方法。
