大模型原理通俗讲解:attention、后训练和蒸馏

这篇用伪代码和能手算的小例子,讲清楚点积是什么、《Attention Is All You Need》里的 attention 怎么工作、Q K V 各自干什么、多头和几十层是怎么回事、新的 token 怎么一个一个生成出来、前馈网络和 MoE 是什么;再讲只会接龙的基座模型怎么经过后训练变成助手、编程模型怎么训练、蒸馏是什么,以及现在最前沿的模型又多了哪些技术。

文章按从浅到深的顺序排列,辅助理解的部分汇总在文末的附录里。文中的小例子数字是为了讲解编出来的;真实模型里的向量动辄几千维,每个数字没有现成的含义。

第一部分:模型怎么算出下一个 token

1. 大模型其实一直在做一件事:文字接龙

大模型每次只做一件事:看着前面所有的字,猜下一个字是什么。

先说清楚 token 是什么:token 就是模型处理文字的最小单位,大致相当于一个字或半个词。比如「今天天气很」可能被切成「今天」「天气」「很」三个 token。

1
2
3
4
5
输入:今天 天气 很
模型:猜下一个 token → 「好」
输入:今天 天气 很 好
模型:猜下一个 token → 「,」
……一直重复,直到模型猜出「结束」这个特殊 token

所以模型说的一大段话,是一个 token 一个 token 接出来的。

今天天气很输入大模型好猜出的下一个 token 把「好」接到输入末尾,再猜下一个一直重复,直到模型猜出「结束」这个特殊 token
图 1:大模型一直在做文字接龙

2. attention 要解决什么问题

每个 token 进到模型里,先被换成一串数字,叫向量(比如 4096 个数字)。可以把向量当成这个词的「意思档案」。

这串最初的数字叫词向量,是从一张「词向量表」里查出来的:

1
2
3
4
5
6
词向量表:词表里的每个 token 占一行,每行 4096 个数字
// 词表大约有 10 万个 token,所以这张表大约是 10 万行 × 4096 列

查表:
「小猫」是词表里的第 52817 号 token → 取出第 52817 行,这 4096 个数字就是「小猫」的词向量
// 编号是随便举的;表里的数字跟其他参数一样,是训练出来的(见第 12 节)

词向量只是起点。进入模型以后,每经过一层,这个向量都会被加上新的信息(见第 10 节的残差连接),所以后面说的「这个词的向量 x」,指的是它在当前这一层的样子,不一定是最初的词向量。

问题是,同一个词放在不同的句子里,意思不一样:

  • 「我吃了一个苹果」:苹果是水果
  • 「苹果发布了新手机」:苹果是公司

刚查出来的「苹果」向量是固定的,不知道自己在哪个句子里。attention 要做的事,就是让每个词去看句子里的其他词,把相关的信息吸收进自己的向量,更新成「在这句话里的意思」。

再举一个例子:「小猫跳上桌子,它很开心」。「它」本身没有意思,必须去前面找,发现「它」说的是「小猫」,然后把「小猫」的信息拿过来。attention 就是做这个「找」和「拿」的机制。

动物小猫小狗老虎家具桌子椅子沙发水果香蕉橙子公司微软谷歌刚查出来的「苹果」(不知道自己在哪个句子里)「我吃了一个苹果」「苹果发布了新手机」
图 2:词向量空间示意:意思相近的词,词向量也挨得近。真实的词向量有 4096 个数字,这里压成平面上的两个数字来画。刚查出来的「苹果」不知道自己在哪个句子里,attention 会把它往水果或公司的方向推

3. Q、K、V 分别是什么

把句子里的每个词想成相亲会上的一个人,每个人身上带着三样东西:

名字 比方和作用
Q Query,查询 我手里的需求卡:「我在找什么样的人」。当前这个词想从别的词那里找什么信息。
K Key,键 我胸前的名牌:「我是什么样的人」。这个词向别人展示自己能提供什么,用来被匹配。
V Value,值 我实际能给你的东西。一旦匹配上,真正被拿走的信息。

拿「它」举例:

  • 「它」的 Q 大概在说:「我是个代词,我在找前面出现过的一个名词,最好是活物」
  • 「小猫」的 K 大概在说:「我是名词,是动物」
  • 「桌子」的 K 大概在说:「我是名词,是家具」
  • 「它」的 Q 和「小猫」的 K 最对得上,所以「它」主要从「小猫」的 V 那里拿信息
小猫 K:名词・动物跳上 K:动作桌子 K:名词・家具它 K:代词 Q:找前面的名词最好是活物很对得上对不上有点对得上对得越上,「它」从那个词的 V 里拿走的信息越多
图 3:「它」拿着自己的 Q 去和每个词的 K 对,线越粗表示对得越上

为什么 K 和 V 要分开?因为「用来被匹配的标签」和「被拿走的内容」不一定是一回事。好比搜索引擎:你按网页标题来匹配(K),但点进去拿到的是正文(V)。

Q、K、V 是怎么来的?每个词的向量分别乘以三个矩阵 W_Q、W_K、W_V,就得到这个词的 q、k、v 三个向量。这三个矩阵是干什么的、为什么要有、从哪里来,见第 5 节「W_Q、W_K、W_V 是什么」。

4. 点积:判断两个向量像不像

后面几乎每一节都会用到「点积」,所以先单独把它讲清楚。点积是模型用来判断「两个向量像不像」的基本操作。

怎么算:对应位置相乘,再加起来

1
2
3
4
5
6
7
8
点积(a, b):
总和 = 0
对每个位置 i:
总和 = 总和 + a[i] × b[i]
返回 总和

例:a = [1, 2, 3],b = [4, 5, 6]
点积 = 1×4 + 2×5 + 3×6 = 4 + 10 + 18 = 32

它的意思:方向越一致,结果越大

假设向量的两个数字分别表示「像不像动物」「像不像家具」(真实模型里的数字没有这么好懂的含义,这里只是为了讲解):

拿「小猫」[1, 0] 去和谁做点积 算式 结果 意思
小狗 [0.9, 0.1] 1×0.9 + 0×0.1 0.9 很像:两个都是动物
桌子 [0, 1] 1×0 + 0×1 0 没关系:一个是动物,一个是家具
猫咪造型的凳子 [0.5, 0.8] 1×0.5 + 0×0.8 0.5 有点像:外形有一半像动物,但其实是家具
「绝对不是动物」[-1, 0] 1×(-1) + 0×0 -1 相反
1
2
3
4
5
6
对每个位置(也就是每个特征):
如果两个向量在这个特征上都是正数:乘出来是正数,给总分加分
如果一个是正数、一个是负数:乘出来是负数,给总分扣分
如果有一个是 0:这个特征不影响总分
最后把所有特征的得分加起来,就是点积
// 所以:方向一致 → 结果是大的正数;毫无关系 → 接近 0;方向相反 → 负数
像不像动物像不像家具小猫 [1, 0] 小狗:0.9 猫咪造型的凳子:0.5 桌子:0「绝对不是动物」:-1 冒号后面是和「小猫」做点积的结果
图 4:点积就是看两个向量的方向有多一致:方向越接近,点积越大;垂直是 0;相反是负数

打个比方:相亲时,我手里有一张需求表(「看重幽默 3 分、看重身高 1 分、讨厌抽烟 -2 分」),对方有一张自我介绍(「很幽默 2 分、身高一般 0 分、抽烟 1 分」)。每一项相乘再加起来:3×2 + 1×0 + (-2)×1 = 4,这就是「我和对方有多对得上」。attention 里的 q 和 k 做点积,就是这个意思(见第 5 节)。

还要知道一点:点积也跟向量的长短有关。方向一样时,向量越长(数字越大),点积越大。所以点积同时反映了「方向一致不一致」和「有多强烈」。另外向量的数字越多,加起来的项越多,结果也容易越大,这就是第 5 节里要「除以 √d」的原因。

矩阵乘法就是一组点积

一个向量乘以一个矩阵,就是拿这个向量去和矩阵的每一列各做一次点积,把结果排成一个新向量。第 5 节的 W_Q、W_K、W_V,第 9 节的前馈网络,用的都是这个操作。

点积是贯穿整个模型的「像不像」

1
2
3
4
attention 里:    q 和 k 做点积                    → 这个词和那个词有多对得上(第 5 节)
前馈网络里: x 和探测器做点积 → 这个词有没有某个特征、有多明显(第 9 节)
MoE 路由器里: x 和每个专家的路由向量做点积 → 这个 token 该交给哪个专家(第 19 节)
最后一步: x 和词表里每个 token 的向量做点积 → 下一个 token 是它的可能性有多大(第 11 节)

模型里几乎所有「判断」,底层都是点积在量「像不像」。

5. attention 的计算过程,代入数字走一遍

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
输入:句子里每个词的向量 x1, x2, …, xn

第 1 步:给每个词算出 q、k、v 三个向量
对每个词 i:
q_i = x_i × W_Q // 这个词想找什么
k_i = x_i × W_K // 这个词的名牌
v_i = x_i × W_V // 这个词能提供的内容

第 2 步:对每个词 i,算出它该从别的词那里拿多少
对每个词 j(句子里所有词,包括 i 自己):
如果 j 在 i 的后面:
把 i 对 j 的分数设成负无穷 // 不许偷看后面的词,见下面「因果遮罩」
否则:
分数[j] = q_i 和 k_j 做点积 ÷ √d
// 点积 = 两个向量对应位置相乘再加起来,方向越一致,结果越大(见第 4 节)
// d 是向量长度,除以 √d 是为了防止分数太大,softmax 之后变得过于极端

权重 = softmax(分数)
// softmax:把一组分数变成一组加起来等于 1 的比例,分数越高,比例越大

混合结果_i = 权重[1]×v_1 + 权重[2]×v_2 + … + 权重[n]×v_n
// 按比例把每个词的 v 混合起来

第 3 步:把混合结果加回这个词自己的向量
对每个词 i:
x_i = x_i + 混合结果_i
// 被更新的是 x,不是 v;是「加上」,不是「换掉」(见第 10 节的残差连接)
// q、k、v 只是这一层从 x 临时算出来的,用完就不再改动

输出:每个词更新后的向量 x(已经吸收了上下文的信息),交给这一层的前馈网络,再交给下一层
下一层会从更新后的 x 重新算一套 q、k、v

一句话概括:用我的 Q 去和每个人的 K 对一下,算出我该多关注谁,然后按这个比例把大家的 V 混合起来,加到我自己的向量 x 上。

W_Q、W_K、W_V 是什么

它们是三个固定的数字表格(矩阵),作用是从同一个词向量里,提取出三种不同用途的信息。词向量就是代表这个词的那串数字,见第 2 节。

矩阵乘法其实就是一组点积。

1
2
3
4
5
6
7
8
9
10
11
x = 「它」的向量,比如 [1, 0, 1](真实模型里有 4096 个数字)

W_Q 是一个表格,每一列是一个「提问方向」:
第 1 列 = [0.5, 0, 0.5]
第 2 列 = [0, 1, 0 ]

