第18课：序列到序列模型

📖 本课概述

Seq2Seq模型实现了"输入序列→输出序列"的映射，是机器翻译、文本摘要的基础。本课深入Encoder-Decoder架构和训练技巧。

🔄 一、Seq2Seq架构

1.1 编码器-解码器

1.2 Teacher Forcing

训练时用真实标签作为下一步输入，而不是模型自己的预测。加速收敛但可能导致暴露偏差。

1.3 束搜索 (Beam Search)

1.4 PyTorch实现Seq2Seq

import torch
import torch.nn as nn
import random

# Seq2Seq实现
class Encoder(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.rnn = nn.GRU(embed_dim, hidden_dim, batch_first=True)
    
    def forward(self, x):
        embedded = self.embedding(x)
        outputs, hidden = self.rnn(embedded)
        return outputs, hidden

class Decoder(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.rnn = nn.GRU(embed_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, vocab_size)
    
    def forward(self, x, hidden):
        embedded = self.embedding(x)
        output, hidden = self.rnn(embedded, hidden)
        prediction = self.fc(output)
        return prediction, hidden

# 简单数字翻译任务：将数字序列"翻译"成逆序
vocab_size = 20
embed_dim = 32
hidden_dim = 64

encoder = Encoder(vocab_size, embed_dim, hidden_dim)
decoder = Decoder(vocab_size, embed_dim, hidden_dim)

optimizer = torch.optim.Adam(list(encoder.parameters()) + list(decoder.parameters()), lr=0.001)
loss_fn = nn.CrossEntropyLoss(ignore_index=0)

# 生成训练数据：输入[1,2,3] → 目标[3,2,1]
def generate_data(batch_size, max_len=8):
    src = torch.randint(1, 10, (batch_size, max_len))
    tgt = src.flip(1)
    # 加SOS和EOS
    tgt_input = torch.cat([torch.full((batch_size,1), 11), tgt], dim=1)
    tgt_output = torch.cat([tgt, torch.full((batch_size,1), 12)], dim=1)
    return src, tgt_input, tgt_output

# 生成固定训练数据集
train_src, train_tgt_in, train_tgt_out = generate_data(64)

print("=== Seq2Seq训练（数字逆序任务）===")
for epoch in range(501):
    optimizer.zero_grad()
    
    # 编码
    _, hidden = encoder(train_src)
    
    # 解码（Teacher Forcing）
    output, _ = decoder(train_tgt_in, hidden)
    
    loss = loss_fn(output.reshape(-1, vocab_size), train_tgt_out.reshape(-1))
    loss.backward()
    optimizer.step()
    
    if epoch % 100 == 0:
        print(f"Epoch {epoch}: loss={loss.item():.4f}")

# 推理演示（自回归解码）
print("\n=== 推理示例 ===")
encoder.eval()
decoder.eval()
test_src = torch.randint(1, 10, (3, 8))
test_tgt_expected = test_src.flip(1)
with torch.no_grad():
    _, hidden = encoder(test_src)
    input_token = torch.full((3, 1), 11, dtype=torch.long)  # SOS
    result = []
    for t in range(8):
        output, hidden = decoder(input_token, hidden)
        pred = output.argmax(2)
        result.append(pred)
        input_token = pred

result = torch.cat(result, dim=1)
for i in range(3):
    correct = (result[i] == test_tgt_expected[i]).all().item()
    print(f"输入: {test_src[i].tolist()} → 输出: {result[i].tolist()} → 期望: {test_tgt_expected[i].tolist()} {'✓' if correct else '✗'}")

🔬 深入拓展

核心要点回顾

本课的核心知识点构成了序列模型学习的重要一环。让我们从更高维度审视这些知识之间的关系：

• 理论层面：理解数学原理是正确应用的前提，每个公式背后都有直觉
• 工程层面：PyTorch提供了高效实现，但理解底层原理才能正确调试
• 实践层面：没有银弹，不同场景需要不同的策略组合

常见陷阱与最佳实践

与前后课程的联系

深度学习是一个整体——每一课的知识都不是孤立的：

• 优化器（第5课）的选择影响正则化（第6课）的效果
• 初始化（第7课）决定了训练能否开始
• CNN（第8-14课）的成功依赖训练技巧（第22-28课）
• Transformer（第20-21课）结合了注意力和位置编码
• 实战项目（第29-35课）综合运用所有知识

📖 延伸阅读

📝 练习

💡 Seq2Seq实践

翻译系统优化

• Teacher Forcing比例递减
• 束搜索宽度5-10
• 处理OOV词的subword方法
• 双向编码器+单向解码器

常见错误与解决方案

性能优化建议

🔬 深度拓展：从理论到实践

核心概念网络

理解本课内容需要将其置于更大的知识网络中。每个核心概念都不是孤立的，它们相互关联、相互支撑：

• 数学基础：线性代数、微积分、概率论是理解所有深度学习算法的根基
• 计算基础：自动微分、GPU并行计算让理论变为现实
• 工程基础：数据处理、模型设计、训练技巧的有机结合
• 领域知识：CV、NLP、语音等领域的先验知识指导模型设计

关键洞察与直觉

建立正确的直觉比记住公式更重要：

与其他课程的关联

本课作为序列模型阶段的核心内容，与前后课程紧密关联：

面试常见问题

进阶学习路径

掌握本课内容后，可以通过以下方式继续深入：

• 阅读本课相关的一手论文，理解原始动机和推导
• 复现论文的实验结果，验证自己的理解
• 尝试改进方法，思考为什么现有方法有局限
• 在真实项目或Kaggle竞赛中应用
• 关注该方向的最新进展（arXiv、顶级会议）

📐 补充：知识体系梳理

核心公式速查

将本课涉及的关键公式整理如下，方便回顾和记忆。理解每个公式背后的直觉比死记硬背更重要——试着用自然语言解释每个公式在做什么。

易混淆概念辨析

代码模板

以下是本课核心概念的标准PyTorch实现模板，可以直接用于实际项目：

• 定义模型时，继承nn.Module，实现__init__和forward
• 训练循环：zero_grad → forward → loss → backward → step
• 验证时使用model.eval()和torch.no_grad()
• 保存模型用torch.save(model.state_dict())
• 加载模型用model.load_state_dict(torch.load())