RLVR：可验证奖励强化学习的原理与工程实践

强化学习从人类反馈（RLHF） 曾是 align 大模型的标准范式：训练一个奖励模型（Reward Model）学习人类偏好，再用 PPO 优化策略。但 RLHF 存在三个根本问题：奖励模型本身有偏差（reward hacking）、训练成本高（需要大量人类标注）、难以评估推理正确性（偏好不等于对错）。

RLVR（Reinforcement Learning with Verifiable Rewards） 的核心思想是：对于答案可以被自动验证的任务（数学、代码、逻辑推理），直接用确定性验证器（verifier）计算奖励，彻底抛弃学习出来的奖励模型。验证器给出的是客观的、无偏的奖励信号——答案正确得 1 分，错误得 0 分，无需人类判断。

据 Andrej Karpathy 在 2025 年终回顾中指出，RLVR 因其巨大的"能力/美元"收益比，已成为 2025 年 LLM 后训练的默认下一阶段。这一范式转变的关键事件是 2025 年 1 月 DeepSeek-R1 的发布——它用 GRPO 算法 + 规则奖励 在数学和代码推理上达到了 OpenAI o1 的水平，且完全开源。

RLVR 与 RLHF 的本质区别：

RLVR 的理论基础 可以追溯到 Lambert et al. (2024) 的工作，但真正大规模验证其效果的是 DeepSeek 团队。DeepSeekMath（Shao et al., 2024）首次提出 GRPO 算法并在数学推理上取得显著提升；DeepSeek-R1（Guo et al., 2025）则将 RLVR 推向主流，证明了纯 RL 训练可以激发出复杂的推理行为（如自我反思、逐步推导、回溯纠错）。

Group Relative Policy Optimization（GRPO） 是 DeepSeek 团队在 DeepSeekMath 论文中提出的 RL 算法（Shao et al., 2024），也是 DeepSeek-R1 的核心训练算法。它的设计目标是：在保持 PPO 训练稳定性的同时，彻底去掉 Critic（价值）网络，大幅降低显存和计算开销。

传统 PPO 需要四个网络：策略网络（Actor）、参考网络（Reference）、奖励模型（Reward）、价值网络（Critic）。对于 671B 参数的 DeepSeek-V3，Critic 网络的显存开销几乎翻倍。GRPO 的核心创新是用组内相对排名替代绝对价值估计——对每个问题采样一组回答，用组内奖励的相对排序来计算优势函数（advantage），完全不需要 Critic。

GRPO 的算法流程：

1. 组采样（Group Sampling）： 对每个问题 q_i，从当前策略 π_θ 采样 G 个回答 {o_1, o_2, ..., o_G}（通常 G=16）
2. 验证奖励： 用确定性验证器计算每个回答的奖励 {r_1, r_2, ..., r_G}
3. 组内标准化： 计算组内奖励的均值 μ 和标准差 σ，对每个奖励做标准化：A_i = (r_i - μ) / σ
4. 截断更新： 使用 PPO 风格的截断目标函数更新策略，加上 KL 散度惩罚

GRPO 的目标函数：

GRPO 使用如下优化目标：J(θ) = E[1/G Σ_i min(ρ_i · A_i, clip(ρ_i, 1-ε, 1+ε) · A_i) - β · D_KL(π_θ || π_ref)]。其中 ρ_i = π_θ(o_i|q) / π_ref(o_i|q) 是重要性采样比率，A_i 是组内标准化的优势，β 是 KL 惩罚系数。

为什么 GRPO 有效？ 组内相对比较天然消除了问题难度差异——难题的正确答案和错误答案在同一组内对比，简单题亦然。这相当于一种 动态课程学习（curriculum learning），模型在每个 batch 中自动从"相对困难"的样本中学习。

DeepSeek-R1 的训练流程：

DeepSeek-R1 采用多阶段训练策略：(1) 冷启动 SFT：用少量高质量长思维链（CoT）数据微调基础模型；(2) GRPO 推理训练：用规则奖励（准确率 + 格式）进行 RL 训练；(3) 拒绝采样 SFT：对模型输出做拒绝采样，收集更广泛的监督数据；(4) 最终 GRPO：在推理+通用场景上做最终轮 RL 训练，兼顾准确性、安全性和有用性。

