关于 Trainer-Generator Mismatch,你需要知道的一切:差异来源、监控、零差异测试与故障调试

发布于
26,378字
18个公式
en / zh语言

在 PPO 或者 GRPO 里,我们通常会有一个很自然的预期:刚刚采完一批数据,还没有开始更新参数,那么新旧策略应该是相同的,importance ratio 也应该等于 1。但在 LLM 的训练中,这个预期未必成立。即使 generator 和 trainer 加载的是同一份权重,generator 在生成回答时报告的 token log-prob,也就是概率的自然对数,也可能与 trainer 重新计算得到的值不同。如果这个差异足够大,那么第一次更新还没有开始,一部分 token 就已经落在 clipping 的区间外了。

我们在介绍 Score Function Centering时,讨论过 generator 的参数版本落后于 trainer 所带来的分布差异。不过,参数版本对齐,并不一定意味着两端实际计算出的策略分布也相同。如果两端的计算本身就有差异,那么后续看到的 KL、ratio 和 clip fraction,也就会同时受到参数更新和执行过程的影响。

这篇文章讨论的 trainer-generator mismatch,指的就是训练端与生成端之间的这些差异。如果你正在接入 RL 训练框架,或者遇到过首次更新前 ratio 就偏离了 1、训练中偶尔出现 KL Spike 的情况,那么可以结合下面的讨论,检查自己的系统。阅读时只需要了解 PPO 或 GRPO 的基本目标,后面涉及的公式,我们都会在用到时重新写出。

这篇文章会先讨论 trainer-generator 之间的差异是怎样影响模型更新的。紧接着,我们会分析这些差异的来源,以及在 RL 训练的监控中,应该保存哪些证据来帮助排查问题。有了这些证据以后,我们会介绍怎样通过零差异测试缩小调查范围,再用一个生成暂停后继续执行的例子,看看如何从 KL Spike 追查到具体的状态错误。除此之外,我们还会讨论温度变换和候选验证,因为两端的概率算得一致,并不意味着实际采样就一定正确。最后,我们会把这些检查与权重同步、回归验证放到一条完整的排查流程中。文末还有一张交互式结构图,方便你按照 trainer 内部、generator 内部和两端之间的关系,找到接下来需要做的检查。

1. 两端的计算差异,会提前用掉 PPO 的更新空间

TL;DR: 当 ratio 使用生成时的概率作为分母时,两端的执行差异就会影响 PPO 的梯度,甚至让部分 token 的 PPO 梯度在第一次参数更新前就被 clip 掉。即使用 trainer 重算的 old log-prob 作为分母后,起始 ratio 等于 1,也不能据此判断 trainer 与 generator 已经一致。

我们把 prompt 记为 xx,把回答记为 y1,…,yNy_1,\ldots,y_N。在生成 yty_t 时,模型已经看到的前缀是 ht=(x,y1,…,yt−1)h_t=(x,y_1,\ldots,y_{t-1}),其中不包含 yty_t 自己。对于这个前缀,trainer 给出的分布记为 πθ\pi_\theta,而 generator 实际生成这个 token 时使用的分布记为 πgenerator\pi_{\mathrm{generator}}。这一节先考虑普通的逐 token 采样:temperature 为 1,没有 top-k、top-p 或者其他 logits 修改,同时假设采样实现是正确的。在这些条件下,generator 报告的 softmax 概率就是实际的采样概率。

如果 importance ratio 的分母采用 generator 实际生成这个 token 时的概率,那么可以先计算两端 log-prob 的差值,再通过指数得到 ratio:

ρt=log⁡πθ(yt∣ht)−log⁡πgenerator(yt∣ht),rt=eρt.\rho_t=\log\pi_\theta(y_t\mid h_t)-\log\pi_{\mathrm{generator}}(y_t\mid h_t),\qquad r_t=e^{\rho_t}.(1)

当 ρt>0\rho_t>0 时,说明 trainer 给这个 token 的概率更高;当 ρt<0\rho_t<0 时,则说明 trainer 给出的概率更低。这里的 ρt\rho_t 既是两端 log-prob 的差值,也是 ratio 的对数。因此,只要两端的前向计算产生了差异,这个差异就会通过 ratio 进入 PPO 的目标。PPO 本身并不知道,这部分变化究竟来自参数更新,还是来自数值计算。

1.1 clipping 无法分辨一次策略更新与一次数值偏移

回顾一下 PPO 中要最大化的单个 token 的目标:

Jt(θ)=min⁡ ⁣(rtAt,  clip⁡(rt,1−ϵ,1+ϵ)At).J_t(\theta)=\min\!\left(r_tA_t,\; \operatorname{clip}(r_t,1-\epsilon,1+\epsilon)A_t\right).(2)

其中,AtA_t 是 advantage,表示这个动作相对于基准有多好,我们在优化时把它视为常数。ϵ\epsilon 则决定了 ratio 的截断范围。在没有发生截断的区间里,由于 generator 的概率不参与求导,我们有 ∇θrt=rt∇θlog⁡πθ(yt∣ht)\nabla_\theta r_t=r_t\nabla_\theta\log\pi_\theta(y_t\mid h_t)。因此,这个 token 的 PPO 目标对应的梯度就是

∇θJt=eρtAt∇θlog⁡πθ(yt∣ht).\nabla_\theta J_t =e^{\rho_t}A_t\nabla_\theta\log\pi_\theta(y_t\mid h_t).(3)

也就是说,在未截断的目标里,eρte^{\rho_t} 会直接缩放这个 token 的更新系数。如果 ρt\rho_t 是一个很大的正数,这个权重就会很大;如果 ρt\rho_t 是一个绝对值很大的负数,权重就会接近零。不过,PPO 是否会把对应的目标截断,还需要结合 advantage 的符号来看。

如果 At>0A_t>0,我们希望提高这个 token 的概率。但是,当 rt>1+ϵr_t>1+\epsilon 时,PPO 的目标会变成常数 (1+ϵ)At(1+\epsilon)A_t,这个 token 对应的 PPO 梯度也就被 clip 掉了,也就是变为零。如果 At<0A_t<0,对应的截断则会发生在 rt<1−ϵr_t<1-\epsilon 时。这里还需要留意另一种情况:当 advantage 为负、ratio 却很大时,min⁡\min 仍然会选择更负的 rtAtr_tA_t,所以这一侧的系数并没有被上界截住。以上讨论的都是当前 token 的 PPO 项,其他 token 或者正则项仍然可能继续更新共享的参数。

我们可以用 ϵ=0.2\epsilon=0.2 来看一个具体的例子。当 advantage 为正时,这个 token 的 PPO 梯度被 clip 掉的条件是 ρt>log⁡1.2≈0.1823\rho_t>\log1.2\approx0.1823;当 advantage 为负时,对应的条件则是 ρt<log⁡0.8≈−0.2231\rho_t<\log0.8\approx-0.2231。假设某个 token 的 advantage 为正,而两端在同一版本的权重下,就已经出现了 ρt=0.25\rho_t=0.25 的差异,那么

rt=e0.25≈1.284>1.2.r_t=e^{0.25}\approx1.284>1.2.(4)

这意味着,虽然 trainer 还没有进行任何参数更新,这个 token 在第一次 backward 时,对应的 PPO 梯度就已经被 clip 掉了。因此,检查同版本的样本时,我们既需要统计有多少 token 越过了这些边界,也需要记录它们的 advantage 符号。如果只统计 ratio 的越界比例,就不能直接知道其中有多少 token 的 PPO 梯度真正被 clip 掉了。

即使差异还没有大到让 ratio 越界,它也会影响后续更新的空间。假设一开始的 ratio 已经是 1.11.1,那么 trainer 只要再把概率提高约 9.1%9.1\%,总 ratio 就会达到 1.21.2;而如果初始 ratio 是 1,就需要把概率提高 20%20\% 才会到达同一个上界。当然,如果初始 ratio 小于 1,那么向上更新的空间反而会更大。无论是哪种情况,clipping 所限制的变化里,都已经包含了 trainer 与 generator 之间原有的差异。

1.2 trainer 重算的 old log-prob,为什么会让这个问题消失在指标里

有些实现会让 trainer 在更新前重新计算这批数据的 log-prob,再把这些结果保存下来,作为后续更新中的固定基准。我们把这个更新前的 trainer 分布记为 πold\pi_{\mathrm{old}},之后只用 πθ/πold\pi_\theta/\pi_{\mathrm{old}} 来做 PPO clipping。这里先假设,generator 生成数据时加载的权重,与更新前的 trainer 是相同的。这样一来,我们就可以把原来的比值拆成两部分:一部分比较 trainer 在参数更新前后给出的概率,另一部分比较尚未更新时 trainer 和 generator 给出的概率。下面这三个概率,针对的都是同一个前缀 hth_t 和同一个 token yty_t:

πθπgenerator=πθπold⏟同一引擎,比较更新前后  πoldπgenerator⏟同一权重,比较两个引擎.\frac{\pi_\theta}{\pi_{\mathrm{generator}}} =\underbrace{\frac{\pi_\theta}{\pi_{\mathrm{old}}}}_{\text{同一引擎,比较更新前后}} \;\underbrace{\frac{\pi_{\mathrm{old}}}{\pi_{\mathrm{generator}}}}_{\text{同一权重,比较两个引擎}}.(5)

例如,generator 在生成某个 token 时给出的概率是 0.200.20。采完这批数据以后,虽然还没有执行第一次更新,trainer 重新计算得到的概率却是 0.220.22。此时,第二个比值已经是 1.11.1,反映的是两端在同一份权重下的计算差异。接下来,如果一次参数更新让 trainer 的概率从 0.220.22 提高到了 0.2310.231,那么第一个比值就会变成 1.051.05,反映这次更新带来的变化。相对于实际采样概率,总 ratio 则是 1.05×1.1=1.1551.05\times1.1=1.155。如果只看第一项,就看不到起点上的这 10%10\% 的差异。

如果在这批数据刚开始用于训练、参数还没有更新时就做测试,并且分子和分母复用了同一份 trainer 评分,那么第一个比值 πθ/πold\pi_\theta/\pi_{\mathrm{old}} 确实等于 1。而第二个比值 πold/πgenerator\pi_{\mathrm{old}}/\pi_{\mathrm{generator}} 却未必等于 1,因为数据仍然来自 generator,两套引擎给出的概率可能不同。这种拆分可以让 clipping 专门限制 trainer 的更新幅度,但它并不会自动消除数据生成分布与 trainer 分布之间的差异。如果忽略了第二项,那么单个 token 在这个起点得到的梯度就是 At∇θlog⁡πθ(yt∣ht)A_t\nabla_\theta\log\pi_\theta(y_t\mid h_t)。也就是说,虽然样本实际来自 generator,我们却给了它与 trainer 自己采出的样本相同的权重。另外,如果分子由 trainer 重新计算,而且这次改变了 batch 或者数值路径,那么即使参数尚未更新,第一个比值也可能因为执行差异而偏离 1。

对于固定的前缀和参数,假设 f(yt)f(y_t) 是我们想要统计的一个量,那么使用完整的 importance weighting,可以校正下一个 token 的期望:Eπgenerator[rtf(yt)]=Eπθ[f(yt)]\mathbb E_{\pi_{\mathrm{generator}}}[r_t f(y_t)]=\mathbb E_{\pi_\theta}[f(y_t)]。不过,这个等式有两个前提:分母确实描述了实际的采样分布,而且目标分布中概率非零的 token,在采样分布下也都必须有机会出现。后一个条件通常称为支持集覆盖。另外,这里只校正了给定前缀后的 token 分布,还没有校正前缀本身的分布,因为这些前缀依然是由 generator 生成的。实际训练中,可以选择使用完整权重,也可以通过截断或者其他目标来控制方差。但无论选择哪一种做法,如果只观察第一个比值,就无法知道这些算法需要应对的执行差异究竟有多大。

这种把限制更新的基准与数据生成分布分开处理的做法,也可以在 Hilton 等人对策略优化的研究中看到。这里的 πold\pi_{\mathrm{old}},指的是每一批数据开始更新时冻结的 trainer 分布。它与通常在整个训练过程中保持不变的 reference model 是两个不同的角色。如果使用异步训练,第二个比值里还会包含 generator 参数版本落后的影响。因此,当我们想要专门检查执行差异时,就需要先把两端固定到同一份权重。

