---
tags: [AI, 深度学习, LSTM, 门控网络]
阶段: 04-深度学习核心
难度: ★★★
created: 2026-10-18
related: "[[循环神经网络RNN]], [[从RNN到注意力机制]], [[反向传播详解]]"
---

# LSTM与GRU

## 定义

**长短期记忆网络**（long short-term memory, LSTM）是在循环网络的每一步引入一个细胞状态 $\mathbf{c}_t$ 与三个取值于 $(0,1)$ 的乘性门，由遗忘门控制旧状态的保留比例、由输入门控制新内容的写入比例、由输出门控制细胞状态向外暴露的比例，从而把状态的更新写成加法形式、使梯度沿细胞状态以逐元素缩放而非矩阵连乘的方式跨时间传播的循环神经网络。

逐项定义符号：

- $\mathbf{x}_t\in\mathbb{R}^{d}$：第 $t$ 步的输入，$d$ 为输入维数。
- $\mathbf{h}_{t-1}\in\mathbb{R}^{m}$：上一步的隐藏状态，$m$ 为隐藏维数；$\mathbf{h}_0=\mathbf{0}$。
- $\mathbf{c}_{t-1}\in\mathbb{R}^{m}$：上一步的细胞状态（cell state），只在本层内部传递，不直接作为输出；$\mathbf{c}_0=\mathbf{0}$。
- $[\mathbf{h}_{t-1};\mathbf{x}_t]\in\mathbb{R}^{m+d}$：隐藏状态与当前输入的拼接向量。
- $\mathbf{W}_f,\mathbf{W}_i,\mathbf{W}_o,\mathbf{W}_g\in\mathbb{R}^{m\times(m+d)}$：四个门的权值矩阵；$\mathbf{b}_f,\mathbf{b}_i,\mathbf{b}_o,\mathbf{b}_g\in\mathbb{R}^{m}$：对应偏置。
- $\mathbf{a}^{f}_t,\mathbf{a}^{i}_t,\mathbf{a}^{o}_t,\mathbf{a}^{g}_t\in\mathbb{R}^{m}$：四个门的激活前值。
- $\mathbf{f}_t,\mathbf{i}_t,\mathbf{o}_t\in(0,1)^{m}$：遗忘门、输入门、输出门，逐元素取值于 $0$ 与 $1$ 之间。
- $\mathbf{g}_t\in(-1,1)^{m}$：候选记忆，取值于 $-1$ 与 $1$ 之间。
- $\sigma(z)=1/(1+e^{-z})$：sigmoid 函数，逐元素作用。
- $\odot$：逐元素乘积，要求两侧同形。
- $\mathbf{r}_t,\mathbf{z}_t\in(0,1)^{m}$：GRU 的重置门与更新门；$\tilde{\mathbf{h}}_t\in(-1,1)^{m}$：GRU 的候选状态。

逐项定义术语：

- 门（gate）：由一个线性变换加 sigmoid 得到的逐元素系数向量，用于按比例通过或阻断信息。
- 细胞状态（cell state）：LSTM 内部维护的 $m$ 维向量，按加法更新，是跨时间传递信息的主要状态变量。
- 候选记忆（candidate memory）：由当前输入与上一隐藏状态经 $\tanh$ 生成的新内容，写入前由输入门缩放。
- 门控循环单元（gated recurrent unit, GRU）：只使用重置门与更新门、并把细胞状态与隐藏状态合并为一个状态的循环单元。
- 重置门（reset gate）：控制上一隐藏状态在计算候选状态时被保留的比例。
- 更新门（update gate）：控制候选状态与旧状态在输出中的混合比例。
- peephole 连接：让门的输入额外包含 $\mathbf{c}_{t-1}$ 的连接方式。
- 耦合输入遗忘门（coupled input-forget gate）：强制 $\mathbf{i}_t=\mathbf{1}-\mathbf{f}_t$，使写入量与保留量之和为 $1$。

## 为什么重要

- 长距离依赖需要梯度跨越多步。标准 RNN 的梯度含 $\prod_{j}\mathbf{W}_h^{\top}\mathrm{diag}(\mathbf{1}-\mathbf{h}_j^{2})$，其范数上界为 $\sigma_{\max}(\mathbf{W}_h)^{T}$。当 $\sigma_{\max}<1$ 时，$50$ 步后的梯度约为 $10^{-15}$ 量级，模型无法从 $50$ 步之前的信息中学习。LSTM 把状态更新的雅可比改为对角矩阵 $\mathrm{diag}(\mathbf{f}_t)$，$50$ 步的连乘为 $\prod f_j$，当 $f\approx0.99$ 时仍为 $0.605$，两者相差约 $15$ 个数量级。
- 记忆与变换的冲突需要分离。RNN 用同一组 $\mathbf{W}_h$ 同时承担「保留旧信息」与「写入新信息」，两种目标对权值的谱性质要求相反。门控把这两个操作拆成两条独立的乘性通路，使网络可以分别学习保留比例与写入内容。
- 输出与记忆需要解耦。LSTM 的隐藏状态由输出门从细胞状态中读出，细胞状态本身不直接暴露。这样网络可以长期保存某个量，而不必在每一步都把它编码进输出。
- 没有门控时，循环网络难以学习跨越数十步以上的依赖，序列任务多依赖手工对齐、短窗口特征或隐马尔可夫模型；门控结构把可用历史长度提高到数百步量级。
- 在本库中的位置：前置为 [[循环神经网络RNN]]（递推式与 BPTT）与 [[反向传播详解]]（链式法则与雅可比连乘）；本篇的门控结构是 [[从RNN到注意力机制]] 的前置对照，注意力用对全部位置的加权读取替代固定维状态，去掉了跨时间的连乘路径；sigmoid 与 tanh 的饱和性质见 [[激活函数]]。
- 对应能力目标：懂原理对应「写出六个门控公式并推导 $\partial\mathbf{c}_t/\partial\mathbf{c}_{t-1}$」；能复现对应「NumPy 手写 LSTM 单元、PyTorch 训练序列分类器」；会评估对应「由门激活值判断记忆是否饱和、由参数量判断模型规模」。

