LLM 是怎么被"训"出来的：预训练、后训练，以及推理/计算/代码三大能力从何而来

零、先读懂 14 个关键术语

后文会反复出现这些词。先给一句话解释 + 一个类比，正文不再重复。

术语	一句话解释	类比
预训练（Pre-training）	在海量无标注数据上，用”预测下一个 token”目标从头训练。最烧钱的阶段	通读百科全书打基础
后训练（Post-training）	预训练之后的所有加工：SFT、偏好优化、强化学习、蒸馏	基础打完后做专项集训
SFT（监督微调）	用”指令 → 理想回答”的成对示范数据训练，教会模型说话的格式与语气	照着范文练习写作
RLHF（人类反馈强化学习）	先训一个”奖励模型”学人类偏好，再用强化学习让模型讨好这个奖励模型	请了个裁判，按裁判的口味练
DPO（直接偏好优化）	跳过奖励模型，直接拿”好答案/坏答案”配对数据优化。更简单更稳	不做裁判，直接看好坏范例对比
RL（强化学习）	让模型自己产生答案 → 环境打分 → 按分数调整策略。核心是”试错”	做题 → 对答案 → 调整思路
RLVR（可验证奖励强化学习）	奖励不来自人、也不来自模型，而来自程序化验证器（答案对不对、测试过不过）	客观题自动阅卷机
GRPO（组相对策略优化）	对同一题采样一组答案，组内互相比较算优势。不需要额外的价值网络，比 PPO 更省	不请教练打分，让同班同学互相排名
PPO	经典强化学习算法，需要一个”价值网络”估计每个回答有多好。GRPO 是它的简化版	请了个专职教练
拒绝采样（Rejection Sampling）	让模型生成很多答案，只保留对的/好的，再拿去做 SFT	自己刷题，只把做对的整理成错题本
蒸馏（Distillation）	用大模型教小模型，把能力压缩进更小的体积	老师带学生
退火（Annealing）	预训练最后 10–20%，切换到最高质量数据并把学习率压到很低	考前最后两周只看精华笔记
课程学习（Curriculum）	按由易到难、由广到精的顺序安排训练数据	先学加减，再学微积分
奖励 hacking	模型钻奖励函数的空子，拿到高分但没真正完成任务	应试技巧：背答案而不是学方法

---

一、全景：三个阶段，各自解决什么问题

先把整条流水线摆出来，后面所有细节都挂在这张图上：

graph TB
    subgraph A["阶段一：预训练（消耗 ~90% 算力）"]
        A1["海量无标注文本<br/>数万亿 token"] --> A2["下一个 token 预测"]
        A2 --> A3["基座模型 Base Model<br/>只会'续写'"]
    end
    subgraph B["阶段二：后训练（消耗 ~10% 算力，决定'好不好用'）"]
        B1["SFT：教格式与指令"] --> B2["偏好优化 DPO/IPO/KTO：教价值观与安全"]
        B2 --> B3["RLVR：教推理/代码/工具"]
        B3 --> B4["拒绝采样 + 再 SFT：巩固"]
    end
    subgraph C["可选：蒸馏"]
        C1["大模型当老师"] --> C2["小模型继承能力"]
    end
    A3 --> B1
    B4 --> C1

三个阶段的分工

	预训练	后训练	蒸馏
核心问题	知识从哪来	能力怎么变成”好用”	能力怎么变小变便宜
数据	无标注海量文本	人工/合成示范 + 偏好 + 可验证题目	教师模型的输出
目标函数	下一个 token 交叉熵	SFT 交叉熵 / 偏好损失 / RL 策略梯度	下一个 token 交叉熵
算力占比	约 90%	约 10%（但重要性极高）	极低
产出	基座模型（Base）	指令模型（Instruct）	小模型

一个常见误解：“模型的能力主要来自预训练”。2026 年的实际情况是——知识主要来自预训练，但”会不会用”几乎全部来自后训练。DeepSWE 用 200 步强化学习，把开源 32B 模型在 SWE-bench Verified 上的成绩从 23% 提到 42%，没有新增任何预训练[citation:33]。

一个贯穿全文的核心判断

后训练各阶段有一个清晰的能力分工[citation:26][citation:30]：

阶段	奖励信号从哪来	教会模型什么	天花板
SFT	人类示范	格式、指令遵循、基本安全	被示范数据封顶——学不到数据里没有的策略
DPO/偏好优化	人类偏好对比	价值观、语气、安全性	被偏好数据封顶
GRPO + RLVR	程序化验证器	自主探索出的新策略	被”验证器能验证什么”封顶

一句话：SFT 是模仿，DPO 是排序，RLVR 是探索。 只有 RLVR 能让模型发现人类从未示范过的解法。

---

二、预训练（上）：数据工程——决定上限的隐形战场

这一节回答一个问题：同样是 Transformer、同样多的算力，为什么各家模型效果差很多？

答案主要在两处：数据配比 和 训练顺序。

2.1 数据清洗的四道工序

原始互联网数据不能直接喂给模型。标准流水线是四道递进的工序[citation:4][citation:10]：

① 精确去重   MD5/SHA256 哈希，删除完全相同的文档
     ↓        快、零误杀，但抓不到"近似重复"
② 近似去重   MinHash + LSH，删除高度相似的文档（阈值约 0.8）
     ↓        工业标准。⚠️ 不同语言/不同来源要分别建表
③ 规则过滤   语言识别、长度过滤、PPL（困惑度）过滤、启发式规则
     ↓        便宜、可解释，覆盖有限
④ 模型评分   用 LLM 标注训练一个轻量分类器，给每篇文档打质量分
             效果最好，FineWeb-Edu 证明了其有效性

