章节导航 第 10 章 / 共 30 章
第 10 章 篇一：预训练数据工程

数据配比与课程化退火

领域/语种配比的实操方法（DoReMi/RegMix）与课程化退火训练策略。

数据配比 课程学习 退火

数据质量决定上限，数据配比决定性格。 预训练的最后 5% 数据，决定了模型 20% 的最终能力。 退火是预训练的”压轴戏”——低学习率 + 高质量精选 = 模型能力的最后跃升。

数据配比与课程化退火

本章是预训练数据工程的收束章节，把”数据混合配比”与”课程化退火”两条线索拧成一根完整的操作主线。前者回答”每种数据各用多少”，后者回答”以什么顺序、在什么状态下喂给模型”。两件事单独看都只是训练脚本里的一个权重表或一段调度代码，合起来却决定了模型的”性格”与最终的分数天花板。

为什么这两件事值得单独成章、且必须合并讨论？因为在真实的工业预训练里，配比与课程从来不是两个独立旋钮。一个团队如果在配比阶段把数学拉到 30%，又在退火阶段把数学再拉到 40%，模型会在 MATH 上暴涨，但通用知识可能塌方；如果一个团队设计了精妙的从易到难课程，却让高质量数据全部落在学习率已经衰减到接近零的末期，那套课程等于白做。配比决定”吃什么”，课程/退火决定”什么时候吃、最后一口吃什么”——两者必须在同一张设计图上协同，这就是本章把它们合并为一章的根本原因。

我们将内容组织为三部分：

  • 第一部分讲配比方法论，从经验直觉一路推到 DoReMi、RegMix、二维分类框架与 2026 年的在线配比前沿。这一部分的目的是把”凭感觉拍比例”升级为”有框架、有工具、可复现”的科学决策。
  • 第二部分讲阶段化配方，把预训练拆成 Pretrain → Midtrain → 退火 → 长文四个阶段，给出可落地的 YAML 配方与实验设计，并附一个 30B 中文模型的完整配比决策案例。这一部分回答的是”配比如何随时间变化”。
  • 第三部分讲课程化与退火实操，从难度评估、课程调度到工业级退火案例、阶段切换时序与踩坑经验，全部落到可执行代码与监控指标上。这一部分回答的是”数据以什么顺序、在什么训练状态下喂给模型最有效”。

阅读建议：如果你只关心”我该怎么做”，直接跳到第二部分的阶段化配方模板和第三部分的退火配方模板；如果你想理解”为什么这样做有效、还有哪些前沿选择”，再回读第一部分的方法论。无论哪条路径，都请记住一句话——最优配比不存在，但快速验证与迭代的机制必须存在。

第一部分：配比方法论——让”配方”决定模型性格

10.1 为什么配比是预训练的核心决策

1.1 配比 = 模型性格

不同数据配比训出来的模型，能力天差地别。同样是几十 T token 的预训练，配方不同，模型就像被塑造出了不同的”性格”：

配方模型性格代表
网页 95%通用对话型，闲聊强，推理弱早期 GPT-3
网页 60% + 代码 30%编程强，通用 OK，推理 OKCode Llama
网页 50% + 数学 30% + 论文 20%推理极强，编程 OKDeepSeek-Math
网页 70% + 多语 30%多语种强BLOOM, Qwen

一句话概括：多代码→编程强；多论文→推理强；多对话→闲聊强——配方是模型的灵魂。

1.2 配比影响为何难以预测

假设你有以下数据源：10 万亿 token 的网页文本、5000 亿 token 的书籍、2000 亿 token 的学术论文、1 万亿 token 的代码、500 亿 token 的数学内容。你要训练一个 70B 的模型，训练预算是 15 万亿 token。问题来了：每种数据各用多少？

这个问题看起来像是一个简单的比例分配，实际上是预训练中最复杂的决策之一，因为：

第一，配比直接决定模型的”知识结构”。 代码数据占 20% 和占 5%，训练出来的模型在编程任务上的表现可以差一倍。更微妙的是，不同配比会产生”跨域溢出效应”——代码数据不仅影响编程能力，还会影响逻辑推理能力。这意味着配比的影响不是线性叠加的。

第二，配比效果很难预测。 不像模型架构或优化器那样有清晰的理论指导，数据配比的效果高度依赖于具体的数据质量和训练目标。同一个配比在不同质量的数据上效果可能完全不同。

第三，配比空间是高维的。 如果你有 8 个数据域，每个域的比例可以从 0% 到 100% 变化，即使只考虑 5% 的粒度，组合数也是天文数字。穷举搜索完全不可行。

第四，最优配比可能随训练阶段变化。 训练初期和训练后期，模型需要的数据分布可能不同。固定配比训练到底是否次优？这是一个尚未完全回答的问题。

一个来自工业实践的故事最能说明配比的杠杆作用。某团队在训练一个 13B 通用模型时，纠结于两个方案：

  • 方案 A：网页 70%、代码 10%、数学 3%、书籍 10%、学术 5%、其他 2%
  • 方案 B：网页 55%、代码 20%、数学 8%、书籍 10%、学术 5%、其他 2%

方案 B 将网页比例降低了 15 个百分点，把这些份额分给了代码和数学。结果如下：

Benchmark方案 A方案 B差异
MMLU（通用知识）63.262.8-0.4
HumanEval（代码）34.147.6+13.5
GSM8K（数学）52.361.7+9.4
ARC-Challenge（推理）51.454.8+3.4
HellaSwag（常识）78.677.9-0.7

方案 B 在代码和数学上的提升是巨大的，通用知识和常识推理上的损失微乎其微，而且——令人惊讶的是——在 ARC-Challenge 这样的纯推理 benchmark 上也有显著提升。这正是代码数据的”推理溢出效应”在发挥作用。

1.3 先统一口径：offline / online 的判定标准

配比方法在文献里的命名相当混乱：同一个 DoReMi，有的论文叫它”动态配比”，有的综述把它归到”静态混合”，工程表格里又要标成”离线”。口径不先定死，读到第四章必然自相矛盾。 所以在展开具体方法之前，先立一把尺子。

判定只需要问两句话：

第一问：主训练（真正那十几 T token）跑起来之后，这份配方还会不会变？
  ├─ 不会变 → offline（离线配比 / 静态混合）
  └─ 会变   → 第二问：变，是因为到了预定的时刻，还是因为模型给了反馈？
        ├─ 到了预定时刻就切换 → 动态 × 规则式（课程学习 / 阶段化配方）
        └─ 反馈触发了重算     → online（真·在线配比）

这把尺子的关键在于把”训练前的搜索”和”训练中的调整”分开。很多方法在训练前有一大堆迭代——训小模型、调权重、拟合回归——但这些迭代全部发生在主训练之前。一旦主训练启动，配方就是一个只读的常量。这类方法按上面的标准统统属于 offline，无论它的搜索过程看起来多”动态”。

检索防呆： 按 “data mixing” 检索时会命中大量蒸馏方向的论文，它们”混合”的是模型分布（student / teacher 的逐 token 插值），不是数据域。例如 arXiv:2610.06671《Learning What to Imitate: Entropy-Aware Distribution Mixing》（2026-10-05）做的就是用 student 预测熵门控的两个分布插值，与本章的域配比无关。本章只讨论”数据域配比”这一种 mixing。

按 Chen et al. (2026)《Data Mixing for LLM Pretraining: A Survey and Outlook》（Data Intelligence）的二维分类法，再叠上第二个维度”配方由谁定”（人工启发式 vs 代理模型 / 拟合 scaling law），得到本章后面一直沿用的框架：

规则式
人工经验 / 启发式公式		学习式
小代理模型 / 拟合 scaling law
offline
主训练全程不变		经验配比：Llama-1/3 的手工比例、按数据量原始比例分配离线搜索型：Data Mixing Laws、Apple Scaling Laws、DoReMi、RegMix、BiMix、OptiMer、CAMEL、DoGE
在 proxy 阶段搜出配方，冻结后用于主训练
online
主训练中变化		预定义调度：课程学习、阶段化配方（Pretrain→Midtrain→退火）、数据调度器
时刻表由人写死，切换时机写在训练脚本里		反馈驱动：ODM、AC-ODM、AutoScale、Aioli、HDS、TiKMiX、重复感知混合缩放定律
按验证 loss / 参考模型打分 / 影响函数周期性重算域权重

⚠️ 两个高频误判，先把它们掐掉：

  1. DoReMi / RegMix 常被称作”动态配比”，但它们的动态只发生在 proxy 阶段的搜索循环里。 参考模型训完、Group DRO 收敛或回归拟合完成之后，主训练拿到的是一份冻结的域权重——按上面的标准属于 offline × 学习式。文献里那个”动态”指的是”搜索过程是迭代的”，而不是”主训练中还在变”。
  2. 课程学习属于”动态”，但不属于 online。 它确实在训练过程中改变数据组成，但依据是一份事先写好的时刻表，不是模型的反馈。所以它是 动态 × 规则式（预定义调度）。真正把 online 区分出来的，是”配方被反馈改写过”。
  1. FastMix 在”单 proxy 训练过程中”更新配比，比 DoReMi / RegMix 更容易被误读成 online。 判据仍然是上面那把尺子：主训练（真正那十几 T token）跑起来之后配方还会不会变？FastMix 的配比更新全部发生在 proxy 训练里，搜完之后主训练拿到的是一份冻结配方 → offline × 学习式，与 DoReMi / RegMix 同格。它在训练中”看起来在动”，动的是 proxy，不是主训练。

为什么这条主线会一路走到 online？ 因为所有 offline 方法都建立在一个隐含假设上：存在一份全程最优的固定配方。 但预训练的学习动态是非平稳的——早期要用通用数据打底、建立稳定的表征空间，晚期要用高质量数据精修、冲高难度能力；同一个配比在 token 消耗到 1T 和 10T 时的边际收益完全不同。这个假设一旦不成立，“算出一个好配方”就不够了，必须让配方能随训练自适应。这就是 2026 年这个方向最大的转向：从”算出一个好配方”转向”让配方一直在被重算”。

1.4 offline 与 online 的工程细节：代价、风险与衔接

上一节给的是位置，这一节给的是代价。现实中选 offline 还是 online，很少是学术口味问题，而是”你愿意付多少工程成本、承担多少不可复现风险”。

对比维度offline（训练前搜好、主训练冻结）online（主训练中由反馈重算）
决策时机主训练开始前一次性确定，此后配方是常量主训练进行中，按 step / checkpoint 周期重算
反馈来源没有真实反馈，只能用 proxy 替代：小模型消融、拟合 scaling law 外推真实训练信号：验证集 loss、各域 loss 曲线斜率、参考模型打分、影响函数 / 梯度归因
额外算力一次性，通常只占主训练的百分之几（RegMix 的 512 个 1M 模型约等于 1-2 张 H100 跑一天）持续性，随训练时长线性增长，信号计算本身就是固定开销
可复现性高。配方是产物：能存档、能审计、能回滚，也拿去解释”模型为什么是这个性格”最省事低。配方是轨迹：依赖训练过程与随机性，换个种子可能走出另一条配比曲线
主要失败模式外推误差：小模型上的最优配比不等于大模型上的最优配比（数学数据的收益通常随规模放大）信号滞后与正反馈：配比调整要训一段才显形；若某域被加权→loss 下降→再被加权，可能自我强化到失衡
适合谁算力预算有限、需要强可复现与可审计、第一次搭配比流程有稳定的验证集 / 参考模型，愿意用不稳定性换性能上限
代表方法经验配比、Data Mixing Laws、Apple Scaling Laws、DoReMi、RegMix、BiMix、OptiMer、CAMEL、DoGEODM、AC-ODM、AutoScale、Aioli、HDS、TiKMiX、重复感知混合缩放定律

⚠️ 上表”online 额外算力 = 持续性、随训练时长线性增长”这一格需要打折。online 方法常被怀疑”开销大”，但实测数据不支持这个笼统判断：AC-ODM（arXiv:2505.23878）在 Pythia-1B 上以减少最多 66% 训练步达到最优验证 PPL，MMLU 相对 +27.5%、HumanEval pass@1 达 2.23×，而每步 wall-clock 仅增加 0.4%、额外显存仅 2%。也就是说，online 的信号计算开销本身可以低到可忽略，真正的成本是”必须持续在线”这件事带来的工程复杂性与不稳定性（见上表”可复现性”一行），而不是算力。做选型时把这两笔账分开算，否则会因为一个错误的成本印象直接否掉整个方向。

online 内部还能再分两类，区分点是反馈信号从哪里来：

  • Adaptive（自适应）：反馈来自模型自身——典型是验证 loss 或各域 loss 的下降速率。某个域的 loss 见顶就降权，把份额让给还在快速下降的域。
  • Externally guided（外部引导）：反馈来自模型之外——一个固定的参考模型、一套专门的验证集，或者梯度空间里的域间影响估计。

但工业上最常见的不是二选一，而是”分阶段混合”：先用 offline 方法搜出一个可靠基线，再把训练时间轴切成几段、每段用一个预先定好的配方（这就是动态 × 规则式的阶段化配方），只在最后的长训练里引入小步长的 online 微调，而且必须限幅——单次调整不超过 ±5%，否则前面辛苦搜出来的基线会被后期震荡吃掉。§8.3 给的那套”评估驱动 / loss 驱动 / 课程式”调整策略，就是这套混合的工程版实现。

这条线上仍未解决的三个问题（来自 Chen et al. 2026 综述）：

  1. 迁移性：在 A 数据集、A 目标、A 模型规模、A 验证集上搜出来的配方，换一个就未必成立。跨域、跨目标、跨模型、跨验证集四个维度都存在迁移损耗。
  2. 评估协议不统一：各论文的 proxy 规模、benchmark 组合、baseline 各不相同，“谁提升了多少”横向比较时可信度有限。这也是本章在表格里对预印本方法统一标注”待验证”的原因。
  3. 成本与收益的张力：从静态到离线搜索再到在线，投入是数量级上升的，收益远不是数量级上升（§4.7 有逐项对比）。多数团队的正确起点是离线搜索 + 阶段化配方，而不是直接上在线。

