第 14 章 · 经典网络结构

RNN 与 LSTM

CNN 专治图像。可另一类数据——一句话、一段语音、一串股价——是有先后顺序的 序列,要处理它,得能“记住前面”。这一章认识第二位专才: RNN(循环神经网络)和它的升级版 LSTM,并看清它们的先天短板—— 这正是下一部分注意力要来救的场。

1. 序列:顺序很重要,还得记住前文

“狗咬人”和“人咬狗”用的字一样,顺序不同意思就反了;要判断“它太重了”里的“它”指谁,得回看前文。 这类数据有两个特点:长度不固定、元素间有顺序和依赖。固定大小的 MLP(第 3 章)一次只吃固定长度、 还把顺序信息丢了,天然不适合。我们需要一种能“边读边记”的结构。

2. RNN:一个带“隐藏状态”的循环

RNN 的想法非常像人读句子:一个词一个词地读,每读一个,就把“到目前为止记住的东西” 打包成一个向量,叫隐藏状态(hidden state),带到下一步。读下一个词时,它同时看两样东西: 这个新词 + 上一步传来的隐藏状态,更新出新的隐藏状态。

一步里到底吃什么、吐什么?

如果把 RNN 看成“主干 + 输出头”,那在第 t 步里,主干真正吃进去的是两样东西: 当前输入 x_t 和上一刻记忆 h_t−1;真正一路往后传的,是新的隐藏状态 h_t。如果任务是“猜下一个词”,再在 h_t 上接一个线性层 + softmax, 就得到这一步的输出概率 ŷ_t。

input_sequence[i][token_id] = 1.0;                 1
rnn_.Forward(input_sequence, hidden_sequence);    2

logits[pos][token_id] = output_bias_[token_id];
logits[pos][token_id] += output_weight_[token_id][dim] *
                         hidden_sequence[pos][dim];   3
auto probs = Softmax(logits[pos]);                    4

抓住一个最重要的区分就够了: RNN 主干负责维护“记忆” h,而输出头负责把这份记忆翻译成具体任务的答案。 做语言模型时,几乎每一步都接输出头去猜下一个词;做句子分类时,常常只拿最后一步的 h_T 去做一次判断。

3. 这个 RNN 语言模型怎么训练、怎么推理?

§2 讲清了“单步里怎么算一个新的隐藏状态”。可真正跑起来时,模型吃进去的不是单独一个 x_t, 而是一整段前缀序列;吐出来的也不是一个数,而是每个时间步各一份“下一个词概率”。 先把这座最小 RNN 语言模型的全貌看清,再去拆训练和推理就容易很多。

① 先看清整座网络

EncodeTokenIds(token_ids, input_sequence);         1
rnn_.Forward(input_sequence, hidden_sequence);    2

for (pos : 0..T)
  logits[pos] = W_o · hidden_sequence[pos] + b_o; 3
// 之后: Softmax(logits[pos]) 得到 ŷ_t             4

② 训练时的任务:每一步猜“下一个词”

拿句子「我 / 喜欢 / 深度 / 学习」当训练样本。RNN 从左到右读,读到第 t 个词时, 手里握着隐藏状态 h_t(“到目前为止的理解”),再接一个小头 输出层去预测下一个词是谁:

每个词先变成向量 x_t(第 15 章的 embedding 或 one-hot 再乘矩阵), 再喂进 RNN。输出层通常是线性层 + Softmax(第 4 章), 在词表上给出概率分布 ŷ_t。

③ 前向:按时推进,并把中间结果存下来

一条样本的训练步,前向可以写成下面这个循环——和第 3 章前向一样,只是“层”换成了“时间步”:

1. 初始化:h₀ 常设为全 0,或学一个可训练的初始向量。
2. 对每个时间步 t = 1 … T:
   • 用 §2 的式子算 h_t = 激活( W_x·x_t + W_h·h_t−1 + b );
   • 用输出层算 ŷ_t = Softmax( W_o·h_t + b_o );
   • 把 h_t、x_t、ŷ_t 存进缓存——反向时要靠它们(第 6 章存 z 是同一道理)。

展开后,RNN 就像一条有 T 段的深链:每段结构相同,共用同一套 W_x、W_h、b。 第 t 步必须等第 t−1 步的 h 算完,所以前向天然串行——这也是后面“没法并行”的根源。

④ 损失:每一步各算一次,再汇总

