Transformer 论文精读 已掌握 0/9
论文精读图文拆解 · 分节学习框架

Attention Is All You Need

Transformer 原论文逐节拆解:从「为什么不要 RNN」讲到注意力公式、多头机制、位置编码、训练配方和消融实验。9 个模块循序渐进,配手算示例和可交互图表。

Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Łukasz Kaiser、Illia Polosukhin
Google Brain · Google Research · 多伦多大学 | NIPS 2017 | 论文注明:作者贡献均等,署名顺序随机

28.4 BLEUWMT14 英→德,比此前最好成绩(含集成模型)高 2 BLEU 以上
41.0 BLEUWMT14 英→法,单模型新纪录
12 小时base 模型在 8 张 P100 上的训练时间(big 模型 3.5 天)
0 个循环层或卷积层:整个模型只靠注意力
一句话读懂用「注意力」彻底取代循环和卷积:每个词只需一步就能直接看到句子里的所有词。这样训练可以高度并行,远距离依赖的路径也最短,在翻译任务上用更低的训练成本拿到了当时最好的成绩。
00开始之前

学习路线:怎么用这份框架

论文正文共 9 页,这里拆成 9 个模块、5 个阶段。建议按顺序学,总共约 4.5 小时。每个模块都有学习目标、图解、误区提醒和自测题。

0.1路线图

0.2三遍阅读法

第一遍 · 速读约 20 分钟

只看标题、摘要、图 1、表 2 和结论。读完能说出:论文要解决什么问题、核心想法是什么、主要结果有多好。

第二遍 · 精读2–3 小时

按本框架 01–09 逐节读:推导公式 (1),亲手算一次注意力,看懂表 1 和表 3,做完每节自测题。

第三遍 · 复现约半天

对照附录的代码骨架,自己搭一个小 Transformer(比如做「复制 / 反转字符串」任务),亲手验证掩码和位置编码。

0.3前置知识自查

下面 6 项不熟也没关系,正文遇到时都会简单解释;如果完全没接触过,建议先花几分钟补一下。

矩阵乘法与形状

(n×d) 乘 (d×m) 得到 (n×m)。能跟踪张量形状,是读懂本文的最大助力。

softmax

把任意实数向量变成和为 1 的概率分布;输入数值越大,输出越「尖」。

编码器–解码器

seq2seq:编码器读入源句,解码器逐词生成目标句。翻译模型的标准结构。

RNN / LSTM

隐状态一步一步往后传,第 t 步依赖第 t−1 步,这正是本文要解决的瓶颈。

残差连接与层归一化

残差:输出 = x + F(x),让深层网络好训练;LayerNorm:把每个向量归一化到均值 0、方差 1。

BLEU 与困惑度

BLEU 衡量译文和参考译文的重合度,越高越好;困惑度(PPL)衡量预测的不确定性,越低越好。

01§1 Introduction · §2 Background第 1–2 页

动机:为什么要抛弃 RNN?

2017 年以前,机器翻译的主流是「RNN 编码器–解码器 + 注意力」。这一节要搞清楚 RNN 慢在哪里、卷积方案差在哪里,以及 Transformer 换来了什么、付出了什么。

约 20 分钟入门关键词:顺序计算 · 并行 · 路径长度

学习目标

  • 说清 RNN 为什么难以并行训练
  • 理解「关联两个位置需要多少步操作」这个衡量标准
  • 知道 Transformer 的取舍:路径变短了,代价是什么、怎么补救

1.1RNN 的瓶颈:只能一步一步算

循环神经网络沿着序列逐个位置计算隐状态:

第 t 步的隐状态 ht 依赖上一步的 ht−1 和当前输入 xt

这种「天生顺序」的结构排除了样本内部的并行计算:不算完第 t−1 步,就没法算第 t 步。序列越长问题越严重,而显存又限制了跨样本的批量大小。论文提到,分解技巧(factorization tricks)和条件计算(conditional computation)等改进虽然显著提升了效率,但顺序计算这个根本约束依然存在。

1.2三种方案对比:x₁ 的信息怎样传到 x₆?

衡量一个结构「学远距离依赖」难不难,可以看两个位置之间的信号要走多少步。路径越短,梯度越容易传过去。

RNN:顺序递推

h₁h₂h₃h₄h₅h₆ x₁x₂x₃x₄x₅x₆ 时间方向 →
O(n) 步

x₁ 要经过 5 次递推才到 h₆,而且这 5 步必须按顺序算,无法并行。

卷积:逐层扩大视野

x₁ x₂ x₃ x₄ x₅ x₆ 输入 层1 层2 层3
O(n/k) 层

卷积核 k=3 时要堆 3 层,x₁ 和 x₆ 才能「碰面」。ConvS2S 的步数随距离线性增长;ByteNet 用空洞卷积,降到 O(logk n)。

自注意力:一步直达

y₁ y₂ y₃ y₄ y₅ y₆ x₁ x₂ x₃ x₄ x₅ x₆ 输入 输出
O(1) 步

每个位置直接和所有位置相连,任意两个词之间都只隔一层,而且所有位置可以同时计算。

模型与计算方式关联两位置的操作数层内并行
RNN / LSTM沿时间步递推O(n),随距离线性增长否
ConvS2S堆叠卷积随距离线性增长是
ByteNet堆叠空洞卷积随距离对数增长是
Transformer自注意力常数 O(1)是
取舍:路径短了,分辨率会变低注意力的输出是对各位置的加权平均,平均会「抹平」细节,降低有效分辨率。论文用多头注意力来抵消这个问题(见模块 04)。

1.3自注意力并不是新概念

自注意力(self-attention,也叫 intra-attention)指把同一个序列中不同位置关联起来,以计算这个序列的表示。它此前已用于阅读理解、摘要生成、文本蕴含和学习句子表示等任务;端到端记忆网络则用了基于注意力的循环机制。

论文的关键说法是:据作者所知,Transformer 是第一个完全依赖自注意力来计算输入和输出表示、不使用按序列对齐的 RNN 或卷积的转导(transduction)模型。

常见误区「Transformer 发明了注意力机制。」—— 不对。注意力早就用在 RNN 翻译模型里了(如 Bahdanau 等人 2014 年的工作)。本文的创新是只用注意力,把循环和卷积彻底去掉。
自测 · 3 题先想好答案再展开
Q1RNN 训练难以并行的根本原因是什么?

