第20课：Transformer原理

📖 本课概述

Transformer彻底改变了NLP乃至整个深度学习的格局。本课深入理解"Attention is All You Need"的核心创新。

🏗️ 一、Transformer架构总览

1.1 编码器-解码器结构

1.2 核心创新

• 完全基于注意力，无任何循环或卷积
• 并行计算，训练速度远超RNN
• 多头注意力捕获不同子空间的信息
• 位置编码注入序列顺序信息

📐 二、多头注意力

🔧 三、前馈网络(FFN)

3.1 PyTorch实现Transformer

import torch
import torch.nn as nn
import math

# Transformer实现
class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, n_head):
        super().__init__()
        self.d_model = d_model
        self.n_head = n_head
        self.d_k = d_model // n_head
        
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)
    
    def forward(self, Q, K, V, mask=None):
        B = Q.size(0)
        Q = self.W_q(Q).view(B, -1, self.n_head, self.d_k).transpose(1, 2)
        K = self.W_k(K).view(B, -1, self.n_head, self.d_k).transpose(1, 2)
        V = self.W_v(V).view(B, -1, self.n_head, self.d_k).transpose(1, 2)
        
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
        attn = torch.softmax(scores, dim=-1)
        context = torch.matmul(attn, V)
        
        context = context.transpose(1, 2).contiguous().view(B, -1, self.d_model)
        return self.W_o(context)

class TransformerBlock(nn.Module):
    def __init__(self, d_model, n_head, d_ff, dropout=0.1):
        super().__init__()
        self.attn = MultiHeadAttention(d_model, n_head)
        self.ffn = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.ReLU(),
            nn.Linear(d_ff, d_model)
        )
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)
    
    def forward(self, x, mask=None):
        x = x + self.dropout(self.attn(x, x, x, mask))
        x = self.norm1(x)
        x = x + self.dropout(self.ffn(x))
        x = self.norm2(x)
        return x

# 测试
d_model = 128
n_head = 4
model = TransformerBlock(d_model, n_head, d_model*4)
x = torch.randn(2, 20, d_model)
out = model(x)
params = sum(p.numel() for p in model.parameters())
print(f"Transformer Block: 输入{list(x.shape)} → 输出{list(out.shape)}")
print(f"参数量: {params:,}")

# PyTorch内置Transformer
print("\n=== PyTorch内置Transformer ===")
transformer = nn.Transformer(d_model=128, nhead=4, num_encoder_layers=2, num_decoder_layers=2, dim_feedforward=512)
src = torch.randn(20, 2, 128)
tgt = torch.randn(15, 2, 128)
out = transformer(src, tgt)
print(f"输入: src={list(src.shape)}, tgt={list(tgt.shape)}")
print(f"输出: {list(out.shape)}")
print(f"参数量: {sum(p.numel() for p in transformer.parameters()):,}")

# 掩码注意力
print("\n=== 因果掩码（自回归）===")
seq_len = 8
mask = torch.tril(torch.ones(seq_len, seq_len)).unsqueeze(0).unsqueeze(0)
print(f"因果掩码(下三角):")
for i in range(seq_len):
    print(f"  位置{i}: 可见位置={mask[0,0,i].nonzero().squeeze().tolist()}")

🔬 深入拓展

核心要点回顾

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

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

常见陷阱与最佳实践

与前后课程的联系

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

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

📖 延伸阅读

📝 练习

💡 Transformer实践

训练大模型

• Warmup必不可少
• 学习率1e-4到5e-4
• AdamW优于Adam
• 注意序列长度限制

常见错误与解决方案

性能优化建议

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

核心概念网络

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

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

关键洞察与直觉

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

与其他课程的关联

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

面试常见问题

进阶学习路径

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

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