🤖 Transformer 通俗详解

从零开始,用人话讲清楚 Transformer 的每一个步骤
附带生活化例子,保证看懂

📑 目录导航

  1. 为什么需要 Transformer?— 从翻译说起
  2. 一眼看完全貌 — Transformer 整体架构
  3. 第一步:把文字变成数字 — 词嵌入 + 位置编码
  4. 核心中的核心 — 自注意力机制(Self-Attention)
  5. 多角度看问题 — 多头注意力(Multi-Head Attention)
  6. 独立思考层 — 前馈神经网络(FFN)
  7. 防退化神器 — 残差连接 + 层归一化
  8. 编码器(Encoder)— 理解输入
  9. 解码器(Decoder)— 生成输出
  10. 完整流程走一遍 — 以机器翻译为例
  11. 为什么 Transformer 这么强?
  12. Transformer 家族 — GPT、BERT、T5…

1. 为什么需要 Transformer?

🔤 先讲个故事

假设你是一个翻译官,要把英文 "I love cats" 翻译成中文 "我爱猫"。

在 Transformer 出现之前,最流行的做法是 RNN(循环神经网络)。RNN 的工作方式很像一个人逐字逐句地阅读:

📖 RNN 的阅读方式

先看 "I" → 记住 → 再看 "love" → 和前面的记忆混合 → 再看 "cats" → 再混合 → 最后翻译

问题:看到 "cats" 的时候,"I" 的印象已经模糊了(梯度消失),而且必须一个一个看,不能并行。

2017 年,Google 的论文 "Attention Is All You Need" 提出了 Transformer,它的核心思想非常简单:

💡 核心思想

不要一个一个看!一次把整句话都看完,然后让每个词去"关注"其他所有词。

就像你读这句话时,眼睛虽然在某个字上,但大脑同时在联系上下文的每个词。

🎯 对比

RNN:"小明说他明天要去北京,因为那里有一个很重要的会议。" → 读到最后,可能忘了"那里"指的是"北京"。

Transformer:同时看到所有词,"那里"可以直接"关注"到"北京",不管隔多远。

2. 一眼看完全貌 — Transformer 整体架构

Transformer 的结构可以浓缩成一句话:左边是编码器(理解输入),右边是解码器(生成输出)。

┌─────────────────────────────────────────────────┐ │ Transformer 全景图 │ │ │ │ 输入("我爱猫") 输出("I love cats") │ │ │ ▲ │ │ ▼ │ │ │ ┌─────────┐ ┌─────────────┐ │ │ │ 词嵌入 │ │ 词嵌入 │ │ │ │ +位置编码 │ │ +位置编码 │ │ │ └────┬────┘ └──────┬──────┘ │ │ ▼ ▼ │ │ ┌─────────────────────────────────────┐ │ │ │ 编码器 × N 层 │ │ │ │ ┌───────────────────────────────┐ │ │ │ │ │ 自注意力 → FFN → 残差+归一化 │ │ │ │ │ └───────────────────────────────┘ │ │ │ └──────────────┬──────────────────────┘ │ │ │ (传递理解) │ │ ▼ │ │ ┌─────────────────────────────────────┐ │ │ │ 解码器 × N 层 │ │ │ │ ┌───────────────────────────────┐ │ │ │ │ │ 掩码自注意力→交叉注意力→FFN │ │ │ │ │ └───────────────────────────────┘ │ │ │ └──────────────┬──────────────────────┘ │ │ ▼ │ │ 线性层 + Softmax │ │ │ │ │ ▼ │ │ 输出概率分布 │ │ "I love cats" │ └─────────────────────────────────────────────────┘
📝 输入文字
→
🔢 转成数字
→
🧠 编码器理解
→
✍️ 解码器生成
→
📄 输出文字

接下来我们一步一步拆解每一部分。

3. 第一步:把文字变成数字 — 词嵌入 + 位置编码

🔤 问题:计算机不认识字

计算机只认识数字。所以第一步是把每个词变成一个数字向量(一列数字)。

🏠 生活比喻

想象每个词都有一张"身份证",上面写着一串数字来描述它的特征。

比如 "猫" 的身份证可能是 [0.8, -0.3, 0.5, 0.1, ...],代表它"是动物""可爱""小"等特征。

