← 返回首页
🧠

Transformer原理详解

📂 llm ⏱ 2 min 308 words

--- title: "Transformer原理详解" description: "深入解析Transformer架构的核心组件和工作原理，理解现代大语言模型的基石" tags: ["Transformer", "深度学习", "NLP", "架构"] category: "llm" icon: "🧠"

Transformer原理详解

Transformer的诞生背景

在 Transformer 出现之前，序列建模主要依赖 RNN（循环神经网络）和 LSTM（长短期记忆网络）。这些模型存在两个关键问题：

  1. 无法并行处理：必须按顺序处理序列中的每个元素
  2. 长距离依赖问题：难以捕获序列中相距较远的元素之间的关系

2017 年，Google 团队提出了 Transformer 架构，通过自注意力机制解决了这些问题，彻底改变了自然语言处理领域。

Transformer的整体架构

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

输入序列 → [编码器] → 编码表示
                      ↓
输出序列 ← [解码器] ← 编码表示

编码器（Encoder）

编码器由 N 个相同的层堆叠而成，每层包含两个子层：

  1. 多头自注意力机制（Multi-Head Self-Attention）
  2. 前馈神经网络（Feed-Forward Network）

每个子层都使用残差连接（Residual Connection）和层归一化（Layer Normalization）。

解码器（Decoder）

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

  1. 掩码多头自注意力机制（Masked Multi-Head Self-Attention）
  2. 编码器-解码器注意力机制（Encoder-Decoder Attention）
  3. 前馈神经网络

核心组件详解

位置编码（Positional Encoding）

Transformer 没有循环结构，需要额外的位置信息来区分序列中不同位置的元素：

import torch
import math

def positional_encoding(max_len, d_model):
    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)
    return pe

# 生成位置编码
pe = positional_encoding(max_len=512, d_model=512)
print(f"位置编码形状: {pe.shape}")  # [512, 512]

自注意力机制（Self-Attention）

自注意力是 Transformer 最核心的组件。它允许序列中的每个位置都能关注到所有其他位置：

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

其中 Q（查询）、K（键）、V（值）分别由输入经过不同的线性变换得到。

多头注意力（Multi-Head Attention）

多头注意力将注意力机制扩展为多个并行的注意力头，每个头学习不同的表示子空间：

import torch.nn as nn

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super().__init__()
        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 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)
        
        # 计算注意力
        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)
        output = torch.matmul(attn, V)
        
        # 合并多头
        output = output.transpose(1, 2).contiguous().view(batch_size, -1, self.num_heads * self.d_k)
        return self.W_o(output)

前馈神经网络（FFN）

每个编码器和解码器层都包含一个全连接的前馈网络：

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

模型参数配置

以 Transformer 原论文的配置为例：

参数 值 说明
d_model 512 模型维度
num_heads 8 注意力头数
num_layers 6 编码器/解码器层数
d_ff 2048 前馈网络隐藏层维度
vocab_size 37000 词汇表大小
max_len 5000 最大序列长度

Transformer的优势

  1. 并行计算：自注意力机制可以并行处理整个序列，大幅提升训练速度
  2. 长距离依赖：任意两个位置之间的交互只需 O(1) 的操作
  3. 灵活性：同一架构可应用于各种序列到序列的任务
  4. 可扩展性：通过增加模型大小和数据量，性能持续提升

总结

Transformer 架构是现代大语言模型的基石。理解其核心组件——自注意力机制、多头注意力、位置编码和前馈网络——对于深入学习 LLM 至关重要。在下一篇文章中，我们将深入探讨注意力机制的数学原理。