Transformer架构详解

字数统计: 1.4k字   |   阅读时长≈ 6分

Transformer架构详解：从原理到实战

一、引言：为什么需要Transformer？

在深度学习的发展历程中，序列建模一直是一个核心挑战。传统的循环神经网络（RNN）和长短期记忆网络（LSTM）虽然在机器翻译、文本生成等任务中取得了显著成果，但它们存在两个关键缺陷：

  1. 序列计算瓶颈：RNN必须按时间步顺序处理数据，无法并行计算，导致训练速度缓慢
  2. 长距离依赖问题：尽管LSTM通过门控机制缓解了梯度消失，但在处理超长序列时，信息仍然会逐渐衰减

2017年，Google团队在论文《Attention Is All You Need》中提出了Transformer架构，彻底改变了这一局面。Transformer摒弃了循环结构，完全基于自注意力机制（Self-Attention），实现了高效的并行计算，同时能够捕捉任意距离的依赖关系。

如今，Transformer已成为自然语言处理（NLP）领域的基础架构，BERT、GPT、T5等主流模型均基于此。本文将深入剖析Transformer的核心原理，并通过代码示例帮助你快速上手。

二、技术原理详解

2.1 整体架构概览

Transformer采用编码器-解码器（Encoder-Decoder）结构。编码器将输入序列映射为连续表示，解码器则基于该表示生成输出序列。每个编码器和解码器由多个相同的层堆叠而成。

核心组件包括：

  • 多头自注意力（Multi-Head Self-Attention）
  • 前馈神经网络（Feed-Forward Neural Network）
  • 残差连接与层归一化（Residual Connection & Layer Normalization）
  • 位置编码（Positional Encoding）

2.2 自注意力机制

自注意力机制是Transformer的灵魂。它允许模型在处理某个位置时，关注输入序列中的所有其他位置，从而捕捉全局依赖。

计算步骤：

  1. 对输入向量X分别乘以三个权重矩阵Wq、Wk、Wv，得到Query、Key、Value
  2. 计算Query与所有Key的点积，得到注意力分数
  3. 对分数进行缩放（除以√d_k）并应用Softmax归一化
  4. 将归一化后的权重与Value加权求和

公式表示为：

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

2.3 多头注意力

多头注意力将上述过程并行执行多次，每次使用不同的线性投影，从而让模型关注不同子空间的信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import torch
import torch.nn as nn
import math

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        assert d_model % n_heads == 0
        
        self.d_model = d_model
        self.n_heads = n_heads
        self.d_k = d_model // n_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, x, mask=None):
        batch_size = x.size(0)
        
        # 线性投影并分割多头
        Q = self.W_q(x).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
        K = self.W_k(x).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
        V = self.W_v(x).view(batch_size, -1, self.n_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_weights = torch.softmax(scores, dim=-1)
        
        # 加权求和
        context = torch.matmul(attn_weights, V)
        context = context.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)
        
        return self.W_o(context)

2.4 位置编码

由于自注意力机制本身不具备序列顺序信息（它是对集合的操作），必须显式注入位置信息。Transformer使用正弦和余弦函数生成位置编码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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).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)
        
        self.register_buffer('pe', pe.unsqueeze(0))
        
    def forward(self, x):
        return x + self.pe[:, :x.size(1)]

这种编码方式的优势在于：能够表示相对位置信息，且无需额外参数。

三、实战代码示例：构建小型Transformer

下面我们实现一个完整的Transformer编码器层，并用于文本分类任务。

3.1 编码器层实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class TransformerEncoderLayer(nn.Module):
    def __init__(self, d_model, n_heads, d_ff, dropout=0.1):
        super().__init__()
        
        self.self_attn = MultiHeadAttention(d_model, n_heads)
        self.feed_forward = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(d_ff, d_model)
        )
        
        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.self_attn(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

3.2 完整Transformer分类器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
class TransformerClassifier(nn.Module):
    def __init__(self, vocab_size, d_model=512, n_heads=8, 
                 n_layers=6, d_ff=2048, num_classes=2, max_len=100):
        super().__init__()
        
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.pos_encoding = PositionalEncoding(d_model, max_len)
        
        self.encoder_layers = nn.ModuleList([
            TransformerEncoderLayer(d_model, n_heads, d_ff)
            for _ in range(n_layers)
        ])
        
        self.classifier = nn.Linear(d_model, num_classes)
        self.dropout = nn.Dropout(0.1)
        
    def forward(self, x, mask=None):
        # 词嵌入 + 位置编码
        x = self.embedding(x)
        x = self.pos_encoding(x)
        x = self.dropout(x)
        
        # 通过编码器层
        for layer in self.encoder_layers:
            x = layer(x, mask)
        
        # 取[CLS]标记的输出（假设第一个token是分类标记）
        cls_output = x[:, 0, :]
        
        return self.classifier(cls_output)

# 使用示例
model = TransformerClassifier(vocab_size=10000, num_classes=2)
dummy_input = torch.randint(0, 10000, (32, 50))  # batch=32, seq_len=50
output = model(dummy_input)
print(f"输出形状: {output.shape}")  # torch.Size([32, 2])

四、最佳实践建议

4.1 训练技巧

  1. 学习率调度：使用Warmup策略，先线性增加学习率，再按步长衰减
  2. 梯度裁剪：将梯度范数限制在1.0以内，防止梯度爆炸
  3. 标签平滑：用soft标签代替硬标签，提高泛化能力

4.2 模型配置经验

  • 小规模任务：d_model=256, n_heads=4, n_layers=3
  • 中等规模：d_model=512, n_heads=8, n_layers=6
  • 大规模任务：d_model=1024, n_heads=16, n_layers=12

4

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、聚合支付、
开源爱好者、Linux

联系QQ:2067409116

很惭愧

只做了一点微小的工作
谢谢大家
切换形象
转人工
🔮 今日运势
✨ 切换至 Live2D
收起
客服系统
🗑️ ✕

确定要重置当前对话吗？

确定
取消