推理 RL 与 RLVR 数据

DPO 教模型品味，RL 让模型思考。

RLVR 的奖励是 0/1，干净得像数学证明——这是后训练最锋利的工具。

“The most exciting phrase to hear in science, the one that heralds new discoveries, is not ‘Eureka!’ but ‘That’s funny…’” —— Isaac Asimov

DeepSeek-R1 的 “aha moment”——模型自发地学会了反思和自我纠正——正是这样一个 “That’s funny” 时刻。

本章是后训练数据工程的核心章，围绕”推理与强化学习数据”展开：没有 verifier 的 RL 数据是盲的，没有推理链的 RL 数据是浅的。全章以 RLVR（Reinforcement Learning with Verifiable Rewards）数据工程为主线——数据三要素、五类可验证任务、prompt 池构建、verifier 设计的坑、GRPO 风格 rollout、reward hacking 检测、工业 SOP；同时以推理数据体系为辅线——CoT 与长思维链的涌现、推理数据的难度分级与粒度设计、R1 式冷启动-RL-蒸馏全流程、过程级信号与自主训练循环的前沿。两条线索互补拼合，构成”推理与强化学习数据”的完整知识版图。

---

21.1 范式转折：从 DPO 天花板到 R1-Zero 的涌现

21.1.1 DPO 的天花板

DPO 是离线方法，只能在已有数据上优化。它的天花板是”数据集中最好的响应”——模型永远学不到”比数据更好的响应”。这不是工程实现的问题，而是方法论的边界。

DPO 的三个根本局限：

1. 离线束缚：无法探索数据集外的响应。数据里没有的解法，模型永远学不会。
2. 分布偏移：训练数据来自其他模型（通常是更强的教师），与当前策略分布不一致。教师擅长的路径未必是学生走得通的路径。
3. 偏好粒度粗：只有好/坏，没有”多好”。一个勉强正确的解和一个优雅的解，在偏好对里得到同样的对待。

对于一般对话任务，这个天花板或许可以接受；但对于推理任务，它意味着模型的上限被锁死在”别人已经写出来的推理”之内。推理能力的本质恰恰是探索数据集中不存在的路径——这正是 DPO 给不了的。

21.1.2 RL 的突破

RL（Reinforcement Learning）允许模型自我 rollout——用当前策略生成响应，用 reward 评估，再优化策略。这让模型可以”探索数据集外的空间”，突破离线天花板。换句话说，RL 把”训练数据”从静态的语料变成了动态的、模型自己生产的过程。

RL 的核心公式：

L_RL = -E_{y~π(x)}[reward(x, y)] + β·KL(π||π_ref)

注意这个公式里没有出现”数据集”——期望是在当前策略 π(x) 上取的。数据在训练循环中源源不断地被生成、被评估、被消费。这正是 RL 数据工程与 SFT/DPO 数据工程最根本的分野：SFT 数据工程的核心是”采集与清洗”，RL 数据工程的核心是”设计生成与验证的闭环”。

21.1.3 RLVR：奖励干净到极致

RLVR（RL with Verifiable Rewards）的核心：用可验证的函数做 reward，而不是用 Reward Model。

Reward 类型	来源	噪声	可信度
Reward Model	学习得到	高	中
用户反馈	用户点击	极高	低
Verifier	规则/代码	零	极高

从任务侧看，各类可验证奖励的形态如下：

任务类型	验证方法	奖励信号	可靠性
数学题	比较最终答案	答案正确 +1，错误 -1	高
代码题	运行测试用例	全部通过 +1，部分 +0.5	极高
逻辑推理	形式化验证器	证明有效 +1	极高
翻译	BLEU/参考答案	连续分数	中
问答	字符串匹配	匹配 +1	中

RLVR 的 reward 只有 0 和 1：

• 数学题答对：1，答错：0
• 代码通过单测：1，不通过：0
• 指令符合格式：1，不符合：0

这种”干净到极致”的奖励信号，让模型可以学到真正的推理能力，而不是”骗过 Reward Model”。它还有一个常被低估的经济学优势：可验证奖励消除了人类偏好标注的瓶颈。在数学和代码领域，你可以生成几乎无限量的训练信号——只需要有足够的题目和正确答案。数据瓶颈从”标注产能”完全转移到”算力和题库规模”。

21.1.4 隐藏失败模式：hard problem 零信号

RLVR 的 0/1 奖励”干净”，但也暗藏一个致命弱点：当模型对 hard problem 所有 N 个 rollout 都得到 0 分时，GRPO 的组内 z-score 归一化完全失效——所有 advantage 均为 0，产生零学习信号。模型在这个 prompt 上”学不到任何东西”。

但”学不到”的原因比”advantage 全为 0”更深一层。zero advantage 描述的是这一组采样的现象，而 RLV$^\varepsilon$R 的分析给出了结构性解释——support barrier：把 GRPO 动力学看作概率单纯形上的 replicator 流，边界状态 $p_0\in\{0,1\}$ 是吸收态，因此初始概率为零的推理模式无法被 RLVR 创造出来。也就是说，pass@8=0 的题不只是”这一组没采到正确解”，而是”这条正确路径在初始策略里的概率为 0，RL 根本没有可放大的东西”——再怎么增加 rollout 数也不会凭空出现。

这一层解释改变了”怎么办”。如果问题只是 advantage 全零，那么加大采样、换采样策略、做动态过滤就够了；而如果问题撞的是 support barrier，这些都无效，唯一有效的是从外部注入这条路径——这正是本节下面两条路线（OC-GRPO 注入特权引导、教师引导课程逐步撤除引导）必须存在的根本理由，而不是为了让 advantage 数值上不全零。

对称的问题同样存在：如果所有 rollout 都得 1 分（模型已经完全掌握），advantage 同样为 0。这就是后面 DAPO 的 Dynamic Sampling 要过滤”全对/全错组”的原因（见 21.5.2），也是过程级信号研究（见 21.6.5）要解决的核心困境。

Off-Context GRPO（Agrawal et al., arXiv:2607.19313）针对”全 0”这一侧提出了一个精巧的解决方案：

1. 训练时注入特权引导：当检测到全 0 奖励时，给训练 prompt 注入 solution prefix（如推理的第一步）作为”特权引导”，使模型能产生非零 reward rollout。
2. 重要性修正回原始目标：用 importance-corrected objective 将更新导回原始无引导目标，确保推理时不依赖引导。
3. 几乎零额外成本：只需修改训练时的 prompt 构造，不需要额外的 reward model 或人工标注。

在数学推理基准上平均 +3.9% absolute（+13.8% relative）。这对”始终 0”的 hard problem 区间尤为有效——而这恰恰是模型最需要突破的能力边界。

第二条路线：教师引导课程（Teacher-Guided Curriculum）。OC-GRPO 走的是”注入提示后用重要性采样修正回原目标”，另一条路线选择从课程侧撤除引导：用更强教师的部分推理轨迹为不可解题构造难度梯度，再以反向链式课程（backward-chaining curriculum）逐步撤走引导，直到模型独立解出（arXiv:2609.13997）。该路线给出一个可直接引用的数据效率锚点——仅用 128 道不可解题训练，在九个基准的平均上达到或超过用 2000 题全量语料训练的 GRPO（约 16× 数据效率），并在大 k 的 pass@k 上显著扩展推理边界。它也点出了单用不可解题训练的代价：分布偏移，对应其提出的 Monotone Frontier Curriculum（MFC）。两条路线可组合：OC-GRPO 解决”训练时这一组没有信号”，课程路线解决”这批题长期进不了学习区”。

📌 该工作 2026-09-12 首发于 arXiv（两作者），据 abs 页 comments 字段已收录于 EMNLP 2026 Findings（Findings of the Association for Computational Linguistics: EMNLP 2026）。本轮引用时仍按”会议收录、但尚未见正式版卷期”处理，数字以 arXiv 版为准。

21.1.5 DeepSeek-R1-Zero：纯 RL 训练出推理能力的里程碑

2025 年 1 月，DeepSeek 发布了 R1 系列模型，其中 DeepSeek-R1-Zero 是一个里程碑：它仅通过强化学习（无 SFT warm-start）就获得了强大的推理能力。

DeepSeek-R1-Zero 的训练过程：

  基座模型（DeepSeek-V3-Base）
          ↓
  直接进入 RL 训练
  ├── 算法：GRPO（Group Relative Policy Optimization）
  ├── 数据：数学+代码推理题（含可验证答案）
  ├── 奖励：基于答案正确性的规则奖励
  └── 无 SFT 数据、无人类偏好数据

  训练过程中出现的"涌现"行为：
  1. 模型自发地学会了"chain of thought"推理
  2. 出现了自我反思：生成 "wait, let me reconsider..."
  3. 出现了"aha moment"：模型发现自己之前的错误并修正

从数据视角看，R1-Zero 做了一个激进实验：跳过 SFT，直接在 base model 上做 RLVR。可观察的结果是：

• 输出长度从初始的 500 tokens 增长到 12000 tokens——模型自己”决定”思考更久；
• 模型自发学会”反思”、“验证”、“回溯”等高级推理策略——没有任何人类示范；
• 在 MATH、AIME 上达到 SOTA。

这是后训练的里程碑——第一次证明”不需要人类示范，模型也能学会推理”。对数据工程而言，它宣告了一类全新数据的诞生：你不再需要生产”推理示范”，而是需要生产”能逼出推理的问题 + 能判定对错的验证器”。

21.1.6 RLVR：从”奖励类型”到”独立范式”

可验证奖励最初只是奖励信号的一种选择，但到 2026 年，围绕它构建的训练范式——RLVR——已经成为与 RLHF 并列的独立技术路线。所有主要实验室（DeepSeek、NVIDIA、Google、OpenAI）都将 RLVR 作为推理能力训练的标准方案。

维度	RLHF	RLVR
奖励来源	人类标注 → 奖励模型	规则/程序自动验证
标注成本	高（每轮迭代都需要新标注）	零（验证器是确定性的）
信号质量	受标注者噪声和偏差影响	无噪声（对/错是确定的）
可扩展性	受限于标注产能	受限于算力
适用范围	所有任务（含主观任务）	有明确正确答案的任务
数据瓶颈	偏好标注	高质量题库
典型代表	InstructGPT, Claude	DeepSeek-R1, DAPO

RLVR 的端到端数据流程：题库 → 在线采样 → 规则验证 → 梯度更新。整个循环中没有任何人类参与，数据瓶颈从”标注产能”完全转化为”算力和题库规模”。

需要强调的是，二者并非替代关系。实际的 RL 训练通常混合使用：可验证任务用 RLVR，主观任务用 RLHF——DeepSeek-R1 的完整训练正是这一混合策略（见 21.6.4）。

21.1.7 适用范围与边界

可验证奖励适用的场景：
  ✅ 数学推理（有标准答案）
  ✅ 代码生成（有测试用例）
  ✅ 逻辑推理（可形式化验证）
  ✅ 棋类/游戏（有明确胜负）

正在拓展的场景：
  🔄 通用推理（Apriel-Reasoner, 2026.04——多任务可验证奖励设计）
  🔄 多步 Agent 任务（环境反馈作为验证信号）

仍不适用的场景：
  ❌ 创意写作（什么是"好"的创意？）
  ❌ 对话质量（"有帮助"很难量化）
  ❌ 安全对齐（"无害"的边界模糊）

→ 实际的 RL 训练通常混合使用：
   - 可验证任务用 RLVR
   - 主观任务用 RLHF
   DeepSeek-R1 的完整训练正是这一混合策略

“正在拓展”一栏值得数据工程师特别注意：每当你能为一类新任务定义出可靠 verifier，就意味着一类新能力可以被 RL 训练。verifier 设计能力本身就是 RLVR 时代的核心数据技能（见 21.2 与 21.4）。

但”可验证”的边界不是”有没有规则可写”。上面三栏的划分隐含了一个前提：verifier 是规则型/程序型的，所以”创意写作""对话质量”这类没有标准答案的域天然不可用。ACL 2026 的一项工作（Crossing the Reward Bridge，Yi Su 等，苏州大学 + 腾讯）把这条边界往前推了一格，而且给出了规则型 verifier 的一个负面规模律：

