# 人工智能之语言领域

第十二章 Transformer架构

---

> @[TOC](文章目录)

---

# 前言 Transformer架构

Transformer 是自然语言处理（NLP）领域的**革命性架构**，由 Google 在 2017 年论文《Attention Is All You Need》中提出。它**完全摒弃了 RNN 和 CNN**，仅依靠**注意力机制**实现序列建模，在机器翻译任务上首次超越传统模型，并成为 BERT、GPT 等大语言模型的基石。本章将系统解析 Transformer 的整体结构、核心组件、训练技巧、主流变体，并通过机器翻译实战完整演示其构建过程。

---

## 12.1 Transformer的整体架构

Transformer 采用经典的 **Encoder-Decoder** 架构，但内部完全由注意力和前馈网络堆叠而成。

```mermaid

graph TD
Input["源序列 (e.g., 'Hello world')"] --> E1["Encoder Layer 1"]
E1 --> E2["..."]
E2 --> EN["Encoder Layer N"]

EN --> D1["Decoder Layer 1"]
D1 --> D2["..."]
D2 --> DN["Decoder Layer N"]

DN --> Output["目标序列 (e.g., '你好 世界')"]

```

> 📌 **关键特点**：
> 
> - **并行化**：无 RNN 时序依赖，训练速度极快
> - **全局依赖**：自注意力直接建模任意距离词间关系
> - **可扩展性**：堆叠更多层可提升性能（如 BERT-base: 12 层, BERT-large: 24 层）

---

### 12.1.1 编码器（Encoder）结构详解

每个 Encoder 层包含两个子层：

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

每层后接 **残差连接 + 层归一化（LayerNorm）**。

```mermaid
flowchart TB
 X["输入 X"] --> Add1["\+"]
 X --> MHA["Multi-Head Self-Attention"]
 MHA --> LN1["LayerNorm"]
 LN1 --> Add1
 Add1 --> Y["输出 Y"]
 Y --> Add2["\+"]
 Y --> FFN["Position-wise FFN"]
 FFN --> LN2["LayerNorm"]
 LN2 --> Add2
```

> ✅ **作用**：
> 
> - 自注意力：捕获词间依赖
> - FFN：非线性变换，增强表达能力

---

### 12.1.2 解码器（Decoder）结构详解

每个 Decoder 层包含**三个子层**：

1. **掩码多头自注意力（Masked Multi-Head Self-Attention）**
2. **多头跨注意力（Multi-Head Cross-Attention）**
3. **前馈神经网络（FFN）**

同样使用残差连接 + LayerNorm。

```mermaid
flowchart TB
 Tgt["目标输入 (已生成部分)"] --> MaskedMHA["Masked Self-Attention"]
 MaskedMHA --> Add1["\+"]
 Tgt --> Add1
 Add1 --> LN1["LayerNorm"]
 LN1 --> CrossAttn["Cross-Attention (K,V=Encoder输出)"]
 Enc["Encoder输出"] --> CrossAttn
 CrossAttn --> Add2["\+"]
 LN1 --> Add2
 Add2 --> LN2["LayerNorm"]
 LN2 --> FFN["FFN"]
 FFN --> Add3["\+"]
 LN2 --> Add3
 Add3 --> Output["输出"]
```

> 🔒 **掩码机制（Masking）**：
> 防止解码器在预测第 $ t $ 个词时“偷看”未来词（$ t+1, t+2, ... $）。
> 实现：在注意力分数矩阵中，将未来位置设为 $ -\infty $，经 Softmax 后权重为 0。

---

### 12.1.3 残差连接与层归一化

#### 残差连接（Residual Connection）

- 公式：$ \text{Output} = \text{Layer}(X) + X $
- 作用：缓解梯度消失，支持深层网络训练

#### 层归一化（Layer Normalization）

- 对**单个样本的所有特征**做归一化（与 BatchNorm 不同）
- 公式：$ \text{LayerNorm}(x) = \gamma \frac{x - \mu}{\sigma} + \beta $
- 作用：稳定训练，加速收敛

> 💡 **顺序**：先残差连接，再 LayerNorm（Post-LN）；也有 Pre-LN 变体（先归一化）

---

## 12.2 Transformer的核心组件

### 12.2.1 位置编码（Positional Encoding）

**问题**：Transformer 无 RNN/CNN，**丢失序列顺序信息**！
**解决方案**：将位置信息注入输入嵌入。

#### 正弦位置编码（Sinusoidal PE）