## 原理与推导

### 1. RNN 的长期依赖问题

标准 RNN 的隐藏状态梯度满足

$$\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}$$

连乘中的每个因子都是矩阵，矩阵乘积的奇异值按因子奇异值的乘积增长或衰减。设 $\sigma_{\max}(\mathbf{W}_h)=\rho$，则

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

$\rho<1$ 时梯度随距离指数衰减，$\rho>1$ 时随距离指数增长。两种情形都破坏学习：前者使远距离信息不可学，后者使数值溢出。

问题不只是梯度尺度。同一矩阵 $\mathbf{W}_h$ 既要保存信息又要变换信息：保存要求 $\mathbf{W}_h$ 接近正交且谱半径接近 $1$，变换要求它对不同输入产生区分度较大的响应。单个矩阵难以同时满足两种要求，这是门控结构要解决的表达瓶颈。

### 2. LSTM 的结构与三个门公式

LSTM 在每一步计算四个中间量，再更新两个状态。设 $\mathbf{x}_t$ 与 $\mathbf{h}_{t-1}$ 已拼接为 $[\mathbf{h}_{t-1};\mathbf{x}_t]$：

$$\mathbf{a}^{f}_t=\mathbf{W}_f[\mathbf{h}_{t-1};\mathbf{x}_t]+\mathbf{b}_f,\qquad \mathbf{f}_t=\sigma\!\left(\mathbf{a}^{f}_t\right)$$

$$\mathbf{a}^{i}_t=\mathbf{W}_i[\mathbf{h}_{t-1};\mathbf{x}_t]+\mathbf{b}_i,\qquad \mathbf{i}_t=\sigma\!\left(\mathbf{a}^{i}_t\right)$$

$$\mathbf{a}^{o}_t=\mathbf{W}_o[\mathbf{h}_{t-1};\mathbf{x}_t]+\mathbf{b}_o,\qquad \mathbf{o}_t=\sigma\!\left(\mathbf{a}^{o}_t\right)$$

$$\mathbf{a}^{g}_t=\mathbf{W}_g[\mathbf{h}_{t-1};\mathbf{x}_t]+\mathbf{b}_g,\qquad \mathbf{g}_t=\tanh\!\left(\mathbf{a}^{g}_t\right)$$

细胞状态与隐藏状态的更新：

$$\mathbf{c}_t=\mathbf{f}_t\odot\mathbf{c}_{t-1}+\mathbf{i}_t\odot\mathbf{g}_t$$

$$\mathbf{h}_t=\mathbf{o}_t\odot\tanh\!\left(\mathbf{c}_t\right)$$

六个公式的维度一致：四个门的激活前值都是 $m$ 维，两个状态也都是 $m$ 维。因此 $\mathbf{h}_t$ 可以直接作为下一时刻拼接向量的一部分，$\mathbf{c}_t$ 可以直接参与下一时刻的逐元素更新。四个权值矩阵的形状相同，实践中合并为一个大矩阵 $\mathbf{W}\in\mathbb{R}^{4m\times(m+d)}$，一次矩阵乘法得到 $4m$ 维结果再切分，以减少小矩阵乘法的开销。

数据流可以写成以下顺序：拼接、四个仿射变换、三个 sigmoid 与一个 tanh、细胞状态的加权和、隐藏状态的读出。计算图如下：

```mermaid
flowchart LR
    X["x_t"] --> CAT["[h_{t-1}, x_t]"]
    H["h_{t-1}"] --> CAT
    CAT --> F["f_t = sigmoid"]
    CAT --> I["i_t = sigmoid"]
    CAT --> O["o_t = sigmoid"]
    CAT --> G["g_t = tanh"]
    C["c_{t-1}"] --> MUL1["f_t * c_{t-1}"]
    F --> MUL1
    MUL1 --> ADD["c_t = f_t*c_{t-1} + i_t*g_t"]
    I --> MUL2["i_t * g_t"]
    G --> MUL2
    MUL2 --> ADD
    ADD --> TC["tanh(c_t)"]
    TC --> MUL3["o_t * tanh(c_t)"]
    O --> MUL3
    MUL3 --> HOUT["h_t"]
```

该图中 $\mathbf{c}_t$ 只有一条入边来自 $\mathbf{c}_{t-1}$，且中间只经过一次逐元素乘法，这是第 4 小节梯度分析的图形依据。

### 3. 三个门与候选记忆的逐项解释

