LLM 中的 Reinforcement Learning

Reinforcement learning 已经成为 LLM post-training 中很重要的一部分。SFT 让模型学习已有的高质量 responses，RL 让模型生成自己的 responses，再根据它们得到的反馈继续学习；从直觉上说，我们希望模型逐渐提高那些能够获得更高 reward 的行为的 probability。

这个目标听起来很直接，将它变成一次 parameter update 时却会遇到 SFT 中没有的问题。先回忆一个熟悉的 SFT training step。给定 prompt $x$ 和 demonstration response $y^{\star}=(y_1^{\star},\ldots,y_T^{\star})$，causal language model 在每个位置预测下一个 token：prompt 最后一个位置的 logits 预测 $y_1^{\star}$，读入 $y_1^{\star}$ 后的 logits 预测 $y_2^{\star}$，后面的 response tokens 依次类推。这个 one-position shift 将每一行 logits 与它的 next-token target 对齐，loss mask 再排除 prompt，只留下 assistant response 上的 cross-entropy：

\[\mathcal L_{\mathrm{SFT}}(\theta) =- \frac{1}{T} \sum_{t=1}^{T} \log p_\theta(y_t^{\star}\mid x,y_{<t}^{\star}).\]

因为 dataset 已经固定了每个位置的 target token，SFT 只需要取出这些 tokens 在对应 prefixes 下的 log probabilities，cross-entropy 的 gradient 随后便能沿着 logits 和 hidden states 回到 model parameters。

进入 RL 后，同一个 decoder 仍然在每个 prefix 上产生 next-token distribution，RL 根据这些对象在生成过程中的作用为它们赋予了新的名字。生成第 $t$ 个 token 之前，prompt 与已经生成的 tokens 组成当前 state $s_t=(x,y_{<t})$；vocabulary 中接下来选择的 token 是 action $a_t=y_t$；模型在这个 state 上为所有 actions 分配的 probability distribution 被称为 policy：

\[\pi_\theta(a_t\mid s_t) =p_\theta(y_t\mid x,y_{<t}).\]

因此，policy 可以理解成一个从当前 state 到 action distribution 的映射。LLM rollout 每次从这份 distribution 中 sample 一个 token，将它接到 prefix 后形成新的 state，再重复同样的过程，直到产生完整 response $y$：

\[y\sim\pi_\theta(\cdot\mid x).\]

Reward model、verifier 或 environment 随后为这条 response 返回一个 scalar $R(x,y)$。一旦 rollout 完成，sampled response $y$ 已经固定，这个 reward 在 policy update 中通常也被当作固定值；如果直接使用 $\mathcal L(\theta)=-R(x,y)$，它对 current policy parameters 的 gradient 就是零：

\[\nabla_\theta[-R(x,y)]=0.\]

这似乎留下了一个矛盾：reward 是我们唯一得到的反馈，它本身却无法提供可以反向传播的 gradient。RL 当然仍然能够利用这个 scalar 更新模型，关键线索在于，reward 虽然已经固定，生成这条 response 的 probability 仍然由 model parameters 决定。接下来，我们从这一区别出发，推导 LLM reinforcement learning 中最基础的 policy gradient。

从 Expected Reward 到 Policy Gradient

先考虑一个只有两条 possible responses 的极小模型。对于同一个 prompt，response $y^{(1)}$ 的 reward 是 $1$，response $y^{(2)}$ 的 reward 是 $0$。假设当前 policy 生成 $y^{(1)}$ 的 probability 是 $p_\theta$，生成 $y^{(2)}$ 的 probability 自然就是 $1-p_\theta$，那么它能够获得的 expected reward 为

\[J(\theta) =p_\theta\cdot 1+(1-p_\theta)\cdot 0 =p_\theta.\]

两条 responses 各自的 reward 都是固定常数，expected reward 却会随着 $p_\theta$ 改变。比如，policy 将高 reward response 的 probability 从 $0.25$ 提高到 $0.30$，它的 expected reward 也会从 $0.25$ 提高到 $0.30$。RL 所优化的正是这种由整个 policy distribution 决定的平均表现。

把这个例子推广到任意数量的 responses。对于一个给定 prompt $x$，policy 的 objective 可以写成

\[J(\theta) =\mathbb E_{y\sim\pi_\theta(\cdot\mid x)}[R(x,y)] =\sum_y\pi_\theta(y\mid x)R(x,y).\]

这个 expectation 定义了我们希望优化的量，也就是 policy 在所有可能 responses 上的平均 reward。第二个等号将它展开成显式求和，其中 $y$ 要遍历 policy 对当前 prompt 可能生成的所有完整 responses。每个 $R(x,y)$ 都可以保持固定，$J(\theta)$ 仍然会通过 $\pi_\theta(y\mid x)$ 依赖 model parameters；改变不同 responses 的 probability，会重新分配这份 sum 中的 probability mass，最终改变 expected reward。

定义 objective 以后，训练还需要知道应该怎样改变 $\theta$，所以我们真正要计算的是 $\nabla_\theta J(\theta)$。这里同时存在一个现实限制：LLM 的 response space 无法枚举，训练只能从 current policy 中 rollout 少量 responses。如果能够将 gradient 本身写成 current policy 下的 expectation，便可以使用这些 samples 的平均值来近似它。这个目标决定了接下来的推导方向。

先从 expected reward 的显式求和开始。由于每条 response 对应的 reward 都被视为常数，gradient 只会作用在它被 policy 选中的 probability 上：

\[\nabla_\theta J(\theta) =\sum_y R(x,y)\nabla_\theta\pi_\theta(y\mid x).\]

这是一个正确的 gradient，却还无法直接通过 sampling 估计。按照 expectation 的定义，从 $\pi_\theta$ sampling 所估计的量展开成求和后，每一项都由 $\pi_\theta(y\mid x)$ 加权，而当前 gradient sum 中出现的是 $\nabla_\theta\pi_\theta(y\mid x)$。因此，我们需要将它写成 $\pi_\theta(y\mid x)$ 乘以另一个可以计算的量。Log probability 恰好提供了这样的分解。根据 $\log z$ 的 derivative，

\[\nabla_\theta\log\pi_\theta(y\mid x) =\frac{1}{\pi_\theta(y\mid x)} \nabla_\theta\pi_\theta(y\mid x).\]

将两边乘以 $\pi_\theta(y\mid x)$，便得到

\[\nabla_\theta\pi_\theta(y\mid x) =\pi_\theta(y\mid x) \nabla_\theta\log\pi_\theta(y\mid x).\]

把这个 identity 代回 objective 的 gradient，我们得到

\[\nabla_\theta J(\theta) =\sum_y \pi_\theta(y\mid x) \left[ R(x,y)\nabla_\theta\log\pi_\theta(y\mid x) \right].\]

现在，每一项前面都出现了所需的 $\pi_\theta(y\mid x)$。按照 expectation 的定义，整个 gradient 可以写成

\[\nabla_\theta J(\theta) =\mathbb E_{y\sim\pi_\theta(\cdot\mid x)} \left[ R(x,y)\nabla_\theta\log\pi_\theta(y\mid x) \right].\]

这正是推导开始时想要的形式：gradient 本身成为了 policy 下的 expectation。我们从 current policy 中 rollout 一条 response $y$，得到 reward $R(x,y)$，再计算这条 response 在 model 下的 log probability，便可以构造一次 stochastic gradient estimate：

\[\widehat{\nabla_\theta J} =R(x,y)\nabla_\theta\log\pi_\theta(y\mid x), \qquad y\sim\pi_\theta(\cdot\mid x).\]

在许多 sampled responses 上对这个 estimate 取平均，会逐渐逼近真正的 $\nabla_\theta J(\theta)$。这就是 policy gradient 最核心的结果 (Williams, 1992)。Reward 不需要对 $\theta$ 可微，它在这里充当一个 weight，决定 sampled response 的 log-probability 应该得到多大的更新。使用 gradient ascent 时，positive reward 会提高这条 response 的 log-probability；实现中通常使用 gradient descent，因此可以写出对应的 loss：

\[\mathcal L_{\mathrm{PG}}(\theta) =-R(x,y)\log\pi_\theta(y\mid x),\]

其中 $R(x,y)$ 在反向传播时被视为常数。Gradient 会经过 $\log\pi_\theta(y\mid x)$ 回到 model parameters，这条路径与 SFT 中经过 token log-probabilities 的路径重新连接了起来。

对于 autoregressive LLM，一条完整 response 的 probability 是每一步 next-token probability 的乘积：

\[\pi_\theta(y\mid x) =\prod_{t=1}^{T} \pi_\theta(y_t\mid x,y_{<t}).\]

取 logarithm 后，乘积变成逐 token 求和：

\[\log\pi_\theta(y\mid x) =\sum_{t=1}^{T} \log\pi_\theta(y_t\mid x,y_{<t}).\]

因此，最朴素的 sequence-level policy-gradient loss 可以写成

\[\mathcal L_{\mathrm{PG}}(\theta) =-R(x,y) \sum_{t=1}^{T} \log\pi_\theta(y_t\mid x,y_{<t}).\]

这个形式与前面的 SFT loss 已经非常接近。两者都会在 sampled 或 target tokens 的 log-probabilities 上反向传播；在 policy gradient 中，每个 token 的训练方向和强度由 rollout 得到的 signal 加权。由此，一个不可微的 sequence-level reward 最终变成了 model parameters 上可计算的 gradient。

从 Sequence Reward 到 Token-Level Advantage

上一节得到的 policy-gradient loss 会用 reward 为 sampled response 的 log-probability 加权：

\[\mathcal L_{\mathrm{PG}}(\theta) =-R(x,y) \log\pi_\theta(y\mid x).\]

先把完整 response 看成一个 sampled outcome。假设 current policy 对同一个 prompt 生成两条 responses，分别得到 $80$ 和 $90$ 分。如果它通常只能得到 $60$ 分，这两条 responses 都超过了当前水平；如果它通常能得到 $85$ 分，$90$ 分仍然值得鼓励，$80$ 分已经低于预期。Reward 的绝对大小缺少这样的参照系，而 policy update 真正关心的是一条 response 相比 current policy 的通常表现好多少。

我们可以为 prompt $x$ 选择一个 baseline $b(x)$，并用 reward 与 baseline 的差作为 response-level advantage：

\[A(x,y)=R(x,y)-b(x).\]

只要 $b(x)$ 不依赖 sampled response $y$，并且在 policy update 中被当作固定 coefficient，减去它就不会改变 expected policy gradient。使用上一节已经推导过的 $\pi_\theta\nabla_\theta\log\pi_\theta=\nabla_\theta\pi_\theta$，baseline 对 gradient 的期望贡献为

\[\begin{aligned} \mathbb E_{y\sim\pi_\theta(\cdot\mid x)} \left[ b(x)\nabla_\theta\log\pi_\theta(y\mid x) \right] &=b(x)\nabla_\theta\sum_y\pi_\theta(y\mid x) \\ &=b(x)\nabla_\theta 1=0. \end{aligned}\]

因此，policy gradient 可以使用 $A(x,y)$ 代替 raw reward：

\[\nabla_\theta J(\theta) =\mathbb E_{y\sim\pi_\theta(\cdot\mid x)} \left[ A(x,y)\nabla_\theta\log\pi_\theta(y\mid x) \right].\]

如果 $b(x)$ 近似 current policy 在 prompt $x$ 上的 expected reward，那么 positive advantage 表示这条 response 超过了当前水平，negative advantage 表示它低于当前水平。在前面的例子中，取 $b(x)=85$，两条 responses 的 advantages 就分别是 $-5$ 和 $5$。Baseline 没有改变 expected policy gradient，却让每个 sample 的 coefficient 直接表达相对表现，同时通常也能降低 gradient estimate 的 variance。

当一个 Response 被拆成 Tokens

到目前为止，我们仍然把完整 response 当作一个选择。LLM 的 policy 实际由逐 token distributions 组成：

\[\log\pi_\theta(y\mid x) =\sum_{t=1}^{T} \log\pi_\theta(y_t\mid x,y_{<t}).\]

如果直接使用同一个 response-level advantage，所有 sampled tokens 仍然共享相同的 coefficient。可是，response 每生成一个 token，模型掌握的信息都会更多一些。一个只看 prompt 的 baseline 无法反映这些新信息。我们真正想知道的是：生成当前 token 以后，这条 response 获得高 reward 的前景变好了多少？

先考虑 LLM RL 中一个常见的 setting：模型逐 token 生成 response，生成过程中没有 intermediate rewards，直到 response 结束后，verifier 才返回最终 reward $R(x,y)$。在 timestep $t$，模型已经看到 prompt 和前 $t-1$ 个 response tokens。把这个 prefix 记为

\[s_t=(x,y_{<t}).\]

从同一个 prefix 出发，policy 可以生成许多不同的 continuations，它们最终得到的 rewards 也可能不同。对这些 possible continuations 的 rewards 取平均，就得到当前 prefix 的 value：

\[V^\pi(s_t) =\mathbb E_\pi[R(x,y)\mid x,y_{<t}],\]

其中 expectation 中的 continuation 由 current policy 生成。$V^\pi(s_t)$ 表示从当前 prefix 继续生成时，policy 预期能够得到多高的最终 reward。前面的 response-level baseline $b(x)$ 只使用 prompt；$V^\pi(s_t)$ 还使用了已经生成的 tokens，所以它能够随着 response 的进展不断更新。

如果 verifier reward 只有 $0$ 和 $1$，这个解释会更加直观。此时，平均 reward 就等于成功概率，所以 $V^\pi(s_t)=0.6$ 可以直接理解为：从当前 prefix 继续生成，最终成功的 probability 是 $60\%$。

在 sample 下一个 token 之前，当前 response 的前景由 $V^\pi(s_t)$ 表示。接下来，policy 从 $\pi(\cdot\mid s_t)$ 中 sample token $a_t=y_t$，并把它接到 response 后面。新的 prefix 为

\[s_{t+1}=(x,y_{\leq t}).\]

此时，response 的前景变成了 $V^\pi(s_{t+1})$。假设当前 prefix 的 value 是 $0.6$，sample 某个 token 后，新 prefix 的 value 变成 $0.75$。在 binary-reward 例子中，这表示模型认为最终成功的 probability 从 $60\%$ 上升到了 $75\%$。这个 token 相对于 sample 之前的 baseline 带来了 $0.15$ 的提升，因此它的 advantage 是 $0.15$。如果新 prefix 的 value 降到 $0.4$，它的 advantage 就是 $-0.2$。

这已经给出了 terminal-reward setting 中最核心的 token-level intuition。对于一个 non-terminal token，生成前后的 value difference 就是它的 exact advantage：

\[A^\pi(s_t,a_t) =V^\pi(s_{t+1})-V^\pi(s_t).\]

Standard RL notation 会把“固定当前 action 后的 expected reward”记为 action value：

\[Q^\pi(s_t,a_t) =\mathbb E_\pi[R(x,y)\mid x,y_{\leq t}].\]

在 LLM 中，选择 token $a_t$ 会确定 next prefix $s_{t+1}$。对于 non-terminal token，生成过程还没有返回 reward，因此

\[Q^\pi(s_t,a_t)=V^\pi(s_{t+1}).\]

于是，RL 中通常写作 $Q-V$ 的 advantage，放回这里正好就是刚才的 prefix value difference：

\[A^\pi(s_t,a_t) =Q^\pi(s_t,a_t)-V^\pi(s_t).\]

对于最后一个 token，response 随即结束并得到 final reward，所以 $Q^\pi(s_T,a_T)=R(x,y)$，对应的 advantage 是 $R(x,y)-V^\pi(s_T)$。$Q$ 在这里帮助我们用统一的公式覆盖普通 token 和 terminal token，实际需要学习的 baseline 仍然是 prefix value。

用 $V^\pi(s_t)$ 作为 baseline 不会改变 expected policy gradient，因为它由 sample 当前 token 之前的 prefix 决定，不依赖这一次 sample 到的 action。Token-level policy gradient 可以写成

\[\nabla_\theta J(\theta) =\mathbb E_{y\sim\pi_\theta(\cdot\mid x)} \left[ \sum_{t=1}^{T} A^\pi(s_t,a_t) \nabla_\theta\log\pi_\theta(a_t\mid s_t) \right].\]

这里需要区分 exact advantage 与训练时能够得到的 estimate。Exact $Q^\pi(s_t,a_t)$ 要对固定当前 token 后的所有 possible continuations 求 expected reward，真实 LLM 的 continuation space 无法枚举。实际训练会学习一个带参数的 value model $V_\phi(s_t)$ 来近似 $V^\pi(s_t)$。给定一条固定的 prompt-response sequence，causal Transformer 会为每个 prefix $s_t$ 产生 hidden state $h_t$，再通过一个 scalar value head 输出

\[V_\phi(s_t)=w_V^\top h_t+b_V.\]

Causal mask 保证 $h_t$ 只能读取当前 prefix，因此一条 full sequence 经过一次 forward 就能得到所有 response positions 的 values。Value model 可以使用独立 Transformer，也可以与 policy 共享部分 backbone；无论具体实现如何，它在每个 prefix 上输出的是一个 scalar expected return。$Q^\pi(s_t,a_t)$ 则通过有限的 rollouts 来估计。

