1700 字

9 分钟

梯度消失与长短时记忆网络

2026-04-21

Deep Learning

深度学习

/

RNN

/

LSTM

/

梯度消失

梯度消失与长短时记忆网络#

1. RNN 的梯度消失回顾#

RNN 反向传播时，梯度需要沿时间步传递：

$\frac{\partial L}{\partial h_0} = \frac{\partial L}{\partial h_T} \prod_{t=1}^{T} \frac{\partial h_t}{\partial h_{t-1}}$

每步都要乘以 $W_h^T \cdot \text{diag}(\tanh'(z_t))$ 。由于 $\tanh'$ 最大值为 1，长序列下梯度指数衰减，早期时间步几乎得不到更新。

1.5 梯度爆炸：与梯度消失相反的危机#

梯度消失是梯度太小，梯度爆炸则是梯度太大。当 $W_h$ 的特征值大于 1 时，每步相乘后梯度指数级增长：

$\frac{\partial L}{\partial h_0} \sim \lambda^T \quad (\lambda > 1 \Rightarrow \text{梯度爆炸})$

危害：参数更新幅度极大，loss 剧烈震荡甚至变成 NaN，训练直接崩溃。

解决方案：梯度裁剪（Gradient Clipping）

当梯度的范数超过阈值 $\theta$ 时，等比例缩小：

$\mathbf{g} \leftarrow \frac{\theta}{\|\mathbf{g}\|} \mathbf{g} \quad \text{当 } \|\mathbf{g}\| > \theta$

类比：给油门加一个限速器——踩再猛也不会超速，但方向不变。

	梯度消失	梯度爆炸
原因	$\\|\lambda\\| < 1$ ，梯度指数衰减	$\\|\lambda\\| > 1$ ，梯度指数增长
症状	早期层参数不更新，模型学不到长程依赖	loss 震荡或 NaN，训练崩溃
解决	LSTM/GRU 门控机制	梯度裁剪

2. LSTM：用”门”控制记忆#

类比：LSTM 就像一个有三道闸门的水库——遗忘门决定放掉多少旧水，输入门决定注入多少新水，输出门决定放出多少水供下游使用。水库里的水就是细胞状态 $C_t$ ，是跨时间步传递长期记忆的”主干道”。

2.1 LSTM 四个核心计算#

$f_t = \sigma(W_f [h_{t-1}, x_t] + b_f) \quad \text{（遗忘门）}$ $i_t = \sigma(W_i [h_{t-1}, x_t] + b_i) \quad \text{（输入门）}$ $\tilde{C}_t = \tanh(W_C [h_{t-1}, x_t] + b_C) \quad \text{（候选记忆）}$ $o_t = \sigma(W_o [h_{t-1}, x_t] + b_o) \quad \text{（输出门）}$

细胞状态更新：

$C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C}_t$ $h_t = o_t \odot \tanh(C_t)$

其中 $\odot$ ¹ 表示逐元素乘法（Hadamard 积）， $\tilde{C}_t$ ² 为候选记忆。 核心数据³ 三个“阀门”⁴ 数学符号与参数⁵

2.2 为什么 LSTM 能缓解梯度消失？#

细胞状态 $C_t$ 的更新是加法而非乘法：

$C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C}_t$

梯度通过加法路径传回时，关键梯度项为：

$\frac{\partial C_t}{\partial C_{t-1}} = f_t$

只要遗忘门 $f_t$ 接近 1（网络选择”记住”），梯度就能无衰减地传回早期时间步，从而保持梯度流动。

3. 代码实现#

1
import micropip
2
await micropip.install("numpy")  # 仅适用于 Obsidian Code Emitter (Pyodide) 环境
3
import numpy as np
4

5
def sigmoid(z): return 1 / (1 + np.exp(-z))
6

7
def lstm_step(x_t, h_prev, C_prev, params):
8
    Wf, Wi, WC, Wo, bf, bi, bC, bo = params
9
    concat = np.concatenate([h_prev, x_t])  # 拼接隐藏状态和输入
10

11
    f = sigmoid(Wf @ concat + bf)           # 遗忘门
12
    i = sigmoid(Wi @ concat + bi)           # 输入门
13
    C_tilde = np.tanh(WC @ concat + bC)     # 候选记忆
14
    o = sigmoid(Wo @ concat + bo)           # 输出门
15

16
    C = f * C_prev + i * C_tilde            # 更新细胞状态
17
    h = o * np.tanh(C)                      # 更新隐藏状态
18
    return h, C
19

20
# 初始化参数
21
hidden, input_size = 16, 8
22
concat_size = hidden + input_size
23
params = [
24
    np.random.randn(hidden, concat_size) * 0.01,  # Wf
25
    np.random.randn(hidden, concat_size) * 0.01,  # Wi
26
    np.random.randn(hidden, concat_size) * 0.01,  # WC
27
    np.random.randn(hidden, concat_size) * 0.01,  # Wo
28
    np.zeros(hidden), np.zeros(hidden),            # bf, bi
29
    np.zeros(hidden), np.zeros(hidden),            # bC, bo
30
]
31

32
h, C = np.zeros(hidden), np.zeros(hidden)
33
for t in range(10):  # 序列长度10
34
    x_t = np.random.randn(input_size)
35
    h, C = lstm_step(x_t, h, C, params)
36

37
print("最终隐藏状态:", h.shape)
38
print("最终细胞状态:", C.shape)

4. LSTM vs GRU#

GRU⁶ 是 LSTM 的简化版，将遗忘门和输入门合并为更新门，参数更少，训练更快。

对比项	LSTM	GRU
门数量	3（遗忘、输入、输出）	2（更新、重置）
参数量	较多	较少（约 LSTM 的 3/4）
性能	长序列略优	短序列相当甚至更好
计算速度	较慢	较快

实践中两者差异不大，优先尝试 GRU（更快），若效果不足再换 LSTM。

GRU 核心公式#

$z_t = \sigma(W_z [h_{t-1}, x_t] + b_z) \quad \text{（更新门）}$ $r_t = \sigma(W_r [h_{t-1}, x_t] + b_r) \quad \text{（重置门）}$ $\tilde{h}_t = \tanh(W_h [r_t \odot h_{t-1}, x_t] + b_h) \quad \text{（候选隐藏状态）}$ $h_t = (1 - z_t) \odot h_{t-1} + z_t \odot \tilde{h}_t$

更新门 $z_t$ 同时控制”遗忘多少旧状态”和”写入多少新状态”，相当于 LSTM 遗忘门和输入门的合并。