| 量 | 公式 | 维度 | 取 0 的极限 | 取 1 的极限 | 作用 |
| --- | --- | --- | --- | --- | --- |
| 遗忘门 $\mathbf{f}_t$ | $\sigma(\mathbf{W}_f[\mathbf{h}_{t-1};\mathbf{x}_t]+\mathbf{b}_f)$ | $m$ | 完全清除旧状态 | 完全保留旧状态 | 控制细胞状态的保留比例 |
| 输入门 $\mathbf{i}_t$ | $\sigma(\mathbf{W}_i[\mathbf{h}_{t-1};\mathbf{x}_t]+\mathbf{b}_i)$ | $m$ | 不写入新内容 | 全量写入新内容 | 控制候选记忆的写入比例 |
| 候选记忆 $\mathbf{g}_t$ | $\tanh(\mathbf{W}_g[\mathbf{h}_{t-1};\mathbf{x}_t]+\mathbf{b}_g)$ | $m$ | 写入内容为零 | 写入内容接近上界 | 提供当前时刻的新内容 |
| 输出门 $\mathbf{o}_t$ | $\sigma(\mathbf{W}_o[\mathbf{h}_{t-1};\mathbf{x}_t]+\mathbf{b}_o)$ | $m$ | 不向外暴露状态 | 全量暴露状态 | 控制细胞状态的读出比例 |

四项设计的因果关系：

1. 遗忘门与输入门分别乘在旧状态与新内容上，使 $\mathbf{c}_t$ 成为 $\mathbf{c}_{t-1}$ 与 $\mathbf{g}_t$ 的加权和；当 $\mathbf{f}_t+\mathbf{i}_t=\mathbf{1}$ 时是严格的凸组合，此时 $|\mathbf{c}_t|<1$。一般情况下由 $|\mathbf{g}_t|<1$ 得 $|\mathbf{c}_t|\le f_t|\mathbf{c}_{t-1}|+i_t$，从 $\mathbf{c}_0=\mathbf{0}$ 递推得 $|\mathbf{c}_t|<i/(1-f)$，即状态有界，但上界随 $f\to1$ 增大；若 $f+i\le1$，上界收紧为 $1$。在耦合输入遗忘门的变体中 $i=1-f$，该上界严格成立。
2. 候选记忆使用 $\tanh$ 而非 sigmoid，因为新内容需要能表达正负两个方向；若写入项恒非负，细胞状态只能依靠遗忘门下降，可表达的变化方向受限。
3. 输出门与 $\tanh(\mathbf{c}_t)$ 相乘，使 $\mathbf{h}_t$ 的每个分量被限制在 $(-1,1)$，与 RNN 的隐藏状态量级一致，可安全送入下一层。
4. 细胞状态 $\mathbf{c}_t$ 不直接输出，只在本层循环。若某个信息需要被保存很多步但不影响当前输出，网络可以把 $\mathbf{o}_t$ 压到接近 $0$，同时保持 $\mathbf{c}_t$ 不变。

门偏置初始化的实践：把 $\mathbf{b}_f$ 初始化为 $1$ 时，初始遗忘门为 $\sigma(1)=0.731$，网络在训练初期倾向于保留细胞状态，梯度更容易传回早期时间步。这不是结构上的要求，而是常用的初始化选择。PyTorch 的 `nn.LSTM` 默认把所有权值与偏置初始化为 $U(-1/\sqrt{m},1/\sqrt{m})$，不包含该特殊设置；若需要，可手动把遗忘门对应的偏置切片置为 $1$。

### 4. 为何细胞状态的加法更新缓解梯度消失

对 $\mathbf{c}_t=\mathbf{f}_t\odot\mathbf{c}_{t-1}+\mathbf{i}_t\odot\mathbf{g}_t$ 求 $\mathbf{c}_t$ 对 $\mathbf{c}_{t-1}$ 的导数。注意 $\mathbf{f}_t,\mathbf{i}_t,\mathbf{g}_t$ 都由 $\mathbf{h}_{t-1}$ 计算，而 $\mathbf{h}_{t-1}$ 依赖 $\mathbf{c}_{t-1}$，故完整导数为四项：

$$\frac{\partial\mathbf{c}_t}{\partial\mathbf{c}_{t-1}}=\mathrm{diag}(\mathbf{f}_t)+\mathrm{diag}(\mathbf{c}_{t-1})\frac{\partial\mathbf{f}_t}{\partial\mathbf{c}_{t-1}}+\mathrm{diag}(\mathbf{g}_t)\frac{\partial\mathbf{i}_t}{\partial\mathbf{c}_{t-1}}+\mathrm{diag}(\mathbf{i}_t)\frac{\partial\mathbf{g}_t}{\partial\mathbf{c}_{t-1}}$$

第一项来自 $\mathbf{f}_t\odot\mathbf{c}_{t-1}$ 对 $\mathbf{c}_{t-1}$ 的直接依赖，后三项来自门对 $\mathbf{c}_{t-1}$ 的间接依赖。若把门视为只由 $\mathbf{x}_t$ 决定（或在分析中忽略 $\mathbf{h}_{t-1}$ 对 $\mathbf{c}_{t-1}$ 的依赖），后三项为零，得到

$$\frac{\partial\mathbf{c}_t}{\partial\mathbf{c}_{t-1}}=\mathrm{diag}(\mathbf{f}_t)$$

对角矩阵的乘积仍为对角矩阵且可交换，于是跨 $T-t$ 步的雅可比为

$$\frac{\partial\mathbf{c}_T}{\partial\mathbf{c}_t}=\prod_{j=t+1}^{T}\mathrm{diag}(\mathbf{f}_j)=\mathrm{diag}\!\left(\prod_{j=t+1}^{T}\mathbf{f}_j\right)$$

其第 $i$ 个对角元是 $\prod_{j=t+1}^{T}f_{j,i}$，即同一单元上的标量连乘，不涉及不同单元之间的混合。这正是与 RNN 的关键差别：RNN 的连乘是矩阵乘积，奇异值按因子相乘且方向被反复旋转；LSTM 的连乘是对角乘积，第 $i$ 个单元的梯度只被第 $i$ 个单元的遗忘门缩放。