ht 依赖 ht−1,同一个序列里的各时间步只能顺序计算;序列一长,显存又限制了跨样本的批量大小。

Q2ConvS2S、ByteNet 这类卷积模型相比 RNN 好在哪,又差在哪?

好在同一层所有位置可以并行计算;差在关联两个远距离位置需要的操作数随距离增长(ConvS2S 线性、ByteNet 对数),远距离依赖更难学。

Q3自注意力把路径长度降到常数,代价是什么?怎么弥补?

加权平均会降低有效分辨率;论文用多头注意力来抵消。

02§3 Model Architecture · §3.1 Encoder and Decoder Stacks第 2–3 页

整体架构:一张图看懂 Transformer

图 1 是全文最重要的一张图。先建立整体印象:左边编码器、右边解码器,各由 6 个相同的层堆叠而成,每个子层外面都套着「残差 + 层归一化」。

约 30 分钟进阶关键词:编码器 · 解码器 · 自回归 · Add & Norm

学习目标

  • 能指着图 1 说出每个模块的作用
  • 能追踪数据在模型中的形状变化
  • 理解「输出右移一位 + 掩码」怎样保证自回归

2.1编码器–解码器框架

多数有竞争力的序列转导模型都是编码器–解码器结构:编码器把输入符号序列 (x1, …, xn) 映射成连续表示 z = (z1, …, zn);解码器根据 z 每次生成一个符号,得到输出 (y1, …, ym)。每一步都是自回归的:生成下一个符号时,把已经生成的符号当作额外输入。

2.2图 1 逐块标注

把鼠标移到(或点按)右侧说明上,图中对应的编号会高亮。

论文图 1:Transformer 模型架构。左侧为编码器,右侧为解码器,各堆叠 N 层。
论文图 1:Transformer 模型架构(编号为本页添加)

2.3编码器和解码器各有几层、几个子层?

编码器 · N = 6 层

每层 2 个子层:

  1. 多头自注意力
  2. 逐位置全连接前馈网络

每个子层外都有残差连接,接着做层归一化。

解码器 · N = 6 层

每层 3 个子层:

  1. 掩码多头自注意力(不能看后面的位置)
  2. 对编码器输出的多头注意力
  3. 逐位置全连接前馈网络

同样每个子层都有残差 + 层归一化。

为了方便做残差连接,模型中所有子层和嵌入层的输出维度都是 dmodel = 512。

2.4形状追踪:数据一路怎么变

编码器(源句有 n 个词)
源句 tokenn 个
→
嵌入 + 位置编码n × 512
→
编码器层 × 6n × 512
→
编码器输出 zn × 512
解码器(目标句有 m 个词;每一层都读取编码器输出 z)
目标句(右移)m 个
→
嵌入 + 位置编码m × 512
→
解码器层 × 6m × 512
→
Linearm × |V|
→
Softmax下一个词的概率

|V| 是词表大小。注意编码器层不改变形状,「n × 512 进,n × 512 出」,所以才能随意堆叠。

2.5Add & Norm:每个子层外面的包装

Sublayer(x) 是子层本身(注意力或 FFN)。先把子层输出和输入 x 相加(残差连接),再做层归一化。训练时子层输出在相加之前还会经过 dropout(模块 07)。

这种「先相加、后归一化」的写法后来被称为 Post-LN。很多后续实现改成 Pre-LN,即 x + Sublayer(LayerNorm(x)),训练更稳定。这属于后续工作,不是本文内容。

输入 x 子层:注意力 或 FFN Dropout + LayerNorm 输出(送入下一个子层) 残差连接

2.6输出右移一位 + 掩码 = 自回归

解码器的自注意力经过修改,不允许某个位置关注它后面的位置。这个掩码,再加上「输出嵌入右移一位」,保证了位置 i 的预测只依赖于位置小于 i 的已知输出。以把 “I love you” 翻译成德语为例:

位置1234
解码器输入(右移后)<s>Ichliebedich
要预测的输出(标签)Ichliebedich</s>

<s> 表示句子开始,</s> 表示句子结束。位置 2 的输入是 “Ich”,它要预测 “liebe”,只能看到 <s> 和 Ich。

常见误区「Transformer 生成时也是并行的。」—— 只对了一半。训练时完整的目标句是已知的,配合掩码,解码器所有位置可以并行计算;推理时仍然是自回归的,必须一个词一个词地生成。
自测 · 3 题先想好答案再展开
Q1编码器每层有几个子层?解码器呢?分别是什么?

编码器 2 个:多头自注意力、FFN。解码器 3 个:掩码多头自注意力、编码器–解码器注意力、FFN。

Q2为什么所有子层的输出都统一成 dmodel = 512 维?

为了方便残差连接:x + Sublayer(x) 要求两者维度相同。

Q3「输出右移一位」和「掩码」分别解决什么问题?

右移让位置 i 的输入是第 i−1 个词,用它来预测第 i 个词;掩码阻止位置 i 看到后面的词。两者结合,保证位置 i 的预测只依赖于已知的前文。

03§3.2 Attention · §3.2.1 Scaled Dot-Product Attention第 3–4 页

缩放点积注意力:全文的核心公式

公式 (1) 只有一行,却是整个 Transformer 的发动机。先用直觉理解 Q、K、V,再亲手算一遍,最后用交互实验看懂为什么要除以 √dk。

约 40 分钟核心难点关键词:Query · Key · Value · softmax · √dk

学习目标

  • 能用自己的话解释 Q、K、V 分别是什么
  • 能写出公式 (1),并标出每一项的形状
  • 能解释缩放因子 1/√dk 的作用

3.1注意力到底在做什么

论文的定义:注意力函数把一个查询(query)和一组键–值对(key-value)映射成一个输出,query、key、value 和输出都是向量。输出是 value 的加权和,每个 value 的权重由 query 和对应 key 的兼容性函数(compatibility function)算出。

Query 查询

你想找什么

当前这个词发出的「提问」:我需要哪些信息?

Key 键

每本书的标签

每个词对外展示的「索引」,用来和 query 比较匹配程度。

Value 值

书里的内容

匹配之后真正被取走、被加权混合的信息。

