编码器-解码器：序列到序列的黄金框架

可视化演示

通过编码器序列压缩（输入token→LSTM→上下文向量）、信息瓶颈（序列越长信息保留越少）与解码器自回归生成（上下文→逐词生成→结束标记）三个模式，展示Seq2Seq黄金框架的核心机制。

架构总览

传话游戏的第一课，是认清两个角色的分工：队首的小明负责“听”和“压缩”，队尾的小华负责“拿”和“还原”。这就是编码器-解码器架构的基本流水线——输入一条序列，经过一次“先压缩后还原”的旅行，输出另一条长度往往不同的序列。你可能会问：为什么非要搞得这么麻烦？因为输入和输出的长度压根对不上。机器翻译里，“你好吗”是 3 个字，英文译文 “How are you?“ 是 3 个词；语音转文字时，一句话的音频包含几千帧，而对应的文字只有十几个字。这种”长度不齐”的转换任务，让传统定长模型完全无从下手。

Seq2Seq（Sequence to Sequence）正是为解决这类问题而生的端到端框架：编码器把整个输入序列“读”成一个稠密向量——上下文向量；解码器再以这个向量为起点，“写”出输出序列。写作时是逐词进行的，每生成一个新词，模型都会参考已经生成的词，形成链式推进。正是这种“先听、后复述”的结构，让模型在两种不同长度的序列之间学会了灵活映射，也让它成了机器翻译、文本摘要、语音识别等众多任务共同的地基。

回看传话游戏，架构总览就是游戏规则：小明只负责听和总结，小华只负责拿到字条讲故事，两人之间唯一的交接物是那张纸条。接下来我们就先钻进小明的耳朵，看看他是怎么一边听一边做批注的。

编码器原理

小明有个特别的本事——他从不等到 200 个字全听完才开始总结，而是边听边在大脑里更新“批注”：听到“小猫”记一笔，听到“追”补一笔，每进来一个新词，批注就把新词和旧记忆融在一起。深度学习里，这个“边读边批注”的机制叫 RNN（循环神经网络）。RNN 是一种自带记忆的神经网络，它按时间步逐个读取词，并不断更新自己的隐藏状态 $h_t$——所谓隐藏状态，就是那条“批注”：一个努力浓缩了迄今为止全部信息的向量。

当编码器读到第 $t$ 个词时，它把上一条批注 $h_{t-1}$ 和新词 $x_t$ 一起喂给一个非线性函数 $f$（通常是一个 GRU 或 LSTM 单元），得到新的批注 $h_t$：

这是编码器最核心的一步更新。$h_t$ 既承载了当前词的信息，也保留了对前文所有词的记忆。值得注意的是，RNN 是“按顺序”处理序列的，所以天然尊重词的先后顺序——“猫追老鼠”和“老鼠追猫”会得到完全不同的批注；而普通全连接网络无法做到这一点。

小明一路听一路写批注，批注越来越丰满。但有个规矩：他不能把一整本“批注本”直接塞给小华，只能把最终批注抄到一张固定大小的纸条上——这正是下一节“上下文向量”的由来。

上下文向量

故事听完了，小明要在几秒钟内把 200 字的故事浓缩成一句“核心意思”，工工整整地写在小纸条上递给小华。注意，不管原故事是 50 字还是 2000 字，这张纸条的大小永远不变。这张固定大小的纸条，就是上下文向量（Context Vector）。它是编码器与解码器之间唯一的“信物”。

在经典 RNN 编码器-解码器里，上下文向量被定义为编码器读完整个输入序列之后的最终隐藏状态：

其中 $T$ 是输入序列的长度，$h_T$ 是最后一个时间步的隐藏状态。这个向量用固定维度（比如 256 或 512 个浮点数）承载整句话的语义。拿到 $c$ 之后，编码器的任务就宣告完成，小明可以功成身退了。

上下文向量是整个序列转换的“咽喉要道”：编码器侧的全部信息都必须从这个固定大小的篮子里递给解码器。这带来一个著名的隐患——信息瓶颈。我们稍后会看到，这正是长句翻译掉链子的根源。眼下，小华已经拿到纸条，他要怎么从零开始把故事讲出来？下一节轮到解码器登场。

解码器生成

小华拿到纸条后，并不会像倒放录音一样“还原”原文，而是从头开始，一个字一个字地把故事讲出来。每开口说一个词，他都要兼顾三件事：之前说过了什么、纸条上写了什么、接下来哪个词最顺口。解码器的工作方式与此惊人地一致：它本质上也是一个 RNN，但输入多了一个上下文向量 $c$。

