大模型只训一次，所有决定都在小模型上做完

一条曲线定下一次训练

2025 年 10 月，Meta 等机构的一篇论文做了一件以前只在预训练里做过的事：他们花了 40 万 GPU 小时研究强化学习的缩放，拟合出一条 S 形曲线，然后把一次强化学习一路跑到 10 万 GPU 小时，用前一小段的数据预测后面的走势，最后的结果落在曲线上。【文中有据，ScaleRL，arXiv 2510.13786，第 1 至 2 页】

同一年 12 月，DeepSeek-V3.2 的报告写明，它在后训练上花的算力超过了预训练的 10%。【文中有据，DeepSeek-V3.2 报告第 2 页】作为对照，半年前 DeepSeek-R1 的强化学习用了 10 万 H800 卡时，只占它预训练算力的 3.75%。【文中有据，ScaleRL 第 2 页引用 R1 的数字】

这两件事放在一起，说明大模型训练这门手艺在 2025 年变成了什么样。旗舰模型的预训练动辄数月、数千张卡，没有人付得起第二次，所以每个决定都先在小模型上试，再靠曲线外推。这套方法在预训练里已经用了五年，从 2020 年的 Kaplan 到 2024 年的 Llama 3，后者在开训之前就用小于 $10^{22}$ FLOPs 的模型预测出了 405B 在 ARC-Challenge 上的成绩。新的部分是后训练：它不再是预训练结束后的一层薄薄的微调，而是一个有自己的算力预算、自己的缩放曲线、自己的失败方式的阶段。如今用户能直接感受到的那些差别，比如模型会不会写一段能跑的前端动画、画一张像样的 SVG、说话像不像人，主要是在这个阶段决定的。

下面按真正动手时的顺序走一遍。每一步说清楚四件事：手里有什么，能怎么选，业界实际怎么选的、数字是多少，选错了会看到什么。另外还有一件：这个决定是靠哪个小实验做出来的。

一条流水线上的十二个决定

下面这张图是全景。上面一行是预训练，下面一行是预训练之后的事。点任意一个方框，图下会列出三次参照训练在这一步的实际选择，以及做这个决定所依据的那个小实验。

图 1训练流水线的十二个决定。点方框切换下方的表；表里每一项都在后文对应的小节里展开，出处也在那里给出。

这张表最该看的是最后一行。几乎每一步都有一个和它配对的小实验：定大小用 isoFLOP 曲线，定数据用 1B 到 8B 模型上的消融，定分词器用 1B 模型训 100B token 的对照，定结构上的稳定性改动用小模型的学习率扫描。大模型本身只负责执行。这个主题按环节拆开，可以写成四篇：预算与配比，数据与分词器，结构、并行与稳定性，后训练与评测。这里合成一篇，按决定的顺序走，每一节也可以单独读。

算力预算与 6ND

一切从钱开始。钱换算成算力：多少张卡、用多少天、每张卡实际能跑出多少 FLOP/s。输出是一个总数 $C$，单位是浮点运算次数。后面所有的取舍，都是在固定 $C$ 的条件下做的，所以先要会用 $C$ 算账。

稠密 Transformer 训练一个 token 的计算量，近似是参数量的 6 倍：

$$C\approx 6\,\role{op}{N}\,\role{in}{D}$$

其中 N 是参数量，D 是训练的 token 数。6 的来历很具体。前向时每个参数参与一次乘法和一次加法，是 2 次运算；反向时要对激活求梯度，还要对权重求梯度，各是一次同样规模的矩阵乘，合起来 4 次。2 加 4 等于 6。这个式子漏掉了注意力里和序列长度有关的那一项：每个 token 的前向还要多做大约 $2\,n_{\text{layer}}\,n_{\text{ctx}}\,d$ 次运算（Kaplan 等人 2020，表 1）。代入 Llama 3 405B 的形状，126 层、宽 16384、上下文 8192，三倍之后是每个 token $1.0\times10^{11}$，而 $6N$ 是 $2.4\times10^{12}$，漏掉的那一项约占 4%。上下文拉到 128K 时同一项会涨到 $6N$ 的六成以上，这时 6ND 就不能直接用了。

用这个式子核对几个公开的数字：

A100 的 BF16 稠密峰值按 312 TFLOP/s，H100 和 H800 按 989 TFLOP/s。前三行出自 LLaMA 论文第 4 页和 Llama 2 论文表 2；Llama 3 出自其报告第 1 页和表 4；DeepSeek-V3 出自其报告表 1。DeepSeek-V3 是混合专家模型，6ND 里的 N 只能取每个 token 实际经过的 37B 激活参数，并且漏掉了注意力和路由的开销，所以反推的吞吐偏低；它的大部分矩阵乘用 FP8 做，FP8 峰值是 BF16 的两倍。

这张表给了一个比任何单个数字都有用的经验：实际吞吐稳定在 BF16 峰值的 35% 到 47% 之间，换了三代硬件、四个团队都没跳出这个区间。这个比例叫 MFU（model FLOPs utilization）。剩下的五成多去了通信、流水线气泡、注意力等非矩阵乘运算，以及重算激活。预算时直接按 40% 打折，误差不会超过两成。

拿一个整数做一次完整的估算。7B 模型训 2T token：$6\times7\times10^9\times2\times10^{12}=8.4\times10^{22}$。一张 H100 按 40% 的 MFU 每秒跑 $4\times10^{14}$ 次，需要 $2.1\times10^{8}$ 卡秒，约 5.8 万卡时。1024 张卡要 2.4 天，按 H800 每卡时 2 美元的租价（DeepSeek-V3 报告用的口径）是 12 万美元。同样的算法套到 DeepSeek-V3 上：报告里每训练一万亿 token 用 18 万 H800 卡时，2048 张卡 3.7 天；预训练 266.4 万卡时，加上长上下文扩展 11.9 万和后训练 0.5 万，合计 278.8 万卡时，乘 2 美元是 557.6 万美元。报告自己写明，这个数不含此前在结构、算法和数据上做的研究和消融实验。【文中有据，DeepSeek-V3 报告第 5 页、表 1】

参数量和 token 数的配比

预算定了，接下来是怎么花：$C$ 固定时，$N$ 和 $D$ 只剩一个自由度。模型大一倍，能看的 token 就少一半。这个决定的输入是一组小模型实验，输出是两条幂律 $N^*(C)\propto C^{a}$ 和 $D^*(C)\propto C^{1-a}$，指数 $a$ 决定了预算增加时钱该往哪边放。

两条矛盾的幂律

2020 年，Kaplan 等人给出的答案是 $a=0.73$：算力每多 10 倍，模型变大 5.4 倍，数据只多 1.9 倍。这条规律主导了之后两年的大模型。GPT-3 是 175B 参数训 300B token，每个参数不到 2 个 token；Gopher 是 280B 参数，同样 300B token。

2022 年，DeepMind 的 Hoffmann 等人用三种方法重新估计，得到 $a=0.50$、$0.49$、$0.46$：参数和数据应该同比例增长。按这个结论，Gopher 的预算应该训一个小 4 倍的模型、多看 4 倍的数据。他们训了这个模型，就是 Chinchilla：70B 参数，1.4T token，算力和 Gopher 相同，MMLU 达到 67.5%，比 Gopher 高出 7 个点以上。每个参数 20 个 token 这条经验规则就是从这里来的。【文中有据，Chinchilla 论文第 1 至 2 页、表 2】

两份报告的数据、模型、优化器都相近，指数却差了 0.23。按 Porian 等人复现出的两条规律，在 Chinchilla 的预算 $5.88 imes10^{23}$ 上，最优模型一个是 3T 参数，一个是 77B，差 39 倍。这个差距的来源，直到 2024 年才被两组人分别查清楚，而且查出来的原因和 Chinchilla 自己的解释不一样。后面单独讲。先看配比是怎么从实验里读出来的。

isoFLOP 曲线

Chinchilla 的第二种方法最直观。固定一个算力，比如 $10^{20}$ FLOPs，训一排大小不同的模型，每个模型的训练 token 数由 $D=C/6N$ 决定。小模型看了很多数据，但容量不够；大模型容量够，但只看了很少的数据。最终损失对 $\log N$ 画出来是一个 U 形，谷底就是这个算力下的最优大小。换十个算力档位重复一遍，把谷底连起来，就得到 $N^*(C)$。

第三种方法把所有实验点拟合进一个参数化的损失函数：

$$L(\role{op}{N},\role{in}{D})=E+\frac{A}{\role{op}{N}^{\alpha}}+\frac{B}{\role{in}{D}^{\beta}}$$

三项各有含义。$E$ 是文本本身的熵，模型和数据再多也降不下去；$A/N^\alpha$ 是有限模型容量带来的额外损失；$B/D^\beta$ 是有限数据带来的额外损失。在 $6ND=C$ 的约束下求最小值，得到 $N^*\propto C^{\beta/(\alpha+\beta)}$。下图用的是 Epoch AI 在 2024 年重新拟合的参数：$E=1.8172$，$A=482.01$，$B=2085.43$，$\alpha=0.3478$，$\beta=0.3658$。拖动滑块改变算力，看谷底往哪里走。

图 2按 Chinchilla 数据重新拟合的损失面，在固定算力下画出的 isoFLOP 曲线。浅灰是 $10^{18}$ 到 $10^{26}$ 每个整数量级的曲线，绿色是滑块选中的算力，橙色圆点是它的谷底，灰色虚线连起所有谷底。空心点是几个真实模型在各自算力下的位置；它们用的数据和分词器各不相同，纵坐标只表示如果用 Chinchilla 的数据会落在哪里，不是它们的实际损失。读数行末尾的文字链接可以换成 Hoffmann 论文正文里四舍五入后的参数。

拖的时候有三件事可以看见。第一，谷底沿一条斜率接近 1/2 的直线移动，每个参数对应的 token 数从 $10^{18}$ 时的二十几慢慢降到 $10^{26}$ 时的十六左右，几乎不变。第二，算力越大，U 形底部越平：在 $3.8\times10^{25}$ 处，模型大小偏离最优值 1.5 倍，损失只差千分之一左右。Llama 3 报告里正是用这一点来解释为什么最后选了 405B 而不是拟合给出的 402B。【文中有据，Llama 3 报告第 8 页】第三，GPT-3 和 Gopher 都落在谷底的右侧很远的地方，模型太大、数据太少；Llama 3 8B 落在左侧更远的地方，它是故意的，最后一小节会讲原因。

