第 16 讲：Alignment: RLVR

本讲介绍 RLVR (Reinforcement Learning from Verifiable Rewards) — 一种利用可自动验证的 reward signal 进行强化学习的方法。与 RLHF 依赖人类标注不同，RLVR 的核心优势在于 reward 可以通过程序自动计算，从而实现大规模、低成本的 RL 训练。

1. RLVR 概念

1.1 什么是 Verifiable Rewards

Verifiable Rewards 指的是可以通过程序自动判断正确性的 reward signal。与 RLHF 中需要人类或 reward model 主观判断不同，verifiable rewards 具有客观标准：

• 数学答案验证：数学题有明确的正确答案，可以直接比较模型输出与标准答案
• 代码执行验证：运行模型生成的代码，检查是否通过所有 test case
• 形式逻辑验证：使用 proof verifier 检查数学证明的正确性
• 事实性验证：通过知识库或搜索引擎验证事实陈述的准确性

1.2 RLVR vs RLHF

方面	RLHF	RLVR
Reward 来源	人类偏好 → Reward Model	自动验证器
标注成本	高（需要人类标注者）	低（自动化）
Reward 准确性	受 RM 质量限制，可能有偏差	准确、无偏（正确答案是客观的）
Reward Hacking 风险	高（RM 容易被欺骗）	低（难以欺骗自动验证器）
适用范围	广泛（任何文本生成任务）	受限（需要可验证的任务）
扩展性	受限于标注速度	几乎无限扩展

2. 数学推理场景下的 RL

数学推理是 RLVR 最成功的应用场景。数学题具有天然的可验证性：答案要么对，要么错。

2.1 问题设定

在数学推理场景中，RL 的设定如下：

• Input (Prompt)：数学题目
• Output (Response)：解题过程和最终答案
• Reward：如果最终答案正确，reward = 1；否则 reward = 0（binary reward）

2.2 答案验证方法

数学答案的验证看似简单，实际上有一些技术细节：

import re
from sympy import simplify, parse_expr

def verify_math_answer(model_output, ground_truth):
    """Verify if the model's answer matches the ground truth."""
    # Step 1: Extract the final answer from model output
    # Common format: "The answer is \\boxed{42}"
    match = re.search(r'\\boxed\{(.+?)\}', model_output)
    if match is None:
        return 0.0  # No answer found

    model_answer = match.group(1)

    # Step 2: Try exact string match first
    if model_answer.strip() == str(ground_truth).strip():
        return 1.0

    # Step 3: Try symbolic equivalence (e.g., "2/4" == "1/2")
    try:
        expr1 = parse_expr(model_answer)
        expr2 = parse_expr(str(ground_truth))
        if simplify(expr1 - expr2) == 0:
            return 1.0
    except:
        pass

    return 0.0

2.3 常用数学训练数据集

• GSM8K：8.5K 小学数学应用题，答案为整数
• MATH：12.5K 竞赛数学题，难度从 Level 1 到 Level 5
• AIME：美国数学邀请赛题目，高难度
• NuminaMath：大规模数学问题集，适合 RL 训练

3. GRPO 算法

GRPO (Group Relative Policy Optimization) 是 DeepSeek 提出的一种 RL 算法，专门设计用于 LLM 的 alignment。它是 PPO 的一个重要改进，避免了训练 value model（critic）的需求。

3.1 PPO 的问题

在 LLM 场景中，PPO 存在几个实际问题：

• 需要 Value Model：PPO 需要一个 value function（critic）来估计 advantage。这个 value model 通常与 policy model 一样大，导致 GPU 内存翻倍。
• Value Model 训练不稳定：LLM 生成的 reward 是 sparse 的（只在序列末尾给出），使得 value function 难以学习。
• 计算开销大：同时维护 policy model、reference model、reward model 和 value model 四个大模型。

3.2 GRPO 的核心思想

GRPO 的关键创新是用组内相对比较来替代 value model 进行 advantage 估计。对于每个 prompt，生成一组（group of）回答，然后用组内的 reward 统计量来估计 advantage：

