## Transformer网络结构原理详解 Transformer是一种基于自注意力机制的神经网络架构，它彻底摒弃了传统RNN/CNN的序列处理方式，实现了完全并行的序列建模，在自然语言处理和计算机视觉领域取得了革命性突破[ref_6]。 ### 一、核心架构：编码器-解码器结构 Transformer采用经典的编码器-解码器框架，其整体结构如下表所示： | 组件 | 数量 | 核心功能 | 关键技术 | |------|------|----------|----------| | **编码器** | N个（通常N=6） | 将输入序列转换为富含上下文信息的隐藏表示 | 多头自注意力 + 前馈神经网络 | | **解码器** | N个（通常N=6） | 基于编码器输出和已生成部分生成目标序列 | 掩码多头自注意力 + 编码器-解码器注意力 + 前馈网络 | ```python # Transformer整体结构伪代码 class Transformer(nn.Module): def __init__(self, num_encoders=6, num_decoders=6, d_model=512): super().__init__() self.encoders = nn.ModuleList([ EncoderLayer(d_model) for _ in range(num_encoders) ]) self.decoders = nn.ModuleList([ DecoderLayer(d_model) for _ in range(num_decoders) ]) def forward(self, src, tgt): # 编码器处理源序列 memory = src for encoder in self.encoders: memory = encoder(memory) # [ref_6] # 解码器生成目标序列 output = tgt for decoder in self.decoders: output = decoder(output, memory) # [ref_6] return output ``` ### 二、核心组件详解 #### 1. 自注意力机制（Self-Attention） 自注意力机制是Transformer的核心创新，它允许序列中的每个位置直接关注序列中的所有位置，从而捕获长距离依赖关系[ref_2]。 **计算过程：** 1. **QKV矩阵生成**：每个输入向量通过线性变换生成查询（Query）、键（Key）、值（Value）三个矩阵 2. **注意力分数计算**：通过Q和K的点积计算位置间的相关性 3. **Softmax归一化**：将注意力分数转换为概率分布 4. **加权求和**：用注意力权重对V进行加权求和 ```python import torch import torch.nn as nn import math class SelfAttention(nn.Module): def __init__(self, d_model=512, num_heads=8): super().__init__() self.d_model = d_model self.num_heads = num_heads self.d_k = d_model // num_heads # 线性变换层生成Q、K、V 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): batch_size, seq_len, _ = x.shape # 生成Q、K、V矩阵 Q = self.W_q(x) # [batch_size, seq_len, d_model] K = self.W_k(x) # [batch_size, seq_len, d_model] V = self.W_v(x) # [batch_size, seq_len, d_model] # 多头分割：将d_model维度分割为num_heads个头 Q = Q.view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) K = K.view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) V = V.view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) # 计算注意力分数：Q·K^T / sqrt(d_k) scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k) attention_weights = torch.softmax(scores, dim=-1) # [ref_2] # 加权求和 context = torch.matmul(attention_weights, V) # 合并多头 context = context.transpose(1, 2).contiguous().view( batch_size, seq_len, self.d_model ) # 输出投影 output = self.W_o(context) return output ``` #### 2. 多头注意力（Multi-Head Attention） 多头注意力通过并行运行多个自注意力头，从不同表示子空间学习信息，增强了模型的表达能力[ref_2]。 ```python class MultiHeadAttention(nn.Module): def __init__(self, d_model=512, num_heads=8, dropout=0.1): 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) self.dropout = nn.Dropout(dropout) def split_heads(self, x): """将输入分割为多个头""" batch_size, seq_len, _ = x.shape return x.view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) def forward(self, query, key, value, mask=None): batch_size = query.size(0) # 线性变换并分割多头 Q = self.split_heads(self.W_q(query)) K = self.split_heads(self.W_k(key)) V = self.split_heads(self.W_v(value)) # 计算缩放点积注意力 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 = torch.softmax(scores, dim=-1) attention_weights = self.dropout(attention_weights) # 加权求和 context = torch.matmul(attention_weights, V) # 合并多头 context = context.transpose(1, 2).contiguous().view( batch_size, -1, self.d_model ) # 输出投影 output = self.W_o(context) return output, attention_weights ``` #### 3. 位置编码（Positional Encoding） 由于自注意力机制本身不具备位置信息，Transformer通过位置编码为输入序列注入位置信息[ref_6]。 ```python class PositionalEncoding(nn.Module): def __init__(self, d_model=512, max_len=5000, dropout=0.1): super().__init__() self.dropout = nn.Dropout(dropout) # 创建位置编码矩阵 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) # [1, max_len, d_model] self.register_buffer('pe', pe) def forward(self, x): # x: [batch_size, seq_len, d_model] x = x + self.pe[:, :x.size(1)] return self.dropout(x) ``` #### 4. 前馈神经网络（Feed-Forward Network） 每个注意力层后都接一个前馈网络，进行非线性变换[ref_6]。 ```python class FeedForward(nn.Module): def __init__(self, d_model=512, d_ff=2048, dropout=0.1): super().__init__() self.linear1 = nn.Linear(d_model, d_ff) self.linear2 = nn.Linear(d_ff, d_model) self.dropout = nn.Dropout(dropout) self.relu = nn.ReLU() def forward(self, x): # 两层线性变换 + ReLU激活 return self.linear2(self.dropout(self.relu(self.linear1(x)))) ``` ### 三、完整编码器层实现 ```python class EncoderLayer(nn.Module): """Transformer编码器单层""" def __init__(self, d_model=512, num_heads=8, d_ff=2048, dropout=0.1): super().__init__() self.self_attn = MultiHeadAttention(d_model, num_heads, dropout) self.feed_forward = FeedForward(d_model, d_ff, dropout) # 层归一化 self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) # Dropout self.dropout1 = nn.Dropout(dropout) self.dropout2 = nn.Dropout(dropout) def forward(self, x, mask=None): # 多头自注意力 + 残差连接 + 层归一化 attn_output, _ = self.self_attn(x, x, x, mask) x = x + self.dropout1(attn_output) x = self.norm1(x) # [ref_6] # 前馈网络 + 残差连接 + 层归一化 ff_output = self.feed_forward(x) x = x + self.dropout2(ff_output) x = self.norm2(x) # [ref_6] return x ``` ### 四、Transformer在视觉领域的变体：Swin Transformer Swin Transformer通过引入**层次化特征图**和**滑动窗口注意力**，将Transformer成功应用于计算机视觉任务[ref_3]。 **核心创新点：** 1. **窗口多头自注意力**：将特征图划分为不重叠的窗口，在每个窗口内计算自注意力，大幅降低计算复杂度 2. **移位窗口**：通过周期性移动窗口边界，实现跨窗口的信息交互 3. **相对位置偏置**：为注意力分数添加可学习的相对位置偏置，更好地建模空间关系 ```python # Swin Transformer Block简化实现 class SwinTransformerBlock(nn.Module): def __init__(self, dim, num_heads, window_size=7, shift_size=0): super().__init__() self.window_size = window_size self.shift_size = shift_size # 窗口多头自注意力 self.attn = WindowAttention(dim, num_heads, window_size) # 前馈网络 self.mlp = FeedForward(dim) # 层归一化 self.norm1 = nn.LayerNorm(dim) self.norm2 = nn.LayerNorm(dim) def forward(self, x): # 保存残差连接 shortcut = x # 层归一化 + 窗口注意力 x = self.norm1(x) # 窗口划分和注意力计算 if self.shift_size > 0: # 移位窗口操作 x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2)) x_windows = window_partition(x, self.window_size) attn_windows = self.attn(x_windows) x = window_reverse(attn_windows, self.window_size, x.shape[1:3]) if self.shift_size > 0: # 恢复移位 x = torch.roll(x, shifts=(self.shift_size, self.shift_size), dims=(1, 2)) # 残差连接 x = shortcut + x # 前馈网络部分 x = x + self.mlp(self.norm2(x)) return x ``` ### 五、Transformer的优势与应用场景 #### 优势对比： | 特性 | Transformer | RNN/LSTM | CNN | |------|-------------|-----------|-----| | **并行性** | 完全并行 | 序列依赖，难以并行 | 局部并行 | | **长距离依赖** | 直接全局建模 | 通过门控机制缓解梯度消失 | 感受野有限 | | **计算复杂度** | O(n²) | O(n) | O(k×n) | | **位置信息** | 需显式编码 | 隐式包含 | 卷积核隐含 | #### 应用场景： 1. **自然语言处理**：机器翻译（原始应用）、文本生成、情感分析[ref_6] 2. **计算机视觉**：图像分类、目标检测（如YOLOv12的Transformer模块[ref_1]）、图像分割 3. **多模态任务**：视觉-语言模型、跨模态检索 ### 六、Transformer的关键改进方向 1. **计算效率优化**：线性注意力、稀疏注意力、局部注意力等变体降低O(n²)复杂度 2. **位置编码改进**：相对位置编码、旋转位置编码等更灵活的位置表示方法 3. **架构简化**：仅编码器（BERT）或仅解码器（GPT）的单向架构 4. **跨模态融合**：视觉-语言Transformer统一多模态表示学习 Transformer通过自注意力机制实现了对序列数据的全局建模，其并行计算特性使其在大规模预训练中展现出巨大优势。从最初的NLP任务扩展到计算机视觉领域，Transformer已成为深度学习领域最重要的基础架构之一[ref_5]。