观察 ratio 是否偏离 1,可以告诉我们两端的概率是否相同,但还不能说明这个差异来自哪里。为了排除参数更新和版本落后的影响,我们可以先固定两端的权重,再比较同一个前缀、同一个 token 的 log-prob。如果在这些条件下,两端给出的值仍然不同,那么就需要继续检查它们实际执行的计算路径。 接下来,我们就从这些路径之间的区别谈起。

2. 同一份权重,为什么 trainer 和 generator 算出的概率仍然不同?

TL;DR: 权重、最终 dtype 和 backend 名称相同,都不能保证实际的运算顺序、中间精度与状态相同。因此,排查时既要比较 trainer 与 generator,也要检查 generator 内部的 prefill 与 decode,并确认它们使用了相同的前缀。

在数学里,我们习惯把模型看成一个由参数确定的函数。但当这个函数变成实际运行的程序时,还需要选择具体的运算顺序、数据类型,以及怎样使用已经保存的状态。比如,trainer 通常会一次处理整段序列,而 generator 会先通过 prefill 处理 prompt,再通过 decode 逐个生成 token。在 decode 的过程中,generator 还会读取此前保存的 key 和 value,也就是 KV cache。因此,虽然两端使用的是同一个数学模型,实际执行的却未必是同一组浮点运算。

2.1 浮点加法不满足结合律,batch 形状会改变归约顺序

取 a=108a=10^8、b=−108b=-10^8、c=1c=1,每一步都按照 FP32 舍入,会得到

(a+b)+c=1,a+(b+c)=0.(a+b)+c=1,\qquad a+(b+c)=0.(6)

按照第一种顺序,两个大数会先相互抵消,最后再加上 1,所以结果是 1。而按照第二种顺序,需要先计算 −108+1-10^8+1。由于 FP32 在这个量级上无法保留相差 1 的精度,结果会被舍入回 −108-10^8,随后再与 10810^8 相加,得到的也就变成了 0。这里丢失的信息发生在中间步骤,所以即使后续计算提高了精度,也无法把它恢复回来。

在实际模型里,batch 的变化就可能改变这样的计算顺序。以矩阵乘法为例,一个输出元素需要把许多乘积加在一起。GPU 既可以让一个工作单元按顺序累积这些乘积,也可以把求和拆成几段,分别计算部分和,最后再把它们合并起来。后一种方式提高了并行度,但也改变了加法的组合方式。当 batch 较大时,许多独立的行已经能够提供足够的并行工作;而当 batch 较小时,kernel 就可能选择在求和维度上再做切分。因此,即使某个请求自己的输入完全没有变化,只要它所在的 batch 形状变了,计算结果也可能随之改变。PyTorch 的数值精度文档也指出,批量计算与逐项计算并不保证得到逐位相同的结果。

这里需要区分固定配置下的重复性和改变 batch 以后的结果。一个 kernel 完全可能在固定形状下,每次都得到相同的结果;但只要换了 batch 大小,就会稳定地得到另一个结果。固定随机种子无法消除这种差异,因为在使用随机数采样之前,差异就已经出现在 logits 里了。

batch invariance 要求同一个请求的计算结果,不会随着 batch 的大小、请求在 batch 中的位置,或者其他请求的变化而改变。 对于包含归约的算子,一种实现思路是固定每个输出的分块方式和归约顺序。这样,增大 batch 只会增加独立工作的数量,而不会改变同一个输出的求和方式。Thinking Machines 的推理确定性文章和开源算子提供了具体实现。当然,这样做也有代价:一些原本可以根据形状选择的性能优化会受到限制,尤其是在 batch 很小的时候。

不过,即使两个 kernel 都满足 batch invariance,它们也可能采用两套固定但不同的求和顺序。这样一来,两端各自的结果虽然都很稳定,彼此之间却仍然存在差异。因此,要消除 trainer-generator mismatch,还需要让两端采用相互匹配的数值路径。

2.2 最终 dtype 相同,不代表中间的计算相同

除了运算顺序,舍入发生在哪一步,也会影响计算结果。假设两个相邻的运算是 ff 和 gg,而 RR 表示把结果舍入到某种较低的精度。如果一条路径先把中间结果以低精度存下来,再执行下一步,而另一条融合后的路径保留了精度更高的中间值,直到最后才进行舍入,那么它们实际计算的分别是

R(g(R(f(x))))与R(g(f(x))).R\bigl(g(R(f(x)))\bigr) \quad\text{与}\quad R\bigl(g(f(x))\bigr).(7)

即使最终输出的 dtype 相同,这两个式子也不一定相等。因此,仅仅确认“两端的模型都是 BF16”,还不足以判断数值路径是否一致。我们还需要知道,权重在加载时是否发生了转换,乘法和累加器分别使用什么精度,以及中间张量会在什么时候被写回。例如,使用 LoRA 时,先合并权重再做乘法,与分别计算基础模型和 adapter 的输出、最后再相加,就可能在不同的位置发生舍入。

KV cache 还会把此前的数值差异带到后面的计算中。这是因为,decode 使用的是此前已经写入缓存的 K、V,而 trainer 会对完整序列重新计算它们。如果缓存的存储精度与 trainer 的计算路径不同,那么后续的 attention 就会反复使用那些已经被舍入过的值。除此之外,缓存也可能属于错误的参数版本。例如,更新权重以后,如果仍然沿用旧缓存,那么旧的 K、V 就不能代表当前模型对这个前缀的计算了。这两类问题需要分别处理:对于舍入造成的差异,需要核对缓存和计算的数值精度;对于仍然使用旧版本缓存的问题,则需要检查权重更新时,已有状态是怎样被处理的。

对于 MoE 模型,还需要考虑离散的 expert 选择。当两个 router 的得分非常接近时,上游的一点数值变化,就可能让 top-k 选中不同的 expert。这样,后面实际执行的函数也会随之改变。因此,如果看到某一层之后的差异突然增大,我们就需要同时比较这一层接收到的输入、router 的得分,以及最终选中的 expert。我们在讨论 GSPO 与 MoE 的训练稳定性时提到过 Routing Replay,它会记录每一层中各个 token 选中的 expert 编号,让后续的前向计算继续使用这些选择。

不过,replay 使用的 expert 编号来自哪一端,会决定它能够约束哪一种差异。 《Stabilizing Reinforcement Learning with LLMs》对此区分了两种做法。第一种是 Vanilla Routing Replay,简称 R2。它保存的是 trainer 在更新前重算 log-prob 时选中的 expert,后续更新会继续沿用这些编号。因此,它约束的是 πθ/πold\pi_\theta/\pi_{\mathrm{old}} 中因路由改变而产生的变化。如果参数还没有更新时,trainer 和 generator 就已经选中了不同的 expert,那么 R2 并不能让两端的选择变得一致。

另一种是 Rollout Routing Replay,简称 R3。它保存的是 generator 实际生成时选中的 expert 编号,并让 trainer 在重算 old log-prob 和后续更新时,都沿用这些选择。因此,R3 更直接地针对两端的路由差异。不过,即使 expert 编号相同,它们的混合权重和内部计算仍然可能不同,所以还不能据此保证两端的 log-prob 相等。而且,即使在第一次更新之前,强制采用 generator 的选择,也可能改变 trainer 按照自身路由原本会得到的策略。因此,在排查问题时,我们可以把 replay 作为隔离路由差异的一组对照;但如果准备长期用它来训练,还需要评估这种约束会怎样影响优化目标。

2.3 同一个 generator 的 prefill 与 decode,也可能执行不同的计算路径

前面讨论的这些区别,也会出现在同一个 generator 的内部。prefill 会一次处理许多 token,而 decode 通常只为每个请求处理一个新 token,所以两者的矩阵形状和缓存读写方式并不相同。为了分别优化这两个阶段,同一个推理引擎也可能为它们选择不同的算法。例如,SGLang 的 attention backend 文档允许用户分别指定 prefill 和 decode 的 backend,也说明了一个上层 backend 还可以继续调用不同的子实现。

除了选择不同的 kernel,两个阶段采用的计算形式本身,也可能发生变化。比如,DeepSeek-V2 中的 Multi-Head Latent Attention,也就是 MLA,可以把 key 的投影矩阵合并到 query 一侧的计算中。我们先只看不包含位置编码的内容部分,把 query 向量记为 q\mathbf q,把缓存中的压缩向量记为 c\mathbf c,而 WW 是把压缩向量恢复成 key 的投影矩阵。那么,同一个 attention score 就可以写成下面两种形式:

q⊤(Wc)=(W⊤q)⊤c.\mathbf q^\top(W\mathbf c)=(W^\top\mathbf q)^\top\mathbf c.(8)

等式左边会先恢复 key,而右边会先变换 query,因此不需要再为每一个历史位置显式恢复 key。这两种形式在实数运算中是相等的,但它们产生的中间张量、乘加顺序和舍入位置都有所不同,浮点计算的结果也就未必相等。因此,如果 prefill 和 decode 分别采用了这两种形式,即使权重和最终的 dtype 完全相同,我们仍然需要检查它们的数值结果是否一致。这里为了说明计算重排,只讨论了内容部分;完整的 MLA 还需要处理位置编码。

前面提到的 MoE 路由分歧,还可能把微小的数值差放大为不同的计算分支。为了看看这会怎样影响输出概率,我们可以构造一个 top-1 router 的例子。两个 expert 对当前输入分别输出标量 +1+1 和 −1-1,router 选中了哪一个,就把那个 expert 的输出记为 uu。后面的输出层只有两个 token,logits 是 [u,0][u,0]。此时,即使两条路径只在 router 得分上有很小的偏差,也可能出现下面这样的结果:

路径两个 expert 的得分选中的输出 uu第一个 token 的概率
prefill[1.0001,1.0000][1.0001,1.0000]+1+1e/(1+e)≈0.7311e/(1+e)\approx0.7311
decode[0.9999,1.0000][0.9999,1.0000]−1-11/(1+e)≈0.26891/(1+e)\approx0.2689

在这个例子里,router 得分只变化了 0.00020.0002,同一个输出 token 的 log-prob 却已经相差 log⁡(0.7311…/0.2689…)=1\log(0.7311\ldots/0.2689\ldots)=1。我们把选中的 expert 权重设为 1,是为了单独观察离散选择带来的影响;在真实模型中,差异的幅度还会取决于 expert 的输出、混合权重和后续的层。这个例子想说明的是,即使最终的概率差很大,最初的数值差也可能很小。因此,排查时需要继续向前寻找,看看第一次路由分歧之前发生了什么变化。当然,路由差异和概率差同时出现,还不能证明两者之间的因果关系。我们还需要在相同输入下固定路由,再做一组对照。

因此,即使 prefill 和 decode 配置的是同名的 attention backend,也仍然需要核对它们实际调用的 kernel、输入形状和中间精度,同时检查 attention 之外的 router、expert 计算和结果合并。如果更换一个 backend 以后,差异并没有变化,那么我们目前能确认的,只是这次更改没有消除所测到的差异。如果还没有确认程序确实进入了新的计算路径,就更不能据此排除原来怀疑的原因。

2.4 两端可能连前缀都没有对齐

除了数值计算,还存在一类更直接的原因:两端收到的输入或者使用的状态,本来就不相同。无论是 token IDs、position IDs、attention mask,还是多模态输入的预处理,只要其中存在差别,两端计算的条件分布就可能不同。而对于自回归模型来说,一个位置上的错误还可能影响后面许多 token,因为这个位置产生的状态会继续参与后续的生成。

这种前缀错位,可能发生在一条回答暂停生成、随后继续执行的时候。这里的一条生成请求,指的是让模型根据一个 prompt 生成一条回答。generator 通常会同时处理多条请求,由调度器决定每一轮为哪些请求安排计算。例如,当 KV cache 的空间不足时,调度器可能暂时停止为其中一条请求安排后续计算,稍后再把它加入 batch,接着已经生成的 token 继续写。这种让同一条尚未完成的请求重新参与计算的过程,就是下文所说的“请求恢复”。要正确地继续生成,引擎就必须保留或者重建与已有 token 对应的前缀、位置和缓存状态。

例如,记录中的 prompt 是 xx,回答已经生成了 A、B、C,接下来准备生成 D。假设这条请求在暂停后重新加入 batch 时,generator 用来继续生成的前缀漏掉了 C,那么它就可能实际从 B 后面继续生成 D。等到 trainer 根据最终保存的完整序列,重新计算 D 的概率时,两端比较的就变成了