$$
\begin{aligned}
PE_{(pos, 2i)} &= \sin\left(\frac{pos}{10000^{2i/d}}\right) \\
PE_{(pos, 2i+1)} &= \cos\left(\frac{pos}{10000^{2i/d}}\right)
\end{aligned}
$$

其中：

- $ pos $：词在序列中的位置（0,1,2,...）
- $ i $：维度索引（0 到 $ d/2 $）
- $ d $：嵌入维度

```python
import torch
import math

def positional_encoding(seq_len, d_model):
 pe = torch.zeros(seq_len, d_model)
 position = torch.arange(0, seq_len, dtype=torch.float).unsqueeze(1) # [seq_len, 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) # 奇数维
 return pe.unsqueeze(0) # [1, seq_len, d_model]

# 使用示例
pe = positional_encoding(50, 512) # 50个位置，512维
```

> ✅ **优势**：
> 
> - 可处理任意长度序列（理论上）
> - 不同位置编码正交，利于模型学习相对位置

> 🆚 **可学习位置编码**：BERT 等模型使用可训练的 Position Embedding（长度固定）

---

### 12.2.2 前馈神经网络（FFN）

每个位置独立应用相同的两层全连接网络：

$$
\text{FFN}(x) = \max(0, xW_1 + b_1) W_2 + b_2
$$

- 输入/输出维度：$ d_{\text{model}} $（如 512）
- 隐藏层维度：通常 $ d_{\text{ff}} = 2048 $（4倍扩大）

> 💡 **作用**：为每个 token 提供非线性变换能力，增强模型表达力

---

## 12.3 Transformer的训练与优化

### 12.3.1 损失函数与优化器选择

#### 损失函数

- **标准交叉熵损失（Cross-Entropy Loss）**
- 忽略填充 token（Padding）：`ignore_index=pad_id`

```python
criterion = nn.CrossEntropyLoss(ignore_index=0) # 假设0是<PAD>
loss = criterion(logits.view(-1, vocab_size), targets.view(-1))
```

#### 优化器

- **Adam 优化器**（带 warmup）
- 超参：$ \beta_1=0.9, \beta_2=0.98, \epsilon=10^{-9} $

---

### 12.3.2 训练技巧

#### （1）学习率调度：Warmup + Decay

- **Warmup**：前 $ n $ 步线性增大学习率（防早期不稳定）
- **Decay**：之后按平方根衰减

$$
\text{lr} = d_{\text{model}}^{-0.5} \cdot \min(\text{step}^{-0.5}, \text{step} \cdot \text{warmup\_steps}^{-1.5})
$$

```python
from transformers import get_linear_schedule_with_warmup

optimizer = torch.optim.Adam(model.parameters(), lr=0)
scheduler = get_linear_schedule_with_warmup(
 optimizer,
 num_warmup_steps=4000,
 num_training_steps=total_steps
)
```

#### （2）梯度裁剪（Gradient Clipping）

- 防止梯度爆炸
- 通常裁剪到 1.0

```python
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
```

---

## 12.4 Transformer的变体

### 12.4.1 轻量化Transformer

| 模型 | 核心思想 | 压缩方式 |
|------|--------|--------|
| **DistilBERT** | 知识蒸馏 | 用 BERT 教小模型，移除 token-type emb 和 pooler |
| **MobileBERT** | 瓶颈结构 | 引入 bottleneck 层减少计算量 |
| **ALBERT** | 参数共享 | 跨层共享参数，降低内存 |

> ✅ **适用场景**：移动端、边缘设备部署

---

### 12.4.2 长文本Transformer

标准 Transformer 的自注意力复杂度为 $ O(n^2) $，难以处理长文本（>512 tokens）。

| 模型 | 核心思想 | 复杂度 |
|------|--------|-------|
| **Longformer** | 局部窗口 + 全局注意力 | $ O(n) $ |
| **BigBird** | 随机注意力 + 滑动窗口 | $ O(n) $ |
| **Reformer** | LSH 哈希近似注意力 | $ O(n \log n) $ |

> 📊 **应用场景**：法律文档、科研论文、书籍摘要

---

## 12.5 实战：基于Transformer的机器翻译模型搭建

### 任务目标

构建一个英译德的小型 Transformer，训练数据使用 **Multi30k**（3万句对）。

### 完整代码实现（PyTorch）

