Transformer架构详解

Transformer架构自2017年提出以来，彻底改变了自然语言处理领域，成为现代AI模型的基础架构。

架构概述

整体结构

Transformer采用编码器-解码器（Encoder-Decoder）架构：

graph TD
    A[输入序列] --> B[编码器]
    B --> C[解码器]
    C --> D[输出序列]

• 编码器：将输入序列编码为内部表示
• 解码器：基于编码器输出生成目标序列

核心创新

1. 完全基于注意力机制：摒弃了RNN和CNN
2. 并行化处理：大幅提升训练效率
3. 长距离依赖建模：有效捕获序列中的长程关系

自注意力机制

数学原理

自注意力机制的核心公式：

Attention(Q, K, V) = softmax(QK^T / √d_k)V

其中：

• Q（Query）：查询矩阵
• K（Key）：键矩阵
• V（Value）：值矩阵
• d_k：键向量的维度

实现细节

import torch
import torch.nn as nn
import torch.nn.functional as F
import math

class SelfAttention(nn.Module):
    def __init__(self, d_model, d_k, d_v):
        super(SelfAttention, self).__init__()
        self.d_k = d_k
        self.d_v = d_v
        
        self.W_q = nn.Linear(d_model, d_k, bias=False)
        self.W_k = nn.Linear(d_model, d_k, bias=False)
        self.W_v = nn.Linear(d_model, d_v, bias=False)
        
    def forward(self, x, mask=None):
        # x: [batch_size, seq_len, d_model]
        batch_size, seq_len, d_model = x.size()
        
        # 计算Q, K, V
        Q = self.W_q(x)  # [batch_size, seq_len, d_k]
        K = self.W_k(x)  # [batch_size, seq_len, d_k]
        V = self.W_v(x)  # [batch_size, seq_len, d_v]
        
        # 计算注意力分数
        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)
        
        # 应用softmax
        attention_weights = F.softmax(scores, dim=-1)
        
        # 加权求和
        output = torch.matmul(attention_weights, V)
        
        return output, attention_weights

注意力机制直观理解

注意力机制允许模型在处理每个位置时，关注序列中的所有其他位置：

• Query：“我需要什么信息？”
• Key：“我有什么信息？”
• Value：“具体信息内容是什么？“

多头注意力

设计动机

多头注意力允许模型同时关注不同类型的信息：

• 不同头部可以学习不同的关系模式
• 增强模型的表达能力
• 提供更丰富的特征表示

实现代码

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super(MultiHeadAttention, self).__init__()
        assert d_model % n_heads == 0
        
        self.d_model = d_model
        self.n_heads = n_heads
        self.d_k = d_model // n_heads
        
        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, x, mask=None):
        batch_size, seq_len, d_model = x.size()
        
        # 计算Q, K, V并重塑为多头形式
        Q = self.W_q(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
        K = self.W_k(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
        V = self.W_v(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
        
        # 计算注意力
        attention_output, attention_weights = self.scaled_dot_product_attention(
            Q, K, V, mask)
        
        # 合并多头输出
        attention_output = attention_output.transpose(1, 2).contiguous().view(
            batch_size, seq_len, d_model)
        
        # 输出线性变换
        output = self.W_o(attention_output)
        
        return output, attention_weights
    
    def scaled_dot_product_attention(self, Q, K, V, mask=None):
        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)
        
        attention_weights = F.softmax(scores, dim=-1)
        output = torch.matmul(attention_weights, V)
        
        return output, attention_weights

位置编码

为什么需要位置编码

由于Transformer没有循环或卷积结构，模型本身无法感知序列中的位置信息。位置编码为模型提供了位置感知能力。

正弦位置编码

原始Transformer使用正弦和余弦函数的位置编码：

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_len=5000):
        super(PositionalEncoding, self).__init__()
        
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len).unsqueeze(1).float()
        
        div_term = torch.exp(torch.arange(0, d_model, 2).float() *
                           -(math.log(10000.0) / d_model))
        
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        
        pe = pe.unsqueeze(0)
        self.register_buffer('pe', pe)
        
    def forward(self, x):
        return x + self.pe[:, :x.size(1)]