图书馆类比普通检索只把最匹配的那一本书给你;注意力是「软检索」:按匹配程度给每本书分配权重(加起来等于 1),把所有书的内容按权重混合成答案。

3.2公式 (1) 与 5 个计算步骤

论文图 2 左:缩放点积注意力,自下而上依次为 MatMul、Scale、Mask(可选)、SoftMax、MatMul
论文图 2(左):缩放点积注意力
  1. 1MatMul:打分

    Q 乘以 KT,得到每个 query 对每个 key 的匹配分数。

  2. 2Scale:缩放

    所有分数除以 √dk,防止数值过大(见 3.4)。

  3. 3Mask:掩码(可选)

    解码器里把「未来位置」的分数设为 −∞(见模块 04)。

  4. 4SoftMax:归一化

    对每一行做 softmax,变成和为 1 的权重。

  5. 5MatMul:加权求和

    权重乘以 V,得到每个 query 的输出。

(1)
Q:n × dk K:m × dk V:m × dv → QKT:n × m → 输出:n × dv

实际计算时,把一组 query 打包成矩阵 Q,key 和 value 打包成矩阵 K、V,一次矩阵运算就能同时算出所有位置的输出。这就是 Transformer 能高度并行的原因。

3.3手算一遍:3 个词的小例子

假设句子只有「我 爱 你」3 个词,取 dk = 4、dv = 2(真实模型 dk = 64,这里取小值方便手算)。Q、K、V 本来由词向量乘可学习矩阵得到,这里直接给出。表格底色越深,数值越大。

Q(查询)
行d1d2d3d4
我1010
爱0201
你1100
K(键)
行d1d2d3d4
我1010
爱0101
你1110
V(值)
行v1v2
我10
爱01
你11
1打分:S = QKT

每个查询向量和每个键向量做点积,得到 3×3 的分数表(行 = 发出查询的词,列 = 被查看的词)。例如「我」看「我」:1×1 + 0×0 + 1×1 + 0×0 = 2。

QKT
行看我看爱看你
我202
爱032
你112
2缩放:÷ √dk = ÷ 2

dk = 4,所以 √dk = 2,把每个分数除以 2。真实模型 dk = 64,要除以 8。

QKT / √dk
行看我看爱看你
我1.00.01.0
爱0.01.51.0
你0.50.51.0
3softmax:按行变成权重

对每一行做 softmax,变成一组加起来等于 1 的权重。以「爱」这一行为例:e0 : e1.5 : e1 ≈ 1 : 4.48 : 2.72,归一化后 ≈ 0.12 : 0.55 : 0.33。带框的是每行最大的权重。

注意力权重
行看我看爱看你
我0.420.160.42
爱0.120.550.33
你0.270.270.45
4加权求和:× V

用权重把 V 的各行混合起来。例如「我」这一行:0.42×[1, 0] + 0.16×[0, 1] + 0.42×[1, 1] ≈ [0.84, 0.58]。

输出 = 权重 × V
行v1v2
我0.840.58
爱0.450.88
你0.730.73
怎么读结果输出的每一行,都是 V 各行按权重混合的结果。比如「爱」这一行:55% 的注意力给了自己,33% 给了「你」,12% 给了「我」,所以它的新表示 [0.45, 0.88] 主要由「爱」和「你」的 value 混合而成。

3.4为什么要除以 √dk?

论文的说法是作者猜测(we suspect):dk 较大时,点积的绝对值会变得很大,把 softmax 推进梯度极小的区域。脚注 4 给出了直观解释:假设 q 和 k 的各个分量是相互独立、均值为 0、方差为 1 的随机变量,那么

点积的标准差是 √dk。除以 √dk 之后:

dk = 64 时,点积的标准差约为 8。几个分数相差十几,softmax 的输出就几乎变成 one-hot:最大的那个接近 1,其余接近 0,梯度也几乎为 0。动手试试:

互动:不缩放会怎样?可操作

随机生成 1 个 query 和 8 个 key(每个分量都服从标准正态分布),比较 softmax(q·k) 和 softmax(q·k/√dk) 的权重分布。

选择 dk
不缩放:softmax(q·k)
缩放后:softmax(q·k / √dk)
q·k 的标准差(2000 次实测)–
理论值 √dk–
最大权重 · 不缩放–
最大权重 · 缩放后–

3.5两种常见注意力:加性 vs 点积

加性注意力(additive)

用一个单隐层的前馈网络来计算兼容性函数。理论复杂度和点积注意力相近。

点积注意力(dot-product)

和本文算法相同,只差缩放因子 1/√dk。可以用高度优化的矩阵乘法实现,实践中更快、更省显存。

dk 较小时两者表现相近;dk 较大时,不缩放的点积注意力不如加性注意力。缩放因子正是为了解决这个问题。

自测 · 3 题先想好答案再展开
Q1Q 为 n×dk、K 为 m×dk、V 为 m×dv 时,注意力权重矩阵和输出分别是什么形状?

权重矩阵 softmax(QKT/√dk) 是 n×m(每个 query 对每个 key 一个权重);输出是 n×dv。

Q2若 q、k 各分量独立、均值 0、方差 1,q·k 的方差是多少?缩放后呢?

方差为 dk;除以 √dk 后方差变为 1。

Q3为什么点积注意力比加性注意力更快?

点积注意力可以写成矩阵乘法,能直接用高度优化的矩阵乘法代码一次算完;加性注意力要过一个前馈网络。

04§3.2.2 Multi-Head Attention · §3.2.3 Applications of Attention第 4–5 页

多头注意力:从多个角度同时看

与其用一组 512 维的 Q、K、V 做一次注意力,不如切成 8 个 64 维的「头」各算各的,再拼起来。这一节还会讲清注意力在模型里的三种用法。

约 40 分钟核心难点关键词:头 · 线性投影 · Concat · 掩码 · 交叉注意力

学习目标

  • 能画出多头注意力的数据流,并标出形状
  • 理解为什么 8 个头的计算量和 1 个全维度头差不多
  • 能区分三种注意力中 Q、K、V 的来源

4.1思路:投影 h 次、并行算注意力、再拼接

