《AI Agent 技术原理与架构·决策、记忆与学习》12.3 Agentic RL:可验证奖励、GRPO 与探索

Agent 的 RL 与棋盘游戏 RL 的关键区别是奖励可验证:只认结果,不认“看起来合理”。本节用二元奖励演示 GRPO 组内相对优势与退化组问题,用精确公式量化有效信号随组大小与难度如何变化,并用 pass@k 与多档奖励说明探索预算和梯度信号的关系。

以下数字为教学示例,不构成对任何真实系统或供应商的承诺。

SFT 让 Agent 照着演示做,偏好对齐让 Agent 学"哪个更受欢迎",而 Agentic RL 教 Agent 的是**“做没做对”**——用一个可验证的检查器,对每条轨迹给一个确定的分数。这一节讲它的两个核心信号问题:奖励怎么定义、梯度怎么来。奖励上,“只认结果、不认看起来合理"是可验证奖励的定义;梯度上,GRPO 用组内相对优势替代全局基线,但随之而来的是退化组问题。

可验证奖励:只认结果

先看奖励函数本身。Agentic RL 的奖励是可验证的:代码跑没跑过测试、查询命没命中引用、任务有没有达成既定目标。它和偏好对齐的最大区别是——它不认中间文本。本节的实验模块把奖励函数写成 binary_reward(correct) = 1.0 if correct else 0.0:只有结果对才得 1,中间文本不在计分范围内。

“看起来合理"是 RLHF 时代的评价方式:人类标注者觉得这条轨迹逻辑通顺、语气得体,就给高分。可验证奖励没有这个通道——中间写得多漂亮不算数,只有结果对才得 1。这个定义的直接后果是:Agent 不再有动机写"漂亮的错误回答”,因为它不能兑换奖励;它只优化结果。

代价也在这里:可验证奖励要求有一个客观检查器。能自动化检查的任务(代码测试、确定性检索)才谈得上 Agentic RL;只有人工判断的任务,检查器本身是人类,Agentic RL 就退化成偏好对齐。

组内相对优势:GRPO 与 LOO

有了奖励,怎么变成梯度?GRPO 的做法是组内标准化:一次采样 G 条 rollout,用这组样本的均值做基线,把每条奖励减去均值再除以标准差。实验用 [1.0, 0.0, 0.0, 0.0] 这一组奖励看两种优势:

rewards: [1.0, 0.0, 0.0, 0.0]
grpo adv: [1.732, -0.577, -0.577, -0.577]
loo adv: [1.0, -0.333, -0.333, -0.333]

GRPO 的优势:成功的那条得 +1.732(均值 0.25,标准差 0.433,加 epsilon 后归一),失败的得 -0.577。组内优势是相对的:一组 rollout 里只要存在差异,成功者被抬、失败者被压,梯度方向自动指向"多采样成功的行为”。

LOO(leave-one-out)是另一个基线:用其余样本的均值做基线,不除以标准差。成功者 +1.0,失败者 -0.333。它不放大组内方差,梯度更温和。选择 GRPO 还是 LOO 是超参决策,本节不偏袒,但要看清两者的共同点——它们都建立在"组内存在差异"之上。

退化组:组内无差异时没有梯度

组内相对优势的软肋在退化组:一组 rollout 全部成功、或全部失败时,均值等于每条奖励,标准化后优势全是 0——这组样本不提供任何梯度。GRPO 的实现里,标准差小于 epsilon 时直接返回全 0。

退化组的概率是精确可算的。对成功率为 p 的二元奖励:

$$P(\text{退化}) = p^G + (1-p)^G$$

实验直接打印这个数字:G=4、p=0.5 时,退化概率是 0.125——每 8 组就有 1 组白采样。这就是"二元奖励 + 固定组大小"的固有成本。

有效信号怎么变

下面的实验扫组大小 G 与成功率 p,输出"组内存在差异、能产生非零优势"的概率 1 - p^G - (1-p)^G:

# file: agp_lab/agentic_rl.py | write
# tier: 3
# verify: python3 -m unittest tests.test_agentic_rl
"""Agentic RL 的信号量:可验证奖励、组内相对优势与探索预算。

一组 G 条 rollout 都成功或都失败时,组内相对优势全为 0,这条样本
不提供梯度。对成功率为 p 的二元奖励,退化概率是 p^G + (1-p)^G。
实验用精确公式展示:任务越简单或越难、组越小或越大,有效信号如何
变化;再用 pass@k 说明探索预算与成功率的关系。
"""
from __future__ import annotations

import math

DEFAULT_EPS = 1e-9


def binary_reward(correct: bool) -> float:
    """可验证奖励只认结果,不认“看起来合理”的中间文本。"""
    return 1.0 if correct else 0.0


def group_relative_advantages(rewards: list[float], eps: float = DEFAULT_EPS) -> list[float]:
    """GRPO 的组内标准化优势;组内无方差时返回全 0。"""
    if not rewards:
        raise ValueError("组不能为空")
    mean = sum(rewards) / len(rewards)
    variance = sum((reward - mean) ** 2 for reward in rewards) / len(rewards)
    std = math.sqrt(variance)
    if std < eps:
        return [0.0 for _ in rewards]
    return [(reward - mean) / (std + eps) for reward in rewards]