探索方向：更细粒度的域划分（把”网页”拆成语义桶，见 §4.5 的 GEM）、逆向数据混合（先定能力目标再反推配比）、pipeline-aware 设计（把清洗 / 去重管线的状态也纳入配比决策）。

本章后续就按这个框架组织：offline × 规则式（§10.3 的 Llama-1 配方）→ offline × 学习式（§4.1-4.4 的 Data Mixing Laws、DoReMi、RegMix、BiMix / OptiMer / CAMEL）→ online（§4.5 的前沿工作与 §8.3 的在线调整实践）。

10.2 主要数据域与配比考量

2.1 数据域的分类

预训练数据通常可以分为以下几个主要域：

数据域典型来源特点
网页文本Common Crawl, 自建爬虫量最大、质量参差、覆盖面广
书籍Gutenberg, Books3结构完整、语言规范、叙述连贯
学术论文arXiv, S2ORC, PubMed知识密度高、专业术语多、格式特殊
代码GitHub, The Stack逻辑严密、多语言、质量分层大
数学教材、题库、合成数据需要特殊处理（LaTeX）、量相对少
百科/参考Wikipedia, StackExchange质量高、知识密度大、量有限
对话/社交Reddit, 论坛口语化、多样性高、噪声也高
多语言各语言的网页和书籍不同语言的 token 效率差异大

2.2 主流大模型的公开配比趋势

尽管大多数模型不公开精确的数据配比，但从技术报告中可以拼凑出一个大致的图景：

Llama 3（Meta, 2024）

  • 总量：15.6T tokens
  • 英文为主（据估计 >85%），显著增加了代码比例
  • 关键决策：大幅增加了代码数据（据推测约 17%），并首次系统性地引入数学数据
  • 值得注意：相比 Llama 2，代码比例大幅增加是最显著的变化之一

DeepSeek V3（DeepSeek, 2024）

  • 总量：14.8T tokens
  • 已知特点：代码和数学数据占比极高
  • DeepSeek 系列一直以强调代码和数学能力著称，从 DeepSeek Coder 到 V3，代码数据的处理持续精细化
  • 多语言配比中中英平衡

Qwen 2.5（阿里, 2024）

  • 总量：18T tokens
  • 中英文平衡（中文占比显著高于 Llama）
  • 强化代码和数学
  • 覆盖了 29+ 种语言

Gemma 2（Google, 2024）

  • 总量：13T tokens（27B 模型）
  • 英文为主，但引入了多模态数据
  • 代码占比较高

从这些数据中可以看出几个趋势：

  1. 代码比例在普遍上升——从早期的 5-8% 到现在的 15-25%
  2. 总训练 token 数在快速增长——从 Chinchilla 时代的 1-2T 到现在的 15T+
  3. 多语言的重视度在提升——但策略差异很大（Llama 以英文为主，Qwen 中英平衡）
  4. 高质量数据（代码、数学、学术）的比例在挤占网页文本的份额

2.3 代码数据的推理溢出效应

这可能是近年来数据配比领域最重要的发现之一：代码数据对模型推理能力的提升远超预期，而且这个提升是跨领域的。

ICLR 2024 的论文《At Which Training Stage Does Code Data Help LLMs Reasoning?》（Ma et al., 2024）系统性地研究了代码数据在不同训练阶段对推理能力的影响。核心发现：

  1. 预训练阶段混入代码数据可以显著提升通用推理能力，而且几乎没有对其他任务造成负迁移
  2. 代码数据在预训练阶段的收益最大，在 SFT 阶段的收益较小——这意味着代码的推理增强效果更多来自”学会了结构化思维”，而非”学会了编程语法”
  3. 代码数据的比例有一个”甜蜜点”——太少没有效果，太多会挤压自然语言知识

另一篇 2024 年的研究《To Code, or Not To Code? Exploring Impact of Code in Pre-training》（arXiv: 2408.10914）在控制了大量变量后确认了代码数据对以下能力的正向影响：

  • 自然语言推理（NLI）
  • 常识推理（Commonsense reasoning）
  • 世界知识（World knowledge，小幅提升）
  • 数学能力（显著提升）

为什么代码能提升推理？ 直觉上的解释有几个：

  • 结构化思维：代码天然具有严格的逻辑结构——条件分支、循环、函数调用、变量追踪。模型在大量代码上训练后，会学到这些结构化推理的模式，并将其迁移到自然语言推理中。
  • 精确性要求：代码是”不容错”的——一个语法错误就无法运行。这种精确性训练了模型对细节的敏感度，对于数学推理这种需要精确步骤的任务特别有帮助。
  • 多步推理：一段复杂代码需要追踪多个变量和状态的变化，这本质上是多步推理。模型在代码上学到的”追踪状态变化”能力，可以迁移到多步数学推理中。

对配比的启示：

  1. 代码数据的比例应该高于你直觉中的”够了”。即使你的目标是训练一个通用对话模型而非编程助手，15-25% 的代码数据也是值得的。
  2. 代码数据的质量同样重要。GitHub 上的代码质量参差不齐——有经过良好注释的开源项目代码，也有学生的练习作业和自动生成的配置文件。质量分层（按 star 数、lint 通过率、docstring 覆盖率等指标）是必要的。
  3. 代码相关的自然语言数据也很有价值。文档、README、Issue 讨论、PR review——这些代码周边的自然语言能帮助模型建立”代码-自然语言”的双向桥梁。

2.4 配比中的隐性决策

除了各域的宏观比例，还有一些”隐性”的配比决策同样重要：

域内的子域配比：比如代码域中，Python、Java、C++、JavaScript 各占多少？不同编程语言的数据对模型不同能力的贡献不同——Python 对数据科学和脚本能力重要，JavaScript 对 Web 开发重要，C/C++ 对底层系统理解有帮助。

质量层次的配比：同一个域内，高质量数据和低质量数据怎么混合？一种常见做法是：高质量数据多次重复使用（oversampling），低质量数据只用一遍或不用。

数据重复（Repetition）：有些高质量数据（如 Wikipedia）量很少，需要在训练中重复多次。但重复过多会导致记忆化。一般认为 3-5 次重复是安全的，超过 10 次可能开始出现问题（但混合训练下的容忍度远高于此，详见 §4.4 重复感知混合缩放定律）。

2.5 配比与能力的非线性关系：为什么”拍脑袋”会失败

理解配比，最重要的是建立”非线性”与”跨域溢出”两个直觉，否则后面的所有方法学都只是空中楼阁。

直觉一：能力不是配比的线性函数。 很多人误以为”代码数据加 10%，代码能力就加 10%“。真实情况是，配比—能力曲线有”甜蜜点”：在 0→15% 区间，每加一点代码数据，HumanEval 涨得很快；到 15%→25% 区间，边际收益开始递减；超过 30%，通用能力（闲聊、常识）开始被挤压，整体反而可能下降。这就是为什么”任何单一类型不能超过 30%“是一条经验红线——它不是拍脑袋，而是非线性曲线的安全边界。

直觉二：域与域之间会互相”借力”。 最典型的就是代码对推理的溢出（见 §2.3）。更深一层，代码数据还能间接提升数学、NLI、常识推理。这意味着你在优化配比时，不能把每个域当成独立变量去调——提升代码，可能顺带把数学和 ARC 也拉起来了；反过来，过度削减网页文本，可能让模型的常识与语言流畅度悄悄退化，而这在代码 benchmark 上看不出来。

直觉三：配比效应有规模依赖。 同样的配比，在 1B 模型和 70B 模型上带来的收益结构可能不同。数学数据在小模型上收益有限，到大模型上往往”突然开窍”。这也是为什么所有科学配比方法都强调”先小模型搜索、再外推验证”，而不是在小模型上找到最优就直接套用。

这三条直觉合在一起，解释了开头那个真实故事：方案 B 只是把网页砍了 15 个百分点分给代码和数学，就带来了代码 +13.5、数学 +9.4、推理 +3.4 的巨大收益，而通用知识只掉了 0.4。它不是因为代码和数学”本身更强”，而是因为利用了非线性甜蜜点 + 跨域溢出，在几乎不伤通用能力的前提下，把推理相关能力整体抬了上去。

10.3 经典静态配比：Llama-1 配方

Llama-1（Meta, 2023）首次公开了详细的预训练配方，成为后续开源模型的基准：

Llama-1 经典配方 (1T tokens):
  English CommonCrawl:  67%
  C4:                   15%
  GitHub:               4.5%
  Wikipedia:            4.5%
  Books:                4.5%
  ArXiv:                2.5%
  StackExchange:        2%

这个配方的问题也很明显——配比是静态的，整个训练过程不变。其 YAML 表达如下：

# Llama-1 静态配方
pretrain_mix:
  - source: 'cc_filtered'       # 过滤后的 CC
    weight: 0.67
    tokens: 670B
  - source: 'c4'                # C4 数据集
    weight: 0.15
    tokens: 150B
  - source: 'github_clean'      # 高质量 GitHub
    weight: 0.045
    tokens: 45B
  - source: 'wikipedia'         # 多语种 Wiki
    weight: 0.045
    tokens: 45B
  - source: 'books3'            # 书籍
    weight: 0.045
    tokens: 45B
  - source: 'arxiv'             # 学术论文
    weight: 0.025
    tokens: 25B
  - source: 'stackexchange'     # 问答
    weight: 0.020
    tokens: 20B

total_tokens: 1T

静态配比的实现并不复杂，核心是按权重归一化后采样到目标 token 数：

import numpy as np

class StaticMixer:
    """静态配比采样器"""
    
    def __init__(self, sources_weights):
        """
        sources_weights: dict, {source: weight}
        权重之和应为1
        """
        # 归一化
        total = sum(sources_weights.values())
        self.weights = {k: v/total for k, v in sources_weights.items()}
        self.sources_tokens = {}
    
    def sample(self, target_tokens):
        """按权重采样到目标 token 数"""
        for source, weight in self.weights.items():
            self.sources_tokens[source] = int(target_tokens * weight)
        return self.sources_tokens

# Llama-1 经典配方
llama1_mix = {
    'cc_filtered': 0.67, 'c4': 0.15, 'github_clean': 0.045,
    'wikipedia': 0.045, 'books3': 0.045, 'arxiv': 0.025,
    'stackexchange': 0.020,
}
mixer = StaticMixer(llama1_mix)
print(mixer.sample(target_tokens=1_000_000_000_000))  # 1T tokens

静态配比的三大局限：

  1. 配比靠经验：67% CC 是 Meta 工程师拍脑袋的，没有理论依据
  2. 训练全程不变：早期应该多通用、晚期应该多高质量精选
  3. 不适应数据变化：如果某个 source 突然变小，配比自动失效

3.4 静态配比的适用边界：它真的”过时”了吗？

尽管 DoReMi、RegMix 等学习式方法在 benchmark 上更亮眼，静态配比并没有被淘汰，而是找到了自己合适的位置。判断该不该上学习式方法，取决于三个约束：

算力约束。RegMix 需要 512 个 1M 模型 + 分布式训练管线，即便用 1-2 张 H100 也要跑一整天；DoReMi 需要训一个 reference 模型再做 Group DRO。如果你的团队只有一两张卡、训练窗口只有几周，静态配比（加一点熵驱动启发式，见 §4.6 第 0 步）可能是唯一现实的选择。

数据约束。学习式方法依赖”能在小模型上稳定反映大模型趋势”这一前提（rank invariance）。如果你的大部分数据是新爬的、质量未经验证、分布会随训练刷新，那 RegMix 的回归模型会失效，此时 CausalMix 这类因果方法更合适，但那也是预印本。在没有把握时，先用静态配比 + 多轮 proxy 消融反而更稳。

时间约束。静态配比最大的优势是”可解释、可复现、可审计”。当你需要向合作方或监管解释”为什么模型是这个性格”时，一份 Llama-1 风格的明文配方比一套黑盒回归预测更容易讲清楚。很多公司的”第一个能跑起来的模型”用的都是静态配比，等验证了数据管线，才在第二版上做学习式优化。

一句话总结：静态配比是工业落地的”第一版正确答案”，学习式配比是”追求极致的第二版答案”。 本章后续的方法学，目标不是否定静态配比，而是告诉你”什么时候、用什么成本、能换来多少提升”。

10.4 科学配比方法

4.1 Data Mixing Laws 与 Apple Scaling Laws

Data Mixing Laws（数据混合定律）。复旦 MOSS 团队 2024 年提出的 Data Mixing Laws（Ye et al., 2024）是这个方向的重要工作。核心思想是：数据配比对模型性能的影响是可以用函数关系建模和预测的。

具体来说，他们发现：

  1. 对于每个评估任务，模型性能与各域数据比例之间存在一个嵌套的 scaling law关系
  2. 可以先用小模型 + 少量训练 token来拟合这个关系，然后外推预测大模型在完整训练下的性能
  3. 基于预测的性能，可以用优化算法搜索最优配比

这个方法的实用价值在于：你不需要真的训练很多大模型来比较不同配比的效果，只需要训练一批小模型（如 400M-1B 参数），就可以预测大模型的最优配比。

具体流程：

1. 选择 N 个不同的配比（可以用拉丁超立方采样等方法高效覆盖配比空间）
2. 对每个配比，训练一个小模型（如 400M 参数，训练 50B token）
3. 评估每个小模型在目标 benchmark 上的表现
4. 拟合 Data Mixing Law 函数
5. 用拟合好的函数预测大模型的最优配比
6. （可选）用中等规模模型验证预测

局限性：小模型到大模型的外推不总是准确的。某些域的配比效应可能有规模依赖——比如数学数据在大模型上的收益可能比小模型上更大。需要设计验证实验来校准外推的可靠性。

Apple Scaling Laws for Optimal Data Mixtures。Apple 与索邦大学在 NeurIPS 2025 提出的 Scaling Laws for Optimal Data Mixtures 是 Data Mixing Laws 的重要扩展。相比 MOSS 团队的嵌套 scaling law 方法，Apple 方法的关键创新在于：参数可从少量小规模训练中估计，且可以跨模型规模和跨外推到未见过的域权重。实验表明，其预测能力可推广到大规模预训练。

