---
tags: [AI, 深度学习, RNN, 序列建模]
阶段: 04-深度学习核心
难度: ★★★
created: 2026-10-18
related: "[[神经网络与前向传播]], [[反向传播详解]], [[LSTM与GRU]], [[从RNN到注意力机制]]"
---

# 循环神经网络RNN

## 定义

**循环神经网络**（recurrent neural network, RNN）是按同一组权值在序列的每个时间步上重复计算、并把上一步的隐藏状态作为当前步输入的一部分的神经网络；由于权值在时间步之间共享，它能处理任意长度的序列，并把整个前缀压缩为一个固定维数的隐藏状态。

逐项定义符号：

- $\mathbf{x}_t\in\mathbb{R}^{d}$：第 $t$ 步的输入向量，$d$ 为输入维数；单样本的序列记为 $\mathbf{x}_{1:T}=(\mathbf{x}_1,\dots,\mathbf{x}_T)$。
- $T$：序列长度；批内不同样本的长度可以不同，靠填充对齐。
- $\mathbf{h}_t\in\mathbb{R}^{m}$：第 $t$ 步的隐藏状态，$m$ 为隐藏维数；$\mathbf{h}_0=\mathbf{0}$ 为初始状态。
- $\mathbf{W}_x\in\mathbb{R}^{m\times d}$：输入到隐藏的权值矩阵。
- $\mathbf{W}_h\in\mathbb{R}^{m\times m}$：隐藏到隐藏的权值矩阵，全部时间步共用。
- $\mathbf{b}\in\mathbb{R}^{m}$：隐藏层偏置。
- $\mathbf{z}_t=\mathbf{W}_h\mathbf{h}_{t-1}+\mathbf{W}_x\mathbf{x}_t+\mathbf{b}$：第 $t$ 步的激活前值。
- $\mathbf{o}_t\in\mathbb{R}^{K}$：第 $t$ 步的输出 logits，$K$ 为类别数或词表大小；$\mathbf{U}\in\mathbb{R}^{K\times m}$ 与 $\mathbf{c}\in\mathbb{R}^{K}$ 为输出层参数。
- $\mathbf{p}_t=\mathrm{softmax}(\mathbf{o}_t)$：第 $t$ 步的预测分布。
- $y_t$：第 $t$ 步的监督标签；$L_t$：第 $t$ 步的损失；$L=\sum_{t=1}^{T}L_t$：序列总损失。
- $\boldsymbol{\delta}_t=\partial L/\partial\mathbf{z}_t$：第 $t$ 步激活前值的梯度。
- $\mathrm{diag}(\mathbf{v})$：以向量 $\mathbf{v}$ 为对角元素的对角矩阵。
- $\odot$：逐元素乘积；$\mathbf{1}$：全 1 向量。
- $B$：批大小；$\sigma_{\max}(\cdot)$：最大奇异值；$\rho(\cdot)$：谱半径，即特征值模的最大值。

逐项定义术语：

- 展开（unrolling）：把递推关系按时间步画成前馈计算图，第 $t$ 步对应第 $t$ 层。
- 参数共享（parameter sharing）：同一组 $\mathbf{W}_x,\mathbf{W}_h,\mathbf{b}$ 在所有时间步重复使用。
- 沿时间反向传播（backpropagation through time, BPTT）：在展开图上执行的反向传播算法。
- 截断 BPTT（truncated BPTT）：把长序列切成长度固定的片段，每段反向一次并在段间截断梯度。
- teacher forcing：训练时以真实前缀作为条件预测下一步，而不是以模型自己的输出作为条件。
- 暴露偏差（exposure bias）：训练时条件来自真实数据、推理时条件来自模型自身输出，两者分布不一致。
- 双向 RNN（bidirectional RNN）：分别沿正序与逆序运行两个 RNN 并拼接其隐藏状态。
- 深层 RNN（deep RNN）：把多个 RNN 层按「第 $l$ 层的输入是第 $l-1$ 层的输出序列」堆叠。
- 序列到序列（sequence-to-sequence）：用编码器把输入序列压缩为状态、用解码器从该状态生成输出序列的结构。

## 为什么重要

- 输入长度不固定。文本、语音、传感器读数、日志事件的长度随样本变化，而全连接层要求固定维输入。把序列切成固定窗口会丢失跨窗口状态，且窗口长度成为新的超参数。
- 顺序携带信息。同一个集合的元素按不同顺序排列可以表示不同含义，因此模型必须对位置敏感。RNN 通过递推把顺序写进计算结构，不需要额外的位置编码。
- 参数效率。若用 $T$ 个独立的全连接层处理长度 $T$ 的序列，参数量为 $T(dm+m^2+m)$；RNN 用一组参数完成同样深度的计算，参数量为 $dm+m^2+m$，与 $T$ 无关。这使长序列的训练在参数与显存上可行。
- 状态摘要。隐藏状态 $\mathbf{h}_t$ 是前缀 $\mathbf{x}_{1:t}$ 的固定维摘要，后续所有预测只通过它获取历史信息。这一设计把「保留哪些历史」交给学习，而不是交给人工设计的窗口。
- 没有 RNN 时，语言模型只能使用 $n$ 元文法或固定窗口的前馈网络，长距离依赖与变长输入都无法直接建模。
- 在本库中的位置：前置为 [[神经网络与前向传播]]（线性层与激活）与 [[反向传播详解]]（链式法则与参数共享的梯度累加）；本篇的梯度连乘问题是 [[LSTM与GRU]] 的直接动因；注意力机制取消了逐步递推，把固定维状态替换为对全部位置的加权读取，见 [[从RNN到注意力机制]]。
- 对应能力目标：懂原理对应「手推 BPTT 的求和形式」；能复现对应「NumPy 实现前向与 BPTT 并用数值梯度校验」；会评估对应「判断梯度消失或爆炸发生在哪一段、是否需要门控或裁剪」。