用不同的、可学习的线性投影,把 query、key、value 分别投影 h 次,变成 dk、dk、dv 维;在每个投影版本上并行执行注意力,得到 h 个 dv 维的输出;把它们拼接起来,再做一次投影,得到最终结果。

为什么要多头? 多头注意力让模型能同时关注来自不同表示子空间、不同位置的信息。只用一个头时,平均操作会抑制这种能力。
论文图 2 右:多头注意力,V、K、Q 分别经过 h 组线性层,进入 h 个并行的缩放点积注意力,拼接后再经过一个线性层
论文图 2(右):多头注意力由 h 个并行的注意力层组成
输入 Xn × 512
8 组投影 WiQ、WiK、WiV每组 512 × 64
head₁n×64
head₂n×64
head₃n×64
head₄n×64
head₅n×64
head₆n×64
head₇n×64
head₈n×64
Concat 拼接n × (8×64) = n × 512
乘 WO512 × 512 → 输出 n × 512
其中投影矩阵的形状为
头数h = 8
每个头的维度dk = dv = 512 / 8 = 64
总计算量≈ 一个 512 维的单头

因为每个头的维度缩小到 1/8,8 个头加起来的计算量和一个全维度单头注意力相近:多头几乎是「免费」的。

4.2注意力在模型里的三种用法

① 编码器自注意力 Iloveyou.

Q、K、V 全部来自编码器上一层的输出。编码器中每个位置都能关注上一层的所有位置。

② 解码器掩码自注意力 × <s>Ichliebedich

每个位置只能关注截至自己(含自己)的位置。为保持自回归性质,在缩放点积注意力内部,把非法连接对应的 softmax 输入设为 −∞。

③ 编码器–解码器注意力 <s>Ichliebe Iloveyou.

Q 来自解码器上一层,K、V 来自编码器的输出。解码器每个位置都能关注输入序列的所有位置,模仿了经典 seq2seq 模型的注意力。

上排:解码器(提供 Q);下排:编码器输出(提供 K、V)

容易忽略的细节6 个解码器层用的 K、V,都来自编码器最后一层的输出 z,而不是与它同层的编码器层。

4.3互动:因果掩码

掩码让解码器「不偷看答案」可操作

把 “I love you very much” 译成 “Ich liebe dich sehr”。下表每一行是一个 query 位置,每一列是被关注的 key 位置,格子里是注意力权重。选择一行看计算过程。

当前位置
自测 · 3 题先想好答案再展开
Q1h = 8、dmodel = 512 时,每个头的 dk 是多少?WO 是什么形状?

dk = dv = 512 / 8 = 64;WO ∈ ℝhdv×dmodel = ℝ512×512。

Q2编码器–解码器注意力里,Q、K、V 分别来自哪里?

Q 来自解码器上一层的输出;K 和 V 来自编码器最后一层的输出。

Q3掩码为什么把分数设成 −∞,而不是 0?

掩码作用在 softmax 之前。e−∞ = 0,被屏蔽位置的权重才会严格等于 0;如果把分数设为 0,e0 = 1,这些位置仍会分到权重。

05§3.3 FFN · §3.4 Embeddings and Softmax · §3.5 Positional Encoding第 5–6 页

其余零件:FFN、嵌入共享与位置编码

注意力负责在位置之间交换信息。剩下的零件负责加工信息、把词变成向量,以及告诉模型「谁在前、谁在后」。

约 40 分钟进阶关键词:逐位置 · 权重共享 · 正弦位置编码

学习目标

  • 理解「逐位置」前馈网络是什么意思
  • 知道嵌入层和输出层共享权重,并乘以 √dmodel
  • 能解释正弦位置编码的公式和它的好处

5.1逐位置前馈网络(FFN)

编码器和解码器的每一层,除了注意力子层,还有一个全连接前馈网络。它分别且相同地作用在每个位置上:两个线性变换,中间夹一个 ReLU。

(2)
x₁
W₁+ReLU
2048
W₂
512
y₁
x₂
W₁+ReLU
2048
W₂
512
y₂
x₃
W₁+ReLU
2048
W₂
512
y₃
x₄
W₁+ReLU
2048
W₂
512
y₄
4 个位置共用同一组 W1、b1、W2、b2:512 → 2048 → 512

同一层里所有位置共享参数,但不同层的参数不同。也可以把它理解成两个卷积核大小为 1 的卷积。输入、输出维度 dmodel = 512,中间层维度 dff = 2048。

一个好记的分工(常见解读,非论文原话)注意力负责「位置之间交流」,FFN 负责「每个位置自己消化」。粗略估算,每层 FFN 约有 2×512×2048 ≈ 210 万个参数,大约是同层注意力投影矩阵(4×512×512 ≈ 105 万)的两倍。

5.2嵌入与 Softmax:三处共用一个矩阵

用学到的嵌入把输入和输出 token 变成 dmodel 维向量;用普通的线性变换加 softmax,把解码器输出变成下一个 token 的概率。论文让两个嵌入层和 softmax 之前的线性层共享同一个权重矩阵,并且在嵌入层里把权重乘以 √dmodel。

共享权重矩阵 E形状 |V| × 512,每一行是一个 token 的向量

① 编码器输入嵌入

按 token 编号查 E 的对应行,再乘以 √512 ≈ 22.6

② 解码器输出嵌入

同一个 E,同样查表并乘以 √512

③ Softmax 前的线性层

解码器输出(m × 512)乘以 ET(512 × |V|),得到每个词的打分

论文没说的部分论文没有解释为什么要乘 √dmodel。常见解读是:嵌入的数值较小,放大后与取值在 [−1, 1] 的位置编码量级相当,词义信息不会被位置信息淹没。另外,共享嵌入要求源语言和目标语言使用同一个词表;英德任务正好用了约 37000 个 token 的共享 BPE 词表(§5.1)。

5.3位置编码:告诉模型词序

模型里没有循环也没有卷积,自身分辨不出词的先后(把输入顺序打乱,自注意力的输出只会跟着打乱)。所以必须额外注入位置信息:在编码器和解码器的底部,把位置编码加到输入嵌入上。两者都是 dmodel 维,可以直接相加。论文使用不同频率的正弦和余弦函数:

pos 是位置,i 是维度序号:偶数维用 sin,奇数维用 cos

