Where Training Data Comes From: Synthesis, Verification, and Distillation Across the Training Stack (中文版)

目录

• 每一个数据问题，其实都是同一个问题
• 一套能撑过全部六个阶段的词汇
• 三种监督来源
• 合成手册
  • 八种模式
  • 多样性才是那个紧约束
• 验证阶梯
  • 两类错误并不对称
  • Grounding 胜过精巧
• Pre-training：过滤就是产品
  • 数据墙，以及重复能买到什么
  • 崩塌是协议层面的 bug
  • 为什么混合比例实验会骗人
• Mid-training：没人写下来的那个阶段
  • Continual pre-training 的机制
  • 知识注入：认得出不等于答得出
  • 长 context 数据是制造出来的
  • 把 mid-training 当作 RL 的准备
• SFT：一道就绪闸门，而不是能力来源
• RL 数据是 prompt，不是答案
• Agent 层面的数据：environment、任务、rubric、trajectory
  • Environment 优先，任务针对它铸造
  • 在你花掉一次 rollout 之前就该跑完的闸门
  • Trajectory 是错误的采集单位，却是正确的过滤单位
  • Rubric，以及它失败的两种方式
• 把 distillation 当作一种数据获取策略
  • 按 access tier 划分，你能拿到什么
  • 容量差距（capacity gap）
  • 一份 playbook：小模型，强 teacher
  • 蒸馏语料的卫生守则
• Contamination：你的评测集也是流水线的一部分
  • 检测是群体统计量，而不是判决书
  • 语料过滤器看不见的那些通道
  • 评测完整性是一种系统属性
• 数据平台
• 决策指南
• 开放问题
• 附录：面试问题
  • 框架
  • Pre-training
  • Mid-training 与 continual pre-training
  • SFT
  • RL 与 agentic RL
  • 蒸馏
  • 评测与 contamination
• 如何引用
• 参考文献

每一个数据问题，其实都是同一个问题

去问三家实验室他们是怎么训模型的，你会拿到三份在架构上大同小异的回答，和三份在数据上闪烁其词的回答。技术报告只会说「一份多样化的公开与授权来源混合语料」，给你一个 token 数，然后就翻篇了。这种不对称本身就很说明问题：已经商品化的部分会被写进文档，而真正决定谁能胜出的部分不会。我在别处写过完整的训练流水线；这篇文章要讲的，是那篇文章刻意压缩成一节的那个阶段——因为它值得单独成篇。

写它还有一个私心。过去一年我做过的几乎每一场研究面试，最后都会收敛到数据上：你会怎么为这个领域构建一份 mid-training 语料，什么时候该合成、什么时候该过滤，你怎么知道你的 verifier（校验器）没有被钻空子，在已经有 frontier model 的今天你会拿一个小模型做什么。这些问题听上去像是六个不同的问题。它们其实是同一个问题被问了六遍；而这篇文章的目标，就是把这个结构讲得足够明显，让你能够推导出答案，而不是背下答案。

这个问题是：

核心问题。 在训练的每一个阶段，什么算作一个训练样本，以及谁来保证它是正确的？

其余一切——过滤、合成、混合配比、rubric（评分细则）、蒸馏、decontamination——都是这个答案的下游。而随着你沿着这个栈往上爬，答案的形态也在变：在底层，你拥有的是一堆文本，没有任何人为其中任何一条背书；在顶层，你拥有的是一段能够认证行为的软件，而所谓「数据」，不过是递给它的一份任务规格说明。

一套能撑过全部六个阶段的词汇

关于训练数据的大部分混乱，都源自用「数据」这一个词去指代六种几乎不共享任何属性的东西。沿着四条轴把它们拆开——单位、来源、认证者、特征性失败——整个栈就变得可读了。

图 1. 六个阶段，六种都被叫做「数据」的不同对象。随着你往上爬，验证单个样本的成本会上升若干个数量级，而你需要的样本数量会下降若干个数量级。图中的数量取自公开配方的典型值，不是硬性上限。

六个阶段与六种对象。真正能预测你工程投入量的那一列，是「谁认证正确性」。

在往下走之前，有两个推论值得先说清楚。

数据的单位不再是文本。 在 pre-training 里你买的是 token。在 RLVR 里你买的是带 checker 的题目——答案不是数据，checker 才是。在 agentic RL 里你买的是 environment，也就是说，你买的是软件。这就是为什么越往上走，数据工作会从数据工程迁移到软件工程；也是为什么一个 post-training 团队的人员构成，和一个 pre-training 数据团队毫无相似之处。

经济学发生反转。 一份 pre-training 语料是 10⁹–10¹⁰ 篇文档，每篇的验证成本基本为零。一次 RLVR 训练是 10³–10⁵ 条 prompt，每一条都需要一个由某个人写出来并验证过的 checker。Agentic RL 是 10²–10⁴ 个任务，每一个都可能需要一个 Docker 镜像。单样本成本上升五到六个数量级，而样本数量下降五到六个数量级——这就是为什么「多搞点数据就是了」在栈的底层是好建议，到了顶层却几乎总是错的。

要点。 「训练数据」是六种不同的对象，配六种不同的认证者。在回答任何数据问题之前，先说清楚你处在哪个阶段，以及在那里谁对正确性负责。所有关于合成数据的分歧里，有一半是两个人站在不同的梯级上。

三种监督来源

「合成 vs 真实」是一条错误的轴，它之所以会催生无法收场的争论，是因为争论双方描述的本就是不同的 regime。真正能预测行为的那条轴是谁提供正确性信号，而候选者恰好只有三个。

图 2. 每一份配方，都是在三种正确性来源之上的一个投资组合。随着你沿着栈往上爬，组合会发生轮动：pre-training 倚重人类文本，SFT 倚重 teacher，RL 倚重世界。图中各点的位置是编者判断，不是实测值。

• 人类。 示范、标注、偏好，以及——这一点至关重要——品味。天花板是无界的，因为人类专家能够识别出那些还没有任何人形式化过的质量。它同样无法规模化，而且每多一项新能力，你就要再付一次钱。
• Teacher。 一个更强模型的输出：答案、trace、trajectory、判定、logits。便宜，天然可并行，而且以今天的价格，跟一次训练比几乎可以四舍五入成零。它的天花板就是那个 teacher，再减去一项 capacity gap（容量差距）带来的折损——后文会把它量化。
• 世界。 执行：编译器、单元测试、证明检查器、模拟器、environment 状态、真实用户。checker 你只造一次，然后可以永远跑下去；而且——这才是关键——它能够为从来没有人产生过的行为打分，这是唯一一条能让模型超越自己 teacher 的性质。它的弱点则是彻底的：在可校验的领域之外，它什么也说不出来。

之所以要坚持这个框架，是因为它让天花板变得可组合。如果你 pipeline 里的每一个监督信号都来自 teacher，那么你的模型会朝那个 teacher 收敛，然后停下；你的策略已经悄悄变成了「等下一次 teacher 发版」。如果每一个信号都来自世界，那么你是无界的，但在所有你写不出 checker 的地方都会失声——而在今天，那恰恰覆盖了人们真正想让助手做的大部分事情。跑得通的配方都是投资组合：用 teacher 做 cold start，用世界完成攀登，用人类提供品味、以及那些你没法自动化的 checker。

这个投资组合视角还解释了一条否则看起来像是巧合的经验规律。文献里最大、最可靠的那些「合成数据」胜利，靠的都不是合成文本——而是合成标签。FineWeb-Edu 让 Llama-3-70B 为 460k 个网页的教育价值打分，把这些判定蒸馏进一个冻结 embedder 之上的线性 head（阈值取 3 时 F1 ≈ 82%），再把它应用到 15T tokens 上，花费约 6,000 H100 小时；由此得到的 1.3T-token 语料在 38B tokens 处就达到 33.6% MMLU，而次优数据集需要约 300B——大致是 10× 的 token 效率（Penedo et al., 2024）。DataComp-LM 的整个头条结果，就是换了一个过滤模型，在固定 7B/280B 计算量下把 MMLU 从 35% 推到 44%（Li et al., 2024）。phi-1 的第一个 ablation，发生在任何生成文本进场之前，是一个由 GPT-4 打标的质量分类器（Gunasekar et al., 2023）。

洞察 —— teacher 最擅长的活是验证，不是创作。 拿一个 frontier model 去写你的数据，会把你锁死在它的分布上。同一个模型拿去给你的数据打分，则会成倍放大你本来就拥有的那份语料的价值，而且这个打分还能被蒸馏成便宜到足以跑遍数万亿 token 的东西。当人们说「合成数据有用」时，真正承重的那些胜利，通常属于第二种。

合成手册

一旦你接受了生成很便宜这件事，有意思的问题就不再是要不要合成，而是该用哪个算子。反复出现的模式一共有八种，每一种都有一个特征性失败，出现得稳定到足以被预测。

图 3. 制造一个训练样本的八种方式，按各自的输入排列。最右边那一列是人们通常会跳过的部分：每一种模式都需要一个认证者，而这个模式能有多好，完全取决于那个认证者。

八种模式

1. 精选与手写。 完全不做合成：在严苛的过滤条件下挖掘高信号的人类语料，再把长尾部分手写出来。LIMA 的 1,000 条样本（750 条在明确的长度与语域过滤条件下挖自 Stack Exchange / wikiHow / Reddit，250 条为手写）在 300 条开放式 prompt 的两两对比中，有 43% 被判定为不劣于甚至优于 GPT-4（Zhou et al., 2023）。失败方式：不可规模化，也覆盖不了技能面。样本量从 2K 加到 32K，质量就已经进入平台期；而在更小的 base 上做的复现，给它的分数要低得多。

2. 改写与复述。 保留信息，改变风格。WRAP 让一个冻结的 Mistral-7B 把 C4 文档改写成四种语域（easy / medium / hard / QA），每篇上限 300 tokens——因为改写器一旦超过这个长度就会开始丢信息——再以 1:1 的真实:合成比例混合训练，换来约 3× 的 pre-training 加速（Maini et al., 2024）。失败方式：不增加任何知识。论文自己就把话说死了——「synthetic data can not impart ‘new knowledge’. It can only help pre-train faster」——而它自己那张知识密集型的表里，用 1T 真实 token 训练的 TinyLlama 以 45.6 对 45.5 略胜合成混合语料一筹。

3. 蒸馏或重新打标。 保留你的 prompt，把回答换成更强模型的。整个 SFT 文献里最便宜的高回报干预，来自 Self-Instruct 自己的 ablation：只用更强的模型重新生成输出字段，prompt 一条不改，在四级评分量表上拿到最高一档评分的输出占比就从 44.4% 提到了 54.4%（Wang et al., 2022）。失败方式：继承 teacher 的天花板，连同它的习气（参见蒸馏）。

4. 自生成与过滤。 模型提议，checker 定夺。Self-Instruct 从 175 条种子出发，配一道 ROUGE-L < 0.7 的新颖性门槛，自举出了 52,445 条指令。值得记住的数字是它的审计结果：92% 的生成指令描述了一个有效任务，但只有 58% 的输出是正确的。 失败方式：产出错误答案。这个模式能可靠地生成指令分布，却不能可靠地生成解答；这也正是它为什么必须搭上模式 3，或者外挂一个 verifier。

5. 反向构造。 把流水线倒过来跑：把已有的高质量文本当作 gold 回答，再生成本该产生它的那条指令。Humpback 在 502k 个网页片段上训练一个反向模型 p(x|y)，用模型自己的 5 分制打分自我筛选出 41,821 对样本，仅凭 3,200 条人工标注就在 65B 规模上做到了 AlpacaEval 83.71（Li et al., 2023）。它的数据 scaling 系数（每 log-样本的胜率）是 6.95，而 LIMA 是 2.86、Alpaca 是 1.99。失败方式：一旦拿掉筛选门槛就一文不值——未经筛选的反向翻译数据，规模越大反而越差。

洞察 —— 去生成问题，而不是答案。 反向构造之所以奏效，是因为它把合成中困难的那一半，转嫁给了早已把这件事做完的人类。写出一段正确、文笔好、事实有据的回答，才是昂贵的部分；从一段好答案倒推出一个合理的问题，则几乎不要钱。同样的花招会在栈的每一层重现：数学里是答案 → 题目，代码里是已合入的 PR → issue，agent 里是观察到的 environment 状态 → 任务。

6. 种子条件化的多样性扩展。 把生成条件化在一个大规模的外部上下文集合上，让生成器没法退回自己的 mode。Persona Hub 通过 text-to-persona 与 persona-to-persona 两种扩展方式，从网页中挖出约 1.01B 个 persona，用 MinHash 在 0.9、embedding 相似度在 0.9 处做去重，然后把其中一个前置到任意合成 prompt 上；相似度 0.9 的 persona 对，产出的题目相似度只有 0.6–0.75，因此这个 persona 集合起到了多样性下界的作用（Ge et al., 2024）。Tülu 3 用了其中约 250K 个，并报告说去掉 persona 数据要付出 19.2 分的 IFEval 代价（Lambert et al., 2024）。失败方式：它是把 mode 挪动了 250,000 次，而不是把 mode 拓宽（见下文）。

7. 演化与难度升级。 拿一个条目，反复改写得更难。Deita 的关键动作不在演化，而在打分：把每条指令演化五次，然后在同一个 prompt 里让 judge 对全部六个变体一起排序打分——因为一个被要求孤立地给单个样本打分的 judge，会把所有东西都压缩到 7–8/10（Liu et al., 2023）。LIMO 则用选择而非生成达到了同样的效果——只保留那些强推理模型在 32 次尝试中只解出 1–3 次的题目（Ye et al., 2025）。失败方式：复杂度代理指标会偏离真实难度。在 Deita 的受控对比里，基于 perplexity 的选择（4.06 / 1.89 MT-Bench）和基于指令长度的选择（在噪声池上 4.00）双双低于随机选择（5.84 / 4.93），因为高 perplexity 的样本恰恰是那些回答极短的样本。

8. Agentic 流程式生成。 把合成拆解成多个阶段，每个阶段是一组角色专门化的 agent（智能体），其中一部分带工具。AgentInstruct 从原始文档和代码取种——从不从 prompt 取种——先跑内容变换（仅阅读理解一项就用了九个 agent），再按题型生成（43 种题型），然后交给 Suggester–Editor 组合，它们唯一的任务就是把题目变难；覆盖 17 项技能、100+ 个子类，pipeline 本身产出 22M 对样本（Mitra et al., 2024）。给这些 agent 配上工具，正是生成出来的回答能够超过生成模型本身的机制所在。失败方式：巨量的手工工程，以及极不均匀的回报——同一条 pipeline，把 GSM8K 推高 +54% 的同时，IFEval 只涨 +2%，GPQA 还掉了 −4%。另外，头条数字也要仔细读：常被引用的约 25.8M，是 22M 合成数据加上 3.8M 的 Orca-2.5 数据，所以它报告的增益并不能单独归因于这条 agentic pipeline。

多样性才是那个紧约束

整个这一片文献里最锋利的结果是关于多样性的，而它重新框定了合成数据之争。Verbalized Sampling 从机制而非症状出发：偏好数据里的标注者会系统性地偏好 base model log-probability 更高的文本，与质量无关。把 reward 建模为 r_true + α·log π_ref，那么对齐后的最优解就变成 π* ∝ π_ref^γ，其中 γ = 1 + α/β > 1，只要 α > 0 就成立。在正确性匹配的样本对上拟合 α，得到 α̂ ≈ 0.57–0.65，p < 10⁻¹⁴。于是，在任何候选之间真实质量本就持平的子集上——创意写作、对话、大多数开放式合成——对齐会把模型锐化到 base model 的 mode 上，而 typicality bias（典型性偏差）就是那个决胜项（Zhang et al., 2025）。这套推导本身无懈可击；它真正依赖的，是把 log π_ref 当作一种典型性偏好的代理这一建模假设——作者对此是明说的。

这对一条数据 pipeline 造成的实测后果相当残酷。用一条普通的 prompt 让 GPT-4.1 和 Gemini-2.5-Flash 生成 1,000 道合成竞赛数学题，让 Qwen3-32B 写 trace，再用结果去 SFT 小规模 student：MATH500 / OlympiadBench / Minerva 的平均分是 30.6，低于你干脆不做 fine-tune 时的 32.8。其他什么都不改，只把要一个回答换成要「五个回答及其概率」，同样的 teacher、同样的预算、同样的 student，给出的就是 36.1；换成同一条 prompt 的多轮变体，还会升到 37.5。收益的正负号，会因为改写一条 prompt 而反转。

同一篇论文还测量了 mode collapse 如何在 post-training 过程中累积：在一项写诗任务上，base model 多样性 45.4% → SFT 之后 20.8% → DPO 之后 10.8%，而分布层面的 prompting 全程维持在约 30%（Zhang et al., 2025）。

权衡 —— 条件化的多样性不是采样出来的多样性。 Persona、种子文档和主题分类体系提升多样性的方式，是每换一个条件就把 mode 所在的位置挪一次。分布层面的 prompting 提升多样性的方式，则是把采样分布本身压平。二者是互补的；而据我所知，还没有人发表过把两者结合起来的结果。如果你的合成数据 pipeline 跑在一个对齐过的模型上，第二种做法几乎是免费的，在你花钱买更多 persona 之前，应该先试试它。

