循环神经网络：RNN → LSTM → GRU

本章对应课件：《1.5 循环神经网络》。核心内容：RNN 的隐藏状态与参数共享、长程依赖问题、LSTM 三门一状态、GRU、Deep RNN，以及为什么 Transformer 最终取代了 RNN。

5.1 为什么需要 RNN

普通 MLP 的输入是固定长度的向量；但文本、语音、时间序列都是变长序列：

我 / 今天 / 非常 / 开心

而且顺序至关重要：

狗 咬 人   ≠   人 咬 狗

所以 RNN 引入 hidden state（隐藏状态） $h_t$：

当前状态由两部分决定：

• 当前输入 $x_t$；
• 过去的记忆 $h_{t-1}$。

$\phi$ 通常是 tanh。展开来看：

x₁ → h₁ → x₂ → h₂ → x₃ → h₃

5.2 参数共享：RNN 最重要的设计 ★

不同时间步不是用 $W_1, W_2, W_3, \ldots$，而是同一个 $W$ 反复使用：

否则序列长度 100 就要 100 套参数——不仅参数量爆炸，短序列上学的模式也无法迁移到长序列。

import torch, torch.nn as nn

rnn = nn.RNN(input_size=4, hidden_size=8, batch_first=True)
x = torch.randn(3, 5, 4)          # [batch=3, seq_len=5, d_in=4]
h0 = torch.zeros(1, 3, 8)         # 初始隐藏状态 [num_layers, batch, hidden]

out, hn = rnn(x, h0)
print(out.shape)   # [3, 5, 8]  每个时间步的隐藏状态
print(hn.shape)    # [1, 3, 8]  最后一个时间步的隐藏状态

5.3 RNN 的任务类型

机器翻译（many-to-many，长度可不同）：

I love you  →  我 爱 你

序列标注：

小明 / 去 / 北京
PER    O   LOC

5.4 长程依赖：RNN 的致命问题 ★

看这个例子：

我出生在法国……（中间隔了 100 个 token）……所以我会说流利的 ____。

模型需要记住 100 步前的「法国」。但普通 RNN 的梯度在时间维度连续相乘：

如果每个 $\frac{\partial h_t}{\partial h_{t-1}}$ 的谱半径小于 1，连乘 100 次后梯度趋近 0——梯度消失；大于 1 则爆炸。这与第 4 章深层网络的梯度问题同源，只是「深度」变成了时间步数。

5.5 LSTM：门控与 Cell State ★

LSTM 有两个核心状态：

• $h_t$：hidden state（对外输出）；
• $C_t$：cell state（长期记忆）。

可以把 $C_t$ 理解为长期记忆高速公路。三个门都用 sigmoid（输出 0~1）控制信息流量。

逐项拆解：四个门与两个状态

注意：门用 sigmoid（01 的开关），内容用 tanh（−11 的信号）——这个分工是 LSTM 的设计核心。

最小数字例子（单维标量）

设 $C_{t-1} = 0.8$，$\tilde C_t = 1.0$，$f_t = 0.7$，$i_t = 0.4$，$o_t = 0.5$：

记忆更新：

含义：旧记忆保留了 70%（0.56），新记忆写入了 0.40，最终记忆 0.96。

输出：

如果 $f_t = 0.1$（几乎遗忘）：$C_t = 0.08 + 0.4 = 0.48$，记忆大幅刷新；如果 $i_t = 0$（拒绝新信息）：$C_t = 0.56$，完全靠旧记忆维持。

遗忘门（Forget Gate）

因为 sigmoid，$f_t \in (0,1)$：

• $f_t = 0$：旧记忆忘掉；
• $f_t = 1$：完整保留。

所以 $f_t \odot C_{t-1}$ 决定保留多少过去的信息（$\odot$ 是逐元素相乘，element-wise multiplication：两个同形状向量对应位置相乘）。

输入门（Input Gate）

候选记忆（用 tanh 产生 −1~1 的内容）：

$i_t \odot \tilde C_t$ 表示新信息写入多少。

核心公式（必须理解，不要死背）

• 第一部分 $f_t \odot C_{t-1}$：保留旧记忆；
• 第二部分 $i_t \odot \tilde C_t$：写入新记忆。

新记忆 = 旧记忆剩下的 + 新写进去的。

输出门（Output Gate）

cell state 里有很多信息，但到底哪些暴露给当前输出，由 output gate 控制。

lstm = nn.LSTM(input_size=4, hidden_size=8, batch_first=True)
x = torch.randn(3, 5, 4)             # [B, S, d_in]
h0 = torch.zeros(1, 3, 8)
c0 = torch.zeros(1, 3, 8)
out, (hn, cn) = lstm(x, (h0, c0))    # 两个状态都要传

# 手写一个 LSTM cell（理解用）：
def lstm_cell(x, h, c, Wf, Wi, Wc, Wo, Uf, Ui, Uc, Uo):
    f = torch.sigmoid(x @ Wf + h @ Uf)      # 遗忘门
    i = torch.sigmoid(x @ Wi + h @ Ui)      # 输入门
    cc = torch.tanh(x @ Wc + h @ Uc)        # 候选记忆
    o = torch.sigmoid(x @ Wo + h @ Uo)      # 输出门
    c_new = f * c + i * cc                  # 记忆更新（加法！）
    h_new = o * torch.tanh(c_new)
    return h_new, c_new

5.6 GRU：更轻的 LSTM

GRU 的方程：

重置门（决定计算新内容时看不看历史）：

更新门（决定新旧状态混合比例）：

候选状态：

最终状态（旧状态和新状态的加权混合）：

直觉：

• $r_t$：计算新内容时，要不要看以前；
• $z_t$：旧状态和新状态到底混多少（$z_t = 1$ 完全保留旧的，$z_t = 0$ 完全用新的）。

最小数字例子（二维向量）

设 $z_t = 0.6$，$h_{t-1} = [1, 2]$，$\tilde h_t = [3, 4]$：

$z_t = 0.6$ 表示「保留 60% 旧状态 + 40% 新候选」；如果 $z_t = 1$，状态完全不变（记忆锁死）；如果 $z_t = 0$，完全换成新候选（立即刷新）。

gru = nn.GRU(input_size=4, hidden_size=8, batch_first=True)
x = torch.randn(3, 5, 4)
h0 = torch.zeros(1, 3, 8)
out, hn = gru(x, h0)   # 只有 h，没有 c

5.7 Deep RNN 与双向 RNN

普通 RNN 只有时间维：

t₁ → t₂ → t₃ → t₄

Deep RNN 还有网络深度：

Layer 3
  ↑
Layer 2
  ↑
Layer 1

两个方向同时存在：

• 横向：时间依赖；
• 纵向：层间表示。

双向 RNN（BiRNN）：一个从左到右读，一个从右到左读，两个方向的 $h_t$ 拼接。适合「理解」类任务（如 BERT 的前身思想），不适合自回归生成（生成时看不到未来）。

5.8 为什么 Transformer 取代了 RNN

RNN 的串行结构：

t₁ → t₂ → t₃ → ⋯ → tₙ

三个致命问题：

Transformer 的对比：

• 所有 token 同时参与计算（矩阵乘法天然并行）；
• 任意两个位置的信息交换只需 1 层（Attention 直接连接）；
• 训练可以用海量数据并行加速。

代价：Attention 的计算复杂度是 $O(S^2)$（序列长度平方），所以后来有各种高效 Attention 变体。这个 trade-off 是理解现代 LLM 的重要背景。