q = x × W_Q
q 的第 1 个数字 = x 和第 1 列做点积 = 1×0.5 + 0×0 + 1×0.5 = 1
q 的第 2 个数字 = x 和第 2 列做点积 = 1×0 + 0×1 + 1×0 = 0
q = [1, 0]
// 正好是下面「代入数字走一遍」里「它」的 q

所以 x × W_Q 就是:拿 x 去和 W_Q 的每一列各做一次点积,结果排成一个新向量。真实模型里,W_Q 是 4096 行 × 128 列,也就是把 4096 个数字的词向量,变成 128 个数字的 q。严格来说,只有第 1 层乘的是最初查出来的词向量;后面的层乘的是被前面几层加工过的版本,长度还是 4096 个数字(见第 2 节)。

三个矩阵各管一件事。

1
2
3
4
同一个「它」的向量 x:
q = x × W_Q // 用 W_Q 提取「我在找什么」:我是代词,在找前面的名词
k = x × W_K // 用 W_K 提取「我是什么」:我是代词
v = x × W_V // 用 W_V 提取「我能提供什么内容」

可以把它们想成三副不同的眼镜:戴上 W_Q 看这个词,看到的是「它想找什么」;戴上 W_K,看到的是「它是什么」;戴上 W_V,看到的是「它能给别人什么」。

「它」的向量 x[1, 0, 1]× W_Qq:我在找什么 × W_Kk:我是什么 × W_Vv:我能提供什么同一个 x 乘三个不同的矩阵,得到三种用途的向量
图 5:W_Q、W_K、W_V 像三副不同的眼镜:同一个词向量,乘不同的矩阵,得到用途不同的 q、k、v

为什么不直接用 x,非要乘三个矩阵。

1
2
3
4
5
6
7
8
9
10
如果不要 W_Q、W_K,直接用 x 当 q 和 k:
「它」对「小猫」的分数 = x(它) 和 x(小猫) 做点积
问题 1:每个词跟自己的点积往往最大,每个词都会最关注自己
问题 2:匹配变成了对称的:「它」对「小猫」的分数 = 「小猫」对「它」的分数
可是语言里的关系往往是单向的:「它」要去找「小猫」,「小猫」并不需要去找「它」

有了两个不同的矩阵 W_Q 和 W_K:
「它」的 q 和「小猫」的 k 可以对得很上
「小猫」的 q 和「它」的 k 可以对不上
// 「谁找谁」变成了单向的,模型才能表达「代词去找名词」这种关系

从哪里来:训练出来的。

1
2
3
训练开始:每一层、每一个头的 W_Q、W_K、W_V,都填上随机数
训练中: 每猜一次下一个 token,就把这些数字往「猜得更准」的方向调一点点
训练结束:这些数字就固定下来,之后不再改变
  • 每一层、每一个头都有自己的一套。Llama 3 8B 有 32 层、每层 32 个头,所以有 1024 套 W_Q(K 和 V 是几个头共用一套,见第 20 节讲的 GQA)。
  • 训练完之后,所有的词、所有的句子都用同一套 W_Q。同一个头里,「它」和「小猫」的 q 不一样,是因为它们的 x 不一样;用来乘的 W_Q 是同一个。
  • 「W_Q 的某一列代表什么提问方向」这种事,同样没有人规定,都是训练中为了猜准下一个 token 形成的。训练具体怎么调,见第 7 节和第 12 节。

代入数字走一遍

句子:「小猫 跳上 桌子 它」,我们算「它」从别的词那里拿到了什么。为了好算,向量只用 2 个数字,并且省掉除以 √d 那一步。下面这些数字是为了讲解编出来的,真实模型里的数字没有这么好懂的含义(见第 7 节)。

假设 v 的两个数字分别表示「像不像动物」「像不像家具」:

词 k(名牌) v(内容)
小猫 [2, 0] [1, 0]
跳上 [0, 1] [0, 0]
桌子 [1, 1] [0, 1]
它 [0.5, 0] [0, 0]

「它」的 q = [1, 0](意思是「我在找动物」)

1
2
3
4
5
6
7
8
9
10
11
12
13
第 1 步:「它」的 q 和每个词的 k 做点积
和「小猫」:1×2 + 0×0 = 2
和「跳上」:1×0 + 0×1 = 0
和「桌子」:1×1 + 0×1 = 1
和「它」 :1×0.5 + 0×0 = 0.5

第 2 步:softmax,把分数 [2, 0, 1, 0.5] 变成比例
先对每个分数求 e 的次方:7.39, 1, 2.72, 1.65,总和 12.76
每个除以总和:小猫 58%,跳上 8%,桌子 21%,它 13%

第 3 步:按比例混合每个词的 v
0.58×[1,0] + 0.08×[0,0] + 0.21×[0,1] + 0.13×[0,0]
= [0.58, 0.21]

「它」分给每个词的注意力比例:

比例 示意
小猫 58% ██████████████
桌子 21% █████
它 13% ███
跳上 8% ██

结果:混合出来的是 [0.58, 0.21],主要是「动物」的信息。这个结果会加到「它」自己的向量 x 上:

1
2
假设「它」进这一层时的 x = [0.1, 0]      // 一个代词,自己几乎没有意思(数字是为了讲解编的)
x = x + 混合结果 = [0.1, 0] + [0.58, 0.21] = [0.68, 0.21]

所以变的是「它」的 x,不是「它」的 v。表里「它」的 v 是 [0, 0],意思只是「它」自己没有什么内容可以提供给别的词。x 里带上了「动物」的信息以后,「它」现在就偏向于指小猫了。

「它」的 q = [1, 0] 词 q・k 分数 softmax 后的比例 v 小猫 258%[1, 0] 跳上 08%[0, 0] 桌子 121%[0, 1] 它 0.513%[0, 0] 加到「它」上 [0.58, 0.21] 比例 × v 再加起来:0.58×[1,0] + 0.21×[0,1] = [0.58, 0.21]
图 6:把上面代入数字的三步画在一起:分数 → 比例 → 按比例混合 v

补充:因果遮罩(不许偷看后面)

生成文字时,后面的字还没生成出来,所以每个词只能看自己和前面的词。上面伪代码里「如果 j 在 i 的后面就把分数设成负无穷」就是做这个的:负无穷经过 softmax 之后比例变成 0,等于完全不看。读到后面才明白前面时(比如读到「开心」才确定「它」是小猫),模型会不会回头改「它」的向量,见第 6 节。

每一列:可以被看的词小猫跳上桌子它很每一行:正在算新向量的词小猫看 ×××× 只能看自己跳上看看 ××× 桌子看看看 ×× 它看看看看 × 看不到后面的「很」很看看看看看最后一个词,能看全部看可以看:用这一行词的 q 和这一列词的 k 做点积,算出分数 × 不许看:这一列的词在后面,分数设成负无穷,比例变成 0
图 7:因果遮罩怎么读:先挑一行,这一行的词在算自己的新向量;再横着看,写「看」的格子就是它能看的词。比如「它」这一行(橙色)能看小猫、跳上、桌子和自己,看不到后面的「很」。第 5 节算出的 4 个比例(小猫 58%、跳上 8%、桌子 21%、它 13%),就是这一行 4 个写「看」的格子

补充:位置信息

attention 本身不知道词的先后顺序,「猫追狗」和「狗追猫」在 attention 看来是同一堆词。所以模型会给每个词的向量加上位置信息(叫位置编码,现在常用的一种叫 RoPE)。

6. 读到后面才明白前面:模型会回头改「它」的向量吗

我的问题:「小猫跳上桌子,它很开心」,读到「它」的时候,其实还不确定「它」是小猫还是桌子;读到「开心」才能确定,因为桌子不会开心。那模型读到「开心」时,会回头修改「它」的向量吗?

不会回头改。「它」到底指谁,是在后面的位置上重新判断出来的。

为什么不能回头改

1
2
3
4
5
6
7
处理到「它」的时候(在每一层):
「它」的 attention 只能看:小猫、跳上、桌子、,、它
算出「它」在这一层的新向量,同时算出「它」的 k 和 v,存进 KV cache

处理到「开心」的时候:
「它」的向量、k、v 都不会再被修改
// 因为「它」那个位置的计算规定了不能看后面的词,「开心」出现与否,对它来说没有区别

不回头改是故意这么设计的,有两个原因:

1
2
3
4
5
6
7
8
9
10
原因 1:训练的需要
训练时,模型对每个位置都要同时猜下一个 token
如果「它」的向量能看到后面的「开心」:
在「它」的位置上猜下一个字时,答案就等于被偷看了,训练就作弊了

原因 2:生成速度
现在:每生成一个新 token,前面所有词的 k、v 直接从 KV cache 里拿,只算新 token 自己
如果每来一个新词都要回头更新前面所有词的向量:
每生成一个 token,都要把整段话所有层重新算一遍
对话越长越慢,几千字之后就慢得没法用

「它指的是小猫」这个结论放在哪里

放在后面的词的位置上。每个新位置都可以重新去看前面所有的词,自己做判断:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
处理到「它」的时候:
「它」的 attention 看到了「小猫」和「桌子」
「它」的向量里写入的大概是:多半指小猫,也可能指桌子
// 读到「它」时,模型其实已经偏向小猫了:
// 小猫是句子的主语,代词通常指前面的主语;小猫是活物,「它」后面常接活物的状态
// 所以「读到『它』时还不确定」是对的,但不是五五开,而是已经有明显倾向

处理到「开心」的时候:
「开心」的 attention 可以看前面所有的词:小猫、桌子、它……
「开心」需要知道「谁开心」,于是去找「它」和它可能指的对象
桌子不会开心,小猫会开心 → 在「开心」自己的向量里写入:开心的是小猫

再往后的词需要知道「它」指谁时:
可以去看「开心」的位置(那里已经写了结论)
也可以自己再去看「它」「小猫」「桌子」,重新判断一遍
小猫跳上桌子,它很开心当时的看法:多半指小猫写完就不改新写下:开心的是小猫「开心」回头去看前面的词(只读不改),自己做判断
图 8:「它」的位置写下的看法不会再改;「开心」回头去看前面的词,把新结论写在自己的位置上

换一个结尾,就能看出这种机制的好处:

1
2
3
4
5
6
「小猫跳上桌子,它很结实」

读到「它」: 还是多半指小猫(跟上面完全一样,因为「它」看不到后面)
读到「结实」:「结实」的 attention 回头看,发现桌子更可能结实
→ 在「结实」的向量里写入:结实的是桌子
// 「它」那个位置的判断错了也没关系,后面的位置会自己纠正

打个比方:记日记

前面的位置写下的是「当时的看法」,写了就不改;后面的位置能看到更多信息,会写下「更新后的看法」。就像昨天的日记不会改,但今天可以写一句「昨天想错了,其实是……」。

有没有能回头看的模型

1. BERT 这类双向模型。BERT 没有因果遮罩,每个词同时看前面和后面的所有词,所以「它」的向量会直接吸收「开心」的信息。但它没法一个一个往外生成文字,主要用在理解类的任务上,比如分类、搜索、判断两句话意思是否相同。

2. 扩散语言模型(第 20 节)。先生成一整段模糊的文字,再一轮轮修改,每一轮所有位置都能互相看,前面的字可以根据后面的字被改掉。

