模块 2: 神经网络与反向传播

模块 01以手工构造特征上的线性模型作结，即 f(\mathbf{x}) = \mathbf{w}^\top\boldsymbol{\psi}(\mathbf{x})。（模块 01 把特征映射写作 \boldsymbol{\phi}；本模块把 \phi 留给激活函数。）只有当有人知道 \boldsymbol{\psi} 时，这样的模型才行得通：对于环内的圆盘，\boldsymbol{\psi}(\mathbf{x}) = (x_1^2, x_2^2, x_1x_2) 就能让两个类别线性可分。而对于一幅图像或一条振动频谱，没有人能把 \boldsymbol{\psi} 写出来。神经网络（neural network）把特征映射变成模型的一部分，并从数据中学出来：

其中 \mathbf{W} 和 \mathbf{b} 与 \mathbf{w} 一起训练，用的是同一种梯度下降。

多层感知机

多层感知机（multilayer perceptron，MLP）把这样的层堆叠起来。本模块将它写作

其中 \mathbf{W}^{(l)} \in \mathbb{R}^{d_{l-1}\times d_l}（每一行对应该层的一个输入，每一列对应一个单元），\mathbf{b}^{(l)} \in \mathbb{R}^{d_l}。下文处处沿用这一约定。激活函数（activation function）\phi 是逐分量作用的固定非线性函数（第 5 节比较各种选择）。最后一层没有 \phi：它的输出 \mathbf{z}^{(L)} 在回归中就是预测值，在分类中就是 logits 向量，由损失函数来处理它，即平方误差或 softmax 交叉熵（cross-entropy）（模块 01，第 5 节）。术语如下：\mathbf{x} 是输入；第 1 到 L-1 层是隐藏层（hidden layer），\mathbf{h}^{(l)} 的每个分量是一个隐藏单元（hidden unit）；第 L 层是输出层；d_l 是第 l 层的宽度（width）；L，即权重层的数目，是深度（depth）；\mathbf{z}^{(l)} 是预激活（pre-activation）。图 2.1 在一个小网络上标出了这些量。

为什么必须有非线性

没有 \phi，深度什么也换不来。两层给出

这里用到 \mathbf{B}^\top\mathbf{A}^\top = (\mathbf{A}\mathbf{B})^\top：结果是一个仿射映射。由归纳法，任意多个仿射层的堆叠都塌缩成一个，所以没有激活函数的深层网络就是带冗余参数的线性模型。

通用近似定理说了什么

有了 \phi，原则上一个隐藏层就够了。通用近似定理（universal approximation theorem）：设 \phi 连续且不是多项式。对紧集 K \subset \mathbb{R}^d 上的每个连续函数 f 和每个 \varepsilon > 0，都存在有限的宽度 N 和一组权重，使单隐藏层网络 g(\mathbf{x}) = \sum_{j=1}^{N} a_j\,\phi(\mathbf{w}_j^\top\mathbf{x} + b_j) + c 满足

Cybenko（1989）对 sigmoid 证明了它，Hornik（1991）推广到有界、非常数的激活函数；Leshno 等人（1993）表明“不是多项式”恰好是充要条件，因此 ReLU 也在其内。这个例外不难理解：若 \phi 是 p 次多项式，则每个这样的 g 都是次数至多为 p 的多项式，这是一个固定的函数族，无法任意接近 \sin 3x。

这个定理说的比看上去的要少。它没有说 N 要多大：构造性的证明实际上是用网格铺满 K，而 d 维空间中间距为 h 的网格约有 h^{-d} 个单元格，所以单元数可能随 d 指数增长。它没有说从随机初始点出发的梯度下降能找到这样的权重。它也没有说拟合有限个样本得到的网络能够泛化。本模块其余部分讨论第二个问题；模块 01 第 10 节的评估规范则针对第三个问题。

一维情形下的构造性证明

在一维中，权重可以直接写出来。取节点 a = x_0 < x_1 < \dots < x_K = b，令 p 为 f 的分段线性插值，它在第 k 段上的斜率为 s_k = \big(f(x_{k+1}) - f(x_k)\big)/(x_{k+1} - x_k)。在 [a, b] 上，

在第一段上只有第一个铰链处于激活状态，所以 p 从 f(x_0) 出发，斜率为 s_0；之后每个铰链在其节点处打开，并使斜率恰好改变 c_k。这就是一个含 K 个单元的单隐藏层 ReLU 网络：输入权重为 1，偏置为 -x_k，输出权重为 c_k，输出偏置为 f(x_0)。

它的误差来自线性插值的余项。固定 [x_k, x_{k+1}] 段中的 x，段长为 h，选常数 C，使 e(u) = f(u) - p(u) - C(u - x_k)(u - x_{k+1}) 在 u = x 处为零。那么 e 有三个零点 x_k、x 和 x_{k+1}，所以两次应用罗尔定理，得到某个 \xi 使 e''(\xi) = f''(\xi) - 2C = 0；于是 f(x) - p(x) = \tfrac12 f''(\xi)(x - x_k)(x - x_{k+1})。这个乘积的绝对值在中点处最大，为 h^2/4，所以令 M = \max|f''|，

要达到精度 \varepsilon，需要 h \le \sqrt{8\varepsilon/M}：在一维中，所需单元数正比于 \varepsilon^{-1/2}。

深度为什么有帮助

这一构造每个线性段花费一个单元。对某些函数，深度要高效得多。[0, 1] 上的帐篷映射（tent map）用两个 ReLU 单元：

它把 [0, 1] 的每一半都映满整个 [0, 1]，前一半上升，后一半下降，所以再作用一次，就把每个线性段对折：k 重复合 t^k 是一个有 2^k 段的锯齿波（Telgarsky 2016）。作为网络，t^k 是 k 层、每层 2 个单元。第一层有 2 个权重和 2 个偏置；之后每一层通过 4 个权重和 2 个偏置读取上一层的一对输出 (h_1, h_2)，因为 t = 2h_1 - 4h_2 是这一对输出的线性函数；输出 2h_1 - 4h_2 需要 2 个权重和 1 个偏置。合计：2k 个单元，4 + 6(k - 1) + 3 = 6k + 1 个参数。

标量输入上的单隐藏层 ReLU 网络 g(x) = \sum_j a_j\operatorname{ReLU}(w_jx + b_j) + c，只在某个单元切换的地方改变斜率，即 x = -b_j/w_j 处。有 n 个单元时，它至多有 n 个断点，因而至多有 n + 1 段。因此表示 t^k 至少需要 2^k - 1 个单元和 3(2^k - 1) + 1 个参数（每个单元有一个输入权重、一个偏置和一个输出权重，外加 c）。复合在每一段上重用同样的两个单元；宽度则要为每一段分别付出代价。

这个论证所表明的是：存在这样的函数，深层网络表示它的代价比浅层网络低指数倍；更一般地，ReLU 网络能产生的线性区域数随深度指数增长（Montúfar 等人 2014）。它并没有表明你关心的函数属于这一类，也没有表明梯度下降能找到这种深层构造。深度也有代价：梯度必须穿过每一层往回传，而第 3 节会说明它在途中如何消失，第 5 节、第 6 节和第 10 节处理这个问题。支持深度的非正式理由是：真实数据看上去具有组合结构，边缘组成纹理，纹理组成部件（模块 03），而简单映射的复合正好契合这种结构。

隐藏单元学到了什么

第一层的 ReLU 单元计算 \operatorname{ReLU}(\mathbf{w}^\top\mathbf{x} + b)：在直线 \mathbf{w}^\top\mathbf{x} + b = 0 的一侧为零，在另一侧随到直线的距离线性上升，沿这条直线为常数。它是一个脊函数（ridge function），即半平面上的一个斜坡。输出层用权重把这些斜坡相加，所以 logit 是分段线性的，决策边界（logit 为零处）是一个多边形。三个斜坡可以用一个三角形围住圆盘；两个只能形成一个楔形，什么也围不住。

第 1 节把一个样本写成列向量。训练一次处理 B 个样本组成的一个 batch，把它们堆成矩阵的各行。网络代码中的大多数 bug 都是形状 bug，所以本节把每个形状都写下来。它还统计前向传播在参数、运算量和内存上的开销，因为本系列后面所有的开销估算都从这些计数出发。

batch 形式

令 \mathbf{H}^{(0)} = \mathbf{X} \in \mathbb{R}^{B\times d_0}，每行一个样本，

其中 \mathbf{1} \in \mathbb{R}^{B} 是全 1 向量，所以 \mathbf{1}\mathbf{b}^{(l)\top} 把偏置复制到每一行。\mathbf{Z}^{(l)} 的第 i 行是 \mathbf{h}_i^{(l-1)\top}\mathbf{W}^{(l)} + \mathbf{b}^{(l)\top}，即第 1 节 \mathbf{W}^{(l)\top}\mathbf{h}_i^{(l-1)} + \mathbf{b}^{(l)} 的转置：计算相同，只是样本按行而不是按列排列。在 NumPy 中偏置不需要复制：把形状为 (d_l,) 的数组加到形状为 (B, d_l) 的数组上，会沿行广播（broadcast）。输出 \mathbf{Z}^{(L)} \in \mathbb{R}^{B\times K} 为每个样本给出一行 K 个 logits；softmax 发生在损失函数内部（第 12 节），绝不作为它前面的一层。

import numpy as np

rng = np.random.default_rng(0)
sizes = [64, 128, 128, 10]                         # d0 ... d3: the digits network
params = [(rng.normal(0, np.sqrt(2 / m), (m, n)), np.zeros(n))    # W is (d_{l-1}, d_l)
          for m, n in zip(sizes[:-1], sizes[1:])]

X = rng.normal(size=(64, sizes[0]))                # a batch: B = 64 rows
H = X
for l, (W, b) in enumerate(params, start=1):
    Z = H @ W + b                                  # (B, d_{l-1}) @ (d_{l-1}, d_l) + (d_l,)
    assert Z.shape == (X.shape[0], W.shape[1])
    H = np.maximum(Z, 0) if l < len(params) else Z     # no activation on the logits
print(H.shape, sum(W.size + b.size for W, b in params))

(64, 10) 26122

参数、FLOPs 与内存

第 l 层有 d_{l-1}d_l 个权重和 d_l 个偏置，所以网络共有 \sum_{l=1}^{L}(d_{l-1}d_l + d_l) 个参数。一个 (B\times m) 矩阵与一个 (m\times n) 矩阵相乘，要算 Bn 个长度为 m 的点积：Bmn 次乘法和差不多同样多的加法，即 2Bmn 次浮点运算（floating-point operations，FLOPs）。对各层求和，前向传播约花费权重数的 2B 倍：每个权重对每个样本参与一次乘法和一次加法。偏置加法和激活每层花费 O(Bd_l)，对宽层而言，与 Bd_{l-1}d_l 相比可以忽略。大模型前向传播每个 token 约花费 2N FLOPs 的经验法则就来源于此。

