Transformer模型自2017年由Google提出以来，已成为自然语言处理和计算机视觉等多个领域的基石架构。其核心在于完全摒弃了循环神经网络（RNN）的顺序依赖，转而采用**自注意力（Self-Attention）机制**，实现了高效的并行计算。下面将对Transformer的核心组件进行逐一解析，并提供关键代码实现。 ### 一、模型整体架构 Transformer是一个典型的**编码器-解码器（Encoder-Decoder）** 结构。编码器负责将输入序列编码为富含上下文信息的连续表示，解码器则利用该表示以及已生成的部分输出，自回归地生成目标序列。 **核心流程如下：** 1. **输入嵌入**：将输入符号（如单词）转换为向量。 2. **位置编码**：为序列中的每个位置生成一个唯一的向量，并与嵌入向量相加，以注入序列的顺序信息。 3. **编码器堆叠**：输入经过N个相同的编码器层。每层包含一个**多头自注意力机制**和一个**前馈神经网络**，均伴有残差连接和层归一化。 4. **解码器堆叠**：输出经过N个相同的解码器层。每层包含一个**掩码多头自注意力机制**（用于防止信息泄露）、一个**编码器-解码器注意力机制**（用于关注编码器输出）和一个**前馈神经网络**，同样伴有残差连接和层归一化。 5. **线性层与Softmax**：解码器的最终输出通过一个线性层映射到词汇表大小，再经Softmax得到下一个词的概率分布。 ### 二、核心组件深度解析与代码实现 #### 1. 词嵌入与位置编码 **词嵌入（Embedding）** 将离散的词汇ID映射为连续的稠密向量。**位置编码（Positional Encoding）** 则至关重要，因为自注意力机制本身是位置无关的。Transformer使用正弦和余弦函数来生成位置编码。 ```python import torch import torch.nn as nn import math 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, 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) # 偶数位置使用sin [ref_1] pe[:, 1::2] = torch.cos(position * div_term) # 奇数位置使用cos [ref_1] pe = pe.unsqueeze(0).transpose(0, 1) self.register_buffer('pe', pe) # 注册为缓冲区，不参与训练 [ref_1] def forward(self, x): # x: [seq_len, batch_size, d_model] x = x + self.pe[:x.size(0), :] return x class TransformerEmbedding(nn.Module): """整合词嵌入和位置编码""" def __init__(self, vocab_size, d_model, max_len=5000, dropout=0.1): super().__init__() self.token_embedding = nn.Embedding(vocab_size, d_model) self.position_encoding = PositionalEncoding(d_model, max_len) self.dropout = nn.Dropout(dropout) self.layer_norm = nn.LayerNorm(d_model) # 层归一化 [ref_1] def forward(self, x): # x: [batch_size, seq_len] token_emb = self.token_embedding(x) # [batch_size, seq_len, d_model] token_emb = token_emb.transpose(0, 1) # [seq_len, batch_size, d_model] emb = self.position_encoding(token_emb) emb = self.dropout(emb) emb = self.layer_norm(emb) # 应用层归一化 [ref_1] return emb.transpose(0, 1) # 恢复为 [batch_size, seq_len, d_model] ``` #### 2. 缩放点积注意力机制 这是注意力机制的核心。其公式为：$\\text{Attention}(Q, K, V) = \\text{softmax}(\\frac{QK^T}{\\sqrt{d_k}})V$。缩放因子 $\\sqrt{d_k}$ 用于防止点积结果过大导致softmax梯度消失 [ref_1][ref_2]。 ```python def scaled_dot_product_attention(query, key, value, mask=None): """ query, key, value: [batch_size, num_heads, seq_len, d_k] mask: [batch_size, 1, 1, seq_len] 或 [batch_size, 1, seq_len, seq_len] """ d_k = query.size(-1) scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k) # 计算缩放点积 [ref_1] if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) # 将mask为0的位置填充为负无穷 attn_weights = torch.softmax(scores, dim=-1) output = torch.matmul(attn_weights, value) return output, attn_weights ``` #### 3. 多头注意力机制 将模型的**表示空间**投影到多个“头”上，允许模型在不同位置共同关注来自不同表示子空间的信息，增强了模型的表达能力 [ref_2][ref_3]。 ```python class MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads, 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 # 定义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) self.dropout = nn.Dropout(dropout) def forward(self, query, key, value, mask=None): batch_size = query.size(0) # 1. 线性投影并分头 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) # 2. 应用缩放点积注意力 x, attn = scaled_dot_product_attention(Q, K, V, mask) # x: [batch_size, num_heads, seq_len, d_k] # 3. 拼接多头结果 x = x.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model) # 4. 最终线性投影 output = self.w_o(x) return output, attn ``` #### 4. 前馈网络与残差连接 每个编码器和解码器层中都包含一个**位置级前馈网络（Position-wise Feed-Forward Network, FFN）**。它由两个线性变换和一个ReLU激活函数组成，对每个位置独立操作 [ref_1][ref_6]。**残差连接（Residual Connection）** 和**层归一化（Layer Normalization）** 是稳定深层网络训练的关键。 ```python class PositionwiseFeedForward(nn.Module): def __init__(self, d_model, d_ff, 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.activation = nn.GELU() # 常用GELU替代ReLU def forward(self, x): return self.linear2(self.dropout(self.activation(self.linear1(x)))) class EncoderLayer(nn.Module): """单个编码器层""" def __init__(self, d_model, num_heads, d_ff, dropout=0.1): super().__init__() self.self_attn = MultiHeadAttention(d_model, num_heads, dropout) self.feed_forward = PositionwiseFeedForward(d_model, d_ff, dropout) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.dropout1 = nn.Dropout(dropout) self.dropout2 = nn.Dropout(dropout) def forward(self, x, mask=None): # 子层1: 多头自注意力 + 残差 & 归一化 attn_output, _ = self.self_attn(x, x, x, mask) x = x + self.dropout1(attn_output) # 残差连接 x = self.norm1(x) # 层归一化 [ref_3][ref_6] # 子层2: 前馈网络 + 残差 & 归一化 ff_output = self.feed_forward(x) x = x + self.dropout2(ff_output) x = self.norm2(x) return x ``` #### 5. 编码器与解码器 编码器由N个上述的`EncoderLayer`堆叠而成。解码器结构类似，但包含两个注意力子层：**掩码多头自注意力**（防止看到未来信息）和**编码器-解码器注意力**（关注编码器输出）。 ```python class DecoderLayer(nn.Module): """单个解码器层""" def __init__(self, d_model, num_heads, d_ff, dropout=0.1): super().__init__() self.self_attn = MultiHeadAttention(d_model, num_heads, dropout) self.cross_attn = MultiHeadAttention(d_model, num_heads, dropout) # 编码器-解码器注意力 self.feed_forward = PositionwiseFeedForward(d_model, d_ff, dropout) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.norm3 = nn.LayerNorm(d_model) self.dropout1 = nn.Dropout(dropout) self.dropout2 = nn.Dropout(dropout) self.dropout3 = nn.Dropout(dropout) def forward(self, x, enc_output, src_mask=None, tgt_mask=None): # 子层1: 掩码自注意力 attn1, _ = self.self_attn(x, x, x, tgt_mask) x = x + self.dropout1(attn1) x = self.norm1(x) # 子层2: 编码器-解码器注意力 attn2, _ = self.cross_attn(x, enc_output, enc_output, src_mask) x = x + self.dropout2(attn2) x = self.norm2(x) # 子层3: 前馈网络 ff_output = self.feed_forward(x) x = x + self.dropout3(ff_output) x = self.norm3(x) return x ``` #### 6. 掩码机制 Transformer使用两种掩码： * **填充掩码（Padding Mask）**：在注意力计算中，忽略填充符`<pad>`的位置，防止其影响有效词的注意力权重。 * **序列掩码（Sequence Mask / Look-ahead Mask）**：在解码器的自注意力中，用于掩盖“未来”的位置，确保当前位置的预测仅依赖于已知输出，这是自回归生成的关键 [ref_1][ref_6]。 ```python def create_padding_mask(seq, pad_idx=0): # seq: [batch_size, seq_len] mask = (seq == pad_idx).unsqueeze(1).unsqueeze(2) # [batch_size, 1, 1, seq_len] return mask def create_look_ahead_mask(size): # 创建一个上三角矩阵，对角线及以下为1，以上为0 mask = torch.triu(torch.ones(size, size), diagonal=1).bool() # mask: [seq_len, seq_len] return mask.unsqueeze(0).unsqueeze(0) # [1, 1, seq_len, seq_len] ``` ### 三、应用场景与变体 Transformer的原生设计为机器翻译而生，但其影响力已远超NLP。以下是一些著名的变体与应用： | 模型/领域 | 核心改进/应用点 | 说明 | | :--- | :--- | :--- | | **BERT** (NLP) | 仅使用编码器，采用双向上下文训练。 | 通过掩码语言模型（MLM）进行预训练，成为众多NLP任务的强大基石 [ref_2]。 | | **GPT系列** (NLP) | 仅使用解码器，采用单向自回归训练。 | 专注于文本生成，通过预测下一个词进行预训练，参数规模不断增大 [ref_6]。 | | **Vision Transformer (ViT)** (CV) | 将图像分割为Patch序列进行处理。 | 将Transformer直接应用于图像分类，证明了其在非序列数据上的有效性 [ref_5]。 | | **xFormers** (优化库) | 提供内存高效注意力、稀疏注意力等算子。 | 旨在解决Transformer训练中的内存爆炸和速度瓶颈问题，提升训练效率 [ref_4]。 | ### 四、训练技巧 训练大型Transformer模型需要一些关键技巧： * **标签平滑（Label Smoothing）**：在计算交叉熵损失时，对真实标签进行平滑，防止模型过于自信，提升泛化能力 [ref_6]。 * **学习率调度（Learning Rate Scheduling）**：通常使用带热启动的余弦退火或逆平方根调度器，以稳定训练并加速收敛。 * **梯度裁剪（Gradient Clipping）**：裁剪梯度范数，防止训练不稳定和梯度爆炸 [ref_6]。 通过以上对Transformer核心组件的逐层解析与代码实现，可以清晰地看到其如何通过自注意力机制捕获长距离依赖，并通过模块化设计实现强大的表征学习能力。理解这些基础组件是进一步探索BERT、GPT等现代大模型架构的前提。