前沿算法深度解析（二）

第三篇：GRPO --- 群体相对策略优化

1. 引言

2025 年初，DeepSeek-R1 以其卓越的数学推理能力震惊了 AI 界。其核心训练算法------Group Relative Policy Optimization（GRPO） ------提出了一种极其优雅的策略优化方法：完全抛弃价值函数（Critic），仅通过同一问题的多次采样进行组内相对比较来估计优势函数。

这一设计带来了三个革命性优势：

省去 Critic 网络：节省约 50% 的训练计算量和显存
无需奖励模型标注：可直接使用可验证的规则奖励（如数学答案对错）
推理涌现：通过纯 RL 训练，模型自发涌现出 Chain-of-Thought、自我反思等高级推理行为

2. 策略梯度的数学基础

2.1 问题定义

强化学习的核心问题：在马尔可夫决策过程（MDP）(S,A,P,R,γ)(\mathcal{S}, \mathcal{A}, P, R, \gamma)(S,A,P,R,γ) 中，找到最优策略 π∗\pi^*π∗ 使得累积回报最大化。

对于语言模型，MDP 的特殊形式为：

概念	对应
状态 sts_tst	(q,y1,y2,...,yt)(q, y_1, y_2, \ldots, y_t)(q,y1,y2,...,yt)：问题加已生成的 token
动作 ata_tat	yt+1y_{t+1}yt+1：下一个 token
策略 πθ\pi_\thetaπθ	pθ(yt+1∣q,y1:t)p_\theta(y_{t+1} \mid q, y_{1:t})pθ(yt+1∣q,y1:t)：语言模型的条件概率
回报 RRR	序列级别奖励（如数学题答案正确 +1，错误 0）

目标函数：

J(θ)=Eτ∼πθ $R(τ)$ =Ey∼πθ(⋅∣q) $R(q,y)$ J(\theta) = \mathbb{E}{\tau \sim \pi\theta} \left $R(\\tau) \\right$ = \mathbb{E}{y \sim \pi\theta(\cdot | q)} \left $R(q, y) \\right$ J(θ)=Eτ∼πθ $R(τ)$ =Ey∼πθ(⋅∣q) $R(q,y)$

2.2 策略梯度定理

定理（Policy Gradient Theorem, Sutton et al., 1999）：

∇θJ(θ)=Eτ∼πθ $\sumt=0T-1\nablaθlogπθ(at∣st)\cdotAπθ(st,at)$ \nabla_\theta J(\theta) = \mathbb{E}{\tau \sim \pi\theta} \left $\\sum_{t=0}\^{T-1} \\nabla_\\theta \\log \\pi_\\theta(a_t \| s_t) \\cdot A\^{\\pi_\\theta}(s_t, a_t) \\right$ ∇θJ(θ)=Eτ∼πθ $t=0\sumT-1\nablaθlogπθ(at∣st)\cdotAπθ(st,at)$

其中优势函数定义为：

Aπ(s,a)=Qπ(s,a)−Vπ(s) A^{\pi}(s, a) = Q^{\pi}(s, a) - V^{\pi}(s) Aπ(s,a)=Qπ(s,a)−Vπ(s)

Qπ(s,a)=Eτ∼π $\sumk=0\inftyγkRt+k∣st=s,at=a$ Q^{\pi}(s, a) = \mathbb{E}_{\tau \sim \pi} \left $\\sum_{k=0}\^{\\infty} \\gamma\^k R_{t+k} \\Big\| s_t = s, a_t = a \\right$ Qπ(s,a)=Eτ∼π $k=0\sum\inftyγkRt+k st=s,at=a$

Vπ(s)=Ea∼π $Qπ(s,a)$ V^{\pi}(s) = \mathbb{E}_{a \sim \pi} \left $Q\^{\\pi}(s, a) \\right$ Vπ(s)=Ea∼π $Qπ(s,a)$

证明：

从目标函数出发：

J(θ)=Eτ∼πθ $R(τ)$ =∫pθ(τ)R(τ)dτ J(\theta) = \mathbb{E}{\tau \sim \pi\theta} $R(\\tau)$ = \int p_\theta(\tau) R(\tau) d\tau J(θ)=Eτ∼πθ $R(τ)$ =∫pθ(τ)R(τ)dτ

其中轨迹概率：

pθ(τ)=p(s0)∏t=0T−1πθ(at∣st)P(st+1∣st,at) p_\theta(\tau) = p(s_0) \prod_{t=0}^{T-1} \pi_\theta(a_t | s_t) P(s_{t+1} | s_t, a_t) pθ(τ)=p(s0)t=0∏T−1πθ(at∣st)P(st+1∣st,at)

取梯度：

∇θJ(θ)=∫∇θpθ(τ)R(τ)dτ \nabla_\theta J(\theta) = \int \nabla_\theta p_\theta(\tau) R(\tau) d\tau ∇θJ(θ)=∫∇θpθ(τ)R(τ)dτ

利用对数导数技巧（log-derivative trick）：