## 原理与推导

### 1. 序列任务与变长输入

序列任务按输入输出结构分为四类：

| 类型 | 输入 | 输出 | 例 |
| --- | --- | --- | --- |
| 多对一 | $\mathbf{x}_{1:T}$ | 单个标签 | 文本分类、情感分析 |
| 多对多（等长） | $\mathbf{x}_{1:T}$ | $y_{1:T}$ | 词性标注、命名实体识别 |
| 多对多（不等长） | $\mathbf{x}_{1:S}$ | $\mathbf{y}_{1:T}$ | 机器翻译、摘要 |
| 自回归 | $\mathbf{x}_{1:t}$ | $x_{t+1}$ | 语言模型、时间序列预测 |

批内序列长度不同，标准做法是填充到批内最大长度 $T_{\max}$，并对损失使用掩码 $m_t\in\{0,1\}$，其中 $m_t=1$ 表示第 $t$ 个位置有效：

$$L=\frac{\sum_{t=1}^{T_{\max}}m_t\,L_t}{\sum_{t=1}^{T_{\max}}m_t}$$

掩码只作用于损失，不作用于递推。补零位置仍会更新隐藏状态，因为

$$\mathbf{h}_t=\tanh\!\left(\mathbf{W}_h\mathbf{h}_{t-1}+\mathbf{W}_x\mathbf{0}+\mathbf{b}\right)$$

一般不等于 $\mathbf{h}_{t-1}$。因此取最后一个时间步作为序列表示时会取到填充后的状态，正确做法是按各样本的真实长度索引，即取 $\mathbf{h}_{T_i}$，或使用 `pack_padded_sequence` 让循环在真实长度处停止。若进一步对损失不做掩码而直接对全部位置求平均，短序列的损失被大量填充位置稀释，梯度尺度随批内最大长度变化。

变长输入的另一种处理是按长度分桶，使同一批内的长度接近，从而减少填充比例。

### 2. 递推式与展开计算图

基本 RNN 的递推式：

$$\mathbf{z}_t=\mathbf{W}_h\mathbf{h}_{t-1}+\mathbf{W}_x\mathbf{x}_t+\mathbf{b},\qquad \mathbf{h}_t=\tanh(\mathbf{z}_t),\qquad \mathbf{h}_0=\mathbf{0}$$

维度核对：$\mathbf{W}_h\mathbf{h}_{t-1}$ 为 $(m\times m)(m\times1)=(m\times1)$，$\mathbf{W}_x\mathbf{x}_t$ 为 $(m\times d)(d\times1)=(m\times1)$，$\mathbf{b}$ 为 $m$ 维，三者可加。批量形式把 $\mathbf{h}_{t-1}$ 换成 $B\times m$ 矩阵，$\mathbf{x}_t$ 换成 $B\times d$，计算变为 $\mathbf{H}_{t-1}\mathbf{W}_h^\top+\mathbf{X}_t\mathbf{W}_x^\top+\mathbf{b}$。

把 $T$ 步展开，得到一张深度为 $T$ 的前馈计算图：第 $t$ 层的输入是 $\mathbf{x}_t$ 与第 $t-1$ 层的输出，所有层共享同一组 $\mathbf{W}_x,\mathbf{W}_h,\mathbf{b}$。图中有两条边通向每个隐藏单元：一条来自当前输入，一条来自上一时刻状态。反向传播时两条路径的梯度相加，这正是 [[反向传播详解]] 中多路径累加规则的实例。

选择 $\tanh$ 的原因有三点：输出有界于 $(-1,1)$，使前向状态不会无界增长；零中心，梯度不会被系统性偏置；导数 $1-\tanh^2(z)\in(0,1]$，形式简单。若改用无界的 ReLU，$\mathbf{W}_h$ 的谱半径稍大于 $1$ 时状态与梯度会沿时间指数增长；若改用 sigmoid，输出恒正导致梯度方向偏置，且导数上界只有 $0.25$。激活函数的比较见 [[激活函数]]。

### 3. 输出层与损失

多对一任务只使用最后一步的状态：

$$\mathbf{o}=\mathbf{U}\mathbf{h}_T+\mathbf{c},\qquad L=-\log\,\mathrm{softmax}(\mathbf{o})_{y}$$

多对多任务在每个有效位置接输出层：

$$\mathbf{o}_t=\mathbf{U}\mathbf{h}_t+\mathbf{c},\qquad L_t=-\log\,\mathrm{softmax}(\mathbf{o}_t)_{y_t}$$

自回归语言模型把第 $t$ 步的输出与第 $t+1$ 步的输入对齐，最小化