实践价值：不需要为每个候选配比跑完整的小模型训练，只需要几个基准点就能拟合参数，预测任意配比组合的效果。这比传统的全量小模型训练实验效率更高。

4.2 DoReMi：配比搜索的开山之作

DoReMi（Domain Reweighting with Minimax Optimization, Xie et al., 2023, Google/Stanford）是第一个被广泛认可的配比搜索方法，在 §1.3 的二维框架中属于 offline × 学习式（离线搜索型）——它是在 proxy 阶段迭代搜出域权重，主训练拿到的是冻结的配方。

这里要先把一个历史遗留的叫法说清楚：DoReMi 在文献里常被称作”动态配比方法”，但那个”动态”指的是它的搜索过程是迭代的，不是”主训练中还在变”。按 §1.3 的判定标准，它属于离线。核心思想：用 Group DRO（Distributionally Robust Optimization）自动调整配比，用一个小的参考模型来指导大模型的数据域权重。

核心思想与两阶段流程：

  1. Reference 阶段：用初始配比训练一个小的 reference 模型
  2. Domain Weight 阶段：基于 reference 模型在各个 domain 上的 loss，自动调整权重——loss 大的 domain 加权重，loss 小的减权重
原始配比 → 训练 ref 模型 → 计算各 domain loss
   → 调整权重（loss 大的加权重） → 用新配比训练大模型

具体算法：

  1. 先用默认配比训练一个小的参考模型
  2. 然后训练一个同样大小的代理模型，使用 Group DRO（分组分布式鲁棒优化）来动态调整各域的采样权重——目标是最小化最差域上的超额损失
  3. 训练过程中产生的域权重就是优化后的配比
  4. 用这个配比训练大模型
import torch
import torch.nn.functional as F

class DoReMi:
    """DoReMi 域权重重估 / 离线配比搜索（简化版，工业级用 Ray/Spark 分布式）"""
    
    def __init__(self, domains, initial_weights, lr=0.01):
        self.domains = domains
        self.weights = torch.tensor(initial_weights, requires_grad=False)
        self.lr = lr
        self.domain_losses = {d: [] for d in domains}
    
    def update_weights(self, domain_losses):
        """
        根据各 domain 的 loss 更新权重
        domain_losses: dict, {domain: loss}
        """
        losses = torch.tensor([domain_losses[d] for d in self.domains])
        # Group DRO 更新：softmax on losses
        # 让权重更倾向于 loss 大的 domain
        temperature = 0.1
        new_weights = F.softmax(losses / temperature, dim=0)
        # 指数平滑更新（避免震荡）
        momentum = 0.9
        self.weights = momentum * self.weights + (1 - momentum) * new_weights
        self.weights = self.weights / self.weights.sum()
        return {d: self.weights[i].item() for i, d in enumerate(self.domains)}

# 使用示例
doremi = DoReMi(
    domains=['cc', 'github', 'arxiv', 'wiki', 'books', 'stackexchange'],
    initial_weights=[0.67, 0.045, 0.025, 0.045, 0.045, 0.020],
    lr=0.01
)
losses = {'cc': 2.5, 'github': 1.8, 'arxiv': 3.2, 'wiki': 2.0, 'books': 2.3, 'stackexchange': 2.1}
new_weights = doremi.update_weights(losses)
print(f'Adjusted weights: {new_weights}')
# arxiv 的 loss 最大（3.2），权重会被调高

DoReMi 实证效果。DoReMi 论文报告（在 8B 模型上，The Pile 数据集）：用 280M 模型得到的域权重可以有效指导 8B 模型的训练，在所有域上的困惑度都有改善，下游 few-shot 任务平均提升 6.5%。

配比策略MMLUARCTriviaQA
Llama-1 静态24.541.035.8
DoReMi 动态26.843.537.2

用同样数据，仅靠配比优化，MMLU 提升 2.3 分——零成本改进。

DoReMi 的关键洞察：默认配比（通常是按各域的原始大小比例）往往不是最优的。某些量大但质量一般的域（如网页文本）的权重应该降低，而某些量小但信息密度高的域（如数学、代码）的权重应该提高。

DoReMi 的局限性：优化目标是”最小化最差域的损失”，这是一个鲁棒性目标。但如果你的实际目标不是”所有域都好”，而是”某些域特别好”（比如你主要关心代码和数学能力），DoReMi 的结果可能不是最优的。这也催生了后续把目标函数改造成能力定向的改进（如 CAMEL，见 §4.4）。

4.3 RegMix：学习式配比

RegMix（Qian Liu et al., ICLR 2025, Sea AI Lab + SMU + Contextual AI + SUTD）是把”小模型搜索最优配比”思想推到工业级极致的代表，也是 §1.3 二维框架中 offline × 学习式（离线搜索型）的另一主力。与 DoReMi 在 proxy 阶段用 Group DRO 迭代搜索权重不同，RegMix 用回归模型直接在离线阶段拟合最优配比，再把结果用到大模型上——两者同属离线搜索型，区别只在”怎么搜”。

核心方法：

  1. 用大量小模型（如 1B）跑各种配比实验
  2. 记录每个配比对应的最终 loss
  3. 训练一个回归模型（如 LightGBM）预测”配比 → loss”
  4. 用回归模型优化出最优配比，再用于大模型训练
设计 1000 种配比 → 跑 1B 小模型 → 收集 (配比, loss) 数据
   → 训练 LightGBM 回归 → 优化出最优配比 → 用于大模型
import lightgbm as lgb
import numpy as np
from scipy.optimize import minimize

class RegMixOptimizer:
    """RegMix 学习式配比优化器"""
    
    def __init__(self, domains):
        self.domains = domains
        self.regressor = None
    
    def generate_random_mixes(self, n_mixes=1000):
        """生成 n_mixes 种随机配比（Dirichlet 分布）"""
        mixes = []
        for _ in range(n_mixes):
            alpha = np.ones(len(self.domains))
            mixes.append(np.random.dirichlet(alpha))
        return np.array(mixes)
    
    def train_regressor(self, mixes, losses):
        self.regressor = lgb.LGBMRegressor(n_estimators=200, learning_rate=0.05, num_leaves=32)
        self.regressor.fit(mixes, losses)
    
    def optimize_weights(self, target_loss='minimize'):
        def objective(weights):
            normalized = weights / weights.sum()
            mix = normalized.reshape(1, -1)
            return self.regressor.predict(mix)[0]
        x0 = np.ones(len(self.domains)) / len(self.domains)
        bounds = [(0, 1) for _ in self.domains]
        constraints = {'type': 'eq', 'fun': lambda x: x.sum() - 1}
        result = minimize(objective, x0, method='SLSQP', bounds=bounds, constraints=constraints)
        optimal_weights = result.x / result.x.sum()
        return {d: w for d, w in zip(self.domains, optimal_weights)}

# 使用示例
optimizer = RegMixOptimizer(domains=['cc', 'github', 'arxiv', 'wiki', 'books', 'stackexchange'])
mixes = optimizer.generate_random_mixes(n_mixes=1000)
losses = run_small_models_with_mixes(mixes)  # 实际需要分布式训练
optimizer.train_regressor(mixes, losses)
optimal_mix = optimizer.optimize_weights()
print(f'Optimal mix: {optimal_mix}')

关键假设：rank invariance。RegMix 整套方法依赖一个比 scaling law 拟合弱得多的假设——“不同配比之间的相对排名，在模型规模和训练 token 数变化时保持稳定”。换句话说：配比 A 在 1M 模型上比配比 B 好，在 1B / 7B / 100B 模型上 A 仍然比 B 好。这比传统的 “loss 数值外推”（需要假设 loss 的具体函数形式）弱得多，因此 RegMix 只需要 512 个 1M 小模型就能在 7B / 100B 上找到 13 个下游任务平均高 2 个点的最优配比。

工程落地细节：训练 512 个 1M 参数的小代理模型，每个训 1B token；512 × 1B = 5.12 × 10¹¹ token 总训练量，FLOPs 约为 1B 模型的 2%；在 64 个候选配比（1B / 25B token 两个规模）上做小模型搜索；用简单的回归模型把 1M 模型上的配比排名，映射到 1B / 25B 模型上的配比表现。

对工程团队的启示：

  • RegMix 的价值是能给出候选配比的精确排序——几百个 1M 模型用 1-2 张 H100 跑一天即可，所得排名可直接可视化与解释。但若目标只是得到一份好配方，2026 年起已有成本约 1.3 GPU 小时的替代（见本节末尾 FastMix），不必付这份钱
  • rank invariance 假设的稳健性是关键，方法在跨规模时表现稳定
  • 不依赖复杂回归，仅用配对排名即可

RegMix vs DoReMi：

特性DoReMiRegMix
思路参考模型 loss 驱动，proxy 阶段迭代调权重小模型消融数据驱动，离线回归拟合
计算量中（需训 reference 模型）高（需跑 1000+ 小模型）
准确性中-高高
可解释性中高
适用场景配比不确定时、在线自适应有充足算力做消融、追求精确排序

FastMix：把”需要几百个 proxy”这个成本前提直接拿掉（arXiv:2606.14971，ICLR 2026；代码 github.com/hrtan/fastmix）

上表的成本对比（RegMix”高：需跑 1000+ 小模型”）在 2026 年已经不是这一格的必付代价。FastMix 把配比搜索重构成双层优化（bilevel optimization），其核心等价性结论是：优化配比，等价于在”均匀采源”下给每个源分配一个损失权重。这一步把配比系数直接嵌进了可微的训练目标，于是配比可以跟着梯度走——只需训练单个 proxy 模型，而不需要为每个候选配比各训一个。实现上是内外层交替：内层按当前配比更新模型参数，外层按验证反馈更新配比；另加熵正则与训练损失项，抑制对验证集的过拟合与源的过度集中。

实测（回源 HTML 正文）：

场景FastMix对照
预训练（17 个 Pile 子集，proxy 最多 1B tokens；搜完训 1B 模型 25B tokens）14 个下游基准均分 48.2、平均 rank 1、9/14 项最佳；搜索成本 1.3 GPU 小时CLIMB 47.5（71.9 GPU 小时）、RegMix 47.2（720.5 GPU 小时）
后训练 SFT（math-tuning）搜索成本 2.2 GPU 小时，所得配方泛化到 coding 与 STEM-QA，达 65.4（+5.5 over next best）RegMix 115.9 小时、CLIMB 117.4 小时

推荐（三条，按你要的是什么来选）：

  1. 算力充裕且需要”多候选配比的精确排序” → RegMix（回归 + 配对排名的思路仍适合做 top-k 排序与可视化）
  2. 只需要一份好配方、且希望搜索成本可忽略 → FastMix（单 proxy + 梯度搜索，1.3 GPU 小时，同组得分还更高）
  3. 连一个 proxy 都跑不动 / 需要最强可审计性 → DoReMi 或静态配比（§3.4）

⚠️ 防误读：FastMix 不是 online。 它在”训练过程中”更新配比，但那些更新全部发生在 proxy 训练里——按 §1.3 那把尺子（“主训练跑起来之后配方还会不会变”），主训练拿到的仍是一份冻结配方，因此它属于 offline × 学习式，与 DoReMi / RegMix 同格，与 §1.4 的 AC-ODM 那种”主训练中由反馈重算”是两回事。它改变的是这一格的搜索成本，不是这一格的归属。

4.4 配套学习式方法：BiMix / OptiMer / 重复感知 / CAMEL

在 DoReMi、RegMix 之外，二维框架”静态学习式”象限里还有几类重要的补充方法，它们分别解决”联合外推""持续预训练""重复建模""容量感知”等问题。

BiMix：双变量 scaling law + 熵驱动免训练。BiMix 是 RegMix 同期的双变量 scaling law 工作，方法学上有两个关键贡献：

贡献 1：双变量 scaling law——同时建模”配比”和”训练 token 数”对 loss 的联合影响，弥补了 Data Mixing Laws 只能做单点（固定 token 数）外推的不足，在 1B / 4B / 7B / 13B 多个规模上验证。

贡献 2：熵驱动的免训练数据混合（意外发现）——BiMix 实验过程中发现：仅基于数据本身的熵特征（无需训练代理模型）就能取得与资源密集型方法相当甚至更优的性能。具体做法：计算每个数据源的 token 熵 / n-gram 熵 / 文档长度熵等指标，用简单的加权公式作为混合权重。这意味着工业实践中可以用一个轻量级、可解释的 heuristic 替代昂贵的 proxy 训练。

对工程团队的启示：在预算有限或需要快速 baseline 时，“熵驱动的启发式混合”是值得首先尝试的低成本路径；BiMix 本身的双变量 scaling law 适合做”我要训多少 token、用什么配比”的联合优化；熵驱动 + RegMix 可以组合：先用熵快速筛出 top-10 候选配比，再用 RegMix 精确排序。

OptiMer：分布向量合并方法。OptiMer 提出了一种革命性的持续预训练配比优化范式。核心思想：不为每种数据类型单独训练模型，而是先为每种数据类型单独训练一个模型并提取”分布向量”（distribution vector），然后通过贝叶斯优化将这些向量合并，寻找最优组合权重。相比传统方法：不需要固定配比下从头训练；搜索时间从数周缩短到数小时；效率提升 15-35 倍。在多语言和多领域任务上的实验均显示显著改进。

重复感知混合缩放定律（Repetition-Aware Mixture Scaling Law, Apple, 2026, arXiv: 2605.12715）。这是现有 Data Mixing Laws 的重要补充，系统研究了混合预训练中数据重复的影响。

核心问题：当目标领域数据稀缺时，我们需要重复使用这些数据。但重复多少次是最优的？传统 Data Mixing Laws 假设每条数据只出现一次，没有建模重复的边际效益递减。

实验规模：2000+ 次 LLM 训练运行，覆盖多种模型规模、目标数据集大小、数据类型（多语言/领域专用/质量筛选）。

关键发现：

  1. 混合训练对重复的容忍度远高于单一数据源训练。在单源训练中，数据重复超过 4 次后性能开始退化；但在混合训练中，稀缺目标语料可被重复使用 15-20 次而不退化。原因是通用数据起到了正则化作用，抵消了重复带来的记忆化风险。
  2. 样本重复次数是影响目标领域性能的核心因素，比单纯的数据量更重要。
  3. 最优重复次数取决于三个变量的交互：目标数据规模、计算预算和模型参数量。可以用缩放定律形式化建模。