数值对比（单元素）：

| 每步缩放 | 25 步后 | 50 步后 | 100 步后 |
| --- | --- | --- | --- |
| $f=0.5$ | $2.98\times10^{-8}$ | $8.88\times10^{-16}$ | $7.89\times10^{-31}$ |
| $f=0.9$ | $7.18\times10^{-2}$ | $5.15\times10^{-3}$ | $2.66\times10^{-5}$ |
| $f=0.99$ | $0.778$ | $0.605$ | $0.366$ |

$f=0.5$ 一行对应 RNN 在谱半径 $0.5$ 附近的行为；$f=0.99$ 一行说明遗忘门接近 $1$ 时，100 步后梯度仍有初始值的 $36.6\%$。遗忘门由 sigmoid 产生，$f<1$ 恒成立，因此严格来说梯度仍按指数衰减，只是衰减率可以由数据学习到接近 $1$，且不再受 $\mathbf{W}_h$ 奇异值的约束。

从细胞状态到隐藏状态的读出还要乘一个因子：

$$\frac{\partial\mathbf{h}_t}{\partial\mathbf{c}_t}=\mathrm{diag}\!\left(\mathbf{o}_t\odot\left(\mathbf{1}-\tanh^{2}(\mathbf{c}_t)\right)\right)$$

该因子最大为 $1$，通常在 $0.1$ 至 $0.9$ 之间。梯度的完整路径还要经过输出门与 $\mathbf{h}_{t-1}$ 对门的贡献，因此 LSTM 并非无条件消除消失，而是提供了一条不被矩阵连乘阻断的通路。这样理解与严格推导的关系是：对角形式在「门不依赖 $\mathbf{c}_{t-1}$」的近似下成立，完整雅可比包含额外三项，但主对角项始终存在且等于 $\mathbf{f}_t$。

三项限制需要同时说明：

1. 遗忘门恒小于 $1$，极长序列上连乘仍会衰减到零，因此 LSTM 的有效记忆长度有限，通常为数十到数百步。
2. 反向传播还要经过 $\tanh$ 的饱和区，$\mathbf{c}_t$ 的绝对值较大时 $\partial\mathbf{h}_t/\partial\mathbf{c}_t$ 接近 $0$。
3. 梯度爆炸仍可能发生，因为门与输出层的雅可比没有上界约束，训练中通常仍配合梯度裁剪。

### 5. 参数量计算

四个门各有一个 $m\times(m+d)$ 权值矩阵与一个 $m$ 维偏置，故 LSTM 层参数量为

$$\text{Params}_{\text{LSTM}}=4\left(m(m+d)+m\right)=4m(m+d+1)$$

GRU 有三个门，参数量为 $3m(m+d+1)$；标准 RNN 为 $m(m+d+1)$。三者之比为 $4:3:1$（忽略偏置时严格成立）。

以 $d=8$、$m=16$ 为例：

| 结构 | 数学形式 | 数值 | PyTorch 实现 | PyTorch 数值 |
| --- | --- | --- | --- | --- |
| RNN | $m(m+d+1)$ | $16\times25=400$ | $m(m+d+2)$ | $416$ |
| LSTM | $4m(m+d+1)$ | $4\times16\times25=1600$ | $4m(m+d+2)$ | $1664$ |
| GRU | $3m(m+d+1)$ | $3\times16\times25=1200$ | $3m(m+d+2)$ | $1248$ |

PyTorch 的数值比数学形式多 $m$、$4m$、$3m$，原因是每个门有 `bias_ih` 与 `bias_hh` 两个偏置向量，二者在计算中等价于一个偏置，但存储为两份。核对模型规模时应以 `sum(p.numel() for p in module.parameters())` 为准，不要用手推公式直接与 `state_dict` 对照。

规模示例：$d=300$、$m=512$ 时 LSTM 层参数量为 $4\times512\times(812+1)=1{,}665{,}024$，单个 float32 参数占 $4$ 字节，该层约 $6.35$ MB；若改为 $4$ 层堆叠且层间输入维保持 $512$，第一层之后每层为 $4\times512\times(512+1)=1{,}050{,}624$。

### 6. GRU 的重置门与更新门

GRU 把细胞状态与隐藏状态合并为一个 $\mathbf{h}_t$，用两个门完成保留与写入：

$$\mathbf{r}_t=\sigma\!\left(\mathbf{W}_r[\mathbf{h}_{t-1};\mathbf{x}_t]+\mathbf{b}_r\right)$$

$$\mathbf{z}_t=\sigma\!\left(\mathbf{W}_z[\mathbf{h}_{t-1};\mathbf{x}_t]+\mathbf{b}_z\right)$$

$$\tilde{\mathbf{h}}_t=\tanh\!\left(\mathbf{W}_h[\mathbf{r}_t\odot\mathbf{h}_{t-1};\mathbf{x}_t]+\mathbf{b}_h\right)$$

$$\mathbf{h}_t=(\mathbf{1}-\mathbf{z}_t)\odot\mathbf{h}_{t-1}+\mathbf{z}_t\odot\tilde{\mathbf{h}}_t$$

各项作用：