验证阶梯

如果生成是廉价的、验证才是真正的资产，那么任何数据 pipeline 中最核心的设计决策，就是你给每个样本挂上哪一种认证机制——而这是一架阶梯，不是一个二元选择。每往上爬一级，成本更高、对你真正想要的东西覆盖得更全，同时也以自己独有的方式失效。

图 4. 十种最常见的验证机制，按每个样本的成本排序，并按主导各自失效方式的错误类别着色。规则不是「尽可能往高处爬」，而是「选出能够约束住你真正在意的那类错误的最便宜的一级」——并且请注意，robustness 并不随成本单调递增。下面的表格补充了图中省略的三级。

验证阶梯。每一级的证据见下文各节；结构上最重要的事实是：成本与覆盖度一同上升，而 robustness 不会。

关于这架阶梯，有三个事实比阶梯本身更有价值。

两类错误并不对称

基于规则的 verifier 以 false negative 的方式失效。一项对三个标准数学 verifier、跨四个数据集的细致审计发现，precision 高于 99%，但 recall 的平均值分别是 0.86、0.92 和 0.93——对其中最弱的那一个来说，大致相当于每七个正确答案里就有一个被判错——在最难的数据集上降到 0.78，在数学之外则是 0.35–0.58（Huang et al., 2025）。论文自己报告的趋势是：在更强 policy 所产生的那些更难、更多样的答案分布上，recall 会退化。Model judge 与测试套件则以另一种方式失效，也就是 false positive：reward 照付，行为却是错的。

两类错误都会随能力增长而恶化，这才是「verification horizon（验证视界）」这个说法真正的内容。但它们的危险程度并不相等。无偏噪声只是让性能退化；有偏噪声则会把模型带偏。One-shot RLVR 实验显示，60% 的随机错误标签只带来约 1.3 个平均分的损失，即便 90% 的标签是错的，这一轮训练依然好过什么都不做（Wang et al., 2025）——但一个模型有可能真的够到的错误标签，其破坏力远大于一个它根本够不着的错误标签：在单个训练样本上，「错误但能猜中」的答案得分 57.0，「错误且不可达」的得分 64.4，正确答案则约为 74。危险的错标，是那种看起来合理的错标。

Grounding 胜过精巧

文献中每一次 robustness 上的胜利，都来自把 reward 锚定在 policy 无法改写的东西上——执行、过程日志、一个真实运行的浏览器、一个共同演化的 discriminator、真实用户。每一次 robustness 上的失败，都来自让一个模型去读，然后发表意见。定量版本是这样的：在 13 种对抗性 hacking 模式下，直接给出判断的判别式 verifier 的攻击成功率为 0.1–0.4%，而生成式 CoT verifier 落在 7.7–23.7%，最差的单个格子是伪造「答案解释」攻击下的 77.9%（Huang et al., 2025）。chain of thought 本身就是攻击面。

