Transformers 简介：深度学习架构的革命

原创于 2025-12-01 19:17:51 发布 · 716 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#架构 #Transformer #ai

AI 同时被 2 个专栏收录

73 篇文章

订阅专栏

Architect

5 篇文章

订阅专栏

Transformers 简介：深度学习架构的革命

历史背景与发展

从RNN到Transformer的演进

在Transformer出现之前，循环神经网络（RNN）及其变体（LSTM、GRU）是处理序列数据的主流方法。然而，这些架构存在一些固有的局限性：

RNN的主要问题：

梯度消失/爆炸：在长序列中，梯度难以有效传播
顺序计算：无法并行处理，训练效率低
长距离依赖：难以捕捉序列中相距较远的元素之间的关系
记忆容量有限：随着序列增长，早期信息容易丢失

Transformer的诞生

2017年，Google的研究团队在论文《Attention Is All You Need》中提出了Transformer架构，彻底改变了自然语言处理领域。这篇论文的核心思想是：完全摒弃循环结构，仅使用注意力机制来处理序列数据。

关键创新点：

完全基于注意力机制，无需循环或卷积
支持并行计算，大幅提高训练效率
能够捕捉长距离依赖关系
为后续的预训练模型（BERT、GPT等）奠定基础

核心架构概览

整体结构

Transformer遵循经典的编码器-解码器架构，但完全基于注意力机制：

输入序列 → 编码器 → 解码器 → 输出序列

编码器（Encoder）

编码器由N个相同的层堆叠而成（原始论文中N=6），每层包含两个子层：

多头自注意力机制（Multi-Head Self-Attention）
位置前馈网络（Position-wise Feed-Forward Network）

每个子层都使用残差连接和层归一化：

输出 = LayerNorm(输入 + 子层(输入))

解码器（Decoder）

解码器同样由N个相同的层堆叠而成，但每层包含三个子层：

掩码多头自注意力机制（Masked Multi-Head Self-Attention）
编码器-解码器注意力机制（Encoder-Decoder Attention）
位置前馈网络（Position-wise Feed-Forward Network）

注意力机制详解

什么是注意力？

注意力机制的核心思想是：在处理序列的某个位置时，让模型能够"关注"序列中的其他位置。

缩放点积注意力（Scaled Dot-Product Attention）

这是Transformer中最基本的注意力形式：

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

其中：

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

自注意力（Self-Attention）

自注意力是Transformer的核心创新。在这种机制中，Q、K、V都来自同一个输入序列：

对输入序列的每个位置，计算其与其他所有位置的关联度
使用这些关联度作为权重，对序列信息进行加权求和
这样每个位置都能获取到整个序列的上下文信息

自注意力的优势：

全局感受野：每个位置都能直接访问序列中的所有位置
并行计算：所有位置可以同时计算
长距离依赖：轻松捕捉序列中任意两个位置之间的关系

位置编码

为什么需要位置编码？

由于Transformer没有循环结构，模型本身无法感知序列中元素的顺序。为了解决这个问题，需要显式地加入位置信息。

正弦位置编码

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

PE(pos, 2i) = sin(pos / 10000^(2i/d_model))
PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))

其中：

pos：位置索引
i：维度索引
d_model：模型维度

位置编码的性质

相对位置信息：可以表示相对位置关系
外推能力：能够处理训练时未见过的更长序列
周期性：具有周期性特征，有助于模型学习位置模式

多头注意力

概念

多头注意力通过将注意力机制应用多次（使用不同的线性变换）来增强模型的表达能力：

MultiHead(Q, K, V) = Concat(head_1, ..., head_h)W^O

where head_i = Attention(QW_i^Q, KW_i^K, VW_i^V)

多头的好处

多维度关注：不同的头可以关注不同类型的关系
增强表达能力：多个线性变换提供更多的参数和学习能力
稳定性：多个头的平均效果通常更稳定

实际效果

在实践中，不同的注意力头往往会学习到不同的语言特征：

有些头关注语法关系
有些头关注语义关系
有些头关注长距离依赖

前馈网络与层归一化

位置前馈网络

每个注意力子层后面都有一个全连接前馈网络：

FFN(x) = max(0, xW_1 + b_1)W_2 + b_2

这个网络：

位置独立：同一个网络应用于所有位置
非线性变换：通过ReLU激活函数引入非线性
维度扩展：通常将维度扩展4倍再压缩回来