对配比实践的直接影响：

传统认知：高质量数据重复不超过 5 次
                ↓
重复感知定律：混合训练中，稀缺领域可重复 15-20 次

实操建议：
  - 对于数据充足的域（如英文网页）：1x 采样
  - 对于数据稀缺但重要的域（如数学、小语种）：可上采样到 15-20x
  - 关键前提：必须有足够的通用数据做"正则化锚点"
  - 判断标准：监控目标域 loss 是否出现回升（记忆化信号）

CAMEL：容量感知混合定律（Capacity-Aware Mixture scaling Law, arXiv: 2603.08022, Mar 2026）。首个建模模型规模与数据混合非线性交互的缩放定律。

核心创新：将混合优化重构为”容量约束分配”问题。传统方法假设域权重的最优值与模型规模无关，但 CAMEL 发现：每个内在域的有效参数分配随混合比例和模型容量变化——模型越大，分配给通用域的”容量”占比越少，分配给专业域的”容量”占比越多。

方法架构：

CAMEL 管线：
1. 小模型拟合 → 在 7B-A150M MoE 上拟合容量约束参数
2. 损失预测 → 从容量约束推导各域验证损失
3. 基准预测（loss-to-benchmark prediction law）→ 建立验证损失 → 基准准确率的映射
4. 大模型外推 → 外推到 55B-A1.2B 验证

效果：优化成本降低 50%，下游基准性能提升最高 3%。CAMEL 的”沙漏采样策略”（小模型拟合→大模型外推）解决了现有混合定律在大模型外推时失效的问题；loss-to-benchmark 映射更是实用创新——大多数团队关心的是 benchmark 分数而非验证损失，CAMEL 直接建立了这个桥梁。

4.5 前沿进展：从静态到在线配比

在 DoReMi / RegMix 之后，2026 年的配比研究出现了两条清晰的前沿分支：一是改进”语义桶”划分前提（GEM、DoGraph），二是从静态配比转向在线/动态配比（RegMix-D、CausalMix、HDS、TiKMiX）。

GEM：几何熵混合优化语义分桶（ICML 2026）。GEM 解决了 DoReMi/RegMix/Aioli 等 mixing 框架的前提问题——如何划分”语义桶”。现有 K-Means（欧氏空间）与 cosine-based embedding 不兼容导致 cluster collapse。GEM 用 vMF（von Mises-Fisher）混合在超球面上聚类 + 平衡正则防塌缩 + Teacher-Student 蒸馏到 FastText，在 1.1B 模型上叠加三种 mixing 框架平均提升 1.2%。核心启示：配比优化的输入质量同样重要——垃圾入桶，垃圾出配比。

DoGraph（ACL 2026） 则挑战了更底层的前提——“域”本身：用梯度空间聚类构建”模型眼中的域”，超越人工定义的”数据来源类别”。主实验（GPT-2 Medium / SlimPajama）平均分 37.9，高于 DoReMi（36.5）、RegMix（35.7）、Uniform（35.4），PPL 3.09 为所有对比方法最低（Uniform 4.13）；在 LLaMA-1.1B / LLaMA-3.2-3B / The Pile 上稳定领先；计算开销仅比 RegMix 高约 4.51%。

CausalMix：因果推断化解数据池漂移（清华，2026）。RegMix 的致命缺陷是假设数据池固定不变——当数据源刷新/过滤/扩展时回归模型失效。CausalMix 将配比优化重定义为因果推断问题：数据池统计特征→协变量，配比权重→treatment，目标→估计 CATE（条件平均处理效应）。因果模型吸收分布漂移而非崩溃。在 Qwen2.5-0.5B 上 512 次代理训练后，可外推到 7B 模型 + 800K 文档池，无需重跑回归。（预印本，但问题定义方式有理论创新性。）

RegMix-D：从静态配比到动态混合（东京大学/NII, 2026）。RegMix 只用终点 loss，RegMix-D 利用完整损失轨迹预测多阶段最优配比，支持离线（预生成混合计划）和在线（训练中自适应）两种模式。仅需 RegMix 25% 代理算力（128 个代理模型）即可超越 RegMix 性能。（预印本，但方法是对 RegMix 的自然扩展。）

HDS（Holistic Data Scheduler, arXiv:2606.24133） 是这条线上较新的代表：将配比建模为连续控制 MDP，用 Soft Actor-Critic（SAC）在线调整各域采样概率，奖励由三维 holistic 信号构成——数据质量驱动（data-driven）+ 域间影响梯度对齐（gradient-driven，承接 AC-ODM）+ 模型中心权重范数（weight-norm，促进收敛稳定）。

量化结果（The Pile / Pythia-1B，50B tokens）：达到次优方法（AC-ODM）的最终验证 PPL 少 44% 训练迭代；相对静态 The Pile Weights（TPW）基线少 57% 迭代；MMLU 0-shot +7.2%、5-shot +4.0%，Pile 测试集 PPL 再降 7.0%。代码已公开。

成熟度更正：HDS 已中稿 KDD 2026——第 32 届 ACM SIGKDD（KDD ‘26，2026-08-09~13，韩国济州），DOI 10.1145/3770854.3780325，ISBN 979-8-4007-2258-5/2026/08，发表日 2026-06-23。本章此前把它与 TiKMiX 合并标注为”预印本待验证”，会低估该方向的成熟度——它与下文”在线/动态 = 潜力最大”的评价叠在一起，容易让读者做出”先别用”的错误判断。

TiKMiX（arXiv:2508.17677） 走 influence-function 路线：定义 Group Influence（域级影响估计）作为在线配比目标，TiKMiX-D（直接优化）在 20% RegMix 计算资源下超越 RegMix，TiKMiX-M（回归预测器）在 9 个下游任务平均 +2%，训练规模达 1T tokens。其核心观点与 RegMix-D 一致：域偏好随训练进度与模型规模漂移，静态配比会”欠消化”（underdigestion）。

CausalMix 与 RegMix-D 的路线差异：两者都回应”数据池漂移”，但改的是不同对象——RegMix-D 在训练中动态调整配方（时序维度），CausalMix 改的是拟合对象（用 CATE 刻画”数据池特征如何驱动性能”，而非”哪些固定配比碰巧有效”）。理解这一点，就能抓住配比研究的两大前沿分支。

配比方法论演进总览：

方法范式核心创新局限性
DoReMi离线学习式Group DRO 自适应收敛慢，噪声大
RegMix学习式配比LightGBM 回归预测假设数据池固定
CausalMix因果配比CATE 吸收漂移预印本待验证
RegMix-D动态学习式完整损失轨迹预印本待验证
GEM语义桶优化vMF 超球面聚类与配比方法解耦
DoGraph域定义重构梯度空间聚类计算略高于 RegMix
HDS在线配比SAC 连续控制 MDPKDD 2026 已录用（DOI 10.1145/3770854.3780325）
TiKMiX在线配比Group Influence预印本待验证

4.6 配比搜索方法决策树

结合本章的方法学框架与陷阱分析，给出一个配比搜索方法决策树，帮助工程团队按需选择路径：

第 0 步（推荐作为 baseline）：熵驱动的免训练混合
  - 计算每个数据源的 token 熵 / n-gram 熵 / 文档长度熵
  - 用简单加权公式作为混合权重
  - 成本：几小时 CPU 即可完成
  - 适用：预算紧、需要快速 baseline、不确定要不要上 proxy 训练
  - 出处：BiMix 论文的意外发现

第 1 步：小模型回归校准（分两档，按"你要的是一份配方还是一份排序"选）
  - 1a（默认）FastMix：单 proxy + 梯度搜索，成本 1.3 GPU 小时
    - 适用：我需要一份好配方，不需要候选排序（FastMix 在同组 14 基准上 48.2 rank 1，高于 RegMix 47.2）
  - 1b（需要排序时）RegMix / Apple Scaling Laws：512 个 1M 模型 + 配对排名，成本 1-2 张 H100 × 1 天
    - 适用：我需要 top-3 候选并理解为什么（可解释性与可视化是这一档的真实价值）

第 2 步：双变量 scaling law 联合优化
  - BiMix（配比 + token 数）
  - 成本：需要 1B / 4B / 7B 三个规模
  - 适用：训练预算确定后想知道最优 token 分配

第 3 步：分布向量后验优化
  - OptiMer（贝叶斯优化 + 分布向量合并）
  - 成本：搜索时间从数周缩短到数小时
  - 适用：持续预训练场景（已有基座 + 多个新数据源）

第 4 步：能力定向注入
  - CAMEL（容量感知）/ DoReMi（鲁棒性目标）
  - 适用：需要模型规模 × 混合比例的非线性交互建模

第 5 步：训练中动态调整
  - 课程学习（按难度调度）
  - 重复感知混合缩放定律（按目标域 loss 回升信号调整）
  - 适用：训练周期长、有能力迁移需求

决策核心：多数团队应从第 0 步开始——熵驱动 baseline 已经能跑赢人工经验配比；预算允许时第 1a 步（FastMix）是当下性价比最高的科学化升级（1.3 GPU 小时即可拿到同组 rank 1 的配方）；只有当你需要候选排序而非单份配方时，才付第 1b 步的钱；只有在第 1、2 步都不奏效时，再考虑第 3、4、5 步。

现成框架：别从零拼管线。 本章给出的都是可粘贴的片段，但把它们拼成能跑的管线仍是读者的活。若不想从零搭，可先看 DataFlex（arXiv:2603.26164，2026-03-27）：建在 LLaMA-Factory 之上的统一 data-centric 动态训练框架，覆盖 sample selection / domain mixture adjustment / sample reweighting 三种范式，与原训练流程完全兼容（drop-in replacement），提供可扩展 trainer 抽象与模块化组件，并支持 DeepSpeed ZeRO-3 的大规模设置。

它有两个额外价值：① 独立复现——本章 DoReMi / ODM 的数字此前全部来自各自原论文，DataFlex 提供了第三方统一实现下的一致性验证（动态数据选择在 Mistral-7B 与 Llama-3.2-3B 上稳定优于静态全量训练；DoReMi 与 ODM 在 Qwen2.5-1.5B / SlimPajama 的 6B 与 30B token 两个规模上同时改善 MMLU 与语料级 PPL）；② 可比性——三派方法散落在各自代码库、接口不一致，是”无法公平比较”的主因，统一框架先解决这一层。

选型提示：框架只解决”跑得起来与可比”，不解决”配方对不对”——上面 §4.6 这套方法学选择仍然是读者的活。另：DataFlex 绑定 LLaMA-Factory 生态，若不在此生态内，仍需自行移植。

4.7 方法学选择的成本-收益权衡：一张表说清

为了把前面的方法横向摆在一起，下面用一张综合表对比它们的”投入”与”预期回报”，帮助你在立项时做预算决策：

方法算力投入工程复杂度预期收益适用阶段风险
经验静态配比无低基线任何偏低（靠经验）
熵驱动免训练几小时 CPU低中（跑赢经验）baseline低
Data Mixing Laws中（多小模型）中中-高选型外推误差
Apple Scaling Laws低（少基准点）中中-高选型外推误差
DoReMi中（ref + proxy）中+2~3 分离线搜索鲁棒目标偏保守
FastMix低（1.3 GPU 小时）中（需实现双层优化的内外层交替与熵正则）≥ RegMix（48.2 vs 47.2，同组 14 基准）离线搜索 + 后训练 SFT依赖验证集反馈，需防对验证集过拟合
RegMix高（512×1M，约 720 GPU 小时）高+2 分均分（同组 47.2）离线精排数据池假设
BiMix中-高中中（联合 token）联合优化中等
OptiMer中（分布向量）高高（持续预训练）CPT工程复杂
CAMEL中高+3 分上限容量感知待验证
重复感知定律高（2000+ 实验）中重复次数优化稀缺域下限已知
在线/动态（HDS/TiKMiX 等）高很高潜力最大长训练HDS 已中稿 KDD 2026，其余多为预印本

读表要点：

  1. 同格方法的成本可以差两个数量级而收益不降：FastMix 1.3 GPU 小时（48.2 / rank 1）vs RegMix 约 720 GPU 小时（47.2），平均分反而更高。所以选型时先问”我要的是一份配方还是一份排序”，再谈预算——而不是先假设科学化配比一定贵。（原”RegMix 比 DoReMi 贵一个数量级但收益只多不到 1 分”这条仍然成立，只是它不再是这张表最重要的一句话。）
  2. 表中所有”待验证/预印本”的方法，都建议先在小规模 proxy 上复现再决定是否进主训练流程，不要让未经验证的方法直接决定 15T token 的配方。
  1. 最佳实践是”组合”而非”单选”：熵驱动筛 top-10 → FastMix 精搜（或 RegMix 精排） → CAMEL 做容量校准 → 重复感知定律定稀缺域上采样倍数。这一串组合的总算力仍远低于”为每个候选配比跑全量大模型”。

10.5 多语言配比的特殊考量

对于需要支持多种语言的模型，数据配比中多了一个关键维度：语言配比。

5.1 中英文配比的微妙平衡

以一个面向中文用户但也需要英文能力的模型为例，中英文配比的选择涉及多个权衡：

英文数据量远大于中文。互联网上高质量英文内容的量级大约是中文的 5-10 倍。如果简单按”可用数据量”分配，英文占比会远超中文。

但中文能力需要足够的中文数据来保证。经验上，如果中文数据占比低于 15-20%，模型的中文表现会明显不足——中文的成语使用、文言文理解、文化常识等都需要大量中文语料来学习。

英文数据对中文能力有间接帮助。很多知识是”语言无关”的——物理定律、数学概念、编程逻辑。模型从英文数据中学到的这些知识，可以一定程度上迁移到中文。所以即使中文是目标语言，大量英文数据也是有价值的。

实际案例对比：

模型中文占比（估计）英文占比（估计）其他语言中文能力英文能力
Llama 3~5%~85%~10%弱强
Qwen 2.5~40%~40%~20%强强
DeepSeek V3~25%~55%~20%强强