3. 推理模型的思考过程,是一种很实用的「回头改」。模型想不清楚时,可以在思考过程里写出「等一下,这里的『它』应该指桌子,不是小猫」。这句话写出来之后也是新的 token,后面的计算都能看到它。相当于模型没法改旧的向量,就把修正后的看法直接写成文字,留给后面的自己用。

7. Q 里的数字是谁定义的

上面那个 [1, 0] 和「在找动物」是为了讲解编出来的。真实模型里,没有人定义 Q。Q 是算出来的,算 Q 用到的东西全是训练学出来的:

1
2
3
4
5
6
7
8
9
10
「它」在第 5 层、第 3 个头里的 q 是怎么来的:

x = 「它」进入第 5 层时的向量
// x 一开始是从「词向量表」里查出来的(这张表也是训练学的),
// 然后经过前 4 层,已经混进了上下文的信息
q = x × W_Q(第 5 层, 第 3 个头)
// W_Q 是一个数字矩阵,训练开始时全是随机数,训练中被一点点调整

所以 q 里的数字 = 学出来的词向量表 + 前面几层学出来的加工 + 学出来的 W_Q
没有任何一步是人写的规则

这里有三点要说清楚:

1. 真实模型里,q 的每个数字没有现成的含义。一个 q 向量有 128 个数字,没有哪一个数字叫「动物」。「找动物」这种意思,往往是这 128 个数字组合起来的一个方向,而且一个方向可能同时混着好几种意思。我们说「这个头在找指代对象」,是研究人员在训练完之后去观察出来的,是人事后给它起的名字,不是事先规定的。

2. 同一个「它」,在不同句子里的 Q 也不一样。因为 x 是前几层加工过的,已经带上了上下文。「小猫跳上桌子,它很开心」里的「它」,和「这个方案很好,它的成本很低」里的「它」,进到第 5 层时 x 已经不同了,所以算出来的 q 也不同,找的东西也不同。

3. 唯一「定义」了 Q 的,是训练目标:猜准下一个 token。

1
2
3
4
5
6
7
8
9
10
训练中某一次:
句子:「小猫跳上桌子,它很」,正确答案是下一个字「开心」
如果「它」的 q 没对上「小猫」的 k:
模型不知道「它」是小猫,猜「开心」的概率就低
反向计算:W_Q 里的每个数字往哪个方向调一点,
「它」的 q 就会更接近「小猫」的 k,「开心」的概率就会变高
按这个方向,把 W_Q 里的数字都调一点点(W_K、W_V 和其他所有矩阵也一起调)

这样的调整做了几万亿次之后,W_Q 自然就变成了:
遇到代词时,算出来的 q 会去对上前面名词的 k

8. 多头注意力:头的个数怎么定,分工怎么出现

一组 Q、K、V 只能从一个角度去找关系。所以模型同时用很多组(比如 32 组),每一组叫一个「头」:

1
2
3
4
5
头 1:可能学会了找「代词指的是谁」
头 2:可能学会了找「这个动词的主语是谁」
头 3:可能学会了看「前一个字是什么」
……
最后把所有头算出来的结果拼起来,再乘一个矩阵合成一个向量

头的个数:人在训练前定,但只定一个数字

头 1 代词找它指谁小猫跳上桌子,它很开心头 2 动词找主语小猫跳上桌子,它很开心头 3 看前一个词小猫跳上桌子,它很开心每个头各看各的,最后把所有头的结果拼起来,再乘一个矩阵合成一个向量
图 9:多头注意力示意:同一句话,不同的头关注的关系不一样(每个头干什么是训练出来的,这里是举例)

头的个数是人定的,属于「超参数」。超参数就是训练开始之前人手工设定、训练中不会变的配置,比如层数、向量长度、头数。人只定「有 32 个头」,不定每个头干什么。

没有一个「100 种功能」的菜单让模型去挑。每个头一开始都是一组随机数,地位完全平等,没有任何预设的角色。

一些真实模型的配置:

模型 层数 每层的头数 每个头的向量长度
GPT-2 小号 12 12 64
GPT-3(1750 亿参数) 96 96 128
Llama 3 8B 32 32 128

人一般是这样定头数的:

1
2
3
4
先定每个词的向量总长度 d_model(模型越大,d_model 越大,比如 4096)
再定每个头的向量长度,经验上通常取 64 或 128
头数 = d_model ÷ 每个头的长度
例:4096 ÷ 128 = 32 个头

为什么是 64 或 128?是试出来的经验值:每个头的长度太短,一个头能表达的东西太少;太长,头数就少了,角度不够多。研究发现,在模型总大小固定时,头数从十几个变成几十个,效果差别不大;真正决定效果的主要是模型总大小和训练数据量。还有研究发现,训练好的模型里很多头删掉也几乎不影响效果(论文《Are Sixteen Heads Really Better than One?》,2019),说明头数给多了,也只是有些头闲着。

分工是怎么出现的:像一家公司招了 32 个新人,不分配岗位,只看整体业绩

1
2
3
4
5
6
7
8
9
10
11
12
13
训练开始:
32 个头的 W_Q、W_K、W_V 都是不同的随机数
// 起点不同很关键:如果 32 个头的随机数一模一样,它们会被一模一样地调整,永远一样

每一次训练:
模型猜下一个 token,算出猜错了多少
对每个头:算出「这个头的矩阵往哪个方向调,能让整体猜得更准」,然后调一点点

为什么各个头会分到不同的活:
如果头 1 已经在找「代词指的是谁」,并且找得不错:
那么让头 2 也去做同一件事,对猜准下一个字几乎没有额外帮助
头 2 被调整的方向,就会偏向「还有哪些错误没被解决」,比如「动词的主语是谁」
// 每个头被调整的方向,取决于其他头已经做了什么、还剩下哪些错误

为什么偏偏会出现「找代词指的是谁」这样的头?因为训练数据里大量的句子需要它。几万亿个 token 的文本里,「它」「他」「这个」到处都是,不知道代词指谁,后面的字就经常猜错。这类错误反复出现、数量巨大,所以总会有某个头被推着去解决这件事。反过来说,数据里常用的规律,就会有头去学;数据里很少用到的规律,就没有头专门去学。

人怎么知道某个头在找代词?是训练完之后去观察:把很多带代词的句子喂进去,看某个头的 attention 比例是不是总集中在代词指的那个名词上。研究人员确实在 BERT 里找到过这样的头(《What Does BERT Look At?》,2019)。还有一种很有名的头叫「归纳头」:如果前面出现过「A B」,后面又出现「A」,归纳头就去找前面那个 A 后面跟的是什么,然后预测下一个是「B」。但要说清楚:大部分头的作用人看不太懂,能被清楚命名的只是一小部分。

9. 前馈网络:每个词自己去查记忆

前馈网络在哪里

1
2
3
一个 Transformer 层:
x = x + attention(x) // 第一部分:词和词之间交换信息
x = x + 前馈网络(x) // 第二部分:每个词自己加工
attention 前馈网络
看不看别的词 看。每个词去看前面所有的词 不看。每个词单独处理,互相之间没有任何交流
干什么 把别的词的信息搬过来 拿自己现在的向量,去自己的「记忆」里查东西,把查到的加回来
比方 开会:问别人、听别人说 散会后回到工位,自己翻手册、查资料

前馈网络英文叫 Feed-Forward Network,常简写成 FFN,也有人叫它 MLP。名字的意思是「数据只往前走一遍,不绕回来」,跟它干什么关系不大,不用纠结这个名字。

结构:放大、筛选、缩回

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
输入:一个词的向量 x(4096 个数字)

第 1 步:放大
h = x × W1 // W1 把 4096 个数字变成 16384 个数字(通常放大到 4 倍左右)

第 2 步:筛选
对 h 里的每一个数字:
如果这个数字大于 0:保留
否则:变成 0
// 这一步叫激活函数,上面写的是最简单的一种,叫 ReLU
// 现在的模型多用 SwiGLU,多了一个「门」矩阵,道理是一样的

第 3 步:缩回
输出 = h × W2 // W2 把 16384 个数字变回 4096 个数字

最后:x = x + 输出 // 残差连接,加回到原来的向量上

怎么理解:16384 个「探测器」,每个探测器配一条「笔记」

只看矩阵乘法很难理解它在干嘛。换个角度看就清楚了(这个看法来自论文《Transformer Feed-Forward Layers Are Key-Value Memories》,2021):

1
2
3
4
5
6
7
8
9
W1 可以看成 16384 个探测器,每个探测器检查一种模式
W2 可以看成 16384 条笔记,跟探测器一一对应

对每个探测器 i:
分数_i = x 和探测器 i 做点积 // x 跟这个探测器要找的模式有多像
如果 分数_i > 0:这个探测器「亮了」
否则:这个探测器不亮,分数变成 0

输出 = 每个亮了的探测器的分数 × 它对应的那条笔记,全部加起来
探测器(W1 的一列)点积 ReLU 后对应的笔记(W2 的一行)「首」的向量 x4096 个数字#5021 国家 + 首 3.23.2 加上「都」的方向#880 法国 + 首都 2.12.1 加上「巴黎」的方向#12000 一首歌 -1.50 不加#301 在写代码 -0.40 不加…… 一共 16384 个,大部分不亮输出 = 3.2 × 笔记 #5021 + 2.1 × 笔记 #880 + ……,再加回 x
图 10:前馈网络:x 和每个探测器做点积,ReLU 把负数变成 0,亮了的探测器按强度把自己的笔记加进来

这跟 attention 很像:都是「拿我的向量去和一堆东西做点积 → 算出该取哪些 → 按比例把对应的内容加起来」。区别是:

  • attention 里被比对的 k 和取走的 v,来自这句话里的其他词,每句话都不一样
  • 前馈网络里的探测器和笔记,是训练时学好、固定写在参数里的,不管输入什么句子都是同一套

attention 是查这句话的上下文,前馈网络是查模型自己的记忆。

走一个例子:「巴黎是法国的首」

还是看最后一个位置「首」,在中间某一层:

1
2
3
4
5
6
7
8
9
10
进入这一层时:
attention 已经把「巴黎」「法国」的信息搬进了「首」的向量

前馈网络:
探测器 #5021:检查「前面在说一个国家 + 当前是『首』」→ 分数 3.2,亮了
对应的笔记:往向量里加上「接下来很可能是『都』」的方向
探测器 #880:检查「法国 + 首都」→ 分数 2.1,亮了
对应的笔记:往向量里加上「巴黎」「首都」相关的方向
探测器 #12000:检查「在说一首歌」→ 分数 -1.5,不亮,什么都不加
……16384 个探测器里,大部分都不亮

探测器的编号和含义是为了讲解编的。真实模型里,一个探测器往往同时对好几种不相干的模式都有反应,没这么干净。

为什么第 2 步「筛选」不能少

如果不做筛选,x × W1 × W2 等于 x × (W1 × W2),两个矩阵合起来就是一个矩阵,放大到 16384 也白放大了。正是「小于 0 就变成 0」这一步,让前馈网络能做「如果看到这种模式才加这条笔记,否则什么都不加」这种判断。