本系列把这类计数的约定一次定下，见模块 06 第 11 节：在 FLOP 计数中，N 指参与矩阵乘法的权重（嵌入查表不花 FLOPs），注意力另加一项，随上下文增长，一个训练步按三次前向传播计（第 3 节说明为什么反向传播至多花两次）。相比之下，内存要计入每一个参数。

反向传播（第 3 节）需要每一层的输入 \mathbf{H}^{(l-1)} 和预激活 \mathbf{Z}^{(l)}（或足以计算 \phi' 的信息），所以为训练而做的前向传播要存储 O(B\sum_l d_l) 个数。参数只存一份；激活则 batch 中每个样本存一份，这就是为什么激活内存随 batch 大小乘以深度增长。字节单位遵循本系列的约定：kB、MB 和 GB 是十进制（10^3、10^6 和 10^9 字节）；KiB、MiB 和 GiB 是二进制（2^{10}、2^{20} 和 2^{30} 字节）。

实践中的形状

PyTorch 的 nn.Linear(d_in, d_out) 把权重存成 (d_out, d_in) 张量，计算 \mathbf{X}\mathbf{W}^\top + \mathbf{b}。数学上完全相同，只是存储布局不同，在 NumPy 和 PyTorch 之间复制权重时这一点很要紧。实验 1 正是出于这个原因把 W1.T 复制进 PyTorch 的层。

import torch, torch.nn as nn

layer = nn.Linear(64, 128)                         # PyTorch stores (d_out, d_in)
print(tuple(layer.weight.shape), tuple(layer.bias.shape))

pred, t = torch.zeros(256, 1), torch.zeros(256)    # (B, 1) against (B,)
print(tuple((pred - t).shape))                     # broadcast, silently

(128, 64) (128,)
(256, 256)

在每个数组旁边写下它的形状，写在注释里或写成 assert。第二个 print 显示了回归中最常见的静默形状 bug：形状为 (B, 1) 的预测减去形状为 (B,) 的目标，会广播成 (B, B)，即每个预测对每个目标。NumPy 毫无提示地算出结果。PyTorch 的 F.mse_loss 会警告：“Using a target size (torch.Size([256])) that is different to the input size (torch.Size([256, 1])). This will likely lead to incorrect results due to broadcasting”，然后继续运行。模型于是学到错误的东西。对预测 \hat y_i，在所有目标上的均值是 \frac1B\sum_j(\hat y_i - t_j)^2 = (\hat y_i - \bar t)^2 + \operatorname{Var}(t)，所以当每个预测都等于目标均值 \bar t 时损失最小，与输入无关，此时损失等于目标的方差。

梯度下降需要每一层的 \partial\mathcal{L}/\partial\mathbf{W}^{(l)} 和 \partial\mathcal{L}/\partial\mathbf{b}^{(l)}。反向传播（backpropagation）是经过组织的链式法则，使每一层的梯度都由下一层的梯度算出，只需一次反向扫描，代价与前向传播相当。本节推导它，使反向传播的每一行都能手工写出、检验和估算开销。

矩阵微积分，够用即可

标量对向量或矩阵的梯度，与该向量或矩阵形状相同。对于 \mathbf{y} = f(\mathbf{x})，\mathbf{y} \in \mathbb{R}^m，\mathbf{x} \in \mathbb{R}^n，雅可比矩阵（Jacobian）\mathbf{J} \in \mathbb{R}^{m\times n} 的元素为 J_{ij} = \partial y_i/\partial x_j。链式法则把雅可比矩阵复合起来，\mathbf{J}_{g\circ f} = \mathbf{J}_g\mathbf{J}_f，对标量损失，它写成

由此得到三个事实，本节只用这三个。