DeepSeek-R1-Zero 则更激进——完全跳过 SFT 阶段，直接在基础模型上做纯 RL 训练。结果发现了令人惊讶的 涌现行为（emergent behaviors）：模型自发学会了自我反思（"让我重新检查"）、回溯纠错（"这个步骤不对，让我换一种方法"）和长链推理。但也出现了可读性差、语言混杂等问题，这解释了为什么正式版 R1 加入了冷启动 SFT。

# GRPO 算法伪代码实现

import torch
import torch.nn.functional as F

def grpo_update(
    policy_model,      # π_θ: 当前策略模型
    ref_model,         # π_ref: 参考模型（冻结）
    questions,         # 一批问题 {q_1, ..., q_B}
    verifier,          # 确定性验证器
    group_size=16,     # G: 每个问题的采样数
    epsilon=0.2,       # PPO 截断范围
    beta_kl=0.01,      # KL 惩罚系数
    lr=1e-6,
):
    """
    GRPO: 对每个问题采样一组回答，用组内相对排名计算优势
    """
    optimizer = torch.optim.Adam(policy_model.parameters(), lr=lr)

    for q in questions:
        # Step 1: 组采样 - 从当前策略生成 G 个回答
        outputs = []
        for _ in range(group_size):
            o = policy_model.generate(q, max_length=32768, temperature=1.0)
            outputs.append(o)

        # Step 2: 验证奖励 - 确定性验证器打分
        rewards = torch.tensor([verifier(q, o) for o in outputs])
        # 奖励通常为 0/1（正确/错误），也可以是格式奖励等

        # Step 3: 组内标准化（计算优势）
        mean_r = rewards.mean()
        std_r = rewards.std() + 1e-8
        advantages = (rewards - mean_r) / std_r  # A_i = (r_i - μ) / σ

        # Step 4: 计算重要性采样比率和损失
        log_probs = []
        ref_log_probs = []
        for o in outputs:
            log_probs.append(policy_model.log_prob(q, o))
            with torch.no_grad():
                ref_log_probs.append(ref_model.log_prob(q, o))

        log_probs = torch.stack(log_probs)
        ref_log_probs = torch.stack(ref_log_probs)
        ratios = torch.exp(log_probs - ref_log_probs)  # ρ_i

        # PPO 风格截断目标
        surr1 = ratios * advantages
        surr2 = torch.clamp(ratios, 1 - epsilon, 1 + epsilon) * advantages
        policy_loss = -torch.min(surr1, surr2).mean()

        # KL 散度惩罚（防止偏离参考模型太远）
        kl_loss = beta_kl * (ref_log_probs - log_probs).mean()

        total_loss = policy_loss + kl_loss

        # Step 5: 反向传播更新
        optimizer.zero_grad()
        total_loss.backward()
        optimizer.step()

    return total_loss.item()

RLVR 的核心组件是验证器（Verifier）——它决定了奖励信号的质量。与 RLHF 中需要精心设计奖励模型不同，RLVR 的验证器是确定性的、规则驱动的。根据任务类型不同，验证器的设计差异很大。

二值规则奖励（Binary Rule-based Reward） 是最常见的形式：数学题用数值匹配（答案是否等于标准答案），代码题用单元测试（所有测试用例是否通过），格式奖励检查输出是否符合要求的模板（如把推理过程放在特定标签内）。DeepSeek-R1 的奖励设计就包含两类：准确率奖励（最终答案是否正确）和格式奖励（是否将思维过程放在 标签内），后者用于引导模型形成可读的推理链。

概率/软奖励（Soft/Probabilistic Reward） 用于无法精确匹配的场景。例如自由文本答案，可以用生成式验证器（Generative Verifier）输出 [0,1] 区间的部分正确分数。Su et al. (2025) 提出用概率奖励处理非结构化答案，这在开放域 QA 中尤为重要。

混合验证（Hybrid Verification） 结合规则检查和模型评估。VerIF（Peng et al., 2025）框架就采用了代码执行验证 + LLM 语义评估的组合方式。这在 Agent 任务中很常见：功能正确性用测试用例验证，代码风格、可读性等则由评估模型打分。