- 重置门 $\mathbf{r}_t$ 逐元素缩放上一状态后再参与候选状态的计算。$\mathbf{r}_t\to\mathbf{0}$ 时，候选状态只依赖当前输入，等于丢弃历史；这使 GRU 能在需要时快速切换上下文。
- 更新门 $\mathbf{z}_t$ 决定新旧状态的混合比例。$\mathbf{z}_t\to\mathbf{0}$ 时保留旧状态，$\mathbf{z}_t\to\mathbf{1}$ 时采用候选状态。它与 LSTM 的遗忘门作用相反地编码保留量：GRU 的保留系数是 $1-\mathbf{z}_t$。
- 候选状态中的重置作用发生在 $\mathbf{h}_{t-1}$ 上而不是整个拼接向量上，使当前输入始终完整参与候选计算。PyTorch 的实现把重置门作用在 $\mathbf{W}_{hn}\mathbf{h}_{t-1}+\mathbf{b}_{hn}$ 上，与部分文献把 $\mathbf{r}_t\odot\mathbf{h}_{t-1}$ 先拼接再乘矩阵的写法在参数上等价、在数值上略有差异。

GRU 的梯度通路与 LSTM 同源：$\partial\mathbf{h}_t/\partial\mathbf{h}_{t-1}$ 含对角项 $\mathrm{diag}(\mathbf{1}-\mathbf{z}_t)$，当 $\mathbf{z}_t$ 接近 $0$ 时该通路接近恒等，梯度可以跨步传播。

LSTM 与 GRU 的对比：

| 项目 | LSTM | GRU |
| --- | --- | --- |
| 门数 | 3 个（遗忘、输入、输出） | 2 个（重置、更新） |
| 状态 | $\mathbf{h}_t$ 与 $\mathbf{c}_t$ 分离 | 只有 $\mathbf{h}_t$ |
| 参数量（相对） | $4$ | $3$ |
| 保留系数 | $\mathbf{f}_t$ 独立学习 | $1-\mathbf{z}_t$，与写入量耦合 |
| 输出读出 | 经输出门与 $\tanh$ | 直接输出 $\mathbf{h}_t$ |
| 计算量 | 4 次 $m\times(m+d)$ 乘法 | 3 次 $m\times(m+d)$ 乘法 |
| 显存 | 需保存两个状态 | 只需一个状态 |

两者在多数任务上的差异小于初始化、学习率与数据规模带来的差异，没有普遍占优的结构。参数量少 $25\%$ 使 GRU 在数据较少或延迟受限时更常被采用；需要显式分离「长期保存」与「当前输出」时，LSTM 的额外状态提供了更大的调节空间。

### 7. 变体

1. peephole 连接：让门直接读取 $\mathbf{c}_{t-1}$，例如 $\mathbf{f}_t=\sigma(\mathbf{W}_f\mathbf{x}_t+\mathbf{U}_f\mathbf{c}_{t-1}+\mathbf{b}_f)$。每个门增加 $m\times m$ 参数，共 $3m^{2}$。它使门可以在不经过 $\mathbf{h}_{t-1}$ 的情况下感知细胞状态，代价是参数量增加且难以并行；现代实现较少使用。
2. 耦合输入遗忘门：令 $\mathbf{i}_t=\mathbf{1}-\mathbf{f}_t$，则 $\mathbf{c}_t=\mathbf{f}_t\odot\mathbf{c}_{t-1}+(\mathbf{1}-\mathbf{f}_t)\odot\mathbf{g}_t$。省去一组权值，使写入与保留严格互补，适合状态不需要同时增加与保留的场景。
3. 门控偏置初始化：把 $\mathbf{b}_f$ 置为 $1$ 或更大，使初始遗忘门接近 $1$，缓解训练初期的梯度衰减。
4. 层归一化 LSTM：对门的激活前值做层归一化，稳定深层堆叠与长序列训练的数值范围。
5. 双向与堆叠：双向 LSTM 拼接正序与逆序状态，输出维数为 $2m$；堆叠多层时第 $l$ 层的输入是第 $l-1$ 层的输出序列，层间可加残差连接与 Dropout。
6. GRU 变体：重置门作用位置不同（先乘状态或先算仿射）、更新门的计算顺序不同，各框架的实现细节需以文档为准。

## 关键直觉

> [!tip] 细胞状态是一条由逐元素门控调节的线性通路
> 因为 $\mathbf{c}_t=\mathbf{f}_t\odot\mathbf{c}_{t-1}+\mathbf{i}_t\odot\mathbf{g}_t$，$\mathbf{c}_t$ 对 $\mathbf{c}_{t-1}$ 的雅可比是以 $\mathbf{f}_t$ 为对角元的对角矩阵，跨时间的梯度是这些对角矩阵的乘积，即逐元素的 $\prod f_j$。与 RNN 的矩阵连乘相比，它避免了不同单元之间的混合与奇异值的反复相乘，使遗忘门接近 $1$ 时梯度可以跨越较多步。输出门把「保存什么」与「当前输出什么」分开，使长期存储不必以当前输出为代价。

## 例子与代码

### 一步手算

取 $m=d=1$，$\mathbf{h}_{t-1}=0.5$，$\mathbf{c}_{t-1}=0.8$，$x_t=1$，四个门的权值与偏置分别为 $\mathbf{W}_f=1,b_f=0$；$\mathbf{W}_i=0.5,b_i=0$；$\mathbf{W}_o=-1,b_o=0$；$\mathbf{W}_g=1,b_g=0$。

四个门的激活前值：