位置编码的每一维对应一条正弦波,波长从 2π 到 10000·2π 呈几何级数增长:靠前的维度变化快(像秒针),靠后的维度变化慢(像时针)。合在一起,每个位置都得到一个独一无二的「指纹」。

位置编码热力图 悬停或触摸查看数值

位置 pos:0 → 99
−1+1
把鼠标移到图上(手机上用手指按住拖动)查看具体数值

不同维度的波形:频率越来越低

5.4为什么选正弦?相对位置是一个线性变换

作者假设这种函数能让模型轻松学会按相对位置做注意力:对任意固定的偏移 k,PEpos+k 都能表示成 PEpos 的线性函数。用三角函数的和角公式就能看出来。令

右边的系数 cos ωk、sin ωk 只和偏移 k 有关,与位置 p 无关。也就是说,把 (sin ωp, cos ωp) 这个二维向量旋转一个固定角度 ωk,就得到位置 p+k 的编码。

学习式位置嵌入

作者也试了让模型自己学位置向量。表 3 (E):25.7 BLEU,和正弦版本几乎相同。

正弦位置编码(最终选择)

25.8 BLEU。选它是因为它可能让模型外推到比训练时更长的序列(论文的假设,文中没有实验验证)。

自测 · 4 题先想好答案再展开
Q1FFN 的「逐位置」是什么意思?不同层的 FFN 参数相同吗?

每个位置独立地经过同一组 W1、W2,位置之间不交换信息。同一层内各位置共享参数,不同层参数不同。

Q2位置编码和词嵌入怎样结合?为什么可以这样做?

直接逐元素相加。因为两者维度都是 dmodel = 512。

Q3正弦位置编码的最短和最长波长分别是多少?

最短 2π(第 0、1 维),最长接近 10000·2π,呈几何级数排列。

Q4学习式位置嵌入效果如何?作者为什么仍然选正弦?

效果几乎相同(25.7 vs 25.8 BLEU)。选正弦是因为它可能外推到训练时没见过的更长序列。

06§4 Why Self-Attention · 表 1第 6–7 页

为什么用自注意力:三把尺子比一比

第 4 节把自注意力层和循环层、卷积层放在一起,用三个标准比较:每层计算量、能否并行、远距离依赖的路径长度。表 1 是这一节的核心。

约 25 分钟进阶关键词:复杂度 · 顺序操作数 · 最大路径长度

学习目标

  • 能读懂表 1 的每一格
  • 知道自注意力在什么条件下比 RNN 更省计算
  • 理解为什么路径长度对学习远距离依赖很重要

6.1三个比较维度

尺子 ①

每层总计算复杂度

一层要做多少运算。

尺子 ②

可并行的程度

用「最少需要多少次顺序操作」来衡量,越少越能并行。

尺子 ③

最大路径长度

任意两个位置之间,前向和反向信号要走多远。越短,越容易学到远距离依赖。

6.2表 1 逐格解读

层类型每层复杂度顺序操作数最大路径长度
自注意力O(n²·d)O(1)O(1)
循环层O(n·d²)O(n)O(n)
卷积层O(k·n·d²)O(1)O(logk(n))
受限
自注意力
O(r·n·d)O(1)O(n/r)

n:序列长度;d:表示维度;k:卷积核大小;r:受限自注意力的邻域大小。卷积层的路径长度按空洞卷积计算。

6.3互动:自注意力什么时候更省?

自注意力每层是 O(n²·d),循环层是 O(n·d²),两者之比为 n/d。所以当序列长度 n 小于表示维度 d 时,自注意力层更快。机器翻译中最先进的模型使用 word-piece 或 byte-pair 表示,句子长度通常远小于 512,这个条件大多能满足。

每层计算量随序列长度变化(d = 512)拖动滑块

n = 50
自注意力 n²·d循环层 n·d²卷积层 k·n·d²(k = 3)
自注意力 n²·d–
循环层 n·d²–
自注意力 ÷ 循环层 = n/d–

这里只比较表 1 中的复杂度量级,忽略常数项,所以只看相对趋势。

6.4卷积与受限注意力

  • 单个卷积层(核宽 k < n)连不通所有输入输出位置对:连续卷积核要堆 O(n/k) 层,空洞卷积要 O(logk(n)) 层,这会拉长任意两个位置之间的最长路径。卷积层的计算量通常也比循环层多 k 倍。
  • 可分离卷积能把复杂度大幅降到 O(k·n·d + n·d²)。但即使 k = n,它的复杂度也只是等于「自注意力层 + 逐点前馈层」的组合,而这正是 Transformer 的做法。
  • 面对非常长的序列,可以把自注意力限制在以输出位置为中心、大小为 r 的邻域里:复杂度降到 O(r·n·d),代价是最大路径长度增加到 O(n/r)。作者计划在未来研究这个方向。
附带的好处:可解释性自注意力可能让模型更容易解释。作者观察注意力分布后发现:不同的头明显学会了执行不同的任务,很多头的行为和句子的句法、语义结构有关。论文说示例放在附录中,但这份 NIPS 版 PDF 没有附录,可以在 arXiv 版中看到这些注意力可视化。
自测 · 3 题先想好答案再展开
Q1n = 100、d = 512 时,自注意力层和循环层谁的每层计算量更小?

自注意力:n²·d ≈ 5.1×10⁶;循环层:n·d² ≈ 2.6×10⁷。自注意力更小,约为循环层的 n/d ≈ 0.2 倍。

Q2为什么「最大路径长度」很重要?

前向和反向信号要穿过的路径越短,越容易学到远距离依赖。

Q3受限自注意力(邻域大小 r)换来了什么,又付出了什么?

复杂度从 O(n²·d) 降到 O(r·n·d);代价是最大路径长度从 O(1) 变为 O(n/r)。

07§5 Training第 7–8 页

训练配方:数据、硬件、优化器与正则化

好模型也需要好配方。这一节的 warmup 学习率调度和标签平滑,后来几乎成了训练 Transformer 的标配。

约 25 分钟进阶关键词:BPE · Adam · warmup · dropout · 标签平滑

学习目标

  • 记住数据规模和训练时长
  • 能画出学习率曲线,并算出峰值
  • 知道两种正则化用在哪里、有什么效果

7.1数据、批处理与硬件

§5.1 数据

WMT 2014 英→德