Qwen 系列的策略是中英文大致均衡，这保证了强劲的中文能力。Llama 系列则以英文为核心，中文能力相对较弱。DeepSeek 走了一个中间路线。

5.2 Token 效率差异的影响

一个常被忽视但很重要的因素是：不同语言的 token 效率差异很大。

以 BPE tokenizer 为例，同样一段内容：

  • 英文：“The cat sat on the mat” → 约 6 个 token
  • 中文：“猫坐在垫子上” → 可能 5-7 个 token（取决于 tokenizer）

但中文的信息密度通常高于英文——同样语义的内容，中文的字数更少。这意味着：

  1. 同样 token 数的中文数据，可能包含更多的信息
  2. 如果按 token 数计算配比，中文的”实际内容量”可能被低估
  3. 多语言 tokenizer 的设计会影响配比的实际效果——一个对中文友好的 tokenizer（中文 token 效率高）意味着同样的中文内容消耗更少的 token

5.3 低资源语言的”搭便车”效应

一个有趣的发现是：即使某种语言在训练数据中只占很小的比例，如果该语言与训练中占比较大的语言有较高的相似性，模型仍然可以表现不错。这被称为”搭便车效应”（free-riding effect）或”跨语言迁移”（cross-lingual transfer）。

例如：

  • 日文模型可以从大量中文数据中”搭便车”——两者共享汉字
  • 西班牙语模型可以从法语和意大利语数据中受益——拉丁语系的相似性
  • 粤语理解可以从普通话数据中受益——但程度有限

这意味着多语言配比不需要对每种语言都保证大量数据，但需要理解语言之间的迁移关系。FineWeb-2 的多语言管线方案为这个问题提供了一个系统化的参考框架。

5.4 多语言配比的决策框架

Step 1: 明确目标语言的优先级（一级语言、二级语言、支持语言）
Step 2: 估算各语言的可用高质量数据量
Step 3: 考虑语言间的迁移关系
Step 4: 设定各语言的最低配比保障线（一级语言 >20%，二级语言 >5%）
Step 5: 用 proxy 实验验证配比效果
Step 6: 在训练过程中监控各语言的 benchmark 表现，必要时微调

10.6 配比实践中的常见陷阱

6.1 按数据量的原始比例分配

最简单也最常见的做法是”有多少用多少”——数据源有多大，就按这个比例分配。但这几乎肯定不是最优的。网页文本在 Common Crawl 中的量级远大于所有其他域的总和，如果按原始比例分配，网页文本会占 90% 以上，高质量域（代码、数学、学术）被严重稀释。

正确做法：将高质量域的配比提升到明显高于其原始比例，代价是降低网页文本的比例。这通常需要对高质量数据做 2-5 倍的重复采样。

6.2 过度重复高质量数据

为了提升高质量域的配比，常见的做法是让高质量数据在训练中被重复看多次。但重复过度会导致：

  • 记忆化：模型开始”背诵”这些内容而非理解
  • 多样性下降：模型的输出会偏向这些被重复的数据的风格

经验法则：单条数据的重复次数不宜超过 5 次。如果某个域的数据确实不够，考虑用合成数据来扩充，而非过度重复。

更定量的边界：InfoLaw（arXiv: 2605.02364, 2026）。经验法则”不超过 5 次”是粗粒度的，InfoLaw 的质量-重复联合 Scaling Law 提供了更精确的决策边界。核心发现：是否应该强化上采样高质量数据，取决于是否处于”过度训练”（overtraining）区间。如果模型尚未充分训练，增加上采样权重始终有益；但一旦进入过度训练区间，继续增加上采样会加剧重复，反而降低性能。判断是否进入过度训练区间，需要监控训练 loss 的下降趋势——当目标域的 loss 下降明显放缓时，可能已接近或进入过度训练区间，此时应停止增加高质量数据的上采样权重，转而寻找新的高质量数据源。

6.3 只看整体 benchmark，忽视分项分析

一个看似不错的配比可能掩盖了严重的能力偏科。比如代码比例过高可能导致 MMLU 整体分数不变（代码推理的提升弥补了通用知识的下降），但模型在历史、地理等知识性问题上退化了。

正确做法：建立一个多维评估体系，分别监控每个能力维度的表现。确保没有任何能力出现明显退化。

6.4 忽视域内的质量分层

把”代码”作为一个整体来设置配比是过于粗糙的。GitHub 上的代码质量差异巨大：高 star 数的项目代码 vs 学生作业；有完善文档和测试的代码 vs 没有注释的代码；主流编程语言 vs 小众语言；正常的源码 vs 自动生成的配置文件。

正确做法：在域内也做质量分层，对不同质量层赋予不同的采样权重。高质量代码可以 3x 采样，低质量代码可以 0.5x 或直接过滤掉。

6.5 训练中途改配比时不考虑连续性

如果在训练进行到一半时决定改变配比（比如增加数学数据），需要注意平滑过渡。突然大幅改变数据分布可能导致训练 loss 突然上升，甚至训练不稳定。

正确做法：配比变化应该在 1000-5000 步内线性过渡到新配比，而非一步跳变。

6.6 配比过偏向某一类的踩坑经验（工程实证）

以下是工业实践中反复出现的配比失误案例，与上述陷阱一一呼应：

  • 坑1：配比过偏向某一类。某团队为了提升数学能力，把数学数据配比拉到 50%，结果模型闲聊能力崩塌，“hello” 都不会回答。任何单一类型不能超过 30%（通用模型口径）。

    口径限定（必读）：这条 30% 上限针对的是通用模型。代码模型、数学模型等专精模型不在此限——本章 §7.3 的「代码模型配方」即把 github_clean 提到 0.50（代码占大头，配 cc_tech 0.25），代价是通用能力显著退化。同章两处并列出现而没有口径说明，容易让读者困惑”代码到底能不能超 30%“。判断标准不是比例数字，而是”你能否接受通用能力退化”：能接受，专精域可以远超 30%；不能接受，就守住 30%。

  • 坑2：多语种配比失衡。某团队中文项目，配比 80% 中文，结果模型英文能力极弱，无法理解英文 prompt。多语种模型至少 20% 英文。
  • 坑3：代码数据过多导致”代码味”。某团队配比 40% 代码，结果模型生成自然语言时频繁吐出 print()、def 等代码片段。代码配比建议 15-25%。
  • 坑4：退火数据与主训练重复。某团队退火用的是主训练数据的子集，结果退火几乎无效果。退火数据必须独立精选，且质量更高（详见第三部分）。
  • 坑5：阶段切换太突然。某团队从 Pretrain 切到 Midtrain 时学习率突然降 10 倍，loss 跳变。阶段切换时学习率应平滑过渡（如 1000 步线性插值）。

第二部分：阶段化配方——Pretrain → Midtrain → 退火 → 长文

第一部分解决的是”单个配比怎么定”，但工业级预训练从来不是一份固定配方训到底。模型在不同的 token 阶段需要不同的数据分布——早期打基础、中期注入能力、末期精修、最后扩展上下文。第二部分把配比从”单点”扩展成”随时间变化的配方曲线”。

10.7 训练阶段切分与阶段化配方

7.1 四阶段总览

工业级预训练通常分 4 个阶段，每个阶段配比不同：

阶段定位配比特点规模
Pretrain 一阶段建立通用能力网页 60%+代码 15%+书籍 10%+数学 10%+多语 5%10-15T
Midtrain 二阶段注入推理/代码代码 30%+数学 20%+推理 15%+网页 25%+其他 10%1-3T
Annealing 退火收尾提分高质量精选 50%+数学代码 30%+少量 SFT 20%50-500B
Long Context 长文扩展上下文拼接长文档、书籍、代码仓库50-200B

7.1.1 为什么是四个阶段，而不是更多或更少

把预训练切成四段，不是一个随意的选择，而是对”学习动态非平稳性”的工程妥协。

两阶段（只分主训练 + 退火） 是最朴素的切法，很多早期模型就是这么做的。它的好处是简单、切换少、不容易出 bug；坏处是错过了”中期注入能力”的窗口——如果代码和数学只在退火那 200B 里拉满，模型根本没有足够的 token 去内化结构化的代码思维，退火只能起到”唤醒”而非”建立”的作用。DeepSeek-V3 的经验恰恰说明，代码/数学能力需要在主训练中期就大量注入，退火只是收尾放大器。

三阶段（主训练 + 中训练 + 退火） 是当下最主流的折中。它在两阶段基础上，把”能力注入”从退火提前到 Midtrain，让模型有足够 token 真正学会代码和推理。代价是需要一次额外的阶段切换（见 §14 的平滑过渡机制）。

四阶段（再加长文） 则是为”长上下文”产品准备的。长文阶段不能太早——在模型还没建立基本语言能力时就喂它 32K 的拼接长文档，会稀释语言建模的信号；也不能太晚——如果进后训练才扩展上下文，SFT/RL 数据都要重做。所以长文训练被放在退火之后、后训练之前，作为一个独立的短阶段（50-200B）。

为什么不建议超过四阶段？ 经验法则是”阶段数控制在 3-5 个，每个阶段至少 200B tokens”（见 §14.3 坑3）。阶段切得太碎，每次切换都有能力损失（loss 跳变、知识遗忘），总账反而不划算。YuLan-Mini 之所以敢切 27 个课程阶段，是因为它把”课程”放在同一份数据内部按难度排序，而不是每次都改全局学习率和数据分布——这是”软课程”和”硬阶段切换”的本质区别。

一个常被忽视的视角：阶段配比的”连续性约束”。 相邻两个阶段的数据分布不能跳变太大。从 Pretrain（网页 60%）直接跳到 Midtrain（代码 30%）看似激进，但因为保留了大量网页，过渡是平滑的；但如果从 Pretrain 直接跳到退火（数学 40%），就必须用 §14 的渐进混合（保留 20% 主训练数据）来兜底，否则会出现知识遗忘。这个约束决定了你的阶段配方不能各自独立设计，而必须作为一个整体曲线来规划。

7.2 各阶段配方详解

Pretrain 一阶段配方（建立通用地基，数据以高质量网页为主）：

# Pretrain 一阶段（10-15T tokens）
pretrain_phase1:
  duration: 10T-15T tokens
  learning_rate: 3e-4
  
  mix:
    - source: 'cc_high_quality'    # FineWeb-Edu ≥3
      weight: 0.60                # 6-9T
    - source: 'github_clean'
      weight: 0.15                # 1.5-2.25T
    - source: 'books'
      weight: 0.10                # 1-1.5T
    - source: 'arxiv_latex'
      weight: 0.07                # 0.7-1.05T
    - source: 'wikipedia_multilingual'
      weight: 0.05                # 0.5-0.75T
    - source: 'stackexchange_high_vote'
      weight: 0.03                # 0.3-0.45T
  
  # 多语种细分（在 wiki 内部）
  language_split:
    en: 0.40
    zh: 0.15
    other: 0.45

Midtrain 二阶段配方（注入推理与代码能力，代码/数学占比拉高）：

# Midtrain 二阶段（1-3T tokens）
midtrain_phase2:
  duration: 1T-3T tokens
  learning_rate: 1e-4  # 比 Phase1 低
  
  mix:
    - source: 'cc_filtered'         # 通用网页（保持语言能力）
      weight: 0.25
    - source: 'github_clean'
      weight: 0.30                # 提升代码能力
    - source: 'arxiv_math'
      weight: 0.20                # 提升推理
    - source: 'reasoning_chains'   # 合成推理链
      weight: 0.15
    - source: 'wikipedia'
      weight: 0.05
    - source: 'stackexchange'
      weight: 0.05

Annealing 退火阶段配方（收尾精修，详见第三部分）：

# Annealing 退火（50-500B tokens）
annealing_phase3:
  duration: 50B-500B tokens
  learning_rate: 3e-5  # 大幅降低
  schedule: linear_decay_to_zero  # 线性衰减到0
  
  mix:
    - source: 'fineweb_edu_4plus'  # ≥4分精选
      weight: 0.50                # 50%
    - source: 'arxiv_math'         # 数学/论文
      weight: 0.20
    - source: 'github_clean'       # 代码
      weight: 0.15
    - source: 'stackexchange_top'  # 高赞问答
      weight: 0.10
    - source: 'synthetic_reasoning' # 合成推理链（GSM8K等）
      weight: 0.05

Long Context 长文阶段配方（扩展上下文窗口）：

# Long Context 长文（50-200B tokens）
long_context_phase4:
  duration: 50B-200B tokens
  learning_rate: 1e-5
  context_length: 32768  # 从 8K 扩展到 32K
  position_encoding: rope_scaling  # 用 RoPE scaling
  
  mix:
    - source: 'long_documents'      # 拼接长文档
      weight: 0.40
    - source: 'books_full'           # 完整书籍
      weight: 0.30
    - source: 'github_repo_full'     # 完整代码仓库
      weight: 0.20
    - source: 'multi_turn_dialogues' # 多轮对话
      weight: 0.10

7.3 推荐配方模板

通用模型配方：

# 通用大模型（如 Llama3 类）
recommended_general:
  pretrain:
    cc_high_quality: 0.60
    github_clean: 0.15
    books: 0.10
    arxiv: 0.05
    wiki: 0.05
    stackexchange: 0.05
  midtrain:
    cc: 0.30
    github: 0.30
    arxiv_math: 0.20
    reasoning: 0.15
    wiki: 0.05
  annealing:
    fineweb_edu_4plus: 0.50
    arxiv_math: 0.20
    github: 0.15
    stackexchange_top: 0.10
    sft_like: 0.05

中文模型配方：

# 中文大模型
recommended_chinese:
  pretrain:
    cc_zh: 0.50           # 中文 CC
    cc_en_filtered: 0.15  # 英文 CC（保留通用能力）
    github_clean: 0.10
    wiki_zh: 0.10
    books_zh: 0.05
    books_en: 0.05
    baike: 0.05           # 百科类

代码模型配方：

# 代码模型（如 Code Llama）
recommended_code:
  pretrain:
    github_clean: 0.50    # 代码占大头
    cc_tech: 0.25         # 技术网页
    stackexchange: 0.10
    arxiv: 0.10
    wiki: 0.05

10.8 配比实验设计：Proxy 实验与 Scaling Law 外推