位置编码特性

• 唯一性：每个位置都有唯一的编码
• 相对位置感知：相近位置的编码相似
• 外推能力：可以处理训练时未见过的序列长度

前馈网络

结构设计

每个Transformer层都包含一个前馈网络：

class FeedForward(nn.Module):
    def __init__(self, d_model, d_ff, dropout=0.1):
        super(FeedForward, self).__init__()
        self.linear1 = nn.Linear(d_model, d_ff)
        self.linear2 = nn.Linear(d_ff, d_model)
        self.dropout = nn.Dropout(dropout)
        
    def forward(self, x):
        return self.linear2(self.dropout(F.relu(self.linear1(x))))

作用机制

• 非线性变换：引入非线性激活函数
• 特征提取：学习更复杂的特征表示
• 维度变换：通常先升维再降维

残差连接和层归一化

残差连接

class TransformerBlock(nn.Module):
    def __init__(self, d_model, n_heads, d_ff, dropout=0.1):
        super(TransformerBlock, self).__init__()
        self.attention = MultiHeadAttention(d_model, n_heads)
        self.feed_forward = FeedForward(d_model, d_ff, dropout)
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)
        
    def forward(self, x, mask=None):
        # 自注意力 + 残差连接 + 层归一化
        attn_output, _ = self.attention(x, mask)
        x = self.norm1(x + self.dropout(attn_output))
        
        # 前馈网络 + 残差连接 + 层归一化
        ff_output = self.feed_forward(x)
        x = self.norm2(x + self.dropout(ff_output))
        
        return x

优势分析

• 梯度流动：缓解梯度消失问题
• 训练稳定性：提高深层网络的训练稳定性
• 收敛速度：加快模型收敛

完整Transformer实现

class Transformer(nn.Module):
    def __init__(self, vocab_size, d_model, n_heads, n_layers, d_ff, max_len, dropout=0.1):
        super(Transformer, self).__init__()
        self.d_model = d_model
        
        # 嵌入层
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.pos_encoding = PositionalEncoding(d_model, max_len)
        
        # Transformer层
        self.transformer_blocks = nn.ModuleList([
            TransformerBlock(d_model, n_heads, d_ff, dropout)
            for _ in range(n_layers)
        ])
        
        # 输出层
        self.ln_f = nn.LayerNorm(d_model)
        self.head = nn.Linear(d_model, vocab_size)
        
    def forward(self, x, mask=None):
        # 嵌入 + 位置编码
        x = self.embedding(x) * math.sqrt(self.d_model)
        x = self.pos_encoding(x)
        
        # 通过Transformer层
        for transformer in self.transformer_blocks:
            x = transformer(x, mask)
        
        # 最终输出
        x = self.ln_f(x)
        output = self.head(x)
        
        return output

应用场景

自然语言处理

• 机器翻译：BERT、GPT等模型的基础
• 文本生成：GPT系列模型
• 文本理解：BERT、RoBERTa等模型

计算机视觉

• Vision Transformer (ViT)：图像分类
• DETR：目标检测
• Swin Transformer：分层视觉表示

多模态应用

• CLIP：图像-文本理解
• DALL-E：文本到图像生成
• Flamingo：少样本学习

优势与局限

主要优势

1. 并行化训练：相比RNN可以并行处理
2. 长距离依赖：有效建模长序列关系
3. 可解释性：注意力权重提供可解释性
4. 迁移学习：预训练模型效果显著

主要局限

1. 计算复杂度：注意力机制的二次复杂度
2. 内存需求：大模型需要大量内存
3. 数据依赖：需要大量训练数据
4. 位置编码：固定长度限制

未来发展

效率优化

• Sparse Attention：稀疏注意力机制
• Linear Attention：线性复杂度注意力
• Efficient Transformers：各种效率优化方案

架构创新

• Switch Transformer：专家混合模型
• PaLM：路径语言模型
• GPT-4：多模态大模型

总结

Transformer架构通过自注意力机制革命性地改变了深度学习领域，其并行化处理能力和强大的表示学习能力使其成为现代AI系统的核心组件。随着技术的不断发展，Transformer将继续在各个领域发挥重要作用。