三个容易踩的坑[citation:1][citation:10]：

坑	后果	对策
不同语言/来源共用一张 LSH 表	同模板的代码文件被整批误删——最常见的事故	按语言、按来源分别建表
训练数据里混入评测集	基准分数虚高，实际能力没提升	去重后再做一轮”与评测集 n-gram 去重”
只做精确去重	近似重复（fuzzy duplicate）比精确重复多得多	必须上 MinHash + LSH

2.2 数据配比：比清洗更重要

一个被广泛认同的判断：“配比”比”清洗”更重要[citation:10]。

数据像是模型的”饮食结构”：网页、书、代码、多语种各占多少，决定了模型擅长什么。清洗只是把发霉的食材扔掉，配比才决定营养均衡。这就是为什么各家”秘方”都藏着配比。

2026 年一个典型的预训练配比[citation:7]：

领域	占比
网页（Common Crawl 过滤后）	45%
代码（GitHub 去重后）	15%
书籍 / arXiv / 维基百科	12%
数学（证明 + 教科书）	8%
垂直领域（法律、医学）	6%
合成数据（指令、QA）	2%

配比怎么定？ 三种方法，成本递增[citation:4][citation:5]：

方法	做法	成本
手工配比 + 小规模消融	靠经验定，用小模型验证	低，但小模型结论未必能迁移到大模型
DoReMi	训一个小 proxy 模型，用 Group-DRO 优化各领域权重	中。一次额外小训练即可
RegMix	用多个小模型在不同配比下训练，拟合”配比 → 性能”的回归模型	约 DoReMi 的 10% 算力
DeMix（2026）	用模型合并代替反复训练：每个领域各训一个”领域模型”，然后按权重合并，直接评测	低。解耦了”搜索”与”训练”[citation:8]

一个诚实的开放问题：在小型 proxy 上学到的配比，迁移到 70B+ 时仍会以非平凡的方式偏移[citation:5]。这是配比优化至今没有完全解决的问题。

2.3 课程学习：不是均匀打乱，而是有顺序地喂

这是 2024–2026 年最重要的预训练发现之一。如果把所有数据均匀打乱喂进去，效率更低。

主体阶段 + 退火阶段

主流做法分两段[citation:2][citation:7][citation:11][citation:17]：

阶段	token 占比	数据特点	学习率
主体阶段（Bulk）	前 80%	广泛分布、以网页为主、质量门槛较低	峰值
退火阶段（Anneal / Cooldown）	后 10–20%	高质量子集：教科书、论文、数学、精选代码、合成指令数据	降到峰值的 1/10 甚至 1%

为什么有效？ 直觉是：早期训练建立广泛的语言能力，晚期训练把模型”塑形”成目标分布。在低学习率下用高质量数据退火，比全程均匀混合高质量数据，在提升下游任务上高效得多[citation:7]。

一个具体的量化案例：Llama 3 报告了一次独立的”退火运行”——在峰值学习率的 1/10 下，用高度过滤的 40B token 高质量数据继续训练。这部分只占总训练量的极小比例，却贡献了数个 MMLU 分数[citation:7]。

一个三阶段的真实配比表[citation:1]：

阶段	步数占比	中文	英文	代码	数学	学习率
预热	2%	45%	35%	10%	10%	线性升到峰值
主训练	88%	45%	30%	15%	10%	峰值
退火	10%	35%	20%	25%	20%	峰值 × 0.1

退火阶段代码 + 数学合计抬到 45%——这是”高价值数据最后给”的具体体现。

⚠️ 一个工程细节：切换阶段时不要直接换数据源，要用 2–3% 的步数做平滑混合，否则 loss 会出现可见的台阶[citation:1]。

五阶段实例：IBM Granite 4.1

一个公开的、可对照的完整案例[citation:16]：

阶段	token 量	配比要点	目的
① 通用预训练	10T	CC 59%、代码 20%、技术文档 10.5%、数学 7%	建立广泛语言理解
② 数学/代码预训练	2T	数学拉到 35%（×5）、代码 30%	转向强推理，仍保通用覆盖
③④ 高质量退火	2T + 0.5T	掺入长思维链 12.5%、合成指令数据	沉淀能力
⑤ 长上下文训练	—	4K → 32K → 128K → 512K 逐级扩展	扩展窗口

2.4 长上下文：分阶段扩展，而不是一步到位

从零训练一个 128K 上下文模型是低效的——注意力的 FLOPs 成本随长度平方增长，而早期预训练主要受益于短序列。

主流做法是分阶段[citation:7]：

阶段 1（0–90% tokens）  ：4K 上下文    → 构建通用语言能力
阶段 2（90–95%）        ：32K 上下文   → 引入长程依赖模式
阶段 3（95–100%）       ：128K 上下文  → 配合精选长文档（书籍、代码库、长论文）

Llama 3 用了四阶段课程达到 128K[citation:7]。分阶段扩展的成本：不到总训练算力的 2%[citation:2]。

扩展的技术路线有三种[citation:46][citation:49]：

路线	做法	成本	上限
YaRN 外推	在位置编码层做频率插值（“打补丁”）	低	有理论上限
RoPE base 扩大	直接拉伸位置编码的频率基数	中	中等
架构级方案	从注意力架构层面绕开（如压缩注意力）	高	无上限

一个真实配置：某 671B MoE 模型用 YaRN 从 4K 扩到 128K，两个各 1000 步的阶段，学习率固定 7.3e-6，总代价约 11.9 万 H800 GPU 小时。扩展后 128K 位置的困惑度从 142 降到 8.1（4K 上为 7.2）[citation:49]。

