从零实现Seq2Seq对话模型：PyTorch+GRU+Attention实战

很多人一上来就追着“大模型”跑，翻了一堆 Transformer、GPT 的博客，结果连第一行代码都不知道从哪写起。我劝这类朋友先冷静一下——如果你真的想把大模型玩明白，Seq2Seq 是绕不过去的第一站。对话功能、翻译任务、摘要生成，这些的底层逻辑全都和 Seq2Seq 一脉相承。这篇文章就用 PyTorch 从零实现一个最简单的对话模型，输入“你好”，让它学会回“你好呀，很高兴见到你”。适合有 Python 基础、会用 PyTorch 基本张量操作、但还没真正实现过完整 NLP 项目的朋友。我不讲花活，只讲能跑起来、能理解、能复现的流程。

1. 为什么从 Seq2Seq 起步：核心思路与方案选型

1.1 对话任务和大模型的关系

对话功能的本质是一个“条件文本生成”问题：给定一句输入文本，模型预测一句输出文本。听起来简单，但它揭开了一个很核心的迷雾——现代大模型比如 GPT 系列、ChatGPT，本质上都是“输入一串 token，逐字预测下一个 token”。这和 Seq2Seq 里 Decoder 做的事一模一样，只是把底层的 RNN 换成了 Transformer，把参数量放大了几个数量级，把数据从几万条换成了几十亿条。

所以你在小模型上搞清楚“这一步输入是什么、输出是什么、梯度怎么回传”，再去看大模型的架构，会发现很多概念都是眼熟的，比如 attention 机制、teacher forcing、self-attention 的 query/key/value 雏形，在 Seq2Seq 里全都已经出现。

很多人一上来就接触 Ollama、vLLM 这些部署大模型的工具，装上就能跑通 chat，但里面发生了什么完全黑盒。我不是说工具不好，而是如果你想进阶到微调、私有化部署、甚至自己设计模型，黑盒一定会卡住你。用 Seq2Seq 自己造一个小对话模型，是最低成本的破局方式。

1.2 技术选型：PyTorch + GRU + 字级 token

选型上我直接给了结论，但每个选择背后都有理由。

第一，用 PyTorch 而不是 Keras、TensorFlow 或现成的 Hugging Face。参考动手学深度学习的框架选择，PyTorch 的自动求导和 RNN 接口最直白，写起来像搭积木。不直接调 Hugging Face 的 Seq2Seq 封装，是因为封装把 attention、decoder 全部隐藏了，学了等于没学。

第二，用 GRU 而不是 LSTM。GRU 参数更少，训练更快，在小数据量情况下效果和 LSTM 几乎没差。对教学 demo 来说完全够用。你后面看 Transformer 的时候，不需要纠结 LSTM 的几个门控细节，GRU 的复杂度刚刚好。

第三，用字级 tokenizer 而不是词级。中文不像英文有天然空格分词，如果用 jieba 分词，会多一层依赖，词表也更大。字级方案每个汉字就是一个 token，词表几百个字符就够，代码简单，对“理解流程”这个目标聚焦得最好。真实项目中你当然会换掉，但先跑通再说。

1.3 架构预览：编码器-解码器与注意力

Seq2Seq 架构可以抠成三个部分：Encoder、Decoder、Attention。

Encoder 负责读入完整输入句子，把每个 token 映射成向量，经过一个双向 GRU 后，把整个句子的信息压缩成一个隐藏状态向量。这个向量被当作任务里说的“语义向量”。Decoder 则拿着这个向量作为初始状态，一步一步地把答案里的每个字预测出来。每预测一步，它都会通过 Attention 机制回看 Encoder 输出的每个位置，找到当前生成最该关注的输入词——这就像是做题时“带着当前问题回到原文找线索”，而不是闭着眼睛硬编。

生活里类比一下：你把一段中文交给我翻译成英文，我先完整听懂（Encoder），再根据理解一句一句翻（Decoder），翻每个词时我会在脑里回想原文最相关的部分（Attention）。这三个组件不是可选项，而是分工关系。

2. 数据准备：把“人话”变成模型认识的数字

2.1 对话数据集怎么来

真实场景下，训练对话模型至少需要几千到几万条对话对。常见的开源中文闲聊语料有 LCCC、小黄鸡语料等，直接下载后按“问题\t回答”的格式解析即可。