∇θpθ(τ)=pθ(τ)∇θlog⁡pθ(τ) \nabla_\theta p_\theta(\tau) = p_\theta(\tau) \nabla_\theta \log p_\theta(\tau) ∇θpθ(τ)=pθ(τ)∇θlogpθ(τ)

且：

∇θlog⁡pθ(τ)=∑t=0T−1∇θlog⁡πθ(at∣st) \nabla_\theta \log p_\theta(\tau) = \sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t | s_t) ∇θlogpθ(τ)=t=0∑T−1∇θlogπθ(at∣st)

因此：

∇θJ(θ)=Eτ∼πθ $R(τ)\sumt=0T-1\nablaθlogπθ(at∣st)$ \nabla_\theta J(\theta) = \mathbb{E}{\tau \sim \pi\theta} \left $R(\\tau) \\sum_{t=0}\^{T-1} \\nabla_\\theta \\log \\pi_\\theta(a_t \| s_t) \\right$ ∇θJ(θ)=Eτ∼πθ $R(τ)t=0\sumT-1\nablaθlogπθ(at∣st)$

现在关键一步：引入基线（baseline）减少方差。

对于任意不依赖于 ata_tat 的函数 b(st)b(s_t)b(st)：

Eat∼πθ $\nablaθlogπθ(at∣st)\cdotb(st)$ =b(st)∇θ∑aπθ(a∣st)⏟=1=0 \mathbb{E}{a_t \sim \pi\theta} \left $\\nabla_\\theta \\log \\pi_\\theta(a_t \| s_t) \\cdot b(s_t) \\right$ = b(s_t) \nabla_\theta \underbrace{\sum_{a} \pi_\theta(a | s_t)}_{=1} = 0 Eat∼πθ $\nablaθlogπθ(at∣st)\cdotb(st)$ =b(st)∇θ=1 a∑πθ(a∣st)=0

因此我们可以将 R(τ)R(\tau)R(τ) 替换为"从时间步 ttt 开始的累积回报减去基线"：

∇θJ(θ)=Eτ∼πθ $\sumt=0T-1\nablaθlogπθ(at∣st)\cdot(\sumk=tT-1γk-tRk-b(st))$ \nabla_\theta J(\theta) = \mathbb{E}{\tau \sim \pi\theta} \left $\\sum_{t=0}\^{T-1} \\nabla_\\theta \\log \\pi_\\theta(a_t \| s_t) \\cdot \\left( \\sum_{k=t}\^{T-1} \\gamma\^{k-t} R_k - b(s_t) \\right) \\right$ ∇θJ(θ)=Eτ∼πθ $t=0\sumT-1\nablaθlogπθ(at∣st)\cdot(k=t\sumT-1γk-tRk-b(st))$

选择最优基线 b(st)=Vπθ(st)b(s_t) = V^{\pi_\theta}(s_t)b(st)=Vπθ(st)，括号内恰好是优势函数 Aπθ(st,at)A^{\pi_\theta}(s_t, a_t)Aπθ(st,at)。■\blacksquare■

2.3 REINFORCE 算法

最直接的策略梯度估计器：

∇θJ(θ)≈1N∑i=1N∑t=0T−1∇θlog⁡πθ(at(i)∣st(i))⋅R(τ(i)) \nabla_\theta J(\theta) \approx \frac{1}{N} \sum_{i=1}^{N} \sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t^{(i)} | s_t^{(i)}) \cdot R(\tau^{(i)}) ∇θJ(θ)≈N1i=1∑Nt=0∑T−1∇θlogπθ(at(i)∣st(i))⋅R(τ(i))

方差问题 ：直接使用 R(τ)R(\tau)R(τ) 作为优势估计，方差极高。高方差导致梯度估计不稳定，训练缓慢。

方差的数学分析：

设 g(τ)=R(τ)∑t∇θlog⁡πθ(at∣st)g(\tau) = R(\tau) \sum_t \nabla_\theta \log \pi_\theta(a_t | s_t)g(τ)=R(τ)∑t∇θlogπθ(at∣st)，则：

Var $g$ =E $∥g∥2$ −∥E $g$ ∥2 \text{Var} $g$ = \mathbb{E} $\\\|g\\\|\^2$ - \|\mathbb{E} $g$ \|^2 Var $g$ =E $∥g∥2$ −∥E $g$ ∥2

引入基线 bbb 后：

Var $gb$ =Var $g$ −2b⋅E $g\cdot\sumt\nablalogπ$ +b2⋅E $∥\sumt\nablalogπ∥2$ \text{Var} $g_b$ = \text{Var} $g$ - 2b \cdot \mathbb{E} $g \\cdot \\sum_t \\nabla \\log \\pi$ + b^2 \cdot \mathbb{E} $\\\|\\sum_t \\nabla \\log \\pi\\\|\^2$ Var $gb$ =Var $g$ −2b⋅E $g\cdott\sum\nablalogπ$ +b2⋅E $∥t\sum\nablalogπ∥2$

最优基线（使方差最小）为：