log⁡πθ(D∣x,A,B,C)与log⁡πgenerator(D∣x,A,B).\log\pi_\theta(D\mid x,A,B,C) \quad\text{与}\quad \log\pi_{\mathrm{generator}}(D\mid x,A,B).(9)

即使两套程序使用完全相同的权重和算子,我们也不应该期待这两个数相等,因为它们计算 D 的概率时,使用的条件前缀已经不同了。这里的 D 仍然是一个合法的 token,程序也可能继续正常运行,所以仅仅检查 token ID 是否超出了词表范围,并不能发现这个问题。后面的请求恢复案例会进一步解释:当 C 还在返回途中时,输出计数和 token 列表是怎样发生这种错位的。

到这里可以看到,即使已经确认两端使用的是同一份权重,我们仍然需要核对它们的运算顺序、数值精度和实际输入。但在真正排查问题时,通常不会一开始就知道差异属于哪一类。因此,接下来我们需要看看,监控应该保存哪些信息,才能帮助我们继续区分这些可能的原因。

3. 平均 KL 描述整体差异,异常 token 才能告诉我们哪里出了问题

TL;DR: 很小的平均 KL 仍然可能掩盖少量严重异常,而差异最大的 token 也未必是错误最早发生的位置。监控需要保存能够复现异常的输入和执行状态,让我们可以沿着序列追查首次分歧。

给定前缀 hth_t,如果 token 确实来自 πgenerator\pi_{\mathrm{generator}},且两端比较的是相同前缀下的概率,那么

Eyt∼πgenerator(⋅∣ht)[−ρt]=KL ⁣(πgenerator(⋅∣ht)∥πθ(⋅∣ht)).\mathbb E_{y_t\sim\pi_{\mathrm{generator}}(\cdot\mid h_t)}[-\rho_t] =\mathrm{KL}\!\left(\pi_{\mathrm{generator}}(\cdot\mid h_t)\middle\|\pi_\theta(\cdot\mid h_t)\right).(10)

这个等式让我们可以从分布的角度,理解两端 log-prob 的差异。我们在讨论 KL 估计器时用过的三个写法,放到这里分别是 k1=−ρtk_1=-\rho_t、k2=ρt2/2k_2=\rho_t^2/2 和 k3=eρt−1−ρtk_3=e^{\rho_t}-1-\rho_t。如果两个分布能够产生的 token 集合相同,并且都给这些 token 非零的概率,那么 k1k_1 和 k3k_3 的期望就等于上面的 KL,而 k2k_2 则是两个分布接近时的二阶近似。在实际监控中,我们通常会对 rollout 里有效生成 token 的统计量取平均。这样得到的是沿着这些采样前缀统计出来的平均值,还不能直接当作整条序列的 KL。下面我们用 mean⁡(ρ2)\operatorname{mean}(\rho^2),也就是 2k22k_2 的平均值,看看只保留汇总统计会遗漏什么信息。

3.1 同一个均值,可能对应两种完全不同的故障

假设我们收集了 10,000 个 token,并构造两组差异分布。第一组中,每个 token 的 ∣ρ∣|\rho| 都是 0.20.2。第二组中,9,999 个 token 在两端得到的 log-prob 完全一致,只有一个 token 出现了 ρ=−20\rho=-20 的差异。把每个 token 的 log-prob 差值平方,再对所有 token 取平均,就会发现这两组数据得到的都是 0.040.04:

0.22=9999×0+20210000=0.04.0.2^2=\frac{9999\times0+20^2}{10000}=0.04.(11)
统计量每个 token 都有差异只有一个极端异常
mean⁡(ρ2)\operatorname{mean}(\rho^2)0.040.04
max⁡∣ρ∣\max\lvert\rho\rvert0.220
∣ρ∣\lvert\rho\rvert 的第 99 百分位数0.20
差异非零的 token 数10,0001

第二组中,那个异常 token 的 ratio 是 e−20≈2.06×10−9e^{-20}\approx2.06\times10^{-9},也就是说,两端给它的概率相差了近九个数量级。但如果只看 mean⁡(ρ2)\operatorname{mean}(\rho^2),两组数据却没有任何区别,甚至连第二组的 p99 都没有显示出异常。这两种情况对应的调查方向也不太一样:对于第一组,我们可以优先检查所有请求共同使用的执行配置;而对于第二组,更值得做的是导出异常 token 所在的完整 rollout,再沿着序列寻找第一次发生分歧的位置。

这两组数据对模型更新的影响也不同。第一组中,如果某个 token 的 ρ=+0.2\rho=+0.2,而且 advantage 为正,那么由于它已经超过了 log⁡1.2\log1.2,它对应的 PPO 梯度就会被 clip 掉。相比之下,ρ=−0.2\rho=-0.2 对应的 ratio 约为 0.8190.819,还没有越过下界。再看第二组的极端 token:如果分母使用 generator 的概率,那么在 advantage 有界的条件下,这个 token 自身的系数会很小,或者已经被截断;但如果只使用 trainer 重算的 old log-prob,原有的差异却会从 ratio 中消失。无论采用哪一种目标,这个异常都值得继续追查,因为它可能暴露出一个也会影响其他请求的状态错误。

因此,均值、最大值和超过阈值的 token 数量,最好一起记录。它们分别反映了整体偏差的程度、极少数异常的幅度,以及异常影响了多少 token。至于阈值,可以根据同版本、同执行配置下测得的正常基线来确定。另外,跨卡汇总时也需要留意计算方式:如果把每张卡的最大值再取平均,单卡上的极端差值就会被压低。全局最大值应该取各卡最大值中的最大值,而全局均值则应该用总和除以总 token 数。由于观察的 token 越多,遇到极端值的机会也越大,所以比较不同运行的最大值时,还需要同时看它们各自的样本数量。

3.2 最大的差异可能出现在错误已经传播以后

对于差异最大的几个 token,我们需要保存它们的 rollout ID、位置和编号、两端的 log-prob,以及能够恢复完整输入的 token IDs。这里仅仅保存解码后的文字还不够,因为看起来相似的文本,可能对应不同的 token 序列。如果缺少原始 token IDs,就可能无法恢复模型当时实际收到的输入。除此之外,权重版本、generator 节点、batch 形状和缓存相关的事件,也应该随样本一起保存。否则,一旦离开了原来的调度条件,这个问题就可能很难再次出现。

找到异常 rollout 以后,还需要沿着序列往前看,确认差异最早是从哪里开始的。最大的差异可能出现在一段很长的重复文本末尾,但真正导致它的错误,却发生在几十个 token 之前。如果差异表现为持续的小幅偏移,可以先比较共同的数值路径;如果某次同步以后差异整体抬升,就可以核对同步的权重,以及旧缓存是否被正确处理。如果从某个位置开始连续出现大幅偏移,则可以检查这个位置前后的输入、缓存和请求状态。不过,这些形态只能帮助我们选择调查方向。要确认具体原因,仍然需要通过固定权重、改变 batch、清空缓存或者核对状态,逐一进行比较。

还有一个前提需要记住:如果 generator 实际使用的前缀已经与记录不一致,那么两端 log-prob 相减,得到的就是两个不同条件下的计算差值,前面的 KL 等式也就不再适用了。后面的请求恢复例子会具体说明这种情况。

4. 找到了异常 token,为什么还需要零差异测试?

TL;DR: 零差异测试通过固定输入和权重、匹配计算路径,为定位执行差异提供受控的对照。加入 generator 的 prefill 重算以后,我们可以分别检查 trainer 与 prefill、prefill 与 decode 的差异,再沿出现分歧的路径继续定位。

假设监控已经导出了一条异常回答。trainer 和 generator 的权重版本相同,但其中几个 token 的 log-prob 差异很大。仅凭这条回答,我们还不知道应该从哪个配置开始检查。这可能是因为两端一直采用不同的求和顺序,只是这次输入把差异放大了;也可能是因为某次同步、缓存复用或者请求恢复出了错误,让这条回答偏离了原本的计算路径。如果直接提高报警阈值,两种情况都可能被放过;而降低学习率,也无法帮助我们分辨究竟发生了哪一种情况。

为了继续判断,我们需要建立一组可以控制条件的对照。具体来说,就是固定输入和权重,只改变准备调查的计算路径或者执行事件,再观察差异是否随之变化。这样的比较,并不要求两端一开始就完全相等。例如,如果大幅偏移是在请求恢复以后突然出现的,我们就可以先把它与不经过恢复的路径进行比较。零差异测试则是其中更严格的一种对照:让两端采用相互匹配的计算路径,并要求同一个 token 的 log-prob 逐项相等。 如果两端仍然不同,我们就沿着计算路径寻找第一个分歧;如果已经一致了,就逐项恢复原来的配置或者执行事件,观察差异会从哪里重新出现。

在一些场景下,建立这样的零差异参照会尤其有用。比如,更换模型实现或者推理引擎时,我们需要确认新的路径有没有引入偏移;检查权重同步时,一次很小的参数更新,又可能被原有的数值差异掩盖。如果异常的幅度已经接近正常的计算偏差,那么继续调整报警阈值,也很难把两者区分开来。零差异配置把这些检查的数值基线降到了零,因此能够暴露原本被容差放过的变化。不过,如果已经有了明确的状态错误线索,我们也可以先做相应的局部对照,不需要等到整套模型完全归零以后才开始排查。

这里所说的“相互匹配”,包括 attention 的实现、运算和缓存的精度、并行布局,以及涉及跨卡通信的归约顺序。因此,仅仅把两端都设置成 BF16,或者只开启 generator 的 batch-invariant kernel,还没有满足全部条件。生产训练也不一定需要采用这套零差异配置。我们可以另外保留一套运行得更慢、覆盖范围更小的诊断配置,专门用于这些比较。如果两端的数值路径还没有对齐,那么测到非零差异,本身并不能证明程序有 bug。反过来,即使切换配置以后差异归零了,也只能说明差异与被改变的路径有关,还不能直接证明原来的路径没有错误。

工程上常常会把这个测试叫作“0 KL”,但真正判断是否通过时,我们应该直接比较每一个有效 token 的原始 log-prob。这是因为,k1k_1 有正有负,取平均以后可能相互抵消;而 k3k_3 在接近零时,又涉及相近的数相减,也可能因为舍入而得到零,甚至很小的负值。因此,逐项比较原始 log-prob,可以避免把这些情况误判为通过。如果目标是 bitwise equality,也就是逐位相等,就还需要检查相同 dtype 下的原始位模式。格式化日志里都打印为零,并不足以证明这一点。

4.1 固定生成的序列,才能比较同一个预测事件

最小测试可以从一个短 prompt 和几条短回答开始。在 generator 生成回答时,我们需要保存实际生成的 token IDs、每一个生成 token 的 log-prob,以及对应的权重版本。随后,让 trainer 对保存下来的整条序列做 teacher forcing,也就是把已经生成的 token 作为输入,重新计算每个预测位置的概率。在这组测试里,两端都关闭 dropout,把 temperature 设为 1,同时不使用概率截断或者其他 logits 修改。

这里需要固定的是已经生成的序列,不能让两个程序各自重新生成一遍,再去比较回答。因为只要其中一个位置采到了不同的 token,后面的前缀就都不同了,我们也就无法继续判断同一输入上的计算差异。出于同样的原因,固定随机种子也不能代替保存实际的 token 序列。

以 [P1, P2, P3, A, B] 为例,前三个 token 是 prompt,A、B 则是回答。P3 所在位置的输出用于预测 A,而 A 所在位置的输出用于预测 B。因此,如果拿 B 位置的输出去比较 B 的概率,就会错开一个位置。对于一条没有 padding 的短序列,PyTorch 中的索引可以写成下面这样。这里,token_ids 的形状是 [1, L],LL 表示总长度,valid_vocab_size 表示有效词表的大小。代码会先去掉为了并行对齐而补出的额外列:

valid_logits = logits[..., :valid_vocab_size]
logp = valid_logits.float().log_softmax(dim=-1)
next_token_logp = logp[:, :-1].gather(
    dim=-1, index=token_ids[:, 1:, None]
).squeeze(-1)
response_logp = next_token_logp[:, prompt_length - 1:]

next_token_logp 的第一个位置,对应的是输入中的第二个 token。因此,当 prompt 长度为 3 时,回答 A、B 的 log-prob 就需要从下标 2 开始取。这段代码主要用来说明索引和归一化的范围,对于短序列,可以直接计算完整的 FP32 log-softmax。但在接入零差异测试时,我们应该使用训练 loss 实际采用的 log-prob 计算路径。如果 loss 使用的是融合的 cross-entropy kernel,而检查时又另外写了一套 log-softmax,那么检查得到的结果就未必代表 loss 真正使用的概率了。至于最终应该选出哪些位置,还需要结合 padding、EOS 和有效生成长度来确定。