在每个时间步，解码器输出一个概率分布，表示“下一个词是词表里每个词的可能性”，然后从中选出概率最高的词作为这一步的输出。用公式表示就是：

其中 $s_t$ 是解码器的隐藏状态，由上一个输出词 $y_{t-1}$、上一个状态 $s_{t-1}$ 和上下文 $c$ 共同更新；$W_s$ 是可学习的权重矩阵，把隐藏状态“投影”到词表大小的空间上。

这个过程是自回归的——第 $t$ 步生成的词会作为第 $t+1$ 步的输入，一个字符一个字符地“挤”出来，直到模型预测到结束标记 EOS 才收声。这很像写诗：先有了上一个字，才敢定下一个字。小华每说一个词就更新一次“故事进度”，他越讲越远，离纸条也越来越远——那么问题来了：怎么训练小华，才能让他讲得又准又稳？

训练策略

传话游戏开赛前要排练。排练时，教练会塞给小华“标准答案”：不管小华上一句说错了什么，教练都会把他该说的下一句原原本本递到他嘴边，让他照着说下去。这种“错了也按标准答案继续”的排练法，在 Seq2Seq 里叫 Teacher Forcing（老师强迫）。它的数学目标是最大化输出序列的条件概率——让模型在每个时间步都尽量猜中真实词。我们用交叉熵损失来刻画“预测分布”与“真实分布”的差距：

训练时，解码器第 $t$ 步的输入直接取真实词 $y_{t-1}$，而不是模型自己刚预测的词。这样模型在每一步都站在“正确位置”上学习规律，梯度信号更干净，训练也快得多。但代价是：推理时没有教练递答案，模型只能拿自己的预测当输入，一旦开头出错，错误就会一路滚雪球——这叫曝光偏差（Exposure Bias），是训练与推理之间的“两副面孔”。

另外，训练序列必须用两个特殊标记开头和结尾：BOS（Beginning of Sequence，序列开始）用来告诉解码器“故事从这起笔”；EOS（End of Sequence，序列结束）用来告诉解码器“故事到这收尾”。没有 EOS，解码器永远不会学会“闭嘴”。排练结束后，小华上了赛场，却很快发现一个残酷的事实——纸条太小了。

信息瓶颈

游戏进行到晋级赛，教官换了一篇 2000 字的超长故事。小明听完后，依然只能把那张 50 字容量的小纸条写满。他拼了命想塞下所有情节，但纸条就那么大，只能忍痛割爱挑重点写。结果小华还原出来的故事支离破碎，连主角的名字都丢了。

这个悲剧在数学上叫信息瓶颈（Information Bottleneck）。上下文向量是固定维度 $d$ 的，而输入序列长度 $T$ 是变化的。平均每个输入词能分到的“表示空间”是：

句子越长，每个词平均分到的容量就越小，细节自然被挤掉。论文实验也证实了这一点：当句子长度超过约 20~30 个词时，Seq2Seq 的翻译质量会断崖式下跌，长距离的依赖关系大面积丢失。这不是训练不够努力，而是结构上的先天缺陷——让无限长度的信息穿过一个有限宽度的“漏斗”，必然有损。

传话游戏里，我们有一个直觉解法：别让小华只盯那张纸条，干脆让他随时翻原稿。这个朴素想法在 AI 界有个响亮的名字——注意力机制。它能不能救小华于水火？下一节就是大结局。

改进方向

老师终于看不下去了，修改了游戏规则：小华讲故事时可以拿着原稿，讲到哪一段就低头看哪一段，拿不准时甚至可以把原稿上对应的句子找出来反复读。这一改，传话失真的问题瞬间缓解。这就是注意力机制（Attention）的核心思想——解码器每一步不再只依赖那一个固定的上下文向量，而是可以“回看”编码器的每一个隐藏状态，并按需分配它们的权重：

其中 $e_{ij}$ 表示解码器第 $i$ 步对编码器第 $j$ 个词的“相关性打分”；经过 softmax 归一化后，$\alpha_{ij}$ 是总和为 1 的注意力权重；最后编码器的所有隐藏状态按权重加权求和，得到当前步的动态上下文。于是那个固定的小纸条被升级成“随时可查的原稿”，信息瓶颈被一举打破。

