Attention Is All You Need
Transformer 原论文逐节拆解:从「为什么不要 RNN」讲到注意力公式、多头机制、位置编码、训练配方和消融实验。9 个模块循序渐进,配手算示例和可交互图表。
学习路线:怎么用这份框架
论文正文共 9 页,这里拆成 9 个模块、5 个阶段。建议按顺序学,总共约 4.5 小时。每个模块都有学习目标、图解、误区提醒和自测题。
0.1路线图
0.2三遍阅读法
只看标题、摘要、图 1、表 2 和结论。读完能说出:论文要解决什么问题、核心想法是什么、主要结果有多好。
按本框架 01–09 逐节读:推导公式 (1),亲手算一次注意力,看懂表 1 和表 3,做完每节自测题。
对照附录的代码骨架,自己搭一个小 Transformer(比如做「复制 / 反转字符串」任务),亲手验证掩码和位置编码。
0.3前置知识自查
下面 6 项不熟也没关系,正文遇到时都会简单解释;如果完全没接触过,建议先花几分钟补一下。
(n×d) 乘 (d×m) 得到 (n×m)。能跟踪张量形状,是读懂本文的最大助力。
把任意实数向量变成和为 1 的概率分布;输入数值越大,输出越「尖」。
seq2seq:编码器读入源句,解码器逐词生成目标句。翻译模型的标准结构。
隐状态一步一步往后传,第 t 步依赖第 t−1 步,这正是本文要解决的瓶颈。
残差:输出 = x + F(x),让深层网络好训练;LayerNorm:把每个向量归一化到均值 0、方差 1。
BLEU 衡量译文和参考译文的重合度,越高越好;困惑度(PPL)衡量预测的不确定性,越低越好。
动机:为什么要抛弃 RNN?
2017 年以前,机器翻译的主流是「RNN 编码器–解码器 + 注意力」。这一节要搞清楚 RNN 慢在哪里、卷积方案差在哪里,以及 Transformer 换来了什么、付出了什么。
学习目标
- 说清 RNN 为什么难以并行训练
- 理解「关联两个位置需要多少步操作」这个衡量标准
- 知道 Transformer 的取舍:路径变短了,代价是什么、怎么补救
1.1RNN 的瓶颈:只能一步一步算
循环神经网络沿着序列逐个位置计算隐状态:
这种「天生顺序」的结构排除了样本内部的并行计算:不算完第 t−1 步,就没法算第 t 步。序列越长问题越严重,而显存又限制了跨样本的批量大小。论文提到,分解技巧(factorization tricks)和条件计算(conditional computation)等改进虽然显著提升了效率,但顺序计算这个根本约束依然存在。
1.2三种方案对比:x₁ 的信息怎样传到 x₆?
衡量一个结构「学远距离依赖」难不难,可以看两个位置之间的信号要走多少步。路径越短,梯度越容易传过去。
RNN:顺序递推
x₁ 要经过 5 次递推才到 h₆,而且这 5 步必须按顺序算,无法并行。
卷积:逐层扩大视野
卷积核 k=3 时要堆 3 层,x₁ 和 x₆ 才能「碰面」。ConvS2S 的步数随距离线性增长;ByteNet 用空洞卷积,降到 O(logk n)。
自注意力:一步直达
每个位置直接和所有位置相连,任意两个词之间都只隔一层,而且所有位置可以同时计算。
| 模型与计算方式 | 关联两位置的操作数 | 层内并行 |
|---|---|---|
| RNN / LSTM沿时间步递推 | O(n),随距离线性增长 | 否 |
| ConvS2S堆叠卷积 | 随距离线性增长 | 是 |
| ByteNet堆叠空洞卷积 | 随距离对数增长 | 是 |
| Transformer自注意力 | 常数 O(1) | 是 |
1.3自注意力并不是新概念
自注意力(self-attention,也叫 intra-attention)指把同一个序列中不同位置关联起来,以计算这个序列的表示。它此前已用于阅读理解、摘要生成、文本蕴含和学习句子表示等任务;端到端记忆网络则用了基于注意力的循环机制。
论文的关键说法是:据作者所知,Transformer 是第一个完全依赖自注意力来计算输入和输出表示、不使用按序列对齐的 RNN 或卷积的转导(transduction)模型。
Q1RNN 训练难以并行的根本原因是什么?
ht 依赖 ht−1,同一个序列里的各时间步只能顺序计算;序列一长,显存又限制了跨样本的批量大小。
Q2ConvS2S、ByteNet 这类卷积模型相比 RNN 好在哪,又差在哪?
好在同一层所有位置可以并行计算;差在关联两个远距离位置需要的操作数随距离增长(ConvS2S 线性、ByteNet 对数),远距离依赖更难学。
Q3自注意力把路径长度降到常数,代价是什么?怎么弥补?
加权平均会降低有效分辨率;论文用多头注意力来抵消。
整体架构:一张图看懂 Transformer
图 1 是全文最重要的一张图。先建立整体印象:左边编码器、右边解码器,各由 6 个相同的层堆叠而成,每个子层外面都套着「残差 + 层归一化」。
学习目标
- 能指着图 1 说出每个模块的作用
- 能追踪数据在模型中的形状变化
- 理解「输出右移一位 + 掩码」怎样保证自回归
2.1编码器–解码器框架
多数有竞争力的序列转导模型都是编码器–解码器结构:编码器把输入符号序列 (x1, …, xn) 映射成连续表示 z = (z1, …, zn);解码器根据 z 每次生成一个符号,得到输出 (y1, …, ym)。每一步都是自回归的:生成下一个符号时,把已经生成的符号当作额外输入。
2.2图 1 逐块标注
把鼠标移到(或点按)右侧说明上,图中对应的编号会高亮。
2.3编码器和解码器各有几层、几个子层?
编码器 · N = 6 层
每层 2 个子层:
- 多头自注意力
- 逐位置全连接前馈网络
每个子层外都有残差连接,接着做层归一化。
解码器 · N = 6 层
每层 3 个子层:
- 掩码多头自注意力(不能看后面的位置)
- 对编码器输出的多头注意力
- 逐位置全连接前馈网络
同样每个子层都有残差 + 层归一化。
为了方便做残差连接,模型中所有子层和嵌入层的输出维度都是 dmodel = 512。
2.4形状追踪:数据一路怎么变
|V| 是词表大小。注意编码器层不改变形状,「n × 512 进,n × 512 出」,所以才能随意堆叠。
2.5Add & Norm:每个子层外面的包装
Sublayer(x) 是子层本身(注意力或 FFN)。先把子层输出和输入 x 相加(残差连接),再做层归一化。训练时子层输出在相加之前还会经过 dropout(模块 07)。
这种「先相加、后归一化」的写法后来被称为 Post-LN。很多后续实现改成 Pre-LN,即 x + Sublayer(LayerNorm(x)),训练更稳定。这属于后续工作,不是本文内容。
2.6输出右移一位 + 掩码 = 自回归
解码器的自注意力经过修改,不允许某个位置关注它后面的位置。这个掩码,再加上「输出嵌入右移一位」,保证了位置 i 的预测只依赖于位置小于 i 的已知输出。以把 “I love you” 翻译成德语为例:
| 位置 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 解码器输入(右移后) | <s> | Ich | liebe | dich |
| 要预测的输出(标签) | Ich | liebe | dich | </s> |
<s> 表示句子开始,</s> 表示句子结束。位置 2 的输入是 “Ich”,它要预测 “liebe”,只能看到 <s> 和 Ich。
Q1编码器每层有几个子层?解码器呢?分别是什么?
编码器 2 个:多头自注意力、FFN。解码器 3 个:掩码多头自注意力、编码器–解码器注意力、FFN。
Q2为什么所有子层的输出都统一成 dmodel = 512 维?
为了方便残差连接:x + Sublayer(x) 要求两者维度相同。
Q3「输出右移一位」和「掩码」分别解决什么问题?
右移让位置 i 的输入是第 i−1 个词,用它来预测第 i 个词;掩码阻止位置 i 看到后面的词。两者结合,保证位置 i 的预测只依赖于已知的前文。
缩放点积注意力:全文的核心公式
公式 (1) 只有一行,却是整个 Transformer 的发动机。先用直觉理解 Q、K、V,再亲手算一遍,最后用交互实验看懂为什么要除以 √dk。
学习目标
- 能用自己的话解释 Q、K、V 分别是什么
- 能写出公式 (1),并标出每一项的形状
- 能解释缩放因子 1/√dk 的作用
3.1注意力到底在做什么
论文的定义:注意力函数把一个查询(query)和一组键–值对(key-value)映射成一个输出,query、key、value 和输出都是向量。输出是 value 的加权和,每个 value 的权重由 query 和对应 key 的兼容性函数(compatibility function)算出。
你想找什么
当前这个词发出的「提问」:我需要哪些信息?
每本书的标签
每个词对外展示的「索引」,用来和 query 比较匹配程度。
书里的内容
匹配之后真正被取走、被加权混合的信息。
3.2公式 (1) 与 5 个计算步骤
- 1MatMul:打分
Q 乘以 KT,得到每个 query 对每个 key 的匹配分数。
- 2Scale:缩放
所有分数除以 √dk,防止数值过大(见 3.4)。
- 3Mask:掩码(可选)
解码器里把「未来位置」的分数设为 −∞(见模块 04)。
- 4SoftMax:归一化
对每一行做 softmax,变成和为 1 的权重。
- 5MatMul:加权求和
权重乘以 V,得到每个 query 的输出。
实际计算时,把一组 query 打包成矩阵 Q,key 和 value 打包成矩阵 K、V,一次矩阵运算就能同时算出所有位置的输出。这就是 Transformer 能高度并行的原因。
3.3手算一遍:3 个词的小例子
假设句子只有「我 爱 你」3 个词,取 dk = 4、dv = 2(真实模型 dk = 64,这里取小值方便手算)。Q、K、V 本来由词向量乘可学习矩阵得到,这里直接给出。表格底色越深,数值越大。
| 行 | d1 | d2 | d3 | d4 |
|---|---|---|---|---|
| 我 | 1 | 0 | 1 | 0 |
| 爱 | 0 | 2 | 0 | 1 |
| 你 | 1 | 1 | 0 | 0 |
| 行 | d1 | d2 | d3 | d4 |
|---|---|---|---|---|
| 我 | 1 | 0 | 1 | 0 |
| 爱 | 0 | 1 | 0 | 1 |
| 你 | 1 | 1 | 1 | 0 |
| 行 | v1 | v2 |
|---|---|---|
| 我 | 1 | 0 |
| 爱 | 0 | 1 |
| 你 | 1 | 1 |
每个查询向量和每个键向量做点积,得到 3×3 的分数表(行 = 发出查询的词,列 = 被查看的词)。例如「我」看「我」:1×1 + 0×0 + 1×1 + 0×0 = 2。
| 行 | 看我 | 看爱 | 看你 |
|---|---|---|---|
| 我 | 2 | 0 | 2 |
| 爱 | 0 | 3 | 2 |
| 你 | 1 | 1 | 2 |
dk = 4,所以 √dk = 2,把每个分数除以 2。真实模型 dk = 64,要除以 8。
| 行 | 看我 | 看爱 | 看你 |
|---|---|---|---|
| 我 | 1.0 | 0.0 | 1.0 |
| 爱 | 0.0 | 1.5 | 1.0 |
| 你 | 0.5 | 0.5 | 1.0 |
对每一行做 softmax,变成一组加起来等于 1 的权重。以「爱」这一行为例:e0 : e1.5 : e1 ≈ 1 : 4.48 : 2.72,归一化后 ≈ 0.12 : 0.55 : 0.33。带框的是每行最大的权重。
| 行 | 看我 | 看爱 | 看你 |
|---|---|---|---|
| 我 | 0.42 | 0.16 | 0.42 |
| 爱 | 0.12 | 0.55 | 0.33 |
| 你 | 0.27 | 0.27 | 0.45 |
用权重把 V 的各行混合起来。例如「我」这一行:0.42×[1, 0] + 0.16×[0, 1] + 0.42×[1, 1] ≈ [0.84, 0.58]。
| 行 | v1 | v2 |
|---|---|---|
| 我 | 0.84 | 0.58 |
| 爱 | 0.45 | 0.88 |
| 你 | 0.73 | 0.73 |
3.4为什么要除以 √dk?
论文的说法是作者猜测(we suspect):dk 较大时,点积的绝对值会变得很大,把 softmax 推进梯度极小的区域。脚注 4 给出了直观解释:假设 q 和 k 的各个分量是相互独立、均值为 0、方差为 1 的随机变量,那么
dk = 64 时,点积的标准差约为 8。几个分数相差十几,softmax 的输出就几乎变成 one-hot:最大的那个接近 1,其余接近 0,梯度也几乎为 0。动手试试:
3.5两种常见注意力:加性 vs 点积
加性注意力(additive)
用一个单隐层的前馈网络来计算兼容性函数。理论复杂度和点积注意力相近。
点积注意力(dot-product)
和本文算法相同,只差缩放因子 1/√dk。可以用高度优化的矩阵乘法实现,实践中更快、更省显存。
dk 较小时两者表现相近;dk 较大时,不缩放的点积注意力不如加性注意力。缩放因子正是为了解决这个问题。
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为什么点积注意力比加性注意力更快?
点积注意力可以写成矩阵乘法,能直接用高度优化的矩阵乘法代码一次算完;加性注意力要过一个前馈网络。
多头注意力:从多个角度同时看
与其用一组 512 维的 Q、K、V 做一次注意力,不如切成 8 个 64 维的「头」各算各的,再拼起来。这一节还会讲清注意力在模型里的三种用法。
学习目标
- 能画出多头注意力的数据流,并标出形状
- 理解为什么 8 个头的计算量和 1 个全维度头差不多
- 能区分三种注意力中 Q、K、V 的来源
4.1思路:投影 h 次、并行算注意力、再拼接
用不同的、可学习的线性投影,把 query、key、value 分别投影 h 次,变成 dk、dk、dv 维;在每个投影版本上并行执行注意力,得到 h 个 dv 维的输出;把它们拼接起来,再做一次投影,得到最终结果。
为什么要多头? 多头注意力让模型能同时关注来自不同表示子空间、不同位置的信息。只用一个头时,平均操作会抑制这种能力。
因为每个头的维度缩小到 1/8,8 个头加起来的计算量和一个全维度单头注意力相近:多头几乎是「免费」的。
4.2注意力在模型里的三种用法
Q、K、V 全部来自编码器上一层的输出。编码器中每个位置都能关注上一层的所有位置。
每个位置只能关注截至自己(含自己)的位置。为保持自回归性质,在缩放点积注意力内部,把非法连接对应的 softmax 输入设为 −∞。
Q 来自解码器上一层,K、V 来自编码器的输出。解码器每个位置都能关注输入序列的所有位置,模仿了经典 seq2seq 模型的注意力。
上排:解码器(提供 Q);下排:编码器输出(提供 K、V)
4.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,这些位置仍会分到权重。
其余零件:FFN、嵌入共享与位置编码
注意力负责在位置之间交换信息。剩下的零件负责加工信息、把词变成向量,以及告诉模型「谁在前、谁在后」。
学习目标
- 理解「逐位置」前馈网络是什么意思
- 知道嵌入层和输出层共享权重,并乘以 √dmodel
- 能解释正弦位置编码的公式和它的好处
5.1逐位置前馈网络(FFN)
编码器和解码器的每一层,除了注意力子层,还有一个全连接前馈网络。它分别且相同地作用在每个位置上:两个线性变换,中间夹一个 ReLU。
2048
512
2048
512
2048
512
2048
512
同一层里所有位置共享参数,但不同层的参数不同。也可以把它理解成两个卷积核大小为 1 的卷积。输入、输出维度 dmodel = 512,中间层维度 dff = 2048。
5.2嵌入与 Softmax:三处共用一个矩阵
用学到的嵌入把输入和输出 token 变成 dmodel 维向量;用普通的线性变换加 softmax,把解码器输出变成下一个 token 的概率。论文让两个嵌入层和 softmax 之前的线性层共享同一个权重矩阵,并且在嵌入层里把权重乘以 √dmodel。
5.3位置编码:告诉模型词序
模型里没有循环也没有卷积,自身分辨不出词的先后(把输入顺序打乱,自注意力的输出只会跟着打乱)。所以必须额外注入位置信息:在编码器和解码器的底部,把位置编码加到输入嵌入上。两者都是 dmodel 维,可以直接相加。论文使用不同频率的正弦和余弦函数:
位置编码的每一维对应一条正弦波,波长从 2π 到 10000·2π 呈几何级数增长:靠前的维度变化快(像秒针),靠后的维度变化慢(像时针)。合在一起,每个位置都得到一个独一无二的「指纹」。
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。选它是因为它可能让模型外推到比训练时更长的序列(论文的假设,文中没有实验验证)。
Q1FFN 的「逐位置」是什么意思?不同层的 FFN 参数相同吗?
每个位置独立地经过同一组 W1、W2,位置之间不交换信息。同一层内各位置共享参数,不同层参数不同。
Q2位置编码和词嵌入怎样结合?为什么可以这样做?
直接逐元素相加。因为两者维度都是 dmodel = 512。
Q3正弦位置编码的最短和最长波长分别是多少?
最短 2π(第 0、1 维),最长接近 10000·2π,呈几何级数排列。
Q4学习式位置嵌入效果如何?作者为什么仍然选正弦?
效果几乎相同(25.7 vs 25.8 BLEU)。选正弦是因为它可能外推到训练时没见过的更长序列。
为什么用自注意力:三把尺子比一比
第 4 节把自注意力层和循环层、卷积层放在一起,用三个标准比较:每层计算量、能否并行、远距离依赖的路径长度。表 1 是这一节的核心。
学习目标
- 能读懂表 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,这个条件大多能满足。
这里只比较表 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)。作者计划在未来研究这个方向。
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)。
训练配方:数据、硬件、优化器与正则化
好模型也需要好配方。这一节的 warmup 学习率调度和标签平滑,后来几乎成了训练 Transformer 的标配。
学习目标
- 记住数据规模和训练时长
- 能画出学习率曲线,并算出峰值
- 知道两种正则化用在哪里、有什么效果
7.1数据、批处理与硬件
WMT 2014 英→德
约 450 万句对;用 byte-pair encoding 编码,源语言和目标语言共享约 37000 个 token 的词表。
WMT 2014 英→法
规模大得多:3600 万个句子,切分成 32000 个 word-piece 的词表。
按长度分批
长度相近的句子放在一起;每批约 25000 个源 token 和 25000 个目标 token。
1 台机器 · 8 张 P100
所有模型都在一台装有 8 张 NVIDIA P100 GPU 的机器上训练。
10 万步 · 约 12 小时
每步约 0.4 秒。
30 万步 · 约 3.5 天
每步约 1.0 秒。
7.2优化器与 warmup 学习率
使用 Adam 优化器,β1 = 0.9,β2 = 0.98,ε = 10−9。学习率按公式 (3) 随训练步数变化:
也就是说:前 warmup_steps 步学习率线性增大,之后按步数平方根的倒数衰减。论文取 warmup_steps = 4000。两段在 step = warmup_steps 处相交,那里就是峰值:
7.3正则化
Residual Dropout
在每个子层的输出加到子层输入、做归一化之前施加 dropout;另外,对编码器和解码器中「嵌入 + 位置编码」的和也施加 dropout。
base 模型:Pdrop = 0.1
Label Smoothing 标签平滑
训练时使用 εls = 0.1 的标签平滑。
这会损害困惑度(模型学会变得更不确定),但能提升准确率和 BLEU。
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)。
实验结果与消融:更好,也更便宜
表 2 证明 Transformer 又好又省;表 3 逐个改动超参数,告诉我们哪些设计真正重要。
学习目标
- 能复述主要结果,以及训练成本的对比
- 知道推理时用了哪些解码设置
- 能从表 3 总结出 3–4 条结论
8.1主结果:表 2
英→德:big 模型 28.4 BLEU,比此前最好的结果(包括集成模型)高出 2.0 以上,在 8 张 P100 上训练了 3.5 天。就连 base 模型也超过了此前所有已发表的模型和集成,训练成本只是它们的一小部分。
英→法:big 模型 41.0 BLEU,超过所有已发表的单模型,训练成本不到此前最佳模型的 1/4。
越靠左上越好:BLEU 高、成本低。英→德上,big 模型只用以往集成模型约 1/3 到 1/8 的成本就超过了它们;英→法上,它用约 1/50 的成本逼近了最好的集成模型(41.0 vs 41.29)。
| 模型 | BLEU 英→德 | BLEU 英→法 | 训练成本 英→德 | 训练成本 英→法 |
|---|---|---|---|---|
| ByteNet | 23.75 | |||
| Deep-Att + PosUnk | 39.2 | 1.0×10²⁰ | ||
| GNMT + RL | 24.6 | 39.92 | 2.3×10¹⁹ | 1.4×10²⁰ |
| ConvS2S | 25.16 | 40.46 | 9.6×10¹⁸ | 1.5×10²⁰ |
| MoE | 26.03 | 40.56 | 2.0×10¹⁹ | 1.2×10²⁰ |
| Deep-Att + PosUnk 集成 | 40.4 | 8.0×10²⁰ | ||
| GNMT + RL 集成 | 26.30 | 41.16 | 1.8×10²⁰ | 1.1×10²¹ |
| ConvS2S 集成 | 26.36 | 41.29 | 7.7×10¹⁹ | 1.2×10²¹ |
| Transformer(base) | 27.3 | 38.1 | 3.3×10¹⁸ | |
| Transformer(big) | 28.4 | 41.0 | 2.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)。
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)。
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」。
总结与延伸:这篇论文改变了什么
回顾三大贡献、作者自己规划的未来方向,再看看论文的局限和后来的发展。
9.1三大贡献
第一个纯注意力的转导模型
用多头自注意力取代编码器–解码器中最常用的循环层。
训练快得多
训练速度显著快于基于循环或卷积的结构:base 模型 12 小时,big 模型 3.5 天。
翻译新纪录
WMT14 英德、英法两个任务都达到新的最好水平;英德上甚至超过了此前所有集成模型。
9.2作者规划的未来方向
- 把基于注意力的模型应用到其他任务上
- 扩展到文本以外的输入输出模态
- 研究局部的、受限的注意力机制,高效处理图像、音频、视频这类大规模输入和输出
- 让生成过程不那么依赖顺序(less sequential)
论文的训练和评估代码发布在 GitHub 的 tensorflow/tensor2tensor 仓库。
9.3局限与思考 延伸思考
O(n²) 的代价
计算量和显存随序列长度平方增长,长序列很贵。§4 已经提出受限注意力作为方向。
推理仍是自回归
训练可以并行,生成时仍要逐词进行。这也是作者把「生成不那么依赖顺序」列为目标的原因。
点积未必最优
表 3 (B) 暗示,比点积更精细的兼容性函数可能有益,论文没有继续探索。
外推能力未验证
正弦位置编码「可能外推到更长序列」只是一个假设,文中没有实验支持。
9.4后来的故事 延伸 · 非本文内容
纯注意力的编码器–解码器,用于机器翻译。
只用解码器,在大规模文本上做生成式预训练。
只用编码器,做双向的掩码语言模型预训练。
保留编码器–解码器,把各种任务统一成「文本到文本」。
把图像切成小块(patch)当作 token,Transformer 进入计算机视觉。
9.5合上论文,你能讲清这 7 件事吗?
已完成 0 / 7
速查表与代码骨架
复习时用的速查资料:超参数、符号、术语,以及一份 PyTorch 风格的代码骨架。
A.1超参数速查(表 3)
| 超参数 | base | big |
|---|---|---|
| N(层数)编码器、解码器各 N 层 | 6 | 6 |
| dmodel模型维度 | 512 | 1024 |
| dffFFN 中间层维度 | 2048 | 4096 |
| h(头数) | 8 | 16 |
| dk = dvdmodel / h | 64 | 64 |
| Pdrop英→法 big 用 0.1 | 0.1 | 0.3 |
| εls标签平滑 | 0.1 | 0.1 |
| 训练步数 | 10 万 | 30 万 |
| 训练时间8 张 P100 | 12 小时 | 3.5 天 |
| 参数量 | 6500 万 | 2.13 亿 |
| warmup_steps公式 (3) | 4000 | 4000 |
| Adam | β1 = 0.9,β2 = 0.98,ε = 10−9(base 与 big 相同) | |
A.2符号表
A.3中英术语对照
A.4PyTorch 代码骨架
教学用骨架,对应论文的公式 (1)–(3)。省略了 padding 掩码、批处理和训练循环,可以作为第三遍「复现」的起点。
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)