用于检查的样本,还必须包含原本准备比较的所有生成 token。如果先按照 ratio 过滤掉异常,再检查剩余的样本,那么错误就已经在比较开始之前被排除了。因此,在完成位置对齐以后,我们需要一起检查有效 token 的数量、数值是否有限,以及逐项的差异。空样本和缺少 log-prob 的情况,都应该判为失败。这里检查的是已经选中的 token 的概率。如果还想检查完整的 next-token 分布,则可以先在小词表上比较全部的 log-prob 向量。

4.2 用 generator 的 prefill 重算,把差异拆到两段路径上

如果两端的比较没有通过,直接把整个模型都换成更高精度,往往只能告诉我们“差异变小了”,却还不能说明差异具体来自哪个环节。为了把调查范围缩小,我们可以在相同的权重和 token 序列上,增加 generator 自己对整段序列重新评分的路径。以 decode 阶段产生的 token 为例,这样就有三个结果可以比较:trainer 对完整序列的评分、generator 对完整序列的 prefill 评分,以及生成时实际记录下来的 decode 评分。

prefill 在这里也是一条需要检查的路径。即使它与 decode 属于同一个引擎,我们也不能直接把它给出的概率当作生成时的实际概率。 如果 generator 重新计算自己生成的回答的 log-prob 时,就已经出现了差异,那么我们实际上已经得到了一个不依赖 trainer 的复现。即使后来把 trainer 完全对齐到了这条 prefill 路径,prefill 与 decode 之间的差异也仍然存在。因此,仅仅证明两套整段评分一致,还不足以覆盖真正产生训练数据的计算路径。

为了让这次重新评分成为独立的参照,需要从干净的缓存开始。比如,vLLM 的 prefix caching会让新请求复用已有前缀的 KV cache。如果这次计算恰好复用了出错运行留下的状态,就无法起到独立对照的作用了。因此,我们需要先关闭前缀缓存复用并清空旧状态,再提交完整的 token 序列,获取 prompt log-prob。如果 prefill 本身采用分块计算,也需要把分块方式记录下来,因为它同样会影响实际的数值路径。

我们把这三个 log-prob 分别记为 ℓttrain\ell_t^{\mathrm{train}}、ℓtprefill\ell_t^{\mathrm{prefill}} 和 ℓtdecode\ell_t^{\mathrm{decode}}。前两个值,都是按照记录中的同一个前缀重新计算的,而最后一个值保留的是生成时实际得到的结果。只要加上再减去中间的 prefill 评分,就可以把总差值拆成两段:

ρt=ℓttrain−ℓtdecode=(ℓttrain−ℓtprefill)+(ℓtprefill−ℓtdecode).\begin{aligned} \rho_t&=\ell_t^{\mathrm{train}}-\ell_t^{\mathrm{decode}}\\ &=(\ell_t^{\mathrm{train}}-\ell_t^{\mathrm{prefill}}) +(\ell_t^{\mathrm{prefill}}-\ell_t^{\mathrm{decode}}). \end{aligned}(12)
trainer按记录整段重算
整段实现之差权重与前向计算
generator prefill不复用旧缓存
增量路径之差decode 计算或状态
实际 decode生成时保存的结果
图 1:加入 prefill 的评分以后,就可以把原来的比较分成两段。trainer 与 prefill 之间比较的是两套整段计算,而 prefill 与 decode 之间,则用于检查增量计算和实际执行状态的差异。

有了这三个结果,就可以进一步选择调查方向。例如,如果 trainer 与 generator prefill 的结果一致,而 decode 的结果不同,我们就可以把调查集中到 prefill 和 decode 之间。如果 generator 内部的两条路径彼此一致,却都与 trainer 不同,那么就可以优先检查两个引擎的权重转换、算子实现和并行配置。《0 train-infer mismatch for Open-weight MoE RL in Open-source code》也是沿着这三条路径对齐前向计算,并进一步检查下一次 decode 将会读取的缓存状态。

我们可以用一个 token 的构造数据,看看只对齐其中一段,会留下什么问题。假设 trainer、prefill 和 decode 的 log-prob 分别是 −1.6-1.6、−1.7-1.7、−2.0-2.0,那么总差值就是 0.40.4。其中,trainer 与 prefill 相差 0.10.1,prefill 与 decode 相差 0.30.3。即使把第一段完全对齐,剩下的 ratio 也仍然是 e0.3≈1.350e^{0.3}\approx1.350。对于 ϵ=0.2\epsilon=0.2、advantage 为正的 token,这已经超过了前面讨论的 clipping 上界,而且这里并没有参数版本落后的影响。

这里能够直接相加的,是每个 token 的 log-prob 差,以及使用同一组 token、同一组统计权重计算出来的均值。如果对两段差值分别计算 k3k_3,就不能再把它们直接相加,当作总差值的 k3k_3。这是因为,k3k_3 是差值 ρ\rho 的非线性函数:k3(ρ)=eρ−1−ρk_3(\rho)=e^\rho-1-\rho。以上面的数值为例,k3(0.4)≈0.0918k_3(0.4)\approx0.0918,而 k3(0.1)+k3(0.3)≈0.0550k_3(0.1)+k_3(0.3)\approx0.0550,两者并不相等。

如果保留差值的正负号,再取期望,我们还可以把这两段差异与 KL 联系起来。固定同一个前缀,把 prefill 评分对应的分布记为 πprefill\pi_{\mathrm{prefill}}。这里假设 decode 记录的概率确实描述了实际采样分布 πgenerator\pi_{\mathrm{generator}},同时三个分布能够产生的 token 集合相同,并且都给这些 token 非零的概率。在这些条件下,把前面的差值取负,再对 decode 样本取期望,就得到

KL(πgenerator∥πθ)=KL(πgenerator∥πprefill)+Ey∼πgenerator[log⁡πprefill(y)−log⁡πθ(y)].\begin{aligned} \mathrm{KL}(\pi_{\mathrm{generator}}\|\pi_\theta) ={}&\mathrm{KL}(\pi_{\mathrm{generator}}\|\pi_{\mathrm{prefill}})\\ &+\mathbb E_{y\sim\pi_{\mathrm{generator}}} \left[\log\pi_{\mathrm{prefill}}(y)-\log\pi_\theta(y)\right]. \end{aligned}(13)

这个式子省略了三者共同的前缀条件。其中,第一项确实是 generator 的 decode 与 prefill 之间的 KL。对于 decode 采出的样本,可以先用 decode 的 log-prob 减去 prefill 的 log-prob,再对差值取平均,来估计这一项。但第二项使用的也还是 decode 样本,所以它可能为负,而且通常不等于 KL(πprefill∥πθ)\mathrm{KL}(\pi_{\mathrm{prefill}}\|\pi_\theta)。因此,我们可以用 k1k_1 的分解来量化生成端内部的差异,同时也需要保留后一项的符号。这两个量并不是两个非负的 KL,也不能仅凭这样的拆分,就把误差归结为两个互不影响的原因。

如果 decode 的前缀已经损坏,逐 token 的 log-prob 差仍然可以在代数上拆成前面的两段,但就不能继续套用同一前缀下的 KL 解释了。此时,prefill 与 decode 的差值里,既可能包含数值路径的差异,也可能包含实际执行状态的错误。为了区分两者,我们可以从正确的前缀重新建立缓存,再让 decode 强制沿着记录中的 token 逐步推进,作为一条不经过暂停和恢复的控制路径。如果这条路径上也存在差异,就继续检查 decode 算子和缓存精度;如果差异只在请求恢复时出现,就核对恢复前后的计数和状态。这些差异的大小和形态可以帮助我们安排实验,但具体原因还是要靠对照结果和状态记录来确认。

经过这组比较,我们能够把调查范围缩小到某条具体的路径,但还没有找到最终的原因。下一节会沿着“trainer 与 prefill 一致,实际 decode 却出现异常”这个分支,分析一个前缀恢复错误。至于怎样继续比较层内张量、验证权重同步,以及判断修复是否完成,我们会放到后面的完整排查流程中讨论。

5. 从 KL Spike 追到请求恢复:一次前缀错位的排查

TL;DR: 暂停后继续生成时,如果在途 token 没有被正确处理,记录中的前缀就可能与引擎实际使用的前缀不同,此时 log-prob 的差值也就失去了同一前缀下的 KL 含义。验证修复需要重新触发相应的暂停与恢复条件,并核对交接前后的状态,仅仅观察到 KL Spike 消失还不够。

假设监控中出现了一次 KL Spike。我们导出异常的 rollout,并对照 generator 的调度记录,发现其中一条回答还没生成完,就曾经被调度器暂时移出了后续的生成 batch。稍后,它重新加入 batch,继续生成剩下的回答。这里恢复的是同一条尚未完成的生成请求:引擎需要接着已有的 token 继续写,而不是从 prompt 开始重新生成一条回答。

进一步比较每个 token 的 log-prob,就会发现,大幅差异集中在这条请求重新加入 batch 之后生成的那一段回答中。generator 给这些 token 的概率很高,而 trainer 根据记录中的完整前缀重新计算时,却认为它们几乎不可能出现。这样,我们就有了一个具体的检查位置:暂停前后的 token 记录和执行状态。不过,请求恢复与异常出现在相近的位置,还不能直接证明原因。下面我们用一组简化的 token,说明一种可能造成这个现象的错误,再看看怎样通过对照来验证它。

为了减少 GPU 等待 CPU 的时间,运行在 CPU 上的异步调度器可能会提前安排后续的计算。因此,即使调度器已经决定暂时不再为某条请求安排新的计算,先前提交给 GPU 的工作也可能还没有全部报告结果。这时,GPU 可能已经生成了一些 token,CPU 却还没有处理完这些 token 的返回结果。所以,“已经报告了多少个输出”,与“把仍在返回途中的结果也算进去,生成已经推进到了哪里”,反映的是两个不同的进度。当调度器准备让这条请求继续执行时,它会向负责 GPU 计算的 worker 发送所需的 token 和状态信息,下文把这份信息称为恢复消息。如果消息中的计数和 token 列表混用了两个进度,模型接下来使用的前缀就可能出错。

我们继续使用前面的 token 序列。假设 prompt 是 [P1, P2, P3],已经报告的输出是 [A, B],而另一个已经生成的结果 C 还没有返回。此时,请求被暂时跳过,随后又准备恢复执行。如果恢复消息把包含 C 的输出数量 3,与还没有包含 C 的 token 列表一起交给 worker,就会产生下面这个不一致的状态。

已经报告的 token 列表
P1P2P3AB
尚未返回
C已计入输出数量 3,却不在上面的列表中
按末尾 3 项恢复输出
P3ABP3 被误当成了输出
图 2:在这个假设的恢复消息中,输出数量和列表内容对应的是不同的进度。由于列表里的每个 token ID 都是合法的,所以普通的取值范围检查无法发现这个错误。

如果 worker 按照“从列表末尾取 3 项”的规则来恢复输出,拿到的就会是 [P3, A, B]。但正确的输出本来应该等到 C 返回以后,再恢复成 [A, B, C]。这一步错位以后,随后重建的位置、上下文或者缓存状态,也就可能发生偏移。不过,程序仍然能够继续运行,因为 P3 本来就是一个合法的 token,而 generator 也仍然可以根据自己当前的状态,计算出一个合法的概率分布。

这时,generator 给出的高概率,只能说明这个 token 在它实际使用的那个上下文下很合理,不能据此判断记录中的回答也合理。当 trainer 根据正常记录重新计算概率时,使用的已经是另一个前缀,所以两端可能从这里开始,持续出现大幅差异。如果错误的状态进一步让生成进入了重复段落,那么后面的异常就会越来越显眼。不过,最值得检查的位置,仍然是请求恢复前后的第一次分歧。

接下来,就可以使用上一节介绍的 prefill 重算方法。我们把记录中的正确序列交给 generator,重新建立缓存,再计算同一批 token 的 log-prob。如果这次的评分与 trainer 接近,却与保存的 decode 结果相差很大,就可以按照图 1,继续检查增量计算和执行状态,并用强制沿记录序列推进的 decode 来区分这两种来源。这里,prefill 的评分与 trainer 一致,是帮助我们缩小调查范围的证据。但如果只是重新提交同一个 prompt,让模型再生成一次回答,那么调度时机可能已经改变了,也就可能错过原来的触发条件。因此,这两种“重放”提供的证据是不同的。