def leave_one_out_advantages(rewards: list[float]) -> list[float]:
    """用其余样本的均值做基线,不除以标准差;同样在退化组上返回 0。"""
    if not rewards:
        raise ValueError("组不能为空")
    count = len(rewards)
    if count == 1:
        return [0.0]
    total = sum(rewards)
    return [reward - (total - reward) / (count - 1) for reward in rewards]


def degenerate_probability(pass_rate: float, group_size: int) -> float:
    """二元奖励下,整组结果完全相同的概率:p^G + (1-p)^G。"""
    if not 0.0 <= pass_rate <= 1.0:
        raise ValueError("pass_rate 必须在 [0, 1] 内")
    if group_size < 1:
        raise ValueError("group_size 必须大于 0")
    return pass_rate ** group_size + (1.0 - pass_rate) ** group_size


def informative_probability(pass_rate: float, group_size: int) -> float:
    """组内存在差异、能产生非零优势的概率。"""
    return 1.0 - degenerate_probability(pass_rate, group_size)


def graded_informative_probability(probs: tuple[float, ...], group_size: int) -> float:
    """多档奖励下,组内至少出现两种取值的概率。"""
    if not probs:
        raise ValueError("奖励分布不能为空")
    if abs(sum(probs) - 1.0) > 1e-9:
        raise ValueError("奖励分布之和必须为 1")
    if any(prob < 0.0 for prob in probs):
        raise ValueError("奖励概率不能为负")
    if group_size < 1:
        raise ValueError("group_size 必须大于 0")
    return 1.0 - sum(prob ** group_size for prob in probs)


def pass_at_k(pass_rate: float, k: int) -> float:
    """至少一次成功的概率:1 - (1-p)^k。"""
    if not 0.0 <= pass_rate <= 1.0:
        raise ValueError("pass_rate 必须在 [0, 1] 内")
    if k < 1:
        raise ValueError("k 必须大于 0")
    return 1.0 - (1.0 - pass_rate) ** k


def _print_group_table() -> None:
    sizes = (1, 2, 4, 8, 16, 32)
    rates = (0.50, 0.80, 0.95)
    print("informative groups: 1 - p^G - (1-p)^G")
    print(f"{'G':>4}" + "".join(f"{f'p={rate:.2f}':>12}" for rate in rates))
    for size in sizes:
        print(
            f"{size:>4}"
            + "".join(f"{informative_probability(rate, size):>12.4f}" for rate in rates)
        )


def _print_pass_table() -> None:
    print()
    print("pass@k: 1 - (1-p)^k")
    print(f"{'k':>4}" + "".join(f"{f'p={rate:.2f}':>12}" for rate in (0.50, 0.80, 0.95)))
    for k in (1, 4, 8):
        print(
            f"{k:>4}"
            + "".join(f"{pass_at_k(rate, k):>12.4f}" for rate in (0.50, 0.80, 0.95))
        )


def _print_graded() -> None:
    print()
    print("graded reward, G=8")
    for name, probs in (
        ("binary", (0.70, 0.30)),
        ("three-level", (0.60, 0.25, 0.15)),
        ("five-level", (0.40, 0.25, 0.20, 0.10, 0.05)),
    ):
        print(f"{name:<12}{graded_informative_probability(probs, 8):>10.4f}")


if __name__ == "__main__":
    rewards = [1.0, 0.0, 0.0, 0.0]
    print("rewards:", rewards)
    print("grpo adv:", [round(value, 3) for value in group_relative_advantages(rewards)])
    print("loo adv:", [round(value, 3) for value in leave_one_out_advantages(rewards)])
    print("degenerate:", round(degenerate_probability(0.5, 4), 4))
    print()
    _print_group_table()
    _print_pass_table()
    _print_graded()

运行:

cd private/labs/agp-lab
python3 -m agp_lab.agentic_rl

输出:

rewards: [1.0, 0.0, 0.0, 0.0]
grpo adv: [1.732, -0.577, -0.577, -0.577]
loo adv: [1.0, -0.333, -0.333, -0.333]
degenerate: 0.125

informative groups: 1 - p^G - (1-p)^G
   G      p=0.50      p=0.80      p=0.95
   1      0.0000      0.0000      0.0000
   2      0.5000      0.3200      0.0950
   4      0.8750      0.5888      0.1855
   8      0.9922      0.8322      0.3366
  16      1.0000      0.9719      0.5599
  32      1.0000      0.9992      0.8063

这张表有三条曲线,对应三个工程结论。

G=1 永远是 0.0000。 单条 rollout 的组里没有"相对",全成功或全失败,优势全 0——组内相对优势至少需要 G≥2。这在直觉上荒谬(采样一条也能得 0 或 1 分),但 GRPO 的基线是组内均值,一条样本没有均值可言。这提醒:组内标准化方法的组大小是设计出来的,不是随便填的。