内在概率奖励（Intrinsic Probability Reward） 是一种无需外部验证器的方法。RLPR（Yu et al., 2025）提出用 LLM 自身对参考答案的似然概率作为奖励信号，完全不需要外部验证器，但效果依赖于模型本身的校准质量。

奖励黑客（Reward Hacking） 是 RLVR 的重要风险。2025 年 6 月的一项研究发现，Qwen2.5-Math-7B 在随机奖励下也能在 MATH-500 上提升 21.4%，接近真实奖励的 29.1% 提升。这暗示部分"RLVR 收益"可能来自训练过程本身（如数据分布变化），而非验证器的信号质量。不过后续分析表明，这一现象在特定模型家族（Qwen2.5-Math）中存在数据污染问题，在其他模型上不易复现。

工程实现要点： 验证器需要高吞吐量——DeepSeek-R1 训练中每步生成 8192 个输出，验证器必须在 GPU 集群上并行运行。实践中常用方案包括：数学验证用 SymPy 做符号计算 + 数值比较；代码验证用沙箱执行（如 Docker 容器运行测试用例）；格式验证用正则表达式。验证器的假阴性率（把正确答案判错）必须极低，否则会严重损害训练效果。

# RLVR 验证器的工程实现示例

import re
import subprocess
from typing import Optional

class MathVerifier:
    """数学答案验证器：提取最终答案并与标准答案比较"""

    def verify(self, response: str, ground_truth: str) -> float:
        # 从 \boxed{} 或 "答案是" 后提取答案
        boxed = re.search(r'\\boxed\{([^}]+)\}', response)
        if boxed:
            predicted = boxed.group(1).strip()
        else:
            # 回退：取最后一行的数字
            lines = response.strip().split('\n')
            predicted = lines[-1].strip()

        # 数值比较（处理分数、小数等）
        try:
            return 1.0 if self._normalize(predicted) == self._normalize(ground_truth) else 0.0
        except:
            return 0.0

    def _normalize(self, s: str) -> str:
        """标准化数值表示：1/2 = 0.5, 去掉空格等"""
        s = s.replace(' ', '').replace(',', '')
        # 处理分数
        if '/' in s:
            num, den = s.split('/')
            s = str(float(num) / float(den))
        return s


class CodeVerifier:
    """代码验证器：在沙箱中执行测试用例"""

    def verify(self, code: str, test_cases: list[dict]) -> float:
        passed = 0
        total = len(test_cases)
        for tc in test_cases:
            try:
                result = self._run_code(code, tc['input'], timeout=5)
                if result == tc['expected_output']:
                    passed += 1
            except (TimeoutError, RuntimeError):
                pass
        return passed / total

    def _run_code(self, code: str, input_data: str, timeout: int) -> str:
        """在隔离沙箱中执行代码"""
        result = subprocess.run(
            ['python3', '-c', code],
            input=input_data, capture_output=True, text=True,
            timeout=timeout
        )
        return result.stdout.strip()


class FormatReward:
    """格式奖励：检查推理是否在指定标签内"""

    def __init__(self, open_tag="", close_tag=""):
        self.open_tag = open_tag
        self.close_tag = close_tag

    def compute(self, response: str) -> float:
        has_open = self.open_tag in response
        has_close = self.close_tag in response
        # 检查标签顺序正确
        if has_open and has_close:
            open_idx = response.index(self.open_tag)
            close_idx = response.index(self.close_tag)
            if open_idx < close_idx and close_idx - open_idx > 10:
                return 1.0
        return 0.0

DeepSeek-R1（2025 年 1 月 20 日发布）是 RLVR 的里程碑事件。它是第一个用开源模型达到 OpenAI o1 推理水平的模型，让全世界看到了 RLVR 的巨大潜力。R1 基于 DeepSeek-V3（671B 参数 MoE 模型），使用 GRPO + 规则奖励进行训练。

DeepSeek-R1 的关键数据： 在 AIME 2024 数学竞赛上，R1 的 pass@1 准确率达到 79.8%（cons@64 达 86.7%），而 GPT-4o 仅 13.4%。在 CodeForces 编程竞赛中，R1 的 Elo 为 2029，超过 87% 的人类参赛者。在 GPQA Diamond 科学推理上，R1 达到 71.5%（pass@1），显著超越 GPT-4o 的 41.5%。