假设我们从同一个 $s_t,a_t$ 出发继续生成很多次，并对这些 continuations 的 final rewards 取平均。这个平均值会逐渐接近 $Q^\pi(s_t,a_t)$。一条 rollout 只提供其中一次随机结果，所以它最终得到的 $R(x,y)$ 可以看作 $Q^\pi(s_t,a_t)$ 的一个 Monte Carlo sample。用这个 sample 估计 $Q$，再减去 learned baseline，便得到 Monte Carlo advantage：

\[\hat A_t^{\mathrm{MC}} =R(x,y)-V_\phi(s_t).\]

同一条 response 中，所有 positions 使用的 $R(x,y)$ 都相同，prefix-dependent baseline $V_\phi(s_t)$ 会不断变化，所以不同 tokens 仍然可以得到不同的 estimated advantages。与此同时，某个早期 token 后面可能恰好接上了一段很好的 continuation，也可能被后续的糟糕 choices 拖累。Single-rollout estimate 会把这些后续 sampling 的随机性一并归到当前 token 上，因此 variance 较高，也很难区分当前 token 和后续 continuation 分别对最终结果产生了多大影响。

GAE 如何组合不同长度的 Estimates

上一节的 $R(x,y)-V_\phi(s_t)$ 已经是对当前 token advantage 的一种 estimate：$R(x,y)$ 是选定这个 token 后最终得到的 return，$V_\phi(s_t)$ 是生成它之前的 expected return。问题在于，$R(x,y)$ 来自一条具体的 sampled continuation。当前 token 后面的每一次 sampling 都会影响最终结果，因此用这一个 $R(x,y)$ 估计当前 token 有多好，variance 往往很高。

Value model 还提供了另一种估计方式。我们可以只使用当前一步真实观察到的 reward，然后用 $V_\phi(s_{t+1})$ 预测剩余 return；也可以使用接下来两步的真实 rewards，再用 $V_\phi(s_{t+2})$ 预测余下部分。继续增加真实观察的步数，就会依次得到 one-step、two-step，直到使用完整 response 的 full-rollout estimate。较短的 estimate 很早便依赖 value prediction，较长的 estimate 会纳入更多 sampled continuation。GAE 的核心就是将这些不同 horizon 的 advantage estimates 组合起来 (Schulman et al., 2015)。

先定义我们要估计的对象。把执行 action $a_t$ 后立即得到的 reward 记为 $r_t$，从 timestep $t$ 开始的 discounted return 为

\[G_t =r_t+\gamma r_{t+1}+\gamma^2r_{t+2}+\cdots+ \gamma^{T-t}r_T.\]

$\gamma$ 决定 delayed rewards 在 return 中占多大权重。一个两步后出现的 reward $1$，在当前 return 中计作 $\gamma^2$。LLM 的 outcome reward 通常只在 response 结束时出现，因此 $r_1,\ldots,r_{T-1}$ 都是 $0$，$r_T=R(x,y)$；训练中常取 $\gamma=1$，让 final reward 无需随 token distance 衰减。

从 return 的定义中取出当前 reward，可以得到整个推导最关键的一步：

\[G_t=r_t+\gamma G_{t+1}.\]

执行当前 action 后，$r_t$ 已经可以观察，$G_{t+1}$ 仍然取决于尚未生成的 continuation。Next-state value $V^\pi(s_{t+1})$ 预测的正是这段 future return：

\[V^\pi(s_{t+1}) =\mathbb E_\pi[G_{t+1}\mid s_{t+1}].\]

因此，我们可以用 current reward 加上 predicted future return 来估计当前 action 的 return。再减去 action 发生前的 baseline，就得到 one-step advantage estimate，也称为 TD error：

\[\delta_t =r_t+\gamma V_\phi(s_{t+1})-V_\phi(s_t).\]

这里的 $r_t$ 是当前 transition 已经获得的 reward。$V_\phi(s_{t+1})$ 预测从下一步开始的整个 future return，所以站在 timestep $t$ 看时，这段 future tail 需要整体乘以 $\gamma$。这就是 $\gamma$ 出现在 value 前面的原因。

One-step estimate 到 $s_{t+1}$ 就开始依赖 value prediction。我们也可以继续观察一步，使用真实的 $r_{t+1}$，到 $s_{t+2}$ 才开始 bootstrap：

\[\begin{aligned} \hat A_t^{(2)} &=r_t+\gamma r_{t+1} +\gamma^2V_\phi(s_{t+2})-V_\phi(s_t) \\ &=\delta_t+\gamma\delta_{t+1}. \end{aligned}\]

每延长一步 horizon，就多使用一个实际观察到的 reward，并把 value prediction 向后推一步。如果 environment 每一步都返回 $1$ 且 $\gamma=1$，two-step estimate 中实际观察到的 reward 部分确实是 $1+1=2$；完整 advantage 还要加上 $V_\phi(s_{t+2})$，再减去原来的 $V_\phi(s_t)$。在 terminal-reward LLM 中，中间 rewards 都是 $0$，只有 horizon 到达 response 结尾时，$R(x,y)$ 才会进入这个 sum。

Short-horizon estimates 更依赖 value model，通常 variance 较低；long-horizon estimates 使用更多 sampled continuation，逐渐接近 full-rollout estimate $G_t-V_\phi(s_t)$，同时会带入更多 sampling variance。GAE 使用 $\lambda$ 对这些不同 horizon 的 estimates 做 exponentially weighted combination。每向后保留一个 TD error，就会比前一项多一层 $\lambda$ 权重。写成 TD errors 的形式，就是

\[\hat A_t^{\mathrm{GAE}(\gamma,\lambda)} =\delta_t +\gamma\lambda\delta_{t+1} +(\gamma\lambda)^2\delta_{t+2} +\cdots.\]

$\gamma$ 和 $\lambda$ 在这里承担不同角色。$\gamma$ 已经在 return 的定义中决定 future rewards 的价值；$\lambda$ 决定 estimator 应该保留多少 long-horizon information，在 value-model bias 与 rollout variance 之间取舍。对于 $k$ 步以后的 TD error，$\gamma^k$ 来自它在 return 中的位置，$\lambda^k$ 来自 horizon weighting。在 LLM 常用的 $\gamma=1$ setting 中，coefficient 变成 $\lambda^k$，两者的区别也最直接。

当 $\lambda=0$ 时，GAE 只使用 one-step TD error；当 $\lambda=1$ 时，它保留所有后续 TD errors。令 terminal state 的 future value 为零，中间的 value terms 会逐项抵消，最终得到 full-rollout estimate $G_t-V_\phi(s_t)$。Policy-gradient loss 随后变为

\[\mathcal L_{\mathrm{PG}}(\theta) =- \sum_{t=1}^{T} \hat A_t \log\pi_\theta(a_t\mid s_t).\]

回到这一节最初的问题，我们希望估计当前 token 让 response 的 expected return 改变了多少。Full-rollout estimate 一直使用真实 rollout 到 response 结束；one-step estimate 只使用眼前这一步的 reward，随后让 value model 预测剩余 return；two-step estimate 多使用一步真实 observation，再让 value model 接手。GAE 对这一整组 estimates 加权，$\lambda$ 决定权重更偏向较短的 horizon，还是更偏向沿 sampled rollout 看得更远。

GAE 最终为同一个 prefix 产生两个紧密相关的 training quantities。$\hat A_t$ 是相对 rollout-time baseline 的 advantage，用来训练 policy；将 baseline 加回去，则得到 value model 的 regression target：

\[\hat R_t = \hat A_t+V_{\mathrm{old}}(s_t).\]

这里的 $V_{\mathrm{old}}(s_t)$ 是计算 GAE 时保存的 value prediction。当 $\lambda<1$ 时，$\hat R_t$ 是混合 sampled rewards 与 value bootstrap 得到的 target。Value model 因此既在 GAE 中提供 prefix-dependent predictions，也会根据 $\hat R_t$ 学习更准确的 expected return。Policy 则使用 $\hat A_t$ 作为每个 sampled token 的 update coefficient：positive advantage 提高这个 token 的 probability，negative advantage 降低它的 probability，绝对值决定 update signal 的强弱。

Proximal Policy Optimization (PPO)

上一节最终得到的 policy-gradient loss 是

\[\mathcal L_{\mathrm{PG}}(\theta) = -\mathbb E_t\left[ \hat A_t\log\pi_\theta(a_t\mid s_t) \right].\]

如果每次都用 current policy 生成 rollouts，计算 advantages，只做一次很小的 gradient update，随后立即丢弃数据并重新 rollout，这个 loss 可以直接使用。Samples 与 gradient 始终来自同一个 policy，只要 update 足够小，它们描述的就是 policy 当前所在位置附近的改进方向。

实际训练通常会先收集一批 responses，计算好 rewards、old values、GAE advantages 和 value targets，再把这批数据分成 minibatches，执行若干 optimizer steps，甚至训练多个 epochs。这样可以更充分地利用已经生成的 rollouts。问题也随之出现：rollout batch 在整个 update 阶段保持 fixed，正在训练的 policy 却会在每个 optimizer step 后发生变化。

把生成这批 responses 时的 policy snapshot 记为 $\pi_{\mathrm{old}}$，正在更新的 policy 记为 $\pi_\theta$。Update 刚开始时两者完全相同。完成第一个 optimizer step 后，$\pi_\theta$ 已经改变，剩余 minibatches 中的 sampled tokens、visited prefixes 和 advantages 却仍然来自 $\pi_{\mathrm{old}}$。实现中通常会保存 rollout-time log-probabilities，因此计算 ratio 并不一定需要始终保留第二份完整的 policy model。

我们由此面对两个相连的问题。第一，old policy sample 出来的 actions 应该怎样用于估计 current policy 下的 objective？第二，随着 current policy 逐渐远离 old policy，这批 fixed evidence 还能被信任到什么程度？PPO 分别用 probability ratio 和 clipping 回答它们。Proximal 所描述的，就是只在 rollout policy 附近使用这份局部 evidence，完成有限次 updates 后重新 rollout (Schulman et al., 2017)。

Probability Ratio：重新加权 Old-Policy Samples

先处理第一个问题。固定 rollout 中的一个 prefix $s$，手里的 action 由 old policy sample 得到，我们想估计的则是 current policy 下的 expected advantage。假设在同一个 prefix $s$ 上，old policy 选择某个 action 的 probability 是 $0.2$，current policy 下变成了 $0.4$。如果分别从两个 policies 在这个 prefix 上重复采样很多次，那么每 $100$ 个 samples 中，old policy 大约只会产生 $20$ 次这个 action，而 current policy 大约会产生 $40$ 次。现在我们手里仍然只有 old policy 采出的那约 $20$ 次，却希望用它们估计 current policy 下的 expectation，因此每一次 observation 都需要代表 current policy 下大约两次这样的 occurrence，也就是乘上 $\frac{0.4}{0.2}=2$ 的权重。

这个 weight 就是 current probability 与 old probability 的 ratio。上一节已经用 $r_t$ 表示 reward，所以这里将 probability ratio 记为

\[\rho_t(\theta) = \frac{\pi_\theta(a_t\mid s_t)} {\pi_{\mathrm{old}}(a_t\mid s_t)}.\]

在这一阶段，$\rho_t$ 承担的是 change of measure：它让 old-policy samples 能够估计另一个 action distribution 下的 expectation。它还没有处理一次 update 应该走多远。把这个 intuition 写成公式，先将 old-policy advantage $A^{\pi_{\mathrm{old}}}(s,a)$ 当作已经计算好的 quantity：

\[\mathbb E_{a\sim\pi_\theta(\cdot\mid s)} \left[A^{\pi_{\mathrm{old}}}(s,a)\right] = \mathbb E_{a\sim\pi_{\mathrm{old}}(\cdot\mid s)} \left[ \frac{\pi_\theta(a\mid s)} {\pi_{\mathrm{old}}(a\mid s)} A^{\pi_{\mathrm{old}}}(s,a) \right].\]

左边要求从 current policy sample actions；右边继续使用 old policy 的 samples，再用 ratio 调整每个 sample 的统计权重。把这个 identity 应用到 rollout batch 中，就得到 local surrogate objective：

\[J_{\mathrm{sur}}(\theta) = \mathbb E_t\left[\rho_t(\theta)\hat A_t\right].\]

这个 objective 也能接回上一节的 policy gradient。Old-policy probability 对 $\theta$ 是常数，因此

\[\nabla_\theta\rho_t = \rho_t\nabla_\theta\log\pi_\theta(a_t\mid s_t).\]

Update 开始时，$\pi_\theta=\pi_{\mathrm{old}}$，所以 $\rho_t=1$。此时

\[\nabla_\theta\left(\rho_t\hat A_t\right) = \hat A_t\nabla_\theta\log\pi_\theta(a_t\mid s_t),\]

正好得到上一节的 sampled-token policy-gradient term。这里把 $J_{\mathrm{sur}}$ 写成需要 maximize 的 objective，实现时通常 minimize $-J_{\mathrm{sur}}$。

这个 correction 有一个重要边界。LLM 是逐 token 生成 response 的，前面 token 的改变会改变后面所有 prefixes。假设 old policy 的 rollout 走到了某个 prefix $s_t$，current policy 如果降低了前面某个 token 的 probability，那么它之后可能很少走到 $s_t$，甚至根本不会走到这里。可是当我们计算 $\rho_t$ 时，已经把 $s_t$ 当作给定，只比较两个 policies 在这个 prefix 下选择当前 token 的 probability。

因此，ratio 修正的是 conditional action distribution，也就是“已经来到这个 prefix 以后，next token 应该怎样重新加权”；它没有修正 prefix 本身被访问到的 probability。Rollout 中访问过哪些 prefixes、后面出现了哪条 continuation，以及 $\hat A_t$ 的值仍然由 old policy 决定，所以 $J_{\mathrm{sur}}$ 仍然只是一份围绕 old policy 的 local objective。直观地说，ratio 可以重新计算一条旧路径在某个 checkpoint 之后的 next-step 权重，却没有重新生成通往这个 checkpoint 的整条路径。

Ratio 虽然是作为 importance weight 推导出来的，它的数值也直接反映 sampled action 的 probability 已经改变了多少。当 $\rho_t=1$ 时，新旧 probabilities 相同；$\rho_t=1.25$ 表示 current policy 将它的 probability 相对提高了 $25\%$；$\rho_t=0.8$ 表示相对降低了 $20\%$。这个 interpretation 不会改变 ratio 乘在 advantage 上的统计原因，却让我们能够观察 current policy 已经沿着这条 old-policy evidence 移动了多远。

Clipping：限制固定 Rollout Evidence 的影响

Ratio 解决了 old-policy samples 怎样进入 current-policy expectation 的问题，但它还没有回答：同一批 fixed rollouts 可以继续推动 current policy 多远？要看到这个问题，先暂时不加入任何额外限制。对一个 positive-advantage sample，surrogate objective 中对应的 contribution 是 $\rho_t\hat A_t$。因为我们在 maximize 这个 objective，提高这个 sampled action 的 probability 会提高 $\rho_t$，也会让这一项变大。这就是不加 clipping 时的 surrogate term，也常被称为 unclipped term。

这个方向在 old policy 附近是我们想要的：如果一个 action 的 estimated advantage 是 positive，policy 应该提高它的 probability。问题出现在同一批数据被反复使用时。$\hat A_t$ 始终是 old rollout 给出的 fixed estimate；current policy 走得越远，unclipped objective 却仍然会继续奖励 $\rho_t$ 增大，仿佛这条旧 evidence 无论 policy 已经移动多远都同样可靠。对于 negative advantage，objective 也会持续鼓励 $\rho_t$ 减小。

这里需要把 ratio 的两个作用分开看。作为 expectation 中的 weight，较大的 ratio 是合理的，因为这个 action 在 current policy 下本来就会更频繁地出现。作为 optimization objective 中的变量，持续增大的 ratio 又会让同一条 fixed evidence 继续提供更强的 incentive。Ratio 完成了 sampling-distribution correction，却没有给这批 evidence 设置有效范围；current policy 离 old policy 越远，prefix distribution、后续 continuation 和 advantage estimate 与它的匹配程度就越弱。

这正是 clipping 处理的问题。Advantage 在当前 iteration 中保持 fixed，PPO 限制的是同一条 old-policy evidence 沿有利方向还能继续提供多少 optimization incentive。它为 ratio 构造一个限制在 $[1-\epsilon,1+\epsilon]$ 内的 clipped copy，并在 original term 与 clipped term 之间选择更保守的一个：

\[J_{\mathrm{PPO}}(\theta) = \mathbb E_t\left[ \min\left( \rho_t(\theta)\hat A_t, \operatorname{clip}\bigl(\rho_t(\theta),1-\epsilon,1+\epsilon\bigr)\hat A_t \right) \right].\]

这个公式最容易混淆的地方，是 $\min$ 在什么情况下返回哪个 candidate term。逐个 case 拆开容易让符号失去主线。下面用 图 1 把一个 sampled token 的六种可能性放在一起，直观看到 clipped term 为什么会变成平台。

为避免把单个 sampled token 的 contribution 和完整的 expectation 混在一起，图中的纵轴只表示括号内的 per-token term，记作 $\ell_t$。