$$\mathbf{a}^{f}_t=1\cdot0.5+1\cdot1=1.5,\qquad \mathbf{f}_t=\sigma(1.5)=0.8176$$
$$\mathbf{a}^{i}_t=0.5\cdot0.5+0.5\cdot1=0.75,\qquad \mathbf{i}_t=\sigma(0.75)=0.6792$$
$$\mathbf{a}^{o}_t=-1\cdot0.5-1\cdot1=-1.5,\qquad \mathbf{o}_t=\sigma(-1.5)=0.1824$$
$$\mathbf{a}^{g}_t=0.5+1=1.5,\qquad \mathbf{g}_t=\tanh(1.5)=0.9051$$

细胞状态与隐藏状态：

$$\mathbf{c}_t=0.8176\times0.8+0.6792\times0.9051=0.6541+0.6148=1.2689$$
$$\mathbf{h}_t=0.1824\times\tanh(1.2689)=0.1824\times0.8535=0.1557$$

三个量的量级差异说明了门的实际作用：旧状态被保留 $81.8\%$，新内容写入 $67.9\%$，但输出门只放出 $18.2\%$，因此尽管 $\mathbf{c}_t$ 已增长到 $1.27$，$\mathbf{h}_t$ 仍只有 $0.156$。若把 $\mathbf{h}_t$ 的更新写成 $\mathbf{o}_t\odot\mathbf{c}_t$（漏掉 $\tanh$），结果为 $0.231$，与正确值相差 $48\%$；若把输出门误当成遗忘门，$\mathbf{c}_t$ 变为 $0.1824\times0.8+0.6792\times0.9051=0.761$，与正确值相差 $40\%$。

### NumPy 手写 LSTM 单元前向

```python
import numpy as np

def sigmoid(x):
    return 1.0 / (1.0 + np.exp(-x))

rng = np.random.default_rng(42)
D, H = 4, 6                                  # 输入维、隐藏维

Wf = rng.normal(0, 0.3, (D + H, H)); bf = np.full(H, 1.0)   # 遗忘门偏置取 1
Wi = rng.normal(0, 0.3, (D + H, H)); bi = np.zeros(H)
Wo = rng.normal(0, 0.3, (D + H, H)); bo = np.zeros(H)
Wg = rng.normal(0, 0.3, (D + H, H)); bg = np.zeros(H)

X = rng.normal(size=(10, D))                 # 长度 10 的序列
h = np.zeros(H)                              # 初始隐藏状态
c = np.zeros(H)                              # 初始细胞状态

for t in range(10):
    xh = np.concatenate([X[t], h])           # [x_t, h_{t-1}]
    f = sigmoid(xh @ Wf + bf)                # 遗忘门
    i = sigmoid(xh @ Wi + bi)                # 输入门
    o = sigmoid(xh @ Wo + bo)                # 输出门
    g = np.tanh(xh @ Wg + bg)                # 候选记忆
    c = f * c + i * g                        # 细胞状态：乘性保留 + 乘性写入
    h = o * np.tanh(c)                       # 隐藏状态
    if t in (0, 4, 9):
        print(f"t={t}  f={f.mean():.4f} i={i.mean():.4f} o={o.mean():.4f} "
              f"g={g.mean():.4f} |c|={np.linalg.norm(c):.4f} |h|={np.linalg.norm(h):.4f}")
```

输出：

```text
t=0  f=0.7196 i=0.5081 o=0.4642 g=-0.2705 |c|=0.5566 |h|=0.2746
t=4  f=0.7039 i=0.5160 o=0.4976 g=-0.1511 |c|=1.0533 |h|=0.5091
t=9  f=0.7390 i=0.5375 o=0.5267 g=-0.2015 |c|=0.5634 |h|=0.2670
```

对门激活值的解读：

- 遗忘门均值在 $0.70$ 至 $0.74$ 之间，高于无偏置时的 $0.5$，原因是 $\mathbf{b}_f=1$ 使 $\sigma(1)=0.731$ 成为初始中心。若把 $\mathbf{b}_f$ 改为 $-1$，均值会降到 $0.27$ 附近，细胞状态在每一步被清除约七成，长期记忆无法形成。
- 输入门均值约 $0.52$，输出门均值约 $0.50$，说明随机初始化的网络对写入与读出都没有明显偏好。训练后通常可以观察到输出门在「需要输出」的时刻升高、在「只需存储」的时刻降低。
- $|\mathbf{c}|$ 从 $0.5566$ 上升到 $1.0533$ 再回落到 $0.5634$，量级保持在 $1$ 附近，未出现无界增长。这是加法更新加门控的结果：若去掉遗忘门（$f\equiv1$），$\mathbf{c}_t$ 变为累加和 $\sum_{k\le t}\mathbf{i}_k\odot\mathbf{g}_k$，不再有逐项衰减，范数随步数按随机游走的量级增长，门控对状态的稳定作用随之消失。
- 隐藏状态范数始终小于细胞状态范数，因为 $\mathbf{h}_t=\mathbf{o}_t\odot\tanh(\mathbf{c}_t)$ 的每个分量都被 $o_i\cdot\tanh(c_i)$ 压缩。

### 门激活值的观察方法

`nn.LSTM` 只返回输出、$\mathbf{h}_n$、$\mathbf{c}_n$，不暴露逐步的门激活。需要观察门时，可用 `nn.LSTMCell` 按时间步手动展开，并按 PyTorch 的权值顺序切片。PyTorch 把四个门按 $i,f,g,o$ 的顺序拼接，这一顺序必须与切片对应：

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

torch.manual_seed(0)
D, H = 8, 32
cell = nn.LSTMCell(D, H)
x = torch.randn(4, 20, D)                     # 批 4、长度 20
h = torch.zeros(4, H)
c = torch.zeros(4, H)

