第 15 关 · 原理 · 在浏览器里运行
English

掩码与多头注意力

怎样不让一个词看到某些词?怎样同时用几种方式去看?

在第 14 关,每个词都看每个词,只用一组 W_Q、W_K 和 W_V。GPT 还需要两样东西:

  1. 掩码(mask),让一个词可以被禁止看某些词:它后面的词,或者填充。
  2. 好几个头,让模型可以同时用好几种方式去看。

这一关把两样都加上,最后由你写出 GPT 的一个注意力头。

1. 掩码:谁不许看

有两种情况,需要把权重表里的一些格子强制设为零。

  • 不许往后看。 模型一次写一个词时,词 3 不能用词 4:词 4 正是它要 预测的东西。因果掩码(causal mask)挡住对角线上方的每一格。
  • 不许看填充。 一个批里的句子长短不一,所以短句会用 PAD token 补齐, 直到长度都一样。谁都不应该看这些 token。填充掩码(padding mask)挡住它们所在的列。

掩码是一张 True/False 的表,True = 挡住。被挡住的分数在 softmax 之前变成 −∞,而 e^−∞ = 0。 两个掩码用 OR 合并:只要有一个掩码挡住某一格,这一格就被挡住。

选择cat 的分数是 [0.34, 0.05, 挡住];第三个词是 PAD token。如果被挡住的分数设成 0 而不是 −∞ 会怎样?用 e^0.34 ≈ 1.40,e^0.05 ≈ 1.05,e^0 = 1。PAD token 会拿到……

掩码决定每个词可以注意哪些词

点一个词,把它变成填充。指向或点一下某个权重,看它为什么被挡住。

填充掩码 (1, 5):一行
00011
↓ 往下复制到每一行(广播)
00011
00011
00011
00011
00011
OR
因果掩码 (5, 5)
01111
00111
00011
00001
00000
=
合并后 (5, 5)
thecatsatPADPAD
the01111
cat00111
sat00011
PAD00011
PAD00011
权重(分数都相等,被挡住的格子在 softmax 之前设为 −∞)
thecatsatPADPAD
the1.000.000.000.000.00
cat0.500.500.000.000.00
sat0.330.330.330.000.00
PAD0.330.330.330.000.00
PAD0.330.330.330.000.00

在一个批里,填充掩码的形状是 (B, 1, 5);那个 1 是查询轴,掩码沿着它被复制。

25 个格子里有 12 个是开着的。
1 = 挡住:这个分数变成 −∞,权重为 0 0 = 允许
动手试试

在掩码实验台里取消勾选“因果”,点最后两个词,把它们变成填充。现在哪些列空了? 再把“因果”打开。不管你填充哪些词,哪一行总是正好只有一个开着的格子?

形状 一句话有 6 个 token。它的因果掩码是什么形状?
我卡在这里了 为什么因果掩码是一张 6×6 的表,而不只是 6 个数?

因为它是加在权重上的掩码,而权重表每个去看的词占一行,每个被看的词 占一列。对因果掩码来说,“词 i 能不能看词 j”同时取决于 i 和 j,所以需要一整张 6×6 的表。

填充掩码确实只要 6 个数,每列一个:PAD token 对所有人都是挡住的。 所以它存成一行,形状 (1, 6),用的时候再往下复制到每一行。

表的大小来自看自己的那个序列:6 个 token 看同样这 6 个 token。支线 N7 里有两个 序列的模型(源序列和目标序列,长度不同)。它的第 5 节说明了每种注意力用哪个掩码,以及哪个长度决定掩码的大小。

数字 只用因果掩码,4 个 token。16 个权重里有几个可以不为零?

整个批用一个掩码

一个批里有好几个句子,每个句子有自己的填充。它的分数形状是 (B, L, L)。

我卡在这里了 (B, 1, L) 里的 B 是什么?

B 是批大小:一起处理多少个句子。每个句子有自己的填充方式, 所以填充掩码是 (B, L),每个句子一行。分数是 (B, L, L)。为了让形状对得上,掩码在 中间加一个 1,变成 (B, 1, L),NumPy 再把这一行复制到所有 L 个查询行。这种复制叫作广播。

形状 一个批里有 2 个句子,每句 5 个 token。填充掩码是 (2, 1, 5),分数是 (2, 5, 5)。广播之后掩码是什么形状?

在实验台里,PAD 行仍然把自己的权重分给真实的词。这没关系:PAD token 的输出从来不会被用到, 损失也会跳过它。掩码只需要挡住真实的词去看 PAD。

掩码要用到两个 NumPy 函数。np.where(mask, a, b) 在 mask 为 True 的地方取 a,其余地方取 b:

blocked = np.array([True, False, False])
np.where(blocked, -np.inf, np.array([0.34, 0.05, 0.9]))   # [-inf, 0.05, 0.9]

要构造因果掩码,还要一个函数。np.triu(M, k)(“triangle, upper”,上三角)保留 M 在第 k 条对角线上及其上方的元素, 其余的设为 0(或 False)。k = 0 是主对角线,k = 1 从它上面一格开始:

np.triu(np.ones((3, 3), dtype=int), k=0)    # [[1, 1, 1],
                                            #  [0, 1, 1],
                                            #  [0, 0, 1]]