"狗" 的身份证和 "猫" 很接近(都是宠物),但和 "经济" 差很远。

📐 词嵌入(Word Embedding)

词嵌入就是一个大查找表:

🔍 例子

假设词表有 5 个词,嵌入维度是 4:

词编号嵌入向量(4维)
我0[0.2, 0.5, -0.1, 0.8]
爱1[0.7, 0.3, 0.6, -0.2]
猫2[0.8, -0.3, 0.5, 0.1]
狗3[0.75, -0.25, 0.45, 0.15]
经济4[-0.5, 0.9, -0.7, 0.3]

注意 "猫" 和 "狗" 的向量很接近,和 "经济" 差很远 — 这就是嵌入的魔力!

📍 位置编码(Positional Encoding)

但光有词嵌入还不够!Transformer 是同时看所有词的,它不知道词的顺序。

⚠️ 顺序问题

"我爱猫" 和 "猫爱我" — 词一样,意思完全不同!

所以我们给每个位置加一个"位置信号"。

原始论文用的是正弦/余弦函数来生成位置信号:

📐 位置编码公式(简化理解)

位置 0 的信号:[sin(0), cos(0), sin(0), cos(0), ...] = [0, 1, 0, 1, ...]

位置 1 的信号:[sin(1/10000), cos(1/10000), sin(1/10000²), cos(1/10000²), ...]

每个位置都有独一无二的"指纹"!

✅ 最终输入

最终输入 = 词嵌入 + 位置编码

这样每个词既有了"含义",又有了"位置"。

4. 核心中的核心 — 自注意力机制(Self-Attention)

这是 Transformer 最精华的部分,也是最需要耐心理解的部分。

🎯 核心问题:每个词该关注哪些词?

📚 考试比喻

想象你在做阅读理解题:"小明把书还给了图书馆,因为它太破了。"

问题是:"它"指的是什么?

你需要回过头去看每个词:

  • "小明" → 不太会"破",关注度 0.1
  • "书" → 可能会"破",关注度 0.7 ✅
  • "图书馆" → 也可能破,关注度 0.2

这就是注意力:计算每个词对其他词的"关注程度"。

🔧 具体怎么算?— Q、K、V 三兄弟

自注意力用三个概念:Q(Query,查询)、K(Key,键)、V(Value,值)。

🔍 图书馆比喻

想象你去图书馆找书:

  • Q(你的需求):"我想找一本关于猫的书"
  • K(书的标签):每本书封面上的关键词
  • V(书的内容):书里面实际写了什么

过程:用你的需求 Q,去和每本书的标签 K 做匹配(点积),匹配度高的书,它的内容 V 就会被重点参考。

📐 数学过程(别怕,很简单)

🔢 计算步骤

步骤 1:把输入向量 X 分别乘以三个权重矩阵,得到 Q、K、V

Q = X × WQ     K = X × WK     V = X × WV

步骤 2:用 Q 和 K 计算相似度(点积)

Score = Q × KT

步骤 3:缩放(除以 √dk,防止数值太大)

Score = Score / √dk

步骤 4:Softmax 归一化(变成 0~1 的概率)

Attention = Softmax(Score)

步骤 5:用注意力权重对 V 加权求和

Output = Attention × V

🎯 完整例子:"我爱猫"

假设三个词 "我" "爱" "猫" 经过嵌入后得到向量(简化为2维):

词向量 X
我[1, 0]
爱[0, 1]
猫[1, 1]

假设 WQ、WK 都是单位矩阵(简化),那么:

Q = K = X(实际中不会这样,这里为了演示)

计算相似度矩阵(Q × KT):

Q\K
我
爱
猫
我
1×1+0×0=1
1×0+0×1=0
1×1+0×1=1
爱
0×1+1×0=0
0×0+1×1=1
0×1+1×1=1
猫
1×1+1×0=1
1×0+1×1=1
1×1+1×1=2

Softmax 后(按行归一化),"我" 这一行的注意力大概是:

我 → 我: 0.27   爱: 0.10   猫: 0.27(还有更多…)

最后用这些权重对 V 加权求和,得到 "我" 的新表示 — 它已经融合了上下文信息!

💡 一句话总结

自注意力 = 每个词去看其他所有词,计算"关注度",然后把相关信息融合到自己的表示中。

