第 N7 关 · 原理 · 经典网络 · 在浏览器里运行
English

2017 年的编码器–解码器 Transformer

最早的 Transformer 怎样用两摞层把一个序列变成另一个序列?

支线 · 最好在之后学: 第 17 · 完整的 Transformer 关

学完这一关,你就能读懂 2017 年最早的 Transformer 设计。它的结构图里有两摞层,这一关把两摞都搭出来。

第 17 关的模型只有一摞:数字、=、然后是英文单词,全都在同一个序列里,每一处都用带掩码的自注意力。 2017 年的第一个 Transformer 搭法不同。它是为翻译做的:读一个语言的源句子,写出另一个语言的目标句子。 所以它有两摞层:负责读的编码器(encoder)和负责写的解码器(decoder)。 (在这一页上,“目标”指要写出来的句子,不是训练用的目标值 y。)

这一关搭出这种设计,并让它做第 17 关的任务:把一个数用英文读出来。训练用的还是那 900 个数,留出的还是那 100 个:

"427"  →  four hundred twenty seven

如果你做过支线 N5,你在那里用两个 LSTM 加上它们之间的注意力解过这种任务。这个模型沿用那个方案(一个编码器、一个解码器、 从一边到另一边的注意力),只是把 LSTM 换成了注意力层。N5 是可选的,这一关用不到它。

demo.py 会打印出这一页上的每个数字。想自己运行的话,把它下载到一个单独的文件夹里, 在那里运行 python demo.py(环境配置)。它需要 PyTorch,大约运行 20 秒。

1. 两摞层

两摞层各管一部分工作:

  • 编码器一次读完整个源序列:每个源 token 都可以看其他所有源 token;
  • 解码器一次写一个词。它看已经写出来的词,也看源序列。

编码器的一层是自注意力加 FFN。解码器的一层有三个子层:对已写出的词做带掩码的自注意力,用交叉注意力(cross-attention)读源序列, 再加 FFN。

交叉注意力就是普通的注意力,只有一点不同:它的 Q 来自一个序列,K 和 V 来自另一个序列。 编码器最后的输出叫 memory:每个源 token 一个向量。解码器读的就是它。

选择在解码器的交叉注意力里,K 和 V 从哪里来?

2017 年的设计还把 LayerNorm 放在和第 17 关不同的位置。每个子层都包成 LayerNorm(x + sublayer(x)),也就是“相加并归一化”(add & norm):先加上残差,再归一化。这就是第 16 关第 3 节的包法, 叫 post-norm。第 17 关则是把进入每个子层的东西归一化(pre-norm), 第 19 关会讲为什么这样训练深的堆叠效果更好。

一个编码器层和一个解码器层

选一个方块,看它做什么、处理的是什么形状。滑块可以改变大小。

编码器层
memory (1, 5, 8) → 送到解码器的交叉注意力
解码器层
交叉注意力

每个目标词都看源句子。解码器就是这样读输入的。

输入
(B, L, d_model) = (1, 4, 8) 和 memory (1, 5, 8)
输出
(B, L, d_model) = (1, 4, 8)
Q, K, V
Q 来自解码器。K 和 V 来自 memory,即编码器的输出。
形状
每个头的权重 (B, L_tgt, L_src) = (1, 4, 5):每个目标词一行,每个源词一列
参数
256

去掉它: 没有它,解码器永远看不到源序列:它只能写一句话,不能翻译一句话。

“交叉注意力”内部,一个张量一个张量地看
张量形状发生了什么
1每个头的 Q (B, heads, L_tgt, d_k) = (1, 2, 4, 4) 来自解码器,d_model 分成几个头
2来自 memory 的 K, V (B, heads, L_src, d_k) = (1, 2, 5, 4) 来自编码器的输出
3权重 (B, heads, L_tgt, L_src) = (1, 2, 4, 5) 每个查询词一行,每个键词一列
4输出 (B, L_tgt, d_model) = (1, 4, 8) 各个头重新并排拼起来,然后乘 W_O
交叉注意力:输出 (B, L, d_model) = (1, 4, 8) · 256 个参数
注意力 前馈网络(FFN) 残差 + LayerNorm 输入
我卡在这里了 “memory”到底是什么?