但这篇是 demo，为了让代码零依赖、复制就能跑，我直接内置了一个 10 条左右的 MiniChitChat 数据集。它够我们跑通完整流程，也能看到模型学到一点“接话”的规律。你如果追求实际效果，把它换成几千条真实语料就行，后面代码完全不用改。

pairs = [ ("你好", "你好呀，很高兴见到你"), ("你叫什么名字", "我叫小智，你呢"), ("今天天气怎么样", "天气不错，适合出门走走"), ("你是谁", "我是一个小小的对话机器人"), ("你会做什么", "我可以陪你聊聊天"), ("再见", "再见，下次再聊"), ("你多大了", "我一岁啦"), ("你喜欢什么", "我喜欢和大家聊天"), ("什么是人工智能", "人工智能就是让机器学会思考的技术"), ("你好吗", "我很好，谢谢关心"), ]

字段就是两个字符串，简单粗暴。

2.2 字级词表与特殊标记

每个字符要被映射成一个整数 id，模型才能处理。这里要引入几个特殊 token，它们各自解决一个实际问题：

• <pad>用于把 batch 里不同长度的句子对齐到相同长度；
• <bos>表示句子开始，Decoder 第一步的输入；
• <eos>表示句子结束，Decoder 生成到它时就停止；
• <unk>用于替换词表中没出现的字，兜底用。

构建词表的代码很简单，核心是统计所有对话里的字符频次：

class Vocab: def __init__(self): self.stoi = {"<pad>": 0, "<bos>": 1, "<eos>": 2, "<unk>": 3} self.itos = {} for k, v in self.stoi.items(): self.itos[v] = k def build(self, sentences, min_freq=1): counter = {} for s in sentences: for ch in s: counter[ch] = counter.get(ch, 0) + 1 for ch, freq in counter.items(): if freq >= min_freq: self.stoi[ch] = len(self.stoi) self.itos[self.stoi[ch]] = ch def encode(self, s): return [self.stoi.get(ch, self.stoi["<unk>"]) for ch in s] def decode(self, ids): return "".join(self.itos[i] for i in ids if i not in (self.stoi["<pad>"], self.stoi["<bos>"], self.stoi["<eos>"]))

我实测发现一个容易踩的坑：处理中文数据时，英文标点和中文标点混在一起，如果不做min_freq过滤，词表会被各种只出现一次的标点塞满。这里的min_freq=1已经放得很宽，真实数据建议调成 2 或 3。

2.3 批处理与 Padding 细节

PyTorch 的 RNN 要求一个 batch 内序列长度一致。做法是每个 batch 按最长句子做 padding。这里有个经验之谈：pad 到最长的句子而不是固定长度，这样不至于浪费算力。

collate_fn是 DataLoader 里最关键的一环，它要把一条条样本拼成 batch，同时给目标序列加上<bos>和<eos>。训练时 Decoder 输入是<bos>+ 答案原文，预测目标是 答案原文 +<eos>。这两者的长度必须一致，Loss 才能对齐。

def collate_fn(batch, vocab): src_list, tgt_list = zip(*batch) pad_id = vocab.stoi["<pad>"] bos_id = vocab.stoi["<bos>"] eos_id = vocab.stoi["<eos>"] src_len = max(len(s) for s in src_list) tgt_len = max(len(t) for t in tgt_list) + 1 src_ids = [s + [pad_id] * (src_len - len(s)) for s in src_list] tgt_in_ids = [[bos_id] + t + [pad_id] * (tgt_len - len(t) - 1) for t in tgt_list] tgt_out_ids = [t + [eos_id] + [pad_id] * (tgt_len - len(t) - 1) for t in tgt_list] return torch.tensor(src_ids), torch.tensor(tgt_in_ids), torch.tensor(tgt_out_ids)

再封装一个 Dataset 就齐了。跑 DataLoader 时设置batch_size=32，shuffle=True，用collate_fn传进去就行。

3. 模型核心代码：Encoder、Decoder 与 Attention

3.1 Encoder：理解输入序列

Encoder 我选择了双向 GRU。先说为什么双向：对话里有些信息需要从句尾回看句首。比如“我不喜欢他，但他帮过我”这句话，“他”到底指谁，需要往后多看几个字才能清楚。双向 GRU 一个方向从前往后编码，另一个方向从后往前编码，每个 token 的向量都同时包含前后文信息，效果明显更好。