8.1 小模型消融实验

在没有现成工具的情况下，一个更朴素但有效的方法是系统化的 proxy 实验：用小模型（如 1B-3B）+ 短训练（如 100B-300B token）来快速测试不同配比的效果，然后将最优配比应用到大模型训练上。

设计要点：

  1. 基准配比（Baseline）：先确定一个”合理的默认值”作为基准。一个常见的起点是：网页文本 60%、代码 15-20%、书籍 8-10%、学术论文 5%、数学 3-5%、其他 5%
  2. 消融变量：一次只改变一个域的比例，观察其对不同 benchmark 的影响
  3. 交叉效应检测：注意不同域之间的交互效应。增加代码可能同时提升数学和推理，但增加对话数据可能降低写作的正式性
  4. 统计显著性：小模型实验的方差较大。建议每个配比至少用 2-3 个不同的随机种子训练，取平均值
  5. 评估指标的选择：不要只看一个 benchmark。设计一个涵盖你关心的所有能力的评估集，并给不同能力赋予权重
# 一个简化的配比实验设计框架
domains = ['web', 'code', 'math', 'books', 'academic', 'wiki', 'conversation']

# 基准配比
baseline = {
    'web': 0.58, 'code': 0.17, 'math': 0.05,
    'books': 0.08, 'academic': 0.05, 'wiki': 0.04, 'conversation': 0.03
}

# 消融实验：逐个域调整
ablations = []
for domain in ['code', 'math', 'books']:
    for delta in [-0.05, 0.0, 0.05, 0.10]:
        config = baseline.copy()
        config[domain] += delta
        config['web'] -= delta  # 用网页文本来平衡
        ablations.append(config)

# 每个配比训练一个 1B 模型，100B token，评估并分析结果

用 1B 模型做配比消融的实操代码：

def ablation_experiment(mix_configs):
    """用 1B 小模型测试不同配比"""
    results = []
    for config_name, mix in mix_configs.items():
        print(f'Running experiment: {config_name}')
        model = train_1b_model(mix=mix, tokens=100_000_000_000, lr=3e-4)
        scores = {
            'mmlu': eval_mmlu(model),
            'arc': eval_arc(model),
            'human_eval': eval_human_eval(model),
            'gsm8k': eval_gsm8k(model)
        }
        results.append({'config': config_name, 'mix': mix, 'scores': scores})
    return results

# 设计 5-10 个对比配方
ABLATION_CONFIGS = {
    'baseline': {'cc': 0.7, 'code': 0.1, 'math': 0.05, 'wiki': 0.05, 'other': 0.1},
    'more_code': {'cc': 0.5, 'code': 0.3, 'math': 0.05, 'wiki': 0.05, 'other': 0.1},
    'more_math': {'cc': 0.5, 'code': 0.1, 'math': 0.25, 'wiki': 0.05, 'other': 0.1},
    'balanced': {'cc': 0.4, 'code': 0.2, 'math': 0.2, 'wiki': 0.1, 'other': 0.1},
}

8.2 Scaling Law 外推

# 用小模型结果外推到大模型
def extrapolate_scaling_law(small_results, target_params):
    """用 Chinchilla Scaling Law 外推"""
    import numpy as np
    from scipy.optimize import curve_fit
    
    def loss_fn(N, A, alpha, B, beta, E):
        return E + A / N**alpha + B / small_results['tokens']**beta
    
    popt, _ = curve_fit(loss_fn, small_results['params'], small_results['losses'])
    predicted_loss = loss_fn(target_params, *popt)
    return predicted_loss

8.3 在线配比调整

一个更高级的策略是在训练过程中动态调整配比，而非使用固定配比训练到底。

基本思路：每隔 N 步评估模型在不同 benchmark 上的表现，根据评估结果调整下一阶段的数据配比。如果某个能力落后了，就加大对应域的数据比例。

实现方案（前两项属于 §1.3 定义的 online 反馈驱动；第三项其实是预定义调度，只是恰好也发生在训练过程中，别把它当成 online）：

  1. 评估驱动的调整：每训练 10B token，在一组快速评估集上评估模型；如果某个能力（如数学）低于目标，增加数学数据的采样权重；平滑调整（每次变化不超过 ±5%），避免剧烈波动
  2. Loss 驱动的调整：监控每个域的训练 loss；如果某个域的 loss 下降明显放缓（表明该域接近学习饱和），降低其权重，将权重转移给 loss 仍在快速下降的域
  3. 课程式调整：训练早期以高质量低噪声数据为主（书籍、维基、学术论文），中期逐步加入网页和代码，后期增加代码、数学等”推理密集”数据的比例

在线调整的挑战在于评估的延迟——配比变化对模型能力的影响不是即时的，需要训练一段时间后才能在 benchmark 上反映出来。如果调整频率太高，可能在效果还没显现时就又改了配比。所以工程上的做法通常是”offline 搜基线 + 分阶段预定义 + 后期小步 online 微调”（见 §1.4）。

10.9 一个配比决策的完整案例

下面用一个端到端的案例展示配比决策的完整过程（目标：30B 通用中文模型，8T token 预算，要求代码/数学/中文/英文四能力均衡）。

Step 1：盘点可用数据

数据域可用量（token）平均质量评估
中文网页3T中
英文网页8T中
中文书籍200B高
英文书籍500B高
代码2T中-高
数学100B高（含合成）
学术论文300B高
维基百科（中+英）50B高
中文对话/论坛500B低-中

Step 2：设定初始配比

数据域配比实际 token 数重复倍数
中文网页25%2T<1x
英文网页25%2T<1x
中文书籍6%480B2.4x
英文书籍6%480B~1x
代码20%1.6T<1x
数学5%400B4x
学术论文5%400B1.3x
维基百科3%240B4.8x
中文对话5%400B<1x

Step 3：Proxy 实验（1B 模型 + 100B token 训练 9 个配比变体）：

关键发现：
1. 代码从 15% → 20% → 25%：HumanEval +5.2/+3.1，GSM8K +2.3/+1.8，ARC +1.4/+0.9
   → 代码 20% 是性价比最高的点，25% 边际收益递减
2. 数学从 3% → 5% → 8%：GSM8K +4.2/+2.8
   → 5% 足够，8% 的额外收益不够显著
3. 中文网页从 20% → 25% → 30%：C-Eval +1.8/+1.2，MMLU_CN +1.5/+0.8
   → 25% 是合理的平衡点
4. 维基百科重复 3x vs 5x vs 8x：MMLU +0.5/+0.2/-0.3
   → 5x 以上开始出现记忆化迹象

Step 4：确定最终配比

数据域最终配比
中文网页25%
英文网页23%
代码20%
中文书籍7%
英文书籍6%
数学5%
学术论文5%
维基百科4%
中文对话5%

Step 5：训练中监控与调整

  • 每训练 500B token，在完整评估集上评估一次
  • 如果某个能力出现明显退化（>2%），分析原因并考虑微调配比
  • 训练最后 10%（800B token）阶段，增加高质量数据比例（“退火”）

回顾：这个案例展示了一个务实的配比决策流程。它不追求”理论最优”，而是通过系统化的实验和监控，找到一个”足够好且稳健”的配比。在实际工作中，完美的配比是不存在的——关键是建立一个快速验证和迭代的机制，而不是追求一次做对。

8.4 OP-Mix：把 on-policy 混合扩展到全生命周期

上面 §8.3 的工程结论是”offline 搜基线 + 分阶段预定义 + 后期小步 online 微调”，其隐含前提是：评估一次候选配比的代价很高（要么训 proxy 模型，要么等验证集反馈）。OP-Mix（On-Policy Mix） 直接攻击的就是这个前提。

来源：arXiv:2605.15220《Always Learning, Always Mixing: Efficient and Simple Data Mixing All The Time》（Michael Y. Hu、Apurva Gandhi、Kyunghyun Cho、Tal Linzen、Pratyusha Sharma，2026-05-13）。

核心机制：候选配比的效果可以用低秩适配器之间的插值来廉价模拟——这些适配器直接训在当前模型上，因此彻底去掉了独立的 proxy 模型，且搜索始终锚定模型真实的学习动态，不再依赖”小模型上的结论能迁移到大模型”这个假设（而这正是 §4.2 DoReMi / §4.3 RegMix 整套 proxy 方法论的前提）。

三个与本章现有内容构成对照的维度：

维度本章已列的 online 方法（ODM / AC-ODM / AutoScale / Aioli / HDS / TiKMiX）OP-Mix
是否依赖 proxy 模型多数依赖（AC-ODM 提供 proxy / non-proxy 双模式）不依赖，用当前模型上的低秩适配器插值
覆盖阶段仅预训练单阶段预训练 + 持续中训练 + 持续指令微调 全生命周期
世界观训练是若干离散阶段，配比按阶段预定义训练是一个连续过程，配比是持续在线决策

量化结果：预训练相对”不做混合”平均 PPL 提升 6.3%；持续学习场景下，达到与重训同等性能省 66% 算力、与 on-policy distillation 同等性能省 95% 算力。

对 §8.3 结论的修正：采用 OP-Mix 这类 on-policy 方案时，“分阶段预定义”这一步可以被弱化甚至省去——配比本身由在线搜索给出。两条路线各有适用场景：

  • 阶段化配方（本章第二部分）胜在可控、可复现：配方写死在训练脚本里，出问题能回溯，适合需要向多方交代训练过程的团队。
  • on-policy 混合（OP-Mix）胜在无需 proxy、能覆盖持续学习场景：本章所有 online 方法都只解预训练，而”持续中训练 / 持续指令微调该配什么”这个问题此前没有原则性指导（原文：“continual learning lacks principled guidance altogether”）。

选型的实际判断点：如果你的训练流程包含持续中训练或持续指令微调，OP-Mix 是目前唯一给出统一解的方案；如果只有预训练单阶段，本章 §4.5 的 HDS / TiKMiX 与 §8.3 的阶段化路线依然是更成熟、更有实测积累的选择。

第三部分：课程化与退火实操

第二部分给出了”配方曲线”，第三部分回答两个更精细的问题：数据以什么顺序呈现（课程化），以及如何用最后一段高质量数据把模型能力推上顶峰（退火）。这两件事把”配比”从空间维度（各域比例）扩展到时间维度（呈现顺序与训练末态）。

10.10 课程学习原理

10.1 什么是课程学习

课程学习（Curriculum Learning, Bengio et al., 2009）的核心思想：模型像人一样，应该从易到难学习。

直觉上：

  • 学数学先学加减，再学乘除，最后学代数
  • 学语言先学日常对话，再学复杂论证
  • 训练大模型也应该先学简单模式，再学复杂推理

10.2 为什么课程学习有效

  1. 梯度方向更稳定：早期数据简单，模型梯度方向稳定，收敛快
  2. 避免被难数据”震飞”：如果一开始就喂复杂数学，模型容易陷入局部最优
  3. 逐步建立抽象：简单模式是复杂模式的基础，先建立基础再上层建筑

10.3 难度评估

如何判断数据的”难度”？三种主流方法：

class DifficultyEstimator:
    """数据难度评估"""
    
    def __init__(self):
        self.ref_model = load_reference_model()
    
    def estimate_by_ppl(self, text):
        """方法1: 用参考模型计算 PPL。PPL 高 = 难，PPL 低 = 易"""
        ppl = compute_perplexity(self.ref_model, text)
        if ppl < 3.0: return 1
        elif ppl < 4.0: return 2
        elif ppl < 5.0: return 3
        elif ppl < 6.0: return 4
        else: return 5
    
    def estimate_by_features(self, text):
        """方法2: 基于文本特征（句子长度、长词比例、公式、代码行数）"""
        sentences = text.split('.')
        avg_sentence_len = np.mean([len(s.split()) for s in sentences])
        words = text.split()
        long_words = sum(1 for w in words if len(w) > 8)
        long_word_ratio = long_words / max(len(words), 1)
        formula_count = text.count('$')
        code_lines = text.count('```')
        score = 0
        if avg_sentence_len > 25: score += 1
        if long_word_ratio > 0.15: score += 1
        if formula_count > 10: score += 1
        if code_lines > 3: score += 1
        if len(text) > 5000: score += 1
        return min(score + 1, 5)
    
    def estimate_by_fineWeb_edu(self, text):
        """方法3: 用 FineWeb-Edu 教育价值评分
        1-2 = 容易（基础内容），3 = 中等，4-5 = 难（高密度知识）"""
        return fineweb_edu_classify(text)

EACL 2026 发现的最有效难度信号（Zhang et al., 2026, EACL 2026 Main）：系统研究 200+ 模型在 100B tokens 上的课程学习效果，识别出三种比 FineWeb-Edu 更有效的难度信号：

  1. 压缩比（Compression Ratio）：文本经 gzip 压缩后的比率，压缩比越低 = 冗余度越高 = 越容易
  2. 词汇多样性 MTLD：衡量文本词汇丰富度，MTLD 越高 = 词汇越多样 = 越难
  3. 可读性 Flesch Reading Ease：基于句子长度和音节数计算，得分越低 = 文本越难

EACL 2026 还发现课程学习可加速收敛 18-45%，作为 warmup 后切换随机采样可获得持续 +3.5% 提升——暗示”课程学习 + 随机混合”的组合策略可能优于纯课程学习。

难度信号的”偏好侧”扩展（PDPC, arXiv:2501.13126）：上述难度信号都来自”文本侧”，Preference Curriculum（PDPC）提出用偏好数据中的”预测难度（prediction difficulty, PD）“作为课程难度信号，配合 S 形（sigmoid）调度，在 3B 规模平均提升 +4.1%。这把”难度信号来源”从文本统计扩展到偏好信号。

课程学习的组合协调（CGLS, ICML 2026, arXiv:2506.11389）：课程学习通常与其它训练加速策略（如渐进层堆叠 progressive layer stacking）各自独立使用，CGLS 将二者在同一训练流程中联合调度，探索”课程 × 层堆叠”的协调范式——这代表课程学习从”单点策略”走向”组合策略”的延伸方向。

10.4 课程学习的实验对比

Lee et al. (2024) 的实验（1B 模型）：