为了验证这个假设,我们需要构造“请求仍然有结果在返回途中,却准备恢复执行”的情形,再检查恢复消息中的数量和列表内容。对于上述状态机,一种修复方式是等到在途结果全部报告以后,再允许请求恢复。另一种设计则是把尚未完成的状态显式传递出去,让接收方按照同一套规则处理。无论采用哪种方式,恢复消息里的数量、token 列表和状态,都必须对应同一个进度。

在验证修复时,我们除了要确认原来的错误状态会被拒绝,还需要确认测试确实走到了这条恢复路径。因为只看到 KL Spike 消失,还无法区分究竟是“错误已经修复了”,还是“这一次没有碰到触发条件”。如果生产系统暂时通过丢弃异常 rollout 来继续运行,也应该记录被丢弃的数量和样本特征。比如,长回答更容易经历暂停和恢复,如果这些回答被更多地过滤掉,训练数据的长度分布也可能随之改变。

在这个例子里,我们先从监控保留的异常 token 开始调查,再通过 prefill 与 decode 的比较缩小范围,最后结合恢复前后的状态记录,解释错误是怎样发生的。找到原因以后,还需要用专门构造的恢复场景来验证修复。如果原来的零差异测试没有覆盖这种状态转换,就应该把这个场景也补充进去,避免以后再次遗漏。

6. 两端 log-prob 一致,为什么还不能保证采样正确?

TL;DR: 即使两端的 log-prob 完全相同,返回的概率也未必描述了 token 的实际采样分布。对于 speculative decoding,候选块的评分、接受与重采样规则,以及拒绝后的缓存状态,都需要分别验证。

前面的测试检查的是,同一个 token 在两端得到的评分是否相同。但如果要把 generator 返回的概率用作 importance ratio 的分母,我们还需要确认,输出的 token 确实是按照这个分布采出来的。比如,温度变换可能让实际采样分布与接口返回的概率不同;而更复杂的候选验证过程,即使每一步的评分都完全正确,也可能因为接受规则出了问题,最终采出错误的分布。

为了区分这两件事,把接口返回的 log-prob 记为 ℓtreport\ell_t^{\mathrm{report}},由日志算出的差值记为

ρ^t=log⁡πθ(yt∣ht)−ℓtreport.\widehat\rho_t=\log\pi_\theta(y_t\mid h_t)-\ell_t^{\mathrm{report}}.(14)

前面定义的 ρt\rho_t,使用的是实际采样分布 πgenerator\pi_{\mathrm{generator}}。因此,只有当接口返回的值确实等于这个分布的 log-prob 时,ρ^t\widehat\rho_t 才会等于 ρt\rho_t,我们也才能把前面的 KL 解释用于日志里的数值。对于由 decode 产生的 token,前面拆分计算路径时记录的 ℓtdecode\ell_t^{\mathrm{decode}},也就是这里的 ℓtreport\ell_t^{\mathrm{report}}。所以,逐 token 的代数拆分始终可以用于日志差值,但如果要把这个差值解释为真实的 log-ratio,就还需要确认返回值描述的是实际采样分布。下面的两个例子会分别说明,概率返回模式和采样实现是怎样破坏这个前提的。

6.1 温度改变了采样分布,raw log-prob 却可能保持不变

前面一直把 temperature 设为 1,是为了让原始的 softmax 分布与实际采样分布相同。但在生产配置发生变化以后,我们还需要明确,训练目标使用的究竟是哪一个分布。例如,如果我们希望训练的就是温度变换后的策略,那么 trainer 在计算概率时,也应该使用相同的温度。这样,两端比较的都是变换后的概率,分子和分母的定义才是一致的。

另一种设定是,把原始模型的分布保留为训练目标,先用温度变换后的分布生成样本,再通过 importance correction 来校正期望。在这种情况下,raw log-prob 所描述的概率与实际采样概率,就是两个不同的量了。我们把 generator 输出的 logits 记为 zvz_v,把原始分布记为 πraw\pi_{\mathrm{raw}},实际产生样本的 behavior policy 则记为 πbehavior\pi_{\mathrm{behavior}}:

πraw(v)=ezv∑uezu,πbehavior(v)=ezv/T∑uezu/T,T>0.\pi_{\mathrm{raw}}(v)=\frac{e^{z_v}}{\sum_u e^{z_u}},\qquad \pi_{\mathrm{behavior}}(v)=\frac{e^{z_v/T}}{\sum_u e^{z_u/T}},\qquad T>0.(15)

假设词表中只有 A、B,logits 是 [0,log⁡3][0,\log3],那么原始概率就是 [0.25,0.75][0.25,0.75]。当 T=2T=2 时,实际采样概率会变成约 [0.366025,0.633975][0.366025,0.633975]。如果 trainer 的目标分布仍然采用原始分布,而且两端都返回 raw log-prob,那么逐项比较的差异就会是零。但是,如果要把 behavior 分布下的单步动作期望校正到 trainer 的目标分布,正确的权重应该分别是

0.250.366025…≈0.683013,0.750.633975…≈1.183013.\frac{0.25}{0.366025\ldots}\approx0.683013,\qquad \frac{0.75}{0.633975\ldots}\approx1.183013.(16)

如果误把 raw 概率用作分母,两个权重就都会变成 1。我们可以直接看看这会带来什么影响:A 在实际样本中的比例约为 0.366025,乘上正确的权重以后,会回到目标分布中的 0.25;但如果乘上的权重是 1,这个比例就仍然是 0.366025。也就是说,虽然两端的数值计算完全一致,期望却并没有被校正到我们希望优化的目标分布。

因此,在接入采样接口时,我们需要确认,返回的 log-prob 描述的是温度变换之前,还是变换之后的概率。例如,vLLM 的 --logprobs-mode 文档区分了 raw_logprobs 和 processed_logprobs,其中默认使用的是 raw_logprobs,而 processed_logprobs 描述的是经过 temperature、top-k、top-p 等处理后的生成概率。文档还特别说明,prompt log-prob 不经过这些采样处理,所以两种模式在 prompt 上会返回相同的结果。当我们通过 prefill 重新评分时,这就是需要核对的一项接口差别。

除此之外,top-k、top-p 和受约束解码,还会把一些 token 的概率变成零。如果目标策略仍然给这些 token 非零的概率,那么仅靠实际采到的样本,就无法无偏地恢复完整的目标动作期望。这是因为,那些被排除的 token 永远不会出现在样本里,也就没有机会贡献它们在目标分布下对应的那部分期望。

所以,在开始排查之前,就应该先确认概率的定义。否则,我们可能花了很长时间去对齐两个数,却始终没有确认,这两个数是不是训练目标真正需要的概率。不过,即使接口的定义没有问题,采样过程本身也仍然可能出错。

6.2 候选验证用错了概率,两端评分仍然可能完全相等

在 speculative decoding 中,通常会先由计算成本较低的 drafter 提出若干候选 token,再由目标模型 verifier 为这些候选评分,决定接受哪些 token,以及在哪个位置重新采样。Multi-Token Prediction,也就是 MTP,则提供了产生候选的一种方式。MTP 本身是一种多 token 预测的训练目标,或者对应的附加预测模块,因此它与 speculative decoding 并不是同一个概念。例如,DeepSeek-V3 技术报告就说明,在推理时,既可以丢弃 MTP 模块、只使用主模型,也可以让 MTP 模块参与候选生成。

对于 RL 来说,我们关心的是,候选经过验证以后,最终输出是否仍然服从主模型希望采样的分布。以 speculative sampling 论文中的标准拒绝采样算法为例,我们固定前缀 hh,把 verifier 的目标分布记为 πverifier\pi_{\mathrm{verifier}},把 drafter 实际使用的提议分布记为 πdraft\pi_{\mathrm{draft}}。这两个分布,都已经包含了各自采用的温度变换、截断和其他处理。下面省略共同的前缀条件 hh。对于 drafter 提出的 token yy,它被接受的概率是

a(y)=min⁡ ⁣(1,πverifier(y)πdraft(y)).a(y)=\min\!\left(1,\frac{\pi_{\mathrm{verifier}}(y)}{\pi_{\mathrm{draft}}(y)}\right).(17)

这样一来,通过接受分支得到 yy 的概率就是 πdraft(y)a(y)=min⁡(πverifier(y),πdraft(y))\pi_{\mathrm{draft}}(y)a(y)=\min(\pi_{\mathrm{verifier}}(y),\pi_{\mathrm{draft}}(y))。如果候选被拒绝,我们会把 max⁡(0,πverifier−πdraft)\max(0,\pi_{\mathrm{verifier}}-\pi_{\mathrm{draft}}) 归一化,再从这个分布中采一个 token。由于总拒绝概率恰好等于这些正差值的总和,所以拒绝分支补足的,正是接受分支还没有覆盖的那部分 verifier 概率。把两个分支合在一起,最终的 behavior 分布就会等于 πverifier\pi_{\mathrm{verifier}}。不过,这个结论有一个必要条件:接受规则使用的提议概率,必须与实际生成候选时使用的概率一致。

对于一块按顺序提出的候选,验证会从第一个位置开始。如果在某个位置第一次发生拒绝,就会在这个位置重新采一个 token,并舍弃后面的所有候选。而如果这一块候选全部被接受,就会从所有候选之后的 verifier 分布中,再采一个 token,通常称为 bonus token。这个额外的 token 直接来自 verifier,因此不需要再经过 draft 的接受判断。

因此,在上述条件成立时,传给 RL 的应该是最终 token 在 verifier 分布下的 log-prob。无论这个 token 是被接受的候选、拒绝后重新采出的结果,还是 bonus token,都遵循同一个定义。对于重新采出的 token,尤其需要区分两个量:RL 需要的是把接受和拒绝两个分支合起来以后得到的行为概率,而拒绝分支中使用的残差概率,还额外带有“已经发生了拒绝”这个条件。两者不能混用。如果 trainer 的目标分布与 verifier 的采样分布不同,就仍然按照前面的定义计算 importance ratio,不需要再额外乘上一次针对 draft 概率的修正。

如果接受规则使用了错误的 draft 概率,前面的分布保证就会失效,但逐项比较 log-prob 未必能够发现这个错误。 我们可以构造一个固定前缀上的例子:verifier 给 A、B 的概率是 [0.6,0.4][0.6,0.4],drafter 的原始概率也恰好相同。但由于 drafter 使用了 top-1,它实际每次提出的都是 A。如果验证程序错误地读取了截断前的概率 0.60.6,那么 A 的接受概率就会被算成 0.6/0.6=10.6/0.6=1,最终每次都会输出 A。正确的分母应该是实际提议概率 11。只有这样,A 才会以 0.60.6 的概率被接受,剩下的拒绝分支则会补出 B。

在这个错误实现中,generator 仍然可以为 A 返回 verifier 的 log⁡0.6\log0.6,而 trainer 重新计算 A 的 log-prob,也会得到 log⁡0.6\log0.6,所以日志里的 ρ^=0\widehat\rho=0。但 A 的实际行为概率已经变成了 11,真实的 log-ratio 应该是 ρ=log⁡0.6−log⁡1≈−0.511\rho=\log0.6-\log1\approx-0.511。这与前面 trainer 重算 old log-prob 的例子有一个相似之处:即使日志里的 ratio 看起来等于 1,也不能据此保证样本来自 trainer 的分布。如果 PPO 仍然把接口返回的概率用作分母,就无法通过这个 ratio 纠正 A 被过度采样的问题。更进一步说,即使我们已经知道了真实的行为概率,由于样本中从来不会出现 B,importance weighting 也无法补回 B 在目标期望中的贡献。所以,这里需要修正的是接受规则本身。

固定同一个前缀,把这个只有两个 token 的正确和错误采样过程各模拟 100,000 次,得到的 A 的频率分别是 59.808%59.808\% 和 100%100\%。这里,正确实现也不会恰好得到 60%60\%。对于相互独立的采样,频率的标准误是 0.6×0.4/100000≈0.00155\sqrt{0.6\times0.4/100000}\approx0.00155,所以这次观察到的偏离,符合正常的抽样波动。这个例子说明,频率检查可以发现逐项评分检查遗漏的错误。但在判断结果时,我们仍然需要结合采样数量,不能把任何偏离都当作 bug。