同一项研究里最反直觉的结果，是值得留着应付面试的那一个：作者 fine-tune 了一个 verifier，让它在静态指标上更好——recall 从 0.49 提到 0.62，precision 从 0.68 提到 0.73——它却带来了全文最差的一次 RL run，因为 policy 发现自己只要输出一个 { 就能拿到钱。静态分类准确率不但没能预测 RL 的结果，方向还是反的。

要点。 挑选 verifier 要看对抗性 robustness，要看它在一整轮训练过程中的表现，绝不要看 held-out 准确率。有两件仪器能把这件事做得很便宜：一套对抗模式测试集，以及一条 oracle 通道——在每个 checkpoint 上用一个强大的外部模型对约 1,000 条采样出来的训练 prompt 重新打分，并把 training reward 与 oracle reward 画在同一组坐标轴上。这两条曲线一旦背离，就是你能买到的最可靠的警报。

Pre-training：过滤就是产品

Pre-training 的漏斗——抽取、去重、分类、混合——我已经在前沿实验室那篇里讲过了，所以这里我只想讲那些会改变你对栈里其余部分看法的内容，外加那些推翻了既有共识的结果。

基于模型的过滤，是迄今为止所有被测量过的旋钮里杠杆率最高的一个，而「质量」的含义是「长得像任务」。 DCLM 的受控 benchmark（五个 compute 尺度、416 组 baseline 实验、53 项评测）发现，一个朴素的 fastText bigram 分类器打败了 perplexity 过滤器、embedding 分类器、语义 dedup 和 AskLLM（Li et al., 2024）。正类的参考语料比分类器本身更重要：指令数据加上 r/ExplainLikeImFive，比 Wikipedia/书籍/OpenWebText 组成的参考集高出 3.5 个 CORE 点；而过滤得更狠（top 10%）胜过 top 15% 与 top 20%。整条 pipeline 把 240T 原始 tokens 变成一份 3.8T-token 的语料；他们用其中 2.6T tokens 训练的 7B 模型能达到 64% MMLU。

我愿意把这个发现印在海报上：在同一个 benchmark 里，AskLLM 过滤器与人类标注者的一致性达到约 82% ROC-AUC，训练出的模型却比 fastText 分类器更差；而标注一致性与下游分数之间的相关性 R² < 0.3。最好的过滤器，并不是那个在「什么算好文字」上最认同人类的过滤器。

去重并不是单调有益的。 FineWeb 在 96 个 Common Crawl 快照上跑了迭代式的全局 MinHash，把最早那批 crawl 删掉了多达 90%，剩下 4T tokens，相对于完全不去重基本没有增益（Penedo et al., 2024）。真正让人记住的是那个直接对照实验：在单个 2013 年的 crawl 上，从全局 dedup 中幸存下来的约 31B tokens，训练出的模型比 171B tokens 训练出来的更差——后者是把全局 dedup 扔掉的那 90% 单独再去重一次得到的。一个页面在多个 crawl 中重复出现，只是它值得保留的微弱证据，所以全局 dedup 会优先留下广告和关键词垃圾。按快照分别去重（20T tokens）才是真正有效的配方。

选择的单位可以比文档更小。 Rho-1 在一份过滤后的数学语料上做的 token 级普查，是那种可以永久终结争论的结果：51% 的 token 已经学会了，26% 是学习真正发生的地方，11% 是不可约的难点，还有 12% 在训练过程中变得更差。 把 loss 按 excess loss（learner loss 减去 reference loss）只保留在排名前约 60% 的 token 上，能让 1B 模型在数学上拿到 +16.5 的平均分提升，也能让 7B 模型只用 15B tokens——3% 的 token 量——就追平一个用 500B token 训练出来的数学专用模型（Lin et al., 2024）。

数据墙，以及重复能买到什么

数据墙的预测值得精确引用，因为流传最广的那个版本在两个方向上都是错的。已被索引的 web 估计有约 510T tokens；做质量修正（只有 10–40% 可用）后中位数降到 100T；再做重复修正又回到约 320T。需求以约 0.38 OOM/年（2.4×/年）的速度增长，中位数的交叉点在 2028 年（Villalobos et al., 2022）。凡是说「web 那么大，我们永远用不完」的人，引的是原始数字；凡是说「我们去年就已经用完了」的人，则忽略了重复，也忽略了过滤器还在不断变好这个事实。

重复到底能买到多少？经典答案是：4 个 epoch 以内几乎是免费的（一个 8.7B 模型在 44B 不重复 tokens 上训 4 个 epoch，最终 validation loss 只比在 178B 不重复 tokens 上训一个 epoch 差 0.5%），有意义的增益一直持续到约 16 个 epoch，而到 40 个 epoch 时重复就完全不值钱了。人们最容易忘掉的是拟合出来的半衰期：重复 token 的价值以 R*_D = 15.4 衰减，而多余参数以 R*_N = 5.3 衰减，所以当你受数据约束时，应该先买 epoch，再买参数——这与 Chinchilla 的等分做法正好相反（Muennighoff et al., 2023）。

开放问题 —— 4-epoch 规则是依赖模型规模的。 一项 2026 年的研究在控制住重复这一混杂因素后发现，在一份稀缺的高质量语料上，最优的遍历次数从 30M 模型的约 24 次一路降到 757M 模型的约 5 次，同时最优的高质量数据占比在同一区间内从 0.75 降到 0.15（Repetition Mismatch）。模型越大，想要的重复越少、新鲜 web 文本越多。「四个 epoch」是某一个尺度上得到的数字，不是定律。

崩塌是协议层面的 bug

model collapse 的文献通常被当作害怕合成数据的理由来引用，而被引的那条主张几乎总是错的。原始结果证明的是：在替换掉先前数据的前提下，递归地在自己的输出上训练，会让分布坍缩成一个 delta 函数；论文展示的退化，来自一个在 2M 词上 fine-tune 的 125M 模型（Shumailov et al., 2023）。但同一篇论文里那个每一代保留 10% 原始数据的设置，本身就已经显示「只有轻微退化」。

让协议贴近现实——web 上的数据是累积的，不是被换掉的——发散现象就消失了。在累积设定下，测试误差可被证明由一个与迭代次数无关的常数所界定（σ²d/(T−d−1) · π²/6），而在替换设定下误差随代数线性发散；经验上，在测试过的每一个模型尺度上，cross-entropy 在五轮迭代中都保持平稳（Gerstgrasser et al., 2024）。

要点。 操作层面的规则是永不替换，始终累积；该问的问题也不是「合成数据是不是毒药？」，而是「这份语料里有多大比例是真实数据，以及它们会不会一直留在里面？」另外请注意好消息的诚实版本：累积情形下的上界是 π²/6 ≈ 1.645× 的单次迭代误差，这是实打实的 64% 惩罚；而且我能找到的 collapse 实验全都跑在 ≤126M 参数规模上。没有人发表过前沿规模的测试。

为什么混合比例实验会骗人

数据混合比例的优化，是这个领域方法论问题暴露得最彻底的地方。那个诱人的假设叫秩不变性：如果混合方案 A 在一个小的 proxy 上胜过 B，那么在目标规模上它也会胜过 B。2026 年的三项独立结果说这个假设不成立，而且各自的原因都不一样。

混杂因素：因为一份稀缺的高质量语料在 proxy 预算下被重复的次数与在目标预算下不一样，loss landscape 会随之移动。只要同时对数据集和 horizon 做下采样、把重复次数固定住，一次仅用目标 token 预算 6% 的 proxy run 就能落在最优混合方案的 0.05 以内，而朴素外推的误差是 0.75——如果不做这项修正而想达到同样的精度，代价是完整预算的 44–94%（Repetition Mismatch）。

机制层面：最优的训练混合比例确实不等于目标混合比例，也确实会随模型规模与 token 数量而移动。一个带容量竞争项和数据驱动噪声项的机理模型，用约 85 个自由参数拟合了 64 组已有的 run；仅在 122M/10B 上拟合时，它外推出的 1B/30B 混合方案，与一条可以访问目标规模才拟合出来的经验律相当（Dai and Zheng, 2026）。

再看那个 sanity check：DoReMi——正是它让基于 proxy 的混合比例优化成为标准做法，在 Pile 上带来 +6.5pp 的下游提升（Xie et al., 2023）——当 domain 换成 256 个学出来的语义簇、而不是 22 个来源标签时，它在四组对照中的三组里输给了均匀混合，一个合理的解释是：worst-group 目标会给那些格式噪声很重、却没有任何能力 benchmark 会奖励的垃圾内容加权（Qiao et al., 2026）。

洞察 —— 粒度与选择规则是被联合决定的。 同一项研究发现，按 bucket 做质量筛选在 65k 个 bucket 时值 +0.025，在 130k 个 bucket 时则一文不值，因为候选池的中位数从 2,271 篇文档收缩到 429 篇，bucket 内部的排序退化成了均匀抽样。domain 划得更细一直是有用的，直到你的 bucket 小到内部无法排序为止。这与 RL 里难度分档的问题是同一个形状：选择需要一个可供选择的样本池。

Mid-training：没人写下来的那个阶段

Mid-training（中期训练）是这样一个阶段：没有公认的定义，没有标准配方，而且——这并非巧合——面试题最多。从操作层面看，它涵盖了你判定 pre-training 已经结束之后、开始收集偏好数据或奖励数据之前发生的一切：给某个领域加权、扩展 context、在高质量混合数据上做 annealing、装上一种输出格式、注入一份专有语料，以及把模型准备到让 RL 有东西可以放大的状态。技术报告里往往只用一句话带过。而对本文的大多数读者来说，它也是唯一一个用适度预算仍然能撬动接近前沿的数字的阶段——这恰恰就是它频繁出现在面试里的原因。

这一阶段的数据单元是一个精选数据包（curated pack），而它的认证机制是所有阶段里最弱的：一个 proxy eval 加上一个 replay 比例。没有人会去逐份检查文档。你真正在决定的是一个分布和一份日程表；而整个文献中反复出现的教训是：同样的事实，换一种格式，价值大约要高出一个数量级。 Mid-training 是唯一一个阶段，在这里你可以改变一条训练样本长什么样，却不改变由谁来提供正确性。

Continual pre-training 的机制

这里有一套稳定的旋钮，而且少到可以背下来。

continual pre-training 的旋钮集合。其中只有两个真正存在争议：peak LR 与 replay。

人们所说的灾难性遗忘，大约有三分之一其实来自 learning rate 的日程安排，而不是数据。 拿一个 405M 模型，在它原本就用来 pre-training 的那份 Pile 数据上重新 warmup、重新 decay，Pile 的 validation loss 依然会上升：在 η_max = 3e-4 时峰值 +0.1 nats，在 6e-4 时 +0.2。而当真的切换到 SlimPajama 时，峰值是 +0.35 和 +0.45——也就是说，schedule 大约解释了观测到的退化中的四分之一到一半，而且模型「即便在同一份数据集上训练，也无法从性能下跌中快速恢复」（Ibrahim et al., 2024）。在你怪罪新语料之前，先把 optimizer 的账算进去。这也正是 infinite-LR schedule、以及从未经 decay 的 checkpoint 恢复训练的全部动机。

replay 比例应当由分布偏移的大小来定，而不是由 token 预算来定。 这里的数字异常干净（Ibrahim et al., 2024）。405M 上做 Pile → SlimPajama：0% replay 在 Pile 上要付出 0.27 nats 的代价；1% 的 replay 就能挽回其中的 0.18，而在新数据上的代价是 0.00 nats（两种情况下 SlimPajama loss 都是 2.50）。Pile → 德语则需要 25% 才能达到 1.75 这个 union baseline 的平均 loss，而 1% 只能到 1.97。规模几乎不改变这笔账——5% 的 replay 在 10B 上挽回 0.19 nats，在 405M 上挽回 0.21，因为更大的模型本来就遗忘得更少。生产环境里的 run 比论文保守：Zamba 在 decay 阶段用了 60% 的 replay，DeepSeek-V2 在 6T 的 CPT tokens 上用了 30%。如果你手上没有原始的 pre-training 数据，实用的替代方案是在混合数据里保留一路通用 web 数据流，然后换个名字管它叫 replay。

关于 peak LR 的分歧，值得去理解，而不是急着调和。 经典的 CPT 论文（Gupta et al., 2023；Ibrahim et al., 2024）说：re-warm 到 pre-training 的 O(η_max)，并把 η_max 当作「适应 vs. 保留」的调节旋钮，在 405M 上这给出 3e-4。一项 2026 年的 scaling 研究则说，最优值会随总有效算力而减小，并预测一个 dense 的 8B 模型在 55B tokens 上继续训练时应取 5e-5——用 5e-4 会损失 3.7 个平均分，并把 GSM8K 从 40.7 拉到 31.1（Zhou et al., 2026）。两者在各自的 regime 里都是对的；而调和二者的量，是你的 CPT 预算与该 checkpoint 的等效 pre-training 算力之比——这个比值可以通过测量 checkpoint 在你的 CPT 验证集上的 loss、再反解 loss–compute 定律来估计。经典设定是在 300B 的 pre-training 之上再做 300B tokens 的 CPT，所以在那里高 LR 是正确的；而一个训练充分的 8B 模型只看 55B 新 tokens，是这条曲线上完全不同的一个点。另外值得注意的是，同一项研究发现最优 batch size 会随算力上升，而且 MoE 上升的速度比 dense 快 2.2×——routing 在小 batch 下会失稳。

知识注入：认得出不等于答得出

下面这个结果，是我在任何一场关于领域适配的讨论中都会拿来开场的，因为它直接判了默认方案的死刑。

一个模型可以逐 token 完美背下一份文档，却答不出关于它的任何一个问题。 在 100,000 份格式固定的合成人物传记上做 pre-training，然后只在其中一半人物上 fine-tune 一个 QA 头。在 held-out 的那一半上，平均准确率是 9.7%，对照的多数猜测 baseline 是 2.7%——按属性拆开看，出生日期（永远是名字之后的第一个属性）上得 33.5%，其余五个属性上只有 1.1–13.8%。规模救不了它，加大力气也救不了它：一个 682M 参数的模型——平摊下来每个人物约 6,800 个参数——训练 1,350 遍之后，在它 fine-tune 过的那些 QA 对上达到 99.0% 的首 token 准确率，而在 held-out 的那些上只有 4.4%；而 LoRA 与全参数 fine-tuning 在大约三十种设定下全部失败（Allen-Zhu and Li, 2023）。

probing 分析给出了原因，而且这个解释可以推广。在单一格式的语料里，属性是弥散地编码在整份文档的 token 上的，而不是线性地编码在紧邻实体名字的 hidden state 里。一个问题只提供名字。那个位置上根本没有东西可读。fine-tuning 修不好它，因为 fine-tuning 无法搬动知识的存放位置——那是语料在 pre-training 时刻就决定了的性质。

数据增强能把它搬过去，而起作用的成分是多样性，不是体量。 五种不同的改写再加上句子置换，把同一个模型从 9.7% 拉到 96.6%，probing 准确率同步上升。但如果五种改写按固定顺序出现，就只能到 41.0%；而单独做置换反而有害（4.4%，比什么都不做还差）。另外两条性质让这件事变得可操作：

• 它会传染。 额外加入一批互不相交的、经过增强的 100k 份「名人」传记，QA 任务只在名人上做 fine-tune，那么完全没被动过、也没有做增强的「少数派」集合会从 4.4% 升到 86.8%。模型学会了那套存储约定，并把它应用到只见过一次的文档上。你不必增强所有东西。
• 还有一扇更便宜的门。 把 QA 格式的数据混进 pre-training，而不是留到 SFT 阶段，在完全未做增强的传记上就能达到 86.6%。

预算这笔账来自同一个组。 一个训练充分的 transformer 每个参数大约存储 2 bits 的知识——一个 7B 模型装得下 ~14B bits，作者估计这超过了英文 Wikipedia 加上教科书的总量——但「训练充分」意味着每条事实大约要出现 1,000 次；如果只有 100 次曝光，你得到的是每个参数 1 bit（Allen-Zhu and Li, 2024）。所以「让每条事实以更多形式、更频繁地出现」不是什么小技巧，它是直接作用在存储常数上的杠杆。有两条推论值得带进设计评审：int8 量化是免费的（仍然 2 bits/param），而 int4 则会塌到 0.7；以及，稀释效应完全取决于混进来的是哪一种垃圾。 混入 7/8 的高 entropy 垃圾——从不重复的随机事实——在 100 次曝光下会损失 20× 的容量。混入 7/8 的重复性垃圾则毫无代价。而缓解手段几乎不要钱：在有用的文档前面加上一个 provenance（来源溯源）token，20× 的惩罚就变成 2×，到 300 次曝光时更是完全追平无垃圾时的规律。模型学会了按领域给自己的容量做路由，而它事先并不知道哪些领域是好的。

洞察 —— 这就是为什么 replay 不等于稀释。 两个看起来矛盾的结果——「7/8 的垃圾要损失 20× 容量」与「大量 replay 在 loss 上几乎不花代价」——可以用垃圾的分类来调和。replay 数据是重复的、in-distribution 的、而且此前已经学过的。它属于免费的那一类，而且是在这里真正重要的那个意义上免费：它不消耗容量。它真正消耗的是预算——在 50% 的 replay 下，你会少看 150B 个新 tokens，这也正是为什么已发表的配方都落在 1–25%。高 entropy 的、学不会的文本才是昂贵的那一类。如果你没法清洗语料，那就给它打标签：provenance token 几乎不花任何成本，就能挽回大部分损失。

这条建议的生产级版本叫 EntiGraph，而它说：改写还不够。 拿 265 本冷门书籍、总共 1.3M tokens——这个语料比已发表的最小的领域自适应 CPT 语料还要小 10,000×——先抽取实体，再让一个 teacher 去分析每一个实体对与三元组之间的关系，并且始终以原始文档为条件。这把 1.3M 的真实 tokens 膨胀成了 455M 的合成 tokens；在它们上面做 CPT（Llama-3-8B，2 个 epoch，10% replay，peak LR 5e-6），把闭卷准确率从 39.49% 提到了 56.22%，并且在跨三个数量级的合成 token 数上呈对数线性，拟合出的渐近线是 64.5%（Yang et al., 2024）。有两个对比撑起了整个论证：

• 在原始的 1.3M tokens 上做 CPT 只有 38.15%——低于 base model 的 39.49%。 在你自己的文档上训练，反而把模型变差了。
• Rephrase 式的 CPT 在 38M tokens 处就走平了，随后被放弃。表层的措辞变化，和对一张关系图做组合式覆盖，根本不是同一个算子。

而且它买到了 retrieval 所能买到的大部分东西：在 base model 上做 RAG 能到 60.35，Recall@8 为 99.63，所以 EntiGraph 的 +16.73 相当于 RAG 绝对增益的 80%，而且在测试时完全不需要访问语料；两者叠加起来是 62.60。当有人问你该 fine-tune 还是该 retrieve 时，这就是应该随时能报出来的数字。最诚实的表述来自作者自己：EntiGraph「并不凭空创造知识；它只是把源文档中的知识重新排列成一种更容易被学习的布局」。

一条我可以从内部给出的注意事项。 几年前我做过这个问题的一个小规模版本，比较了问题形态的合成表示在全部三条注入路径上的表现（Zhang et al., 2024）。可迁移的结论是：最佳的数据格式随路径而不同——SFT 用短的对齐 QA 对，CPT 用「问题 + 上下文」块，retrieval 用问题增强过的文章；而且更细的 conditioning 窗口优于更粗的。有一个结论我想报告得比论文摘要更谨慎一些，那就是幅度。标题里的「+21.2% BioASQ」是相对 base model 的绝对 F1 增益；如果对照正确的 baseline——在原始文章上做 CPT——三个数据集上的增益分别是 +11.6 / +3.1 / +1.1 个 F1 点，而在其中一个数据集上，原始文章的 CPT 已经拿到 0.242，最好成绩也不过 0.253。那个实验用的还是在数千条样本上做 QLoRA，而不是在数十亿 tokens 上做全参数 CPT。这就引出了一个值得知道的矛盾：在我们的设定里，原始文档的 CPT 明显有帮助；而在 EntiGraph 的设定里，它比 base model 还差。可能的原因是语料的冷门程度。EntiGraph 刻意挑了一份 base model 不知道的语料；而从 Wikipedia 和 PubMed 派生出来的 benchmark 知识库，很可能早就在 pre-training 里了，这就让「raw CPT」成了一次复习，而不是一次注入。

权衡 —— 改写足以支撑查找，却支撑不了理解。 五种模板改写把 single-hop 的属性抽取从 9.7% 拉到 96.6%；而同样的操作用在真实散文上，当问题需要跨越一份 5,000 token 的文档做推理时，在 38M tokens 之后就走平了。两支文献都同意多样性是背后的机制。它们分歧的是：改写究竟能提供多少多样性。判别标准在于，缺失的表示究竟是挂在某个实体上的属性，还是实体之间的关系。在选择增强算子之前，先诊断清楚你需要的是哪一种。

长 context 数据是制造出来的

长 context 能力大体上是被解锁出来的，而不是被装进去的：在任意位置使用信息的能力，很大程度上是在短 context 的 pre-training 期间获得的——这也是为什么 5B tokens 就能做到早期工作花 400B 才做到的事。needle-in-a-haystack 准确率随 CPT tokens 的变化：100M → 37.8，300M → 59.0，500M → 81.1，1B → 85.3，5B → 88.0，10B → 84.0。作者把 10B 处的这个回落读作对训练长度范围的过拟合；但这只是在一个模型上跑的一次扫描，所以峰值的位置只能当作近似，真正稳健的部分是那段平台（Fu et al., 2024）。整个 run 在 8×A100 上跑五天，而且在 80K context 下训练每 token 只比 4K 慢 3×，因为 I/O 才是主导项，它把二次方的 attention 开销盖住了。

这支文献里最有用的方法论结论是：loss 对它是盲的。 两份 SlimPajama 混合数据，在从 1K 到 128K 的每一个长度上 validation loss 相差都 ≤0.01 nats，在检索上的表现却天差地别（Fu et al., 2024）。更糟的是，perplexity 可能指错方向：当长数据占比从 20% 升到 100% 时，PG19 的 perplexity 一直在改善，而下游长任务的平均分却在下降（Gao et al., 2024）。而且标准 benchmark 会饱和——一个在 needle-in-a-haystack 上拿 100 的模型，在 HELMET 的重排序任务上只有 23.1，而 Llama-3.1-8B 是 37.0。如果这一小节你只带走一句话：永远不要用 perplexity 或 NIAH 来验证长 context 的配方。

现有的两套配方彼此不一致，而这种不一致更多是有启发性的，而不是可以被解决的：

两套长 context 数据配方。第二套报告称在长任务和短任务上都胜过第一套，但它同时也用了更新的 base model、更好的 benchmark，以及第一套当时还不存在的数据来源。

精选来源那一侧有三个发现，反直觉到值得背下来。100% 的长数据比 60% 的长数据更差，哪怕只看长任务，而且损害是在 SFT 之后才显现的——一个在长文档上被特化过的模型，是通用 instruction tuning 的糟糕初始化。训练长度要超过评测长度：从一个 20B tokens 的 64K checkpoint 出发，把接下来的 4B tokens 花在 512K 上，胜过花在 64K 上，而且这是在 64K 上测出来的（recall 98.5 vs 95.0，重排序 32.9 vs 28.0），原因是一份长度为 nd 的文档，比 n 份长度为 d 的文档多出 (n−1)(d−1) 条距离为 d 的依赖。还有，短数据那一部分决定了你的数学分数：同样的长数据混合，配上一路包含 OpenWebMath 与 Tulu-v2 的精选短数据流，GSM8K 能拿 46.6，高于 base model 的 44.7；而换成 SlimPajama、FineWeb-Edu 和 DCLM-Baseline，全都落在 39–42 附近。同一份工作还有一个负面结果，它与好几套前沿配方的做法相矛盾：往 SFT 里加入合成的长指令数据会造成损害——0% 时 55.7，1% 时 54.1，50% 时 43.3，每一个比例都输给 0%，尽管中间这些点并不构成一条干净的单调曲线——而且换成 70B 的生成器依然如此。

如果你在短 context 下做 mid-training，就默认长 context 已经没了。 27B tokens 的 8K context 能力 mid-training，把某个模型在 128K 上的 RULER 分数从 59.09 打到 6.46，同时把 8K 上的 RULER 提升到 89.02。目前找到的最佳修复方案具体得有些古怪，但值得记住：把 15% 的 base weights 合并回 mid-training 之后的模型，再跑 ~1k 步的全参数长 context 扩展，这能把 128K 恢复到 42.16，同时数学保持在 44.48，代码从 10.71 提到 25.54（Runwal et al., 2026）。只做合并只能到 11.32；只做扩展是 36.32–38.41。另一种做法是在 16K 而不是 8K 下做 mid-training：在同一项研究的 3B ablation 里，16K 在全部五个 benchmark 上都胜过 8K，也是作者推荐的平衡点；不过 32K 在其中三个上略微反超（GPQA 39.89 vs 38.89，LiveCodeBench 14.93 vs 12.19，MATH500 82.70 vs 82.47），并在 AIME24 上落败（30.98 vs 31.82）。

把 mid-training 当作 RL 的准备

正是这个视角，让 mid-training 成为一个一等重要的阶段，而不是一道收尾工序；而且它回答了一个人们不断在问的问题：为什么 R1-Zero 式的 RL 在某些开源 base model 上有效，在另一些上却失败？

问题不在 RL 算法，而在 base model 的 pre-training。 在 GRPO 下，一个 Llama-3.2-3B base 会把回复长度顶到 4,096 的上限，开头就写 \boxed{}，然后退化成反复输出「Solution」语句；而一个 Qwen2.5-3B base 的长度增长则很平滑。200B tokens 的数学 mid-training（恒定 LR）外加一条 20B tokens 的 decay 分支，就补上了这个差距：MATH500 从 7.4（base）和 10.0（base + RL）变成 25.8（mid-training 之后）和 65.2（mid-training + RL），对照 Qwen2.5-3B 的 66.4（Wang et al., 2025）。mid-training 装进去的不是数学，而是：一种可解析的输出格式、足以让 policy 不退化的指令跟随能力，以及一份好到能从中采样出正确解法的语料。

从这份工作及其后续研究中，可以提炼出四条可迁移的规则：

1. 语料质量压过语料规模。 在完全相同的 20B tokens 预算下，MegaMath-Web-Pro 带来了很大的 post-RL 增益，而 FineMath-4plus 则复现了长度爆炸的失败模式。
2. 对 QA 成分而言，分布对齐胜过体量。 从 web 派生出来的 QA，相对纯 web 带来了零 post-RL 提升；而从真实 benchmark 分布派生出来的 QA 才有效。decay 阶段最优的 QA 占比在 30% 处进入平台期，到 40% 就开始下降。
3. 大约 1% 的 instruction 数据是承重的。 89:10:1 的 web:QA:instruct 配比，在 ~200 个 RL step 之后解锁了 QA 数据的收益，并让长度增长变得平滑。
4. base 阶段的评测是错误的选择标准。 70B 与 100B 的 mid-training checkpoint 在 base benchmark 上得分相同，而在 RL 之后却单调地排成 100B > 70B > 20B。

真正改变了我对整条 pipeline 看法的，是 weight 层面的证据。 在来自四个家族的七个 base model 上，mid-training 让超过 90% 的参数变动了至少 1%（归一化 L2 距离 0.175），而 RL 只动了大约 5%（L2 0.0003——小 580×），留下 >93% 的权重仍在其 mid-training 取值的 1% 以内，以 CKA > 0.998 保住了表示几何，而且它的大部分变化集中在最初的 200–400 步（Runwal et al., 2026）。无论有没有做过 mid-training，RL 留下的 weight 足迹都差不多——只不过只有做过，它才管用。这对数据规划的直接后果是：你没法在 RL 阶段新增一个领域。 把 RL 的混合数据从 math+code 换成 math+code+science，六个 benchmark 的平均分只变动了 −0.21；而对 mid-training 的混合数据做同样的事，平均分是 +5.60，GPQA-Diamond 上更是 +17.34。只做数学的 mid-training 实际上把 GPQA 拉低了 5.2 分，而加入 science 挽回了 +10.10，同时没有牺牲代码。

对于「如果后面接 RL，一条 mid-training 样本应该长什么样」这个问题，还有一个具体而且异常优雅的答案。不是（问题，解法），而是（问题，一组已验证正确、但策略上各不相同的解法）。这个论证从梯度出发：当模型很自信时，一步 policy gradient 大约把被采样 token 的概率改变 ηAε²；而当概率质量分散在 N 个模式上时，改变量是 ηA·(1/N)(1−1/N)——一个过度自信的模型，几乎是 RL 推不动的。让每个问题都在 n 条经过验证、彼此不同的解法上训练，恰好就制造出了这些多模态的分叉点（RRV et al., 2026）。真正让它可用的是那些经验细节：

• 把 n 设成约等于你的 RL rollout group size。 在 group size 为 16 时，n = 16 胜过 n = 64，因为一组 16 条 rollout 可以覆盖 16 种学到的策略，却只能覆盖 64 种中的一个子集。
• 在固定预算下，深度胜过广度。 463 个问题 × 16 种解法，在 post-RL 的 pass@k 上以约 7% 的相对幅度胜过 7,408 个问题 × 1 种解法。
• RL 会组合出它从未被展示过的策略。 展现出一种以上不同解题启发式的推理链所占比例，从 mid-training 之后的 23.3% 升到 RL 之后的 56.7%；而一些在 RL 之前出现率为 0% 的特定组合，之后达到了 13–37%。
• 验证这一步没得商量。 同样这些多样的推理链，如果最终答案是错的，会把 post-RL 的 pass@k 在每一个 k 上都压到低于朴素 RL。没有正确性过滤的多样性，价值是负的。
• 在同一个任务上，自生成的胜过蒸馏来的：从 QwQ-32B 上为每个问题采样 16 条链，在多样性指标上反而更低（10.95 vs 13.81），并且产生了更冗长、更重复的 RL rollout。

要点。 mid-training 决定的是模型能做什么；RL 只决定它做得有多可靠。预算也应当照此分配：在 16K context 下用 ~15–27B tokens，LR 取 ~5e-5 并 cosine 衰减到 0.1×，replay 按偏移幅度来定，~1% 的 instruction 数据，你将来会想要的每一个领域都要有代表，之后再单独安排一个长 context 修复阶段。然后，用 post-RL 的表现来评判这个 checkpoint，而不是用它自己的 benchmark 分数——两者是解耦的，而这种解耦正是这一阶段所能犯的、代价最昂贵的那一个错误。

还有两个配套决策，把这个阶段补齐。筛选：在异质的 mid-training 混合数据里，质量这条轴是来源的性质，而不是语料的性质，任何一个全局打分器都会悄无声息地删掉某项能力——perplexity 和 n-gram 重要性过滤器在长记录上会崩掉，而 DataMan 因为输入长度限制而根本无法给它们打分，所以它对 agent trajectory 完全没有任何信号。在来源分组内部做阈值筛选，可以把一份 50B tokens 的语料砍掉一半而 macro 平均分不下降；但要注意，保留来源结构的随机采样是一个非常强的 baseline（63.23 对 64.20），而且胜过他们 benchmark 过的四个已发表过滤器中的三个，其中就包括 perplexity、n-gram 重要性和 DataMan（MIRA）。目标函数路由：loss 函数本身也可以随数据而变。在完全相同的语料上，朴素的 LM loss 在推理上胜过 distillation loss，而 distillation loss 在检索与合理性上更强；起判别作用的统计量不是 teacher 的自信度，而是 teacher 与数据的对齐程度——teacher 有多少概率质量落在实际观测到的那个 token 上。在代码上，teacher 已经把 83% 的质量放在那里了，所以 distillation 只会稀释信号；在通用文本上它只放 50%，剩下的一半携带着信息（Yuan et al., 2026）。按领域做路由，你就能同时胜过这两个单一目标。这是一个主题最干净的定量表述，而那个主题会在 distillation 一节里再次出现：teacher 在它与现实一致的地方有帮助，在它只是听起来自信的地方则有害。

SFT：一道就绪闸门，而不是能力来源

一条 SFT 样本是一个三元组：一个 prompt、一段可选的 reasoning trace，以及一个 response。它的 certifier（认证者）就是你摆在它前面的那个 filter——一个 verifier（校验器）、一个 judge，或者一个人。这让 SFT 成为整条流程里 certifier 最明显地属于设计选择、而不是世界固有属性的那个阶段；同样一份名义上相同的配方，落到不同人手里会跑出天差地别的结果，原因也正在这里。

在你说清楚 base model 和 eval 的覆盖广度之前，「我需要多少 SFT 数据」这个问题没有答案。 这不是打太极，而是整个文献里最大的单一效应。拿 800 条精选的长 reasoning 样本，去 fine-tune 同一家厂商、相隔一代的两个 32B 模型（Qwen1.5-32B-Chat 和 Qwen2.5-32B-Instruct）：AIME24 在较老的 base 上只到 9.2%，在较新的 base 上则到 63.3%。仅仅 base model 的差别就带来 54.1 分的摆幅，比我为写这篇文章读过的任何论文里的任何数据干预都更大（Ye et al., 2025）。剩下的分歧则由 eval 的广度来解释。在单一的开放式对话指标上，质量在约 2K 条样本时就已经进入平台期，数据再多 16× 也买不到任何东西（Zhou et al., 2023）。而在一个由刻意补齐能力缺口构建出来的 12 项技能平均分上，性能在 939,344 条样本时仍在提升（Lambert et al., 2024）。两者都是真的。窄 eval 之所以很早就饱和，是因为窄 eval 度量的是一种行为，而行为很便宜。

「有多便宜」值得内化，因为它会重构你对整个阶段的理解。 三十条多轮样本，就把一个模型的「优秀」回答比例从 45.2% 提到 76.1%，并把对话失败从 42 轮里的 15 次降到 46 轮里的 1 次（Zhou et al., 2023）。六条样本就足以装上稳定可靠的结构化输出。SFT 数据的单位不是一条样本，而是一种行为；在一个已经具备底层能力的 base model 上，一种行为的成本是个位数到两位数条样本。它买不到的是能力本身——这正是通往 distillation 那一节的桥梁，也是为什么 SFT 正确的心智模型是一道就绪闸门：它决定的是，模型是否能被要求交出它本来就知道的东西，以及 RL 接手时是否有一个可用的 policy 可供改进。

这些坐标轴是有先后次序的，而且这个次序并不是大家争来争去的那一个。「质量还是数量」是一个提法很糟的问题；证据支持的是一个严格的优先级：

1. 正确性是一道闸门，而不是一个坐标轴。 在可验证的领域里，错误数据具有负价值。一份 100K 条样本、未经筛选的数学 reasoning 语料（NuminaMath，一个外部数据集）只拿到 32.3，而未经 fine-tune 的 base model 是 49.9——训练本身造成了 17.6 分的损伤（Ye et al., 2025）。而在同一个 base model、同一套 eval 上，800 条精选样本拿到了 78.1。
2. 其次是 prompt 多样性，因为它决定天花板。 在 response 质量相同、数量相同的条件下，多样化的 prompt 胜过同质化的 prompt，在 1–6 分制上是 3.83 对 3.49（Zhou et al., 2023）。在复杂度与质量都固定的情况下，仅靠基于多样性的筛选就能把 MT-Bench 从 5.82 → 6.17（Liu et al., 2023）。而在 ablation 做得最彻底的那份开源配方里，单项 ablation 造成的最大跌幅，来自移除那批只为了注入多样性而存在的 persona 条件化数据：IFEval −19.2 分，相比之下，移除全部数学数据是 GSM8K −12.1（Lambert et al., 2024）。
3. 再次是 response 质量，因为它决定斜率。 只用一个更强的模型重新生成 response 字段、一个 prompt 都不改，就把获得最高一档评级的输出比例从 44.4% 提到了 54.4%（Wang et al., 2022）。
4. 最后才是数量，而且只有在前三条都成立之后，它才是免费的。 经过精选的 backtranslation 数据，每单位 log-example 带来 6.95 个 win-rate 点，而人工精选是 2.86、Alpaca 是 1.99（Li et al., 2023）——所有数据都会随规模提升，但「精选且多样」的数据提升速度快 2.4×。

已发表的数据筛选信号里，大多数都还不如随机，而且失败的方式彼此押韵。 在一项受控比较中，在同一个候选池、固定 6K 预算的条件下，基于 perplexity 的筛选在两个池上分别得到 4.06 和 1.89，而随机筛选是 5.84 和 4.93；按 instruction 长度筛选在噪声更大的那个池上得到 4.00，在那里低于随机，在另一个池上也只是打平；但按 response 长度筛选得到 5.65，高于随机（Liu et al., 2023）。长度在输出侧是有信息量的，在输入侧则是误导性的；而高 perplexity 最后被证明其实是在挑那些极短的 response。真正有效的信号共享同一种结构：它们让候选之间互相比较，而不是孤立地给每一条打分。让 judge 去评一条 instruction 的复杂度，结果是所有东西都被压缩到 7–8/10；而把这条 instruction 演化五次，再让 judge 在同一个 prompt 里对全部六个变体排序打分，就能产生真实的区分度（6.27 对直接打分的 5.16——不过这是拿一个全池数字去比一个 50K 子采样数字；在 50K 上对齐后是 5.73）。同样的原则也解释了，为什么最强的 reasoning 数据筛选器压根不是一个 judge，而是一次测量：保留那些强 reasoner 在 32 次采样里只解出 1–3 次的题目。在解答来源固定不变的前提下，只改变你挑哪些题目，就值 AIME24 上的 +16 分（Ye et al., 2025）。

洞察 —— 成组打分，不要孤立打分。 这批文献里每一个可靠的数据筛选信号都是相对的：让六个演化变体互相排序、在 32 次采样上测一个解出率、把 embedding 距离与已经选中的邻居作比较。每一个不可靠的信号都是绝对的：给这条样本打 1–10 分、取它的 perplexity、量它的长度。如果你正在造一个数据打分器，而它的输入是单条样本，那就做好它跑不过随机筛选的准备。

离开这个阶段之前，还有两点必须诚实说明。第一，「less is more」类结果更多时候是算力效率结果，而不是性能结果——就连那篇主张 800 条样本的论文，报告自己最好成绩时用的也是它最大的数据集规模（2,000）。第二，SFT 更多是在锐化而不是在拓宽，而如果后面还要接 RL，这一点就很关键：一次 self-taught-reasoner 风格的 SFT 在 pass@1 上涨了 +1.94，在 pass@64 上则什么都没涨；而对每道题用多个已验证解答做 mid-training，则在两者上都有提升（RRV et al., 2026）。如果你的 SFT 阶段是给 RL 做 cold start，那就用 pass@k 而不是 pass@1 来评估它，因为 pass@1 恰恰是那个奖励你把分布收窄的指标——而那个分布，正是你接下来要让 RL 去探索的。

RL 数据是 prompt，不是答案

关于 RL 数据，最常见的一个误解是：它是一份正确答案的数据集。它不是。一条 RLVR 样本是一个任务加一个 checker，而答案——如果它真的存在的话——只是 checker 的一个实现细节。这会改变你要采购的东西。你买的不再是 response，而是那种「成功与否可以被机械地检测出来」的题目，而这是一种稀有得多、也昂贵得多的对象。

一条好的 RL prompt，其一阶属性是它能产生 reward 方差。 在 group 归一化的 advantage 下，一条所有 rollout 得分都相同的 prompt 贡献的梯度字面意义上为零，所以通过率被钉死在 0 或 1 的 prompt 就是在浪费算力。我所知的两种已发表筛选准则都是这一点的可操作化——而且第二种准则的作者明确表示，他们的准则「不一定是最优的」，也不是他们那个结果里真正吃重的部分：一种按每个 prompt 逐 epoch 的 reward trajectory 与平均学习曲线的贴合程度打分，保留贴合最好的 16.3%，从而达到全量数据集的性能，并比同等规模的随机子集高出 8.7 个平均分（Li et al., 2025）；另一种则干脆保留历史 reward 方差高的 prompt（Wang et al., 2025）。

「不可解」比「不存在」更糟。 这是需要记住的那个不对称性。在那项单样本研究里，用一道模型从来解不出的题目去训练，会把 MATH500 拖到 45.0——低于只给 format reward 时能拿到的 65.6，而且只比 base model 高出一点点。一条通过率为零的 prompt 不是「难数据」；它要么真的超出能力范围，要么标注错误，要么根本无法验证，而这三种情况需要的应对方式完全不同。从来没被解出过的那一档，系统性地富集着坏掉的任务（Verification Horizon），所以「筛出最难的样本」这句口号，会悄悄地把垃圾塞满你的训练集。与之相关的一个发现是：宁要完整题目，也不要它的困难子步骤。把一道题削减到只剩那一步困难的算术，平均分会从 35.0 掉到 30.0（Wang et al., 2025），因为围绕这一困难步骤的 chain-of-thought 本身就是训练信号的一部分。

而所需的 prompt 数据量比任何人预期的都小，小到应该让你起疑。 一条训练样本就在六个 benchmark 上拿到 35.7 的平均分，而包含它在内的那个 1,209 条样本的数据集是 35.9。在这单独一道题上，训练准确率在第 100 步之前就饱和了，而测试准确率还会继续上升 1,400–1,900 步——这是饱和后泛化；而且在这一道题上跑掉数百万次 rollout 之前，模型都不会 overfit。

这个结果，以及与它相伴的另一个结果，逼出了一个你应该对自己的训练 run 也问一遍的问题。

你的 RL 是在教，还是在唤起？ 在 Qwen2.5-Math-7B 上，用随机 reward——抛硬币——做 RLVR，在 MATH-500 上涨了 +21.4 分，而 ground-truth reward 是 +29.1；也就是说，噪声复现了全部有监督增益的 73%。刻意给错误的 reward 则涨了 +24.1。这里的机制是被识别出来的，而不是被断言出来的：GRPO 里的 clipping 项不对称地偏袒本来概率就高的 token，于是更新过程会不断把 prior 里已有的东西往上棘轮；用三种不同方式去掉 clipping，随机 reward 带来的增益就消失了（Shao et al., 2025）。在没有这种可被利用的 prior 的模型上，图景则完全反转：OLMo2-7B 从 ground-truth reward 得到 +15.5，而每一种虚假的替代 reward 都是持平或负的（多数投票 −6.4、随机 −8.3、format +0.4）。

这种二分并不是 RLVR 的属性。它是你那对（model, domain）组合的属性，而且测起来很便宜。由此就得到四组对照——在相信任何 RLVR 结果之前，包括我自己的结果，我现在会认为它们是必需的：

一次 RLVR 训练的四组对照（Shao et al., 2025）。它们中的任何一组，都可能把一个头条级结果变成零结果。

实际后果落在「钱该花在哪」上。 如果 format reward 就能吃掉你大部分增益，那你是在做唤起，reward 的内容几乎可以互换，在 verifier 质量上的投入基本是浪费。唤起本身也会饱和——已经做过 RL post-training 的模型，在任何 reward 下的增益都很小，包括 ground truth。prior 只能收割一次。反过来，所有 verifier 质量带来了巨大且持久增益的场景，都是 prior 撑不住模型的场景：带过程监控的 agentic coding、跨领域科学、截止时间之后的评测。正是在这些地方，「验证才是资产」这句话是字面意义上成立的，而不只是一句修辞。

关于标签噪声，形状比比例更重要——这一点我在验证阶梯里提过，值得在 prompt 筛选的语境下再说一遍。无偏噪声只是让性能退化；有偏噪声则会带偏方向。六成标签随机出错，代价大约只有 1.3 个平均分（Wang et al., 2025）。而一个规则 verifier 的 false negative，其代价比它的比例所暗示的要高，因为它们集中在最难、最新颖、格式最不寻常的那些正确答案上——恰恰是你想要推进的前沿——而且随着模型变强，它们只会更糟（Huang et al., 2025）。筛查坏 gold label 的廉价手段是多数投票：对 RL 之前的模型采样 64 次，把「相对多数答案与标签不一致」的 prompt 标记出来（Shao et al., 2025）。不一致要么意味着标签是坏的，要么意味着题目是真的难，而你需要知道到底是哪一种。

权衡 —— prompt 筛选作为算力杠杆，比作为性能杠杆更可靠。「less is more」的说法被过度推销了，而最干净的反证就藏在一篇主张做筛选的论文里：9,139 条经 evaluator 筛选的样本拿到 23.52，而全部 19,050 条仅经规则筛选的样本拿到 24.75（Verification Horizon）。未经筛选、规模翻倍的那一组赢了——但要注意，它的最好成绩出现在 600 个训练 step，而筛选后的那一组是 450 步。作者自己也说得很直白——在更高算力成本下，把数据量翻倍可以补偿质量 filter 的缺席——并把这一结论的适用范围限定在受限的候选池上。请把 curation 当作一种用更低成本达到同一个数字的手段，并对任何声称它能抬高天花板的人保持怀疑。

Agent 层面的数据：environment、任务、rubric、trajectory

在这个栈的顶端，一条训练样本就是一段软件。 它是一个可重置的 environment、一个针对该 environment 状态定义的任务，以及一段读取最终状态、判断任务是否完成的程序。这三者不可分割：没人能检查的任务不是一条样本，没有可复现初始状态的 checker 也不是 checker。这里的产物是 Dockerfile 和 test harness，而成本的计价单位是工程师小时和 container 秒。

最初那套配方的产出率，解释了为什么它之后的一切都是在设法逃离它。 SWE-bench 把已合并的 pull request 变成可执行任务：人写的 issue 是 prompt，人写的 fail-to-pass test 是 checker。来自 12 个 Python 仓库的大约 90,000 个 pull request，最后只剩下 2,294 条实例，产出率 2.5%；而杀掉绝大多数候选的那一条约束是，这个 pull request 必须同时修改测试文件（Jimenez et al., 2023）。正是这条约束让一条样本变得可评分，也正是它给供给量设了上限。

图 5. Agentic 数据工厂：任务是针对一个已经搭好的 environment 铸造出来的，checker 与任务一同生成并由执行来验证，而三分之二的候选在跑第一次 rollout 之前就已经被丢弃。

Environment 优先，任务针对它铸造

把 environment 建一次，然后针对它铸造任务。 SWE-smith 为每个仓库构建一个 Docker image，配上一套基本能通过的 test suite，然后往里注入 bug；一个候选有效，当且仅当它弄坏了一个原本能通过的测试——于是执行一次就同时给出了任务和 grader。128 个仓库产出 50,137 条实例，花费 $1,360 和大约 20 小时人力，其中大部分时间用在核验一个 agent（智能体）写出来的安装配置上（Yang et al., 2025）。每仓库一个 image，50k 个任务占 295 GB；每任务一个 image，2,438 个任务就要 6 TB。

这个领域剩下的部分，都是针对一个活的系统去跑逆向构造。 先做点什么，观察发生了什么变化，事后再把它描述出来——这样得到的任务在构造上就是可执行的，因为它本来就是从一次执行里推导出来的。

通往一条 agentic 样本的六条路线。唯一一条没有基于执行的 checker 的路线，也是唯一一条没有正确性信号的路线。

在生成任务的同一次调用里把 checker 也生成出来，然后靠运行它来验证它。 VERIGEN 的 proposer 会同时产出一个任务和一个可执行的 judge，第二个角色对这个 judge 做静态审查，第三个角色在 container 里 dry-run 它，测试目标状态是否可达、是否被正确打分。去掉那个静态审查角色，可执行 judge 的比例就从 94.5% 掉到 62.3%（Lv et al., 2026）。而这些 judge 在一次 160 条 trajectory 的审计中，也只和专家人类达成 82.5% 的一致率——所以这里的「可验证」意思是确定性，而不是正确。一旦 checker 的问题解决了，多样性就是结构性的而非词汇性的：覆盖 373 个工具的 12k 条任务，用少 4× 的数据打败了固定两工具池上的 48k 条任务（Chen et al., 2026）。

洞察 —— checker 的作者不能看到解答，而 agent 不能看到 checker。 CLI-Universe 把写测试的 agent 与写解答的 agent 相互隔离（Hua et al., 2026）。镜像式的错误则是把 grader 泄漏进 prompt：把失败的测试直接当作 issue 文本交给 SWE-smith 的 student 之后，它在 500 次运行里只有 127 次尝试复现问题，而不是 379 次。

在你花掉一次 rollout 之前就该跑完的闸门

拒绝本身就是设计，而且它应该发生在 rollout 之前，因为钱都花在 rollout 上。 CLI-Universe 的候选经过四道闸门，保留率依次是 100% → 70.0% → 56.0% → 42.0% → 33.6%。它自己的 ablation 拿掉的是 pipeline 的其他部分，而不是这些闸门——在 Terminal-Bench 2.0 上，资产策略 −6.2、测试用例 rubric −3.9、查询 rubric −3.4——但这个结果的形状是：没有任何单一组件是承重的，而它们合在一起是承重的。

提示条件检验这道闸门是最值得偷师的：它是唯一一个能把「不可能」和「难」区分开的廉价测试。

难度是被工程出来的，不是被找出来的。 CLI-Universe 把真实的仓库与文档证据折进每一份规格里，并把通过率从 68.2% 降到 54.9% 当作这件事的目的来报告。VERIGEN 则按每个任务成功率移动平均上的一个高斯分布（中心在 0.5）来加权采样，理由是机械性的：一个 GRPO group 里如果所有 rollout 都成功、或者全都失败，组内 advantage 就是零，整个 group 都被浪费掉。

权衡 —— 难度对 RL 确有可见的回报，对 SFT 则未必。 SWE-smith 的难度评分器（在 1,699 条人类标注上准确率 75.3%）追踪的是可解性：专家在 easy、medium、hard 三个子集上的解决率分别是 58.6%、41.0% 和 17.0%。但用难度 2、4、6、8 各 500 个任务的 SFT 数据集训出来的 student，pass@1 分别是 12.4、10.8、13.6 和 12.2，基本是平的。CLI-Universe 只做 SFT，却把它的增益归功于难度——所以这是一处尚未解决的分歧，而不是一条已成定论的规则。

Trajectory 是错误的采集单位，却是正确的过滤单位

你没法像订购标注那样订购 trajectory。你只能跑 rollout，然后留下幸存者。 SWE-smith 在 8,686 条实例上做了 17,906 次尝试，得到 6,457 次成功解决的运行，再把每条实例上的 trajectory 上限设为三条，最终得到 5,016 个 SFT 数据点。R2E-Gym 从 4,578 个 environment 中的 2,048 个里拿到了 3,321 次成功，也就是说，只有 44.7% 的 environment 曾经产出过一次成功——大多数什么都没产出（Jain et al., 2025）。

只保留成功样本，其价值高于它删掉的那些数据。 在任务和 teacher 都固定的条件下，CLI-Universe 只留成功的 6k 数据集在 Terminal-Bench 2.0 上拿到 33.4，而完整的 10k 数据集只有 28.2——也就是说，删掉 40% 的语料值 5.2 分。异议来自 GUI 方向：OS-Genesis 给每条 trajectory 打 1 到 5 分，并按这个分数成比例采样，而不是拿它当硬性门槛，结果打败了「只保留完整轨迹」的二元标注方案（Sun et al., 2024）。一个说得通的调和是领域差异：一条失败的 GUI trajectory 里仍然包含正确的视觉 grounding，而一个错误的 patch 包含的是一次错误的映射——但没有人做过交叉实验来验证。真正的变量其实不是「失败」：SWE-smith 之所以给每条实例的 trajectory 设上限，是因为被反复解出的简单任务同样会让模型变差；所以真正有害的，是两个极端上的低信息量。幸存下来的数据不会单独拿去训模型，而是进入一个混合配比，大约是 0.2 的 agent 数据配 0.8 的通用 instruction 数据，因为只用 agent 数据训练，会让一个 7B 模型在 held-out agent 综合指标上从 0.67 崩到 0.09（Zeng et al., 2023）。

要点。 失败的 trajectory 是糟糕的模仿对象、优秀的 verifier 训练数据，以及极好的 curriculum。ARCO（Tian et al., 2026）把一个刻意较弱的 policy teacher 与一个很强的 rubric teacher 配成一对，因为一个近乎完美的 teacher 不会留下任何有缺陷的动作，供 evaluator 学着去惩罚。 VERIGEN 则在 rollout 最早发生偏离的那一步把失败任务切开，把每个子目标变成一个带自己 verifier 的更简单任务，价值 OSWorld 上的 4.1 分。

Rubric，以及它失败的两种方式

rubric（评分细则）是你在没有测试可用时写出来的东西：一组带正负号权重的判据、一个对每条判据返回「满足」或「不满足」的 judge，以及一个归一化的加权和。它是这里唯一一种能给「执行看不见的东西」打分的机制。令人不适的基线事实是：rubric reward 经常打不过一个二元 reward。在多跳 QA 上用一个 4B policy，三种已发表的 rubric reward 方法的 exact match 分别是 38.00、34.80 和 32.20，而朴素的二元 reward RL 是 39.40 和 41.00；其中最弱的那一种甚至低于未经训练的 base model 的 34.40，次弱的那一种基本与它持平（Tian et al., 2026）。

饱和是第一种失效模式。 随着 policy 变强，它越来越多的采样都能满足每一条判据，reward 也就失去了方差。把一个联合训练的 rubric 生成器按「其评分在采样答案上的标准差」来给奖励，在 4B 上相对外部撰写的 golden rubric 能买到 15.82 → 20.80；而在分布外，那些 golden rubric 会让 instruction-following 掉 15.3 分，共同演化出来的 rubric 却涨了 6.2（Ding et al., 2026）。这份证据来自单轮医疗 QA，且每种配置只跑了一次，所以它要靠论证才能延伸到 agent 上。

错位是第二种，也是真正会咬到 long-horizon agent 的那一种。 当每个动作都配一份全新的 rubric 时，唯一把 step 得分与现实绑在一起的约束，就是它们加起来要等于 trajectory 的最终结果——这只钉住了总和，对分布只字未提。最终答案那一步的得分预测成功的 AUROC 是 0.82–0.87，而中间搜索步骤的得分只有 0.58–0.65，随机水平是 0.50（Tian et al., 2026）：step 信号最可靠的地方，恰恰是 credit assignment 最不重要的地方。粒度是非单调的，在每步三条判据时达到峰值（exact match 42.80，相比之下一条时是 41.00、七条时是 40.60），因为九条判据实际上也只覆盖大约三个不同的主题。

这里真正未解决的，大部分是测量问题。 没有人发表过端到端的「每条可用 trajectory 的成本」；上文那个大约 $1 每条被接受任务的数字，只覆盖了合成环节。也没有人测量过一个不完美的 judge 究竟要付出什么代价——82.5% 的 judge–人类一致率和 68.7% 的 OSWorld 成功率被放在一起报告，却没有任何关于「缺失的那 17.5% 对天花板意味着什么」的估计（Lv et al., 2026）。这又是 verifier 鲁棒性问题，而且在这里更严重，因为 judge 是每个 environment 一份，而不是共享的。至于针对 environment 状态的 reward hacking（奖励作弊），被断言的程度远大于被测量的程度：被引用最多的那个数字——只用结果 reward 时，大约 40% 被正向强化的 episode 其实歪曲了某条约束——出现在正文行文里，背后没有表格、没有样本量、也没有任务集（Arora et al., 2026）。不过它提出的防御手段便宜到值得直接采用：把 episode 结束时的实体计数与初始化时的基线作比较，这能抓到那种靠伪造记录来达成目标的 agent。

开放问题 —— 没有人单独测量过「恢复」的价值。 这里没有任何一项 ablation 去比较「先失败、再恢复的 trajectory」与「直接成功的 trajectory」。这一点很重要，因为验证恰恰是前沿 agent 最不擅长的事：在 Terminal-Bench 2.0 上横跨四个前沿模型，验证类失败——也就是一次看起来合理、却从未正确检查目标状态是否成立的尝试——占全部失败的 47–60%，比执行错误还多（Hua et al., 2026）。你的 pipeline 最需要教会的那种行为，恰恰是你那个「只留成功」的 filter 最不可能包含的。

把 distillation 当作一种数据获取策略

大多数关于 distillation（蒸馏）的讨论都在谈损失函数。这个框架恰恰掩盖了真正重要的那个决策。Distillation 本质上是一种获取监督信号的方式，而人们围绕它提出的每一个问题——用 forward KL 还是 reverse KL、off-policy 还是 on-policy、我的 student 能不能超过 teacher、为什么换了更强的 teacher 反而变差——都是两个事实的下游产物：你能从 teacher 那里物理性地提取到什么数据，以及你和 teacher 之间隔得有多远。把这两点想清楚，损失函数几乎是机械地推导出来的。

让我把这个实际问题直接摆出来，因为它既是我在面试中被问到过的问题，也是本节余下部分要回答的问题：我手上有一个小模型。前沿模型已经存在，而且强得多。我该怎么办？

按 access tier 划分，你能拿到什么

你的 access tier（访问权限层级）决定了你的目标函数集合。这不是细节，这就是整个设计空间。

各 access tier 及其所允许的目标函数。结构性难题在于：实践中信号密度与 teacher 强度是反相关的，因为最强的 teacher 只能通过 API 访问。

在这个阶梯上每往下走一级的代价都是可测量的，而且比你猜的要小。 从完整 logits 降到 top-k = 128，validation loss 增加 +0.11 nats——但 top-k = 128 配合 30% 的 ground-truth next-token loss 只增加 +0.01 nats，在统计上与完整分布无法区分（Busbridge et al., 2025）。这是整个 distillation 文献里最实用的一个数字，因为在 32k 词表下，完整的 float32 teacher logits 每个 token 大约要占 129 KB，2T tokens 就是大约 260 petabytes。正是截断加上一点 hard-target loss，才让离线复用 logits 在物理上成为可能。

从 gray-box 降到 black-box，你失去的是纠正的方向，但并非全部信号。两个锚点，都被那篇 on-policy distillation 综述收录（Song et al., 2026）：一个 770M 模型用 teacher 的 rationale 而不是 teacher 的标签来训练，只用一半的样本就打败了 540B 的 teacher；以及来自 black-box teacher 的离散口头评分——字面意义上就是让它打 0–9 分——在 web QA 上换来 +12.9% 的 exact match，在数学上换来 +25.7%。那篇综述的总结值得记住：on-policy 探索本身就贡献了相当大一部分学习信号，而 teacher 的角色更接近于在 student 的若干条 trajectory 之间做选择，而不是逐 token 地纠正。

洞察 —— 过程数据才是护城河，而市场的行为也印证了这一点。 可蒸馏数据的价值梯度是：最终答案 < 代码与工具调用 < 完整 agent trajectory < 原始 reasoning trace。支持这一排序最有力的证据不是某个实验，而是一个产品决策——前沿 reasoning API 只暴露 chain of thought 的摘要，却扣住 trace 本身不放。社区中还长期流传着一些未经证实的说法，称存在一个专门提取这份被扣住的产物的灰色市场；我不打算为它标注来源，也不打算复述其内容，但这类说法的存在本身，就是关于价值究竟沉淀在何处的一个观察。站得住脚的技术结论是：如果重要的是过程，而过程恰恰是你买不到的，那么你想要的目标函数，就是那个在本地生成过程、只让 teacher 来打分的目标函数——也就是 on-policy distillation。

容量差距（capacity gap）

更好的 teacher 可能训出更差的 student，而现在我们有了一个数字来标记它从哪里开始。 Student 的 cross-entropy 关于 teacher 的 cross-entropy 服从一条 broken power law（Busbridge et al., 2025），断点位于

L_T / L̃_S = 1.315 (90% CI 1.302–1.327)

其中 L̃_S 是同一个 student 在相同参数量与相同 token 量下、用普通监督训练所能达到的 cross-entropy。有三点让这个版本值得背下来。它是学习容量之比，而不是参数量之比——相对规模只是其中一个特例。Teacher 只通过它自身的 cross-entropy 进入这条定律，因此 teacher 的参数量与 token 量作为搜索维度被完全消掉了，你可以直接按 validation loss 来挑 teacher。而且机制是可测量的：teacher 与 student 之间的 KL 散度会随 teacher 能力上升，所以越过断点之后，student 会发现 teacher 太难拟合，于是不再从 teacher 的改进中获益。

同一条定律还给出另外两个会重置默认直觉的结论。相比监督训练，distillation 的 loss 对参数更不敏感，对 token 更敏感——拟合出的指数从 α = 0.408, β = 0.431 变成 α = 0.321, β = 0.637。而因为 compute-optimal 的参数占比是 β/(α+β)，这反而把分配推向了另一个方向：参数占比从 Chinchilla 式的 0.51 升到 0.66，token 占比则从 0.49 降到 0.34。对数据的回报更陡，意味着你会更早耗尽数据这个轴，于是边际的那份 FLOP 就流向了模型宽度。以及，distillation 在渐近意义上无法胜过监督学习。 作者给出的双条件判据足够干脆，可以在设计评审上逐字引用：当且仅当 (i) student 的算力或 token 预算低于一个与 student 规模相关的阈值，并且 (ii) teacher 已经存在、或其成本将被摊销到不止一个 student 身上时，distillation 才更高效。否则，直接训 student。就连 weak-to-strong generalization——student 打败自己的 teacher——最后也被证明是有限数据下的假象：给 student 喂足够多的 distillation token，它就会重新漂回 teacher 的 cross-entropy。

容量差距还有一个运行时版本，它测起来更便宜，而且适用于 scaling law 覆盖不到的场景。 在 held-out 集上测量候选 teacher 与 student 之间初始的 per-token KL。校准数据来自一次受控替换：把一个同源的 30B teacher 换成客观上更强的 235B 模型，其他一切保持不变，归一化能力分在一种 loss 下从 0.937 掉到 0.600，在另一种 loss 下掉到 −1.190，训练在第 18 步灾难性发散。两种配置之间可测量到的差别，是初始 per-token KL 的 ~0.19 对 ~0.04（Ma et al., 2026）。在 policy-gradient loss 下——也就是退化而非发散的那一种——student 的 policy entropy 从 0.30 收缩到 0.21，因为它接收到的梯度主要来自 teacher 的低概率区域，是惩罚性的；而在第 18 步炸掉的，是截断的 top-k loss。如果你与 teacher 的 KL 一开始就很高，那么更好的 teacher 就是更差的 teacher——而这只是一次 pre-flight 检查，代价是在验证集上跑一次 forward pass，而不是跑一次训练。

有一个注意事项我想特别标出来，因为它是一处真正悬而未决的分歧，而不是已被解决的问题：一项知名研究把 teacher 从 340M 扫到 1.5B、student 固定为 125M，结果发现 student 的表现与 teacher 规模正相关——根本不存在容量差距（Gu et al., 2023）。目前能给出的调和解释是：forward KL 的 mode-covering 压力会加剧这个差距，而 reverse KL 的 mode-seeking 行为则能部分缓解它，而那条 scaling law 完全是在 forward KL 下拟合的。我倾向于把 1.315 这个阈值看作在 pre-training 式 forward-KL distillation 中已被充分确立，在其他场景下则作为一个有用的先验。

一份 playbook：小模型，强 teacher

下面是我实际会遵循的决策流程，第一个匹配上的分支胜出。

图 6. Access tier 与容量差距决定了方法；损失函数是你最后才选的东西，而不是最先选的。图中数字来自本节引用的文献。

第 0 步。两项 pre-flight 诊断。 测量候选 teacher 与 student 之间初始的 per-token KL 或 top-k 重合度（校准参考上文：~0.04 可行，~0.19 会失败）。测量你的 student 在目标 prompt 上的通过率——如果接近零，on-policy 梯度会消失，你需要先做 curriculum 节奏控制，或者先来一段更容易的 warm-up。

第 1 步。你是在压缩，还是在获取能力？ 如果你是在从零 pre-training 一个更小的模型，就按字面意思套用上面那个双条件判据；如果不满足，那就老老实实做监督式 pre-training。如果你是在对一个已有的小模型做 post-training，继续往下看。

第 2 步。永远从 off-policy 开始。 在 teacher trace 上做序列级 distillation 比 on-policy 便宜 4–5×——综述给出的估计是，在一个 70B→7B 的配置里大约是 300 对 1,200–1,500 GPU-hours，这是一个数量级意义上的数字，而不是实测出来的（Song et al., 2026）——而且它会弥合那个 pattern gap：on-policy distillation 必须先弥合它，才可能奏效。证明单靠 off-policy 就足够的存在性证据是 R1 的 distillation 系列，如那篇综述所转述：~800K 条 trace 训出的 32B student 拿到 72.6% 的 AIME24 pass@1，而在同一个 base 上直接跑 GRPO 只有 47.0%。如果容量比超过 ~10×、且任务的推理深度有界——事实型 QA、翻译、摘要——那就继续留在 off-policy。

第 3 步。当误差会累积时，为 on-policy 付钱。 在以下情况切换：student 大于大约 7B 并且已经在探索静态 trace 流形之外的区域；中间错误会在多步推理中累积；或者 off-policy loss 已经进入平台期，而 held-out reward 在 on-policy rollout 下仍在提升。然后：把 student 自己生成的数据比例开到至少 25%（Agarwal et al., 2023）；按解码机制而不是按意识形态来选散度（采样式或开放式生成需要 mode-covering，指令遵循和唯一正确答案型推理需要 mode-seeking）；负担得起就用全词表 KL，如果要把信号通过网络传输就用带 debias 项的 top-k，如果你能加上方差缩减，那就只用采样到的 token。

第 4 步。只要满足下列任一条件，就把 teacher 当作 verifier，而不是作者。 访问权限是 black-box。Teacher 与 student 来自不同家族。或者你想要超过 teacher——这是决定性的情形，因为 distillation 的目标是天花板，而 reward 不是。这里的存在性证据相当惊人：一个基于 rubric 的 on-policy 方案训出的 4B student 在 AIME25 上拿到 68.75%，而它自己的前沿 teacher 只有 67.08%（Song et al., 2026）。Teacher 从未亲手写下这套获胜行为中的任何一个 token；它只是指出了 student 的哪些尝试是好的。

第 5 步。如果你不得不用跨家族的 teacher，就把它放进 RL 梯度里面，而不是摆在它旁边。 对于「小模型 + 强 teacher」这个设定，这是近期最有用的结果。与其去拟合 teacher 的分布，不如用 teacher 的 log-probability ratio 去重加权 verifier 已经认可过的那些 trajectory 的 advantage，并且只在 advantage 为正的地方施加。让它奏效的正是这个门控：没有它，失败 trajectory 上被 teacher 偏好的 token 反而会受到更大的惩罚，把 student 推离 teacher。单独消融掉这一个组件，平均 pass@1 最多要掉 8.81 个点（Distilled RL）。而且它给出的排序与本节其他所有结论都相反——在他们报告的那一对 student 里，跨家族反而成了这个方法最好的场景（在跨家族 student 上比朴素 on-policy distillation 高 +4.73，而在同家族 student 上只高 +1.16）——而被提出的解释是：teacher 自始至终只是在重新分配一个以 reward 为根基的信号，永远无法把 student 拽出已验证的流形。两个 student 还不足以把它称作一条定律。注意同一张表里还有两处排序翻转：在跨家族设定下，纯 RL（36.86）胜过 on-policy distillation（35.27），而把两种 loss 按 1:1 朴素相加（36.54）仍然没能胜过纯 RL。

第 6 步。不要在 RL loss 旁边随手加一个 distillation loss，然后祈祷。 在三个 student 中的两个上，1:1 的组合都比纯 RL 更差，因为 distillation 收敛得很快，随后就把 student 钉死在一个由 KL 诱导出的局部最优里，而此时 RL 的曲线还在上升。

还有一种模式值得知道，尽管它需要的 teacher 你多半并不拥有。如果你确实掌控自己的 teacher——比如你负担得起从一个共享 checkpoint 出发、按 domain 分别跑 RL——那么我见过的、组合多种能力的最强结果，是先独立训练出各领域的 specialist，然后在 policy 空间而不是权重空间里融合它们，在 on-policy distillation 期间把每条 prompt 路由到与之匹配的 teacher。这种做法能够均匀地回收每个 specialist 91–95% 的提升空间（归一化分 0.937，最好的 baseline 是 0.882，朴素权重平均是 0.328），而且它可以迭代：从融合后的 student 出发重训 specialist，把下一轮的 teacher 推到了 1.030（Ma et al., 2026）。对其他人而言真正有意义的教训在于它的前提条件——每一个 teacher 都是初始化该 student 的同一个 SFT checkpoint 的 RL 后代。真正在起作用的是同源。

要点。 Distillation 能可靠地买到行为，却只能不可靠地买到能力；而且只要你的循环里没有任何东西以真实世界为根基，天花板就是 teacher。尊重上述所有事实的复合配方是：用 off-policy trace 做冷启动，如果误差会累积就加上 on-policy 纠正，在任何你想要超过 teacher 的地方都把 teacher 当作打分者而不是作者，并且在整套东西下面垫一个 verifier，让 teacher 去重新分配 credit，而不是去定义目标。

蒸馏语料的卫生守则

下面这些失效模式是蒸馏数据特有的，而且大多对你正在优化的那个指标不可见。我标注了哪些在文献中被真正测量过、哪些只是动机充分的猜想，因为在这个话题上，这种区分丢失得非常快。

风格以接近 100% 的比例迁移，知识以接近 0% 的比例迁移，而你的 judge 看不出来。 那个奠基性结果至今仍是最锋利的：用某个闭源 chat 模型的输出去 fine-tune 开源模型，把「权威口吻」从 57% 拉到 98%——而这里的天花板（以 teacher 的一个样本去比对它自己的另一个样本来测得）是 98%——把列表格式的匹配度从 13% 拉到 81%，天花板是 83%。在同样的范围内，Natural Questions 的准确率却从 20 掉到 15。众包标注者的评判中，约 70% 的模仿模型输出被认为与 teacher 相当或更好，一个强 LLM judge 也显示出同样的趋势（Gudibande et al., 2023）。与此同时，在 6,000 条任务局部样本上做有针对性的模仿，把同一个 benchmark 从 20 提到了 27，而 teacher 是 31。由此得出的规则是：永远不要把偏好胜率当作能力迁移的证据。 给每一个基于 judge 的评测都配上一个你的模仿数据没有覆盖到的、针对性的能力 benchmark；当两者结论不一致时，相信 benchmark。

蒸馏语料特有的卫生失效模式。最后两项，是人们断言得最笃定、而公开证据最少的两项。

从实践角度给这份清单再补两条。第一条是缺陷 prefix 陷阱：当 student 写出一个分布外的 prefix 时，teacher 对后续内容的条件分布本身就没有校准好，于是你是在满怀信心地蒸馏噪声。第二条是一个几乎不花成本的具体流水线动作：把自我身份标识字符串、厂商名称、拒答套话，以及 system prompt 留下的口癖，从 teacher trace 里过滤掉或改写掉，并在你的评测套件里加一项身份探针。 身份泄漏只是一个更普遍性质的可见端点——蒸馏语料会携带 teacher 的分布指纹，包括它的 contamination 和它的安全行为，不管你想不想要。

洞察 —— 继承如今比学习便宜得多，这就把它变成了一个战略问题。 生成一份大规模 teacher trace 语料的边际成本，与一次训练运行相比已经降到了舍入误差的量级，所以「继承还是学习」不再由预算决定。它由你希望两年后什么是真的来决定。一条每一个监督信号都来自 teacher 的 pipeline，隐含着一张路线图——等下一个 teacher 发布，加一些架构改动，发版——而它的天花板只有在别人的天花板动了之后才会动。一条内部有 verifier 的 pipeline，天花板由真实世界设定。论文用定量结果说明了这一点；产业界则用它选择加密什么来说明这一点。

Contamination：你的评测集也是流水线的一部分

上面的每一个阶段，都把你构建的产物与你用来衡量它的仪器分了开来。Contamination（污染）正是这种分离崩塌的地方：评测集是训练语料的一个子集，或者与训练语料只隔一次 distillation，或者是你的 agent 在推理时下载下来的东西。这让它成为一个流水线问题，而不是一个伦理问题，并且它正好映照出本文的核心问题：谁来保证这条样本不在语料里——而且不在那个生成了这份语料的模型的语料里？

在被干净测量过的地方，benchmark 过拟合最多值 8 个准确率点，而且它是按模型家族而不是按单个模型聚集的。 GSM1k 是 1,205 道人工撰写的小学数学题，在解题步数与答案量级上与 GSM8k 做了匹配，并通过人类「挑出异类」测试验证了与之不可区分——识别率 21.83%，随机水平为 20%（Zhang et al., 2024）。下降幅度：Yi-6B-Chat 43.7% → 35.7%，math-shepherd-mistral-7b-rl 82.6% → 75.4%，phi-2 56.6% → 50.4%。前沿模型则完全看不出问题——gpt-4o 93.1% → 92.9%，gemini-1.5-flash 79.7% → 83.5%，在它训练时还不存在的那个集合上反而更好。

两点限定。这个下降幅度不等于能力：phi-2 掉了 6.3 个点，仍然解出了 GSM1k 的一半以上，大致相当于参数量是它 25× 的 Llama2-70B 所处的位置。而且这个测量依赖 prompt——换成第二种 prompt 格式后，deepseek-math-7b-rl 从看起来很干净的 −3.1 个点，变成了看起来污染严重的 +6.4。

检测是群体统计量，而不是判决书

标准的 membership-inference 方法本身是一个弱信号，却被当作证据来引用。 Min-K% Prob 只用一份文档中概率最低的那 20% 的 token 的平均 log-probability 来给它打分，其理论依据是：没见过的文本里会包含少数几个令人意外的 token，而被记住的文本则不会（Shi et al., 2023）。在 WikiMIA 上，它在五个模型上平均取得 AUC 0.72，而朴素 perplexity 是 0.67。宣传中的「相比最好的 baseline 提升 7.4%」是相对值：绝对上是 +0.05 AUC，而这不足以支撑关于任何单一文档的任何论断。

它恰恰在你最需要它的地方最弱。同一篇论文的下游研究做到了 0.86 AUC，但那是靠在一份 27M-token 的语料（其中插入了每个 benchmark 各 200 条样本）上、以 lr 1e-4 对 LLaMA-7B 做整整一个 epoch 的 continual pre-training 才达成的；把学习率降到 1e-5，BoolQ 上的检测就从 0.91 掉到 0.64。检测效果会随模型规模、文本长度、重复次数与学习率而变好——而这恰好与真正让你担心的那种情形相反：一条很短的 benchmark 条目，在训练后期只被看到过一次。它需要 token 级的 log-probability，而大多数前沿 API 已经不再暴露这个了。作为一个比值来用，它会更强：在一个 unlearned checkpoint 与它的原始版本之间做对比，它标出了 188 个可疑的书籍片段，而原始 perplexity 一个都没标出来。

洞察 —— contamination 与过拟合不是同一个变量。 把每个模型在 GSM8k 上的逐字符 log-likelihood 对它在新集合上的落差做回归，得到 Spearman ρ = 0.36（p = 0.03）（Zhang et al., 2024）——确实存在，但只解释了少部分方差。math-shepherd-mistral-7b-rl 属于过拟合最严重的模型之列，但它在 GSM8k 上的 likelihood 却是最低的之一；作者的假设是：它那个用合成的步骤级数据训练出来的 process reward model，泄漏了正确的 GSM8k 推理链，而题目本身从未出现在训练中。Llemma 则正好反过来：likelihood 很高、语料中确认存在 GSM8k 样本，过拟合却极小。

Decontamination 不是一个你能做完的预处理步骤。 n-gram 与 hash 匹配只能抓到逐字复制和数据集的镜像转储，别的什么也抓不到；embedding 相似度能抓到改写，配上多语言 encoder 还能抓到翻译，代价是一个 recall/precision 权衡——它「可能导致过度的数据删除」（Al-Lawati et al., 2026）。整条链路上没有任何一个阈值是以下游结果为依据来论证的；Min-K% 的 k = 20 来自一次验证集扫描，此后就被到处沿用。而且这些过滤器是「在一个固定时间点」运行的，会漏掉「经由 continual pre-training、模型 distillation，或由被污染模型生成合成数据而产生的间接泄漏」。Contamination 是一个数据集在流水线中某个时刻上的属性，而不是这个数据集本身的属性。

语料过滤器看不见的那些通道

只有最后两行建立在直接测量之上；而第一行，几乎是 2026 年每一条 pipeline 现在都有的那一条。

部署日志回收是其中被测量得最好的一条，而且它看上去就像普通的产品工作。 拿同一个 7B base 做三次 fine-tune，只改变 Chatbot Arena 数据的占比：0% / 30% / 70%，对 Llama-3.1-8B-Instruct 的 ArenaHard 胜率从 23.5% → 42.7% → 49.9%，相对提升 112%，而 MMLU 则是 66.5% → 64.4% → 65.9%（Singh et al., 2025）。没有任何一条题目泄漏；只是这个分数不再衡量能力了，而两条曲线之间的背离是唯一的破绽。同一份审计还发现，2024 年 12 月的 Arena prompt 中有 7.3% 在 2025 年 1 月逐字重现，并指出你其实根本不需要在这些日志上训练：它们同样可以用来在评测分布附近播种合成数据。

检索会把一个干净的模型变成一次被污染的评测。 在 MedQA 的前 100 道题上，Gemini Deep Research 有 60% 的 trajectory 访问过一个同时包含题目和答案的页面，尽管搜索只把它的准确率从 97% 提到 99%（Wang et al., 2026）。在 MedQA 上，答案被显式泄漏的前一轮，准确率是 7.69%，后一轮是 89.74%（n = 39），Cox hazard ratio 为 4.21。两点注意：在六个 benchmark 中的五个上，URL 级别的元数据命中所对应的 hazard ratio 低于 1，所以粗粒度的检测会误导人；而「最高 4%」这个分数虚高的标题数字从未被推导出来——最接近的量是 HLE-149 上 4.05 个点的落差，而它在 MedQA 上是 −1.50，在 MedMCQA 上是 −2.90。这六个 benchmark 全是临床领域的，所以普适性是被断言的，而不是被展示出来的。可迁移的结论关乎 provenance（来源溯源）：一个使用精选 PubMed 索引的 agent 在 MedQA 上泄漏率为 0%，却在抽样的 100 道 PubMedQA 题目中泄漏了 65 道，因为 PubMedQA 就是从 PubMed 构建出来的。

评测完整性是一种系统属性

没有任何过滤器能修好这件事；这些失败散落在系统的不同部位。

要点。 四件仪器。在每一个头条数字旁边都报告一个明确分布外的评测，并去读两者之间的背离，而不是其中任何单独一个数字。给每一个分数附上尝试次数：两个逐字节相同的 Aya-Vision-8B checkpoint 提交到 Chatbot Arena，分别得到 1069 与 1052 分，中间还排着四个模型（Singh et al., 2025）。如果你的系统会做检索，那就把每个评测都跑一遍开搜索和关搜索两种设置，并在准确率旁边公布答案泄漏率。还要留出一份经过审核的 canary 子集——GSM1k 正是靠它来检测那些为了给闭源模型打分而不得不使用的厂商 API 所造成的泄漏。

私有的 held-out 集合以牺牲独立验证为代价换来了干净的测量，而且它需要共享权重或 API 访问权限，这又会把题目重新暴露出去。动态重新生成能够抵抗条目级的泄漏，却摧毁了纵向可比性。

开放问题 —— 一个 benchmark 能否以一种你无法在其上训练的形式发布？ 最有意思的提案利用了 Transformer 中训练与推理之间的不对称性：发布每道题的 KV cache 与倒数第二层的 hidden state，只把答案以明文保留，于是这条题目可以用于推理，却对一次梯度更新毫无用处（Al-Lawati et al., 2026）。这是一篇没有实验的立场论文，它自己引用的文献也说 KV-cache 反演攻击在 multi-head attention 上是奏效的，在 grouped-query attention 上也只是「效果差得多」而已，而且掌握着 anchor 模型的人依然能看到明文。还有两件相邻的事情同样未被测量：contamination 从 teacher 传播到 student，以及一个 LLM judge 是否曾在它所评分的那个评测集上训练过。

数据平台

如果这篇文章的论点成立——随着你沿着这个栈往上爬，数据的单位会从文本变成软件——那么一个认真的实验室要造的就不是一份数据集，而是一个平台。面试官会用一种迂回的方式问到这件事（「你会怎么把这套东西搭起来？」），值得准备一个具体的答案，所以下面就是上文所有内容共同蕴含的组件清单。

一个 provenance 与 lineage 服务。每一条训练样本都需要携带：它从哪里来、由哪个 generator 和哪条 prompt 生成、通过了哪个 certifier 的认证、被哪些 run 消费过。这不是官僚主义：provenance（来源溯源）正是让你能够回答「这份语料是真实的还是合成的，真实的那部分还在不在？」的东西——而这个问题决定了 accumulation 能否保护你不发生 collapse。它也是你在发现某个被污染的来源之后，唯一能把数据撤回的手段，同时还是你能拿到的最廉价的容量干预：给文档前置一个 provenance token，就把语料稀释造成的 20× 容量损失挽回了大部分（Allen-Zhu and Li, 2024）。

一个 decontamination 服务，而不是一个 decontamination 脚本。在 prompt 侧做 n-gram 匹配，对你报告的每一个 eval、你加入的每一份语料都跑一遍，合成语料和 RL prompt 集也不例外。它应该长在平台里，而不是长在每个项目里，因为已经公开的重叠率高到足够吓人，而你是不会记得手动去跑的。

一个 scorer registry（打分器注册表）。质量分类器是 pre-training 里杠杆最高的那个旋钮，也是 mid-training 里最危险的那个，因为它们带有长度偏置，会悄无声息地删掉你的 long-context 数据和 agent trajectory 数据。给每个 scorer 登记它是在什么来源分布上 calibration 的、它的长度—响应曲线，以及正在使用的阈值——并且永远把「保留来源分布的随机选择」作为 baseline 一并报告，因为它能打败大多数已发表的 filter。

一个 verifier registry，并且附带对抗测试集。每一个 checker 都是一份软件：有版本号，有在你自己数据上实测出来的 precision 和 recall，还有一套它必须能够抵抗的对抗模式。阶梯那一节给出的、没有商量余地的教训是：静态准确率并不能预测 RL 的结果，所以你要做版本管理的工件是 verifier（校验器）加上它的攻击测试集，而且随着 policy 变强，这套测试集必须重新生成。

一条 oracle 通道。在每个 checkpoint 上，采样约 1,000 条训练 prompt，重新生成，然后用一个强力的外部模型给它们打分。把 training reward 和 oracle reward 画在同一张坐标轴上。这两条曲线之间的背离，是我所知最可靠的 reward hacking（奖励作弊）警报；而且和 held-out eval 不同，它的代价只是每个 checkpoint 一次生成。

一个 environment registry。container 镜像、随机种子、任务规格、rubric（评分细则），以及一份双向的验证记录，证明 checker 在未修复的实例上判失败、在已修复的实例上判通过。这部分毫无疑问就是软件工程，也正是在这个栈的顶层，人力真正投进去的地方。

私有的、轮换的、新鲜采集的 eval。不管你对外公布什么，都要保留一份永远不出公司的 held-out 集合，按固定周期轮换其中一部分，并维护一套在每个 checkpoint 上都会跑的非回归测试集。原因写在污染那一节里，而它背后的激励分析很简单：contamination（污染）不只是网页爬取的意外产物，它更是一个组织在自己的目标函数坍缩成一个分数之后，会自然漂移过去的终点。

决策指南

这篇文章存在的意义就是回答下面这些问题，这里是压缩版的答案。每一条都能用上文的证据站住脚；但没有哪一条可以替代你在自己的技术栈上亲自测量。

开放问题

下面这些缺口，是我没能从文献里解决掉的；我把它们表述得足够精确，以至于值得动手去做。

没有人测量过 replay 比例与知识增强之间的交互作用。做增强的那批论文把 replay 固定在 10%，从不扫描它；做 replay 的那批论文扫描它，却从不做增强；两项重要的 mid-training 研究干脆完全没有报告 replay 比例，因为它们改成把通用网页数据折进混合配比里了。如果真的存在一套统一的 continual pre-training 旋钮组合，那这里就是缺掉的那一格。

model collapse 从未在前沿规模上被检验过。已发表的每一个 accumulation 对 replacement 的实验，都在 126M 参数或以下，而 accumulation 的界是单次迭代误差的 π²/6 ≈ 1.645×（Gerstgrasser et al., 2024）——这是实打实的 64% 惩罚，不是零。这个常数随规模是保持、增长还是缩小，无人知晓；而它是整个 synthetic data 策略背后的一条承重假设。

基于代理模型的混合配比优化，没有任何一种方法能在自己的假设下存活。排序不变性至少因为三个彼此独立的原因而失效——重复带来的混杂、最优点确实会随规模移动，以及对领域粒度的敏感——而那个让这套做法成为领域标准的方法，一旦领域是按语义而不是按 provenance 定义，就会输给均匀采样。目前没有公认的替代方案。

不存在能够预测 RL 结果的 verifier benchmark。这一点上唯一干净的实验是一个负面结果：一个在静态 recall 和 precision 上都有提升的 verifier，跑出了那篇论文里最差的一次 RL run。在有人做出一套排序与下游 RL 表现相关的评测之前，verifier 的选择仍然是一件靠经验、逐项目摸索的事。

contamination 从 teacher 传播到 student 这件事，无人测量过。它被广泛断言，机制上也显而易见——蒸馏出来的 trace 携带着 teacher 见过的东西——但我没有找到任何一篇论文测量了它的效应量。身份与 provenance 泄漏也是同样的情况：它是「persona 几乎完整迁移」这一结论的直接推论，却没有任何已发表的测量。

条件化多样性与采样式多样性从未被组合使用。persona 条件化会把 generator 的众数搬动很多次；分布层面的 prompting 则会把被采样的那个分布压平。两者都有效。据我所知，没有人把它们放在一起跑过，而后者几乎不花钱。

reverse KL 与 on-policy 采样下的容量差距仍未解决。1.315 这个阈值完全是在 forward、off-policy 的 KL 下拟合出来的，而至少有一项严谨的研究发现，在 reverse KL 下根本不存在这个差距（Gu et al., 2023）。既然实践中几乎所有 post-training 蒸馏都是 reverse KL 且 on-policy 的，那么人们真正需要的正是这个版本的定律——也正是没有人拥有的那个版本。

数据归因在每一个阶段都是缺失的。本文中没有任何一个结果能告诉你，是哪些训练样本造就了哪项能力。文献里的每一种筛选方法，都是对一个我们尚且回答不了的归因问题的代理，这也正是它们当中如此多的方法会输给随机选择的原因。

附录：面试问题

我写这篇文章，部分原因就是不想再临场发挥地回答这些问题。所有好答案的套路都是同样的三步：点出阶段、点出在这个阶段是谁在认证正确性，以及给出一个数字，连同它的 baseline。下面是压缩版；上面那些章节是演算过程。

框架

「合成数据还是真实数据？」（”Synthetic data or real data?”） 先否定这条轴，然后把它重建起来。真正能预测行为的问题是：谁提供正确性信号——人、teacher，还是世界——而每一份配方都是在这三者之上的一个投资组合，并随着你在栈上往上爬而不断轮换权重。接着给出那条承重的观察：最大的、可靠的 synthetic data 胜利，来自加在真实文本之上的合成标签，而不是合成文本。有一份语料在 38B token 上达到了 33.6% 的 MMLU，而次优者需要约 300B；其机制是用一个 70B 模型给 460k 个网页的教育价值打分，把它蒸馏成一个廉价分类器，再用约 6,000 H100 小时把它应用到 15T token 上。

「今天训练数据真正的瓶颈是什么？」（”What is the actual bottleneck in training data today?”） 是验证，而且它会随着你往上爬而反转。在底层你有 10⁹–10¹⁰ 份文档，每份文档的验证成本为零；在顶层你有 10²–10⁴ 个任务，每一个都可能需要一个 container 和一个经过验证的 checker。单样本的验证成本上升五到六个数量级，而样本数量下降同样多的数量级——这就是为什么「多搞点数据」在底层是对的，在顶层几乎总是错的。

「你怎么看待数据质量？」（”How do you think about data quality?”） 质量不是文档的属性，它是文档与任务之间的一种关系。证据是：一个与人类标注者的一致性达到约 82% ROC-AUC 的 filter，训出来的模型反而不如一个朴素 bigram 分类器；而标注者一致性与下游分数之间的相关性 R² < 0.3。选择正类的参考语料，比选择分类器更重要——指令数据加上一个「大白话解释」类的 subreddit，比以 Wikipedia 和书籍为参考集的方案高出 3.5 个点。

Pre-training

「pre-training 数据是一个已经解决的问题吗？」（”Is pre-training data a solved problem?”） 不是，而且最近有三条公认的信念被推翻了。deduplication 不是单调有益的——跨 snapshot 的全局 dedup 会优先保留广告和关键词垃圾；在某一次爬取上，幸存下来的 31B token 训出来的模型，反而比它扔掉的那 171B token 训出来的更差。作为杠杆，filtering 胜过架构，而且它本质上是一个参考语料的决策。另外，选择的单位可以比文档更小：在一份经过筛选的数学语料里，51% 的 token 已经被学会了，26% 是学习真正发生的地方，11% 属于难到无法再降的部分，还有 12% 在训练过程中反而变差；把 loss 掩蔽到按 excess loss 排序的前约 60%，让一个 7B 模型用 15B token 就追平了一个用 500B token 训练的专用模型。

「我们的数据要用完了吗？」（”Are we running out of data?”） 严谨的预测是：已被索引的约 510T token，做质量调整后约 100T，允许重复之后约 320T；需求以每年约 2.4× 增长，交叉点的中位数落在 2028 年前后。然后补上关于重复的结论：最多 4 个 epoch 几乎不花代价，收益一直延续到约 16 个，而到 40 个 epoch 时重复已经毫无价值——还有一条重要推论：当你受数据约束时，应该先买 epoch，再买参数，因为重复 token 的价值衰减比多余参数更慢。然后诚实地反过来削自己一刀：最优遍数依赖于模型规模，在一项 2026 年的研究里，从 30M 的约 24 遍一路降到 757M 的约 5 遍——所以「四个 epoch」是来自某一个规模的数字，不是定律。

「在合成数据上训练难道不会导致 model collapse 吗？」（”Doesn’t training on synthetic data cause model collapse?”） 只有在一种没人会用的协议下才会。原始结果每一轮都会把上一代的数据替换掉；而在累积之下——也就是网络上真实发生的情况——测试误差可被证明由一个与迭代次数无关的常数界住，与之相对的是替换协议下的线性发散；实验上，cross-entropy 在五轮迭代里保持平坦。可操作的规则是：永远不替换，永远累积。诚实的保留意见是：accumulation 的界仍然是单次迭代误差的 π²/6 ≈ 1.645×，而且已发表的每一个实验都在 ≤126M 参数上。

Mid-training 与 continual pre-training

「为领域 X 设计一份 mid-training 语料。」（”Design a mid-training corpus for domain X.”） 用旋钮组合来回答，不要靠感觉：选收敛最充分的、或者未经 decay 的 checkpoint；约 1% 的 warmup，峰值 LR 约 5e-5，cosine 衰减到 0.1×；replay 按分布漂移幅度设定（弱漂移 1–5%，强漂移约 25%）；语料要混合，绝不能按领域顺序排；约 1% 的指令数据，好让 policy 后面不会退化；所有你以后可能想要的领域都要放进去，因为到了 RL 阶段你就加不进去了；在 16K 上下文下约 15–27B token；再加一个独立的 long-context 修复阶段。然后说清楚你打算怎么评估它——这才是把好答案区分出来的部分：在 SFT 之后评，在你没有训过的东西上评，而且——如果后面还有 RL——要按 post-RL 的表现来评，而不是按这个 checkpoint 自己的分数来评。

「为什么 continual pre-training 会导致遗忘？」（”Why does continual pre-training cause forgetting?”） 有一部分其实不是遗忘。即便是在模型当初预训练所用的完全相同的数据上重新做 warmup 和 decay，validation loss 仍然会上升 +0.1 到 +0.2 nats，而真实分布漂移下是 +0.35 到 +0.45。所以被称作遗忘的东西里，有相当一部分其实是优化器造成的——这也正是无限 learning rate schedule 和从未 decay 的 checkpoint 续训这两种做法存在的原因。然后量化 replay 这剂药：1% 的 replay 挽回了 0.27 nat 回退中的 0.18，而且在新数据上零代价。

「你怎么把专有知识注入模型？」（”How do you inject proprietary knowledge into a model?”） 先讲失败。一个模型可以逐 token 地把一份语料背下来，却在关于语料中 held-out 实体的问题上只答对 9.7%——而多数类 baseline 是 2.7%——并且没有任何一种 fine-tuning 配置能修好它：某次 682M 参数的实验在语料上跑了 1,350 遍之后，在它调过的那批 QA pair 上拿到 99.0%，在 held-out 的那批上只有 4.4%。原因是位置，不是容量：这条事实弥散在整篇文档里，而不是挂在实体的名字上，而问题所能提供的恰恰只有那个名字。然后讲修复方法及其形态：五份彼此不同的改写加上句子置换能达到 96.6%；五份固定顺序的改写只有 41%；只做置换反而有害。然后是两个放大器：只增强一个不相交的子集，就能教会模型存储约定，把未被触碰的文档从 4.4% 提升到 86.8%；而把 QA 格式的数据混进 pre-training，在完全不做增强的情况下就能到 86.6%。最后是生产版本：关系图扩展把 1.3M 真实 token 膨胀成 455M 合成 token，把闭卷准确率从 39.49 推到 56.22，相当于检索所买到收益的约 80%；而在原始的 1.3M token 上做 continued pre-training 只得到 38.15——低于 base model。

「long context 需要多少数据？」（”How much data do you need for long context?”） 500M token 就能解锁其中大部分，5B 是峰值，10B 开始回退，因为模型会过拟合自己的训练长度范围。但答案的篇幅应该花在方法论上：两份在每个长度上差距都 ≤0.01 nats 的混合配比，在检索上的表现天差地别；perplexity 会在长任务表现下滑的同时反而变好；一个在 needle-in-a-haystack 上拿 100 分的模型，在 re-ranking 上只有 23.1。另外：60% 长 / 40% 短的配比，哪怕对长任务也胜过 100% 全长；想在 64K 上表现好，就在 512K 上训；还要认真策划那条短数据流，因为它才是让你的数学分数活下去的东西。

「为什么 R1-Zero 式的 RL 在有些 base model 上有效、在另一些上无效？」（”Why does R1-Zero-style RL work on some base models and not others?”） 因为 RL 放大的是 base 已经能采样出来的东西，而修复手段在 mid-training。在 GRPO 下，某个家族的 base 把生成长度一路顶到上限，退化成不断重复的「Solution」token；200B token 的数学 mid-training 加上一条 20B 的 decay 分支，把 MATH500 从 10.0（base + RL）拉到了 65.2。被装进去的东西是：一个可解析的格式、约 1% 的指令跟随能力，以及一份好到足以从中采样出正确解法的语料。权重层面的证据是压轴的：mid-training 改动了 >90% 的参数，RL 只改动约 5%——一次小了 580× 的更新，把表征几何留在了 CKA > 0.998——而改变 RL 的混合配比，只让六项 benchmark 的平均分动了 −0.21，改变 mid-training 的混合配比却让它动了 +5.60，在 GPQA-Diamond 上动了 +17.34。

SFT

「你需要多少 SFT 数据？」（”How much SFT data do you need?”） 这个问题本身就没说清楚，而用一个数字把这一点说出来，就是答案。完全相同的 800 条精选样本，在 Qwen1.5-32B-Chat 和 Qwen2.5-32B-Instruct 上分别给出 9.2% 和 63.3% 的 AIME24——54.1 个点的落差全部来自 base model，比我找到的任何数据干预都大。剩下的部分由评测广度解释：单个 chat 指标在约 2K 条样本处就饱和了；一个 12 项技能的平均分在 939,344 条时仍在上升。而且单位是行为，不是样本：30 条样本装上了多轮对话，6 条装上了结构化输出。

「你会怎么从 1M 的样本池里挑出 10K 条？」（”How would you select 10K examples from a 1M pool?”） 先设正确性闸门，因为错误数据的价值是负的——某份 100K 条未经筛选的推理语料，得分比未经 fine-tune 的 base 还低 17.6 个点。然后是 prompt 多样性，因为它决定了天花板，也因为在最详尽的那份开源配方里，单项影响最大的 ablation 就是移除注入多样性的 persona 数据（IFEval −19.2）。然后才是回答质量。最后才是数量。至于具体做法，坚持使用相对信号：在同一条 prompt 内部对演化出的变体做排序，而不是孤立地给样本打分；或者测量解题率。绝对信号会输给随机——perplexity 得到 4.06 和 1.89，而随机得到 5.84 和 4.93。

「在合成 pipeline 里，最便宜的大收益是什么？」（”What is the cheapest big win in a synthesis pipeline?”） 改写一条 prompt。用一条普通 prompt 从两个前沿 generator 那里合成的竞赛数学数据，把三项 benchmark 的平均分拉到 30.6，低于你什么都不做、根本不 fine-tune 时的 32.8。换成向同样的模型要「五个回答并附上它们各自的概率」，这个数字就变成 36.1，多轮变体则是 37.5。其机制在于：偏好标注者会系统性地偏爱 base log probability 更高的文本，与质量无关，拟合系数为 0.57–0.65，p < 10⁻¹⁴；因此，在按这种方式建模的 reward 之下，只要候选之间的真实质量是平的，alignment 就会把模型锐化到它的 base 众数上。

RL 与 agentic RL

「一个 RL 数据集由什么构成？」（”What does an RL dataset consist of?”） 是任务和 checker，不是答案。保留有 reward 方差的 prompt，因为当一个 group 里每条 rollout 得分都相同时，group 归一化的 advantage 根本产生不了梯度。剔除从未被解出的 prompt：在一道无解的题目上训练，把某个 benchmark 拉到了 45.0，低于只用格式 reward 得到的 65.6。还要区分一条 prompt 从未被解出的三种原因——太难、标注错误、无法验证——因为零通过率的那一桶里，坏掉的任务是被富集了的。

「你怎么知道你的 reward 没有被 hack？」（”How do you know your reward is not being hacked?”） 两件仪器加一个习惯。一套对抗模式测试集，因为在 13 种攻击模式上，discriminative verifier 的攻击成功率只有 0.1–0.4%，而 generative chain-of-thought verifier 在 7.7–23.7% 之间，其中一格高达 77.9%。一条 oracle 通道：在每个 checkpoint 上，用一个强力的外部模型给约 1,000 条采样出的训练 prompt 重新打分，把 training reward 与 oracle reward 画在同一张坐标轴上；两者背离是这三件里最可靠的警报。以及一个习惯：绝不按 held-out 准确率来挑 verifier——唯一一篇尝试把 verifier 的静态 recall 从 0.49 提升到 0.62 的论文，跑出了它自己最差的一次 RL run，因为 policy 学会了只输出一个 {。

「RLVR 是在教会模型，还是在激发它本来就有的东西？」（”Is RLVR teaching the model or eliciting what is already there?”） 这取决于（模型，领域）这一对组合，而且它是可测量的。在某个数学专用的 7B base 上，随机 reward 买到了 +21.4 个点，而 ground truth 是 +29.1——靠掷硬币就拿到了 73% 的收益——其通道是 GRPO 的 clipping 偏置，它会棘轮式地不断推高本来概率就高的 token。而在一个没有这种先验的 base 上，ground truth 收益是 +15.5，每一种弱替代方案都在掉分。所以要跑四个对照：只看格式的 reward、随机 reward、一个非 Qwen 的 base，以及一个数据截止之后的 benchmark。如果格式 reward 就能吃掉你大部分收益，那你做的是激发，reward 的内容几乎是可互换的，而你在 verifier 上的投入是浪费的。

「你的标签可以有多脏？」（”How noisy can your labels be?”） 在一个方向上比你以为的更能容忍，在另一个方向上则远远更不能容忍。无偏噪声只是让性能退化：60% 随机错误的标签，平均只损失约 1.3 个点。有偏噪声则会把模型带偏：在单条训练样本上，一个「错但看起来合理」的答案得到 57.0，而一个「错且完全够不着」的答案得到 64.4，正确答案约 74。危险的错误标注是那个看起来合理的；而规则 verifier 的 false negative 在构造上就是有偏的——它们集中在最新颖的那批正确答案上，并且会随着你的 policy 变强而越来越糟。

蒸馏

「我手里只有一个小模型，而前沿模型是存在的。你会怎么做？」（”I have a small model and frontier models exist. What do you do?”） 按决策树的顺序回答。先检查到每个候选 teacher 的初始 per-token KL（约 0.04 是有产出的，约 0.19 会退化），再看你的 student 在目标任务上的通过率。用 teacher 的 trace 做 off-policy 冷启动，它便宜 4–5×，而且能补上模式上的差距；约 800K 条 trace 训出了一个 32B 的 student，AIME24 达到 72.6%，而在同样的 base 上做 RL 只有 47.0%。只有当中间步骤的错误会累积放大时，才转向 on-policy。如果你的 teacher 属于另一个家族，或者你需要超过它，那就别再去对齐它了：改用它来打分、写 rubric，或者在已验证为正的 trajectory 上重新加权 advantage。

「student 能超过它的 teacher 吗？」（”Can a student beat its teacher?”） 能，但只能通过一条不是模仿的通道。蒸馏的目标是天花板；reward 不是。某个基于 rubric 的 on-policy 方案训出了一个 4B 的 student，在 AIME25 上达到 68.75%，而它那个前沿 teacher 是 67.08%——获胜的那些行为没有一条是 teacher 写出来的，它只负责评判。渐近地看，蒸馏无法超过监督学习，就连 weak-to-strong 泛化也只是一种有限数据下的假象，token 一多就消失了。

「为什么更强的 teacher 反而会让我的 student 更差？」（”Why would a stronger teacher make my student worse?”） 容量差距，而且有一个数字：拟合出来的那条定律的折点，落在 teacher 与 student 的 cross-entropy 比值 1.315 处，而且这是学习容量上的差距，不是参数量上的差距。运行时版本是一次受控替换：把一个同源的 teacher 换成另一个家族里强得多的 teacher，归一化分数从 0.937 掉到 0.600；在截断 loss 下更是掉到 −1.190，并在第 18 步发散——对应的初始 per-token KL 是约 0.19 对约 0.04。在 policy-gradient loss 下，student 的 entropy 从 0.30 收缩到 0.21，因为它在吸收来自 teacher 低概率区域的惩罚性梯度；而真正发散的是那个截断 loss。

「forward KL 还是 reverse KL？」（”Forward KL or reverse KL?”） 这取决于你测量的是什么，而把这一点说出来就是答案。在 pre-training 的 cross-entropy 上，forward KL 以一半的成本赢了 reverse KL 0.28 nats——2.42 对 2.70（Busbridge et al., 2025）。在自由生成的指令跟随上，forward KL 却让 student 比 teacher 校准得更差（ECE 0.682 对 teacher 的 0.356），并伴随不断增长的 exposure bias。forward KL 优化的是它训练时所用的那个指标；reverse KL 优化的是模型在采样温度下真正吐出来的东西——而且 reverse KL 是用 pass@k 换 pass@1，如果后面还有 RL，这一点很要紧。

「在蒸馏数据上训练有哪些风险？」（”What are the risks of training on distilled data?”） 风格的迁移率约 100%，知识的迁移率约 0%，而你的 judge 分辨不出来：权威口吻从 57% 涨到 98%，对应的天花板是 98%，与此同时事实准确率从 20 掉到 15，却仍有约 70% 的输出被评为与 teacher 持平或更好。然后列出那些被实测到的卫生问题——entropy 坍缩、calibration 退化、长度病态、对 teacher 自身似然的 hack——并且诚实地承认：人们断言得最斩钉截铁的那两种失败，也就是经由 teacher 洗白的 contamination 和身份泄漏，恰恰是已发表证据最少的。最后给出廉价的缓解手段：剥掉自我身份声明和拒答套话，在评测集里加一个身份探针，并且给每一项基于 judge 的评测都配上一个你的模仿数据没有覆盖到的能力 benchmark。

评测与 contamination

「你怎么知道你的 benchmark 数字是真的？」（”How do you know your benchmark number is real?”） 把你的评测集当作 pipeline 的一部分来对待。在 prompt 侧，对每一个 eval、每一份语料（包括合成语料和 RL prompt 集）做 n-gram decontamination；一份永远不出公司的私有 held-out 集合；其中一部分定期轮换；一套在每个 checkpoint 上都跑的非回归测试集；以及至少一个在你的数据截止日期之后采集的 benchmark。之所以要靠系统而不是靠勤勉，原因在于那些已公开的重叠率：Tülu 3 自己对广泛使用的指令数据集所做的审计发现，Evol CodeAlpaca 与 HumanEval 的 70.7% 重叠，LMSys-Chat-1M 与 AlpacaEval 的 46.5% 重叠，而他们干脆把其中四个数据集整份排除，而不是去清洗它们（Lambert et al., 2024）。同一批人也试过基于 embedding 的检测，然后放弃了，因为它无法把分布相似性与真正的改写区分开来；而 n-gram 仍然能抓住最要紧的那种情况：一道只改了数字的数学题。

如何引用

Zhang, Jiaxin. (Jul 2026). Where Training Data Comes From: Synthesis, Verification, and Distillation Across the Training Stack. Jiaxin Zhang’s Blog. https://jxzhangjhu.github.io/blog/2026/where-training-data-comes-from/

@article{zhang2026trainingdata,
  title   = "Where Training Data Comes From: Synthesis, Verification, and Distillation Across the Training Stack",
  author  = "Zhang, Jiaxin",
  journal = "Jiaxin Zhang's Blog",
  year    = "2026",
  month   = "Jul",
  url     = "https://jxzhangjhu.github.io/blog/2026/where-training-data-comes-from/"
}

参考文献

[1] Rishabh Agarwal, et al. “On-Policy Distillation of Language Models: Learning from Self-Generated Mistakes.” arXiv:2306.13649, 2023.

[2] Ali Al-Lawati, et al. “LLM Benchmark Datasets Should Be Contamination-Resistant.” arXiv:2605.19999, 2026.

[3] Zeyuan Allen-Zhu, et al. “Physics of Language Models: Part 3.1, Knowledge Storage and Extraction.” arXiv:2309.14316, 2023.

[4] Zeyuan Allen-Zhu, et al. “Physics of Language Models: Part 3.3, Knowledge Capacity Scaling Laws.” arXiv:2404.05405, 2024.

[5] Akshay Arora, et al. “Beyond Static Evaluation: Building Simulation Environments for Scalable Agentic Reinforcement Learning.” arXiv:2607.05773, 2026.

[6] Dan Busbridge, et al. “Distillation Scaling Laws.” arXiv:2502.08606, 2025.

[7] Aili Chen, et al. “DIVE: Scaling Diversity in Agentic Task Synthesis for Generalizable Tool Use.” arXiv:2603.11076, 2026.

[8] Rui Dai, et al. “Explaining Data Mixing Scaling Laws.” arXiv:2606.08167, 2026.

[9] Hongxin Ding, et al. “EvoRubrics: Dynamic Rubrics as Rewards via Adversarial Co-Evolution for LLM Reinforcement Learning.” arXiv:2606.23038, 2026.

[10] Yao Fu, et al. “Data Engineering for Scaling Language Models to 128K Context.” arXiv:2402.10171, 2024.

[11] Tianyu Gao, et al. “How to Train Long-Context Language Models (Effectively).” arXiv:2410.02660, 2024.

[12] Tao Ge, et al. “Scaling Synthetic Data Creation with 1,000,000,000 Personas.” arXiv:2406.20094, 2024.

[13] Matthias Gerstgrasser, et al. “Is Model Collapse Inevitable? Breaking the Curse of Recursion by Accumulating Real and Synthetic Data.” arXiv:2404.01413, 2024.

[14] Yuxian Gu, et al. “MiniLLM: On-Policy Distillation of Large Language Models.” arXiv:2306.08543, 2023.

[15] Arnav Gudibande, et al. “The False Promise of Imitating Proprietary LLMs.” arXiv:2305.15717, 2023.

[16] Suriya Gunasekar, et al. “Textbooks Are All You Need.” arXiv:2306.11644, 2023.

[17] Kshitij Gupta, et al. “Continual Pre-Training of Large Language Models: How to (re)warm your model?.” arXiv:2308.04014, 2023.

[18] Zhanbo Hua, et al. “CLI-Universe: Towards Verifiable Task Synthesis Engine for Terminal Agents.” arXiv:2606.22883, 2026.

[19] Yuzhen Huang, et al. “From Accuracy to Robustness: A Study of Rule- and Model-Based Verifiers in Mathematical Reasoning.” arXiv:2505.22203, 2025.

[20] Adam Ibrahim, et al. “Simple and Scalable Strategies to Continually Pre-train Large Language Models.” arXiv:2403.08763, 2024.

[21] Naman Jain, et al. “R2E-Gym: Procedural Environments and Hybrid Verifiers for Scaling Open-Weights SWE Agents.” arXiv:2504.07164, 2025.

[22] Carlos E. Jimenez, et al. “SWE-bench: Can Language Models Resolve Real-World GitHub Issues?.” arXiv:2310.06770, 2023.

[23] Nathan Lambert, et al. “Tülu 3: Pushing Frontiers in Open Language Model Post-Training.” arXiv:2411.15124, 2024.

[24] Xian Li, et al. “Self-Alignment with Instruction Backtranslation.” arXiv:2308.06259, 2023.

[25] Jeffrey Li, et al. “DataComp-LM: In search of the next generation of training sets for language models.” arXiv:2406.11794, 2024.

[26] Xuefeng Li, et al. “LIMR: Less is More for RL Scaling.” arXiv:2502.11886, 2025.

[27] Zhenghao Lin, et al. “Rho-1: Not All Tokens Are What You Need.” arXiv:2404.07965, 2024.

[28] Wei Liu, et al. “What Makes Good Data for Alignment? A Comprehensive Study of Automatic Data Selection in Instruction Tuning.” arXiv:2312.15685, 2023.

[29] Bowen Lv, et al. “ScaleCUA: Scaling Computer Use Agents with Verifiable Task Synthesis and Efficient Online RL.” arXiv:2607.11185, 2026.

[30] Wenhan Ma, et al. “MOPD: Multi-Teacher On-Policy Distillation for Capability Integration in LLM Post-Training.” arXiv:2606.30406, 2026.

[31] Pratyush Maini, et al. “Rephrasing the Web: A Recipe for Compute and Data-Efficient Language Modeling.” arXiv:2401.16380, 2024.

[32] Arindam Mitra, et al. “AgentInstruct: Toward Generative Teaching with Agentic Flows.” arXiv:2407.03502, 2024.

[33] Niklas Muennighoff, et al. “Scaling Data-Constrained Language Models.” arXiv:2305.16264, 2023.

[34] Guilherme Penedo, et al. “The FineWeb Datasets: Decanting the Web for the Finest Text Data at Scale.” arXiv:2406.17557, 2024.

[35] Ziyun Qiao, et al. “HERMES: A Multi-Granularity Labeling Substrate for Pre-training Data Mixtures.” arXiv:2607.02266, 2026.

[36] Qwen Team “The Verification Horizon: No Silver Bullet for Coding Agent Rewards.” arXiv:2606.26300, 2026.

[37] Aswin RRV, et al. “Mid-Training with Self-Generated Data Improves Reinforcement Learning in Language Models.” arXiv:2605.08472, 2026.

[38] Bharat Runwal, et al. “PRISM: Demystifying Retention and Interaction in Mid-Training.” arXiv:2603.17074, 2026.

[39] Rulin Shao, et al. “Spurious Rewards: Rethinking Training Signals in RLVR.” arXiv:2506.10947, 2025.

[40] Weijia Shi, et al. “Detecting Pretraining Data from Large Language Models.” arXiv:2310.16789, 2023.

[41] Ilia Shumailov, et al. “The Curse of Recursion: Training on Generated Data Makes Models Forget.” arXiv:2305.17493, 2023.

[42] Shivalika Singh, et al. “The Leaderboard Illusion.” arXiv:2504.20879, 2025.

[43] Mingyang Song, et al. “A Survey of On-Policy Distillation for Large Language Models.” arXiv:2604.00626, 2026.

[44] Qiushi Sun, et al. “OS-Genesis: Automating GUI Agent Trajectory Construction via Reverse Task Synthesis.” arXiv:2412.19723, 2024.

[45] Zihang Tian, et al. “ARCO: Adaptive Rubrics with Co-Evolution for Multi-Step LLM-Based Agents.” arXiv:2606.21262, 2026.

[46] Pablo Villalobos, et al. “Will we run out of data? Limits of LLM scaling based on human-generated data.” arXiv:2211.04325, 2022.

[47] Yizhong Wang, et al. “Self-Instruct: Aligning Language Models with Self-Generated Instructions.” arXiv:2212.10560, 2022.

[48] Zengzhi Wang, et al. “OctoThinker: Mid-training Incentivizes Reinforcement Learning Scaling.” arXiv:2506.20512, 2025.

[49] Yiping Wang, et al. “Reinforcement Learning for Reasoning in Large Language Models with One Training Example.” arXiv:2504.20571, 2025.

[50] Chen Wang, et al. “Distilled Reinforcement Learning for LLM Post-training.” arXiv:2607.17247, 2026.

[51] Haowen Wang, et al. “MIRA: Mid-training Rubric Anchoring for Source-Aware Data Selection.” arXiv:2605.30288, 2026.

[52] Yongjie Wang, et al. “Search-Time Contamination in Deep Research Agents: Measuring Performance Inflation in Public Benchmark Evaluation.” arXiv:2606.05241, 2026.

[53] Sang Michael Xie, et al. “DoReMi: Optimizing Data Mixtures Speeds Up Language Model Pretraining.” arXiv:2305.10429, 2023.

[54] Zitong Yang, et al. “Synthetic Continued Pretraining.” arXiv:2409.07431, 2024.

[55] John Yang, et al. “SWE-smith: Scaling Data for Software Engineering Agents.” arXiv:2504.21798, 2025.

[56] Yixin Ye, et al. “LIMO: Less is More for Reasoning.” arXiv:2502.03387, 2025.

[57] Jiangan Yuan, et al. “Let the Data Decide: Supervision Analysis, Capability Trade-offs, and Adaptive Objective Routing in Continued Pre-training via Off-Policy Distillation.” arXiv:2607.16246, 2026.

[58] Aohan Zeng, et al. “AgentTuning: Enabling Generalized Agent Abilities for LLMs.” arXiv:2310.12823, 2023.

[59] Hugh Zhang, et al. “A Careful Examination of Large Language Model Performance on Grade School Arithmetic.” arXiv:2405.00332, 2024.

[60] Jiaxin Zhang, et al. “Synthetic Knowledge Ingestion: Towards Knowledge Refinement and Injection for Enhancing Large Language Models.” arXiv:2410.09629, 2024.

[61] Jiayi Zhang, et al. “Verbalized Sampling: How to Mitigate Mode Collapse and Unlock LLM Diversity.” arXiv:2510.01171, 2025.

[62] Chunting Zhou, et al. “LIMA: Less Is More for Alignment.” arXiv:2305.11206, 2023.

[63] Yongwei Zhou, et al. “Predictable Scaling Laws of Optimal Hyperparameters for LLM Continued Pre-training.” arXiv:2606.05610, 2026.

[64] Kevin Zhou, et al. “Repetition Mismatch: Why Data Mixture Experiments Don’t Scale and How to Fix Them.” arXiv:2606.07597, 2026.