规则型 verifier 的适用性即便在结构化领域也比想象中窄，而且随着多域、free-form 训练数据增加，规则系统的性能反而会退化——不是”覆盖不到所以这些域做不了”，而是”数据越多、域越杂，规则 verifier 越会拖后腿”。解法是把二值规则奖励换成生成式 verifier 产出的软概率奖励；依据是”给 ground-truth 参考时，强 LLM 对人类评判者的一致性很高”，因此可以自动产出奖励而无需人工标注或逐步 rationale。结果：一个 7B 生成式奖励模型指导 7B 策略，超过最大 10 倍于它的模型，含 Qwen2.5-Instruct-72B（+8.6%），并在七个 OOD 基准上强泛化。训练数据来自 ExamQA（48+ 一级学科、638K 大学水平题目，去掉干扰项转为 free-form QA）。

⚠️ 提案另提到”比规则奖励基线 +7.0%“，本书在 ACL Anthology 摘要页未检索到该数字，故不予采用；ExamQA 的具体规模数字亦未逐条回源。

一句话收口：这意味着”多域 free-form 主观题”正在从”❌ 不适用”移向”🔄 正在拓展”，代价是把二值规则奖励换成生成式软奖励——而这一换就重新引入了奖励模型的可被 hack 问题。可验证性的边界每往前推一格，reward hacking 的攻击面就跟着长一格。这正是 21.7 必须紧跟在本章过程级信号之后的原因，也是为什么 Ch20 讨论的 PRM 鲁棒性门禁（受控扰动 + 闭环探测）在这里同样适用。

---

21.2 RLVR 数据三要素与五类可验证任务

21.2.1 三要素结构

RLVR 数据与 SFT/DPO 数据截然不同，它的核心是三要素：

{
  "prompt": "求解 x^2 - 5x + 6 = 0",
  "verifier": {
    "type": "math_sympy",
    "expected_answer": "x=2 or x=3",
    "check_fn": "lambda ans: sympy.checker(eq='x^2-5x+6', ans=ans)"
  },
  "metadata": {
    "difficulty": "easy",
    "domain": "algebra",
    "pass_at_8": 0.85,
    "source": "numina_math"
  }
}

• prompt：任务指令
• verifier：判断响应是否正确的函数
• metadata：难度、领域、pass@8 等元信息

与 SFT 数据对比可以看清差异的本质：SFT 数据是”问题 + 标准答案”，学习信号藏在答案里；RLVR 数据是”问题 + 判定规则”，学习信号在训练时由模型自己的 rollout 与判定规则的交互产生。答案是一次性的，verifier 是可复用的判定能力——同一个 verifier 可以评判同一道题的一万次不同尝试，这正是 RL 能持续产生新训练信号的原因。

metadata 中的 pass_at_8 尤其关键：它不是题目本身的属性，而是题目与当前模型能力的相对属性，直接决定这道题的训练价值（见 21.3.1）。这也意味着 RLVR 数据的 metadata 是”活的”——随着训练推进，同一道题的 pass@8 会变化，需要周期性重估（见 21.5.4 课程化重采）。

21.2.2 verifier 是核心

SFT 数据的灵魂是 response，RLVR 数据的灵魂是 verifier。一个坏的 verifier 会让模型学到错误行为，且极难发现——错误会以”训练看起来正常推进”的方式被固化进策略。

verifier 设计的核心原则：

1. 正确性：必须真的能判断对错。
2. 鲁棒性：不能被 reward hacking 骗过。
3. 效率：单个验证 < 1 秒（rollout 时调用频繁）。
4. 可扩展：能批量验证 N=16-64 个 rollout。
5. 可量化：用 Youden’s J = TPR - FPR 作为 verifier 质量的单标量指标。J > 0 时 GRPO 学习成功（噪声只影响收敛速率，不改变最终命运），J < 0 时学习退化。现实中 verifier 不会完美（单元测试只覆盖有限 corner case），但 J 提供了一个可量化的验收标准——“足够好”的 verifier 至少需要 J > 0.5。

第 5 条值得展开：Noisy RLVR 理论给出的结论是，verifier 噪声不改变学习的方向性，只改变收敛的速度——前提是 J > 0。这为工程实践提供了一个难得的”容错空间”：你不需要完美的 verifier 才能开始训练，你需要的是一个可测量、且 J 显著大于 0 的 verifier。把 verifier 质量从”玄学”变成”可验收的指标”，是 RLVR 数据工程走向工业化的关键一步。

严格形式（J 的”摩擦系数”解释）。这条结论有一个更硬的版本：把 GRPO 的学习动力学建模为概率单纯形上的 replicator process（复制子动力学，一种自然选择式的流），可以证明 J = TPR − FPR 是唯一决定学习方向与速度的摩擦系数——$J>0$ 时错误模式的质量被推向消亡（学习成功），$J=0$ 时过程中性，$J<0$ 时错误模式被放大直至主导（反学习与崩溃）。在 $J>0$ 的学习区内，噪声的作用只在于重新标度收敛时间，不改变最终命运——即所谓 “rate, not fate”（Rate or Fate? RLV$^\varepsilon$R，2026-01-07）。这让”J > 0.5”这条工程线有了含义：J 越小，达到同等准确率所需的训练步数越多。

⚠️ 换算口径：部分二手解读把上述关系写成”需要 $1/J$ 倍的步数”。本书在论文 HTML 全文中未检索到 1/J 这一表达式，能确认的只有摘要与正文的定性表述”噪声主要重新标度收敛时间”。因此若要用它做预算换算（如 J=0.5 → 约 2 倍步数），请视为本书的示意性换算，不是论文给出的公式。

⚠️ 更重要的一条边界：上述容错结论只在”随机独立噪声”下成立。“J > 0 就够”这句话隐含了一个噪声模型——verifier 的错误是随机的、跨样本独立的标签翻转。现实中的 verifier 往往不是这样：静态代码检查器会因为格式缺一个括号而对所有样本一致地判错，会因为语言而对一类正确答案一致地拒绝。这类系统性误差的行为与随机噪声完全不同（Delay, Plateau, or Collapse，COLM 2026）：

• 系统性 false negative（因格式缺少某个括号、或因语言而拒绝正确答案）通常只是延迟训练——模型最终会学会避开那个”被禁”的格式，同时仍然把题解出来。
• 系统性 false positive 才是危险的：它给模型一条通往高奖励的捷径，会造成永久 plateau 甚至彻底 collapse。论文举的触发器包括：相对误差容忍（“接近就够了”）、词级触发器（输出含 “Certainly” / “python”）、长度触发器（字符数落在某个区间）。
• 因此 verifier 的总体错误率是差的预测指标。同一个 J 值，背后可能是一个随机乱判的 verifier（只是慢），也可能是一个专门奖励”写 Python 代码”的 verifier（直接 collapse）——J 是聚合统计量，它把”错在哪”平均掉了。真正决定成败的是”verifier 奖励了哪些行为触发器”。

论文为此引入 Conditional Advantage $C(t)$：衡量某个触发器 $t$ 所关联的行为与真实 ground-truth reward 是正相关还是负相关。正相关 → plateau，负相关 → collapse。这条判据可以直接变成一道验收：列出你的 verifier 可能被利用的触发器，逐个测它关联的奖励与真能力的相关性符号。

收口：这两条合起来改写了第 5 条的工程含义。“J > 0.5”仍然是一个必要的验收线，但它不充分——它筛掉的是”方向错了”的 verifier，筛不掉”方向对但错得有规律”的 verifier。完整的验收应当是两步：先测 J（聚合方向），再测触发器的条件优势（系统性结构）。

21.2.3 数学（sympy 验证）

import sympy

def math_verifier(response, expected_answer):
    # 1. 抽取最终答案
    final_answer = extract_final_answer(response)
    # 2. 用 sympy 检查等价
    try:
        expr1 = sympy.sympify(final_answer)
        expr2 = sympy.sympify(expected_answer)
        is_equiv = sympy.simplify(expr1 - expr2) == 0
        return 1.0 if is_equiv else 0.0
    except:
        # 退回到字符串匹配
        return 1.0 if normalize(final_answer) == normalize(expected_answer) else 0.0

典型数据源：GSM8K、MATH、NuminaMath、AMC/AIME 题目。

数学是最早被 RLVR 攻克的领域，原因有三：答案紧凑（一个表达式）、等价判定可程序化（sympy）、题库充足（从小学到竞赛有天然难度阶梯）。但等价判定远比看上去微妙——1/2 与 0.5、(x+1)^2 与 x^2+2x+1 都是”形式不同但等价”的例子，字符串匹配会全部误判（详见 21.4.1）。

21.2.4 代码（单测验证）

def code_verifier(response, test_cases):
    # 1. 抽取代码
    code = extract_code(response)
    # 2. 沙箱执行
    with Sandbox() as sb:
        try:
            sb.execute(code)
            results = [sb.run_test(tc) for tc in test_cases]
            pass_rate = sum(results) / len(test_cases)
            return pass_rate  # 0-1 连续值
        except Exception as e:
            return 0.0

典型数据源：HumanEval、MBPP、APPS、CodeContests。

代码是 verifier 可靠性最高的领域——“跑通了就是对的”。但代价是工程复杂度：沙箱隔离、超时控制、资源限制缺一不可（见 21.4.2）。注意代码 verifier 天然支持连续奖励（pass_rate），不必强行二值化；GRPO 的组内归一化对连续奖励同样友好。

21.2.5 指令遵循（规则验证）

def instruction_following_verifier(response, constraints):
    score = 0
    for constraint in constraints:
        if check_constraint(response, constraint):
            score += 1
    return score / len(constraints)

# 示例约束
constraints = [
    "response length <= 200 words",
    "response contains exactly 3 paragraphs",
    "response starts with 'Sure'",
    "response does not contain 'I'"
]

典型数据源：IFEval、FollowBench。

指令遵循验证的特点是约束可枚举、判定可组合：每个约束独立检查，得分取平均。这类任务的价值在于把”听话”变成可训练的能力——模型学会的不是”回答好”，而是”在硬性约束下回答”。要注意的是，这类 verifier 往往内嵌英语假设（比如英文单词计数规则），跨语言使用时需要审计（见 21.3.8）。

21.2.6 信息抽取（F1 验证）

def extraction_verifier(response, ground_truth_entities):
    extracted = parse_entities(response)
    # F1 score
    tp = len(extracted & ground_truth_entities)
    fp = len(extracted - ground_truth_entities)
    fn = len(ground_truth_entities - extracted)
    precision = tp / (tp + fp) if (tp + fp) > 0 else 0
    recall = tp / (tp + fn) if (tp + fn) > 0 else 0
    f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
    return f1

典型数据源：CONLL2003、ACE2005。

抽取类任务的 ground truth 是实体集合，天然适合集合运算。F1 作为连续奖励，比二值判定保留了更多信息——多抽、漏抽、错抽分别对应 precision 与 recall 的不同失衡。

21.2.7 多步推理（中间步骤验证）

def multi_step_verifier(response, expected_steps):
    extracted_steps = parse_reasoning_steps(response)
    # 检查每个步骤是否正确
    correct = 0
    for ext, exp in zip(extracted_steps, expected_steps):
        if check_step_equivalence(ext, exp):
            correct += 1
    # 全对才给 1，部分对给部分分
    return correct / len(expected_steps)

典型数据源：StrategyQA、ProofWriter。

多步推理验证是最接近”过程级奖励”的形态——它评估的是推理路径本身，而非只看终点。这也是五类任务中最难做好的一类：步骤对齐、步骤等价判定都需要针对任务定制。它在 2026 年的重要性迅速上升，因为”过程 vs 结果奖励”被证明是比”奖励质量”更强的一阶效应（见 21.6.5 开头的奖励粒度实验）。

21.2.8 五类任务的共同结构

把五类 verifier 并排看，可以发现它们共享同一个骨架：抽取 → 判定 → 打分。