点积输出 -4-224ReLUGELU(虚线)ABC 小于 0 的点积变成 0;大于 0 的原样保留绿点是第 9 节的探测器 A(2.5)、B(0.1)、C(-1 → 0)
图 11:ReLU 和 GELU:负数被压成 0(或接近 0),正数基本原样保留

点积和 ReLU 合起来在做什么

我的理解是:点积用来检查向量里有没有某个特征,ReLU 让「有这个特征的就保留,没有的就直接变成 0」。这个理解基本对,再补三点:

1. 点积算出来的不只是「有没有」,还有「有多强」。

1
2
3
4
5
x = [1, 0.5]

探测器 A = [2, 1] 点积 = 1×2 + 0.5×1 = 2.5 → ReLU 后保留 2.5,对应的笔记按 2.5 倍加进去
探测器 B = [0.1, 0] 点积 = 0.1 → ReLU 后保留 0.1,对应的笔记只加一点点
探测器 C = [-1, 0] 点积 = -1 → ReLU 后变成 0,对应的笔记完全不加
  • 如果 x 里有某个特征,点积的大小就是这个特征有多明显
  • ReLU 把这个强度原样留下来;如果点积是负数,就说明 x 里没有这个特征,ReLU 直接把它变成 0
  • 特征越明显,对应的笔记就加得越多

2. 「大于 0」这个门槛也是可以学的。早期的模型会在点积后面再加一个数字(叫偏置),这时的判断就变成「点积大于某个门槛才算数」,每个探测器的门槛都是训练出来的。现在很多大模型(比如 Llama)把偏置去掉了,但道理一样。另外,现在的模型多用 GELU、SwiGLU 这类比 ReLU 更「圆滑」的函数:小于 0 的部分不是一刀切成 0,而是慢慢压到接近 0。理解的时候按 ReLU 来想就够了。

3. 「特征」很广义,而且比想象中更乱。一个特征可以是任何东西:

  • 某个具体的词,比如「当前这个字是『首』」
  • 语法,比如「这里是一个动词的宾语」
  • 话题,比如「在讲法国」
  • 格式,比如「现在在一段代码的字符串里面」
  • 语气,比如「这句话是在讽刺」

但真实模型里有个麻烦:探测器和特征不是一一对应的。一个探测器往往同时对好几种毫不相干的特征都有反应(比如同时对「法语」和「棒球」亮);反过来,一个特征也常常分散在很多个探测器上。原因是模型要记的特征远比探测器多,只好挤在一起存(见下面「16384 个探测器够用吗」)。第 21 节提到的「金门大桥特征」,就是 Anthropic 用专门的方法把这些挤在一起的特征拆开之后找到的。

知识主要存在前馈网络里

1. 参数大部分在前馈网络里。以向量长度 4096 的模型为例:

1
2
3
4
5
6
attention 的参数:W_Q、W_K、W_V,再加最后合并多头的那个矩阵,一共 4 个 4096×4096 的矩阵
≈ 6700 万个数字
前馈网络的参数:W1 是 4096×16384,W2 是 16384×4096
≈ 1.34 亿个数字

前馈网络大约占每一层参数的三分之二

2. 改前馈网络,就能改模型记住的事实。有一篇很有名的研究(ROME,2022):研究人员找到模型中间几层前馈网络里存着「埃菲尔铁塔在巴黎」的位置,只改了那一层前馈网络里的一小部分数字,模型就开始坚持「埃菲尔铁塔在罗马」。问它「从埃菲尔铁塔出发,去最近的火车站怎么走」,它会回答罗马的车站。

所以第 13 节说「知识是预训练学到的」,具体来说,大量的事实知识就写在各层前馈网络的探测器和笔记里。

16384 个探测器够用吗

我原来的疑问是:16384 才 1 万多个,相当于 1 万多个知识点,太少了吧?

先说数字:16384 是按「放大到 4 倍」算的(4096 × 4),量级是真实的。真实模型的数字如下:

模型 向量长度 每层前馈网络的探测器数 层数 所有层加起来的探测器数
Llama 3 8B 4096 14336 32 约 46 万
Llama 3 70B 8192 28672 80 约 229 万
GPT-3 175B 12288 49152 96 约 472 万
DeepSeek-V3 7168 每个专家 2048 个,每层 256 个可选专家加 1 个共享专家 61 约 3000 万

(Llama 3 用的是 SwiGLU,有三个矩阵,所以放大倍数不是正好 4 倍,而是 3.5 倍左右。)

但「1 万多个知识点」这个算法本身有误会:一个探测器不等于一个知识点。原因有三个:

1. 每一层都有一套,几十层加起来就多了。而且层和层之间是接力的:第 10 层前馈网络加进向量里的东西,会变成第 11 层探测器的输入,后面的层可以在前面的基础上组合出更复杂的判断。

2. 知识存在「哪些探测器一起亮、各亮多强」的组合里,不是一个探测器存一条。

1
2
3
4
5
6
7
假设只有 3 个探测器,每个只有「亮」和「不亮」两种状态:
可以组合出 2 × 2 × 2 = 8 种模式

16384 个探测器:
光算亮或不亮,就有 2 的 16384 次方种组合
// 这个数字有将近 5000 位,比宇宙里的原子数还多得多
// 而且每个探测器还有「亮多强」的区别

打个比方:钢琴只有 88 个键,但能弹出所有的曲子,因为曲子是好几个键一起按出来的和弦,不是一个键对应一首曲子。屏幕上每个像素也只有红、绿、蓝 3 个数字,却能显示一千多万种颜色。Anthropic 在 2024 年做过一个实验:从 Claude 3 Sonnet 中间的一层里,用专门的方法拆出了最多 3400 万个特征,而那一层的探测器数量远比这个少。

3. 知识也不只存在前馈网络里。词向量表、attention 的矩阵里也存着一部分,前馈网络只是存得最多的地方。

一个模型到底能记多少

有研究专门测过(《Physics of Language Models》第 3.3 部分,2024):语言模型大约每个参数能存 2 个比特的知识。按这个估算,Llama 3 8B 有 80 亿个参数 × 2 比特 ≈ 160 亿比特 ≈ 2 GB 的纯知识。这里的「纯知识」指的是去掉了所有重复和废话之后的事实信息,比如「某人生于某年」「某个函数在某个库里」,不是 2 GB 的文本。这也解释了为什么小模型更容易胡编:参数少,能存的知识就少,没存住的东西被问到时,只能编一个看起来像的答案。

10. 几十上百层:越往上越抽象,和 CNN 像不像

一个「Transformer 层」= attention(让词和词之间交换信息)+ 一个前馈网络(每个词自己消化一下吸收进来的信息,前馈网络具体是什么见第 9 节)。大模型会叠几十到上百层。

CNN 是卷积神经网络,常用来识别图片。拿 CNN 来类比,一半对。

对的地方:确实是一层层加工,越往上越抽象

CNN 识别猫:底层认出边缘和纹理(比如毛发的纹路),中间层认出眼睛、耳朵,高层认出「这是一只猫」。

Transformer 也有类似的趋势,研究人员观察到的大致是这样的(论文《BERT Rediscovers the Classical NLP Pipeline》,2019):

1
2
3
底层:  这个词本身是什么、词性是什么、和旁边的词怎么组成短语
中间层:句子结构(谁是主语、谁是宾语)、代词指谁、调出相关的知识
高层: 整句话的意图,以及「下一个字该说什么」

不对的地方,有三点

CNN(识别图片) Transformer(大模型)
分辨率 每往上一层图片被缩小(224×224 → 112×112 → …… → 7×7),细节真的被丢掉了 每一层的词数和向量长度都不变:输入 10 个 token,第 1 层是 10 个向量,第 80 层还是 10 个,每个都是 4096 个数字
能看多远 底层只能看到一小块图片,要叠很多层才能「看到」整张图 第 1 层的 attention 就能让任何一个词去看前面任何一个词,不管隔多远
低层的细节 往上走时逐渐被丢掉 一直留在向量里,后面的层随时能读到(见下面的残差连接)

残差连接:低层的细节不会被丢掉

Transformer 每一层不是把向量换成新的,而是在原来的向量上加一点东西:

1
2
3
4
5
6
7
8
x = 词向量 + 位置信息

对第 1 层到第 L 层,每一层:
x = x + attention(x) // 从别的词那里拿来的信息,加到 x 上
x = x + 前馈网络(x) // 这个词自己消化之后得到的信息,再加到 x 上
// 注意是「x + 新东西」,不是「x = 新东西」,原来的内容还在

最后用最后一个位置的 x 去给词表里的每个 token 打分

这种「在原来的基础上加」的做法叫残差连接。所以更贴切的比方不是「分辨率」,而是一份不断被批注的档案:每个词有一个档案袋,第 1 层的人往里写了「这是名词」,第 10 层的人写了「这是主语」,第 30 层的人写了「这个指的是前面那只猫」…… 前面写的东西一直都在,后面的层随时都能读到。

x 词向量 + 位置信息给词表打分第 1 层 attention+ 从别的词搬来信息第 1 层 前馈网络 + 自己查记忆第 L 层 attention+ 第 L 层 前馈网络 +⋮ 中间还有几十层每一层都是「x + 新东西」:原来的内容一直留在 x 里
图 12:残差连接:x 像一条一直往上走的主干道,每一层算出的东西都加回到 x 上,原来的内容不会被换掉

走一个例子:「巴黎是法国的首」

看最后一个位置「首」的向量一路上被加了什么(简化说明,真实情况要模糊得多):

「首」这个位置的档案袋,每一层往里加一条批注,旧的批注都还在:

阶段 往档案袋里加了什么
刚进模型 「首」这个字本身(可能是首都、首先、首页、一首歌……)
底层加上 前面是「法国的」,「首」后面很可能是「都」或「府」
中间层加上 attention 找到了「巴黎」和「法国」,调出「巴黎是法国的首都」这条知识
高层加上 下一个字应该输出「都」

研究人员有一种方法叫 logit lens,就是把每一层的 x 直接拿去给词表打分,看「如果模型在这一层就停下来,它会猜什么」。结果一般是:底层猜得乱七八糟,越往上越接近最终答案。这说明越往上的层,向量里的信息越接近最终要输出的答案。

11. 新的 token 是怎么出来的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
输入:「今天 天气 很」