$$L=-\sum_{t=1}^{T-1}\log p_\theta(x_{t+1}\mid \mathbf{x}_{1:t})$$

其中 $p_\theta(x_{t+1}\mid\mathbf{x}_{1:t})=\mathrm{softmax}(\mathbf{U}\mathbf{h}_t+\mathbf{c})_{x_{t+1}}$。该目标把联合分布的链式分解

$$p(x_{1:T})=\prod_{t=1}^{T}p(x_t\mid x_{<t})$$

逐项实现，每一项由同一条递推计算。

### 4. BPTT 完整推导

为得到 $\partial L/\partial\mathbf{W}_h$，需要先求出损失对每个隐藏状态的梯度。由于 $\mathbf{h}_t$ 同时影响 $L_t$ 与 $\mathbf{h}_{t+1}$，由多路径链式法则：

$$\frac{\partial L}{\partial\mathbf{h}_t}=\frac{\partial L_t}{\partial\mathbf{h}_t}+\left(\frac{\partial\mathbf{h}_{t+1}}{\partial\mathbf{h}_t}\right)^{\!\top}\frac{\partial L}{\partial\mathbf{h}_{t+1}}$$

其中

$$\frac{\partial\mathbf{h}_{t+1}}{\partial\mathbf{h}_t}=\mathrm{diag}\!\left(\mathbf{1}-\mathbf{h}_{t+1}^{2}\right)\mathbf{W}_h$$

故

$$\frac{\partial L}{\partial\mathbf{h}_t}=\frac{\partial L_t}{\partial\mathbf{h}_t}+\mathbf{W}_h^{\top}\,\mathrm{diag}\!\left(\mathbf{1}-\mathbf{h}_{t+1}^{2}\right)\frac{\partial L}{\partial\mathbf{h}_{t+1}}$$

边界条件为 $t=T$ 时第二项不存在。把该式从 $T$ 递推展开到 $t$：

$$\frac{\partial L}{\partial\mathbf{h}_t}=\sum_{\tau=t}^{T}\left(\prod_{j=t+1}^{\tau}\mathbf{W}_h^{\top}\,\mathrm{diag}\!\left(\mathbf{1}-\mathbf{h}_j^{2}\right)\right)\frac{\partial L_\tau}{\partial\mathbf{h}_\tau}$$

约定 $\tau=t$ 时括号内的空乘积为单位矩阵 $\mathbf{I}$。该式是 BPTT 的核心：时刻 $t$ 的状态梯度等于未来所有时刻损失经各自雅可比连乘回传的贡献之和。

记 $\boldsymbol{\delta}_t=\partial L/\partial\mathbf{z}_t$。由 $\mathbf{h}_t=\tanh(\mathbf{z}_t)$ 得

$$\boldsymbol{\delta}_t=\mathrm{diag}\!\left(\mathbf{1}-\mathbf{h}_t^{2}\right)\frac{\partial L}{\partial\mathbf{h}_t}$$

$\mathbf{W}_h$ 出现在每个时间步的 $\mathbf{z}_t$ 中，故总梯度是各步贡献之和。单步贡献为 $\boldsymbol{\delta}_t\mathbf{h}_{t-1}^{\top}$，因为 $\partial\mathbf{z}_t/\partial\mathbf{W}_h$ 的第 $(i,j)$ 个元素是 $\partial z_{t,i}/\partial W_{h,ij}=h_{t-1,j}$。于是

$$\frac{\partial L}{\partial\mathbf{W}_h}=\sum_{t=1}^{T}\boldsymbol{\delta}_t\mathbf{h}_{t-1}^{\top},\qquad \frac{\partial L}{\partial\mathbf{W}_x}=\sum_{t=1}^{T}\boldsymbol{\delta}_t\mathbf{x}_t^{\top},\qquad \frac{\partial L}{\partial\mathbf{b}}=\sum_{t=1}^{T}\boldsymbol{\delta}_t$$

输出层参数只与对应时刻有关：$\partial L/\partial\mathbf{U}=\sum_t(\mathbf{p}_t-\mathbf{y}_t)\mathbf{h}_t^{\top}$，$\partial L/\partial\mathbf{c}=\sum_t(\mathbf{p}_t-\mathbf{y}_t)$。

求和形式的三个直接推论：

1. 同一参数被 $T$ 次使用，梯度是 $T$ 项之和，与原序列长度成正比，这也是长序列梯度尺度需要额外处理的原因。
2. 每一项 $\boldsymbol{\delta}_t$ 都含有从 $t$ 到 $T$ 的雅可比连乘，早期时刻的项被更多因子缩放，因而更小。
3. 若序列只有末端一个损失，则 $\partial L_t/\partial\mathbf{h}_t=0$ 对所有 $t<T$ 成立，全部梯度只能经由最后一项回传，长距离依赖完全依赖连乘。

### 5. 梯度消失与爆炸

考察连乘因子

$$\mathbf{J}_{t:\tau}=\prod_{j=t+1}^{\tau}\mathbf{W}_h^{\top}\,\mathrm{diag}\!\left(\mathbf{1}-\mathbf{h}_j^{2}\right)$$

其谱范数满足

