【纯新手向】我的深度学习打怪升级之路（四）：Transformer——让机器“读懂”上下文的注意力奇迹

曦晨166

329人浏览 · 2026-05-31 12:45:20

曦晨166 · 2026-05-31 12:45:20 发布

前言：这是我深度学习自学系列的第六篇。前面我们走过了 CNN、RNN/LSTM，终于来到了当下大模型的基石——Transformer。这篇文章依然秉持“纯新手向”的原则，用大白话把 Transformer 的核心思想讲清楚。希望能帮到和曾经的我一样被各种公式砸晕的同学们。

写在前面：为什么要学 Transformer
Part 1 | Transformer 概览：一个全新的架构
Part 2 | Input Block：词向量 + 位置编码
Part 3 | Encoder：自注意力与多头注意力
Part 4 | Decoder：带掩码的解码器
Part 5 | Output Part：从向量到单词
Part 6 | Network Training：训练过程
Part 7 | 总结：从 RNN 到 Transformer 的进化

1. 写在前面：为什么要学 Transformer

2017 年，Google 发表了一篇论文《Attention Is All You Need》，论文的标题言简意赅——你只需要注意力机制就够了。这篇论文提出的 Transformer 架构，彻底改变了 NLP（自然语言处理）领域的格局。

一句话理解 Transformer 的位置：

在 Transformer 之前，处理序列数据（比如一句话）主要靠 RNN/LSTM。它们的问题是什么？一个字一个字串行处理，不能并行计算，速度慢；而且句子一长，前后的依赖关系就容易丢失。
Transformer 的核心创新：抛弃了 RNN 的循环结构，完全靠注意力机制来处理序列。这让模型可以并行地“看到”整个句子，训练速度大幅提升，效果也更好。

后面我们熟知的 BERT、GPT、T5，以及现在的 ChatGPT，底层架构都是 Transformer 或其变体。

新手小笔记：可以把 Transformer 理解为一个“升级版的自动翻译引擎”，它不再纠结于从左到右一个词一个词地读，而是一下子看到整句话，自行判断哪些词之间更相关。

2. Part 1 | Transformer 概览：一个全新的架构

2.1 整体结构：Encoder-Decoder 双塔

Transformer 的总体结构仍然是 Encoder-Decoder（编码器-解码器） 框架，这和经典的 Seq2Seq 模型是一样的：

输入句子 → [Encoder 编码器] → 中间语义表示 → [Decoder 解码器] → 输出句子

但 Encoder 和 Decoder 的内部结构，跟 RNN 时代完全不同了。

2.2 Transformer 的整体架构图（文字版）

                    ┌──────────────┐
    输入句子        │   Input      │
     "I love you"  │   Embedding  │
                    │ + Positional │
                    │   Encoding   │
                    └──────┬───────┘
                           │
                    ┌──────▼───────┐
                    │   Encoder    │
                    │  × N 层      │  每层包含：
                    │  - Self-Attn │  ① 多头自注意力
                    │  - Add&Norm  │  ② 残差连接+层归一化
                    │  - FeedFwd   │  ③ 前馈神经网络
                    │  - Add&Norm  │  ④ 残差连接+层归一化
                    └──────┬───────┘
                           │
                    ┌──────▼───────┐
                    │   Decoder    │
                    │  × N 层      │  每层包含：
                    │  - Masked SA │  ① 掩码多头自注意力
                    │  - Add&Norm  │  ② 残差连接+层归一化
                    │  - Cross-Attn│  ③ 交叉多头注意力
                    │  - Add&Norm  │  ④ 残差连接+层归一化
                    │  - FeedFwd   │  ⑤ 前馈神经网络
                    │  - Add&Norm  │  ⑥ 残差连接+层归一化
                    └──────┬───────┘
                           │
                    ┌──────▼───────┐
                    │   Linear +   │
                    │   Softmax    │
                    │ 输出下一个词  │
                    └──────────────┘