双向 GRU 返回的hidden是两层方向的拼接，这里要用一个全连接层把它融合成 Decoder 能用的初始隐藏状态。直接拼会导致信息冗余和维度不匹配，过一层线性加 tanh 可以有效压缩特征。

class Encoder(nn.Module): def __init__(self, vocab_size, emb_size, hid_size): super().__init__() self.embedding = nn.Embedding(vocab_size, emb_size) self.gru = nn.GRU(emb_size, hid_size, bidirectional=True) self.fc = nn.Sequential( nn.Linear(2 * hid_size, 2 * hid_size), nn.Tanh() ) def forward(self, x): # x: (batch, src_len) emb = self.embedding(x) # (batch, src_len, emb_size) outputs, hidden = self.gru(emb) # outputs: (batch, src_len, 2*hid) # hidden: (2, batch, hid) hidden = torch.cat([hidden[0], hidden[1]], dim=-1) # (batch, 2*hid) hidden = self.fc(hidden).unsqueeze(0) # (1, batch, 2*hid) return outputs, hidden

注意这里outputs是每个输入位置的完整上下文向量序列，它要留给 Attention 使用。hidden是整句话的摘要，用来初始化 Decoder。

3.2 Decoder：逐字生成答案

Decoder 手里的牌比 Encoder 少一半——它拿不到未来信息，只能一步一步往前“猜”。它每生成一个字符，就把这个字符作为下一步输入，循环下去。这也是大模型里“自回归生成”的原始形态。

实现上，Decoder 的隐藏层大小我故意设为2 * hid_size，目的是和 Encoder 双向输出维度对齐，这样 attention 点积计算时不需要额外投影层，代码更干净。

class Decoder(nn.Module): def __init__(self, vocab_size, emb_size, hid_size): super().__init__() self.embedding = nn.Embedding(vocab_size, emb_size) self.gru = nn.GRU(emb_size, 2 * hid_size) self.out = nn.Linear(4 * hid_size, vocab_size) def forward(self, y, enc_outputs, enc_hidden): # y: (batch, tgt_len) emb = self.embedding(y) # (batch, tgt_len, emb_size) outputs, hidden = self.gru(emb, enc_hidden) # (batch, tgt_len, 2*hid) scores = torch.bmm(outputs, enc_outputs.transpose(1, 2)) attn_weights = F.softmax(scores, dim=-1) # (batch, tgt_len, src_len) context = torch.bmm(attn_weights, enc_outputs) # (batch, tgt_len, 2*hid) logits = self.out(torch.cat([outputs, context], dim=-1)) return logits, hidden

enc_hidden传给 GRU 后，GRU 内部会把它当作初始 hidden 使用，返回的hidden是最后一步的状态，推理时可以继续传给下一步。

3.3 Attention：带着问题找答案

这是很多初学者最容易懵的部分，我拆开讲。

Attention 的核心是算“当前该重点关注原文哪个位置”。Decoder 生成每一步时，都有一个当前步的隐藏状态outputs[:, t, :]，我把它和 Encoder 输出的所有位置enc_outputs[:, i, :]做点积，得到一个分数。分数越高，说明当前位置和生成当前词越相关。把这组分数过 softmax，变成了权重，再用这些权重对 Encoder 所有位置做加权平均，得到“上下文向量”。

上下文向量再和当前的 GRU 输出拼在一起，过一个全连接层得到词汇表上的分布。翻译成大白话就是：模型每写一个字之前，先回头看看原文哪些字“在用”，然后把“看到的重点”和“当前的想法”合并，最终决定写哪个字。

torch.bmm是批量矩阵乘法，它一次性算完所有时间步的 attention 分数，比循环快得多。这就是分块并行处理的直觉——能矩阵化计算就不写 for 循环，不光是效率，代码也简洁。

3.4 组合成完整 Seq2Seq

把 Encoder 和 Decoder 拼成一个完整模型，前向计算链路是：输入问题 token ❯ Encoder 编码 ❯ 得到语义向量和输出序列 ❯ Decoder 逐字生成 ❯ 输出每个位置的词表分布。

class Seq2Seq(nn.Module): def __init__(self, encoder, decoder): super().__init__() self.encoder = encoder self.decoder = decoder def forward(self, src, tgt_in): enc_outputs, enc_hidden = self.encoder(src) return self.decoder(tgt_in, enc_outputs, enc_hidden)

我建议新手先把三个类的 forward 后分别 print 出每个 tensor 的 shape，跑通一次前向再训练。这一步能帮你省掉至少两小时的调试时间。