代码构造因果掩码:在词会往后看的地方(列 > 行)是 True(或 1),其余地方是 False(或 0)。

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

2. 多个头

一组 W_Q 和 W_K 给出一种看法:一张分数表。可是词和词之间同时有好几种关系。 多头注意力(multi-head attention)并排运行几个注意力,每个用这些数中单独的一片,最后再把它们混合起来。

这里 d_model = 4,有 2 个头,所以每个头分到 d_k = 2 列。头和其他东西一样,从 0 开始编号。 每个头给每个词输出 2 个数,各个头的输出并排放进一张表,叫作 concat(拼接), 头 0 在最前面。

拆分不会增加参数。W_Q、W_K 和 W_V 仍然是 (d_model, d_model):各个头分用它们的列, 而不是每个头都拿一份完整的副本,所以 8 个头的开销和 1 个大头一样。

形状 3 个词,2 个头,每个头给每个词输出 2 个数。各个头的输出合成一张叫 concat 的表,每个词一行。concat 是什么形状?
数字 2 个头,每个给每个词输出 2 个数。它们的输出并排放进一张表 concat,头 0 在最前面。头和列都从 0 开始数。头 1 的输出从 concat 的第几列开始?

现在在实验台里选一个头,跟着看它的那几列。

两个头,各用各的列,再由 W_O 混合起来

选一个头,看它拥有哪些数。X 和 W_O 可以改。

1 词;W_Q 和 W_V 是单位矩阵,所以 Q = V = X

X(3 个词 × d_model 4)= Q = V
0123
cat
dog
car
K = X W_K
0123
cat2001
dog1110
car0211

2 每个头只用自己的两列做注意力

头 0 的权重(第 0、1 列)
catdogcar
cat0.770.190.05
dog0.330.330.33
car0.050.190.77
头 1 的权重(第 2、3 列)
catdogcar
cat0.200.400.40
dog0.400.200.40
car0.250.250.50

3 各个头的输出并排放着;W_O 把它们混合成一个输出

concat(头 0, 头 1) (3 × 4)
h0h0h1h1
cat1.720.280.600.80
dog110.800.60
car0.281.720.750.75
W_O (4 × 4)
h0
h0
h1
h1
输出 = concat W_O
cat1.720.280.600.80
dog110.800.60
car0.281.720.750.75
头 0 读 Q、K、V 的第 0–1 列,写到 concat 的第 0–1 列,而 W_O 里只有第 0–1 行读它。
头 0 拥有的数 W_O 是各个头被混合的地方:进去 2 个头,出来 1 个输出。

头 0 用 Q、K、V 的第 0 列和第 1 列,这里正好就是第 14 关(第 2 节)的 cat、dog、car,所以它给出同样的权重。 头 1 用第 2 列和第 3 列,而且因为它的键交换过,得到的是另一种模式。最后只有一个输出:进去 2 个头, 经过 W_O 之后,出来 1 个输出。

我卡在这里了 头 0 只看到每个词的一半吗?

不是。每个头都用到每个词的全部 d_model 个数:Q = X @ W_Q 把每个输入数都混进 Q 的每一列。 拆分发生在 Q、K、V 上,而不是 X 上。在这个实验台里 W_Q 是单位矩阵,所以 Q 的列碰巧就是 X 的列。在训练好的模型里,Q 的第 0 列是这个词全部四个数的混合。

深入一点 W_O 做什么

各个头运行完后,它们的输出并排放着:concat 是 (3, 4)。没有 W_O 的话,头 0 的结果会一直待在 第 0–1 列,头 1 的待在第 2–3 列,永远是分开的。W_O 是一个 (4, 4) 的矩阵。输出的第 j 列是 concat 全部四列的混合,所以每个输出数都能用上两个头。W_O 的第 0–1 行是头 0 那些数的权重, 第 2–3 行是头 1 的。

数字 一个模型的 d_model = 512,有 8 个头。每个头分到几个数(dₖ)?

3. 全部合在一起

现在你已经知道每个部分了:三个投影、分数、缩放、掩码、softmax、加权平均。 下面把它们写成一个带因果掩码的函数。这就是 GPT 的一个注意力头。

代码写一个带因果掩码的注意力头,从 X 和三个权重矩阵一直算到输出 out。需要写好几行。

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

小结

通关后的总结

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

你现在会了

  • 构造因果掩码和填充掩码,并说出它们挡住了权重表的哪些格子。
  • 把 d_model 拆给几个头,并说出每个头的输出在 concat 里的位置。
  • 用 NumPy 写出一个带掩码的注意力头,从 X 一直到输出。

要记住

  • True = 挡住;被挡住的分数在 softmax 之前变成 −∞,而 e^−∞ = 0
  • 因果掩码,形状 (L, L):对一张全是 True 的表做 np.triu(…, k=1)
  • 用 np.where(mask, -np.inf, scores) 加上掩码
  • :各个头平分宽度
  • concat 是 (L, d_model),头 0 在最前;W_O 把各个头混合起来

常见错误

  • 把被挡住的分数设成 0 而不是 −∞:e⁰ = 1,被挡住的词仍然会拿到权重。
  • 在 np.triu 里用 k=0:这样连对角线也挡住了,而一个词是可以看它自己的。

按 ? 查看快捷键

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