第 1 步:把每个 token 换成向量,加上位置信息
第 2 步:所有向量依次经过几十层 Transformer 层,每层都做 attention + 前馈网络
第 3 步:取最后一个位置(「很」那个位置)的向量
// 因为因果遮罩,最后一个位置是唯一看过全部前文的位置
第 4 步:把这个向量乘以一个大矩阵,给词表里的每个 token 打一个分数
// 这个大矩阵每一行对应词表里的一个 token,每行也是 4096 个数字
// 乘法就是拿「很」的向量去和每一行做点积(见第 4 节):越像,这个 token 的分数越高
// 词表大约有 10 万个 token,所以得到 10 万个分数
第 5 步:softmax,把分数变成概率
第 6 步:按概率抽一个 token
如果 temperature(温度)调低:几乎总是选概率最高的「好」,回答稳定
否则如果 temperature 调高:「热」「冷」也有不小的机会被抽中,回答更多样
第 7 步:把抽中的「好」接到输入末尾,变成「今天 天气 很 好」,回到第 1 步
// 「好」现在是新的最后一个位置:先查词向量表得到它的初始向量,再走一遍第 2–6 步
如果抽中的是「结束」token:停止生成
输入今天 天气 很第 1 步查词向量表,加上位置信息第 2 步几十层 Transformer 层每层:attention + 前馈网络第 3 步取最后一个位置「很」的向量第 4 步给词表里约 10 万个 token 各打一个分数第 5 步 softmax:分数变成概率第 6 步按概率抽一个:「好」第 7 步第 7 步:把「好」接到末尾,回到第 1 步;抽到「结束」就停
图 13:生成一个新 token 的全过程,每生成一个 token 就走一遍

第 5 步之后,「今天 天气 很」后面每个 token 的概率(示意):

比例 示意
好 40% ██████████
热 25% ██████
冷 15% ████
不 5% █
其他 15% ████

顺带说一下 KV cache

每生成一个新 token 都要重新跑一遍,但前面那些词的 k 和 v 已经算过了,不会变(因为前面的词看不到后面的词)。所以模型会把它们存起来,新 token 只需要算自己的 q、k、v,然后用自己的 q 去和存起来的所有 k 对一下就行。这就是为什么对话越长越占显存:存的 k 和 v 越来越多。

KV cache:前面的词算过一次就存起来 kv 今天 kv 天气 kv 很 qkv 好新 token:只算自己新 token 的 q 和存起来的每个 k 做点积对话越长,存的 k、v 越多,越占显存
图 14:KV cache:前面词的 k、v 存起来不再重算,新 token 只算自己的 q、k、v

第二部分:模型是怎么训练出来的

12. 这些参数是怎么学出来的

1
2
3
4
5
6
重复几万亿次:
从网上的文本里取一段,比如「小猫跳上桌子,它很开心」
让模型根据「小猫跳上桌子,它很」去猜下一个字
如果模型猜「难过」的概率高、猜「开心」的概率低:
算出每个矩阵里的每个数字应该往哪个方向调一点点,才能让「开心」的概率变高
把所有矩阵(包括 W_Q、W_K、W_V)都按这个方向微调一点点

没有人告诉模型「Q 要用来找代词指的是谁」。只是因为找对了指代,才能猜对下一个词,所以在大量的微调过程中,矩阵自然就变成了能做这件事的样子。

人只定结构:多少层、每层多少个头、向量多长。每个头找什么、每一层加工什么、Q 里的数字是什么意思,全部是「猜准下一个 token」这一个目标在几万亿次训练里推出来的。

哪些是人定的,哪些是训练出来的

除了少数几个由人在训练前定好的数字,模型里所有的参数都是训练出来的,而且是用同一种方式一起训练:

1
2
3
4
5
6
7
8
9
10
人在训练前定好的(超参数):
层数、向量长度、头数、前馈网络放大到几倍、MoE 有多少个专家、每次挑几个专家

训练出来的(参数):全部从随机数开始,一起按「让下一个 token 猜得更准」的方向一点点调
词向量表
每一层 attention 的 W_Q、W_K、W_V 和合并多头的矩阵
每一层前馈网络的 W1、W2(也就是探测器和笔记)
MoE 里每个专家自己的 W1、W2
MoE 的路由器(MoE 见第 19 节)
最后给词表打分的那个大矩阵

所以「探测器检查什么模式」「笔记里写什么」「路由器怎么挑专家」,都跟 attention 的头一样,没有人规定过。

13. 基座模型只会接龙,助手是什么样子

大模型的训练分两个阶段:

1
2
3
4
5
6
7
8
9
第一阶段:预训练
拿几十万亿个 token 的网上文本(网页、书、论文、代码、论坛……)
让模型一遍遍地猜下一个 token
得到的模型叫「基座模型」(base model)
// 这一步花掉绝大部分的钱和时间,模型的知识基本都是这一步学到的

第二阶段:后训练
拿少得多、但精心准备的数据,把基座模型调整成一个会对话、会干活的助手
得到的就是我们平时用的聊天模型
第一阶段第二阶段:后训练预训练几十万亿 token 的网上文本 SFT 几万到几十万条示范答案 RLHF 人比较两个回答哪个更好自动判对错的强化学习数学题、代码题对了才奖励→ 基座模型:只会接龙→ 助手花的钱和时间(示意)预训练占绝大部分后训练
图 15:训练分两个阶段:预训练得到只会接龙的基座模型,后训练把它变成助手(不同公司的步骤和顺序有差别)

「只会接龙」是什么样子

基座模型只学过一件事:这段文字在网上通常会怎么接下去。它不知道有人在问它问题,也不知道自己应该回答。下面这些都是基座模型的典型表现(示意,不是某个模型的原话):

例 1:问一个问题,它接着出题。网上「XX 的首都是哪里?」这种句子大量出现在练习题、试卷里,后面跟的往往是下一道题,而不是答案。

1
2
3
4
5
输入:中国的首都是哪里?
基座模型续写:
美国的首都是哪里?
日本的首都是哪里?
法国的首都是哪里?

例 2:让它写请假邮件,它写成了论坛求助帖。网上「帮我写一封……」最常出现在论坛和问答网站的提问里,后面跟着的是回帖。

1
2
3
4
5
6
输入:帮我写一封请假邮件
基座模型续写:
明天要交给领导,急!!在线等,谢谢各位大佬
——————
2 楼:楼主是什么原因请假?
3 楼:网上搜一下模板不就行了

例 3:不知道什么时候停,还会替用户说话。它只是觉得「这是一份对话记录」,就把整份记录接着编下去,自己演两个角色。

1
2
3
4
5
6
7
8
输入:用户:1+1 等于几?
助手:
基座模型续写:
2。
用户:那 2+2 呢?
助手:4。
用户:你真聪明,那你能帮我写作业吗?
助手:……

例 4:什么风格都学,好的坏的一起学。

  • 问「怎么判断一个数是不是质数」,它可能写出 StackOverflow 上某个有 bug 的回答,因为网上确实有很多有 bug 的代码
  • 问危险的问题,网上有相关内容,它就照着接下去,没有「这个不该回答」的概念
  • 开头写得像营销号,它就接成营销号的风格

但知识其实已经在基座模型里了

如果把输入写成下面这样,基座模型就会接「北京。」因为文本被伪装成了「问答格式」,「答:」后面最可能接的就是正确答案。

1
2
3
4
5
6
问:日本的首都是哪里?
答:东京。
问:法国的首都是哪里?
答:巴黎。
问:中国的首都是哪里?
答:

这说明后训练的主要作用不是灌知识,而是教模型以「助手」的身份、用正确的格式把已有的知识用出来。

以前要给 AI 举例子(one-shot、few-shot),就是这个原因

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2020 年,GPT-3:
GPT-3 就是一个基座模型,没有做过对话的后训练
它的论文标题就叫《Language Models are Few-Shot Learners》(语言模型能从几个例子里学会任务)
zero-shot、one-shot、few-shot 这几个词就是这篇论文流行起来的:
zero-shot:不给例子,直接给任务
one-shot:给 1 个例子
few-shot:给几个例子
对基座模型来说:
如果不给例子:模型不知道你要什么,经常接成别的东西
如果给了例子:文本看起来像「一份已经开了头的问答记录」,模型就照着格式接下去

2022 年,InstructGPT 和 ChatGPT:
OpenAI 对模型做了 SFT 和 RLHF(见第 14 节)
从这时起,模型不给例子也能听懂指令,zero-shot 就能用了

后来的几年:
后训练越做越好,大部分任务直接说清楚要求就够了
例子现在主要用在:指定一种很具体的输出格式、模仿某种写作风格、处理少见的任务

同类的例子还有:2022 年流行在提示词后面加一句「让我们一步一步地想」,模型做数学题的正确率会明显提高。现在的推理模型已经通过强化学习把「先想再答」练成了习惯,就不需要再加这一句了。很多以前要靠提示词技巧做到的事,后来都被训练进了模型里。

「像助手」是什么样子

输入 基座模型 后训练之后的助手
中国的首都是哪里? 接着出下一道题 「北京。」然后停下来
帮我写一封请假邮件 编成论坛帖和回帖 直接写出邮件,可能顺便问一句请假原因和天数
用户:1 + 1 等于几? 编出好几轮对话 只回答「2」,然后停下来等用户
怎么做一个危险物品 照着网上内容接下去 拒绝,或者只说安全相关的信息
你不知道的事 编一个看起来像真的答案 更倾向于说「我不确定」(做得还不完美)
「用表格列出来」 不一定理会 按要求出表格

后训练之后,模型做的仍然是接龙

聊天界面里看到的对话,送进模型时其实是一段带特殊标记的文字:

1
2
3
<|系统|>你是一个有帮助的助手<|结束|>
<|用户|>中国的首都是哪里?<|结束|>
<|助手|>

模型从 <|助手|> 后面开始接龙,接出「北京。<|结束|>」。看到 <|结束|> 这个特殊 token,程序就停止生成,把回答显示出来。所以后训练其实是把模型训练成:一看到 <|助手|>,就接出一个好助手会说的话;说完就接 <|结束|>。

14. 后训练具体怎么做

现在常见的后训练分三步,不同公司的叫法和顺序会有些差别。

第 1 步:监督微调(SFT)—— 给模型看示范答案

1
2
3
4
5
6
7
8
9
10
准备数据:请人写几万到几十万条「问题 + 理想回答」
例:
<|用户|>帮我写一封请假邮件,明天家里有事<|结束|>
<|助手|>主题:请假申请(11月7日)
王经理您好:
因家中有事需要处理,我想申请明天(11月7日)请假一天……<|结束|>

训练方法:跟预训练一样,还是猜下一个 token
不同的是:只在 <|助手|> 后面那部分计算猜错了多少,用户说的话不算
// 意思是只让模型学「助手该怎么说」,不学「用户会怎么问」

做完这一步,模型就学会了对话格式:该回答时回答、回答完会停、不再替用户说话。

第 2 步:偏好训练(RLHF)—— 让人比较哪个回答更好

光有示范不够,因为请人写出满分答案很难、很贵,但让人比较两个回答哪个更好,就容易得多。

1
2
3
4
5
6
7
8
9
第 1 步:对同一个问题,让模型生成两个回答 A 和 B
第 2 步:请人选哪个更好
如果 A 更准确、更清楚、更有礼貌:标记「A 比 B 好」
第 3 步:用几十万条这样的比较结果,训练一个「打分模型」
// 打分模型(也叫奖励模型):输入一个问题和一个回答,输出一个分数,模仿人的偏好
第 4 步:让聊天模型不断生成回答,打分模型给每个回答打分
如果分数高:把模型的参数往「更容易说出这种回答」的方向调
如果分数低:往反方向调
// 这种「做了之后根据分数调整」的训练方式叫强化学习