4. 训练流程：Teacher Forcing 与超参调整

4.1 损失函数与标签对齐

Loss 用CrossEntropyLoss，但必须设置ignore_index=PAD_IDX，否则模型会把大量时间花在预测 pad 位置，损失的数值会被 padding 灌满，实际学习不到什么。

训练时模型输入的是tgt_in（前面加过<bos>），要预测的是tgt_out（末尾加了<eos>）。两者长度相同，直接 reshape 成(-1, vocab_size)和(-1)就能算 loss。这一步维度对齐是 Transformer 时代之后依然沿用的标准姿势。

4.2 训练循环与梯度裁剪

训练里有个关键技巧叫 Teacher Forcing。简单说，训练时每一步的输入都用“真实的上一个词”，而不是模型自己上一步预测出来的词。为什么这样做？因为刚开始模型预测得乱七八糟，如果让它拿自己的错误输出继续往后生成，错误会传播、叠加，最终什么都学不会。Teacher Forcing 相当于教练在旁边把正确答案喂给它，让它有机会学好每一局部再谈全局。

我实现的方式是用tgt_in一次性输入整个目标序列，这本身就是 100% 的 teacher forcing。代码更短，训练更快。有人会问要不要用 50% 概率的自由生成去混合训练，那是 schedule sampling，等模型能收敛之后再考虑，目前超纲。

训练循环还有一个必备操作：梯度裁剪。RNN 对梯度爆炸非常敏感，一个小学习率加clip_grad_norm_能省大量调参时间。

model = Seq2Seq(encoder, decoder) optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) criterion = nn.CrossEntropyLoss(ignore_index=PAD_IDX) for epoch in range(30): model.train() total_loss = 0 for src, tgt_in, tgt_out in dataloader: optimizer.zero_grad() logits, _ = model(src, tgt_in) loss = criterion(logits.reshape(-1, len(vocab)), tgt_out.reshape(-1)) loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) optimizer.step() total_loss += loss.item() print(f"epoch {epoch + 1}, loss: {total_loss / len(dataloader):.4f}")

跑 30 个 epoch 时，能看到 loss 从 2.3 一路掉到 0.3 以下，这时候模型已经有模有样了。

4.3 超参数经验表

下面是我这 10 条数据上实测比较稳的参数组合。小数据量下参数太大了容易过拟合，太小了学不动，表里的值可以作为起点。

一个经验：如果你的数据只有 10 条，别指望效果惊天动地。跑通流程的意义不是获得一个能上线的机器人，而是将来换大语料时，“怎样把数据变成张量、怎样对齐 label”这些环节你已经胸有成竹。

5. 推理生成与效果测试

5.1 贪心解码

训练好之后的模型拿到新输入时，没法再用 teacher forcing 拿到真实答案，只能“自己接自己的话”。最朴素的解码算法是贪心解码：每一步都取概率最大的那个字，作为下一步输入，直到出现<eos>或达到最大长度。

def greedy_decode(model, query, vocab, max_len=20): model.eval() tokens = [vocab.stoi["<bos>"]] + vocab.encode(query) + [vocab.stoi["<eos>"]] src = torch.tensor(tokens).unsqueeze(0) with torch.no_grad(): enc_outputs, enc_hidden = model.encoder(src) dec_input = torch.tensor([[vocab.stoi["<bos>"]]]) hidden = enc_hidden result = [] for _ in range(max_len): logits, hidden = model.decoder(dec_input, enc_outputs, hidden) next_id = logits.argmax(-1).item() if next_id == vocab.stoi["<eos>"]: break result.append(vocab.itos[next_id]) dec_input = torch.tensor([[next_id]]) return "".join(result)

贪心解码的问题是容易陷入局部最优。比如它有可能会生成“你好”后，下一步十分自信地生成“再见”，直接把对话结束。进阶方案是 Beam Search，它每一步存概率最高的前 k 个候选序列，最后从 k 个完整序列里挑得分最高的。下表是直觉对比：

在小 demo 里贪心已经足够，能让你看到模型学到的对话模式。

5.2 小模型的实际对话效果

实测下来，MiniChat 数据集训练的模型能生成这样的对话：

问：你好 答：你好呀，很高兴见到你 问：你叫什么名字 答：我叫小智，你呢 问：今天天气怎么样 答：天气不错，适合出门走走