训练策略数据顺序MMLU
随机全程随机混合24.5
从难到易5→4→3→2→122.1（崩塌）
从易到难1→2→3→4→526.8

从难到易反而比随机差——印证了”先易后难”的合理性。

10.5 三种课程策略与当前研究结论

数据配比解决的是”各域的比例”问题，课程学习解决的是”以什么顺序呈现数据”的问题。传统的预训练做法是把所有数据混在一起随机打乱后顺序训练。但一个自然的问题是：如果精心安排数据的呈现顺序，能否提高训练效率或最终性能？

三种主要策略：

  • 策略一：从易到难（Easy-to-Hard）：先让模型学习简单、清晰、低噪声的数据（如维基百科、精选书籍），再逐步引入复杂、嘈杂的数据（如网页文本、论坛帖子）。直觉：先建立基本的语言理解能力，再在这个基础上学习更复杂的内容。
  • 策略二：从质到量（Quality-to-Quantity）：训练前期用高质量但量少的数据（高过滤阈值），训练后期用低质量但量大的数据（低过滤阈值）。直觉：高质量数据帮助模型建立好的”学习习惯”，后期用更多数据来扩展知识覆盖。
  • 策略三：完全随机（Random Shuffle）：传统做法，也是最简单的。没有特别的顺序安排。

当前的研究结论：关于课程学习在大模型预训练中是否有效，研究结论并不一致。

正面证据：

  • Kim et al.（2024）研究表明，在某些设置下，从易到难的课程策略可以加速训练收敛
  • 2026 年初的一项研究（arXiv: 2601.21698）系统性地训练了 200+ 个模型来分析课程学习的效果，发现在特定条件下，按质量排序的课程可以带来稳定的收益

负面/复杂证据：

  • 一些研究发现，课程学习的收益在模型规模增大后会缩小——大模型似乎更能”自我纠正”学习顺序带来的影响
  • 另一个有趣的发现（arXiv: 2601.21698）是，课程学习改变的可能不是模型最终学到什么，而是学到的顺序——最终收敛点可能是相似的
  • 学习率衰减与课程冲突的问题（OpenReview, 2026）：如果你用”先低质后高质”的课程安排，但学习率是单调衰减的，那高质量数据出现在低学习率阶段，模型反而学不充分。这是一个被低估的实操问题。

实操建议：

  1. 对于大规模预训练（>10T token），课程学习的收益可能不大。随机打乱是一个安全且高效的默认选择。投入在课程设计上的精力，不如投入在数据质量提升上。
  2. 对于中等规模训练（1T-10T token），可以尝试简单的课程策略。比如训练的最后 10% 阶段加入更多高质量数据（“退火”策略），这是 Llama 3 等模型在训练后期采用的做法。
  3. 对于中训练和 SFT 阶段，课程学习更有价值。因为数据量较小，顺序的影响更大。比如在 SFT 阶段，先用简单指令训练再用复杂指令训练，通常优于反过来。
  4. 如果要做课程，注意与学习率调度的协调。确保高质量数据不要全部集中在学习率已经很低的阶段（这也正是 §11 退火策略设计要解决的问题）。

10.6 课程化的工业实现

难度排序的数据准备与调度是课程化的落地关键。下面给出可运行的实现骨架：

def prepare_curriculum_data(documents):
    """准备课程化数据：打难度标签 → 分桶 → 准备阶段混合"""
    for doc in documents:
        doc['difficulty'] = estimate_difficulty(doc['text'])
    buckets = {1: [], 2: [], 3: [], 4: [], 5: []}
    for doc in documents:
        buckets[doc['difficulty']].append(doc)
    curriculum = {
        'phase1_easy':      {1: 0.50, 2: 0.30, 3: 0.15, 4: 0.04, 5: 0.01},
        'phase2_medium':    {1: 0.20, 2: 0.30, 3: 0.30, 4: 0.15, 5: 0.05},
        'phase3_hard':      {1: 0.05, 2: 0.15, 3: 0.30, 4: 0.30, 5: 0.20},
        'phase4_annealing': {1: 0.00, 2: 0.05, 3: 0.20, 4: 0.40, 5: 0.35},
    }
    return buckets, curriculum
class CurriculumScheduler:
    """课程学习调度器"""
    
    def __init__(self, curriculum, total_tokens):
        self.curriculum = curriculum
        self.total_tokens = total_tokens
        self.current_phase = 'phase1_easy'
        self.phase_progress = 0
    
    def get_phase_for_step(self, step):
        """根据当前训练步数确定阶段"""
        phase_allocations = [
            ('phase1_easy', 0.25),
            ('phase2_medium', 0.35),
            ('phase3_hard', 0.30),
            ('phase4_annealing', 0.10)
        ]
        cumulative = 0
        for phase, alloc in phase_allocations:
            cumulative += alloc
            if step < cumulative * self.total_tokens:
                return phase
        return 'phase4_annealing'
    
    def sample_batch(self, buckets, batch_size):
        """按当前阶段的配比采样一个 batch"""
        mix = self.curriculum[self.current_phase]
        batch = []
        for difficulty, weight in mix.items():
            n_samples = int(batch_size * weight)
            samples = random.sample(buckets[difficulty], min(n_samples, len(buckets[difficulty])))
            batch.extend(samples)
        return batch[:batch_size]

10.11 退火（Annealing）策略设计

11.1 什么是退火

退火（Annealing）源自金属学——缓慢冷却使晶体结构更稳定。在大模型训练中，退火指：

  1. 学习率线性衰减：从训练中后期的 lr 衰减到 0
  2. 数据切换为高质量精选：用退火专用数据集
Pretrain 主训练:  LR=3e-4, 数据=混合, tokens=10T
         ↓
退火阶段:         LR=3e-5→0, 数据=精选, tokens=200B

11.2 为什么退火有效

退火有效的核心是“最后一刻”的精炼：

  1. 训练末期是巩固期：模型已经在大量数据上学到模式，最后阶段是”打磨”
  2. 低学习率避免破坏：用低 lr 微调，不会破坏已有能力
  3. 高质量数据注入”精华”：精选数据是”知识浓缩”，每个 token 信息密度高

11.3 退火的核心要素

# 退火的核心配置
ANNEALING_CONFIG = {
    # 学习率配置
    'lr_start': 3e-5,           # 起始学习率（比主训练低10倍）
    'lr_end': 1e-7,             # 传统推荐=接近0（但 ICLR 2026 发现这会浪费高质量数据，见 §11.4 策略4 CMA）
    'schedule': 'linear_decay',
    'warmup_steps': 100,
    
    # 数据配置
    'data_quality': 'high',
    'data_size': 200_000_000_000,
    'mix': {
        'fineweb_edu_4plus': 0.50,
        'arxiv_math': 0.20,
        'github_clean': 0.15,
        'stackexchange_top': 0.10,
        'synthetic_reasoning': 0.05,
    },
    
    # 训练配置
    'batch_size': 'same_as_pretrain',
    'gradient_accumulation': 'same',
    'weight_decay': 0.1,
}

11.4 四种退火策略

⚠️ LR 衰减的隐患（ICLR 2026, Luo et al., arXiv:2511.18903）：课程学习在恒定 LR 下显著优于随机打乱，但在标准 LR 衰减（WSD/Cosine）下优势几乎消失。原因是 LR 衰减到低值时模型更新步长过小，无法充分学习最后阶段的高质量数据——“LR 衰减浪费了最好的数据”。解决方案见下文策略 4（CMA）和 CDMA。

策略1：纯线性衰减（最简单，效果中等，适合算力紧张）：

def linear_decay_lr(step, total_steps, lr_start, lr_end):
    return lr_start - (lr_start - lr_end) * (step / total_steps)

策略2：余弦衰减（更平滑，效果略好于线性）：

import math
def cosine_decay_lr(step, total_steps, lr_start, lr_end):
    progress = step / total_steps
    cosine_factor = 0.5 * (1 + math.cos(math.pi * progress))
    return lr_end + (lr_start - lr_end) * cosine_factor

策略3：阶梯式衰减（最复杂但效果最好，Llama3 采用）：

def step_decay_lr(step, total_steps, stages):
    """stages: [(end_step1, lr1), (end_step2, lr2), ...]"""
    for end_step, lr in stages:
        if step < end_step:
            return lr
    return stages[-1][1]

stages = [
    (50_000_000_000, 3e-5),   # 前50B: 3e-5
    (120_000_000_000, 1e-5),  # 50-120B: 1e-5
    (170_000_000_000, 3e-6),  # 120-170B: 3e-6
    (200_000_000_000, 1e-6),  # 170-200B: 1e-6
]

策略4：CMA（Controlled Moderate Annealing, ICLR 2026）——对传统”衰减到 0”的修正：

def cma_lr(step, total_steps, lr_peak, final_ratio=0.2):
    """CMA：最终 LR 保持在峰值 LR 的 1/5~1/3，而非衰减到 0"""
    lr_end = lr_peak * final_ratio
    progress = step / total_steps
    cosine_factor = 0.5 * (1 + math.cos(math.pi * progress))
    return lr_end + (lr_peak - lr_end) * cosine_factor
    # 示例：lr_peak=3e-5, final_ratio=0.2 → lr_end=6e-6（而非传统的 1e-7）

关键思想：将”步长控制”与”噪声降低”解耦。CMA 保持中等 LR 以确保高质量数据阶段有足够的学习步长，噪声降低则通过 CDMA（Checkpoint-Decoupled Model Averaging） 实现——对最后 N 个 checkpoint 做加权平均（如 EMA），在不牺牲步长的情况下降低噪声。

ICLR 2026 在 1.5B/30B tokens 实验上，CMA+CDMA 组合比传统 LR 衰减到 0 的方案提升 1.64%。这挑战了”LR 逼近 0 的衰减”——“LR 逼近 0”的衰减恰恰浪费了退火阶段精心准备的高质量数据。

11.5 退火实证

Llama3 的退火实验：

策略数据退火 tokenMMLU
不退火-084.2
线性退火同主训练数据200B86.1
线性退火高质量精选200B88.6
阶梯退火高质量精选200B88.4

关键发现：退火数据的”质量”比退火策略本身更重要。

10.12 退火数据组成

退火数据是预训练的”压轴戏”，每条 token 都要”值得”。

12.1 推荐组成（500B tokens 为例）

annealing_data:
  # 主力1: 高质量教育内容（50%）
  fineweb_edu_4plus:
    weight: 0.50
    tokens: 250B
    source: 'FineWeb-Edu ≥4 分精选'
    description: '高中-大学级深度内容，结构化、信息密集'
  
  # 主力2: 学术论文与数学（20%）
  arxiv_math:
    weight: 0.15
    tokens: 75B
    source: 'arXiv 数学/物理/CS 论文'
  openwebmath:
    weight: 0.05
    tokens: 25B
    source: 'OpenWebMath'
  
  # 主力3: 代码（15%）
  github_clean:
    weight: 0.10
    tokens: 50B
    source: '高 star GitHub 仓库'
  the_stack:
    weight: 0.05
    tokens: 25B
    source: 'The Stack v2'
  
  # 主力4: 高质量问答（10%）
  stackexchange_top:
    weight: 0.07
    tokens: 35B
    source: 'StackExchange 高赞回答'
  
  # 主力5: 合成推理链（5%）
  synthetic_reasoning:
    weight: 0.03
    tokens: 15B
    source: 'GSM8K/MATH 合成推理链'
  orca_reasoning:
    weight: 0.02
    tokens: 10B
    source: 'Orca 风格推理数据'
  
  # 主力6: 少量 SFT 风味（5%）
  sft_like_data:
    weight: 0.03
    tokens: 15B
    source: '指令风格数据'

12.2 为什么需要 SFT 风味

退火阶段加少量 SFT 风味数据（5%）的原因：

  1. 为后训练破冰：让模型提前”感受”指令格式，减少 SFT 时的分布偏移
  2. 提升指令遵循能力：少量指令数据让模型学会”听指挥”
  3. 不破坏生成能力：5% 比例足够小，不会让模型只学会指令跟随
SFT_LIKE_TEMPLATES = [
    {'prompt': 'What is 15 * 24? Think step by step.',
     'response': 'Let me calculate 15 * 24 step by step.\n15 * 20 = 300\n15 * 4 = 60\n300 + 60 = 360\nSo 15 * 24 = 360.'},
    {'prompt': 'Explain how photosynthesis works.',
     'response': 'Photosynthesis is the process by which plants convert light energy into chemical energy...'},
    {'prompt': 'What does this code do?\n```python\ndef fib(n): return n if n<2 else fib(n-1)+fib(n-2)```',
     'response': 'This is a recursive implementation of the Fibonacci sequence...'}
]

12.3 合成推理链

退火阶段推荐加 5% 合成推理链，特别提升数学/推理能力：

SYNTHETIC_REASONING_EXAMPLES = [{
    'task': 'Solve: A train travels 60 km/h for 2 hours, then 80 km/h for 1 hour. Total distance?',
    'reasoning': '''
Step 1: Calculate distance for first part
60 km/h × 2 hours = 120 km
Step 2: Calculate distance for second part  
80 km/h × 1 hour = 80 km
Step 3: Add distances
120 + 80 = 200 km
Answer: 200 km''',
    'answer': '200 km'
}]
def generate_synthetic_reasoning(num_samples=10000):
    """用 GPT-4 生成合成推理链（用 GSM8K 题目作为种子）"""
    from openai import OpenAI
    client = OpenAI()
    examples = []
    gsm8k_problems = load_gsm8k_train()
    for problem in gsm8k_problems[:num_samples]:
        response = client.chat.completions.create(
            model='gpt-4',
            messages=[
                {'role': 'system', 'content': 'You are a math tutor. Solve the problem step by step with clear reasoning.'},
                {'role': 'user', 'content': problem['question']}
            ],
            temperature=0.7
        )
        examples.append({
            'question': problem['question'],
            'reasoning': response.choices[0].message.content,
            'answer': problem['answer']
        })
    return examples

注意：合成推理数据必须用 GPT-4/Claude 等顶级模型生成并做质量验证，用 GPT-3.5 生成可能引入错误推理链（见 §15 坑5）。

12.4 退火的 Python 配方表达

# 退火阶段数据组成（500B tokens 为例）
ANNEALING_MIX = {
    'fineweb_edu_4plus': {'weight': 0.50, 'tokens': 250_000_000_000, 'description': 'FineWeb-Edu ≥4 分'},
    'arxiv_math':        {'weight': 0.15, 'tokens': 75_000_000_000,  'description': 'arXiv 数学论文'},
    'synthetic_reasoning': {'weight': 0.10, 'tokens': 50_000_000_000, 'description': 'GSM8K/MATH 合成推理链'},
    'github_clean':      {'weight': 0.15, 'tokens': 75_000_000_000,  'description': '高 star GitHub'},
    'sft_like_data':     {'weight': 0.10, 'tokens': 50_000_000_000,  'description': '指令风格数据，为后训练"破冰"'}
}

10.13 工业级退火实践案例

13.1 Llama3 退火实践

阶段tokensLR数据
Pretrain 主训练15T3e-4 → 3e-5混合
退火阶段200B3e-5 → 0精选（同主训练但质量更高）

关键发现：退火数据用”主训练数据中质量最高的子集”，而不是全新数据。这避免了分布偏移。

13.2 DeepSeek-V3 退火实践

阶段tokensLR数据
Pretrain 主训练14T3e-4 → 3e-5数学/代码占比高
退火阶段500B3e-5 → 1e-6数学 30%+代码 30%+推理 20%
长文训练100B1e-5长文档拼接

关键发现：退火阶段数学/代码配比拉满，效果显著——MATH 从 35 跃升到 61.6。

13.3 Qwen2.5 退火实践

qwen25_annealing:
  total_tokens: 300B
  lr_schedule:
    - {tokens: 100B, lr: 3e-5}
    - {tokens: 100B, lr: 1e-5}
    - {tokens: 70B,  lr: 3e-6}
    - {tokens: 30B,  lr: 1e-6}
  mix:
    fineweb_edu_4plus: 0.40
    arxiv_math: 0.20
    synthetic_reasoning: 0.15  # 比例较高
    github_clean: 0.15
    wiki: 0.05
    sft_like: 0.05

13.4 YuLan-Mini：小规模开源模型的完整课程+退火配方

上述三个案例都是大厂大模型，YuLan-Mini（人大高瓴，arXiv:2412.17743）则提供了一个小规模开源模型的完整落地配方，作为”课程 + 退火”在小体量模型上的对照样本：

  • 27 阶段课程学习：将预训练切分为 27 个难度递进的课程阶段（远多于大厂的 3-8 阶段），在较小算力下精细调度数据难度
  • 80B tokens 退火：退火阶段规模与模型体量匹配，而非简单套用大厂的 200-500B
  • RoPE 基频提升：在课程后期配合 RoPE 基频调整，扩展长程位置建模能力

YuLan-Mini 的价值在于说明”课程 + 退火”并非大厂专属——小体量模型同样可以用更细粒度的课程切分 + 匹配体量的退火规模 + 位置编码调整，拼出完整的能力曲线。

13.5 三家对比

维度Llama3DeepSeek-V3Qwen2.5
退火 tokens200B500B300B
学习率衰减阶梯线性阶梯
数学配比5%30%20%
合成推理0%5%15%
SFT 风味0%0%5%

核心规律：

  1. 退火 tokens 占总训练的 1-5%
  2. 学习率降到主训练的 1/10 到 0
  3. 数据全部用高质量精选
  4. 数学/代码配比拉满（推理能力提升关键）

10.14 训练阶段切换时序

14.1 完整预训练时序

时间轴 →

Pretrain 主训练 (10T tokens, 3-6 个月)
   ↓
Midtrain 二阶段 (1-3T tokens, 2-4 周)
   ↓
退火阶段 (200-500B tokens, 3-7 天)
   ↓
长文训练 (50-200B tokens, 2-5 天)
   ↓
进入后训练 (SFT/DPO/RL)

14.2 阶段切换的”平滑过渡”

阶段切换最忌讳”硬切”。下面给出一个阶段切换调度器的实现，对 LR 与混合比例都做线性插值：

class PhaseTransitionScheduler:
    """阶段切换调度器"""
    
    def __init__(self):
        self.transitions = []
    
    def add_transition(self, from_phase, to_phase, transition_tokens=10_000_000_000):
        self.transitions.append({
            'from': from_phase, 'to': to_phase,
            'transition_tokens': transition_tokens
        })
    
    def get_lr_during_transition(self, step, transition_steps):
        from_lr = self.transitions[0]['from']['lr']
        to_lr = self.transitions[0]['to']['lr']
        progress = step / transition_steps
        return from_lr + (to_lr - from_lr) * progress  # 线性插值
    
    def get_mix_during_transition(self, step, transition_steps):
        from_mix = self.transitions[0]['from']['mix']
        to_mix = self.transitions[0]['to']['mix']
        progress = step / transition_steps
        blended_mix = {}
        for key in set(from_mix.keys()) | set(to_mix.keys()):
            from_w = from_mix.get(key, 0)
            to_w = to_mix.get(key, 0)
            blended_mix[key] = from_w * (1 - progress) + to_w * progress
        total = sum(blended_mix.values())
        return {k: v/total for k, v in blended_mix.items()}

14.3 切换的踩坑

  • 坑1：学习率突然降10倍。某团队从 Pretrain（LR=3e-4）切到退火（LR=3e-5）时直接切换，loss 突然跳变 0.3，模型陷入次优解。解决：用 10B tokens 做线性插值过渡。
  • 坑2：数据突然切换。某团队从混合数据切到精选数据时直接切换，模型在切换后出现”知识遗忘”。解决：渐进切换混合比例（保留 20% 主训练数据 + 80% 退火数据）。
  • 坑3：阶段切换太频繁。某团队设计了 8 个阶段（每 200B tokens 切换一次），结果每次切换都损失一些能力，最终效果不如 3 阶段。解决：阶段数控制在 3-5 个，每个阶段至少 200B tokens。

10.15 退火效果监控与踩坑经验

15.1 退火效果监控

退火过程中必须监控所有能力维度，及时发现能力倒退：

class AnnealingMonitor:
    """退火效果监控"""
    
    def __init__(self):
        self.metrics_history = []
    
    def log_metrics(self, step, model, eval_loader):
        metrics = {
            'step': step,
            'train_loss': self._compute_train_loss(model),
            'eval_loss': self._compute_eval_loss(model, eval_loader),
            'mmlu': eval_mmlu(model),
            'gsm8k': eval_gsm8k(model),
            'human_eval': eval_human_eval(model),
            'mt_bench': eval_mt_bench(model),
        }
        self.metrics_history.append(metrics)
        self._check_regression(metrics)
        return metrics
    
    def _check_regression(self, current):
        if len(self.metrics_history) < 2:
            return
        prev = self.metrics_history[-1]
        for metric in ['mmlu', 'gsm8k', 'human_eval', 'mt_bench']:
            if prev[metric] - current[metric] > 2:
                print(f'⚠️ {metric} regression: {prev[metric]} → {current[metric]}')

某 7B 模型的退火前后对比：

指标退火前退火后提升
MMLU48.252.8+4.6
GSM8K12.322.1+9.8
HumanEval28.535.2+6.7
MT-Bench5.86.2+0.4

退火对推理类任务（GSM8K）提升最大，对闲聊类（MT-Bench）提升最小。

15.2 退火的踩坑经验

  • 坑1：退火数据与主训练重复。某团队退火用的是主训练数据的子集，结果退火几乎无效果。退火数据必须独立精选，质量比主训练高一个级别。
  • 坑2：退火 tokens 过多。某团队退火用了 2T tokens（占总训练 20%），结果模型出现过拟合，泛化能力下降。退火 tokens 应该占总训练的 1-5%。
  • 坑3：退火学习率太高。某团队退火学习率 = 主训练的 1/3，结果退火过程中 loss 波动剧烈。退火学习率应为主训练的 1/10 到 1/100。
  • 坑4：未做能力倒退监控。某团队退火后发现数学能力提升，但代码能力下降 5 分。退火过程中必须监控所有能力维度，及时调整配比。
  • 坑5：合成推理数据质量差。某团队用 GPT-3.5 生成合成推理链，结果推理链有错误，模型学到了错误推理。合成数据必须用 GPT-4/Claude 等顶级模型生成，且要做质量验证。

10.16 推荐退火配方模板

16.1 通用模型退火

general_annealing:
  total_tokens: 200B  # 主训练的 2%
  lr_schedule: linear_decay
  lr_start: 3e-5
  lr_end: 1e-7
  
  mix:
    fineweb_edu_4plus: 0.50  # 100B
    arxiv_math: 0.20         # 40B
    github_clean: 0.15       # 30B
    stackexchange_top: 0.10  # 20B
    synthetic_reasoning: 0.05 # 10B

16.2 数学模型退火

math_annealing:
  total_tokens: 100B
  mix:
    arxiv_math: 0.40         # 数学论文 40B
    openwebmath: 0.20        # 数学网页 20B
    synthetic_reasoning: 0.25 # 合成推理 25B（高比例）
    fineweb_edu_4plus: 0.10
    gsm8k_augmented: 0.05

16.3 代码模型退火

code_annealing:
  total_tokens: 100B
  mix:
    github_clean: 0.50       # 高 star 代码 50B
    the_stack_v2: 0.20       # BigCode 数据 20B
    stackexchange: 0.15       # 编程问答 15B
    fineweb_edu_4plus: 0.10
    synthetic_code: 0.05     # 合成代码（如 LeetCode 题解）

🛠️ 本章衍生工具

🎓

数据工程·课程退火调度器

《AI 数据全书》第 10 章「数据混合与课程学习」配套——① 退火配方沙盘：§11.3 / §12.1 / §12.4 / §16.1-16.3 共 9 套退火配比并排一键切换，差异单元格高亮（Llama3 与 DeepSeek-V3 为定性重建，按钮打 ⚠）；挂 §15.2 五坑校验器实时判定（配比跳变 / 数据重复 / LR 未降够 / 无监控 / 用量不足）+ §11.5 Llama3 实证表作文献锚点（不退火 84.2 → 同数据退火 86.1 → 高质量退火 88.6 → 阶梯退火 88.4）；并显式呈现书内三处自相矛盾（§13.1 vs §15.2 坑1、§11.4 vs §11.5、§7.1 vs §12.2）· ② LR 退火曲线工坊：线性 / 余弦 / 阶梯（Llama3 四档 50B→3e-5、120B→1e-5、170B→3e-6、200B→1e-6）/ CMA（ICLR 2026）四条曲线同图，⭐ 有效学习量面积图 = Σ lr(t) × quality(t)（8 段数据质量曲线可编辑，看你把好数据放在尾巴还是浪费在高峰）+ 尾部 20% 面积对比 + CDMA 面板（把「步长控制」与「降噪」解耦，EMA 权重 α^(N-1-i) 分布图 + 传统/传统+CDMA/CMA/CMA+CDMA 四组合步长与噪声并排）· ③ 课程调度器：§10.10.6 CurriculumScheduler 真跑（4 阶段 25/35/30/10 配比 + 难度桶 1-5 + 余弦/恒定/WSD 衰减），5 种调度策略并排（易到难 / 难到易 / 随机 / 从量到质 / 反向从量到质），分数经网格搜索校准到与 Lee et al. (2024) 同序（易到难 27.35 / 随机 24.50 / 难到易 20.97，文献 26.8 / 24.5 / 22.1，已标注非复现）；难度估计器是真算的——gzip 压缩比走浏览器原生 CompressionStream、MTLD 双向词类计数、Flesch 对中文显式标「不适用」、§10.3 五条文本特征规则、二元字符 n-gram 伪 PPL 打琥珀标（教学版，非真实 LLM）；带 LR × 课程冲突面板（一键重现 OpenReview 2026 的争议）+ EACL 2026 / PDPC / CGLS 数据点 · ④ 四阶段时序与平滑过渡：§7.1 四阶段（Pretrain 10-15T → Midtrain 1-3T → Annealing 50-500B → Long Context 50-200B）可编辑时序条 + 5 域配比滑杆，⭐ TVD 总变差距离跳变检测（相邻阶段 > 0.5 标红，默认配置下 annealing→long context 高达 0.750）+ §14.2 线性插值平滑过渡窗口 + §14.3 三坑复现（LR 骤降损失尖峰 / 数据切换遗忘 / 阶段数 2-3-4-8 对比，N=8 净收益翻负）+ §15.1 能力倒退监控（MMLU/GSM8K/HumanEval/MT-Bench 四条曲线，掉 > 2 分标红圈，关闭监控则倒退被静默吞掉）+ YuLan-Mini 软课程 27 阶段 vs 硬阶段切换（§13.4）

⚖️

数据工坊·配比方案规划器

《AI 数据全书》第 10 章「数据配比 · 课程学习 · 退火」配套产品原型（系列第四个实用工具）——把「我要训 2T token」翻译成每个域到底该放多少、放几遍 ⭐ 重复代价模型：数据受限下 EffTok(U,R) = U·R（R≤1）/ U·[1+τ(1−e^(−(R−1)/τ))]（R>1），边际价值 e^(−(R−1)/τ)，可交互曲线直观看「第 4 遍只剩 78% 效率、第 8 遍只剩 54%」 ⭐ 名义配比 vs 有效配比：同一个方案，按名义 token 算数学占 20%，按有效 token 算只剩 12%，两张堆叠条形图并排放，差距一眼可见 ⭐ 自动诊断：epoch >4 报红（重复过久已近乎无增益）、被上限截断、名义/有效漂移 ≥1pp、退火池与主体重叠（§10.16 退火失效的头号原因）、高质量域占比 <20%、单域 >60% ⭐ 退火设计：从主域里圈出退火域，单独给预算，检查是否与主体重叠 ⭐ 配方库：Llama-1 / 通用基线 / 数学退火 / 代码退火 / 通用退火 5 套历史配比一键载入 · 导出 YAML 配比方案，数据不出本机

🧪

数据配比模拟器 2.0

10 数据源 · 预训练/后训练双阶段 · 2026 模型换血 · 预算博弈 · 合成数据+推理轨迹——如果你来训下一代大模型