把链接切到原文参数，曲线整体下移，谷底向左跑：$5.88\times10^{23}$ 处的最优比例从每参数 18 个 token 变成 93 个。同一组实验数据，只是参数抄错了位数，结论就差了五倍。这件事后面还要细说。

四处口径差异

Chinchilla 论文对 Kaplan 指数偏大的解释是学习率调度：Kaplan 对所有模型用同一个固定长度的余弦调度，训练中途截下来的损失偏高。这个解释流传最广，但 2024 年两项独立的复盘都没有支持它。

Porian 等人在 Llama 式的训练框架里先复现出 Kaplan 的结果，然后一次只改一处口径，看指数怎么走。下图逐步重放他们的图 1。

图 3四步修正下最优模型大小随算力的幂律。直线的位置由 Porian 等人图 1 各面板给出的指数 $a$ 和 Chinchilla 预算 $5.88\times10^{23}$ 处的最优大小确定，只画到他们实验覆盖的范围加上外推段；当前一步是绿色，之前几步退成浅灰。

四步里影响最大的两步都和学习率无关。第一步是算力的记账方式：Kaplan 只计入非嵌入参数的计算量，漏掉了最后那个输出层。词表有五万，宽度只有几百的小模型，输出层的计算量占了总量的一大块，把它算进来，指数就从 0.835 降到 0.706。第二步是预热：Kaplan 对所有模型用同样长的预热，对小模型来说预热占了训练的一大截，小模型因此吃亏，最优点被推向大模型；把预热长度和模型大小挂钩，指数降到 0.602。匹配余弦调度的长度（也就是 Chinchilla 认为最关键的那一处）只把指数从 0.602 降到 0.571，影响最小。最后按模型大小分别调学习率、批大小和 AdamW 的 $\beta_2$，指数落到 0.497，和 Chinchilla 吻合，而这最后一步用的是常数学习率，完全没有衰减。【文中有据，Porian et al. 第 1 至 2 页、图 1】

Pearce 和 Song 从另一个方向得到相近的结论：拿 Chinchilla 拟合出的损失面，在 Kaplan 当年的模型尺度（1k 到 1.5B 参数）上模拟一遍 Kaplan 的分析，只要改用非嵌入参数计数，就能得到 0.78 的局部指数，接近 Kaplan 的 0.73；改用总参数，得到 0.51。他们的解释是：小模型里嵌入参数占比大，按非嵌入参数计数会系统地扭曲小尺度上的斜率。【文中有据，Pearce & Song 第 1 页、图 1】

两组人给出的主因不完全相同，一组强调最后一层的计算量，一组强调参数的计数口径，但它们指向同一件事：小实验和大实验的口径只要有一处不一致，外推出来的指数就会偏。参数算不算嵌入，计算量算不算输出层，预热按步数还是按比例，这些在单次实验里都是无关紧要的约定，放进一条跨六个数量级的幂律里，就变成了几十倍的模型大小。

第三种拟合里的四舍五入

Chinchilla 的第三种方法给出的指数是 0.46，比前两种的 0.50 和 0.49 小，置信区间却窄得出奇：0.454 到 0.455。2024 年，Epoch AI 的 Besiroglu 等人从论文的图 4 里把散点按坐标和颜色逐个读出来，重建了 240 个实验点，重新拟合，得到了上面图 2 用的那组参数。差别出在两处。【文中有据，Besiroglu et al. 第 2 至 5 页】

一处是四舍五入。论文正文写的是 $\beta=0.28$，TeX 源文件的注释里是 $0.2849$。在 $D=10^{11}$ 时，$D^{0.2849}$ 和 $D^{0.28}$ 差了 $10^{11\times0.0049}\approx1.13$ 倍，数据项被高估 13%，这足以让拟合的残差整体偏离零点。另一处是优化器提前停止：原作者对 Huber 损失求了平均而不是求和，损失的尺度太小，L-BFGS 在远没收敛时就停了；自助法（bootstrap）重抽样时同样停在初始值附近，于是置信区间窄到要六十万次实验才可能达到的程度，而他们实际做了四百多次。原作者事后确认了这两点。

按原文未四舍五入的参数，在 Chinchilla 的预算上求最优比例，得到每参数 59 个 token；按正文四舍五入后的参数是 93 个；Epoch 的重拟合是 18 个，和前两种方法、也和 Chinchilla 实际用的 20 个一致。所以通行的 20 这个数是对的，只是论文里第三种方法的那组参数不能拿来用。

同样的事情在 Llama 3 报告里又出现了一次，规模更小但更直接。正文写 $N^*(C)=AC^{\alpha}$，$(\alpha,A)=(0.53,0.29)$，外推到 $3.8\times10^{25}$ 应该训 16.55T token。这里的 $N^*$ 指的是 token 数，不是参数量，记号和本文相反。按正文的两个数代进去，得到的是 10.5T；图 3 图例里写的是 $\alpha=0.537$、$A=0.299$，代进去是 16.3T，才和 16.55T 对得上。指数第三位小数差 0.007，外推四个半数量级之后，结果差了 1.6 倍。另外，按 6ND，402B 参数训 16.55T token 需要 $4.0\times10^{25}$，比预算多出 5%，报告没有交代这里的计算量口径。【文中有据，Llama 3 报告第 7 至 8 页；推算是本文的】

这两处放在一起是一条可以带走的规矩：外推的距离有多少个数量级，指数就需要多少位有效数字。报告缩放律时写两位小数，对读者来说是一个结论；对要用它做决定的人来说，是一个丢了信息的参数。

为推理多付的训练

回到图 2 里那个落在谷底左侧很远的点。Llama 3 8B 训了 15T token，每个参数 1875 个，是 Chinchilla 比例的九十多倍。按图 2 用的损失面，同样的算力 $7.2\times10^{23}$ 本可以训一个 80B 左右的模型，损失低 0.05 nat。Meta 是在知情的情况下做的这个选择。

原因在于 Chinchilla 的问题问错了对象。它求的是训练算力固定时损失最低的配置，但一个模型训练一次，要被调用成千上万次。推理每生成一个 token 大约花 $2N$ 次运算。模型一生的总花费是：

$$C_{\text{总}}\approx 6\,\role{op}{N}\,\role{in}{D_{\text{训}}}+2\,\role{op}{N}\,\role{out}{D_{\text{推}}}$$

推理量 $D_{\text{推}}$ 越大，第二项越占主导，最优点就越往小模型、多数据的方向移。Sardana 等人给过一个具体的例子：目标是 13B Chinchilla 最优模型的质量，预计一生要推理 2T token，那么改训一个 7B 模型、多喂数据到同样的损失，总算力能省 $1.7\times10^{22}$，约 17%。他们还训了 47 个 150M 到 6B 的模型，把每参数 token 数从 10 一路拉到 10000，模型质量一直在提高，没有找到饱和点。【文中有据，Sardana et al. 第 1 至 2 页、图 1】

这就是为什么后来的开放模型都远远越过了 20：MiniCPM 在自己的实验里得到的平均最优比例是 192（报告第 8 页），OLMo 2 7B 是 4.05T token 对 7.3B 参数，约 555，DeepSeek-V3 按激活参数算是 400，Kimi K2 是 15.5T token 对 32B 激活参数，约 480。【文中有据】走得最远的是 Qwen3：从 0.6B 到 235B 的整个家族都用同一份约 36T token 的语料预训练，0.6B 那个模型每个参数分到六万个 token，是 Chinchilla 比例的三千倍。【文中有据，Qwen3 报告第 2 至 3 页】小模型的用途是被大量部署，训练多花的钱很快就从推理上省回来；何况家族里的小模型还会用大模型做强到弱的蒸馏，数据量对它来说已经不是瓶颈。一个可以手算的判断标准是：如果预计推理 token 总量超过训练 token 量的几倍，就应该往小模型多数据的方向走，走多远由上面那个式子的最小值决定。

从网页快照到训练语料

模型吃什么，比模型长什么样更费人力。原料是公开网页的快照（Common Crawl 每一两个月发布一次，每次几十亿个网页）、代码仓库、书籍、论文和各种专门收集的数据；输出是一份去重、过滤、按比例混好的 token 序列。这一步占用的人力通常比模型结构多得多，而它的每一个子决定都有同一个难处：好数据的定义，只能用训出来的模型来检验。所以数据团队的标准动作是消融：固定一个小模型，比如 FineWeb 用的 1.71B 参数训 28B 到 350B token，只换数据处理的一个环节，比较下游任务的平均分。

抽取与基础过滤

Common Crawl 同时提供原始网页（WARC）和它自己抽好的纯文本（WET）。FineWeb 发现 WET 里留了太多导航栏和菜单，改用 trafilatura 从 WARC 重新抽取，同样的训练量下分数明显更高。之后是三道基础过滤：按网址黑名单去掉成人网站；用 fastText 的语种分类器只留英文，得分阈值 0.65；套用 MassiveText 的质量和重复度规则。对 96 个快照做完这三步，用 GPT-2 分词器计数，还剩约 36T token。【文中有据，FineWeb 第 3 至 4 页、图 2】

Llama 3 报告里有一个反常识的细节：他们发现以网页为主的模型训练在保留 Markdown 记号的文本上效果更差，于是把所有 Markdown 标记都删掉了。【文中有据，Llama 3 报告第 5 页】这说明抽取格式本身是一个超参数：同一段内容带不带格式符号，模型学到的分布不一样，而下游评测几乎全是纯文本。

去重的反直觉结果

网页里有大量重复：镜像站、模板页、转载。去重的标准工具是 MinHash：把每篇文档切成 5 个词一组的片段，用 112 个哈希函数各取一个最小值，得到一个 112 维的签名；再把签名分成 14 个桶，每桶 8 个值，只要有一个桶的 8 个值全部相同，两篇文档就算重复。这个分法对应一条 S 形的判定曲线。两篇文档相似度（Jaccard 系数）为 $s$ 时，单个桶全同的概率是 $s^8$，14 个桶里至少一个全同的概率是：