📖 困惑度（PPL, Perplexity）：衡量模型”对下一个词有多不确定”。越低越好。上例中 142 → 8.1 意味着模型在 128K 长文本上从”完全摸不着头脑”变成”接近短文本水平”。

2.5 一个必须记住的数字：4 个 epoch

研究表明，在高质量数据上，多轮训练最多有效至约 4 个 epoch，之后模型开始过拟合[citation:7]。

这解释了为什么 2024 年后前沿模型纷纷转向自产合成数据——公开互联网的高质量文本正在被用完（“数据墙”）。

⚠️ 合成数据的两条纪律[citation:10]：

• 控制比例（业界经验 < 20%）；
• 警惕模型坍缩（model collapse）——用自己生成的数据反复训练会导致多样性退化。

---

三、预训练（下）：工程实现——怎么把万亿 token 喂进去

这一节讲”怎么算得动”。即使数据准备好了，一个千亿参数模型也放不进任何一张显卡。

3.1 先算一笔显存账

混合精度 + Adam 训练时，每个参数占用的显存是固定的[citation:1]：

项目	字节数
bf16/fp16 权重	2
bf16/fp16 梯度	2
fp32 主权重（master weight）	4
Adam 一阶动量（m）	4
Adam 二阶动量（v）	4
合计	16 字节 / 参数

举例：一个 70B 参数的模型，光优化器相关状态就要 70B × 16 = 1.12 TB 显存。一张 H100 只有 80GB。这就是为什么必须分片。

3.2 ZeRO：把状态切开

ZeRO（零冗余优化器） 的核心思想是：数据并行时每张卡都存完整副本太浪费，把状态按数据并行维度切分[citation:7][citation:12]：

档位	切分什么	节省
ZeRO-1	优化器状态	约 4×
ZeRO-2	+ 梯度	约 8×
ZeRO-3 / FSDP	+ 模型参数	N×（全分片）

FSDP（PyTorch 原生全分片数据并行）就是 ZeRO-3 的 PyTorch 实现：需要参数时临时聚合，用完立即丢弃[citation:7]。

3.3 3D 并行：三种切法叠加

单一维度的并行都不够用，前沿训练把三种叠起来[citation:12]：

并行方式	切什么	通信特点	用在哪
数据并行（DP）	不同卡吃不同数据	梯度 AllReduce	跨副本
张量并行（TP）	把单层内部的矩阵切开	通信量极大，需要 NVLink	节点内（如 8 卡一台机器）
流水线并行（PP）	把不同层分给不同卡	阶段间 P2P，走 InfiniBand	跨节点
专家并行（EP）	MoE 的专家分布到不同卡	All-to-All	MoE 模型

布局原则：张量并行（最吃带宽）贴节点内的 NVLink；流水线并行（通信较少）跨节点；数据并行在最外层。各自覆盖别人的弱点[citation:12]。

流水线气泡：一个可以用算术算清楚的问题

流水线并行有个固有问题：前面的阶段在工作时，后面的阶段在空等。这个空闲叫”气泡”，大小是[citation:12]：

bubble = (P − 1) / (M + P − 1)

P = 流水线阶段数，M = 微批次数

P=4, M=1  ：3/4   = 75% 空闲  ← 灾难
P=4, M=32 ：3/35  = 9%        ← 可接受

同样的 4 张卡、同样的模型，唯一的区别是把批次切成更多微批，空闲率从 75% 掉到 9%。这就是微批（micro-batching）的全部意义[citation:12]。

3.4 一个 175B 训练的完整账本

把上述维度放到一次真实训练上[citation:6]：

模型：175B dense，L=96 层，H=12288，96 头，seq=2048
硬件：1024 × H100 80GB（8 卡/节点，128 节点）
目标：全局批次 4M tokens，MFU ≥ 45%

切分：TP=8（贴 8 卡节点）  PP=16（跨 16 节点）  DP=8
单卡参数：175B / (8×16) ≈ 1.37B，bf16 权重约 2.74 GB
优化器状态：不切分约 16.4 GB → 用 ZeRO-1 按 DP 维再切，降到约 2 GB

📖 MFU（Model FLOPs Utilization，模型算力利用率）：实际算出的 FLOPs ÷ 硬件理论峰值。反映有多少算力被真正用在计算上，其余都耗在通信与等待上。真实的 MFU 能到 35–50% 就已经是胜利，不是失败[citation:12]。

3.5 混合精度与稳定性

技术	作用
BF16 / FP16	显存减半、张量核心上约 2× 算力——“免费午餐”，默认开启
FP8	进一步压缩，DeepSeek 用 FP8 混合精度使计算速度比 BF16 提高一倍[citation:1]
激活检查点（Gradient Checkpointing）	少存激活、反向时重算——用算力换显存
梯度裁剪	不是省显存，而是稳定性安全带，防止大训练跑飞
CPU/NVMe 卸载	把冷优化器状态放到主机内存/固态盘。慢，但让不可能变成可能

⚠️ 一个实操建议：FP8 出 NaN 时（scaling 窗口、amax history、loss scaler 没跟上），先回 BF16 复现，再逐项打开 FP8，比盲调更快[citation:6]。

3.6 预训练工程小结

要素	实现
目标函数	下一个 token 交叉熵（唯一目标，无需标注）
优化器	AdamW；学习率调度用余弦或 WSD（预热-稳定-衰减）
显存	混合精度 + ZeRO/FSDP + 激活检查点
并行	3D：TP（节点内）+ PP（跨节点）+ DP；MoE 加 EP
精度	BF16 为主，FP8 用于加速
长上下文	分阶段扩展（4K→32K→128K），成本 < 2% 总算力
关键指标	MFU（35–50% 为佳）、loss 曲线无台阶、困惑度