注意力机制之后，这条进化之路继续延伸：双向编码器让每个词的表示同时看到前文和后文，语义更立体；Transformer 则彻底抛弃了 RNN 的循环结构，用自注意力并行处理整个序列，成为今天大语言模型（如 GPT、BERT）的基座。从小纸条到原稿，从单向复述到随时查证，传话游戏最终长成了一棵枝繁叶茂的大树——而编码器-解码器，正是这棵树最坚实的树干。

AI 应用场景

Python 演示

import torchimport torch.nn as nnimport torch.optim as optim torch.manual_seed(42)VOCAB = 13                # 0=PAD, 1=EOS, 2=BOS, 3~12=数字0~9HIDDEN = 32EOS_ID = 1BOS_ID = 2CHAR_IDS = {c: i + 3 for i, c in enumerate('0123456789')}ID_CHARS = {i + 3: c for i, c in enumerate('0123456789')}  def make_sample(length=4):    # 随机生成一个4位数字序列，目标是它的逆序    nums = [str(torch.randint(0, 10, (1,)).item()) for _ in range(length)]    src = [CHAR_IDS[c] for c in nums] + [EOS_ID]    tgt = [BOS_ID] + [CHAR_IDS[c] for c in reversed(nums)] + [EOS_ID]    return torch.tensor(src, dtype=torch.long), torch.tensor(tgt, dtype=torch.long)  class Encoder(nn.Module):    def __init__(self):        super().__init__()        self.emb = nn.Embedding(VOCAB, HIDDEN)        self.rnn = nn.GRU(HIDDEN, HIDDEN)     def forward(self, x):        # x: (seq_len, batch)，GRU 返回最后一个隐藏状态作为上下文向量        _, h = self.rnn(self.emb(x))        return h  class Decoder(nn.Module):    def __init__(self):        super().__init__()        self.emb = nn.Embedding(VOCAB, HIDDEN)        self.rnn = nn.GRU(HIDDEN, HIDDEN)        self.fc = nn.Linear(HIDDEN, VOCAB)     def forward(self, x, hidden):        out, hidden = self.rnn(self.emb(x), hidden)        return self.fc(out), hidden  enc = Encoder()dec = Decoder()opt = optim.Adam(list(enc.parameters()) + list(dec.parameters()), lr=0.01)loss_fn = nn.CrossEntropyLoss() for epoch in range(300):    src, tgt = make_sample()    context = enc(src.unsqueeze(1))    # Teacher Forcing: 输入是 tgt[:-1]（含BOS），监督标签是 tgt[1:]（含EOS）    logits, _ = dec(tgt[:-1].unsqueeze(1), context)    loss = loss_fn(logits.view(-1, VOCAB), tgt[1:].reshape(-1))    opt.zero_grad()    loss.backward()    opt.step()    if epoch % 60 == 0:        print(f"epoch {epoch} loss {loss.item():.3f}")  def predict(num_str):    src = torch.tensor([CHAR_IDS[c] for c in num_str] + [EOS_ID],                       dtype=torch.long).unsqueeze(1)    with torch.no_grad():        context = enc(src)        x = torch.tensor([[BOS_ID]], dtype=torch.long)        out = []        for _ in range(8):            logits, context = dec(x, context)            x = logits.argmax(dim=2)            if x.item() == EOS_ID:                break            out.append(ID_CHARS[x.item()])        return ''.join(out)  demo = '7258'print('input  :', demo)print('predict:', predict(demo))print('expect :', demo[::-1])

1. context = enc(src.unsqueeze(1))这行是“小明听故事”：编码器一次性读完整条输入序列，返回最终隐藏状态作为上下文向量（小纸条）。
2. logits, _ = dec(tgt[:-1].unsqueeze(1), context)这行是“教练塞答案”：Teacher Forcing 模式下，解码器输入真实目标序列（去掉末尾 EOS），输出每一步的预测分数。
3. loss = loss_fn(logits.view(-1, VOCAB), tgt[1:].reshape(-1))交叉熵损失把预测分布和真实词逐一对比，正确词概率越高，损失越小。
4. _, h = self.rnn(self.emb(x))GRU 直接返回最后一步隐藏状态，这就是论文里 c = h_T 的代码实现。
5. x = torch.tensor([[BOS_ID]], dtype=torch.long)推理时从 BOS 开始，让解码器“从零起笔”；在循环里用上一步预测的 argmax 作为下一步输入，体现自回归生成。
6. if x.item() == EOS_ID: break遇到 EOS 就收声，没有这个判断，模型会无限生成下去。

常见误区

面试题