GRPO-VPS：可验证过程监督增强的组相对策略优化

概述

GRPO-VPS (Group Relative Policy Optimization with Verifiable Process Supervision) 是一种无需辅助模型的过程监督方法，通过追踪模型对正确答案的信念变化来实现细粒度信用分配。

核心创新

自适应熵基分割：在不确定性高的位置划分推理轨迹
段级进度估计：利用模型自身概率计算每段的贡献度
混合优势函数：结合轨迹级结果奖励与段级过程信号

1. 问题背景

1.1 标准GRPO的局限性

原始GRPO存在两个关键问题：

无差别信用分配：单一轨迹级奖励被均匀传播到所有中间token
过度思考：模型可能强化虚假推理步骤或惩罚有希望的中间逻辑

1.2 过程监督 vs 结果监督

方面	结果监督	过程监督
反馈时机	轨迹末端	推理全程
粒度	单一二值奖励	每步评估
信用分配	无差别	精确
可解释性	低	高

2. GRPO-VPS核心算法

2.1 自适应熵基分割

使用token级熵在推理轨迹中划分边界：

U = {t | e_t ≥ τ}

其中：

$e_{t}$ = 位置t的token级熵
$τ$ = 自适应阈值（基于分位数）
边界放置在高不确定性位置（“推理junction”）

2.2 段级进度估计

对于每个段边界，计算置信度分数：

C (z_{\leq k}) = π_{θ} (y^{*} ∣ x, z_{\leq k})

其中：

$x$ = 输入问题
$y^{*}$ = 目标答案
$z_{\leq k}$ = 到段k的部分推理轨迹

段进度分数（核心创新）：

Δ C_{k} = C (z_{\leq k}) - C (z_{\leq k - 1}) = π_{θ} (y^{*} ∣ x, z_{\leq k}) - π_{θ} (y^{*} ∣ x, z_{\leq k - 1})

$Δ C_{k} \in [- 1, 1]$ 反映每段对正确答案信念的改善（正）或恶化（负）。

2.3 混合优势计算

最终混合优势融合轨迹级和段级信号：

\tilde{A}_{k} = A_{i} + α \cdot Δ C_{k}

其中：

$A_{i} = r_{i} - \frac{1}{G} \sum_{j = 1}^{G} r_{j}$ = 组相对结果优势
$α$ = 权重因子（经验最优值1.2）

2.4 算法流程

对于每个问题x（目标答案y*）：
  1. 生成完整轨迹 o ~ π_θ(·|x)
  2. 计算token熵 e_t
  3. 使用自适应熵截断点分割 o = (z_1, ..., z_m, y)
  4. 计算初始置信度 C_0 = π_θ(y* | x)
  5. 对于 k = 1 到 m：
       C_k = π_θ(y* | x, z_≤k)
       ΔC_k = C_k - C_{k-1}
  6. 使用结果+过程信号计算混合优势 Ã_k
  7. 通过梯度下降更新策略

3. 可验证过程奖励的作用

3.1 为什么过程监督重要

过程监督提供与模型内部决策流对齐的密集、可解释的反馈。

3.2 可验证 vs 学习的过程奖励

传统PRM（过程奖励模型）：

需要训练辅助模型
容易受到奖励黑客攻击
增加系统复杂度

GRPO-VPS方法（可验证过程监督）：

使用真值答案计算置信度分数
不需要辅助模型
从模型自身的信念动态中导出信号
每个轨迹一次前向传播（高效率）

3.3 关键洞察

“中间推理步骤的贡献可以通过在相应断点处附加参考答案后模型置信度的增量来探查。“

4. 数学推理提升

4.1 数学基准测试性能

模型	指标	GRPO	GRPO-VPS	提升
Qwen2.5-Math-1.5B	Pass@1	41.0%	43.6%	+2.6 pts
	平均Token数	3772	3355	-11.0%
Qwen2.5-Math-7B	Pass@1	51.2%	52.3%	+1.1 pts
	平均Token数	3620	3121	-13.7%
Gemma-2-2B-it	Pass@1	11.1%	11.7%	+0.6 pts
	平均Token数	3115	2399	-23.0%

4.2 基准测试详细结果

Qwen2.5-Math-1.5B:

AMC23: 46.9% → 55.0% (+8.1 pts)
AIME24: 18.3% → 15.0% (-3.3 pts)
MATH: 68.8% → 72.2% (+3.4 pts)
OlympiadBench: 30.0% → 32.1% (+2.1 pts)

4.3 泛化到非数学任务

基准	Base	GRPO	GRPO-VPS
GPQA	17.8%	36.2%	37.8%
MMLU-Pro	49.7%	52.7%	54.4%
TheoremQA	24.5%	34.9%	37.3%
WebInstruct	54.4%	70.3%	73.9%

5. 与标准GRPO的对比

5.1 架构差异

方面	GRPO	GRPO-VPS
优势估计	仅轨迹级	混合（轨迹+段）
信用分配	对所有token均匀	基于 $Δ C_{k}$ 的每段
反馈密度	稀疏（每轨迹1个）	密集（每轨迹M个）
辅助模型	无	无
Rollouts	否	否

5.2 GRPO-VPS的优势

更好的样本效率：密集反馈实现更有针对性的策略更新
减少过度思考：压缩冗余推理步骤
可解释： $Δ C_{k}$ 直接反映步骤质量
可扩展：无需辅助模型或rollouts
鲁棒：跨不同模型家族（Qwen, Gemma）有效

