第32课：机器翻译

📖 本课概述

机器翻译是序列到序列学习的经典任务。本课实现一个基于Transformer的翻译系统。

🌐 一、机器翻译发展

📐 二、BLEU评估指标

2.1 Transformer翻译实现

import torch
import torch.nn as nn
import math

# 机器翻译实现
print("=== Transformer机器翻译 ===")

# 词表
src_vocab_size = 1000
tgt_vocab_size = 800
d_model = 128
nhead = 4
num_layers = 2

# 模拟数据
torch.manual_seed(42)
max_src_len = 15
max_tgt_len = 12
batch_size = 32

X_src = torch.randint(1, src_vocab_size, (batch_size, max_src_len))
X_tgt = torch.randint(1, tgt_vocab_size, (batch_size, max_tgt_len))

# Transformer模型
class TranslationModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.src_embed = nn.Embedding(src_vocab_size, d_model)
        self.tgt_embed = nn.Embedding(tgt_vocab_size, d_model)
        self.transformer = nn.Transformer(
            d_model=d_model, nhead=nhead,
            num_encoder_layers=num_layers,
            num_decoder_layers=num_layers,
            dim_feedforward=d_model*4,
            dropout=0.1, batch_first=True
        )
        self.fc = nn.Linear(d_model, tgt_vocab_size)
    
    def forward(self, src, tgt, tgt_mask=None):
        src_emb = self.src_embed(src)
        tgt_emb = self.tgt_embed(tgt)
        out = self.transformer(src_emb, tgt_emb, tgt_mask=tgt_mask)
        return self.fc(out)

model = TranslationModel()
params = sum(p.numel() for p in model.parameters())
print(f"模型参数量: {params:,}")

# 生成因果掩码
def generate_causal_mask(sz):
    mask = torch.triu(torch.ones(sz, sz), diagonal=1).bool()
    return mask

tgt_mask = generate_causal_mask(max_tgt_len)

# 训练
optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)
loss_fn = nn.CrossEntropyLoss(ignore_index=0)

for epoch in range(0, 51, 10):
    optimizer.zero_grad()
    out = model(X_src, X_tgt[:, :-1], tgt_mask=generate_causal_mask(max_tgt_len-1))
    loss = loss_fn(out.reshape(-1, tgt_vocab_size), X_tgt[:, 1:].reshape(-1))
    loss.backward()
    optimizer.step()
    
    if epoch % 10 == 0:
        print(f"Epoch {epoch}: loss={loss.item():.4f}")

# BLEU计算
def compute_bleu(reference, hypothesis, max_n=4):
    """简化BLEU计算"""
    from collections import Counter
    
    ref_len = len(reference)
    hyp_len = len(hypothesis)
    
    if hyp_len == 0:
        return 0.0
    
    # BP
    bp = min(1.0, math.exp(1 - ref_len / hyp_len)) if hyp_len < ref_len else 1.0
    
    # n-gram精度
    precisions = []
    for n in range(1, max_n + 1):
        ref_ngrams = Counter([tuple(reference[i:i+n]) for i in range(len(reference)-n+1)])
        hyp_ngrams = Counter([tuple(hypothesis[i:i+n]) for i in range(len(hypothesis)-n+1)])
        
        clipped = sum(min(count, ref_ngrams[ng]) for ng, count in hyp_ngrams.items())
        total = max(sum(hyp_ngrams.values()), 1)
        precisions.append(clipped / total)
    
    avg_precision = math.exp(sum(math.log(max(p, 1e-10)) for p in precisions) / max_n)
    return bp * avg_precision

# BLEU示例
ref = [1, 2, 3, 4, 5]
hyp1 = [1, 2, 3, 4, 5]  # 完全匹配
hyp2 = [1, 2, 3, 6, 7]  # 部分匹配
hyp3 = [8, 9, 10, 11, 12]  # 完全不匹配

print(f"\nBLEU示例:")
print(f"完全匹配: BLEU={compute_bleu(ref, hyp1):.4f}")
print(f"部分匹配: BLEU={compute_bleu(ref, hyp2):.4f}")
print(f"完全不匹配: BLEU={compute_bleu(ref, hyp3):.4f}")

🔬 深入拓展

核心要点回顾

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

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

常见陷阱与最佳实践

与前后课程的联系

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

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

📖 延伸阅读

📝 练习

💡 翻译系统技巧

翻译优化

• Subword分词(BPE)
• Beam Search宽度5-10
• 反向模型做数据增强
• 集成多个模型

常见错误与解决方案

性能优化建议

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

核心概念网络

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

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

关键洞察与直觉

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

与其他课程的关联

本课作为实战项目阶段的核心内容，与前后课程紧密关联：

面试常见问题

进阶学习路径

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

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