$\rho_t$ range	$\hat A_t$	Return value of $\min$	Objective clipped?	Sign of objective	policy gradient?
$1-\epsilon<\rho_t<1+\epsilon$	$+$	$\rho_t\hat A_t$	no	$+$	✓
$1-\epsilon<\rho_t<1+\epsilon$	$-$	$\rho_t\hat A_t$	no	$-$	✓
$\rho_t<1-\epsilon$	$+$	$\rho_t\hat A_t$	no	$+$	✓
$\rho_t<1-\epsilon$	$-$	$(1-\epsilon)\hat A_t$	yes	$-$	×
$\rho_t>1+\epsilon$	$+$	$(1+\epsilon)\hat A_t$	yes	$+$	×
$\rho_t>1+\epsilon$	$-$	$\rho_t\hat A_t$	no	$-$	✓

$\hat A_t>0$

$\hat A_t<0$

图中可以看到，PPO 在两种 clipped cases 中返回的是固定的 $(1+\epsilon)\hat A_t$ 或 $(1-\epsilon)\hat A_t$。这个 term 仍然有 objective value，却不再依赖 $\theta$，所以对应的 policy gradient 为 $0$。

曲线把同一件事画成了几何形状。$\hat A_t>0$ 时，policy 希望提高 sampled action 的 probability，selected objective 在 $\rho_t=1+\epsilon$ 之后变平。$\hat A_t<0$ 时，policy 希望降低 sampled action 的 probability，平台出现在 $\rho_t=1-\epsilon$ 左侧。

令 $\epsilon=0.2$，当 $\hat A_t=2$、$\rho_t=1.3$ 时，original term 是 $2.6$，clipped term 是 $2.4$，所以 $\min$ 返回 $2.4$。Actor loss 的数值是 $-2.4$，但继续增大 $\rho_t$ 不会改变这个返回值，因而这一条 sample 的 policy gradient 为 $0$。如果 policy 朝着 advantage 反对的方向移动，$\min$ 会返回 original term，objective 仍然会惩罚这个 change。Clipping 因此只移除沿有利方向走得过远后还能获得的额外收益，也不会强制所有 ratios 都停留在 $[1-\epsilon,1+\epsilon]$ 内。

KL 与 Trust-Region 视角

Clipping 使用 sampled-action-level 的 ratio 构造 local safeguard。如果希望从整个 next-token distribution 的尺度描述 policy change，可以先对 ratio 取 logarithm，将 relative probability change 写成 log-probability difference：

\[\log\rho(a\mid s) = \log\pi_\theta(a\mid s) - \log\pi_{\mathrm{old}}(a\mid s).\]

KL divergence 将整个 action distribution 上的 log-probability differences 聚合起来。它的一般定义是

\[D_{\mathrm{KL}}(p\Vert q) = \sum_a p(a)\log\frac{p(a)}{q(a)}.\]

这个 quantity 在 $p$ 认为更可能的 actions 上赋予更高权重，并比较它们在 $p$ 与 $q$ 下的 log-probabilities。放到同一个 prefix 下的新旧 policies 上，可以写成

\[D_{\mathrm{KL}} \left( \pi_{\mathrm{old}}(\cdot\mid s) \Vert \pi_\theta(\cdot\mid s) \right) = -\mathbb E_{a\sim\pi_{\mathrm{old}}(\cdot\mid s)} [\log\rho(a\mid s)].\]

Ratio 描述一个 sampled action 上的 relative probability change，KL 描述整个 next-token distribution 的 average change。两个 distributions 相同时 KL 为 $0$；KL 具有方向，交换两者的位置通常会得到不同的值。

这里的 trust region 指一块围绕 old policy 的邻域：只有在这块邻域内，我们才相信 old prefixes 和 old advantages 构成的 surrogate 仍然能够可靠地指导 current policy。Trust Region Policy Optimization（TRPO）将这个想法直接写成 constrained optimization (Schulman et al., 2015)：

\[\begin{aligned} \max_\theta\quad &\mathbb E_t\left[\rho_t(\theta)\hat A_t\right] \\ \text{subject to}\quad &\mathbb E_{s_t}\left[ D_{\mathrm{KL}} \left( \pi_{\mathrm{old}}(\cdot\mid s_t) \Vert \pi_\theta(\cdot\mid s_t) \right) \right] \leq \delta. \end{aligned}\]

PPO 保留了同样的 local-update intuition，并用 sampled ratios 上的 clipping 避免这类 constrained optimization。Clipping 没有保证所有 ratios 都落在 clipping interval 内，也没有保证整体 KL 低于 $\delta$；它限制的是 fixed rollout evidence 在 surrogate 中能够继续提供的收益。因此，KL 给出 distribution-level 的 trust-region 视角，clipping 提供一个更容易用 minibatch SGD 优化的近似 safeguard。

一次完整的 LLM PPO Update

到这里，PPO 本身已经有了三类对象：current policy 负责更新，old policy 是本轮 rollout 的固定 snapshot，value model 负责提供 critic prediction。LLM RLHF 中通常还会加入一个 reference policy (Ouyang et al., 2022)。它和 old policy 解决的问题不同：old policy 只在当前 iteration 内作为 PPO 的比较起点，reference policy 则通常固定为 RL 开始前的 SFT model，用来约束多轮训练后的长期漂移。

一次 PPO update 中涉及的 models 和 parameter snapshots 可以完整列出来：

Clipping 约束的是 current policy 与本轮 old policy 之间的局部变化。可是每一轮结束后，更新过的 policy 都会成为下一轮的 old policy；经过许多轮小幅更新，model 仍然可能逐渐远离 RL 开始前的 SFT model。Reference policy 的作用就是提供一个跨越许多 iterations 的长期 anchor。Reward model 或 verifier 同样通常保持冻结，负责为 sampled response 提供 task reward。

下面先采用把 reference KL 直接放进 actor loss 的 convention。这样 task reward 进入 GAE，reference regularization 留在 actor update 中，两个 training signals 的来源可以分别看清楚。

Actor 最小化 clipped policy loss：

\[\mathcal L_{\mathrm{policy}}(\theta) = -\mathbb E_t\left[ \min\left( \rho_t(\theta)\hat A_t, \operatorname{clip}\bigl(\rho_t(\theta),1-\epsilon,1+\epsilon\bigr)\hat A_t \right) \right].\]

如果我们把 reference policy 当作长期 regularization 的来源，可以直接在 actor loss 中加入 reference penalty。对于每个 rollout prefix，定义

\[\mathcal R_{\mathrm{ref}}(\theta) = \mathbb E_t\left[ D_{\mathrm{KL}} \left( \pi_\theta(\cdot\mid s_t) \Vert \pi_{\mathrm{ref}}(\cdot\mid s_t) \right) \right].\]

它比较的是 current policy 和 reference policy 在同一个 prefix 下的完整 next-token distributions。current policy 越偏离 reference，$\mathcal R_{\mathrm{ref}}$ 越大。于是 actor 的 loss 可以写成

\[\mathcal L_{\mathrm{actor}}(\theta) = \mathcal L_{\mathrm{policy}}(\theta) + \beta\mathcal R_{\mathrm{ref}}(\theta).\]

这里的 reference penalty 只作用于 actor。它不参与 GAE，也不改变 critic 的 value target；这样可以清楚地区分 PPO 的 local clipping 和 reference model 的 long-term regularization。

Critic 则 regression 到 GAE 在上一节构造的 fixed value target：

\[\mathcal L_V(\phi) = \frac12\mathbb E_t\left[ \left(V_\phi(s_t)-\hat R_t\right)^2 \right].\]

训练还可以加入 optional entropy bonus，避免 next-token distribution 过早变得过于集中：

\[\mathcal H_t = -\sum_{v\in\mathcal V} \pi_\theta(v\mid s_t) \log\pi_\theta(v\mid s_t).\]

在这个 convention 下，整体 training objective 可以概括为

\[\mathcal L_{\mathrm{total}} = \mathcal L_{\mathrm{actor}} +c_V\mathcal L_V -c_H\mathbb E_t[\mathcal H_t].\]

有些 LLM RLHF 实现会采用另一种 convention，把 sampled reference KL 写进 rollout reward。对于 sampled token $a_t$，可以使用

\[r_t = r_t^{\mathrm{task}} - \beta \left[ \log\pi_{\mathrm{old}}(a_t\mid s_t) - \log\pi_{\mathrm{ref}}(a_t\mid s_t) \right].\]

这时 KL penalty 会进入 GAE，进而同时影响 actor 的 $\hat A_t$ 和 critic 的 $\hat R_t$。它仍然表达 reference regularization，只是 regularization 的路径经过了 reward、advantage 和 value target。

这种写法并不只是工程上的方便。把 reference KL 放进 reward，等价于直接优化 KL-regularized RL objective

\[\max_{\pi}\; \mathbb E_{x\sim\mathcal D,\;y\sim\pi(\cdot\mid x)} \left[ r^{\mathrm{task}}(x,y) \right] - \beta\, \mathbb D_{\mathrm{KL}} \left[ \pi(\cdot\mid x) \,\|\, \pi_{\mathrm{ref}}(\cdot\mid x) \right],\]

而这个 objective 对 $\pi$ 有 closed-form optimum (Rafailov et al., 2023)：

\[\pi^{*}(y\mid x) = \frac{1}{Z(x)} \pi_{\mathrm{ref}}(y\mid x) \exp\left( \frac{1}{\beta} r^{\mathrm{task}}(x,y) \right), \qquad Z(x) = \sum_{y} \pi_{\mathrm{ref}}(y\mid x) \exp\left( \frac{1}{\beta} r^{\mathrm{task}}(x,y) \right).\]

也就是说 reference KL 不是为了稳定训练临时加上去的 penalty，而是 objective 本身的一部分：它定义出来的最优 policy 就是 reference policy 被 reward 做指数倾斜（exponential tilting）后的分布，$\beta$ 控制倾斜的强度。$\beta$ 很大时 $\pi^{}$ 退回 $\pi_{\mathrm{ref}}$，$\beta$ 很小时 $\pi^{}$ 集中到 reward 最高的 responses 上。DPO 正是从同一个 optimum 出发，把它反解成关于 reward 的表达式，从而绕开显式的 RL 循环。

把 KL 写进 reward 之后，RL 这一层就变回一个普通的 maximize-return 问题，而它的 optimum 恰好是上面的 $\pi^{*}$。相比之下，把 KL 留在 actor loss 里更接近对每次更新附加一个 proximity penalty：它只作用在 actor 的 gradient 上，不进入 return，也不经过 credit assignment。两种写法都在表达 reference regularization，但优化的并不是同一个 objective，因此只能二选一，不能把同一个 reference penalty 同时放进 reward 和 actor loss。

Actor 与 critic 使用独立 models 和 optimizers 时，两条 losses 会分别 backward；如果它们共享 backbone，两种 training signals 都可能更新 shared parameters。Reference model、reward model、old log-probabilities、advantages 和 value targets 在当前 PPO update 中都不接收 gradient。

一次完整的 iteration 因而形成下面的循环：

1. 用 $\pi_{\mathrm{old}}$ 为一批 prompts 生成 responses，并保存 sampled tokens、old log-probabilities 和 old values；reference policy 的 log-probabilities 可以在 rollout 时保存，也可以在 actor update 时由 frozen reference model 重新计算。
2. 计算 task rewards，再用 GAE 得到 fixed advantages $\hat A_t$ 和 value targets $\hat R_t$。
3. 将 rollout batch 分成 minibatches。Current actor 重新计算 sampled-token probabilities，通过 ratio、clipping 和 reference regularization 更新 $\theta$；current critic 重新计算 prefix values，通过 value loss 更新 $\phi$。
4. 在当前 batch 上完成有限次 updates 后丢弃这些 rollouts。更新后的 policy 生成下一批 responses，并成为下一轮的 $\pi_{\mathrm{old}}$。

现在可以把 PPO 的核心逻辑串起来：rollout batch 提供 old-policy evidence，probability ratio 让这些 samples 进入 current-policy surrogate，并衡量 sampled actions 的 probabilities 已经改变了多少；clipping 限制同一批 fixed advantages 还能继续带来多少优化收益。Value model 为每个 prefix 提供 baseline 和 bootstrap prediction，reference regularization 则在许多 iterations 上约束长期漂移。完成一次局部 update 后，policy 重新 rollout，整套 evidence 随之刷新。

Group Relative Policy Optimization（GRPO）

上一节讲清楚了 PPO 如何使用 advantage 更新 policy，但也留下了一个很实际的问题：为了得到这些 advantages，一次完整的 LLM PPO update 需要准备哪些模型？

在 policy optimization 这一条主线上，PPO 需要同时处理三个核心模型。Policy model 是真正被更新的 actor；value model 读取每个 prefix，预测从这里继续生成时可能得到的 expected return；reference model 通常固定为 SFT model，为长期训练提供 KL regularization。除此之外，系统还需要一个 reward model 或 verifier 给完整 response 提供 task reward。Old policy 则是当前 rollout 时的 policy snapshot，通常通过保存 old log-probabilities 表示，不一定需要额外保留一份完整模型。

其中，value model 是 PPO 的一项额外负担。上一节中，GAE 需要用 $V_\phi(s_t)$ 作为 prefix-dependent baseline，并构造 value target $\hat R_t$，所以每一轮 PPO 除了更新 policy，还要让 value model 拟合来自 sampled responses 的 targets。这些 targets 带有 sampling noise，policy 更新后其对应的 prefixes 和 rewards 也会改变；在 terminal-reward LLM setting 中，critic 还要把 response 结尾才出现的 reward 传播回更早的 prefixes。于是可以提出一个更具体的问题：如果我们已经为同一个 prompt 采样了多个 responses，能不能直接用这组 responses 的相对表现构造 advantage，从而省去单独训练 value model？

GRPO 的核心思路就是从这个问题出发的。它不再先为每个 prefix 训练一个 value prediction，而是让同一个 prompt 生成一组 responses，然后在这组 responses 内部比较 reward。相对于同组其他 responses 表现更好的 response 得到正的 update signal，表现更差的 response 得到负的 update signal (Shao et al., 2024)。

图 2 把两条 pipeline 放在一起。两边都保留 policy、reward model 或 verifier，以及 reference policy；区别集中在 advantage 从哪里来：PPO 需要一个被训练的 value model，再由 GAE 把 reward 和 value 组合成 per-token advantage，同时 GAE 隐含的 return 还要作为 value target，通过 value loss 反过来训练这个 critic（图里指回 value model 的虚线就是这条通路）。GRPO 则把单次采样换成一组 responses，组内的 mean 充当 baseline、standard deviation 只负责 rescale，于是 critic 连同它的 value loss 一起消失了。图里所有虚线都表示 parameter update：PPO 有两条，一条从 advantage 回到 policy，一条把 value target 送回 critic；GRPO 只剩下回到 policy 的那一条。PPO-style 的 ratio 和 clipping 在图里省略了，因为这张图想突出的是 baseline 从哪里来，以及 KL 在哪一步进入优化流程。

图里 PPO 的 KL 走的是 reward 这条路径：reference 的 log-probability 先从 task reward 里减掉，得到 per-token 的 $r_t$，之后才交给 GAE，所以 advantage 和 value target 都带着这个 penalty。前面推导 clipped loss 时为了把 task signal 和 regularization signal 分开看，暂时把 KL 留在了 actor loss 里；这里画成 reward 版本，是因为它对应上面那个有 closed-form optimum 的 KL-regularized objective，也是 RLHF 实现中更常见的写法。GRPO 没有 critic，KL 也就没有必要经过 reward——它留到 advantage 之后，在 policy optimization 那一步才被减掉，这样 group 的 mean 和 standard deviation 只由 task reward 决定，normalization 不会被 penalty 污染。两个面板各有一个「$-$」节点，它们在 pipeline 上的位置差别就是这两种 convention 的差别，也是前面说的「只能二选一」在图上的体现。图里采用 maximizing-objective 的写法，所以 GRPO 那一项是 $-\beta\,\mathrm{KL}$；如果按 minimization loss 来写，它就是 $+\beta\,\mathrm{KL}$。

从同一个 Prompt 采样一组 Responses

给定一个 prompt $x$，用 rollout-time policy $\pi_{\mathrm{old}}$ 采样 $G$ 个 responses：

\[y_1,y_2,\ldots,y_G \sim \pi_{\mathrm{old}}(\cdot\mid x).\]

Reward model 或 verifier 分别为它们给出 response-level rewards：

\[R_1,R_2,\ldots,R_G.\]

这些 responses 共享同一个 prompt，所以它们提供了一个自然的比较环境。先计算这一组的平均 reward：

\[\bar R = \frac{1}{G}\sum_{j=1}^{G}R_j.\]

对于 response $y_i$，我们可以用它相对于组内平均值的差异作为 relative advantage：

\[\tilde A_i=R_i-\bar R.\]

如果 $\tilde A_i>0$，说明这个 response 的 reward 高于同一个 prompt 下这组 samples 的平均表现，policy 应该提高生成它的 probability。如果 $\tilde A_i<0$，说明它在这组比较中表现较差，policy 应该降低它的 probability。

实际实现中通常还会用组内标准差进行 normalization：

\[\hat A_i = \frac{R_i-\bar R} {\operatorname{std}(R_1,\ldots,R_G)+\epsilon}.\]