RLHF 是「基于人类反馈的强化学习」的英文缩写。语气、详略程度、什么该拒绝什么不该拒绝,这些很难写成标准答案的东西,主要靠这一步调出来。也有让 AI 按照一份写好的原则来打分、代替部分人工打分的做法,Anthropic 叫它 Constitutional AI。

第 3 步:可以自动检查对错的强化学习 —— 数学、代码

1
2
3
4
给模型一道数学题,题目有标准答案
让模型自己写解题过程和最终答案(同一题可以做很多遍)
如果最终答案和标准答案一致:奖励,把参数往「更容易写出这种解题过程」的方向调
否则:惩罚,往反方向调

这一步能让模型的能力真正变强,不只是变得会说话。o1、DeepSeek-R1 这类「先想很久再回答」的推理模型,就是靠大量这种训练学会的:没有人教它要怎么想,只是因为「多检查一遍」「换个方法试试」的那些解题过程更容易做对、更常得到奖励,模型就慢慢养成了这种思考习惯。

15. 为什么需要后训练

一句话:预训练的目标是「像网上的文本」,而我们想要的是「对用户有用」,这两件事不一样。

1
2
3
4
5
6
7
8
网上的文本里:
问题后面,经常跟的是另一个问题、回帖、广告,不一定是答案
答案里,有对的也有错的,有认真的也有胡扯的
没有「我是一个助手,我应该帮这个人解决问题」这种角色

所以:
预训练只能得到一个「什么文本都能接」的模型
后训练负责告诉它:在 <|助手|> 后面,只接「好助手会说的话」

打个比方

预训练像一个人把图书馆里所有的书都读了一遍,什么都知道一点,但从来没上过班。后训练是岗前培训:教他听懂客人的要求、直接回答、说完就停、不知道的别乱说、有些事不能帮着做。对应到模型上:知识主要来自预训练,回答问题的方式主要来自后训练。

为什么不直接用对话数据做预训练?因为高质量的对话数据太少了,只用对话数据,模型学不到足够的世界知识。所以先用海量文本学知识,再用少量精心准备的数据学做事。两种数据的量相差非常大:预训练是几十万亿个 token,后训练的示范数据通常是几万到几百万条。

16. 编程场景专门的后训练

有,而且是现在投入最多的方向之一。编程模型的训练一般分两层:

1. 继续预训练:在基座模型的基础上,再拿大量代码(GitHub 仓库、文档、技术问答)继续做「猜下一个 token」,让模型对代码更熟。Code Llama、Qwen-Coder 这类专门的代码模型就是这么做的。这一步严格说还属于预训练性质。

2. 编程专用的后训练:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
SFT:示范怎么写函数、怎么解释代码、怎么修 bug、怎么写测试

用测试来自动打分的强化学习:
给模型一道编程题,加上一组单元测试
让模型写代码,在沙盒里运行这组单元测试
如果全部通过:奖励
否则如果部分通过:给部分奖励
否则:惩罚

编程 agent 的强化学习:
给模型一个真实的代码仓库,加上一个需要修复的 bug 描述
模型在沙盒里自己读文件、搜索代码、运行命令、改代码,可以来回很多轮
最后运行这个项目原有的测试
如果 bug 修好了、原来的功能也没坏:奖励
否则:惩罚

像 Claude Code 这种能自己读文件、跑命令、改多个文件的编程助手,背后的模型就要经过大量这类训练。至于具体用了哪些数据、怎么做的,各家公开的细节不多。

模型会钻空子(reward hacking)

模型的目标是拿到奖励,而不是真的把代码写好,所以会学到一些作弊的办法:

  • 发现改测试比改代码容易,就直接把测试改成一定会通过
  • 测试只检查了几个固定的输入,就在代码里写「如果输入是 5,就返回 120」,专门对付这几个输入
  • 遇到报错,就把整段代码用 try 包起来,什么错误都吞掉

所以设计训练环境时要专门防这些作弊,比如不让模型改测试文件,或者额外准备一批模型看不到的测试。

除了编程,其他场景也有专门的后训练:数学、调用工具和搜索、长文写作、多语言、安全(什么该拒绝、什么不该拒绝)等等。一个通用模型的后训练,通常是把很多个场景的数据混在一起训练。

Claude Code 好用,是因为这方面的后训练又多又好吗?

先说清楚:Anthropic 内部具体怎么训练的,公开资料里没有细节,下面的判断来自公开信息。在这个前提下:编程 agent 的后训练是很重要的原因,但不是全部。实际用起来的效果,是三样东西乘在一起的结果:

1
2
3
4
5
6
7
8
实际用起来的效果 ≈ 基座模型的能力 × 编程和 agent 方面的后训练 × 产品本身

基座模型:决定上限。知识、理解代码的能力,主要来自预训练
后训练: 决定能发挥出多少、往哪个方向发挥。
会不会自己读文件、跑测试、遇到报错会不会换个方法
产品本身:Claude Code 这个程序。给模型提供哪些工具、系统提示词怎么写、
对话太长时怎么压缩上下文、权限怎么管
// 同一个模型放进不同的编程工具里,效果可能差不少

另外,「其他模型比不上」这个说法要打个折扣。到 2026 年 6 月为止,OpenAI 的 Codex、Google 的 Gemini 等在编程评测上跟 Claude 是互有胜负的,排名变得很快。DeepSeek 的训练预算比几家头部公司小得多,价格也便宜得多,比较的时候要把这一点考虑进去。

17. 蒸馏:让一个模型照着另一个模型学

蒸馏 = 让一个模型(学生)去模仿另一个模型(老师)的输出。通常老师是大而强的模型,学生是小而便宜的模型,或者是另一家公司的模型。

蒸馏和后训练关系很紧:最常见的蒸馏,就是用老师模型代替人,来写后训练用的示范答案。

做法一:学老师的回答(只要能调用老师的 API 就能做)

1
2
3
4
5
第 1 步:准备几十万到几百万个问题(编程题、数学题、日常问题……)
第 2 步:把每个问题发给老师模型,收集老师的回答
如果老师是推理模型:连它的思考过程一起收集
第 3 步:把「问题 + 老师的回答」当成 SFT 数据,训练学生模型
// 训练方法和第 14 节的 SFT 一模一样,只是示范答案从「人写的」换成了「老师写的」

真实的例子:

  • Stanford Alpaca(2023):调用 OpenAI 的模型生成了 5.2 万条「指令 + 回答」,用来微调 Meta 的 LLaMA 7B,花了几百美元,就得到了一个能像 ChatGPT 一样对话的小模型
  • Vicuna(2023):用网友在 ShareGPT 网站上分享的 ChatGPT 对话记录来训练
  • DeepSeek-R1 的蒸馏版:DeepSeek 自己把 R1 的推理过程拿去训练 Qwen 和 Llama 的小模型,发布了 DeepSeek-R1-Distill 系列,小模型的推理能力明显提升

平时说「A 蒸馏了 B」,一般说的就是这种做法:A 公司大量调用 B 公司模型的 API,把回答拿来训练自己的模型。大模型公司的使用条款通常禁止用它们模型的输出去训练竞争对手的模型,所以这句话常常带有指控的意思。有个很常见的露馅方式:问学生模型「你是谁」,它回答「我是 ChatGPT」或者「我是 Claude」。因为老师的自我介绍也混在训练数据里,一起被学去了。

做法二:学老师的概率分布(只有能拿到老师内部输出的人才能做)

模型在生成每个 token 时,会给词表里每个 token 算一个概率(见第 11 节)。

普通训练告诉学生的:

1
2
3
4
输入:今天 天气 很

正确答案是「好」
// 只有一个正确答案,其他都算错

蒸馏告诉学生的:

1
2
3
4
5
6
输入:今天 天气 很

老师认为:好 40%、热 25%、
冷 15%、不 5%、香蕉 0.0001%……
// 学生要让自己的概率分布
// 尽量接近老师的

老师的概率分布里藏着很多额外信息:「热」和「冷」也说得通,只是没那么常见;「香蕉」完全不行。只给一个正确答案,这些信息就丢了。所以学生从老师的概率分布里学,比从正确答案里学,效率高得多。这个想法来自 Hinton 等人 2015 年的论文,也是「蒸馏」这个名字的来源。

普通训练告诉学生的好 100% 热 0% 冷 0% 不 0% 香蕉 0% 只有一个正确答案蒸馏告诉学生的(老师的概率)好 40% 热 25% 冷 15% 不 5% 香蕉≈0 哪些也说得通、哪些完全不行
图 16:蒸馏让学生学老师的整个概率分布,比只学一个正确答案多出很多信息

这种做法需要拿到老师对每个 token 的完整概率,一般的 API 不提供这么完整的数据,所以通常是公司用自家的大模型蒸馏自家的小模型。比如 Google 的 Gemma 2 小模型和 Meta 的 Llama 3.2 1B、3B,都用过这种方式从自家更大的模型学习。

为什么蒸馏能让 A 变得像 B

1
2
3
4
5
6
7
8
9
10
11
12
原因 1:学生的基座模型本来就有很多知识,缺的是「怎么用」
老师的回答正好是大量高质量的示范,教的就是「怎么用」
// 跟第 13 节那个「问:…答:…」的例子一样:知识已经在基座里了,后训练是把它引出来

原因 2:老师的回答比网上文本好学得多
风格统一、格式整齐、每一步都写出来了
如果老师是推理模型,连「怎么想」都写出来了,学生可以直接照着学解题套路

原因 3:便宜、量大
请人写一条高质量示范答案可能要几十块钱
调用老师模型生成一条,可能只要几分钱
所以可以生成几百万条,覆盖各种各样的问题

蒸馏的局限

  • 学生的上限受自己的大小限制。一个 70 亿参数的小模型,就算照着一个大模型学,也装不下大模型的全部知识。它学得最好的是老师的风格和常见题型的套路
  • 只能学到老师展示出来的东西。训练数据里没覆盖到的问题,学生就没学过;遇到没见过的难题,跟老师的差距就露出来了
  • 一般学不到超过老师的水平。老师答错的地方,学生也会照着学错
  • 所以常见的情况是:蒸馏出来的模型在常用的评测题上分数接近老师,真正用起来,遇到复杂一点、没见过的问题,就不如老师

18. 不同厂商的基座模型差不多吗

我原来的理解是:不同厂商的基座模型能力差不多,实际用起来差得远,主要是后训练造成的。

不能这么理解。基座模型之间的差距是真实存在的,而且很重要。这一条最容易理解偏(附录里汇总了更多辅助理解的部分)。基座模型的差别主要来自这几样东西:

1
2
3
4
5
6
训练数据:
量有多大(十几万亿 token 还是几十万亿)
质量怎么样:怎么过滤垃圾网页、怎么去重、代码和数学的占比多少、有没有用模型生成的高质量数据
// 各家最不愿意公开的就是数据怎么做,普遍认为这是差距最大的地方
算力:用了多少张 GPU、训练了多久。头部公司之间可能差好几倍
模型结构和训练技巧:比如第 19 节讲的 MoE