如果换成真的只背了 10 条语料的模型，很多没见过的问法会直接触发<unk>或者<eos>提前结束。这不是 bug，是数据量太小导致的覆盖不足。下一次你在网上看到“大模型对话翻车”，很多其实也是数据覆盖问题，而不是模型结构问题。

所以这个 demo 验证的是什么？验证的是：一个 5 万参数左右的小模型，能够通过这么简单的训练流程，学会把“问题”和“回答”之间的对应联系编码进参数里。大的对话系统之所以复杂，不是在基础原理上多出什么神迹，而是在“数据量、模型容量、场景适配”这三个维度上不断加码。

5.3 从 Seq2Seq 到现代大模型

你一旦理解这个模型，再去看 GPT 的生成过程就非常顺：输入一段文本，模型预测下一个 token的概率分布，采样一个 token，把它接到输入后面，继续预测下一个。这就是 Decoder 的自回归逻辑，一模一样。注意力机制在 Transformer 里被升级成了 self-attention，让每个 token 都能同时看到序列中所有位置的其它 token，并行度更高，长距离依赖也更强。

我见过不少人直接拿 Ollama 跑开源模型跑通了本地部署，但一问到“finetune 时改了哪些层”“context length 超了会怎样”就答不上来。玩大模型的正确姿势，是先有这种几千行代码的控制感，再去看几十亿参数的黑盒。

6. 常见问题与排查技巧

6.1 训练 Loss 不下降怎么办

最常见原因是学习率设置太大，Loss 在某个值附近震荡。解决办法是先降到1e-4试试。如果还不行，检查词表里是不是有大量<unk>，说明数据集太小，很多测试字没见过。另一个容易被忽视的点是：collate_fn 中的 padding 逻辑有没有写错，如果 target 和 input 的长度没对齐，loss 数值会很怪。我常用一招，直接打印一个 batch 的src、tgt_in、tgt_out，人工检查每个序列的起始和结束 token 是否符合预期。

6.2 预测输出全是一个字，或者触发 EOS

这是 Seq2Seq 训练里最常见的问题之一。原因通常是：Decoder 的初始 hidden 和 GRU 维度不匹配，或者 encoder 双向 hidden 拼接顺序写错，导致解码器没有拿到任何有效的句子信息。还有一个原因：训练时 teacher forcing 效果太好，模型过分依赖真实前缀，一到推理环节暴露了自己的“猜词能力”。解决办法：一是检查初始 hidden 的计算；二是增加训练轮数，让模型在 teacher forcing 外尽快摸索出独立解码能力。

6.3 Attention 看不到正确位置

想排查 attention 问题，直接打印 attention 权重矩阵热力图。如果生成某个词时，模型给了<pad>很高的权重，说明 padding 位置干扰了模型。改进思路是构造 key mask，在算 softmax 前把 padding 位置的分数设成负无穷。小 demo 里通常不影响，但真实项目里这个 mask 是必须的。

6.4 长句效果差

RNN 类模型按序列逐个处理，长句子很容易丢失前面信息，这是结构性限制。如果将来要处理超过 30 个字的长句，短序列的 Seq2Seq 就不好使了。这点也解释了为什么现代大模型普遍使用 Transformer——attention 让每个 token 都能直接“看到”任何远距离 token，不再依赖顺序传导。

6.5 如何继续扩展成大模型

如果你已经跑通了这个小 demo，接下来的路就很清晰。先升级 Transformer：把 Encoder 和 Decoder 替换成 Transformer 层，训练逻辑基本不变。然后换大数据集：几万条对话起步。再了解预训练和微调：用开源基座模型，在自己的对话语料上做 fine-tune，这时 Ollama 和 vLLM 这类部署工具就派上用场了。

大模型上下文长度的处理、显卡显存如何规划、量化部署怎么做，这些都是后面系列文章要展开的内容。但不管往后走多远，Seq2Seq 教会你的那件事永远适用：模型再大，本质仍是“输入序列，条件生成”。

我最后再分享一个个人体会：第一次跑通这个小模型时，训练完发现输出全是“你好你好你好”，排查了一晚上才发现是 Decoder 的初始 hidden 维度不对。当时我特别焦虑，觉得模型太复杂了。后来我把所有 tensor shape 打印出来逐个核对，才意识到一小行unsqueeze就能解决所有问题。调模型这件事，绝大多数时间不是在看数学，而是在核对维度。建议你也从打印 shape 开始排查，比瞎猜超参数靠谱得多。