$$\left\|\mathbf{J}_{t:\tau}\right\|_2\ \le\ \prod_{j=t+1}^{\tau}\left\|\mathbf{W}_h^{\top}\right\|_2\left\|\mathrm{diag}\!\left(\mathbf{1}-\mathbf{h}_j^{2}\right)\right\|_2\ \le\ \sigma_{\max}(\mathbf{W}_h)^{\tau-t}$$

第二个不等式用到 $\tanh$ 的导数上界：$0<1-h_j^2\le1$，故对角因子的谱范数不超过 $1$。当 $\sigma_{\max}(\mathbf{W}_h)<1$ 时，上界随步数指数衰减；当 $\sigma_{\max}(\mathbf{W}_h)>1$ 时，上界指数增长。$\tanh$ 的饱和提供额外的收缩：$|h_j|\to1$ 时 $1-h_j^2\to0$，连乘因子进一步减小。

实际行为由 $\mathbf{W}_h$ 的谱半径与状态的饱和程度共同决定。取 $8$ 维隐藏状态、$30$ 步、$\mathbf{W}_h=\rho\mathbf{Q}$（$\mathbf{Q}$ 为正交矩阵，故 $\sigma_{\max}=\rho$），把全 1 向量沿时间反向传播 $30$ 步，测得梯度范数：

| $\rho$ | 30 步后的梯度范数 | 状态平均范数 | $\rho^{30}$ |
| --- | --- | --- | --- |
| 0.5 | $1.98\times10^{-9}$ | 0.275 | $9.31\times10^{-10}$ |
| 0.9 | $5.23\times10^{-2}$ | 0.438 | $4.24\times10^{-2}$ |
| 1.0 | $6.63\times10^{-1}$ | 0.596 | $1$ |
| 1.1 | $3.24$ | 0.837 | $17.45$ |
| 1.3 | $12.7$ | 1.234 | $2620$ |

三点解读：

- $\rho\le1.1$ 时梯度范数与 $\rho^{30}$ 同阶，差异来自 $\tanh$ 导数的平均收缩因子。$\rho=0.5$ 时 30 步后梯度已降到 $10^{-9}$，等价于该步之前的依赖无法被学习。
- $\rho=1.3$ 时上界为 $2620$，实测只有 $12.7$。上界假设每一步的收缩因子为 $1$，而实测中状态平均范数为 $1.234$，$8$ 个单元的平均绝对值约为 $0.44$，对应的 $\tanh$ 导数约为 $0.81$。$0.81^{30}\approx1.8\times10^{-3}$，与 $\rho^{30}$ 相乘后为 $4.7$ 量级，与实测的 $12.7$ 同量级。这说明只有在状态接近 $0$、$\tanh$ 导数接近 $1$ 时，连乘才按 $\rho^{30}$ 增长；状态幅值越大，收缩因子越小。
- 爆炸的后果是数值溢出：梯度经多步放大后超过 float32 范围，损失变为 `nan`，参数被一次更新破坏。消失的后果是优化停滞：早期时间步几乎收不到梯度，模型只学会利用最近几步的信息。

时间方向的连乘与深度方向的连乘是同一现象的两个实例：深度网络每层乘一个雅可比，RNN 每个时间步乘一个雅可比，因此缓解手段相通，包括门控结构（见 [[LSTM与GRU]]）、残差连接、归一化与梯度裁剪。

### 6. 梯度裁剪

设全部参数梯度拼接为向量 $\mathbf{g}$，裁剪阈值为 $c$：

$$\mathbf{g}\leftarrow\mathbf{g}\cdot\min\!\left(1,\ \frac{c}{\left\|\mathbf{g}\right\|_2}\right)$$

当 $\left\|\mathbf{g}\right\|_2\le c$ 时不做任何改变；超过阈值时按同一比例缩小全部梯度，方向保持不变，范数变为 $c$。PyTorch 的 `clip_grad_norm_` 计算所有参数梯度的总范数并原地缩放，返回裁剪前的范数，可用于监控。

两个实现要点：

1. 裁剪必须在 `loss.backward()` 之后、`optimizer.step()` 之前执行，否则参数已被更新。
2. 逐元素裁剪（把每个分量截断到 $[-c,c]$）会改变梯度方向，等同于对更新方向做非线性变换；按范数裁剪保持方向，二者不等价。对 $[30,40]$，范数为 $50$，阈值 $5$ 时范数裁剪得 $[3,4]$，方向不变；逐元素裁剪得 $[5,5]$，方向改变。

裁剪只限制单步更新的幅度，不恢复已经消失的梯度，因此它与门控结构、残差连接是互补手段，而非替代。

### 7. 双向 RNN

双向 RNN 同时运行两个独立的递推：

$$\overrightarrow{\mathbf{h}}_t=\tanh\!\left(\mathbf{W}_h^{\rightarrow}\overrightarrow{\mathbf{h}}_{t-1}+\mathbf{W}_x^{\rightarrow}\mathbf{x}_t+\mathbf{b}^{\rightarrow}\right)$$

$$\overleftarrow{\mathbf{h}}_t=\tanh\!\left(\mathbf{W}_h^{\leftarrow}\overleftarrow{\mathbf{h}}_{t+1}+\mathbf{W}_x^{\leftarrow}\mathbf{x}_t+\mathbf{b}^{\leftarrow}\right)$$

