← 返回首页
🤖

Transformer架构详解：现代AI的基石

📂 ai ⏱ 2 min 325 words
Transformer深度学习注意力机制

Transformer架构详解：现代AI的基石

引言

2017年，Google发表了划时代的论文《Attention is All You Need》，提出了Transformer架构。这一架构彻底改变了自然语言处理领域，并成为GPT、BERT等大语言模型的基础。

为什么需要Transformer？

传统的RNN和LSTM存在几个关键问题：

  1. 序列依赖：必须按顺序处理，无法并行化
  2. 长距离依赖：难以捕捉远距离的语义关系
  3. 梯度消失：序列越长，训练越困难

Transformer通过自注意力机制解决了这些问题。

Transformer的核心组件

1. 自注意力机制（Self-Attention）

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

计算公式：

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

其中：

2. 多头注意力（Multi-Head Attention）

多头注意力将注意力计算扩展到多个子空间，让模型能够同时关注不同位置的不同表示子空间。

import torch
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_model = d_model
        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, Q, K, V, mask=None):
        batch_size = Q.size(0)
        
        # 线性变换并分头
        Q = self.W_q(Q).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        K = self.W_k(K).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        V = self.W_v(V).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        
        # 计算注意力
        scores = torch.matmul(Q, K.transpose(-2, -1)) / (self.d_k ** 0.5)
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
        attention = torch.softmax(scores, dim=-1)
        output = torch.matmul(attention, V)
        
        # 合并多头
        output = output.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)
        return self.W_o(output)

3. 位置编码（Positional Encoding）

由于Transformer没有循环结构，需要额外的位置信息来区分不同位置的词。

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_len=5000):
        super().__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)
        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)]

4. 前馈网络（Feed-Forward Network）

每个Transformer层都包含一个前馈网络，通常由两个线性变换和一个激活函数组成。

class FeedForward(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.relu = nn.ReLU()
    
    def forward(self, x):
        return self.linear2(self.dropout(self.relu(self.linear1(x))))

Transformer编码器

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

  1. 多头自注意力机制
  2. 前馈网络
  3. 残差连接和层归一化
class TransformerEncoderLayer(nn.Module):
    def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
        super().__init__()
        self.self_attention = MultiHeadAttention(d_model, num_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):
        # 自注意力 + 残差 + 归一化
        attention_output = self.self_attention(x, x, x, mask)
        x = self.norm1(x + self.dropout(attention_output))
        
        # 前馈网络 + 残差 + 归一化
        ff_output = self.feed_forward(x)
        x = self.norm2(x + self.dropout(ff_output))
        
        return x

Transformer解码器

解码器在编码器的基础上增加了：

  1. 掩码多头注意力（防止看到未来位置）
  2. 编码器-解码器注意力（关注编码器输出）

Transformer的优势

  1. 并行计算：所有位置可以同时计算，大大加速训练
  2. 长距离依赖：自注意力可以直接建立任意距离的连接
  3. 可解释性：注意力权重可以可视化，理解模型关注点
  4. 灵活性：可以处理任意长度的序列

实际应用

总结

Transformer架构通过自注意力机制实现了高效的序列建模，成为现代AI的基石。理解Transformer的原理对于深入学习大语言模型至关重要。