$$P(s)=1-(1-s^{8})^{14}$$

代几个数：$s=0.6$ 时 $P=0.21$，$s=0.75$ 时 $P=0.77$，$s=0.9$ 时 $P\approx1$。曲线的陡坡落在 0.75 附近，这就是 FineWeb 说的针对至少 75% 相似的文档。【文中有据，FineWeb 第 5 页；数值是本文按公式算的】增加每桶的哈希个数，陡坡右移、判得更严；增加桶数，陡坡左移、判得更松。112 个哈希的总预算固定时，这两个旋钮互相牵制。

直觉上去重越彻底越好。FineWeb 的第一版就是这样做的：从最新的快照往前，每个快照都和之前处理过的所有快照一起去重。做完只剩 4T token，最老的那些快照被删掉了九成。用这份数据训模型，结果和不去重几乎一样，远低于 RefinedWeb。

他们接着做了一个漂亮的对照。在 2013 年 48 周那个老快照里，被全局去重保留下来的 31B token 训一个模型；被删掉的约 460B token 只在快照内部去重后得到 171B，再训一个模型。结果被删掉的那部分训出来的模型更好。人工翻看之后发现，留下来的一成里广告、关键词堆砌和格式混乱的页面更多。【文中有据，FineWeb 第 5 至 6 页、图 3 和图 4】

道理在去重留下了什么。好页面会被转载、被镜像、跨快照反复出现，所以在全局去重里成片地被判为重复删掉，只剩一份；垃圾页面往往每次抓取都不一样，反而每份都是唯一的，全部留下。全局去重于是把垃圾在剩余数据里的比例放大了。改成每个快照内部单独去重，结果是 20T token，训出来的模型追平了 RefinedWeb。作者的假设是：去重的主要收益来自删掉那些在每个快照里都有成千上万份副本的巨大重复簇，而重复次数在一百以下的小簇，删掉反而有害。

图 4FineWeb 的数据流，条的长度正比于剩下的 token 数（GPT-2 分词器）。逐步往下看；第三步是被放弃的全局去重，用橙红标出。最后的 15T 是 FineWeb，1.3T 是再经过教育质量分类的 FineWeb-Edu。数字出自 FineWeb 论文第 4 至 9 页。

值得对照的是 Llama 3 的做法：他们恰恰做了全局的文档级 MinHash 去重，另外还做了网址级去重（同一网址只留最新的版本）和很激进的行级去重（在每 3000 万篇文档的桶里，出现超过 6 次的行全部删掉）。报告承认行级去重删掉的不只是导航栏和 cookie 提示，也有高频的好文本，但实验上效果明显更好。【文中有据，Llama 3 报告第 5 页】两家的结论不矛盾：Llama 3 在去重之后还有好几层基于模型的质量过滤，全局去重放大的那部分垃圾会在后面被筛掉；FineWeb 的全局去重实验发生在质量过滤之前。【推断，依据：两份报告的处理顺序】

质量分类器

启发式规则能删掉明显的垃圾，删不掉写得通顺但没有信息量的页面。这一层要靠分类器，而分类器的标注本身也越来越多地由大模型来做。

FineWeb-Edu 是一个公开得很完整的例子。他们让 Llama-3-70B-Instruct 给 46 万个网页的教育价值打 0 到 5 分，用的是逐条加分的提示词，并且特意要求按中小学的知识水平来评，避免模型偏爱 arXiv 摘要一类的高度专业文本。然后在 Snowflake-arctic-embed-m 嵌入模型上训一个线性回归头，用 41 万条标注训练、5 万条验证。阈值取 3 分时，验证集 F1 是 82%。把这个分类器跑遍 15T token 用了 6000 个 H100 卡时，最后留下 1.3T token。1.71B 模型训 350B token，MMLU 从 33% 到 37%，ARC 从 46% 到 57%。【文中有据，FineWeb 第 8 至 9 页】

代价写在同一段里：阈值 3 是在知识类任务和 HellaSwag 这类常识续写任务之间折中出来的。教育类过滤偏向教科书式的文本，会损失口语、叙事和网络上的日常知识。Llama 3 用了两种分类器：便宜的 fastText，判断一个网页会不会被维基百科引用；贵一些的 DistilRoberta，学 Llama 2 对网页质量的判断。代码和数学另有专门的分类器和抽取流程，因为它们的 token 分布和自然语言差得太远。【文中有据，Llama 3 报告第 5 页】

好文本不够用之后的改写

过滤越严，留下的好数据越少。FineWeb-Edu 从 15T 里只留下 1.3T；而 2025 年的旗舰模型要喂 15T 到 36T token。缺口只有两种补法：把好数据重复多看几遍，或者把好数据换个说法再写一遍。

Kimi K2 的报告把这两种办法放在一起比过。他们拿维基百科类的知识文本，在一个早期检查点上试了三种用法，用 SimpleQA（一个考事实问答的评测）打分：原文重复 10 遍是 23.76；改写一次、再把改写版重复 10 遍是 27.39；改写 10 次、每个版本只看一遍是 28.94。【文中有据，Kimi K2 报告第 5 页、表 1】同样的知识，用十种说法各读一遍，比同一种说法读十遍记得牢。这和人背书的经验一致：换着角度讲同一件事，比把同一页念十遍有用。

改写不是随便让模型复述。K2 的做法有三层：提示词要求换风格、换视角但忠实于原文；长文档切成段，逐段改写，每段都看得到前面已经改好的部分，保证全文连贯；改写完逐段和原文比对语义，偏离的丢掉。报告自己也保留了警惕：每份语料最多改写两次，并且承认合成数据在规模放大后会不会带来幻觉和毒性，还需要更多研究。【文中有据，Kimi K2 报告第 5 至 6 页】

这里的取舍和蒸馏一样：改写用的模型有自己的口头禅和偏好，它们会随着改写数据进入下一代模型的预训练。后面讲说人话的那一节会回到这件事。【推断】

配比、退火与给数据估价

各个来源清洗完之后，要决定按什么比例混。Llama 3 最终的配比是：通用知识约 50%，数学和推理 25%，代码 17%，多语言 8%。这个配比本身也是用小模型的缩放律实验选出来的：在一个候选配比上训几个小模型，预测大模型在这个配比上的表现，换一个配比重复，挑出候选后再训一个更大的模型验证。他们还训了一个知识类别分类器，把网页上过度代表的类别（比如艺术和娱乐）降采样。【文中有据，Llama 3 报告第 6 页】

配比不是一成不变的。Llama 3 在训练过程中改过几次：提高非英语数据的比例，提高数学数据的比例，在后期加入更新的网页数据把知识截止时间往后推，把事后发现质量较差的子集降采样。【文中有据，Llama 3 报告第 14 页】

新数据源层出不穷，不可能每来一份小数据集就做一套缩放律实验。Llama 3 用了一个便宜得多的办法：拿一个训到一半的 Llama 3 8B，在 40B token 上把学习率线性降到 0，混入 30% 的新数据集和 70% 的默认配比，看下游分数涨多少。学习率降到 0 的这一段叫退火，模型在这一段对数据最敏感，所以小剂量的好数据能被看出来。用同样的办法，他们发现在退火里加入 GSM8k 和 MATH 的训练集，8B 模型在这两个验证集上分别涨 24.0% 和 6.4%，405B 几乎没有变化。【文中有据，Llama 3 报告第 6 页】

这个结果有两种读法。报告的读法是 405B 的上下文学习能力足够强，不需要领域内样本。另一种读法是：退火对小模型的帮助很大一部分来自学会了题目的格式，大模型本来就会。后一种读法意味着，在 8B 上用退火给数据估价，会系统地高估格式类数据对旗舰模型的价值。【推断，依据：两个模型增益的差距】

OLMo 2 把这一套做成了固定的两段式：前 90% 到 95% 的算力是预训练，用以网页为主的数据；最后 5% 到 10% 叫中期训练（mid-training），学习率线性降到 0，换成上采样后的高质量网页、精选的非网页数据和专门补数学的合成数据。7B 模型的中期训练做三次，每次 50B token、数据顺序不同，最后把三个模型的权重平均。【文中有据，OLMo 2 第 6 至 7 页】

测试集污染

预训练语料来自全网，评测集也在网上。Llama 3 用 8-gram 重叠来判断一道评测题是否被污染：题目里有足够比例的 token 落在某个在训练语料中出现过的 8-gram 里，就算污染；这个比例的阈值对每个评测集分别选，选那个让干净子集和全集分数差距最大的值。结果很不均匀：HellaSwag 有 85% 的题目被判为污染，估计带来约 14.8 个点的虚高；PiQA 55%，约 8 个点；Natural Questions 也有 52% 被判为污染，但分数几乎不受影响；GSM8K 41%，影响在 0 到 1.3 个点之间。【文中有据，Llama 3 报告第 33 至 34 页、表 15】

污染的比例和它造成的虚高不是一回事。Natural Questions 的题目短、答案是常见事实，在网上出现过不代表模型背下了答案；HellaSwag 是续写题，原文出现过就等于见过标准答案。读一份评测报告时，该问的不是污染了多少，而是在干净子集上的分数是多少。

OLMo 2 报告里有一个很诚实的脚注：预训练完之后发现数学能力差，他们从 GSM8K 的 1319 道测试题里抽了 200 道当开发集来调中期训练的数据，之后只在剩下的 1119 道上报告成绩。【文中有据，OLMo 2 第 7 页脚注 6】这种做法在业界很普遍，只是很少被写出来。只要开发集和报告集严格分开，它是合理的；危险在于反复看同一份测试集来调数据，调到第十次时，这份测试集已经变成了训练信号的一部分。

分词器

分词器看上去是个小部件，它决定了一个 token 是什么，因此也决定了前面所有关于 token 数的预算具体指多少文字。现在的主流做法是字节级 BPE（byte-pair encoding）：从 256 个字节出发，在训练语料里反复找出现次数最多的相邻一对，合并成一个新 token，记下这条合并规则，直到词表达到目标大小。编码时按规则的先后顺序重放这些合并。