2.3 核心创新：并行计算

传统 RNN 处理一句话必须按顺序来，比如先读"I"，再读"love"，再读"you"。Transformer 不一样，它一次性把整个句子扔进去，并行处理所有词。这种并行能力让 Transformer 可以充分利用 GPU 进行训练，这也是为什么它能堆出几百亿参数的大模型。

新手理解：RNN 像是一个一个珠子串起来穿，必须等前面的珠子穿好才能穿下一个。Transformer 像是把所有珠子同时撒到桌上，然后用多只手同时去分类整理。

3. Part 2 | Input Block：词向量 + 位置编码

数据进入 Transformer 的第一步，是把自然语言变成模型能理解的向量。

2.1 输入嵌入（Input Embedding）

每个单词都要被映射成一个固定维度的向量。比如"I" → [0.12, -0.34, 0.56, ...]（比如 512 维）。

这里和之前学的 Word2Vec、GloVe 类似，只不过在 Transformer 中，这个嵌入矩阵是随模型一起训练的。

2.2 位置编码（Positional Encoding）

这是一个非常关键的问题： 既然 Transformer 并行处理所有词，那模型怎么知道"I love you"中"I"排第一个，"love"排第二个？

答案是：给每个词的向量加上一个表示位置信息的编码。

Transformer 论文中使用的是 正弦/余弦函数 来生成位置编码：

PE(pos, 2i)     = sin(pos / 10000^(2i/d_model))
PE(pos, 2i + 1) = cos(pos / 10000^(2i/d_model))

pos：单词在句子中的位置（第 0 个、第 1 个…）
i：向量的维度索引
d_model：词向量的维度（如 512）

公式看起来吓人，但核心思想很朴素：

每个位置 pos 会生成一个唯一的向量
不同位置的编码向量有明显的模式差异（正弦波的不同相位）
偶数维度用 sin，奇数维度用 cos
对于任意两个位置，模型都能通过线性变换推断出它们的位置关系

新手小笔记：位置编码 = 给每个词印上它在句子中的“座位号”，让模型知道谁在前谁在后。

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

Input_vector = Word_Embedding + Positional_Encoding

两个向量直接相加，结果就是 Transformer Encoder 的真正输入。为什么相加而不是拼接？因为相加后向量维度不变，且实验证明模型能够自动在这混合信息中学到词义和位置两方面的特征。

4. Part 3 | Encoder：自注意力与多头注意力

这是 Transformer 的 绝对核心，也是理解难度最高的部分。我们用逐层递进的方式来拆解。

3.1 Self-Attention：让每个词“看到”其他所有词

先抛开所有复杂概念，理解一个直觉：

在句子 “The animal didn’t cross the street because it was too tired” 中，“it” 指的是 “animal” 还是 “street”？作为人类，我们通过上下文推断 “it” = “animal”。Self-Attention 就是让模型自动学会这种推断能力。

Self-Attention 的计算过程（先理解大框架，再补细节）：

Step 1：三个关键矩阵 Q, K, V

对于每个输入的词向量，通过三个不同的权重矩阵 W_Q、W_K、W_V，分别生成：

Q（Query，查询）：提问向量——“我在找什么？”
K（Key，键）：索引向量——“我是什么？”
V（Value，值）：内容向量——“我包含什么信息？”

类比理解：你在图书馆（整个句子）里找书。你脑子里有一个想找的主题（Query），每本书的标签是 Key，书的内容是 Value。你会对比 Query 和各本书的 Key 的匹配度，决定看哪本书（attention 权重），然后从这本书里获取信息（加权 Value）。

Step 2：计算注意力分数

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

这个公式分三步理解：

Q × K^T：计算每个词和其他所有词之间的“相关性分数”（点积越大 = 越相关）
÷ √d_k：除以维度的平方根做缩放（防止点积过大导致 softmax 梯度消失）
softmax(…) × V：把分数转为概率权重（总和为 1），然后按权重对 Value 加权求和