标准化主要调整 update signal 的 scale。当一组 responses 的 reward 差异很大时，update 可以更强；当它们的 reward 很接近时，relative advantages 会更小。这里的 group mean 提供了一个 prompt-conditioned baseline，但它和 PPO 中的 value function 仍然不同：value function 试图对任意 prefix 预测未来 return，而 group mean 只在当前采样出来的这一组 responses 中，描述这个 prompt 的相对平均表现。

Relative Advantage 如何进入 Token-Level Update

到这里，GRPO 得到的是一个 response-level advantage。对于 response $y_i$ 中的每一个 sampled token $a_{i,t}$，通常使用同一个 $\hat A_i$：

\[\hat A_{i,t}=\hat A_i.\]

这也构成了 GRPO 与 PPO 的一个重要区别。两者最终都要在 token level 计算 policy loss，因为 language model 的 probability 本来就是逐个 next token 产生的；差别在于每个 token 前面的 advantage 从哪里来，以及它是否随 prefix 改变。

在 PPO 中，GAE 和 value model 为不同 prefixes 估计不同的 $\hat A_t$。同一条 response 中，较早和较晚的 tokens 可以因为各自的 value prediction 不同而得到不同的 advantages。GRPO 则先比较同一个 prompt 下的完整 responses，再把某条 response 的 relative advantage 分配给其中所有 tokens：

\[-\hat A_i \sum_{t=1}^{T_i} \log\pi_\theta(a_{i,t}\mid s_{i,t}).\]

同一条 response 的所有 tokens 因此共享一个 $\hat A_i$。这个 signal 仍然没有判断某个 token 单独对最终结果贡献了多少，它只表达一个 response-level 的判断：在当前 prompt 下，这条完整 response 相比同组 responses 表现更好还是更差。GRPO 省去的是 prefix-level value prediction，以及由此产生的逐 token advantage estimation；使用这个 signal 完成 update 的 loss 仍然由 response 中每个 token 的 log-probability 组成。

GRPO 与 PPO Objective 的关系

到这里，GRPO 已经提供了一个不依赖 value model 的 $\hat A_i$。接下来仍然可以使用 PPO 的 probability ratio，因为 rollout responses 依旧由 old policy 生成，而 current policy 会在同一批 data 上执行多个 optimizer steps：

\[\rho_{i,t}(\theta) = \frac{\pi_\theta(a_{i,t}\mid s_{i,t})} {\pi_{\mathrm{old}}(a_{i,t}\mid s_{i,t})}.\]

将这个 ratio 与 group-relative advantage 结合，并保留 PPO 的 clipping，可以得到 GRPO 的核心 policy objective：

\[\mathcal L_{\mathrm{GRPO}}(\theta) = -\mathbb E_{i,t} \left[ \min\left( \rho_{i,t}(\theta)\hat A_i, \operatorname{clip} \bigl(\rho_{i,t}(\theta),1-\epsilon,1+\epsilon\bigr)\hat A_i \right) \right].\]

它和 PPO clipped objective 的结构相同，变化集中在 advantage 的来源：这里的 $\hat A_i$ 来自上面构造的 group-relative reward。Ratio 仍然负责把 old-policy samples 重新加权到 current-policy objective 中，clipping 仍然限制 fixed rollout evidence 能够推动 policy 移动多远。

如果训练中还使用 reference model，GRPO 也可以加入和 PPO 相同的 reference regularization：

\[\mathcal L_{\mathrm{actor}}(\theta) = \mathcal L_{\mathrm{GRPO}}(\theta) + \beta\mathcal R_{\mathrm{ref}}(\theta).\]

这里不再有 value loss，因为 GRPO 没有训练 value model，也就不需要拟合 GAE 产生的 $\hat R_t$。Reward model 或 verifier 仍然需要存在，reference model 也仍然可以存在。GRPO 去掉的是 critic 这条训练路径，并没有去掉 task reward 或 reference regularization。

一次完整的 GRPO Update

一次 GRPO iteration 可以按下面的顺序理解：

1. 对每个 prompt，用 rollout-time policy 采样一组 responses，并保存 sampled tokens 以及 old log-probabilities。
2. 用 reward model 或 verifier 为每条 response 计算一个完整的 reward，再在同组 responses 内计算 mean、standard deviation 和 relative advantages。
3. Current policy 重新计算 sampled-token probabilities，用 probability ratio、group-relative advantage 和 PPO clipping 构造 actor loss；如果需要，再加入 reference-model regularization。
4. 在这批 group samples 上执行有限次 optimizer steps，随后重新 rollout，让下一批 responses 提供新的 group comparisons。

PPO 和 GRPO 最终都更新 token probabilities，但构造 update coefficient 的方式不同。PPO 询问的是：从当前 prefix 出发，未来 expected return 相比 value model 的预测高出了多少？GRPO 询问的是：对于同一个 prompt，这条 response 的 reward 相比同组其他 responses 高出了多少？GRPO 的核心简化在于，它不尝试从单条 response 中完成 token-level credit assignment。它先得到 response-level relative performance，再把这个结果转化成共享的 token-level policy signal；PPO 的 ratio 和 clipping 则继续负责安全地使用这批 evidence。

从 GRPO 出发：Policy Optimization 还可以怎样改进？

GRPO 去掉了 value model，让同一个 prompt 下多条 responses 的相对 reward 直接参与 policy update。训练流程因此更轻了，许多原本由 value model 和 PPO training loop 承担的选择，也转移到了 group signal、loss weighting、ratio/clipping 和 rollout organization 上。

我们先从 GRPO 自己的 objective 看起。一个看似简单的 normalization，可能改变不同 prompts 和不同长度 responses 在训练中的权重；当这些选择逐渐暴露出限制时，后续方法就会沿着具体问题继续修改。

Dr. GRPO 与 DAPO：Group Signal 与 Objective Weighting

先把 GRPO 中两个会影响 update scale 的 choice 写出来。给定同一个 prompt 的 rewards $R_1,\ldots,R_G$，GRPO 先减去 group mean：

\[\tilde A_i=R_i-\bar R, \qquad \bar R=\frac{1}{G}\sum_{j=1}^{G}R_j.\]

随后，常见的 GRPO 写法还会用 group standard deviation 对它进行 normalization：

\[\hat A_i=\frac{\tilde A_i}{\operatorname{std}(R_1,\ldots,R_G)+\epsilon}.\]

减去 group mean 的作用是提供一个 baseline。它回答的是“这条 response 相对于同组平均表现好多少”，这正是 GRPO 想要的比较。除以 standard deviation 又做了另一件事：它会根据每个 group 自己的 reward spread，重新缩放这个 prompt 的所有 updates。于是，不同 prompts 的 update strength 会受到各自 group composition 的影响。

举一个 binary reward 的例子。第一个 group 的 rewards 是 $(1,1,0,0)$，mean 是 $0.5$，population standard deviation 是 $0.5$，所以成功和失败 response 的 advantages 分别是 $+1$ 和 $-1$。第二个 group 的 rewards 是 $(1,0,0,0)$，mean 是 $0.25$，standard deviation 约为 $0.433$，成功 response 的 advantage 约为 $+1.73$，失败 responses 的 advantage 约为 $-0.58$。两组都在做同一件事：比较成功和失败 responses；经过 group-level normalization 后，单条 response 的 update scale 却不同了。

这种 scaling 本身不一定不合理。它会放大 group 中的 rare outcomes，这可能帮助 policy 关注少数正确 response 或少数错误 response。问题在于，这个放大只由当前 group 的 reward spread 决定，standard deviation 无法判断 rare outcome 是有价值的探索，还是一次 sampling noise。

如果我们希望每个 prompt 按原始数据分布参与训练，那么 per-group standard deviation 就引入了额外的 prompt weighting：低 standard deviation 的 group 会得到更大的 advantage coefficient。这个额外的 reweighting 并不属于原本的 expected-reward objective，因此需要单独审视。这个选择减少了 prompt-specific scaling，也保留了 group mean 作为 baseline 的作用。

GRPO objective 还有一个与此独立的 length normalization。把 ratio、clipping 和 advantage 组合成的 token-level term 简记为 $\ell_{i,t}(\theta)$，一种常见的 response-level aggregation 方式是先在每条 response 内对 token loss 求平均，再对同一个 batch 中的 responses 求平均：

\[\mathcal L_{\mathrm{response}}(\theta) =- \frac{1}{G} \sum_{i=1}^{G} \frac{1}{T_i} \sum_{t=1}^{T_i} \ell_{i,t}(\theta).\]

这种写法让每条 response 在 batch 中拥有相同的总权重。假设一条 response 有 $100$ 个 tokens，另一条有 $1000$ 个 tokens，那么前者每个 token 的系数是 $1/100$，后者每个 token 的系数是 $1/1000$。长 response 中单个 token 的 update signal 只有短 response 的十分之一。这里没有代数错误，它表达的是“每条 response 作为一个整体等权参与训练”的选择。

问题在于，terminal reward 会被复制到同一条 response 的所有 tokens 上。对于一条获得正 advantage 的长 response，这意味着它包含的许多 reasoning tokens 都在共同分享一个被 $1/T_i$ 缩小的 signal；对于一条获得负 advantage 的长 response，每个 token 受到的惩罚也同样变弱。于是，response length 会影响 reward 最终如何转换成 token updates。对于 long CoT，这种 weighting choice 可能产生 response-level length bias。

Dr. GRPO（Group Relative Policy Optimization Done Right）的改动可以直接对应到上面两个 normalization (Liu et al., 2025)。对于 group-level signal，它保留 centered reward，也就是

\[\hat A_i^{\mathrm{Dr}}=R_i-\bar R,\]

Dr. GRPO 选择省略 group standard deviation，是因为它会给每个 prompt 加上一个由当前 group composition 决定的额外缩放。某个 group 的 rewards 如果恰好比较接近，standard deviation 就比较小，原本很小的 reward difference 会被放大；另一个 group 的 rewards 如果分布更分散，同样大小的 reward difference 反而会被缩小。于是，一条 response 的 update strength 会受到同组其他 responses 的 sampling 结果影响。

这个缩放可能有助于强调 rare outcomes，但它也可能把 prompt 难度和 sampling noise 混进 policy update。Dr. GRPO 因此保留 group mean 带来的 relative comparison，只去掉这层额外的 prompt-dependent scaling，让 reward difference 本身决定 update signal 的大小。

它同时去掉 per-response 的 $1/T_i$ normalization，并用一个固定的 global denominator 聚合所有 token contributions。这样，response length 不会再通过每条 response 自己的 token count 改变单个 token 的系数。用前面定义的 $\ell_{i,t}(\theta)$ 表示 token-level clipped surrogate，Dr. GRPO 的核心可以简写为

\[\mathcal L_{\mathrm{Dr.GRPO}}(\theta) \propto -\sum_i\sum_{t=1}^{T_i} \ell_{i,t}(\theta;\hat A_i^{\mathrm{Dr}}),\]

这里省略了固定的 loss denominator；关键点是它不再使用当前 response 的 token count。

因此，Dr. GRPO 的重点是修正已有 group-relative signal 进入 objective 的方式。它保留 group comparison，同时去掉 group standard deviation 和 per-response length normalization，让 prompt difficulty 与 response length 不再通过额外 weighting 改变 update strength。

这个 weighting 修正仍然建立在 group 内存在 reward variation 的前提上。DAPO（Decoupled Clip and Dynamic Sampling Policy Optimization）保留 group-relative advantage 的基本形式，包括 group standard deviation (Yu et al., 2025)：

\[\hat A_i^{\mathrm{DAPO}} = \frac{R_i-\bar R} {\operatorname{std}(R_1,\ldots,R_G)+\epsilon}.\]

它面对的是另一种情况：有些 group 从一开始就没有 relative signal。对于 binary reward，假设同一个 prompt 采样了四条 responses。如果它们全部正确，reward 是

\[(1,1,1,1),\]

group mean 是 $1$，每条 response 的 centered reward 都是 $0$。如果它们全部错误，reward 是

\[(0,0,0,0),\]

group mean 是 $0$，centered reward 仍然全部是 $0$。这听起来完全合理，因为这两种情况下 group 内都没有可供比较的信息。全对的 group 没有告诉我们哪条 response 更好；全错的 group 也没有告诉我们哪条 response 值得提高 probability。GRPO 从这样的 group 得到零 policy gradient，是这个 estimator 的自然结果。

训练效率的问题在于，随着 policy 变强，越来越多 prompts 可能采样出全对的 responses；对于仍然困难的 prompts，也可能长期采样出全错的 responses。每次 rollout 仍然要生成并评分这些 responses，但它们没有给 group-relative update 提供有效方向。训练 batch 中真正提供 signal 的 prompts 变少以后，gradient 会变弱，也会更容易受到剩余 samples 的噪声影响。

DAPO 的 Dynamic Sampling 对 binary reward group 加入了这个条件：

\[0<\sum_{i=1}^{G}R_i<G.\]

这个条件表示 group 中至少有一条成功 response，也至少有一条失败 response。DAPO 会过滤掉 accuracy 为 $0$ 或 $1$ 的 groups，并继续采样，直到 batch 中积累足够多 mixed groups。它没有声称 all-correct group 在逻辑上有一个隐藏的 token-level gradient；它只是避免把大量计算花在当前 group-relative estimator 无法提供方向的 samples 上。

DAPO 还处理了 long-CoT 训练中的三个额外问题。

第一处是 clipping。标准 PPO-style clipping 使用对称的 interval：

\[[1-\epsilon,\,1+\epsilon].\]

对于 positive advantage，policy 会尝试提高 sampled token 的 probability；当 ratio 超过上界以后，clipped objective 不再奖励它继续增大。举一个具体例子：假设 rollout 时某个 token 的 probability 只有 $0.01$，PPO 的 upper clip 是 $1.2$。如果把这个 ratio boundary 暂时理解成一个 hard constraint，那么这个 token 的 probability 最多只能被推到

\[0.01\times 1.2=0.012.\]

它的绝对增幅只有 $0.002$。而一个本来就比较常见的 token，即使使用同样的 relative ratio，也拥有更大的 absolute probability change。这里还要注意，PPO clipping 实际上约束的是 surrogate objective，并不严格保证 current policy 的 probability 永远不超过 $0.012$；它的直接作用是，ratio 超过 $1.2$ 后，这条 sample 不再继续提供沿 positive advantage 方向的额外优化收益。

这就解释了为什么 upper clip 可能限制 exploration。一个低概率 token 可能因为少量 successful rollouts 获得 positive advantage，但它还没有来得及从 $0.01$ 增长到一个更容易被再次采样的概率，就已经进入 clipped region，后续 update 很难继续通过这条 evidence 推动它。DAPO 将这种策略命名为 Clip-Higher，也就是把 lower clip 和 upper clip 解耦，并把 upper bound 设得更宽。这样，policy 仍然限制了过大的更新，同时给低概率 exploration tokens 留出更大的 probability growth space。

第二处是 loss aggregation。前面介绍 Dr. GRPO 时已经看到，去掉 per-response 的 $1/T_i$ 以后，objective 可以直接累积所有 active tokens。DAPO 在这一点上采取了相近的选择，将它明确写成 Token-Level Policy Gradient Loss：

\[\mathcal L_{\mathrm{token}}(\theta) =- \frac{\sum_i\sum_{t=1}^{T_i}\ell_{i,t}(\theta)} {\sum_i T_i}.\]

在 DAPO 中，denominator 使用当前 batch 的 active-token 数量 $\sum_iT_i$。因此同一个 batch 内每个 active token 的系数相同，长 response 也会因为包含更多 tokens 而拥有更大的总贡献。Dr. GRPO 使用固定的 global denominator，DAPO 使用 batch-dependent denominator；两者在 token aggregation 上属于同一种思想，主要差别体现在整体 gradient scale。

第三处是 overlong response 的 reward treatment。长 CoT 训练通常会设置最大 generation length。一条 response 如果在预算耗尽时被截断，verifier 看到的可能只是一个没有完成的答案；此时得到失败 reward，并不能区分 reasoning 本身错误和 response 只是还没有生成完。如果所有被截断的 responses 都被当作普通失败样本，policy 可能会压低一条本来有价值的 reasoning trajectory。

DAPO 在这里提供了两种处理方式。第一种是 Overlong Filtering：直接 mask 掉被截断 response 的 policy loss，不让它参与这一轮的 update。这个选择相当于承认，这条 response 的最终 reward 不足以判断它的 reasoning 是否有效，因此暂时不使用这份 evidence。

第二种是 Soft Overlong Punishment。它在最大长度之前设置一个 buffer 区域。response 没有进入这个区域时不受到 length penalty；进入 buffer 后，越接近最大长度，penalty 越大；超过最大长度时，施加最大的惩罚。令 $L_{\max}$ 为最大长度，$L_{\mathrm{cache}}$ 为 buffer 长度，一种分段形式是

\[R_{\mathrm{len}}(y)= \begin{cases} 0, & |y|\leq L_{\max}-L_{\mathrm{cache}},\\ \dfrac{(L_{\max}-L_{\mathrm{cache}})-|y|}{L_{\mathrm{cache}}}, & L_{\max}-L_{\mathrm{cache}}<|y|\leq L_{\max},\\ -1, & |y|>L_{\max}. \end{cases}\]

这个 reward shaping 给了 policy 一个逐渐变强的 signal：模型可以继续进行较长 reasoning，但越接近 generation budget，就越需要学会更早结束。相比把所有超长 responses 统一标记为失败，这种处理减少了截断带来的 reward noise，也把 length budget 转化成了更连续的训练信号。