b∗=E $R(τ)\cdot∥\sumt\nablalogπ∥2$ E $∥\sumt\nablalogπ∥2$ b^* = \frac{\mathbb{E} $R(\\tau) \\cdot \\\|\\sum_t \\nabla \\log \\pi\\\|\^2$ }{\mathbb{E} $\\\|\\sum_t \\nabla \\log \\pi\\\|\^2$ } b∗=E $∥\sumt\nablalogπ∥2$ E $R(τ)\cdot∥\sumt\nablalogπ∥2$

3. Actor-Critic 与 PPO

3.1 Actor-Critic 框架

Actor-Critic 方法用两个网络分别表示策略和价值函数：

Actor（演员） ：πθ(a∣s)\pi_\theta(a | s)πθ(a∣s)，决定采取什么动作
Critic（评论家） ：Vϕ(s)V_\phi(s)Vϕ(s)，评估状态的好坏

优势函数的估计（GAE）：

A^t=∑l=0T−t−1(γλ)lδt+l \hat{A}t = \sum{l=0}^{T-t-1} (\gamma \lambda)^l \delta_{t+l} A^t=l=0∑T−t−1(γλ)lδt+l

其中 TD 误差：

δt=Rt+γVϕ(st+1)−Vϕ(st) \delta_t = R_t + \gamma V_\phi(s_{t+1}) - V_\phi(s_t) δt=Rt+γVϕ(st+1)−Vϕ(st)

这就是 GAE（Generalized Advantage Estimation, Schulman et al., 2016）。

λ\lambdaλ 控制偏差-方差权衡：

λ=0\lambda = 0λ=0：A^t=δt\hat{A}_t = \delta_tA^t=δt，低方差但高偏差
λ=1\lambda = 1λ=1：A^t=∑l=0∞γlRt+l−Vϕ(st)\hat{A}t = \sum{l=0}^{\infty} \gamma^l R_{t+l} - V_\phi(s_t)A^t=∑l=0∞γlRt+l−Vϕ(st)，无偏但高方差

3.2 PPO：近端策略优化

PPO（Proximal Policy Optimization, Schulman et al., 2017） 是目前最流行的策略优化算法。

PPO-Clip 目标函数：

LPPO(θ)=Et $min⁡(rt(θ)A\^t, clip(rt(θ),1−ϵ,1+ϵ)A\^t)$ L^{\text{PPO}}(\theta) = \mathbb{E}_t \left $\\min \\left( r_t(\\theta) \\hat{A}_t, \\; \\text{clip}(r_t(\\theta), 1-\\epsilon, 1+\\epsilon) \\hat{A}_t \\right) \\right$ LPPO(θ)=Et $min(rt(θ)A\^t,clip(rt(θ),1−ϵ,1+ϵ)A\^t)$

其中概率比：

rt(θ)=πθ(at∣st)πθold(at∣st) r_t(\theta) = \frac{\pi_\theta(a_t | s_t)}{\pi_{\theta_{\text{old}}}(a_t | s_t)} rt(θ)=πθold(at∣st)πθ(at∣st)

直觉解释：

当 A^t>0\hat{A}_t > 0A^t>0（好动作）：rtr_trt 增大 → 概率增加 → 但被裁剪到 1+ϵ1+\epsilon1+ϵ
当 A^t<0\hat{A}_t < 0A^t<0（坏动作）：rtr_trt 减小 → 概率降低 → 但不低于 1−ϵ1-\epsilon1−ϵ

3.3 PPO 在 LLM 对齐中的应用：RLHF

RLHF（Reinforcement Learning from Human Feedback） 流程：

阶段 1：监督微调（SFT）