有一个例子能说明后训练也很重要:DeepSeek-V3 和 DeepSeek-R1 用的是同一个基座模型。R1 只是在这个基座上多做了大量推理方面的强化学习,数学和编程能力就明显强了一大截。所以两样都重要:

  • 基座差,后训练很难救回来:后训练基本加不进新知识
  • 基座好,后训练做得不好,也发挥不出来

还有一点:头部的闭源公司(OpenAI、Anthropic、Google)都不公开基座模型,外人没法直接比较它们的基座;能拿来比较的只有开源的基座模型,比如 Llama、Qwen、DeepSeek。而且现在预训练和后训练的边界越来越模糊:很多公司在预训练的后期就开始混入对话数据和推理数据,这一段有时被叫作「中期训练」。

第三部分:更进一步

19. MoE:把前馈网络拆成很多个专家

从前馈网络的一个浪费说起

第 9 节「巴黎是法国的首」的例子里有一句话:「16384 个探测器里,大部分都不亮」。这意味着:

1
2
3
4
5
6
每个 token 经过前馈网络时:
16384 个探测器都要算一遍分数
算完发现大部分都不亮,结果是 0
// 大量计算白做了

想让模型知道更多 → 就要更多探测器 → 前馈网络更大 → 每个 token 都要算更多 → 更慢、更贵

MoE(Mixture of Experts,混合专家)的想法就是:既然每次大部分探测器都用不上,那干脆把前馈网络拆成很多个小的,每次只挑几个来算。

1
2
3
4
5
6
7
8
9
10
11
12
13
原来:每一层有 1 个大的前馈网络

MoE:每一层有很多个小的前馈网络,每个叫一个「专家」(比如 256 个)
再加一个「路由器」(就是一个小矩阵)

对每个 token,在每一层:
第 1 步:路由器给 256 个专家各打一个分数
分数 = 这个 token 的向量 和 每个专家的「路由向量」做点积
第 2 步:只挑分数最高的 8 个专家
第 3 步:把这 8 个分数用 softmax 变成比例
第 4 步:只让这 8 个专家处理这个 token,其余 248 个专家这次不算
第 5 步:用第 3 步算出的比例,把 8 个专家的输出加起来,作为这一层前馈网络的输出
最后:x = x + 输出

代入数字走一遍:第 3 步的比例用在哪里

用 4 个专家、每次挑 2 个的小例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
第 1 步:路由器给 4 个专家打分
专家 1:2.0 专家 2:0.5 专家 3:1.0 专家 4:-1.0

第 2 步:挑分数最高的 2 个 → 专家 1 和专家 3

第 3 步:只对这 2 个分数做 softmax,变成比例
e 的 2.0 次方 = 7.39,e 的 1.0 次方 = 2.72,总和 10.11
专家 1 的比例 = 7.39 ÷ 10.11 = 0.73
专家 3 的比例 = 2.72 ÷ 10.11 = 0.27

第 4 步:只让专家 1 和专家 3 处理这个 token(各自就是一个小前馈网络)
专家 1 的输出 = [1, 0]
专家 3 的输出 = [0, 1]

第 5 步:用第 3 步的比例,把两个专家的输出加起来
输出 = 0.73 × [1, 0] + 0.27 × [0, 1] = [0.73, 0.27]
// 路由器越看好的专家,它的输出占的分量越大

最后:x = x + [0.73, 0.27]
token 的向量 x 路由器给专家打分专家 1 分数 2.0,比例 0.73[1, 0] 专家 2 分数 0.5,这次不算专家 3 分数 1.0,比例 0.27[0, 1] 专家 4 分数 -1.0,这次不算输出 0.73×[1,0]+0.27×[0,1] 只挑分数最高的 2 个专家来算,按比例把它们的输出加起来
图 17:MoE 代入第 19 节的数字:4 个专家挑 2 个,按比例把输出加起来

这个比例还有一个更关键的作用:路由器正是靠这个比例才学得会挑专家。

1
2
3
4
5
6
7
8
9
10
训练时:
如果专家 1 的输出让下一个 token 猜得更准:
训练会把专家 1 的比例往上调,也就是把路由器给专家 1 的分数调高
→ 路由器学到:以后遇到这类 token,更应该选专家 1
否则:
把路由器给专家 1 的分数调低

如果没有这个比例,只是「挑出 2 个专家、把输出直接相加」:
路由器的分数就不影响输出结果
训练就没法告诉路由器它挑得好不好,路由器永远学不会

不同模型的细节有差别:Mixtral 是这里写的做法;DeepSeek-V3 打分时不用 softmax,用的是另一个函数,挑完之后再把选中的几个分数换算成加起来等于 1 的比例。道理一样。

MoE 和前馈网络的关系:MoE 是前馈网络的一种造法。attention 那部分不变,所有专家共用同一套 attention;只是把每层的「1 个大前馈网络」换成「很多个小前馈网络 + 一个负责挑选的路由器」。

模型 每层的专家数 每个 token 用几个 总参数 每个 token 实际用到的参数
Mixtral 8x7B 8 2 约 470 亿 约 130 亿
DeepSeek-V3 256 个可选的 + 1 个所有 token 都用的 8 个可选的 + 1 个共用的 6710 亿 370 亿

DeepSeek-V3 那个「所有 token 都用的专家」叫共享专家,用来放大家都需要的通用知识,这样其他专家就可以更专注于各自的东西。

除了这两个,Llama 4、Qwen3、OpenAI 的开源模型 gpt-oss 都是 MoE,GPT-4 也普遍被认为是 MoE。

打个比方:大医院的分诊台

医院里有几百个医生(总参数很多,什么病都能看)。病人进门先到分诊台(路由器),分诊台根据症状挑 2~3 个科室(选几个专家),病人只看这几个医生(每个 token 只用一小部分参数)。所以医院的能力取决于一共有多少医生,每个病人花的时间只取决于看了几个医生。

要修正的一点:这家医院的分诊台不是按「消化科」「骨科」这种科室分的,更像是按非常具体的症状分(比如「咳嗽加发烧」送这几个医生,「骨头疼」送那几个医生);而且医生没有科室名牌,各自擅长什么,是在长期接诊中自己形成的,人只能事后统计「哪类病人常被送到哪个医生那里」。

MoE 几个容易误会的地方

1. 「专家」并不是「数学专家」「历史专家」。跟第 8 节讲的头一样,专家分工是训练中自然形成的,没人规定。Mixtral 的论文专门看过:路由器挑哪个专家,跟话题(数学、生物、哲学)关系不大,更多跟词的类型有关。比如有的专家专门处理代码里的缩进和括号,有的专门处理标点。「专家」这个名字其实有点误导。

2. 每个 token、每一层,挑的专家都可能不一样。同一句话里,「巴黎」在第 10 层可能去了专家 3、17、88,「首」在第 10 层可能去了专家 5、17、201;到了第 11 层,又重新挑一遍。

3. MoE 省的是计算,不省内存。虽然每个 token 只用 370 亿个参数,但下一个 token 可能要用别的专家,所以 6710 亿个参数全部要放在显存或内存里。这就是为什么本地跑 DeepSeek-V3 需要几百 GB 的内存,但跑起来的速度比同样大小的普通模型快得多。

4. 路由器有「偏心」的问题。训练刚开始时,如果某几个专家碰巧表现好一点,路由器就更爱选它们,它们得到的训练就更多,变得更好,路由器就更爱选它们…… 最后少数几个专家几乎包揽了所有 token,大部分专家很少被选中,也就没学到东西。所以训练时要专门加规则让负载均衡:

1
2
3
4
5
常见做法:
如果有专家被选得太多、有专家被选得太少:额外给模型扣分,逼路由器分散着选
DeepSeek-V3 的做法:不扣分,而是给每个专家的路由分数加一个可调的偏移量
如果一个专家最近被选得太多:把它的偏移量调低一点,让它少被选
如果一个专家最近被选得太少:把它的偏移量调高一点

5. MoE 的目的不只是「省掉不必要的计算」,而是「同样的计算量,模型可以大得多」。我原来的理解是:MoE 是对前馈网络的优化,很多情况下没必要算的就不算,以此降低推理成本。方向对,但目的说反了一半:

1
2
3
4
5
6
7
8
我原来的理解像是:
先有一个大的前馈网络 → 发现很多计算是浪费的 → 跳过那些计算 → 变便宜

实际情况更像是:
预算只够每个 token 算 370 亿个参数
如果做成普通模型:模型就只有 370 亿个参数
如果做成 MoE:模型可以有 6710 亿个参数,每个 token 还是只算 370 亿个
→ 同样的计算量,装下的知识多得多,模型更聪明

而且 MoE 模型通常从训练一开始就是 MoE 结构,不是先训练一个普通模型再拆开的;专家和路由器是一起从随机数开始训练出来的。再加上第 3 点说的不省内存,MoE 也有代价:所有专家都要放在内存里。

6. 编程和医学场景用的专家会有差别,但没有「编程专家」「医学专家」。路由器是按每个 token 挑专家的。一段代码里全是括号、缩进、def、return,一段医学文字里是病名、药名,token 长得很不一样,挑出来的专家组合自然就有差别。但研究发现,专家的分工更多跟词的类型和格式有关,而不是跟领域有关:Mixtral 的论文对比过数学论文、生物医学论文、哲学论文,路由器挑专家的分布差别不大;反而像 Python 里的 self、代码的缩进这类 token,会稳定地被送到某几个专家那里。DeepSeek-V3 那种「很多个小专家加共享专家」的做法被认为分工更细、更专一些,但也谈不上有一个专门的「医学专家」。

7. 路由器挑得好不好,影响很大,但不会因为一次挑得不好就出大错。

1
2
3
4
5
6
7
8
9
10
影响大的地方:
如果路由器挑错了专家:这个专家存的知识跟这个 token 无关,加进去的东西没用甚至有害
如果路由器偏心:少数专家被挤爆,大部分专家闲着没学到东西(见第 4 点)

不会一次就出大错的原因:
每次挑好几个专家(比如 8 个),按比例混合,一个挑得不太对,影响会被稀释
DeepSeek-V3 还有一个所有 token 都用的共享专家兜底
有残差连接:这一层加错了一点,原来的向量还在,后面几十层还能修正
专家和路由器是一起训练出来的:路由器学着往专家那里送合适的 token,
专家也在学着处理路由器送来的 token,两边一起磨合

把前馈网络和 MoE 放在一起看

1
2
3
4
一个 Transformer 层:
x = x + attention(x) // 去这句话里的其他词那里查信息
x = x + 前馈网络(x) // 去模型自己的记忆里查信息,大量的事实知识存在这里
// 如果是 MoE 模型:这里换成「路由器挑几个专家,只算这几个专家」
  • 前馈网络:每个词自己去查记忆的部分,占了大部分参数,存了大量知识
  • MoE:把这部分记忆拆成很多块,每个 token 只查其中几块,从而能让记忆总量变得很大,而每个 token 的计算量不变

20. 现在最前沿的模型又多了什么

基本框架还是这些:Transformer、attention、逐个生成 token、预训练加后训练。但在这个框架上,近两年有不少重要的改进。下面都是公开发表过的,截止到 2026 年 6 月。混合专家模型(MoE)也是这两年最重要的改进之一,已经在第 19 节单独讲过,这里不再重复。