最终效果： 每个词的输出，都是整个句子中所有词的加权组合。与该词越相关的词，权重越大。

新手理解：“I love you”，当模型处理 “love” 时，它会对 “I” 和 “you” 都给予较高权重，而对句子中不相关的词给低权重。这样 “love” 的上下文信息就被编码进了它的输出表示中。

3.2 Multi-Head Attention：多个注意力并行

只用一个 Self-Attention，模型可能只捕捉到一种关系模式。多头注意力 就是同时跑多个 Self-Attention，每个“头”关注不同的方面：

头 1：可能关注“语法关系”（主语-谓语）
头 2：可能关注“指代关系”（it → animal）
头 3：可能关注“语义相似性”
…

$Concat(head_1, head_2, ..., head_h) \times W_O$

每个 head 就是一组独立的 Self-Attention，最后把所有 head 的结果拼接起来，再通过一个线性层 W_O 投影回原来的维度。

论文中使用了 8 个注意力头。

3.3 Add & Norm：残差连接 + 层归一化

每个子层（注意力层、前馈层）之后都有：

Add（残差连接）：Output = Layer(x) + x
- 为什么需要？防止深层网络退化。即使注意力层“学坏了”，残差连接至少能保证信息不丢失。
- 和 ResNet 里的残差连接思路一致。
Norm（层归一化）：让数据分布保持稳定
- 把每层的输出归一化到均值为 0、方差为 1，加速训练收敛。

x → SubLayer(x) → x + SubLayer(x) → LayerNorm → 输出

3.4 Feed-Forward Network（前馈神经网络）

每个 Encoder 层中还有一个全连接前馈网络：

$FFN(x) = ReLU(x W_1 + b_1) W_2 + b_2$

其实就是两个线性变换，中间夹一个激活函数 ReLU。第一层通常把维度扩大（如 512 → 2048），第二层再缩回来。

这也是 Transformer 模型参数量的重要来源之一。

3.5 Encoder 结构总结

堆叠 N 层（论文中 N=6），每层包含：

输入 x
  → Multi-Head Self-Attention → Add & Norm
    → Feed-Forward → Add & Norm
      → 输出（传给下一层或 Decoder）

3.6 一个小结

组件	作用	通俗理解
Self-Attention	让词看到上下文	开会时每个人都能发言，互相交流
Multi-Head	多角度理解	多个专家组同时分析，意见汇总
Add & Norm	稳定训练	每个环节的“保险丝”，防止信息断裂
Feed-Forward	增加表达能力	每个人会后自己思考消化

5. Part 4 | Decoder：带掩码的解码器

Decoder 的结构和 Encoder 类似，但有三个关键区别：

4.1 Masked Self-Attention（掩码自注意力）

黄金规则： 在生成第 t 个词时，模型只能看到第 1 到第 t-1 个词，不能偷看后面的答案。

实现方式：在计算 Attention 分数时，将未来位置的分数设为 -∞。这样经过 softmax 之后，这些位置的权重就变为 0。

输入："I am going to buy a new car"
解码时：
  - 生成 "I"      时，只能看到 [START]
  - 生成 "am"     时，只能看到 [START, I]
  - 生成 "going"  时，只能看到 [START, I, am]
  - ...

这保证了模型是自回归生成，即一个词一个词预测，满足因果性。

4.2 Cross-Attention（交叉注意力）

Decoder 中有一个额外的注意力层——交叉注意力：

Q 来自 Decoder 自身（当前解码状态）
K、V 来自 Encoder 的输出

直观理解：Decoder 在生成目标语言的每个词时，都要“看一眼”源语言的整个句子。Encoder 已经把源句子的所有信息浓缩好了，Decoder 的 Cross-Attention 负责从这个浓缩信息中“提取”需要的内容。

4.3 Decoder 结构总结

堆叠 N 层（同样 N=6），每层包含：