任务	抽取什么	怎么判定	奖励形态
数学	最终答案表达式	sympy 符号等价	二值
代码	代码块	沙箱跑单测	连续（pass rate）
指令遵循	响应整体	规则逐条检查	连续（约束满足率）
信息抽取	实体集合	集合运算 F1	连续
多步推理	推理步骤序列	步骤对齐比对	连续（步骤正确率）

设计新任务的 verifier 时，先回答三个问题：从响应里抽取什么结构？用什么规则判定等价/正确？奖励是二值还是连续？——五类任务覆盖了绝大多数组合形态，新任务通常是这五种模式的变体或组合。

---

21.3 RLVR Prompt 池构建

如果说 verifier 决定”学得对不对”，prompt 池决定”学得快不快”。RLVR 训练对 prompt 池有四个核心要求：难度梯度、多样性、可验证性、语言覆盖。前三者是常被讨论的”经典三属性”，第四个属性在多数开源配方里被默认成了常量。

21.3.1 难度梯度：pass@8 与 solve rate

RLVR 训练的关键是难度梯度——太简单的模型已经会，学不到东西；太难的模型完全不会，也学不到东西。

工业级用 pass@K 量化难度：

def compute_pass_at_k(model, prompt, verifier, k=8):
    results = []
    for _ in range(k):
        response = model.generate(prompt, temperature=0.7)
        results.append(verifier(response))
    return sum(results) / k  # 0-1

难度分桶：

pass@8	难度	训练价值	推荐占比
0.8-1.0	太简单	低	10%
0.5-0.8	简单	中	20%
0.2-0.5	中等	高	40%
0-0.2	困难	中	20%
0	太难	低	10%

本表与 23.14.1 的 RLVR 难度配方为同一套，两处数字以本节五档版为准（2026-09-22 已对齐）。“pass@8 = 0”这一档必须独立保留——它是 21.1.4”零信号”问题的对应区间，也是课程化解锁的对象，并入 0-0.2 会让上述讨论失去对应的行。

经验：pass@8 在 0.2-0.5 的 prompt 训练价值最高——模型有时能解、有时不能解，正是在”学习边界”上。

这背后是 GRPO 的组内归一化机制：advantage 来自组内 reward 的相对差异（见 21.5.1）。solve rate 为 0% 或 100% 的组内没有差异，也就没有梯度。用 solve rate 的语言重新表述最佳学习区：

太简单（模型 solve rate > 90%）：
  → 梯度信号太弱，学不到东西
  → 浪费计算资源

太难（模型 solve rate < 5%）：
  → 几乎所有采样都是失败的
  → 无法产生有效的正向信号
  → 可能导致训练不稳定

最佳难度（solve rate 20-50%）：
  → 足够的正向信号来学习
  → 足够的挑战来提升能力
  → 组内差异大，GRPO 梯度信号强

pass@8 分桶与 solve rate 区间是同一件事的两种度量——pass@8 是”事前用 k 次采样估计的难度”，solve rate 是”训练时组内实际的通过率”。前者用于建池分桶，后者用于训练中监控。

度量本身的边界：上面这套分桶默认 pass@K 是可靠的难度度量，但它只判最终答案、不判推理过程。数学题的答案常是简单整数，多采样下”推理错但蒙对答案”的概率并不低，pass@K 会把它计为成功，从而系统性高估模型能力。这一偏差对 0-0.2 与 =0 两桶的判定影响最大：一条题 pass@8=0 未必是模型不会，8 次采样不足同样会得到 0；一条题 pass@8=0.25 里也未必每次都是真推理解出的。CoT-Pass@K（arXiv:2506.14245，ICLR 2026）要求最终答案与推理链一并正确，并按 any-correct / majority-correct / all-correct 三种口径报告，可剔除蒙对噪声。该文还给”答案级奖励为何仍能改进推理”提供了理论依据：只要 CoT 正确时答案正确的概率高于 CoT 错误时答案正确的概率，仅凭 0/1 答案奖励也会单调提升正确推理链的概率——这是 21.6.5 过程级信号一节的理论落点。

由此得到一条工程取舍：分桶仍用 pass@8（便宜），能力边界的判定改用 CoT-Pass@K，或至少在抽样子集上校验一次。三个尺度是分工关系而非替代关系——pass@8 建池分桶、大 k 的 pass@k 探能力边界、CoT-Pass@K 剔除蒙对。

从经验规则到有下界保证：“0.2-0.5 最佳”此前只有 GRPO 组内归一化这一定性解释（组内差异大则梯度强）。EACL 2026 的在线难度过滤分析（Online Difficulty Filtering for Reasoning Oriented Reinforcement Learning，Bae 等，2026.eacl-long.30）把同一结论上升为可证明的下界：期望策略提升的下界等于任务级成功概率的方差，中等难度任务使该方差最大化，学习效率因而最高；据此设计的 balanced filtering 在多个数学推理基准上取得最高 +12% 增益，且训练步数不到标准 GRPO 的一半。

第二个独立证据源：从 GRPO 的 replicator 动力学也能得到同一结论——训练在 $p\approx0.5$ 的中等难度提示上最有效，因为此时奖励方差最大（见 21.2.2 引的 RLV$^\varepsilon$R 分析）。这与 EACL 的方差下界是同一事实的两种表述，一个从下界证明出发，一个从动力学出发，互为印证。

两侧不对称，这一点比”中等难度最优”本身更重要。难度过低（$p\to1$）与过高（$p\to0$）看起来是对称的两个极端，实际不是一回事：$p\to1$ 一侧只是方差小、梯度弱，属于”收益递减”；$p\to0$ 一侧撞的是 support barrier——RLVR 能放大任何非零概率已有的正确解，但无法创造初始概率恰为 0 的正确解（边界状态 $p_0\in\{0,1\}$ 是吸收态）。所以低难度侧可以靠多采样、加数据缓解，高难度侧不能。

21.3.2 数学推理数据的难度分级

落到具体领域，难度梯度需要变成可执行的分级设计。以数学为例：

难度级别设计：

Level 1: 基础运算和简单应用
  - GSM8K 级别（小学数学）
  - 只需 2-4 步推理
  - 用途：warm-up，建立基础推理习惯

Level 2: 中等数学
  - MATH 数据集中的中低难度
  - 需要 4-8 步推理
  - 涉及代数、几何基础
  - 用途：主体训练数据

Level 3: 竞赛预备
  - AMC/AIME 级别
  - 需要 8-15 步推理
  - 需要组合不同数学工具
  - 用途：提升上限

Level 4: 竞赛级
  - IMO/Putnam 级别
  - 需要深度证明和创造性思考
  - 用途：少量使用，推动极限

推荐配比：
  Level 1: 20%  |  Level 2: 45%  |  Level 3: 30%  |  Level 4: 5%

注意 Level 分级是内容难度（题目固有的推理步数与知识跨度），pass@8 是相对难度（题目相对当前模型的能力）。两者要配合使用：用 Level 分级做粗筛与领域配平，用 pass@8 做训练价值的精确度量。随着模型能力提升，同一 Level 的题目 pass@8 会整体上移——这就是需要课程化重采的原因（见 21.5.4）。

21.3.3 代码推理数据的粒度

代码数据的难度轴不是”步数”而是”粒度”：

函数级 → 文件级 → 项目级

函数级：
  "实现一个函数，判断一棵二叉树是否是 BST"
  验证：10-20 个测试用例
  适用：基础代码能力

文件级：
  "实现一个 LRU 缓存类，支持 get/put/delete，线程安全"
  验证：完整的单元测试套件
  适用：模块设计能力

项目级：
  "实现一个简单的 key-value 数据库，支持持久化和并发访问"
  验证：集成测试 + 性能测试
  适用：系统设计能力（当前最难）

粒度越粗，验证基础设施越重：函数级只需要一组测试用例，项目级需要集成测试、性能测试乃至分布式环境。当前开源 RLVR 配方绝大多数停留在函数级——不是因为文件级/项目级没有训练价值，而是因为 verifier 的构造成本急剧上升。这再次印证了本 章 21.2.2 的论断：verifier 是 RLVR 数据的真正瓶颈，任务的天花板由验证能力决定。

21.3.4 多样性

Prompt 池要覆盖多维度：

• 领域：代数/几何/微积分/数论/组合
• 题型：求解/证明/应用题
• 长度：短题（<100 字）/中题/长题（>500 字）
• 难度：小学/初中/高中/本科/竞赛

多样性的作用机制与 SFT 时代不同。SFT 时代多样性防的是过拟合具体表述；RLVR 时代多样性防的是策略过早坍缩到单一解题模式——如果 prompt 池全是一元二次方程，模型会学出”看到方程就求根公式”的窄策略，在别的问题上一塌糊涂。多样性的度量可以用 n-gram 重叠（工业惯例 4-gram 去重阈值 ≥ 0.6 视为重复）或 embedding 聚类控制。

21.3.5 可验证性筛选

不是所有 prompt 都能做 RLVR——必须能定义 verifier。

def filter_verifiable(prompts):
    verifiable = []
    for p in prompts:
        if has_ground_truth_answer(p):
            verifiable.append(p)
        elif has_test_cases(p):
            verifiable.append(p)
        elif has_explicit_constraints(p):
            verifiable.append(p)
        # 开放式问题（如"写一首诗"）无法 RLVR
    return verifiable

踩坑：约 60-70% 的 prompt 因无法定义 verifier 被过滤，需要预留冗余采集。

这个过滤比例常被低估。实践中更隐蔽的坑是”名义可验证、实际验证不了”——题目有标准答案，但答案表示不唯一（多解坑，见 21.4.3），或者答案本身有错（开源题库的错误率不可忽视，关键 prompt 必须 Cross-Verifier 抽验，见 21.4.4）。可验证性筛选不是一次性动作，而是随 verifier 能力演进的过程：今天验证不了的任务，等你写出更好的 verifier 之后再回来。

21.3.6 静态配比 vs 自适应机制

启动方案——静态配比：如果你刚开始搭建 RL 训练管线，Level 1-4 按 20/45/30/5% 配比是合理的起点。它足够简单，且在多数场景下表现不差。

进阶方案——自适应机制：静态配比的问题在于，随着模型能力提升，固定难度分布会逐渐偏离”最佳学习区”。DAPO 的 Dynamic Sampling 提供了一个优雅的解决方案：直接过滤掉 solve rate 为 0% 或 100% 的 prompt，让训练自动聚焦在有信息量的数据上。 实验表明，这种自适应机制比任何人工设定的固定配比都更高效——DAPO 的训练步数比 R1-Zero 减少约 50%。

2026 年的 ICLR 研究进一步量化了数据效率：通过课程策略和数据选择的组合，RLVR 训练可以在使用显著更少的题目的情况下达到相当甚至更好的性能。一个可核验的锚点是 21.1.4 的教师引导课程：仅用 128 道不可解题训练，在九个基准平均上达到或超过用 2000 题全量语料训练的 GRPO（约 16× 数据效率）。这意味着 RL 数据的瓶颈不在量，而在”信息密度”——每道题在当前模型能力边界上能提供多少梯度信号。

静态配比与自适应机制的关系，类似于”手工特征工程”与”端到端学习”的关系：前者可控、可解释、启动快；后者上限高、免维护、但要求训练框架支持动态过滤。工程上的稳妥路径是先静态后自适应——用静态配比跑通管线、积累监控数据，再切到 Dynamic Sampling 类的自适应方案。

21.3.7 程序化无限环境：从静态数据集到环境设计

上述难度控制讨论都基于静态数据集（AIME/MATH/GSM8K 等），但静态数据集有两个根本局限：(1) 数量有限，RLVR 训练很快过拟合；(2) 难度分布固定，无法跟随模型能力自适应调整。

Reasoning Gym（arXiv:2505.24760）引入了”程序化无限环境”范式——每个训练环境都是程序化生成的，可调整难度和分布，从根本上解决了过拟合和难度适配问题。

静态数据集 vs 程序化无限环境：

静态数据集（AIME/MATH/GSM8K）：
  数量：有限（数千至数万题）
  难度：固定分布
  过拟合风险：高（尤其 RLVR 多轮训练后）
  课程学习：需人工配比或 Dynamic Sampling

程序化无限环境（Reasoning Gym）：
  数量：无限（程序化生成）
  难度：可调（参数化控制）
  过拟合风险：极低（每道题都是新的）
  课程学习：天然支持（逐步调整生成参数）
  覆盖领域：数学/逻辑/代码/物理等多领域

这对数据工程范式的改变是根本性的：从”筛选固定数据集”转向”设计生成规则”。数据工程师的角色从数据策展人转变为环境设计师——核心技能不再是”如何从有限数据中选出最优子集”，而是”如何设计生成规则使产出的数据持续处于模型能力边界上”。

值得注意的是，程序化环境与 prompt 池构建并不冲突：环境生成规则的参数空间（难度参数、领域模板、约束类型）本身就是一种更高阶的”prompt 池”——只不过池子的维护从”采集去重”变成了”调参与扩展模板”。本 章 21.10 的工业 SOP 对两种形态都适用。

21.3.8 语言维度：被忽略的第四个属性

21.3.1-21.3.5 讨论的是 prompt 池的难度、多样性、可验证性三个属性。但还有一个属性在绝大多数开源配方里被默认为常量：语言。本章五类可验证任务的 benchmark（GSM8K、MATH、HumanEval、BFCL 等）几乎全是英语，中文 RLVR 数据工程长期缺少系统的实证依据。

GRPO Beyond English（Konstantin Dobler 等 5 人，arXiv:2608.13698）是目前规模最大的多语言 GRPO 实证研究，覆盖多种 base model、训练语言与推理语言奖励设置。三条结论对中文场景有直接价值：

结论	原文发现	对中文 RLVR 的含义
母语训练差距小	用母语做推理训练，与英语推理训练的差距通常只有很小一点	不必默认”必须翻译成英文 prompt 才有推理能力”，中文 prompt 池是可行的
跨语言迁移强	在一种语言上训练，往往能提升其他多种语言的表现	中文数据不足时，可先在中英混合上训练，不必等中文数据齐备
但存在严重回退	趋势高度依赖具体模型与语言；某些语言上的训练会导致其他语言域外能力严重回退	加中文数据不等于全面提升，必须做回退监控

必须加的工程动作：第三条是这张表里唯一带风险的一条，也是提案与多数转述都略过的部分。它把”多语言配比”从一次性的静态决策，变成了需要持续监控的动态问题：

# 按语言分桶跟踪域外能力，而不是只看总体指标
def multilang_regression_check(ckpt, base_ckpt, eval_sets_by_lang):
    for lang, evals in eval_sets_by_lang.items():
        for name, metric in evals.items():
            delta = eval(ckpt, name) - eval(base_ckpt, name)
            if delta < -REGRESSION_THRESHOLD:   # 建议 3-5 个百分点
                alert(f"[{lang}] {name} 回退 {delta:.1f}pp")

配套的两个判断：

• verifier 的语言偏差：数学/代码的 verifier 相对语言中立，但指令遵循（IFEval 类）与信息抽取（F1）的 verifier 往往内嵌英语假设，中文上直接套用会系统性低估。这是比 prompt 池更难发现的偏差源。
• 不要靠”加中文数据”解决回退：论文指出的是回退存在且依赖模型语言对，并未给出普适的配比解。正确做法是先量化回退，再决定是调整配比、混合训练，还是回退到上一检查点。

⚠️ 成熟度提示：该研究为 2026-08 的实证工作，其结论的普适性受限于所覆盖的模型与语言集合。中文是否在”强迁移”或”严重回退”一侧，需要在你自己的基座上实测，不宜直接外推。

---

21.4 Verifier 设计的坑

verifier 是 RLVR 数据的灵魂，也是最容易埋雷的地方。这一节集中讨论四类高频坑：等价判定、沙箱隔离、多解表示、单一验证器盲点——以及一个更根本的问题：当 verifier 本身有噪声时怎么办。

21.4.1 数学等价坑

# 错误：字符串匹配
"1/2" == "0.5"  # False，但数学等价

# 正确：sympy 等价检查
sympy.simplify(sympy.sympify("1/2") - sympy.sympify("0.5")) == 0  # True

陷阱：

• (x+1)^2 vs x^2+2x+1：展开形式不同但等价
• 2 vs 2.0：类型不同但数值相同
• {-1, 1} vs ±1：集合表示差异

解决方案：用 sympy 的 simplify(a - b) == 0 检查等价，覆盖 95%+ 情况。

这个坑的杀伤力在于它的静默性：字符串匹配的 verifier 不会报错，只会把”表述不同但正确”的答案判为错。模型于是学会输出 verifier 偏好的表述形式——一种隐蔽的 reward hacking（见 21.7）。更阴险的是边界情况如 $\sqrt{2}/2$ 与 $1/\sqrt{2}$，连 sympy 的默认化简路径都可能误判，需要显式的有理化预处理。verifier 上线前，务必用一批”形式多样、答案等价”的探针样本做回归测试。

21.4.2 沙箱隔离坑

代码 verifier 必须在沙箱中执行，否则有安全风险。

# 错误：直接 exec
exec(user_code)  # 危险！可能删库

# 正确：Docker 沙箱
def safe_execute(code, test_cases):
    with docker_container(image="python:3.11-slim") as sb:
        sb.copy("solution.py", code)
        sb.copy("test.py", generate_test_file(test_cases))
        result = sb.run("python test.py", timeout=10)
        return parse_result(result)

踩坑：

• 沙箱必须有超时（10 秒）——死循环会卡死 rollout
• 沙箱必须限制内存（512MB）——大内存分配会拖垮系统
• 沙箱必须无网络——否则模型学会”调 API 作弊”

这三条坑分别对应三种攻击/失效模式：资源耗尽（死循环、内存炸弹）拖垮训练集群；环境逃逸（网络调用）让模型绕过”自己写代码”的任务本身。尤其注意第三条——模型学会调外部 API 解题是一种完全合法但完全违背训练意图的行为，而它只会在”沙箱有网”时悄然发生，reward 曲线上看一切都是”变好了”。

21.4.3 多解坑

数学题常有多种解法，verifier 必须支持：

def math_verifier_multi(response, acceptable_answers):
    final = extract_final_answer(response)
    for ans in acceptable_answers:
        if sympy_equivalent(final, ans):
            return 1.0
    return 0.0

# 示例：x^2 = 4 的解可以是 {-2, 2} 或 x=±2
acceptable = ["{-2, 2}", "{2, -2}", "x=±2", "x=2 or x=-2"]

多解坑的根源是答案的表示空间远大于答案的语义空间。同一组解可以有集合、枚举、参数式等十余种写法。工程上的正解不是穷举 acceptable 列表（永远枚不完），而是把答案统一解析到规范化的中间表示（符号集合、区间、数值容差），再做等价判定。对于无法规范化的任务，退回 Cross-Verifier + 人审兜底。

21.4.4 Cross-Verifier：防单一验证器的盲点

为防止单一 verifier 的盲点，关键 prompt 用多个 verifier 交叉验证：

def cross_verify(response, prompt):
    v1 = math_sympy_verifier(response, prompt)
    v2 = math_llm_verifier(response, prompt)  # LLM 当备份 verifier
    v3 = math_human_verifier(response, prompt)  # 抽样人审

    if v1 == v2:
        return v1
    else:
        # 分歧时人审
        return v3

经验：1% 的 prompt 会出现 verifier 分歧，必须人审，否则会导致错误训练信号。

Cross-Verifier 的本质是给验证器引入异构冗余：sympy 擅长符号等价但对表述敏感，LLM verifier 擅长理解表述但自身有噪声，人审最准但最贵。三者对齐时置信度最高，分歧时暴露盲点。这个思路在后面会反复出现——21.6.5 中 RSTG 的”教师信号只作补充”、21.7.4 的 hacking 检测，用的都是同一哲学：外部信号要作为交叉校验，而非替代。

21.4.5 验证器本身的局限与去偏校正

RLVR 假设验证器是完美的，但现实中并非如此：

• 数学边界情况：等价但形式不同的答案（如 $\sqrt{2}/2$ 与 $1/\sqrt{2}$）可能被误判
• 代码测试覆盖不完整：测试用例无法覆盖所有 edge case，模型可能学会”通过测试但逻辑有缺陷”的捷径
• 回吐验证器漏洞：模型可能发现验证器的假阳性模式，产生 reward hacking

针对噪声验证器的去偏校正已成为一个活跃的研究方向。核心思路是：在 RL 训练中显式建模验证器的错误率，并在梯度更新中做相应补偿——类似于带噪声标签学习中的 loss correction 技术。

与 21.2.2 的 Youden’s J 框架对照着看：J = TPR - FPR 度量的是验证器”方向正确”的程度，去偏校正则是在 J > 0 但不完美时，进一步估计并扣除系统性偏差的影响。前者是验收标准，后者是补偿手段，二者共同构成”承认 verifier 不完美”前提下的工程方法论。

但补偿手段有一条硬边界，必须同时写明。去偏校正在数学上处理的是”可估计的系统性偏差”——你需要能估出 TPR 与 FPR，才谈得上在梯度里扣掉它。而 21.2.2 引的那条 COLM 2026 结论指向的是另一种情况：系统性 false positive 的触发器与真实能力负相关时，模型学到的是一条通往高奖励的捷径，此时无论怎么补偿都救不回来——因为问题不在”判错了多少”，而在”奖励了什么行为”。

判据很直接：如果你的 verifier 的某个系统性 FP 触发器（长度落在某区间、输出含某关键词、误差容忍到某个阈值）所关联的行为，与真实 ground-truth reward 负相关，正确动作是改 verifier，而不是改 loss。反过来，若触发器与真能力正相关，去偏校正仍有价值——此时问题只是慢（plateau），不是崩。

21.4.6 奖励信号的有效性危机：Spurious Rewards

上述讨论隐含一个关键假设：奖励信号的质量决定 RLVR 的训练效果。但 2025 年的 Spurious Rewards（arXiv:2506.10947）研究严重动摇了这一根基。

在 Qwen2.5-Math 模型上，研究者使用完全随机奖励、错误奖励（将正确答案标为错误）甚至恒定奖励进行 RLVR 训练，仍然在 MATH-500 上获得 21-25% 的显著提升。这不是微小的统计波动——随机奖励的效果竟然接近精心设计的一致性奖励。

Spurious Rewards 实验结果：

奖励类型                    MATH-500 提升
正确奖励（标准 RLVR）        +27%
随机奖励（均匀随机）          +25%
错误奖励（正确标为错误）      +21%
恒定奖励（所有样本相同）      +18%

→ 即使奖励信号完全错误，RLVR 仍然显著提升推理能力

两种解释假说：

1. 策略正则化假说：RLVR 训练的主要作用是防止策略坍塌——类似于探索正则化。奖励信号仅作为”训练信号存在”的标记而非质量信号，防止模型在 SFT 后的分布上过度自信地收敛。
2. 探索激励假说：RLVR 训练增加了输出多样性，让模型接触到更多推理路径。模型不是通过奖励选择最优路径，而是通过更广泛的探索”碰巧”发现了更好的推理方式。

对推理 RL 数据工程的影响：

• 数据质量投入的边际收益需重新评估——在强基座模型上，随机奖励都能起正则化作用
• 可能需要将重心从”奖励信号质量”转向”训练动态设计”（如探索策略/正则化强度）
• Spurious Rewards 不意味着奖励质量无关——在弱基座上仍需质量信号，且随机奖励的效果仍低于正确奖励

对数据工程师而言，这项研究是一次诚实的”水位校准”：你在 verifier 上投入的巨大精力，其边际收益在强基座上可能低于直觉。但它划出的边界同样清楚——随机奖励 +27% 中的 25 个点可能来自正则化，但正确奖励仍多出 2 个点，且在弱基座、长训练、跨域泛化场景下差距只会更大。verifier 质量仍是下限的保证，只是不再是全部。

---

21.5 Rollout 工程：GRPO 训练数据流水线

prompt 池与 verifier 解决”静态数据”问题；rollout 工程解决”动态生成”问题——如何在训练循环中高效地采样、打分、分配信用。这是 RL 数据工程与 SFT 数据工程分野最大的地方。

21.5.1 GRPO 算法核心与数据流程

GRPO（Group Relative Policy Optimization, DeepSeek 2024）是 RLVR 的主流算法，相比 PPO 显存占用低 4 倍。它的核心是不需要独立的奖励模型（Critic/Value Model），而是用”组内相对排名”来提供学习信号。

核心思想：对每个 prompt 采样 N 个响应，用组内归一化计算 advantage，无需训练 value model。

从训练侧看 GRPO 的一次更新：

def grpo_step(model, ref_model, prompt, verifier, n=16):
    # 1. 采样 N 个响应
    responses = [model.generate(prompt, temperature=0.7) for _ in range(n)]

    # 2. 计算 reward
    rewards = [verifier(r) for r in responses]

    # 3. 组内 z-score 归一化
    mean_r = np.mean(rewards)
    std_r = np.std(rewards)
    advantages = [(r - mean_r) / (std_r + 1e-8) for r in rewards]

    # 4. 计算梯度
    for r, adv in zip(responses, advantages):
        log_ratio = log_prob(model, r) - log_prob(ref_model, r)
        loss = -adv * log_ratio + β * kl_penalty(model, ref_model, r)
        loss.backward()

    optimizer.step()

从数据侧看，同一个循环长这样——GRPO 的一次数据生成循环：

def grpo_data_pipeline(
    prompt: str,          # 推理问题
    model,                # 当前策略模型
    reward_fn,            # 奖励函数（如答案正确性）
    group_size: int = 16, # 每组采样数量
) -> dict:
    # Step 1: 对同一个 prompt，采样 group_size 个回复
    responses = []
    for _ in range(group_size):
        response = model.generate(prompt, temperature=1.0)
        responses.append(response)

    # Step 2: 对每个回复计算奖励
    rewards = [reward_fn(prompt, r) for r in responses]

    # Step 3: 计算组内相对优势
    mean_reward = sum(rewards) / len(rewards)
    std_reward = max(np.std(rewards), 1e-8)
    advantages = [(r - mean_reward) / std_reward for r in rewards]

    # Step 4: 高于平均的回复被"鼓励"，低于平均的被"抑制"
    training_pairs = []
    for response, advantage in zip(responses, advantages):
        training_pairs.append({
            "prompt": prompt,
            "response": response,
            "advantage": advantage,
        })

    return {
        "prompt": prompt,
        "pairs": training_pairs,
        "group_stats": {
            "mean_reward": mean_reward,
            "max_reward": max(rewards),
            "min_reward": min(rewards),
            "solve_rate": sum(1 for r in rewards if r > 0) / group_size,
        },
    }

两个视角合在一起才能看清 GRPO 的数据本质：每个 prompt 生产的是一个”组”，而不是一条样本。组内有相对排序就有梯度，组内全对或全错就没有梯度——这就是 21.3.1 难度分桶与 21.5.2 Dynamic Sampling 的算法根源。group_stats 中的 solve_rate 是训练时最重要的实时监控指标：它直接告诉你这个 prompt 是否还处在”最佳学习区”。

21.5.2 从 GRPO 到 DAPO：四大技术跃迁

GRPO 奠定了”无需独立 Critic 模型”的基础，但它在实际大规模训练中暴露了若干瓶颈——熵坍缩（策略过早收敛到少数模式）、长序列梯度稀释、以及对无效 batch 的计算浪费。2025 年 3 月，字节跳动与清华联合提出的 DAPO（arXiv:2503.14476，NeurIPS 2025）在 GRPO 之上做了四项关键改进：

技术	解决的问题	核心思路	数据层面的意义
Clip-Higher	熵坍缩	对概率提升方向设置更高的裁剪上界，保持策略多样性	允许模型在更多元的推理路径上探索，间接扩大了有效数据空间
Dynamic Sampling	无信息量 batch	自动过滤全对/全错的 prompt（solve rate 为 0% 或 100%），只保留有梯度信号的 batch	隐式实现了 21.3 节所描述的”最佳 solve rate”课程调度——无需人工设定难度梯度
Token-level PG Loss	长 CoT 梯度稀释	将策略梯度从回复级改为 token 级，每个 token 都获得梯度信号	长推理链（数百步）的每一步都参与学习，数据利用率大幅提升
Overlong Reward Shaping	超长响应	对超出长度限制的响应施加软惩罚（而非截断），引导模型学会在有限长度内完成推理	减少因截断产生的无效样本，提高数据效率

实验结果：DAPO 将 Qwen2.5-32B 在 AIME 2024 上训练至 50 分，训练步数比 R1-Zero 方案减少约 50%。目前 Qwen、Nemotron 等生产模型已采用类似技术。

DAPO 最重要的工程启示是 Dynamic Sampling——它让难度控制从一个需要预先设计的静态参数（配比 20/45/30/5%）变成了训练过程中的自适应行为。这与 21.3.6 的结论呼应：自适应难度控制优于任何人工固定配比。

DAPO 的 Dynamic Sampling 通过丢弃退化组解决方差坍缩。DBB 奖励估计（arXiv:2603.18444，KAIST, 2026）提供了一种互补方案——不丢弃 prompt，而是用折扣 Beta-Bernoulli 估计改进优势计算的统计质量，使更多 prompt 产生有效训练信号。两者可叠加：DBB 减少需要丢弃的 prompt 数量，Dynamic Sampling 兜底处理 DBB 也救不了的极端情况。GRPO+DBB 在 1.7B/8B 模型上的 Acc@8 平均提升为：in-distribution 3.43/2.32 点，out-of-distribution 10.05/8.34 点。⚠️ 该组数字取自论文 v2（2026-05-23）；v1（2026-03-19）报告的是 3.22/2.42 与 12.49/6.92，v2 对实验结果做了修订，且 arXiv 摘要页的元数据仍显示 v1 数字，引用时须以正文为准。

21.5.3 关键参数

参数	推荐值	备注
N（group size）	16	太小方差大，太大显存爆
temperature	0.7	太低无探索，太高全乱码
β（KL 系数）	0.001-0.01	比 DPO 小一个数量级
max_tokens	8192-32768	长链 CoT 必需
学习率	1e-6 到 1e-5	极小，否则崩溃
动态 N	4→16（方差驱动）	VIGOR 策略比固定 N 省 30-57% 预算

这张表的每一行背后都是一个失败模式：N 太小 advantage 估计噪声大；temperature 太低组内无多样性（z-score 分母趋零）；β 太大模型锁死在参考策略上、太小则语言能力漂移；学习率超出区间训练直接发散——RLVR 的超参敏感度显著高于 SFT，“先小规模扫参再全量训练”不是可选项而是必选项。

21.5.4 课程化重采与动态难度调整

RLVR 训练中 prompt 池不是固定的，要根据模型能力动态调整：

def curriculum_resampling(model, prompt_pool, epoch):
    # 每个 epoch 重新评估 pass@8
    for p in prompt_pool:
        p['pass_at_8'] = compute_pass_at_k(model, p, p['verifier'], k=8)

    # 课程化：简单 prompt 逐渐减少
    if epoch < 10:
        weights = [1.0 if p['pass_at_8'] < 0.3 else 0.3 for p in prompt_pool]
    elif epoch < 30:
        weights = [1.0 if 0.2 < p['pass_at_8'] < 0.5 else 0.5 for p in prompt_pool]
    else:
        weights = [1.0 if p['pass_at_8'] < 0.3 else 0.2 for p in prompt_pool]

    return sample_with_weights(prompt_pool, weights)

一个高级的 RL 训练系统应该能够动态调整题目难度：

自适应难度调整：

  每 N 步 → 评估当前模型在各难度级别的 solve rate
      ↓
  Level 1 solve rate > 90%? → 降低 Level 1 比例
  Level 3 solve rate < 10%? → 降低 Level 3 比例
      ↓
  重新平衡难度分布，确保"最佳学习区"
      ↓
  继续训练

两种实现殊途同归：课程化重采是在数据侧重估难度再加权采样，动态难度调整是在配比侧按 Level 汇总调节。前者精细（prompt 级权重），后者轻量（级别级比例）。工程选择取决于重估 pass@8 的预算——每道题跑 8 次 rollout 的代价不小，大池子可以只对”疑似移出学习区”的题重估。

把 21.3.6 与本节串起来，难度控制的完整图景是三层递进：静态配比（建池时）→ 课程化重采（每 epoch）→ Dynamic Sampling（每 step，自动过滤退化组）。三层分别作用于不同时间尺度，互不冲突，逐层叠加。

21.5.5 VIGOR：方差驱动的动态 rollout 分配

GRPO 的标准做法是每个 prompt 固定 N=16 个 rollout，但这忽略了 prompt 间的能力差异——对 easy prompt 浪费预算，对 hard prompt 可能不够。VIGOR（Jiang et al., arXiv:2607.22002）提出了一个高效替代方案：

1. 从少量开始：每个 prompt 初始 N=4 个 rollout。
2. 方差引导分配：将额外 rollout 预算分配给 reward 方差最大的 prompt——方差高意味着模型对该 prompt 尚不稳定，需要更多探索。
3. 理论保证：reward 方差控制梯度幅度，高方差 prompt 的梯度对策略更新贡献更大。

实证结果：数学任务达到同样准确率用 2.3× 更少 rollout，代码任务 full pass rate 用 1.49× 更少 rollout，平均 test pass rate +3.4pp。

工程启示：固定 N=16 不是唯一正解。如果你的训练集群有 rollout 并行度瓶颈，VIGOR 的方差驱动策略比单纯”加大 N”更聪明。它与 DAPO 的 Dynamic Sampling 构成互补：Dynamic Sampling 丢弃无信息组（二值决策），VIGOR 给有信息组分配更多预算（连续决策）——一个做减法，一个做加法。

21.5.6 Cue-GRPO：信用分配的结构级偏斜

VIGOR 解决的是采样多少（预算分配），但采样完之后还有第二个问题：采到的样本各占多少权重。

RLVR 的常规做法是把每个正确 completion 当作等价的独立学习信号。Cue-GRPO（Zhe Cao、Miaowen Wen、Fangjiong Chen，arXiv:2608.03467）指出这在 GRPO 中会产生 结构级偏斜（structure-level skew）：反复出现的正确解法形式会按被采样到的频次成比例地累积正 advantage，而稀有的解法形式只分到有限的 credit。论文把这一现象形式化为 multiplicity-induced structure-level credit concentration（由重复多样性诱导的结构级信用集中）。

后果是反直觉的：模型最容易想到的那种解法会被反复强化，而”少数派正确解法”——恰恰是泛化能力可能最强的部分——反而得不到训练信号。在 repeated-sampling 场景（如 AIME 多次采样取最优）下，这直接限制了采样预算增加能带来的收益。

做法：按簇（cluster）稀有度重新分配正 advantage。Cue-GRPO 的工程设计值得单独一提——它用确定性的 Strategy Cues 在 rollout 内部构建 verified-correct 轨迹的分区，不需要任何辅助模型推理，因此不增加推理开销。论文在 Qwen2.5-Math-7B 与 Llama-3.1-8B-Instruct 上验证了 AIME repeated-sampling 的提升，且采样预算越高增益越大。

三层分工（与既有方法的关系）：

环节	问题	代表方法
采样预算	每个 prompt 采多少 rollout	VIGOR（21.5.5）
零信号挽救	全错 prompt 怎么学到东西	OC-GRPO / SCOPE-RL（21.6.5）
信用分配	学到的正确解各占多少权重	Cue-GRPO（本节）

⚠️ 口径提醒：部分转述把 Cue-GRPO 描述为”token 级稀有度信用再分配”。论文的原文表述是 structure-level / cluster 级——衡量的是解法形式（strategy cluster）的稀有度，不是单个 token。这个区别很重要：token 级方案需要处理序列位置的信用归属，而 Cue-GRPO 的方案只需对轨迹做分区，实现成本低得多。

21.5.7 GRPO 的隐藏杀手：策略熵坍缩

RLVR 训练中最常被忽视但致命的问题，不是 reward hacking，而是更根本的策略熵坍缩。

现象：GRPO 训练几个 epoch 后，组内 rollout 的 advantage 信号逐渐消失——所有采样都趋向同一策略输出，训练停滞。这正是策略熵（policy entropy）逐渐下降的结果。

ACL 2026 Outstanding Paper STEER（Stabilizing Token-level Entropy-changE via Reweighting，浙江大学+腾讯 CodeBuddy，arXiv:2510.10150）从 token-level 熵变角度首次系统性解释了这一机制：

四类 token 更新决定熵变方向：

• 增枝型：低概率 token 被推高 → 熵增 → 探索空间扩大
• 剪枝型：高概率 token 被压低 → 熵减 → 策略收敛
• 巩固型：高概率 token 被推更高 → 熵减 → 确定性增强
• 修正型：中概率 token 被调整 → 熵变不定

GRPO 的优势函数设计天然倾向”剪枝”——成功 rollout 让模型更确定地沿同一条路走，最终导致探索空间过早收缩。

STEER 的解决方案：在 token 级别施加”限速器”——估计每个 token 的熵变贡献，对过度”剪枝”的 token 降权训练。效果：

• 数学任务：+4.4 分（AIME/GSM8K 等）
• 代码任务：+2.5 分（HumanEval/MBPP 等）
• 跨模型族（Llama/Qwen/DeepSeek）和 RLVR 算法（GRPO/DAPO）一致有效

工程建议：从 epoch 5 开始监控策略熵。如果 entropy 下降超过 50%，降低 learning rate 50% 并增大 KL 系数 2 倍。STEER 的开源实现可作为训练稳定的标准插件。

熵坍缩与 21.3.4 的多样性论述是同一枚硬币的两面：prompt 池多样性是”输入侧”的防坍缩手段，STEER 式的熵监控是”优化侧”的防坍缩手段。两头都要抓——输入再多样，优化过程把策略压成一条路，多样性也白费。

21.5.8 On-policy vs Off-policy 与数据新鲜度

Off-policy 数据：
  用旧版本的模型（或其他模型）生成的数据
  优点：可以提前准备，不阻塞训练
  缺点：与当前模型的分布不匹配，效果有折扣

On-policy 数据：
  用当前版本的模型实时生成的数据
  优点：分布完全匹配，学习效率最高
  缺点：需要实时推理，增加训练复杂度

当前的共识：On-policy 数据显著优于 off-policy，特别是在 RL 训练的后期。DeepSeek-R1 采用的就是完全 on-policy 的方式。

对数据工程来说，on-policy 意味着”数据新鲜度”成为一等公民的管理对象：

"""
RL 训练中的数据新鲜度管理
"""

def rl_data_freshness_check(
    model_version: int,
    data_generated_at_version: int,
    max_stale_versions: int = 3,
) -> dict:
    """
    检查 RL 数据的新鲜度
    """
    staleness = model_version - data_generated_at_version

    status = (
        "fresh" if staleness == 0 else
        "acceptable" if staleness <= max_stale_versions else
        "stale"
    )

    return {
        "model_version": model_version,
        "data_version": data_generated_at_version,
        "staleness": staleness,
        "status": status,
        "recommendation": {
            "fresh": "直接使用",
            "acceptable": "可以使用但建议混入新数据",
            "stale": "丢弃，重新生成",
        }[status],
    }

这套新鲜度管理在两个场景下尤其重要：一是异步 RL 架构（rollout 与训练解耦，天然产生 staleness）；二是 off-policy 数据的补充使用（如 21.6.5 的 RSTG 教师引导数据、拒绝采样的回放数据）。staleness 的容忍度与 KL 系数联动——β 越大，可容忍的 staleness 越大，因为更新本身被信任域约束住了。

---

21.6 长链思维与推理数据构造

RLVR 提供了”逼出推理”的训练机制，而推理能力的载体是长链思维（Long Chain-of-Thought）。本节讨论推理数据的构造：R1-Zero 的涌现机制、超长输出的工程处理、R1 式训练全流程与蒸馏，以及过程级信号的前沿。

21.6.1 R1-Zero 的涌现

DeepSeek R1-Zero 做了一个激进实验：跳过 SFT，直接在 base model 上做 RLVR。结果模型自己涌现出了长链思维：

• 输出长度从初始的 500 tokens 增长到 12000 tokens
• 模型自发学会”反思”、“验证”、“回溯”等高级推理策略
• 在 MATH、AIME 上达到 SOTA

涌现的意义不只在结果，更在机制：长链思维不是被”教”出来的，而是被”选”出来的。组内相对优势意味着”思考更久、验证更多”的 rollout 只要更常答对，就会被持续强化。反思与回溯不是设计目标，而是这条强化路径上的中间产物。理解这一点，才能理解接下来”不给参考过程”的设计选择。

21.6.2 不给参考过程

R1-Zero 的关键设计：只给 reward，不给参考思维过程。

如果给参考 CoT，模型会学会”模仿参考”，永远困在参考的水平。不给参考，模型必须自己”发现”推理路径，可以超越参考。

# 传统 SFT（限制天花板）
prompt: "求 x^2-5x+6=0"
response: "用求根公式...x=2 or x=3"  # 模仿参考

# R1-Zero（突破天花板）
prompt: "求 x^2-5x+6=0"
response: "让我思考...因式分解：(x-2)(x-3)=0...验证：代入 2，4-10+6=0 ✓...所以 x=2 or x=3"
# 模型自己发明的推理路径

这是推理数据构造与 SFT 数据构造最深刻的分歧点：SFT 思维链数据的天花板是”标注者（或教师模型）能想到的最好推理”，RLVR 推理数据的上限是”verifier 能判定的所有正确推理”。前者的上限在人，后者的上限在验证能力。这也解释了为什么推理数据工程的投入重心，应当从”生产更好的 CoT 样本”转向”构造更好的可验证任务 + 更可靠的 verifier”。

21.6.3 超长输出处理

长链 CoT 的输出长度可达 8K-32K，对工程是巨大挑战：

# 工业级长输出处理
def generate_long_cot(model, prompt, max_tokens=32768):
    # 1. 分段生成（避免 OOM）
    response = ""
    while not is_finished(response):
        chunk = model.generate(
            prompt + response,
            max_tokens=4096,
            temperature=0.7
        )
        response += chunk
        if len(response) > max_tokens:
            break

    # 2. 检查 finishing signal
    if "<|end_of_reasoning|>" not in response:
        response += "\n最终答案：..."

    return response

显存优化：

• 用 vLLM 做 rollout，支持 PagedAttention
• KV cache 量化（INT8）
• 长 prompt 用 YaRN 等长度外推技术

超长输出还会反哺训练侧的设计：max_tokens 设太小，正确推理被硬截断，verifier 判 0——模型学到”别想太久”的错误信号；设太大，无效长输出消耗预算。DAPO 的 Overlong Reward Shaping（软惩罚替代硬截断，见 21.5.2）正是对这个两难的正解。监控”输出长度分布 vs reward 的关系”是长链 CoT 训练的标配：如果长度持续增长而 reward 不涨，多半是模型学会了”啰嗦”而非”深思”。

21.6.4 R1 式训练全流程：冷启动、RL 与蒸馏

R1-Zero 证明了纯 RL 的可能性，但工业可用的 R1 完整版是一条更务实的混合流水线。理解它，才能理解”推理数据”在全生命周期中的不同形态。

R1 完整训练的四个阶段：

阶段一：冷启动（Cold-start SFT）
  - 收集数千条高质量长 CoT 样本做 SFT
  - 目的：给 base model 一个可读的推理"格式起点"，
    解决 R1-Zero 输出可读性差、语言混杂的问题
  - 数据形态：prompt + 精选长 CoT response（一次性、量小、质高）

阶段二：推理导向 RL
  - GRPO + 规则奖励（答案正确性）
  - 辅以语言一致性奖励，缓解中英混杂
  - 数据形态：prompt + verifier（21.2 的三要素形态）

阶段三：拒绝采样 + SFT
  - 从 RL checkpoint 采样海量推理轨迹
  - 用规则 + 奖励过滤正确轨迹，去重、质筛
  - 得到约 60 万条推理数据 + 20 万条非推理数据（写作、问答、翻译等）
  - 重新 SFT 基座
  - 数据形态：prompt + 模型自产的高质量 response
    （RL 产出的"蒸馏给自己的数据"）

阶段四：全场景 RL
  - 在混合奖励（可验证 + 人类偏好）下做最终 RL
  - 兼顾推理能力与通用能力、安全性

四个阶段对应四种数据形态的接力：人产 CoT（点火）→ 可验证任务（提纯）→ 自产 CoT（固化）→ 混合奖励（对齐）。其中阶段三是”拒绝采样”的标准用武之地——本章标题里与 rollout 并列的第三个关键词：从大量采样中”拒绝”掉不合格的，把幸存的正确推理变成下一轮 SFT 的教材。这本质上是把 RL 探索出来的能力蒸馏回模型权重，让能力不再依赖采样运气。

R1 式蒸馏：把强模型的推理能力搬进小模型

R1 系列的另一个关键发现来自蒸馏实验：用 R1 产出的约 80 万条推理样本直接 SFT 小模型（Qwen、Llama 系列），得到的 R1-Distill 系列显著强于在小模型上直接做同规模 RL。两条路线的对比结论是：

• 对小模型，蒸馏 > 直接 RL：小模型探索能力有限，直接 RL 难以自行发现高质量推理路径；大教师已经探索完毕，样本直接可用。
• 对大模型，RL 可以进一步超越蒸馏：教师的天花板不再是上限（呼应 21.6.2”不给参考过程”的逻辑——蒸馏同样受教师路径约束，RL 才能突破）。

蒸馏与 RL 的这个分工，给推理数据工程画出清晰的能力路线图：预算有限时，用强模型的输出构造蒸馏数据是性价比最高的选择；要突破教师上限、建立自己的能力壁垒时，RLVR 是唯一路径。二者的组合拳（先蒸馏再 RL）是当前开源推理模型的主流配方。

RSTG（见 21.6.5）可以视为这条流水线在训练循环内部的微缩版：教师信号不再用于离线蒸馏，而是以 on-policy distillation 的形式嵌入 RL 过程、且只在失败处介入。

21.6.5 奖励粒度与过程级信号的前沿

R1-Zero 范式强调”只给 reward，不给参考”，但 2026 年的研究证明：在保持可验证性的前提下，增加过程级信号密度可以显著提升效果。这不是推翻 R1-Zero，而是扩展其边界。

先看动机：粒度是比质量更强的一阶效应

Spurious Rewards（见 21.4.6）揭示了奖励质量（正确 vs 随机）的边际收益可能低于预期。最新研究（arXiv:2607.02869，2026-07）从另一个正交维度——奖励粒度（过程 vs 结果）——给出了不同的图景。

实验设计：Qwen2.5-0.5B + GSM8K + GRPO，5 种奖励配置：

配置	Test Accuracy	差距
纯过程奖励	63.73%	—
纯结果奖励	53.75%	-9.98pp
混合 (λ=0.9 过程)	61.03%	-2.70pp
混合 (λ=0.5)	58.23%	-5.50pp
混合 (λ=0.1 过程)	50.12%	-13.61pp ⚠️
无 RL 基线	~48%	—

三个关键发现：

1. 粒度是比质量更强的一阶效应。Spurious Rewards 中正确 vs 随机奖励差距仅 2pp（+27% vs +25%），而过程 vs 结果差距达 10pp——粒度的影响是质量的 5 倍。

2. 混合权重存在”危险区”。λ=0.1（少量过程+大量结果）的配置劣于纯结果奖励。两种奖励信号在优化方向上存在冲突：过程奖励鼓励”一步一步来”，结果奖励鼓励”快速到答案”。低过程权重时模型接收到矛盾信号。

3. 错误模式质性不同。过程模型犯的是”结构不一致但算术正确”的错误，结果模型犯的是”简洁但推导错误多”的错误。前者更容易通过增加推理预算修复，后者需要根本性的推理能力提升。

对数据工程的影响：

• RLVR 数据工程需要同时考虑”奖励准确性”和”奖励粒度”两个维度
• 如果预算有限：优先投入过程级奖励信号（如中间步骤验证），而非追求完美奖励质量
• 混合奖励需要谨慎调参——存在性能坍塌的”危险区”

五条过程级信号的实现路线

在”保持可验证性”的约束下，2026 年的研究给出了五条互补路线：

路线一：SCOPE-RL——将稀疏奖励稠密化（arXiv:2607.11506，Xiaojian Liu 等，2026-07-13）

GRPO 的奖励只在最终答案正确时给 1，否则 0。对困难问题经常”零学习信号”——所有 rollout 都错，模型不知从何改起。SCOPE-RL 两阶段稠密化：

1. Adaptive Scaffolded RL：将问题分解为子问题链，每个子问题给可验证奖励。
2. Quality-Aware Process RL：对正确轨迹用过程质量奖励进一步细化。

效果：DAPO-Math 和 Big-Math 上准确率最高提升 11.2pp，推理 token 减少 27.1%。

路线二：TRM——思考奖励模型（ICML 2026 Oral）

TRM（Thought Reward Model）评估推理链的质量，不仅是答案对错。基于 ME² principle 标注 103K 偏好对训练。关键设计是 gated reward shaping——只有答案正确时才让 TRM 参与 reward 计算，错误轨迹的 reward 始终为 0。这确保了可验证性本质不被破坏。

路线三：OC-GRPO——用特权信息激活”零正确率”问题（arXiv:2607.19313，2026-07-21）

当模型在困难问题上所有 rollout 都得 0 分（pass@8=0），典型做法是放弃这些 prompt。OC-GRPO（即 21.1.4 的 Off-Context GRPO）用”特权指导”（如解答前缀）在训练时帮助模型到达正确解，但用重要性修正使更新目标指向”无指导”的原始 prompt。平均提升 3.9%（相对提升 13.8%），几乎无额外成本。

路线四：RSTG——向教师借信号，但只在失败处借（arXiv:2608.00782，2026-08-01）

SCOPE-RL 与 OC-GRPO 都是”从任务侧造信号”（拆子问题 / 加特权信息）。还有第三条路：从教师侧借信号。

GRPO 有一个比”奖励稀疏”更硬的边界：当组内所有响应拿到相同奖励时（全对或全错），梯度完全消失。on-policy distillation（OPD）能提供稠密的 token 级监督，看起来是天然解药，但论文发现朴素地 GRPO + OPD 反而损害性能，原因有三：

1. 并非所有样本都能从蒸馏中受益
2. 过快拟合教师会削弱 RL 本身的探索能力
3. OPD 的优势是不对称的——它抑制了大部分 token

RSTG（Recovering Learning Signals via Adaptive Teacher Guidance，Zhuowen Han 等 12 人）的对策是选择性地、精确地在需要的地方施加蒸馏（distill where you fail）。论文标题中的 “Negative RL-Groups” 点明了主战场：全负组（所有 rollout 都失败）本是完全无信号的死区，恰恰是教师引导价值最高的地方。

工程判据：如果你已经在做 RLVR 且手上有更强的教师模型，RSTG 给出的不是”把 OPD 全量打开”，而是”只在负组上打开，并控制拟合速度”。这与 21.4.4 的 Cross-Verifier 思路同源——外部信号要作为补充而非替代。

路线五：StructReward——不训练 verifier 的过程奖励（arXiv:2608.08326，2026-08-08）

PRM（过程奖励模型）能提供更细粒度的反馈，但工业落地的成本一直很高——通常要单独训练一个 verifier、准备昂贵的 CoT 过程标注，或在训练循环里挂一个 LLM 做在线判定。

StructReward（Yifan Li、Ruxin Sun、Tongzhou Zhao）的做法是把生成的 solution 表示为一个推理步骤序列，然后用轻量的数值、符号与词汇匹配规则把它与带过程标注的参考步骤对齐，从而产出稠密的过程级奖励。三样昂贵的东西——独立 verifier、CoT 标注、LLM 在线判定——一个都不需要，论文的定位正是 compute-efficient。

⚠️ 引用边界：StructReward 的实证场景是多模态推理（multimodal reasoning）与自我纠错（self-correcting）。部分转述将其泛化为”长链 CoT 的中间步骤评分”，方向没错但场景被放大了——纯文本长链 CoT 上是否同样成立，论文未给出结论。如需在纯文本场景采用，建议先在小规模上验证步骤对齐规则的覆盖率。

路线六：VeriGate——用 verifier 做闸门，只在它沉默时才请 PRM 出场（arXiv:2605.30451，Aakriti Agrawal、Minghui Liu、Furong Huang，2026-05-28）

前五条路线都在回答”过程级信号从哪来”，没有一条正面回答”PRM 一旦引入就会被 hack怎么办”。VeriGate 补的正是这一格，而且它给的是结构性解法而非调参技巧。

三个设计：① 按 verifier 信息量设闸门——只要 verifier 奖励能在组内区分出优劣，就严格退回标准 GRPO，ground-truth verifier 保持绝对权威；只有整组 rollout 全为 0（verifier 完全无信息）时才启用 PRM 作为兜底恢复机制。② 未来累积 token 奖励（FCTR）——不把 PRM 的步骤分 collapse 成轨迹级标量，而是给每步算”未来累积”奖励，步内 token 继承该值，奖励的是”为下游成功铺路”而不是”局部看起来好”。③ 组内归一化的 token 级 advantage。

关键性质在③：论文给出并证明了 Proposition 3.1（Advantage invariance to prompt-wise positive affine PRM transformations）——若某次策略更新给一个 prompt 下所有 token 的奖励施加了统一的仿射变换 $c'_{i,j}=a(x)\,c_{i,j}+b(x)$（$a(x)>0$，$b(x)\in\mathbb{R}$，与 $i,j$ 无关），则 VeriGate 的 advantage 保持不变。这意味着：模型若想通过某种风格给所有步骤统一加一个常数奖励（或统一缩放）来 hack，组内归一化会把这个假信号完全抹掉。这是本章六条路线里唯一一条给出抗 hacking 形式化保证的。

结果：在 MATH 上训练、六个数学推理基准（AIME / AMC / GSM8K / MATH-500 / Minerva / Olympiad）上评测，Qwen2.5-Instruct 的 1.5B 与 7B 平均准确率提升约 20% 与 12%，同时显著减少零梯度失败，并抗住了朴素 PRM 优化（PRM-as-ORM）导致的输出极冗长化。

⚠️ 两个数字必须带口径读。论文表 2（PRM 用 Qwen-PRM-7B 的主结果表；表 3 是改用 Math-Shepherd PRM 的对照表）里逐基准标注的百分比是相对提升（GSM8K 71.11 → 72.10 标为 +1.39%），“平均 +20% / +12%“是六个基准相对提升的平均值，不是 20 个绝对百分点。1.5B 那一档的 20% 主要由 AMC（+83.51%）与 Minerva（+35.10%）拉高，GSM8K 只有 +1.39%，AIME 上 VeriGate 与基线的绝对值都是 0.00。把它读成”+20 个点”会严重高估。

与既有路线的关系：OC-GRPO 从任务侧（注入特权信息）救全 0 组，VeriGate 从过程侧（借 PRM）救全 0 组，两者可以并列。它也直接回应了本节前面”混合权重有危险区”的顾虑——VeriGate 不需要调混合权重，因为它在组内奖励有区分度时完全不启用 PRM，只有 verifier 彻底沉默时才切换，不存在”两个信号同时起作用、权重怎么配”的问题。

综合结论：2026 的趋势是在保持可验证性的前提下，增加过程级信号密度。六条路线各有适用场景：任务侧造信号（SCOPE-RL / OC-GRPO）适合有结构化分解能力的任务；教师侧借信号（RSTG）适合已有更强教师模型；思考质量奖励（TRM）适合已有过程偏好标注能力；免 verifier 的规则对齐（StructReward）适合推理步骤可被程序化比对的场景；而如果你担心引入 PRM 后被 hack，VeriGate 是唯一有形式化保证的入口。这为”pass@8=0 的困难问题不可训练”提供了新解法。它们与”奖励粒度”实验的启示一致：过程级信号是值得优先投入的方向，但混合调参要避开危险区。

---

21.7 Reward Hacking 检测与安全

过程级信号让奖励更稠密，但也让攻击面更大。reward hacking 是 RLVR 工程化的头号敌人——本节先讲性能层面的检测，再讲更严重的安全层面风险。

21.7.1 什么是 Reward Hacking

模型学会”骗过 verifier”而不是真正解决问题。典型表现：

• 数学题：模型输出”答案是 42”（碰巧命中 verifier 的字符串匹配）
• 代码题：模型写 assert True 直接通过测试
• 指令题：模型输出格式正确但内容无关

reward hacking 的根源在 21.4 已经埋下伏笔：verifier 的盲点（等价坑、测试覆盖不全）就是模型的”捷径地图”。Goodhart 定律在 RLVR 里的表述是：当 reward 变成优化目标，它就不再是好度量——reward 与真实能力之间的缝隙，恰好是模型梯度下降最擅长钻的空子。

21.7.2 检测方法 1：reward 突增告警

class RewardMonitor:
    def __init__(self, window=100):
        self.history = []
        self.window = window

    def check(self, reward):
        self.history.append(reward)
        if len(self.history) < self.window:
            return False

        recent = self.history[-self.window:]
        baseline = self.history[-2*self.window:-self.window] if len(self.history) >= 2*self.window else self.history[:self.window]

        recent_mean = np.mean(recent)
        baseline_mean = np.mean(baseline)

        # reward 突然上涨 20% 以上，告警
        if recent_mean > baseline_mean * 1.2:
            return True
        return False

突增告警的逻辑：真实能力的提升是渐变的，reward 曲线陡增往往是模型找到了 verifier 漏洞的信号。注意区分两种陡增——难度课程切换（刻意加大难题占比导致的暂时回落再上升）是正常运营动作，告警系统应感知 curriculum 的变更日志以免误报。

21.7.3 检测方法 2：rollout 模式聚类

def detect_hacking_by_clustering(rollouts):
    # 用 embedding 聚类 rollout
    embeddings = encode(rollouts)
    labels = cluster(embeddings, n_clusters=10)

    # 如果某个簇占比 > 50%，说明模型在"重复同一答案"
    for label in set(labels):
        ratio = sum(labels == label) / len(labels)
        if ratio > 0.5:
            print(f"Warning: cluster {label} 占比 {ratio:.0%}, 可能 reward hacking")

聚类的逻辑：多样性是 RLVR 健康的体温计。策略在正常学习时，正确解法应分布在多个簇里；如果某个正确簇占比畸高，说明模型收敛到了一条”万能作弊路径”。这个检测与 21.5.7 的熵监控互为印证——熵坍缩是它的另一种表现。

21.7.4 检测方法 3：Cross-Verifier

def cross_verify_hacking(response, primary_verifier, secondary_verifier):
    v1 = primary_verifier(response)
    v2 = secondary_verifier(response)

    if v1 == 1 and v2 == 0:
        # 主 verifier 通过但副 verifier 不通过，强烈怀疑 hacking
        return True
    return False

这是 21.4.4 Cross-Verifier 的安全侧应用：主 verifier 被”骗过”而副 verifier（异构实现）没有，两者的分歧就是 hacking 的直接证据。副 verifier 的选择要点是异构性——用 LLM 判卷对照 sympy 判卷有意义，用 sympy 的另一个封装对照 sympy 没有意义。

21.7.5 检测方法 4：人审 sample

每个 epoch 抽样 100 个 reward=1 的 rollout，人审检查是否真的解决问题。如果人审通过率 < 80%，立即停止训练排查。

人审是最后也是最硬的防线。自动化检测都可能被”一起骗过”（当主副 verifier 共享同一个盲点时），只有人的判断能发现”答对了但推理是垃圾”这类深层次退化。把人审通过率做成常设监控指标而非一次性动作，是工业级 RLVR 与实验室配方的分水岭之一。

21.7.6 RLVR 的安全反转风险：HarmRLVR 的警示

前面讨论的 reward hacking 聚焦于性能层面——模型用”取巧”方式骗 verifier 而不是真正解决任务。但 2026 年 ACL Long Paper HarmRLVR（arXiv:2510.15499，Yuexiao Liu 等）揭示了一个更严重的问题：RLVR 可以轻易逆转安全对齐。

核心发现：仅用 64 条有害 prompt（无需响应） + GRPO，即可逆转 Llama/Qwen/DeepSeek 等 5 个模型的安全对齐。攻击成功率 96.01%，有害性平均分 4.94/5，且通用能力完全保持——被攻击的模型在 MATH/MMLU 等基准上不掉分。

三个关键事实更令人担忧：

1. 安全对齐是单向的：一旦被 HarmRLVR 攻破，再用 SafeRLVR 训练其他安全数据无法修复——有害能力已被固化为策略的一部分。

2. 混合安全数据不仅无效，反而增强有害能力：在 64 条有害 prompt 中混入安全数据，模型的攻击能力反而更强。GRPO 的裁剪机制使模型学会精确区分何时输出有害内容、何时输出安全内容。

3. 现有防御基本失效：SafeLoRA 等参数级约束在 GRPO 的探索机制面前形同虚设——RLVR 训练的多样性探索会自动绕过静态约束。

对工业实践的影响：开放式 RLVR 训练能力即等于”一键去安全”能力。任何提供 RLVR 微调的 API/平台必须内置：

• 奖励层面的安全约束（不仅是 verifier，还需 safety classifier）
• 训练过程中实时有害性评分监控（不仅是最终 reward）
• prompt 池的安全审计（防止注入有害种子）

附记：RLVR 的奖励用 0/1 确实”干净到极致”，但干净 ≠ 安全。64 条有害 prompt 就能让干净变危险——这也许是 RLVR 这把利刃最隐蔽的一面。从数据工程视角，这给 21.3.5 的”可验证性筛选”补上了安全维度：筛选不仅要问”能否验证”，还要问”验证的是不是该验证的东西”。

---

21.8 自验证与自博弈：走向完全自主的训练循环

RLVR 解决了”谁来评判答案”，但仍然依赖人类设计的题库。2025-2026 年的前沿方向正在消除最后的人类依赖——题目本身、乃至奖励信号本身，都开始由模型自己生产。

21.8.1 自验证（RISE）

RLVR 训练的模型会”做对题”，但不一定会”检查自己的推理”——即使最终答案正确，中间步骤可能包含逻辑跳跃或隐含错误。RISE 在同一个 RL 过程中同时训练问题求解和自我验证能力：模型不仅要生成解答，还要学会在推理过程中捕捉自身的错误。

这对数据的要求是：训练题目需要同时提供答案级验证（最终结果对不对）和过程级验证（中间步骤有没有逻辑缺陷）的信号。数学和代码领域比较容易构造这种双层验证——数学可以检查每一步推导的合理性，代码可以在中间状态插入断言。

RISE 与 21.6.5 的过程级信号路线天然契合：过程级 verifier 提供的正是”中间步骤有没有缺陷”的判定，恰好是自验证能力的训练靶点。

21.8.2 合成自博弈（SPICE）

SPICE 框架引入了一个 “Challenger-Reasoner” 双角色结构：

• Challenger 从已有文档中挖掘生成推理任务（而非人工设计题目）
• Reasoner 求解这些任务
• 文档锚定防止幻觉放大——每道题都可以追溯到源文档

实验结果：数学推理 +8.9%，通用推理 +9.8%。

SPICE + RLVR 构成了一个完全无人参与的自适应训练循环：模型自己出题 → 自己解题 → 规则验证 → 梯度更新。21.5.8 描述的 on-policy 数据生成是”用当前模型生成回答”，SPICE 更进一步，连题目本身也由模型生成。这是否会导致训练分布的退化（类似 Model Collapse）？目前的证据表明，文档锚定和可验证奖励的双重约束提供了足够的接地力，但长期效果仍需观察。

21.8.3 Absolute Zero 与 INTUITOR：去掉最后的外部依赖

自主训练循环的终局形态，是把外部数据与外部信号一起去掉：

Absolute Zero Reasoner（arXiv:2505.03335）让模型完全不需要外部训练数据（无人工标注、无预置问题），通过自博弈同时扮演”出题者”和”解题者”，在可验证域（数学/代码）的自动验证中实现自监督训练——出题的正确性由”题目是否可解、解是否唯一”来保证，解题的正确性由代码执行与数学验证来判定。

INTUITOR（arXiv:2505.19590）则走了另一条路：不减少外部数据，而是消除外部信号依赖——用模型自身的内部置信度作为训练信号，完全不需要外部奖励模型或验证器。它把 GRPO 中的可验证奖励直接替换为 self-certainty（模型输出分布与均匀分布之间的平均 KL 散度），其余训练流程不变。关键发现：这个纯内在信号在域内数学基准上追平了 GRPO，但在域外任务上泛化得更好——Qwen2.5-3B 在 MATH 上训练后，LiveCodeBench 相对提升 65%（GRPO 为 0），CRUXEval-O 提升 76%（GRPO 为 44%）。

两条路径互补：Absolute Zero 消除数据依赖 + INTUITOR 消除信号依赖，两者结合可实现完全自监督推理训练。如果推理能力可以无数据、无信号地习得，“推理 RL 数据工程”的角色需从”提供训练数据”转向”设计训练环境和动态”——这与 21.3.7 的 Reasoning Gym”环境设计”范式完全吻合。

---

21.9 认知演变：五代去依赖

把本章的演进脉络压缩成一张表，可以看到一条异常清晰的主线：

推理模型 RL 数据的认知演变——五代去依赖

时间	认知	去掉了什么
2023	”推理能力需要 CoT 数据 + SFT”	—
2024.01	”o1 证明 RL 可以产生强大的推理——但方法未公开”	—
2025.01	”DeepSeek-R1 开源证明纯 RL 也能训练出推理。关键：可验证奖励 + GRPO”	去掉 SFT warm-start
2025.03	”DAPO 四大技术超越 GRPO。Dynamic Sampling 让难度控制全自动化”	去掉独立 Critic 模型 + 人工难度设定
2025-2026	”RLVR 成为独立范式，与 RLHF 并列。数据瓶颈从标注转为算力”	去掉人类偏好标注
2026	”SPICE 自博弈 + RISE 自验证 → 完全自主训练循环。模型自己出题、解题、验证”	去掉人工设计的静态题库
2026	”Absolute Zero 零外部数据自博弈 + INTUITOR 内部置信度替代外部奖励”	去掉外部数据 + 外部信号

五代演进的主线清晰：每一代去掉一个外部依赖，从 SFT 数据、Critic 模型、人类标注、静态数据集，到最后连题目设计都交给模型自己。第六代将这一演进推向极致——不仅去掉外部数据，连外部奖励信号都去掉了。

但”去依赖”不等于”数据工程失业”。恰恰相反：依赖每被去掉一层，数据工程的抽象层级就上移一层——从”生产 CoT 样本”到”设计 verifier 与 prompt 池”，再到”设计生成规则与训练环境”。21.10 的工业 SOP 描述的是当下这一层的最佳实践；下一代数据工程师的 SOP，正在 Reasoning Gym 与 Absolute Zero 这类研究里成形。

---

21.10 RLVR 数据构建工业 SOP

1. 需求定义：要补哪类可验证能力（数学/代码/指令）
2. Prompt 池构建：
   - 开源：GSM8K/MATH/HumanEval/IFEval
   - 合成：模板生成 + Magpie 过滤可验证
3. Verifier 设计：
   - 数学：sympy 等价检查
   - 代码：Docker 沙箱单测
   - 指令：规则检查
4. 难度评估：每个 prompt 算 pass@8
5. 难度分桶：0.2-0.5 占 40%（甜点）
6. 多样性筛选：4-gram ≥ 0.6
7. GRPO 训练：N=16, lr=1e-6, β=0.005
8. 课程化重采：每 epoch 重评 pass@8
9. Reward Hacking 检测：reward 监控 + 聚类 + Cross-Verifier
10. 评估：MATH/GSM8K/HumanEval/IFEval

把 SOP 的十步对照本章结构：步骤 1-2 对应 21.3（prompt 池），步骤 3 对应 21.2 与 21.4（verifier 设计与防坑），步骤 4-6 对应 21.3.1/21.3.4（难度与多样性），步骤 7-8 对应 21.5（rollout 工程与课程化），步骤 9 对应 21.7（hacking 检测），步骤 10 之外还应补上 21.3.8 的多语言回退监控与 21.7.6 的安全审计。SOP 本身是线性的，但真实的 RLVR 迭代是一个环——评估的结果回流到需求定义，进入下一轮池子重建。

---

本章要点回顾

1. DeepSeek-R1 证明了纯 RL 可以训练出推理能力——这是范式级的转变。
2. GRPO 消除了单独奖励模型的需求，用组内相对排名提供信号；DAPO 四大技术（Clip-Higher / Dynamic Sampling / Token-level PG / Overlong Shaping）全面超越 GRPO，训练效率提升约 50%。
3. RLVR 已从”奖励类型”升级为”独立范式”——与 RLHF 并列，适用于所有有明确正确答案的任务。
4. RLVR 数据三要素是 prompt + verifier + metadata——verifier 是灵魂，其质量可用 Youden’s J 量化验收（J > 0.5 为合格线）。
5. 五类可验证任务共享”抽取-判定-打分”骨架——数学 sympy、代码单测、指令规则、抽取 F1、多步推理步骤比对。
6. 难度控制至关重要：pass@8 0.2-0.5 / solve rate 20-50% 是最佳学习区；静态配比 → 课程化重采 → Dynamic Sampling 三层递进。
7. On-policy 数据远优于 off-policy——RL 训练的数据必须”新鲜”，staleness 需要显式管理。
8. Spurious Rewards 与奖励粒度实验重新校准了投入方向——粒度（过程 vs 结果）是比质量更强的一阶效应；过程级信号值得优先投入，但混合调参有危险区。
9. R1 式训练是”冷启动 SFT → 推理 RL → 拒绝采样 SFT → 全场景 RL”的混合流水线；对小模型蒸馏优于直接 RL，要突破教师上限则必须 RLVR。
10. Reward Hacking 检测四板斧：reward 突增告警、rollout 聚类、Cross-Verifier、人审抽样；HarmRLVR 警示 RLVR 还可能被用于逆转安全对齐——安全审计必须内置于数据管线。
11. RISE 自验证 + SPICE 自博弈 + Absolute Zero/INTUITOR 正在构建完全自主的训练循环——五代演进的主线是每一代去掉一个外部依赖。
12. 数据工程师的角色在升级：从生产 CoT 样本，到设计 verifier 与 prompt 池，再到设计生成规则与训练环境。

---

动手环节

练习 1：构造可验证奖励

为 GSM8K 中的 10 道题设计奖励函数：

• 支持数值答案和分数答案
• 处理等价表示（如 1/2 = 0.5 = 50%）
• 用 Youden’s J 评估你的 verifier：构造 20 个”正确但表述不同”的探针样本和 20 个”错误但表述接近”的探针样本，计算 TPR 与 FPR

练习 2：分析 GRPO 的采样效率

对同一道题采样 16 次，记录：

• 有多少次正确？（solve rate）
• 正确和错误回复之间的差异在哪里？
• 这个 solve rate 是否在”最佳学习区”内？

练习 3：难度分桶实操

从 MATH 数据集抽取 100 道题，对每道题计算 pass@8，按 21.3.1 的分桶表统计分布，并回答：如果目标分布是 10/20/40/20/10，你需要补充哪些桶的题目？从哪个 Level 的开源数据源补？

练习 4：reward hacking 侦探

给定一个”输出长度恰好卡在约束上限、格式全对、内容空洞”的指令遵循 rollout，判断：它属于哪类 reward hacking？设计一个 Cross-Verifier 方案检测它。

---