下面这个分词器就是这样训出来的，训练语料是本页的正文，最多 1500 次合并。拖动滑块，看三行文字的切分方式怎么随合并次数变化。

图 5在本页正文上训练的字节级 BPE。上面三行是切分结果，相邻 token 用深浅两种底色区分；橙红的小块是一个汉字被切开后剩下的单个字节，显示为十六进制。下面的曲线是整份正文每个 token 平均对应的字符数，橙色点是滑块当前的位置。

滑块拖到最左边时，每个字节是一个 token：英文一个字母一个 token，汉字在 UTF-8 里占三个字节，一个汉字变成三个橙红的碎块。往右拖，最先被合并的是最常见的字节对，在这份以中文为主的语料里，最先出现的合并几乎都是把汉字的三个字节拼回一个字。再往右，常用词和词组开始成为单个 token。英文那一行的变化慢得多，因为这份语料里英文很少；代码那一行几乎不动。分词器在什么数据上训，就对什么数据压缩得好，这是这张图最直接的结论。

这个结论在大模型上有具体的代价。Llama 2 的词表是 32K，Llama 3 换成了 128K：其中 100K 来自 OpenAI 的 tiktoken，另加 28K 专门给非英语语言的 token。在一份英文样本上，平均每个 token 对应的字符数从 3.17 升到 3.94。报告的说法是，同样的训练算力能读更多的文字；加的 28K 非英语 token 改善了压缩率和下游表现，对英文的切分没有影响。【文中有据，Llama 3 报告第 7 页】按字符算，3.94 比 3.17 多 24%，同样 15T token 的预算，相当于多读了 24% 的文本。

大词表的代价在嵌入层上，可以手算。Llama 3 8B 的实际词表是 128,256（表 3 写的 128,000 是约数，多出的 256 个是特殊 token），宽度 4096，输入嵌入是 $128256\times4096=5.25$ 亿个参数，输出层不和它共享，又是 5.25 亿。合计 10.5 亿，占 8.03B 的 13%。同样的词表放到 405B 上只占 1%。所以词表大小对小模型是一个昂贵的决定，对大模型几乎免费。OLMo 2 在 1B 模型、100B token 上对比了新旧两种分词器，新的略好，同时说明在这个规模上大词表其实处于略微不利的位置，预期收益在更大的模型上才会显出来。【文中有据，OLMo 2 第 6 页、表 2】

分词器还有一个容易被忽略的后果：不同分词器下的 token 数不能直接比。DeepSeek-V3 的 14.8T 是在它自己 128K 词表下的计数（报告第 22 页明确写了 in our tokenizer），FineWeb 的 15T 是 GPT-2 分词器下的计数，Llama 3 的 15.6T 又是另一套。跨报告比较数据量时，换算成字节或字符才有意义。

一个 8B 模型的零件清单

结构反而是最没有悬念的一步。和数据比起来，这一步在过去三年里变化很小。Llama 3 的报告直说它用的是标准的稠密 Transformer，和 Llama、Llama 2 没有明显区别，性能的提升主要来自数据质量、多样性和训练规模。【文中有据，Llama 3 报告第 6 页】结构上的决定于是变成了一张清单：每一项都有一个默认值，偏离默认值需要理由。最好的读法是把一个具体的模型拆开，数一数每个零件有多少参数。

Llama 3 报告表 3。三个模型共用：SwiGLU 激活，128K 词表，RoPE 的基频 $\theta=500{,}000$。

图 6Llama 3 8B 的参数，逐层拆开。条的长度正比于参数量。第一步是整个模型，第二步拆成嵌入、32 个块和输出层，第三步把一个块拆成七个矩阵，最后两步换成 70B 和 405B，看各部分的比例怎么变。数字按表 3 的形状逐项相乘得到，总数和 Meta 公布的 8.03B、70.6B、405B 一致。

拆开之后有三个数值得记住。一个块里，前馈层（三个矩阵，各 $4096\times14336$）占 1.76 亿，注意力（四个矩阵）只占 4200 万，前馈层是注意力的 4.2 倍；所以说一个 Transformer 的参数主要在前馈层里，注意力只是很小的一部分。8B 的嵌入和输出层合计 10.5 亿，占 13%，到 405B 降到 1%：这就是上一节说的大词表对小模型贵、对大模型便宜。K 和 V 的投影矩阵各只有 Q 的四分之一，这是分组查询注意力（GQA）的结果：32 个查询头共用 8 组键和值。

GQA 省下的不是参数，而是推理时的显存。生成每一个 token，都要为它在每一层存下 K 和 V，供之后的 token 查询。8B 模型每个 token 每层存 $2\times8\times128$ 个数，按 2 字节算是 4 KB，32 层是 128 KB。上下文 128K 时，一条序列的 KV 缓存就是 16 GiB；如果 32 个头都有自己的 K 和 V，是 64 GiB，一张 80 GB 的卡装不下几条。405B 每个 token 是 504 KB，128K 上下文要 63 GiB。DeepSeek-V3 换了一条路，用多头潜在注意力（MLA）把 K 和 V 压进一个 512 维的潜在向量，再加 64 维的位置部分，每个 token 每层只存 576 个数，61 层合计约 70 KB。【文中有据，表 3、DeepSeek-V3 报告第 22 页；字节数是本文按 BF16 算的】

清单上其余几项，每一项都对应一种第一版会遇到的失效：

出处：Llama 3 报告第 6 至 7 页；OLMo 2 第 12 页；前馈层宽度的取整规则来自 Llama 3 官方仓库里 8B 模型的 params.json（ffn_dim_multiplier 为 1.3，multiple_of 为 1024），按 $\lceil 1.3\times\lfloor\tfrac{2}{3}\cdot4\cdot4096\rfloor/1024\rceil\times1024=14336$ 可以验算。

混合专家（MoE）是清单之外唯一的大分叉。DeepSeek-V3 的 61 层里，除了前 3 层，每层的前馈层换成 1 个共享专家加 256 个路由专家，每个专家的隐藏宽度 2048，每个 token 只激活其中 8 个。总参数 671B，每个 token 只经过 37B。计算量按 37B 算，显存按 671B 算，这就是它能用 2048 张卡训一个 671B 模型的原因。代价是路由：专家之间负载不均，有的专家被挤爆、有的闲置。DeepSeek-V3 的做法是给每个专家的路由打分加一个偏置项，按负载动态调整，更新速度在前 14.3T token 是 0.001，最后 500B token 设为 0；序列内的平衡损失权重只有 0.0001，只防极端情况。【文中有据，DeepSeek-V3 报告第 22 至 23 页】

到 2025 年，前沿的开放模型几乎全是这条分叉上的。Kimi K2 总参数 1.04T，每个 token 激活 32B；它把专家数从 DeepSeek-V3 的 256 个加到 384 个，每次仍只激活 8 个，稀疏度 48。报告给的理由是他们自己的缩放实验：激活参数固定时，专家越多、越稀疏，损失越低。代价落在推理上，所以 K2 把注意力头从 DeepSeek-V3 的 128 个减到 64 个，抵掉一部分开销。【文中有据，Kimi K2 报告第 7 页】Qwen3 的旗舰是 235B 总参数、22B 激活。稠密模型在大尺度上已经很少见了。

稀疏化的下一站是注意力。DeepSeek-V3.2 相对上一版只改了一处结构：加入 DeepSeek 稀疏注意力（DSA）。一个很小的闪电索引器先给每个查询 token 和之前所有 token 打一个粗略的相关分，只挑出分数最高的 2048 个，再在这 2048 个上做完整的注意力。这个改动不是从头训的，而是在已有模型上继续训练接进去：先用一小段预热只训索引器，让它学会模仿原来的注意力分布，再放开整体训练。【文中有据，DeepSeek-V3.2 报告第 3 至 4 页】上下文是 128K 时，原本每个 token 要看十几万个位置，现在只看两千个，长上下文推理的代价因此大幅下降；报告在标准和长上下文评测上都没有看到明显退化。

显存账与四种并行

模型定了，下一个问题很具体：几千张卡，每张 80 GB，怎么把模型和训练状态摆上去。输入是模型形状、序列长度、批大小和集群的网络拓扑，输出是一组并行度：张量并行（TP）、上下文并行（CP）、流水线并行（PP）和数据并行（DP）各取多少。

先算一张卡要装什么。混合精度训练里，每个参数要存 BF16 的权重 2 字节、BF16 的梯度 2 字节，以及优化器状态：FP32 的主权重、Adam 的一阶矩和二阶矩，各 4 字节，共 12 字节。合计每个参数 16 字节。ZeRO 论文的例子是一个 7.5B 模型，光这些就要 120 GB。【文中有据，ZeRO 第 8 页】Llama 3 8B 是 128 GB，比一张 H100 的 80 GB 还多。这还没算激活：每一层的前向结果要留到反向时用，按 Korthikanti 等人 2022 年的估算，一层大约要 $34\,s\,b\,d$ 字节（$s$ 是序列长度，$b$ 是每卡的序列数，使用 FlashAttention 时注意力矩阵本身不存）。8B 模型、8192 的序列、每卡 1 条，32 层是 36 GB。

四种并行各自切掉其中的一块：

• 数据并行：每张卡处理不同的数据。朴素的数据并行在每张卡上存完整的 16 字节每参数；ZeRO（以及 PyTorch 的 FSDP）把优化器状态、梯度、权重依次分摊到 $N_d$ 张卡上，第三档时每卡只剩 $16N/N_d$ 字节，代价是每步都要把权重收集回来，通信量增加一半。
• 张量并行：把每个矩阵按行或列切到几张卡上，权重和激活都按切分数缩小。每一层都要做一次全归约，通信最频繁，所以只放在一台服务器的 8 张卡里，走 NVLink。
• 流水线并行：按层切，第一组卡算前几层，交给下一组。通信只在相邻两段之间，可以跨机器；代价是气泡：第一个微批次进流水线时后面的卡在等，最后一个出流水线时前面的卡在等。
• 上下文并行：把一条长序列切成几段放在不同的卡上，注意力需要的 K 和 V 再收集起来。只在长上下文阶段打开。

拖动下图的滑块，改变模型大小，看每种方案下单卡要装多少。