6.3 验证时的数值路径与拒绝后的缓存,都需要单独检查

即使接受算法本身是正确的,speculative decoding 也会增加一条需要对齐的数值路径。普通的 decode 通常只为每个请求处理一个新位置,而 verifier 会一次处理多个候选位置,因此矩阵形状、attention kernel 和归约顺序,都可能发生变化。前面关于分布保持的数学证明,假定的是同一个前缀对应同一个目标分布。如果浮点计算改变了这个目标分布,就还需要单独检查,不能直接用数学证明来代替。vLLM 的文档也把理论上的分布保持,与实际 log-prob 的稳定性分开说明。

除此之外,候选验证还增加了拒绝以后的状态处理。假设 drafter 提出了 A、B、C,而 verifier 接受了 A、拒绝了 B,并在 B 所在的位置重新采到了 D,那么最终提交的输出就应该是 A、D。此时,B、C 对应的临时缓存必须被回退或者屏蔽,而 D 对应的状态,也需要在后续计算使用它之前正确建立。

提出候选
ABC
验证结果
A:接受B:拒绝C:作废
提交输出并准备下一轮
AD:重采样后续计算的有效前缀是原前缀加 A、D,不能继续读取 B、C 的状态。
图 3:即使候选的评分都正确,如果拒绝以后仍然使用候选分支留下的状态,那么下一轮计算也会偏离已经提交的序列。因此,要发现这一类错误,还需要检查状态回退以后的第一次计算。

这也与前面的请求恢复案例联系起来了。我们需要分别确认,评分路径是否一致,接受规则是否保持了目标分布,以及后续状态是否对应已经提交的序列。如果只是关闭 speculation,然后看到异常消失,还无法分辨究竟是验证时的计算形状、接受概率,还是拒绝后的状态出了问题。因此,在后面的排查流程里,这几项检查都需要分别保留。

7. 从异常样本到回归测试,一次排查应该怎样推进?

TL;DR: 排查需要从能够复现的异常样本出发,通过受控比较找到第一处具体分歧。修复后的验证还要覆盖非零参数更新与权重同步、原来的故障触发条件以及生产配置,并确认检查本身能够发现主动引入的错误。

把前面的检查接入自己的系统时,我们可以先确认比较对象,再建立受控对照,随后根据结果缩小调查范围,最后验证修复是否有效。如果是第一次接入模型,可以从一组短样本开始;如果是生产训练中出现了 KL Spike,就应该优先保留出错的 rollout,以及当时触发问题的执行事件。还有一种值得调查的情况是:固定权重以后,开启或者关闭 speculation,会让 token 频率、回答长度等统计量出现可重复的变化,但日志中的评分差却没有相应变化。这时就需要检查采样过程了。不过,单凭这些统计变化,还无法区分问题来自接受算法、验证时的数值路径,还是正常的抽样波动。

7.1 先保存能够复现的输入,并确认两端比较的是同一个量

开始排查时,我们首先需要拿到一份能够重新评分的样本记录。如果手里只有均值曲线,或者只有解码后的回答,就还不足以完成下面的对照。具体需要保存哪些信息,可以参考这张表:

需要保存和核对什么要排除的歧义
完整 token IDs、prompt 边界、有效生成位置,以及实际使用的 position IDs、mask 和多模态输入两端是否在相同前缀上预测同一个 token,是否包含了 padding 或漏掉 EOS
generator 生成时返回的 ℓtreport\ell_t^{\mathrm{report}}、trainer 实际 loss 路径的 log-prob、各自的 dtype是否用了 trainer 重算的 old log-prob 代替 generator 记录,是否发生了导出精度损失
权重快照标识、同步记录,以及可核对的张量名称、形状、dtype 和内容摘要版本号相同是否真的对应相同权重,是否漏传 adapter、router 或某组 expert
temperature、top-k、top-p、logits processor 与 log-prob 返回模式比较的是 raw 分布,还是处理后的实际采样分布
batch、并行与缓存配置,以及请求暂停、恢复和权重切换的位置哪些执行条件需要在复现时保留
启用候选验证时,两模型的版本、候选与接受结果、重采出的 token、实际提议概率、每个候选的 verifier 概率,以及回退前后的有效缓存长度接受规则是否使用了实际提议概率,被拒绝候选是否也保留评分,回退后状态是否对应提交的序列

在核对权重时,需要先把分片或者打包后的表示,还原到相同的逻辑张量上。如果两端采用的存储布局不同,就不能直接比较它们的字节摘要。另外,如果系统允许在生成过程中切换权重版本,就需要把每个 token 或者生成片段对应到具体的版本,再挑选同版本的部分进行比较。否则,参数版本落后的影响,就会混进我们本来想要检查的执行差异中。

如果比较对象还没有对齐,就应该先修正输入、索引或者概率定义。 如果缺少 generator 在生成时返回的 log-prob,就需要补充记录功能以后重新采集。trainer 事后重新计算出来的概率,无法替代 generator 当时实际给出的结果。

如果正在调查生产故障,就应该从保存下来的原样本和当时的权重开始,先完成下面的路径比较。换了新配置以后重新生成的一条正常回答,未必经历过原来的触发条件,因此不能代替出错的那条回答。只有在需要隔离某个因素时,我们才有针对性地改变配置,或者增加新的对照。

如果是第一次接入模型,或者准备建立回归测试,则可以从短样本开始。在 temperature 为 1、没有截断、关闭 dropout、使用干净缓存的条件下,采集生成结果和对应的评分。如果能够让两端采用匹配的数值路径,就建立严格的零差异参照;如果暂时还做不到,也仍然可以先检查输入和状态,再测量每一对路径之间的数值偏差。后面会继续讨论,怎样利用这些非零的结果来排查问题。

如果系统使用 MTP 或者其他 drafter 来加速生成,可以先关闭候选生成,建立普通逐 token 采样的参照,再开启候选验证路径进行比较。但如果是在调查已经发生的故障,就需要保留原来的候选和接受记录,因为重新生成一组候选,可能会避开原来的触发条件。同时,接受规则需要使用生成这组候选时的实际提议概率。更新 drafter 以后重新计算出来的概率,不能用来替代它。

原样本里保存的概率,也会决定我们应该怎样比较。如果保存的是 raw log-prob,就可以与两端重新计算得到的 raw log-prob 比较。但如果只保存了处理后的概率,就需要先在 trainer 和 prefill 的 logits 上,重放相同的温度变换、截断和其他处理,再比较选中 token 的概率。要做到这一点,必须能够恢复处理所需的完整状态。仅靠某个选中 token 的 raw log-prob,通常无法重新计算变换后的归一化项。如果这些状态已经无法恢复,那么可以先把原样本用于 trainer 与 prefill 的 raw 评分比较,再另外采集 decode 的数值对照。不过,这仍然没有补齐原故障的 decode 概率记录,还需要通过增加记录,或者重新触发原来的条件,继续调查。

7.2 先检查 generator 能否复现自己的评分与状态

保存了生成时的评分以后,我们可以先让 generator 对同一条序列做几组对照。这样,即使 trainer 还没有接入,也能够开始检查生成端。这几组比较都需要固定 token IDs、权重、预测位置和概率定义。同时,每次重新计算时,还要明确哪些状态是重新建立的,哪些状态是从已有结果中复用的。

做强制 decode 时,关键是把“计算下一个 token 的分布”和“选择下一个输入 token”分成两步。每一步先读取当前模型的原始 logits 或者 raw log-prob,记录待比较 token 的分数;随后,把已经保存的序列中的下一个 token 作为输入,继续推进缓存。这样既保留了增量计算,也避免了重新采样带来的序列变化。如果框架通过屏蔽其他 token 来强制选择,就必须在屏蔽之前取得评分。否则,处理后的分布里只剩下一个 token,它的 log-prob 就会变成零。如果框架还没有暴露这些接口,可以先做 prefill 的重复计算和 batch 对照;但要完成 decode 的比较,仍然需要增加引擎侧的记录。

比较什么改变哪个条件结果怎样帮助下一步判断
同一条序列重复 prefill每次清空旧状态,保持执行配置和 batch 相同如果仍有差异,就先调查同一路径的重复性。如果结果相等,则继续检查下面两组对照,还不能直接推断 decode 也一致。
同一阶段内,单独执行与加入其他请求执行prefill 和强制 decode 分别比较,记录每步 batch;prefill 分块另做对照在该阶段的两种 batch 配置之间逐层定位,MoE 同时比较 router 得分与选中的 expert
prefill 与沿固定序列推进的 decode两者先都单独处理这条序列,固定并行配置,排除其他请求的干扰仍有差异时,比较两个阶段的实际算子与状态,保留首次分歧的输入和形状
继续使用已有状态与清空后重建状态在同一前缀边界比较两种状态来源,随后强制推进同一段 token检查重建是否改变后续评分,并保留边界状态与第一次分歧的位置

表格中的前两行,分别检查固定配置下的重复性和 batch 不变性,第三行才开始检查 prefill 与 decode 的一致性。一个实现完全可能在每次运行时,都稳定地产生两套不同的结果。因此,前面的检查通过了,并不能代替后面的检查。单请求的对照虽然排除了其他请求的干扰,但 prefill 的多行计算与 decode 的单行计算,仍然具有不同的形状。所以,第三行测到的是阶段切换带来的整体差异,还不能直接把它归因于 attention 或者缓存。如果差异只有在加入其他请求以后才出现,就应该先在同一阶段的两种 batch 配置之间定位,再重新做跨阶段的比较。

表格的最后一行,在多轮对话里尤其有用。假设第一轮已经生成了 A、B、C,工具返回的 token 序列是 R,那么第二轮就需要从前缀 (x,A,B,C,R)(x,A,B,C,R) 继续。我们可以让一条路径保留第一轮逐步生成时留下的缓存,再处理尚未写入状态的尾部 token 和 R;另一条路径则清空状态,对同一个完整前缀重新执行 prefill。等到两条路径都处理到同一个边界以后,再固定后续 decode 的 batch、kernel 和输入 token,比较第二轮的评分。即使 token IDs、位置和权重版本都正确,这两种方式形成的数值状态也仍然可能不同。因此,仅凭这个现象,还不能证明缓存已经过期或者损坏。

要继续区分状态计算与状态管理,我们可以从同一份已经核对过的增量状态出发。一条路径直接继续计算,另一条路径经过准备调查的保存、恢复或者复用流程,然后再使用相同的 decode 配置继续计算。如果直接继续时结果正常,而经过状态交接以后出现了新的差异,就需要逐项检查交接前后的逻辑状态、有效长度和位置映射。对于本来应该原样传递的张量,还需要确认它们的数值没有发生变化。如果在没有任何状态交接的对照中,干净的逐 token 重建仍然与 prefill 不同,就可以先沿着这两种状态构建路径定位。差异有多大、是否集中在分页边界,都只能帮助我们选择检查位置,还不能单独证明问题属于哪一类原因。

对于带有递归状态的模型,我们还需要检查边界处的状态张量。整段或者分块 prefill,与逐 token 更新,在精确算术下可以是等价的。但由于计算的分组方式不同,它们可能留下不同的数值状态,而后续 token 又会继续读取这些状态。公开的 Gated DeltaNet 对齐分析给出了这类问题的例子。因此,除了确认当前 token 的评分一致,我们还需要看看本次计算写出了什么状态,以及下一次计算是否会读取到正确的状态。

在多轮记录里,还有一种容易混淆的比较。当 A、B、C 被放进第二轮的 prompt 以后,通过 prompt log-prob 得到的,是 prefill 对第一轮回答的重新评分。这些结果可以用于前面的诊断,但不能用来覆盖第一轮生成时保存的 decode log-prob。RL 使用的行为概率,需要保留生成时的实际来源。不能因为同一段文字到了下一轮变成了 prompt,就把重新计算的概率当作它最初被采出来时的概率。

7.3 比较实际执行过的路径,再决定下一项实验

完成 generator 自身的检查以后,我们再针对同一份权重和序列,取得 trainer 的评分、干净缓存下 generator 的 prefill 评分,以及生成时保存下来的评分。下面的比较主要针对由 decode 产生的 token。回答中的第一个 token,通常是从 prompt 的 prefill 输出中采样得到的,因此需要单独标记。在计算差值之前,还要先确认有效 token 的数量是否符合预期,有没有缺失值或者非有限值。如果提前过滤掉异常 token,或者让空结果也通过检查,后面的比较就失去了意义。