1. 对 \mathbf{z} = \mathbf{W}^\top\mathbf{h} + \mathbf{b}，z_j = \sum_i W_{ij}h_i + b_j，所以 \partial z_j/\partial h_i = W_{ij}：雅可比矩阵是 \mathbf{W}^\top，且 \nabla_{\mathbf{h}}\mathcal{L} = \mathbf{W}\,\nabla_{\mathbf{z}}\mathcal{L}。
2. W_{ij} 只出现在 z_j 中，系数为 h_i，所以 \partial\mathcal{L}/\partial W_{ij} = h_i\,\partial\mathcal{L}/\partial z_j：\nabla_{\mathbf{W}}\mathcal{L} = \mathbf{h}\,(\nabla_{\mathbf{z}}\mathcal{L})^\top，是一个外积。
3. 对逐元素的 \mathbf{h} = \phi(\mathbf{z})，h_i 只依赖于 z_i，所以雅可比矩阵是 \operatorname{diag}(\phi'(\mathbf{z}))，且 \nabla_{\mathbf{z}}\mathcal{L} = \nabla_{\mathbf{h}}\mathcal{L}\odot\phi'(\mathbf{z})，其中 \odot 是逐元素乘积。

拿不准转置放在哪里时，检查形状：\nabla_{\mathbf{W}}\mathcal{L} 必须是 d_{\text{in}}\times d_{\text{out}}，\mathbf{h} 的长度是 d_{\text{in}}，\nabla_{\mathbf{z}}\mathcal{L} 的长度是 d_{\text{out}}，只有 \mathbf{h}(\nabla_{\mathbf{z}}\mathcal{L})^\top 具有这个形状。

误差信号与输出处的方程

把第 l 层的误差信号（error signal）定义为损失对其预激活的梯度，针对一个样本：\boldsymbol{\delta}^{(l)} = \partial\mathcal{L}/\partial\mathbf{z}^{(l)} \in \mathbb{R}^{d_l}。

方程 1，在输出处。对于 softmax 交叉熵，\mathcal{L} = -\sum_k y_k\ln\hat p_k，其中 \hat{\mathbf{p}} = \softmax(\mathbf{z})，\mathbf{y} 为独热向量。模块 01 第 6 节是分情形推导这个梯度的；借助雅可比矩阵，两行就够了。对 \hat p_k = e^{z_k}/\sum_m e^{z_m} 求导，得 \partial\hat p_k/\partial z_j = \hat p_k([k = j] - \hat p_j)，其中 [k = j] 在 k = j 时为 1，否则为 0：softmax 的雅可比矩阵是 \operatorname{diag}(\hat{\mathbf{p}}) - \hat{\mathbf{p}}\hat{\mathbf{p}}^\top。于是

因为 \sum_k y_k = 1。所以 \boldsymbol{\delta}^{(L)} = \hat{\mathbf{p}} - \mathbf{y}，与逻辑回归中的 \hat p - y 相同，其各项之和为零。对线性输出上的平方误差 (\hat y - y)^2，\delta^{(L)} = 2(\hat y - y)。当损失在一个 batch 上取平均时，每个样本的 \boldsymbol{\delta} 带有一个因子 1/B。

方程 2，层与层之间

第 l + 1 层计算 \mathbf{z}^{(l+1)} = \mathbf{W}^{(l+1)\top}\phi(\mathbf{z}^{(l)}) + \mathbf{b}^{(l+1)}。事实 1 把误差从 \mathbf{z}^{(l+1)} 传回 \mathbf{h}^{(l)}，事实 3 再把它传过 \phi：

误差沿着当初传递信号的同一组权重被推回去，并受激活函数导数的门控：\phi'(z_i) = 0 的单元什么也传不回去。

方程 3 和 4，参数梯度

对第 l 层应用事实 2，再加上 \partial\mathbf{z}^{(l)}/\partial\mathbf{b}^{(l)} = \mathbf{I}，得到

权重梯度是流入该层的量与流出的误差的外积，其形状与 \mathbf{W}^{(l)} 相同。这四个方程就是整个算法：一次前向传播，存下方程需要的量，然后一次反向扫描（图 2.5）。

forward:   h(0) = x
           for l = 1 … L:   z(l) = W(l)ᵀ h(l−1) + b(l);   h(l) = φ(z(l))   (no φ at l = L)
           keep every h(l−1) and z(l)
backward:  δ(L) = ∂𝓛/∂z(L)                      p̂ − y, or 2(ŷ − y)            Equation 1
           for l = L … 1:
               ∂𝓛/∂W(l) = h(l−1) δ(l)ᵀ;   ∂𝓛/∂b(l) = δ(l)                  Equations 3, 4
               if l > 1:   δ(l−1) = (W(l) δ(l)) ⊙ φ′(z(l−1))                Equation 2

batch 形式与代码

对一个 batch，把误差信号堆成各行，\boldsymbol{\Delta}^{(l)} \in \mathbb{R}^{B\times d_l}，第 i 行等于 \boldsymbol{\delta}_i^{(l)\top}。逐行转置这些方程，并把参数梯度在 batch 上求和：

由于 (\mathbf{H}^\top\boldsymbol{\Delta})_{jk} = \sum_i H_{ij}\Delta_{ik}，乘积 \mathbf{H}^{(l-1)\top}\boldsymbol{\Delta}^{(l)} 就是外积 \mathbf{h}_i\boldsymbol{\delta}_i^\top 在 batch 上的和；偏置梯度是 \boldsymbol{\Delta}^{(l)} 的列和。实验 1 中两层回归网络（均方误差）的 backward 函数，与这几行一一对应。把它在小网络上作为只含一个样本的 batch 运行，会打印出上面的数字：

import numpy as np

def forward(p, X):
    Z1 = X @ p["W1"] + p["b1"]; H1 = np.maximum(Z1, 0)        # (B, d1), ReLU
    Y = H1 @ p["W2"] + p["b2"]                                # (B, 1), no activation
    return Y, (X, Z1, H1)                                     # keep what backward needs

def backward(p, cache, Y, T):
    X, Z1, H1 = cache; B = X.shape[0]
    dY = 2 * (Y - T) / B                  # Delta(2): Equation 1, mean over the batch
    g = {"W2": H1.T @ dY, "b2": dY.sum(0)}    # Equations 3 and 4: H1^T Delta, column sums
    dH1 = dY @ p["W2"].T                  # Equation 2: the error passed down ...
    dZ1 = dH1 * (Z1 > 0)                  # ... gated by ReLU'(Z1)
    g["W1"] = X.T @ dZ1; g["b1"] = dZ1.sum(0)
    return g

p = {"W1": np.array([[0.5, -1.0], [0.25, 0.5]]), "b1": np.array([0.1, 0.0]),
     "W2": np.array([[0.8], [-0.6]]), "b2": np.array([0.2])}
X, T = np.array([[2.0, 1.0]]), np.array([[1.0]])             # one example: B = 1
Y, cache = forward(p, X)
g = backward(p, cache, Y, T)
for k in ("W1", "b1", "W2", "b2"):
    print(k, np.round(g[k], 4).tolist())

W1 [[0.896, 0.0], [0.448, 0.0]]
b1 [0.448, 0.0]
W2 [[0.756], [0.0]]
b2 [0.56]

反向传播的开销

第 l 层的前向传播是一次乘积 \mathbf{H}^{(l-1)}\mathbf{W}^{(l)}，花费 2Bd_{l-1}d_l FLOPs。它的反向传播做两次同样大小的乘积：用 \boldsymbol{\Delta}^{(l)}\mathbf{W}^{(l)\top} 把误差往下传，用 \mathbf{H}^{(l-1)\top}\boldsymbol{\Delta}^{(l)} 求权重梯度。门控和偏置求和花费 O(Bd_l)。所以反向传播至多花前向传播的两倍，一个训练步至多约为三次前向传播。当第一层占了很大一部分工作量时，开销会低于两倍，因为不需要对输入 \mathbf{X} 求梯度，第一层省去了误差乘积。模块 06 第 11 节把这一论证推广为 Transformer 的训练 FLOPs 计数。

两个推论

从这四个方程可以得到两个事实，它们解释了训练实践中的很多做法。

梯度随深度消失或爆炸。从输出处展开方程 2，

这是 L - l 个矩阵 \mathbf{D}^{(k-1)}\mathbf{W}^{(k)} 的乘积，每个都是一层的转置雅可比矩阵。如果它们的范数小于 1，误差在传向前面各层的途中几何级数地缩小，梯度就消失（vanish）；如果大于 1，误差增大，梯度就爆炸（explode）。深层 sigmoid 网络在 20 世纪 90 年代出了名地难训练，很大程度上就是这个原因，因为 \sigma' \le 1/4。ReLU、仔细的初始化、归一化和残差连接是对应的补救办法，大致按这个历史顺序出现（第 5 节、第 6 节和第 10 节）。

训练内存随深度乘以 batch 增长。方程 3 需要每一层的输入 \mathbf{h}^{(l-1)}，所以前向传播必须把每层的输入保留到反向扫描走到它为止：内存正比于深度乘以 batch，正如第 2 节所统计的。梯度检查点用重新计算代替存储，正是为此而存在（第 4 节）。

第 3 节手工推导了 MLP 的反向传播。一种新的层类型，比如卷积或注意力块，就需要一次新的推导，而每次手工推导都可能引入 bug。框架通过机械地对程序求导来避免这两点。自动微分（automatic differentiation，autodiff）把链式法则应用到程序实际执行的基本运算上，反向传播就是它的反向模式的一个实例。本节在一个小例子上演示两种模式，说明为什么对标量损失应当用反向模式，并描述调用 loss.backward() 时 PyTorch 做了什么。

计算图

计算图（computational graph）为每个基本运算（加、乘、矩阵乘积、exp、log、sin、tanh、ReLU）设一个节点，边传递中间值 v_i，这些值按一种求值顺序编号，其中每个节点都排在它的输入之后（拓扑序）。每个基本运算都知道自己的局部偏导数：\partial(uv)/\partial u = v，\partial\ln u/\partial u = 1/u。贯穿本节的例子来自 Baydin 等人（2018）：

其中 v_1 = \ln x_1，v_2 = x_1x_2，v_3 = \sin x_2，v_4 = v_1 + v_2，f = v_4 - v_3（图 2.7）。每个输入连到两个节点。

前向模式

前向模式在每个值旁边携带一个切向量（tangent）\dot v_i，即 v_i 沿输入空间中选定方向的导数：

用一个方向给输入赋初值，\dot{\mathbf{x}} = \mathbf{u}，一次传播就得到方向导数 \mathbf{J}\mathbf{u}，即雅可比-向量积（Jacobian-vector product，JVP）。对偶数（dual number）实现了它：形如 a + b\epsilon、\epsilon^2 = 0 的数。由泰勒定理，f(a + b\epsilon) = f(a) + f'(a)\,b\epsilon，\epsilon 的更高次幂都为零，所以对偶数上的算术可以精确地把导数带着走。乘积法则由 (a + b\epsilon)(c + d\epsilon) = ac + (ad + bc)\epsilon 自然得出。

import math

class Dual:
    """a + b·ε with ε² = 0: the value a carries its derivative b along."""
    def __init__(self, a, b=0.0):
        self.a, self.b = a, b
    def __add__(self, o):
        return Dual(self.a + o.a, self.b + o.b)
    def __sub__(self, o):
        return Dual(self.a - o.a, self.b - o.b)
    def __mul__(self, o):                      # (a + bε)(c + dε) = ac + (ad + bc)ε
        return Dual(self.a * o.a, self.a * o.b + self.b * o.a)

def log(u): return Dual(math.log(u.a), u.b / u.a)
def sin(u): return Dual(math.sin(u.a), math.cos(u.a) * u.b)

def f(x1, x2):
    return log(x1) + x1 * x2 - sin(x2)

y = f(Dual(2.0, 1.0), Dual(5.0, 0.0))          # seed the tangent (1, 0)
print(f"f = {y.a:.4f}, df/dx1 = {y.b:.4f}")
y = f(Dual(2.0, 0.0), Dual(5.0, 1.0))          # seed the tangent (0, 1)
print(f"f = {y.a:.4f}, df/dx2 = {y.b:.4f}")

f = 11.6521, df/dx1 = 5.5000
f = 11.6521, df/dx2 = 1.7163

反向模式

反向模式先把程序向前运行一遍并保留各个值，然后从 \bar f = 1 出发，向后传递伴随量（adjoint）\bar v_i = \partial f/\partial v_i：

“+=”就是多元链式法则：一个变量在多处被使用，就会沿多条路径影响输出，它的伴随量是所有这些路径贡献之和。用 \mathbf{u} 给输出赋初值，一次传播就得到向量-雅可比积（vector-Jacobian product，VJP）\mathbf{u}^\top\mathbf{J}。对标量损失，u = 1，这唯一的一行就是整个梯度。

选哪种模式，开销是多少

对 f: \mathbb{R}^n \to \mathbb{R}^m，完整的雅可比矩阵需要 n 次前向模式传播（每次一列），或 m 次反向模式传播（每次一行）（图 2.8），每次传播的开销是计算一次 f 的一个很小的常数倍；对反向模式而言，这就是廉价梯度原理（cheap gradient principle）（Griewank 和 Walther 2008）。训练中 m = 1，n 从约 10^4 到 10^{11}，所以反向模式胜出的倍数为 n 的量级。当 n \ll m 时，前向模式胜出。对一条含 1,000 个采样点的模拟轨迹，求它对 3 个设计参数的灵敏度，需要 3 次前向传播，而反向传播则要 1,000 次。海森矩阵-向量积（Hessian-vector product）的算法是：对反向模式的梯度再做前向模式。物理信息神经网络（模块 05 第 9 节）对网络关于其少数几个输入求导，这是前向模式的自然用途。

磁带与梯度检查点

反向模式的代价是内存。反向扫描需要前向值，所以要把它们记录下来（即磁带，tape），并一直保留到扫描用完它们为止。梯度检查点（gradient checkpointing）只存其中一部分，其余的重新计算：保留每第 k 层的输入，当反向扫描到达某一段时，从它的检查点出发把这一段的 k 层重新前向运行一遍，以重建它们的激活。峰值约为 L/k 个检查点加一段 k 层，在 k = \sqrt L 附近最小：激活内存从 O(L) 降到 O(\sqrt L)，代价是多做约一次前向传播（Chen 等人 2016）。

作为 VJP 规则的层

框架从不构造雅可比矩阵。每个层提供一条规则，把其输出的伴随量映射为其输入的伴随量：

• 线性层，\mathbf{z} = \mathbf{W}^\top\mathbf{h} + \mathbf{b}：给定 \bar{\mathbf{z}}，\bar{\mathbf{h}} = \mathbf{W}\bar{\mathbf{z}}，\bar{\mathbf{W}} = \mathbf{h}\bar{\mathbf{z}}^\top，\bar{\mathbf{b}} = \bar{\mathbf{z}}；
• 激活，\mathbf{h} = \phi(\mathbf{z})：\bar{\mathbf{z}} = \bar{\mathbf{h}}\odot\phi'(\mathbf{z})；
• logits 上的 softmax 交叉熵：\bar{\mathbf{z}} = \hat{\mathbf{p}} - \mathbf{y}。

这些就是第 3 节的方程，其中 \bar{\mathbf{z}}^{(l)} = \boldsymbol{\delta}^{(l)}：反向传播就是把每一层视为一个基本运算的反向模式。改为构造雅可比矩阵是没有希望的。对一个作用于 512 个样本的 batch 的 4,096 → 4,096 层，全部输出对全部输入的雅可比矩阵有 (512\cdot 4{,}096)^2 \approx 4.4\times 10^{12} 个元素，其中几乎全是零，而 VJP 只是一次矩阵乘积。

调用 loss.backward() 时 PyTorch 做了什么

对 requires_grad=True 的张量做的每个运算都会记录一个节点，可通过结果的 .grad_fn 看到，里面存着它的 VJP 规则所需的内容。loss.backward() 按反向拓扑序遍历这些节点，并用“+=”累加到每个叶子张量的 .grad 中。图在每次前向传播时随代码的运行重新构建（define-by-run，即运行时定义），在 backward() 用完之后释放。torch.no_grad() 关闭记录，用于评估和优化器自身的更新；.detach() 返回一个从图中切出的张量，若误用，会悄无声息地阻断梯度。在第 2 节的小网络上：

import torch

x = torch.tensor([2.0, 1.0])
W1 = torch.tensor([[0.5, -1.0], [0.25, 0.5]], requires_grad=True)   # leaves
b1 = torch.tensor([0.1, 0.0], requires_grad=True)
W2 = torch.tensor([[0.8], [-0.6]], requires_grad=True)
b2 = torch.tensor([0.2], requires_grad=True)

def loss_fn():                                # the network of s2, target t = 1
    h1 = torch.relu(W1.T @ x + b1)            # every operation records a node
    return ((W2.T @ h1 + b2 - 1.0) ** 2).sum()

loss = loss_fn()
node, chain = loss.grad_fn, []
while node is not None:                       # follow the first input of each node
    chain.append(node.name().split("::")[-1])
    node = node.next_functions[0][0] if node.next_functions else None
print(" <- ".join(chain))

loss.backward()                               # reverse sweep; the graph is then freed
print(W1.grad, b2.grad)
loss_fn().backward()                          # the next step's backward, not zeroed
print(W1.grad[:, 0], b2.grad)                 # added to the old values: doubled

for p in (W1, b1, W2, b2):
    p.grad = None                             # what optimizer.zero_grad() does
with torch.no_grad():
    print(loss_fn().requires_grad)            # nothing was recorded
print(W1.detach().requires_grad)              # a tensor cut out of the graph

SumBackward0 <- PowBackward0 <- SubBackward0 <- AddBackward0 <- MvBackward0 <- PermuteBackward0 <- AccumulateGrad
tensor([[0.8960, 0.0000],
        [0.4480, 0.0000]]) tensor([0.5600])
tensor([1.7920, 0.8960]) tensor([1.1200])
False
False

沿着每个节点的第一个输入往回走，从损失出发，依次经过求和、平方、减去 t、偏置、乘积 \mathbf{W}^{(2)\top}\mathbf{h}^{(1)} 和转置，最后到达 AccumulateGrad，即把梯度加进 W2.grad 的节点。梯度就是第 3 节的数字。第二次 backward 调用又加上了第二份：因为 .grad 是累加的，所以每个优化器步骤之前都必须调用 optimizer.zero_grad()。使链式法则成立的同一个“+=”，也使忘记 zero_grad 的后果是把过去所有的梯度加进每一步（实验 5，脚本 B）。

实验 2 构建一个约 100 行的标量反向模式引擎，做的正是这件事，每个节点一个数。它还说明了为什么框架要在张量上工作：对 100 个样本做一个 337 参数网络的一个训练步，会创建 66,440 个标量节点，而 PyTorch 只记录约十个张量运算。

第 3 节的式 2 在误差信号向下传播的每一层都要乘以 \phi'(\mathbf{z})。因此，选择激活函数（activation function）首先就是在选择一个导数：每个反向传播的误差在每一层都要被它缩放一次。本节推导这些导数，并说明单元停止传递梯度的两种方式：饱和（saturation）与死亡。

常见选择

\Phi 是标准正态分布的累积分布函数，\phi_N 是标准正态分布的密度函数。截至 2026 年，大多数开放权重的大语言模型在 SwiGLU 前馈块中使用 SiLU（模块 06，第 9 节）。PyTorch 约定 ReLU 在 z = 0 处的导数为 0。图 2.9 画出了这六个函数及其导数。

推导导数

把 sigmoid 写成 (1+e^{-z})^{-1} 并求导：

这是因为 e^{-z}/(1+e^{-z}) = 1 - 1/(1+e^{-z})。(0, 1) 内的一个数与它的补数之积 s(1-s) 在 s = 1/2，即 z = 0 处最大，等于 1/4。反向传播时可以直接用存下来的输出来计算它。

对于 tanh，把 (e^z - e^{-z})/(e^z + e^{-z}) 的分子分母同乘 e^{-z}：

tanh 就是一个在纵向拉伸到 (-1, 1)、在横向压缩为二分之一的 sigmoid。由链式法则，\tanh'(z) = 4\sigma'(2z)，在原点处等于 4\cdot\tfrac14 = 1：形状相同，但以零为中心，斜率是 sigmoid 的四倍。GELU 和 SiLU 都是乘积，用乘积法则可直接得到导数：\Phi + z\phi_N 和 \sigma + z\sigma(1-\sigma)。

自动微分（autograd）能复现这些数值，这是检查你自己实现的任何激活函数的廉价办法：

import torch
import torch.nn as nn

z = torch.tensor([-3.0, 0.0, 1.0, 2.0, 5.0], requires_grad=True)
acts = {"sigmoid": torch.sigmoid, "tanh": torch.tanh, "relu": torch.relu,
        "gelu": nn.GELU(), "silu": nn.SiLU()}
for name, phi in acts.items():
    (grad,) = torch.autograd.grad(phi(z).sum(), z)   # elementwise, so this is phi'(z)
    print(f"{name:8s}", " ".join(f"{g:8.4f}" for g in grad.tolist()))

sigmoid    0.0452   0.2500   0.1966   0.1050   0.0066
tanh       0.0099   1.0000   0.4200   0.0707   0.0002
relu       0.0000   0.0000   1.0000   1.0000   1.0000
gelu      -0.0119   0.5000   1.0833   1.0852   1.0000
silu      -0.0881   0.5000   0.9277   1.0908   1.0265

饱和，以及 ReLU 为何胜出

当 \phi' \approx 0 时，单元几乎不传递梯度，称为饱和。sigmoid 的导数在 |z| > 4.6 时低于 0.01，tanh 的导数在 |z| > 3.0 时低于 0.01。饱和的单元并非永远死亡：它仍在学习，只是速率由那个极小的导数决定。

ReLU 胜出，靠的是它的导数。在激活一侧导数恰为 1，所以误差穿过许多层时不会被激活函数削弱，而 sigmoid 每层最多把误差乘以 1/4。它的计算也很廉价：一次比较，没有指数运算。GELU 和 SiLU 保留了正侧近似线性的特点，并增加了光滑性。

GELU 和 SiLU 都不是单调的。GELU 在 z = -0.752 处取最小值 -0.170，SiLU 在 z = -1.278 处取最小值 -0.278，在这些点之下它们的导数略为负。GELU 常用如下近似来计算： 0.5z\big(1 + \tanh(\sqrt{2/\pi}\,(z + 0.044715z^3))\big)，它与 z\Phi(z) 至多相差 4.7\times 10^{-4}（在 |z| = 2.7 附近最大）。PyTorch 的 nn.GELU() 使用精确的误差函数形式；nn.GELU(approximate="tanh") 使用该近似。

零中心

sigmoid 层的输出全为正。对于单个样本，流入单元 j 的权重的梯度是 \partial\mathcal{L}/\partial W_{ij} = h_i\delta_j（第 3 节），而当所有 h_i > 0 时，这些梯度的符号都与 \delta_j 相同。于是单元 j 的入边权重向量只能沿各分量同号的方向移动，要到达目标就得走之字形。tanh 因为是零中心的，避免了这个问题；零均值的输入和归一化层同样如此（第 6 节和第 10 节）。这一约束只对单个样本成立；mini-batch 梯度是对多个样本求和，各样本的 \delta_j 符号不同，约束因此被放松。

死亡 ReLU 单元

如果某个 ReLU 单元的预激活对每个训练样本都为负，它的导数处处为零：它的入边权重和偏置得不到任何梯度，普通梯度下降永远无法使它复活（练习 5）。常见原因有两个：一次很大的更新（学习率过高）把偏置推到很负的位置，以及不佳的参数初始化。补救办法是降低学习率、使用 He 初始化（第 6 节），或者改用左侧斜率非零的激活函数（leaky ReLU、GELU）。要把它量化出来：死亡比例是指在一个 batch 的所有样本上输出都为 0 的单元所占的比例，实验 4和实验 5都会记录它。

输出层不同

输出层的“激活函数”由损失函数决定，而不是为梯度流动而选：平方误差用恒等函数，交叉熵内部则是 logits 进入 softmax 或 sigmoid（第 12 节）。

训练是从初始权重所计算出的结果开始的。如果权重的尺度不对，在优化器迈出第一步之前，前向信号和反向误差就会随深度呈几何级数增长或衰减（即第 3 节中的雅可比矩阵连乘）。本节从一个要求出发推导尺度，即信号在每一层的大小应当相同，并测量要求不满足时会发生什么。

对称性

把一层的所有权重设成同一个值，无论是零还是别的常数，这一层的每个单元对其输入计算的是同一个函数，收到的误差信号相同，因而梯度也相同。更新之后这些单元仍然完全相同，并且永远保持相同：这一层只有一个单元的表达能力。若权重为零且使用 ReLU，情况更糟，因为 \boldsymbol{\delta}^{(l)} = (\mathbf{W}^{(l+1)}\boldsymbol{\delta}^{(l+1)})\odot\phi' 为零，连第一层的梯度也消失。随机权重打破对称性（symmetry）；偏置可以从零开始，因为随机权重已经使各单元彼此不同。Rumelhart、Hinton 和 Williams（1986）正是出于这个原因从小的随机权重出发。剩下的问题就是尺度。

前向推导

取一个单元，z_j = \sum_{i=1}^{n} w_{ij}h_i，输入数 n = n_{\text{in}}（初始化时偏置为零）。假设 w_{ij} 相互独立，均值为零、方差为 \sigma_w^2，并且与输入 h_i 独立。于是 \mathbb{E}[z_j] = \sum_i \mathbb{E}[w_{ij}]\mathbb{E}[h_i] = 0。z_j^2 的交叉项也为零，因为当 i \ne k 时 \mathbb{E}[w_{ij}h_iw_{kj}h_k] = \mathbb{E}[w_{ij}]\,\mathbb{E}[w_{kj}]\,\mathbb{E}[h_ih_k] = 0，所以

输入是通过它的二阶矩 \mathbb{E}[h^2] 而不是方差进入的。只有当 h 均值为零时两者才一致，而 ReLU 的输出不满足这一点。

现在要求 \operatorname{Var}(z^{(l)}) = \operatorname{Var}(z^{(l-1)})。对于原点附近的 tanh，h \approx z，所以 \mathbb{E}[h^2] \approx \operatorname{Var}(z^{(l-1)})，式 6.1 要求 \sigma_w^2 = 1/n_{\text{in}}（LeCun 等 1998）。对于 ReLU，z^{(l-1)} 关于零对称，所以 \mathbb{E}[h^2] = \tfrac12\operatorname{Var}(z^{(l-1)})（第 5 节的例题），要保持不变就需要

这就是 He 初始化（He 等 2015）。ReLU 把二阶矩减半，因子 2 把它补回来。它并没有把方差减半，方差会降到 0.341\operatorname{Var}(z)。

反向推导

误差满足 \delta^{(l)}_i = \phi'(z^{(l)}_i)\sum_{j=1}^{n_{\text{out}}} w^{(l+1)}_{ij}\delta^{(l+1)}_j，这是对该单元所连接的 n_{\text{out}} 个单元求和。同样的论证，在权重与误差独立的前提下，给出

在原点附近，tanh 的 \phi' \approx 1；ReLU 的 \mathbb{E}[\phi'^2] = P(z > 0) = 1/2。因此反向传播的保持条件是：tanh 用 \sigma_w^2 = 1/n_{\text{out}}，ReLU 用 2/n_{\text{out}}。Glorot 和 Bengio（2010）取折中， \sigma_w^2 = 2/(n_{\text{in}} + n_{\text{out}})，即 Xavier 或 Glorot 初始化。在均匀分布形式下，权重取自 U(-a, a)；因为 \operatorname{Var}(U(-a, a)) = a^2/3，边界为 a = \sqrt{6/(n_{\text{in}} + n_{\text{out}})}。He 等人指出只满足一个方向就够了：按扇入缩放时，每层的反向因子为 n_{\text{out}}\cdot(2/n_{\text{in}})\cdot\tfrac12 = n_{\text{out}}/n_{\text{in}}，各层的乘积逐项相消，只剩两个宽度之比，不随深度增长。扇入模式是 ReLU 的常用选择。