图 7不同并行方案下每张卡的显存。四种颜色依次是权重、梯度、优化器状态和激活；竖线是 80 GB。模型状态按每参数 16 字节精确计算；激活按 $34\,s\,b\,d$ 每层估算（序列 8192、每卡 1 条），模型的层数和宽度按 Llama 3 的长宽比从参数量反推，所以激活一栏是示意。超出画幅的条在右端标出实际总量。

拖到 8B 可以看到，朴素数据并行已经装不下，主要是 12 字节的优化器状态；ZeRO 第一档把它分掉，就只剩激活这一大块。拖到 70B，权重和梯度本身就超过了一张卡，只能连权重一起分摊（ZeRO 第三档或 FSDP），或者用张量并行把每一层切开。拖到 405B，任何单一方案都不够，需要把四种组合起来。

Llama 3 405B 的实际配置是这样的：

Llama 3 报告表 4。

每一列都可以手算核对：$8\times1\times16\times64=8192$，$8\times16\times16\times8=16384$。三行的每批 token 数都是 16M，卡数翻倍之后数据并行组翻倍，每组分到的序列就减半，矩阵乘变小，MFU 从 43% 降到 41%；报告把这一点归因于此。长上下文那一行把 DP 从 128 砍到 8，腾出 16 倍给上下文并行。

四个维度的排列顺序是 [TP, CP, PP, DP]，从内到外，按通信需求从高到低：TP 每层通信，放在服务器内；DP（实际是 FSDP）通信最少，而且可以异步预取权重，放在最外层，跨越带宽只有 1:7 超额订阅的集群顶层网络。这套集群有 24K 张卡，每 3072 张卡组成一个内部全带宽的 pod，pod 之间带宽不足，并行配置和作业调度都按拓扑来安排，尽量不让通信跨 pod。【文中有据，Llama 3 报告第 9 至 12 页】

学习率、批大小与调度

然后是优化器的旋钮。输入是模型大小和总 token 数，输出是峰值学习率、预热长度、衰减曲线和批大小随训练的变化。三份报告给出的配方放在一起：

出处：Llama 3 报告第 14 页；DeepSeek-V3 报告第 22 至 23 页；OLMo 2 第 6 页表 3。

几个规律可以直接读出来。学习率随模型变大而变小：Llama 3 的 8B、70B、405B 依次是 $3\times10^{-4}$、$1.5\times10^{-4}$、$8\times10^{-5}$，大致和宽度成反比。批大小在训练早期较小、之后逐步增大，Llama 3 给的理由是早期小批更稳定。Llama 3 的原文在这里有一个笔误：它写的是批大小增至 8M sequences of 8,192 tokens，按字面是每批 690 亿 token，整个训练只够两百多步；按上下文应为每批 8M token、序列长 8192。用这个读法核对步数：前 252M token 每步 4M 是 63 步，到 2.87T 每步 8M 约 33 万步，余下的每步 16M 约 80 万步，合计约 115 万步，和余弦调度的 120 万步对得上。【推断，依据：第 14 页的步数和批大小】

三家在衰减方式上的分歧最有意思。Llama 3 用的是经典的余弦，衰减的长度必须事先定好，Chinchilla 的附录发现余弦周期比实际训练长出 25% 以上，损失就明显变差。DeepSeek-V3 和 OLMo 2 都偏离了这个做法：一个是长时间保持常数、最后再降，一个是余弦中途截断、最后线性降到 0。它们都是 WSD（warmup-stable-decay）这一类调度的变体。

WSD 的想法来自 MiniCPM：预热之后长时间保持常数学习率，只在最后一小段衰减。他们发现衰减段只需要总 token 数的 10% 左右，而且损失会在衰减段里突然下降一大截。Hägele 等人系统比较后发现，常数学习率加上占 20% 步数的衰减就能追平余弦，衰减形状用 $1-\sqrt{t}$ 比线性还略好。【文中有据，MiniCPM 第 5 至 6 页、图 5；Hägele et al. 第 4 至 5 页】

这类调度真正的价值不在最终损失，而在于它改变了实验的组织方式。余弦调度下，想知道训 1T、2T、4T token 各是什么效果，需要三次独立的训练。WSD 下只需要一次常数学习率的长训练，在 1T、2T、4T 处各存一个检查点，从每个检查点分出去做一次短的衰减即可，衰减只占 10% 到 20% 的算力。对一个要外推的团队来说，这等于用一次训练的价钱得到一整条缩放曲线。旗舰模型自己也受益：没有人能事先确定要训多少 token，常数段可以一直延长，等数据和时间都确定了再衰减。

衰减段为什么会让损失突然下降？一个常用的图景是：常数学习率时，参数在损失面的一条山谷里沿谷底前进，同时在两侧谷壁之间来回振荡，振荡的幅度和学习率成正比，这部分振荡在损失里表现为一个高出谷底的平台。学习率一降，振荡收缩，参数落回谷底，损失立刻掉下来；而沿谷底前进的进度，在常数段已经积累好了。这个图景解释了为什么衰减段不需要很长。

换掉 Adam 的 Muon

上面三份配方用的都是 AdamW，这是 2017 年以来几乎没人动过的默认值。2025 年第一个在万亿参数上动它的是 Kimi K2，用的是 Muon。

两者的差别在于怎么看一个权重矩阵的梯度。Adam 把矩阵里的每个元素当作独立的数，各自按历史梯度的大小缩放。Muon 把整个梯度矩阵当作一个整体：先算动量，再把动量矩阵正交化，也就是保留它的方向结构、把所有奇异值拉到同一个大小，然后用这个矩阵去更新权重。直观地说，Adam 更新时会让少数几个强势方向占满整个更新，Muon 让每个方向都走一样远。Moonshot 此前的实验表明，同样的算力下 Muon 能把损失降得更低，也就是每个 token 学到的更多。在高质量数据越来越紧的时候，这正是他们想要的。【文中有据，Kimi K2 报告第 2 至 3 页】

问题在规模放大时出现。他们用原版 Muon 训一个激活 9B、总参数 53B 的 MoE，注意力 logit 的最大值很快超过 1000，这已经足以导致数值不稳甚至发散。补丁叫 QK-Clip：每一步更新之后，检查每个注意力头在这一批里出现过的最大 logit $S_{\max}^h$，超过阈值 $\tau$ 就把这个头的查询和键投影矩阵按 $\gamma_h=\min(1,\tau/S_{\max}^h)$ 缩回去，查询和键各分一半（各乘 $\sqrt{\gamma_h}$）。它不改动当前这一步的前向和反向，只是在权重变大之后把它压回来，而且只压那几个出问题的头。K2 用 $\tau=100$，整个 15.5T token 的预训练里没有出现一次损失尖峰；最大 logit 在训练开始后很快涨到 100 并被压住，大约训练到 30% 之后自己回落到正常范围，阈值从头到尾没有调过。【文中有据，Kimi K2 报告第 4 页、图 2 和图 3】

和上一节 OLMo 2 的 QK 归一化比，两者治的是同一种病：查询和键的点积无限增大。QK 归一化是在每次前向时把查询和键的尺度固定住，属于结构改动；QK-Clip 是盯住结果、超标了再动权重，结构不变。后者的好处是对 MLA 这类把键压缩成潜在向量的结构也能用，而在 MLA 上做 QK 归一化很别扭，因为键在推理时并不完整地存在。【推断，依据：K2 报告对 MLA 各分量分别裁剪的说明】

开跑之后的故障与尖峰

开训之后要准备的不是一个决定，而是一套应对规程：坏了怎么办，损失突然跳起来怎么办。

平均三小时一次中断

Llama 3 报告里有一张表，记录了 405B 预训练期间一段 54 天里的全部 466 次中断。其中 47 次是计划内的（固件升级、配置变更、数据集更新），419 次是意外。按类别：

Llama 3 报告第 13 页表 5，合并了最后十个小类。最后一列是本文用各行次数除以 419 重算的结果。

表里的次数加起来正好是 419，百分比加起来却只有 94.9%。差在第一行：148 除以 419 是 35.3%，不是表里写的 30.1%。正文说 GPU 问题占全部意外中断的 58.7%，这个数是用 30.1% 加其他 GPU 类别得到的，按次数重算应该是 64.0%。结论的方向不变，GPU 仍然是最大的故障源，只是比报告说的更大。【文中有据，表 5；重算是本文的】

拿这张表做一次手算。419 次意外中断分摊在 54 天里，平均每 3.1 小时一次。集群有 16384 张卡，摊到每张卡上，平均无故障时间是 $16384\times54\times24/419\approx5.1$ 万小时，接近 6 年。单张卡 6 年坏一次，听起来很可靠；一万六千张卡同步训练，任何一张坏了整个作业都要停，就变成了三小时一次。这是同步训练的根本脆弱性，也是规模继续扩大时最先碰到的墙。

每次中断要付三笔账：从上一个检查点到故障时刻之间的计算要重做；重启作业、重新加载检查点要花时间；平时写检查点本身也要暂停训练。检查点写得越勤，重做的越少，但写检查点的开销越多。设写一次检查点的停顿是 $\delta$，平均故障间隔是 $M$，检查点间隔是 $\tau$，浪费掉的时间比例大约是：

$$\text{浪费}\approx\frac{\delta}{\tau}+\frac{\tau}{2M}+\frac{R}{M}$$

第一项是写检查点，第二项是平均重做半个间隔，第三项 $R$ 是每次重启的固定开销。对 $\tau$ 求最小值，得到 $\tau^*=\sqrt{2\delta M}$，这是 Young 在 1974 年给出的公式。拖动下图的滑块改变卡数，看最优间隔和浪费比例怎么变。

图 8检查点间隔与浪费比例。单卡的故障率取 Llama 3 表 5 的实测值（每卡约 5.1 万小时一次）；写检查点的停顿 $\delta$ 取 20 秒，重启开销 $R$ 取 6 分钟，这两个数报告没有给，是示意，取值依据见正文。橙红曲线是总浪费，三条灰线是它的三项，橙色点是最优间隔。

