Seq2Seq与注意力机制：从原理到PyTorch实战翻译模型

1. 从“输入一句话，输出另一句话”说起：Seq2Seq 到底在解决什么问题

第一次接触 Seq2Seq 的人，脑子里往往有个疑问：我直接用全连接网络不行吗？输入一个向量，输出一个向量，多简单。问题在于，现实世界里大量任务的输入和输出都是变长序列——翻译一句话，中文 10 个字，英文可能 15 个词；做文本摘要，原文 500 字，摘要 80 字；语音识别，3 秒音频对应 20 个字符。输入长度和输出长度都不固定，而且两者之间没有天然的一一对应关系。全连接网络要求固定维度，RNN 虽然能吃变长输入，但只能输出等长或单步的结果，没法直接生成一个结构完整的变长输出序列。

Seq2Seq（Sequence-to-Sequence）就是冲着这个痛点来的。它的核心思路非常朴素：用一个编码器把输入序列压缩成一个上下文表示，再用一个解码器从这个表示里逐步“解码”出目标序列。编码器和解码器通常都是 RNN 家族成员（LSTM、GRU），但也可以是 Transformer、CNN。整个框架不关心输入输出具体多长，只关心“怎么把源序列的信息传递到目标序列的生成过程中”。

这个框架能做的事情远超翻译。机器翻译是它的成名作，但文本摘要、对话生成、语音识别、代码生成、甚至化学分子式生成，都能套进这个范式。适合谁来学？如果你已经写过简单的 RNN 分类模型，想进一步处理“输入输出都是序列”的任务，Seq2Seq 是绕不过去的一站。如果你正在做翻译或摘要项目，直接上手 Seq2Seq 加注意力机制，基本就是当前工程实践的标准起点。

我见过不少新手一上来就冲 Transformer，结果连编码器-解码器结构为什么需要两个独立网络都说不清楚。Seq2Seq 是理解这一切的基石，把它吃透，后面看 Attention、Transformer、BERT 的 encoder-decoder 架构，都会顺很多。

2. 编码器-解码器架构拆解：为什么非要拆成两半

2.1 编码器：把变长输入“压”成一个向量

编码器的工作流程可以用一句话概括：逐个读入源序列的每个 token，不断更新自己的隐藏状态，读完之后把最终隐藏状态交给解码器。假设输入序列是 (x_1, x_2, ..., x_T)，编码器在每个时间步 (t) 计算：

[ h_t = f(x_t, h_{t-1}) ]

其中 (f) 可以是 LSTM 单元、GRU 单元或者普通 RNN 单元。读完整句话之后，我们拿到最终隐藏状态 (h_T)（对于 LSTM 还有细胞状态 (c_T)）。这个 (h_T) 就是整个源序列的“压缩表示”，也叫上下文向量（context vector）。

这里有个关键问题：为什么用最终隐藏状态而不是所有隐藏状态的拼接？因为解码器需要的是一个固定维度的输入，而源序列长度是变化的。把所有隐藏状态拼起来维度会随输入长度变化，没法直接喂给解码器。最终隐藏状态维度固定，正好充当“源序列摘要”的角色。

但这也埋下了一个隐患：如果源序列很长，比如 50 个词，最终隐藏状态真的能记住所有信息吗？答案是不能。这就是后面 Attention 机制要解决的核心问题。不过在短序列任务上，比如 10 个词以内的翻译，纯 Seq2Seq 已经能跑出不错的结果。

2.2 解码器：一步一步“吐”出目标序列

解码器的初始隐藏状态直接复制编码器的最终隐藏状态。然后它开始逐个时间步生成目标 token。每个时间步的输入是上一个时间步生成的 token（训练时是真实标签，推理时是模型自己生成的），输出是当前 token 的概率分布。

具体来说，解码器在时间步 (t) 的计算是：

[ s_t = g(y_{t-1}, s_{t-1}) ] [ P(y_t | y_{<t}, x) = \text{softmax}(W_o s_t + b_o) ]

其中 (y_{t-1}) 是上一个 token 的 embedding，(s_{t-1}) 是解码器上一时刻的隐藏状态。训练时我们通常用Teacher Forcing：把真实的目标 token 作为下一步输入，而不是模型自己预测的 token。这样做的好处是训练更稳定、收敛更快，因为模型不用在早期就面对自己犯下的错误。