十层上的实测

错误的尺度会造成什么

尺度过大时，tanh 单元饱和：前向信号仍有界，但大多数单元上 \phi' \approx 0，梯度消失；而 ReLU 的激活值会呈几何级数增长直至溢出。尺度过小时，信号呈几何级数缩小，于是不论输入是什么，输出都等于偏置。误差在回传时也会缩小，因为它被同样很小的权重相乘，所以前面的层只能得到很小的梯度，训练一开始就处在平台期。实验 1第 7 步在一个以 \mathcal{N}(0, 10^{-4}) 初始化的浅层网络上展示了这个平台期。

框架默认值不是 He

PyTorch 的 nn.Linear 从 U(-1/\sqrt{n_{\text{in}}}, 1/\sqrt{n_{\text{in}}}) 中抽取权重和偏置，权重方差为 1/(3n_{\text{in}})。这只有 He 的六分之一。

对于没有归一化的深层 ReLU 堆叠，请显式调用 He 初始化器。浅层网络以及带归一化层的网络可以容忍默认值；实验 3 到 5 在深度为 3 时使用默认值。

for m in model.modules():
    if isinstance(m, nn.Linear):
        nn.init.kaiming_normal_(m.weight, nonlinearity="relu")  # std sqrt(2 / fan_in)
        nn.init.zeros_(m.bias)