$\delta$ 和 $R$ 怎么取：报告说每张卡的检查点是 1 MB 到 4 GB，存储系统持续写入 2 TB/s、峰值 7 TB/s；405B 的全部训练状态按 16 字节每参数约 6.5 TB，按持续带宽 3 秒多就能写完，加上同步和校验，取 20 秒是宽松的。报告还说有效训练时间超过 90%；在三小时一次故障的条件下，前两项在最优间隔处合计约 6%，浪费不超过 10% 就要求 $R/M$ 小于 4%，倒推 $R$ 最多七八分钟。【推断，依据：Llama 3 报告第 8 至 9 页、第 13 页】

滑块拖到 16K 卡，最优间隔约 11 分钟，总浪费约 9%，和报告的 90% 以上有效时间吻合。拖到 128K 卡，故障间隔缩到 23 分钟，即使检查点间隔优化到最好，浪费也有 43%，其中六成来自重启。所以重启开销 $R$ 是比检查点频率更关键的量：报告里专门写了他们缩短了作业启动和写检查点的时间，并开发了快速诊断工具；466 次中断里只有 3 次需要显著的人工介入，其余都由自动化处理。【文中有据，第 13 页】

同一页还有几个只有在这个规模上才会出现的现象：一天之中吞吐会随气温波动 1% 到 2%，因为中午温度高，GPU 的动态调频降频；几万张卡同时等待检查点或通信时功耗同时下降，同时恢复时又同时上升，整个数据中心的功率在几十兆瓦的量级上摆动，已经在挑战电网的承受能力。还有一种更难查的故障：一张卡没有坏，只是变慢了，它会拖慢同步训练里所有的卡。

损失尖峰

另一类故障来自训练本身。OLMo 2 的报告详细描述了它的前一个版本 OLMo-0424 遇到的症状：损失突然跳起，更常见的是梯度范数突然跳起，而且梯度范数的大幅跳动往往发生在损失跳动之前；模型越大，尖峰越频繁；同时梯度范数在整个训练中缓慢增长，增长越多，尖峰越频繁。这些问题叠在一起，最终导致发散，更大的模型根本训不下去。【文中有据，OLMo 2 第 10 页】

他们最后改了八处：

• 数据：删掉含有 32 次以上重复 n-gram 的文档（n 从 1 到 13 个 token），训练器在读数据时再检查一遍，把这类片段的损失屏蔽掉；
• 初始化：从按层缩放的初始化改成所有参数都用均值 0、标准差 0.02 的正态分布；
• 归一化：从无参数的 LayerNorm 换成 RMSNorm；
• 归一化的位置：从对注意力和前馈层的输入归一化，改成对它们的输出归一化后再加回残差；
• QK 归一化：计算注意力之前，对查询和键的投影各做一次 RMSNorm；
• z-loss：给输出 logit 的对数配分函数加一个正则项，防止 logit 无限增长；
• 嵌入层不做权重衰减；
• AdamW 的 $\epsilon$ 从 $10^{-5}$ 降到 $10^{-8}$。

重复 n-gram 那一条最具体。报告给了三个触发尖峰的样本，一个是 g4ODg4ODg4OD 无限重复的 base64 片段，一个是一长串 667, 667, 667，一个是一长串 255, 255, 255。这种片段让模型在很多位置上做出极其自信的预测，梯度集中在少数方向上。但报告也说得很谨慎：同一段重复序列在大模型上触发尖峰、在小模型上不触发；换一种数据顺序就不触发；同样的序列在其他没有尖峰的批次里也出现过。过滤之后尖峰明显减少，但没有消失，而且对梯度范数的缓慢增长没有作用。【文中有据，OLMo 2 第 12 至 13 页、图 3】

注意力 logit 的增长是另一个已知的来源。Wortsman 等人证明它可以在小模型上复现：把学习率调高，一个很小的 Transformer 就会出现注意力 logit 无限增大、注意力权重退化成独热分布的现象，和大模型上报告的一模一样。QK 归一化和系数 $10^{-4}$ 的 z-loss 能让同一个小模型在跨三个数量级的学习率上都训练成功。【文中有据，Wortsman et al. 第 1 至 3 页】这又是本文的主题：一个只在大模型上出现的问题，一旦能在小模型上用调高学习率的办法复现，就可以在小模型上便宜地筛选补丁。

收尾的长上下文、退火与权重平均

预训练的最后几个百分点，三家报告都单独拿出来讲。输入是一个已经训了十几万亿 token 的模型，输出是一个能读长文、在高质量数据上收过尾的基座模型。

长上下文放在最后的原因是算力：注意力的计算量随序列长度平方增长，从一开始就用 128K 的序列训练，代价不可接受。Llama 3 在预训练的最后阶段，分六步把上下文从 8K 加到 128K，这一段共用了约 800B token。每加长一步，要等两个条件都满足才进入下一步：短上下文的评测分数完全恢复，以及在当前长度上完美通过大海捞针测试（在一长段无关文本里埋一句话，问模型这句话的内容）。【文中有据，Llama 3 报告第 14 页】DeepSeek-V3 的做法更省：预训练用 4K 序列，结束后用 YaRN 调整位置编码，再做两段各 1000 步的训练，先到 32K、再到 128K，合计 11.9 万卡时，是预训练的 4.5%。【文中有据，DeepSeek-V3 报告第 23 页、表 1】

之后是退火。Llama 3 报告写的是：在最后 40M token 上把学习率线性降到 0，上下文保持 128K，同时上采样质量很高的数据源，最后把退火过程中的若干个检查点做平均（Polyak 平均），作为最终的预训练模型。这里的 40M 很可疑。此时的批大小是每步 16M token，40M token 只够两步半，在两步半里线性降到 0 没有意义；同一份报告在数据一节用退火评估数据质量时，用的是 40B token。我认为这里是 40B 的笔误，但报告没有给出可以核对的其他数字。【推断，依据：第 6 页与第 14 至 15 页】

权重平均是收尾里最便宜的一步。OLMo 2 7B 把 50B token 的中期训练按不同的数据顺序跑三遍，平均三组权重；13B 和 32B 是三次 100B 加一次 300B，四组平均。【文中有据，OLMo 2 第 7 页】几个从同一起点出发、只是数据顺序不同的模型，停在了同一个低谷的不同位置上，平均之后更靠近谷底的中心。代价是收尾段的算力乘以份数，换来的是一个更平稳的最终模型，以及对数据顺序这个随机因素的一次平滑。

看图和看视频的两条路线

到这里为止讲的都是文字。2025 年的旗舰模型几乎都能看图，很多能看视频，Gemini 还能直接听视频里的声音。这一步在流程里的位置，取决于走哪条路线，而两条路线的差别比通常说的要细。

一种常见的说法是：Gemini 是原生多模态，能直接理解视频；其他模型是在语言模型上外挂一个视觉编码器，只能抽几帧当图片看。这个说法抓住了一半。先说它不准的那一半：两条路线都在抽帧，也都要把像素变成 token。没有哪个模型把每秒 30 帧的原始视频完整地喂进去，那样一小时的视频就是几千万个 token。差别在别处。

图 9两条路线的数据流。上面一行是外挂式，以 Qwen3-VL 为例：图像和视频帧先过一个单独预训练好的 ViT，经过一个小的投影层（merger）变成语言模型能接收的 token，视频的时间写成文字形式的时间戳。下面一行是原生式，以 Gemini 为例：文字、图像、音频、视频在预训练一开始就交错放进同一个模型。

外挂式的代表是 Qwen3-VL。它的三个部件各有来历：视觉编码器是现成的 SigLIP-2（4 亿参数那一档），语言模型是已经训好的 Qwen3，中间是一个 MLP 投影层。训练分四段：第一段冻住其他所有部分，只训投影层，让视觉 token 先对得上语言模型的输入空间；之后才放开全部参数，上下文依次加到 8K、32K、256K。视频按每秒一到两帧左右抽取（评测时多数用 2 fps），每一组帧前面插一段文字时间戳，比如 <3.0 seconds>。它还把 ViT 中间几层的特征也送进语言模型的多个层（DeepStack），让语言模型同时看到粗和细两个层级的视觉信息。【文中有据，Qwen3-VL 报告第 2 至 4 页、第 9 页】

原生式的代表是 Gemini。报告的说法是 Gemini 2.X 系列从一开始就按原生多模态构建，文字、图像、音频、视频在预训练里同时出现。【文中有据，Gemini 2.5 报告第 1 至 2 页】Gemini 同样要抽帧，同样把每一帧变成一组 token。它和外挂式真正的区别有三处。一是时间：几种模态从预训练的第一步就在同一个模型里交错出现，模型学到的是它们之间的对应关系，而不是在一个已经定型的语言模型上补学视觉。二是声音：视频的音轨也变成 token，和画面按时间对齐地放在一起，所以它能回答画面里没有、只在声音里出现的问题；大多数外挂式的视觉语言模型只看画面。三是预算：同样的上下文能装多长的视频，完全取决于每帧和每秒音频各要多少 token。

第三点可以手算。Gemini 的公开文档给的是每秒抽 1 帧，每帧 258 个 token，音频每秒 32 个 token，合计每秒视频 290 个 token。100 万 token 的上下文装得下 $10^6/290\approx3448$ 秒，约 0.96 小时。Gemini 2.5 报告说，他们训练模型在每帧只用 66 个 token 时也能保持竞争力，于是同样的上下文从大约 1 小时变成大约 3 小时：$10^6/(66+32)\approx10204$ 秒，2.8 小时。【文中有据，Gemini 2.5 报告第 8 页；每帧和音频的 token 数出自 Gemini API 文档；换算是本文的】拖动下图的滑块，改变每帧的 token 数，看一百万 token 能装多少分钟。

图 10一百万 token 的上下文能装下的视频时长，横轴是每秒抽几帧。橙色是带音轨（每秒 32 个 token），蓝色是只有画面。滑块改的是每帧的 token 数；258 和 66 是 Gemini 2.5 报告里的两个取值。

拖到 66 再沿横轴往右看，就能看到抽帧率和每帧精度之间的交换：每帧 token 少了，就能每秒多抽几帧，看清快速的动作；每帧 token 多了，就能看清画面里的小字。两种路线都在这条曲线上选点。外挂式模型多看画面、少看时间的选择，部分是这个预算逼出来的，部分是因为它的语言模型在接上视觉之前已经定型，后补的视觉能力受限于投影层和后续训练能搬动多少。【推断】