其中 G 是 group size（每个 prompt 生成的回答数量），r_i 是第 i 个回答的 reward。

3.3 GRPO 算法流程

def grpo_step(policy, ref_model, prompts, reward_fn, group_size=16):
    """One step of GRPO training."""
    all_advantages = []
    all_responses = []
    all_old_logprobs = []

    for prompt in prompts:
        # 1. Sample a group of responses
        responses = [policy.generate(prompt) for _ in range(group_size)]

        # 2. Compute rewards for each response
        rewards = [reward_fn(prompt, resp) for resp in responses]
        rewards = torch.tensor(rewards)

        # 3. Compute group-relative advantages (no value model needed!)
        mean_r = rewards.mean()
        std_r = rewards.std() + 1e-8
        advantages = (rewards - mean_r) / std_r

        # 4. Compute log probabilities under current policy
        for resp, adv in zip(responses, advantages):
            logprob = policy.log_prob(prompt, resp)
            all_responses.append((prompt, resp))
            all_advantages.append(adv)
            all_old_logprobs.append(logprob.detach())

    # 5. PPO-style clipped update with KL penalty
    for epoch in range(num_epochs):
        for (prompt, resp), adv, old_lp in zip(
            all_responses, all_advantages, all_old_logprobs
        ):
            new_lp = policy.log_prob(prompt, resp)
            ref_lp = ref_model.log_prob(prompt, resp)

            # Importance ratio
            ratio = torch.exp(new_lp - old_lp)
            clipped_ratio = torch.clamp(ratio, 1 - eps, 1 + eps)

            # Clipped objective
            policy_loss = -torch.min(ratio * adv, clipped_ratio * adv)

            # KL penalty
            kl_loss = beta * (new_lp - ref_lp)

            loss = policy_loss + kl_loss
            loss.backward()
            optimizer.step()

3.4 GRPO 的优势

• 无需 Value Model：节省约 50% 的 GPU 内存，使得在同样硬件上可以训练更大的模型
• 更稳定：避免了 value model 训练不稳定的问题
• 适合 sparse reward：group-relative advantage 不依赖于时间步级别的 reward 估计
• 实现简单：比完整的 PPO 实现简单得多

4. DeepSeek-R1 中的 RL 应用

DeepSeek-R1 是 RLVR 最成功的案例之一，展示了纯 RL 训练如何让模型"自发"发展出强大的推理能力。

4.1 DeepSeek-R1-Zero

DeepSeek-R1-Zero 是一个里程碑式的实验：完全不使用 SFT 数据，直接在 base model 上进行 RL 训练（使用 GRPO），模型自发发展出了 chain-of-thought 推理能力。

关键发现：

• Emergent Chain-of-Thought：模型自主学会了在给出答案前进行长链推理，包括尝试不同方法、自我验证和反思
• "Aha Moment"：在训练过程中观察到模型突然学会重新审视自己的推理过程的时刻
• 推理长度自适应：模型学会了根据问题难度调整推理过程的长度

4.2 DeepSeek-R1 的完整流程

完整的 DeepSeek-R1 在 R1-Zero 基础上增加了更多阶段：

1. 冷启动数据收集：先用少量 long-CoT SFT 数据进行微调，为 RL 提供更好的起点
2. 推理 RL 训练：使用 GRPO 在数学和代码任务上进行 RL 训练，reward 来自自动验证器
3. 拒绝采样 + SFT：用 RL 模型生成大量推理数据，筛选高质量的进行 SFT
4. 全场景 RL：在更广泛的任务上进行第二轮 RL，包括有用性和安全性

4.3 从 DeepSeek-R1 中学到的教训

• RL 可以发现人类没有明确教授的能力：长链推理、自我反思等能力不是通过 SFT 模仿人类示范学到的，而是通过 RL 自发涌现的
• Reward 设计至关重要：好的 reward signal 是 RL 成功的关键。数学和代码的可验证性提供了"完美"的 reward
• SFT + RL 的协同效应：先 SFT 再 RL 通常比单纯 RL 效果更好，但纯 RL 也能达到令人惊讶的水平