做完之后,"我" 不再只是 "我",而是 "在'爱猫'这个语境下的我"。

5. 多角度看问题 — 多头注意力(Multi-Head Attention)

一个注意力头只能从一个角度关注。但语言是复杂的,一个词可能同时需要关注多个方面。

👁️ 多双眼睛

看一幅画:

  • 👀 头 1 关注语法结构(谁是主语?谁是谓语?)
  • 👀 头 2 关注语义关系("它"指的是谁?)
  • 👀 头 3 关注情感色彩(正面还是负面?)
  • 👀 头 4 关注距离关系(相邻的词还是远处的词?)

最后把这些视角拼接起来,得到全面的理解。

📐 数学过程

假设有 h 个头(论文中 h=8),输入维度 dmodel=512:

每个头的维度 = 512 / 8 = 64

每个头独立计算注意力,最后拼接:

MultiHead = Concat(head1, head2, ..., headh) × WO

🔬 论文中发现的有趣模式

研究人员发现不同头确实学到了不同的关注模式:

头学到的模式
头 1关注前一个词(局部语法)
头 2关注句子中的动词
头 3关注逗号/句号等标点
头 4关注代词的先行词("它"→"猫")

6. 独立思考层 — 前馈神经网络(FFN)

自注意力做完之后,每个词已经融合了上下文信息。接下来 FFN 对每个词独立地做进一步加工。

🧠 思考比喻

自注意力像是(大家互相交换信息),FFN 像是"独立思考"(每个人回去消化吸收)。

📐 FFN 结构

两层全连接网络,中间用 ReLU 激活:

FFN(x) = max(0, x × W₁ + b₁) × W₂ + b₂

关键:W₁ 把维度从 512 扩大到 2048,W₂ 再缩回 512。

这个"先扩后缩"让网络有了更强的表达能力。

💡 为什么要"独立"?

FFN 是对每个位置独立计算的(不像自注意力要看其他位置)。

这意味着它可以并行处理,非常快!

有研究认为,FFN 层其实像一个"知识库",存储了大量学到的事实(比如"巴黎是法国的首都")。

7. 防退化神器 — 残差连接 + 层归一化

🔗 残差连接(Residual Connection)

🏊 安全绳比喻

想象你在学游泳:

  • 没有残差连接:每学一个新动作,你可能反而游得更差(梯度消失/爆炸)
  • 有残差连接:你身上绑着一根安全绳,新动作是在原有基础上"加一点",不会退步

数学上:输出 = 输入 + 处理(输入),至少不会比输入差!

📐 公式

output = LayerNorm(x + SubLayer(x))

其中 SubLayer 可以是自注意力或 FFN。

📊 层归一化(Layer Normalization)

归一化就是把数据,防止数值跑偏。

🌡️ 温度比喻

假设你在控制室温:

温度计读数可能忽高忽低,但你想要一个稳定的、标准化的读数。

归一化就是把数据的均值变成 0,方差变成 1,让每层的输入都在一个"舒适区"。

输入 x
→
自注意力
→
+ x (残差)
→
LayerNorm
→
FFN
→
+ 残差
→
LayerNorm
→
输出

8. 编码器(Encoder)— 理解输入

编码器的任务:彻底理解输入句子。

🏗️ 一层编码器的结构
┌────────────────────────────────────────────┐ │ 编码器的一层 │ │ │ │ 输入: "我 爱 猫" 的嵌入向量 │ │ │ │ │ ▼ │ │ ┌─────────────────┐ │ │ │ 多头自注意力 │ ← 每个词看其他所有词 │ │ └────────┬────────┘ │ │ │ │ │ ▼ │ │ ┌─────────────────┐ │ │ │ 残差 + 归一化 │ │ │ └────────┬────────┘ │ │ │ │ │ ▼ │ │ ┌─────────────────┐ │ │ │ 前馈网络 FFN │ ← 独立加工每个位置 │ │ └────────┬────────┘ │ │ │ │ │ ▼ │ │ ┌─────────────────┐ │ │ │ 残差 + 归一化 │ │ │ └────────┬────────┘ │ │ │ │ │ ▼ │ │ 输出: 融合了上下文的向量 │ └────────────────────────────────────────────┘