从续写到回答的后训练

预训练出来的模型只会续写：给它一个问题，它可能接着写出十个类似的问题。把续写变成回答，是后训练的事。一年前，这一步的算力在预训练面前还是零头：DeepSeek-V3 的后训练只用了 5000 个卡时，占总量的 0.2%。【文中有据，DeepSeek-V3 报告表 1】到 DeepSeek-V3.2，这个比例超过了 10%。中间发生的事情，按出现的顺序讲。

监督微调

最直接的办法是给模型看问答对，只在回答部分计算交叉熵，提示部分的损失屏蔽掉。InstructGPT 第一次把这个流程公开得很完整：40 名标注员，监督微调用了约 1.3 万条提示，奖励模型 3.3 万条，强化学习 3.1 万条。结果是 1.3B 参数的 InstructGPT 在标注员的偏好评测里胜过了 175B 的 GPT-3，参数少一百多倍；175B 的 InstructGPT 有 85% 的时候比 175B 的 GPT-3 更受偏好（上下浮动 3%）。【文中有据，InstructGPT 第 1 至 3 页、第 7 页】

这个结果后来被反复验证，含义很清楚：预训练模型已经具备回答的能力，后训练做的是把它调出来，而不是教给它。到了 Llama 3，监督微调的数据大部分已经不是人写的：对每条人工收集的提示，用当前最好的模型采样 10 到 30 个回答，用奖励模型挑出最好的一个，这叫拒绝采样；再加上针对代码、数学、工具调用等能力专门合成的数据。405B 的微调学习率 $10^{-5}$，8500 到 9000 步。报告自己也说，虽然叫监督微调，很多训练目标其实是模型生成的。【文中有据，Llama 3 报告第 16 至 18 页】Tülu 3 公开了完整的微调数据，共 939,344 条。【文中有据，Tülu 3 第 12 页表 7】

奖励模型与 DPO

监督微调只告诉模型什么是对的，不告诉它两个都还可以的回答里哪个更好。偏好数据补的是这一块：对同一个提示给出两个回答，标注员选一个。Llama 3 的标注员还要标出偏好的强度（明显更好、更好、略好、差不多），并且可以再编辑一遍选中的回答，于是有些样本有三个排好序的回答：编辑过的、选中的、被拒的。训练时只用明显更好和更好这两档，相近的样本丢掉。【文中有据，Llama 3 报告第 16 至 17 页】

InstructGPT 的做法是先用偏好数据训一个奖励模型，再用 PPO 让语言模型去最大化这个奖励。PPO 要同时在显存里放策略模型、参考模型、奖励模型和价值模型，对 405B 来说代价很高。Llama 3 最后选了 DPO（直接偏好优化），它把奖励模型和强化学习合成一个类似分类的损失：提高被选中回答相对参考模型的对数概率，降低被拒回答的。报告说试过 PPO，DPO 在大模型上算力更省，而且在指令遵循的评测上表现更好。超参数是学习率 $10^{-5}$、$\beta=0.1$。【文中有据，Llama 3 报告第 16 页】

报告里两处对 DPO 的修改很能说明第一版会怎么坏。第一处：对话格式里的特殊 token（标记说话人、标记一轮结束）同时出现在选中和被拒的回答里，DPO 要同时提高和降低它们的概率，结果模型学会了在结尾不停重复，或者突然输出结束符。补丁是把这些格式 token 从 DPO 损失里屏蔽掉。第二处：DPO 只管两个回答的相对概率，选中回答本身的概率可能一起下降，格式就开始走样。补丁是对选中的回答额外加一个系数 0.2 的负对数似然项。整个流程（奖励模型、拒绝采样、微调、DPO）一共做了六轮，每一轮用上一轮最好的模型重新采样、重新收集偏好。【文中有据，Llama 3 报告第 16 至 17 页】

可验证奖励与 GRPO

数学题和代码题有一个特殊的性质：答案对不对可以由程序判断，不需要人，也不需要奖励模型。Tülu 3 把这类训练叫作带可验证奖励的强化学习（RLVR）：答案能被验证为正确就给奖励 10，否则给 0，用 PPO 训练，用了约 3 万条带标准答案的提示。【文中有据，Tülu 3 第 31 至 32 页】

DeepSeek-R1-Zero 把这条路走到了头：不做任何监督微调，直接在 DeepSeek-V3 的基座上用规则奖励做强化学习。算法是 GRPO，它去掉了 PPO 里的价值模型，改用同一道题的一组回答互相比较。每道题采样 $G=16$ 个回答，每个回答的奖励 $r_i$ 减去这一组的均值、除以这一组的标准差，就是它的优势：

$$A_i=\frac{r_i-\mathrm{mean}(r_1,\dots,r_G)}{\mathrm{std}(r_1,\dots,r_G)}$$

优势为正的回答，其中每个 token 的概率被推高；为负的被压低。奖励只有对错两种时，这个式子有一个直接的后果。拖动下图的滑块，改变 16 个回答里答对的个数。

图 11一道题 16 个回答的 GRPO 优势。绿色是答对的回答，橙红是答错的；条的高度是优势 $A_i$。读数行里的信号总量是 16 个优势绝对值之和，它决定了这道题对这一步梯度的贡献有多大。

全对或全错的时候，所有回答的奖励一样，标准差为 0，优势全是 0：这道题对训练没有任何贡献。只答对 1 个时，那个答对的回答优势是 3.87，15 个答错的各是 $-0.26$，一次罕见的成功被放大了十几倍。信号总量在答对一半时最大，等于 $32\sqrt{p(1-p)}$，$p$ 是答对的比例。所以 GRPO 训练的效率取决于题目难度的分布：太简单和太难的题都是白算，最有用的是模型现在答对一半左右的题。这也是为什么这类训练普遍要按当前模型的通过率筛选题目。【推断，依据：公式本身】

R1-Zero 的数字：学习率 $3\times10^{-6}$，KL 系数 0.001，每步 32 道题、每题 16 个回答，最大长度在第 8200 步之前是 32,768 个 token，之后放宽到 65,536，共训 10,400 步。AIME 2024 上的平均单次通过率从 15.6% 升到 77.9%，16 次投票后是 86.7%。回答长度在训练中自发变长，模型开始在回答里检查和推翻自己之前的推理。【文中有据，DeepSeek-R1 v2 第 3 至 5 页】

强化学习的预算与缩放曲线

R1 证明了可验证奖励的强化学习能把推理能力推得很远，接下来的问题就和预训练一样：该花多少算力，花下去会涨多少。2025 年 10 月的 ScaleRL 是第一个系统回答这个问题的工作。他们发现强化学习的表现和算力之间不是幂律，而是一条会饱和的 S 形曲线：

$$R_C-R_0=(A-R_0)\cdot\frac{1}{1+(C_{\text{mid}}/C)^{B}}$$

$R_C$ 是花了算力 $C$ 之后在验证集上的通过率，$R_0$ 是起点，$A$ 是这条曲线最终能到的上限，$B$ 管爬得多快，$C_{\text{mid}}$ 是爬到一半时的算力。这个式子把一个强化学习配方拆成两个可以分开比较的量：天花板 $A$ 和效率 $B$。他们扫了大量常见的设计选择，结论是：损失怎么聚合、优势怎么归一化、课程怎么排、用哪种离策略算法，这些主要改变效率，几乎不动天花板；真正抬高天花板的是更大的模型等少数几项。他们用这条曲线把一次 8B 模型的训练外推到 10 万 GPU 小时，最终结果落在曲线上。【文中有据，ScaleRL 第 1 至 3 页】

这对团队的意义和 isoFLOP 曲线一样：一个新的强化学习技巧，在小预算上看起来涨得快，可能只是 $B$ 大，天花板并不更高；要判断它值不值得放进旗舰模型的配方，就要把曲线拟合出来，看 $A$。

算力加上去之后，钱花在了哪里？DeepSeek-V3.2 的后训练分两步。先在六个领域各训一个专家模型：数学、编程、一般逻辑推理、一般智能体任务、智能体编程、智能体搜索，每个都从同一个基座出发、各自做大规模强化学习；再把这些专家的输出蒸馏回一个模型，之后在混合数据上继续做几千步强化学习。为了智能体任务，他们合成了 1800 多个不同的环境和 85,000 个复杂提示。【文中有据，DeepSeek-V3.2 报告第 2 页、第 5 至 6 页】Kimi K2 为工具调用合成了两万多个工具。【文中有据，Kimi K2 报告第 9 至 10 页】Qwen3 则把会思考和不思考两种模式合进一个模型，用户可以设一个思考预算，控制它在回答前想多久；小模型不单独做强化学习，而是从大模型做强到弱的蒸馏。【文中有据，Qwen3 报告第 1 至 2 页】

把这些放在一起看，后训练在 2025 年变成了一个工程问题：瓶颈从算法转到了环境和奖励。谁能造出更多可以自动判对错的任务，谁的强化学习就能继续往上爬。

渲染出来再打分

可验证奖励最自然的领域是数学和代码：答案对不对、测试过不过。但很多用户在意的能力看上去没法自动判分，比如画一张 SVG 插图，写一段好看的网页动画。2025 年这类能力在几家前沿模型上都跳了一大截，有的模型画出的 SVG 已经可以直接拿来用。这些公司都没有公开具体做法，但公开的研究给出了一条清楚的路：把代码渲染出来，再对渲染结果打分。

NeurIPS 2025 的 RLRF（Reinforcement Learning from Rendering Feedback）是一个具体的例子。任务是给一张图，生成能画出它的 SVG 代码。监督微调的模型从来没见过自己写的代码画出来是什么样，所以经常写出不忠实或者冗长的代码。RLRF 让模型对同一张图采样若干份 SVG，每份都渲染成位图，和原图比较：像素层面像不像，语义层面像不像（用一个视觉模型判断），代码是否简洁（和参考代码的长度差），三项合成奖励，再用强化学习更新。渲染这一步不可求导，正好用强化学习绕过去。结果明显好于只做监督微调。【文中有据，Rodriguez et al. 2025，arXiv 2505.20793，摘要与第 3 节】