输出为拼接 $\mathbf{h}_t=[\overrightarrow{\mathbf{h}}_t;\overleftarrow{\mathbf{h}}_t]\in\mathbb{R}^{2m}$。参数量约为单向的两倍，计算量约为两倍。

使用条件是整条序列在预测时必须已知：逆序递推需要 $\mathbf{x}_{t+1:T}$，因此双向结构不能用于自回归生成，否则会用到未来信息。它适用于标注、分类、编码器等离线任务。与 [[从RNN到注意力机制]] 对照，注意力层不限制信息流向，编码器可以一次读取整条序列，因而不存在正序与逆序两个分支的区分。

### 8. 深层 RNN

第 $l$ 层的递推为

$$\mathbf{h}_t^{(l)}=\tanh\!\left(\mathbf{W}_h^{(l)}\mathbf{h}_{t-1}^{(l)}+\mathbf{W}_x^{(l)}\mathbf{h}_t^{(l-1)}+\mathbf{b}^{(l)}\right)$$

其中 $\mathbf{h}_t^{(0)}=\mathbf{x}_t$。堆叠 $L$ 层后，从损失到第 $1$ 层第 $t$ 步的路径长度约为 $L\cdot T$，梯度连乘的因子数随之增加，因此深层 RNN 通常需要层间残差连接、层归一化与 Dropout。

Dropout 的放置位置需要区分：在层间（垂直方向）对 $\mathbf{h}_t^{(l)}$ 施加 Dropout 是标准做法；在时间方向对循环连接施加 Dropout 会破坏状态在长序列上的连续性，通常改用变分 Dropout，即同一权重掩码在所有时间步共享。

参数量随层数线性增长：单层为 $dm+m^2+m$，$L$ 层为 $dm+m^2+m+(L-1)(2m^2+m)$。计算量随 $L$ 与 $T$ 的乘积增长，且时间步无法并行，这是 RNN 相对卷积与注意力的主要效率劣势。

### 9. teacher forcing

训练自回归模型时，时刻 $t$ 的条件应当是 $\mathbf{x}_{1:t}$。有两种取法：

1. 使用真实前缀，即把数据中的 $\mathbf{x}_{1:t}$ 直接输入。这就是 teacher forcing，训练时每一步的输入分布与数据分布一致，误差不会沿时间累积，梯度估计的方差小。
2. 使用模型自己的预测作为下一步输入，即自由运行（free running）。这与推理时的行为一致，但早期预测错误会传播，训练不稳定。

teacher forcing 的代价是训练与推理的条件分布不一致，称为暴露偏差。推理时模型从未见过自己的错误输出，一旦偏离训练分布，误差会沿生成过程累积。缓解方法包括计划采样（scheduled sampling，按概率混合真实前缀与模型输出）、在训练中加入含噪前缀，或使用强化学习目标直接优化序列级奖励。

对编码器-解码器结构，teacher forcing 作用于解码器：解码器第 $t$ 步的输入是真实的目标序列第 $t-1$ 个词，而不是上一步的预测。

## 关键直觉

> [!tip] RNN 是沿时间轴复用同一组权值的深度网络
> 展开后 $T$ 个时间步对应 $T$ 层，但只有一组参数；BPTT 就是对这个展开图做反向传播，梯度沿时间方向的连乘决定模型能利用多长的历史。隐状态是前缀的固定维摘要，其容量由 $m$ 决定，与序列长度无关。因此 RNN 的表达能力受两个量约束：状态维数决定「能存多少」，雅可比连乘的谱性质决定「能传多远」。

## 例子与代码

### 两步手算

取 $d=1$，$m=2$，$\mathbf{W}_x=[1.0,\ 0.5]^{\top}$，$\mathbf{W}_h=0.5\mathbf{I}$，$\mathbf{b}=\mathbf{0}$，$\mathbf{h}_0=\mathbf{0}$，输入 $x_1=1$，$x_2=-1$。

第 1 步：

$$\mathbf{z}_1=\begin{bmatrix}1.0\\0.5\end{bmatrix},\qquad \mathbf{h}_1=\tanh(\mathbf{z}_1)=\begin{bmatrix}0.7616\\0.4621\end{bmatrix}$$

第 2 步：

$$\mathbf{z}_2=0.5\begin{bmatrix}0.7616\\0.4621\end{bmatrix}-\begin{bmatrix}1.0\\0.5\end{bmatrix}=\begin{bmatrix}-0.6192\\-0.2689\end{bmatrix},\qquad \mathbf{h}_2=\tanh(\mathbf{z}_2)=\begin{bmatrix}-0.5506\\-0.2626\end{bmatrix}$$

注意第二步的第一维由 $0.3808-1.0=-0.6192$ 得到：上一状态被 $0.5$ 缩放后与当前输入相加，当前输入的符号直接改变了状态方向。这就是「状态同时依赖历史与当前输入」的最小实例。

### 梯度范数随步数衰减