但 Teacher Forcing 有个著名的副作用：曝光偏差（Exposure Bias）。训练时模型见到的都是正确输入，推理时却要基于自己生成的、可能有错的 token 继续生成，一旦第一步错了，错误会累积放大。工程上常见的缓解手段是 scheduled sampling：训练前期用 Teacher Forcing，后期逐渐替换成模型自己的预测，让模型慢慢适应推理时的输入分布。

2.3 两个网络为什么要分开

有人会问：能不能用一个 RNN 同时做编码和解码？理论上可以，但实践上不推荐。编码器和解码器的职责完全不同：编码器要充分理解源序列，解码器要流畅生成目标序列。两者的词表可能不同（比如中英文），需要的隐藏层维度也可能不同。分开设计让每个部分可以独立调参、独立优化。更重要的是，分开之后才能方便地插入 Attention 机制，让解码器在每一步都能“回头看”编码器的所有隐藏状态，而不是只依赖一个固定向量。

3. 注意力机制：Seq2Seq 从能用变好用的分水岭

3.1 固定上下文向量的瓶颈

纯 Seq2Seq 最被人诟病的地方就是那个固定长度的上下文向量。想象一下，你要把一篇 300 字的文章压缩成一个 256 维的向量，然后再从这个向量里恢复出 200 字的摘要。信息瓶颈太严重了。实验上也能明显看到：当源序列超过 20 个 token 时，BLEU 分数断崖式下跌。解码器在生成后面的词时，已经“忘记”了源序列开头的内容。

这个问题不是调参能解决的，是架构本身的限制。2015 年 Bahdanau 等人提出的注意力机制，直接改变了 Seq2Seq 的命运。

3.2 注意力到底在算什么

注意力机制的核心思想是：解码器在每一步生成时，不要只盯着一个固定向量，而是动态地从编码器的所有隐藏状态中“挑选”最相关的信息。具体计算分三步：

第一步，计算解码器当前隐藏状态 (s_t) 和编码器每个隐藏状态 (h_i) 的相似度：

[ e_{t,i} = \text{score}(s_t, h_i) ]

score 函数可以是点积、双线性映射或者一个小型 MLP。Bahdanau 原始论文用的是 MLP 形式。

第二步，把相似度归一化成概率分布：

[ \alpha_{t,i} = \frac{\exp(e_{t,i})}{\sum_j \exp(e_{t,j})} ]

这些 (\alpha) 就是注意力权重，表示解码器当前步对编码器每个位置的关注程度。

第三步，用注意力权重对编码器隐藏状态做加权求和，得到当前步的上下文向量：

[ c_t = \sum_i \alpha_{t,i} h_i ]

然后解码器用 (c_t) 和 (s_t) 一起预测当前 token。这样一来，解码器在生成每个词时，都能“看到”源序列的不同部分。生成第一个词时可能关注源序列开头，生成最后一个词时可能关注结尾，完全动态调整。

3.3 一个通用的注意力模块长什么样

热词里提到的“a generic attention module for a decoder in seq2seq pytorch”，其实就是在说：能不能写一个通用的、可插拔的注意力模块，方便在不同 Seq2Seq 模型里复用。我自己的做法是定义一个Attention类，接收编码器输出encoder_outputs和解码器当前隐藏状态decoder_hidden，返回上下文向量和注意力权重。这样不管是 LSTM 还是 GRU 解码器，都能直接调用同一个模块。

一个典型的 PyTorch 实现大概长这样：

import torch import torch.nn as nn import torch.nn.functional as F class Attention(nn.Module): def __init__(self, enc_hid_dim, dec_hid_dim): super().__init__() self.attn = nn.Linear(enc_hid_dim + dec_hid_dim, dec_hid_dim) self.v = nn.Linear(dec_hid_dim, 1, bias=False) def forward(self, decoder_hidden, encoder_outputs): # decoder_hidden: (batch, dec_hid_dim) # encoder_outputs: (batch, src_len, enc_hid_dim) src_len = encoder_outputs.shape[1] decoder_hidden = decoder_hidden.unsqueeze(1).repeat(1, src_len, 1) energy = torch.tanh(self.attn(torch.cat((decoder_hidden, encoder_outputs), dim=2))) attention = self.v(energy).squeeze(2) # (batch, src_len) return F.softmax(attention, dim=1)

这个模块的优点是与编码器类型解耦。只要编码器输出是(batch, src_len, enc_hid_dim)的形状，不管它是 LSTM、GRU 还是 CNN 产生的，注意力模块都能正常工作。工程上这种解耦非常关键，因为你可以先跑通一个 LSTM 版本，后面想换 Transformer 编码器时，注意力模块几乎不用改。