6. 过程 vs 结果监督：理论视角

6.1 关键理论发现

主要定理：

在标准数据覆盖假设下，通过结果监督的强化学习在统计难度上不比通过过程监督差（以时间范围的多项式因子为上界）。

6.2 优势函数作为最优过程奖励

任何策略的优势函数都可以作为最优过程奖励模型。

这在结果监督和过程监督之间建立了直接联系。

7. 实现细节

7.1 段粒度

最优权衡：每段约4个点

更细粒度（n=2）：更精确但计算成本高
更粗粒度（n=8）：更快但精度降低

7.2 α敏感性分析

α值	准确率
0.0（无过程）	68.8%
0.8	71.7%
1.0	72.0%
1.2	72.2%
1.4	71.9%
1.6	69.7%

7.3 代码实现

#include <bits/stdc++.h>
using namespace std;
 
struct Trajectory {
    vector<int> tokens;
    vector<double> token_entropies;
    double reward;
};
 
struct Segment {
    int start_idx;
    int end_idx;
    double delta_confidence;  // ΔC_k
    double hybrid_advantage;  // Ã_k
};
 
vector<Segment> adaptive_entropy_segmentation(
    const Trajectory& traj,
    double entropy_percentile = 0.75
) {
    vector<Segment> segments;
    
    // 计算熵阈值
    vector<double> sorted_ent = traj.token_entropies;
    sort(sorted_ent.begin(), sorted_ent.end());
    double tau = sorted_ent[int(sorted_ent.size() * entropy_percentile)];
    
    // 找到高熵位置作为分割点
    vector<int> cut_points = {0};
    for (int i = 0; i < traj.tokens.size(); i++) {
        if (traj.token_entropies[i] >= tau) {
            cut_points.push_back(i);
        }
    }
    cut_points.push_back(traj.tokens.size());
    
    // 创建段
    for (int i = 0; i < cut_points.size() - 1; i++) {
        Segment seg;
        seg.start_idx = cut_points[i];
        seg.end_idx = cut_points[i + 1];
        segments.push_back(seg);
    }
    
    return segments;
}
 
double compute_segment_confidence(
    Policy& policy,
    const vector<int>& prompt_tokens,
    const vector<int>& partial_tokens,
    int target_answer_token
) {
    // 计算模型对目标答案的条件概率
    vector<int> input = prompt_tokens;
    input.insert(input.end(), partial_tokens.begin(), partial_tokens.end());
    
    double prob = policy.forward(input);
    return prob[target_answer_token];
}
 
vector<double> compute_delta_confidence(
    Policy& policy,
    const vector<int>& prompt_tokens,
    const vector<Segment>& segments,
    int target_answer_token
) {
    vector<double> delta_confidences;
    double prev_conf = compute_segment_confidence(
        policy, prompt_tokens, {}, target_answer_token
    );
    
    for (const auto& seg : segments) {
        vector<int> segment_tokens(
            prompt_tokens.begin() + seg.start_idx,
            prompt_tokens.begin() + seg.end_idx
        );
        
        double curr_conf = compute_segment_confidence(
            policy, prompt_tokens, segment_tokens, target_answer_token
        );
        
        double delta = curr_conf - prev_conf;
        delta_confidences.push_back(delta);
        prev_conf = curr_conf;
    }
    
    return delta_confidences;
}
 
double grpo_vps_loss(
    Policy& policy,
    const vector<Trajectory>& trajectories,
    const vector<double>& group_rewards,
    double alpha = 1.2
) {
    // 1. 计算组统计量
    double mean_reward = accumulate(group_rewards.begin(), 
                                    group_rewards.end(), 0.0) / group_rewards.size();
    double std_reward = 0.0;
    for (double r : group_rewards) {
        std_reward += (r - mean_reward) * (r - mean_reward);
    }
    std_reward = sqrt(std_reward / group_rewards.size()) + 1e-8;
    
    // 2. 计算组相对优势
    vector<double> advantages;
    for (double r : group_rewards) {
        advantages.push_back((r - mean_reward) / std_reward);
    }
    
    double total_loss = 0.0;
    
    // 3. 对每个轨迹计算混合优势
    for (int i = 0; i < trajectories.size(); i++) {
        const auto& traj = trajectories[i];
        
        // 自适应分割
        auto segments = adaptive_entropy_segmentation(traj);
        
        // 计算每段的ΔC_k
        auto delta_confidences = compute_delta_confidence(
            policy, traj.prompt, segments, traj.target_answer
        );
        
        // 更新段的ΔC
        for (int k = 0; k < segments.size(); k++) {
            segments[k].delta_confidence = delta_confidences[k];
            // 混合优势
            segments[k].hybrid_advantage = advantages[i] + alpha * delta_confidences[k];
        }
        
        // 计算策略梯度
        for (const auto& seg : segments) {
            double ratio = policy.log_prob(seg) / old_policy.log_prob(seg);
            double clipped = clamp(ratio, 1 - epsilon, 1 + epsilon);
            
            double loss = -min(
                ratio * seg.hybrid_advantage,
                clipped * seg.hybrid_advantage
            );
            total_loss += loss;
        }
    }
    
    return total_loss / trajectories.size();
}

Metaphor

探索