```python
import numpy as np

def orthogonal(scale, seed, n=8):
    r = np.random.default_rng(seed)
    q, r_ = np.linalg.qr(r.normal(size=(n, n)))
    return scale * q * np.sign(np.diag(r_))    # 去掉 QR 分解的符号自由度

def decay(rho, T=30, seed=11):
    Wh = orthogonal(rho, seed)                 # 谱半径为 rho 的正交阵缩放
    x = 0.1 * np.random.default_rng(7).normal(size=(T, Wh.shape[0]))
    h = np.zeros(Wh.shape[0])
    hs = []
    for t in range(T):
        h = np.tanh(x[t] + h @ Wh.T)
        hs.append(h)
    dh = np.ones(Wh.shape[0])
    for t in reversed(range(T)):
        dh = (dh * (1 - hs[t] ** 2)) @ Wh      # 逐步乘雅可比
    return np.linalg.norm(dh), np.mean([np.linalg.norm(v) for v in hs])

print("rho   ||dh_30||     mean|h|")
for rho in (0.5, 0.9, 1.0, 1.1, 1.3):
    nrm, mh = decay(rho)
    print(f"{rho:3.1f}  {nrm:.3e}  {mh:.4f}")
```

输出：

```text
rho   ||dh_30||     mean|h|
0.5  1.977e-09  0.2750
0.9  5.234e-02  0.4377
1.0  6.631e-01  0.5960
1.1  3.244e+00  0.8366
1.3  1.271e+01  1.2340
```

代码只做一件事：把全 1 向量按 BPTT 的连乘规则反向传播 30 步，输出其范数。$\rho=0.5$ 与 $\rho=1.3$ 两行对应两个失败模式：前者梯度消失到 $10^{-9}$，早期时间步的依赖无法学习；后者梯度已被放大到 $12.7$，说明爆炸已经发生。若输入与初始化更小、状态未进入 $\tanh$ 的收缩区，增长速率将接近 $\rho$，几十步即可超出 float32 的表示范围并产生 `inf` 与 `nan`。

### NumPy 实现前向与 BPTT

```python
import numpy as np

rng = np.random.default_rng(0)
D, H, T, B, K = 4, 5, 6, 3, 10   # 输入维、隐藏维、步数、批大小、类别数


def softmax(z):
    z = z - z.max(axis=-1, keepdims=True)      # 减去最大值，避免指数溢出
    e = np.exp(z)
    return e / e.sum(axis=-1, keepdims=True)


def init_params():
    return {
        "Wx": rng.normal(0.0, 0.5, (D, H)),    # 输入到隐藏
        "Wh": rng.normal(0.0, 0.5, (H, H)),    # 隐藏到隐藏，跨时间共享
        "bh": np.zeros(H),
        "Wy": rng.normal(0.0, 0.5, (H, K)),    # 隐藏到输出
        "by": np.zeros(K),
    }


X = rng.normal(size=(B, T, D))                 # (批, 步, 输入维)
y = rng.integers(0, K, size=(B,))              # 每个序列一个类别标签


def forward(p, X):
    Wx, Wh, bh, Wy, by = p["Wx"], p["Wh"], p["bh"], p["Wy"], p["by"]
    Bn, Tn, _ = X.shape
    h = np.zeros((Bn, H))
    hs = []
    for t in range(Tn):
        z = X[:, t, :] @ Wx + h @ Wh + bh      # 仿射变换
        h = np.tanh(z)                         # 隐藏状态
        hs.append(h)
    logits = hs[-1] @ Wy + by                  # 只在最后一步接输出层
    prob = softmax(logits)
    loss = -np.mean(np.log(prob[np.arange(Bn), y] + 1e-12))
    return loss, (X, hs, prob)


def backward(p, cache, y):
    X, hs, prob = cache
    Wx, Wh, Wy = p["Wx"], p["Wh"], p["Wy"]
    Bn, Tn, _ = X.shape
    g = {k: np.zeros_like(v) for k, v in p.items()}
    dlogits = prob.copy()
    dlogits[np.arange(Bn), y] -= 1.0           # softmax 与交叉熵组合的梯度
    dlogits /= Bn
    g["Wy"] = hs[-1].T @ dlogits
    g["by"] = dlogits.sum(axis=0)
    dh = dlogits @ Wy.T                        # 流入 h_{T-1} 的梯度
    for t in reversed(range(Tn)):
        dz = dh * (1.0 - hs[t] ** 2)           # tanh 的导数
        g["Wx"] += X[:, t, :].T @ dz
        if t > 0:
            g["Wh"] += hs[t - 1].T @ dz        # t=0 时 h_{-1}=0，无贡献
            dh = dz @ Wh.T                     # 继续回传到 t-1
        g["bh"] += dz.sum(axis=0)
    return g


p = init_params()
loss, cache = forward(p, X)
g = backward(p, cache, y)
print(f"初始损失 {loss:.4f}")

eps = 1e-5                                     # 中心差分的步长
worst = 0.0
for k in p:
    flat = p[k].reshape(-1)
    num = np.zeros_like(flat)
    for i in range(flat.size):
        old = flat[i]
        flat[i] = old + eps
        lp, _ = forward(p, X)
        flat[i] = old - eps
        lm, _ = forward(p, X)
        flat[i] = old
        num[i] = (lp - lm) / (2 * eps)
    ana = g[k].reshape(-1)
    rel = np.max(np.abs(num - ana) / np.maximum(1e-8, np.abs(num) + np.abs(ana)))
    worst = max(worst, rel)
    print(f"{k}: 最大相对误差 {rel:.3e}")

print(f"最差相对误差 {worst:.3e}")
```

