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

嵌入与相似度

一个 token id 怎样变成一串有意义的数字?

第 12 关把文本变成了 token id。把 hello 切成字符,词表是 e、h、l、o(id 0 到 3), 这个词就变成 [1, 0, 2, 2, 3]。

网络不能直接用这些 id。它会把它们当成数量:l(2)会是 h(1)的“两倍”。 所以每个 id 都换成一小串数,也就是一个向量(vector),从一张表里查出来。这叫嵌入(embedding)。

1. 嵌入表

这张表每个 id 一行。嵌入一个 token,就是取出它的那一行。这里每行有 2 个数; 真实的模型有几百到几千个。所以一句 L 个 token 的话会变成形状 (L, d) 的数组:每个 token 一行。

形状 表 E 的形状是 (4, 2):4 个 id,每个 2 个数。你查找“hello”的 5 个 id,[1, 0, 2, 2, 3]。结果是什么形状?
选择“hello”有两个 l,在位置 2 和 3(从 0 开始数)。查表之后,它们的两个向量一样吗?

从 token 到向量:查表

选一个 token,看它的独热行乘以嵌入表。拖动一个点(或选中它后用方向键)可以改它那一行。

token id(共 5 个 token)。选一个。

嵌入表 E,形状 (4, 2)

id字符one-hotE 的行
0e0[-1.4, 0.1]
1h1[1.5, -1.2]
2l0[-0.1, -1.5]
3o0[-1.3, 1.5]
-2-2-1-11122第 1 个数 →↑ 第 2 个数ehlo
“h” → id 1 → one-hot [0, 1, 0, 0] @ E = 第 1 行 = [1.5, -1.2]

“取第 2 行”也可以写成矩阵乘法。做一个独热(one-hot)行:全是 0, 只在第 2 个位置上是 1。用它乘这张表,除了第 2 行,每一行都乘了 0。 在实验台里选一个 token,看看 one-hot 那一列。

代码用独热行乘以嵌入表来做嵌入。

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

我卡在这里了 为什么不直接把 id 当成数交给网络?h = 1、l = 2 本来就是数。

因为网络会把它们当成数量。它会“认为” l(2)是 h(1)的两倍, 而 o(3)在 l 再往后一点的地方。这些都不对。id 只是名字,按字母顺序排而已。

每个 token 用一个由好几个数组成、网络可以自由学习的向量,就没有这个问题。两个 token 可以 因为真实的原因变得接近或远离,而且可以在很多个方向上接近。

深入一点 表里的数是从哪来的

用第 12 关的 BPE token,这张表有几万行,每行有几百到几千个数。 道理和这里一样:一个 id 选出一行。

这些行一开始是随机数。它们就是权重,和第 3 关的权重完全一样,训练时用梯度下降 去移动它们。用法相似的 token 会得到相似的行,因为这有助于模型预测下一个 token。 没有人手工写进含义。第 3 节会说明为什么会这样。

2. 比较两个向量:点积

既然相似的 token 会得到相似的向量,你就需要一个数来表示“有多相似”。最简单的是 点积(dot product):把两个向量逐个数相乘,再加起来。你在第 1 关就做过这件事: 它就是矩阵乘法里的一格。

点积:方向和长度

拖动箭头的尖端(或选中它后用方向键),每次移动 0.5。选一对,看它们的夹角。

x →↑ ycatdogcar
词向量长度
cat[2, 1]2.24
dog[1.5, 1.5]2.12
car[-1, 2]2.24
一对点积cos(夹角)
2×1.5 + 1×1.5 = 4.50.949
2×-1 + 1×2 = 00.000
1.5×-1 + 1.5×2 = 1.50.316
在表里选一对,看它们的夹角。
正 点积:方向大致相同 0:成直角 负:方向大致相反
数字 [2, 1] · [1, 3] 是多少?
选择cat = [2, 1]。你把 car 转到和 cat 方向相反。cat·car 会怎样?
动手试试

cat·car 一开始正好是 0:cat 和 car 成直角。现在不动 dog,让 dog·car 正好等于 0。然后把 dog 沿同一个方向拖得离中心更远。 它和 cat 的点积变大了,但 cos(夹角) 不变。点积混合了两件事: 方向(夹角)和长度。

深入一点 点积、长度和夹角