残差连接

深层网络还要再加一种手段。残差连接（residual connection） \mathbf{h}^{(l)} = \mathbf{h}^{(l-1)} + f(\mathbf{h}^{(l-1)}) 的雅可比矩阵是 \mathbf{I} + \partial f/\partial\mathbf{h}^{(l-1)}。于是第 3 节的反向连乘中总含有一条恒等路径，梯度沿这条路径不会消失。此时前向方差变成相加，\operatorname{Var}(\mathbf{h}^{(l)}) \approx \operatorname{Var}(\mathbf{h}^{(l-1)}) + \operatorname{Var}(f)，如果每个分支都保持其输入的方差，每经过一个块方差就会翻倍。因此深层残差网络会缩小每个分支最后一层的尺度，或者把它初始化为零，使每个块在起始时接近恒等映射。模块 03通过 ResNet 引入残差连接，模块 06则表明每个 Transformer 块里都有它。

输出层

较小的输出尺度会使初始预测接近均匀分布，所以 K 类分类器一开始的损失接近 \ln K（数字识别是 \ln 10 = 2.303）。检查这一点是第 14 节的第一项测试。

固定学习率的普通随机梯度下降很少被直接使用。原因在最简单的损失函数，即二次函数上就能看出来，第一个补救办法动量（momentum）也是如此。本节在二次函数上分析两者，并推导各自能取的最大学习率。

二次函数上的梯度下降

模块 01，第 3 节分析过这种情形；这里给出后文所需的形式。取 \mathcal{L}(\theta) = \tfrac12\theta^\top\mathbf{A}\theta，其中 \mathbf{A} 为对称正定矩阵，特征值为 \lambda_1 \le \dots \le \lambda_d，标准正交特征向量为 \mathbf{q}_i。梯度是 \mathbf{A}\theta，所以一步为 \theta \leftarrow (\mathbf{I} - \eta\mathbf{A})\theta。在特征坐标 u_i = \mathbf{q}_i^\top\theta 下，矩阵是对角的，每个坐标各自演化：

当且仅当 |1 - \eta\lambda_i| < 1 时，坐标 i 收缩，所以当且仅当 \eta < 2/\lambda_{\max} 时所有坐标都收缩。最慢的坐标决定速率 \max_i|1 - \eta\lambda_i|，而且只有两个极端特征值在竞争。令二者平衡，1 - \eta\lambda_{\min} = -(1 - \eta\lambda_{\max})，得到 \eta = 2/(\lambda_{\max} + \lambda_{\min}) 和最佳速率

当 \kappa 很大时，\ln\rho_{\text{GD}} \approx -2/\kappa：误差每缩小到原来的 1/e 约需 \kappa/2 步。陡峭方向决定步长，平缓方向决定所需的时间。

在极小点 \theta^* 附近，梯度为零，网络损失的二阶泰勒展开是 \mathcal{L}(\theta^*) + \tfrac12(\theta - \theta^*)^\top\mathbf{H}(\theta - \theta^*)，其中海森矩阵 \mathbf{H} 取代了 \mathbf{A}。同样的局部限制 \eta < 2/\lambda_{\max}(\mathbf{H}) 在此成立。在全 batch 训练中，\lambda_{\max}(\mathbf{H}) 倾向于上升，直到约为 2/\eta，然后在那里徘徊，而损失仍在不均匀地下降：这就是稳定性边缘（edge of stability，Cohen 等 2021）。学习率不仅要顺应曲率；它还塑造了网络最终所处的曲率。

使用 mini-batch 时，梯度等于完整梯度加上零均值噪声，噪声协方差按 1/B 下降（模块 01，第 4 节）。噪声使损失不再单调下降，并留下一个与 \eta 成正比的噪声底；第 9 节会测量它，学习率调度则能消除它。

重球动量

动量维护一个速度，采用 Polyak（1964）的形式，Rumelhart、Hinton 和 Williams（1986）以及 PyTorch 的 SGD 都使用它：

从 \mathbf{v}_0 = \mathbf{0} 展开，\mathbf{v}_t = \sum_{k=0}^{t-1}\mu^k\mathbf{g}_{t-k}，是过去梯度的指数加权和。对于恒定的梯度，它趋于 \mathbf{g}/(1-\mu)，所以步长趋于 \eta\mathbf{g}/(1-\mu)：即有效学习率（effective learning rate）\eta/(1-\mu)，当 \mu = 0.9 时是 \eta 的十倍。消去 \mathbf{v} 得到等价形式 \theta_{t+1} = \theta_t - \eta\mathbf{g}_t + \mu(\theta_t - \theta_{t-1})：一步梯度步，加上上一步位移的 \mu 倍，也就是小球的惯性。图 2.11 展示了在峡谷地形上两者的差别。

为什么这样有帮助，用滤波器的角度看最清楚。给递推 v_t = \mu v_{t-1} + g_t 输入一个以频率 \omega 振荡的梯度分量 g_t = e^{i\omega t}：\omega = 0 是每一步都相同的分量，\omega = \pi 是每一步都变号的分量。稳态下 v_t = H(\omega)e^{i\omega t}；代入得 H e^{i\omega t} = \mu H e^{i\omega(t-1)} + e^{i\omega t}，所以

动量是一个低通滤波器。沿峡谷的横向，梯度每一步都变号，被衰减 1/(1+\mu) = 0.53 倍；沿峡谷的纵向，梯度方向一致，被放大 1/(1-\mu) = 10 倍，二者之比是 (1+\mu)/(1-\mu) = 19（图 2.12）。

在二次函数上，这一分析是精确的。沿曲率为 \lambda 的特征向量，等价形式写成 u_{t+1} = (1 + \mu - \eta\lambda)u_t - \mu u_{t-1}，这是一个线性递推，其解为 u_t = r^t，其中

两个根之积为 \mu，所以当它们是复数时，二者的模都是 \sqrt\mu：不论 \lambda 是多少，误差每步都收缩 \sqrt\mu 倍。当且仅当多项式在 r = 1 和 r = -1 处都为正（且 \mu < 1）时，两个根都位于单位圆内：在 r = 1 处它等于 \eta\lambda > 0，在 r = -1 处它等于 2(1 + \mu) - \eta\lambda > 0。因此重球在 \eta\lambda_{\max} < 2(1 + \mu) 时稳定，\mu = 0.9 时这个界是 3.8，梯度下降则是 2。取 \eta = 4/(\sqrt{\lambda_{\max}} + \sqrt{\lambda_{\min}})^2 和 \mu = \big((\sqrt\kappa - 1)/(\sqrt\kappa + 1)\big)^2，两个极端特征值就恰好落在复数区域的边缘（代数推导见 Polyak 1964），得到速率 (\sqrt\kappa - 1)/(\sqrt\kappa + 1)：误差每缩小到原来的 1/e 约需 \sqrt\kappa/2 步，而不是 \kappa/2 步。

Nesterov 动量

Nesterov 动量在速度即将把参数带到的那个点上计算梯度： \mathbf{v} \leftarrow \mu\mathbf{v} + \nabla\mathcal{L}(\theta - \eta\mu\mathbf{v})， \theta \leftarrow \theta - \eta\mathbf{v}。PyTorch 的 SGD(nesterov=True) 使用一种等价改写，在存储的参数处计算梯度，\mathbf{v} \leftarrow \mu\mathbf{v} + \mathbf{g}， \theta \leftarrow \theta - \eta(\mathbf{g} + \mu\mathbf{v})。这种前瞻在速度冲过头之前就对其进行修正，在 \eta 适中时 Nesterov 更快。但它并不更稳定。它的特征方程是 r^2 - (1+\mu)(1-\eta\lambda)\,r + \mu(1-\eta\lambda) = 0，在 r = -1 处做同样的检验，得到 \eta\lambda_{\max} < 2(1+\mu)/(1+2\mu)：\mu = 0.9 时为 1.36，低于梯度下降的 2 和重球的 3.8。

实践中的情形

动量的作用主要是提高有效学习率。在实验 3的数字识别网络上，普通 SGD 在 \eta = 0.05 时 20 个轮次（epoch）内训练损失始终没有降到 0.1 以下，而 \eta = 0.5 的 SGD 与 \eta = 0.05、\mu = 0.9 的 SGD 分别在第 3 轮和第 4 轮就达到了，最终验证准确率相差不超过 0.3 个百分点。在不同库或论文之间转换时，有两个约定需要注意。PyTorch 的动量缓冲没有 (1-\mu) 因子（dampening=0），这与 Adam 的一阶矩不同（第 8 节）；在两种形式之间切换，会使有效学习率变化 1/(1-\mu) 倍。动量为 0.9 并配合学习率调度的 SGD 对卷积网络仍然很强（模块 03）；第 8 节的自适应方法则是 Transformer 的默认选择。

动量改进的是步的方向；它对尺度无能为力。网络各参数的梯度大小可以相差几个数量级：在实验 3的数字识别网络的第一步，非零梯度分量从 1.8\times 10^{-7} 到 6.4\times 10^{-2} 不等。于是单个 \eta 对一些参数太大，对另一些又太小。自适应方法施加一个对角预条件矩阵，\theta \leftarrow \theta - \eta\mathbf{D}^{-1}\mathbf{g}，其中 \mathbf{D} 由梯度自身的历史估计，使每个参数都有自己的步长。

AdaGrad 与 RMSProp

AdaGrad（Duchi、Hazan 和 Singer 2011）逐元素地除以累积平方梯度的平方根：