输入 x（已生成的序列）
  → Masked Multi-Head Self-Attention → Add & Norm      ← 看自己（不能看未来）
    → Cross-Attention (Q来自Decoder, K/V来自Encoder) → Add & Norm  ← 看Encoder
      → Feed-Forward → Add & Norm                        ← 思考消化
        → 输出

6. Part 5 | Output Part：从向量到单词

Decoder 最后一层输出一个向量（比如 512 维），如何把它变成具体的单词？

5.1 Linear + Softmax

Linear:  512维向量 → vocab_size 维向量（比如 30000 维，每个维度对应一个词）
Softmax: 把 30000 维的分数 → 概率分布（总和 = 1）

取概率最大的那个词作为当前步的输出。

比如：输入 “I love”，模型输出概率分布 → “you” 的概率是 0.78，最高 → 预测下一个词是 “you”。

在训练时，我们已经知道正确答案，所以是用 teacher forcing（直接给正确答案）来训练，而不是用模型自己的预测。

7. Part 6 | Network Training：训练过程

6.1 训练数据是什么样？

以机器翻译为例，训练数据是一对一对的句子：

源语言：I am going to buy a new car
目标语言：我要买一辆新车

训练时：

源语言句子输入 Encoder
目标语言句子输入 Decoder（带 Mask，逐个词预测）
模型预测下一个目标词，与真实答案对比
计算损失（交叉熵损失），反向传播更新参数

6.2 损失函数：交叉熵损失

对于每个位置，模型输出一个概率分布（所有词的概率），真实标签是一个 one-hot 向量（只有正确词是 1）。

交叉熵损失衡量这两个分布之间的差距：

$\sum_{i} y_i \log(\hat{y}_i)$

其中 $y_i$ 是真实标签（0 或 1）， $\hat{y}_i$ 是模型预测的概率。

6.3 训练技巧

Adam 优化器：自适应学习率，训练更稳定
Warmup（学习率预热）：一开始用很小的学习率，逐步增加到目标值，然后再衰减
Label Smoothing（标签平滑）：不要 100% 自信地认为正确标签就是 1，稍微平滑一下，防止过拟合
Dropout：随机丢弃一些神经元，防止过拟合

8. Part 7 | 总结：从 RNN 到 Transformer 的进化

Transformer 的优势

对比维度	RNN / LSTM	Transformer
计算方式	串行（必须按顺序）	并行（同时处理全部）
长距离依赖	差（梯度消失问题）	好（Attention 直接连接任意位置）
训练速度	慢	快（GPU 友好）
可扩展性	有限	极强（可堆到千亿参数）
解释性	较难	Attention 权重可视化，更直观

一张图总结 Transformer

Encoder:
  "I love you" → [Embedding + PosEncode]
    → [Self-Attn → Add&Norm → FFN → Add&Norm] × 6
      → 编码后的上下文表示

Decoder:
  已生成的部分 + 位置编码
    → [Masked Self-Attn → Add&Norm
       → Cross-Attn(看Encoder) → Add&Norm
       → FFN → Add&Norm] × 6
    → Linear → Softmax → 下一个词

学习心得

作为一个深度学习新手，学 Transformer 的过程中我有几点体会：

不要被公式吓到 —— Attention 的公式看起来复杂，但核心就是“加权求和”。先理解直觉，公式自然就能看懂。
画图是最好的学习方式 —— Transformer 的结构是“对称的”，Encoder 和 Decoder 高度相似，把图画出来就清晰很多。
QKV 是理解的关键 —— 把 Query、Key、Value 用生活中的例子去类比（如图书馆找书、搜索引擎），会豁然开朗。
Transformer 是“积木式”设计 —— 每一层都是独立的模块，理解了每个模块的功能，整个架构也就通了。
从 Transformer 到 ChatGPT —— 后面的 BERT 只用了 Encoder，GPT 只用了 Decoder（堆了很多层）。理解了 Transformer，大模型的基石就掌握了。