注意：注意力权重的 softmax 维度一定是src_len那一维，不要搞错。我见过有人对 batch 维度做 softmax，结果训练完全跑不动，loss 一直不降。

4. 动手实现一个带注意力的 Seq2Seq 翻译模型

4.1 数据准备与词表构建

我们以一个小规模的中英翻译任务为例。数据格式是每行一对句子，用 tab 分隔。第一步是构建词表。源语言和目标语言各建一个词表，特殊 token 至少要有四个：<pad>、<sos>、<eos>、<unk>。<pad>用于 batch 内对齐，<sos>和<eos>标记序列开始和结束，<unk>处理未登录词。

词表大小建议控制在 10000 到 30000 之间。太小会导致大量<unk>，太大则 embedding 矩阵参数量爆炸。我的经验是：如果训练数据少于 10 万句对，词表 8000 左右就够了；如果数据量在百万级别，可以放到 30000 以上。构建词表时按词频排序，只保留频率最高的前 N 个词，其余全部映射到<unk>。

from collections import Counter def build_vocab(sentences, max_size=10000, min_freq=2): counter = Counter() for sent in sentences: counter.update(sent.split()) vocab = {'<pad>': 0, '<sos>': 1, '<eos>': 2, '<unk>': 3} for word, freq in counter.most_common(max_size - 4): if freq >= min_freq: vocab[word] = len(vocab) return vocab

4.2 编码器实现细节

编码器用单层双向 LSTM。双向的好处是每个位置的隐藏状态都同时包含左侧和右侧的上下文信息。对于翻译任务，源语言的理解需要全局信息，双向编码器比单向效果好很多。编码器输出两个东西：所有时间步的隐藏状态（给注意力用）和最终隐藏状态（给解码器做初始化）。

class Encoder(nn.Module): def __init__(self, vocab_size, emb_dim, enc_hid_dim, dec_hid_dim, dropout): super().__init__() self.embedding = nn.Embedding(vocab_size, emb_dim, padding_idx=0) self.rnn = nn.LSTM(emb_dim, enc_hid_dim, bidirectional=True, batch_first=True) self.fc = nn.Linear(enc_hid_dim * 2, dec_hid_dim) self.dropout = nn.Dropout(dropout) def forward(self, src): embedded = self.dropout(self.embedding(src)) outputs, (hidden, cell) = self.rnn(embedded) # hidden: (2, batch, enc_hid_dim) -> (batch, dec_hid_dim) hidden = torch.tanh(self.fc(torch.cat((hidden[-2], hidden[-1]), dim=1))) return outputs, hidden

这里有个细节：双向 LSTM 的最终隐藏状态有两个，分别来自前向和后向。我们把它们拼接后过一个线性层，映射到解码器需要的维度。这样解码器的初始隐藏状态就同时包含了源序列开头和结尾的信息。

4.3 解码器与注意力融合

解码器每个时间步做四件事：读入当前 token 的 embedding、用注意力计算上下文向量、把上下文向量和 embedding 拼接后送入 LSTM、通过输出层预测下一个 token。

class Decoder(nn.Module): def __init__(self, vocab_size, emb_dim, enc_hid_dim, dec_hid_dim, dropout, attention): super().__init__() self.attention = attention self.embedding = nn.Embedding(vocab_size, emb_dim, padding_idx=0) self.rnn = nn.LSTM(emb_dim + enc_hid_dim * 2, dec_hid_dim, batch_first=True) self.fc_out = nn.Linear(emb_dim + dec_hid_dim + enc_hid_dim * 2, vocab_size) self.dropout = nn.Dropout(dropout) def forward(self, input_token, hidden, encoder_outputs): input_token = input_token.unsqueeze(1) # (batch, 1) embedded = self.dropout(self.embedding(input_token)) # (batch, 1, emb_dim) attn_weights = self.attention(hidden, encoder_outputs) # (batch, src_len) attn_weights = attn_weights.unsqueeze(1) # (batch, 1, src_len) context = torch.bmm(attn_weights, encoder_outputs) # (batch, 1, enc_hid_dim*2) rnn_input = torch.cat((embedded, context), dim=2) output, (hidden, cell) = self.rnn(rnn_input, (hidden.unsqueeze(0), cell.unsqueeze(0))) prediction = self.fc_out(torch.cat((output.squeeze(1), context.squeeze(1), embedded.squeeze(1)), dim=1)) return prediction, hidden.squeeze(0), cell.squeeze(0)