约 450 万句对;用 byte-pair encoding 编码,源语言和目标语言共享约 37000 个 token 的词表。

§5.1 数据

WMT 2014 英→法

规模大得多:3600 万个句子,切分成 32000 个 word-piece 的词表。

§5.1 批处理

按长度分批

长度相近的句子放在一起;每批约 25000 个源 token 和 25000 个目标 token。

§5.2 硬件

1 台机器 · 8 张 P100

所有模型都在一台装有 8 张 NVIDIA P100 GPU 的机器上训练。

§5.2 base 模型

10 万步 · 约 12 小时

每步约 0.4 秒。

§5.2 big 模型

30 万步 · 约 3.5 天

每步约 1.0 秒。

7.2优化器与 warmup 学习率

使用 Adam 优化器,β1 = 0.9,β2 = 0.98,ε = 10−9。学习率按公式 (3) 随训练步数变化:

(3)

也就是说:前 warmup_steps 步学习率线性增大,之后按步数平方根的倒数衰减。论文取 warmup_steps = 4000。两段在 step = warmup_steps 处相交,那里就是峰值:

学习率曲线 拖动滑块

4000
当前设置论文默认 warmup = 4000
峰值学习率–
峰值出现在–
第 100k 步(与 warmup 无关)–
为什么要 warmup?(常见解读,非论文原话)论文没有解释原因。一种常见说法是:训练初期参数是随机的,Adam 对梯度二阶矩的估计也还不准,一上来就用大学习率容易不稳定,所以先小后大。注意 warmup 越大,峰值越低:峰值和 warmup−0.5 成正比。

7.3正则化

Residual Dropout

在每个子层的输出加到子层输入、做归一化之前施加 dropout;另外,对编码器和解码器中「嵌入 + 位置编码」的和也施加 dropout。

base 模型:Pdrop = 0.1

Label Smoothing 标签平滑

训练时使用 εls = 0.1 的标签平滑。

这会损害困惑度(模型学会变得更不确定),但能提升准确率和 BLEU。

标签平滑示意:5 个词的小词表,正确答案是 “Katze”

普通 one-hot 目标
平滑后(εls = 0.1,K = 5)
这里用的是把 ε 平均分给全部 K 个类别的常见写法:正确词 0.9 + 0.1/5 = 0.92,其余各 0.02。
论文只给出 εls 的取值,没有写具体公式。
精读彩蛋原文写的是「训练中使用了三种正则化」(We employ three types of regularization),但下面只有 Residual Dropout 和 Label Smoothing 两个小标题,其中 Residual Dropout 一段描述了两处 dropout。读论文时留意这类小出入,也是精读的乐趣。
自测 · 3 题先想好答案再展开
Q1warmup_steps = 4000 时,学习率峰值约为多少?出现在第几步?

约 7.0×10−4(512−0.5 × 4000−0.5),出现在第 4000 步。

Q2Residual Dropout 用在哪两个地方?

① 每个子层的输出,在加残差、做归一化之前;② 编码器和解码器中「嵌入 + 位置编码」的和。

Q3为什么标签平滑让困惑度变差,BLEU 却变好?

标签平滑不让模型对正确词的概率逼近 1,模型变得「不那么自信」,所以困惑度变差;但这减轻了过度自信、提高了泛化能力,准确率和 BLEU 因此提升。表 3 (D) 也印证了这一点:去掉标签平滑后 PPL 更低(4.67),BLEU 却更低(25.3)。

08§6 Results · 表 2 · 表 3第 8–9 页

实验结果与消融:更好,也更便宜

表 2 证明 Transformer 又好又省;表 3 逐个改动超参数,告诉我们哪些设计真正重要。

约 35 分钟进阶关键词:BLEU · FLOPs · 检查点平均 · 束搜索 · 消融

学习目标

  • 能复述主要结果,以及训练成本的对比
  • 知道推理时用了哪些解码设置
  • 能从表 3 总结出 3–4 条结论

8.1主结果:表 2

英→德:big 模型 28.4 BLEU,比此前最好的结果(包括集成模型)高出 2.0 以上,在 8 张 P100 上训练了 3.5 天。就连 base 模型也超过了此前所有已发表的模型和集成,训练成本只是它们的一小部分。

英→法:big 模型 41.0 BLEU,超过所有已发表的单模型,训练成本不到此前最佳模型的 1/4。

BLEU 与训练成本(横轴为对数刻度)

Transformer其他单模型空心:集成模型

越靠左上越好:BLEU 高、成本低。英→德上,big 模型只用以往集成模型约 1/3 到 1/8 的成本就超过了它们;英→法上,它用约 1/50 的成本逼近了最好的集成模型(41.0 vs 41.29)。

模型BLEU 英→德BLEU 英→法训练成本 英→德训练成本 英→法
ByteNet23.75
Deep-Att + PosUnk39.21.0×10²⁰
GNMT + RL24.639.922.3×10¹⁹1.4×10²⁰
ConvS2S25.1640.469.6×10¹⁸1.5×10²⁰
MoE26.0340.562.0×10¹⁹1.2×10²⁰
Deep-Att + PosUnk 集成40.48.0×10²⁰
GNMT + RL 集成26.3041.161.8×10²⁰1.1×10²¹
ConvS2S 集成26.3641.297.7×10¹⁹1.2×10²¹
Transformer(base)27.338.13.3×10¹⁸
Transformer(big)28.441.02.3×10¹⁹

训练成本单位为 FLOPs(浮点运算次数)。英→法的最高分 41.29 来自集成模型;在单模型中,Transformer big 的 41.0 最高。

8.2训练成本是怎么估算的

论文的估算方法:训练时间 × GPU 数量 × 每块 GPU 持续单精度浮点算力的估计值。P100 取 9.5 TFLOPS(脚注中 K80、K40、M40 分别取 2.8、3.7、6.0 TFLOPS)。

上:base 模型训练 12 小时;下:big 模型训练 3.5 天 = 84 小时(3600 为每小时秒数,8 为 GPU 数)。结果与表 2 一致。