p=0.50 的中等难度任务信号最足。 G=8 时有效信号概率 0.9922,G=4 时 0.8750。p 在中间时,成功失败混合得最充分,退化组最少。中等难度的任务给 RL 提供最多的有效信号。

p=0.95 的高成功率任务是信号黑洞。 任务越简单,组里全成功的概率越高:G=8 时只有 0.3366 的组有差异,G=32 才到 0.8063。模型已经会做的任务,RL 几乎采不到梯度。这解释了一个反直觉现象:Agentic RL 在"老是不会"的任务上进步快,在"已经会做"的任务上训练似乎停滞——不是没进步,是没梯度。

探索预算与 pass@k

退化组的对策之一是增大探索预算:既然单个样本容易失败,就多试几次。pass@k 衡量"试 k 次至少成功一次":

pass@k: 1 - (1-p)^k
   k      p=0.50      p=0.80      p=0.95
   1      0.5000      0.8000      0.9500
   4      0.9375      0.9984      1.0000
   8      0.9961      1.0000      1.0000

p=0.50 的单步成功率只有 0.5,但试 4 次有 93.75% 至少成一次,试 8 次 99.61%。k 次采样把"单步不行"变成了"多步可靠"——这正是 12.1 复合衰减的镜像:行为克隆的长轨迹被累积误差拖垮,pass@k 用重复采样把累积成功率救回来。

这条表还解释了探索预算的工程含义:预算不是玄学,是算术。任务单步成功率 p 已知时,试几次能达到目标通过率可以直接算出来;预算加在哪一步、加多少,按 p 查表即可。

多档奖励:打破退化组

二元奖励"非 0 即 1"是退化组的主要来源。实验最后比较三档奖励在 G=8 时的有效信号:

graded reward, G=8
binary          0.9423
three-level     0.9832
five-level      0.9993

把奖励从两档拆成三档、五档,有效信号从 0.9423 提到 0.9832、再到 0.9993。多档奖励让组内更容易出现差异——不必等一条"全对",部分对、一半对也能产生非零优势。这也是工程上一个很实用的提示:如果 RL 训练信号稀疏,先别加数据,先看能不能把奖励分档。

判据

判据合格的样子不合格的样子
可验证奖励来自客观检查器奖励靠人工打分
组内差异有效信号概率有估算退化了还不知道
预算算术探索预算按 p 计算预算拍脑袋
奖励分档多档奖励只有二元
结果唯一中间文本不换分文字漂亮可换奖励

架构含义

Agentic RL 对架构有三个直接约束:

  1. 检查器是一等组件。 可验证奖励的质量等于检查器的质量,检查器要独立、确定、可重跑。
  2. 退化组要监控。 训练日志记录退化组比例,超过阈值触发任务难度调整或奖励分档。
  3. 组大小与预算显式设计。 G 和 k 是超参,按任务成功率 p 计算而不是沿用默认值。

第 1 条是 Agentic RL 的地基:检查器不独立,Agent 就能学会骗检查器(呼应 7.3 的验证器漏洞);检查器不确定,同一结果两次给分不同,奖励信号就被注入噪声。可验证奖励的价值取决于检查器的可信度。

与三条工作负载的关系

  • W1 检索问答:检查器可以是"命中引用且答案与来源一致",可验证;适合 Agentic RL。
  • W2 代码修复:测试通过是最自然的可验证奖励,W2 是 Agentic RL 最好的场景。
  • W3 运维处置:可验证奖励要用"处置结果是否达成既定目标"(服务恢复、状态正确),但不能奖励"看起来忙"。

W3 的教训:运维里最容易退化的是"奖励动作频度"——处置得多、日志写得勤,看似在干活,实际结果没变。可验证奖励必须钉死在结果上:服务恢复状态为真、告警确实消除,才给分。

小结

  • 可验证奖励只认结果,不认"看起来合理"的中间文本。
  • GRPO 用组内相对优势做基线,组内无差异时优势全 0。
  • 退化组概率是 p^G + (1-p)^G:G=4、p=0.5 时每 8 组白采样 1 组。
  • 中等难度任务信号最足,高成功率任务是信号黑洞。
  • pass@k 用重复采样把单步失败变成多步可靠,探索预算按 p 可算。
  • 多档奖励把有效信号从 0.94 提到 0.99,是低成本提效手段。

阅读导航:上一节:12.2 RLHF/DPO:偏好与拒绝 · 下一节:13.1 反馈飞轮:从使用到改进 。

常见错误与边界

  1. 奖励"看起来忙"。 处置动作频繁但结果没变,可验证奖励会揭穿它。
  2. 组大小拍脑袋。 G=1 永远零梯度,组内标准化至少需要差异。
  3. 不监控退化组。 训练停滞时先查退化组比例,再谈其他优化。
  4. 二元奖励用到底。 信号稀疏先分档,可能比加数据便宜。
  5. 检查器不可信。 不独立的检查器会被 Agent 骗,可验证奖励失去意义。
  6. 探索预算拍脑袋。 预算按 p 查表可算,别靠感觉。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图