论文中堆叠了 N = 6 层编码器。每一层都在前一层的基础上,进一步提炼理解。

📖 读书比喻

第 1 层:理解基本的词义和局部语法("我"是主语,"爱"是动词)

第 2 层:理解短语关系("爱猫"是一个动宾短语)

第 3 层:理解句子整体含义("我"喜欢"猫"这种动物)

…层层递进,理解越来越深。

9. 解码器(Decoder)— 生成输出

解码器的任务:根据编码器的理解,一个词一个词地生成输出。

解码器和编码器很像,但有两个关键区别:

区别 1:掩码自注意力(Masked Self-Attention)

🔒 考试比喻

翻译时,你不能"偷看"未来的词!

比如翻译 "I love cats":

  • 生成 "我" 时 → 只能看 "I"
  • 生成 "爱" 时 → 只能看 "I love"
  • 生成 "猫" 时 → 可以看 "I love cats"

这就是 Mask(掩码)的作用:把未来的位置遮住,设为 -∞,Softmax 后变成 0。

区别 2:交叉注意力(Cross-Attention)

🔗 翻译官比喻

解码器在生成每个词时,都会"回头看"编码器的输出:

  • Q(查询)来自解码器("我现在需要什么信息?")
  • K、V(键和值)来自编码器("原文说了什么?")

这样解码器在生成每个词时,都能参考原文的完整含义。

🏗️ 一层解码器的结构
┌────────────────────────────────────────────┐ │ 解码器的一层 │ │ │ │ 输入: 已生成的输出词的嵌入 │ │ │ │ │ ▼ │ │ ┌─────────────────┐ │ │ │ 掩码多头自注意力 │ ← 不能看未来 │ │ └────────┬────────┘ │ │ ▼ │ │ ┌─────────────────┐ │ │ │ 残差 + 归一化 │ │ │ └────────┬────────┘ │ │ │ │ │ ▼ ┌───────────┐ │ │ ┌─────────────────┐ │ 编码器输出 │ │ │ │ 交叉注意力 │ ◄─────│ (K, V) │ │ │ └────────┬────────┘ └───────────┘ │ │ ▼ │ │ ┌─────────────────┐ │ │ │ 残差 + 归一化 │ │ │ └────────┬────────┘ │ │ ▼ │ │ ┌─────────────────┐ │ │ │ 前馈网络 FFN │ │ │ └────────┬────────┘ │ │ ▼ │ │ ┌─────────────────┐ │ │ │ 残差 + 归一化 │ │ │ └────────┬────────┘ │ │ ▼ │ │ 输出: 下一个词的概率 │ └────────────────────────────────────────────┘

🎲 最后的输出层

解码器最后一层的输出,经过:

线性层
→
Softmax
→
概率分布
→
选最大概率的词
🎯 例子

假设词表有 5 个词,解码器输出概率:

词概率
我0.72 ✅
他0.15
猫0.08
爱0.03
吃0.02

选概率最大的 "我" 作为输出,然后把这个 "我" 加入输入,继续生成下一个词。

10. 完整流程走一遍 — 以机器翻译为例

让我们用 "I love cats" → "我爱猫" 这个例子,走一遍完整流程。

📥 阶段 1:编码(理解英文)

  1. 分词:"I" "love" "cats" → 三个 token
  2. 词嵌入:查表得到三个向量 [0.2, 0.5, ...], [0.7, 0.3, ...], [0.8, -0.3, ...]
  3. 加位置编码:每个向量加上对应位置的信号
  4. 通过 6 层编码器:
    • 每层做:自注意力 → 残差归一化 → FFN → 残差归一化
    • 最终输出:三个词各自融合了整句上下文的向量

📤 阶段 2:解码(生成中文,逐步进行)

🔁 生成第 1 个词:"我"

输入:特殊起始符 [START]

过程:

  • 掩码自注意力:[START] 只看自己
  • 交叉注意力:查看编码器输出("I love cats" 的理解)
  • FFN:进一步加工
  • Softmax 输出:概率最高的是 "我"

输出:"我"

🔁 生成第 2 个词:"爱"

输入:[START] + "我"

过程:

  • 掩码自注意力:"我" 可以看 [START] 和自己,但不能看未来
  • 交叉注意力:继续参考 "I love cats"
  • Softmax 输出:概率最高的是 "爱"