很少被更新的参数保持较大的步长，这适合稀疏特征。但 \mathbf{G} 只增不减：梯度大小大致恒定时，\sqrt{\mathbf{G}} 按 \sqrt t 增长，有效步长按 1/\sqrt t 衰减，所以长时间的非凸训练会停滞。RMSProp（Tieleman 和 Hinton 2012，出自一张讲义幻灯片而不是论文）把求和换成指数滑动平均，使其遗忘旧的梯度：

Adam

Adam（Kingma 和 Ba 2015）在 RMSProp 上加入动量，即梯度的滑动平均，并对两个平均都做了从零启动的修正：

其中 \beta_1 = 0.9，\beta_2 = 0.999，\epsilon = 10^{-8}。大语言模型常取 \beta_2 = 0.95，使 \mathbf{v} 能更快地跟上梯度尺度的变化。

偏差修正（bias correction）。 取 \mathbf{m}_0 = \mathbf{0}，把滑动平均展开得到 m_t = (1-\beta_1)\sum_{s=1}^{t}\beta_1^{t-s}g_s。若梯度均值恒定，

这用到了等比级数求和。平均值被偏向零，偏差因子是 1-\beta_1^t，除以它就消除了偏差；对 \beta_2 和 g^2 做同样的论证，就得到 \hat{\mathbf{v}}。不做修正时，步长 m/\sqrt v 等于修正后的步长乘以 (1-\beta_1^t)/\sqrt{1-\beta_2^t}。对 \beta_2 = 0.999，这个因子在 t = 1 时是 3.16，在 t = 12 时达到峰值 6.57，到 t = 1{,}000 时仍有 1.26：早期的步长大了好几倍。对 \beta_2 = 0.95，它在 t = 1 时是 0.45，从未超过 1.10。误差朝哪个方向，取决于 \beta_2 与 \beta_1 的相对大小（图 2.13）。

Adam 的步长是什么。 参数 i 移动的距离约为 \eta|\hat m_i|/\sqrt{\hat v_i}。由于 \hat v_i 估计的是 \mathbb{E}[g_i^2] = \mathbb{E}[g_i]^2 + \operatorname{Var}(g_i)，梯度一致时步长约为 \eta，梯度有噪声时步长更小。在 t = 1 时，\hat m = g 且 \hat v = g^2，所以步长恰为 \eta g/(|g| + \epsilon) \approx \eta\,\operatorname{sign}(g)：每个梯度不可忽略的参数都移动 \eta。

这一更新对损失的缩放不变：\mathbf{g} \to c\mathbf{g} 使 \hat{\mathbf{m}} \to c\hat{\mathbf{m}}，\sqrt{\hat{\mathbf{v}}} \to |c|\sqrt{\hat{\mathbf{v}}}，比值不变（不计 \epsilon）。把损失乘以 1,000，SGD 的步长就变成 1,000 倍，所以凡是原先稳定的 \eta 都会发散；Adam 的步长则不变。这就是 Adam 能容忍未缩放损失的原因。它对参数的缩放并不具有不变性，这也是未缩放的输入仍会伤害它的原因（练习 15）。

Adam 还是逐坐标的：它在参数坐标轴方向上均衡尺度，却无法消除旋转方向上的曲率。在 optimiser-paths 控件的峡谷上（第 7 节），谷底与坐标轴对齐时它需要约 126 步，谷底旋转 45° 时需要约 214 步，而梯度下降和重球不受影响。

内存。 Adam 为每个参数多保存两个数。若权重和梯度为 fp32，则每个参数 4 + 4 + 4 + 4 = 16 字节；若权重和梯度为 bf16，再加一份 fp32 主副本，则同样是 2 + 2 + 4 + 4 + 4 = 16 字节。数字识别网络需要 26{,}122\cdot 16 = 417{,}952 字节，即 418 kB；一个有 7\times 10^9 个参数的模型在还没算任何激活之前就需要 112 GB。完整的核算见模块 08，第 8 节。

在 Adam 下，权重衰减不等于 L2

在 SGD 下两者相同。在损失中加上 (\lambda/2)\|\theta\|^2，就是在梯度中加上 \lambda\theta，于是

每一步把权重收缩 1 - \eta\lambda 倍：这就是权重衰减（weight decay）。PyTorch 的 weight_decay=λ 对应惩罚项 (\lambda/2)\|\theta\|^2；模块 01 把惩罚项写成 \lambda\|\theta\|^2，系数翻了一倍。

在 Adam 下两者不同（Loshchilov 和 Hutter 2019）。使用 L2 惩罚时，\mathbf{g} + \lambda\theta 进入 \mathbf{m} 和 \mathbf{v}，衰减项与其他所有量一样被除以 \sqrt{\hat{\mathbf{v}}}：参数 i 每步收缩约 \eta\lambda\theta_i/\sqrt{\hat v_i}。梯度历史大的参数被正则化得更少，梯度小的则更多。AdamW 把衰减放在归一化之外，

使每个参数每步都收缩相同的倍数，并且遵循学习率调度。除非 \hat{\mathbf{v}} 对所有参数都相同，否则任何 L2 系数都无法复现它。

在 PyTorch 中，torch.optim.AdamW 是解耦形式（默认 weight_decay=0.01），torch.optim.Adam(weight_decay=λ) 是耦合的 L2 形式（默认 0）；较新的版本还接受 Adam(..., decoupled_weight_decay=True)，它就是 AdamW。应当对权重矩阵做衰减，而不是对偏置或归一化的增益，后两者决定偏移和尺度，衰减只会扭曲它们。用两个参数组即可做到：

decay = [p for p in model.parameters() if p.ndim >= 2]      # weight matrices
no_decay = [p for p in model.parameters() if p.ndim < 2]    # biases, norm gains
opt = torch.optim.AdamW([{"params": decay, "weight_decay": 0.01},
                         {"params": no_decay, "weight_decay": 0.0}], lr=2e-3)
print(sum(p.numel() for p in decay), sum(p.numel() for p in no_decay))

25856 266

对于数字识别网络，25,856 个权重做衰减，266 个偏置不做。Adam 最初的收敛性证明后来被证明有缺陷（Reddi、Kale 和 Kumar 2018）。这个方法在实践中有效，而这就是它的证据。

优化器周围有三种手段：调度在训练过程中改变 \eta，范围测试找出它的量级，梯度裁剪则限制偶尔出现的巨大梯度。

为什么要衰减

模块 01，第 4 节推导过原因。在曲率为 \lambda、mini-batch 梯度噪声方差为 s^2/B 的一个二次方向上，恒定步长使迭代点在极小点附近徘徊，其稳态方差为

额外损失 \tfrac12\lambda V 与 \eta/B 成正比。因此，恒定学习率会让最终模型停在一个带状区域内的随机一点，这个带的宽度由 \eta 决定；衰减 \eta 就能缩小这个带。

调度方式

阶梯衰减（step decay）在训练的固定比例处，例如 50% 和 75%，把 \eta 乘以 0.1。余弦衰减（cosine decay，Loshchilov 和 Hutter 2017）在 T 步内沿半个余弦曲线从 \eta_{\max} 降到 \eta_{\min}：

线性预热（linear warmup）在前 T_w 步内把 \eta 从接近 0 升到 \eta_{\max}，通常占训练的 1–5%，也就是几百到几千步；之后余弦衰减在剩余的 T - T_w 步上进行。预热加余弦、降到峰值的十分之一或更低，是语言模型的默认做法；截至 2026 年，保持峰值、只在接近结束时才衰减的预热-稳定-衰减调度也是常见的替代方案（模块 08，第 6 节）。图 2.14 在同一组坐标轴上画出了三种调度。

预热有三个理由。起始时 Adam 的 \hat{\mathbf{v}} 只由少数几个梯度估计，即便经过偏差修正仍有噪声，所以早期步长不稳定（Liu 等 2020）。初始化时的曲率可能很高，所以后来安全的步长在那时就太大了。此外，大 batch SGD 在放大学习率之后需要一个爬升过程：Goyal 等（2017）把 \eta 与 batch 大小成线性比例放大，并用 5 个轮次预热。大 batch 的情形属于模块 08。

范围测试

峰值学习率是除架构之外最重要的超参数。学习率范围测试（learning-rate range test，Smith 2017）几分钟就能找到它的量级：训练几百步，同时把 \eta 从约 10^{-6} 按几何级数升到 10，记录经指数滑动平均平滑后的损失，并对 \log\eta 作图。曲线在 \eta 太小时是平的，在大约一个数量级的范围内下降得最快，到达最小值，随后陡然上升。选择比最小值小约 3–10 倍、靠近下降最陡处的值作为峰值：完整训练比测试更长也更嘈杂。

在 PyTorch 中，CosineAnnealingLR(opt, T_max) 统计的是 scheduler.step() 的调用次数：按轮次调用就是轮次，按 batch 调用就是 batch。预热来自 SequentialLR 内部的 LinearLR，或者来自 LambdaLR。请在 optimizer.step() 之后调用 scheduler.step()。例题中的调度写成代码如下：

from torch.optim.lr_scheduler import CosineAnnealingLR, LinearLR, SequentialLR

opt = torch.optim.AdamW(model.parameters(), lr=3e-3)
total, warm = 10_000, 500
sched = SequentialLR(opt, milestones=[warm], schedulers=[
    LinearLR(opt, start_factor=1e-3, end_factor=1.0, total_iters=warm),
    CosineAnnealingLR(opt, T_max=total - warm, eta_min=3e-5)])   # T_max in batches

梯度裁剪

按全局范数的梯度裁剪（gradient clipping）把所有参数的梯度拼接成一个向量，如果它的范数超过阈值 c，就把它重新缩放：\mathbf{g} \leftarrow c\,\mathbf{g}/\|\mathbf{g}\|。方向保持不变。Transformer 和循环网络常取 c = 1.0（Pascanu、Mikolov 和 Bengio 2013；模块 04，第 4 节）。逐个值分别裁剪（clip_grad_value_）会改变方向，是更粗糙的工具。

即使在步长已被归一化的 Adam 下，裁剪也很重要，因为尖峰仍会进入 \mathbf{m} 和 \mathbf{v}。以典型梯度为单位（g \approx 1，m \approx 1，v \approx 1），设某一步来了一个大小为 100 的梯度。则 v = 0.999 + 0.001\cdot 100^2 = 11.0，\sqrt v = 3.3，所以该参数后续的步长缩小约 3.3 倍。超出的部分按 10\cdot 0.999^t 衰减，时间常数为 1/(1-\beta_2) = 1{,}000 步：\sqrt v 需要约 3,860 步才能回到正常值的 10% 以内。与此同时，m = 0.9 + 0.1\cdot 100 = 10.9 指向尖峰方向，那一步的大小是 10.9/3.3 \approx 3 倍于通常。先裁剪就能同时避免这两种后果。clip_grad_norm_ 返回裁剪之前的范数：请把它记录下来。如果裁剪在大多数步上都触发，就说明阈值或学习率不对。

