推导 · 参数量与「展开等价性」

参数量：$W_{hh}$（$d_h^2$）、$W_{xh}$（$d_h d_x$）、$\boldsymbol b_h$（$d_h$）、$W_{hy}$（$d_y d_h$，$\boldsymbol b_y$ 为 $d_y$）相加即为表中合计项；每一项都不含 $T$。对照「每步一套权重」的方案，参数量为 $T\left[(d_x d_h + d_h) + \cdots\right]=\mathcal O(T)$。

展开等价性：定义 $T$ 个「层」$\boldsymbol h_t=\phi(W_{hh}\boldsymbol h_{t-1}+W_{xh}\boldsymbol x_t+\boldsymbol b_h)$。若把它们看作一个普通的 $T$ 层前馈网络，则它的第 $t$ 层权重矩阵按定义全部相等（都等于 $W_{hh}$ 与 $W_{xh}$）。反过来，任何一组「层间权重相等」的 $T$ 层网络都可以折叠回递推式。因此：RNN = 一个绑定了权重共享约束的 $T$ 层网络。这个等价关系的价值在于，它把「沿时间反向传播」（2.2.3）变成第 1 讲里已经学过的普通反向传播，只是把「层」换成了「时间步」。$\blacksquare$

∎

推导 · 从链式法则到连乘（完整）

(1) 单步雅可比。 由 $\boldsymbol h_k=\phi(\boldsymbol z_k)$ 与 $\boldsymbol z_k=W_{hh}\boldsymbol h_{k-1}+(\text{与 }\boldsymbol h_{k-1}\text{ 无关的项})$，逐元素求导得

$$\frac{\partial h_k^{(i)}}{\partial h_{k-1}^{(j)}}=\phi'(z_k^{(i)})\cdot W_{hh}^{(i,j)} \;\Longrightarrow\; J_k=\operatorname{diag}\bigl(\phi'(\boldsymbol z_k)\bigr)W_{hh}.$$