DeepSeek-R1-Zero 的涌现行为 是 RLVR 最引人入胜的发现。这个完全不做 SFT、纯 RL 训练的模型，自发学会了：(1) 逐步推理（Chain-of-Thought）：将复杂问题分解为中间步骤；(2) 自我反思（Self-Reflection）：在推理过程中说"让我重新检查这一步"；(3) 回溯纠错（Backtracking）：发现错误路径后主动换一种方法；(4) 策略探索：尝试不同的解题策略并评估效果。这些行为从未在训练数据中被显式标注——它们是 RL 优化的涌现结果。

OpenAI o 系列 是 RLVR 的另一条线索。o1（2024 年 9 月）是第一个"推理模型"，但 OpenAI 未公开技术细节。o3（2025 年 4 月）进一步提升了推理能力，在 AIME 2024 上 pass@1 达到 83.3%（cons@64），CodeForces Elo 达 2195。根据 OpenAI 在 o3 直播中透露的信息，o3 使用了 10 倍于 o1 的训练计算量。

模型对比（2025-2026 年主要推理模型）：

关键洞察： Karpathy 指出，RLVR 的核心价值在于"测试时计算扩展"（test-time compute scaling）——模型在推理时花更多 token 思考，可以显著提升难题的准确率。这意味着计算预算从预训练向推理阶段转移，是 LLM 发展的重要趋势。据估计，RLVR 提供了当前最高的"能力/美元"回报率。

RLVR 的工程挑战 主要集中在三个方面：训练效率、验证器设计和奖励稀疏性。

训练效率方面，RLVR 的计算开销巨大。DeepSeek-R1 的训练使用了数千块 GPU，每步生成 8192 个输出（32 问题 × 16 采样 × 16 步累积），每个输出最长 32768 token。这意味着每步需要处理约 2.68 亿 token。工程上的优化手段包括：(1) Rollout 与训练流水线化：生成和更新交替进行，避免 GPU 空闲；(2) 混合专家并行：利用 MoE 架构减少激活参数；(3) FlashAttention 和序列并行：处理超长推理链。

验证器设计 是 RLVR 的核心瓶颈。对于数学和代码，验证器相对成熟（符号计算、沙箱执行）。但对于更广泛的推理任务（科学推理、逻辑推理、多步规划），可靠的自动验证器仍然稀缺。2026 年的前沿研究方向包括：

(1) RLVRR（Reinforcement Learning with Verifiable Reference-based Rewards）：被 ICLR 2026 接收。核心思想是从高质量参考输出中提取有序的可验证信号链（reward chain），将单一的"最终答案正确/错误"扩展为多步骤的过程验证。这使得 RLVR 可以应用于报告撰写、邮件回复等开放式任务。

(2) K2V（Knowledge-to-Verification）：将 RLVR 扩展到知识密集型领域。通过从文本构建知识图谱，将知识验证建模为图谱补全任务，自动生成大规模可验证的 QA 数据。

(3) CoT-Pass@K：新评估指标，不仅检查最终答案是否正确，还验证推理链的每一步是否合理。这解决了传统 Pass@K 忽略推理质量的问题。

(4) DAPO（Dynamic Advantage Policy Optimization）：针对 GRPO 的工程改进，包括动态采样（移除组内奖励平坦的样本）、per-token loss（替代 per-response loss）和双 clip 参数（正负优势用不同截断范围）。

奖励稀疏性 是 RLVR 的固有问题。二值奖励（正确/错误）导致信号极其稀疏——对于难题，模型可能采样 16 个回答全部错误，优势函数全为 0，无法学习。解决方案包括：(1) 课程学习：从简单题开始，逐步增加难度；(2) 过程奖励：不仅验证最终答案，还验证中间步骤；(3) 内在奖励：用模型自身的概率作为辅助奖励信号。

RLVR 是否真正教会模型"思考"？ 这是当前最核心的争论。清华团队发现 RLVR 主要提升采样效率（压缩 Pass@1 和 Pass@K 的差距），而非扩展能力边界。具体数据：RLVR 前 Pass@1=40%、Pass@8=75%（差距 35pp）；RLVR 后 Pass@1=65%、Pass@8=77%（差距 12pp）。71% 的差距被压缩，但天花板仅提升 2pp。不过，跨域迁移实验（数学 RL 训练后代码能力提升）和 CoT-Pass@K 指标下的持续改进，提供了"真正更聪明"的证据。