loss.backward()
grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)  # pre-clip
opt.step()
sched.step()

第 6 节选取初始权重，使预激活在起点具有合理的尺度。但这只在第 0 步成立。训练会改变权重，一旦预激活的均值或离散程度漂移得很大，对应的单元就会进入饱和区或死亡区。归一化层（normalisation layer）在网络内部的每一步都对激活重新做标准化。常用的变体有三种，区别在于均值和离散程度是对哪些数取的（图 2.15）。

批归一化

批归一化（batch normalisation，Ioffe 和 Szegedy 2015）对每个特征在 mini-batch 上做标准化。设一个 batch 的预激活为 \mathbf{Z} \in \mathbb{R}^{B\times d}，考虑其中一个特征 j，

在整个 batch 上，\hat{\mathbf{Z}} 的每个特征均值为 0，方差略小于 1。可学习的增益（gain）\gamma_j（初始化为 1）和偏移（shift）\beta_j（初始化为 0）把标准化拿走的自由度还给网络：取 \gamma_j = \sqrt{\sigma^2_{\mathcal{B}} + \epsilon}、\beta_j = \mu_{\mathcal{B}} 时，该层原样返回输入，所以插入它不会去掉网络本来能表示的任何函数。常数 \epsilon 通常取 10^{-5}，保证除法有限。

由于减去了均值，加在某个特征上的常数会从 \hat z 中消失。因此，批归一化前一层的偏置是冗余的，其作用由 \beta 接替；这正是第 3 模块在每个批归一化之前都写 bias=False 的原因。

训练与评估。 在训练模式下，该层使用当前 batch 的统计量，同时更新滑动平均，

在 PyTorch 中，滑动方差使用的是无偏的 batch 方差，如上式所写；momentum=0.1 就是 m，即新值的权重，与优化器中动量的约定相反。在评估模式（model.eval()）下，该层使用 \mu_{\text{run}} 和 \sigma^2_{\text{run}}，因此单个样本的输出不再依赖同一 batch 中的其他样本。忘记调用 model.eval() 是经典的错误（实验 5）。在训练早期就评判模型也是如此，因为这时滑动平均还跟不上快速变化的权重。

import torch, torch.nn as nn

bn = nn.BatchNorm1d(1)                           # gamma = 1, beta = 0, momentum = 0.1
z = torch.tensor([[2.0], [4.0], [6.0], [8.0]])   # one feature, a batch of four
y = bn(z)                                        # training mode: batch statistics
print("train out:", [f"{v:.3f}" for v in y.detach().ravel().tolist()])
print(f"running mean {bn.running_mean.item():.3f}, var {bn.running_var.item():.3f}")
bn.eval()                                        # evaluation mode: running statistics
print(f"eval out for 6: {bn(torch.tensor([[6.0]])).item():.3f}")

train out: ['-1.342', '-0.447', '0.447', '1.342']
running mean 0.500, var 1.567
eval out for 6: 4.394

在 batch 上做归一化有四个后果。其一，样本在训练中的输出依赖同一 batch 的其他样本，这会带来噪声（一种温和的正则化），也会引出上面那些错误。其二，小 batch 的统计量噪声大；每个 batch 少于 16 个样本时，应改用组归一化或层归一化（第 3 模块）。其三，长度不一的序列与之不相配，因为填充会污染统计量。其四，batch 大小为 1 时，每个特征的方差都为零；在训练模式下，PyTorch 会拒绝这种输入，并报错 Expected more than 1 value per channel when training。

为什么有效

原论文把批归一化的作用归因于减少“内部协变量偏移”（internal covariate shift），即每一层输入分布的漂移。Santurkar 等人（2018）质疑了这种解释：即使用噪声在每个批归一化之后重新制造漂移，网络依然训练得很好；他们测得的收益主要是损失曲面更平滑、条件更好，因而能容忍更大的学习率。

有一个精确的事实，解释了批归一化与优化器的大部分相互作用。设权重 \mathbf{W} 的输出送入一个批归一化。把权重缩放 c > 0 倍，\mathbf{z}、\mu_{\mathcal{B}} 和 \sigma_{\mathcal{B}} 都缩放 c 倍，于是 \hat z 不变（忽略 \epsilon），\mathcal{L}(c\mathbf{W}) = \mathcal{L}(\mathbf{W})。两边对 \mathbf{W} 求导，

权重越大，得到的梯度按比例越小，所以一步梯度更新的相对变化 \eta\|\nabla\mathcal{L}\|/\|\mathbf{W}\| 按 \eta/\|\mathbf{W}\|^2 变化：有效学习率取决于权重的范数。再对 \mathcal{L}(c\mathbf{W}) 在 c = 1 处对 c 求导，还得到 \langle\mathbf{W}, \nabla\mathcal{L}\rangle = 0：梯度与 \mathbf{W} 正交，所以朴素的梯度步会使 \|\mathbf{W}\| 缓慢增大，有效学习率随之下降。对这类权重做权重衰减无法限制函数本身，因为函数与 \|\mathbf{W}\| 无关；它的主要作用是让范数保持较小，从而使有效学习率保持较高。

层归一化与 RMSNorm

层归一化（layer normalisation，Ba、Kiros 和 Hinton 2016）改为对单个样本的 d 个特征取统计量：

它在训练和评估时完全一致，也与 batch 无关，所以批归一化的那四个后果都不会出现。循环神经网络和 Transformer 使用它。

均方根归一化（RMSNorm，Zhang 和 Sennrich 2019）去掉了减均值和偏移，改为除以均方根：

它只需一次归约而不是两次，实际效果一样好，截至 2026 年大多数大语言模型都采用它；第 6 模块说明它在模块中的位置（前置归一化与后置归一化之比较）。PyTorch 提供 nn.BatchNorm1d、nn.LayerNorm，以及自 2.4 版起的 nn.RMSNorm。

归一化的反向传播

归一化改变了梯度能做的事。取层归一化，\boldsymbol{\gamma} = \mathbf{1}， \boldsymbol{\beta} = \mathbf{0}，忽略 \epsilon，于是 \hat z_k = (z_k - \mu)/\sigma，并记 \bar{\mathbf{g}} = \partial\mathcal{L}/\partial\mathbf{y}。各个部分如下：

• \partial\mu/\partial z_j = 1/d。
• \partial\sigma^2/\partial z_j = \frac{2}{d}\sum_k (z_k - \mu)\big([k = j] - \tfrac{1}{d}\big) = \frac{2}{d}(z_j - \mu)， 因为各偏差之和为零；所以 \partial\sigma/\partial z_j = (z_j - \mu)/(d\sigma) = \hat z_j/d。
• 由商的求导法则， \dfrac{\partial\hat z_k}{\partial z_j} = \dfrac{[k = j] - 1/d}{\sigma} - \dfrac{z_k - \mu}{\sigma^2}\,\dfrac{\hat z_j}{d} = \dfrac{1}{\sigma}\Big([k = j] - \dfrac{1}{d} - \dfrac{\hat z_k\hat z_j}{d}\Big)。
• 与 \bar g_k 相乘并求和：

由于 \sum_j\hat z_j = 0 且 \sum_j\hat z_j^2 = d，这个梯度的各分量之和为零，并且与 \hat{\mathbf{z}} 正交。经过归一化之后，下面的各层无法改变它们向上传递的内容的均值或尺度，只能改变其模式；尺度和偏移由 \boldsymbol{\gamma} 和 \boldsymbol{\beta} 决定。批归一化的反向传播是同一个公式，只是均值改为在 batch 上而不是在特征上取。

第 1 模块第 9 节把正则化看作用方差换偏差，其强度在验证集上调节。网络让这幅图景变得更复杂。它们通常是过参数化的（实验 4 用 26,122 个参数拟合 1,078 张训练图像），却依然能泛化，一部分靠 SGD 噪声的隐式正则化（第 1 模块第 4 节），一部分靠下面这些显式方法。

权重衰减

权重衰减就是第 1 模块的 L_2 惩罚，通过 AdamW 实现，使每个权重每步都按相同的比例收缩，而不论其梯度历史如何（第 8 节）。\lambda 的典型取值从 10^{-4} 到 10^{-1}，取决于优化器及其约定。偏置和归一化增益不做衰减；对于输出送入归一化层的权重，衰减的主要作用是提高有效学习率（第 10 节）。

随机失活

随机失活（dropout，Srivastava 等 2014）在训练时破坏隐藏单元。每个单元乘以一个独立的掩码 m_i \sim \text{Bernoulli}(1 - p)，它以概率 p 取 0，存活的单元再放大 1/(1 - p) 倍，这就是反向（inverted）形式：

评估时不丢弃也不缩放。正是这个缩放使两种模式一致。对掩码取期望，

所以下一层在两种模式下看到的期望输入相同。至于方差， \mathbb{E}[\tilde h_i^2] = (1 - p)\,h_i^2/(1 - p)^2 = h_i^2/(1 - p)，因此

这是乘性噪声，大小与单元自身的大小成正比，相对方差在 p = 0.5 时为 1，在 p = 0.1 时为 0.11。最初的表述是在测试时把权重乘以 1 - p；框架实现的是反向形式，这样评估时完全不需要改动。

它为什么有效：没有哪个单元可以依赖，因为任何一个都可能缺席。等价地说，训练是在一个 n 单元层的 2^n 个共享权重的“瘦身”网络中采样，评估则近似它们的集成：对于接 softmax 的单层，是精确的，等于它们预测的重新归一化的几何平均（Hinton 等 2012）；对更深的网络则是近似的。测试时保持 dropout 开启并对多次前向取平均，可以得到廉价的不确定性估计，即 Monte Carlo dropout（Gal 和 Ghahramani 2016）。

典型的 p：旧式 MLP 和 AlexNet 的全连接层中最高到 0.5；Transformer 中为 0.1。截至 2026 年，许多大语言模型的预训练不使用它，因为每个 token 大约只被看到一次（第 8 模块）。

早停

早停（early stopping）每个轮次（epoch）评估一次验证损失，保留验证损失最低的检查点，并在连续若干个轮次没有改进（即耐心值 patience）之后停止；随后恢复最佳权重。第 1 模块说明了它为什么起正则化作用：从零出发做 t 步梯度下降，二次函数的第 i 个特征方向停在 \big[1 - (1 - \eta\lambda_i)^t\big]\theta^*_i，接近岭回归的 \lambda_i/(\lambda_i + \tau)\cdot\theta^*_i，其中 \tau \approx 1/(\eta t)，\tau 是惩罚项 (\tau/2)\|\theta\|^2 的系数（Goodfellow 等 2016，§7.8）：这近似于强度由训练时间决定的 L_2 正则化。对网络而言，新的是流程：检查点、耐心值，以及恢复最佳权重。