这样看，Dr. GRPO 和 DAPO 解决的是相邻但不同的问题。Dr. GRPO 重新审视 GRPO objective 如何给 response 和 token 分配权重；DAPO 则进一步处理 long-CoT 训练中的 exploration、有效 sampling、loss aggregation 和 overlong responses。两者都继续使用 group-relative advantage，也都不需要单独训练 value model。它们的核心变化集中在 advantage 之后的 objective，以及 rollout 数据进入 training loop 的方式。

这也留下了一个具体问题：GRPO 的 reward 和 advantage 都是在完整 response 上定义的，但 ratio 和 clipping 仍然作用在每个 token 上。Response-level reward 与 token-level policy correction 之间是否一定要这样对应？如果我们把整条 response 看成一次完整的 sampling event，importance correction 是否也应该在这个层次上进行？

GSPO：让 Importance Ratio 与 Response 对齐

GRPO 和 DAPO 都从整条 response 得到一个 relative advantage，再把 policy loss 展开到这条 response 的 tokens 上。这里先区分两个层次：response-level reward 如何传回 autoregressive policy，以及 old policy 与 current policy 的 probability mismatch 如何被修正。前者本身并不奇怪，因为一条 response 的 log probability 可以分解为

\[\log\pi_\theta(y_i\mid x) = \sum_{t=1}^{T_i} \log\pi_\theta(y_{i,t}\mid s_{i,t}).\]

因此，如果 $\hat A_i$ 是整条 response 的 advantage，那么

\[\hat A_i \sum_{t=1}^{T_i} \nabla_\theta\log\pi_\theta(y_{i,t}\mid s_{i,t})\]

这就是 response-level reward 进入 token-level policy gradient 的方式。整条 response 的 advantage 共享给其中的 tokens，来自 response probability 的链式分解。这个对应关系本身可以保留，接下来需要检查的是另一个层次：importance ratio 是否也应该逐 token 计算。

真正需要重新检查的是 importance ratio。GRPO 在 token-level objective 中使用

\[\rho_{i,t}(\theta) = \frac{\pi_\theta(y_{i,t}\mid s_{i,t})} {\pi_{\mathrm{old}}(y_{i,t}\mid s_{i,t})}.\]

于是同一条 response 的不同 tokens 会拥有不同的 policy-change coefficient。省略 clipping 后，一条 response 对 gradient 的贡献可以写成

\[g_i^{\mathrm{GRPO}} \propto \hat A_i \sum_{t=1}^{T_i} \rho_{i,t}(\theta) \nabla_\theta \log\pi_\theta(y_{i,t}\mid s_{i,t}).\]

对于短 response，这些 token-level ratios 可能还比较容易控制。response 变长以后，许多 sampled tokens 的 local ratios 会一起进入 update，局部 ratio 的波动也会逐渐累积。此时，sequence-level reward 配合 token-level importance correction，可能产生 high-variance gradient。直观地说，训练信号评价的是整条 response 的结果，importance correction 却把这条 response 拆成许多局部的 probability changes 来处理。response 越长，这些局部变化越多，单个 token ratio 的噪声就越容易影响整条 response 的 update。

如果把整条 response 当作 importance-sampling 的对象，它的 likelihood ratio 应该由整条 response 的 likelihood 构成：

\[\frac{\pi_\theta(y_i\mid x)} {\pi_{\mathrm{old}}(y_i\mid x)} = \prod_{t=1}^{T_i} \rho_{i,t}(\theta).\]

Group Sequence Policy Optimization（GSPO）正是从这个角度重新定义 importance ratio。它使用 length-normalized geometric mean (Zheng et al., 2025)：

\[s_i(\theta) = \left( \prod_{t=1}^{T_i}\rho_{i,t}(\theta) \right)^{1/T_i} = \exp\left( \frac{1}{T_i} \sum_{t=1}^{T_i}\log\rho_{i,t}(\theta) \right).\]

这里的平均发生在 log-ratio 上，所以它是 geometric mean，并非 arithmetic mean。$s_i$ 给整条 response 一个共同的 policy-change coefficient，同时避免长 response 仅仅因为包含更多 tokens 就产生更极端的 ratio。这样，response-level reward、importance ratio 和 clipping 使用了同一个 response-level 的对象。

因此，GSPO 可以把 GRPO 风格的 objective 写成 sequence-level clipping：

\[\mathcal L_{\mathrm{GSPO}} = -\frac{1}{G} \sum_{i=1}^{G} \min\left( s_i\hat A_i,\, \operatorname{clip} \left( s_i,1-\epsilon,1+\epsilon \right)\hat A_i \right).\]

这里的 $\hat A_i$ 仍然来自整条 response 的 relative reward，并且仍然会传回这条 response 中所有 token 的 log-probability gradients。变化发生在 ratio、clipping 和 objective aggregation 的单位：GRPO 为每个 token 使用不同的 $\rho_{i,t}$，GSPO 先为整条 response 计算一个共同的 $s_i$，再对这个 sequence-level quantity clipping。GSPO 改变的是 old rollout evidence 的整体 reweighting，response-level advantage 进入 token-level gradient 的方式仍然来自同一个 log-probability decomposition。

在 agentic search 场景中，Dynamic-filter Sequence-level Policy Optimization（DSPO）将 GSPO 的 sequence-level optimization 与 DAPO 风格的 dynamic filtering 结合起来：前者处理长 trajectory 上的 update stability，后者过滤全成功或全失败的 groups，保证 group-relative signal (Gu et al., 2025)。它更像是面向 agentic RL 的组合方案，这里不再单独展开。

Sequence-level ratio 解决了 reward 与 importance correction 的粒度不一致问题，但 clipping 本身仍然沿用 PPO 的 hard boundary。这个 boundary 是否是控制 fixed rollout evidence 的最好方式？

CISPO 与 SAPO：重新思考 Clipping

先 recall PPO 的 actor loss。CISPO 后面要改变的，正是这一部分的 policy objective。这里暂时只写 actor loss，value loss 和 reference-model regularization 不影响我们对 clipping 的比较：

\[\mathcal L_{\mathrm{PPO}} = -\mathbb E_t\left[ \min\left( \rho_t\hat A_t, \operatorname{clip}(\rho_t,1-\epsilon,1+\epsilon)\hat A_t \right) \right],\]

其中

\[\rho_t = \frac{\pi_\theta(a_t\mid s_t)} {\pi_{\mathrm{old}}(a_t\mid s_t)}.\]

$\hat A_t$ 表示这条 sample 值不值得学习以及学习方向，$\rho_t$ 表示 current policy 相比 rollout-time policy 如何改变了这个 sampled action 的概率。PPO 比较原始的 importance-weighted term 和 clipped term，再由 $\min$ 返回其中对 policy update 更保守的值。

如 图 1 所示，PPO 进入 clipped region 后会返回一个固定的 objective term。这个 term 仍然有数值，却不再随 current policy 改变，因此该 sample 的 policy gradient 为 $0$。CISPO 要处理的正是这个 gradient path 被截断的情况。

先看 $\hat A_t>0$ 的情况。这个 token 比当前 prefix 下的预期表现更好，所以 policy 会倾向于提高它的概率。此时原始项 $\rho_t\hat A_t$ 会随着 $\rho_t$ 增大继续增加。为了限制同一批 old rollout evidence 对 policy 的推动，PPO 在 $\rho_t>1+\epsilon$ 时返回 clipped 项：

\[\min\left( \rho_t\hat A_t, \operatorname{clip}(\rho_t,1-\epsilon,1+\epsilon)\hat A_t \right) = (1+\epsilon)\hat A_t.\]

把这个情况放回 token probability 的尺度，会更容易看到它留下的 trade-off。假设 rollout 时某个 token 的 probability 是 $0.01$。它所在的 response 得到了 positive advantage，current policy 经过一次 update 后把这个 probability 提高到 $0.013$，于是

\[\rho_t=\frac{0.013}{0.01}=1.3.\]

当 $\epsilon=0.2$ 时，$\rho_t$ 已经超过 $1+\epsilon=1.2$。如果 $\hat A_t=2$，PPO 返回的 objective term 是 $(1+\epsilon)\hat A_t=2.4$。这个 term 仍然有数值，actor loss 也仍然会记录为 $-2.4$，但它已经不随 current policy 改变，所以这一条 sample 的 gradient 为 $0$。这里说的是这一条 sample 的 contribution，batch 中其他 samples 仍然可以产生 gradient。

PPO 的这个选择有明确的 conservative intuition：ratio 越过 boundary，说明 current policy 已经相对 rollout-time policy 改变了很多，继续重复使用同一条 old evidence 可能会让 update 失控。CISPO 关注的是另一面：这个 token 的 absolute probability 只从 $0.01$ 增加到 $0.013$，它仍然很少被采样；如果这条 response 是稀有但有价值的 reasoning path，PPO 已经完全停止通过它提供新的 positive signal。对于 $\hat A_t<0$ 的 sample，情况对称：当 $\rho_t<1-\epsilon$ 时，PPO 返回 $(1-\epsilon)\hat A_t$，同样停止继续放大这个方向的 incentive。

Clipped IS-weight Policy Optimization（CISPO）从这里出发。它保留 importance weight 的上界，同时让 log-probability 保持可导。具体做法是先把 ratio clip 成一个有界 coefficient，再把这个 coefficient 当作 stop-gradient 的权重，使用 REINFORCE-style 的 log-probability loss (MiniMax, 2025)：

\[\mathcal L_{\mathrm{CISPO}} = -\mathbb E_{i,t} \left[ \operatorname{sg}\left( \operatorname{clip} \left( \rho_{i,t}, 1-\epsilon_{\mathrm{low}}, 1+\epsilon_{\mathrm{high}} \right) \right) \hat A_i \log\pi_\theta(a_{i,t}\mid s_{i,t}) \right].\]

其中 $\operatorname{sg}$ 表示 stop-gradient。这里沿用 GRPO 的 notation：$\hat A_i$ 是第 $i$ 条 response 的 advantage，同一条 response 中的 token 共享这个 signal，$t$ 只索引 token。CISPO 改变的是 ratio 进入 gradient 的方式：clipped ratio 只作为 bounded update coefficient，$\log\pi_\theta$ 则显式保留了对 current policy 的可导路径。令

\[\bar\rho_{i,t} = \operatorname{clip} \left( \rho_{i,t}, 1-\epsilon_{\mathrm{low}}, 1+\epsilon_{\mathrm{high}} \right),\]

那么 CISPO 的 gradient contribution 可以直接写成

\[\nabla_\theta \mathcal L_{\mathrm{CISPO},i,t} = -\bar\rho_{i,t}\hat A_i \nabla_\theta\log\pi_\theta(a_{i,t}\mid s_{i,t}).\]

沿用上面的数值例子，$\hat A_i=2$、$\rho_{i,t}=1.3$，upper clip 为 $1.2$，因此 $\bar\rho_{i,t}=1.2$。CISPO 的 gradient coefficient 是 $1.2\times2=2.4$，这一条 sample 仍然会更新 policy。即使 $\hat A_i=100$，coefficient 也会变成 $1.2\times100=120$，advantage 仍然会影响 update 的大小。CISPO 保持 advantage 不变，clip 的对象始终是反映 policy mismatch 的 importance ratio。

为什么 ratio 里已经有 $\pi_\theta$，CISPO 还要显式写出 $\log\pi_\theta$？在 PPO 中，当 $\min$ 返回原始项时，确实可以通过

\[\nabla_\theta\rho_t = \rho_t\nabla_\theta\log\pi_\theta\]

从 $\rho_t$ 的导数中得到 log-probability gradient。当 $\min$ 返回 clipped 项时，$\rho_t$ 被截成常数，这条路径就断了。CISPO 把 clipped ratio 作为 detached coefficient，同时把 $\log\pi_\theta$ 保留在 loss 中，于是这条 gradient path 仍然存在。

这就是两条公式看起来相似、训练行为却不同的原因。PPO 在图 1 的两种 clipped case 中有

\[\nabla_\theta \mathcal L_{\mathrm{PPO},t}=0,\]

而 CISPO 保留

\[\nabla_\theta \mathcal L_{\mathrm{CISPO},i,t} = -\operatorname{sg}(\bar\rho_{i,t})\hat A_i \nabla_\theta\log\pi_\theta(a_{i,t}\mid s_{i,t}).\]

因此，CISPO 对同一条 old evidence 的处理可以直观地概括为：它限制这条 evidence 的 importance weight，仍然允许这条 evidence 通过 log-probability 产生 gradient。这个设计保留了稀有但有价值的 tokens 的学习 signal，同时避免 ratio 继续无限放大 update。

到这里，CISPO 已经解决了 PPO 在 clipped case 中直接失去 gradient 的问题。回看图 1，PPO 进入 clipped case 后，selected objective 不再随 current policy 改变，单个 sample 的 gradient 为 $0$；CISPO 则把 clipped ratio 作为 bounded coefficient，同时保留了 log-probability gradient。

为了把两种 policy-gradient behavior 放在同一个尺度上，令 $c_t$ 表示 policy gradient 中的 coefficient：

\[\nabla_\theta \mathcal L_t = -c_t\hat A_t \nabla_\theta\log\pi_\theta(a_t\mid s_t).\]

在 $\hat A_t>0$ 的情形下，图 3 使用同一个 $\rho_t$ 横轴，把三种方法对 policy-gradient coefficient 的处理画在了一起。图 1 的纵轴表示 per-token surrogate objective，图 3 的纵轴表示 policy-gradient coefficient。

先看图 3 的左图和中图。PPO 在 favorable clipping boundary 之后直接变成 $0$，CISPO 仍然保留 gradient，却把 coefficient 固定在 plateau。这是 CISPO 相对 PPO 的改进：clipped sample 仍然可以继续影响 policy update。

中图也暴露出 CISPO 还留下的一个问题：它仍然使用 hard clipping。以 upper clip $1.2$ 为例，在正 advantage 的情形下，CISPO 的 coefficient 可以写成 $c_t=\min(\rho_t,1.2)$。因此，$\rho_t=1.19$ 时，coefficient 是 $1.19$；$\rho_t=1.21$ 时，它立刻变成 $1.2$；当 $\rho_t$ 增加到 $2.0$ 时，coefficient 仍然是 $1.2$。

这里首先存在一个连续性问题：ratio 刚刚越过 clipping boundary，coefficient 就突然进入 plateau。更进一步，$\rho_t=1.21$ 和 $\rho_t=2.0$ 代表 current policy 对这个 sampled action 的相对概率变化程度不同，CISPO 却给它们相同的 coefficient。ratio 偏离 $1$ 越远，说明这个 sampled action 离 rollout 时的 policy 越远；CISPO 对这种远近差异不再继续区分。我们希望保留 CISPO 的 gradient，同时让 coefficient 随着 ratio 的偏离程度连续地减小。

这正是 Soft Adaptive Policy Optimization（SAPO）想要解决的问题。它把 hard boundary 换成一个 smooth gate：ratio 接近 on-policy point $\rho_t=1$ 时，保留大部分 update；ratio 逐渐偏离 $1$ 时，coefficient 逐渐衰减。这样，刚刚越过原来 clipping boundary 的 token 仍然可以提供较强 signal，明显偏离 old policy 的 token 则会受到更强的抑制 (Gao et al., 2025)。

SAPO 使用一个以 on-policy point $\rho=1$ 为中心的 smooth, temperature-controlled gate，让 update coefficient 随着 ratio 偏离 $1$ 逐渐衰减。它的正式形式是

\[w_{i,t}(\theta) = 4p_{i,t}(\theta)\bigl(1-p_{i,t}(\theta)\bigr), \qquad p_{i,t}(\theta) = \sigma\left( \tau_{i,t}\bigl(\rho_{i,t}(\theta)-1\bigr) \right),\]

其中 $\sigma$ 是 sigmoid，$\tau_{i,t}$ 是 temperature。$w_{i,t}$ 是 gate，实际 policy-gradient coefficient 还包含 importance ratio，即形如 $w_{i,t}\rho_{i,t}\hat A_{i,t}$。当 $\rho_{i,t}=1$ 时，$w_{i,t}=1$，update 保持完整；当 ratio 偏离 $1$ 时，$w_{i,t}$ 平滑下降。现在回到图 3 的右图，三条 SAPO 曲线对应 $\tau=2,5,10$：$\tau$ 越大，衰减越快；$\tau$ 较小时，gate 更接近未截断的 importance weighting。SAPO 还根据 advantage 的正负使用不同的 temperature，通常让 negative-token updates 使用更快的衰减，从而抑制它们在大 vocabulary 上扩散出的高方差梯度。

这三种设计可以放在同一个问题下理解。PPO/GRPO 的 hard clip 直接截断 surrogate；CISPO 把 clipped ratio 当作有界的 importance weight，保留 log-probability loss 的梯度路径；SAPO 使用连续 gate，让 update 随 ratio 的偏离程度逐渐衰减。它们都在处理 fixed rollout evidence 的有限可信范围，只是对“超过这个范围后应该怎样处理 gradient”给出了不同答案。

DRPO 与 VPO：重新思考 Reward Signal