对两个向量 aa 和 bb:

a⋅b=∣a∣ ∣b∣cos⁡θa \cdot b = |a|\,|b|\cos\theta

两个向量指向同一方向时 cos⁡θ\cos\theta 是 1,成直角时是 0,方向相反时是 −1。 把点积除以两个长度,只剩下夹角那部分,叫作余弦相似度(cosine similarity)。

下一关的注意力用的是普通的点积。长度在那里有影响:越长的向量,分数越大。

不止两个数

真实的嵌入每个 token 有几百个数,点积的算法一样:逐个数相乘,再加起来。 有三个数时,你还能看到这些向量。转动图片,选两个词。 三条轴就是每个向量的第 1、第 2、第 3 个数。它们没有名字:它们的含义由训练决定。

三维中的词向量

选两个词。拖动图片可以旋转它(先选中它才能缩放)。

拖动旋转 · 点一下后用滚轮缩放

第一个词

第二个词

和 cat 的点积,从大到小

  1. lion6
  2. dog4
  3. bus1
  4. car-1
  5. truck-4
cat · dog = 2×2 + 1×0 + 0×1 = 4 = 影子 1.79 × cat 的长度 2.24 cos(夹角) = 0.80
第一个词 第二个词 它在第一个词所在直线上的影子 小弧线标出两个词之间的夹角;夹角的余弦和影子的长度写在上面的框里。灰色箭头是其他词;离选中的词很近的灰色箭头不标名字,选中它才能看到是哪个词。 每个词的第 1、2、3 个数就是它的 x、y、z。动物指向一个方向,交通工具指向另一个方向:方向相同,点积大;成直角,点积为 0(没有影子);方向相反,点积为负(影子落在起点后面)。

3. 向量从哪里来?

这张表一开始是随机数,训练会移动它们。可是,是什么把“cat”和“dog”推到一起的? 道理很简短:一个词的含义来自它周围的词。cat 和 dog 出现在相同的位置(“the … sleeps”、 “my … is hungry”),所以一个要预测词的邻居的模型,给它们相似的向量效果最好。

只靠数数你就能看到这一点。拿四个很短的句子:“cat eats fish”、“dog eats meat”、“cat drinks milk”、 “car needs fuel”。对每个词,数一数 eats、drinks、needs 分别有几次紧挨着它(在它前面或后面一个词)。

数字 句子:“cat eats fish”、“dog eats meat”、“cat drinks milk”、“car needs fuel”。eats、drinks、needs 一共有几次紧挨着“cat”(在它前面或后面一个词)?

所以按 (eats, drinks, needs),cat = [1, 1, 0]。同样数下去,dog = [1, 0, 0],car = [0, 0, 1]。 这些计数本身就是向量,可以用第 2 节的点积来比较。

数字 按 (eats, drinks, needs):cat = [1, 1, 0],dog = [1, 0, 0],car = [0, 0, 1]。cat · dog 是多少?
选择拿成千上万个像“cat eats fish”、“dog eats meat”、“car needs fuel”这样的句子。cat 和 dog 总是出现在相同的位置,car 出现在别的位置。最后谁的计数向量离 cat 的最近?

我们自己写的规则生成了 3,850 个关于动物、食物和交通工具的短句。数出每个词前后两个词以内出现的所有其他词, 每个词就得到一长行计数。比较这些行(用余弦相似度),再把它们画到二维平面上,这些词的位置是这样的:

按邻居摆放的词

选一个词。连线把它和计数行最像的 3 个词连起来。

正在加载向量……

向量加载后会显示相似度。

没有人告诉它哪些词是动物。三个组之所以出现,是因为每一组都用在自己那类句子里。 同一组里的词很接近,但并不相同:每个词也有几句只属于自己的句子(“the dog barks at night”)。

动手试试

选“fish”。它最常见的邻居混合了两种用法:“people”(人吃鱼)旁边是“swims”、“drinks”和“water”。 我们的规则有时把 fish 当作动物来用。它的点落在食物和动物之间,离食物最近。一个向量要同时服务两种用法, 这正是下一节要讲的问题。

下面是数数这一步的代码。C[i, j] += 1 给表的第 i 行、第 j 列加 1。

代码数邻居:对每个词,它前面紧挨的词和后面紧挨的词各加 1。

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

