我们之前写过一篇读《Approximating KL Divergence》的笔记 ,讨论了 k 1 k_1 k 1 、k 2 k_2 k 2 、k 3 k_3 k 3 这三个估计器在估计 KL 散度的数值时,各自有多大的偏差和方差。这篇文章是那篇笔记的续篇。在训练里,KL 的数值大多只用来记录,或者用来调节 KL 的权重 β \beta β 。KL 真正影响模型更新的方式,是我们把它写进 loss 或者 reward 以后,它在 backward 中产生的梯度。一个估计器能把 KL 的数值估计得很准,并不代表它的梯度指向我们想要的方向。这篇文章就从这个问题讲起。
文章想回答两个问题。第一个问题是,常见的几种 KL 写法在 backward 之后分别产生了什么梯度,这个梯度对应的又是哪一个方向的 KL。第二个问题来自异步 RL。在异步 RL 里,生成数据的 generator 比正在训练的 trainer 落后若干步,我们在介绍 Score Function Centering 加 KL 的文章 里的做法,是加一个 KL,把 trainer 拉向 generator。这个 KL 有好几种写法,我们想弄清楚每一种写法在做什么,又有什么代价。第一个问题的答案,会成为我们回答第二个问题的工具。最后,KL 和它的系数都是在有限精度下算出来的,我们也会讨论计算时需要注意的地方。
对第二个问题,这篇文章不会给出唯一的答案。不同的写法分别防范不同方向的失败,而哪一种失败更值得担心,在不同的设置下可能并不一样。我们会说明每一种写法在做什么、防范哪一类失败、要付出什么代价,具体怎么选,留给读者结合自己的设置来判断。
阅读前的准备
阅读这篇文章需要了解 PPO 或者 GRPO 的 loss 长什么样。下一节的前情回顾整理了 KL 的三个估计器,第 1 章开始就会用到它们。异步 RL 和 Score Function Centering 的背景,要到第 4 章才会用到,我们会在那里再回顾。
如果你遇到过下面这些情况,这篇文章可能会有帮助:
在 GRPO 的 loss 里用了 k 3 k_3 k 3 ,但不确定它实际优化的是哪个方向的 KL。
想弄清楚 KL 放在 reward 里和放在 loss 里有什么区别。
在做异步 RL,用了 trainer 和 generator 之间的 KL,想知道不同的写法会把模型拉向哪里。
在记录或者使用 KL 时,遇到过数值上说不通的结果,比如本该非负的 KL 算出了负数。
第 1 章先说明,为什么直接对 KL 的估计值调用 backward,得到的一般不是 KL 的梯度,并用一个词表只有两个 token 的例子,算出漏掉的那一项会带来多大的差别。为了不必每次都这样逐项计算,第 2 章把每一种 KL 写法的梯度都写成"一个系数乘以 score",从系数就能读出 k 1 k_1 k 1 、k 2 k_2 k 2 、k 3 k_3 k 3 当 loss 时对应的是哪个方向的 KL。同一个系数,放在 reward 里和放在 loss 里的效果也不一样,第 3 章讨论这个区别。前三章都假设样本来自当前模型,第 4 章去掉这个假设,先回顾异步 RL 和 Score Function Centering 的背景,再分别讨论 GRPO 一批数据更新多次和异步 RL 这两种情况。在异步 RL 里,拉近 trainer 和 generator 的写法不止一种,第 5 章把它们都写成对 advantage 的修改,第 6 章再比较它们怎样约束概率正在下降和正在上升的 token、最终会把分布拉到哪里,以及各自要付出什么代价。最后,第 7 章讨论在有限精度下怎样计算 KL 和它的系数,第 8 章是总结。
文中的图都可以交互。把鼠标移到图上可以读出数值,点击图例可以隐藏某一条曲线,有滑块的图可以拖动滑块改变参数。
前情回顾
为了让这篇文章可以单独阅读,这里先回顾后面要用到的三个估计器。
假设我们想估计 K L ( q ∥ p ) = E x ∼ q [ log q ( x ) − log p ( x ) ] \mathrm{KL}(q\|p)=\mathbb E_{x\sim q}[\log q(x)-\log p(x)] KL ( q ∥ p ) = E x ∼ q [ log q ( x ) − log p ( x )] ,但手里只有从 q q q 采出来的样本。这里的 q q q 是采样用的分布,p p p 是另一个分布。记 r = p ( x ) / q ( x ) r=p(x)/q(x) r = p ( x ) / q ( x ) ,John Schulman 在他的博客《Approximating KL Divergence》 里给出了三个估计器:
k 1 = − log r , k 2 = 1 2 ( log r ) 2 , k 3 = ( r − 1 ) − log r . k_1=-\log r,\qquad k_2=\tfrac12(\log r)^2,\qquad k_3=(r-1)-\log r. k 1 = − log r , k 2 = 2 1 ( log r ) 2 , k 3 = ( r − 1 ) − log r . (1)
k 1 k_1 k 1 是无偏的,但方差较大。k 2 k_2 k 2 的方差小,代价是有偏。k 3 k_3 k 3 在 k 1 k_1 k 1 上加了一个期望为 0 的控制变量 r − 1 r-1 r − 1 ,所以它既保持了无偏,方差又小。这三个估计器对任何两个分布都可以使用,后面用到它们时,我们会说明哪个分布处在 q q q 的位置上,哪个分布处在 p p p 的位置上。
1. 直接对 KL 的估计值求导,为什么得不到 KL 的梯度?
TL;DR: KL 是一个期望,θ \theta θ 既出现在被平均的估计值里,也出现在采样的分布里。直接对 KL 的估计值做 backward,只会对估计值本身求导,采样分布随 θ \theta θ 变化带来的那一部分梯度会被漏掉,而且增加样本数也补不回来。所以一个估计器对 KL 的数值无偏,并不保证它当 loss 时给出正确的梯度。
这一章先说明,直接对 KL 的估计值调用 backward,得到的一般不是 KL 的梯度,原因是有一项梯度被漏掉了。然后我们用一个词表只有两个 token 的例子,算出漏掉这一项会带来多大的差别。在此之前,我们先约定第 1 章到第 3 章使用的记号。
为了简化,我们固定一个前缀(prefix),只看下一个 token 的分布。记模型在这个前缀上输出的 logit 为 z z z ,它是一个长度等于词表大小的向量。正在训练的模型记为 π θ \pi_\theta π θ ,它给 token y y y 的概率是 π θ ( y ) = s o f t m a x ( z ) y \pi_\theta(y)=\mathrm{softmax}(z)_y π θ ( y ) = softmax ( z ) y 。KL 正则里的参考分布是 reference model,记为 π ref \pi_{\text{ref}} π ref 。π ref \pi_{\text{ref}} π ref 一般是 RL 开始之前的模型,比如 SFT 之后的模型,它在整个训练过程中固定不变,所以除了训练刚开始的时候,它和 π θ \pi_\theta π θ 并不相同。对一个 token y y y ,记它的 log ratio 为
ρ ( y ) = log π θ ( y ) − log π ref ( y ) . \rho(y)=\log\pi_\theta(y)-\log\pi_{\text{ref}}(y). ρ ( y ) = log π θ ( y ) − log π ref ( y ) . (2)
把 score 记为 s θ ( y ) = ∇ θ log π θ ( y ) s_\theta(y)=\nabla_\theta\log\pi_\theta(y) s θ ( y ) = ∇ θ log π θ ( y ) ,也就是 token y y y 的 log 概率对模型参数的梯度。后面的例子只对 logit z z z 求导,这时 score 有一个简单的形式。记 e y e_y e y 为 token y y y 的 one-hot 向量,也就是只在 y y y 的位置上等于 1、在其余位置上都等于 0 的向量,再把 π θ \pi_\theta π θ 在整个词表上的概率也排成一个向量,仍然记为 π θ \pi_\theta π θ 。由于 log π θ ( y ) = z y − log ∑ v exp ( z v ) \log\pi_\theta(y)=z_y-\log\sum_v\exp(z_v) log π θ ( y ) = z y − log ∑ v exp ( z v ) ,它对 z v z_v z v 的偏导数在 v = y v=y v = y 时是 1 − π θ ( y ) 1-\pi_\theta(y) 1 − π θ ( y ) ,在 v ≠ y v\neq y v = y 时是 − π θ ( v ) -\pi_\theta(v) − π θ ( v ) 。把这些偏导数排成一个向量,就是
∂ log π θ ( y ) ∂ z = e y − π θ . \frac{\partial\log\pi_\theta(y)}{\partial z}=e_y-\pi_\theta. ∂ z ∂ log π θ ( y ) = e y − π θ . (3)
KL 散度有两个方向:
K L ( π θ ∥ π ref ) = E y ∼ π θ [ ρ ( y ) ] , K L ( π ref ∥ π θ ) = E y ∼ π ref [ − ρ ( y ) ] . \mathrm{KL}(\pi_\theta\|\pi_{\text{ref}})=\mathbb E_{y\sim\pi_\theta}[\rho(y)],\qquad
\mathrm{KL}(\pi_{\text{ref}}\|\pi_\theta)=\mathbb E_{y\sim\pi_{\text{ref}}}[-\rho(y)]. KL ( π θ ∥ π ref ) = E y ∼ π θ [ ρ ( y )] , KL ( π ref ∥ π θ ) = E y ∼ π ref [ − ρ ( y )] . (4)
在 RLHF 和 GRPO 里,我们通常想约束的是第一个。本文沿用之前介绍 Score Function Centering 加 KL 的文章 的叫法,把参照分布在前、π θ \pi_\theta π θ 在后的 KL 叫作 reverse KL,例如 K L ( π ref ∥ π θ ) \mathrm{KL}(\pi_{\text{ref}}\|\pi_\theta) KL ( π ref ∥ π θ ) ,把 π θ \pi_\theta π θ 在前的 KL 叫作 forward KL,例如 K L ( π θ ∥ π ref ) \mathrm{KL}(\pi_\theta\|\pi_{\text{ref}}) KL ( π θ ∥ π ref ) 。有一些 RLHF 的论文和代码库的叫法正好相反,文末的附录专门列出了两种叫法的对应关系。
在前情回顾的三个公式里,q q q 是采样用的分布,p p p 是另一个分布。这里我们要估计的是 K L ( π θ ∥ π ref ) \mathrm{KL}(\pi_\theta\|\pi_{\text{ref}}) KL ( π θ ∥ π ref ) ,样本来自 π θ \pi_\theta π θ ,所以 π θ \pi_\theta π θ 处在 q q q 的位置上,π ref \pi_{\text{ref}} π ref 处在 p p p 的位置上。于是 r = π ref ( y ) / π θ ( y ) r=\pi_{\text{ref}}(y)/\pi_\theta(y) r = π ref ( y ) / π θ ( y ) ,log r = − ρ ( y ) \log r=-\rho(y) log r = − ρ ( y ) 。代入以后,三个估计器写成 ρ \rho ρ 的函数分别是
k 1 = ρ , k 2 = 1 2 ρ 2 , k 3 = e − ρ − 1 + ρ . k_1=\rho,\qquad k_2=\tfrac12\rho^2,\qquad k_3=e^{-\rho}-1+\rho. k 1 = ρ , k 2 = 2 1 ρ 2 , k 3 = e − ρ − 1 + ρ . (5)
第 1 章到第 3 章都使用这种写法,只用 ρ \rho ρ ,不再单独使用 r r r 。
1.1 backward 漏掉了哪一项?
为了同时讨论三个估计器,我们用 f θ ( y ) f_\theta(y) f θ ( y ) 表示其中任意一个在样本 y y y 上的值,比如用 k 1 k_1 k 1 时,f θ ( y ) = ρ ( y ) f_\theta(y)=\rho(y) f θ ( y ) = ρ ( y ) 。下标 θ \theta θ 表示它依赖模型参数。对 k 1 k_1 k 1 和 k 3 k_3 k 3 这样的无偏估计器,KL 就等于 E y ∼ π θ [ f θ ( y ) ] \mathbb E_{y\sim\pi_\theta}[f_\theta(y)] E y ∼ π θ [ f θ ( y )] ,所以我们想要的 KL 的梯度,就是这个期望的梯度。把期望写成求和,
E y ∼ π θ [ f θ ( y ) ] = ∑ y π θ ( y ) f θ ( y ) . \mathbb E_{y\sim\pi_\theta}[f_\theta(y)]=\sum_y\pi_\theta(y)\,f_\theta(y). E y ∼ π θ [ f θ ( y )] = y ∑ π θ ( y ) f θ ( y ) . (6)
式子里的 θ \theta θ 出现在两个地方。一个是估计器 f θ ( y ) f_\theta(y) f θ ( y ) 本身,另一个是作为权重的 π θ ( y ) \pi_\theta(y) π θ ( y ) ,也就是 token y y y 被采到的概率。对乘积求导会得到两项。对 f θ ( y ) f_\theta(y) f θ ( y ) 求导的那一项,下文称为估计器项。对 π θ ( y ) \pi_\theta(y) π θ ( y ) 求导的那一项,用 ∇ θ π θ = π θ ∇ θ log π θ \nabla_\theta\pi_\theta=\pi_\theta\nabla_\theta\log\pi_\theta ∇ θ π θ = π θ ∇ θ log π θ 改写以后,下文称为采样项。这样就得到
∇ θ E y ∼ π θ [ f θ ( y ) ] = E y ∼ π θ [ ∇ θ f θ ( y ) ] ⏟ 估计器项 + E y ∼ π θ [ f θ ( y ) s θ ( y ) ] ⏟ 采样项 . \nabla_\theta\,\mathbb E_{y\sim\pi_\theta}[f_\theta(y)]=\underbrace{\mathbb E_{y\sim\pi_\theta}\big[\nabla_\theta f_\theta(y)\big]}_{\text{估计器项}}+\underbrace{\mathbb E_{y\sim\pi_\theta}\big[f_\theta(y)\,s_\theta(y)\big]}_{\text{采样项}}. ∇ θ E y ∼ π θ [ f θ ( y )] = 估计器项 E y ∼ π θ [ ∇ θ f θ ( y ) ] + 采样项 E y ∼ π θ [ f θ ( y ) s θ ( y ) ] . (7)
常见的实现是这样计算 KL 这一项的。先从 π θ \pi_\theta π θ 采出 N N N 个 token y 1 , … , y N y_1,\dots,y_N y 1 , … , y N ,再算出每个 token 的 f θ ( y i ) f_\theta(y_i) f θ ( y i ) ,取平均得到 1 N ∑ i f θ ( y i ) \frac1N\sum_i f_\theta(y_i) N 1 ∑ i f θ ( y i ) ,乘上 β \beta β 加进 loss,最后调用 backward。backward 得到的梯度是 1 N ∑ i ∇ θ f θ ( y i ) \frac1N\sum_i\nabla_\theta f_\theta(y_i) N 1 ∑ i ∇ θ f θ ( y i ) ,它的期望正是上式的估计器项。
采样项来自对权重 π θ ( y ) \pi_\theta(y) π θ ( y ) 求导。在代码里,这个权重并没有作为一个数出现在 loss 中,它的作用是由采样来完成的,概率越大的 token 被采到的次数越多,在平均值里占的分量也就越大。而采样这一步输出的是 token 的编号。θ \theta θ 变化一点点时,采到的编号要么不变,要么突然跳到另一个 token,所以单次采样的结果对 θ \theta θ 的导数要么是 0,要么不存在,自动求导也不会经过这一步。θ \theta θ 对各个 token 被采到的频率的影响,只体现在许多次采样的平均里,任何一次 backward 都看不到它。因此,backward 只会对 f θ ( y i ) f_\theta(y_i) f θ ( y i ) 这个式子求导,并把采到的 y i y_i y i 当成常数,采样项也就这样被漏掉了。需要说明的是,f θ ( y ) f_\theta(y) f θ ( y ) 里也可能含有 π θ ( y ) \pi_\theta(y) π θ ( y ) ,比如 k 1 k_1 k 1 就是 log π θ ( y ) − log π ref ( y ) \log\pi_\theta(y)-\log\pi_{\text{ref}}(y) log π θ ( y ) − log π ref ( y ) ,backward 会对这一处求导,它属于估计器项。被漏掉的只是作为权重的那个 π θ ( y ) \pi_\theta(y) π θ ( y ) 。
采样项的形式和 policy gradient 完全一样。如果把 f θ ( y ) f_\theta(y) f θ ( y ) 看成 token y y y 拿到的 reward R ( y ) R(y) R ( y ) ,采样项就是 E y ∼ π θ [ R ( y ) ∇ θ log π θ ( y ) ] \mathbb E_{y\sim\pi_\theta}[R(y)\nabla_\theta\log\pi_\theta(y)] E y ∼ π θ [ R ( y ) ∇ θ log π θ ( y )] ,也就是 REINFORCE 的梯度。policy gradient 要解决的,正是"采样分布依赖 θ \theta θ 时,怎样求期望的梯度"这个问题。对这个推导不熟悉的读者,可以参考介绍 Score Function Centering 的文章 的 1.1 节。所以,直接对 KL 的估计值求导,相当于只算了估计器本身的梯度,而把采样分布的变化带来的梯度整个丢掉了。
由于被漏掉的是一整项期望,增加样本数量只能让估计器项估计得更准,不能把采样项找回来,所以这里的偏差和样本数量无关。Tang 和 Munos(2025)以及 Zhang 等人(2025)都详细讨论过这个问题,并且指出不少开源实现都受它影响。
1.2 漏掉这一项,差别有多大?
下面在一个词表只有两个 token 的例子里,把三个梯度精确地算出来,看看漏掉采样项会带来多大的差别。
设词表里只有 A 和 B 两个 token,当前模型 π θ ( A ) = 0.7 \pi_\theta(A)=0.7 π θ ( A ) = 0.7 ,参考分布 π ref ( A ) = 0.5 \pi_{\text{ref}}(A)=0.5 π ref ( A ) = 0.5 。为了简洁,记 p A = π θ ( A ) p_A=\pi_\theta(A) p A = π θ ( A ) ,p B = π θ ( B ) p_B=\pi_\theta(B) p B = π θ ( B ) 。我们比较三个量,它们都是对 A 的 logit z A z_A z A 求导的结果,并且都对采样取了精确的期望。
第一个量是 forward KL 本身对 z A z_A z A 的导数,也就是我们想要的结果。只有两个 token 时,K L ( π θ ∥ π ref ) = p A ρ ( A ) + p B ρ ( B ) \mathrm{KL}(\pi_\theta\|\pi_{\text{ref}})=p_A\rho(A)+p_B\rho(B) KL ( π θ ∥ π ref ) = p A ρ ( A ) + p B ρ ( B ) 。由上面的 e y − π θ e_y-\pi_\theta e y − π θ ,log p A \log p_A log p A 对 z A z_A z A 的导数是 1 − p A = p B 1-p_A=p_B 1 − p A = p B ,log p B \log p_B log p B 对 z A z_A z A 的导数是 − p A -p_A − p A 。所以 ρ ( A ) \rho(A) ρ ( A ) 和 ρ ( B ) \rho(B) ρ ( B ) 对 z A z_A z A 的导数分别是 p B p_B p B 和 − p A -p_A − p A ,而 p A p_A p A 和 p B p_B p B 本身的导数等于它们自己乘以对应的 log 概率的导数,分别是 p A p B p_Ap_B p A p B 和 − p A p B -p_Ap_B − p A p B 。对两个乘积分别求导以后,对 ρ \rho ρ 求导的两项是 p A ⋅ p B + p B ⋅ ( − p A ) = 0 p_A\cdot p_B+p_B\cdot(-p_A)=0 p A ⋅ p B + p B ⋅ ( − p A ) = 0 ,正好抵消,这两项就是 1.1 节的估计器项。剩下的是对 p A p_A p A 和 p B p_B p B 求导的两项,也就是采样项,
∂ ∂ z A K L ( π θ ∥ π ref ) = p A p B ( ρ ( A ) − ρ ( B ) ) = 0.7 × 0.3 × ln 0.7 / 0.5 0.3 / 0.5 = 0.21 × ln 7 3 ≈ 0.178. \frac{\partial}{\partial z_A}\mathrm{KL}(\pi_\theta\|\pi_{\text{ref}})=p_Ap_B\big(\rho(A)-\rho(B)\big)=0.7\times0.3\times\ln\frac{0.7/0.5}{0.3/0.5}=0.21\times\ln\frac73\approx0.178. ∂ z A ∂ KL ( π θ ∥ π ref ) = p A p B ( ρ ( A ) − ρ ( B ) ) = 0.7 × 0.3 × ln 0.3/0.5 0.7/0.5 = 0.21 × ln 3 7 ≈ 0.178. (8)
第二个量是把 k 1 k_1 k 1 当成 loss 时,backward 得到的梯度的期望。k 1 = ρ ( y ) = log π θ ( y ) − log π ref ( y ) k_1=\rho(y)=\log\pi_\theta(y)-\log\pi_{\text{ref}}(y) k 1 = ρ ( y ) = log π θ ( y ) − log π ref ( y ) ,它对 z A z_A z A 的导数就是 ∂ log π θ ( y ) / ∂ z A \partial\log\pi_\theta(y)/\partial z_A ∂ log π θ ( y ) / ∂ z A 。由 e y − π θ e_y-\pi_\theta e y − π θ 可知,采到 A 时这个导数是 1 − 0.7 = 0.3 1-0.7=0.3 1 − 0.7 = 0.3 ,采到 B 时是 − 0.7 -0.7 − 0.7 。按 π θ \pi_\theta π θ 取期望,结果是 0.7 × 0.3 + 0.3 × ( − 0.7 ) = 0 0.7\times0.3+0.3\times(-0.7)=0 0.7 × 0.3 + 0.3 × ( − 0.7 ) = 0 。
第三个量是把 k 3 k_3 k 3 当成 loss 时,backward 得到的梯度的期望。k 3 = e − ρ − 1 + ρ k_3=e^{-\rho}-1+\rho k 3 = e − ρ − 1 + ρ ,它对 z A z_A z A 的导数是 ( 1 − e − ρ ) ∂ log π θ ( y ) / ∂ z A (1-e^{-\rho})\,\partial\log\pi_\theta(y)/\partial z_A ( 1 − e − ρ ) ∂ log π θ ( y ) / ∂ z A ,其中 e − ρ = π ref ( y ) / π θ ( y ) e^{-\rho}=\pi_{\text{ref}}(y)/\pi_\theta(y) e − ρ = π ref ( y ) / π θ ( y ) 。采到 A 时,导数是 ( 1 − 0.5 / 0.7 ) × 0.3 ≈ 0.086 (1-0.5/0.7)\times0.3\approx0.086 ( 1 − 0.5/0.7 ) × 0.3 ≈ 0.086 。采到 B 时,导数是 ( 1 − 0.5 / 0.3 ) × ( − 0.7 ) ≈ 0.467 (1-0.5/0.3)\times(-0.7)\approx0.467 ( 1 − 0.5/0.3 ) × ( − 0.7 ) ≈ 0.467 。按 π θ \pi_\theta π θ 取期望,结果是 0.7 × 0.086 + 0.3 × 0.467 = 0.2 0.7\times0.086+0.3\times0.467=0.2 0.7 × 0.086 + 0.3 × 0.467 = 0.2 。
k 1 k_1 k 1 和 k 3 k_3 k 3 作为 KL 数值的估计都是无偏的,但把它们直接当成 loss,得到的期望梯度分别是 0 和 0.2,都不是 forward KL 的 0.178。这三个数都是精确的期望,所以不管 batch 有多大,这个差别都会存在。k 1 k_1 k 1 的情况最极端,它的梯度平均下来是 0,也就是说这一项 KL 根本不会把模型往参考分布那边拉。
这个差别并不是 0.7 这个取值碰巧造成的。图 1 让 π θ ( A ) \pi_\theta(A) π θ ( A ) 取遍 0 到 1 之间的值,画出了同样的几个量,图中的竖线标出的就是上面的例子。拖动滑块可以改变 π ref ( A ) \pi_{\text{ref}}(A) π ref ( A ) 。图里还画了 k 2 k_2 k 2 当 loss 的结果和 reverse KL 的梯度,2.2 节会解释它们为什么分别和 forward KL、k 3 k_3 k 3 的曲线重合。
图 1 需要 JavaScript 才能显示。
k 3 k_3 k 3 给出的 0.2 正好等于 π θ ( A ) − π ref ( A ) \pi_\theta(A)-\pi_{\text{ref}}(A) π θ ( A ) − π ref ( A ) 。下一章会给出一个统一的方法,用它可以直接看出每一种写法对应的是哪个梯度,2.2 节会用它说明 0.2 是从哪里来的。
2. k 1 k_1 k 1 、k 2 k_2 k 2 、k 3 k_3 k 3 当 loss 时,各自给出的是什么梯度?
TL;DR: 把每一种 KL 写法在单个样本上的梯度写成"一个系数乘以 score"以后,比较系数就能判断它优化的是哪个 KL。样本来自当前模型时,k 1 k_1 k 1 当 loss 的期望梯度为 0,k 2 k_2 k 2 给出 K L ( π θ ∥ π ref ) \mathrm{KL}(\pi_\theta\|\pi_{\text{ref}}) KL ( π θ ∥ π ref ) 的梯度,也就是本文所说的 forward KL,k 3 k_3 k 3 给出 K L ( π ref ∥ π θ ) \mathrm{KL}(\pi_{\text{ref}}\|\pi_\theta) KL ( π ref ∥ π θ ) 的梯度,也就是 reverse KL。因此,InstructGPT 式的 PPO 把 k 1 k_1 k 1 放进 reward,优化的是 forward KL,而 GRPO 把 k 3 k_3 k 3 放进 loss,在样本来自当前模型的近似下,优化的是 reverse KL。
第 1 章的三个数是一个一个算出来的。这一章给出一个统一的方法,把每一种 KL 写法在单个样本上的梯度,都写成一个系数乘以 score。2.1 节介绍这个方法,2.2 节用它读出 k 1 k_1 k 1 、k 2 k_2 k 2 、k 3 k_3 k 3 当 loss 时分别对应什么梯度,2.3 节再用这些结论比较 PPO 和 GRPO 里的 KL。
2.1 怎样从一个估计器读出它的梯度?
k 1 k_1 k 1 、k 2 k_2 k 2 、k 3 k_3 k 3 都只依赖 ρ ( y ) = log π θ ( y ) − log π ref ( y ) \rho(y)=\log\pi_\theta(y)-\log\pi_{\text{ref}}(y) ρ ( y ) = log π θ ( y ) − log π ref ( y ) ,所以可以统一写成 f ( ρ ) f(\rho) f ( ρ ) 。π ref \pi_{\text{ref}} π ref 不随 θ \theta θ 变化,因此 ∇ θ ρ ( y ) = s θ ( y ) \nabla_\theta\rho(y)=s_\theta(y) ∇ θ ρ ( y ) = s θ ( y ) 。对于任何形如 f ( ρ ) f(\rho) f ( ρ ) 的写法,单个样本上 backward 得到的梯度都是
∇ θ f ( ρ ( y ) ) = f ′ ( ρ ( y ) ) s θ ( y ) . \nabla_\theta f(\rho(y))=f'(\rho(y))\,s_\theta(y). ∇ θ f ( ρ ( y )) = f ′ ( ρ ( y )) s θ ( y ) . (9)
这个梯度就是一个标量系数 f ′ ( ρ ) f'(\rho) f ′ ( ρ ) 乘以 score。对 loss 做梯度下降时,系数为正会降低这个样本的 log 概率,系数为负会提高它,系数的绝对值决定了变化的幅度。比较不同的写法,就是比较它们的系数。
样本来自当前模型时,系数为 c ( y ) c(y) c ( y ) 的梯度,期望是 E y ∼ π θ [ c ( y ) s θ ( y ) ] \mathbb E_{y\sim\pi_\theta}[c(y)\,s_\theta(y)] E y ∼ π θ [ c ( y ) s θ ( y )] 。score 的期望为 0,所以给 c c c 加上任何一个和 y y y 无关的常数,都不会改变这个期望。这也是 policy gradient 里可以减去 baseline 的原因,我们在介绍 Score Function Centering 的文章 的 2.1 节详细讨论过这一点,后面会反复用到。
再看 forward KL 的梯度应该是什么。在 1.1 节的公式里取 f θ = ρ f_\theta=\rho f θ = ρ ,估计器项是 E [ ∇ θ ρ ] = E [ s θ ] = 0 \mathbb E[\nabla_\theta\rho]=\mathbb E[s_\theta]=0 E [ ∇ θ ρ ] = E [ s θ ] = 0 ,于是 forward KL 的梯度只剩下采样项 E [ ρ s θ ] \mathbb E[\rho\,s_\theta] E [ ρ s θ ] 。也就是说,样本来自当前模型时,系数等于 ρ \rho ρ ,或者 ρ \rho ρ 加上任何常数,给出的就是 forward KL 的准确梯度。下一节会用这个标准来检查三个估计器。
这里说的"准确"指的是期望。系数加减一个常数不改变期望,但会改变梯度的方差。和 policy gradient 里减去 baseline 一样,我们可以从系数里减去一个和当前采到的 token 无关的量,来降低梯度的方差,5.1 节的 k 4 k_4 k 4 也会用到这个想法。需要区分的是,之前的笔记 讨论的方差,指的是 KL 的估计值在样本之间的波动,它和这里说的梯度的方差并不是同一个量。
2.2 k 1 k_1 k 1 、k 2 k_2 k 2 、k 3 k_3 k 3 的系数分别是什么?
先看 k 1 k_1 k 1 。k 1 = ρ k_1=\rho k 1 = ρ ,系数是 f ′ ( ρ ) = 1 f'(\rho)=1 f ′ ( ρ ) = 1 ,期望梯度是 E y ∼ π θ [ s θ ( y ) ] = 0 \mathbb E_{y\sim\pi_\theta}[s_\theta(y)]=0 E y ∼ π θ [ s θ ( y )] = 0 。k 1 k_1 k 1 作为 KL 数值的估计是无偏的,但作为 loss,它的梯度期望恒为 0。在单个 batch 上,它的梯度并不是 0,可是这些梯度平均下来不指向任何方向,只会给训练增加噪声。这就是 1.2 节里 k 1 k_1 k 1 给出 0 的原因。
再看 k 2 k_2 k 2 。k 2 = 1 2 ρ 2 k_2=\tfrac12\rho^2 k 2 = 2 1 ρ 2 ,系数是 f ′ ( ρ ) = ρ f'(\rho)=\rho f ′ ( ρ ) = ρ 。按照 2.1 节的标准,它给出的就是 forward KL 的准确梯度。在 1.2 节的例子里,采到 A 时 ρ = ln ( 0.7 / 0.5 ) ≈ 0.336 \rho=\ln(0.7/0.5)\approx0.336 ρ = ln ( 0.7/0.5 ) ≈ 0.336 ,采到 B 时 ρ = ln ( 0.3 / 0.5 ) ≈ − 0.511 \rho=\ln(0.3/0.5)\approx-0.511 ρ = ln ( 0.3/0.5 ) ≈ − 0.511 ,乘上各自对 z A z_A z A 的导数,再按 π θ \pi_\theta π θ 取期望,得到的正好是 0.178。图 1 里 k 2 k_2 k 2 的虚线和 forward KL 的曲线完全重合,也是这个原因。
这一点和 k 2 k_2 k 2 作为数值估计时的表现正好相反。k 2 k_2 k 2 作为 KL 数值的估计是有偏的,Schulman 的博客说明,在两个分布很接近时,它的期望和 KL 只在二阶以内相同。但是作为 loss,在样本来自当前模型的时候,k 2 k_2 k 2 的梯度却是准确的。原因是 forward KL 的完整梯度只剩下采样项 E [ ρ s θ ] \mathbb E[\rho\,s_\theta] E [ ρ s θ ] ,估计器项的期望是 0,而 k 2 k_2 k 2 做 backward 以后,在单个样本上给出的恰好就是 ρ s θ \rho\,s_\theta ρ s θ 。也就是说,k 2 k_2 k 2 自己的 backward 恰好算出了 k 1 k_1 k 1 漏掉的那一项。
最后看 k 3 k_3 k 3 。k 3 = e − ρ − 1 + ρ k_3=e^{-\rho}-1+\rho k 3 = e − ρ − 1 + ρ ,系数是
f ′ ( ρ ) = 1 − e − ρ = 1 − π ref ( y ) π θ ( y ) . f'(\rho)=1-e^{-\rho}=1-\frac{\pi_{\text{ref}}(y)}{\pi_\theta(y)}. f ′ ( ρ ) = 1 − e − ρ = 1 − π θ ( y ) π ref ( y ) . (10)
它的期望梯度是
E y ∼ π θ [ ( 1 − π ref ( y ) π θ ( y ) ) s θ ( y ) ] = E y ∼ π θ [ s θ ( y ) ] − E y ∼ π ref [ s θ ( y ) ] = − E y ∼ π ref [ s θ ( y ) ] . \mathbb E_{y\sim\pi_\theta}\Big[\Big(1-\frac{\pi_{\text{ref}}(y)}{\pi_\theta(y)}\Big)s_\theta(y)\Big]=\mathbb E_{y\sim\pi_\theta}[s_\theta(y)]-\mathbb E_{y\sim\pi_{\text{ref}}}[s_\theta(y)]=-\mathbb E_{y\sim\pi_{\text{ref}}}[s_\theta(y)]. E y ∼ π θ [ ( 1 − π θ ( y ) π ref ( y ) ) s θ ( y ) ] = E y ∼ π θ [ s θ ( y )] − E y ∼ π ref [ s θ ( y )] = − E y ∼ π ref [ s θ ( y )] . (11)
而 K L ( π ref ∥ π θ ) = E y ∼ π ref [ log π ref ( y ) − log π θ ( y ) ] \mathrm{KL}(\pi_{\text{ref}}\|\pi_\theta)=\mathbb E_{y\sim\pi_{\text{ref}}}[\log\pi_{\text{ref}}(y)-\log\pi_\theta(y)] KL ( π ref ∥ π θ ) = E y ∼ π ref [ log π ref ( y ) − log π θ ( y )] 的梯度也是 − E y ∼ π ref [ s θ ( y ) ] -\mathbb E_{y\sim\pi_{\text{ref}}}[s_\theta(y)] − E y ∼ π ref [ s θ ( y )] 。因此 k 3 k_3 k 3 当 loss 时,期望梯度是 reverse KL 的梯度。回到 1.2 节的例子,reverse KL 对 logit 的梯度是 π θ − π ref \pi_\theta-\pi_{\text{ref}} π θ − π ref ,它在 A 上的分量是 π θ ( A ) − π ref ( A ) = 0.2 \pi_\theta(A)-\pi_{\text{ref}}(A)=0.2 π θ ( A ) − π ref ( A ) = 0.2 ,这就是 k 3 k_3 k 3 给出的那个数。在图 1 里,k 3 k_3 k 3 的虚线和 reverse KL 的曲线完全重合。
在 ρ \rho ρ 接近 0 的时候,1 − e − ρ ≈ ρ − ρ 2 / 2 1-e^{-\rho}\approx\rho-\rho^2/2 1 − e − ρ ≈ ρ − ρ 2 /2 ,和 k 2 k_2 k 2 的系数一阶相同,所以 Liu 等人(2025)把 k 3 k_3 k 3 当 loss 看作 K L ( π θ ∥ π ref ) \mathrm{KL}(\pi_\theta\|\pi_{\text{ref}}) KL ( π θ ∥ π ref ) 的一阶近似。这和"它是 reverse KL 的梯度"并不矛盾。模型离参考分布不远时,两个方向的 KL 梯度本来就很接近,离得越远,它们的差别越大。图 1 也能看出这一点,两条曲线在 π θ ( A ) = π ref ( A ) \pi_\theta(A)=\pi_{\text{ref}}(A) π θ ( A ) = π ref ( A ) 的位置附近几乎重合,离这个位置越远,分开得越多。
k 3 k_3 k 3 的系数在 ρ \rho ρ 的两侧并不对称,图 2 画出了三个估计器在单个样本上的系数。在 ρ > 0 \rho>0 ρ > 0 的一侧,也就是模型给某个 token 的概率高于参考分布时,k 3 k_3 k 3 的系数最大只能到 1。在 ρ < 0 \rho<0 ρ < 0 的一侧,也就是模型给某个 token 的概率低于参考分布时,系数的绝对值按 e − ρ e^{-\rho} e − ρ 指数增长。比如 ρ = 2 \rho=2 ρ = 2 时,k 2 k_2 k 2 的系数是 2,k 3 k_3 k 3 的系数是 0.865。ρ = − 2 \rho=-2 ρ = − 2 时,k 2 k_2 k 2 的系数是 − 2 -2 − 2 ,k 3 k_3 k 3 的系数是 1 − e 2 ≈ − 6.39 1-e^2\approx-6.39 1 − e 2 ≈ − 6.39 。
图 2 需要 JavaScript 才能显示。
要注意,这是单个样本上的系数。对一个 ρ \rho ρ 远小于 0 的 token v v v ,它在 π θ \pi_\theta π θ 下很少被采到。乘上它被采到的概率以后,它的 logit 上的期望梯度是 π θ ( v ) − π ref ( v ) \pi_\theta(v)-\pi_{\text{ref}}(v) π θ ( v ) − π ref ( v ) ,梯度下降会把它往回拉,但拉的幅度不会超过 π ref ( v ) \pi_{\text{ref}}(v) π ref ( v ) 。所以指数增长的系数在期望上并没有带来很大的拉力,它带来的主要是方差,偶尔采到一个这样的 token,就会产生一个很大的梯度。4.1 节会看到,DeepSeek-V3.2 的技术报告 对 k 3 k_3 k 3 的批评说的就是这一点。拉力在两侧各有多大,第 6 章还会在 generator 的设定下专门分析。
2.3 PPO 和 GRPO 的 KL 有什么不同?
除了当 loss,KL 还可以放进 reward。InstructGPT(Ouyang 等人,2022)式的 PPO 就是这样做的,它把每个 token 的 ρ \rho ρ 乘上 β \beta β ,从这个 token 的 reward 里减掉。这时 ρ \rho ρ 被当作 reward 的一部分,不参与求导,它对梯度的影响通过 policy gradient 体现,也就是作为系数乘在 score 前面。KL 这一部分的系数是 β ρ \beta\rho β ρ ,所以它在期望上和 k 2 k_2 k 2 当 loss 相同,给出的也是 forward KL 的梯度。这个结论只在单个位置上成立,放到整条序列上两者有什么区别,第 3 章会讨论。
有了这些结论,我们可以重新看 PPO 和 GRPO 里的 KL。我们在之前的笔记 里写过这样一句话:"k 3 k_3 k 3 正是 GRPO 在 KL 散度估计上区别于 PPO 的一大特点(PPO 使用的是 k 1 k_1 k 1 )"。现在可以把这句话说得更完整一些。InstructGPT 式的 PPO 把 k 1 k_1 k 1 放进 reward,它的梯度对应 forward KL。GRPO(Shao 等人,2024)把 k 3 k_3 k 3 放进 loss,在样本来自当前模型的近似下,它的梯度对应 reverse KL。除了估计器不同以外,两者优化的 KL 方向也不同。2.2 节说过,模型离 reference model 不远时,两个方向的梯度很接近,所以这个差别在实践中的影响可能并不大。DeepSeek-V3.2 的技术报告 后来修正了 GRPO 的这个 k 3 k_3 k 3 项,4.1 节会介绍修正的方式。
到这里,我们讨论的都是单个位置上的梯度。k 1 k_1 k 1 放进 reward 和 k 2 k_2 k 2 放进 loss 在单个位置上期望相同,但在实际训练里,这两种放法仍然有区别,下一章就讨论这个区别。
3. KL 放在 reward 里和放在 loss 里,有什么区别?
TL;DR: KL 放进 reward 时,会和任务 reward 一起经过 advantage 的标准化和 PPO 的 clip,所以同一个 β \beta β 在不同 prompt 上实际起的作用并不相同。它还会通过 advantage 传给前面的 token,这样得到的是整条序列 KL 的准确梯度,但方差更大。KL 放进 loss 时,β \beta β 就是这一项实际的权重,每个 token 只约束自己所在位置上的分布,方差较小,但得到的不是整条序列 KL 的梯度。
把 KL 放进 reward,是指把 β ρ t \beta\rho_t β ρ t (通常是 detach 之后的值)从第 t t t 个 token 的 reward 里减掉,然后和任务 reward 一起计算 advantage,PPO 的经典实现就是这样做的。把 KL 放进 loss,是指 advantage 只由任务 reward 计算,KL 作为一个单独的、可以求导的项加进 loss,比如 L = L PG + β ⋅ m e a n t k ( ρ t ) L=L_{\text{PG}}+\beta\cdot\mathrm{mean}_t\,k(\rho_t) L = L PG + β ⋅ mean t k ( ρ t ) ,GRPO 的做法属于这一种。
2.3 节说明,在单个位置上,k 1 k_1 k 1 放进 reward 和 k 2 k_2 k 2 放进 loss 的期望梯度相同。但这两种放法在实际训练中仍然有两个区别。第一个区别是,放进 reward 以后,KL 会和任务 reward 一起经过 advantage 的各种处理。第二个区别是,放进 reward 以后,KL 会沿着序列传给前面的 token。下面两节分别讨论。这两个区别在后半篇也会用到,第 5 章会看到,在 Score Function Centering 下,拉近 trainer 和 generator 的 KL 都可以写成对 advantage 的修改,那时同样要注意这两个问题。
3.1 放进 reward 以后,KL 会被怎样重新缩放?
把 KL 放进 reward 以后,advantage 里同时包含了"任务做得好不好"和"离参考分布近不近"两种信息,一个回答可能只是因为离参考分布更近,就拿到了更高的 advantage。除此之外,advantage 之后的每一步处理,也都会作用在 KL 上。比如在 reward 里加了 KL,又像 GRPO 那样按组的标准差做标准化,那么每个 prompt 上的 KL 都会被除以这个 prompt 所在组的标准差。组内 reward 差别小的 prompt 标准差也小,KL 会被放大,而组内 reward 差别大的 prompt,KL 会被缩小,所以同一个 β \beta β 在不同的 prompt 上实际起的作用并不相同。PPO 的 clip 也会作用在 KL 上,如果一个 token 的梯度被 clip 掉了,它的 KL 那一部分的梯度也会一起消失。
把 KL 放进 loss 时,这些处理都不会影响 KL,β \beta β 就是 KL 这一项实际的权重。
3.2 放进 reward 以后,KL 为什么会传给前面的 token?
先回顾一下 advantage 是怎样从每个 token 的 reward 算出来的。这里把第 t t t 个 token 上的 reward 记为 R t R_t R t ,把 critic 对第 t t t 步状态的价值估计记为 V ( s t ) V(s_t) V ( s t ) 。GAE(Generalized Advantage Estimation)先算出每一步的 TD 残差 δ t = R t + γ V ( s t + 1 ) − V ( s t ) \delta_t=R_t+\gamma V(s_{t+1})-V(s_t) δ t = R t + γ V ( s t + 1 ) − V ( s t ) ,再把这一步和之后各步的残差按 γ λ \gamma\lambda γ λ 的幂次加权求和,
A t = ∑ l ≥ 0 ( γ λ ) l δ t + l . A_t=\sum_{l\ge0}(\gamma\lambda)^l\,\delta_{t+l}. A t = l ≥ 0 ∑ ( γ λ ) l δ t + l . (12)
其中 γ \gamma γ 是折扣因子,λ \lambda λ 控制 advantage 往后看多远,λ = 0 \lambda=0 λ = 0 时只看一步,λ \lambda λ 越接近 1,看得越远。我们在介绍 GRPO 的文章 的 8.2 节详细介绍过 GAE。取 γ = λ = 1 \gamma=\lambda=1 γ = λ = 1 时,相邻两步的 V V V 两两抵消,A t = ∑ k ≥ t R k − V ( s t ) A_t=\sum_{k\ge t}R_k-V(s_t) A t = ∑ k ≥ t R k − V ( s t ) ,也就是从第 t t t 个 token 开始到序列结束的所有 reward 之和,再减去一个 baseline。
把 KL 放进 reward 时,第 k k k 个 token 的 reward 里多了一项 − β ρ k -\beta\rho_k − β ρ k 。按上面的式子,第 t t t 个 token 的 advantage 里就多了 − β ∑ k ≥ t ρ k -\beta\sum_{k\ge t}\rho_k − β ∑ k ≥ t ρ k ,它包含了从第 t t t 个 token 开始到序列结束的所有 token 的 KL。用 2.1 节的说法,KL 这一部分在第 t t t 个 token 上的系数是
β ∑ k ≥ t ρ k . \beta\sum_{k\ge t}\rho_k. β k ≥ t ∑ ρ k . (13)
这个系数对应的是整条序列的 forward KL 的梯度。原因和 1.1 节的采样项一样。第 t t t 个 token 的选择会改变之后所有 token 所处的前缀,而这些前缀出现的概率也依赖 θ \theta θ ,一个早期的 token 因此要对它之后产生的所有 KL 负责。
把 KL 放进 loss 时,每个 token 的系数只取决于它自己的 ρ t \rho_t ρ t ,比如 k 2 k_2 k 2 的系数是 ρ t \rho_t ρ t ,k 3 k_3 k 3 的系数是 1 − e − ρ t 1-e^{-\rho_t} 1 − e − ρ t 。这相当于在每个固定的前缀上分别约束下一个 token 的分布,但不考虑当前 token 对后面前缀的影响。Tang 和 Munos(2025)把这种做法得到的梯度称为部分梯度。
所以,k 1 k_1 k 1 放进 reward 和逐个 token 的 k 2 k_2 k 2 放进 loss,只在单个位置上等价。放到整条序列上,前者的系数是从当前 token 开始到序列结束的所有 token 的 ρ \rho ρ 之和,它给出的是整条序列 KL 的准确梯度,但序列越长,这个和的波动越大,梯度的方差也就越大。后者每个 token 只用自己的 ρ t \rho_t ρ t ,方差小,但它不是整条序列 KL 的梯度。
如果想在 loss 里得到整条序列 KL 的梯度,可以把 k 2 k_2 k 2 用在整条序列的 log ratio 之和上,也就是 1 2 ( ∑ t ρ t ) 2 \tfrac12\big(\sum_t\rho_t\big)^2 2 1 ( ∑ t ρ t ) 2 。它的梯度是 ( ∑ k ρ k ) ∑ t s θ ( y t ) \big(\sum_k\rho_k\big)\sum_t s_\theta(y_t) ( ∑ k ρ k ) ∑ t s θ ( y t ) ,第 t t t 个 token 的 score 乘上了所有位置的 ρ k \rho_k ρ k 。其中 k < t k<t k < t 的那些 ρ k \rho_k ρ k 在采第 t t t 个 token 之前就已经确定了,和这个 token 的 score 相乘以后期望为 0,所以它在期望上和 k 1 k_1 k 1 放进 reward 相同,只是方差还要更大一些。
前三章都假设样本来自当前模型 π θ \pi_\theta π θ 。GRPO 一批数据更新多次时,以及在异步 RL 里,这个条件都不成立。下一章讨论样本不来自当前模型时会发生什么。
4. 样本不来自当前模型时,会发生什么?
TL;DR: 这一章去掉"样本来自当前模型"这个假设。GRPO 一批数据更新多次时,样本来自 π old \pi_{\text{old}} π old ,k 3 k_3 k 3 当 loss 的梯度既不是 forward KL 的梯度,也不是 reverse KL 的梯度。DeepSeek-V3.2 把 k 3 k_3 k 3 乘上参与求导的比率 π θ / π old \pi_\theta/\pi_{\text{old}} π θ / π old ,得到的才是 forward KL 的准确梯度。在异步 RL 里,样本来自固定的 generator,采样分布不依赖 θ \theta θ ,没有任何一项会被漏掉,所以直接对 k 1 k_1 k 1 或 k 3 k_3 k 3 做 backward,得到的就是 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 的准确梯度。
前三章的 KL 都以 reference model π ref \pi_{\text{ref}} π ref 为参照,样本也都来自当前模型 π θ \pi_\theta π θ 。从这一章开始,样本不再来自 π θ \pi_\theta π θ 。在继续之前,我们先把文中的四个分布放在一起对照一下。
π θ \pi_\theta π θ 是正在训练的模型,每一步都在更新。
π ref \pi_{\text{ref}} π ref 是 reference model,一般是 RL 开始之前的模型,在整个训练过程中固定不变。PPO 和 GRPO 的 KL 正则以它为参照,限制模型离初始模型有多远。
π old \pi_{\text{old}} π old 是 PPO 和 GRPO 里生成当前这批数据的模型,也就是这批数据的 generator。
π generator \pi_{\text{generator}} π generator 是异步 RL 里生成数据的模型。它和 π old \pi_{\text{old}} π old 的角色相同,只是落后得更多。
这几个分布之间的关系,取决于训练的方式。在完全 on-policy 的同步训练里,每批数据只更新一次,更新时的 π θ \pi_\theta π θ 就是刚刚生成这批数据的模型,所以 π old \pi_{\text{old}} π old 和 π θ \pi_\theta π θ 的参数相同,区别只在于 π old \pi_{\text{old}} π old 不参与求导。π ref \pi_{\text{ref}} π ref 则不一样,它从训练开始就固定不变,而 π θ \pi_\theta π θ 一直在更新,所以即使在同步训练里,两者也只在训练刚开始时相同。GRPO 一批数据更新多次时,从第二次更新开始,π θ \pi_\theta π θ 已经比 π old \pi_{\text{old}} π old 多更新了几步,两者不再相同。在异步 RL 里,generator 一边生成数据,trainer 一边更新,π generator \pi_{\text{generator}} π generator 会落后 π θ \pi_\theta π θ 几步甚至几百步。
异步 RL 里的这种落后,正是 Score Function Centering 要处理的问题。从 4.2 节开始,后面几章都在这个设定下讨论,所以这里先回顾它的做法,以及我们在它之外加的 KL。我们之前的文章把 trainer 和 generator 分别记为 p θ p_\theta p θ 和 q ϕ q_\phi q ϕ ,这篇文章记为 π θ \pi_\theta π θ 和 π generator \pi_{\text{generator}} π generator 。
Score Function Centering。 policy gradient 里的 score ∇ θ log π θ ( y ) \nabla_\theta\log\pi_\theta(y) ∇ θ log π θ ( y ) ,只有在 y y y 来自 π θ \pi_\theta π θ 时期望才为 0,这是 advantage 里可以减去 baseline 的前提。当 y y y 来自 π generator \pi_{\text{generator}} π generator 时,这个期望不再是 0,policy gradient 里就会多出一项。这一项等于平均 advantage 乘以 score 在 π generator \pi_{\text{generator}} π generator 下的期望,它在 logit 上的方向是 π generator − π θ \pi_{\text{generator}}-\pi_\theta π generator − π θ ,大小和正负都由平均 advantage 决定,而平均 advantage 并不反映哪个 token 更好。Score Function Centering(下文简称 SFC)把 score 改成以 π generator \pi_{\text{generator}} π generator 为中心,从而去掉了这一项。如果只看对当前位置的 logit 求导的部分,普通的 score 是 e y − π θ e_y-\pi_\theta e y − π θ ,SFC 之后的 score 是 e y − π generator e_y-\pi_{\text{generator}} e y − π generator ,这里的 e y − π θ e_y-\pi_\theta e y − π θ ,就是第 1 章算出的 ∂ log π θ ( y ) / ∂ z \partial\log\pi_\theta(y)/\partial z ∂ log π θ ( y ) / ∂ z 。
计算 SFC 的 score,需要 generator 在这个位置上的完整分布。实际中,generator 只送回概率最高的若干个 token 和它们的概率,这部分称为 head,其余的部分称为 tail。tail 有两种处理方法,一种是再从 tail 里采几个 token 来估计,另一种是只记录 tail 的总概率,我们之前的实验默认用的是后一种。详细的推导见我们介绍 SFC 的文章 。
在 SFC 上加 KL。 SFC 并不限制 trainer 和 generator 之间的距离。距离越大,在 generator 的样本上算出的更新,和在当前模型上应有的更新就差得越多。我们在介绍 SFC 加 KL 的文章 里推导过这个差距的一个上界,它和 K L ( π generator ∥ π θ ) \sqrt{\mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta)} KL ( π generator ∥ π θ ) 成正比,所以又在 SFC 之外加了一个 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 。它对 logit 的梯度是 π θ − π generator \pi_\theta-\pi_{\text{generator}} π θ − π generator ,可以用一个稀疏的估计来计算。对一个从 generator 采到的 token y y y ,这个估计只在 y y y 自己的 logit 上取值 π θ ( y ) / π generator ( y ) − 1 \pi_\theta(y)/\pi_{\text{generator}}(y)-1 π θ ( y ) / π generator ( y ) − 1 ,在其他 logit 上都取 0,它的期望正好是 π θ − π generator \pi_\theta-\pi_{\text{generator}} π θ − π generator 。
另外,每个 token 的 KL 权重会随它的 age 衰减。一个 token 的 age,指的是生成它的 generator 版本比当前 trainer 落后的步数,我们在之前的实验里把它称为 staleness。具体来说,KL 权重 β t \beta_t β t 等于 β 0 \beta_0 β 0 除以这个 token 的 age 的平方根,age 为 0 的 token 权重为 0。
这一章讨论两种样本不来自当前模型的情况。第一种是 GRPO 一批数据更新多次,样本来自 π old \pi_{\text{old}} π old ,KL 的参照仍然是 π ref \pi_{\text{ref}} π ref 。第二种是异步 RL,样本来自 π generator \pi_{\text{generator}} π generator ,我们在 SFC 之外加的 KL 以 π generator \pi_{\text{generator}} π generator 本身为参照,它限制的是每个 generator 版本之内的更新幅度。在完全 on-policy 的同步训练里,generator 就是 π θ \pi_\theta π θ 自己,所以如果不考虑数值误差,这个 KL 恒等于 0,数值误差带来的问题留到 7.2 节讨论。
分析这两种情况时,要用到前面的两个结论,一个是 1.1 节对估计器项和采样项的拆分,另一个是 2.1 节的系数视角。第二种情况是后面几章的基础。
4.1 GRPO 一批数据更新多次时,k 3 k_3 k 3 应该怎么修正?
一批数据更新多次时,从第二次更新开始,样本来自 π old \pi_{\text{old}} π old ,而不是当前的 π θ \pi_\theta π θ 。前面所有的期望都要改成在 π old \pi_{\text{old}} π old 下计算,原来的结论也就不再严格成立。以 k 3 k_3 k 3 当 loss 为例,期望梯度变成了 E y ∼ π old [ ( 1 − π ref / π θ ) s θ ] \mathbb E_{y\sim\pi_{\text{old}}}[(1-\pi_{\text{ref}}/\pi_\theta)\,s_\theta] E y ∼ π old [( 1 − π ref / π θ ) s θ ] ,它既不是 forward KL 的梯度,也不是 reverse KL 的梯度。
要理解这一项该怎么修正,需要先看一个关于 k 3 k_3 k 3 的恒等式。对每一个样本,都有
∇ θ k 3 + k 3 s θ = ( 1 − e − ρ ) s θ + ( e − ρ − 1 + ρ ) s θ = ρ s θ . \nabla_\theta k_3+k_3\,s_\theta=(1-e^{-\rho})s_\theta+(e^{-\rho}-1+\rho)s_\theta=\rho\,s_\theta. ∇ θ k 3 + k 3 s θ = ( 1 − e − ρ ) s θ + ( e − ρ − 1 + ρ ) s θ = ρ s θ . (14)
左边第一项是把 k 3 k_3 k 3 当 loss 时 backward 得到的梯度,对应 1.1 节的估计器项。第二项是把 k 3 k_3 k 3 当作 reward 时 policy gradient 给出的部分,对应 1.1 节里被漏掉的采样项。两者相加,正好是 forward KL 梯度的单样本形式 ρ s θ \rho\,s_\theta ρ s θ 。这个恒等式说明,直接对 k 3 k_3 k 3 做 backward 只保留了估计器项,补回采样项以后就能得到 forward KL 的梯度。
DeepSeek-V3.2 的技术报告 在式 (7) 中修正了这一项,它把 k 3 k_3 k 3 乘上了当前模型和旧模型的比率,
K L ^ = w ⋅ k 3 , w = π θ ( y ) π old ( y ) , y ∼ π old . \widehat{\mathrm{KL}}=w\cdot k_3,\qquad w=\frac{\pi_\theta(y)}{\pi_{\text{old}}(y)},\qquad y\sim\pi_{\text{old}}. KL = w ⋅ k 3 , w = π old ( y ) π θ ( y ) , y ∼ π old . (15)
如果 w w w 参与求导,那么
∇ θ ( w k 3 ) = w s θ k 3 + w ∇ θ k 3 = w ( k 3 s θ + ∇ θ k 3 ) = w ρ s θ , \nabla_\theta(w\,k_3)=w\,s_\theta\,k_3+w\,\nabla_\theta k_3=w\,(k_3\,s_\theta+\nabla_\theta k_3)=w\,\rho\,s_\theta, ∇ θ ( w k 3 ) = w s θ k 3 + w ∇ θ k 3 = w ( k 3 s θ + ∇ θ k 3 ) = w ρ s θ , (16)
最后一步用的就是上面的恒等式。在 π old \pi_{\text{old}} π old 下取期望,得到 E y ∼ π θ [ ρ s θ ] \mathbb E_{y\sim\pi_\theta}[\rho\,s_\theta] E y ∼ π θ [ ρ s θ ] ,就是 forward KL 的准确梯度。
当 w w w 参与求导时,从系数的角度看,这个修正同时做了两件事。第一件事是修正采样分布,把 π old \pi_{\text{old}} π old 下的期望转成 π θ \pi_\theta π θ 下的期望,这是比率本来的用途。第二件事不太明显。w w w 对 θ \theta θ 的导数是 w s θ w\,s_\theta w s θ ,它的作用相当于补回了采样项。因此,即使在第一次更新时 π old \pi_{\text{old}} π old 和 π θ \pi_\theta π θ 完全相同,w w w 的数值等于 1,只要它参与求导,k 3 k_3 k 3 的梯度就会从 reverse KL 变成 forward KL。反过来,如果把 w w w detach 掉,得到的仍然是 reverse KL 的梯度。
DeepSeek-V3.2 的报告也解释了原来的 k 3 k_3 k 3 有什么问题。如果采到的 token 在当前模型下的概率远低于在 reference model 下的概率,k 3 k_3 k 3 的梯度会给它一个很大而且没有上界的权重,使梯度的噪声变大。这对应 2.2 节里 k 3 k_3 k 3 的系数的绝对值在 ρ < 0 \rho<0 ρ < 0 一侧指数增长的那部分。
4.2 样本来自固定的 generator 时,为什么直接对 k 1 k_1 k 1 求导反而是对的?
在我们之前讨论的异步 RL 设定 里,样本来自 π generator \pi_{\text{generator}} π generator ,KL 的参照也是 π generator \pi_{\text{generator}} π generator ,我们要约束的是
K L ( π generator ∥ π θ ) = E y ∼ π generator [ log π generator ( y ) − log π θ ( y ) ] . \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta)=\mathbb E_{y\sim\pi_{\text{generator}}}\big[\log\pi_{\text{generator}}(y)-\log\pi_\theta(y)\big]. KL ( π generator ∥ π θ ) = E y ∼ π generator [ log π generator ( y ) − log π θ ( y ) ] . (17)
和前面不同的是,采样分布 π generator \pi_{\text{generator}} π generator 不依赖 θ \theta θ 。1.1 节的采样项来自"采样分布依赖 θ \theta θ ",现在这个依赖不存在了,也就没有东西会被漏掉。
从这一节开始,KL 的参照是 π generator \pi_{\text{generator}} π generator ,所以我们把 log ratio 相应地定义为 ρ ( y ) = log π θ ( y ) − log π generator ( y ) \rho(y)=\log\pi_\theta(y)-\log\pi_{\text{generator}}(y) ρ ( y ) = log π θ ( y ) − log π generator ( y ) ,并记 r = e ρ = π θ ( y ) / π generator ( y ) r=e^\rho=\pi_\theta(y)/\pi_{\text{generator}}(y) r = e ρ = π θ ( y ) / π generator ( y ) 。套用前情回顾里的三个估计器时,样本来自 π generator \pi_{\text{generator}} π generator ,所以 π generator \pi_{\text{generator}} π generator 处在 q q q 的位置上,π θ \pi_\theta π θ 处在 p p p 的位置上,这里的 r r r 正好就是前情回顾里的 r r r 。
把 k 1 k_1 k 1 ,即 − log r = log π generator ( y ) − log π θ ( y ) -\log r=\log\pi_{\text{generator}}(y)-\log\pi_\theta(y) − log r = log π generator ( y ) − log π θ ( y ) ,直接拿来 backward,单个样本的梯度是 − s θ ( y ) -s_\theta(y) − s θ ( y ) ,它的期望
− E y ∼ π generator [ s θ ( y ) ] = ∇ θ K L ( π generator ∥ π θ ) -\mathbb E_{y\sim\pi_{\text{generator}}}[s_\theta(y)]=\nabla_\theta\mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) − E y ∼ π generator [ s θ ( y )] = ∇ θ KL ( π generator ∥ π θ ) (18)
就是准确的梯度。在 logit 空间里,这个梯度是 π θ − π generator \pi_\theta-\pi_{\text{generator}} π θ − π generator ,梯度下降的更新方向是 π generator − π θ \pi_{\text{generator}}-\pi_\theta π generator − π θ 。用梯度下降最小化它,就是在 generator 采出来的 token 上最大化 log π θ \log\pi_\theta log π θ ,也就是在 generator 的样本上做 SFT。
k 3 k_3 k 3 也可以用。k 3 = ( r − 1 ) − log r k_3=(r-1)-\log r k 3 = ( r − 1 ) − log r ,单个样本的梯度是 ( r − 1 ) s θ (r-1)\,s_\theta ( r − 1 ) s θ 。它的期望
E y ∼ π generator [ ( r − 1 ) s θ ] = E y ∼ π θ [ s θ ] − E y ∼ π generator [ s θ ] = − E y ∼ π generator [ s θ ] \mathbb E_{y\sim\pi_{\text{generator}}}[(r-1)\,s_\theta]=\mathbb E_{y\sim\pi_\theta}[s_\theta]-\mathbb E_{y\sim\pi_{\text{generator}}}[s_\theta]=-\mathbb E_{y\sim\pi_{\text{generator}}}[s_\theta] E y ∼ π generator [( r − 1 ) s θ ] = E y ∼ π θ [ s θ ] − E y ∼ π generator [ s θ ] = − E y ∼ π generator [ s θ ] (19)
和 k 1 k_1 k 1 相同。k 3 k_3 k 3 比 k 1 k_1 k 1 多出来的 r s θ r\,s_\theta r s θ ,在 π generator \pi_{\text{generator}} π generator 下的期望是 E y ∼ π θ [ s θ ] = 0 \mathbb E_{y\sim\pi_\theta}[s_\theta]=0 E y ∼ π θ [ s θ ] = 0 ,因此它是一个控制变量。在 π θ \pi_\theta π θ 和 π generator \pi_{\text{generator}} π generator 接近时,它可以降低梯度的方差。在估计 KL 的数值时,k 3 k_3 k 3 用控制变量降低了数值的方差,在这里,同样的思路降低的是梯度的方差。
把这一节和 2.2 节放在一起看,两处的代码几乎一样,都是对 π θ \pi_\theta π θ 和另一个分布的 log 概率之差做 backward,只差一个符号。样本由当前模型自己采出来时,梯度的期望是 0。样本来自一个固定的 generator 时,它给出的却是 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 的准确梯度。两者的区别只在于采样分布是否依赖 θ \theta θ 。另外,按照第 1 章的叫法,K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 属于 reverse KL,和 GRPO 里 k 3 k_3 k 3 当 loss 时的梯度是同一个方向。
这个更新方向在介绍 SFC 时也出现过。我们在介绍 SFC 的文章 里讨论过,异步 RL 里如果不做 SFC,平均 advantage 会乘上同一个更新方向 π generator − π θ \pi_{\text{generator}}-\pi_\theta π generator − π θ ,大小和正负都由平均 advantage 决定。SFC 把这一项从 policy gradient 里去掉,再加上 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) ,等于把同一个方向加了回来,只是权重变成了我们自己选的 β \beta β 。这也是我们之前选择 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 这个方向的原因。
5. 在 Score Function Centering 下,拉近 trainer 和 generator 的 KL 怎样作用在 advantage 上?
TL;DR: 记 r = π θ ( y ) / π generator ( y ) r=\pi_\theta(y)/\pi_{\text{generator}}(y) r = π θ ( y ) / π generator ( y ) 。在 Score Function Centering 下,加上一个权重为 β \beta β 的 trainer-generator KL,等价于在 advantage 全部算完以后,把每个采到的 token 的 advantage 减去 β \beta β 乘以一个只依赖 r r r 的系数。K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 的系数是 r − 1 r-1 r − 1 。k 4 k_4 k 4 是 log r \log r log r 在 π generator \pi_{\text{generator}} π generator 下的方差的一半,它的系数是 log r \log r log r 。K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 的系数大约是 r log r r\log r r log r 。三个系数在 r = 1 r=1 r = 1 附近一阶相同,所以 trainer 和 generator 离得近时,几种写法的差别不大。
4.2 节说明,样本来自固定的 generator 时,K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 的梯度可以准确地算出来。不过,梯度算得准,只说明我们准确地优化了这个 KL,并不说明它就是最合适的约束。把 trainer 拉向 generator 的写法还有好几种,它们在 trainer 和 generator 接近时作用差不多,离得远时,对概率正在下降和正在上升的 token 施加的力却很不一样。为了比较这些写法,这一章在 Score Function Centering(SFC)的设定下,把它们都写成"给 advantage 减去 β \beta β 乘以一个系数"的形式。5.1 节推导这个形式,5.2 节用一个词表只有三个 token 的例子,看 trainer 和 generator 接近时这几种写法的差别有多大。
5.1 怎样把一个 KL 项写成对 advantage 的修改?
在 SFC 下,score 是以 π generator \pi_{\text{generator}} π generator 为中心的版本,对当前位置 logit 的部分是 e y − π generator e_y-\pi_{\text{generator}} e y − π generator 。从这一章开始,"系数"指的是乘在这个 score 上的量。设样本来自 π generator \pi_{\text{generator}} π generator ,每个样本的系数是 f ( y ) f(y) f ( y ) ,把 f f f 在整个词表上的取值排成一个向量 f f f ,那么期望是
E y ∼ π generator [ f ( y ) ( e y − π generator ) ] = d i a g ( π generator ) f − π generator ( π generator ⊤ f ) = F generator f , F generator = d i a g ( π generator ) − π generator π generator ⊤ . \mathbb E_{y\sim\pi_{\text{generator}}}\big[f(y)\,(e_y-\pi_{\text{generator}})\big]=\mathrm{diag}(\pi_{\text{generator}})\,f-\pi_{\text{generator}}\,(\pi_{\text{generator}}^\top f)=F_{\text{generator}}\,f,\qquad F_{\text{generator}}=\mathrm{diag}(\pi_{\text{generator}})-\pi_{\text{generator}}\pi_{\text{generator}}^\top. E y ∼ π generator [ f ( y ) ( e y − π generator ) ] = diag ( π generator ) f − π generator ( π generator ⊤ f ) = F generator f , F generator = diag ( π generator ) − π generator π generator ⊤ . (20)
记 1 \mathbf 1 1 为所有分量都等于 1 的向量。F generator 1 = π generator − π generator ( π generator ⊤ 1 ) = 0 F_{\text{generator}}\mathbf 1=\pi_{\text{generator}}-\pi_{\text{generator}}(\pi_{\text{generator}}^\top\mathbf 1)=0 F generator 1 = π generator − π generator ( π generator ⊤ 1 ) = 0 ,因此给 f f f 的每个分量加上同一个常数,不会改变结果,这就是 SFC 下的 baseline 不变性。
policy gradient 那一项也可以写成这种形式。在当前前缀上选择 token v v v 之后,记期望的 advantage 为 A v A_v A v ,把它们排成向量 A A A 。policy gradient 那一项的系数是采到的样本的 advantage,它给出的期望更新方向是 F generator A F_{\text{generator}}A F generator A 。如果某个 KL 作为 loss,它的期望梯度也能写成 F generator f F_{\text{generator}}f F generator f ,那么加上权重为 β \beta β 的这个 KL 以后,梯度下降的期望更新方向是 F generator ( A − β f ) F_{\text{generator}}(A-\beta f) F generator ( A − β f ) 。也就是说,加上这个 KL,等价于把 advantage 从 A A A 改成 A − β f A-\beta f A − β f 。
用修改 advantage 的方式来实现时,要注意第 3 章说的两个问题。上面的等价关系在每个位置上分别成立,β \beta β 就是这一项实际的权重。所以对 advantage 的修改应该放在 advantage 全部计算完成之后,也就是组内标准化之后,并且只作用在当前 token 上,不沿序列向前累加。
下面依次看三种写法对应的 f f f 。第一种是 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 。4.2 节说明,它在 logit 空间的梯度是 π θ − π generator \pi_\theta-\pi_{\text{generator}} π θ − π generator ,而 π generator ⊙ r = π θ \pi_{\text{generator}}\odot r=\pi_\theta π generator ⊙ r = π θ ,其中 ⊙ \odot ⊙ 表示逐个分量相乘,所以
F generator ( r − 1 ) = π generator ⊙ ( r − 1 ) − π generator ( ∑ v π θ ( v ) − ∑ v π generator ( v ) ) = π θ − π generator . F_{\text{generator}}(r-1)=\pi_{\text{generator}}\odot(r-1)-\pi_{\text{generator}}\Big(\sum_v\pi_\theta(v)-\sum_v\pi_{\text{generator}}(v)\Big)=\pi_\theta-\pi_{\text{generator}}. F generator ( r − 1 ) = π generator ⊙ ( r − 1 ) − π generator ( v ∑ π θ ( v ) − v ∑ π generator ( v ) ) = π θ − π generator . (21)
因此在 SFC 下,加一个权重为 β \beta β 的 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) ,在期望上等价于把每个样本的 advantage 从 A A A 改成 A − β ( r − 1 ) A-\beta(r-1) A − β ( r − 1 ) 。第 4 章开头回顾的稀疏估计用的也是 r − 1 r-1 r − 1 这个数,只是它乘在 e y e_y e y 上,只更新采到的那个 token 的 logit。两种做法在单个样本上的梯度不同,期望都是 π θ − π generator \pi_\theta-\pi_{\text{generator}} π θ − π generator 。
第二种写法的出发点是,我们希望系数就是 log r \log r log r 本身。和 r − 1 r-1 r − 1 相比,log r \log r log r 只按对数增长,在 r r r 很大时也不会变得很大。可以验证,下面这个目标在 SFC 下对应的系数恰好就是 log r \log r log r ,它是 log r \log r log r 在 π generator \pi_{\text{generator}} π generator 下的方差的一半,
k 4 = 1 2 V a r y ∼ π generator [ log r ( y ) ] . k_4=\tfrac12\,\mathrm{Var}_{y\sim\pi_{\text{generator}}}\big[\log r(y)\big]. k 4 = 2 1 Var y ∼ π generator [ log r ( y ) ] . (22)
它的梯度是
∇ z k 4 = E y ∼ π generator [ ( log r − E π generator log r ) ( e y − π θ ) ] = π generator ⊙ ( log r − E π generator log r ) = F generator log r . \nabla_z k_4=\mathbb E_{y\sim\pi_{\text{generator}}}\big[(\log r-\mathbb E_{\pi_{\text{generator}}}\log r)\,(e_y-\pi_\theta)\big]=\pi_{\text{generator}}\odot(\log r-\mathbb E_{\pi_{\text{generator}}}\log r)=F_{\text{generator}}\log r. ∇ z k 4 = E y ∼ π generator [ ( log r − E π generator log r ) ( e y − π θ ) ] = π generator ⊙ ( log r − E π generator log r ) = F generator log r . (23)
k 2 k_2 k 2 用的是 1 2 ( log r ) 2 \tfrac12(\log r)^2 2 1 ( log r ) 2 的平均值,这里用的是减去均值以后的平方的平均值。为了和前三个估计器并列,下文把它记为 k 4 k_4 k 4 。需要说明的是,Schulman 的博客里只有 k 1 k_1 k 1 到 k 3 k_3 k 3 ,k 4 k_4 k 4 是本文为了叙述方便起的名字。π θ \pi_\theta π θ 和 π generator \pi_{\text{generator}} π generator 很接近时,它和 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 在二阶以内相同,所以也可以把它看成 KL 的一种写法。梯度里 log r \log r log r 减去了它在 π generator \pi_{\text{generator}} π generator 下的均值,这相当于 2.1 节说的减去一个 baseline。在 SFC 下,这个均值减不减都一样,因为 F generator 1 = 0 F_{\text{generator}}\mathbf 1=0 F generator 1 = 0 。
所以在 SFC 下,k 4 k_4 k 4 等价于把 advantage 改成 A − β log r A-\beta\log r A − β log r 。它的实现很简单,不需要单独的 loss 项,只要在每个采到的 token 上,用 detach 之后的 log π θ ( y ) − log π generator ( y ) \log\pi_\theta(y)-\log\pi_{\text{generator}}(y) log π θ ( y ) − log π generator ( y ) 去修改 advantage。KLPO(Zhang, 2026)讨论过同一个目标,它把这种做法称为 token regression,并在附录 D 中把对应的目标写成了 advantage 加权的 log ratio,再加上 β / 2 \beta/2 β /2 倍的 log ratio 方差。
需要注意的是,k 4 k_4 k 4 必须和 SFC 一起使用。如果 score 还是普通的 e y − π θ e_y-\pi_\theta e y − π θ ,同样的代码实现的是不减均值的版本,也就是 1 2 E π generator [ ( log r ) 2 ] \tfrac12\mathbb E_{\pi_{\text{generator}}}[(\log r)^2] 2 1 E π generator [( log r ) 2 ] 的梯度。这个目标在 SFC 下对应的系数是 log r − E π generator [ log r ] ⋅ r \log r-\mathbb E_{\pi_{\text{generator}}}[\log r]\cdot r log r − E π generator [ log r ] ⋅ r ,比 k 4 k_4 k 4 多出了 − E π generator [ log r ] ⋅ r -\mathbb E_{\pi_{\text{generator}}}[\log r]\cdot r − E π generator [ log r ] ⋅ r 这一项。
第三种是另一个方向的 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 。以 reference model 为参照时,RLHF 通常约束的就是这个方向,所以也值得看一下它用在 generator 上会怎样。它就是以 π generator \pi_{\text{generator}} π generator 为参照的 forward KL,由 2.1 节,它的梯度是 E y ∼ π θ [ log r s θ ] \mathbb E_{y\sim\pi_\theta}[\log r\,s_\theta] E y ∼ π θ [ log r s θ ] 。样本来自 π generator \pi_{\text{generator}} π generator 时,乘上比率 r r r ,就能把这个期望改写成 π generator \pi_{\text{generator}} π generator 下的期望,所以用普通的 score、系数取 detach 之后的 r log r r\log r r log r ,就能得到准确的梯度,
E y ∼ π generator [ r log r ( e y − π θ ) ] = π θ ⊙ log r − π θ E π θ [ log r ] = π θ ⊙ ( log r − K L ( π θ ∥ π generator ) ) . \mathbb E_{y\sim\pi_{\text{generator}}}\big[r\log r\,(e_y-\pi_\theta)\big]=\pi_\theta\odot\log r-\pi_\theta\,\mathbb E_{\pi_\theta}[\log r]=\pi_\theta\odot\big(\log r-\mathrm{KL}(\pi_\theta\|\pi_{\text{generator}})\big). E y ∼ π generator [ r log r ( e y − π θ ) ] = π θ ⊙ log r − π θ E π θ [ log r ] = π θ ⊙ ( log r − KL ( π θ ∥ π generator ) ) . (24)
在 SFC 下,对应的系数是 r ( log r − K L ( π θ ∥ π generator ) ) r\,(\log r-\mathrm{KL}(\pi_\theta\|\pi_{\text{generator}})) r ( log r − KL ( π θ ∥ π generator )) 。当 π θ \pi_\theta π θ 和 π generator \pi_{\text{generator}} π generator 接近时,K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 是一个二阶小量,这个系数约等于 r log r r\log r r log r 。
总结一下,在 SFC 下,K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 的系数是 r − 1 r-1 r − 1 ,k 4 k_4 k 4 的系数是 log r \log r log r ,K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 的系数大约是 r log r r\log r r log r 。三者都是 r r r 的函数,在 r = 1 r=1 r = 1 处都等于 0,并且在 r = 1 r=1 r = 1 附近一阶相同。三种写法都可以通过修改 advantage 来实现,只用到采到的 token 的 π θ ( y ) \pi_\theta(y) π θ ( y ) 和 π generator ( y ) \pi_{\text{generator}}(y) π generator ( y ) ,其中 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 的准确系数还需要估计 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 本身。
5.2 trainer 和 generator 接近时,这几种写法的差别大吗?
5.1 节的三个系数在 r = 1 r=1 r = 1 附近一阶相同,这意味着 trainer 和 generator 接近时,它们给出的梯度应该差别不大。下面用一个词表只有三个 token 的例子来看这一点,同时看看它们在细节上有什么不同。
设 π generator = ( 0.6 , 0.3 , 0.1 ) \pi_{\text{generator}}=(0.6,0.3,0.1) π generator = ( 0.6 , 0.3 , 0.1 ) ,π θ = ( 0.5 , 0.3 , 0.2 ) \pi_\theta=(0.5,0.3,0.2) π θ = ( 0.5 , 0.3 , 0.2 ) ,那么 r = ( 0.833 , 1 , 2 ) r=(0.833,1,2) r = ( 0.833 , 1 , 2 ) ,log r ≈ ( − 0.182 , 0 , 0.693 ) \log r\approx(-0.182,0,0.693) log r ≈ ( − 0.182 , 0 , 0.693 ) ,E π generator [ log r ] ≈ − 0.040 \mathbb E_{\pi_{\text{generator}}}[\log r]\approx-0.040 E π generator [ log r ] ≈ − 0.040 。两个方向的 KL 分别是 K L ( π generator ∥ π θ ) ≈ 0.040 \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta)\approx0.040 KL ( π generator ∥ π θ ) ≈ 0.040 和 K L ( π θ ∥ π generator ) ≈ 0.048 \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}})\approx0.048 KL ( π θ ∥ π generator ) ≈ 0.048 。三种写法在 logit 上的期望梯度如下,图 3 把它们画在了一起。
K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 的梯度是 π θ − π generator = ( − 0.1 , 0 , + 0.1 ) \pi_\theta-\pi_{\text{generator}}=(-0.1,\ 0,\ +0.1) π θ − π generator = ( − 0.1 , 0 , + 0.1 ) 。
k 4 k_4 k 4 的梯度是 π generator ⊙ ( log r − E π generator log r ) ≈ ( − 0.085 , + 0.012 , + 0.073 ) \pi_{\text{generator}}\odot(\log r-\mathbb E_{\pi_{\text{generator}}}\log r)\approx(-0.085,\ +0.012,\ +0.073) π generator ⊙ ( log r − E π generator log r ) ≈ ( − 0.085 , + 0.012 , + 0.073 ) 。
K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 的梯度是 π θ ⊙ ( log r − K L ( π θ ∥ π generator ) ) ≈ ( − 0.115 , − 0.014 , + 0.129 ) \pi_\theta\odot(\log r-\mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}))\approx(-0.115,\ -0.014,\ +0.129) π θ ⊙ ( log r − KL ( π θ ∥ π generator )) ≈ ( − 0.115 , − 0.014 , + 0.129 ) 。
图 3 需要 JavaScript 才能显示。
在梯度下降下,第一个 token 的 logit 会上升,第三个 token 的 logit 会下降,三种写法在这一点上是一致的,都在把 π θ \pi_\theta π θ 拉回 π generator \pi_{\text{generator}} π generator 。区别在第二个 token 上。它的 r = 1 r=1 r = 1 ,在 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 下完全不动,在 k 4 k_4 k 4 下会被轻微压低,在 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 下反而会被轻微抬高。原因是每种写法拿 log r \log r log r 比较的基准不同。k 4 k_4 k 4 拿它和 π generator \pi_{\text{generator}} π generator 下的平均值比较,这个平均值是 − 0.040 -0.040 − 0.040 ,所以 r = 1 r=1 r = 1 的 token 相对来说偏高了。K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 拿它和 π θ \pi_\theta π θ 下的平均值比较,这个平均值就是 K L ( π θ ∥ π generator ) = 0.048 \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}})=0.048 KL ( π θ ∥ π generator ) = 0.048 ,所以同一个 token 相对来说偏低了。
这个例子里几种写法的差别都不大,因为 trainer 和 generator 离得不远。trainer 和 generator 会离多远,取决于 β \beta β 和 advantage 的相对大小。当 β \beta β 明显大于 advantage 之间的差别时,KL 会把 r r r 维持在 1 附近,几种写法的差别不大。当 β \beta β 和 advantage 之间的差别在同一个量级,或者比它更小时,r r r 会离 1 很远,系数在远离 r = 1 r=1 r = 1 处的形状就会让几种写法的行为差别很大。在我们之前的实验设置里,一个典型的 token 的 β t \beta_t β t 只有 0.04 左右,而 advantage 之间的差别可以到 1 这个量级,正好属于后一种情况,6.1 节会给出这两个数的来历。下一章就讨论这种情况。
6. 三种写法分别怎样约束概率下降和概率上升的 token?
TL;DR: 三种写法的差别主要出现在 r r r 远离 1 的时候。对概率正在被压低的 token,k 4 k_4 k 4 的拉力随着概率下降没有上限,能把这些 token 保住。K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 的拉力有上限,K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 的拉力会趋于 0,所以 β \beta β 较小时,在这两种写法下,advantage 偏低的 token 都可能被一直压到 0。对概率正在被抬高的 token,情况正好反过来,k 4 k_4 k 4 的约束最弱,K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 的约束最强。哪一种写法更合适,取决于训练中哪一类 token 的风险更大,以及 β \beta β 和 advantage 的相对大小。
第 5 章把三种写法都写成了给 advantage 减去 β \beta β 乘以一个系数的形式。K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 的系数是 r − 1 r-1 r − 1 ,k 4 k_4 k 4 的系数是 log r \log r log r ,K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 的系数大约是 r log r r\log r r log r 。当 trainer 和 generator 离得比较远时,这三个系数的形状决定了它们的行为。我们分两类 token 来看,一类是概率正在被压低的 token,也就是 r < 1 r<1 r < 1 的 token,另一类是概率正在被抬高的 token,也就是 r > 1 r>1 r > 1 的 token。这一章先在 6.1 节比较三种写法在单个 token 上的拉力,再在 6.2 节用一个简化的模型看它们最终把分布拉到哪里。6.3 节讨论每种写法的代价,6.4 节讨论选择时可以考虑的因素。
6.1 一个 token 的概率被持续压低时,三种写法能把它拉回来吗?
KL 的权重是 β \beta β ,但 KL 对训练的实际影响,还取决于 β \beta β 乘上的那个系数,而且要和 advantage 的大小放在一起比较。为此,我们看某个 token v v v 的 logit 在 SFC 下受到的"力",这里的力指的是这个 logit 上的期望更新量。记 Δ A v = A v − E π generator [ A ] \Delta A_v=A_v-\mathbb E_{\pi_{\text{generator}}}[A] Δ A v = A v − E π generator [ A ] ,其中 A v A_v A v 是 5.1 节定义的、选择 token v v v 之后的期望 advantage。由 5.1 节的工具,policy gradient 这一项在 z v z_v z v 上的期望更新是 ( F generator A ) v = π generator ( v ) Δ A v (F_{\text{generator}}A)_v=\pi_{\text{generator}}(v)\,\Delta A_v ( F generator A ) v = π generator ( v ) Δ A v 。这个量只和 π generator \pi_{\text{generator}} π generator 有关,和 π θ ( v ) \pi_\theta(v) π θ ( v ) 当前是多少无关。也就是说,在 generator 固定的情况下,SFC 会一直用同样的力去推或者拉这个 token。这一点和样本来自当前模型时不同,那时 policy gradient 在 z v z_v z v 上的期望更新是 π θ ( v ) ( A v − E π θ [ A ] ) \pi_\theta(v)\,(A_v-\mathbb E_{\pi_\theta}[A]) π θ ( v ) ( A v − E π θ [ A ]) ,token 的概率越低,推力越小。
三种写法把这个 token 往回拉的力分别如下。
K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 的拉力是 β ( π generator ( v ) − π θ ( v ) ) \beta\,(\pi_{\text{generator}}(v)-\pi_\theta(v)) β ( π generator ( v ) − π θ ( v )) 。当 π θ ( v ) → 0 \pi_\theta(v)\to0 π θ ( v ) → 0 时,这个力趋于 β π generator ( v ) \beta\,\pi_{\text{generator}}(v) β π generator ( v ) ,不会再增大。这和 2.2 节里 k 3 k_3 k 3 当 loss 时的情况相同,那里的拉力也不会超过 π ref ( v ) \pi_{\text{ref}}(v) π ref ( v ) 。
k 4 k_4 k 4 的拉力是 β π generator ( v ) ( E π generator log r − log r v ) \beta\,\pi_{\text{generator}}(v)\,(\mathbb E_{\pi_{\text{generator}}}\log r-\log r_v) β π generator ( v ) ( E π generator log r − log r v ) 。当 π θ ( v ) → 0 \pi_\theta(v)\to0 π θ ( v ) → 0 时,− log r v -\log r_v − log r v 越来越大,这个力随着 logit 下降的幅度线性增长,没有上界。
K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 的拉力是 β π θ ( v ) ( K L ( π θ ∥ π generator ) − log r v ) \beta\,\pi_\theta(v)\,(\mathrm{KL}(\pi_\theta\|\pi_{\text{generator}})-\log r_v) β π θ ( v ) ( KL ( π θ ∥ π generator ) − log r v ) ,写成 β π generator ( v ) \beta\,\pi_{\text{generator}}(v) β π generator ( v ) 乘以系数的形式,系数大约是 − r v log r v -r_v\log r_v − r v log r v 。函数 r log r r\log r r log r 在 r = 1 / e r=1/e r = 1/ e 时取到最小值 − 1 / e -1/e − 1/ e ,之后随着 r r r 继续变小又回到 0。所以它往回拉的力最多约为 β π generator ( v ) / e \beta\,\pi_{\text{generator}}(v)/e β π generator ( v ) / e ,而且 token 被压得越低,这个力越弱。
把推力和拉力放在一起比较。对 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 来说,一个正在被压低的 token,往回拉的力不会超过 β π generator ( v ) \beta\,\pi_{\text{generator}}(v) β π generator ( v ) ,而往下推的力是 π generator ( v ) ∣ Δ A v ∣ \pi_{\text{generator}}(v)\,|\Delta A_v| π generator ( v ) ∣Δ A v ∣ 。只要 Δ A v < − β \Delta A_v<-\beta Δ A v < − β ,推力就一直大于拉力,这个 KL 无法阻止这个 token 的概率继续下降,它最终会被压向 0。样本来自当前模型时,推力会随着 π θ ( v ) \pi_\theta(v) π θ ( v ) 一起变小,有上界的拉力足以把 token 拉住。在 SFC 下推力不会变小,有上界的拉力就可能拉不住。
图 4 把三种写法的拉力画成了 r r r 的函数,单位是 β π generator ( v ) \beta\,\pi_{\text{generator}}(v) β π generator ( v ) ,图中省略了 E π generator log r \mathbb E_{\pi_{\text{generator}}}\log r E π generator log r 和 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 这两个小量。token 被压得越低,就越往图的左边走。虚线是推力 ∣ Δ A v ∣ / β |\Delta A_v|/\beta ∣Δ A v ∣/ β ,拖动滑块可以改变它。一条曲线和虚线相交的地方,就是拉力和推力平衡、token 停下来的位置。如果一条曲线一直在虚线下方,这种写法就拉不住这个 token。
图 4 需要 JavaScript 才能显示。
Δ A v < − β \Delta A_v<-\beta Δ A v < − β 的情况在实际训练中是可能出现的。在我们之前的实验设置 里,KL 的权重 β t \beta_t β t 等于 β 0 = 0.3 \beta_0=0.3 β 0 = 0.3 除以 age 的平方根。在 Countdown 的 4-prompt slice 上,也就是 trainer 每次更新用 4 个 prompt 的 rollout 时,token 的平均 age 大约是 50,一个 age 为 50 的 token 的 β t = 0.3 / 50 ≈ 0.042 \beta_t=0.3/\sqrt{50}\approx0.042 β t = 0.3/ 50 ≈ 0.042 。那些实验计算 advantage 时,答对的回答记为 + 1 +1 + 1 ,答错的记为 − 1 -1 − 1 ,再减去组内的平均值,所以单条回答的 advantage 在 ± 1 \pm1 ± 1 这个量级。单个 token 的 Δ A v \Delta A_v Δ A v 通常比这个小,因为大多数 token 换成别的选择,并不会改变回答的结果。但在少数决定回答走向的 token 上,∣ Δ A v ∣ |\Delta A_v| ∣Δ A v ∣ 可能接近这个量级,远远超过 0.042。
不过,在那些实验里,SFC 加 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 一次都没有崩溃过,这和上面的分析可以同时成立。上面的比较假设推力一直持续,而在实际训练中,每一片 rollout 只用来做一次更新,generator 也在不断刷新,同一个前缀很少被反复更新,推力并不会一直持续。另外,一个 token 被压到 0,也不一定会让训练崩溃。拉力的上限说明的是,一旦推力持续存在,这个 KL 能提供的保护是有限的。
教科书里常说 K L ( q ∥ p ) \mathrm{KL}(q\|p) KL ( q ∥ p ) 是 zero-avoiding 的,只要 q ( v ) > 0 q(v)>0 q ( v ) > 0 而 p ( v ) → 0 p(v)\to0 p ( v ) → 0 ,KL 的数值就趋于无穷,所以最小化它会避免把 p p p 的任何部分压到 0。这个说法对 KL 的数值是成立的。但 K L ( q ∥ p ) \mathrm{KL}(q\|p) KL ( q ∥ p ) 的数值只随 − log p ( v ) -\log p(v) − log p ( v ) 增长,换算到 logit 上大约是线性增长,它对 logit 的梯度是有界的。在一个持续不变的推力面前,数值趋于无穷并不能保证这个 token 不被压到 0。
6.2 一直训练下去,三种写法会把分布拉到哪里?
6.1 节只看了单个 token 受到的力。为了看三种写法最终把整个分布拉到哪里,我们用一个简化的模型。固定一个前缀和一个 generator 版本,假设每个 token v v v 的期望 advantage A v A_v A v 固定不变,然后让期望更新一直进行下去,看它最后停在哪里。
在优化里,梯度等于 0 的点通常称为驻点。这里的更新方向不一定是某一个目标函数的梯度,所以我们说的驻点,指的是期望更新量等于 0 的点,也就是动力系统里的不动点。到达驻点以后,期望更新不再改变 π θ \pi_\theta π θ ,如果更新收敛,就会停在这里。驻点不一定能到达,有些 token 的概率会在更新中一直下降,永远停不下来,这时我们关心的是它的极限。下面的分析和例子都围绕驻点展开。
在 SFC 下,更新方向是 F generator ( A − β f ( r ) ) F_{\text{generator}}(A-\beta f(r)) F generator ( A − β f ( r )) ,其中 f f f 是对应写法的系数。当 π generator \pi_{\text{generator}} π generator 的每个分量都大于 0 时,满足 F generator x = 0 F_{\text{generator}}x=0 F generator x = 0 的向量 x x x 只有常数向量,因此驻点满足的条件是,A v − β f ( r v ) A_v-\beta f(r_v) A v − β f ( r v ) 对所有 token 都相等。
对于 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) ,f ( r ) = r − 1 f(r)=r-1 f ( r ) = r − 1 ,驻点是
r v ∗ = 1 + Δ A v β , π θ ∗ ( v ) = π generator ( v ) ( 1 + A v − E π generator [ A ] β ) . r_v^*=1+\frac{\Delta A_v}{\beta},\qquad \pi_\theta^*(v)=\pi_{\text{generator}}(v)\Big(1+\frac{A_v-\mathbb E_{\pi_{\text{generator}}}[A]}{\beta}\Big). r v ∗ = 1 + β Δ A v , π θ ∗ ( v ) = π generator ( v ) ( 1 + β A v − E π generator [ A ] ) . (25)
驻点 r v ∗ r_v^* r v ∗ 是 advantage 的线性函数。它也是 max p E p [ A ] − β 2 χ 2 ( p ∥ π generator ) \max_p\ \mathbb E_p[A]-\tfrac\beta2\chi^2(p\|\pi_{\text{generator}}) max p E p [ A ] − 2 β χ 2 ( p ∥ π generator ) 的驻点,其中 χ 2 ( p ∥ π generator ) = ∑ v ( p ( v ) − π generator ( v ) ) 2 / π generator ( v ) \chi^2(p\|\pi_{\text{generator}})=\sum_v(p(v)-\pi_{\text{generator}}(v))^2/\pi_{\text{generator}}(v) χ 2 ( p ∥ π generator ) = ∑ v ( p ( v ) − π generator ( v ) ) 2 / π generator ( v ) 。也就是说,SFC 加 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 在一个 generator 版本之内的效果,相当于一个 χ 2 \chi^2 χ 2 正则。χ 2 \chi^2 χ 2 正则在 LLM 对齐里也有人讨论过,Huang 等人(2024)认为它比 KL 正则更能抑制对不完美 reward 的过度优化。这个驻点只有在所有 Δ A v ≥ − β \Delta A_v\ge-\beta Δ A v ≥ − β 时才是一个合法的分布。否则,Δ A v < − β \Delta A_v<-\beta Δ A v < − β 的 token 会被一直压向 0,这和 6.1 节的结论一致。
对于 k 4 k_4 k 4 ,f ( r ) = log r f(r)=\log r f ( r ) = log r ,驻点是
π θ ∗ ( v ) ∝ π generator ( v ) e A v / β . \pi_\theta^*(v)\propto\pi_{\text{generator}}(v)\,e^{A_v/\beta}. π θ ∗ ( v ) ∝ π generator ( v ) e A v / β . (26)
它是 max p E p [ A ] − β K L ( p ∥ π generator ) \max_p\ \mathbb E_p[A]-\beta\,\mathrm{KL}(p\|\pi_{\text{generator}}) max p E p [ A ] − β KL ( p ∥ π generator ) 的经典最优解,和 RLHF、DPO 里 π ∗ ∝ π ref e R / β \pi^*\propto\pi_{\text{ref}}\,e^{R/\beta} π ∗ ∝ π ref e R / β 的形式相同,其中 R R R 是 reward。它永远是一个合法的分布,任何 token 都不会被压到恰好为 0。对于被抬高的 token,驻点上的 r v ∗ r_v^* r v ∗ 不会超过 e Δ A v / β e^{\Delta A_v/\beta} e Δ A v / β ,同时也受概率归一化的限制,不会超过 1 / π generator ( v ) 1/\pi_{\text{generator}}(v) 1/ π generator ( v ) 。如果每个 generator 版本都训练到驻点,再用当前的 trainer 作为新的 generator,那么把一轮一轮的结果连起来,就是 π k + 1 ∝ π k e A k / β \pi_{k+1}\propto\pi_k\,e^{A_k/\beta} π k + 1 ∝ π k e A k / β ,和 mirror descent 的形式相同。另外,k 4 k_4 k 4 用的是 generator 的样本,驻点却对应 K L ( p ∥ π generator ) \mathrm{KL}(p\|\pi_{\text{generator}}) KL ( p ∥ π generator ) 方向的正则,而且整个过程不需要任何 importance weight。
对于 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) ,驻点没有简单的解析形式。按 6.1 节的分析,它对被压低的 token 的拉力最多约为 β π generator ( v ) / e \beta\,\pi_{\text{generator}}(v)/e β π generator ( v ) / e ,并且 token 越低拉力越弱。粗略地说,当 Δ A v \Delta A_v Δ A v 低于 − β / e -\beta/e − β / e 左右时,这个 token 会被一直压到 0。准确的阈值是 − β e K − 1 -\beta e^{K-1} − β e K − 1 ,其中 K K K 是驻点上 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 的值,所以它比 − β / e -\beta/e − β / e 还要再低一些。β \beta β 越大,这个阈值越低,被压到 0 的 token 也就越少。
这里有一个容易让人困惑的地方。k 4 k_4 k 4 的驻点是 K L ( p ∥ π generator ) \mathrm{KL}(p\|\pi_{\text{generator}}) KL ( p ∥ π generator ) 正则问题的最优解,直接加 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) ,驻点反而不是。原因在 policy gradient 那一项。在 SFC 下,这一项的期望是 F generator A F_{\text{generator}}A F generator A ,它由 π generator \pi_{\text{generator}} π generator 决定,不随 π θ \pi_\theta π θ 变化。而在 max p E p [ A ] − β K L ( p ∥ π generator ) \max_p\mathbb E_p[A]-\beta\,\mathrm{KL}(p\|\pi_{\text{generator}}) max p E p [ A ] − β KL ( p ∥ π generator ) 这个问题里,E p [ A ] \mathbb E_p[A] E p [ A ] 对 logit 的梯度是 F θ A F_\theta A F θ A ,其中 F θ = d i a g ( π θ ) − π θ π θ ⊤ F_\theta=\mathrm{diag}(\pi_\theta)-\pi_\theta\pi_\theta^\top F θ = diag ( π θ ) − π θ π θ ⊤ 。k 4 k_4 k 4 的驻点条件是 A − β log r A-\beta\log r A − β log r 为常数,正则问题最优解的条件也是这一个,所以两者重合。直接加 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 时,驻点条件是 F generator A = β F θ log r F_{\text{generator}}A=\beta F_\theta\log r F generator A = β F θ log r ,两边乘的矩阵不同,驻点也就不再是那个最优解。
如果不加任何 KL,也就是 β = 0 \beta=0 β = 0 ,那么驻点的条件变成所有 A v A_v A v 都相等,一般不会成立。这时没有驻点,概率会一直流向 advantage 最高的 token。
下面用两个例子把三种写法放在一起比较。这些数字是从 π θ = π generator \pi_\theta=\pi_{\text{generator}} π θ = π generator 出发,在 logit 上反复做期望更新得到的。对于被压向 0 的 token,给出的是更新的极限。
第一个例子里,有的 token 的 advantage 偏低。设 π generator = ( 0.6 , 0.3 , 0.1 ) \pi_{\text{generator}}=(0.6,0.3,0.1) π generator = ( 0.6 , 0.3 , 0.1 ) ,三个 token 的 advantage 是 A = ( 0.5 , 0 , − 0.5 ) A=(0.5,0,-0.5) A = ( 0.5 , 0 , − 0.5 ) ,于是 E π generator [ A ] = 0.25 \mathbb E_{\pi_{\text{generator}}}[A]=0.25 E π generator [ A ] = 0.25 ,Δ A = ( 0.25 , − 0.25 , − 0.75 ) \Delta A=(0.25,-0.25,-0.75) Δ A = ( 0.25 , − 0.25 , − 0.75 ) 。
β = 1 \beta=1 β = 1 时,β \beta β 和 advantage 的差别在同一个量级。K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 停在 ( 0.75 , 0.225 , 0.025 ) (0.75,0.225,0.025) ( 0.75 , 0.225 , 0.025 ) ,k 4 k_4 k 4 停在 ( 0.733 , 0.222 , 0.045 ) (0.733,0.222,0.045) ( 0.733 , 0.222 , 0.045 ) ,两者很接近。K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 的极限是 ( 0.803 , 0.197 , 0 ) (0.803,0.197,0) ( 0.803 , 0.197 , 0 ) ,第三个 token 被压到了 0。如果把 β \beta β 增大到 3,K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 会停在 ( 0.653 , 0.276 , 0.071 ) (0.653,0.276,0.071) ( 0.653 , 0.276 , 0.071 ) ,第三个 token 保留了下来。
β = 0.2 \beta=0.2 β = 0.2 时,β \beta β 比 advantage 的差别小。K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 的线性驻点是 ( 1.35 , − 0.075 , − 0.275 ) (1.35,-0.075,-0.275) ( 1.35 , − 0.075 , − 0.275 ) ,它不是一个合法的分布,实际的更新最后趋于 ( 1 , 0 , 0 ) (1,0,0) ( 1 , 0 , 0 ) 。K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 也趋于 ( 1 , 0 , 0 ) (1,0,0) ( 1 , 0 , 0 ) 。k 4 k_4 k 4 停在 ( 0.960 , 0.039 , 0.001 ) (0.960,0.039,0.001) ( 0.960 , 0.039 , 0.001 ) ,第二和第三个 token 被压得很低,但都没有到 0。
第二个例子里,一个很少被采到的 token 拿到了较高的 advantage。设 π generator = ( 0.9 , 0.09 , 0.01 ) \pi_{\text{generator}}=(0.9,0.09,0.01) π generator = ( 0.9 , 0.09 , 0.01 ) ,A = ( 0 , 0 , 0.5 ) A=(0,0,0.5) A = ( 0 , 0 , 0.5 ) ,β = 0.05 \beta=0.05 β = 0.05 ,β \beta β 远小于 advantage 的差别。
K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 停在 ( 0.81 , 0.081 , 0.109 ) (0.81,0.081,0.109) ( 0.81 , 0.081 , 0.109 ) ,第三个 token 涨到了原来的约 11 倍。
k 4 k_4 k 4 停在 ( 0.004 , 0.0004 , 0.996 ) (0.004,0.0004,0.996) ( 0.004 , 0.0004 , 0.996 ) ,第三个 token 几乎占据了全部概率,它的 r r r 约为 100,已经到了概率归一化允许的上限 1 / π generator ( v ) 1/\pi_{\text{generator}}(v) 1/ π generator ( v ) 。
K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 停在 ( 0.856 , 0.086 , 0.058 ) (0.856,0.086,0.058) ( 0.856 , 0.086 , 0.058 ) ,第三个 token 涨到了原来的约 5.8 倍。
图 5 画出了这两个例子的驻点。上方的按钮用来切换例子,拖动滑块可以把 β \beta β 从 0.01 调到 10,看三种写法的驻点怎样随 β \beta β 变化。β \beta β 很大时,三种写法的驻点都贴近 generator。β \beta β 越小,它们分开得越明显。
图 5 需要 JavaScript 才能显示。
两个例子放在一起,可以看到三种写法的分工。在第一个例子里,β \beta β 较小时,只有 k 4 k_4 k 4 保留了 advantage 偏低的 token,在另外两种写法下,它们都被压到了 0。在第二个例子里,advantage 较高的稀有 token 在 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 下涨得最少,在 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 下涨得多一些,在 k 4 k_4 k 4 下几乎占据了全部概率。
哪一种行为是我们想要的,取决于 advantage 有多可靠。如果第二个例子里那个稀有 token 的高 advantage 反映的是一个确实更好的行为,让它快速增长就是好事。如果它来自一个过时的样本、一个 reward 的漏洞,或者单纯的噪声,限制它的增长会更安全。第一个例子也是这样。如果低 advantage 的 token 确实不好,把它压到 0 并没有问题。如果它只是这一次运气不好,把它压到 0 就会损失探索。
最后要说明这个简化模型的适用范围。实际训练中,每个 generator 版本只会训练有限的步数,generator 会不断刷新,不同位置之间还共享参数。驻点只能说明每种写法往哪个方向拉、最多拉到哪里,并不能预测训练的具体结果。
6.3 每种写法的代价是什么?
6.1 节和 6.2 节讨论的是每种写法在期望上的行为。实际使用时,还要考虑它们的方差,以及它们的行为本身带来的风险。
5.1 节说明,三种写法都可以通过修改 advantage 来实现,只用到采到的 token 的 π θ ( y ) \pi_\theta(y) π θ ( y ) 和 π generator ( y ) \pi_{\text{generator}}(y) π generator ( y ) ,所以它们在实现上的差别并不大。方差上的差别主要来自系数的大小。K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 的系数 r − 1 r-1 r − 1 里有 1 / π generator ( y ) 1/\pi_{\text{generator}}(y) 1/ π generator ( y ) ,一个在 generator 下概率很小、在 trainer 下概率涨上来的 token,一旦被采到,系数就会很大。K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 的系数 r log r r\log r r log r 比 r − 1 r-1 r − 1 增长得更快,这和 importance sampling 的方差问题是同一类。k 4 k_4 k 4 的系数 log r \log r log r 只按对数增长,方差可能最小。
另一种降低方差的做法,是在 head 上精确计算期望,只对 tail 做估计,原则上三种写法都可以这样做。以 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 为例,记 head 在 generator 下的总概率为 α \alpha α ,head 上的 token 可以精确计算 π θ − π generator \pi_\theta-\pi_{\text{generator}} π θ − π generator ,tail 上采到的 token 用 ( 1 − α ) ( π θ / π generator − 1 ) (1-\alpha)(\pi_\theta/\pi_{\text{generator}}-1) ( 1 − α ) ( π θ / π generator − 1 ) 来估计。如果连 tail 上的采样也省掉,只在 head 上精确计算,并把 tail 合并成一个类别,只用到 tail 的总概率,那么采样带来的方差就没有了,但会漏掉 tail 内部的差异,所以是有偏的,KLPO 把它称为 TopK-KL。我们之前的实验默认用的就是这一类实现,generator 送回概率最高的 128 个 token,不对 tail 采样。tail 的总概率取 generator 给出的值,再按 trainer 自己的概率比例分配给 tail 里的各个 token。这和把 tail 合并成一个类别是一回事。tail 的概率按 trainer 自己的比例分配以后,tail 里每个 token 的 r r r 都相同,都等于 trainer 和 generator 在 tail 上的总概率之比,tail 内部的 KL 也就只剩下一项。
除了方差,k 4 k_4 k 4 的不对称性本身也有好坏两面。好的一面是,它能防止 token 的概率在一个 generator 版本之内被压到 0,从而避免熵下降和探索变少,同时允许确实更好的 token 快速增长。坏的一面是,它对抬高这一侧的约束比较弱,如果一个 token 的高 advantage 来自过时的样本或者噪声,它也会被放任增长。我们之前的实验里有一个间接的参考。其中一个方法是在 SFC 的梯度上再乘一个截断到 2 的比率 min ( π θ / π generator , 2 ) \min(\pi_\theta/\pi_{\text{generator}},2) min ( π θ / π generator , 2 ) ,也就是 truncated importance sampling,这是 Marek 和 Ryabinin(2026)使用的组合。这个方法在 Countdown 上崩溃时,熵持续上升,意味着原本概率很低的 token 整体上被抬高了,回答也越来越长,最后 trainer 和 generator 之间的 KL 突然涨了两个数量级,看起来更像是抬高这一侧出了问题。不过那个 run 里没有任何 KL 项,所以它只能作为一个间接的参考。
K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 和 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 的风险正好在另一侧。6.1 节和 6.2 节已经看到,它们对被压低的 token 的保护都有上限,β \beta β 较小时,低 advantage 的 token 可能被一直压到 0。
6.4 实际中应该怎么选?
在比较几种写法之前,可以先判断这个选择在自己的训练里重不重要。5.2 节说过,当 β \beta β 明显大于 advantage 之间的差别时,KL 会把 r r r 维持在 1 附近,几种写法的差别不大,选哪一个影响有限。只有当 β \beta β 和 advantage 之间的差别在同一个量级或者更小时,比如 6.1 节里 age 为 50、β t \beta_t β t 只有 0.042 的 token,选择才比较重要。
如果选择确实重要,接下来要看训练中更担心哪一类 token 出问题。如果观察到的是熵持续下降、某些 token 被压到几乎不再出现,那么保护被压低的 token 的写法,比如 k 4 k_4 k 4 ,可能更合适。如果观察到的是熵上升、回答越来越长、r r r 的分布出现很长的尾巴,那么限制被抬高的 token 的写法,比如 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 或者 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) ,可能更合适。在不同的模型、数据、optimizer 和 age 的分布下,哪一类 token 的风险更大可能并不相同,所以这个判断最好以自己训练中的观察为依据。
两类风险都需要防范时,可以把几种写法组合起来使用。比如把 k 4 k_4 k 4 和 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 一起加上。按 6.2 节的结果,前者保护被压低的 token,后者对被抬高的 token 约束最强,两者的作用正好互补,代价是需要分别决定两者的权重。
方差也会影响选择。k 4 k_4 k 4 的系数只按对数增长,方差可能也最小。K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 的系数带 1 / π generator 1/\pi_{\text{generator}} 1/ π generator ,K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 的系数增长得更快,偶尔采到一个 r r r 很大的 token,就会带来很大的梯度。几种写法对数值精度的要求也不一样,这是下一章的内容。
另一个可以调节的是 β \beta β 和 age 的关系。我们之前的做法 是让 β t \beta_t β t 随 age 衰减,理由是越旧的 generator 越不适合作为当前 trainer 的参照。反过来也可以这样考虑,样本越旧,离当前模型越远,越需要约束,因此 β \beta β 应该随 age 增大。如果用 6.1 节的数字来看,age 为 50 时 β t \beta_t β t 只有 0.042,在简化模型里,K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 已经拦不住 Δ A v < − 0.042 \Delta A_v<-0.042 Δ A v < − 0.042 的 token。哪一种更合适,取决于旧 generator 的样本在训练中更容易带来哪一种风险。对于 age 为 0 的 token,我们之前把 β \beta β 设为 0,原因和数值精度有关,7.2 节会解释。
最后,trainer 和 generator 之间的 KL,只能限制每一个 generator 版本之内的更新幅度。generator 一直在跟着 trainer 走,这个参照本身也在移动,所以它不能防止模型在很多轮之后离初始模型越来越远。如果需要限制长期的漂移,可以另外加一个以 π ref \pi_{\text{ref}} π ref 为参照的 KL,两者的作用是互补的。
7. 有限精度下,KL 和它的系数应该怎么算?
TL;DR: 计算 KL 和它的系数时,应该在 FP32 下先算出 log 概率之差 ρ = log π θ − log π generator \rho=\log\pi_\theta-\log\pi_{\text{generator}} ρ = log π θ − log π generator ,再用 expm1(rho) 得到 r − 1 r-1 r − 1 ,记录 k 3 k_3 k 3 的数值时用 expm1(rho) - rho 或者泰勒展开,不要先算出接近 1 的 e ρ e^\rho e ρ 再减去 1。否则记录下来的 KL 可能是负数。如果 r r r 以 BF16 存储,r − 1 r-1 r − 1 还会把 ρ \rho ρ 小于约 0.0039 的轻微上涨算成 0,让这些 token 完全不受约束。检查 trainer 和 generator 是否完全一致时,应该要求 ρ 2 \rho^2 ρ 2 的最大值等于 0,不要看 k 1 k_1 k 1 的平均值。
前面的分析都假设计算是精确的。实际训练中,KL 和它的系数都是在有限精度下算出来的。这一章说明,同一个公式用不同的方式计算,结果可能差别很大,而且第 5 章里不同的系数对精度的要求也不同。这一章的数值都按 FP32 或 BF16 的舍入规则实际算过,图 6 和图 7 里的曲线也是按同样的规则逐点计算的。
问题的根源是,浮点数在 0 附近很密,在 1 附近很稀。FP32 里,1 和比它大的下一个数相差 2 − 23 ≈ 1.2 × 10 − 7 2^{-23}\approx1.2\times10^{-7} 2 − 23 ≈ 1.2 × 1 0 − 7 ,而在 0 附近,FP32 可以表示小到 10 − 38 10^{-38} 1 0 − 38 量级的数。BF16 更粗,1 上方相邻两个数相差 2 − 7 ≈ 0.0078 2^{-7}\approx0.0078 2 − 7 ≈ 0.0078 ,1 下方相差 2 − 8 ≈ 0.0039 2^{-8}\approx0.0039 2 − 8 ≈ 0.0039 。如果我们要算的结果是一个很小的量,计算过程中最好不要出现"1 加上这个小量"这样的中间值。一旦中间值被存成了 1 附近的浮点数,那个小量的大部分信息就丢了,之后再减去 1 也找不回来。下面两节分别看这个问题在记录 KL 的数值和计算训练用的系数时会怎样出现。
7.1 记录 KL 的数值时,为什么会算出负数?
以 k 3 = e ρ − 1 − ρ k_3=e^\rho-1-\rho k 3 = e ρ − 1 − ρ 为例,其中 ρ = log r = log π θ ( y ) − log π generator ( y ) \rho=\log r=\log\pi_\theta(y)-\log\pi_{\text{generator}}(y) ρ = log r = log π θ ( y ) − log π generator ( y ) 。在 FP32 下直接按这个式子计算,ρ = 10 − 6 \rho=10^{-6} ρ = 1 0 − 6 时得到的是 − 4.6 × 10 − 8 -4.6\times10^{-8} − 4.6 × 1 0 − 8 。真值大约是 ρ 2 / 2 = 5 × 10 − 13 \rho^2/2=5\times10^{-13} ρ 2 /2 = 5 × 1 0 − 13 ,一个数学上非负的量被算成了负数,误差比真值大了五个数量级。原因是 e ρ e^\rho e ρ 被存成了 1 附近最近的那个 FP32 数,这一步的舍入误差在 10 − 7 10^{-7} 1 0 − 7 量级,减掉 1 以后,剩下的几乎全是舍入误差。改用 expm1(rho) - rho 来计算,expm1 直接算出 e ρ − 1 e^\rho-1 e ρ − 1 ,不经过 e ρ e^\rho e ρ 这个接近 1 的中间值,得到的是 4.5 × 10 − 13 4.5\times10^{-13} 4.5 × 1 0 − 13 ,和真值只差 9%。剩下的这点误差来自 expm1 的结果本身的舍入。这个结果的相对误差在 10 − 7 10^{-7} 1 0 − 7 量级,换算成绝对误差大约是 6 × 10 − 8 ρ 6\times10^{-8}\rho 6 × 1 0 − 8 ρ ,所以 ρ \rho ρ 越小,相对误差越大。如果需要在 ρ \rho ρ 更小时也保持精度,可以在 ∣ ρ ∣ |\rho| ∣ ρ ∣ 很小时直接按泰勒展开 ρ 2 / 2 + ρ 3 / 6 \rho^2/2+\rho^3/6 ρ 2 /2 + ρ 3 /6 来计算,这样就完全没有相减的步骤。
图 6 在对数坐标下画出了 k 3 k_3 k 3 的真值,以及三种算法的误差。直接计算的误差一直停在 10 − 8 10^{-8} 1 0 − 8 到 10 − 7 10^{-7} 1 0 − 7 这个量级,和 ρ \rho ρ 的大小无关。当 ρ \rho ρ 小于大约 3 × 10 − 4 3\times10^{-4} 3 × 1 0 − 4 时,这个误差已经超过了真值本身,算出来的结果没有意义。用 expm1 计算时,误差和 ρ \rho ρ 成正比,要到 ρ \rho ρ 小于 10 − 7 10^{-7} 1 0 − 7 左右才会和真值相当。用泰勒展开计算时,误差在 ρ \rho ρ 很小时一直远小于真值,只有 ρ \rho ρ 变大以后,被省略的高阶项才开始起作用。
图 6 需要 JavaScript 才能显示。
同样的原因还会让一致性检查给出错误的结论。有些检查用的量写成了 1 加上一个二阶小量的形式,例如 1 + ρ ( e ρ − 1 ) 1+\rho\,(e^\rho-1) 1 + ρ ( e ρ − 1 ) ,它在样本来自 generator 时的期望是 1 加上两个方向的 KL 之和。在 FP32 下,只要 ∣ ρ ∣ ≤ 2.4 × 10 − 4 |\rho|\le2.4\times10^{-4} ∣ ρ ∣ ≤ 2.4 × 1 0 − 4 ,这个量就会被舍入成恰好等于 1,看起来就像 trainer 和 generator 完全一致。
k 1 k_1 k 1 的平均值也不适合用来检查两者是否一致。ρ \rho ρ 有正有负,平均值可能因为正负抵消而接近 0,甚至为负。如果想确认 trainer 和 generator 完全一致,更可靠的做法是直接计算 ρ 2 \rho^2 ρ 2 ,要求它的最大值恰好等于 0。ρ 2 \rho^2 ρ 2 不会是负数,最大值等于 0 就说明每个 token 都完全一致。
7.2 训练用的系数受精度影响有多大?
训练时用到的系数同样会受这个问题影响,但几种系数受影响的程度不同。k 4 k_4 k 4 的系数是 log r = ρ \log r=\rho log r = ρ 。只要 ρ \rho ρ 是用 FP32 的 log 概率相减得到的,即使之后转换成 BF16,相对误差也不超过 0.2%。但如果 log 概率本身就以 BF16 存储,相减这一步就会丢掉大部分信息。比如 − 2.3012 -2.3012 − 2.3012 和 − 2.3042 -2.3042 − 2.3042 存成 BF16 以后都是 − 2.296875 -2.296875 − 2.296875 ,相减得到 0,而真值是 0.003。
K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 的系数 r − 1 r-1 r − 1 还多了一层问题。如果先算出 r = e ρ r=e^\rho r = e ρ ,再减去 1,就会遇到这一章开头说的情况。假设 r r r 是以 BF16 存储的,那么 ρ = 0.001 \rho=0.001 ρ = 0.001 和 ρ = 0.003 \rho=0.003 ρ = 0.003 时,r r r 都被存成了恰好等于 1,r − 1 r-1 r − 1 等于 0。ρ = 0.005 \rho=0.005 ρ = 0.005 时,r − 1 r-1 r − 1 变成 0.0078,而真值是 0.0050。ρ = − 0.003 \rho=-0.003 ρ = − 0.003 时,r − 1 r-1 r − 1 变成 − 0.0039 -0.0039 − 0.0039 ,而真值是 − 0.0030 -0.0030 − 0.0030 。由于 1 上方和下方的间距不同,两侧的误差也不对称。ρ \rho ρ 小于约 0.0039 的轻微上涨都会得到系数 0,完全不受约束,而轻微下降的 token 只要 ρ \rho ρ 低于约 − 0.002 -0.002 − 0.002 ,就会被拉回来,并且拉力被放大了。图 7 画出了 BF16 存储的 r r r 减去 1 以后得到的阶梯,两条竖线就是这两个阈值。
图 7 需要 JavaScript 才能显示。
正确的做法是在 FP32 下计算 ρ = log π θ − log π generator \rho=\log\pi_\theta-\log\pi_{\text{generator}} ρ = log π θ − log π generator ,log r \log r log r 直接用这个 ρ \rho ρ ,r − 1 r-1 r − 1 则用 expm1(rho) 得到,6.3 节里 tail 上的估计也是如此。图 7 里的虚线就是先在 FP32 下算 expm1、再存成 BF16 的结果,它和真值几乎重合。K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 的系数 r log r = e ρ ρ r\log r=e^\rho\rho r log r = e ρ ρ 里没有减去 1 的步骤,即使 r r r 以 BF16 存储,相对误差也不超过 0.2%,受这个问题的影响较小。
还有一种数值差异,和存储的精度无关。即使 trainer 和 generator 用的是同一个版本的参数,两者算出来的 log 概率也不会完全相同,因为推理引擎和训练框架使用的 kernel、精度、并行方式、batch 形状都可能不同(Thinking Machines Lab, 2025)。这时 ρ \rho ρ 并不是 0,任何一种 trainer 和 generator 之间的 KL 都会把 trainer 往推理引擎的数值误差上拉。所以对 age 为 0 的 token,也就是 trainer 和 generator 参数版本相同的 token,我们之前把 β \beta β 设为 0。如果想从根本上消除这部分差异,需要让两边的计算方式完全一致,比如使用 batch invariant 的 kernel。这属于推理引擎的问题,不在这篇文章的范围之内。
8. 写在最后
这篇文章讨论了 KL 的写法和它产生的梯度之间的关系。分析一行 KL 代码时,可以先问下面几个问题:
样本是谁采的,是当前模型、旧模型,还是一个固定的 generator?
θ \theta θ 出现在哪几个地方,代码对哪几处求了导?
最后乘在 score 上的系数是什么,它对应的是哪个方向的 KL?
这个系数是在什么精度下算出来的?
对于异步 RL 中拉近 trainer 和 generator 的 KL,几种写法各有分工。k 4 k_4 k 4 保护被压低的 token,K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 约束被抬高的 token,K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 对两类 token 都有作用,但对被压低的 token 的保护有上限。哪一种更合适,取决于训练中哪一类 token 的风险更大,也取决于 β \beta β 和 advantage 的相对大小。
这篇文章讨论的是这几种写法在期望上的行为、它们的代价,以及计算时的精度问题。它们在实际训练中的表现,比如能不能防止训练崩溃,可能还和 head 的大小、tail 的处理方式以及模型的大小等因素有关。这些问题我们会在单独的一篇文章里用实验来讨论。
本文分析的是 token 级别的系数。之后的文章还会把同样的思路用到 prompt 级别。比如 GRPO 按组的标准差对 advantage 做标准化,相当于给每个 prompt 乘上了一个权重,这个权重决定了训练实际在优化哪一个目标。
附录:本文对 KL 方向的叫法,和其他公开资料有什么不同?
本文沿用了之前介绍 Score Function Centering 加 KL 的文章 的叫法。那篇文章把 D K L ( q ϕ ∥ p θ ) D_{\mathrm{KL}}(q_\phi\|p_\theta) D KL ( q ϕ ∥ p θ ) 的估计器叫作 sparse reverse-KL estimator,其中 q ϕ q_\phi q ϕ 是 generator,p θ p_\theta p θ 是 trainer。按照同一个规则,本文把参照分布在前、π θ \pi_\theta π θ 在后的 KL 叫作 reverse KL,例如 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) 和 K L ( π ref ∥ π θ ) \mathrm{KL}(\pi_{\text{ref}}\|\pi_\theta) KL ( π ref ∥ π θ ) 。π θ \pi_\theta π θ 在前的 KL 则叫作 forward KL,例如 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 和 K L ( π θ ∥ π ref ) \mathrm{KL}(\pi_\theta\|\pi_{\text{ref}}) KL ( π θ ∥ π ref ) 。
有一些公开资料的叫法正好相反。RLHF 的论文和代码库通常把正在训练的 π θ \pi_\theta π θ 看作变分推断里那个用来做近似的分布,所以把 K L ( π θ ∥ π ref ) \mathrm{KL}(\pi_\theta\|\pi_{\text{ref}}) KL ( π θ ∥ π ref ) 叫作 reverse KL,把 K L ( π ref ∥ π θ ) \mathrm{KL}(\pi_{\text{ref}}\|\pi_\theta) KL ( π ref ∥ π θ ) 叫作 forward KL。on-policy distillation 的文章也是这样,它们把学生在前、老师在后的 KL 叫作 reverse KL。两种叫法说的是同样的两个量,只是名字对调了。
对照其他资料读本文时,下面几处最容易混淆:
当 loss 用、样本来自当前模型时,k 2 k_2 k 2 的梯度等于 K L ( π θ ∥ π ref ) \mathrm{KL}(\pi_\theta\|\pi_{\text{ref}}) KL ( π θ ∥ π ref ) 的梯度。本文说它给出的是 forward KL,叫法相反的资料会说是 reverse KL。
同样的条件下,k 3 k_3 k 3 的梯度等于 K L ( π ref ∥ π θ ) \mathrm{KL}(\pi_{\text{ref}}\|\pi_\theta) KL ( π ref ∥ π θ ) 的梯度。本文说它给出的是 reverse KL,叫法相反的资料会说是 forward KL。
InstructGPT 式的 PPO 把 k 1 k_1 k 1 放进 reward,梯度对应 K L ( π θ ∥ π ref ) \mathrm{KL}(\pi_\theta\|\pi_{\text{ref}}) KL ( π θ ∥ π ref ) ,在本文里是 forward KL。GRPO 把 k 3 k_3 k 3 当 loss,在样本来自当前模型的近似下,梯度对应 K L ( π ref ∥ π θ ) \mathrm{KL}(\pi_{\text{ref}}\|\pi_\theta) KL ( π ref ∥ π θ ) ,在本文里是 reverse KL。
Liu 等人(2025)说"k 3 k_3 k 3 当 loss 是 reverse KL 的一阶近似",他们说的 reverse KL 是 K L ( π θ ∥ π ref ) \mathrm{KL}(\pi_\theta\|\pi_{\text{ref}}) KL ( π θ ∥ π ref ) ,在本文里是 forward KL。
资料里常说"reverse KL 是 mode-seeking 的",意思是 π θ \pi_\theta π θ 在前的 KL 允许 π θ \pi_\theta π θ 只保留参照分布的一部分取值。在本文的叫法下,这句话说的是 forward KL。6.2 节里,在 K L ( π θ ∥ π generator ) \mathrm{KL}(\pi_\theta\|\pi_{\text{generator}}) KL ( π θ ∥ π generator ) 下,advantage 足够低的 token 会被一直压到 0,就是这个性质的表现。
之前那篇文章里的 KL 项是 K L ( π generator ∥ π θ ) \mathrm{KL}(\pi_{\text{generator}}\|\pi_\theta) KL ( π generator ∥ π θ ) ,它在那篇文章和本文里都叫 reverse KL,没有变化。
所以读这类材料时,最可靠的办法是对照公式。先看 KL 的前后两个位置上各是哪个分布,再看样本来自哪个分布,以及代码对哪几处求了导。这三点确定以后,名字就不会再造成误解。
参考文献