校准与温度缩放

第 1 模块第 7 节度量了校准，并把网络的情形推迟到本模块。用交叉熵长时间训练的网络往往过度自信：它们的最高概率超过其准确率。标签平滑（见下）在训练时起作用，可能矫枉过正，变成自信不足。温度缩放（temperature scaling，Guo 等 2017）把 logits 除以一个标量 T > 0，\hat{\mathbf{p}} = \softmax(\mathbf{z}/T)，T 在验证集上通过最小化负对数似然来拟合。除以一个正常数不改变 logits 的顺序，所以 argmax 和准确率不受影响；T > 1 使过度自信的模型变得温和，T < 1 使自信不足的模型变得尖锐。

第 7 模块会回到语言模型的校准。

数据增强与输入噪声

数据增强是对训练数据做保持标签不变的变换。对图像来说，它是最有效的单一正则化手段（第 3 模块）。对传感器数据或表格数据，可选的是输入噪声，以及标签确实对其不变的时间平移或缩放。用小的高斯输入噪声训练，到一阶近似等价于对输出关于输入的导数施加 Tikhonov 惩罚（Bishop 1995）。

标签平滑

标签平滑（label smoothing，Szegedy 等 2016）用软化的目标 \mathbf{y}_{\text{LS}} = (1 - \alpha)\mathbf{y} + \alpha/K 来训练，真实类别得到 1 - \alpha + \alpha/K，其他每个类别得到 \alpha/K。交叉熵对 logits 的梯度保持第 3 节的形式，即 \hat{\mathbf{p}} - \mathbf{y}_{\text{LS}}。

这样做的原因在于硬标签的行为。在可分的训练数据上，对任何有限的 logit 间隔，-\ln\hat p_y 都为正，只有间隔趋于无穷时才达到 0，所以梯度永不消失，logits 不断增大。使用平滑后的目标时，交叉熵 -\sum_k y_{\text{LS},k}\ln\hat p_k 在 \hat{\mathbf{p}} = \mathbf{y}_{\text{LS}} 处取最小，此处梯度为零；又因为对 softmax 有 z_{\text{true}} - z_{\text{other}} = \ln(\hat p_{\text{true}}/\hat p_{\text{other}})，最优间隔是有限的：

标签平滑常常能提高准确率和校准，但也可能矫枉过正，变成自信不足。它还会抹去错误类别概率之间的相对大小，而知识蒸馏恰恰会用到这些信息（Müller 等 2019）。在 PyTorch 中，它只是一个参数， F.cross_entropy(logits, targets, label_smoothing=0.1)。

最重要的是更多数据

网络的方差随 N 下降，没有任何正则化手段能替代更多数据。每种正则化手段也会改变最佳学习率，因为它改变了梯度：加入之后要重新调 \eta。

损失由指数和对数构成，作用对象是网络自己选出的数。在精确算术中，第 1 模块第 5 节的公式没有问题。在浮点运算中，e^z 对中等大的 z 就会上溢，很小的概率会下溢为零，\ln 0 = -\infty，而一个无穷大在一步之内就会让整个网络变成 NaN。本节划出这些界限，并说明怎样计算损失才能永远碰不到它们。

浮点格式

浮点数有一个符号位、决定范围的指数位，以及决定精度的尾数位；机器 epsilon，即 1 与下一个数之间的间隔，等于 2^{-\text{尾数位数}}。

这些数值是 torch.finfo 和 numpy.finfo 报告的。bf16 保留了 fp32 的八个指数位，因此范围相同，但只有两到三位有效数字；fp16 多三个尾数位，但范围止于 65,504。对最大值取对数，e^z 在 fp32 和 bf16 中于 z \approx 88.7 以上上溢，在 fp16 中于 z = \ln 65{,}504 = 11.09 以上上溢。在另一个方向，e^{-z} 在 fp32 中于 z \approx 103、在 fp16 中于 z \approx 16.6 处低于最小非规格化数，随后很快被舍入为恰好等于零（分别从约 104 和 17.3 起）。

log-sum-exp 恒等式

每个 K 类损失都需要 \ln\sum_j e^{z_j}。对任意常数 m，

这就是第 1 模块的观察（给每个 logit 加同一个常数不改变任何结果）的实际应用。取 m = \max_j z_j。这时每个指数 z_j - m 至多为 0，所以不会上溢，并且有一项等于 e^0 = 1，所以和至少为 1，其对数绝不会是 \ln 0。真实类别为 y 时的交叉熵随之直接得出：

融合函数，即作用于 logits 的 F.cross_entropy，就是这样计算损失的，其梯度 \hat{\mathbf{p}} - \mathbf{y} 也由同样稳定的量算出。第 1 模块中稳定的二分类形式就是 K = 2 的情形。

import torch, torch.nn.functional as F

z = torch.tensor([[1000.0, 999.0, 998.0]])
print(z.exp() / z.exp().sum())                 # by hand: inf / inf
print(f"{F.cross_entropy(z, torch.tensor([0])).item():.6f}")  # logsumexp(z) - z_0

z2 = torch.tensor([0.0, -120.0])
print(torch.log(torch.softmax(z2, dim=0)))     # softmax underflows to 0, then log 0
print(torch.log_softmax(z2, dim=0))            # z - logsumexp(z): finite

logit, target = torch.tensor([17.0]), torch.tensor([0.0])
print(F.binary_cross_entropy(torch.sigmoid(logit), target).item())  # clamped
print(F.binary_cross_entropy_with_logits(logit, target).item())     # correct

tensor([[nan, nan, nan]])
0.407606
tensor([0., -inf])
tensor([   0., -120.])
100.0
17.0

三种出错的方式

分两步先取 softmax 再取对数。 对于很负的 logit，softmax 可能下溢为恰好 0，而 \ln 0 = -\infty 会给出无穷大的损失和 NaN 梯度。

在 F.cross_entropy 之前先做 softmax。 损失自己会做 log-softmax，所以网络的概率会被当作限制在 [0, 1] 内的 logits。最好的情形是真实类别得到概率 1，其他类别为 0，而这些“logits”给出 \hat p_y = e/(e + K - 1)，于是

梯度还要经过多出来的那个 softmax 的雅可比矩阵，其元素的大小至多为 1/4，所以学习非常慢。准确率仍可能上升，这正是它成为常见而隐蔽的错误的原因。

在二分类损失之前先做 sigmoid。 BCEWithLogitsLoss 从 logit 出发计算 \ell = \max(z, 0) - zy + \ln(1 + e^{-|z|})，永远不会上溢。先 sigmoid 再用 BCELoss 则会饱和：在 fp32 中，一旦 e^{-z} < 2^{-24}，1 + e^{-z} 就舍入为恰好 1，也就是从 z = 24\ln 2 \approx 16.64 起，\sigma(z) 变成恰好 1.0，\ln(1 - 1) = -\infty。PyTorch 把对数钳制在 -100，所以损失被悄悄截断在 100，其梯度是错的。

回归损失与规约

平方误差是高斯负对数似然（第 1 模块），对离群值的惩罚是二次的。Huber 损失在 |r| \le \delta_{\text{H}} 时为 \tfrac12 r^2，超出后为 \delta_{\text{H}}(|r| - \delta_{\text{H}}/2)，其梯度被裁剪在 \pm\delta_{\text{H}}，是常用的折中：取 \delta_{\text{H}} = 1（PyTorch 的 delta），残差为 3 时代价是 2.5 而不是 4.5。绝对误差对应拉普拉斯噪声。

规约（reduction）方式同样重要。对 batch 取平均，使梯度的尺度与 B 无关；取和则会把梯度乘以 B，有效学习率也随之乘以 B。PyTorch 默认取平均；改变 batch 大小时要保持一致。

混合精度与方差

混合精度计算用 bf16 或 fp16 做矩阵乘法，但把主权重、softmax、损失和归一化统计量保留在 fp32 中；torch.autocast 按算子选择精度。fp16 还需要损失缩放（loss scaling）：在 backward 之前把损失乘以 S（例如 2^{16}），再把梯度除以 S，使小的梯度不会下溢（Micikevicius 等 2018）。bf16 的范围与 fp32 相同，不需要这样做，这也是遇到 NaN 损失时的第一条建议是用 bf16 而不是 fp16 的原因。第 8 模块讲述大规模下的混合精度。

方差应按 \operatorname{mean}\big((x - \mu)^2\big) 计算，绝不要按 \operatorname{mean}(x^2) - \mu^2，后者要把两个几乎相等的大数相减。在 fp32 中，对 x = (10000, 10001, 10002)，前者给出 0.6667，后者恰好给出 0。

到目前为止的每一节，都在为训练循环中的某一行提供理由。本节把它们合在一起：一个约三十行的循环，训练一个两隐藏层的网络，去区分正方形里圆的内部和外部（与第 1 节游乐场中的圆形数据类似），后面的表格则说明每一行来自哪一节，这样循环就可以被读懂，而不只是被照抄。

import torch, torch.nn as nn, torch.nn.functional as F

torch.manual_seed(0)
X = torch.rand(2048, 2) * 2 - 1                       # points in the square
T = ((X ** 2).sum(1) < 0.5).long()                    # inside the circle of radius sqrt(0.5)
Xtr, Ttr, Xva, Tva = X[:1536], T[:1536], X[1536:], T[1536:]
mu, sd = Xtr.mean(0), Xtr.std(0)                      # standardise with TRAINING statistics
norm = lambda x: (x - mu) / sd

model = nn.Sequential(nn.Linear(2, 32), nn.GELU(), nn.Linear(32, 32), nn.GELU(),
                      nn.Linear(32, 2))
opt = torch.optim.AdamW(model.parameters(), lr=3e-3, weight_decay=1e-2)
sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=400)

for epoch in range(400):
    model.train()
    perm = torch.randperm(len(Xtr))
    for i in range(0, len(Xtr), 64):
        idx = perm[i:i + 64]
        loss = F.cross_entropy(model(norm(Xtr[idx])), Ttr[idx])   # on logits
        opt.zero_grad(); loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        opt.step()
    sched.step()
    if epoch % 100 == 99:
        model.eval()
        with torch.no_grad():
            acc = (model(norm(Xva)).argmax(1) == Tva).float().mean()
        print(epoch + 1, round(loss.item(), 4), round(acc.item(), 3))

100 0.0069 0.992
200 0.0205 0.996
300 0.0056 0.996
400 0.0107 0.996

两点读法说明。打印出的损失是最后一个 mini-batch 的损失，噪声很大：它在第 100 和第 200 个轮次之间从 0.0069 跳到 0.0205，而各轮次的平均值是稳步下降的（0.0108、0.0065、0.0054、0.0046）。应当记录每个轮次的平均值。另外，T_max 数的是 scheduler.step() 的调用次数，这里就是轮次数。