前面的几种方法都假设 reward 已经被整理成一个可以用于 policy update 的 signal。这里把问题往前移一步：这个 signal 应该怎样表达任务真正关心的目标？Decoupled Reward Policy Optimization（DRPO）讨论 correctness 和 reasoning length 被混在同一个 scalar reward 中的情况 (Li et al., 2025)；Vector Policy Optimization（VPO）则讨论 test-time search 需要一组互相不同的 candidates，而训练目标却只鼓励某一个 scalar optimum 的情况 (Bahlous-Boldi et al., 2026)。

先看 DRPO。考虑一个数学 reasoning 任务。最基本的 correctness reward 只判断答案是否正确：正确得到 $1$，错误得到 $0$。为了减少 overthinking，实际训练中通常还会加入 length reward：在 correctness 相同的情况下，越短的 reasoning 得到的 reward 越高。例如，可以对正确 response 使用一个随长度下降的 reward $r_{\mathrm{len}}(o)$，再把它和 correctness reward 组合起来。于是，同一个 prompt 采样出的六条 responses 可能有下面的 correctness：

\[(1,1,1,0,0,0),\]

加入 length reward 后，它们的最终 rewards 可能变成

\[(0.73,0.60,0.20,0,0,0).\]

这些数值表达了一个合理的 preference：前三条都正确，但第三条更长，所以得到的 reward 更低；后三条错误，因此仍然得到 $0$。问题出现在 GRPO 的 group-relative advantage：

\[\hat A_i=R_i-\bar R.\]

这里的 group mean 是 $0.255$，因此第三条 response 的 advantage 是

\[0.20-0.255<0.\]

这条 response 明明给出了正确答案，却因为比另外两条正确 response 更长，落到了整个 group mean 的下方。它在 policy update 中得到的方向会变成负的，policy 会降低生成这条正确 reasoning trajectory 中 tokens 的概率。length reward 原本想表达“正确答案之间的效率差异”，经过 group normalization 后却可能改变 correctness signal 的方向。

这就给出了一个仍然值得优化的地方：correctness 和 length 应该怎样同时进入 learning signal？我们希望错误 responses 受到 correctness 的负向约束；正确 responses 之间再比较 efficiency，较短的正确 response 得到更强的 positive signal，较长的正确 response 得到较弱的 positive signal。较长的正确答案需要被降权，但不应该因为长度稍长就被当成错误答案。

Decoupled Reward Policy Optimization（DRPO）采用的思路是把这两种比较分开。它先根据 correctness 把 responses 分成 positive 和 negative 两组，再只在 positive responses 内部使用 length reward 重新分配权重。这样，length preference 影响的是正确 responses 之间的相对强弱，correctness signal 继续负责区分正确与错误。具体实现可以使用只在 positive group 内归一化的 length-based weights，后续的 policy optimization 仍然可以沿用已有框架。

还有一种优化空间来自 test-time search。假设我们训练的是代码生成模型，每条 response 都会在两个 test cases 上被评估，因此 reward 可以写成一个二维向量：

\[\mathbf r(y_A)=(1,0), \qquad \mathbf r(y_B)=(0,1).\]

$y_A$ 擅长第一类 test case，$y_B$ 擅长第二类 test case。若训练时固定使用 $w^{*}=(0.5,0.5)$ 把向量压成 scalar reward，那么这两条 response 的分数都是 $0.5$。另一条 response $y_C$ 如果得到 $(0.6,0.6)$，scalar reward 就是 $0.6$，训练会更偏向 $y_C$ 一类的 responses。

如果最终只需要一个 response，这个结果没有明显问题。但在 test-time search 中，我们通常会采样多个 candidates，再根据当前任务选择其中一个。此时，未来的 search 可能更重视第一类 test case，也可能更重视第二类 test case：$w=(0.9,0.1)$ 时 $y_A$ 的分数是 $0.9$，$w=(0.1,0.9)$ 时 $y_B$ 的分数是 $0.9$，而 $y_C$ 在这两种情况下都只有 $0.6$。如果训练把所有 samples 都推向 $y_C$，额外的 sampling budget 只能得到许多相似答案，search 也就失去了选择不同策略的机会。

Vector Policy Optimization（VPO）的思路是把训练目标从“找到一个 scalar reward 最高的 response”改成“生成一组 responses，覆盖不同的 reward trade-offs”。对于一个 prompt，model 生成一个 response set $S$，每条 response 都有自己的 reward vector。训练时不断改变 scalarization weight，让不同 responses 在不同的 weight 下成为 set 中最好的 candidate。

形式上，可以把每个 weight vector $w$ 看成一种可能的 downstream preference，并用

\[R(S) = \mathbb E_{w} \left[ \max_{y\in S}w^{\top}\mathbf r(x,y) \right]\]

给整个 set 评分。内层的 $max$ 表示当前 preference 会从 candidates 中选择最合适的一条；外层的 expectation 表示训练希望这个 set 对许多不同 preferences 都有可用的答案。实际方法会从满足 $w_j\geq0$ 且 $\sum_jw_j=1$ 的 weight vectors 中进行随机采样，例如使用 Dirichlet distribution。

VPO 因此改变的是 GRPO 的 learning signal：它先根据 set-level reward 计算 advantage，再沿用 policy-gradient machinery 更新生成这些 responses 的 tokens。这里需要保留的是 reward-space diversity。不同 responses 如果在所有 reward dimensions 上表现相同，即使文字表面不同，也不会为 test-time search 提供新的选择。

DRPO 与 VPO 都在 policy gradient 之前重新构造 learning signal，但它们回答的问题不同。DRPO 处理 composite reward 中 correctness 与 length 的相互干扰；VPO 处理 scalar RL 造成的 candidate collapse，并把 test-time search 所需要的 reward-space coverage 放进训练目标。它们与 CISPO、SAPO 所回答的“拿到 evidence 以后怎样限制 update”属于不同层次。

SAO：异步 Agentic RL

到目前为止，GRPO、DAPO 和 GSPO 都默认一个相对同步的训练节奏：先为每个 prompt 采样一组 responses，等这些 responses 完成并得到 rewards，再用这批 rollout 做 update。这个结构在 response 长度比较接近的任务里很自然。到了 agentic RL，一条 trajectory 可能包含几十甚至几百轮 tool interactions，不同 trajectories 的完成时间很容易拉开差距。短 trajectory 已经结束以后，仍然要等待同一个 group 中最慢的一条，rollout workers 和 learner 都可能因此出现空闲。

SAO，也就是 Single-Rollout Asynchronous Optimization，正是从这个 synchronization 问题出发 (Hou et al., 2026)。它不再要求同一个 prompt 的一组 trajectories 全部到齐，而是每个 prompt 只采样一条 rollout，trajectory 一旦完成就可以进入 learner。

这个选择首先会失去 GRPO 最重要的 baseline。GRPO 的 relative advantage 来自同一个 prompt 下多条 responses 的比较：

\[\hat A_i = R_i-\frac{1}{G}\sum_{j=1}^{G}R_j.\]

如果每个 prompt 只有一条 rollout，$G=1$，那么

\[\hat A_i=R_i-R_i=0.\]

所以 single-rollout training 不能直接沿用 group-relative advantage。SAO 在这里重新引入 PPO-style value model。对于 trajectory 中的 state $s_t$，critic $V_\phi(s_t)$ 估计从这里继续执行的 expected return，再用它构造 token-level advantage。前面介绍 PPO 时已经看到，一步 TD error 可以写成

\[\delta_t = r_t+\gamma V_\phi(s_{t+1})-V_\phi(s_t),\]

随后再通过 GAE 组合不同 horizon 的 estimates。这样，baseline 不再来自同一个 prompt 的其他 sampled trajectories，而是来自 learned value function。Single rollout 因而减少了 group synchronization，却把原来 GRPO 避开的 critic 又带了回来；value estimate 不够准确时，advantage 的 variance 也会重新成为问题。

真正让 SAO 和普通 PPO 拉开距离的是 asynchronous rollout。同步 PPO 中，一轮 rollout 通常由一个 frozen old policy 产生，等完整 batch 收集完成以后 optimizer 才开始更新。因此 sampled token 的 behavior probability 有一个清楚的来源：

\[\rho_t(\theta) = \frac{\pi_\theta(a_t\mid s_t)} {\pi_{\mathrm{old}}(a_t\mid s_t)}.\]

异步训练取消了这个干净的时间边界。Rollout generation 和 optimizer update 可以同时进行。一条 coding trajectory 可能在等待 shell、编译或者 tests 的过程中停留很久，而 learner 已经根据其他完成的 trajectories 更新了若干次。SAO 考虑的系统甚至允许 rollout engine 在同一条 trajectory 的生成过程中同步新的 weights，因此前面的 model call 和后面的 model call 可能来自不同版本的 rollout model。

例如，一条 trajectory 可能经历

\[\pi_1 \longrightarrow \text{tool execution} \longrightarrow \pi_2 \longrightarrow \text{tests} \longrightarrow \pi_4.\]

这里并不存在一份统一的 historical checkpoint，可以简单地代表整条 trajectory 的 behavior policy。

SAO 中继续使用同一个 probability ratio。第 $t$ 个 sampled token 真正来自当时 rollout engine 使用的 policy，因此写成

\[\rho_t(\theta) = \frac{\pi_\theta(a_t\mid s_t)} {\pi_{\mathrm{rollout},t}(a_t\mid s_t)}.\]

这里保留下标 $t$，因为同一条长 trajectory 的不同 model calls 可能由不同版本的 rollout model 产生。每个 token 都应该使用它真正生成时对应的 behavior policy。

仅仅有 importance ratio 还不够。如果 rollout 已经非常 stale，current policy 与 behavior policy 的 ratio 可能远离 $1$，这部分 evidence 对当前 policy 的参考价值也会越来越可疑。SAO 因此使用 Direct Double-Sided Importance Sampling，只在 ratio 落在指定区间时保留这个 token：

\[f(\rho_t;\epsilon_l,\epsilon_h) = \begin{cases} \rho_t, & 1-\epsilon_l<\rho_t<1+\epsilon_h,\\ 0, & \text{otherwise}. \end{cases}\]

这里和普通 PPO clipping 有一个重要区别。PPO 通常把过大的 ratio 截到边界；SAO 对已经偏离 trust region 的 token 直接 mask，不再让它产生 policy gradient。它宁愿丢掉一部分过旧的 evidence，也不希望这些 tokens 把 current policy 推向一个已经缺少可靠局部信息的方向。

Single-rollout 同时让 critic 的质量更加重要。SAO 实际训练中让 value model 比 actor 更新得更频繁，并在 critic training 中冻结 attention parameters，只更新部分 projection parameters；他们的 ablation 表明这些设计有助于 value model 更快跟上变化中的 policy，并降低 critic 自身的不稳定性。

Multi-turn agent 还带来一个普通 text response 没有的问题。Trajectory 往往交替包含

\[[a_0,o_0,a_1,o_1,\ldots],\]

其中 $a_i$ 是 policy 生成的 action，$o_i$ 是 environment 返回的 observation。Observation 并不是 model sample 出来的 action tokens，直接沿整个 token sequence 做相邻 value difference 会把 environment feedback 也放进 advantage propagation。SAO 因此使用 skip-observation token-level GAE，让 advantage estimation 从一个 model action 连接到下一个 model action，跳过中间的 observation tokens。

把这些设计放在一起，SAO 并不是单纯给 PPO 换一个新的 clipping rule。它首先改变 rollout 的单位：不再为一个 prompt 等待完整 group，而是让单条 trajectory 完成后尽快进入 learner。这个选择消除了 group barrier，却同时失去了 GRPO 的 relative baseline，并让 rollout generation 与 policy update 真正重叠起来。Value model、rollout-time log-probabilities、strict token masking 和 skip-observation GAE，都是这个 asynchronous single-rollout setting 随后逼出来的设计。

到这里，policy optimization 已经很难和 rollout architecture 完全分开。对于 long-horizon agent，trajectory 什么时候完成、等待多久才被使用，以及生成过程中 policy 是否已经改变，也开始决定 optimizer 最后能够相信哪些 evidence。

从 Policy Objective 到 Training Loop：Agentic RL 的实践问题

前面的 SAO 已经给出了一个很具体的信号：到了 long-horizon agentic RL，policy objective 很难再和 rollout architecture 分开设计。只是把 grouped synchronous rollout 改成 single-rollout asynchronous training，GRPO 的 relative baseline 就会消失，critic、GAE、rollout-time probabilities 和 stale-sample handling 都需要重新进入 training loop。

这背后还有一个更一般的问题。前面我们一直把 rollout 看成 optimizer 使用的一份 evidence：policy 生成 response，verifier 返回 reward，再用 advantage 决定 sampled actions 的 probabilities 应该怎样变化。对于数学 reasoning 或单轮 code generation，这个抽象相对干净。模型生成一段 response，episode 随即结束，environment 几乎没有自己的长期状态。

Agentic RL 会把这份 evidence 拉成一条真正的 trajectory。模型可能先搜索代码，再读取文件、修改实现、运行 tests，根据新的报错继续行动，最后才提交结果：

\[\tau=(s_0,a_0,o_1,s_1,a_1,o_2,\ldots,s_T).\]

这里的 action 可以是自然语言、shell command、file edit 或结构化 tool call；observation 来自一个会被前面 actions 改变的 environment。软件工程 agent 正是这种 setting 的典型例子。Nebius 将它描述为一个具有 stateful environment 和 non-trivial feedback 的 multi-turn RL 问题，与没有中间 environment feedback 的单轮 reasoning task 有明显区别 (Golubev et al., 2025)。

一旦 trajectory 变成这种 closed loop，optimizer 最后拿到的 learning signal 就取决于更多东西。Environment 是否稳定，final reward 应该归因给哪些 actions，trajectory 有没有被 rollout framework 忠实保存，等它进入 learner 时 policy 又已经变化了多少，这些问题都会影响一条形式上合法的 policy gradient 到底还值不值得相信。

一条 Rollout 是怎样被生产出来的

在数学 RL 中，environment 有时简单到几乎可以忽略。模型生成答案，exact-match checker 返回 $0$ 或 $1$，一次 rollout 就结束了。

Coding agent 的 reward 往往需要一个完整的软件环境才能计算。任务需要固定的 repository snapshot、dependencies、shell、test suite 和文件系统。Agent 的每个 action 都会改变这个环境，后续 observation 也随之改变。如果两条 concurrent rollouts 共享同一个 mutable directory，它们甚至可能直接修改彼此的代码。

因此，一条实际的 SWE rollout 往往需要先创建隔离 environment，启动 agent harness，执行一系列 tool calls，保存 actions 和 observations，最后运行 tests 得到 reward。DeepSWE 使用的 R2E-Gym 就把 Bash、Search、File Editor 和 Finish/Submit 作为 action space，并根据修改后的代码能否通过 tests 产生 sparse outcome reward。它的训练报告还记录过一个非常具体的 scaling 问题：一次 RL iteration 需要并行启动 512 个 Docker containers，规模继续增加后，Docker API server 甚至会压垮 dockerd，最后不得不使用 Kubernetes 调度这些环境 (Luo et al., 2025)。

这里真正值得注意的是，rollout throughput 已经不再只由 decoder 决定。CPU、container startup、filesystem I/O、package installation、test execution、scheduler 以及 tool latency 都可能成为瓶颈。GPU 可以很快地产生下一条 shell command，却可能随后等待几分钟 compilation；一条 trajectory 在等待 tests 时，另一条 trajectory 已经完成了十几个 model calls。

NVIDIA 的 NeMo Gym SWE case study 给出了另一组很直观的数字：16 个 prompts、每个 prompt 32 条 rollouts，意味着同时运行大约 512 个 task instances，粗略估计需要约 512 个 CPU cores。在他们当时的 setup 中，batch size 为 512 的最快 SWE RL step 仍然大约需要 20 分钟 (NVIDIA, 2026)。

所以进入 agentic RL 后，第一个实践问题甚至还没有来到 loss function。我们首先需要知道，一条 trajectory 究竟花多少钱才能产生，它是否真的来自我们想训练的 environment，以及 environment failure 会不会被误记成 policy failure。

长轨迹真正困难的是 Credit Assignment

对于 coding agent，最自然的 reward 仍然是最终结果。Patch 通过 tests 得到 $1$，否则得到 $0$：

\[R(\tau)= \begin{cases} 1, & \text{the submitted patch passes the tests},\\ 0, & \text{otherwise}. \end{cases}\]

这种 outcome reward 有一个很大的优点：它直接对应 task success，而且通常比复杂的 process reward 更难通过表面行为投机。问题在于，一条 trajectory 可以包含几十轮 tool interactions 和数十万 tokens，最终却只剩一个 scalar。

假设 agent 的行为大致是

\[\tau^{+} = [ \text{correct search}, \text{correct edit}, \text{unnecessary detour}, \text{recovery}, \text{success} ],\]

最后得到

\[R(\tau^{+})=1.\]

这条成功 trajectory 中显然存在并不值得鼓励的行为。反过来，也可能得到

\[\tau^{-} = [ \text{correct hypothesis}, \text{correct search}, \text{correct edit}, \text{bad final validation} ],\]

最终因为最后一步失败而得到

\[R(\tau^{-})=0.\]

这里的大部分行为其实值得保留。

这就是 long-horizon agent 中 credit assignment 特别棘手的地方。前面介绍 GRPO 时，我们已经看到一条 response 中的所有 sampled tokens 通常共享同一个 response-level relative advantage：

