大模型原理通俗讲解:attention、后训练和蒸馏
这篇用伪代码和能手算的小例子,讲清楚点积是什么、《Attention Is All You Need》里的 attention 怎么工作、Q K V 各自干什么、多头和几十层是怎么回事、新的 token 怎么一个一个生成出来、前馈网络和 MoE 是什么;再讲只会接龙的基座模型怎么经过后训练变成助手、编程模型怎么训练、蒸馏是什么,以及现在最前沿的模型又多了哪些技术。
文章按从浅到深的顺序排列,辅助理解的部分汇总在文末的附录里。文中的小例子数字是为了讲解编出来的;真实模型里的向量动辄几千维,每个数字没有现成的含义。
第一部分:模型怎么算出下一个 token
1. 大模型其实一直在做一件事:文字接龙
大模型每次只做一件事:看着前面所有的字,猜下一个字是什么。
先说清楚 token 是什么:token 就是模型处理文字的最小单位,大致相当于一个字或半个词。比如「今天天气很」可能被切成「今天」「天气」「很」三个 token。
1 | 输入:今天 天气 很 |
所以模型说的一大段话,是一个 token 一个 token 接出来的。
2. attention 要解决什么问题
每个 token 进到模型里,先被换成一串数字,叫向量(比如 4096 个数字)。可以把向量当成这个词的「意思档案」。
这串最初的数字叫词向量,是从一张「词向量表」里查出来的:
1 | 词向量表:词表里的每个 token 占一行,每行 4096 个数字 |
词向量只是起点。进入模型以后,每经过一层,这个向量都会被加上新的信息(见第 10 节的残差连接),所以后面说的「这个词的向量 x」,指的是它在当前这一层的样子,不一定是最初的词向量。
问题是,同一个词放在不同的句子里,意思不一样:
- 「我吃了一个苹果」:苹果是水果
- 「苹果发布了新手机」:苹果是公司
刚查出来的「苹果」向量是固定的,不知道自己在哪个句子里。attention 要做的事,就是让每个词去看句子里的其他词,把相关的信息吸收进自己的向量,更新成「在这句话里的意思」。
再举一个例子:「小猫跳上桌子,它很开心」。「它」本身没有意思,必须去前面找,发现「它」说的是「小猫」,然后把「小猫」的信息拿过来。attention 就是做这个「找」和「拿」的机制。
3. Q、K、V 分别是什么
把句子里的每个词想成相亲会上的一个人,每个人身上带着三样东西:
| 名字 | 比方和作用 | |
|---|---|---|
| Q | Query,查询 | 我手里的需求卡:「我在找什么样的人」。当前这个词想从别的词那里找什么信息。 |
| K | Key,键 | 我胸前的名牌:「我是什么样的人」。这个词向别人展示自己能提供什么,用来被匹配。 |
| V | Value,值 | 我实际能给你的东西。一旦匹配上,真正被拿走的信息。 |
拿「它」举例:
- 「它」的 Q 大概在说:「我是个代词,我在找前面出现过的一个名词,最好是活物」
- 「小猫」的 K 大概在说:「我是名词,是动物」
- 「桌子」的 K 大概在说:「我是名词,是家具」
- 「它」的 Q 和「小猫」的 K 最对得上,所以「它」主要从「小猫」的 V 那里拿信息
为什么 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 | 点积(a, b): |
它的意思:方向越一致,结果越大
假设向量的两个数字分别表示「像不像动物」「像不像家具」(真实模型里的数字没有这么好懂的含义,这里只是为了讲解):
| 拿「小猫」[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 | 对每个位置(也就是每个特征): |
打个比方:相亲时,我手里有一张需求表(「看重幽默 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 | attention 里: q 和 k 做点积 → 这个词和那个词有多对得上(第 5 节) |
模型里几乎所有「判断」,底层都是点积在量「像不像」。
5. attention 的计算过程,代入数字走一遍
1 | 输入:句子里每个词的向量 x1, x2, …, xn |
一句话概括:用我的 Q 去和每个人的 K 对一下,算出我该多关注谁,然后按这个比例把大家的 V 混合起来,加到我自己的向量 x 上。
W_Q、W_K、W_V 是什么
它们是三个固定的数字表格(矩阵),作用是从同一个词向量里,提取出三种不同用途的信息。词向量就是代表这个词的那串数字,见第 2 节。
矩阵乘法其实就是一组点积。
1 | x = 「它」的向量,比如 [1, 0, 1](真实模型里有 4096 个数字) |
所以 x × W_Q 就是:拿 x 去和 W_Q 的每一列各做一次点积,结果排成一个新向量。真实模型里,W_Q 是 4096 行 × 128 列,也就是把 4096 个数字的词向量,变成 128 个数字的 q。严格来说,只有第 1 层乘的是最初查出来的词向量;后面的层乘的是被前面几层加工过的版本,长度还是 4096 个数字(见第 2 节)。
三个矩阵各管一件事。
1 | 同一个「它」的向量 x: |
可以把它们想成三副不同的眼镜:戴上 W_Q 看这个词,看到的是「它想找什么」;戴上 W_K,看到的是「它是什么」;戴上 W_V,看到的是「它能给别人什么」。
为什么不直接用 x,非要乘三个矩阵。
1 | 如果不要 W_Q、W_K,直接用 x 当 q 和 k: |
从哪里来:训练出来的。
1 | 训练开始:每一层、每一个头的 W_Q、W_K、W_V,都填上随机数 |
- 每一层、每一个头都有自己的一套。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 | 第 1 步:「它」的 q 和每个词的 k 做点积 |
「它」分给每个词的注意力比例:
| 比例 | 示意 | |
|---|---|---|
| 小猫 | 58% | ██████████████ |
| 桌子 | 21% | █████ |
| 它 | 13% | ███ |
| 跳上 | 8% | ██ |
结果:混合出来的是 [0.58, 0.21],主要是「动物」的信息。这个结果会加到「它」自己的向量 x 上:
1 | 假设「它」进这一层时的 x = [0.1, 0] // 一个代词,自己几乎没有意思(数字是为了讲解编的) |
所以变的是「它」的 x,不是「它」的 v。表里「它」的 v 是 [0, 0],意思只是「它」自己没有什么内容可以提供给别的词。x 里带上了「动物」的信息以后,「它」现在就偏向于指小猫了。
补充:因果遮罩(不许偷看后面)
生成文字时,后面的字还没生成出来,所以每个词只能看自己和前面的词。上面伪代码里「如果 j 在 i 的后面就把分数设成负无穷」就是做这个的:负无穷经过 softmax 之后比例变成 0,等于完全不看。读到后面才明白前面时(比如读到「开心」才确定「它」是小猫),模型会不会回头改「它」的向量,见第 6 节。
补充:位置信息
attention 本身不知道词的先后顺序,「猫追狗」和「狗追猫」在 attention 看来是同一堆词。所以模型会给每个词的向量加上位置信息(叫位置编码,现在常用的一种叫 RoPE)。
6. 读到后面才明白前面:模型会回头改「它」的向量吗
我的问题:「小猫跳上桌子,它很开心」,读到「它」的时候,其实还不确定「它」是小猫还是桌子;读到「开心」才能确定,因为桌子不会开心。那模型读到「开心」时,会回头修改「它」的向量吗?
不会回头改。「它」到底指谁,是在后面的位置上重新判断出来的。
为什么不能回头改
1 | 处理到「它」的时候(在每一层): |
不回头改是故意这么设计的,有两个原因:
1 | 原因 1:训练的需要 |
「它指的是小猫」这个结论放在哪里
放在后面的词的位置上。每个新位置都可以重新去看前面所有的词,自己做判断:
1 | 处理到「它」的时候: |
换一个结尾,就能看出这种机制的好处:
1 | 「小猫跳上桌子,它很结实」 |
打个比方:记日记
前面的位置写下的是「当时的看法」,写了就不改;后面的位置能看到更多信息,会写下「更新后的看法」。就像昨天的日记不会改,但今天可以写一句「昨天想错了,其实是……」。
有没有能回头看的模型
1. BERT 这类双向模型。BERT 没有因果遮罩,每个词同时看前面和后面的所有词,所以「它」的向量会直接吸收「开心」的信息。但它没法一个一个往外生成文字,主要用在理解类的任务上,比如分类、搜索、判断两句话意思是否相同。
2. 扩散语言模型(第 20 节)。先生成一整段模糊的文字,再一轮轮修改,每一轮所有位置都能互相看,前面的字可以根据后面的字被改掉。
3. 推理模型的思考过程,是一种很实用的「回头改」。模型想不清楚时,可以在思考过程里写出「等一下,这里的『它』应该指桌子,不是小猫」。这句话写出来之后也是新的 token,后面的计算都能看到它。相当于模型没法改旧的向量,就把修正后的看法直接写成文字,留给后面的自己用。
7. Q 里的数字是谁定义的
上面那个 [1, 0] 和「在找动物」是为了讲解编出来的。真实模型里,没有人定义 Q。Q 是算出来的,算 Q 用到的东西全是训练学出来的:
1 | 「它」在第 5 层、第 3 个头里的 q 是怎么来的: |
这里有三点要说清楚:
1. 真实模型里,q 的每个数字没有现成的含义。一个 q 向量有 128 个数字,没有哪一个数字叫「动物」。「找动物」这种意思,往往是这 128 个数字组合起来的一个方向,而且一个方向可能同时混着好几种意思。我们说「这个头在找指代对象」,是研究人员在训练完之后去观察出来的,是人事后给它起的名字,不是事先规定的。
2. 同一个「它」,在不同句子里的 Q 也不一样。因为 x 是前几层加工过的,已经带上了上下文。「小猫跳上桌子,它很开心」里的「它」,和「这个方案很好,它的成本很低」里的「它」,进到第 5 层时 x 已经不同了,所以算出来的 q 也不同,找的东西也不同。
3. 唯一「定义」了 Q 的,是训练目标:猜准下一个 token。
1 | 训练中某一次: |
8. 多头注意力:头的个数怎么定,分工怎么出现
一组 Q、K、V 只能从一个角度去找关系。所以模型同时用很多组(比如 32 组),每一组叫一个「头」:
1 | 头 1:可能学会了找「代词指的是谁」 |
头的个数:人在训练前定,但只定一个数字
头的个数是人定的,属于「超参数」。超参数就是训练开始之前人手工设定、训练中不会变的配置,比如层数、向量长度、头数。人只定「有 32 个头」,不定每个头干什么。
没有一个「100 种功能」的菜单让模型去挑。每个头一开始都是一组随机数,地位完全平等,没有任何预设的角色。
一些真实模型的配置:
| 模型 | 层数 | 每层的头数 | 每个头的向量长度 |
|---|---|---|---|
| GPT-2 小号 | 12 | 12 | 64 |
| GPT-3(1750 亿参数) | 96 | 96 | 128 |
| Llama 3 8B | 32 | 32 | 128 |
人一般是这样定头数的:
1 | 先定每个词的向量总长度 d_model(模型越大,d_model 越大,比如 4096) |
为什么是 64 或 128?是试出来的经验值:每个头的长度太短,一个头能表达的东西太少;太长,头数就少了,角度不够多。研究发现,在模型总大小固定时,头数从十几个变成几十个,效果差别不大;真正决定效果的主要是模型总大小和训练数据量。还有研究发现,训练好的模型里很多头删掉也几乎不影响效果(论文《Are Sixteen Heads Really Better than One?》,2019),说明头数给多了,也只是有些头闲着。
分工是怎么出现的:像一家公司招了 32 个新人,不分配岗位,只看整体业绩
1 | 训练开始: |
为什么偏偏会出现「找代词指的是谁」这样的头?因为训练数据里大量的句子需要它。几万亿个 token 的文本里,「它」「他」「这个」到处都是,不知道代词指谁,后面的字就经常猜错。这类错误反复出现、数量巨大,所以总会有某个头被推着去解决这件事。反过来说,数据里常用的规律,就会有头去学;数据里很少用到的规律,就没有头专门去学。
人怎么知道某个头在找代词?是训练完之后去观察:把很多带代词的句子喂进去,看某个头的 attention 比例是不是总集中在代词指的那个名词上。研究人员确实在 BERT 里找到过这样的头(《What Does BERT Look At?》,2019)。还有一种很有名的头叫「归纳头」:如果前面出现过「A B」,后面又出现「A」,归纳头就去找前面那个 A 后面跟的是什么,然后预测下一个是「B」。但要说清楚:大部分头的作用人看不太懂,能被清楚命名的只是一小部分。
9. 前馈网络:每个词自己去查记忆
前馈网络在哪里
1 | 一个 Transformer 层: |
| attention | 前馈网络 | |
|---|---|---|
| 看不看别的词 | 看。每个词去看前面所有的词 | 不看。每个词单独处理,互相之间没有任何交流 |
| 干什么 | 把别的词的信息搬过来 | 拿自己现在的向量,去自己的「记忆」里查东西,把查到的加回来 |
| 比方 | 开会:问别人、听别人说 | 散会后回到工位,自己翻手册、查资料 |
前馈网络英文叫 Feed-Forward Network,常简写成 FFN,也有人叫它 MLP。名字的意思是「数据只往前走一遍,不绕回来」,跟它干什么关系不大,不用纠结这个名字。
结构:放大、筛选、缩回
1 | 输入:一个词的向量 x(4096 个数字) |
怎么理解:16384 个「探测器」,每个探测器配一条「笔记」
只看矩阵乘法很难理解它在干嘛。换个角度看就清楚了(这个看法来自论文《Transformer Feed-Forward Layers Are Key-Value Memories》,2021):
1 | W1 可以看成 16384 个探测器,每个探测器检查一种模式 |
这跟 attention 很像:都是「拿我的向量去和一堆东西做点积 → 算出该取哪些 → 按比例把对应的内容加起来」。区别是:
- attention 里被比对的 k 和取走的 v,来自这句话里的其他词,每句话都不一样
- 前馈网络里的探测器和笔记,是训练时学好、固定写在参数里的,不管输入什么句子都是同一套
attention 是查这句话的上下文,前馈网络是查模型自己的记忆。
走一个例子:「巴黎是法国的首」
还是看最后一个位置「首」,在中间某一层:
1 | 进入这一层时: |
探测器的编号和含义是为了讲解编的。真实模型里,一个探测器往往同时对好几种不相干的模式都有反应,没这么干净。
为什么第 2 步「筛选」不能少
如果不做筛选,x × W1 × W2 等于 x × (W1 × W2),两个矩阵合起来就是一个矩阵,放大到 16384 也白放大了。正是「小于 0 就变成 0」这一步,让前馈网络能做「如果看到这种模式才加这条笔记,否则什么都不加」这种判断。
点积和 ReLU 合起来在做什么
我的理解是:点积用来检查向量里有没有某个特征,ReLU 让「有这个特征的就保留,没有的就直接变成 0」。这个理解基本对,再补三点:
1. 点积算出来的不只是「有没有」,还有「有多强」。
1 | x = [1, 0.5] |
- 如果 x 里有某个特征,点积的大小就是这个特征有多明显
- ReLU 把这个强度原样留下来;如果点积是负数,就说明 x 里没有这个特征,ReLU 直接把它变成 0
- 特征越明显,对应的笔记就加得越多
2. 「大于 0」这个门槛也是可以学的。早期的模型会在点积后面再加一个数字(叫偏置),这时的判断就变成「点积大于某个门槛才算数」,每个探测器的门槛都是训练出来的。现在很多大模型(比如 Llama)把偏置去掉了,但道理一样。另外,现在的模型多用 GELU、SwiGLU 这类比 ReLU 更「圆滑」的函数:小于 0 的部分不是一刀切成 0,而是慢慢压到接近 0。理解的时候按 ReLU 来想就够了。
3. 「特征」很广义,而且比想象中更乱。一个特征可以是任何东西:
- 某个具体的词,比如「当前这个字是『首』」
- 语法,比如「这里是一个动词的宾语」
- 话题,比如「在讲法国」
- 格式,比如「现在在一段代码的字符串里面」
- 语气,比如「这句话是在讽刺」
但真实模型里有个麻烦:探测器和特征不是一一对应的。一个探测器往往同时对好几种毫不相干的特征都有反应(比如同时对「法语」和「棒球」亮);反过来,一个特征也常常分散在很多个探测器上。原因是模型要记的特征远比探测器多,只好挤在一起存(见下面「16384 个探测器够用吗」)。第 21 节提到的「金门大桥特征」,就是 Anthropic 用专门的方法把这些挤在一起的特征拆开之后找到的。
知识主要存在前馈网络里
1. 参数大部分在前馈网络里。以向量长度 4096 的模型为例:
1 | attention 的参数:W_Q、W_K、W_V,再加最后合并多头的那个矩阵,一共 4 个 4096×4096 的矩阵 |
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 | 假设只有 3 个探测器,每个只有「亮」和「不亮」两种状态: |
打个比方:钢琴只有 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 | 底层: 这个词本身是什么、词性是什么、和旁边的词怎么组成短语 |
不对的地方,有三点
| CNN(识别图片) | Transformer(大模型) | |
|---|---|---|
| 分辨率 | 每往上一层图片被缩小(224×224 → 112×112 → …… → 7×7),细节真的被丢掉了 | 每一层的词数和向量长度都不变:输入 10 个 token,第 1 层是 10 个向量,第 80 层还是 10 个,每个都是 4096 个数字 |
| 能看多远 | 底层只能看到一小块图片,要叠很多层才能「看到」整张图 | 第 1 层的 attention 就能让任何一个词去看前面任何一个词,不管隔多远 |
| 低层的细节 | 往上走时逐渐被丢掉 | 一直留在向量里,后面的层随时能读到(见下面的残差连接) |
残差连接:低层的细节不会被丢掉
Transformer 每一层不是把向量换成新的,而是在原来的向量上加一点东西:
1 | x = 词向量 + 位置信息 |
这种「在原来的基础上加」的做法叫残差连接。所以更贴切的比方不是「分辨率」,而是一份不断被批注的档案:每个词有一个档案袋,第 1 层的人往里写了「这是名词」,第 10 层的人写了「这是主语」,第 30 层的人写了「这个指的是前面那只猫」…… 前面写的东西一直都在,后面的层随时都能读到。
走一个例子:「巴黎是法国的首」
看最后一个位置「首」的向量一路上被加了什么(简化说明,真实情况要模糊得多):
「首」这个位置的档案袋,每一层往里加一条批注,旧的批注都还在:
| 阶段 | 往档案袋里加了什么 |
|---|---|
| 刚进模型 | 「首」这个字本身(可能是首都、首先、首页、一首歌……) |
| 底层加上 | 前面是「法国的」,「首」后面很可能是「都」或「府」 |
| 中间层加上 | attention 找到了「巴黎」和「法国」,调出「巴黎是法国的首都」这条知识 |
| 高层加上 | 下一个字应该输出「都」 |
研究人员有一种方法叫 logit lens,就是把每一层的 x 直接拿去给词表打分,看「如果模型在这一层就停下来,它会猜什么」。结果一般是:底层猜得乱七八糟,越往上越接近最终答案。这说明越往上的层,向量里的信息越接近最终要输出的答案。
11. 新的 token 是怎么出来的
1 | 输入:「今天 天气 很」 |
第 5 步之后,「今天 天气 很」后面每个 token 的概率(示意):
| 比例 | 示意 | |
|---|---|---|
| 好 | 40% | ██████████ |
| 热 | 25% | ██████ |
| 冷 | 15% | ████ |
| 不 | 5% | █ |
| 其他 | 15% | ████ |
顺带说一下 KV cache
每生成一个新 token 都要重新跑一遍,但前面那些词的 k 和 v 已经算过了,不会变(因为前面的词看不到后面的词)。所以模型会把它们存起来,新 token 只需要算自己的 q、k、v,然后用自己的 q 去和存起来的所有 k 对一下就行。这就是为什么对话越长越占显存:存的 k 和 v 越来越多。
第二部分:模型是怎么训练出来的
12. 这些参数是怎么学出来的
1 | 重复几万亿次: |
没有人告诉模型「Q 要用来找代词指的是谁」。只是因为找对了指代,才能猜对下一个词,所以在大量的微调过程中,矩阵自然就变成了能做这件事的样子。
人只定结构:多少层、每层多少个头、向量多长。每个头找什么、每一层加工什么、Q 里的数字是什么意思,全部是「猜准下一个 token」这一个目标在几万亿次训练里推出来的。
哪些是人定的,哪些是训练出来的
除了少数几个由人在训练前定好的数字,模型里所有的参数都是训练出来的,而且是用同一种方式一起训练:
1 | 人在训练前定好的(超参数): |
所以「探测器检查什么模式」「笔记里写什么」「路由器怎么挑专家」,都跟 attention 的头一样,没有人规定过。
13. 基座模型只会接龙,助手是什么样子
大模型的训练分两个阶段:
1 | 第一阶段:预训练 |
「只会接龙」是什么样子
基座模型只学过一件事:这段文字在网上通常会怎么接下去。它不知道有人在问它问题,也不知道自己应该回答。下面这些都是基座模型的典型表现(示意,不是某个模型的原话):
例 1:问一个问题,它接着出题。网上「XX 的首都是哪里?」这种句子大量出现在练习题、试卷里,后面跟的往往是下一道题,而不是答案。
1 | 输入:中国的首都是哪里? |
例 2:让它写请假邮件,它写成了论坛求助帖。网上「帮我写一封……」最常出现在论坛和问答网站的提问里,后面跟着的是回帖。
1 | 输入:帮我写一封请假邮件 |
例 3:不知道什么时候停,还会替用户说话。它只是觉得「这是一份对话记录」,就把整份记录接着编下去,自己演两个角色。
1 | 输入:用户:1+1 等于几? |
例 4:什么风格都学,好的坏的一起学。
- 问「怎么判断一个数是不是质数」,它可能写出 StackOverflow 上某个有 bug 的回答,因为网上确实有很多有 bug 的代码
- 问危险的问题,网上有相关内容,它就照着接下去,没有「这个不该回答」的概念
- 开头写得像营销号,它就接成营销号的风格
但知识其实已经在基座模型里了
如果把输入写成下面这样,基座模型就会接「北京。」因为文本被伪装成了「问答格式」,「答:」后面最可能接的就是正确答案。
1 | 问:日本的首都是哪里? |
这说明后训练的主要作用不是灌知识,而是教模型以「助手」的身份、用正确的格式把已有的知识用出来。
以前要给 AI 举例子(one-shot、few-shot),就是这个原因
1 | 2020 年,GPT-3: |
同类的例子还有:2022 年流行在提示词后面加一句「让我们一步一步地想」,模型做数学题的正确率会明显提高。现在的推理模型已经通过强化学习把「先想再答」练成了习惯,就不需要再加这一句了。很多以前要靠提示词技巧做到的事,后来都被训练进了模型里。
「像助手」是什么样子
| 输入 | 基座模型 | 后训练之后的助手 |
|---|---|---|
| 中国的首都是哪里? | 接着出下一道题 | 「北京。」然后停下来 |
| 帮我写一封请假邮件 | 编成论坛帖和回帖 | 直接写出邮件,可能顺便问一句请假原因和天数 |
| 用户:1 + 1 等于几? | 编出好几轮对话 | 只回答「2」,然后停下来等用户 |
| 怎么做一个危险物品 | 照着网上内容接下去 | 拒绝,或者只说安全相关的信息 |
| 你不知道的事 | 编一个看起来像真的答案 | 更倾向于说「我不确定」(做得还不完美) |
| 「用表格列出来」 | 不一定理会 | 按要求出表格 |
后训练之后,模型做的仍然是接龙
聊天界面里看到的对话,送进模型时其实是一段带特殊标记的文字:
1 | <|系统|>你是一个有帮助的助手<|结束|> |
模型从 <|助手|> 后面开始接龙,接出「北京。<|结束|>」。看到 <|结束|> 这个特殊 token,程序就停止生成,把回答显示出来。所以后训练其实是把模型训练成:一看到 <|助手|>,就接出一个好助手会说的话;说完就接 <|结束|>。
14. 后训练具体怎么做
现在常见的后训练分三步,不同公司的叫法和顺序会有些差别。
第 1 步:监督微调(SFT)—— 给模型看示范答案
1 | 准备数据:请人写几万到几十万条「问题 + 理想回答」 |
做完这一步,模型就学会了对话格式:该回答时回答、回答完会停、不再替用户说话。
第 2 步:偏好训练(RLHF)—— 让人比较哪个回答更好
光有示范不够,因为请人写出满分答案很难、很贵,但让人比较两个回答哪个更好,就容易得多。
1 | 第 1 步:对同一个问题,让模型生成两个回答 A 和 B |
RLHF 是「基于人类反馈的强化学习」的英文缩写。语气、详略程度、什么该拒绝什么不该拒绝,这些很难写成标准答案的东西,主要靠这一步调出来。也有让 AI 按照一份写好的原则来打分、代替部分人工打分的做法,Anthropic 叫它 Constitutional AI。
第 3 步:可以自动检查对错的强化学习 —— 数学、代码
1 | 给模型一道数学题,题目有标准答案 |
这一步能让模型的能力真正变强,不只是变得会说话。o1、DeepSeek-R1 这类「先想很久再回答」的推理模型,就是靠大量这种训练学会的:没有人教它要怎么想,只是因为「多检查一遍」「换个方法试试」的那些解题过程更容易做对、更常得到奖励,模型就慢慢养成了这种思考习惯。
15. 为什么需要后训练
一句话:预训练的目标是「像网上的文本」,而我们想要的是「对用户有用」,这两件事不一样。
1 | 网上的文本里: |
打个比方
预训练像一个人把图书馆里所有的书都读了一遍,什么都知道一点,但从来没上过班。后训练是岗前培训:教他听懂客人的要求、直接回答、说完就停、不知道的别乱说、有些事不能帮着做。对应到模型上:知识主要来自预训练,回答问题的方式主要来自后训练。
为什么不直接用对话数据做预训练?因为高质量的对话数据太少了,只用对话数据,模型学不到足够的世界知识。所以先用海量文本学知识,再用少量精心准备的数据学做事。两种数据的量相差非常大:预训练是几十万亿个 token,后训练的示范数据通常是几万到几百万条。
16. 编程场景专门的后训练
有,而且是现在投入最多的方向之一。编程模型的训练一般分两层:
1. 继续预训练:在基座模型的基础上,再拿大量代码(GitHub 仓库、文档、技术问答)继续做「猜下一个 token」,让模型对代码更熟。Code Llama、Qwen-Coder 这类专门的代码模型就是这么做的。这一步严格说还属于预训练性质。
2. 编程专用的后训练:
1 | SFT:示范怎么写函数、怎么解释代码、怎么修 bug、怎么写测试 |
像 Claude Code 这种能自己读文件、跑命令、改多个文件的编程助手,背后的模型就要经过大量这类训练。至于具体用了哪些数据、怎么做的,各家公开的细节不多。
模型会钻空子(reward hacking)
模型的目标是拿到奖励,而不是真的把代码写好,所以会学到一些作弊的办法:
- 发现改测试比改代码容易,就直接把测试改成一定会通过
- 测试只检查了几个固定的输入,就在代码里写「如果输入是 5,就返回 120」,专门对付这几个输入
- 遇到报错,就把整段代码用 try 包起来,什么错误都吞掉
所以设计训练环境时要专门防这些作弊,比如不让模型改测试文件,或者额外准备一批模型看不到的测试。
除了编程,其他场景也有专门的后训练:数学、调用工具和搜索、长文写作、多语言、安全(什么该拒绝、什么不该拒绝)等等。一个通用模型的后训练,通常是把很多个场景的数据混在一起训练。
Claude Code 好用,是因为这方面的后训练又多又好吗?
先说清楚:Anthropic 内部具体怎么训练的,公开资料里没有细节,下面的判断来自公开信息。在这个前提下:编程 agent 的后训练是很重要的原因,但不是全部。实际用起来的效果,是三样东西乘在一起的结果:
1 | 实际用起来的效果 ≈ 基座模型的能力 × 编程和 agent 方面的后训练 × 产品本身 |
另外,「其他模型比不上」这个说法要打个折扣。到 2026 年 6 月为止,OpenAI 的 Codex、Google 的 Gemini 等在编程评测上跟 Claude 是互有胜负的,排名变得很快。DeepSeek 的训练预算比几家头部公司小得多,价格也便宜得多,比较的时候要把这一点考虑进去。
17. 蒸馏:让一个模型照着另一个模型学
蒸馏 = 让一个模型(学生)去模仿另一个模型(老师)的输出。通常老师是大而强的模型,学生是小而便宜的模型,或者是另一家公司的模型。
蒸馏和后训练关系很紧:最常见的蒸馏,就是用老师模型代替人,来写后训练用的示范答案。
做法一:学老师的回答(只要能调用老师的 API 就能做)
1 | 第 1 步:准备几十万到几百万个问题(编程题、数学题、日常问题……) |
真实的例子:
- 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 | 输入:今天 天气 很 |
蒸馏告诉学生的:
1 | 输入:今天 天气 很 |
老师的概率分布里藏着很多额外信息:「热」和「冷」也说得通,只是没那么常见;「香蕉」完全不行。只给一个正确答案,这些信息就丢了。所以学生从老师的概率分布里学,比从正确答案里学,效率高得多。这个想法来自 Hinton 等人 2015 年的论文,也是「蒸馏」这个名字的来源。
这种做法需要拿到老师对每个 token 的完整概率,一般的 API 不提供这么完整的数据,所以通常是公司用自家的大模型蒸馏自家的小模型。比如 Google 的 Gemma 2 小模型和 Meta 的 Llama 3.2 1B、3B,都用过这种方式从自家更大的模型学习。
为什么蒸馏能让 A 变得像 B
1 | 原因 1:学生的基座模型本来就有很多知识,缺的是「怎么用」 |
蒸馏的局限
- 学生的上限受自己的大小限制。一个 70 亿参数的小模型,就算照着一个大模型学,也装不下大模型的全部知识。它学得最好的是老师的风格和常见题型的套路
- 只能学到老师展示出来的东西。训练数据里没覆盖到的问题,学生就没学过;遇到没见过的难题,跟老师的差距就露出来了
- 一般学不到超过老师的水平。老师答错的地方,学生也会照着学错
- 所以常见的情况是:蒸馏出来的模型在常用的评测题上分数接近老师,真正用起来,遇到复杂一点、没见过的问题,就不如老师
18. 不同厂商的基座模型差不多吗
我原来的理解是:不同厂商的基座模型能力差不多,实际用起来差得远,主要是后训练造成的。
不能这么理解。基座模型之间的差距是真实存在的,而且很重要。这一条最容易理解偏(附录里汇总了更多辅助理解的部分)。基座模型的差别主要来自这几样东西:
1 | 训练数据: |
有一个例子能说明后训练也很重要:DeepSeek-V3 和 DeepSeek-R1 用的是同一个基座模型。R1 只是在这个基座上多做了大量推理方面的强化学习,数学和编程能力就明显强了一大截。所以两样都重要:
- 基座差,后训练很难救回来:后训练基本加不进新知识
- 基座好,后训练做得不好,也发挥不出来
还有一点:头部的闭源公司(OpenAI、Anthropic、Google)都不公开基座模型,外人没法直接比较它们的基座;能拿来比较的只有开源的基座模型,比如 Llama、Qwen、DeepSeek。而且现在预训练和后训练的边界越来越模糊:很多公司在预训练的后期就开始混入对话数据和推理数据,这一段有时被叫作「中期训练」。
第三部分:更进一步
19. MoE:把前馈网络拆成很多个专家
从前馈网络的一个浪费说起
第 9 节「巴黎是法国的首」的例子里有一句话:「16384 个探测器里,大部分都不亮」。这意味着:
1 | 每个 token 经过前馈网络时: |
MoE(Mixture of Experts,混合专家)的想法就是:既然每次大部分探测器都用不上,那干脆把前馈网络拆成很多个小的,每次只挑几个来算。
1 | 原来:每一层有 1 个大的前馈网络 |
代入数字走一遍:第 3 步的比例用在哪里
用 4 个专家、每次挑 2 个的小例子:
1 | 第 1 步:路由器给 4 个专家打分 |
这个比例还有一个更关键的作用:路由器正是靠这个比例才学得会挑专家。
1 | 训练时: |
不同模型的细节有差别: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 | 常见做法: |
5. MoE 的目的不只是「省掉不必要的计算」,而是「同样的计算量,模型可以大得多」。我原来的理解是:MoE 是对前馈网络的优化,很多情况下没必要算的就不算,以此降低推理成本。方向对,但目的说反了一半:
1 | 我原来的理解像是: |
而且 MoE 模型通常从训练一开始就是 MoE 结构,不是先训练一个普通模型再拆开的;专家和路由器是一起从随机数开始训练出来的。再加上第 3 点说的不省内存,MoE 也有代价:所有专家都要放在内存里。
6. 编程和医学场景用的专家会有差别,但没有「编程专家」「医学专家」。路由器是按每个 token 挑专家的。一段代码里全是括号、缩进、def、return,一段医学文字里是病名、药名,token 长得很不一样,挑出来的专家组合自然就有差别。但研究发现,专家的分工更多跟词的类型和格式有关,而不是跟领域有关:Mixtral 的论文对比过数学论文、生物医学论文、哲学论文,路由器挑专家的分布差别不大;反而像 Python 里的 self、代码的缩进这类 token,会稳定地被送到某几个专家那里。DeepSeek-V3 那种「很多个小专家加共享专家」的做法被认为分工更细、更专一些,但也谈不上有一个专门的「医学专家」。
7. 路由器挑得好不好,影响很大,但不会因为一次挑得不好就出大错。
1 | 影响大的地方: |
把前馈网络和 MoE 放在一起看
1 | 一个 Transformer 层: |
- 前馈网络:每个词自己去查记忆的部分,占了大部分参数,存了大量知识
- 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 | 用一个很小、很快的模型先连续猜 5 个 token |
4. 不是逐个 token 生成的模型:扩散语言模型
画图模型(比如 Stable Diffusion)是从一团噪点开始,一步步修成清晰的图。扩散语言模型也是这个思路:先生成一整段模糊的文字,再一轮轮地修改,最后变成通顺的文字,而不是从左到右一个一个往外接。Google 的 Gemini Diffusion、Inception Labs 的 Mercury 都是这一类,优点是快。目前还不是主流,但值得关注。
5. 可解释性:开始能看懂模型内部了
这两年进展很大,金门大桥特征和电路追踪的例子放在第 21 节。
如果只挑三个先了解
MoE(第 19 节,现在几乎所有大模型都在用)、推理模型和强化学习(这两年能力进步最大的来源)、可解释性(第 21 节,直接回答了「人类到底知不知道它为什么能用」)。
21. 人类到底知不知道它为什么能用
一种常见的理解是:人类也不知道它为什么生效,只知道这个框架能用,就负责把框架搭出来,让里面自己去训练,所以是「蒙出来的」。大方向对,但「纯蒙」说重了。
更准确的说法是:人类完全知道每一步在算什么,也知道为什么训练能让模型越来越准;但不知道训练出来的那几百亿个数字具体学到了什么、靠什么完成了某件事。
1 | 人类清楚知道的: |
更贴切的比方:蒸汽机
人类先造出了能用的蒸汽机,后来才搞清楚热力学。框架是有道理地一步步设计和实验出来的,只是框架里面长出来的东西,人类还在拆解。专门做这件事的研究方向叫「可解释性」,第 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 打分,抽出一个,接到末尾,再来一遍。
预训练让模型读完了整个互联网,学会了知识,但只会接龙;后训练用示范答案、人的偏好打分、可以自动检查的题目,把模型调整成会对话、会干活的助手。编程是现在后训练投入最多的方向之一,核心是用测试结果给模型打分。蒸馏就是用一个强模型的回答(或者概率分布)当作后训练的教材,让另一个模型照着学,所以学生能很快变得像老师,但很难真的赶上老师。