层归一化（Layer Normalization）

层归一化有助于稳定训练过程：

LayerNorm(x) = γ * (x - μ) / σ + β

其中μ和σ是x的均值和标准差，γ和β是可学习的参数。

残差连接

残差连接帮助梯度更好地传播：

输出 = 层归一化(输入 + 子层输出)

Transformer变体

BERT（Bidirectional Encoder Representations from Transformers）

架构：仅使用编码器部分
创新：双向上下文理解
预训练任务：
- 掩码语言模型（MLM）
- 下一句预测（NSP）
应用：文本分类、命名实体识别、问答系统等

GPT（Generative Pre-trained Transformer）

架构：仅使用解码器部分
创新：自回归语言建模
预训练：大规模无监督文本生成
应用：文本生成、对话系统、代码生成等

T5（Text-to-Text Transfer Transformer）

架构：完整的编码器-解码器结构
创新：将所有NLP任务统一为文本到文本的格式
预训练：去噪自编码器目标
应用：翻译、摘要、问答、分类等

其他重要变体

Vision Transformer (ViT)：将Transformer应用于计算机视觉
Swin Transformer：层次化的视觉Transformer
Efficient Transformers：各种优化注意力机制的方法

应用领域

自然语言处理

核心应用：

机器翻译
文本摘要
问答系统
情感分析
命名实体识别
文本分类

具体案例：

Google Translate使用Transformer架构
ChatGPT基于GPT系列模型
各种智能客服系统

计算机视觉

Vision Transformer的应用：

图像分类
目标检测
语义分割
图像生成

优势：

全局感受野
更好的长距离依赖建模
与NLP技术的统一架构

多模态应用

CLIP：连接文本和图像

文本-图像检索
零样本分类
图像生成指导

DALL-E：文本到图像生成

创造性图像生成
概念组合
艺术风格迁移

代码生成

GitHub Copilot：基于Codex模型

代码自动补全
函数生成
代码解释

AlphaCode：DeepMind的编程助手

竞赛编程
算法问题解决

实现细节与代码示例

PyTorch实现基础Transformer

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

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super().__init__()
        assert d_model % num_heads == 0
        
        self.d_model = d_model
        self.num_heads = num_heads
        self.d_k = d_model // num_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 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
    
    def forward(self, query, key, value, mask=None):
        batch_size = query.size(0)
        
        # 线性变换并分头
        Q = self.W_q(query).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        K = self.W_k(key).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        V = self.W_v(value).view(batch_size, -1, self.num_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, -1, self.d_model
        )
        
        output = self.W_o(attention_output)
        
        return output, attention_weights

class PositionwiseFeedForward(nn.Module):
    def __init__(self, d_model, d_ff):
        super().__init__()
        self.fc1 = nn.Linear(d_model, d_ff)
        self.fc2 = nn.Linear(d_ff, d_model)
        self.relu = nn.ReLU()
        
    def forward(self, x):
        return self.fc2(self.relu(self.fc1(x)))

class TransformerBlock(nn.Module):
    def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
        super().__init__()
        self.attention = MultiHeadAttention(d_model, num_heads)
        self.feed_forward = PositionwiseFeedForward(d_model, d_ff)
        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, x, 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

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_seq_length=5000):
        super().__init__()
        
        pe = torch.zeros(max_seq_length, d_model)
        position = torch.arange(0, max_seq_length, dtype=torch.float).unsqueeze(1)
        
        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).transpose(0, 1)
        self.register_buffer('pe', pe)
        
    def forward(self, x):
        return x + self.pe[:x.size(0), :]

训练技巧

学习率调度：使用热身（warmup）策略
标签平滑：防止过拟合
dropout：正则化技术
梯度裁剪：防止梯度爆炸
检查点：保存最佳模型

与其他架构的比较

Transformer vs RNN

特性	Transformer	RNN/LSTM
并行化	✅ 完全并行	❌ 顺序计算
长距离依赖	✅ 直接建模	❌ 梯度消失
计算复杂度	O(n²d)	O(nd²)
内存使用	随序列长度平方增长	线性增长
训练速度	快	慢
推理速度	随长度增加而变慢	稳定

Transformer vs CNN

特性	Transformer	CNN
感受野	全局	局部（需堆叠扩大）
归纳偏置	少	强（平移不变性）
数据需求	大	相对较小
计算效率	序列长度平方	与输入大小线性相关
最适合	序列建模	局部特征提取