深入一点 数数和预测

这一关先数邻居,再压缩这些计数(压缩这一步是矩阵分解;它保留各行差别最大的那些方向)。 更有名的方法是预测:一个很小的网络拿到一个词,训练它给周围的词高概率, 它的嵌入表就是结果。两种方法最后得到的向量相似,因为驱动它们的是同一件事:哪些词有相同的邻居。

语言模型(第 11 关,以及第 21 关的 GPT)不用专门要求,也会做同样的事。它的嵌入表只为 帮助预测下一个 token 而训练,用法相似的词就得到了相似的向量。

4. 一个词一个向量还不够

查找表对同一个 token 总是返回同一行,不管它在什么句子里。 这对 apple 这样的词是个问题:它在一句话里是水果,在另一句话里是公司。

这里四个数有可读的含义:水果(fruit)、科技(tech)、甜(sweet)、动作(action)。表里 apple = [1, 1, 0, 0]: 水果上一个 1,科技上一个 1,因为同一行要同时服务两种含义。 拿两句话来看:“sweet apple”和“apple releases phone”。

选择两句话里,“apple”都是在同一张表里查的。它在“sweet apple”和“apple releases phone”里的向量一样吗?

同一个词,两句话

勾选方框,把句子里的每个词按相等的权重平均。这是注意力的一个简单的初版。

sweet apple

水果科技甜动作
sweet1010
apple1100
apple →1100

apple releases phone

水果科技甜动作
apple1100
releases0101
phone0100
apple →1100
用查找表时,“apple”在两句话里得到完全相同的向量:水果 1,科技 1。

勾选方框,把每句话里的词按相等的权重混合起来。表里 sweet = [1, 0, 1, 0], releases = [0, 1, 0, 1],phone = [0, 1, 0, 0]。

数字 把“apple releases phone”的三个向量平均(apple [1, 1, 0, 0],releases [0, 1, 0, 1],phone [0, 1, 0, 0])。结果的水果那个数,也就是第一项,是多少?(保留 3 位小数)

现在用代码写出这一步,只改一处:词不一定同等重要。每个词有一个权重, 权重加起来等于 1,混合结果就是各行的加权和。权重相等(各 1/2,或各 1/3)就是 实验台里的普通平均。用一个 id 列表去索引表,会按这个顺序取出那些行:

T = np.array([[1, 2], [3, 4], [5, 6]])
T[[2, 0]]                 # [[5, 6], [1, 2]]   第 2 行和第 0 行,形状 (2, 2)
0.75 * T[2] + 0.25 * T[0] # [4, 5]   权重 0.75 和 0.25:0.75·[5, 6] + 0.25·[1, 2]

每个词写一项,只适用于词数固定的情况。第 1 关有更短的写法:一个权重向量 @ 一个矩阵,得到的正是它各行的加权和,行数多少都行。

代码写出 mix:在表 E 里查出 ids 对应的行,再用权重 w(每个 id 一个权重,加起来等于 1)把它们混合成一个 4 个数的向量。比如 ids [1, 0] 配 w = [0.75, 0.25],就是 0.75 × sweet + 0.25 × apple。写两行。

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

按相等的权重平均太简单了:每个邻居都一样重要,连不相关的词也是。 下一关正好解决这个问题。每个词会用你刚学的点积,算出从每个邻居那里取多少。

小结

通关后的总结

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

你现在会了

  • 从嵌入表里取出对应的行,把一串 token id 变成形状 (L, d) 的数组。
  • 手算点积,并读懂它的符号:方向相同、成直角、方向相反。
  • 数邻居给每个词一行数,再把一句话里的向量按相等的权重平均。

要记住

  • 嵌入 = 取出 E 的第 id 行;onehot @ E 得到同样的行
  • 在形状为 (V, d) 的 E 里查 n 个 id → (n, d)
  • :[2, 1] · [1, 3] = 5
  • E[ids].mean(axis=0):权重相等的混合,形状 (d,)
  • 用在相同位置的词会得到相似的向量

常见错误

  • 以为同一个词在不同句子里会从表里查到不同的向量:查表总是返回同一行。
  • 写成 E @ onehot,把表放在了前面:独热行 (L, 4) 应该放在前面。

按 ? 查看快捷键

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