它是最后一个编码器层的输出:每个源 token 一个向量,形状是 (B, L_src, d_model)。 每个源序列只算一次。每个解码器层都通过自己的交叉注意力读同一个 memory,用它来算 K 和 V。 它里面不存东西,也不训练。它只是“编码器的答案”的名字。 它不是 RNN 的隐藏状态(支线 N3)。在这一页上,单说“memory”就是指编码器的输出。 U6 和第 20 关里的“GPU 显存”(GPU memory)是另一回事。

和第 14 关一样,Q 决定注意力权重的行,K 决定列。在交叉注意力里,Q 来自解码器的输入,K 来自 memory。

解码器的输入总是以一个起始 token 开头,写作 <bos>(“beginning of sequence”,序列开头)。在还没写出任何词之前, 它给解码器提供第一个输入。第 4 节会讲解码器怎么用它。

形状 批大小为 2。解码器输入有 3 个 token(<bos> 加 2 个目标词),源序列有 6 个词。一个头的交叉注意力权重是什么形状?

现在手算一次交叉注意力。步骤和第 14 关一样:每个键一个分数,做 softmax,再对值求加权平均。 新的只是每张表从哪里来。

数字 一个解码器 token 读一个有 2 个源 token 的 memory,dₖ = 2。它的查询是 q = [√2 · ln 3, 0],约为 [1.55, 0]。来自 memory 的键是 k₀ = [1, 0] 和 k₁ = [0, 1],值是 v₀ = [4, 0] 和 v₁ = [0, 8]。输出是一个有 2 个数的向量。它的第一个数是多少?

2. 整台机器

编码器读数字,解码器写英文单词。解码器一边写,一边通过交叉注意力读编码器的输出(memory)。 选中一个方块,可以看到它的输入、输出和它有多少参数。这里的形状对应一个数(“427”), 解码器输入有 5 个 token:起始 token <bos> 和最多 4 个词。

整个模型,一块一块地看

选一个方块,看它的输入、输出和它有多少参数。在下面改变大小。

编码器:读“427”
解码器:写出英文单词
解码器层 × 2 (1, 5, 64) → (1, 5, 64)

每一层有三部分:带掩码的自注意力(每个词只看到前面的词)、交叉注意力(Q 来自词,K 和 V 来自 memory)和 FFN。一层有 49,856 个参数。

参数: 99,712(占全部的 58.2%)

参数总数: 171,232 · 每个头的 d_k = 16
占全部参数的比例 不是一层(没有参数)
形状 一个模型把数读出来,d_model = 64。一批有 32 个数。源序列的数字填充到 3 个 token,解码器输入有 5 个 token。memory(编码器的输出)是什么形状?
选择默认大小下,一个解码器层有 49,856 个参数,一个编码器层有 33,280 个。相差 16,576,正好等于一个 FFN。解码器层有什么是编码器层没有的?
深入一点 171,232 个参数都在哪里

默认大小下(d_model 64,4 个头,2 层,d_ff 128):

部件参数
一个注意力块:WQ、WK、WV(各 64 × 64)+ WO(64 × 64 + 64)16,448
一个 FFN16,576
一个编码器层:注意力 + FFN + 2 个 LayerNorm(各 128)33,280
一个解码器层:2 个注意力块 + FFN + 3 个 LayerNorm49,856
两张嵌入表:(13 + 32) × 642,880
输出层:64 × 32 + 322,080
合计:2 个编码器层 + 2 个解码器层 + 嵌入 + 输出171,232

位置数值是直接加上去的,不是学出来的,所以没有参数。 头的个数在这张表里哪儿都没出现。它只决定 64 列怎么切成几份,所以用 8 个头代替 4 个,参数还是 171,232。 这里编码器和解码器各有 2 层,但这两个数互不相关,可以不同。 嵌入表有两张:一张给 13 个源 token(数字和 3 个特殊 token),一张给 32 个目标词。

3. 放到显微镜下

下面是这个模型的一个迷你版(1 层,1 个头,d_model = 6,d_ff = 12),它读入“89”,写出下一个词。 所有的大小都不一样,所以每个轴都能靠大小认出来。每一步都显示张量带轴名的形状、 它的数值,以及同一个张量在这一页的完整模型里的形状。

显微镜下的整个模型

一步一步跟着一个输入走,从 token id 到下一个 token。把鼠标指向或点一下任何一个数,就能看到它在哪个位置。

正在加载录下的运行过程……

把鼠标指向或点一下一个数,看它的完整下标。← → 键也可以在步骤之间切换。
正数 负数 −∞ 被掩码挡住 批 位置 宽度 头 词表