```python
# Step 1: 安装依赖
# pip install torch torchtext spacy

import torch
import torch.nn as nn
import torch.nn.functional as F
import math
import spacy
from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator

# Step 2: 数据预处理（简化版）
# 实际项目建议使用 torchtext.datasets.Multi30k

# 假设已有平行语料: [(src_sent, tgt_sent), ...]
train_data = [
 ("hello world", "hallo welt"),
 ("good morning", "guten morgen"),
 # ... 更多数据
]

# 构建词表
def yield_tokens(data_iter, language):
 for src, tgt in data_iter:
 if language == 'en':
 yield src.split()
 else:
 yield tgt.split()

vocab_en = build_vocab_from_iterator(yield_tokens(train_data, 'en'), specials=['<unk>', '<pad>', '<sos>', '<eos>'])
vocab_de = build_vocab_from_iterator(yield_tokens(train_data, 'de'), specials=['<unk>', '<pad>', '<sos>', '<eos>'])

vocab_en.set_default_index(vocab_en['<unk>'])
vocab_de.set_default_index(vocab_de['<unk>'])

# Step 3: 位置编码
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)
 self.register_buffer('pe', pe.unsqueeze(0))

 def forward(self, x):
 return x + self.pe[:, :x.size(1), :]

# Step 4: Transformer 模型
class TransformerModel(nn.Module):
 def __init__(self, src_vocab_size, tgt_vocab_size, d_model=512, nhead=8, 
 num_encoder_layers=6, num_decoder_layers=6, dim_feedforward=2048, max_len=5000):
 super().__init__()
 self.d_model = d_model
 self.embedding_src = nn.Embedding(src_vocab_size, d_model)
 self.embedding_tgt = nn.Embedding(tgt_vocab_size, d_model)
 self.pos_encoder = PositionalEncoding(d_model, max_len)
 self.transformer = nn.Transformer(
 d_model=d_model, nhead=nhead,
 num_encoder_layers=num_encoder_layers,
 num_decoder_layers=num_decoder_layers,
 dim_feedforward=dim_feedforward,
 batch_first=True
 )
 self.fc_out = nn.Linear(d_model, tgt_vocab_size)

 def generate_square_subsequent_mask(self, sz):
 mask = torch.triu(torch.ones(sz, sz), diagonal=1)
 return mask.masked_fill(mask==1, float('-inf'))

 def forward(self, src, tgt):
 src_emb = self.pos_encoder(self.embedding_src(src) * math.sqrt(self.d_model))
 tgt_emb = self.pos_encoder(self.embedding_tgt(tgt) * math.sqrt(self.d_model))
 
 tgt_mask = self.generate_square_subsequent_mask(tgt.size(1)).to(src.device)
 output = self.transformer(src_emb, tgt_emb, tgt_mask=tgt_mask)
 return self.fc_out(output)

# Step 5: 训练设置
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = TransformerModel(len(vocab_en), len(vocab_de)).to(device)
criterion = nn.CrossEntropyLoss(ignore_index=vocab_de['<pad>'])
optimizer = torch.optim.Adam(model.parameters(), lr=0.0001, betas=(0.9, 0.98), eps=1e-9)

# Step 6: 训练循环（简化）
for epoch in range(10):
 model.train()
 total_loss = 0
 for src_batch, tgt_batch in train_loader: # 假设有数据加载器
 src = [vocab_en[token] for token in src_batch.split()]
 tgt = [vocab_de[token] for token in tgt_batch.split()]
 # 添加 <sos> 和 <eos>
 tgt_in = [vocab_de['<sos>']] + tgt[:-1]
 tgt_out = tgt
 
 src_tensor = torch.tensor(src).unsqueeze(0).to(device)
 tgt_in_tensor = torch.tensor(tgt_in).unsqueeze(0).to(device)
 tgt_out_tensor = torch.tensor(tgt_out).unsqueeze(0).to(device)
 
 optimizer.zero_grad()
 output = model(src_tensor, tgt_in_tensor)
 loss = criterion(output.view(-1, len(vocab_de)), tgt_out_tensor.view(-1))
 loss.backward()
 torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
 optimizer.step()
 total_loss += loss.item()
 print(f"Epoch {epoch}, Loss: {total_loss/len(train_data):.4f}")

# Step 7: 翻译函数（贪心解码）
def translate(model, src_sentence, max_len=50):
 model.eval()
 src = [vocab_en[token] for token in src_sentence.split()]
 src_tensor = torch.tensor(src).unsqueeze(0).to(device)
 
 tgt_tokens = [vocab_de['<sos>']]
 for _ in range(max_len):
 tgt_tensor = torch.tensor(tgt_tokens).unsqueeze(0).to(device)
 with torch.no_grad():
 output = model(src_tensor, tgt_tensor)
 pred_token = output.argmax(2)[:, -1].item()
 if pred_token == vocab_de['<eos>']:
 break
 tgt_tokens.append(pred_token)
 
 return " ".join([vocab_de.get_itos()[i] for i in tgt_tokens[1:]])

# 测试
print(translate(model, "hello world")) # 输出: hallo welt
```