把这个思路推广：凡是输出能被执行或渲染的任务，网页、图表、动画、游戏、排版，都可以造出一个运行环境加一个视觉评审，让模型在里面反复试。评审可以是像素指标，也可以是另一个多模态模型给出的分数或两两比较。我的判断是，前沿模型在 SVG 和前端动画上的突然进步，主要来自这类环境被大规模造出来之后的强化学习，而不是预训练里多加了几份 SVG 文件。【猜测，依据：公开研究的方向和能力出现的时间；相关公司没有披露细节】这类奖励的风险也一样清楚：视觉评审有自己的偏好，比如偏爱饱和的颜色、居中的构图，模型会学会迎合评审，而不是迎合用户。

说人话

后训练还决定了一件所有用户每天都在感受的事：模型说话的腔调。有一类文字一看就是模型写的，喜欢用某些词，喜欢某些句式，比如先否定一个没人提过的说法再给出自己的说法，每段都以总结收尾，三个形容词并排出现。这不是错觉，可以测量。

Kobak 等人统计了 2010 年到 2024 年的 1500 多万篇 PubMed 摘要，找那些在 ChatGPT 出现之后用量突然飙升的风格词（delves 是最有名的一个），估计 2024 年至少 13.5% 的生物医学摘要经过了大模型处理，某些子领域高达 40%。这个词汇冲击比新冠疫情对学术语言的影响还大。【文中有据，Kobak et al.，Science Advances 2025】2025 年的 Antislop 论文直接对模型输出做了同样的统计：拿模型生成的文本和人写的文本比较，有些套路在模型输出里出现的频率是人类文本的一千倍以上，比如不只是 X，而是 Y这种句式。【文中有据，Paech et al.，arXiv 2510.15061，摘要】

腔调从哪里来？预训练语料里这些词并不特别多，所以它主要是后训练的产物。偏好标注和奖励模型会奖励一些表面特征，比如显得周到、显得有条理、显得热情。强化学习把输出分布往高奖励的方向压，压得越狠，分布越窄，这些被奖励的表面特征就越集中地重复出现。再往下一代，这些带着口头禅的输出又被用作合成数据（上一节讲的改写和蒸馏），口头禅就被继承了下来。【推断】

2025 年 4 月，OpenAI 的一次更新把这个机制暴露得很清楚。4 月 25 日推送的 GPT-4o 变得明显谄媚：不只是恭维，还会附和用户的疑虑、助长怒气、怂恿冲动的决定。4 月 28 日开始回滚。事后的复盘说，这次更新加入了一个基于 ChatGPT 用户点赞和点踩的额外奖励信号，它单独看是有用的，但几项改动叠在一起，削弱了原本压住谄媚的主奖励信号，而用户反馈本身就会偏爱更顺耳的回答。他们在发布前没有专门测试谄媚。【文中有据，OpenAI，Expanding on what we missed with sycophancy，2025 年 5 月】一个点赞按钮，就足以通过强化学习改掉一个模型的性格。

怎么让模型说人话，目前有三种做法，处在不同的层级。

• 在词和句式的层级上压。Antislop 先把一个模型相对人类文本过度使用的模式找出来，再用一种只在单个 token 上做偏好优化的方法（FTPO）训练：在模型即将写出某个套路的那个位置，把概率从套路词挪到其他合理的词上。报告的结果是套路减少 90%，GSM8K、MMLU 和创意写作的表现不降；用普通的 DPO 做同样的事，压得不如它干净，写作质量和用词多样性反而明显下降。【文中有据，Antislop 摘要】
• 在原则的层级上讲清楚。Anthropic 在 2026 年 1 月发布的新版 Claude 宪章，不再是一张原则清单，而是一份解释模型应该是什么样、为什么这样的长文档。它在训练中直接起作用：模型用它生成合成训练数据，包括符合这些价值的回答和对候选回答的排序。【文中有据，Anthropic，Claude's new constitution，2026 年 1 月】说话方式在这里是性格的一部分：不讨好、不注水、直接说结论、不确定就说不确定，这些要求写成理由之后，比写成禁用词表更能泛化到没见过的场合。
• 在评审的层级上换标准。如果奖励模型和标注员本身偏爱长、热情、有条理的回答，前两层做得再好也会被强化学习慢慢冲掉。所以评测里要单独测谄媚和啰嗦，这正是 OpenAI 那次事故之后补上的环节。

这三层对应的失效各不一样。只在词上压，模型会换一批同义的套话；只讲原则，模型可能在长对话里慢慢滑回去；只改评审，又很难覆盖所有场景。本页的写作规范其实就是这三层的一个小样本：有一张禁用词表，有一套关于为什么要直说的理由，还有一份交付前的自查清单。

评测与涌现之争

最后要回答的是怎么判断训出来的模型好不好，以及它在更大的规模上会怎样。这里有一个持续了几年的争论，直接关系到本文的主题：如果能力会在某个规模上突然出现，那么小模型的实验就预测不了大模型，整套外推的方法就失效了。

Wei 等人 2022 年把这种现象定义为涌现能力：小模型上不存在、大模型上存在，因而不能通过外推小模型的表现来预测。他们收集了一批例子，比如 GPT-3 在三位数加减法上，训练算力到 $2\times10^{22}$ FLOPs（13B 参数）之前一直接近随机，之后突然远高于随机；MMLU 上，GPT-3、Gopher、Chinchilla 都要到 $10^{22}$ FLOPs（约 10B 参数）附近才明显高于随机。【文中有据，Wei et al. 第 3 至 4 页、图 2】

Schaeffer 等人 2023 年指出，这些突变几乎都出现在两种评分方式下：多选题的正确率，和要求输出与答案逐字一致的精确匹配，两者合计占了 BIG-Bench 上声称的涌现能力的 92% 以上。他们的论证可以写成一个式子。设模型每个 token 预测正确的概率 $p(N)$ 随参数量平滑上升，一道题的答案有 $L$ 个 token，精确匹配要求每个都对：

$$\text{准确率}(N)\approx p(N)^{L}$$

拖动滑块改变答案长度 $L$。

图 12同一个平滑提升的模型族，在不同评分方式下的样子。绿色细线是每个 token 的正确率 $p(N)$，按 Schaeffer 等人的形式 $p=\exp(-(N/c)^{\alpha})$ 取一组示意参数；橙色粗线是长度为 $L$ 的答案的精确匹配率；灰色水平线是 100 道题的测试集能分辨的最小准确率。

$L=1$ 时，两条线重合，提升是平滑的。$L$ 增大，精确匹配的曲线整体右移，并且变得越来越陡：在对数横轴上，它从贴着零到接近满分只跨了一个多数量级。再加上测试集的分辨率，100 道题时低于 1% 的准确率就是 0，曲线左侧被抹平成一条贴地的直线，突变看起来就更突然了。Schaeffer 等人在 InstructGPT 和 GPT-3 上验证了这一点：同样的模型输出，把评分换成按 token 计的编辑距离，突变就消失了；为小模型生成更多测试题，也能看到它们的准确率其实高于随机。【文中有据，Schaeffer et al. 第 3 至 6 页】

这场争论该信到什么程度？我的判断是：Schaeffer 的论证说明了突变的形状很大程度上是评分方式造成的，但没有说明准确率不能突变。用户关心的恰恰常常是精确匹配：代码能不能跑通，证明对不对，数学题的最终答案对不对。对这些任务，能力确实会在某个规模上跨过可用的门槛。要紧的是，这个门槛可以预测。Llama 3 的两步法就是这样做的：先预测平滑的负对数似然，再用一条 S 形曲线把负对数似然映射成准确率，跨四个数量级预测了 ARC-Challenge 的成绩。【文中有据，Llama 3 报告第 8 页、图 4】所以对外推方法的正确结论是：外推连续的量，再把连续的量转成离散的指标；不要直接外推离散的指标。

从第一个小实验到发布的一条时间线

把前面各节按真正发生的顺序串起来。下面是一个基座模型团队可能的推进方式，大部分是从报告里的细节推断出来的，每一步标出依据。

这条时间线里，旗舰模型本身只出现在第五步之后。前四步决定了它会是什么样子，而前四步花掉的算力加起来不到它的百分之一。DeepSeek-V3 报告那句不含此前的研究和消融实验的说明，指的就是这些。它们不贵，但它们是决定性的。

可以带走的两个想法

第一个想法是口径。本文里出过问题的地方，几乎都不是方法错了，而是两个实验没有在同一个口径下比较：参数算不算嵌入，计算量算不算输出层，预热按步数还是按比例，指数写两位还是四位小数，token 用哪个分词器计数，污染用多长的 n-gram 判断。每一个在单次实验里都无关紧要，放进跨越六个数量级的外推里就成了几十倍的误差。读任何一份缩放律报告，先把这些口径列出来，再看结论。

第二个想法是把大问题缩小。损失尖峰、注意力 logit 的增长、数据配比的效果、分词器的好坏，这些看起来只有在大模型上才有意义的问题，都被人找到了在小模型上复现它们的办法：调高学习率，用退火给数据估价，用 1B 模型对比分词器。一个问题一旦能在小模型上复现，就能用小模型的价钱去试几十种补丁。一个团队的研究能力，很大程度上就是把大问题缩小的能力。

留下来值得做的问题至少有四个。一是下游任务的缩放律：负对数似然可以外推，但从负对数似然到准确率的那条 S 形曲线，目前还要靠旧模型来标定，换一个任务、换一种数据就要重新标定。二是数据质量的度量：现在判断一份数据好不好，仍然要训一个模型来看，便宜的、不用训练的质量指标还没有可靠的。三是规模继续扩大时的可靠性：按图 8 的算法，十几万张卡的同步训练会把一半的时间浪费在故障上，需要不要求所有卡同步的训练方式。四是强化学习之外的奖励：数学和代码可以自动判对错，渲染类任务可以用视觉评审，但写作、建议、陪伴这些用户最常用的场景，奖励仍然来自偏好，而偏好会把模型推向讨好和套话。怎样给说得好造一个不被钻空子的奖励，是后训练里最没有解决的问题。

资料与时间

本文引用的报告按时间分三组。数字都追到了下面这些原文的页码、表号或图号；没有公开的内容在正文里标了推断或猜测。