下表中的“异常”,指的是超出了对应路径已知数值范围的差异。如果使用严格的零差异配置,那么任何非零差异都需要调查;如果两端存在已经测量过的数值偏差,就需要分别为两段比较建立参照,后面“暂时无法归零”的部分会介绍具体方法。即使这次的结果落在原有范围内,也只能说明没有观察到新增的异常,还不能据此证明这条路径没有错误。

观察结果下一步做什么要留下什么证据
trainer 与 prefill 异常,prefill 与 decode 符合基线核对两端权重表示、精度和并行配置,再逐层比较两套整段前向计算第一个发生分歧的层,其输入、参数和输出
trainer 与 prefill 符合基线,prefill 与 decode 异常从正确前缀重新建立缓存,强制 decode 沿记录的 token 推进。如果连续推进也有异常,就检查增量算子和缓存精度。如果异常只在暂停、恢复时出现,就检查状态传递。首次分歧的位置,以及相应的缓存写入、读取或恢复事件
两段比较都异常保留两个差值,分别缩小范围;修正一段后,重新运行另一段的比较每次只改变一个因素的结果,避免两段差值相互抵消
受控配置一致,原配置出现差异逐项恢复原来的 batch、kernel、并行、缓存和调度条件,必要时再检查它们的组合差异首次重新出现的配置变化及输入;不能仅凭归零就认定原配置无误
候选块评分出现异常,普通逐 token 评分符合基线在同一前缀上改变候选块长度,比较 verifier 的输入、mask 与数值路径首次分歧的候选位置、块长和对应的层内张量
拒绝前评分符合基线,首次分歧紧跟在拒绝后的计算中从相同状态构造一次拒绝,检查回退与提交,再对照按最终序列重新建立的缓存拒绝位置、回退前后有效缓存长度,以及下一轮首次分歧的位置
原样本重算后与保存的 decode 一致,但训练日志里有差异核对日志中的 token 对应关系与权重版本,再恢复 trainer 当时的 batch 组成、序列拼接和 mask训练时与单独重算时的输入和评分差别,以及日志的索引关系

在比较候选块时,也需要把每个位置的前缀,与 trainer、prefill 和强制逐 token decode 使用的前缀对齐。如果首次拒绝以后,后面的候选已经作废,那么这些位置的计算就只能按照原来的候选前缀来检查,不能把它们的分数对应到重新采样以后的实际输出。对于拒绝位置上重新采出的替代 token,则使用该位置的 verifier 分布来评分。等到下一轮,再检查提交这个新 token 以后形成的真实前缀。后面的回归测试部分,会继续介绍怎样确定地触发拒绝,以便检查状态回退的分支。

表格的最后一行,也可能帮助我们发现 trainer 一侧的前缀错误。例如,把两条回答拼成一行以后,如果 attention mask 没有把它们隔开,那么后一条回答就会看到前一条回答的内容。但如果把后一条回答单独取出来重新评分,这个错误反而不会出现了。因此,在复现问题时,需要保留两端各自的 batch 条件,也不能一开始就认定问题只会出在 generator。

把范围缩小到某条路径以后,可以先比较 embedding 的输出,再沿着各个 block 的输入和输出,寻找最早发生的分歧。只有输入与参数已经对齐,我们才能把新增的差异归到当前算子。 如果某一层收到的输入已经不同,就应该继续向前检查,不能仅仅因为这一层的输出差异最大,就先修改这一层。对于 MoE 模型,还需要同时保存 router 的得分和选中的 expert 编号,以便区分数值变化与离散路由变化。如果框架支持导出路由,我们可以在同一个输入上,增加一组只回放 generator expert 编号的对照,再看看差异是否减小。这个对照能够检验路由选择的影响,但还不能单独证明其他计算都是正确的。

如果完整的 logits 已经一致,但 log-prob 仍然存在差异,我们就可以单独检查最后的归一化步骤。对于 token yy,有

log⁡π(y)=zy−log⁡Z,Z=∑v∈Vezv,\log\pi(y)=z_y-\log Z,\qquad Z=\sum_{v\in\mathcal V}e^{z_v},(18)

其中,zyz_y 是选中 token 的 logit,V\mathcal V 是有效词表,log⁡Z\log Z 则是整个有效词表上的 log-sum-exp。按照这个式子,两条路径的 log-prob 差,等于它们各自 zyz_y 的差,再减去各自 log⁡Z\log Z 的差。因此,我们应该同时记录这两个量,并核对归一化所覆盖的词表范围。例如,如果为并行对齐补出的额外列没有被屏蔽,那么即使所有有效 token 的 logits 都相同,也仍然会因为归一化的分母变了,而产生整体偏移。而如果 logits 和词表范围已经相同,差别只在于归约顺序,那么就可以继续考虑使用 batch-invariant log-softmax 来对齐这一步。

经过这一步,我们应该能够把问题缩小到一处可以重现的具体分歧。例如,“相同输入在经过这个算子以后开始出现差异”,或者“经过这个恢复事件以后,token 计数与列表内容不再一致”。修正这一处问题以后,还需要回到原来失败的输入,再检查是否存在其他差异。因为一个系统中可能同时存在多个问题,消除了第一处偏移,并不意味着排查就已经结束了。

7.4 评分相等以后,怎样检查采样过程?

如果新增或者修改了采样算法,就应该把分布检查作为一项独立的回归测试。即使前面的评分对照全部通过了,这项测试也仍然需要执行。如果生产中出现了“输出统计改变,但评分差没有变化”的现象,也可以从这里开始调查。不过,如果评分路径本身就存在异常,我们需要先把这个异常记录下来并加以定位,避免把 verifier 分布的变化,混进对接受算法的判断之中。

对于标准拒绝采样,可以先检查已有的候选记录。我们用 verifier 的概率和实际提议概率,重新计算每个候选应该有的接受概率 a(y)a(y),再按照这个概率分组,比较组内的实际接受比例与 a(y)a(y) 的平均值,同时保留样本数量和统计误差。这里应该只统计真正执行了接受判断的候选。首次拒绝以后被跳过的候选后缀,并没有再次经过判断,所以不能把它们也记成拒绝。在前面的 top-1 反例中,预期的接受比例应该是 0.60.6,实际却是 11,这个对照就能够直接暴露偏差。

这项检查能否起作用,关键在于我们是否独立核对了提议概率的来源。如果验证模块误读的是 raw 概率,而检查时又拿同一个字段重新计算 a(y)a(y),那么两边仍然会一致,错误也就被一起保留下来了。因此,需要结合实际生成候选的采样步骤和变换记录,确认提议概率究竟是什么。例如,确定性 top-1 提议的概率就应该是 11。即使接受比例符合预期,我们还需要继续检查,拒绝分支是否使用了正确的残差分布。必要时,可以为少量诊断样本导出该位置上的完整目标分布和提议分布。

接下来,可以在固定前缀上重复采样,比较实际的输出频率。我们可以先用小词表上的已知分布来验证算法,再用真实模型的固定前缀检查接入后的结果,同时记录对应的 verifier 分布。如果候选块包含多个位置,小词表测试还应该比较连续两三个 token 的联合频率,并把它与目标模型逐位置条件概率的乘积进行对照。这样可以避免只检查第一个位置,而遗漏后续条件分布的问题。当然,有限数量的样本,对很小的偏差未必有足够的检出能力,因此也需要记录采样次数,以及频率的不确定范围。

如果接受比例和输出频率都符合预期,但开启和关闭 speculation 以后的输出仍有差别,就可以回到候选块的评分路径,检查计算形状的变化是否改变了 verifier 分布。同时也要记住,随机采样本来就会产生不同的回答。即使使用同一个 seed,也不保证两种执行方式会逐 token 地生成相同结果。因此,不能仅凭某一次回答不同,就认定分布出现了错误。

7.5 暂时无法归零时,怎样利用已有的数值偏差继续排查?

即使暂时无法让数值差异归零,也还有一些检查是可以精确完成的。比如,token IDs、预测位置、有效数量和记录的完整性,都不应该因为引入了数值容差而放宽。权重也需要按照预期的分片、转换和量化规则来验证,不能用“误差比较小”来解释漏传的权重。概率的定义和版本之间的对应关系,同样需要明确。这些条件即使在不同的 kernel 之间,也能够进行检查,并不依赖整套模型的数值结果完全一致。

对于剩下的数值偏差,我们需要针对每一对路径分别测量。可以先从 generator 自身的重复计算和 batch 对照开始,再把样本扩展到实际数据会使用的长度和类型。在固定权重、使用干净状态、核对输入的条件下,逐项改变 batch 大小、排列方式和并行配置,记录差值的分布、最大值,以及它随着 token 位置和配置变化的规律。不过,这份参照描述的只是已经观察到的偏差,还不能证明这些偏差一定无害,也不应该只用一个均值来概括它。如果更换了 GPU 架构、kernel 版本或者量化路径,就需要在相同样本和相同统计定义下重新测量。

有了这份参照以后,就可以在相同输入和配置下继续比较。如果同步以后的差异整体抬高了,某个位置之后出现了此前没有的持续偏移,或者某一类输入开始出现新的极端值,就需要回到前面的路径分支中调查。这里也不能要求所有正常的数值偏差,都与位置或者 batch 无关,因为不同计算路径本来就可能产生这样的规律。我们需要检查的是,这些规律能否在受控对照中重现,以及变化是否有能够进一步核对的来源。

在使用容差验收时,还需要注明,这项检查能够发现多大幅度的错误。例如,在测试中主动漏传一个权重以后,如果新增的偏移仍然被现有容差放过,就说明测试还没有证明自己能够检出这类遗漏。此时可以增加能够暴露该权重变化的输入,缩小相关路径的数值偏差,或者直接核对同步后的张量。另一方面,如果平时的数值偏差已经导致大量 token 的 PPO 梯度在第一次更新前就被 clip 掉,就需要优先调整贡献最大的精度或者计算路径,或者明确选择相应的算法校正。即使把这样的结果记录为基线,它对模型更新的影响也仍然存在。

7.6 修复要经过真实更新、故障触发和生产配置的复查

在初始权重下通过比较,只能说明这次静态的前向计算符合预期。我们还需要让 trainer 的参数实际发生变化,再通过正常路径同步给 generator,处理已有的缓存,随后重新生成回答并计算它的 log-prob。如果学习率一直为零,那么即使同步代码根本没有起作用,两端也可能始终一致。比如,假设权重名称映射漏掉了一组 expert。启动时,两端都从 checkpoint 加载了完整权重,所以第一次测试可能正常。只有在参数更新以后,这组 expert 的新权重没有传过去,第二次测试才有机会暴露问题。

因此,最小的验证作业应该包含两个必须完成的阶段:先在初始权重下生成回答并重新评分,再在非零更新、完成同步以后,重复这组生成和评分。 检查时,除了看版本号,还需要确认 trainer 的参数确实发生了变化,而且这些变化已经按照预期到达 generator。两个阶段都必须比较预定的有效 token,并确认所有数值都是有限的。如果使用匹配的零差异配置,那么每一项差异都应该为零。如果作业提前退出、没有有效样本,或者跳过了更新后的阶段,都应该判为失败。

除了验证正常情况,我们还需要确认,检查本身确实能够发现错误。例如,可以在隔离测试中,故意漏传一个已经改变、而且会被测试样本使用的权重张量,或者删除一项 log-prob,再确认测试会拒绝这些结果。对于请求恢复的问题,可以暂缓提交一个已经完成的生成结果,让恢复逻辑确实遇到“结果尚未报告”的状态,再检查它是否会按照设计等待,或者拒绝不一致的消息。随后释放结果,确认请求能够正常继续。这样,测试记录才能同时证明:触发条件确实发生过,修复后的计数、列表和缓存状态也满足了约束。仅仅看到这一次 KL Spike 消失,还不足以验收修复。

对于候选验证,还需要分别覆盖几种情况:所有候选都被接受并产生 bonus token、在第一个位置发生拒绝,以及在中间某个位置发生拒绝。每种情况下,都需要检查最终提交的 token、对应的 verifier log-prob、有效缓存长度,以及下一轮的第一次评分。在小词表测试中,可以让 drafter 在指定位置必定提出一个目标概率为零的 token,这样就能够确保拒绝发生。在真实模型的隔离测试中,也可以控制候选和接受判断使用的随机数,确保程序进入拒绝分支,再检查回退以后的状态。不过,人为控制随机数只用于测试状态处理;如果要检验分布,仍然需要使用正常的随机采样。