注意 $\operatorname{diag}(\phi'(\boldsymbol z_k))$ 是逐元素调制，$W_{hh}$ 负责跨维度混合——两者交替出现是全部问题的根源。

(2) 跨多步的雅可比 = 连乘。 由链式法则（多元情形下逐段相乘）：

$$\frac{\partial \boldsymbol h_s}{\partial \boldsymbol h_t} =\frac{\partial \boldsymbol h_s}{\partial \boldsymbol h_{s-1}}\cdot\frac{\partial \boldsymbol h_{s-1}}{\partial \boldsymbol h_{s-2}}\cdots\frac{\partial \boldsymbol h_{t+1}}{\partial \boldsymbol h_t} =\prod_{k=t+1}^{s}J_k .$$

矩阵乘法的顺序不能交换：$J_sJ_{s-1}\cdots J_{t+1}$ 与 $J_{t+1}\cdots J_{s}$ 一般不同（反向传播里出现的是转置序列）。

(3) 损失对状态的梯度。 因为 $\boldsymbol h_t$ 既影响 $\mathcal L_t$（直接），又通过 $\boldsymbol h_{t+1},\dots,\boldsymbol h_T$ 影响后续所有损失，把 $s$ 从 $t$ 到 $T$ 的所有路径相加：

$$\frac{\partial \mathcal L}{\partial \boldsymbol h_t} =\sum_{s\ge t}\left(\prod_{k=t+1}^{s}J_k\right)^{\!\mathrm T}\frac{\partial \mathcal L_s}{\partial \boldsymbol h_s}, \qquad\text{其中 } s=t \text{ 一项即 } \boldsymbol g_t \text{（空乘积取单位阵）},$$

其中 $s=t$ 一项就是 $\boldsymbol g_t$（空乘积取单位阵）。这解释了为什么「误差回传多远」这个问题必须逐层考虑：远处损失的梯度要先穿过一长串 $J_k$ 才能到达 $\boldsymbol h_t$。

(4) 对参数的梯度（实现里用的递推形式）。 由 $\boldsymbol z_t=W_{hh}\boldsymbol h_{t-1}+\cdots$，有 $\partial\boldsymbol z_t/\partial W_{hh}=\boldsymbol h_{t-1}$ 的线性映射，故

$$\frac{\partial\mathcal L}{\partial W_{hh}}=\sum_{t=1}^{T}\boldsymbol\delta_t\boldsymbol h_{t-1}^{\mathrm T},\qquad \boldsymbol\delta_t=\operatorname{diag}\bigl(\phi'(\boldsymbol z_t)\bigr)\Bigl(\underbrace{W_{hy}^{\mathrm T}\tfrac{\partial \mathcal L_t}{\partial \hat{\boldsymbol y}_t}}_{\text{本步输出带来的误差}}+W_{hh}^{\mathrm T}\boldsymbol\delta_{t+1}\Bigr).$$

这个反向递推式 就是 BPTT 的实现：从 $t=T$ 起，每一步用「本步误差 + 下一步回传的误差」算出 $\boldsymbol\delta_t$，再累加进 $W_{hh}$ 的梯度。可以看到整个反向过程的时间复杂度是 $\mathcal O(T\,d_h^2)$，且必须串行（$\boldsymbol\delta_t$ 依赖 $\boldsymbol\delta_{t+1}$）。

(5) 范数界。 对任意相容矩阵范数，

$$\left\lVert\prod_{k=t+1}^{s}J_k\right\rVert\le\prod_{k=t+1}^{s}\lVert J_k\rVert \le\Bigl(\max_{k}\lVert J_k\rVert_2\Bigr)^{\,s-t},$$

即跨 $n$ 步的梯度量级被「单步雅可比的最大奇异值」的 $n$ 次方控制（严格的最坏情形界；实际谱半径决定长期平均行为）。$\blacksquare$

∎

推导 · 为什么会指数变化，以及「精度地板」是什么

(1) 标量情形先看透。 取 $d_h=1$、$h_t=\phi(w\,h_{t-1}+c)$，则 $J_k=w\,\phi'(z_k)$，跨 $n$ 步的乘积为

$$\frac{\partial h_t}{\partial h_{t-n}}=\prod_{k=t-n+1}^{t}w\,\phi'(z_k) =w^{n}\prod_{k}\phi'(z_k).$$

取 $\phi=\tanh$（$\lvert\phi'\rvert\le1$）得 $\lvert\partial h_t/\partial h_{t-n}\rvert\le\lvert w\rvert^{n}$——与 定理 2.2.2 的范数界一致。

(2) 矩阵情形。 由 $\lVert AB\rVert_2\le\lVert A\rVert_2\lVert B\rVert_2$ 与 $\lVert\operatorname{diag}(\phi')\rVert_2=\max_i\lvert\phi'(z^{(i)})\rvert\le1$ 立得 $\lVert J_k\rVert_2\le\lVert W_{hh}\rVert_2$。更精细的长期刻画用谱半径：当 $J_k$ 的分布稳定时，$\lVert J_s\cdots J_{t+1}\rVert^{1/(s-t)}\to\rho(J)$（乘积的渐近指数增长率），因此「平均意义上」梯度量级随 $n$ 以 $\rho(J)^n$ 变化。

(3) 为什么有一个「地板」。 浮点数不是实数：单精度（float32）能表示的最小正规数约 $1.2\times10^{-38}$，而实际训练里关心的是信噪比——反向传播还要继续与上游梯度、权重相乘，当跨 $n$ 步的因子衰减到 $10^{-7}$ 量级时，它加到参数更新上的贡献通常已经低于学习率与优化器噪声的水平，在效果上等于零（这就是「float32 精度地板 $\approx10^{-7}$」这个工程经验值的含义）。同理，爆炸方向一旦使中间量超过 $3.4\times10^{38}$ 就变成 inf，随后的 inf - inf 或 0 × inf 直接产生 NaN。

(4) 与「长程依赖学不到」的联系。 假设模型需要利用第 5 步的信息来决定第 200 步的输出。该路径的梯度必须经过 $n=195$ 次连乘。由上面的界，梯度量级被 $\rho^{195}$ 控制：$\rho=0.9$ 时为 $10^{-9}$ 量级（已在地板以下），$\rho=1.1$ 时约 $10^{8}$（未被裁剪就会把参数推向发散）。结论不是「RNN 学不会」，而是「朴素 RNN 对长依赖的学习信号被指数衰减吞掉了」——这正是门控结构（2.3）与注意力（2.4）各自要重写的部分。$\blacksquare$

∎

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

torch.manual_seed(0)
B, T, d_x, d_h = 4, 32, 8, 16
x = torch.randn(B, T, d_x, dtype=torch.float64)      # float64：梯度检查需要高精度
y = torch.randint(0, 3, (B, T))                      # 每步 3 类（同步对齐任务）

class RNNCellManual(nn.Module):
    def __init__(self, d_x, d_h, d_y):
        super().__init__()
        # 与 PyTorch 一致：把 W_hh 与 W_xh 拼成一个矩阵，一次矩阵乘算完（实现技巧，不改变数学）
        self.W = nn.Linear(d_x + d_h, d_h, bias=True)
        self.out = nn.Linear(d_h, d_y, bias=True)

    def forward(self, x, h=None):
        B, T, _ = x.shape
        h = torch.zeros(B, self.W.out_features, dtype=x.dtype) if h is None else h
        hs = []
        for t in range(T):                             # 串行：h_t 依赖 h_{t-1}
            h = torch.tanh(self.W(torch.cat([x[:, t], h], dim=-1)))
            hs.append(h)
        return self.out(torch.stack(hs, dim=1)), h     # (B,T,d_y), (B,d_h)

model = RNNCellManual(d_x, d_h, 3)

# ① 梯度检查：用数值微分验证 BPTT 的实现（第 1 讲 1.5 的做法）
x_small = x[:, :4].clone().requires_grad_(True)      # 只取 4 步，数值梯度才跑得动
logits, _ = model(x_small)
loss = F.cross_entropy(logits.reshape(-1, 3), y[:, :4].reshape(-1))
grads = torch.autograd.grad(loss, model.parameters())

for p, g in zip(model.parameters(), grads):
    assert torch.isfinite(g).all(), "梯度出现 inf/NaN：多半是爆炸方向"

# ② 观察「连乘」：把同一权重复制到不同深度的 RNN，看梯度范数如何随步数变化
for T_try in (4, 8, 16, 32):
    logits, _ = model(x[:, :T_try])
    loss = F.cross_entropy(logits.reshape(-1, 3), y[:, :T_try].reshape(-1))
    model.zero_grad(); loss.backward()
    # 取第一层（最靠近输入）权重的梯度范数：它离损失最远，最先被连乘吞掉
    g0 = model.W.weight.grad.norm().item()
    print(f"T={T_try:3d}  最底层权重梯度范数={g0:.3e}")

# ③ 梯度裁剪：训练循环里的标准写法（放在 backward 之后、step 之前）
opt = torch.optim.AdamW(model.parameters(), lr=1e-3)
model.zero_grad()
logits, _ = model(x)
F.cross_entropy(logits.reshape(-1, 3), y.reshape(-1)).backward()
grad_norm = nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)  # 返回裁剪前的范数
print(f"裁剪前全局梯度范数={grad_norm:.4f}（超过 1.0 时被等比缩放到 1.0）")
opt.step(); opt.zero_grad()