\[\hat A_{i,t}=\hat A_i.\]

对于较短的 reasoning response，这种 approximation 可以非常有效。Trajectory 越长，内部 behavior 越 heterogeneous，一个 terminal outcome 被广播给整条 trajectory 时，positive sample 中的 bad behavior 和 negative sample 中的 good behavior 就越容易被一起强化或抑制。

这类问题在真正看 trajectories 时通常比公式更加明显。训练 curve 可以很正常，entropy 没有 collapse，KL 也没有异常，甚至 average reward 还在缓慢增长，held-out agent performance 却主要表现成波动。这时候继续修改 clip range 或 learning rate 未必能触及根因。把成功和失败 trajectories 打开以后，经常首先需要问的是：当前 advantage 到底在奖励哪一段 behavior？

DeepSWE 记录过一个很具体的 failure mode。Agent 可能在前十个 steps 已经得到能够通过 tests 的 patch，随后继续随机修改文件，最后又把正确结果破坏。这个现象既和 termination 有关，也直接暴露了 credit assignment 的困难：最终 outcome 很难自动区分前面的 useful prefix 和后面的 destructive suffix。

类似的问题也出现在 overlong trajectory 上。数学 reasoning 中，一条超过 context limit 的 response 可能只是还没有来得及输出 final answer，所以 DAPO-style overlong filtering 或 soft punishment 可以减少截断带来的 noisy reward。Coding agent 中，过长 trajectory 还可能意味着另一件事：模型已经进入重复搜索、反复修改、测试失败再做相同修改的 loop。如果把所有 overlong samples 全部过滤，它们又恰好可能是一批最值得学习的 negative behaviors。

因此，没有一个脱离 trajectory semantics 的“正确长度”。训练至少需要知道 episode 为什么结束：主动 Finish、tests success、context exhaustion、timeout、max steps，还是 environment failure。它们最终都可能产生一个 $0$，却并不代表同一种 policy behavior。

这里也不一定需要立即解决完美的 per-token causal attribution。实践里一个有用的折中，是只寻找足够可信的局部 boundary。假设 trajectory 中存在一个明显的 first error：

\[[ \underbrace{a_0,\ldots,a_k}_{\text{useful prefix}}, \underbrace{a_{k+1},\ldots,a_T}_{\text{bad suffix}} ].\]

即使我们不能证明每个 action 的精确 causal contribution，只要能够避免因为最终 failure 把前面明显正确的 prefix 一起压低，learning signal 就可能已经更干净。一种做法是保留 prefix，从这个 state 重新 rollout suffix；另一种更一般的做法，则是重新学习 prefix-dependent value。

而这恰好把问题带回了前面已经出现过的 critic。

Critic 回来以后，Credit Assignment 变成了 Value Estimation

回头看 PPO 和 GRPO，它们真正不同的地方之一，就是 advantage 的来源。

GRPO 使用同 prompt 下完整 responses 的相对表现：

\[\hat A_i = R_i-\bar R,\]

然后把这个 signal 分给整条 response。

PPO 则尝试估计每个 prefix 的 future return：

\[V^\pi(s_t) = \mathbb E_\pi[G_t\mid s_t],\]

并通过 TD error 和 GAE 得到随 state 改变的 advantage：

\[\delta_t = r_t+\gamma V_\phi(s_{t+1})-V_\phi(s_t).\]

所以 value model 并不能给出关于 causal attribution 的完美答案。它无法证明“第 17 步修改导致了最终成功”。它做的是另一件事：随着 trajectory 展开，为不同 prefixes 估计 expected future return，让不同位置至少可以得到不同的 baseline。

如果一个 action 以后，trajectory 所处 state 的 expected return 从

\[V_\phi(s_t)=0.3\]

变成

\[V_\phi(s_{t+1})=0.7,\]

那么这个 transition 至少提供了比“整条 trajectory 最后成功”更局部的信息。如果中间没有即时 reward 且 $\gamma=1$，对应的 TD error 约为 $0.7-0.3=0.4$。Value estimation 因此可以看成一种 learned credit assignment。

这也让前面的 SAO 多了一层实践上的解释。SAO 选择 single rollout 后，GRPO 的 group baseline 无法继续使用，于是 critic 被重新引入。系统上，这是为了摆脱 group synchronization；learning signal 上，它也意味着 advantage 再次变成 prefix-dependent。

因此，single-rollout agentic RL 的一个核心困难重新变成了：能不能训练出一个足够好的 value model。

Long-horizon agent 对 critic 并不友好。Final reward 可能在几十轮 tool interaction 以后才出现，早期 state 与 terminal outcome 之间隔着大量 policy decisions 和 environment observations。Actor 还在不断变化，于是

\[V^{\pi_{\theta_k}}(s)\]

的 target 也随着 policy update 改变。Critic 如果学得太慢，GAE 使用的是已经落后的 baseline；critic 如果自身训练不稳定，policy 得到的 advantages 又会直接变得 noisy。

这解释了为什么进入 single-rollout setting 后，value model 很难再被看成 PPO 时代一个可有可无的附属模型。Value pretraining、提高 critic update frequency、限制 critic 自身更新范围，这些实践本质上都在解决同一个问题：让 learned prefix value 至少比一个非常粗的 trajectory-level baseline更有信息，并且能够跟上 actor。

Multi-turn environment 又给 value estimation 增加了一层语义。Trajectory 是

\[[a_0,o_1,a_1,o_2,\ldots],\]

其中 $a_i$ 是 policy action，$o_i$ 是 environment observation。Observation 会显著改变未来成功概率，却不是 policy sample 出来的 action。前面的 SAO 因此还需要专门处理 action 与 observation 之间的 advantage propagation。

从这个角度回看整个 PPO → GRPO → SAO 的路径，会发现 critic 的消失和重新出现体现了 training setting 的变化。GRPO 在 response-level reasoning RL 中用 group comparison 换掉了昂贵的 value estimation；long-horizon agent 一方面让 group synchronization 变贵，另一方面又让 trajectory-level credit 变得更粗，于是 prefix-dependent value重新变得有吸引力。

Learner 看到的真的是 Rollout 当时那条 Trajectory 吗

即使 credit assignment 已经足够好，还有一个完全不同的问题：训练端使用的 $(s_t,a_t)$ 必须真的是 generation 时发生过的 $(s_t,a_t)$。

这件事在单轮 response 中很容易满足。Model 在 token space 中生成

\[z_1,z_2,\ldots,z_T,\]

training side 保存这些 token IDs 和对应 log-probabilities 即可。

Multi-turn agent framework 中，model call 之间通常还存在一层 message protocol。一次 generation 可能先被 decode 成 text，再 parse 成 structured tool call；tool 执行结束后，observation 被写回 conversation，整个 history 又经过 chat template 和 tokenizer，成为下一次 model call 的 input。

即使 tokenizer 从头到尾完全没有变化，也不能保证

\[\operatorname{encode} \left( \operatorname{decode}(z_{1:k}) \right) = z_{1:k}.\]

NVIDIA 的 NeMo Gym 文档记录的正是这类问题：上一轮真正生成的一组 token IDs 在 decode 成字符串后，下一轮重新 tokenize 可能变成另一组 IDs；structured tool-call object 重新经过 chat template render，也可能改变原始 generation 的 formatting (NVIDIA, 2026)。

假设 rollout 时真正发生的是

\[s_t^{\mathrm{rollout}} \rightarrow a_t,\]

training side 却从最终 conversation text 重建出另一个 prefix

\[s_t^{\mathrm{train}} \neq s_t^{\mathrm{rollout}}.\]

那么即使 model weights 完全相同，

\[\pi(a_t\mid s_t^{\mathrm{train}})\]

和 rollout 当时记录的

\[\pi(a_t\mid s_t^{\mathrm{rollout}})\]

也已经不是同一个 conditional probability。

这个问题来自 rollout pipeline 的 state reconstruction，与 asynchronous policy lag 无关。它说明 text 无法作为一条 agent trajectory 的 lossless representation。

解决方式也很工程化：真正把 rollout-time data 当成 source of truth。每次 model call 保存实际使用的 prompt_token_ids、真正 sample 的 generation_token_ids 和对应 generation_log_probs，training side 不再依赖最终 conversation text 去猜当时发生过什么。

Context summary 或 compaction 会把这个问题再推进一步。Retokenization 只是同一段 semantic history 的 token representation 发生变化；summary 会直接改变下一次 model call 所看到的 state。一个 long-horizon trajectory 因此不一定是一条不断追加的 token sequence：

\[z_1,z_2,\ldots,z_T.\]

它更准确地是一系列真实 model calls：

\[s_0\rightarrow a_0, \qquad s_1\rightarrow a_1, \qquad \ldots\]

其中每个 $s_t$ 都可能经过 tool output、truncation 或 compaction 重新构造。训练时真正需要保存的是这些实际出现过的 states。

Rollout 越贵，Freshness 越值钱

有了正确的 trajectory，还要考虑它什么时候进入 learner。

标准 synchronous PPO 的时间边界非常干净。先固定 rollout policy，收集完整 batch，保存 sampled actions 和 rollout-time probabilities，等全部 rollouts 完成以后才开始 optimizer update。这样做最大的好处就是 evidence 来源清楚，而且相对新鲜。

Agentic rollout 的问题是 latency variance 很大。一条简单任务可能几分钟完成，另一条 trajectory 可能经历多轮搜索、编译、测试和恢复，持续二十分钟。只要 training loop 保留 synchronous barrier，已经完成的 trajectories、rollout workers 和 learner 都需要等待最慢的 stragglers。

这也是为什么 asynchronous rollout 如此有吸引力。让已经完成的 trajectories 尽快进入 learner，generation 和 optimization overlap，可以显著提高 system utilization。

代价就是 freshness。

假设一条 trajectory 开始于

\[\pi_1,\]

等它回到 learner 时，current policy 已经变成

\[\pi_4.\]

即使 trajectory 自己从头到尾都固定使用 $\pi_1$，它仍然是一份 stale evidence。前面的 SAO 又展示了更激进的情况：如果 rollout engine 会在一条 trajectory 尚未结束时同步新 weights，同一条 trajectory 本身也可能跨越多个 policy versions。

Importance correction 能够处理一部分 distribution mismatch，却无法让 arbitrarily stale evidence重新获得 fresh rollout 的信息质量。Policy drift 越大，importance ratios 越容易远离 $1$，更多 samples 会落进 clipping 或 masking region，一条昂贵 trajectory 真正贡献给 optimizer 的有效 signal 反而越来越少。

所以在 long-horizon agentic RL 中，on-policy 程度可以看成一种 system budget。

更严格地保持 freshness，需要更多 synchronization，也意味着更多 worker idle time；更积极地 overlap rollout 和 training，可以提高 throughput，却需要接受更大的 policy lag，以及更多 correction、masking 和 sample discard。

NVIDIA 在 SWE RL 上的 preliminary observation 很能体现这种张力。他们原本希望允许更多 off-policy steps 来提高系统利用率，但初步实验发现 4 个 off-policy steps 对 SWE RL 已经过多，因此暂时采用了更保守的配置。这个数字当然不是一个普适阈值，它说明的是一个更基本的问题：SWE rollout 很昂贵，所以我们非常希望重复利用它；policy 又变化得足够快，使得这份昂贵 evidence 的保质期并没有想象中那么长。

这也形成了一个很现实的 trade-off。过滤 stale trajectories 可以提高 data quality，却会降低 effective sample throughput；为了补足 batch 又需要产生更多 rollout，而 rollout 本身恰好是整个系统最昂贵的部分之一。到了这里，data filtering、policy freshness 和 infrastructure utilization 已经开始互相影响。

Reward 上升以后，先去看 Behavior

即使 environment、credit assignment、trajectory fidelity 和 freshness 都处理得不错，还有最后一个经常被低估的问题：training curve 上涨究竟意味着什么？

Agent 可能真的学会了更好的 search 和 debugging strategy，也可能只是发现了 verifier 的 shortcut。它可能修改 tests 而没有修复实现，利用异常退出绕过 checker，反复调用容易获得 shaping reward 的工具，或者学习出某种只在 training harness 中成立的固定流程。

因此，我更倾向于把 reward curve 看成一个需要解释的 observation，并结合 capability 指标判断模型是否真的变强。

这一点在 long-horizon agent 上尤其明显。Trajectory length 增长不自动意味着 reasoning 变强，tool-call frequency 增长也不自动意味着模型更会使用工具。出现更多 reflection-like language、更多 search、更多 retries，都需要进一步问：

\[P(\text{success}\mid\text{this behavior})\]

到底有没有真正提高。

所以 reward design 和 trajectory audit 很难完全分开。训练之前需要人工检查一批 positive / negative trajectories，确认 verifier 给出的 labels 和我们对 task success 的理解一致；训练过程中还要不断抽样失败 trajectories，看 agent 到底失败在哪里。

RAGEN-2 给出了一个更隐蔽的例子。Agent 的 token entropy 可以一直保持在较高水平，模型仍然可能逐渐产生与 input 无关的固定 reasoning templates。他们将这种现象称为 template collapse，并使用 mutual-information-style 的 cross-input distinguishability 补充 entropy diagnosis：同一个输入上还有 output diversity，并不能保证模型仍然根据不同 inputs 改变自己的策略 (Wang et al., 2026)。

Coding agent 里也很容易想象类似现象。它在不同 repository 中生成的 shell commands 表面上都不一样，实际上却始终重复同一套 policy：

\[\text{grep} \rightarrow \text{read README} \rightarrow \text{run tests} \rightarrow \text{edit first match} \rightarrow \text{run tests}.\]

Token-level diversity 还存在，对 environment state 的真正 sensitivity 已经下降。

因此，训练时真正有用的 observability 往往来自 behavior。Success rate、trajectory length、tool distribution、invalid calls、repeated actions、termination reasons 和 reward variance 都值得记录，但指标本身只是入口。更重要的是把这些 metrics 和 actual task success 对齐，并定期打开真实 trajectories 看 policy 到底改变了什么。

很多 agent RL failure 最后无法由某个 scalar dashboard 直接解释。

实践最后更像一个 Debugging Loop

把这些问题放在一起以后，我不太愿意把 long-horizon RL 总结成一套固定 recipe。真实训练更像不断 debugging 一个 closed loop：

\[\text{rollout} \rightarrow \text{inspect} \rightarrow \text{find failure mode} \rightarrow \text{change the loop} \rightarrow \text{rollout again}.\]

最开始通常还是要把 environment 和 verifier 固定下来。让 baseline agent 运行足够多 trajectories，确认 tool parser、sandbox、tests、timeouts 和 reward 没有明显 shortcut 或随机 failure。否则 environment noise 很容易直接变成 policy gradient。

随后要确认模型已经具备 minimum viable agent behavior。如果 tool syntax、search、edit、test loop 都无法稳定完成，RL 中几乎不会产生有意义的 positive evidence。这个阶段更适合先通过 SFT、skill training 或 shorter-horizon tasks 建立 cold start。

再往后，training distribution 可以逐渐扩大。先从 policy 偶尔能够成功的任务开始，再增加 horizon、tool complexity 和 context budget。长 trajectory 本身就可以是一种 curriculum dimension，因为模型需要维护的 state 越多，terminal reward 到早期 decisions 的 attribution 就越困难。

如果 reward curve 不涨，先去看 trajectory。可能需要更好的 exploration，也可能只是大量 all-fail rollouts 没有提供 signal。Reward 涨而 eval 不涨，则要检查 verifier、credit assignment 和 behavior collapse。大量正确 prefix 被最终错误一起惩罚时，问题可能在 credit；value model 跟不上 actor 时，问题可能在 critic；trajectory 很贵而 learner 一直等 worker 时，才有必要进一步增加 asynchronous overlap。

确实需要 shaping 时，可以加入更密集的 signal，但每增加一个 intermediate reward 都需要重新问一遍：policy 有没有开始优化这个 proxy。每次修改 termination、filtering、sampling、context compaction 或 environment logic，也都应该被视为一次 training-distribution change，而不只是 infrastructure refactor。

最后才是把 asynchronous throughput 推到更激进的程度。此时需要同时看 rollout latency、policy freshness、importance ratios、environment failure rate、critic quality、held-out success 和真实 failure trajectories。系统跑得更快只有在这些 trajectories 最终仍然构成有用 evidence 时才有价值。

从这个角度看，agentic RL 的很多实践问题最后可以落到三个不同层面。

Credit assignment 问的是：

\[R(\tau) \quad\text{应该怎样变成}\quad A_t.\]

Trajectory fidelity 问的是 learner 使用的

\[(s_t,a_t)\]

是否真的等于 rollout 当时发生过的 state-action pair。

Policy freshness 问的是这份 evidence 到 optimizer 手里时，

\[\pi_{\mathrm{behavior}}\]

又已经离 current policy 多远。

Environment、rollout infrastructure 和 evaluation 围绕着这三个问题共同决定了 optimizer 最终学到什么。

这也是从普通 LLM RL 进入 agentic RL 后我觉得最明显的变化。前面的 policy-gradient 公式仍然成立：

\[\nabla_\theta J = \mathbb E \left[ A_t \nabla_\theta \log\pi_\theta(a_t\mid s_t) \right].\]