### 关键说明

| 组件 | 实现要点 |
|------|--------|
| **位置编码** | 使用正弦函数，与嵌入相加 |
| **掩码** | 解码器自注意力需 future masking |
| **嵌入缩放** | 乘以 $ \sqrt{d_{\text{model}}} $ 保持方差一致 |
| **解码策略** | 贪心搜索（可升级为 Beam Search） |

---

## Transformer 架构对比总结

| 模型类型 | 编码器 | 解码器 | 典型应用 |
|--------|-------|-------|--------|
| **原始 Transformer** | ✓ | ✓ | 机器翻译 |
| **BERT** | ✓ | ✗ | 文本理解（分类、NER） |
| **GPT** | ✗ | ✓ | 文本生成 |
| **T5** | ✓ | ✓ | 文本到文本（统一框架） |

---

## 小结

Transformer 通过**纯注意力机制**实现了高效、强大的序列建模，其核心创新——**自注意力、位置编码、残差连接**——已成为现代 NLP 的标配。尽管存在计算开销大等挑战，但其变体（如轻量化、长文本模型）不断拓展应用边界。掌握 Transformer 架构，是理解 BERT、GPT、T5 等大模型的基础，也是迈向 NLP 前沿的关键一步。


---

# 资料

咚咚王

《Python 编程：从入门到实践》
《利用 Python 进行数据分析》
《算法导论中文第三版》
《概率论与数理统计（第四版） (盛骤) 》
《程序员的数学》
《线性代数应该这样学第 3 版》
《微积分和数学分析引论》
《（西瓜书）周志华-机器学习》
《TensorFlow 机器学习实战指南》
《Sklearn 与 TensorFlow 机器学习实用指南》
《模式识别（第四版）》
《深度学习 deep learning》伊恩·古德费洛著 花书
《Python 深度学习第二版(中文版)【纯文本】 (登封大数据 (Francois Choliet)) (Z-Library)》
《深入浅出神经网络与深度学习 +(迈克尔·尼尔森（Michael+Nielsen）》
《自然语言处理综论 第 2 版》
《Natural-Language-Processing-with-PyTorch》
《计算机视觉-算法与应用(中文版)》
《Learning OpenCV 4》
《AIGC：智能创作时代》杜雨 +&+ 张孜铭
《AIGC 原理与实践：零基础学大语言模型、扩散模型和多模态模型》
《从零构建大语言模型（中文版）》
《实战 AI 大模型》
《AI 3.0》

Transformer 是自然语言处理（NLP）领域的革命性架构，由 Google 在 2017 年论文《Attention Is All You Need》中提出。它完全摒弃了 RNN 和 CNN，仅依靠注意力机制实现序列建模，在机器翻译任务上首次超越传统模型，并成为 BERT、GPT 等大语言模型的基石。本章将系统解析 Transformer 的整体结构、核心组件、训练技巧、主流变体，并通过机器翻译实战完整演示其构建过程。

人工智能之语言领域 自然语言处理 第十二章 Transformer架构

Transformer 是自然语言处理（NLP）领域的革命性架构，由 Google 在 2017 年论文《Attention Is All You Need》中提出。它完全摒弃了 RNN 和 CNN，仅依靠注意力机制实现序列建模，在机器翻译任务上首次超越传统模型，并成为 BERT、GPT 等大语言模型的基石。本章将系统解析 Transformer 的整体结构、核心组件、训练技巧、主流变体，并通过机

技术岗

编程语言

Transformer是NLP领域的革命性架构，基于注意力机制实现高效序列建模。本章详解其编码器-解码器结构、自注意力机制、位置编码等核心组件，并演示机器翻译实战应用。掌握Transformer是理解BERT、GPT等大模型的基础。

自然语言处理

计算机视觉

数据预处理

机器翻译

智能创作

人工智能

机器学习

深度学习

大数据

Python

2026新春采购季

bigdata-class

ai-class

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

人工智能之语言领域 自然语言处理 第十二章 Transformer架构-腾讯云开发者社区-腾讯云

人工智能之语言领域自然语言处理第十二章 Transformer架构

人工智能之语言领域自然语言处理第十二章 Transformer架构

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

人工智能之语言领域 自然语言处理 第十二章 Transformer架构

人工智能之语言领域 自然语言处理 第十二章 Transformer架构

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

人工智能之语言领域自然语言处理第十二章 Transformer架构

人工智能之语言领域自然语言处理第十二章 Transformer架构