注意输出层把三样东西拼在一起：LSTM 输出、上下文向量、当前 token 的 embedding。这种“三合一”拼接是注意力 Seq2Seq 的常见做法，能让模型在预测时同时利用解码器状态、源序列信息和当前输入。

4.4 训练技巧与超参数选择

训练时用交叉熵损失，但必须忽略<pad>位置的损失。因为 padding 是我们人为补的，不是真实目标。忽略方式很简单：nn.CrossEntropyLoss(ignore_index=0)。

优化器选 Adam，学习率从 1e-3 开始。如果训练 loss 震荡，降到 5e-4 或 3e-4。Batch size 根据显存来，8GB 显存跑 64 到 128 没问题。梯度裁剪一定要加，torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)，防止梯度爆炸。我试过不加梯度裁剪，训练到第 3 个 epoch loss 直接变成 nan，加了之后稳定很多。

Teacher Forcing 的比例可以设成 0.5 到 0.7 之间。完全用 Teacher Forcing 会导致曝光偏差严重，完全不用又收敛太慢。折中方案是训练前期用 0.7，后期降到 0.3。

5. 常见问题与排查技巧实录

5.1 训练 loss 不下降怎么办

这是最常见的问题。排查顺序如下：

我遇到过一次 loss 死活不降，最后发现是词表构建时把<pad>的索引设成了 1，但ignore_index写的是 0。这种低级错误排查起来最费时间，建议一开始就把特殊 token 的索引固定下来，写个常量类管理。

5.2 推理时生成重复词或提前结束

解码器在推理时可能陷入循环，一直生成同一个词。常见原因有两个：一是注意力权重坍缩，所有注意力都集中在一个位置；二是<eos>的概率被低估，模型不知道什么时候该停。

解决方法：在推理时加repetition penalty，对已经生成过的 token 降低其 logit 值。另外可以设置最大生成长度，防止无限循环。如果模型总是提前生成<eos>，检查训练数据里<eos>的比例是否过高，或者损失函数对<eos>的权重是否过大。

5.3 长序列效果差

即使加了注意力，源序列超过 50 个 token 时效果还是会下降。这时候可以考虑：

• 用子词分词（BPE、WordPiece）代替词级分词，缩短序列长度
• 用Transformer替代 RNN，自注意力机制对长距离依赖建模更好
• 在注意力里加位置编码，让模型感知 token 的相对位置

我实测下来，把词级分词换成 BPE 之后，平均序列长度缩短了 40%，BLEU 提升了 3 个点以上。这个投入产出比非常高，建议优先尝试。

5.4 显存不够用

Seq2Seq 训练时显存占用主要来自三块：embedding 矩阵、LSTM 隐藏状态、注意力矩阵。如果显存吃紧，可以：

• 减小 batch size，用梯度累积模拟大 batch
• 降低 embedding 维度，从 256 降到 128
• 用混合精度训练，torch.cuda.amp能省 30% 到 40% 显存
• 把词表大小从 30000 降到 10000

提示：混合精度训练时，softmax 和 loss 计算建议保持在 float32，否则容易数值不稳定。

6. 从 Seq2Seq 到更远的地方

Seq2Seq 加注意力这个组合，在 2017 年之前几乎是序列生成任务的标配。后来 Transformer 出来了，用自注意力完全替代了 RNN，训练并行度更高，长序列效果更好。但 Transformer 的 encoder-decoder 架构，本质上还是 Seq2Seq 的思路：编码器理解输入，解码器生成输出，中间用交叉注意力传递信息。你把 Seq2Seq 的编码器换成 Transformer encoder，解码器换成 Transformer decoder，注意力模块换成多头交叉注意力，就得到了一个标准的 Transformer 翻译模型。

所以我的建议是：先把 Seq2Seq 加注意力跑通，理解每一步在做什么，再去学 Transformer。否则你只是会调库，遇到问题根本不知道从哪里下手。我自己带过几个新人，直接上 Transformer 的，遇到 loss 不降基本束手无策；先跑过 Seq2Seq 的，至少知道要检查注意力权重、检查 padding mask、检查学习率。

这个内容后续还可以这样扩展：把注意力权重可视化出来，看看模型在生成每个词时到底关注了源句子的哪些位置。对于翻译任务，你通常能看到类似“主谓宾对齐”的模式，非常直观。另外可以尝试在解码器端加 beam search，比贪心解码的 BLEU 能高 1 到 2 个点，代价是推理速度变慢。如果要做对话生成，还需要处理“通用回复”问题，那又是另一个话题了。