在完成非零更新和同步以后,还需要再运行这些分支,确认 verifier 使用的是对应的目标权重,而接受规则使用的仍然是候选生成时记录下来的提议概率。评分对照、采样频率检查和状态回退测试,也应该分别记录结果。因为它们验证的是不同的问题,其中一项通过了,并不意味着另外两项也已经通过。

最后,我们还要把测试逐步扩大到实际使用的 batch 大小和排列、序列长度、并行配置,以及输入类型。因为文本测试通过了,还没有覆盖图像 embedding 的精度路径;单卡测试通过了,也还没有覆盖跨卡归约。恢复生产优化以后,如果两端出于设计而采用不同的数值路径,那么验收时就应该分别确认几件事情。输入、版本和记录等精确检查应该通过,原来的故障也应该在触发条件确实发生时得到修复。同时,更新前后、不同 batch 下的残余差异,都应该符合已经测量的范围,并且这些 ratio 偏移对更新的影响已经得到评估。尤其要结合 advantage 的符号,记录有多少 token 的 PPO 梯度提前被 clip 掉,再明确训练作业能够接受的范围。满足这些条件以后,可以把结果记为当前配置下的回归通过。至于是否通过了严格零差异测试,则需要另外记录。

在实际工程里,这些检查也可以分开运行。固定样本的算子或者层级比较,适合在修改代码时执行;包含非零更新和同步的短作业,可以用于集成回归;而暂停恢复、长序列和不同并行配置,则可以放进更完整的定期测试。生产监控还需要继续保存异常样本,把此前没有覆盖的触发条件补充到测试中。这样,每次调查除了留下一个修复,也会留下相应的检查,帮助我们在以后发现同类问题。

如果准备把这些检查做成工具,记录格式、对齐后的逐项比较、统计和报告,都可以复用。需要针对具体框架适配的,主要是怎样取得 prefill 和 decode 的评分、怎样控制缓存和强制推进、怎样导出路由,以及怎样映射同步的权重。只要先把这些接口提供的数据定义明确下来,就可以复用前面的诊断流程,而不需要让所有系统都采用同一套训练和推理实现。

8. 排查 Trainer-Generator Mismatch,要同时检查引擎内部与两端之间的差异

前面的排查流程涉及多个比较对象。在 trainer 内部,我们关心固定权重以后,重复计算、改变 batch 或者 packing 是否会改变评分。在 generator 内部,除了重复计算,还需要比较 prefill、decode 和候选验证的路径,并检查暂停后继续生成时,已有状态是否仍然正确。在比较两端时,我们再检查同一条序列的评分,以及参数更新后权重是否同步到位。每组对照所检查的范围不同,因此,即使某一项检查通过,也不能据此认为整个系统已经一致。

下面这张图按照这些比较对象,串起了全文讨论过的差异来源、监控证据和排查方法。沿着 trainer 与 generator 的内部路径,以及两端之间的连线,可以看到每项检查在系统中的位置。图中也单独保留了实际采样的检查,因为评分相同以后,仍然需要验证输出是否遵循了预期的分布。

点击图中的一项比较,可以查看相应的说明。蓝色描边标出涉及的计算路径。双向箭头表示比较,单向箭头表示更新、生成或数据传递。

Trainer训练 loss 的实际评分路径
Trainer 训练评分
更新前冻结的评分当前参数的评分参数更新带来的变化,与固定权重下的计算差异,需要分别记录。
Generator重算、生成与状态维护
Prefill 整段评分
Decode 生成评分
Trainer 接收生成序列与概率记录Generator 生成
引擎内部的差异和两端之间的差异,需要分别比较

即使 trainer 和 generator 各自重复计算时都能得到相同的结果,两者计算出的概率也可能不同。Generator 内部也是这样,即使 prefill 的结果稳定,也还需要另外确认 decode、缓存状态和采样过程是否正确。

如果已经发现两条路径的评分不同,就从这两条路径开始对照。如果评分相同,生成结果的统计却发生了变化,就继续核对采样分布。图中的每组比较都只能排除一部分原因,需要把结果放在一起判断。

两端需要在同一个前缀上给同一个 token 计算概率

开始比较之前,先逐项核对 token IDs、prompt 的结束位置、EOS、padding、attention mask 和 position IDs。如果输入包含图像等内容,也需要核对对应的输入表示。两端记录的位置必须指向同一个 token,而且这个 token 之前的前缀应当完全一致。如果发现对应关系不一致,就先修正,再比较数值。

在排查计算差异时,还要固定权重,并确认两端记录的都是 raw 概率,或者都是经过相同处理的 processed 概率。随后检查有效记录的数量,以及是否存在缺失值或非有限值。如果生成时的记录没有保存下来,就需要重新采集,因为事后重算的概率无法说明当时的 decode 实际算出了什么。

参数没有更新时,trainer 的计算也可能随 batch 改变

关闭 dropout,固定参数和输入,沿着训练 loss 实际使用的路径重复计算 log-prob。随后把同一条序列单独拿出来评分,再放回训练 batch,或者只改变 packing 的方式,观察结果是否发生变化。如果重复计算的结果就不相同,或者评分随 batch、packing 改变,就检查 mask、计算精度、并行归约和 log-softmax,沿 trainer 自己的计算路径寻找原因。

参数更新以后,概率本来就可能改变,因此需要把这种变化与固定权重时的计算差异分别记录。更新前冻结的 old log-prob 也只代表 trainer 当时的评分,不能用它代替 generator 实际生成 token 时的概率。

重复 prefill 得到相同结果以后,还要改变 batch 再比较

固定权重和整条 token 序列,每次都从干净的状态开始 prefill。先保持 batch 和分块方式不变,确认重复计算能否得到相同的 log-prob。然后分别改变请求的组成、排列和 prefill 分块方式,观察同一条序列的评分是否变化。

如果差异出现在更换 batch 或分块方式之后,就在这两次 prefill 之间寻找最早出现分歧的计算,记录实际调用的 kernel 和中间精度。对于 MoE,还需要保留 router 得分、expert 编号和混合权重。同一配置下的重复性只验证了这一种执行方式,不能据此推断换一种 batch 后,或者切换到 decode 后,结果仍然相同。

Prefill 与 decode 的差异,要沿实际执行的算子定位

让 prefill 和 decode 分别单独处理同一条序列,并固定权重和并行配置。Decode 需要沿记录中的 token 强制推进,同时保留选出 token 之前的评分。这样可以排除其他请求的干扰,但整段计算与逐 token 计算的形状仍然不同,所以仍要核对实际的 backend 分派、MLA 投影顺序、MoE 路由、KV 精度,以及递归状态的更新。

找到第一个出现分歧的算子或者状态以后,再对它做局部比较。如果使用了候选验证,还要在相同前缀上比较 verifier 的候选块评分与逐 token 评分。配置里写着同一个 backend 名称,并不能说明这几条路径执行了相同的浮点计算。

暂停后继续生成时,要核对缓存与 token 记录是否仍然对应

从同一份已经核对过的增量状态出发,让一条路径直接继续生成,另一条经过暂停后再继续,或者经过一次缓存复用。两条路径都强制采用相同的后续 token,并保持 batch 和 decode 配置一致。如果只有经过状态交接的路径出现了差异,就逐项对照交接前后的在途 token、有效长度、位置、页映射和缓存的参数版本。

如果没有状态交接时,逐 token 构建的缓存也与 prefill 重建的状态不同,就先比较这两种构建过程。对于候选被拒绝的情况,还需要确认候选后缀对应的临时缓存已经被回退或者屏蔽,重新采出的 token 已经提交,并检查接下来的第一次计算。异常出现的位置可以帮助选择对照,具体原因仍要由对照结果和状态记录来确认。

评分一致以后,仍要确认采样结果符合目标分布

固定前缀和目标分布,记录温度、截断配置,以及接口返回的是 raw 还是 processed log-prob。核对目标策略与实际采样策略各自可能产生哪些 token。如果使用了候选验证,还需要独立确认提议概率确实来自生成候选的那次计算,然后检查接受比例、拒绝后的残差采样、bonus token 和最终返回的 verifier 概率。

这些检查完成以后,再比较输出频率与目标概率,并说明有限样本带来的统计不确定性。两端评分相同,仍然可能因为接受规则或采样实现错误而生成错误的分布。反过来,某一次生成结果不同,也不足以说明分布出了问题。

比较 trainer 与 prefill,可以定位两套整段前向实现的差异

使用相同的逻辑权重、序列和概率定义,让 generator 从干净缓存开始重算,同时保持两端各自原来的 batch 配置,并把这些配置保存下来。随后从 embedding 开始逐层比较。如果找到了第一个不同的输出,需要先确认该算子的输入与参数已经对齐,再检查分片和量化、LoRA 的表示、激活与累加精度、归约顺序、路由和 expert 计算。

到了输出端,还要核对有效词表和概率归一化。即使 trainer 与 prefill 已经一致,也还需要比较 prefill 与生成时保存的 decode 结果,因为这里尚未验证增量计算和生成状态。

PPO 实际受到的影响,取决于 trainer 与生成记录之间的总差异

比较 trainer 当前计算的 log-prob 与生成时保存的 decode 记录。如果想单独调查执行差异,就选取两端使用同一版本权重的样本。先计算逐 token 的 log-prob 差和 importance ratio。对于以生成时的概率作为 ratio 分母的 PPO 目标,还要结合 advantage 的符号,统计有多少 token 的 PPO 梯度提前被 clip 掉。

加入 prefill 的中间评分,可以判断差异主要来自哪一段路径,也可以发现两段差值相互抵消的情况。逐 token 的 log-prob 差可以按路径相加,但 k3 不能这样相加。如果要把样本均值解释为 KL 的估计,还必须确认实际采样分布与记录的行为概率相符,而且每一项比较都使用了相同的前缀。

权重同步需要在参数真正改变之后验证

保存 trainer 更新前后的快照,确认参数确实发生了变化,再通过正常路径同步到 generator。随后核对对应的 shard、adapter 和 expert 是否收到了新权重,并比较两端的逻辑张量。缓存也需要按照设计清理或更新,避免继续使用旧参数计算出的状态。

完成同步以后,重新生成回答并评分,再运行一次两端对照。在隔离测试中,还可以故意漏传一个确实发生变化、而且测试样本会用到的张量,确认检查能够发现错误。仅仅看到版本号相同,或者学习率为零时两端一致,都不足以证明同步成功。

保留异常样本,才能在修复后重新验证同一个故障

监控除了记录有效 token 数、均值、最大差值、分位数和超阈值数量,还需要保存对应的 rollout、权重版本、batch 配置以及调度和缓存事件。调查时要沿着序列寻找首次分歧,不能只查看差异最大的 token。记录为空、包含缺失值或非有限值,或者异常已被提前过滤,都意味着这次检查没有提供完整证据。

修复以后,先确认原来的触发条件确实再次发生,再检查非零更新和生产配置下的结果。严格零差异与落在已测量容差内是两种不同的结果,应当分别记录。路径比较、采样分布和状态恢复也需要各自的验证结果,这样才能知道修复覆盖了哪些问题。

图 4:两个区域内部,分别检查同一引擎的行为。两端之间,则检查评分的差异和权重同步。同一种异常现象可能有多个来源,因此还需要结合相应的证据继续区分。

9. 结语

同一份权重,并不能自动保证 trainer 和 generator 使用的是同一个策略分布。因此,当我们看到 KL 或者 importance ratio 发生变化时,还需要分辨其中有多少来自参数更新,有多少来自实际执行过程。零差异测试提供了一种受控的比较方法,而生成时保存的概率和状态,则让我们有机会追查生产环境中的异常。对于暂时无法消除的数值差异,也需要测量它出现的条件,以及它对模型更新的影响。有了这些对照,后续再讨论异步训练中的分布偏移、importance sampling 或者 KL 正则时,我们才能更有把握地区分算法本身的效果与系统执行差异带来的影响。

GRPORL infrastructure — 次阅读

评论

引用
@misc{zhang2026trainergeneratorconsistency,
  author = {Zhang, Yihua},
  title  = {Everything You Need to Know About Trainer-Generator Mismatch: Sources, Monitoring, Zero-Difference Tests, and Debugging},
  year   = {2026},
  url    = {https://normaluhr.github.io/en/p/trainer-generator-consistency}
}