5. Process Reward Models vs Outcome Reward Models

在数学推理场景中，reward 的粒度有两种选择：

5.1 Outcome Reward Model (ORM)

ORM 只根据最终答案给出 reward：

• 如果最终答案正确，整个推理过程获得 reward = 1
• 如果最终答案错误，reward = 0
• 优点：标注成本低，验证容易
• 缺点：reward signal 非常 sparse，模型难以知道推理过程中哪一步出了错

5.2 Process Reward Model (PRM)

PRM 对推理过程的每一步都给出 reward：

• 对推理链中的每个 step 判断其正确性
• 提供更细粒度的 reward signal，帮助模型定位错误步骤
• 优点：reward signal 更密集，训练更稳定
• 缺点：需要 step-level 标注，成本极高

5.3 PRM800K 与 Math-Shepherd

OpenAI 的 PRM800K 数据集包含 800K 个 step-level 的标注，用于训练 process reward model。但这种规模的人工标注成本极其高昂。

Math-Shepherd 提出了一种自动生成 process reward 标注的方法：对于每一步推理，通过 Monte Carlo sampling 估计从该步出发最终到达正确答案的概率，作为该步的 process reward。这大幅降低了标注成本。

6. 自动化 Reward 的其他应用

6.1 代码执行验证

代码任务提供了另一种天然的 verifiable reward：

import subprocess
import tempfile

def verify_code(generated_code, test_cases):
    """Verify generated code by running test cases."""
    rewards = []
    for test_input, expected_output in test_cases:
        try:
            # Write code to temp file
            with tempfile.NamedTemporaryFile(suffix='.py', mode='w') as f:
                f.write(generated_code)
                f.write(f"\nprint(solution({test_input}))")
                f.flush()

                # Execute with timeout
                result = subprocess.run(
                    ['python', f.name],
                    capture_output=True, text=True, timeout=10
                )
                actual_output = result.stdout.strip()
                rewards.append(1.0 if actual_output == expected_output else 0.0)
        except (subprocess.TimeoutExpired, Exception):
            rewards.append(0.0)

    return sum(rewards) / len(rewards)  # Fraction of tests passed

代码验证的优势在于测试用例可以涵盖各种边界情况，提供非常可靠的 reward signal。

6.2 事实性验证

事实性验证是另一个重要方向，虽然难度更大：

• 知识库查询：将模型的事实陈述与 Wikipedia 或其他知识库进行对比
• 搜索引擎验证：使用搜索引擎检索相关信息来验证陈述
• NLI (Natural Language Inference) 模型：使用 entailment 模型判断模型输出是否与可信来源一致

FActScore 是一个专门用于评估长文本事实性的 metric，将文本分解为 atomic facts 后逐一验证。

6.3 格式和约束验证

许多实际应用中，模型需要按照特定格式或约束生成输出：

• 生成有效的 JSON / XML 格式
• 遵循特定的字数限制或结构要求
• 生成符合语法规则的 SQL 查询
• 这些约束都可以通过程序自动验证，提供 binary reward

本讲小结

本讲介绍了 RLVR 的概念和实践：

1. RLVR 概念：利用可自动验证的 reward 进行 RL，无需人类标注，可大规模扩展
2. 数学推理 RL：数学答案的可验证性使其成为 RLVR 的最佳场景
3. GRPO 算法：通过 group-relative advantage 估计避免训练 value model，节省内存和计算
4. DeepSeek-R1：证明了纯 RL 可以让模型自发发展出长链推理能力
5. PRM vs ORM：过程奖励提供更细粒度的信号，但标注成本更高
6. 其他 Verifiable Rewards：代码执行、事实性验证、格式约束等

下一讲将讨论 DPO、Expert Iteration 等更多 alignment 方法，以及前沿的 reasoning 和 test-time compute scaling 方向。