输出：

```text
初始损失 2.9117
Wx: 最大相对误差 3.761e-10
Wh: 最大相对误差 2.600e-09
bh: 最大相对误差 7.465e-11
Wy: 最大相对误差 1.259e-07
by: 最大相对误差 2.639e-10
最差相对误差 1.259e-07
```

对应关系需要逐行核对：

- `dz = dh * (1.0 - hs[t] ** 2)` 即 $\boldsymbol{\delta}_t=\mathrm{diag}(\mathbf{1}-\mathbf{h}_t^2)\partial L/\partial\mathbf{h}_t$。
- `g["Wx"] += X[:, t, :].T @ dz` 与 `g["Wh"] += hs[t-1].T @ dz` 即两个求和式，`+=` 对应时间步累加。
- `if t > 0` 分支省略了 $t=0$ 时的 $\mathbf{h}_{-1}$，其值为 $\mathbf{0}$，贡献为零；若误写成 `hs[t-1]` 不判断 $t=0$，会取到最后一个时间步的 `hs[-1]`，梯度完全错误但形状合法。
- 相对误差在 $10^{-7}$ 量级，主要来自 `Wy`：输出层梯度量级较大，中心差分的截断误差与浮点消减在这里最明显。若把 `dlogits /= Bn` 漏掉，所有解析梯度整体放大 $B$ 倍，相对误差接近 $1$，梯度检验会立即报错。

### PyTorch nn.RNN 的形状与逐步等价

```python
import torch
import torch.nn as nn

torch.manual_seed(0)
B, T, D, H = 3, 6, 4, 5
x = torch.randn(B, T, D)
h0 = torch.zeros(1, B, H)                      # (层数*方向数, 批, 隐藏维)

rnn = nn.RNN(input_size=D, hidden_size=H, num_layers=1, batch_first=True)
out, hn = rnn(x, h0)
print(out.shape, hn.shape)                     # torch.Size([3, 6, 5]) torch.Size([1, 3, 5])

cell = nn.RNNCell(D, H)
with torch.no_grad():                          # 把 nn.RNN 的权值复制到单步单元
    cell.weight_ih.copy_(rnn.weight_ih_l0)
    cell.weight_hh.copy_(rnn.weight_hh_l0)
    cell.bias_ih.copy_(rnn.bias_ih_l0)
    cell.bias_hh.copy_(rnn.bias_hh_l0)

h = torch.zeros(B, H)
steps = []
for t in range(T):
    h = cell(x[:, t, :], h)                    # 单步递推
    steps.append(h)
manual = torch.stack(steps, dim=1)             # 拼回 (批, 步, 隐藏维)
print(torch.allclose(manual, out, atol=1e-6))  # True
```

输出：

```text
torch.Size([3, 6, 5]) torch.Size([1, 3, 5])
True
```

两个形状的含义：`out` 是每个时间步的隐藏状态，`hn` 是最后一步的状态，单层单向时 `hn[0]` 与 `out[:, -1, :]` 相等。`batch_first=True` 只改变输入输出的排列，不改变内部计算顺序；默认 `batch_first=False` 时输入应为 $(T,B,D)$。

### 截断 BPTT

长序列一次性展开会使计算图过大。截断 BPTT 把序列切成长度 $S$ 的片段，段间保留状态但截断梯度：

```python
import torch
import torch.nn as nn

torch.manual_seed(0)
B, T, D, H, S = 8, 200, 16, 32, 20            # 序列长 200，每段 20 步
rnn = nn.RNN(D, H, batch_first=True)
head = nn.Linear(H, D)
opt = torch.optim.Adam(list(rnn.parameters()) + list(head.parameters()), lr=1e-3)
loss_fn = nn.CrossEntropyLoss()

x = torch.randn(B, T, D)
target = torch.randint(0, D, size=(B, T))      # 占位任务：每步预测一个类别

h = torch.zeros(1, B, H)
for start in range(0, T, S):
    seg = x[:, start:start + S, :]
    out, h = rnn(seg, h)
    loss = loss_fn(head(out.reshape(-1, H)), target[:, start:start + S].reshape(-1))
    opt.zero_grad()
    loss.backward()
    nn.utils.clip_grad_norm_(rnn.parameters(), 5.0)   # 裁剪在 step 之前
    opt.step()
    h = h.detach()                             # 切断跨段梯度，保留状态数值
```

`h.detach()` 是截断的关键：它保留隐藏状态的数值作为下一段初值，但切断计算图，使反向传播不越过段边界。若漏掉 `detach()`，计算图会随段数线性增长，显存持续上升，最终报「Trying to backward through the graph a second time」或显存溢出。

## 易错点