下面是同一个迷你模型的编码器层画成的图,数值和显微镜里的一样。方块下面那条线是残差通路。 在这种 2017 年的层里,每次相加之后都跟一个 LayerNorm。

在 2017 年的层里,每次相加之后都对残差通路做归一化

按“下一步”,跟着“89”穿过一个编码器层。选一个块,查看它的数。

拖动旋转 · 点一下后用滚轮缩放
按“下一步”开始。
层(7)

看块下面的残差通路:每次相加之后,都有一个 LayerNorm 重新缩放这个和。这就是 post-norm。和第 17 关的块比较一下,那里的 x 直到最后才归一化。

前向(这一步) 选一层,查看它的数。

我卡在这里了 为什么加位置之前,要先把嵌入乘一个系数?

看显微镜里的第 3 步和第 4 步。每个位置数值都在 −1 和 1 之间。这个系数决定 token 和它的位置相比有多强。

这个模型的 token 表一开始的数值大小约为 1/√dmodel,和第 17 关一样。乘以 √dmodel 后,它们的大小约为 1,和位置数值一样。所以两者谁也不比谁大很多。d_model = 64 时, 系数是 √64 = 8。和第 17 关一样,这样一个 token 的那一行长度约为 8,一个位置的那一行长度约为 5.7。

人们通常也是这样解释 2017 年的设计的。在那里,输出层和嵌入表共享权重。 这是让表里的数值小的一个原因。

这很重要。假设表一开始的数值大小是 1。那么一个 token 的那一行长度约为 64,是它位置那一行的 11 倍,和第 17 关一样。 下面是每个模型答对没见过的数的比例:

  • 第 17 关的单摞模型,训练 60 轮后:用大小为 1 的表是 55% 到 79%,用小数值的表是 99% 到 100%;
  • 这个两摞模型,训练 20 轮后:用大小为 1 的表是 71%,用小数值的表是 98%;
  • 这个两摞模型,训练 60 轮后:用大小为 1 的表是 99%,用小数值的表是 100%。

所以用大小为 1 的表,这个模型要多训练几轮才能达到同样的结果。

有多个头时,注意力分数的形状是 (B, h, L_q, L_k):批、头,然后是 Q 的长度和 K 的长度。

形状 一个模型把数读出来。一批有 64 个数,源数字填充到 3 个 token,解码器输入有 5 个 token(词),有 4 个头。交叉注意力分数是什么形状?

4. 一次一个词,带着源序列

解码器写的方式和第 17 关的模型一样:运行,取最后一行,挑出概率最高的词,接到后面,再运行。 只有一点是新的。第 17 关的模型从数字和 = 开始,它们本来就在它的序列里。这个解码器的 输入只有词,所以它从起始 token <bos> 开始。数字只能通过交叉注意力到达它,编码器在写第一个词之前把它们读一次。

按 下一步,看每个阶段。数字下面的条形显示交叉注意力在写每个词时看的是哪个数字。

贪心解码,一次一个词

选一个数让训练好的模型读出来,然后按“下一步”,看它怎样选出每个词。

正在加载训练好的模型的记录……

…
正数 负数 它挑的词 挑错时的正确词
数字 正在读 742。模型已经写出了“seven hundred forty”。这一步有多少行进入解码器?
数字 一个 2 层的解码器读 742:4 个词,每步一个。模型把步与步之间不会变的结果都存起来(缓存),重复使用。在一个解码器层里,整个答案写完,memory 一共乘以 W_K 几次?

这个解码器用两个缓存。交叉注意力的缓存存的是 memory 的键和值:每个源 token 一行,只算一次。 自注意力的缓存每一步多一行。第 20 关会算这样一个缓存在显存和时间上的开销。

动手试试

把模型切换到 训练 2 轮后,让它读 896。它说的是“six hundred eighty”。 它学会了答案的样子(一个数字、“hundred”、一个表示几十的词),但还没学会哪个数字放在哪里。 看交叉注意力的条形。它们很分散,几乎一样高。

然后切回 训练 60 轮后,再读一次 896。现在每个词都看着自己的那个数字:“eight”把全部权重放在 8 上, “six”把 0.92 放在 6 上。训练好的模型把 100 个没见过的数全读对了。

5. 三种注意力和三种掩码

训练时,解码器一次拿到整个正确答案,错开一位:

427:    tgt_in   <bos>  four     hundred  twenty  seven
        tgt_out  four   hundred  twenty   seven   <eos>