8.3推理设置

  • 检查点平均:base 模型取最后 5 个检查点的平均(每 10 分钟保存一次),big 模型取最后 20 个。
  • 束搜索:beam size = 4,长度惩罚 α = 0.6。这些超参数是在开发集上实验选出的。
  • 最大输出长度:输入长度 + 50,能提前结束时就提前结束。
  • 英→法 big 模型使用 Pdrop = 0.1,而不是 0.3。

8.4消融实验:表 3

在英→德开发集 newstest2013 上,以 base 模型为基准,每次只改动一项(这里没有做检查点平均)。困惑度按 word-piece 计算,不能和按词计算的困惑度直接比较。

消融实验浏览器 切换分组

(A) 头数

保持计算量不变,改变头数和每头维度。单头比最佳设置低 0.9 BLEU;头太多(32 个)质量也会下降。

(B) key 的维度 dk

减小 dk 会伤害质量。这说明判断「兼容性」并不容易,比点积更精细的兼容性函数可能有益。

(C)(D) 模型规模与 dropout

模型越大越好;dropout 对防止过拟合非常有帮助,去掉后 BLEU 降到 24.6。

(E) 位置编码

把正弦位置编码换成学习式位置嵌入,结果几乎相同(25.7 vs 25.8)。

自测 · 4 题先想好答案再展开
Q1base 模型的训练成本 3.3×10¹⁸ FLOPs 是怎么来的?

12 小时 × 3600 秒 × 8 块 GPU × 9.5×10¹² FLOPS ≈ 3.3×10¹⁸。

Q2表 3 (A) 中单头注意力比基准低多少 BLEU?说明了什么?

低 0.9(24.9 vs 25.8)。说明多头确实有用;但头数并非越多越好,32 个头时降到 25.4。

Q3表 3 (D) 中去掉 dropout 会怎样?

BLEU 从 25.8 降到 24.6,困惑度从 4.92 升到 5.77,说明出现了明显的过拟合。

Q4去掉标签平滑(εls = 0)后,困惑度和 BLEU 分别怎样变化?

困惑度变好(4.92 → 4.67),BLEU 变差(25.8 → 25.3),印证了「标签平滑损害困惑度、提升 BLEU」。

09§7 Conclusion第 9 页

总结与延伸:这篇论文改变了什么

回顾三大贡献、作者自己规划的未来方向,再看看论文的局限和后来的发展。

约 15 分钟入门关键词:贡献 · 局限 · 后续影响

9.1三大贡献

结构

第一个纯注意力的转导模型

用多头自注意力取代编码器–解码器中最常用的循环层。

效率

训练快得多

训练速度显著快于基于循环或卷积的结构:base 模型 12 小时,big 模型 3.5 天。

效果

翻译新纪录

WMT14 英德、英法两个任务都达到新的最好水平;英德上甚至超过了此前所有集成模型。

9.2作者规划的未来方向

  • 把基于注意力的模型应用到其他任务上
  • 扩展到文本以外的输入输出模态
  • 研究局部的、受限的注意力机制,高效处理图像、音频、视频这类大规模输入和输出
  • 让生成过程不那么依赖顺序(less sequential)

论文的训练和评估代码发布在 GitHub 的 tensorflow/tensor2tensor 仓库。

9.3局限与思考 延伸思考

O(n²) 的代价

计算量和显存随序列长度平方增长,长序列很贵。§4 已经提出受限注意力作为方向。

推理仍是自回归

训练可以并行,生成时仍要逐词进行。这也是作者把「生成不那么依赖顺序」列为目标的原因。

点积未必最优

表 3 (B) 暗示,比点积更精细的兼容性函数可能有益,论文没有继续探索。

外推能力未验证

正弦位置编码「可能外推到更长序列」只是一个假设,文中没有实验支持。

9.4后来的故事 延伸 · 非本文内容

2017Transformer(本文)

纯注意力的编码器–解码器,用于机器翻译。

2018GPT

只用解码器,在大规模文本上做生成式预训练。

2018BERT

只用编码器,做双向的掩码语言模型预训练。

2019T5

保留编码器–解码器,把各种任务统一成「文本到文本」。

2020ViT

把图像切成小块(patch)当作 token,Transformer 进入计算机视觉。

9.5合上论文,你能讲清这 7 件事吗?

已完成 0 / 7

附速查

速查表与代码骨架

复习时用的速查资料:超参数、符号、术语,以及一份 PyTorch 风格的代码骨架。

A.1超参数速查(表 3)

超参数basebig
N(层数)编码器、解码器各 N 层66
dmodel模型维度5121024
dffFFN 中间层维度20484096
h(头数)816
dk = dvdmodel / h6464
Pdrop英→法 big 用 0.10.10.3
εls标签平滑0.10.1
训练步数10 万30 万
训练时间8 张 P10012 小时3.5 天
参数量6500 万2.13 亿
warmup_steps公式 (3)40004000
Adamβ1 = 0.9,β2 = 0.98,ε = 10−9(base 与 big 相同)

A.2符号表

n源序列长度
m目标序列长度
dmodel模型维度(512)
dffFFN 中间层维度(2048)
dk, dv每个头的 key / value 维度(64)
h头数(8)
N层数(6)
|V|词表大小
Q, K, V查询、键、值矩阵
WO多头输出投影矩阵
k卷积核大小
r受限注意力的邻域大小
Pdropdropout 比例
εls标签平滑系数

A.3中英术语对照

self-attention自注意力
multi-head attention多头注意力
scaled dot-product attention缩放点积注意力
query / key / value查询 / 键 / 值
encoder / decoder编码器 / 解码器
sequence transduction序列转导
residual connection残差连接
layer normalization层归一化
positional encoding位置编码
position-wise feed-forward逐位置前馈网络
masking掩码
auto-regressive自回归
label smoothing标签平滑
beam search束搜索
byte-pair encoding (BPE)字节对编码
perplexity (PPL)困惑度
ensemble集成模型
checkpoint averaging检查点平均

A.4PyTorch 代码骨架

教学用骨架,对应论文的公式 (1)–(3)。省略了 padding 掩码、批处理和训练循环,可以作为第三遍「复现」的起点。

transformer_core.py
import math
import torch
import torch.nn as nn
import torch.nn.functional as F


