Llm Opd Tutorial

§0 TL;DR Cheat Sheet

1. OPD = On-Policy Distillation：student 用自己当前 policy 采 trajectory，teacher 在 student 自己访问到的状态上给 per-token 监督信号（KL / log-prob / soft label）。它不是 DPO 的笔误，也不是 Online Preference Distillation——这一术语在 LLM 上下文专指 "on-policy distillation"。代表 paper：MiniLLM (Gu 2024 ICLR, arXiv 2306.08543)、GKD (Agarwal 2024 ICLR, arXiv 2306.13649)、Thinking Machines blog (Lu 2025-10-27)、Qwen3 Technical Report (May 2025, arXiv 2505.09388)、Survey (Song & Zheng 2026, arXiv 2604.00626)。
2. 核心 loss（一行能写下来）：sample $y \sim \pi_\theta(\cdot|x)$，对每个 token 算 reverse KL，定义为 $L_{\text{OPD}}(\theta) = \mathbb{E}_{x \sim D,\, y \sim \pi_\theta}[\sum_t D_{\text{KL}}(\pi_\theta(\cdot|x, y_{student 自己采），KL 方向是 $\pi_\theta \| \pi_T$（reverse / mode-seeking）——这两点是 OPD 与 vanilla KD 的本质区别。完整公式： $$L_{\text{OPD}}(\theta) = \mathbb{E}_{x \sim D,\, y \sim \pi_\theta}\!\left[\sum_{t=1}^{|y|} D_{\text{KL}}\!\big(\pi_\theta(\cdot|x, y_{

3. 三种 distillation 范式速记：

   • SFT / Hard distillation：teacher 生成 $\hat y$，student 在 $\hat y$ 上做 cross-entropy（off-policy + hard label）
   • Vanilla KD / Soft distillation (Hinton 2015)：teacher 生成 $\hat y$，student match teacher 的 soft logits（off-policy + soft label，forward KL，mode-covering）
   • OPD：student 自己生成 $y$，teacher 在 $y$ 上算 logits 给 KL 信号（on-policy + soft label，reverse KL，mode-seeking）
4. 为什么 on-policy 关键：off-policy distillation 有 exposure bias——training 时 teacher 的 prefix 都"完美"，但推理时 student 遇到自己的错误前缀没见过，错误 compound（误差随序列长度 $L$ 大约按 $O(L^2)$ 放大，见 §1.3）。OPD 把训练分布 = 推理分布对齐，把 compound 误差从 $O(L^2)$ 压到 $O(L)$。
5. OPD vs RL（核心卖点）：Thinking Machines blog 给出经验法则——RL 每条 trajectory 教 $O(1)$ bits（一个 outcome reward），OPD 教 $O(N)$ bits（每个 token 都有 teacher 的 soft label 监督）。在 Qwen3-8B-Base + Qwen3-32B-teacher 数学推理实验上，OPD 匹配 RL 在 AIME'24 的 gain，但 compute 降到约 1/9-1/30。Qwen3 Tech Report 也独立报告 OPD ≈ RL 性能但 GPU 时长只需 1/10。
6. 与 DPO / GRPO 的关系：(a) DPO 用 offline preference pair 做 closed-form RLHF，没有 teacher logits，没有 student rollout——与 OPD 几乎正交；(b) GRPO 用 group-relative advantage 做 on-policy RL，有 student rollout 但 reward 是 sparse outcome；(c) OPD = GRPO 的"dense teacher KL 替代 sparse outcome reward" 版本。Survey (Song 2026) 给出统一视角：OPD ≈ "KL-constrained RL with $\beta \to \infty$ 且 token-level reward 来自 teacher log-prob"。
7. 2025-2026 工业采用：Qwen3（off-policy + on-policy 两阶段蒸馏 small models）、DeepSeek-R1 distillation series（off-policy SFT 为主，但后续 follow-up 用 OPD）、Gemma 2/3、MiMo-V2、Kimi distill 系列。Thinking Machines (Murati 团队 2025) 把 OPD 包装成"便宜 RL 替代品"路线。
8. 三个最常考的 footgun：(a) Length inflation / truncation collapse——student rollout 越训越长，触发 truncation 后 gradient 偏置，validation 暴跌（Demystifying OPD 2026, arXiv 2604.08527）；(b) Reverse KL mode collapse——student 收敛到 teacher 单一模，生成多样性塌缩；(c) Teacher / student gap 太大：student 完全采不到 teacher 概率高的 region，OPD 信号近乎 0（"prefix teach, suffix fade" 现象，arXiv 2605.13643）。

§1 直觉：为什么需要 On-Policy Distillation

1.1　Knowledge Distillation 简史（Hinton → DistilBERT → MiniLLM → OPD）

蒸馏的核心思想从 2015 年没变过：用 teacher 的 soft label 训 student。但在 LLM autoregressive 生成上，这个思想有一个隐藏假设需要重新审视——训练时见到的 prefix 来自哪个分布。

关键演化：off-policy → on-policy 这一步是 LLM 蒸馏从"模仿数据集"升级成"模仿决策过程"的分水岭。

1.2　Forward KL vs Reverse KL：mode-covering vs mode-seeking

vanilla KD (Hinton) 用 forward KL：

$$D_{\text{KL}}(\pi_T \,\|\, \pi_\theta) = \sum_y \pi_T(y) \log \frac{\pi_T(y)}{\pi_\theta(y)}$$

期望在 $\pi_T$ 下取，只有 teacher 给高概率的地方贡献 loss。如果 $\pi_T(y) > 0$ 但 $\pi_\theta(y) = 0$，loss 爆炸 → student 被迫覆盖 teacher 的每一个 mode（mode-covering / mass-covering），即使有些 mode 对 student 来说不可达，结果是 student 把概率分散到很多 token 上，生成"安全但平庸"的回答。

MiniLLM 改用 reverse KL：

$$D_{\text{KL}}(\pi_\theta \,\|\, \pi_T) = \sum_y \pi_\theta(y) \log \frac{\pi_\theta(y)}{\pi_T(y)}$$

期望在 $\pi_\theta$ 下取，只有 student 自己采到的地方贡献 loss。如果 $\pi_T(y) = 0$ 但 $\pi_\theta(y) > 0$，loss 爆炸 → student 被迫避开 teacher 认为不可能的 token（mode-seeking / zero-forcing），结果 student 收敛到 teacher 的某一个高质量 mode 上，生成"sharp 且 coherent"的回答。

• forward KL 让 student 学一个 trimodal 平均的分布，每个 mode 都有概率但每个都不够 sharp
• reverse KL 让 student 锁定其中一个 mode（哪个 mode 由 init + sampling 决定），生成最自信、最贴近 teacher 决策的那条路径

对 LLM 生成任务这一般是好事——我们要的是"流畅、自信、正确"的输出，不是"平均、模糊、平庸"的输出。这也是 MiniLLM 第一个把 reverse KL 用到 LLM 蒸馏的关键洞察。

1.3　Exposure bias：off-policy 蒸馏的结构缺陷

考虑一个 autoregressive 生成任务，序列长度 $L$。off-policy 蒸馏（包括 SFT / vanilla KD / seq-level KD）训练时 prefix 来自 teacher 或 dataset；推理时 prefix 来自 student 自己。

假设单步错误率（student 与 teacher 在某个 prefix 上偏离的概率）为 $\epsilon$。off-policy 训练只在 teacher prefix 上"教过"student，所以推理时 student 一旦走错一步，后续步骤进入了训练中没见过的状态分布——student 的错误率不再是 $\epsilon$，而是 $\epsilon' > \epsilon$（甚至跳到 0.5+ 的随机水平）。

Bagnell 2010 在 imitation learning 上证明：off-policy 模仿的累积误差是 $O(L^2 \epsilon)$（compound error），而 on-policy 监督（如 DAgger）能把累积误差压到 $O(L \epsilon)$。这正是 OPD 在 LLM 上的理论动机——把训练 state 分布对齐到推理 state 分布。

Survey (Song & Zheng 2026 arXiv 2604.00626) 在 §3 复述了这个结果：

"off-policy distillation 的 exposure bias 随序列长度大约按平方放大；on-policy distillation 把累积误差线性化。"

这条理论保证是 OPD 在 long-CoT、agent、code 这些长序列 + 高复杂度任务上特别有效的根本原因。

1.4　Bit-rate 视角：dense teacher signal vs sparse RL reward

Thinking Machines blog (Lu 2025-10) 给了一个简洁的 information-theoretic 直觉：

换句话说，OPD 在每个 token 都"教" student 一整个分布，而 RL 只在序列末尾"教"一个数。在数学推理、code、long-form QA 这些需要 dense supervision 的任务上，OPD 的 sample efficiency 显著高于 RL。这也解释了为什么 Qwen3 / Thinking Machines 都报告 OPD 达到 RL 性能但 compute 降一个量级。

§2 OPD 的精确定义与核心公式

2.1　形式化定义

给定：

• prompt 分布 $D$（如 dataset 中 instruction 的分布）
• teacher policy $\pi_T$（固定 frozen，参数量 $\gg$ student）
• student policy $\pi_\theta$（可训练）

OPD 的目标函数（一般形式，from Survey arXiv 2604.00626 §2.1）：

$$\boxed{\;L_{\text{OPD}}(\theta) = \mathbb{E}_{x \sim D}\,\mathbb{E}_{y \sim \pi_\theta(\cdot|x)}\!\left[\sum_{t=1}^{|y|} D_f\!\big(\pi_\theta(\cdot|x, y_{

其中 $D_f$ 是某个 $f$-divergence，常见选择：

核心点：不管 $D_f$ 是哪个，期望下标必须包含 $y \sim \pi_\theta$——student 自己采，这是 "on-policy" 的定义。

2.2　Reverse KL 展开 + token-level loss

把 reverse KL 在每个 prefix $s_t = (x, y_{

$$D_{\text{KL}}\!\big(\pi_\theta(\cdot|s_t)\,\|\,\pi_T(\cdot|s_t)\big) = \sum_{v=1}^{V} \pi_\theta(v|s_t) \left[\log \pi_\theta(v|s_t) - \log \pi_T(v|s_t)\right]$$

这是完整 KL（"full-distribution" 形式），需要 teacher 在每个 prefix 上做一次 forward，得到整个 vocab 的 logits。计算成本：$O(B \cdot L \cdot V)$ 的 teacher forward + softmax。

实践中常用 "sampled-token" 近似——只在 student 实际采到的 token $v = y_t$ 上算：

$$\hat L_t = \log \pi_\theta(y_t|s_t) - \log \pi_T(y_t|s_t)$$

这是 reverse KL 的 single-sample Monte-Carlo 估计（$\mathbb{E}_{v \sim \pi_\theta}[\log \pi_\theta(v) - \log \pi_T(v)] \approx \log \pi_\theta(y_t) - \log \pi_T(y_t)$ when $y_t \sim \pi_\theta$）。这种形式称为 per-token reverse KL，是 Thinking Machines blog 与 Tinker cookbook 实现采用的版本。

• 完整 KL：信息密度高、方差小，但每步要 teacher 做一次 vocab-level forward（昂贵，尤其 teacher 大）
• Sampled-token KL：便宜（teacher 只算 $\log \pi_T(y_t)$ 一个数），但方差大；可以加 control variate baseline（见 §4.4）降方差

2.3　两种实现路线：full-vocab supervised KL vs REINFORCE

OPD 的"理论目标"是 student 在自己访问到的 state 分布 $\rho_{\pi_\theta}$ 上最小化 per-state KL：

$$L_{\text{OPD}}(\theta) = \mathbb{E}_{s \sim \rho_{\pi_\theta}}\!\left[D_{\text{KL}}\!\big(\pi_\theta(\cdot|s)\,\|\,\pi_T(\cdot|s)\big)\right]$$

但 $\theta$ 同时出现在 (a) 内层 KL 和 (b) state visitation $\rho_{\pi_\theta}$ 里。产业实现 选择把这两个 $\theta$-依赖解耦 —— 这才是 MiniLLM / GKD / Thinking Machines / Qwen3 真实做的事：

路线 A：Full-vocab supervised KL + stop-grad rollouts（教科书清晰路径，teacher full logits 可用时的最简形式）

把 rollout 当作"behavior policy"产生的数据（对 $\theta$ stop-grad），训练只反传 KL 内层：

$$\boxed{\;L_{\text{OPD}}^{\text{A}}(\theta) = \mathbb{E}_{s_t \sim \text{rollout}(\pi_{\theta^-})}\!\left[\sum_t \sum_{v \in V} \pi_\theta(v|s_t) \log\frac{\pi_\theta(v|s_t)}{\pi_T(v|s_t)}\right]\;}$$

这里 $\pi_{\theta^-}$ 表示 rollout 阶段对 $\theta$ stop-grad（与 PPO 的 old policy 同思路）；内层 full-vocab 求和直接可微，autograd 即可，不需要 REINFORCE。这是教程下方 §4.1 代码采用的形式。

路线 B：Sampled-token REINFORCE / importance-sampling estimator（Tinker 默认 / MiniLLM trajectory PG 形式）

Route B 需要先讲清两种不同的 gradient 计算，文献中经常混淆：

(B1) Fixed-state inner KL — 假设 prefix $s_t$ 给定，只对内层 $D_{\text{KL}}(\pi_\theta(\cdot|s_t)\,\|\,\pi_T(\cdot|s_t))$ 做 REINFORCE 估计： $$\nabla_\theta D_{\text{KL}}(s_t) = \mathbb{E}_{y_t \sim \pi_\theta(\cdot|s_t)}\!\big[\nabla_\theta \log \pi_\theta(y_t|s_t) \cdot G_t^{\text{detach}}\big],\quad G_t = \log\tfrac{\pi_\theta(y_t|s_t)}{\pi_T(y_t|s_t)}.$$ 这是 §4.4 vOPD estimator 的形式，与 trajectory 上的 state visitation 无关。

(B2) Trajectory objective with state visitation — 若要严格保留 $\rho_{\pi_\theta}$ 对 $\theta$ 的依赖，policy gradient 要求 return-to-go（未来所有 KL cost 的累加）作为 score-function 权重： $$\nabla_\theta\,\mathbb{E}_\tau\!\Big[\sum_t D_{\text{KL}}(s_t)\Big] = \mathbb{E}_\tau\!\Big[\sum_u \nabla_\theta \log\pi_\theta(a_u|s_u)\cdot \underbrace{\sum_{t \ge u} D_{\text{KL}}(s_t)^{\text{detach}}}_{\text{return-to-go}}\Big] + \mathbb{E}_\tau\!\Big[\sum_t \nabla_\theta D_{\text{KL}}(s_t)\Big].$$ 注意 score-function 权重不是同 token $G_t$，是后续所有 step 的 KL 之和。

统一的实践规则：

• Route A（教学清晰，§4.1）：full-vocab KL + stop-grad rollouts，直接 autograd，不需要 REINFORCE。零方差，但需要 teacher full logits。
• Route B1（§4.4 vOPD-style, Tinker / MiniLLM 默认）：sampled-token REINFORCE / IS estimator + control variate。期望等价于 A，方差更大但适配 sampled-token 接口、节约 teacher vocab memory、支持 black-box teacher。
• 不能对 sampled-token 的 $\log(\pi_\theta/\pi_T)$ 直接 .backward() —— 那是 pathwise gradient + 固定 sampled index，丢失 score-function 项，不是 reverse-KL gradient（既不是 MLE，也不是 KL 下降方向）

2.4　与 KL-constrained RL 的关系

考虑 RL with reverse-KL constraint（RLHF 标准目标）：

$$\max_\theta\, \mathbb{E}_{y \sim \pi_\theta}\!\big[R(x, y)\big] - \beta\, \mathbb{E}_{y \sim \pi_\theta}\!\big[D_{\text{KL}}(\pi_\theta \,\|\, \pi_{\text{ref}})\big]$$

OPD 是这个公式在 $R \equiv 0$（无外部 reward）且 $\pi_{\text{ref}} = \pi_T$（reference 换成 teacher）的特例：

$$\min_\theta\, \mathbb{E}_{y \sim \pi_\theta}\!\big[D_{\text{KL}}(\pi_\theta \,\|\, \pi_T)\big]$$

这意味着 OPD 是"纯 KL 项、teacher 当 reference"的 RLHF。从这个视角看 GRPO + KL 项等同于 OPD + GRPO 风格 group baseline；这就是为什么 Survey 把 OPD 归入 "KL-constrained RL 的特殊情况"，也是 §3 中我们能把 OPD 集成进 GRPO 的形式基础。

2.5　Forward KL 形式（"Sampled-Token OPD"）

某些工作（如 Qwen3 部分阶段、TRL GKD trainer）使用 forward KL on student samples：

$$L_{\text{OPD-fwd}}(\theta) = \mathbb{E}_{y \sim \pi_\theta}\!\left[\sum_t D_{\text{KL}}\!\big(\pi_T(\cdot|s_t)\,\|\,\pi_\theta(\cdot|s_t)\big)\right]$$

注意 sample 来自 $\pi_\theta$，但 KL 方向是 forward。展开为 token-level：

$$L_{\text{OPD-fwd}} = \mathbb{E}_{y \sim \pi_\theta}\!\left[\sum_t \sum_v \pi_T(v|s_t)\big(\log \pi_T(v|s_t) - \log \pi_\theta(v|s_t)\big)\right]$$

由于 $\theta$ 只出现在 $\log \pi_\theta$ 中，且不在期望下标里出现（虽然 $y \sim \pi_\theta$ 仍依赖 $\theta$，但 stop-gradient 处理后 forward 项的 $\theta$-依赖简化），训练就退化为对每个 student-visited prefix，对 teacher 分布做 cross-entropy——形式上是 soft-label cross-entropy on student rollouts。这是工程上最简单的 OPD 实现（不需要 REINFORCE / control variate），代价是丢掉了 reverse KL 的 mode-seeking 性质。

§3 OPD 与 DPO / GRPO / RLHF 的关系（统一视角）

3.1　全景对比表

• 与 SFT：OPD 在 student-rollout 上训（SFT 在 teacher/dataset 上训）
• 与 vanilla KD：OPD on-policy + reverse KL（vanilla KD off-policy + forward KL）
• 与 RL (PPO/GRPO)：OPD 用 teacher log-prob 当 dense reward（RL 用 RM 当 sparse reward）

3.2　OPD vs DPO

DPO (Rafailov 2023 NeurIPS, arXiv 2305.18290) 是 closed-form RLHF：把 KL-regularized RL 最优解代回 Bradley-Terry，消去 partition $\log Z$，得到 pairwise preference 损失：

$$L_{\text{DPO}}(\theta) = -\mathbb{E}_{(x, y_w, y_l)}\!\left[\log \sigma\!\big(\beta \log\frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - \beta \log\frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}\big)\right]$$

DPO 是 completely offline：无需 sampling、无 teacher、无 RM、无 critic，只要 preference pair。

两者可以叠加：先 DPO 对齐人类偏好，再 OPD 用更强的 teacher 压缩到小 student。Qwen3 / R1-Distill 的 production pipeline 都用类似套路。

3.3　OPD vs GRPO

GRPO (DeepSeekMath 2024, arXiv 2402.03300) 把 PPO 的 critic 换成组内归一化 advantage：

$$\hat A_i = \frac{r_i - \text{mean}(\mathbf r)}{\text{std}(\mathbf r)}, \quad r_i = R(x, y_i),\; i \in [1..G]$$

$$L_{\text{GRPO}}(\theta) = \mathbb{E}_x \frac{1}{G}\sum_i \frac{1}{|y_i|}\sum_t \min\!\big(\rho_t^i \hat A_i,\, \text{clip}(\rho_t^i, 1{-}\epsilon, 1{+}\epsilon) \hat A_i\big) - \beta\, D_{\text{KL}}(\pi_\theta \,\|\, \pi_{\text{ref}})$$

其中 $\rho_t^i = \pi_\theta / \pi_{\theta_{\text{old}}}$ 是重要性比。

OPD 与 GRPO 的关系：把 GRPO 的 sparse outcome reward $R(x, y_i)$ 替换成 per-token teacher KL reward $r_t^i = \log\pi_T(y_t^i|s_t^i) - \log\pi_\theta^{\text{old}}(y_t^i|s_t^i) = -\log\!\frac{\pi_\theta^{\text{old}}(y_t^i|s_t^i)}{\pi_T(y_t^i|s_t^i)}$（注意必须取 log-ratio，不是 LaTeX 容易误读成的 $-\log\pi_\theta/\pi_T$），且 reference $\pi_{\text{ref}} \leftarrow \pi_T$，GRPO loss 就退化为 OPD 的 policy-gradient 形式（见 §2.3）。

• outcome reward 来自 verifier（math 正确 / test pass）
• dense reward 来自 teacher per-token KL
• 总 reward $r_t = \alpha \cdot r_{\text{outcome}} \cdot \mathbb{1}[t = T] + (1-\alpha) \cdot r_{\text{teacher-KL}}$

这样既得到 outcome 的 task-aligned signal，又得到 teacher 的 dense supervision——是 Qwen3 / DeepSeek 系列 small-model 后训练的标配。

3.4　OPD vs vanilla RL distillation（R1-Distill）

DeepSeek-R1-Distill 系列（Qwen / Llama 1.5B-70B）用 off-policy distillation：

1. 用 R1 teacher 生成 800K reasoning trajectory（math + code + general）
2. 在小 student 上做 token-level cross-entropy SFT
3. 不做 on-policy rollout、不做 KL 信号

这是 hard-label seq-level KD（Kim & Rush 2016 的 LLM 版本），不是 OPD。R1-Distill 的成功主要靠 teacher trajectory 质量极高（R1 经过 RL 调教）+ 数据量大，结构上仍属 off-policy。

OPD 与 R1-Distill 是 互补关系：

• R1-Distill 的 trajectory 数据可以作为 OPD 的 init / SFT warm-start
• OPD 在 R1-Distill 之后跑一轮可以进一步消除 exposure bias

学术 / 工程上一般称这种组合为 "Off-policy SFT + On-policy distillation"，是 Qwen3 small-model recipe 的标准两阶段（见 §6.1）。

§4 实现：核心代码块

4.1　Per-token reverse KL（Route A，full-vocab 概念实现）

import torch
import torch.nn.functional as F


def per_token_reverse_kl_loss(
    student,        # student model, requires_grad
    teacher,        # teacher model, frozen
    input_ids,      # [B, L]  prompt + student rollout (rollout 在外部完成，stop_grad)
    action_mask,    # [B, L]  1 for student-generated tokens, 0 for prompt / pad
):
    """
    Route A — full-vocab per-token reverse KL on student rollouts (concept-clean form).
    要求 teacher full logits 可用。Route B (Tinker / MiniLLM 等生产默认) 期望等价但
    采 sampled-token + IS / REINFORCE estimator，参见 §2.3 callout 和 §4.4。

        L(θ) = E_{s_t ~ rollout(π_{θ⁻})} [ Σ_t D_KL(π_θ(·|s_t) || π_T(·|s_t)) ]
             = E_{s_t} [ Σ_t Σ_v  π_θ(v|s_t) · ( log π_θ(v|s_t) − log π_T(v|s_t) ) ]

    Rollout 已在外部用 stop_grad(θ) 完成（vLLM / TGI 把 input_ids 拿回来）；
    本函数 **只** 计算可微的 full-vocab KL，autograd 直接反传，**不需要 REINFORCE**。
    """
    # Student full-vocab log-probs (requires_grad on θ)
    s_logits = student(input_ids).logits                   # [B, L, V]
    s_log_probs = F.log_softmax(s_logits[:, :-1], dim=-1)  # [B, L-1, V]
    s_probs = s_log_probs.exp()                            # [B, L-1, V]

    # Teacher full-vocab log-probs (frozen, no grad)
    with torch.no_grad():
        t_logits = teacher(input_ids).logits
        t_log_probs = F.log_softmax(t_logits[:, :-1], dim=-1)  # [B, L-1, V]

    # Full-vocab reverse KL per state s_t: Σ_v π_θ(v) (log π_θ(v) − log π_T(v))
    kl_per_token = (s_probs * (s_log_probs - t_log_probs)).sum(dim=-1)  # [B, L-1]

    # Mask 到 student-generated 位置（prompt token 上算 KL 没意义）
    mask = action_mask[:, 1:].float()
    loss = (kl_per_token * mask).sum() / mask.sum().clamp_min(1.0)

    # 诊断：在 sampled 位置上 student 是否比 teacher 更"自信"（监控 over-confidence）
    with torch.no_grad():
        targets = input_ids[:, 1:].unsqueeze(-1)
        s_logp_t = s_log_probs.gather(-1, targets).squeeze(-1)
        t_logp_t = t_log_probs.gather(-1, targets).squeeze(-1)
        overconf_frac = ((s_logp_t > t_logp_t).float() * mask).sum() / mask.sum().clamp_min(1.0)
    return loss, {
        "full_vocab_kl": loss.item(),
        "overconf_frac": overconf_frac.item(),
    }

注意几个生产实现的细节：

• action_mask 必须只 mask student rollout 的 token；prompt 上算 KL 没意义（teacher 也只是 condition）
• teacher forward 用 torch.no_grad() 否则 memory 翻倍
• Full-vocab (Route A) vs sampled-token (Route B)：上面的 loss 是 Route A（求和 over $V$ 个 token，autograd 直接反传）。Route B（sampled-token + REINFORCE/IS，§4.4）是 Tinker / MiniLLM 等生产实现的默认形式，与 PPO/GRPO 共享 sampled-token 接口，支持 black-box teacher，A 与 B 期望等价。无论选哪条，不能对 sampled-token 的 log π_θ − log π_T 直接 .backward() —— 那等价于对固定 sampled index 取 pathwise $\nabla\log\pi_\theta(y_t)$，丢失了 score-function 项，既不是 reverse-KL 梯度，也不是 MLE。Route B 必须配 REINFORCE 估计器（detached reward + score-function trick）
• batched teacher inference 在生产里通常异步：先用 vLLM 起 teacher server，把 student rollout batch 发过去拿 log-probs；本地只跑 student forward + backward。这是 Tinker / vLLM-based 框架的标配
• mixed precision：student 用 bf16，teacher logits 用 fp32 算 log-softmax（防数值不稳）

共用辅助函数（贯穿 §4.2 - §4.6）

def per_token_logp(model, input_ids):
    """
    对每个位置返回 log π(y_{t+1}|s_t)。形状 [B, L-1]。grad 由 caller 决定
    （想要 grad: 直接调；想要 detached behavior log-prob: 包 with torch.no_grad()）。
    """
    logits = model(input_ids).logits[:, :-1]                     # [B, L-1, V]
    log_probs = F.log_softmax(logits, dim=-1)
    targets = input_ids[:, 1:].unsqueeze(-1)                     # [B, L-1, 1]
    return log_probs.gather(-1, targets).squeeze(-1)             # [B, L-1]


def teacher_kl_reward(student, teacher, input_ids, action_mask):
    """
    OPD-GRPO 中作为 dense token reward 的 teacher-vs-behavior KL：
        r_t = log π_T(y_t|s_t) - log π_θ_old(y_t|s_t)
    输入 action_mask 形状 [B, L]（同 input_ids），内部 shift 到 [B, L-1]。
    全程 no_grad，返回每轨迹的标量 reward（sum over generated tokens）。
    """
    with torch.no_grad():
        s_old = per_token_logp(student, input_ids)               # [B, L-1]
        t_lp  = per_token_logp(teacher, input_ids)               # [B, L-1]
        token_mask = action_mask[:, 1:].float()                  # 对齐到 [B, L-1]
        per_tok = (t_lp - s_old) * token_mask
    return per_tok.sum(dim=-1)                                   # [B]

4.2　完整 OPD 训练循环（带 student rollout）

@torch.no_grad()
def student_rollout(student, prompts, max_new_tokens=512, temperature=1.0):
    """student 自己采 trajectory（on-policy 关键步骤）"""
    out = student.generate(
        prompts.input_ids,
        attention_mask=prompts.attention_mask,
        max_new_tokens=max_new_tokens,
        do_sample=True,
        temperature=temperature,
        return_dict_in_generate=True,
    )
    full_ids = out.sequences           # [B, L_prompt + L_gen]
    prompt_len = prompts.input_ids.shape[1]
    action_mask = torch.zeros_like(full_ids)
    action_mask[:, prompt_len:] = 1
    # mask out pad
    action_mask = action_mask * (full_ids != student.config.pad_token_id).long()
    return full_ids, action_mask


def opd_train_step(student, teacher, optimizer, batch, kl_coef=1.0):
    """one step of OPD: sample rollout, compute teacher KL, update student"""
    # 1. student samples (on-policy)
    input_ids, action_mask = student_rollout(student, batch.prompts)

    # 2. compute per-token reverse KL with teacher
    loss, stats = per_token_reverse_kl_loss(
        student, teacher, input_ids, action_mask
    )

    # 3. backward
    optimizer.zero_grad()
    (kl_coef * loss).backward()
    torch.nn.utils.clip_grad_norm_(student.parameters(), max_norm=1.0)
    optimizer.step()
    return stats

这是 OPD 最朴素的训练循环。生产里会在第 2 步加 advantage / baseline / clipping（见 §4.4）；在第 1 步加 group sampling（GRPO 风格，见 §4.5）。

4.3　Off-policy KD vs OPD 的对比代码（差一行）

# ── Off-policy KD (vanilla, Hinton-style) ──
def off_policy_kd_loss(student, teacher_outputs, dataset_y):
    """
    teacher_outputs 在 dataset_y 上 forward
    student 也在 dataset_y 上 forward
    forward KL: teacher → student
    """
    s_logits = student(dataset_y).logits
    t_logits = teacher_outputs                 # 已经预算
    return F.kl_div(
        F.log_softmax(s_logits, dim=-1),
        F.softmax(t_logits, dim=-1),
        reduction="batchmean",
    )


# ── On-Policy Distillation (OPD) ──
def opd_loss(student, teacher, prompts):
    student_y, mask = student_rollout(student, prompts)         # ← 关键差异：student 自己采
    loss, _ = per_token_reverse_kl_loss(student, teacher, student_y, mask)
    return loss

唯一关键差异：OPD 在自己 sample 的 trajectory 上算 loss；off-policy 在 dataset / teacher trajectory 上算。代码上只差一个 student_rollout 调用，但训练分布与推理分布对齐这件事的整体收益巨大。

4.4　Control Variate Baseline（vOPD 风格的 token-level KL）

注：vOPD（"KL for a KL"）的 control-variate 思想是 OPD 文献里反复出现的模式（Survey 2026 / Tinker blog 等都有等价讨论），下面给出正确的 detach + sign + estimator 形式。

REINFORCE 形式的 sampled-token estimator：对单个 sampled token $y_t \sim \pi_\theta(\cdot|s_t)$，无偏估计反向 KL 的 gradient 是

$$\nabla_\theta D_{\text{KL}}(\pi_\theta\,\Vert\,\pi_T)(s_t) = \mathbb{E}_{y_t \sim \pi_\theta}\!\big[\,\nabla_\theta \log \pi_\theta(y_t|s_t) \cdot \underbrace{(\log \pi_\theta(y_t|s_t) - \log \pi_T(y_t|s_t))}_{\hat r_t,\;\textbf{detached}}\,\big].$$

注意 $\hat r_t$ 出现的位置只是 scalar reward（必须 detach），梯度仅来自外面那个 $\nabla_\theta \log\pi_\theta$。Control variate 减方差：

$$\hat r_t \leftarrow \hat r_t - B(s_t),\quad B(s_t) = \mathbb{E}_{y_t \sim \pi_\theta}[\hat r_t] = D_{\text{KL}}(\pi_\theta\,\Vert\,\pi_T)(s_t).$$

$B(s_t)$ 是该 step 整 vocab 的 KL（正号），可从 student forward 闭式算出。它的 detached value 不改变 estimator 的 unbiasedness（因为 $\mathbb{E}_{y_t}[\nabla \log\pi_\theta \cdot B(s_t)] = B(s_t)\cdot \mathbb{E}[\nabla\log\pi_\theta] = 0$），但显著降低方差。

def vopd_token_kl_estimator(student, teacher, input_ids, action_mask):
    """
    Sampled-token REINFORCE estimator of ∇_θ D_KL(π_θ || π_T) with closed-form baseline.

    返回 surrogate loss L_surr，其 ∇L_surr 在期望意义下 = ∇ E[D_KL]。注意 L_surr 本身
    不是 D_KL 的数值估计 —— diagnostic 请用 full-vocab D_KL。
    """
    s_logits = student(input_ids).logits[:, :-1]                    # [B, L-1, V]
    s_log_probs = F.log_softmax(s_logits, dim=-1)
    s_probs     = s_log_probs.exp()
    with torch.no_grad():
        t_logits = teacher(input_ids).logits[:, :-1]
        t_log_probs = F.log_softmax(t_logits, dim=-1)

    targets = input_ids[:, 1:].unsqueeze(-1)                        # [B, L-1, 1]
    s_logp_t = s_log_probs.gather(-1, targets).squeeze(-1)          # grad-aware: log π_θ(y_t|s_t)

    # ── reward signal (must detach: scalar weight, not part of grad path) ──
    with torch.no_grad():
        t_logp_t = t_log_probs.gather(-1, targets).squeeze(-1)
        r_hat    = s_logp_t.detach() - t_logp_t                     # scalar per token

        # closed-form baseline B(s_t) = D_KL(π_θ || π_T)(s_t), full vocab
        baseline = (s_probs.detach() * (s_log_probs.detach() - t_log_probs)).sum(-1)
        advantage = r_hat - baseline                                # both detached

    # ── REINFORCE-style surrogate: ∇ = E[ ∇log π_θ(y_t|s_t) · advantage_detached ] = +∇D_KL ──
    mask = action_mask[:, 1:].float()
    surrogate = (s_logp_t * advantage * mask).sum() / mask.sum().clamp_min(1.0)
    #            ↑ 注意符号：advantage = (logπ_θ − logπ_T) − B 是 KL cost。要 minimize D_KL，
    #            optimizer step 是 θ ← θ − η·∇L_surr，而 ∇L_surr = +E[∇logπ·advantage] = +∇D_KL，
    #            所以 surrogate **正号**，treat surrogate as the loss to .backward().

    # diagnostic（不进 grad）：监控真正的 full-vocab KL
    with torch.no_grad():
        full_kl = (baseline * mask).sum() / mask.sum().clamp_min(1.0)
    return surrogate, {"full_vocab_kl_diag": full_kl.item()}

4.5　OPD 集成进 GRPO（multi-sample group baseline）

GRPO 的 ratio 是 new student policy vs old behavior student policy（rollout 时记录 s_logp_old，update 时算 s_logp_new），teacher 进入两个独立位置：(i) reward 通过 token-level KL reward $r_t^{\text{kl}} = \log\pi_T(y_t|s_t) - \log\pi_\theta^{\text{old}}(y_t|s_t)$（dense token reward 形式），与 outcome reward 加权得到总 reward；(ii) KL regularization 通过 $D_{\text{KL}}(\pi_\theta\,\Vert\,\pi_T)$ 显式约束 student 不偏离 teacher。Teacher 绝不进入 PPO ratio 的分母。

def opd_grpo_step(student, teacher, batch, G=8, alpha=0.5, kl_coef=0.1, clip=0.2):
    """
    OPD + GRPO hybrid（per-prompt group baseline）:
      - 对每个 prompt sample G 条 rollout，记录 behavior-policy log-prob
      - reward = α * outcome_reward + (1-α) * sum_t [log π_T(y_t|s_t) - log π_θ_old(y_t|s_t)]
      - GRPO group-relative advantage（组内归一化）
      - ratio = exp(s_logp_new - s_logp_old.detach())  ← 关键
      - KL penalty 项用 student vs teacher（不是 PPO ratio）

    Shape conventions:
      input_ids / action_mask:   [B, L]   (prompt + generated)
      per_token_logp output:     [B, L-1] (predict y_{t+1} from prefix up to t)
      token_mask = action_mask[:, 1:]：与 per-token logp 对齐
    """
    ids_all, action_mask_all, s_old_all, adv_all = [], [], [], []

    for prompt in batch.prompts:
        rollouts = []
        for _ in range(G):
            ids, action_mask = student_rollout(student, prompt)    # [B', L]; B'=1 for single prompt
            with torch.no_grad():
                s_old = per_token_logp(student, ids)               # [B', L-1] behavior log-prob
                t_lp  = per_token_logp(teacher, ids)               # [B', L-1]
            rollouts.append((ids, action_mask, s_old, t_lp))

        # 组内 G 条 rollout 的总 reward
        rewards = []
        for (ids, action_mask, s_old, t_lp) in rollouts:
            r_outcome = math_verifier(ids)                         # 标量 ∈ {0,1}
            token_mask = action_mask[:, 1:].float()                # [B', L-1]
            r_kl_dense = ((t_lp - s_old) * token_mask).sum().item()
            r_total = alpha * r_outcome + (1.0 - alpha) * r_kl_dense
            rewards.append(r_total)
        # 保证与 s_old / s_logp_new 同 device/dtype，避免 CPU/GPU mismatch
        rewards = torch.tensor(rewards, device=s_old.device, dtype=s_old.dtype)
        adv_per_traj = (rewards - rewards.mean()) / (rewards.std() + 1e-8)  # [G]

        for i, (ids, action_mask, s_old, _t_lp) in enumerate(rollouts):
            ids_all.append(ids); action_mask_all.append(action_mask)
            s_old_all.append(s_old)
            adv_all.append(adv_per_traj[i].view(1, 1).expand_as(s_old))     # broadcast 到 [B', L-1]

    ids         = torch.cat(ids_all, dim=0)                                  # [BG, L]
    action_mask = torch.cat(action_mask_all, dim=0)                          # [BG, L]
    token_mask  = action_mask[:, 1:].float()                                 # [BG, L-1]
    s_logp_old  = torch.cat(s_old_all, dim=0).detach()                       # [BG, L-1]
    A           = torch.cat(adv_all, dim=0).detach()                         # [BG, L-1]

    # ── new student log-prob（这步带 grad） ──
    s_logp_new = per_token_logp(student, ids)                                # [BG, L-1]

    # ── PPO clipped ratio: new student vs old student（不是 student vs teacher） ──
    ratio = torch.exp(s_logp_new - s_logp_old)
    pg = torch.min(ratio * A, torch.clamp(ratio, 1 - clip, 1 + clip) * A)
    pg_loss = -(pg * token_mask).sum() / token_mask.sum().clamp_min(1.0)

    # ── KL penalty: student vs teacher（OPD 的 reverse KL，full-vocab 闭式） ──
    # 传 [B, L] action_mask 进去；§4.1 内部自己 shift 到 [B, L-1]
    kl_loss, _ = per_token_reverse_kl_loss(student, teacher, ids, action_mask)

    return pg_loss + kl_coef * kl_loss

实战 tip：alpha = 0.5 是经验起点；alpha → 1 退化为 pure GRPO（outcome only），alpha → 0 退化为 pure OPD（KL only）。Qwen3 / R1-Distill 类 recipe 通常 stage-wise 调度：早期 alpha 小（先把 student 拉近 teacher），后期 alpha 大（拼 outcome SOTA）。

4.6　Synthetic-data + distillation pipeline（顶层伪代码）

def synthetic_distillation_pipeline(
    teacher,             # 大 teacher（如 R1-671B / Qwen3-32B）
    student,             # 小 student（如 Qwen3-8B-Base）
    prompt_pool,         # 海量 prompt（可以用 unlabeled instruction）
    n_stage1=800_000,    # off-policy SFT 数据量
    n_stage2_steps=5_000,
    n_stage3_steps=1_000,
    verifiable_prompts=None,
):
    # ─── Stage 1: 用 teacher 生成 synthetic trajectory，做 off-policy SFT ───
    synthetic_data = []
    for prompt in random_sample(prompt_pool, n_stage1):           # placeholder sampler
        with torch.no_grad():
            y_teacher = teacher.generate(prompt, max_new_tokens=4096)
        synthetic_data.append((prompt, y_teacher))
    run_sft(student, synthetic_data, epochs=2)                    # cross-entropy on (prompt, y_teacher)

    # ─── Stage 2: 在 student 自己 rollout 上做 OPD ───
    optimizer = torch.optim.AdamW(student.parameters(), lr=1e-5)
    for step in range(n_stage2_steps):
        batch = make_batch(prompt_pool, batch_size=64)
        opd_train_step(student, teacher, optimizer, batch, kl_coef=1.0)

    # ─── Stage 3 (optional): OPD + outcome reward (math/code verifier) ───
    if verifiable_prompts is not None:
        for step in range(n_stage3_steps):
            batch = make_batch(verifiable_prompts, batch_size=64)
            loss  = opd_grpo_step(student, teacher, batch, G=8, alpha=0.5)
            optimizer.zero_grad(); loss.backward(); optimizer.step()

    return student

这是 Qwen3 / R1-Distill / Thinking Machines 类似 recipe 的标准三段式。Stage 1 给 cold start（student 学会模仿 teacher 的 style 与 format），Stage 2 用 OPD 把 exposure bias 消掉，Stage 3 用 verifier 做 task-aligned 微调。

§5 OPD 在 Knowledge Distillation 谱系中的位置

5.1　LLM 蒸馏方法谱系（从 Hinton 到 OPD）

   2015 ─────────── 2019 ─────── 2023 ────── 2024 ─────── 2025/2026
   Hinton          DistilBERT   MiniLLM     GKD          Thinking
   soft target     (Sanh)       (Gu)        (Agarwal)    Machines
                                                          blog
     │              │            │            │            │
     ↓              ↓            ↓            ↓            ↓
   分类             encoder-     LLM 首次     generalized   "便宜 RL"
   forward KL      level KD     reverse KL   JSD + mix     范式 + 大规模
                                + on-policy  on/off        实证（Qwen3/
                                              policy        Gemma/Kimi）

核心演化方向：

• off-policy → on-policy（处理 exposure bias）
• forward KL → reverse KL / JSD（处理 mode-covering）
• hard label → soft logit（保留 dark knowledge）
• single-stage → multi-stage hybrid（off-policy SFT cold start + on-policy OPD + outcome RL）

5.2　关键 paper 一句话索引

5.3　OPD 在 Reasoning Model 蒸馏中的位置（R1-Distill 时代）

reasoning model 蒸馏的两条主线：

何时用哪个：

• 如果 teacher trajectory 质量极高、student 与 teacher capability gap 不大 → off-policy SFT 已经够
• 如果 student 比 teacher 小很多（>5×）、任务长 horizon、对推理时分布敏感 → OPD 是更稳的选择
• 实战通常两者叠加：先 off-policy SFT 给 cold start，再 OPD 消 exposure bias

§6 工程案例：OPD 在生产里怎么用

6.1　Qwen3 Recipe（arXiv 2505.09388 §3.2）

Qwen3 small models（1.7B / 4B / 8B）的 post-training 采用两阶段蒸馏：

Qwen3-235B (teacher, /think + /no_think 双模)
    │
    │ Stage 1: Off-policy distillation
    │   - teacher 生成 trajectory（/think 与 /no_think 混合）
    │   - student SFT on teacher trajectory (cross-entropy)
    │   - 目的：basic reasoning + mode switching
    ↓
Qwen3-8B-mid
    │
    │ Stage 2: On-policy distillation (OPD)
    │   - student 自己 sample → teacher 给 per-token logit
    │   - per-token reverse KL loss
    │   - 目的：消 exposure bias + 拉 reasoning depth
    ↓
Qwen3-8B-final

报告结果：

• 比纯 RL 节省 ~10× GPU 时长
• 在 AIME'24 / AIME'25 上 pass@64 显著提升（说明 OPD 没塌缩 diversity）
• 比 off-policy SFT 在 long-CoT 任务上 +3-5pp

6.2　Thinking Machines Blog（Lu 2025-10-27）

实验 setting：

• Student: Qwen3-8B-Base
• Teacher: Qwen3-32B
• Task: 数学推理（AIME'24 主 benchmark）
• Init: 先用 OpenThoughts 数据 SFT 一轮
• OPD: 用 Tinker 实现，per-token reverse KL，无 outcome reward

报告结果（blog 内容）：

• 用 OPD 训 Qwen3-8B-Base 达到与 RL 几乎相同的 AIME'24 性能
• 总 FLOPs 节省约 9-30×，取决于 batch / lr 设置
• 强调 "OPD 是 RL 的便宜替代品"，不是 RL 的补充

6.3　Tinker Cookbook 实现细节

GitHub: thinking-machines-lab/tinker-cookbook/tree/main/tinker_cookbook/recipes/distillation

关键设计：

• Environment 设计为 no-reward：唯一 supervision 是 teacher KL
• Reverse KL 实现：(student_logp - teacher_logp) * mask
• Advantage 计算：把 KL 当 negative reward 加进 advantage（advantage = -kl_penalty_coef * reverse_kl）
• LoRA: rank 128 + lr 1e-4
• Batch: groups_per_batch = 64（GRPO 风格 grouping）

这种"把 KL 当 reward 注入 advantage"的设计正好对应 §3.3 的 OPD-GRPO 等价：把 sparse outcome reward 替换成 dense teacher KL reward。

6.4　DeepSeek-V4 报告（multi-teacher OPD 替代 RL）

DeepSeek-V4 在 model consolidation 阶段完全用 multi-teacher OPD 替代 mixed RL——多个 teacher（specialized：math / code / reasoning / chat）的 logits 加权 ensemble 作为 student 的 OPD target。这是 OPD 范式扩展到 multi-teacher 与 specialist consolidation 的代表案例。

6.5　Black-Box OPD（不需要 teacher logits）

arXiv 2511.10643 "Black-Box On-Policy Distillation"：当 teacher 是 closed-source API（如 GPT-4 / Claude）只能 sample 不能拿 logit 时怎么做 OPD？

核心思路：用 teacher samples 做 trajectory-level reward，组合 token-level student log-prob 做近似 reverse KL。这把 OPD 从"需要 teacher logit"扩展到"只需 teacher API"。trade-off 是丢掉了 per-token dense supervision，回退到 trajectory-level reward——本质上是 OPD 与 RL 之间的混合体。

§7 失败模式与缓解策略

7.1　Truncation Collapse / Length Inflation

现象（Demystifying OPD 2026, arXiv 2604.08527）：训练中 student rollout 平均长度持续增长，最终撞 max_length truncation，被 truncate 的轨迹贡献了大部分梯度（因为它们 token 多），造成 gradient bias，validation 性能崩盘。

根本原因：reverse KL 的 mode-seeking 性质让 student 倾向于"持续输出 teacher 高概率 token"，而 teacher 在 long-CoT 上本来就喜欢长输出。这是一个正反馈循环。

缓解：

• Length normalization：loss 除以 trajectory length（per-token average，不是 sum）——这是 Tinker / 大多数生产实现的默认
• Length penalty：在 reward 里加 $-\lambda \cdot L$ 抑制超长
• Max-length 比 sample max-length 大很多：避免 truncation 进入训练
• Early stop on val loss spike：检测到 val 暴跌马上停

7.2　Mode Collapse / Diversity Loss

现象：reverse KL 是 mode-seeking 的，理论上 student 应该锁定到 teacher 的一个 mode；但在某些任务（如 open-ended generation）上 student 收敛到单一回答 template，丢掉多样性，pass@N（$N > 1$）下降。

缓解：

• 使用 forward KL / JSD 替代 reverse KL（GKD 的 $\beta$ 插值）
• 加 entropy bonus（类似 PPO）
• Mixed loss：reverse KL × $\alpha$ + forward KL × $(1-\alpha)$
• MiniLLM 的 stabilization trick：mixed policy $\pi_{\text{mix}} = (1-\alpha)\pi_\theta + \alpha\pi_T$ with $\alpha = 0.2$ 防止 mode collapse early

7.3　Reward Hacking（teacher-game）

现象：student 学到一种 hack——输出一些 teacher 概率高但语义垃圾 的 token（如 stopword 序列、重复 phrase），KL loss 极低但 task 性能差。

缓解：

• 混合 outcome reward（§4.5 的 OPD-GRPO hybrid）
• Trajectory-level filter：过滤掉 teacher 都不高概率的 trajectory（"teacher-improbable filter"）
• Token diversity regularizer：penalize token entropy 过低

7.4　Prefix Teach, Suffix Fade（local teachability collapse）

arXiv 2605.13643 报告：训练后期，teacher 在 trajectory 后半段几乎"没东西可教"了——student 与 teacher 在 suffix 上的 log-prob 已经接近，loss 几乎全部来自 prefix。这导致 long-CoT 任务的后半推理段质量低。

缓解：

• Token-level importance weighting：对 suffix token 加权
• Teacher 升级：用更强的 teacher（多 teacher ensemble / 不同任务 specialist）
• Curriculum：先短 trajectory，后逐步增 max_length

7.5　Teacher / Student Gap 太大

现象：student 比 teacher 小很多（如 1B vs 70B）时，student 的 sample 完全采不到 teacher 概率高的 region，OPD 信号近乎 0（"student visits states teacher never thought of"）。

缓解：

• off-policy SFT warm start：先让 student 模仿 teacher 一段时间，状态分布拉近后再 OPD
• Temperature scheduling：训练初期 student temperature 高，扩大探索；后期降到 1.0
• 使用更接近的 teacher：teacher 与 student gap 控制在 4-8×（Qwen3 选 32B teacher → 8B student 是这种考虑）

7.6　Catastrophic Forgetting（旧能力丢失）

现象：OPD 主要在数学 / 推理上训，但 student 通用能力（chat / safety / instruction-following）下降。

缓解：

• Replay buffer：保留一部分通用 SFT 数据，按比例混进 OPD 训练
• Regularization to SFT init：加 $\beta \cdot D_{\text{KL}}(\pi_\theta \,\|\, \pi_{\text{SFT-init}})$ penalty
• Multi-task OPD：同时蒸馏多个领域的 teacher（math + chat + code）

§8 复杂度与资源

8.1　每步训练成本对比

OPD 的额外开销主要来自：(1) student rollout（sampling 比 forward 慢，因 KV cache 累计）；(2) teacher forward（teacher 大）。但相比 RL，OPD 不需要 reward model 训练 + RM forward，所以总成本通常小于纯 RL pipeline。

8.2　显存

降显存技巧：

• Teacher 用 separate inference server（vLLM）跑，student 训练机不存 teacher weight
• Teacher 用 fp8 / int8 quantization（teacher 只 forward 不反传，精度损失小）
• Student 用 LoRA（rank 128）+ teacher 完整 weight
• Async teacher inference：student 训第 $N$ batch 时，teacher server 在算第 $N+1$ batch

8.3　Sample Efficiency

Thinking Machines blog 的核心数据点：

OPD 在同等准确率下 sample efficient 约 9-30×——这是 OPD 火起来的核心数字。

§9 与相关方法的对比与定位

9.1　大表（cheat sheet 主考点）

9.2　决策树：什么场景选什么方法

有 strong teacher 模型吗？
├── 否
│   ├── 有 preference dataset → DPO
│   ├── 有 verifier (math/code) → GRPO
│   └── 有 RM → PPO RLHF
└── 是
    ├── teacher 与 student gap 小 (< 4×) → off-policy SFT KD 就够
    ├── gap 中等 (4-10×) + long CoT 任务 → OPD（首选）
    ├── gap 大 (> 10×) + 复杂任务 → off-policy SFT warm start + OPD
    ├── 同时有 verifier → OPD + GRPO hybrid（生产标配）
    └── teacher 只能 API call → Black-Box OPD

§10 25 高频面试题

L1 必会（10 题，post-training 工程师 / LLM RL 岗）

L2 进阶（10 题，资深 post-training / 论文复现）

L3 顶级 lab（5 题，研究 / 算法 lead）

§A 附录

A.1　Sanity-check：用 OPD 收敛性检验你的实现

实现 OPD 后，做这三个 micro-test 确认 loss 正确：

# Test 1: student == teacher → loss should be ~0
student.load_state_dict(teacher.state_dict())
loss, _ = per_token_reverse_kl_loss(student, teacher, ids, mask)
assert abs(loss.item()) < 1e-4, f"identical model should give zero KL, got {loss}"

# Test 2: student random init → loss > 0
student = init_random_model(...)
loss, _ = per_token_reverse_kl_loss(student, teacher, ids, mask)
assert loss.item() > 0.5, f"random student should give positive KL, got {loss}"

# Test 3: loss should decrease over training
losses = []
for step in range(100):
    loss = opd_train_step(student, teacher, ...)
    losses.append(loss)
assert losses[-1] < losses[0], "OPD should reduce KL over training"

A.2　常见错误与正确做法

A.3　核心 paper 与资源列表

核心 OPD paper：

• MiniLLM (Gu et al. 2023, ICLR 2024) — arXiv 2306.08543
• GKD: On-Policy Distillation of Language Models (Agarwal et al. 2023, ICLR 2024) — arXiv 2306.13649
• A Survey of On-Policy Distillation for LLMs (Song & Zheng 2026) — arXiv 2604.00626
• Rethinking On-Policy Distillation (2026) — arXiv 2604.13016
• KL for a KL (vOPD, 2026) — arXiv 2605.07865
• Black-Box On-Policy Distillation (2026) — arXiv 2511.10643
• Decoupling KL and Trajectories (2026) — arXiv 2605.16826

工业 tech report：

• Qwen3 Technical Report (Qwen Team 2025-05) — arXiv 2505.09388 (§3.2 OPD recipe)
• DeepSeek-R1 (DeepSeek 2025-01) — arXiv 2501.12948 (off-policy distillation series)

Blog / 代码：

• Thinking Machines Lab — "On-Policy Distillation" blog (Lu et al. 2025-10-27) — thinkingmachines.ai/blog/on-policy-distillation/
• Tinker Cookbook — github.com/thinking-machines-lab/tinker-cookbook/tree/main/tinker_cookbook/recipes/distillation
• TRL GKD Trainer — huggingface.co/docs/trl/gkd_trainer
• Awesome OPD list — github.com/thinkwee/AwesomeOPD, github.com/nick7nlp/Awesome-LLM-On-Policy-Distillation

相关基础：

• Hinton, Vinyals, Dean — "Distilling the Knowledge in a Neural Network" (2015) — arXiv 1503.02531
• Sanh et al. — "DistilBERT" (2019) — arXiv 1910.01108
• Kim & Rush — "Sequence-Level Knowledge Distillation" (EMNLP 2016) — arXiv 1606.07947
• Bagnell — "Reinforcement Learning and Imitation Learning" (theoretical foundation for exposure bias)
• DeepSeekMath GRPO (2024) — arXiv 2402.03300
• DPO (Rafailov et al. NeurIPS 2023) — arXiv 2305.18290

A.4　[needs-verify] 标记一览

本 cheat sheet 中下列内容标记为 [needs-verify]，建议在面试前后查原始 paper / tech report 确认：

1. L3-2 "OPD 超越 teacher"：Rethinking OPD (arXiv 2604.13016) 报告的具体 setting 与 magnitude
2. L3-3 DeepSeek-V4 multi-teacher OPD 实现细节：weight 选择策略、是否 token-level routing
3. L3-4 "OPD + PRM 融合"：截至 2026-05 active research，尚无单一权威 paper 整合两者
4. §6.2 Thinking Machines 数据："9-30× FLOPs 节省" 来自 blog secondary source，原 blog 数字与具体 setting 应核对
5. §5.2 timeline：2025-2026 多篇 OPD-related arXiv paper 编号（如 2604.* 系列）来自 2026 Q1-Q2 投稿/预印本，部分 ID 可能在投稿后更新版本号或重排
6. OPD 在 Qwen3 / Gemma 2 / MiMo 上的具体采用细节：多数信息来自 Thinking Machines blog 与 Qwen3 paper §3.2，但 Gemma 2 / MiMo 的 distillation 部分细节需查各自 tech report

A.5　术语速查表