w_ih, w_hh = cell.weight_ih, cell.weight_hh   # (4H, D) 与 (4H, H)
bias = cell.bias_ih + cell.bias_hh            # 两个偏置相加等价于一个偏置

with torch.no_grad():
    for t in range(x.shape[1]):
        gates = torch.sigmoid(x[:, t, :] @ w_ih.T + h @ w_hh.T + bias)
        i, f, g, o = gates.chunk(4, dim=1)     # 顺序为 i, f, g, o
        c = f * c + i * torch.tanh(g)
        h = o * torch.tanh(c)
        if t in (0, 9, 19):
            print(f"t={t:2d}  f={f.mean():.3f}  i={i.mean():.3f}  "
                  f"o={o.mean():.3f}  |c|={c.norm(dim=1).mean():.3f}")
```

未训练的单元其偏置为 $U(-1/\sqrt{32},1/\sqrt{32})$ 的小随机数，三个门的均值都在 $0.5$ 附近，$|\mathbf{c}|$ 随步数增加后趋于平稳。训练后的典型变化是遗忘门均值上升、输出门均值随任务结构分化。若某个单元的门长期饱和在 $0$ 或 $1$，该单元不再传递梯度，属于门饱和现象，可减小初始化尺度或增加遗忘门偏置。

### PyTorch nn.LSTM 在序列分类任务上训练

任务要求跨 $19$ 步保留一个比特：标签只由序列第 $0$ 步的第 $0$ 维符号决定，其余位置为噪声。

```python
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

torch.manual_seed(0)
T, D, N = 20, 8, 4096


def make_data(n, seed):
    g = torch.Generator().manual_seed(seed)
    x = torch.randn(n, T, D, generator=g)
    return x, (x[:, 0, 0] > 0).long()          # 标签只由第 0 步决定


x_tr, y_tr = make_data(N, 1)
x_te, y_te = make_data(1024, 2)


class LSTMClassifier(nn.Module):
    def __init__(self, d_in, hidden=32, n_class=2):
        super().__init__()
        self.lstm = nn.LSTM(d_in, hidden, num_layers=1, batch_first=True)
        self.head = nn.Linear(hidden, n_class)

    def forward(self, x):
        out, (h_n, c_n) = self.lstm(x)         # out: (N, T, H)
        return self.head(out[:, -1, :])        # 取最后时刻的隐藏状态


model = LSTMClassifier(D)
opt = torch.optim.Adam(model.parameters(), lr=1e-2)
loss_fn = nn.CrossEntropyLoss()
loader = DataLoader(TensorDataset(x_tr, y_tr), batch_size=64, shuffle=True)

for epoch in range(10):
    model.train()
    for xb, yb in loader:
        opt.zero_grad()
        loss = loss_fn(model(xb), yb)
        loss.backward()
        nn.utils.clip_grad_norm_(model.parameters(), 5.0)
        opt.step()
    model.eval()
    with torch.no_grad():
        pred = model(x_te).argmax(dim=1)
        acc = (pred == y_te).float().mean().item()
    print(f"epoch {epoch + 1:2d}  loss {loss.item():.4f}  test acc {acc:.4f}")
```

输出结构为每行一个 epoch 的损失与测试准确率。可核对的量级：初始损失接近 $\ln2=0.693$；标签完全由第 $0$ 步决定，正确率的上限为 $1.0$，通常在 $5$ 至 $10$ 个 epoch 内升到 $0.99$ 以上，最终达到 $1.0000$。若准确率长期停在 $0.5$ 附近，说明模型没有把第 $0$ 步的信息传到末端，应先检查取状态的索引是否正确，再把 `hidden` 调大后重试。

同一任务上把 `nn.LSTM` 换成 `nn.RNN` 并保持其他设置不变，通常会观察到收敛更慢或最终准确率更低，因为 $20$ 步的矩阵连乘使第 $0$ 步的梯度被压缩；这是第 4 小节分析的直接体现。该对比受初始化与随机种子影响，应固定种子后重复数次再作结论。

### 参数量核对

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

for cls, d, h in [(nn.RNN, 8, 16), (nn.LSTM, 8, 16), (nn.GRU, 8, 16)]:
    m = cls(d, h)
    print(cls.__name__, sum(p.numel() for p in m.parameters()),
          "数学形式", (4 if cls is nn.LSTM else 3 if cls is nn.GRU else 1) * h * (d + h + 1))
```

输出：

```text
RNN 416 数学形式 400
LSTM 1664 数学形式 1600
GRU 1248 数学形式 1200
```

差值 $16$、$64$、$48$ 分别等于 $m$、$4m$、$3m$，来源是 PyTorch 为每个门各存 `bias_ih` 与 `bias_hh` 两份偏置。

## 易错点