第 t 步的预测 ŷ_t 和真实下一个词 y_t 比,用 交叉熵(第 4 章)打分。整句的损失通常是各步之和或平均:

不同任务只是在“哪几步算损失、输出头接在哪”上换一下:

position_targets[i] = sample[i + 1];               1
position_targets.back() = target_tokens[sample_idx];

rnn_.Forward(input_sequence, hidden_sequence);     2
for (int t = 0; t < seq_len; t++) {
  probs = Softmax(logits_t);
  loss += -log(probs[position_targets[t]]);        3
  grad_logits[target] -= 1.0;
}
rnn_.Backward(grad_hidden, grad_inputs);           4
rnn_.ApplyGradient(lr);                            5

⑤ 反向:BPTT 与“同一套权重,梯度要相加”

损失 L 对参数求导,还是第 6 章反向传播的三步: 从输出层误差出发 → 沿计算图往回传 → 得到每个参数的梯度。只不过这里的“深”是沿时间展开的, 所以叫 BPTT(Backpropagation Through Time,按时间反向传播)。

和 MLP 相比,BPTT 多出来两个必须记住的点:

• 梯度要穿过“记忆连线”:h₄ 的误差会经 W_h 传到 h₃、h₂…… 每传一步都乘一次 W_h 和激活导数——乘多了就消失或爆炸(下一节 §4)。
• 同一套权重,各步梯度要相加:W_h 在每一步都被复用, 所以 ∂L/∂W_h = Σ_t (∂L_t/∂W_h), W_x、b 同理。实现上就是:从最后一个时间步往前循环,每步算出局部梯度,累加到同一块参数上。

反传结束后,用第 5 章的优化器(常配合第 8 章的 Adam) 按学习率更新 W_x、W_h、W_o 等——和全连接网络没有本质区别。

⑥ 工程上绕不开的两招

• 截断 BPTT (Truncated BPTT):句子很长时,既不现实也不稳定把梯度从句末一路传回句首。 常见做法是只反传最近 K 步(例如 20~50),更早的时间步当“起点”截断。 这样省显存、减轻消失梯度,代价是更远的依赖在这一轮里学不到——LSTM 的门、后来的注意力,都是为补这块短板。
• 梯度裁剪:RNN 特别容易梯度爆炸。 反传后若全局梯度范数超过阈值,就整体缩放(第 9 章),避免一步更新把权重炸飞。

⑦ 推理:只看最后一步,再把输出接回去

推理时没有标准答案可抄,所以不会像训练那样对每一步都算损失。做法是:先把当前前缀整条跑一遍, 再只看最后一个时间步的输出,挑一个新词,把它接回输入末尾,然后整条链路再跑一遍。 这就是字符级生成、聊天模型逐字往外蹦的共同骨架。

Forward(token_ids, logits);                        1
last_logits = logits.back();                      2
token_id = argmax(last_logits);                   3

generated_token_ids.push_back(token_id);          4
// 然后带着更长的前缀,再回到第 1 步

训练和推理最大的差别就浓缩在这里: 训练时每一步都拿真实答案监督,目标是把整条序列的参数都学好; 推理时没有答案,只能相信自己刚吐出的词,因此错误会一步步累积。这也是为什么 RNN 一旦前面接错几个词, 后面就容易越写越偏。

4. 两个硬伤

正是“链条特别长 + 严格按顺序”,带来了 RNN 的两个致命短板:

5. LSTM:给记忆装上“门”

为了缓解“失忆”,LSTM(长短期记忆网络)做的第一件事,不是简单把 RNN 变深或变宽, 而是把“记忆”拆成了两条通道:一条负责把长期信息尽量稳稳往前送,一条负责向外暴露“当前这一步该输出什么”。 然后它又加上三个“门”,按需决定“旧记忆留多少、新信息写多少、这一步拿多少出来用”。

① 先分清:它其实有两份“状态”

你可以把 c_t 想成“仓库里的长期库存”,把 h_t 想成“这一步柜台上拿出来给人看的东西”。 LSTM 的精妙之处就在于:柜台上不一定把仓库全搬出来,仓库里的东西也不必每次全部重写。

② 三个门和一个“候选内容”,到底各管什么?

门不是魔法,本质上就是三个小神经层:把当前输入 x_t 和上一刻隐藏状态 h_t−1 拼起来,过一层线性变换,再过 Sigmoid 变成 0~1 之间的数。 这些数不是一个标量,而是一整条向量,和隐藏维度一样长——也就是每个记忆维度都能被单独控制。

③ 一步里到底按什么顺序更新?

上面四个量算出来后,LSTM 的核心更新只有两行,却把“保留旧记忆 + 写入新记忆 + 对外输出”全做完了:

1. 先看旧仓库要留多少:遗忘门 f_t 去乘旧记忆 c_t−1。某一维若 f≈1,这维旧记忆基本原样保留;若 f≈0,这维旧记忆基本被清掉。
2. 再看新信息要写多少:输入门 i_t 控制候选内容 g_t 写进来多少。这样“写什么”和“写多少”被拆成了两件事。
3. 两者相加,形成新记忆:于是新的细胞状态 c_t 既保留了该留的旧信息,又写入了该写的新信息。
4. 最后决定往外拿多少:输出门 o_t 再从 c_t 里筛出这一步要暴露给下一层/输出头的那部分,得到 h_t。

你可以把这四步想成一套非常朴素的流程:先清理旧档案,再把新内容写进档案,最后从档案里抽一份摘要交给当前这一步使用。

④ 为什么这样就更能记住远处?

普通 RNN 的记忆更新更像“整块重写”:每一步都要重新算一个新的 h_t,旧信息很容易在反复乘矩阵、过激活里被磨没。 LSTM 则把长期记忆那条主线改成了加法更新:

这意味着:如果模型觉得“这个信息很重要,暂时别动”,它完全可以让某些维度的 f≈1、i≈0, 于是那部分记忆几乎沿着 c 这条线原样直通。反向传播时,梯度也更容易顺着这条线传回来, 不会像普通 RNN 那样在长链上一路越乘越小。它当然不是“永不衰减”的魔法,但比每步都重写整块记忆要稳得多。

6. 承上启下:为什么 Transformer 取代了它

LSTM 缓解了“失忆”,但串行、慢这条硬伤仍在:再怎么改门,它还是得一步一步顺着读。 当数据和模型都要爆炸式放大时,“不能并行”成了无法忍受的瓶颈。

7. 对照真实代码:最小 RNN 怎么展开和回传

如果把这一章的式子落到代码,核心其实很朴素:一个 SimpleRNN 负责按时间推进隐藏状态, 一个小输出层负责“根据当前隐藏状态猜下一个词”。真正关键的,反而是把整条序列缓存下来,好让 BPTT 倒着走回来。

last_hidden_sequence_.assign(input_sequence.size() + 1,
                             std::vector<double>(hidden_dim_, 0.0));   1

for (int t = 0; t < input_sequence.size(); t++) {
  const auto &input = input_sequence[t];
  const auto &prev_hidden = last_hidden_sequence_[t];
  for (int h = 0; h < hidden_dim_; h++) {
    double sum = bias_[h];
    for (int i = 0; i < input_dim_; i++)  sum += input_weight_[h][i] * input[i];
    for (int i = 0; i < hidden_dim_; i++) sum += hidden_weight_[h][i] * prev_hidden[i];
    hidden[h] = std::tanh(sum);                                        2
  }
  last_hidden_sequence_[t + 1] = hidden;                              3
}

for (int t = grad_hidden_sequence.size() - 1; t >= 0; t--) {       1
  std::vector<double> grad_hidden_total = grad_hidden_sequence[t];
  for (int h = 0; h < hidden_dim_; h++)
    grad_hidden_total[h] += grad_from_future[h];                    2

  for (int h = 0; h < hidden_dim_; h++) {
    double dz = grad_hidden_total[h] * (1.0 - hidden[h] * hidden[h]); 3
    grad_bias_[h] += dz;
    for (int i = 0; i < input_dim_; i++)
      grad_input_weight_[h][i] += dz * input[i];
    for (int i = 0; i < hidden_dim_; i++) {
      grad_hidden_weight_[h][i] += dz * prev_hidden[i];            4
      grad_from_prev[i] += hidden_weight_[h][i] * dz;              5
    }
  }
  grad_from_future = grad_from_prev;
}

RNN 也好、注意力也好,处理文字前都得先把词变成向量。可“词”本是离散符号, 怎么变成有含义的数字?下一章讲词嵌入与 word2vec——让词第一次拥有“语义坐标”。