> [!warning] 常见错误
> - 忽略 `batch_first` 的默认值。`nn.RNN` 默认输入为 $(T,N,D)$，若传入 $(N,T,D)$ 且 $T\ne N$，PyTorch 会把第 $0$ 维当作时间、第 $1$ 维当作批。不显式传 `h0` 时程序仍能运行，但每步看到的是不同样本的同一位置，输出形状 $(N,T,H)$ 与期望的 $(N,T,H)$ 恰好相同，错误不可见；显式传入按批构造的 `h0` 则会报批维不匹配。$T=N$ 时两种解释都成立，错误完全不可见。
> - 初始状态形状错误。`h0` 要求 $(D_{\text{layers}}\times D_{\text{directions}},\,N,\,H)$；单层单向为 $(1,N,H)$，双向为 $(2,N,H)$。传入 $(N,H)$ 会报维度错误；双向时只给 $(1,N,H)$ 会报期望 $2$ 得到 $1$。
> - 忘记清梯度或忘记 detach。训练循环漏掉 `opt.zero_grad()` 会使梯度跨批累积；截断 BPTT 漏掉 `h.detach()` 会使图跨段增长，显存随时间步线性上升，并可能触发二次反向错误。
> - 在填充位置上计算损失。对全部 $T_{\max}$ 位置求平均会稀释短序列的梯度，且填充标签若设为 $0$ 会与真实类别 $0$ 混淆。正确做法是用掩码求和后除以有效 token 数，或使用 `ignore_index`。
> - 取错序列表示。多对一任务取 `out[:, -1, :]` 时，若批内序列长度不同，最后一步可能是填充位置；应按长度索引 `out[torch.arange(N), lengths - 1]`，或先用 `pack_padded_sequence` 压缩。
> - 混淆梯度裁剪的时机与方式。裁剪放在 `optimizer.step()` 之后无效；只对部分参数裁剪会使更新方向失衡；用逐元素截断代替范数裁剪会改变方向。另需注意 `clip_grad_norm_` 返回的是裁剪前范数，可用于监控爆炸。

## 关联笔记

- 前置：[[神经网络与前向传播]] —— RNN 的每一步都是一次「线性变换加激活」，本篇只增加状态反馈这一条边。
- 前置：[[反向传播详解]] —— BPTT 是展开图上的反向传播，参数共享的梯度累加规则直接给出 $\partial L/\partial\mathbf{W}_h$ 的求和形式。
- 后续：[[LSTM与GRU]] —— 本篇第 5 小节的连乘衰减是门控结构的动因，细胞状态的加法更新改变了雅可比的对角结构。
- 后续：[[从RNN到注意力机制]] —— 注意力保留序列建模目标，但去掉递推，使任意两步之间的路径长度为 $1$。
- 对照：[[优化器与学习率]] —— 梯度裁剪、学习率预热与梯度尺度估计在 RNN 训练中比前馈网络更敏感。

## 达标检测

- [ ] 写出展开 $T$ 步后的计算图，说明「深度为 $T$」与「参数量与 $T$ 无关」为何同时成立，并给出 $d=128$、$m=256$、$T=50$ 时 RNN 与 $T$ 个独立全连接层的参数量对比。
- [ ] 从 $\partial L/\partial\mathbf{h}_t$ 的递推式出发，推导含 $\prod_{j=t+1}^{\tau}$ 的完整求和形式并说明 $\tau=t$ 时为何约定为单位矩阵；再由 $\boldsymbol{\delta}_t$ 推出 $\partial L/\partial\mathbf{W}_h=\sum_t\boldsymbol{\delta}_t\mathbf{h}_{t-1}^{\top}$ 与 $\mathbf{W}_x,\mathbf{b}$ 的梯度，指出求和号来自哪个事实。
- [ ] 证明 $\|\mathbf{J}_{t:\tau}\|_2\le\sigma_{\max}(\mathbf{W}_h)^{\tau-t}$，并解释 $\rho=1.3$ 时实测梯度范数远小于 $\rho^{30}$ 的原因。
- [ ] 运行 NumPy BPTT 代码并报告最差相对误差；再故意把 `if t > 0` 去掉，预测并解释梯度检验的结果。
- [ ] 说明 teacher forcing 与自由运行的条件分布差异，给出一种缓解暴露偏差的方法及其代价。
- [ ] 指出 `nn.RNN` 输入形状、`h0` 形状、`h.detach()` 三处各写错时会出现的具体现象（报错信息或静默错误）。

## 参考来源

- Goodfellow, Bengio, Courville, *Deep Learning*, 2016, 第 10 章「Sequence Modeling: Recurrent and Recursive Nets」 —— 对应本篇递推式、展开图、BPTT 推导、梯度消失与爆炸的分析以及双向与深层结构。
- d2l.ai《动手学深度学习》，第 8 章「循环神经网络」 —— 对应 RNN 的从零实现、参数初始化、梯度裁剪与截断 BPTT 的工程做法。
- Stanford CS224n 课程讲义，Language Models and RNNs —— 对应语言模型的链式分解、teacher forcing 与 BPTT 的教学推导。
- PyTorch 官方文档，`torch.nn.RNN`、`torch.nn.RNNCell`、`torch.nn.utils.clip_grad_norm_`、`torch.nn.utils.rnn.pack_padded_sequence` —— 对应张量形状约定、单步与整序列的等价性、梯度裁剪与变长批处理接口。
- Goodfellow, Bengio, Courville, *Deep Learning*, 2016, 第 8 章「Optimization for Training Deep Models」中的「Cliffs and Exploding Gradients」一节 —— 对应本篇梯度裁剪的动机与按范数裁剪的写法。