---

四、后训练：从”会续写”到”会干活”

基座模型只会”续写文本”——你给它一句话，它接着往下编。这不能直接当助手用。后训练就是把”续写机器”改造成”助手”。

4.1 阶段一：SFT——教格式与指令

做什么：用”指令 → 理想回答”的成对数据做监督微调。

数据规模：通常几十万到几百万条。

一个真实的质量把关流程（IBM Granite 4.1 的 SFT 用了 410 万样本）[citation:16]：

原始对话数据
    ↓
LLM-as-Judge 评估（用一个模型当评委，六维打分）
    ↓
确定性规则管道：
  文本归一化 → 硬拒绝规则（幻觉/错误前提/计算错误）
  → 截断与长度过滤 → Schema 校验 → 泄漏检测 → 全局去重
    ↓
接受 / 边缘 / 拒绝 三档

SFT 的三层课程[citation:2]：

阶段	内容
第 1 层：格式与语气	简短直接的指令-回答对，建立对话风格、Markdown 结构、安全护栏
第 2 层：任务专精	领域数据：代码补全、信息抽取、多跳推理
第 3 层：智能体工作流	多轮对话、工具调用、错误恢复轨迹、深层嵌套结构化输出

SFT 的本质是模仿，天花板就是示范数据。 模型学不到数据里没有的策略[citation:26]。

4.2 阶段二：偏好优化——教价值观与安全

这一步回答”两个答案里人更喜欢哪个”。

方法	需要什么数据	要不要奖励模型	特点
RLHF / PPO	偏好三元组 + 三模型 RL 基础设施	要	控制力最强，但复杂、不稳定
DPO	偏好对（chosen/rejected）	不要	简单稳定，2026 年主流
IPO	同 DPO	不要	对标签噪声更鲁棒
KTO	二元点赞/点踩即可	不要	不需要成对数据

为什么 DPO 系成了主流：它们是离线的——不需要在训练中反复生成样本、不需要奖励模型、不需要价值网络，因此更简单、更稳定[citation:30]。

4.3 阶段三：RLVR——教推理、代码、工具

这是 2025–2026 年最重要的范式转变。

核心思想：把奖励模型的活交给程序

	RLHF	RLVR
奖励来源	学出来的奖励模型	程序化验证器
信号形态	连续分数	通常二元（对/错）
单条成本	人工标注（$）	程序检查（≈免费）
奖励 hacking	显著	基本解决（验证器 = 真值）
适合	开放式生成	数学、代码、逻辑、工具调用

RLVR 其实不是一个新算法，就是 GRPO（或 PPO）把奖励函数换成了程序[citation:36]。代码上唯一的改动就是把 reward_fn_rm 换成 reward_fn_verifier。

GRPO：为什么它比 PPO 更适合

**PPO 需要额外训练一个”价值网络”**来估计”这个回答有多好”——参数量与主模型相当，非常贵。

GRPO 的简化[citation:31][citation:28]：

同一个问题采样 G 条回答（比如 16 条）
    ↓
各自打分（对=1，错=0）
    ↓
组内标准化：
    组平均分作为基线
    高于平均分 → 正优势（被强化）
    低于平均分 → 负优势（被抑制）
    ↓
用这个"组内相对优势"更新策略

不需要价值网络——因为组内的统计分布本身就提供了基线[citation:28]。在一组 16 个答案里有 4 个是对的，那这 4 个自然获得正优势，其余获得负优势，无需任何学习出来的近似。

课程学习在 RLVR 中是必需的

这里有个关键的工程事实[citation:2]：

如果直接拿竞赛级难题（如 AIME）去训练一个未经训练的策略，随机探索得到正确答案的概率接近 0（P(correct) ≈ 0）。于是奖励梯度全程为 0，模型什么都学不到。

所以必须按难度分级[citation:2]：

层级	内容	成功率
L1	基础算术、单步方程	≥ 0.70
L2	多步中学数学（GSM8K 级）	中
L3	高中奥数（MATH / AIME 级）	低

模型在 L1 学会”分步写、打草稿”的格式，在 L2 学会”分解子目标、中间验证”，在 L3 学会”用更长的推理路径搜索”。

4.4 阶段四：拒绝采样 + 再 SFT——巩固战果

RL 训完之后，还有一个反直觉的步骤：用 RL 后的模型生成大量答案，只保留对的，再拿去做一轮 SFT[citation:26]。

DeepSeek-R1 的做法：RL 之后，用模型自己的输出做拒绝采样，得到约 60 万条推理样本，与非推理数据混合后再做 SFT[citation:26]。

为什么要绕回来？ 因为 RL 创造能力，SFT 把能力”固化”下来并重新分布[citation:26]。RL 找到的好策略是零散的、概率性的，SFT 让它变成稳定的默认行为。

4.5 2026 年前沿实验室的标准顺序

[citation:30]

① SFT（多样化指令）
      ↓
② DPO / IPO（通用有用性与安全的偏好数据）
      ↓
③ PPO 或 GRPO（用奖励模型做最后打磨，仅限投入了 RM 基础设施的实验室）
      ↓
④ RLVR（数学、代码、结构化工具）
      ↓
⑤ 最终 SFT（用最高质量输出巩固）

开源配方（Tulu 3、Llama 4 后训练、Qwen3 后训练）遵循相似模式，只是用公开数据[citation:30]。

4.6 后训练阶段小结

阶段	信号来源	教什么	天花板
SFT	人类示范	格式、指令、基本安全	示范数据
DPO/IPO/KTO	人类偏好	价值观、语气、安全	偏好数据
GRPO+RLVR	程序验证器	自主探索的新策略	验证器能验证的范围
拒绝采样+SFT	模型自己的正确输出	巩固与固化	上一步的产出
蒸馏	教师模型输出	能力压缩	教师模型

---

五、能力一：逻辑推理是怎么长出来的

5.1 先说清楚：推理能力不是”教”出来的

这是最反直觉的一点。传统 SFT 教推理的逻辑是：给人写的解题过程，让模型模仿。但这条路有明确天花板——模仿不出超越示范数据的策略。

2024–2026 年的突破在于：用强化学习直接优化推理过程本身，奖励信号只来自”答案对不对”[citation:23]。

5.2 DeepSeek-R1 的四阶段配方

这是目前公开最完整、被复现最多的推理模型训练方案[citation:27][citation:26][citation:28]：

阶段 1：冷启动 SFT
    用少量长思维链数据做 SFT，让模型"初步会写推理过程"
    （不需要多好，只需要一个适合 RL 的起点）

阶段 2：大规模 RL（GRPO + 可验证奖励）
    数学题答案对不对、代码能不能跑通，作为奖励
    ↓ 这一步是能力提升的主战场

阶段 3：拒绝采样 + SFT
    收集 RL 过程中表现好的样本（约 60 万条推理样本）
    与非推理数据混合，再做一轮监督微调

阶段 4：小规模 RL 对齐
    最后再做一轮针对人类偏好的轻量 RL

5.3 效果：一组具体数字

模型	训练方式	AIME 2024	MATH-500
DeepSeek-R1-Zero 起点	纯 RL，无 SFT	15.6%	—
DeepSeek-R1-Zero 终点	纯 RL	71.0%（多数投票 86.7%）	—
DeepSeek-R1（完整四阶段）	冷启动+RL+拒绝采样+对齐	79.8%	97.3%
OpenAI o1（闭源参考）	专有 RL	83.3%	96.4%

（数据来源：[citation:26][citation:28][citation:24]，厂商自报）

5.4 “啊哈时刻”：涌现的自我纠正

R1 训练中最被引用的现象[citation:27][citation:31]：

训练过程中，模型自己学会了在推理中间写出 “等等，我发现前面某一步算错了，让我重新来”，然后修正自己的思路。

这不是人工设计的，是 RL 在优化奖励的过程中自发涌现的[citation:27]。

为什么会涌现？ 因为奖励只关心”最终答案对不对”。模型在探索中发现：加入检查、反思、修正这些行为，能提高最终正确率——于是这些行为被奖励信号保留下来。

这是一个非常重要的一般性结论：当奖励只考核结果时，模型会自己摸索出能提高结果的中间行为。这就是 RLVR 与 SFT 的根本区别——SFT 只能学”示范里有的行为”，RL 能发明”没人示范过但有效用的行为”。

5.5 一个极端的验证：1-shot RLVR

2026 年 NeurIPS 上的一篇论文给出了一个近乎荒谬的结果[citation:32]：

对 Qwen2.5-Math-1.5B 用 RLVR 训练
只用【1 条】训练样本：
    MATH500:  36.0% → 73.6%
    六个数学基准平均: 17.6% → 35.7%

这个结果与使用 1.2k 完整数据集（DeepScaleR）的效果相当
（MATH500: 73.6%，平均 35.9%）

用 2 条样本甚至略超：MATH500 74.8%，平均 36.6%

这说明什么？ RLVR 带来的提升主要不是”学到了新知识”，而是”解锁了格式与推理模式”——模型原本就会，只是不知道该这样组织输出。论文还发现：即使训练准确率饱和后，测试性能仍在持续提升（称为 post-saturation generalization）；并且自我反思的频率显著上升[citation:32]。

当然，这不意味着”以后只用 1 条数据训练”。它说明的是：推理能力的瓶颈常常不在知识量，而在”会不会组织推理”。

5.6 推理能力的工程代价

代价	说明
采样成本	长思维链本身就消耗更多 token；RL 还要对同一题采样 G 个候选[citation:35]
执行环境	代码与形式化验证需要真实的执行沙箱[citation:35]
流水线复杂度	加上拒绝采样与蒸馏，整条流水线远比普通 SFT 复杂[citation:35]
推理时算力	推理模型在推理时的计算量是普通模型的 5–20 倍[citation:27]

5.7 推理能力小结

要素	实现
核心机制	长思维链：把一步到位拆成多步，每步只做简单变换[citation:31]
本质作用	外化工作记忆——把中间结果写进输出文本，绕开隐藏状态的容量限制[citation:23]
训练方法	冷启动 SFT → GRPO + 可验证奖励 → 拒绝采样 SFT → 对齐
涌现行为	自我检查、回溯、修正——奖励只考核结果时的自然产物
增强技巧	自洽性/多数投票：采样多条路径投票，正确路径唯一而错误路径五花八门[citation:31]
代价	推理时算力 5–20×；训练需大量采样

---

六、能力二：数值计算——LLM 的软肋与解法

这一章要诚实地说一件很多人不愿承认的事：大模型算数确实不太行，而且这是架构层面的原因。

6.1 为什么算不准：两个根本原因

原因一：数字被切碎了

模型的输入不是”数字 789”，而是被分词器切成的 token 片段——“789” 可能被切成 “78” 和 “9”[citation:47]。模型在处理这些碎片时难以建立准确的数值概念。

这是一个分词器（Tokenizer）的设计决定，不是自然规律。现在有些模型专门让数字逐位分词，或者从右往左按固定位数分组（以保留位值），这能可测量地改善算术能力[citation:50]。

原因二：每一步仍是”预测”而非”计算”

即使用思维链把 4837 × 219 拆成三步，每一步（如 4837 × 200）仍然是概率预测，不是确定性计算[citation:50]。

关键的区分：“数学”其实包含两种完全不同的能力[citation:50]：

• 数学推理：为应用题列对方程、选对方法 → 推理模型和 CoT 能显著提升；
• 原始计算：执行精确的算术 → 只有工具能解决。

一个模型”数学基准分高”，要看是哪种数学——证明题奖励推理，精确答案题奖励计算器。

6.2 四层解法，可靠性递增

方案	怎么做	可靠性	适合
① 直接问	无	低	常见、简单的算式和常识
② 思维链 CoT	拆成简单步骤	中	轻量推理，没有工具时
③ 推理模型	训练它先想再答	中高	多步应用题
④ 工具/代码执行	把计算交给确定性引擎	很高	数字必须准确的场合

一句话结论：需要模型来决定算什么、按什么顺序算；需要确定性的代码来执行计算。模型的活是把一个模糊请求翻译成精确的计算，计算器的活是算准[citation:50]。

6.3 用 RL 教模型”什么时候掏计算器”

这是 2026 年 ICLR 上的热门方向。核心问题：SFT 教不会工具使用的最优策略，RL 能。

为什么 SFT 不够[citation:44]：

1. 模式固化——学到的是”人类怎么用工具”，而不是”最优策略是什么”；
2. 探索受限——没见过的调用方式永远不会尝试；
3. 错误传播——数据里低效或错误的调用模式会被原样学走。

ReTool 的三阶段配方（字节跳动，ICLR 2026）

[citation:44]

阶段 1：合成数据生成（TIRGen）
    用一个已有的"工具集成推理"模型生成含代码调用的轨迹
    过滤后构建冷启动数据集

阶段 2：冷启动 SFT
    全参数微调，给模型一个"知道工具存在、会基本使用"的起点

阶段 3：工具增强 RL（PPO）
    模型在沙箱中与代码解释器交互
    奖励：答案正确 +1，错误 −1

消融实验非常说明问题（Qwen2.5-32B-Instruct，AIME2024）[citation:44]：

配置	AIME2024	说明
原始基座	26.7%	无训练
仅冷启动 SFT（有解释器）	40.9%	SFT 只是”入门”
仅文本 RL（无解释器）	40.0%	有心算但无工具
ReTool 完整（SFT + 工具 RL）	67.0%	两者叠加

RL 贡献了 26 个百分点，代码解释器贡献了 27 个百分点。 二者都是质变，不是锦上添花。

三个关键工程 trick[citation:44]：

技巧	作用
交错式代码执行	模型推理 → 生成代码块 → 环境立即执行 → 结果注入回推理链 → 继续推理。让模型”边想边算”
反馈掩码	代码执行器返回的结果（如 output: 42）是外部注入的 token，不参与策略梯度计算——避免模型去”拟合”输出的格式
KV Cache 复用	代码执行前已生成的 token 的 KV 缓存可复用，避免每个代码调用都从头算
异步沙箱执行	多个轨迹的代码在不同沙箱并行执行，不互相阻塞

涌现行为：模型自发学会了”代码自我纠正”——当执行结果与推理预期不符时，会回溯、反思、修正代码并重跑。训练结束时，模型生成的平均代码行数是训练开始时的 5 倍[citation:44]。

ToRL：更激进的路线

上海交大的 ToRL 主张不需要 SFT 冷启动，直接从基座模型开始 RL[citation:44]：

维度	ReTool	ToRL
训练起点	SFT 冷启动	直接从基座模型
训练数据	合成 TIR 数据 + 数学题	纯数学题（无 TIR 数据）
算法	PPO	GRPO
规模	32B	1.5B / 7B

两者都验证了一件事：工具使用策略可以从零涌现。

6.4 数值计算能力小结

要素	实现
根本限制	数字分词碎片化 + 自回归本质是预测而非计算
架构级改进	逐位分词 / 从右往左分组（保留位值）
方法级改进	CoT 拆分、推理模型
根本解法	工具集成推理（TIR）——代码解释器接管计算
训练方法	冷启动 SFT → 工具增强 RL（交错执行 + 反馈掩码 + KV 复用）
涌现行为	代码自我纠正、按需调用、代码量随训练增长

---

七、能力三：代码编写——最幸运的领域

代码是三大能力中最适合用 RL 训练的一个，原因非常实在。

7.1 为什么代码是”RL 的天选之子”

代码绕开了定义奖励这个最大的难题：测试通过就是通过，编译得过就是过，问题被修复就是被修复。环境本身就是裁判，而且是诚实的裁判[citation:33]。

对比一下其他领域：开放式问题”这个回答好不好”需要人来判断或模型来打分——昂贵、有噪声、可被钻空子。代码不需要这些。

这就是为什么代码成了智能体强化学习的领先领域：几乎没有其他领域能提供一个免费、诚实、可无限重复的内置裁判[citation:33]。

7.2 代码能力的训练栈

阶段	做法
① 预训练	代码语料（GitHub 等）单独配比，需专门去重（同模板文件多）
② SFT	代码指令数据（补全、重构、解释、调试）
③ RLVR	在真实可执行环境中修复 issue，测试通过即奖励

7.3 核心工程：可验证环境的构造

这是最重的一块。一个典型的代码 RL 环境包含五个部分[citation:51]：

① 任务指令（issue 描述、bug 报告）
② 初始状态夹具（repo 的特定 commit）
③ 可用的工具/命令行
④ 验证器（单元测试、状态检查、评分标准）
⑤ 容器定义（Dockerfile，保证可复现）

验证器是把”环境”和”提示词”区分开的东西。 DeepSeek 的 R1 论文把大规模 RL 限制在有规则化检查的任务上，正是因为学习出来的奖励模型容易被钻空子[citation:51]。

规模化的关键：退出码作为通用接口

业界最重要的简化是：用退出码（exit code）作为语言无关的接口[citation:25]。

项目	做法
SWE-Universe（阿里，2026）	构建近 100 万个可验证环境，用退出码做语言无关接口，覆盖 7+ 语言[citation:25]
MindForge	从 PR 实例自动生成 Dockerfile + 验证脚本，针对约 3900 个 PR 实例、4 种语言[citation:25]
ROCK（阿里）	RL 沙箱，智能体在沙箱内原生运行，SDK 从外部编排[citation:25]

几个必要的防作弊设计[citation:25]：

防护	目的
历史安全检出	剥离未来的 git refs，防止智能体直接从 git log 里读到修复方案
LLM 黑客检测	用裁判模型审查每次提交，判断它是否真的执行了代码
隐藏测试文件	直到最终评分阶段才放出
出口防火墙	通过特权 sidecar 强制，防止联网作弊
语法预检	在启动 Docker 前先查语法错误，大幅节省时间

7.4 效果：200 步 RL 的近翻倍

DeepSWE 是最有说服力的案例[citation:33]：

起点：开源 Qwen3-32B 基座
方法：纯强化学习，无新增预训练，无人工标注数据
训练：仅 200 步
结果：SWE-bench Verified  23% → 42%
     （加上测试时扩展达 42.2% Pass@1 / 59%）

模型原本从预训练就”会写看起来合理的代码”；RL 教它写出真正能通过的代码[citation:33]。

自博弈（Self-play）方向：Self-Play SWE-RL 让智能体自己生成训练信号，在 SWE-bench Verified 和 SWE-Bench Pro 上分别 +10.4 和 +7.8 分，并持续优于人类数据基线[citation:33]。

7.5 一个重要的工程陷阱：训练-推理不一致

这是代码 Agent RL 独有的难题[citation:29]：

策略梯度方法要求训练引擎重新计算智能体在 rollout 时生成的 token 的概率。但原生 Agent 框架（如 OpenHands、Claude Code）会动态重写交互历史、压缩上下文、在步骤间重新序列化数据。这造成了严重的训练-推理不一致。

LEGO-RL 的解法：在 LLM 服务的 API 边界部署进程内代理，在生成时直接捕获原始 token ID、对数概率和响应掩码[citation:29]。对稀疏 MoE 模型，还要记录和回放 rollout 时的专家路由决策。

这个细节很能说明代码 RL 的工程难度：你以为在训练模型，实际上有一半的工作在保证”训练引擎看到的”和”推理引擎跑过的”是同一件事。

7.6 环境规模化：从”堆数量”到”设计分布”

2026 年 ACL 上的一批论文揭示了一条清晰演进[citation:48]：

工作	贡献	效果（自报）
EnvScaler	程序化合成工具交互环境，保留 191 个环境、约 7000 个任务场景	Qwen3-8B 在 BFCL-v3 上 28.88 → 37.00（SFT）→ 41.88（RL）
AgentScaler	收集 3 万+ API，构建工具依赖图，组织 1000+ 领域	环境数 0→10000，ACEBench-en 67.2 → 75.7
Echoverse	强调环境的深度（行为深度、失败针对性、共同演化）	9B 模型在 12 个环境训练后，14 个评测分片上 36.5% → 67.1%

关键洞察：环境不是越多越好，而是要在”模型当前能力边缘”[citation:51]：

一个模型总能解决、或总解决不了的任务，在 GRPO 这类组基算法下产生不了梯度。有用的环境必须位于当前能力的边缘。

这也引出两个 2026 年的新方向[citation:51]：

• 能力感知环境选择（AES）：按智能体当前能力挑选环境；
• 分层难度课程（HDC）：通过削弱脚手架、扩大状态规模逐步加难。

7.7 代码能力小结

要素	实现
天然优势	环境即裁判——测试通过与否是免费、诚实、可无限重复的奖励
训练方法	预训练代码语料 → SFT → RLVR（在真实可执行环境中）
环境工程	Dockerfile + 验证器 + 退出码接口；防历史泄漏、防作弊
规模化	从”堆环境数量”到”设计环境分布”（难度要卡在能力边缘）
工程陷阱	训练-推理不一致——必须在生成时捕获原始 token 与路由
效果	200 步 RL 让 32B 开源模型 SWE-bench Verified 从 23% → 42%

---

八、三大能力的共性与差异

8.1 共同点：同一个”可验证性”引擎

三种能力在 2026 年共享同一套训练机制：

         ┌──────────────────────────────────────┐
         │   可验证奖励强化学习（RLVR）          │
         │                                       │
         │   逻辑推理  ← 答案对不对              │
         │   数值计算  ← 执行结果对不对          │
         │   代码编写  ← 测试过不过              │
         │                                       │
         └──────────────────────────────────────┘
                        ↓
              都是"程序化验证器 + GRPO"

四个共同要素：

要素	说明
① 都需要可验证的奖励	这是 RLVR 能跑起来的前提。三者恰好都具备
② 都需要课程学习	难度必须卡在能力边缘——全对或全错都产生不了梯度[citation:2][citation:51]
③ 都依赖”外化中间过程”	推理写思维链、计算写代码、调试跑测试——都是把工作记忆写进上下文
④ 都出现涌现行为	自我纠正、回溯、验证——奖励只考核结果时的自然产物

8.2 差异点：五个维度对照

维度	逻辑推理	数值计算	代码编写
① 验证器	答案比对（可符号匹配）	代码执行结果	单元测试 / 退出码
② 是否必须外挂工具	否（可纯文本推理）	是（必须代码解释器）	环境本身就是工具
③ 环境复杂度	低（纯文本）	中（需沙箱执行代码）	高（需完整 repo + 依赖 + 编译）
④ 主要瓶颈	采样成本（长思维链）	分词器设计 + 心算天花板	环境供给 + 训练-推理一致性
⑤ 是否需要冷启动 SFT	推荐（提高 RL 效率）	推荐（ReTool）但可省（ToRL）	通常需要
⑥ 奖励粒度	二元（对/错）	二元	二元，或按通过的测试数加权
⑦ 成熟度	高（R1 配方被广泛复现）	中（工具集成是 2026 新方向）	高且快速演进

8.3 一个反直觉的发现：三者的瓶颈都不在”知识量”

能力	常见误解	实际情况
推理	需要更多数学知识	1-shot RLVR 就能把 MATH500 从 36% 提到 73.6%[citation:32]——瓶颈在”会不会组织推理”
计算	需要更聪明	瓶颈在分词方式 + 没有计算器；给了解释器，同一模型 AIME 从 40% 到 67%[citation:44]
代码	需要更大的模型	200 步 RL，模型没变大，分数翻倍[citation:33]

三条证据指向同一个结论：能力的主要增量来自”正确的训练方式”，而不是”更多的知识”。

8.4 一个诚实的边界：RLVR 不适用于什么

RLVR 有一个硬前提：必须能程序化验证。

能验证	不能验证
数学答案、代码测试、结构化输出、工具调用是否成功	写作风格、共情、创意、开放式对话质量、价值观判断

对于后者，仍然需要 RLHF / DPO 这类基于人类偏好的信号[citation:36]。

2026 年的现实是：“能验证的地方用 RLVR，其余地方用 RLHF/DPO”[citation:36]。前沿正在努力把验证器往外推——用高质量参考答案把可验证信号扩展到开放式任务（如 RLVRR，ICLR 2026）[citation:36]。

---

九、总结：能力不是”灌”进去的，是”逼”出来的

9.1 三句话总结

1. 预训练买的是知识，后训练买的是”会不会用”。 预训练消耗约 90% 算力，但要让模型从”续写机器”变成”助手”，靠的是后训练那 10%。
2. SFT 的天花板是数据，RL 的天花板是验证器。 想让模型具备数据里没有的能力，唯一已知的方法是给它一个能判对错的环境，让它自己试。
3. 三大能力共享同一个引擎——可验证奖励强化学习。 差异不在算法，而在”验证器怎么造”。

9.2 全文最值得记住的五个数字

数字	含义
16 字节/参数	混合精度+Adam 训练时每个参数的显存开销。这是所有分布式训练的起点[citation:1]
4 个 epoch	高质量数据的有效训练轮数上限。之后必须转向合成数据[citation:7]
75% → 9%	流水线气泡从灾难降到可接受，只需把批次切成更多微批[citation:12]
1 条样本	1-shot RLVR 把 MATH500 从 36.0% 提到 73.6%——瓶颈不在知识量[citation:32]
200 步	纯 RL 让开源 32B 模型 SWE-bench Verified 从 23% 到 42%，无新增预训练[citation:33]

9.3 一个总的判断

回看这条流水线，会发现一个贯穿始终的模式：

阶段	模型在做什么	人类的角色
预训练	被动吸收海量文本	提供数据、定配比
SFT	模仿人类示范	写示范
DPO	按人类偏好排序	做选择
RLVR	主动探索，自己发现策略	只提供”判对错”的规则

前三个阶段，人类都在”喂”——喂数据、喂示范、喂偏好。只有到 RLVR，人类退到了只提供规则的位置，模型开始自己找路。

而 2026 年最重要的那些能力突破——自我纠正、代码自我修正、按需调用工具、反思与回溯——没有一个是人教的，全部是在奖励压力下被”逼”出来的。

一句话：预训练把世界装进模型，后训练教它怎么调用；而真正超出数据边界的能力，只在一个能诚实地告诉它”你错了”的环境里，才会长出来。

---

附：本文关键来源说明

类型	来源性质	使用原则
数据工程（清洗/去重/配比/退火）	技术博客、综述、公开训练报告[citation:1][citation:4][citation:7][citation:10][citation:16]	直接采用
分布式训练（ZeRO/3D并行/显存账）	工程文档与教程[citation:1][citation:6][citation:12][citation:15]	直接采用
后训练流程（SFT/DPO/GRPO/RLVR）	技术综述与官方文档[citation:22][citation:26][citation:30][citation:36]	直接采用
推理模型（R1 配方与效果）	论文与论文解读[citation:24][citation:26][citation:27][citation:28]	标注为厂商自报
1-shot RLVR	NeurIPS 2026 论文[citation:32]	论文结论直接采用
工具集成推理（ReTool/ToRL）	ICLR 2026 论文解读[citation:44]	标注为论文自报
代码 RL（DeepSWE/环境工程）	技术博客与论文[citation:25][citation:29][citation:33][citation:51]	标注为厂商/论文自报
环境规模化	ACL 2026 论文综述[citation:48][citation:51]	标注为论文自报，注明未经独立复现

⚠️ 大模型训练领域迭代极快，本文事实截至 2026 年 10 月 26 日。所有性能提升数字，凡属厂商自报或单篇论文结论，均已标注来源且未独立复现；不同论文的基准与设置不同，跨论文横向比较需谨慎。