真正困难的部分逐渐移动到了公式里的其他对象上：这个 $s_t$ 是不是 model 当时真正看到的 state，这个 $a_t$ 来自哪一个 rollout policy，而最重要的 $\hat A_t$，究竟有没有把最后的 outcome 正确地归给 trajectory 中值得学习的 decisions。

算法 objective 仍然是训练闭环的核心，但到了 long-horizon agentic RL，一条 trajectory 从 environment 中被生产出来、被解释、被保存、被筛选，再最终进入 optimizer 的整个过程，已经共同定义了这次 policy update 到底意味着什么。

总结：从 Policy Optimization 到 Agent Learning Stack

写到这里，再回头看 PPO、GRPO 以及后面的各种 variants，我越来越觉得 PPO 本身其实已经提供了一套相当完整的 RL solution。它用 value model 估计不同 prefixes 的 expected return，用 GAE 构造 token-level advantage，用 probability ratio 处理 rollout policy 与 current policy 的 mismatch，再通过 clipping 限制同一批 fixed evidence 可以把 policy 推多远。问题在于，这套方案很重。Critic 本身需要额外的 model capacity 和训练成本，value target 带有 sampling noise，actor、critic、rollout policy 之间还需要维护严格的数据关系；放到 LLM 上以后，显存、throughput 和 training stability 都会变成实际约束。

Reasoning RL 之后的很多方法，可以看成是在这些约束下寻找更便宜的 approximation。GRPO 是其中最典型的一步。如果同一个 prompt 可以相对便宜地采样多条 responses，final verifier 又足够可靠，那么同组 samples 本身就可以提供一个 baseline：

\[\hat A_i = R_i-\bar R.\]

这样便不再需要额外训练

\[V_\phi(s_t).\]

后面的 Dr. GRPO、DAPO、GSPO、CISPO、SAPO 又继续修改 normalization、sampling、loss aggregation、importance ratio 和 clipping。它们面对的问题各不相同，但共同说明了一件事：在 reasoning RL 这样的 setting 中，PPO 中一些昂贵的组件确实可以被更简单的 estimator 或 training recipe 替代，而且这种 trade-off 往往很划算。

到了 long-horizon agentic RL，这个平衡又开始变化。

一条 rollout 现在会包含 response 之外的完整 interaction：

\[\tau = (s_0,a_0,o_1,s_1,a_1,o_2,\ldots,s_T),\]

其中几十轮甚至上百轮 model actions 和 environment observations 共同决定最终 outcome。此时，一条 successful trajectory 里面可能混着很多 bad decisions，一条最终失败的 trajectory 里面也可能已经包含很长的正确 prefix。如果仍然让整条 trajectory 共享同一个 group-level advantage，reward 对局部 behavior 的解释能力就会越来越弱。

这也是为什么 credit assignment 在 agentic RL 中重新变得突出。真正的问题已经不只是在 trajectory 结束后得到

\[R(\tau),\]

还包括怎样把这个 terminal outcome 转换成 trajectory 内不同 decisions 的 learning signal：

\[R(\tau) \longrightarrow \hat A_t.\]

这里不一定需要恢复完美的 causal attribution。只要能够避免把明显正确的 prefix 因为后面的 failure 一起惩罚，或者避免因为最终 success 把中间明显无效的 actions 全部强化，partial credit 就已经可能比整条 trajectory 共用一个 scalar 更有信息。Value model、subtrajectory return、process signal 或 prefix replay，本质上都在尝试恢复 terminal reward 压缩掉的 trajectory structure。

SAO 在这里形成了一个很有意思的回环。为了避免 grouped rollout 的 synchronization，它改成 single rollout；当 $G=1$ 时，GRPO 的 group baseline 自然也就不存在了。于是 training 又重新需要 learned critic、GAE 和 behavior-policy correction。

某种意义上，我们确实又回到了 PPO。

回来的是 PPO 最核心的那套结构：prefix-dependent value estimation、advantage estimation，以及对 old-policy evidence 的 correction。此时它面对的是一条由 environment interaction、tool latency、context management 和多版本 rollout policy 共同产生的 agent trajectory。SAO 里的 asynchronous rollout、per-token rollout probability、skip-observation GAE 和 stale-sample masking，也都是这个新 setting 在 PPO-like framework 上额外提出的要求。

因此，我现在更愿意把这些算法的变化理解成 bottleneck 在移动。PPO 很完整，却很难训；reasoning RL 中，一些 cheaper approximations 已经足够好，于是 critic 和复杂 value estimation 的成本可以暂时绕开；agent trajectory 继续变长以后，group-level credit 和 synchronous sampling 又开始成为新的限制，于是 value model 和更细的 trajectory bookkeeping 重新值得付出成本。

顺着这个视角继续往下看，真正决定 RL 是否能够工作的大概也不只是哪一个 policy objective。与其去寻找下一个更漂亮的 objective，我现在更愿意把 RL 看成一个完整的 learning stack，如图 4 所示。从 training data 一路到 policy optimization，每一层都在回答一个不同的问题，并最终决定 optimizer 收到的 learning signal 是否值得相信。

这个 stack 可以顺着一条 trajectory 被生产和使用的过程逐层理解。

1. Training data 决定我们拿什么问题训练。 RL 并不会自动决定应该训练哪些 tasks。给定

   \[x\sim\mathcal D_{\mathrm{train}},\]

   task difficulty、domain coverage、horizon、tool complexity，以及 current policy 在这些 tasks 上是否能够产生足够的 successes 和 failures，都会直接决定后续 rollout 中能得到多少 useful evidence。太简单的 tasks 很快全部成功，太困难的 tasks 长期全部失败，两种情况都可能让 estimator 缺少有效方向。Data distribution 因此决定的是 policy 在训练过程中究竟能够遇到什么样的 learning opportunities。

2. Harness 和 environment 决定这些 experiences 怎样发生。 给定一个 task 以后，model 仍然需要在一个具体的 interaction process 中行动。Tool schema、observations、message history、error handling、context management、termination logic 和 environment transition 都会改变 model 实际看到的 state，以及 action 之后会发生什么。对于 agentic RL，这些部分已经直接参与定义 policy 所面对的 state-action process。

3. Rollout distribution 决定最终产生了哪些 trajectories。 即使 input tasks 和 environment 完全相同，sampling temperature、context budget、parallelism、termination、tool latency 和 current policy 仍然会改变

   \[p(\tau\mid x).\]

   Input data 决定训练从哪些问题开始，rollout distribution 则决定这些问题最后变成了哪些 successful、failed、short、long 或异常 trajectories。两者共同构成 RL 真正使用的数据。

4. Reward 和 verifier 决定什么样的 trajectory 被认为是好的。 Rollout 完成以后，verifier 将一条复杂的 interaction 压缩成 reward：

   \[\tau\longrightarrow R(\tau).\]

   这一层最重要的是 reward 尽可能对应真正关心的 outcome。如果 verifier 存在 shortcut，或者 environment failure 被误记成 model failure，后面的 optimizer 并没有额外的信息去恢复我们心里真正想优化的目标。它只会越来越有效地提高实际收到的 reward。

5. Credit assignment 决定这个 outcome 应该归给哪些 decisions。 有了正确的 reward，还需要完成

   \[R(\tau) \longrightarrow \hat A_t.\]

   对 short reasoning response，一个 response-level signal 可能已经足够；对于 long-horizon agent，同一个 terminal outcome 往往覆盖了质量差异很大的 actions。Successful trajectory 中的 bad behavior 不应该全部得到 positive credit，failed trajectory 中的 useful prefix 也不应该全部得到 negative credit。随着 horizon 增长，这一层越来越可能需要 partial credit、subtrajectory estimate 或 prefix-dependent value，而这正是 value model 重新变得重要的原因。

6. Trajectory evidence 决定 learner 拿到的还是不是当时那份 evidence。 Advantage 构造正确以后，$s_t$、$a_t$、action mask 和 rollout-time log probability 还需要对应 generation 时真正发生过的 interaction。如果 multi-turn pipeline 在 decode、tool parsing、re-templating 或 context compaction 中重建了另一个 state，training-time probability 就已经不再对应 rollout 时的 conditional probability。另一方面，trajectory 进入 learner 时也不能 stale 到与 current policy 几乎无关。Fidelity 和 freshness 共同决定一份 rollout evidence 在统计上是否仍然值得用于 update。

7. Policy optimization 决定怎样使用这些 signal 更新 policy。 最后才来到 PPO、GRPO、SAO 或其他 policy optimizer。它们接收已经构造好的 $\hat A_t$，并通过

   \[\hat A_t \nabla_\theta \log\pi_\theta(a_t\mid s_t)\]

   改变 sampled actions 的 probabilities。Ratio、clipping、masking 和各种 weighting rule 决定的是如何使用已有 evidence，以及一次 update 可以在多大范围内相信它。

因此，如果一定要把整个 stack 压成一句话，我更愿意写成

\[\text{good data} \rightarrow \text{good interaction} \rightarrow \text{good reward} \rightarrow \text{good credit} \rightarrow \text{good evidence} \rightarrow \text{good optimization}.\]

这里很难说哪一个永远最重要。实践中经常出现的 “data is all you need”、“credit assignment is all you need” 或 “infra is all you need”，更像是在描述某个阶段的 dominant bottleneck。当其他部分已经足够好时，当前最差的一环自然会决定 training curve 还能不能继续往上走。

不过，如果只看目前的一些 agentic RL 训练实践，credit assignment 是 stack 中特别值得检查的一层。一个反复出现的对比是，在 reasoning RL 中，只要 task distribution 有足够难度，group sampling 能产生有效的 reward variation，train-inference consistency 和 exploration 没有明显问题，GRPO-style 的 response-level signal 往往已经能够支持稳定的 policy improvement。到了 long-horizon agentic task，同样的 recipe 有时会变得困难得多。一些公开实践报告过，training statistics 看起来基本正常，rollout system、entropy、KL 和 train-inference consistency 也没有暴露明显异常，但 held-out evaluation 仍然很难获得稳定提升；继续调整 data、batch size、rollout 数量或者常见 regularization，也未必直接解决问题。

把这种现象放回前面的 RL stack，我更倾向于先检查 credit assignment。GRPO 将同一个 response-level advantage 复制到 response 中所有 action tokens：

\[\hat A_{i,t} = \hat A_i.\]

对于一条几十轮甚至上百轮 interaction 的 agent trajectory，这个 approximation 会把很多性质完全不同的 decisions 放在同一个 update direction 里。任务最后做对了，中间明显错误、冗余甚至有害的 behavior 也会跟着 positive advantage 一起被强化；任务最后失败了，前面已经正确完成的 reasoning、search 和 tool calls 又会一起得到 negative advantage。Reward 可能已经正确判断了 final outcome，信息压缩主要发生在

\[R(\tau) \longrightarrow \hat A_t\]

这一步。后面的 clipping、importance ratio 和 optimizer recipe 能决定已有 advantage 怎样进入 update，却无法自动恢复已经混在同一个 scalar 里的局部差异。

围绕这个问题，最近出现了一类很直观的思路：利用 trajectory 中比较容易识别的位置，把一条长 trajectory 切成更有意义的学习单元。比如 first error、明显的 pivot、某个高置信度的 outcome change 都可以成为 cut point。PivoARL (Guo et al., 2026)、PivotRL (Yi et al., 2026) 和 TreeRL (Hou et al., 2025) 都沿着这个方向探索，只是具体使用的 pivot signal 和 search / retry 机制不同。它们的共同直觉是：如果已经知道某个 prefix 之后的行为开始偏离目标，就不必让整条 trajectory 继续共享原来的 outcome signal；可以固定或复用前面的 prefix，再针对后面的部分重新 rollout、评估和优化。

Prefix replay (Liao et al., 2026) 也出现在相邻的 multi-turn post-training setting 中。它的核心操作同样是保留已经生成的 prefix，把它作为后续 model call 的 context，再把训练预算集中到需要继续改进的 suffix 上。这样做既可以减少重复的 environment interaction，也能让训练信号更集中地落在尚未解决的部分。

另一条路线更接近 PPO 原来的答案：重新学习 prefix-dependent value。

\[V_\phi(s_t) \approx \mathbb E_\pi[G_t\mid s_t],\]

再通过 GAE 得到随 state 改变的 $\hat A_t$。这也是前面的 SAO 在失去 GRPO group baseline 以后采用的方向。Single rollout 让每条 trajectory 可以更快进入 learner，同时也让 credit assignment 很大一部分重新变成了 value estimation 的问题。

把 critic 请回来以后，问题也没有自动解决。Critic 需要从 sparse、long-horizon returns 中学到有意义的 prefix value，还要持续跟上不断变化的 actor。Value model 自身的 cold start 因而值得处理，例如先利用已有的 offline rollouts 或筛选后的 training data 做 value pretraining，再进入 online RL。实际的小规模实践也显示，critic 的训练质量和 actor 的最终效果之间并不总是简单对应，value pretraining、数据筛选和训练频率都可能改变这个关系。与此同时，同一批筛选后的数据既可以帮助 actor 从更合适的 task distribution 开始训练，也可以为 critic 提供更容易学习的 value targets，一些 SAO 相关实践也体现了这种联系。

Learned value 也需要单独诊断。一个自然的问题是：critic 是否真的比简单 baseline 更能解释 return variation？如果 learned $V_\phi(s_t)$ 连 prompt-level 或 group-level mean 都没有提供更多 information，那么它产生的 finer-grained advantage 也未必带来了更好的 credit。EVPO (Pan et al., 2026) 进一步把 explained variance 作为 critic reliability 的一个信号，用来决定什么时候更应该依赖 learned value，什么时候保留更简单的 baseline。

把这些工作放在一起看，long-horizon agentic RL 中的 credit assignment 大致有两条路线。一条路线利用 pivot、cut point 或 prefix replay，先把最明显的错误 credit 从整条 trajectory 中隔离出来；另一条路线训练 prefix-dependent value，让 critic 为不同 state 提供不同的 expected-return estimate。前者更容易作为低成本的局部修正，后者则需要承担 value model 的训练成本和稳定性问题。具体选择取决于 trajectory 的长度、可用的 intermediate signals，以及系统是否愿意维护一套额外的 critic training pipeline。SAO 重新回到 PPO-like training 也因此变得很自然。PPO 中那些看起来昂贵的组件，在新的 task regime 下重新开始解决真实存在的问题。 当然，这只是 stack 中 bottleneck 移动的一个例子。Algorithm 和 infrastructure 一点都不次要。没有稳定的 rollout system、足够的 environment throughput 和准确的 trajectory bookkeeping，long-horizon agent 的实验根本跑不起来，上面的 data、reward 和 credit 也无从谈起。不同任务、不同模型规模和不同资源条件下，真正限制训练的那一层也会继续变化。

还有一件事情没有出现在这条纵向 stack 中，但它几乎贯穿所有阶段，那就是 observability。这也是图 4 把它画成侧面一条 rail 而不是其中一层的原因。它读取整个 learning loop，却不直接产生下一层的 training signal。

Reward 上涨以后，需要知道 agent 究竟改变了什么 behavior；eval 不涨时，需要区分是 input distribution、environment noise、reward shortcut、bad credit、critic error，还是 stale rollout。Success rate、trajectory length、tool-call distribution、termination reason、invalid actions 和 held-out evaluation 都只能提供不同角度的 evidence，最后仍然需要回到真实 trajectory 上看 policy 到底学会了什么。很多看起来一样的 training curve，背后对应的 failure mode 可能完全不同。

继续往 agentic RL 走，我觉得还有一个更值得关注的问题。我们通常把 policy 写成

\[\pi_\theta(a_t\mid s_t),\]

但真实 agent 中的 $s_t$ 已经被 harness 大量塑造。System prompt、tool schema、message protocol、memory、context compaction、error handling 和 termination logic 都会改变 model 每一步实际看到的 state。

因此，实际被训练的对象越来越接近

\[\text{Agent} = \text{Model} + \text{Harness} + \text{Environment}.\]

这会进一步带来一个目前还很开放的问题：如果 RL 始终发生在固定 harness 下，policy 学到的究竟有多少是可以迁移的 agent capability，又有多少已经和某一种 tool interface、context organization 或 interaction protocol 绑定？未来的 agentic post-training 是否需要在不同 harness 和 environments 中共同训练，还是应该针对 deployment harness 做更强的 specialization，这些问题现在还没有一个统一答案。

不过有一点已经越来越明显。写完整篇文章以后，再回到最开始的 policy gradient，

\[\nabla_\theta J(\theta) = \mathbb E \left[ \hat A_t \nabla_\theta \log\pi_\theta(a_t\mid s_t) \right],\]

公式本身其实一直没有变得多么复杂。真正困难的是怎样让公式里的每一个对象都值得相信，也就是图 4 右侧那些 brackets 指向的东西：training distribution 是否提供了合适的问题和 experiences，trajectory 是否发生在正确的 interaction process 中，reward 是否真的代表成功，$\hat A_t$ 是否把 outcome 分给了正确的 decisions，而这些 state-action evidence 到 learner 手里时又是否仍然真实而有效。

从 reasoning RL 走到 agentic RL，我觉得最大的变化也许就在这里。我们最开始主要在研究怎样写出一个更好的 policy update；随着 trajectory、environment 和 harness 变得越来越复杂，RL 逐渐变成了对整个 agent learning system 的设计。