LSFT(θ)=−E(q,y)∼D $∑t=1Tlog⁡πθ(yt∣q,y\ \mathcal{L}{\text{SFT}}(\theta) = -\mathbb{E}{(q, y) \sim \mathcal{D}} \left \\sum_{t=1}\^{T} \\log \\pi_\\theta(y_t \| q, y_{\ LSFT(θ)=−E(q,y)∼Dt=1∑Tlogπθ(yt∣q,y\$

阶段 2：奖励模型训练

LRM(ϕ)=−E(q,yw,yl) $logσ(rϕ(q,yw)-rϕ(q,yl))$ \mathcal{L}{\text{RM}}(\phi) = -\mathbb{E}{(q, y_w, y_l)} \left $\\log \\sigma(r_\\phi(q, y_w) - r_\\phi(q, y_l)) \\right$ LRM(ϕ)=−E(q,yw,yl) $logσ(rϕ(q,yw)-rϕ(q,yl))$

阶段 3：PPO 训练

max⁡θ Eq∼D,y∼πθ $rϕ(q,y)-βDKL(πθ∥πref)$ \max_\theta \; \mathbb{E}{q \sim \mathcal{D}, y \sim \pi\theta} \left $r_\\phi(q, y) - \\beta D_{\\text{KL}}(\\pi_\\theta \\\| \\pi_{\\text{ref}}) \\right$ θmaxEq∼D,y∼πθ $rϕ(q,y)-βDKL(πθ∥πref)$

PPO 在 RLHF 中的问题：

Critic 网络昂贵：需要与 Actor 同等大小的网络
奖励模型不完美：奖励模型的误差会被 RL 放大
训练不稳定：PPO 对超参数敏感

4. GRPO --- 群体相对策略优化

4.1 核心思想

GRPO（Group Relative Policy Optimization, Shao et al., 2024） 的核心洞察：

不需要 Critic 网络。对于同一个问题，采样多个回答，用组内相对排名作为优势估计。

4.2 算法流程

给定问题 qqq，GRPO 的训练流程：

步骤 1：采样一组回答

{y1,y2,...,yG}∼πθold(⋅∣q) \{y_1, y_2, \ldots, y_G\} \sim \pi_{\theta_{\text{old}}}(\cdot | q) {y1,y2,...,yG}∼πθold(⋅∣q)

其中 GGG 是组大小（通常 G=16∼64G = 16 \sim 64G=16∼64）。

步骤 2：计算每个回答的奖励

ri=R(q,yi),i=1,2,...,G r_i = R(q, y_i), \quad i = 1, 2, \ldots, G ri=R(q,yi),i=1,2,...,G

对于数学推理，奖励函数为：

R(q,y)={1if extract_answer(y)=ground_truth(q)0otherwise R(q, y) = \begin{cases} 1 & \text{if extract\_answer}(y) = \text{ground\_truth}(q) \\ 0 & \text{otherwise} \end{cases} R(q,y)={10if extract_answer(y)=ground_truth(q)otherwise

步骤 3：组内标准化优势估计

A^i=ri−mean({r1,...,rG})std({r1,...,rG}) \hat{A}_i = \frac{r_i - \text{mean}(\{r_1, \ldots, r_G\})}{\text{std}(\{r_1, \ldots, r_G\})} A^i=std({r1,...,rG})ri−mean({r1,...,rG})

步骤 4：PPO-Clip 风格的策略更新

LGRPO(θ)=1G∑i=1G1∣yi∣∑t=1∣yi∣ $min⁡(ρt(i)A\^i, clip(ρt(i),1−ϵ,1+ϵ)A\^i)−βDKL(i)$ L^{\text{GRPO}}(\theta) = \frac{1}{G} \sum_{i=1}^{G} \frac{1}{|y_i|} \sum_{t=1}^{|y_i|} \left $\\min \\left( \\rho_t\^{(i)} \\hat{A}_i, \\; \\text{clip}(\\rho_t\^{(i)}, 1-\\epsilon, 1+\\epsilon) \\hat{A}_i \\right) - \\beta D_{\\text{KL}}\^{(i)} \\right$ LGRPO(θ)=G1i=1∑G∣yi∣1t=1∑∣yi∣ $min(ρt(i)A\^i,clip(ρt(i),1−ϵ,1+ϵ)A\^i)−βDKL(i)$

其中概率比：

ρt(i)=πθ(yi,t∣q,yi,<t)πθold(yi,t∣q,yi,<t) \rho_t^{(i)} = \frac{\pi_\theta(y_{i,t} | q, y_{i,<t})}{\pi_{\theta_{\text{old}}}(y_{i,t} | q, y_{i,<t})} ρt(i)=πθold(yi,t∣q,yi,<t)πθ(yi,t∣q,yi,<t)

KL 散度项（token 级别）：

DKL(i)=∑t=1∣yi∣πref(yi,t∣q,yi,<t)πθ(yi,t∣q,yi,<t)−log⁡πref(yi,t∣q,yi,<t)πθ(yi,t∣q,yi,<t)−1 D_{\text{KL}}^{(i)} = \sum_{t=1}^{|y_i|} \frac{\pi_{\text{ref}}(y_{i,t} | q, y_{i,<t})}{\pi_\theta(y_{i,t} | q, y_{i,<t})} - \log \frac{\pi_{\text{ref}}(y_{i,t} | q, y_{i,<t})}{\pi_\theta(y_{i,t} | q, y_{i,<t})} - 1 DKL(i)=t=1∑∣yi∣πθ(yi,t∣q,yi,<t)πref(yi,t∣q,yi,<t)−logπθ(yi,t∣q,yi,<t)πref(yi,t∣q,yi,<t)−1

4.3 GRPO 优势估计的数学分析

定理：GRPO 的组内标准化优势估计是真实优势函数的无偏估计（在特定条件下）。

证明：

设真实奖励 ri=R(q,yi)r_i = R(q, y_i)ri=R(q,yi)，真实优势为：

Aπ(q,y)=R(q,y)−Vπ(q) A^{\pi}(q, y) = R(q, y) - V^{\pi}(q) Aπ(q,y)=R(q,y)−Vπ(q)

其中 Vπ(q)=Ey∼π $R(q,y)$ V^{\pi}(q) = \mathbb{E}_{y \sim \pi} $R(q, y)$ Vπ(q)=Ey∼π $R(q,y)$ 。

GRPO 估计：

A^i=ri−rˉsr \hat{A}_i = \frac{r_i - \bar{r}}{s_r} A^i=srri−rˉ

其中 rˉ=1G∑jrj\bar{r} = \frac{1}{G}\sum_j r_jrˉ=G1∑jrj，sr=1G−1∑j(rj−rˉ)2s_r = \sqrt{\frac{1}{G-1}\sum_j (r_j - \bar{r})^2}sr=G−11∑j(rj−rˉ)2 。

当 G→∞G \to \inftyG→∞：

rˉ→E $R(q,y)$ =Vπ(q)\bar{r} \to \mathbb{E} $R(q, y)$ = V^{\pi}(q)rˉ→E $R(q,y)$ =Vπ(q)
sr→std $R(q,y)$ =σRs_r \to \text{std} $R(q, y)$ = \sigma_Rsr→std $R(q,y)$ =σR

因此：

A^i→R(q,yi)−Vπ(q)σR=Aπ(q,yi)σR \hat{A}_i \to \frac{R(q, y_i) - V^{\pi}(q)}{\sigma_R} = \frac{A^{\pi}(q, y_i)}{\sigma_R} A^i→σRR(q,yi)−Vπ(q)=σRAπ(q,yi)

这是真实优势函数的标准化版本 ，与真实优势具有相同的符号和相对大小。■\blacksquare■

4.4 为什么不需要 Critic

关键洞察：在可验证奖励的设置中，组内比较提供了足够的优势信号。

考虑二值奖励 R∈{0,1}R \in \{0, 1\}R∈{0,1}（如数学题对错）：

组内 50% 正确，50% 错误：正确回答 A^>0\hat{A} > 0A^>0（被鼓励），错误回答 A^<0\hat{A} < 0A^<0（被抑制）
组内全部正确：A^i=0\hat{A}_i = 0A^i=0（无需更新）
组内全部错误：A^i=0\hat{A}_i = 0A^i=0（无需更新）

与 Critic 的对比：

方面	PPO + Critic	GRPO
优势估计	A=R+γV(s′)−V(s)A = R + \gamma V(s') - V(s)A=R+γV(s′)−V(s)	A^=(r−rˉ)/σr\hat{A} = (r - \bar{r}) / \sigma_rA^=(r−rˉ)/σr
需要 Critic 网络	是	否
需要时序差分	是	否
计算成本	2× Actor	1× Actor
显存成本	2× Actor	1× Actor
优势估计质量	更精确	依赖组大小 GGG

4.5 KL 散度正则化的数学细节

GRPO 使用了一种特殊的 KL 散度估计器：

D^KL(t)=πref(yt∣q,y<t)πθ(yt∣q,y<t)−log⁡πref(yt∣q,y<t)πθ(yt∣q,y<t)−1 \hat{D}{\text{KL}}(t) = \frac{\pi{\text{ref}}(y_t | q, y_{<t})}{\pi_\theta(y_t | q, y_{<t})} - \log \frac{\pi_{\text{ref}}(y_t | q, y_{<t})}{\pi_\theta(y_t | q, y_{<t})} - 1 D^KL(t)=πθ(yt∣q,y<t)πref(yt∣q,y<t)−logπθ(yt∣q,y<t)πref(yt∣q,y<t)−1

性质：

D^KL(t)=f(πrefπθ),f(x)=x−log⁡x−1 \hat{D}{\text{KL}}(t) = f\left(\frac{\pi{\text{ref}}}{\pi_\theta}\right), \quad f(x) = x - \log x - 1 D^KL(t)=f(πθπref),f(x)=x−logx−1

证明 f(x)≥0f(x) \geq 0f(x)≥0：

f′(x)=1−1/xf'(x) = 1 - 1/xf′(x)=1−1/x，f′(x)=0⇒x=1f'(x) = 0 \Rightarrow x = 1f′(x)=0⇒x=1。

f′′(x)=1/x2>0f''(x) = 1/x^2 > 0f′′(x)=1/x2>0，所以 x=1x = 1x=1 是全局最小值。

f(1)=1−0−1=0f(1) = 1 - 0 - 1 = 0f(1)=1−0−1=0，因此 f(x)≥0f(x) \geq 0f(x)≥0。■\blacksquare■

与标准 KL 的关系：

Eyt∼πθ $D\^KL(t)$ =DKL(πθ∥πref) \mathbb{E}{y_t \sim \pi\theta} \left $\\hat{D}_{\\text{KL}}(t) \\right$ = D_{\text{KL}}(\pi_\theta \| \pi_{\text{ref}}) Eyt∼πθ $D\^KL(t)$ =DKL(πθ∥πref)

注意：这是 DKL(πθ∥πref)D_{\text{KL}}(\pi_\theta \| \pi_{\text{ref}})DKL(πθ∥πref)（反向 KL），而非 DKL(πref∥πθ)D_{\text{KL}}(\pi_{\text{ref}} \| \pi_\theta)DKL(πref∥πθ)（正向 KL）。

5. 推理涌现的理论分析

5.1 什么是推理涌现

DeepSeek-R1 的一个惊人发现：通过纯 RL 训练（不使用任何 Chain-of-Thought 的监督数据），模型自发学会了：

Chain-of-Thought：逐步推理
自我反思：检查并修正错误
回溯：当发现死胡同时重新尝试
分解：将复杂问题分解为子问题

5.2 涌现的数学解释

设：

短回答 ysy_sys：token 数 ∣ys∣|y_s|∣ys∣ 小，正确率 psp_sps
长推理链 yly_lyl：token 数 ∣yl∣|y_l|∣yl∣ 大，正确率 pl>psp_l > p_spl>ps

在 GRPO 训练中，模型学习最大化奖励。如果长推理链能提高正确率，RL 会自然地偏好长推理链。

形式化：

设策略 πθ\pi_\thetaπθ 生成长度为 LLL 的回答，正确率为 p(L)p(L)p(L)。假设 p(L)p(L)p(L) 是 LLL 的增函数（更多的推理步骤 → 更高的正确率）。

在 GRPO 中，期望优势为：

E $A\^∣L$ =p(L)−pˉσp \mathbb{E} $\\hat{A} \| L$ = \frac{p(L) - \bar{p}}{\sigma_p} E $A\^∣L$ =σpp(L)−pˉ

只要 p(L)>pˉp(L) > \bar{p}p(L)>pˉ，长回答就获得正优势，被 RL 强化。

5.3 涌现的条件

奖励信号足够稀疏：只有最终答案对错，没有中间奖励 → 模型必须自己找到获得奖励的路径
组大小 GGG 足够大：确保组内有足够多样的回答，包括长短不同的推理链
KL 约束不太强：允许策略足够偏离参考策略，探索新的推理模式

6. 完整可运行实现

6.1 GRPO 核心实现

python 复制代码

"""
GRPO (Group Relative Policy Optimization) --- 完整可运行实现
依赖: torch >= 2.0, numpy, matplotlib
"""

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
import matplotlib.pyplot as plt
from typing import List, Tuple, Optional, Dict
from dataclasses import dataclass
import math
import re
from collections import defaultdict


@dataclass
class GRPOConfig:
    """GRPO 配置"""
    num_generations: int = 16       # 组大小 G
    clip_range: float = 0.2         # PPO 裁剪范围 ε
    kl_coef: float = 0.1           # KL 散度系数 β
    max_grad_norm: float = 1.0      # 梯度裁剪
    lr: float = 1e-6               # 学习率
    num_iterations: int = 3         # 每批数据的 PPO 迭代次数
    temperature: float = 0.7        # 采样温度
    max_new_tokens: int = 512       # 最大生成长度


def compute_log_probs(logits, actions, mask):
    """计算动作的对数概率"""
    log_probs = F.log_softmax(logits, dim=-1)
    action_log_probs = log_probs.gather(2, actions.unsqueeze(-1)).squeeze(-1)
    return action_log_probs * mask


def compute_kl_divergence(log_probs, ref_log_probs, mask):
    """计算 token 级别的 KL 散度估计器"""
    log_ratio = ref_log_probs - log_probs
    ratio = torch.exp(log_ratio)
    kl = ratio - log_ratio - 1.0
    return kl * mask


class GRPO:
    """Group Relative Policy Optimization"""

    def __init__(self, model, ref_model, config: GRPOConfig, reward_fn):
        self.model = model
        self.ref_model = ref_model
        self.config = config
        self.reward_fn = reward_fn
        self.optimizer = torch.optim.AdamW(
            model.parameters(), lr=config.lr, weight_decay=0.01
        )

    def compute_group_advantages(self, rewards: torch.Tensor) -> torch.Tensor:
        """
        计算 GRPO 的组内标准化优势。

        A_i = (r_i - mean(r)) / std(r)

        性质:
        - 保持奖励的相对排序
        - 自动归一化到均值 0，标准差 1
        - 组内全部相同时优势为 0
        """
        mean_reward = rewards.mean()
        std_reward = rewards.std(unbiased=False)

        if std_reward < 1e-8:
            return torch.zeros_like(rewards)

        advantages = (rewards - mean_reward) / (std_reward + 1e-8)
        return advantages

    def compute_loss(
        self,
        input_ids: torch.Tensor,
        attention_mask: torch.Tensor,
        response_mask: torch.Tensor,
        old_log_probs: torch.Tensor,
        ref_log_probs: torch.Tensor,
        advantages: torch.Tensor,
    ) -> Dict[str, torch.Tensor]:
        """
        计算 GRPO 损失函数。

        L = L_PPO + β * L_KL
        """
        outputs = self.model(input_ids=input_ids, attention_mask=attention_mask)
        logits = outputs.logits

        new_log_probs = compute_log_probs(
            logits[:, :-1], input_ids[:, 1:], response_mask[:, 1:]
        )

        old_log_probs = old_log_probs[:, 1:] * response_mask[:, 1:]
        ref_log_probs = ref_log_probs[:, 1:] * response_mask[:, 1:]

        log_ratio = new_log_probs - old_log_probs
        ratio = torch.exp(log_ratio)

        advantages_expanded = advantages.unsqueeze(-1)

        surr1 = ratio * advantages_expanded
        surr2 = torch.clamp(
            ratio, 1 - self.config.clip_range, 1 + self.config.clip_range
        ) * advantages_expanded
        ppo_loss = -torch.min(surr1, surr2)

        kl = compute_kl_divergence(new_log_probs, ref_log_probs, response_mask[:, 1:])

        response_lengths = response_mask[:, 1:].sum(dim=1).clamp(min=1)
        ppo_loss_mean = (ppo_loss * response_mask[:, 1:]).sum(dim=1) / response_lengths
        kl_loss_mean = (kl * response_mask[:, 1:]).sum(dim=1) / response_lengths

        total_loss = ppo_loss_mean.mean() + self.config.kl_coef * kl_loss_mean.mean()

        return {
            "loss": total_loss,
            "ppo_loss": ppo_loss_mean.mean(),
            "kl_loss": kl_loss_mean.mean(),
        }

6.2 优势估计方法对比实验

python 复制代码

def compare_advantage_estimation():
    """对比不同优势估计方法的方差和偏差"""
    torch.manual_seed(42)

    num_problems = 100
    group_size = 16
    true_values = torch.randn(num_problems)

    rewards = torch.stack([
        v + torch.randn(group_size) * 0.5 for v in true_values
    ])

    def grpo_advantages(r):
        return (r - r.mean(dim=1, keepdim=True)) / (r.std(dim=1, keepdim=True, unbiased=False) + 1e-8)

    def reinforce_advantages(r):
        return r - r.mean()

    adv_grpo = grpo_advantages(rewards)
    adv_reinforce = reinforce_advantages(rewards)

    print(f"方差比较:")
    print(f"  REINFORCE: {adv_reinforce.var().item():.4f}")
    print(f"  GRPO:      {adv_grpo.var().item():.4f}")

6.3 推理涌现模拟

python 复制代码

def simulate_reasoning_emergence():
    """模拟推理涌现现象"""
    torch.manual_seed(42)

    num_steps = 100
    group_size = 16
    difficulty = 0.1

    def success_probability(chain_length):
        return 1 - np.exp(-difficulty * chain_length)

    chain_lengths = [3.0]
    lr = 0.1

    for step in range(num_steps):
        current_L = chain_lengths[-1]
        L_samples = np.clip(np.random.normal(current_L, 2.0, group_size), 1, 20)
        rewards = np.array([success_probability(l) for l in L_samples])
        advantages = (rewards - rewards.mean()) / (rewards.std() + 1e-8)
        grad = np.mean((L_samples - current_L) * advantages)
        chain_lengths.append(np.clip(current_L + lr * grad, 1, 20))

    print(f"初始平均推理链长度: {chain_lengths[0]:.2f}")
    print(f"最终平均推理链长度: {chain_lengths[-1]:.2f}")
    print(f"长度增加: {(chain_lengths[-1] - chain_lengths[0]) / chain_lengths[0] * 100:.1f}%")

7. GRPO 与其他方法的理论对比

7.1 方法对比表

特性	REINFORCE	Actor-Critic	GRPO
优势估计	R−bR - bR−b	AGAEA^{\text{GAE}}AGAE	(r−rˉ)/σr(r - \bar{r}) / \sigma_r(r−rˉ)/σr
需要 Critic	否	是	否
估计方差	高	低	中
估计偏差	无偏	有偏	无偏（渐近）
计算成本	O(1)O(1)O(1) Actor	O(2)O(2)O(2) Actor	O(1)O(1)O(1) Actor
适用场景	稀疏奖励	密集奖励	可验证奖励

7.2 GRPO 的方差分析

定理：GRPO 优势估计的方差为：

Var $A\^iGRPO$ ≈1−1G \text{Var} $\\hat{A}_i\^{\\text{GRPO}}$ \approx 1 - \frac{1}{G} Var $A\^iGRPO$ ≈1−G1

关键洞察 ：GRPO 的方差不依赖于奖励的绝对尺度，只依赖于组大小 GGG。

7.3 GRPO 的收敛性

定理（非正式）：在适当条件下，GRPO 算法收敛到局部最优策略。

条件：

学习率足够小
组大小 GGG 足够大
KL 约束足够强
奖励函数有界

8. 前沿发展与应用

8.1 DeepSeek-R1 的训练流程

DeepSeek-R1 的训练分为四个阶段：

阶段 1：冷启动（Cold Start）

使用少量高质量 CoT 数据进行 SFT
建立基本的推理格式

阶段 2：推理 RL

使用 GRPO 训练数学、编程等可验证任务
奖励函数：答案正确性 + 格式规范性
涌现：Chain-of-Thought、自我反思

阶段 3：拒绝采样 + SFT

用 RL 模型生成高质量推理数据
混合推理和通用任务数据进行 SFT

阶段 4：全场景 RL

扩展到所有任务（包括不可验证任务）
使用奖励模型 + 规则奖励的混合

8.2 GRPO 的变体

DAPO（Dynamic Sampling Policy Optimization）：

动态调整组大小 GGG
对于困难问题增大 GGG，简单问题减小 GGG

Dr. GRPO（GRPO with Dynamic Regularization）：

动态调整 KL 系数 β\betaβ
训练初期 β\betaβ 较大（保守），后期减小（激进）

GRPO-leave-one-out：

对于每个样本，用其余 G−1G-1G−1 个样本估计基线
减少偏差，但增加方差

8.3 推理模型的未来方向

过程奖励模型（PRM）：不仅奖励最终答案，还奖励每一步推理
树搜索：在推理过程中使用 MCTS 探索多条路径
自我对弈：模型生成问题并自我解答
多模态推理：扩展到图像、视频等模态

9. GRPO 数学公式总结

复制代码

╔══════════════════════════════════════════════════════════════════════════════════════╗
║                    GRPO 数学公式总结                                                  ║
╠══════════════════════════════════════════════════════════════════════════════════════╣
║                                                                                    ║
║  1. 策略梯度定理:                                                                  ║
║     ∇J(θ) = E_{τ~π_θ} [ Σ_t ∇log π_θ(a_t|s_t) · A(s_t, a_t) ]                 ║
║                                                                                    ║
║  2. 优势函数:                                                                      ║
║     A(s, a) = Q(s, a) - V(s)                                                      ║
║     Q(s, a) = E[ Σ_k γ^k R_{t+k} | s_t=s, a_t=a ]                               ║
║     V(s) = E_{a~π}[Q(s, a)]                                                       ║
║                                                                                    ║
║  3. GAE (Generalized Advantage Estimation):                                        ║
║     Â_t = Σ_{l=0}^∞ (γλ)^l δ_{t+l}                                              ║
║     δ_t = R_t + γV(s_{t+1}) - V(s_t)                                             ║
║                                                                                    ║
║  4. PPO-Clip 损失:                                                                ║
║     L_PPO = E_t [ min(ρ_t·Â_t, clip(ρ_t, 1-ε, 1+ε)·Â_t) ]                      ║
║     ρ_t = π_θ(a_t|s_t) / π_old(a_t|s_t)                                          ║
║                                                                                    ║
║  5. GRPO 组内标准化优势:                                                           ║
║     A_i = (r_i - mean(r_1..r_G)) / std(r_1..r_G)                                 ║
║                                                                                    ║
║  6. GRPO 损失函数:                                                                 ║
║     L_GRPO = (1/G) Σ_i (1/|y_i|) Σ_t [                                           ║
║         min(ρ_t·A_i, clip(ρ_t, 1-ε, 1+ε)·A_i) - β·KL_t                          ║
║     ]                                                                              ║
║                                                                                    ║
║  7. KL 散度估计器:                                                                 ║
║     KL_t = π_ref/π_θ - log(π_ref/π_θ) - 1                                        ║
║     性质: KL_t ≥ 0, E[KL_t] = D_KL(π_θ || π_ref)                                 ║
║                                                                                    ║
║  8. 优势估计方差对比:                                                              ║
║     Var[REINFORCE] > Var[GRPO]                                                     ║
║     GRPO 优势: 无需 Critic, 自动归一化, 组内比较                                  ║
║                                                                                    ║
║  9. 推理涌现条件:                                                                  ║
║     - 稀疏奖励 (仅答案对错)                                                       ║
║     - 大组大小 G (足够多样性)                                                      ║
║     - 适中的 KL 约束 (允许探索)                                                    ║
║                                                                                    ║
╚══════════════════════════════════════════════════════════════════════════════════════╝

参考文献

Mamba

Gu, A., Goel, K., & Ré, C. (2022). Efficiently Modeling Long Sequences with Structured State Spaces. ICLR 2022.
Gu, A., & Dao, T. (2023). Mamba: Linear-Time Sequence Modeling with Selective State Spaces.
Dao, T., & Gu, A. (2024). Transformers are SSMs: Generalized Models and Efficient Algorithms Through Structured State Space Duality. ICML 2024.
Gu, A., Dao, T., et al. (2020). HiPPO: Recurrent Memory with Optimal Polynomial Projections. NeurIPS 2020.

Flow Matching

Lipman, Y., Chen, R.T., Ben-Hamu, H., Nickel, M., & Le, M. (2023). Flow Matching for Generative Modeling. ICLR 2023.
Liu, X., Gong, C., & Liu, Q. (2023). Flow Straight and Fast: Learning to Generate and Transfer Data with Rectified Flow. ICLR 2023.
Esser, P., Kulal, S., et al. (2024). Scaling Rectified Flow Transformers for High-Resolution Image Synthesis. ICML 2024.
Chen, R.T., Rubanova, Y., Bettencourt, J., & Duvenaud, D. (2018). Neural Ordinary Differential Equations. NeurIPS 2018.
Song, Y., Sohl-Dickstein, J., et al. (2023). Consistency Models. ICML 2023.

GRPO

Shao, Z., Wang, P., et al. (2024). DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models.
DeepSeek-AI. (2025). DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning.
Schulman, J., Wolski, F., et al. (2017). Proximal Policy Optimization Algorithms. arXiv:1707.06347.
Schulman, J., Moritz, P., et al. (2016). High-Dimensional Continuous Control Using Generalized Advantage Estimation. ICLR 2016.
Sutton, R.S., McAllester, D., et al. (1999). Policy Gradient Methods for Reinforcement Learning with Function Approximation. NeurIPS 1999.
Ouyang, L., Wu, J., et al. (2022). Training Language Models to Follow Instructions with Human Feedback. NeurIPS 2022.
Guo, D., Yang, D., et al. (2025). DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning.