RNN循环神经网络
先回答一个问题:Transformer之前是RNN吗
是.在2017年《Attention Is All You Need》之前,序列建模的主流架构就是RNN家族——基础RNN、LSTM、GRU,再往上搭出Seq2Seq(编码器-解码器),后期还加了注意力机制做补丁.那篇论文标题里的”All You Need”,说的就是”不再需要RNN了”.
本篇只讲RNN本身:它为什么出现,内部怎么算,结构上有哪些变体,怎么写代码,以及它是怎么被自己的缺陷逼下历史舞台的.
为什么需要RNN
在自然语言里,词语的顺序直接决定句子的意思.”猫吃鱼”和”鱼吃猫”用的是同一批词,意思完全相反.
但词向量(Word2Vec这类)只能表示”这个词是什么意思”,它本身不包含任何顺序信息——你把它拆成一个词一个词地喂给全连接网络,模型看到的就是一个无序的词袋,句子的语序、上下文全丢了.
而且文本是变长的:一个句子3个词,一段话300个词,全连接网络没法用固定长度的输入接住任意长度的序列.
所以核心就是语序问题和变长问题.
RNN(Recurrent Neural Network,循环神经网络)就是为解决这两件事提出的:它逐个读取句子中的词,每一步都结合当前词和之前累积的上下文,不断更新对整句的理解.
注:这两个诉求其实贯穿了整个NLP历史.Transformer换掉的只是”实现方式”,这两个诉求一点没变——所以Transformer还得额外加位置编码,还得靠自回归一个词一个词地生成.
基础结构
RNN的核心结构是一个带循环连接的隐藏层,它以**时间步(time step)**为单位,依次处理输入序列中的每个token.
每个时间步做两件事:
- 接收当前token的向量 和上一个时间步的隐藏状态 ;
- 计算出新的隐藏状态 ,并把它传给下一个时间步.
隐藏状态 就是RNN的”记忆”:它是对”从句子开头到第t个词”这段信息的压缩表示.最后一个时间步的 ,就是整句的语义向量.
把循环”展开”(unroll)来看,长这样:
x₁ x₂ x₃ ... x_T
│ │ │ │
▼ ▼ ▼ ▼
h₀ ─→[ tanh ]─→[ tanh ]─→[ tanh ]─→...─→[ tanh ]─→ h_T
│ │ │ │
▼ ▼ ▼ ▼
y₁ y₂ y₃ ... y_T
图里有上下两排东西:中间一排 [ tanh ] 是隐藏状态在时间步之间的传递(也就是”记忆”),下方那排 是每个时间步的输出(预测).注意 不是RNN本体产出的,而是在 之上再接一层输出层算出来的——见下面”一个时间步的计算”.
注:同一行里的方框是同一个隐藏层在不同时间步的副本,不是T个不同的层.这正是RNN的关键设计——参数共享:所有时间步用的是同一套 、、.带来的两个好处:参数量与序列长度无关(多长的句子都是这套参数),而且能处理训练时没见过的长度.
一个时间步的计算
各量的形状(按单个样本、行向量约定):
| 符号 | 含义 | 形状 |
|---|---|---|
| 第t个token的词向量 | ||
| 输入到隐藏层的权重 | ||
| 上一时间步的隐藏状态 | ||
| 隐藏层到隐藏层的权重(记忆的搬运工) | ||
| 偏置 | ||
| 当前隐藏状态 |
可以看出:当前词通过 进来,历史信息通过 进来,两者相加再过 tanh,这就是”结合当前词和前面的上下文”.
如果任务需要每个时间步都有输出(比如序列标注、语言模型),就在 之上再接一个输出层:
就是图里下方那排 ,也就是模型在第t步给出的预测.严格说它是 logits(未归一化的分数),按任务再套激活:
- 语言模型 / 文本生成:softmax over 词表 → 下一个词的概率分布;
- 序列标注(NER、词性标注):softmax over 标签集 → 每个token的标签;
- 回归:不套激活,直接输出数值.
这些 就是拿去和真实标签算损失的东西,每个时间步的损失相加:
形状: 是 , 是 ( = 词表大小或标签数).、 和隐藏层一样,也是所有时间步共享的.
注:输出层不是RNN的一部分.PyTorch 的 torch.nn.RNN 只算隐藏状态,返回的 output 就是 ,里面没有 ;y 要你自己在RNN后面接一个 nn.Linear(hidden_size, V) 算出来.所以”图的每个时间步都有 y、但API里找不到 y”并不矛盾——图是把”RNN + 输出层”一起画了,而 torch.nn.RNN 只卖前半截.
至于”是不是每个时间步都要算 “,取决于任务形态:
| 形态 | 输入 → 输出(例子) | 怎么算 |
|---|---|---|
| many-to-one | 序列 → 一个标签(文本分类、情感分析) | 只取最后一个 接输出层 |
| many-to-many(同步) | 序列 → 等长序列(序列标注、语言模型) | 每个时间步都算 |
| one-to-many | 单个向量 → 序列(图像描述、音乐生成) | 把这个向量当作初始状态 ,再逐步自回归生成 |
| many-to-many(异步) | 序列 → 不等长序列(机器翻译、文本摘要) | 单个RNN不够用,要用两个RNN(编码器 + 解码器)拼起来——后面单独讲 |
注:表格里只有 many-to-many(异步) 这一种需要额外的结构——它的输入和输出是两个长度不同的序列,单个RNN没法直接对齐,得用”编码器先把整句读完 → 解码器再逐步生成”的组合,也就是 Seq2Seq(编码器-解码器).它不属于单个RNN的形态,而是用两个RNN拼出来的架构,是后面”Seq2Seq:把两个RNN拼起来”一节会专门讲.这里先知道”还有这么一种形态、而且它需要额外的结构”就够了,不必现在展开.其余三种形态,一个RNN层就够,区别只在输出层怎么接、以及要不要把上一步的输出喂回去.
上面那张展开图画的是最通用的 many-to-many(同步),所以每个时间步都画了 .
在语言模型里, 对应的就是”下一个词”.完整链路是这样:
h_t ──Linear──→ y_t(logits,长度V) ──softmax──→ 概率分布 ──argmax/采样──→ 下一个词token
│
x_{t+1} ←── Embedding(查词向量) ←───────────────────────┘
│
▼
h_{t+1} = tanh(x_{t+1}W_x + h_t W_h + b)
三个最容易混的点:
- 本身不是词,是一个长度 的分布.”到底是哪个词”要等 argmax 或采样之后才知道,这一步叫解码(decoding),属于推理策略,不写在模型参数里.
- “把生成的词拼到序列末尾再喂回去”只发生在生成阶段,这就是自回归生成;序列标注、文本分类这类任务根本不需要回流.
- 训练时不做这件事. 训练语言模型用的是 teacher forcing:整句(如
[BOS] 我 喜欢 猫)一次性喂进去,每个位置都输出一个”下一个词的分布”,分别和真实的下一个词算交叉熵——不采样、不回流,所以一次前向就能拿到整段序列所有位置的损失;而生成时每一步都得等上一步采样出词才能继续,要调用 T 次模型(外加生成时 batch 通常为 1、还有采样开销),所以生成比训练慢得多.
注:别把”teacher forcing”理解成”时间步可以并行”. 它免掉的是”这一步的输入要等上一步的预测”这个依赖(也就是生成时的逐步解码),而不是 对 的递归依赖——所以 RNN 在训练时照样沿时间步串行计算,能并行的只有 batch 里不同样本之间(以及每个时间步内部的矩阵运算).真正把时间维并行掉的是 Transformer 的自注意力,这也是它取代 RNN 的原因之一,详见下面”从RNN到Transformer”.
还有一点:RNN 的”循环”和自回归的”循环”是两回事. 是模型内部的记忆传递,每个时间步都在发生;把预测的词拼回输入序列,只是生成阶段才有的动作.而因为 RNN 自带 ,回流时不需要重算整句,只要拿 和新词作为输入,就能推出 ——Transformer 没有这个状态,得靠 KV cache 才能达到类似效果.
注:不同教材会写成 ,和上面是同一个东西,只是转置约定不同(左乘/右乘).看论文和代码时认准形状,别被符号绕晕.
结构变体
基础RNN只是最小版本,实际用的时候会在两个维度上加结构:深度(多层)和方向(双向).
多层RNN(Stacked RNN)
把多个RNN层按层次堆叠起来,让不同层学不同层次的语义.
- 底层更容易捕捉局部模式(词组、短语);
- 高层学更抽象的语义(句子主题、语境).
各层的连接方式是:每一层的输出序列,作为下一层的输入序列.最底层接收原始输入,顶层的输出作为最终结果交给后续任务.
注:这和CNN堆卷积层的思路一致——深度换表征能力.但要小心:RNN本身梯度就难传,层数堆多了更难训,所以RNN时代的层数通常只有2~4层,和现在动辄几十层的Transformer不是一个量级.
双向RNN(Bidirectional RNN)
基础RNN在每个时间步只输出一个隐藏状态,它只包含上文信息,看不到当前词之后的下文.
这在一些任务里是硬伤.比如序列标注(给每个token打标签),判断当前词的标签往往需要同时看前后文——只看前文,准确率上不去.
双向RNN用两层RNN解决:
- 正向RNN:按时间顺序(从前到后)处理序列,得到 ;
- 反向RNN:按逆时间顺序(从后到前)处理序列,得到 .
每个时间步的输出是正反两个隐藏状态的组合(通常是拼接,也可以求和):
拼接之后维度翻倍,这也是后面PyTorch里 num_directions × hidden_size 的由来.
注:双向的代价是它不能用于自回归生成.因为生成时”后文”根本还不存在,你没法从后往前读.所以GPT这类自回归模型只能用单向,BERT这类只用编码器的模型才敢用双向.这个限制一直延续到Transformer.
多层+双向
两者可以叠加:堆多层,每层都是一个双向RNN.这是RNN时代编码器的标准配置(ELMo就是这么干的).
代价是:层数 × 方向数,计算量翻倍,而且双向结构必须等整个序列读完才能出结果,天然不适合流式/实时场景.
PyTorch API
PyTorch用 torch.nn.RNN 构建RNN层,支持多层,也能通过参数直接开启双向.
构造参数
torch.nn.RNN(
input_size,
hidden_size,
num_layers=1,
nonlinearity="tanh",
bias=True,
batch_first=False,
dropout=0.0,
bidirectional=False,
device=None,
dtype=None,
)
| 参数名 | 类型 | 说明 |
|---|---|---|
| input_size | int | 每个时间步输入特征的维度(词向量维度) |
| hidden_size | int | 隐藏状态的维度 |
| num_layers | int | RNN层数,默认1 |
| nonlinearity | str | 激活函数,'tanh'(默认)或'relu' |
| bias | bool | 是否使用偏置项,默认True |
| batch_first | bool | 输入张量是否为 (batch, seq, feature),默认False即 (seq, batch, feature) |
| dropout | float | 除最后一层外,各层之间的dropout概率 |
| bidirectional | bool | 是否双向,默认False |
| device | torch.device or str | 模块初始化设备,如 'cuda'、'cpu' |
| dtype | torch.dtype | 模块初始化的默认数据类型,如 torch.float32 |
注:batch_first 这个坑几乎人人踩过一次.PyTorch默认把序列长度放在第0维,而大家习惯的数据加载器吐出来的是 (batch, seq, feature).忘了设 batch_first=True,模型不报错,但算出来的东西完全是错的(它把batch当成了时间步).
注:nonlinearity 默认是tanh,不是ReLU.原因是tanh输出范围是 、均值接近0,能让隐藏状态在时间步之间稳定传递;换成ReLU虽然也能跑,但循环结构下更容易发散.这也是为什么后面讲梯度消失时,tanh的导数 成了主角.
输入输出
rnn = torch.nn.RNN(...)
output, h_n = rnn(input, h_0)
| 名称 | 说明 | |
|---|---|---|
| 输入 | input | 输入序列,形状 (seq_len, batch_size, input_size);若 batch_first=True 则为 (batch_size, seq_len, input_size) |
| 输入 | h_0 | 可选,初始隐藏状态,形状 (num_layers × num_directions, batch_size, hidden_size);不传默认全0 |
| 输出 | output | 最后一层每个时间步的隐藏状态,形状 (seq_len, batch_size, num_directions × hidden_size);batch_first=True 时为 (batch_size, seq_len, num_directions × hidden_size) |
| 输出 | h_n | 最后一个时间步的隐藏状态,包含每一层的每个方向,形状 (num_layers × num_directions, batch_size, hidden_size) |
三个最容易搞混的点,一次说清:
- **
output只包含最后一层.**中间层的输出要靠num_layers或手动逐层调用才能拿到,output里没有. output的最后一维是num_directions × hidden_size(双向拼接,所以翻倍),而h_n的最后一维是hidden_size(它是按层/方向分开存的,没有拼接).output[:, -1, :]和h_n[-1]在单层单向时是同一个东西;多层双向时不是——h_n带着所有层,output只有顶层.
形状维度对上了,RNN就算用明白了.
一个完整例子
import torch
batch_size, seq_len, input_size, hidden_size = 32, 10, 100, 128
# 2层、双向
rnn = torch.nn.RNN(
input_size=input_size,
hidden_size=hidden_size,
num_layers=2,
batch_first=True,
bidirectional=True,
)
x = torch.randn(batch_size, seq_len, input_size) # (32, 10, 100)
h_0 = torch.zeros(2 * 2, batch_size, hidden_size) # (num_layers*num_directions, batch, hidden)
output, h_n = rnn(x, h_0)
print(output.shape) # torch.Size([32, 10, 256]) 最后一层、双向拼接 2*128
print(h_n.shape) # torch.Size([4, 32, 128]) 2层 × 2方向
四种结构的形状对应关系:
| 结构 | output 末维 | h_n 第0维 |
|---|---|---|
| 单层单向 | hidden_size | 1 |
| 多层单向 | hidden_size | num_layers |
| 单层双向 | 2 × hidden_size | 2 |
| 多层双向 | 2 × hidden_size | num_layers × 2 |
训练:时间反向传播(BPTT)
RNN的训练方式和普通网络没有本质区别,还是前向 → 算损失 → 反向传播 → 更新参数.唯一特殊的是:因为参数在时间维度上被共享了,梯度必须沿着时间步一路链式回传,这种方法叫时间反向传播(Backpropagation Through Time, BPTT).
一句话概括:把展开后的T个时间步看成一个T层的网络,对它做普通的反向传播——只不过这T层共享同一套权重,所以各时间步算出的梯度要累加到同一组参数上:
如果任务要求每个时间步都有输出(比如”每个词预测下一个词”),损失也是各时间步损失之和:
**问题恰恰出在这个”连乘+累加”上.**下面展开看.
致命问题:学不会长期依赖
RNN在实战中最严重的问题是长期依赖建模困难:当输入序列很长时,模型很难学到”序列早期的输入”对”最终输出”的影响.
举个例子:句子开头说”我出生在法国……“,隔了三十个词之后要预测”我说一口流利的____”.人知道该填”法语”,但RNN填不出来——因为三十步之前的信息,在梯度里已经衰减没了.
为什么:梯度消失与梯度爆炸
看总梯度里的早期路径那一条(以第1个时间步为例),把它沿时间展开:
= \frac{\partial L}{\partial h_T}\cdot\underbrace{\left(\prod_{k=2}^{T}\frac{\partial h_k}{\partial h_{k-1}}\right)}_{\text{一连串连乘}}\cdot\frac{\partial h_1}{\partial W_h}$$ 而其中每一环(为了看清结构,按标量推导): $$h_t = \tanh(u_t),\qquad u_t = x_tW_x + h_{t-1}W_h + b$$ $$\frac{\partial h_t}{\partial h_{t-1}} = \tanh'(u_t)\cdot W_h$$ 代回去,早期路径的展开就变成了: $$\frac{\partial L}{\partial h_1}\cdot\frac{\partial h_1}{\partial W_h} = \frac{\partial L}{\partial h_T}\cdot\tanh'(u_T)W_h\cdot\tanh'(u_{T-1})W_h\cdots\tanh'(u_2)W_h\cdot\frac{\partial h_1}{\partial W_h}$$ **注意这里有 (T-1) 个 $\tanh'(u_t)W_h$ 在连乘.**而 $\tanh' \in (0,1]$(最大值为1,在 $u=0$ 处取到,两边迅速趋近0),所以: - 当 $\left|\tanh'(u_t)W_h\right| < 1$ 时,T-1次连乘会让早期路径的梯度**指数级衰减,迅速趋近于0**——这就是**梯度消失**; - 当 $\left|\tanh'(u_t)W_h\right| > 1$ 时,T-1次连乘会让它**指数级增长**——这就是**梯度爆炸**. ### 后果 梯度消失的后果是**结构性的**: 由于早期时间步的梯度几乎为0,总梯度 $\frac{\partial L}{\partial W_h}$ 基本上只由**最近几个时间步**决定.于是在更新参数时: $$W_h \leftarrow W_h - \eta\cdot\frac{\partial L}{\partial W_h}$$ **早期输入的信息对 $W_h$ 的更新几乎没有贡献.**模型于是只能学到短期依赖(最近几个词的关系),学不到长期依赖(隔了几十步的依赖).这不是"训练不够久"能解决的问题,是**结构本身**决定的. 梯度爆炸的后果不同:它会让参数更新极不稳定,loss直接飞掉(NaN).但它相对好治——**梯度裁剪(gradient clipping)**就能压住: ```python # 训练循环里,反向传播之后、更新参数之前 torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0) optimizer.step() ``` 注:梯度裁剪是RNN时代的标配操作,现在的Transformer训练也常带着它.判断依据就是梯度的L2范数. 梯度消失则没有这种"补丁".**LSTM、GRU用门控机制(输入门/遗忘门/输出门)给梯度开了一条"高速公路",把长期依赖的建模能力提升了一大截,但并没有彻底解决**——序列一长,该衰减还是会衰减. |项目|LSTM|GRU| |---|---|---| |门数量|遗忘门、输入门、输出门(3 个)|更新门、重置门(2 个)| |状态|细胞状态Ct + 隐状态ht两套|只有隐状态ht| |参数量|更多,计算慢|更少,速度更快| |能力|长序列能力通常略强|性能接近,小数据集表现不错| ## Seq2Seq:把两个RNN拼起来 上一节那张表里最难的一种形态是**输入和输出都是序列、而且长度还不相等**的任务(机器翻译、文本摘要、问答、对话).单个RNN没法把两个长度不同的序列直接对齐,于是有了 **Seq2Seq(Sequence to Sequence,序列到序列)**: - **编码器(Encoder)**:一个RNN,依次读完整个输入序列,把隐藏状态交出去.最后一个隐藏状态 $h_T$ 就是**上下文向量(context vector)**,代表"整句的意思"; - **解码器(Decoder)**:另一个RNN,以上下文向量作为初始状态 $s_0$,配合起始标记 `<sos>` 和结束标记 `<eos>`,**自回归**地逐步生成目标序列——每一步把上一步生成的词当作这一步的输入,直到吐出 `<eos>`. ```text 编码器: 我 → 喜欢 → 你 ⇒ h₁ h₂ h₃ = 上下文向量 c │ 解码器: c → <sos> → I → like → you → <eos> 每一步把上一步的输出当作输入 ``` **它的瓶颈**:整句信息被压进**一个固定长度的向量**.句子一长,最早的信息就被后面的词冲淡了——解码器每一步都只能用这同一个向量,没有"回头看看源句某处"的权限. 注:这就是 many-to-many(异步) 的实现方式,需要**两个RNN**而不是一个.其中"自回归"和"训练/推理的差别"(训练用 teacher forcing,整句真实标签一次性喂进去算损失,不采样、不回流)前面"一个时间步的计算"一节已经讲过. ## 注意力机制:RNN时代的补丁 **注意力(Attention)比 Transformer 早出现三年(2014),而且最早就是装在RNN上的外挂.** 它的核心思想一句话:**别让解码器只靠那一个固定向量,让它每生成一个词,都回头把编码器的所有隐藏状态重新看一遍.** (出处:Bahdanau 等 2014《Neural Machine Translation by Jointly Learning to Align and Translate》;Luong 等 2015《Effective Approaches to Attention-based Neural Machine Translation》.) ### 它要治什么病 就是上面那个瓶颈的症状: 1. **信息压缩困难**:固定长度的向量装不下长句或复杂语义,关键信息容易丢; 2. **缺乏动态感知**:解码器每一步都依赖**同一个** $c$,没法按当前要生成的词,有选择地取用源句的不同部分. 举个直观的:翻译"我出生在法国,所以我法语说得很流利".生成"fluent"时最需要的是很早之前那个"法国",但在原始 Seq2Seq 里它早被后面十几个词冲淡了——解码器没有回头看的权限. 注:别把"信息瓶颈"和"梯度消失"混为一谈.注意力治的是前者(解码器看不到源句细节);后者(编码器内部 $h$ 连乘衰减)**它治不了**——这也是它最终被 Transformer 取代的原因之一. ### 四步机制 | 步骤 | 做什么 | 公式 | |---|---|---| | ① 打分 | 解码器状态和**每一个**编码器输出算相关性 | $e_{ti}=\text{score}(s,h_i)$ | | ② 归一化 | 打分过 softmax,得到和为 1 的权重 | $\alpha_{ti}=\dfrac{\exp(e_{ti})}{\sum_{j=1}^{T}\exp(e_{tj})}$ | | ③ 加权求和 | 得到**这一步专用**的上下文向量 | $c_t=\sum_{i=1}^{T}\alpha_{ti}h_i$ | | ④ 融合出词 | $c_t$ 和解码器状态拼接,过线性层 + softmax | $P(y_t)=\text{softmax}\big(W_y\tanh(W_c[c_t;s_t])\big)$ | 关键在③:原始 Seq2Seq 里所有解码步共用**一个** $c$,现在变成**每一步现算一个** $c_t$.这就是"注意力"字面上的意思——模型把注意力分配在源句的不同位置上,所以它天然具备**对齐(alignment)**能力. 拿「我 喜欢 你」→「I like you」走一遍(编码器留下 $h_1,h_2,h_3$): ```text 解码第1步 → 权重 α = [0.1, 0.3, 0.6] → c₁ → 生成 "I" 解码第2步 → 权重 α = [0.6, 0.3, 0.1] → c₂ → 生成 "like" 解码第3步 → 权重 α = [0.2, 0.4, 0.4] → c₃ → 生成 "you" ↑ 每一步的权重分布都不一样 ``` (数字只是示意.)真实模型学出来的权重分布往往接近"词对齐",把它画成热力图就是当年很有名的 attention 可视化. ### $c_t$ 接在哪:进输入端,还是用在输出端 这里有两套写法,分别来自两篇论文,**别把它们混在一起看**: **Bahdanau 2014(加性)**:$c_t$ 进**输入端**,打分用**上一步**状态 $s_{t-1}$: $$e_{ti}=v_a^{\top}\tanh(W_a s_{t-1}+U_a h_i)$$ $$s_t=\text{RNN}\big(s_{t-1},\,[y_{t-1};c_t]\big)$$ 顺序是:先算 $c_t$ → 再把 $[y_{t-1};c_t]$ 喂进RNN → 得到 $s_t$. **Luong 2015(乘性)**:解码器RNN保持原样,$c_t$ 用在**输出端**,打分用**当前**状态 $s_t$: $$s_t=\text{RNN}(s_{t-1},\,y_{t-1})$$ $$e_{ti}=\text{score}(s_t,h_i),\qquad \tilde s_t=\tanh\big(W_c[c_t;s_t]\big),\qquad P(y_t)=\text{softmax}(W_s\tilde s_t)$$ 还有个变体叫 **input-feeding**:把 $\tilde s_t$ 拼进下一步的输入($[y_t;\tilde s_t]$),让注意力结果回流到递归里. 注:两份讲义式材料常把"用**当前**状态打分"(Luong)和"**Concat** 评分"(Bahdanau,实际用的是**上一步**状态)并列写在一起,读起来会觉得矛盾——它们本来就是两篇论文的两套做法,看公式里用的是 $s_{t-1}$ 还是 $s_t$ 就能分辨. ### 每一步传下去的是什么 三个量要分清: | 量 | 是什么 | 每步怎么变 | |---|---|---| | $h_1\dots h_T$ | 编码器隐藏状态,**记忆库** | 编码完就固定,解码每一步都被检索一次 | | $c_t$ | 这一步从源句取到的信息 | **每步现算**,用完就丢,不进入递归链 | | $s_t$ | 解码器隐藏状态,**已生成输出的记忆** | 递归传递的**只有它** | **传给下一步的只有 $s_t$**;下一步重新算 $c_{t+1}$.(除非用 Bahdanau 的输入拼接或 Luong 的 input-feeding,那 $c$ 才会通过影响 $s_{t+1}$ 间接进入下一步.) 初始状态 $s_0$ 仍然要有,因为解码器本身还是个RNN: ```text 写法 A(Bahdanau:$c$ 进输入端) s_{t-1} ──┬──→ 打分(s_{t-1}, h_i) → α → c_t │ │ y_{t-1} ──┴──────────────────────────────┤ ▼ s_t = RNN(s_{t-1}, [y_{t-1} ; c_t]) │ 传给下一步的只有 s_t ─────┘ ``` $s_0$ 通常取**编码器最后一步的隐藏状态**;双向编码器则把正向、反向的最后一个状态拼接后过一层 $\tanh$,投影到解码器维度($d_s\ne d_h$ 时这个投影是必须的).也可以直接用零向量或可学习的初值——因为 $c_1$ 已经把源句信息带进来了,$s_0$ 从"唯一的信息通道"降级成了"一个起点". 另外注意两种写法里 $s_0$ 的参与程度不同:**Luong 写法里 $s_0$ 只用来算 $s_1$,连打分都不参与;Bahdanau 写法里 $s_0$ 还要负责第一步"该看源句哪儿".** ### 三种评分函数 | 名称 | 公式 | 出处 | 特点 | |---|---|---|---| | Dot(点积) | $e=s_t^{\top}h_i$ | Luong 2015 | 最简单,要求两边维度相同 | | General(通用点积) | $e=s_t^{\top}W h_i$ | Luong 2015 | 加一个可学习矩阵 $W$,解决编解码维度不一致 | | Concat(拼接) | $e=v^{\top}\tanh(W_s s_t+W_h h_i)$ | Bahdanau 2014 | 带非线性,表达力最强、参数最多 | 三种本质都一样:衡量解码器状态与编码器各步状态的相关性,内积越大越相关——和 Transformer 里那套算法是同一个内核. ### 和Transformer的关系:先把QKV对上看 Transformer 里的 Query / Key / Value,在RNN + 注意力里**已经有雏形了**,只是当年不这么叫: | QKV 角色 | RNN + 注意力里是谁 | 含义 | |---|---|---| | Query | 解码器状态 $s_t$(或 $s_{t-1}$) | "我要找什么信息" | | Key | 编码器各步 $h_i$ | "我这里有什么信息" | | Value | 同一个 $h_i$ | "匹配上就把内容给你" | 所以:**打分 = Query 和 Key 做匹配,加权求和 = 按匹配度取 Value**.Transformer 的创新在于——Q/K/V **不再由RNN生产,而是全部由输入自己线性变换得到**(自注意力),于是任意两个位置可以直接交互、整段序列可以并行计算.这也正是论文标题的意思:注意力本来只是RNN的辅助零件,那篇论文证明它**自己就够用**. ### 为什么打了补丁还是不够 1. **依然无法并行**:时间步之间强依赖,必须顺序执行,GPU喂不满,序列越长越慢; 2. **长期依赖仍是老样子**:注意力只让**解码器**能直接读到编码器的每个输出,**编码器内部**的信息传递依然靠 $h$ 一步步连乘,梯度消失照旧; 3. **额外计算**:解码器每生成一个词都要和 $T$ 个编码状态打分,每步多出 $O(T)$,总共 $O(T\cdot U)$——Transformer 的 $O(n^2)$ 种子在这里就埋下了. ### 伪代码 ```python # 编码器:每一步的隐藏状态全部保留(不再只留最后一个) h = [None] * (T + 1) for i, x in enumerate(src_tokens, 1): h[i] = rnn_enc(x, h[i - 1]) # 解码器:每一步都重新算一遍注意力(Luong 写法) s = torch.tanh(W_s(h[T])) # s0:编码器最后状态投影到解码器维度 y_prev = <sos> for t in range(1, U + 1): s = rnn_dec(y_prev, s) # ① 推进解码器状态 e = [score(s, h[i]) for i in range(1, T + 1)] # ② 打分 alpha = softmax(e) # ③ 归一化 c = sum(a * h[i] for a, i in zip(alpha, range(1, T + 1))) # ④ 加权求和 s_tilde = torch.tanh(W_c(torch.cat([c, s]))) # ⑤ 融合 y_t = softmax(W_s(s_tilde)) # ⑥ 出词 y_prev = embedding(y_t) ``` ## 从RNN到Transformer 补丁能治的都治了,剩下两条——**时间步必须串行**、**长距离依赖仍靠 $h$ 连乘**——是RNN结构本身带来的,补不掉. 2017年,Google在《Attention Is All You Need》中提出Transformer:**彻底扔掉RNN,只用注意力机制建模序列中各位置之间的关系.**好处是——任意两个位置直接建立联系(路径长度从O(T)变成O(1),长距离依赖不再靠连乘传递),以及没有时间步依赖(整个序列可以并行计算,GPU终于能跑满). | 对比项 | RNN(含LSTM/GRU) | Transformer | |---|---|---| | 序列建模方式 | 隐藏状态逐步递归传递 | 自注意力,任意位置直接交互 | | 长距离依赖路径 | O(T),需连乘,会衰减 | O(1),一步直达 | | 并行能力 | 时间步串行,无法并行 | 全序列并行 | | 顺序信息 | 天然带(顺序即计算顺序) | 需位置编码显式注入 | | 训练效率 | 低,长序列尤其慢 | 高,可大规模预训练 | 注:RNN被淘汰不是因为"表达能力不行",而是**又慢又记不住长东西**.它留下的思想——用隐藏状态表示"截至当前的理解"、用递归建模上下文——是理解LSTM/GRU乃至Transformer的起点.所以我现在还在回头补这一课. ## 小结 - **动机**:词向量没有顺序信息,且序列变长,全连接网络处理不了,RNN逐个读词、逐步更新记忆. - **核心**:带循环连接的隐藏层,$h_t = \tanh(x_tW_x + h_{t-1}W_h + b)$,所有时间步**参数共享**. - **变体**:多层(深度换表征)、双向(拼接正反向,但自回归生成不能用)、多层+双向(经典编码器配置). - **API**:`torch.nn.RNN`,记住 `batch_first`、`output` 只含最后一层、`output` 末维会因双向翻倍而 `h_n` 不会. - **训练**:BPTT,梯度沿时间步连乘累加. - **死穴**:$\tanh'(u_t)W_h$ 连乘 → 梯度消失(学不到长期依赖)/梯度爆炸(训练不稳,可裁剪);再叠加时间步必须串行,于是被Transformer取代. - **组合结构与注意力**:输入输出都是变长序列时用 Seq2Seq(编码器-解码器两个RNN);它的"固定上下文向量"瓶颈靠**注意力机制**补——解码器每一步现算一个 $c_t$,按权重取用编码器所有隐藏状态($c_t$ 不进递归链,传下去的只有 $s_t$).但注意力治不了RNN的串行和梯度连乘,所以才有Transformer.