> [!warning] 常见错误
> - 门顺序写错。PyTorch 的 LSTM 权值按 $i,f,g,o$ 排列，用 `chunk(4)` 后若按 $f,i,g,o$ 解包，遗忘门与输入门被交换，模型仍可训练但收敛显著变慢，且门激活分析全部失效。用 `nn.LSTMCell` 手写时尤其容易发生，应按官方文档确认顺序。
> - 混淆 $\mathbf{h}_t$ 与 $\mathbf{c}_t$。把 $\mathbf{c}_t$ 直接作为层输出传给下一层或分类头，会绕开输出门与 $\tanh$，数值范围超出 $(-1,1)$；把 $\mathbf{h}_t$ 当作细胞状态参与下一时刻的乘法更新，则丢失长期存储通路。LSTM 的状态是二元组，初始状态也必须成对给出。
> - 更新顺序错误。若先算 $\mathbf{h}_t$ 再用新的 $\mathbf{h}_t$ 计算门，等于把当前输出反馈到当前门，违反递推定义；正确顺序是用 $\mathbf{h}_{t-1}$ 算四个门，再更新 $\mathbf{c}_t$，最后由 $\mathbf{c}_t$ 读出 $\mathbf{h}_t$。另需注意 $\mathbf{h}_t=\mathbf{o}_t\odot\tanh(\mathbf{c}_t)$ 中的 $\tanh$ 不可省略，省略后 $\mathbf{h}_t$ 无界。
> - 初始状态形状与方向数错误。`nn.LSTM` 要求 `h0` 与 `c0` 都是 $(D_{\text{layers}}\times D_{\text{directions}},\,N,\,H)$。双向时第一维为 $2L$，只给 $L$ 会报维度错误；把 `c0` 漏传入时 PyTorch 默认全零，程序不报错但自定义初始化被静默忽略。与 `batch_first` 无关，状态形状的第一维始终是层数与方向数的乘积。
> - 截断 BPTT 只 detach 隐藏状态。LSTM 返回 $(\mathbf{h}_n,\mathbf{c}_n)$，两者都要 `.detach()` 才能切断跨段计算图；只 detach 其中一个仍会使图跨段增长。段间保留数值、切断梯度是截断的定义，两者不可只做一半。
> - 参数量按无偏置公式估算。用 $4m(m+d)$ 估算会漏掉全部偏置项，与 PyTorch 实现相差 $8m$；用数学形式的一个偏置估算会与 PyTorch 实现相差 $4m$，因为框架为每个门存两份偏置。核对规模应以参数迭代求和为准。

## 关联笔记

- 前置：[[循环神经网络RNN]] —— 递推式、展开图与 BPTT 的求和形式是理解门控结构的前提，本篇第 1 小节的连乘分析直接来自该篇。
- 前置：[[反向传播详解]] —— 链式法则与雅可比连乘提供了 $\partial\mathbf{c}_T/\partial\mathbf{c}_t$ 的推导工具，门控只改变雅可比的结构，不改变反向传播算法。
- 后续：[[从RNN到注意力机制]] —— 注意力取消了跨时间的递推，把任意两步之间的路径长度降为 $1$，与本篇的对角通路形成对照。
- 对照：[[激活函数]] —— sigmoid 的导数上界 $0.25$ 与 tanh 的饱和区共同决定门控的有效范围，门饱和问题需要结合两者的性质分析。
- 对照：[[优化器与学习率]] —— 门控网络的梯度尺度差异大，学习率预热、梯度裁剪与自适应优化器的选择对该结构的训练稳定性影响明显。

## 达标检测

- [ ] 写出 LSTM 的六个公式，标注每个张量的形状，并说明若把四个权值矩阵合并为一个 $4m\times(m+d)$ 矩阵，切分顺序与各门如何对应。
- [ ] 推导 $\partial\mathbf{c}_t/\partial\mathbf{c}_{t-1}$ 的主对角项，写出完整导数中另外三项的来源，并解释为何说 LSTM 缓解而非消除梯度消失。
- [ ] 计算 $d=8$、$m=16$ 时 RNN、LSTM、GRU 的参数量（数学形式与 PyTorch 实现两种口径），说明两者差值的来源。
- [ ] 运行 NumPy LSTM 单元代码，报告 $t=9$ 时三个门的均值，把 $\mathbf{b}_f$ 由 $1$ 改为 $-1$ 后重跑，解释 $|\mathbf{c}|$ 曲线的变化。
- [ ] 写出 GRU 的四个公式，说明 $\mathbf{r}_t$ 与 $\mathbf{z}_t$ 分别控制什么，并解释为什么 GRU 的保留系数是 $1-\mathbf{z}_t$ 而不是 $\mathbf{z}_t$。
- [ ] 指出门顺序切片错误、$\mathbf{c}_t$ 与 $\mathbf{h}_t$ 混用、截断 BPTT 只 detach $\mathbf{h}$ 三处错误各自会导致的现象，并说明哪一处不会报错但会静默改变模型行为。

## 参考来源

- Goodfellow, Bengio, Courville, *Deep Learning*, 2016, 第 10 章「Sequence Modeling: Recurrent and Recursive Nets」中的 LSTM 与门控 RNN 小节 —— 对应本篇细胞状态、三个门的公式，以及加法更新对梯度通路的分析。
- d2l.ai《动手学深度学习》，第 9 章「现代循环神经网络」 —— 对应 LSTM 与 GRU 的从零实现、门控的数值示例与参数量对照。
- Stanford CS224n 课程讲义，Recurrent Neural Networks and Language Models —— 对应 RNN 到 LSTM 的动机推导与门控结构的教学讲解。
- PyTorch 官方文档，`torch.nn.LSTM`、`torch.nn.GRU`、`torch.nn.LSTMCell` —— 对应门权值的排列顺序、`bias_ih` 与 `bias_hh` 的双偏置约定、状态张量形状与 `batch_first` 语义。
- Colah, *Understanding LSTM Networks*, 2015, https://colah.github.io/posts/2015-08-Understanding-LSTMs/ —— 延伸阅读，对应门控流程的图示与逐步展开的叙述；本篇不采用该文中的比喻，公式与梯度分析以本篇推导为准。