def attention(q, k, v, mask=None):
    """缩放点积注意力,公式 (1)"""
    d_k = q.size(-1)
    scores = q @ k.transpose(-2, -1) / math.sqrt(d_k)      # (..., n, n)
    if mask is not None:
        scores = scores.masked_fill(~mask, float("-inf"))   # 不允许看的位置设为 -inf
    weights = F.softmax(scores, dim=-1)                     # 每行权重和为 1
    return weights @ v, weights


class MultiHeadAttention(nn.Module):
    """多头注意力:h=8 个头,每个头 d_k = d_v = 512 / 8 = 64"""
    def __init__(self, d_model=512, h=8):
        super().__init__()
        assert d_model % h == 0
        self.h, self.d_k = h, d_model // h
        self.w_q = nn.Linear(d_model, d_model, bias=False)  # 8 个 W_i^Q 拼成一个矩阵
        self.w_k = nn.Linear(d_model, d_model, bias=False)
        self.w_v = nn.Linear(d_model, d_model, bias=False)
        self.w_o = nn.Linear(d_model, d_model, bias=False)  # W^O

    def forward(self, x_q, x_kv, mask=None):
        b, n, _ = x_q.shape

        def split(t):  # (b, len, 512) -> (b, 8, len, 64)
            return t.view(b, -1, self.h, self.d_k).transpose(1, 2)

        q, k, v = split(self.w_q(x_q)), split(self.w_k(x_kv)), split(self.w_v(x_kv))
        out, _ = attention(q, k, v, mask)
        out = out.transpose(1, 2).reshape(b, n, self.h * self.d_k)  # Concat
        return self.w_o(out)


class PositionwiseFFN(nn.Module):
    """逐位置前馈网络,公式 (2):512 -> 2048 -> 512"""
    def __init__(self, d_model=512, d_ff=2048):
        super().__init__()
        self.lin1 = nn.Linear(d_model, d_ff)
        self.lin2 = nn.Linear(d_ff, d_model)

    def forward(self, x):
        return self.lin2(F.relu(self.lin1(x)))


def positional_encoding(n, d_model=512):
    """正弦位置编码(3.5 节)"""
    pos = torch.arange(n).unsqueeze(1).float()               # (n, 1)
    i2 = torch.arange(0, d_model, 2).float()                  # 2i = 0, 2, 4, ...
    angle = pos / torch.pow(10000.0, i2 / d_model)            # (n, d_model/2)
    pe = torch.zeros(n, d_model)
    pe[:, 0::2] = torch.sin(angle)                            # 偶数维用 sin
    pe[:, 1::2] = torch.cos(angle)                            # 奇数维用 cos
    return pe


def causal_mask(n):
    """解码器掩码:位置 i 只能看 0..i(True = 允许)"""
    return torch.tril(torch.ones(n, n, dtype=torch.bool))


class EncoderLayer(nn.Module):
    """自注意力 + FFN,每个子层:LayerNorm(x + Dropout(Sublayer(x)))"""
    def __init__(self, d_model=512, h=8, d_ff=2048, p=0.1):
        super().__init__()
        self.attn = MultiHeadAttention(d_model, h)
        self.ffn = PositionwiseFFN(d_model, d_ff)
        self.norm1, self.norm2 = nn.LayerNorm(d_model), nn.LayerNorm(d_model)
        self.drop = nn.Dropout(p)

    def forward(self, x, src_mask=None):
        x = self.norm1(x + self.drop(self.attn(x, x, src_mask)))
        return self.norm2(x + self.drop(self.ffn(x)))


class DecoderLayer(nn.Module):
    """掩码自注意力 + 编码器-解码器注意力 + FFN"""
    def __init__(self, d_model=512, h=8, d_ff=2048, p=0.1):
        super().__init__()
        self.self_attn = MultiHeadAttention(d_model, h)
        self.cross_attn = MultiHeadAttention(d_model, h)
        self.ffn = PositionwiseFFN(d_model, d_ff)
        self.norms = nn.ModuleList([nn.LayerNorm(d_model) for _ in range(3)])
        self.drop = nn.Dropout(p)

    def forward(self, y, memory, tgt_mask, src_mask=None):
        y = self.norms[0](y + self.drop(self.self_attn(y, y, tgt_mask)))
        # Q 来自解码器,K、V 来自编码器输出 memory
        y = self.norms[1](y + self.drop(self.cross_attn(y, memory, src_mask)))
        return self.norms[2](y + self.drop(self.ffn(y)))


class Transformer(nn.Module):
    """6 层编码器 + 6 层解码器(base 模型)"""
    def __init__(self, vocab, d_model=512, N=6, h=8, d_ff=2048, p=0.1, max_len=1024):
        super().__init__()
        self.emb = nn.Embedding(vocab, d_model)
        self.scale = math.sqrt(d_model)                       # 嵌入乘以 sqrt(d_model)
        self.register_buffer("pe", positional_encoding(max_len, d_model))
        self.enc = nn.ModuleList([EncoderLayer(d_model, h, d_ff, p) for _ in range(N)])
        self.dec = nn.ModuleList([DecoderLayer(d_model, h, d_ff, p) for _ in range(N)])
        self.drop = nn.Dropout(p)
        self.out = nn.Linear(d_model, vocab, bias=False)
        self.out.weight = self.emb.weight                     # 嵌入层与输出层共享权重

    def embed(self, tokens):
        return self.drop(self.emb(tokens) * self.scale + self.pe[: tokens.size(1)])

    def forward(self, src, tgt, src_mask=None):
        x = self.embed(src)
        for layer in self.enc:
            x = layer(x, src_mask)
        tgt_mask = causal_mask(tgt.size(1)).to(tgt.device)
        y = self.embed(tgt)
        for layer in self.dec:
            y = layer(y, x, tgt_mask, src_mask)
        return self.out(y)                                    # softmax 交给损失函数


def lrate(step, d_model=512, warmup=4000):
    """学习率调度,公式 (3)"""
    step = max(step, 1)
    return d_model ** -0.5 * min(step ** -0.5, step * warmup ** -1.5)


# 训练配置(5.3、5.4 节)
# opt = torch.optim.Adam(model.parameters(), lr=1.0, betas=(0.9, 0.98), eps=1e-9)
# sched = torch.optim.lr_scheduler.LambdaLR(opt, lambda s: lrate(s + 1))
# loss_fn = nn.CrossEntropyLoss(label_smoothing=0.1)