我卡在这里了 为什么解码器的输入和它的目标是同样的词,只是错开一位?

因为位置 t 要猜下一个词。把它们上下对齐写出来:<bos> 下面的答案是“four”; “four”下面的答案是“hundred”。tgt_out 就是 tgt_in 往左移一步, 末尾再加上 <eos>。第 17 关在它的单个序列上做同样的错位;这里错位只涉及那些词。

模型用到三种注意力,每种都有自己的掩码。掩码的形状总是和它要挡的分数一样, 即(Q 的长度,K 的长度)。L_src 是源序列的长度,L_tgt 是解码器输入的长度,<bos> 也算在内。 所有的头都用同一个掩码:

注意力Q 来自K 和 V 来自掩码
编码器自注意力数字数字只挡住 PAD 数字
解码器自注意力tgt_intgt_in因果,并挡住 PAD 词
交叉注意力tgt_inmemory只挡住 PAD 数字

它们的分数形状是:

  • 编码器自注意力:(B, h, L_src, L_src);
  • 解码器自注意力:(B, h, L_tgt, L_tgt);
  • 交叉注意力:(B, h, L_tgt, L_src)。

下面把一个短例子的三种掩码并排放在一起。行是 Q 所来自的 token,列是 K 所来自的 token。

编码器自注意力
(3, 3),挡住 3 格
15PAD
1001
5001
PAD001
行(Q): 数字
列(K): 数字
解码器自注意力
(4, 4),挡住 9 格:6 格未来,3 格 PAD
<bos>fifteenPADPAD
<bos>0111
fifteen0011
PAD0011
PAD0011
行(Q): 解码器输入
列(K): 解码器输入
交叉注意力
(4, 3),挡住 4 格
15PAD
<bos>001
fifteen001
PAD001
PAD001
行(Q): 解码器输入
列(K): memory(数字)
挡住:未来挡住:PAD1 表示 True:被挡住。被挡住的分数变成 −∞,所以它的权重是 0。
读 15:源序列“15”填充到 3 位,解码器输入是<bos> fifteen PAD PAD。既是未来又是 PAD 的格显示为未来。
形状 源序列有 5 个 token。解码器输入是 <bos> 加 5 个目标词。解码器自注意力里的因果掩码是什么形状(一个句子)?
我卡在这里了 因果掩码的大小由哪个长度决定?

因果掩码只用在解码器的自注意力里,那里 Q 和 K 都来自解码器的输入: <bos> 加上 5 个目标词,共 6 个 token。源序列的长度从不进入因果掩码。

我卡在这里了 为什么编码器和交叉注意力不用因果掩码?

因果掩码是为了不让一个位置看到它要猜的那个词。只有解码器在猜词,也只有解码器自己的输入里有这些词。 数字是题目,不是答案:每个词都可以读整个数,每个数字也都可以读其他所有数字。

数字 读 42,所在的批里较长的答案需要 5 个词。解码器输入是 <bos> forty two PAD PAD:5 个位置。如果因果掩码挡住某一格,或者这一格所在的列是 PAD 词,解码器自注意力的掩码就挡住它。25 格里有多少格被挡住?

现在为一个例子构造全部三种掩码。和第 15 关一样,True 表示被挡住。第 15 关的填充掩码每一列只有一项; 要让它变成分数的形状,就把这一行沿每个查询行拉伸。np.broadcast_to(row, (n, len(row))) 就做这件事:np.broadcast_to(np.array([False, True]), (3, 2)) 是一张 (3, 2) 的表,三行都是 [False, True]。 | 逐格合并两张 True/False 表:只要其中一张是 True,那一格就是 True。因果的部分,回想一下 第 15 关的 np.triu。

代码为一个例子构造三种掩码。src 存的是数字的 id,tgt_in 是解码器输入的 id,pad 是 PAD 的 id。返回 (enc, dec, cross),被挡住的格为 True:enc 是 (Ls, Ls),dec 是 (Lt, Lt),cross 是 (Lt, Ls)。需要写好几行。

Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行

现在在交叉注意力里用上这个交叉掩码。写一个头,挡住源序列里的 PAD token。

代码写一个交叉注意力头。y 是解码器的行,memory 是编码器的输出;src_pad 在源 token 是 PAD 时为 True。返回 (out, A):输出和权重。需要写好几行。

Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行

深入一点 标签平滑,以及为什么损失永远到不了 0