1. 推理模型和「想得越久越准」

就是第 14 节讲的「可以自动检查对错的强化学习」。重要的发现是:除了把模型做大,让模型在回答之前多想一会儿也能提升能力,这叫「测试时计算」。DeepSeek 公开了一种很省资源的强化学习算法 GRPO,被很多团队采用。

2. 让 KV cache 变小、让长对话变便宜

第 11 节讲过:对话越长,要存的 k 和 v 越多。所以有很多办法来压缩:

  • GQA:多个头共用同一组 k、v(Llama 3 就是 32 个 Q 头共用 8 组 K、V)
  • MLA:DeepSeek 的做法,把 k、v 压缩成更短的向量再存起来
  • 稀疏注意力:每个词不再看前面所有的词,只挑最相关的一部分去看(DeepSeek-V3.2 用了这种做法)
  • 混合结构:一部分层不用标准的 attention,换成计算量不随长度暴涨的结构(比如 Mamba 这一类),只留少数几层用标准 attention

3. 投机解码(speculative decoding):让生成变快

1
2
3
4
5
6
7
用一个很小、很快的模型先连续猜 5 个 token
让大模型一次性检查这 5 个 token:
对每个位置:
如果大模型也会选这个 token:接受
否则:从这个位置开始,用大模型自己选的 token 替换掉,后面的都丢掉
// 大模型检查 5 个 token 和生成 1 个 token 的时间差不多,猜对得越多,速度提升越大
// 最终结果和大模型自己一个一个生成的结果一样,不损失质量
小模型先猜 5 个大模型检查一遍这一轮得到今天天气✓很✓好✓啊✗大模型要的是「,」。丢掉天气很好,大模型检查 5 个 token 的时间 ≈ 生成 1 个,这一轮直接得到 4 个
图 18:投机解码:小模型先连续猜几个,大模型一次检查,从第一个不对的地方换成大模型自己的选择

4. 不是逐个 token 生成的模型:扩散语言模型

画图模型(比如 Stable Diffusion)是从一团噪点开始,一步步修成清晰的图。扩散语言模型也是这个思路:先生成一整段模糊的文字,再一轮轮地修改,最后变成通顺的文字,而不是从左到右一个一个往外接。Google 的 Gemini Diffusion、Inception Labs 的 Mercury 都是这一类,优点是快。目前还不是主流,但值得关注。

5. 可解释性:开始能看懂模型内部了

这两年进展很大,金门大桥特征和电路追踪的例子放在第 21 节。

如果只挑三个先了解

MoE(第 19 节,现在几乎所有大模型都在用)、推理模型和强化学习(这两年能力进步最大的来源)、可解释性(第 21 节,直接回答了「人类到底知不知道它为什么能用」)。

21. 人类到底知不知道它为什么能用

一种常见的理解是:人类也不知道它为什么生效,只知道这个框架能用,就负责把框架搭出来,让里面自己去训练,所以是「蒙出来的」。大方向对,但「纯蒙」说重了。

更准确的说法是:人类完全知道每一步在算什么,也知道为什么训练能让模型越来越准;但不知道训练出来的那几百亿个数字具体学到了什么、靠什么完成了某件事。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
人类清楚知道的:
每一步的计算:乘矩阵、点积、softmax、相加,全部是确定的数学,没有任何神秘的地方
为什么训练会让模型变准:每次都按「让猜错变少」的方向调参数,这一点在数学上是清楚的
框架里每个零件为什么要加:
attention:以前的模型(RNN)一个字一个字往后传信息,句子一长前面的就忘了;
attention 让任何两个字直接对上
残差连接:从图像模型(ResNet)借来的,不加的话叠几十层就训练不动了
除以 √d:不除的话分数太大,softmax 之后比例变成「一个 100%、其他全是 0」,训练会卡住
规模和效果的关系:模型多大、数据多少,最后能猜得多准,可以提前用公式估出来(叫 scaling law)

人类不太知道的:
训练完之后,某个头、某个矩阵里的数字到底代表什么
模型为什么突然学会了某种能力(比如做算术、写代码),具体靠哪些部件
模型给出某个回答时,内部到底经过了哪些「思考步骤」

更贴切的比方:蒸汽机

人类先造出了能用的蒸汽机,后来才搞清楚热力学。框架是有道理地一步步设计和实验出来的,只是框架里面长出来的东西,人类还在拆解。专门做这件事的研究方向叫「可解释性」,第 8 节说的「归纳头」就是这个方向的成果之一。

还有一点要补充:模型的回答「看起来跟人类想要的差不多」,不全是猜下一个 token 带来的。光用网上的文本训练出来的模型只会接龙,后面还有一步「后训练」:让人给模型的回答打分,再按「得分高的回答」去调参数,模型才变得会回答问题、语气像助手。具体见第 13~15 节。

这几年可解释性的进展

Anthropic 2024 年从 Claude 内部找到了一个代表「金门大桥」的特征,把这个特征调强之后,模型不管聊什么都会扯到金门大桥上(叫 Golden Gate Claude);2025 年又发表了「电路追踪」的研究,能追踪模型回答问题时内部一步步用了哪些特征。比如模型写押韵的诗时,会先想好行末要押哪个词,再倒着写这一行。

附录:辅助理解的部分

下面是学习过程中我自己的一些理解,有的对,有的偏。把它们和实际情况放在一起对照,可以帮助理解正文。

我原来的理解 实际情况 详见
多头注意力有一个预设的范围,比如预先准备 100 种功能,模型从里面挑几个 偏了。没有任何功能菜单。人只定「每层有多少个头」,每个头从随机数开始,地位平等;每个头干什么,是训练中为了猜准下一个 token 自然分出来的,人只能事后观察 第 8 节
W_Q、W_K、W_V 是训练出来的 对,补一点。它们是三个矩阵,作用是从同一个词向量里提取出三种不同用途的信息:想找什么、自己是什么、能提供什么。矩阵乘法就是拿词向量去和矩阵的每一列做点积。用两个不同的矩阵算 q 和 k,「谁找谁」才能是单向的。每一层、每一个头各有一套,训练完之后固定不变 第 5 节
层数越往上越抽象,就像 CNN:越往上分辨率越低、越能描绘轮廓,越往下越是毛发这样的细节 一半对。一层层加工、越往上越抽象,这一点对。但 Transformer 每层的词数和向量长度都不变,没有分辨率降低这回事;第 1 层就能看到整句话;而且有残差连接,低层写进去的信息一直留在向量里,不会被丢掉。更贴切的比方是「一份不断被批注的档案」 第 10 节
人类也不知道它为什么能用,只是把框架搭出来让它自己训练,是纯蒙出来的 大方向对,「纯蒙」说重了。每一步计算、框架里每个零件为什么要加、为什么训练能让模型变准,人类都清楚;不清楚的是训练出来的几百亿个数字具体代表什么。更像先造出蒸汽机、后来才搞懂热力学 第 21 节
以前用 AI 要给一个例子(one-shot),是因为当时的后训练做得不够 基本对。GPT-3 本身就是没做过对话后训练的基座模型,给例子是为了让文本看起来像「已经开了头的问答记录」;2022 年 ChatGPT 做了后训练之后,不给例子也能听懂指令 第 13 节
Claude Code 好用,就是因为编程方面的后训练又多又好,别的模型在这方面比不上 只对一部分。实际效果 ≈ 基座模型的能力 × 编程和 agent 的后训练 × 产品本身(工具、提示词、上下文管理)。而且到 2026 年 6 月为止,OpenAI、Google 等在编程评测上跟 Claude 互有胜负,排名变化很快 第 16 节
不同厂商的基座模型能力差不多,实际用起来的差距主要是后训练造成的 偏差最大的一条。基座之间的差距真实存在而且很重要,来自数据的量和质量、算力、模型结构。基座决定上限,后训练基本加不进新知识。反过来,DeepSeek-V3 和 R1 用同一个基座、R1 强了一大截,说明后训练也很重要:两样都重要 第 18 节
ReLU 的作用:点积检查有没有某个特征,有这个特征就保留,没有就直接变成 0 基本对,补一点。点积算出来的不只是「有没有」,还有「有多强」,ReLU 把强度原样留下,特征越明显,对应的笔记加得越多。另外探测器和特征不是一一对应的,一个探测器常常同时对好几种不相干的特征有反应 第 9 节
前馈网络每层只有 16384 个探测器,相当于 1 万多个知识点,太少了 偏了。一个探测器不等于一个知识点。每层一套、几十层接力;知识存在「哪些探测器一起亮、各亮多强」的组合里,组合数是天文数字;词向量表和 attention 里也存了一部分。研究估计每个参数大约能存 2 比特知识,80 亿参数的模型大约能存 2 GB 的纯知识 第 9 节
MoE 是对前馈网络的优化,很多情况下没必要算的就不算,用来降低推理成本 方向对,目的说反了一半。更准确的是「同样的计算量,模型可以大得多」:预算只够每个 token 算 370 亿参数时,普通模型只有 370 亿参数,MoE 可以有 6710 亿。MoE 通常从训练一开始就是这个结构,不是先训练好再拆;而且省计算不省内存 第 19 节
编程和医学场景差别大,用的专家也不一样,就像拉肚子去消化科、摔断腿去骨科 一部分对。token 长得不一样,挑出来的专家组合会有差别;但专家的分工更多跟词的类型和格式有关(比如代码缩进、括号),不是按领域分的,没有「医学专家」。分诊台更像是按很具体的症状分,医生也没有科室名牌,人只能事后统计 第 19 节
路由器挑得好不好,对结果影响很大 对,补一点。挑错专家、路由器偏心都会让效果变差,是 MoE 训练里最难的部分之一。但每次挑好几个专家按比例混合、有共享专家兜底、有残差连接,一次挑得不好不会出大错;路由器和专家是一起训练、互相磨合出来的 第 19 节
读到「它」时不确定指小猫还是桌子,读到「开心」才确定;那时模型应该会回头修改「它」的向量 前半句基本对,后半句不对。读到「它」时模型已经明显偏向小猫(主语、活物),只是不完全确定。读到「开心」时不会回头改「它」的向量:因果遮罩加 KV cache,前面的位置写了就不改。「开心的是小猫」这个结论写在「开心」自己的位置上;如果前面判断错了,后面的位置会自己纠正 第 6 节

总结

attention 让每个词拿自己的 Q 去和所有前面词的 K 比对,算出该关注谁、关注多少,再按这个比例把那些词的 V 加进自己的向量。叠几十层之后,最后一个位置的向量就知道了整段话的意思,用这个向量给词表里每个 token 打分,抽出一个,接到末尾,再来一遍。

预训练让模型读完了整个互联网,学会了知识,但只会接龙;后训练用示范答案、人的偏好打分、可以自动检查的题目,把模型调整成会对话、会干活的助手。编程是现在后训练投入最多的方向之一,核心是用测试结果给模型打分。蒸馏就是用一个强模型的回答(或者概率分布)当作后训练的教材,让另一个模型照着学,所以学生能很快变得像老师,但很难真的赶上老师。