输出:"爱"

🔁 生成第 3 个词:"猫"

输入:[START] + "我" + "爱"

过程:

  • 掩码自注意力:看 [START]、"我"、"爱"
  • 交叉注意力:参考 "I love cats",特别关注 "cats"
  • Softmax 输出:概率最高的是 "猫"

输出:"猫"

🔁 生成第 4 个词

输入:[START] + "我" + "爱" + "猫"

输出:[END](结束符)

翻译完成!🎉

🏋️ 训练 vs 推理

训练(Training)推理(Inference)
输入完整的正确翻译("我爱猫")逐个生成(自回归)
目标让模型预测下一个词的概率尽可能接近真实生成翻译
方式并行处理所有位置(快!)一个一个生成(慢)
损失函数交叉熵损失(Cross-Entropy Loss)无

11. 为什么 Transformer 这么强?

优势说明
🚀 并行计算 RNN 必须一个一个处理,Transformer 可以同时处理所有位置,训练快几十倍
🔗 长距离依赖 自注意力让任意两个词直接连接,不管距离多远,信息传递只用一步
📐 可扩展性 堆更多层、用更多数据、加大参数量,效果持续提升(Scaling Law)
🧠 通用架构 同一套架构,换不同的数据就能做翻译、问答、写代码、画画…
👁️ 可解释性 注意力权重可以可视化,让我们看到模型"在看哪里"
🏆 终极比喻

如果把 AI 模型比作一个团队:

  • RNN 像一个流水线:每个人做完传给下一个人,效率低
  • Transformer 像一个圆桌会议:所有人同时发言、互相讨论,效率高且理解深

12. Transformer 家族 — GPT、BERT、T5…

原始 Transformer 有编码器和解码器两部分。后来的研究者们"拆开"来用,发展出了不同的模型:

模型用了哪部分特点代表
GPT 系列 只用解码器 自回归生成,像"接龙"一样一个词一个词生成 GPT-4、ChatGPT
BERT 只用编码器 双向理解,擅长"完形填空"式任务 BERT、RoBERTa
T5 / BART 编码器 + 解码器 完整的 Seq2Seq,什么任务都能做 T5、mBART
ViT 只用编码器 把图片切成 patch,当"词"来处理 Vision Transformer
🎯 GPT vs BERT 的核心区别

GPT(解码器):像写作文 — 只能从左往右写,不能偷看后面

"今天天气___" → 预测 "很" → "今天天气很___" → 预测 "好"

BERT(编码器):像做完形填空 — 可以同时看前后文

"今天 [MASK] 气很好" → 同时看 "今天" 和 "气很好" → 预测 "天"

📊 参数量对比

模型参数量层数发布时间
原始 Transformer~6500 万62017
BERT-Base1.1 亿122018
GPT-215 亿482019
GPT-31750 亿962020
GPT-4~1.8 万亿(传闻)~1202023

🎉 总结:一张图记住 Transformer

输入文字 │ ▼ ┌───────────────┐ │ 词嵌入+位置编码 │ ← 把文字变成带位置信息的向量 └───────┬───────┘ │ ┌──────┴──────┐ │ │ ▼ │ ┌─────────┐ │ │ 编码器 │ │ ← 理解输入(N 层堆叠) │ 自注意力 │ │ 每层:自注意力 → FFN │ FFN │ │ + 残差连接 + 归一化 └────┬────┘ │ │ │ │ ┌────────┘ │ │ ▼ ▼ ┌─────────────┐ │ 解码器 │ ← 生成输出(N 层堆叠) │ 掩码自注意力 │ 每层:掩码自注意力 → 交叉注意力 → FFN │ 交叉注意力 │ + 残差连接 + 归一化 │ FFN │ └──────┬──────┘ │ ▼ ┌─────────────┐ │ 线性+Softmax │ ← 输出下一个词的概率 └──────┬──────┘ │ ▼ 输出文字
🎯 五个关键词记住 Transformer

1. 嵌入:文字 → 数字

2. 注意力:每个词关注所有词(Q·K → 权重 → 加权 V)

3. 多头:多个角度同时关注

4. FFN:独立思考,存储知识

5. 残差+归一化:保证稳定训练