# DAPO 的关键改进：动态采样 + 双 clip

def dapo_loss(
    log_ratios,        # log(π_θ / π_ref) for each output
    advantages,        # 组内标准化的优势
    epsilon_low=0.2,   # 负优势 clip 范围
    epsilon_high=0.2,  # 正优势 clip 范围（可以更大以提升好样本）
):
    """
    DAPO 改进：正负优势使用不同的 clip 范围
    - 正优势（好回答）：允许更大的 ratio 提升
    - 负优势（坏回答）：更保守的 clip
    """
    ratios = torch.exp(log_ratios)

    # 双 clip：对正负优势分别处理
    clip_low = torch.clamp(ratios, 1 - epsilon_low, 1 + epsilon_low)
    clip_high = torch.clamp(ratios, 1 - epsilon_high, 1 + epsilon_high)

    # 正优势用宽松 clip，负优势用严格 clip
    surr = torch.where(
        advantages > 0,
        torch.min(ratios * advantages, clip_high * advantages),
        torch.max(ratios * advantages, clip_low * advantages)
    )
    return -surr.mean()


def dynamic_sampling(rewards, group_size, threshold=0.01):
    """
    动态采样：移除组内奖励全为 0 或全为 1 的问题
    这些问题无法提供有效的梯度信号（优势全相同）
    """
    valid_mask = []
    for i in range(0, len(rewards), group_size):
        group = rewards[i:i + group_size]
        std = group.std()
        # 标准差太小说明组内没有区分度，跳过
        valid_mask.append(std > threshold)
    return torch.tensor(valid_mask)

若你计划在自有基座模型上复现 RLVR，建议按以下顺序推进，避免「一上来就全量 GRPO」导致训练不稳定。整条链路通常需要算法、推理基础设施与数据工程三方协作，单点优化很难见效，务必留足联调时间。

阶段 0：验证器先行。在接入任何 RL 之前，用离线数据跑通验证器：随机采样 1000 条模型输出，人工抽检验证器的假阴性率（正确答案被判错）和假阳性率。假阴性率超过 1% 会严重伤害训练；假阳性率过高则奖励信号噪声大。数学任务优先用 SymPy + 数值容差；代码任务用 Docker 沙箱 + 超时熔断。记录每条误判样本，迭代规则直至抽检通过。

阶段 1：小模型冒烟（7B）。在 7B 模型上用 1K-5K 道简单题做 GRPO，确认 loss 下降、奖励曲线上升、输出格式稳定。此阶段重点观察：组内奖励是否长期平坦（全 0 或全 1）、KL 是否爆炸、是否出现语言混杂。建议 G=8、max_length=8192，先不追求榜单分数；跑满 200-500 步无崩溃再放大。

阶段 2：扩展数据与课程。将题目按难度分层，从 MATH level 1-2 逐步过渡到 AIME 级别。动态采样（DAPO）在此阶段启用：过滤组内标准差过小的 batch，避免无效梯度。格式奖励权重建议从 0.2 起步，准确率奖励 1.0；格式权重过高会牺牲推理深度，过低则输出难以解析。

阶段 3：规模化与对齐。模型规模放大后，同步升级 rollout 并行度与参考模型更新频率（DeepSeek-R1 约每 400 步更新 π_ref）。最终轮可叠加轻量 RLHF 或安全过滤器，避免推理能力提升后以牺牲对齐为代价。若资源有限，可先用 LoRA/QLoRA 在 32B 上验证全链路，再决定是否全参训练。

可观测性指标：除 pass@1 外，务必记录平均生成长度、验证器通过率、组内奖励标准差、KL 散度、以及「无效 batch 占比」。这些工程指标比单一 benchmark 更能预警训练崩溃。

开源工具链：VERL、OpenRLHF、TRL 均已支持 GRPO/DAPO 类训练循环；数学验证可对接 Hendrycks MATH 官方评测脚本，代码验证可参考 LiveCodeBench 的沙箱接口。选型时优先看验证器插件是否与你目标数据集同构，而非框架本身的 star 数。团队内建议维护一份「验证器单元测试集」，每次改规则都回归跑一遍，防止线上奖励分布静默漂移。