这个模型用了 label_smoothing=0.1,和 2017 年的设计一样。每个位置的目标不是“100% 是正确的词”, 而是“90% 是正确的词,剩下的 10% 平均分给全部 32 个词”。这能防止模型变得完全确定,通常对没见过的输入有帮助。

因此,即使是完美的模型,损失也到不了 0。可能的最低损失是平滑后目标的熵。正确的词得到 0.9 + 0.1 / 32 = 0.903125, 其他 31 个词各得到 0.1 / 32 = 0.003125。所以最低损失是 −(0.903125 ln 0.903125 + 31 × 0.003125 ln 0.003125) ≈ 0.651。这次训练结束时损失是 0.652,只比它高 0.001, 同时没见过的数全部答对。训练过程中没见过的数的准确率:第 1 轮后 0%,第 10 轮后 89%,第 20 轮后 98%, 第 40 轮后 98%,第 60 轮后 100%。

6. 读懂 2017 年的原始设计

现在你认识了 2017 年原始 Transformer 的每个部件。它的结构图和正文用的是下面这些名字。 右边一栏写着本课程在哪里讲每一个。其中有些关你可能还没做。

2017 年设计里的名字它是什么本课程在哪里讲
Input Embedding、Output Embeddingtoken 表:一张给源序列,一张给目标序列第 13 关;第 2 节
把嵌入乘以 √dmodel加位置之前先缩放 token第 16 关第 1 节;第 3 节
Positional Encoding(正弦和余弦)一张固定的位置数值表,加到 token 上第 16 关第 1 节
Scaled Dot-Product Attentionsoftmax(Q Kᵀ / √dₖ) V第 14 关
Multi-Head Attention,h = 8把注意力分成 8 个头,再用 WO 合起来第 15 关第 2 节;第 21 关
Masked Multi-Head Attention解码器带因果掩码的自注意力第 15 关第 1 节;第 17 关
encoder–decoder attention交叉注意力:Q 来自解码器,K 和 V 来自编码器的输出第 1 节
Add & Norm残差,然后 LayerNorm(post-norm)第 16 关第 3 节;第 19 关
Position-wise Feed-Forward NetworksFFN,对每个位置分别使用第 16 关第 2 节
N×(N = 6)编码器和解码器里各叠了几层第 17 关;第 2 节
Outputs (shifted right)解码器输入 tgt_in:目标往右移一步,以 <bos> 开头第 5 节
Linear、Softmax输出层,以及在词表上的概率第 17 关
嵌入和输出共享权重输出层复用嵌入表(本课程没有这样做)第 3 节
label smoothing,0.1正确的 token 得 90%,10% 分给所有 token第 5 节
warmup,然后衰减的学习率学习率调度第 7 关第 4 节
dropout,0.1训练时随机把一些数值设为 0第 8 关第 2 节
beam search,宽度 4保留最好的 4 个部分答案第 18 关第 4 节

原始的大小:d_model = 512,h = 8 个头,所以 dₖ = 512 / 8 = 64;d_ff = 2048 = 4 × d_model;两边各 6 层。

今天的聊天模型只保留解码器那一摞,和第 17 关一样:“源序列”就是序列的开头部分。 在输入和输出明显是两种不同东西的地方,比如翻译或语音转文字,编码器–解码器设计仍在使用。

小结

通关后的总结

通关后,这里会显示关键公式和常见错误。

你现在会了

  • 说出编码器层和解码器层各有哪些子层,并说出交叉注意力的 Q、K、V 分别从哪里来。
  • 说出编码器–解码器里每一种注意力的分数和掩码的形状,<bos> 也算在内。
  • 用 NumPy 为一个例子构造三种掩码。

要记住

  • 交叉注意力:Q 来自解码器,K 和 V 来自 memory;分数是 (B, h, L_tgt, L_src)
  • tgt_in = <bos> + 答案,tgt_out = 答案 + <eos>:位置 t 猜第 t + 1 个词
  • 只有解码器的自注意力是因果的;编码器的自注意力和交叉注意力只挡住源序列里的 PAD token
  • 2017 年的放法把每个子层包成 LayerNorm(x + sublayer(x))(post-norm)

常见错误

  • 用源序列的长度来构造解码器的因果掩码:它应该跟着解码器的输入走,<bos> 也算在内。
  • 把交叉注意力的两个轴弄反:行是解码器的 token(Q),列是源序列的 token(K)。

按 ? 查看快捷键

阅读模式 · 实验台数值全部显示,不计星