正则化

0. 本章导读

第 14 章是病理学：奖励模型是真实人类偏好的代理，优化器只要跑得够久，一定会找到那个「奖励很高但人类看了想吐」的角落——回复越写越长、满屏 emoji、中英文乱切、推理过程写得头头是道但答案离谱、或者干脆开始输出重复的特殊字符。这就是过优化（over-optimization）。

第 15 章是药理学：既然优化器一定会往那边跑，我们手上有哪些工具能把它拽住？本章把这些工具从最核心的一件（到参考策略的 KL 惩罚）铺开到最外围的一圈（预训练梯度混合、margin loss、熵正则、权重平均），并且——这是本章真正值钱的地方——告诉你哪些是必需品，哪些只是某篇论文为了让实验跑通而临时搭的脚手架，下一代模型出来就被拆掉了。

但本章不止讲「显式加什么惩罚项」。它还有一条更深的线索：优化器本身就有形状。SFT 的损失函数在数学上恰好等价于最小化一个前向 KL（forward KL），而带 KL 惩罚的 RL 目标恰好等价于最小化一个反向 KL（reverse KL）。这两个方向的数值行为完全不同——一个求覆盖（mass-covering），一个求聚焦（mode-seeking）——而这个差异直接解释了 2025–2026 年后训练社区最重要的一批实证结论：SFT 会记忆并遗忘，RL 会泛化并保留。也就是说，on-policy 的 RL 自带一层隐式正则化，就算你把 $\beta$ 设成 0、把参考模型从显存里删掉，它依然比 SFT 更不容易破坏模型原有的能力。

本章要回答的具体问题：

• KL 惩罚到底加在奖励里还是损失里？两种写法的梯度一样吗？
• 实践中的 KL 是估计出来的。$k_1 / k_2 / k_3$ 三种估计器分别是什么、偏差和方差怎么权衡、为什么现在的开源实现清一色默认 $k_3$。
• 系数 $\beta$（有时写作 $\lambda_{\text{KL}}$）的量级怎么定？为什么最早的 RLHF 论文用的是一个反馈控制器而不是常数？为什么现在又转回常数了？
• 参考模型该选谁、要不要中途更新、它在工程上要付出多少显存和算力？
• KL 之外还有什么：预训练梯度混合、DPO+NLL、Llama 2 的 margin loss、熵正则、权重平均 / model soup。
• 2026 年发生了什么变化：为什么前沿的 agentic 配方在删掉 KL 惩罚，同时又在别的地方加回约束。

1. 病与药：为什么必须约束「别离参考策略太远」

优化器不会自己停下来

回顾一下 RLHF 那个循环在干什么：从 prompt 集合里采一批 $x$，用当前策略 $\pi_\theta$ 生成回复 $y$，用奖励模型 $r_\theta$ 给 $(x, y)$ 打分，然后做策略梯度更新，让高分回复的概率上升。这个循环唯一的目标函数是

问题在于 $r_\theta$ 不是真实的人类偏好，它只是一个在有限偏好数据上拟合出来的代理（proxy）。真实偏好和代理在训练数据分布附近是吻合的，但一旦策略跑到分布外，代理的行为就完全没有保证了——它可能给一段乱码打出 8 分，因为它从没见过乱码，只见过「长的、格式漂亮的回复分数高」，而那段乱码恰好长且有 markdown 标题。

于是发生的事情是可预测的：优化器忠实地执行你写下的目标，一路爬到代理奖励的最高点，而那个点在真实偏好上可能比起点还差。第 14 章已经把这条曲线画出来了——代理奖励单调上升，真实奖励先升后降，两条线在某个 KL 预算处分道扬镳。

过优化在文本上长什么样

原文列了几种典型的「优化脱轨」形态——这些是你在曲线之外、真正去读 rollout 样本时会看到的东西：输出彻底不成句（大段重复、特殊字符堆积）、语言漂移（中途切换语种）、形似而神非的推理（步骤读起来完全通顺、格式规范，但答案错得离谱——这是最危险的一种，因为它能骗过格式类奖励和相当一部分人类标注员）、以及长度膨胀（几乎所有 RLHF 配方的默认失败模式，也是最好检测的一个）。

这些现象的共同点是：模型跑到了一个参考策略几乎不会生成的文本区域。所以最直接的药方也就呼之欲出了——在奖励里减掉一项，直接度量「你现在生成的东西，参考模型觉得有多离谱」。

通用形式

本章所有方法都可以套进同一个模板：

其中 $r_\theta$ 是任务信号（奖励模型打分，或者 RLVR 里的可验证奖励），$r_{\text{reg.}}$ 是「你离原来的自己有多远」的某种度量，$\lambda \ge 0$ 是价格。截至 2026 年，绝大多数实现里这个 $r_{\text{reg.}}$ 就是到参考策略的 KL 散度：

符号约定（本章统一遵守）：$x$ 是 prompt，$y$ 是完整的 completion（不是单个 token）。$\pi_{\text{RL}} = \pi_\theta$ 是正在训练的策略，$\pi_{\text{ref}}$ 是冻结的参考模型——通常就是 RL 开始前的那个 SFT checkpoint。$\lambda_{\text{KL}}$ 在大部分代码库和论文里被写成 $\beta$，本章后面也主要用 $\beta$。

RLVR 也有正则化，但最佳实践不同

把奖励模型换成可验证的检查函数（数学答案对不对、代码单测过不过），RL 循环本身一模一样，但正则化的实践发生了明显分化。推理模型（在工具使用普及之前）常常直接把 KL 惩罚删掉——因为可验证奖励是不可 hack 的（答案对就是对），过优化的压力小得多，而 KL 惩罚会实打实地拖慢学习速度、压低最终分数。你会在开源 RLVR 配方里反复看到 beta: 0.0。

但随着大规模工具使用的到来，正则化又回来了——只是瞄准的东西变了：不再是「离参考模型的漂移」，而是「离采样分布的漂移」。这是本章第 9 节的主题。

2. KL 惩罚的机制：方向、采样、逐 token 展开

定义与两个方向

离散分布上的 KL 散度定义为

这里 $z$ 是样本空间 $\mathcal{Z}$ 上的一个通用随机变量（不是 prompt——这是原文特意提醒的一处符号复用）。在 RLHF 里，两个分布分别是当前策略和参考策略。谁放左边、谁放右边，是一个有实质后果的选择。

选反向 KL 的工程理由非常朴素：你手上现成就有从 $\pi_\theta$ 采出来的样本。RL 的每一步本来就要生成 rollout，这些 rollout 就是从 $\pi_\theta$ 采的。要算前向 KL，你得额外从参考模型采一批样本，等于每步多跑一次生成，代价直接翻倍。反向 KL 让 KL 惩罚变成一次几乎免费的搭车。

行为上的理由同样重要：过优化的失败模式是「模型跑进了参考模型的低概率区」，而反向 KL 正好在这种情况下爆炸——$\pi_\theta(y)$ 大而 $\pi_{\text{ref}}(y)$ 接近 0，$\log \frac{\pi_\theta}{\pi_{\text{ref}}}$ 巨大，惩罚项立刻把它拉回来。前向 KL 在这种情况下反而看不见问题（因为它按 $\pi_{\text{ref}}$ 的质量加权，而参考模型在那个乱码区的质量本来就是 0）。

从求和到期望：蒙特卡洛形式

定义式里的求和是对整个样本空间做的。对语言模型来说，$\mathcal{Z}$ 是所有可能的 completion 的集合——大小是 $|V|^T$，天文数字，不可能枚举。但只要你能从 $P$ 采样，求和就可以变期望：

这一步是整个实现的关键。它把一个需要枚举词表的量，变成了「拿采出来的那个序列，在两个模型下各算一遍 log 概率，相减」。而 log 概率本来就是语言模型训练里到处都是的东西——你算交叉熵损失时算的就是它。

参考实现

下面这段是把原文的实现示例展开并加了注释的版本。注意 generate 和 forward 的分工：前者自回归地逐 token 采样出序列，后者对已有序列做一次并行前向拿到每个位置的 logits——不采样，只打分。

# --- Step 1: 从当前策略采样一条完整序列（自回归，慢）
generated_tokens = model.generate(inputs)          # (B, T_prompt + T_gen)

# --- Step 2: 对同一序列各跑一次前向（并行，快）
#   注意切掉最后一个 token：位置 t 的 logits 预测的是位置 t+1 的 token
logits     = model.forward(generated_tokens[:, :-1]).logits      # (B, L-1, |V|)
ref_logits = ref_model.forward(generated_tokens[:, :-1]).logits  # (B, L-1, |V|)

# --- Step 3: logits -> log 概率（在词表维度上做 log_softmax）
logprobs     = F.log_softmax(logits,     dim=-1)   # (B, L-1, |V|)
ref_logprobs = F.log_softmax(ref_logits, dim=-1)

# --- Step 4: 只取「实际生成的那个 token」的 log 概率
targets = generated_tokens[:, 1:].unsqueeze(-1)                  # (B, L-1, 1)
token_logprobs     = logprobs.gather(-1,     targets).squeeze(-1)  # (B, L-1)
ref_token_logprobs = ref_logprobs.gather(-1, targets).squeeze(-1)  # (B, L-1)

# --- Step 5: 序列级 log 概率之差 = KL 的单样本估计（即后面的 k1）
seq_logprob     = token_logprobs.sum(dim=-1)       # (B,)
ref_seq_logprob = ref_token_logprobs.sum(dim=-1)   # (B,)
kl_approx = seq_logprob - ref_seq_logprob          # (B,)

# 对比：F.kl_div 算的是「对整个词表求和」的精确 KL，不是采样估计
kl_full = F.kl_div(ref_logprobs, logprobs, reduction='batchmean')

最后两行的对比值得强调。kl_approx 只用了实际采出来的那条路径；kl_full 在每个位置上对整个词表求和，算的是逐 token 的精确 KL。后者更准，但要保留 $(B, L, |V|)$ 的完整 log 概率张量——在 $|V| \approx 1.5\times10^5$、$L \approx 4096$ 的现代设置下，光这一个中间量就是几十 GB，通常不可行。所以生产实现几乎清一色用采样估计。

一段被遗忘的前史

KL 控制不是 LLM 时代的发明。早在 2017 年，Sequence Tutor（Jaques et al., 2017）就把「用 KL 约束把 RL 微调拴在预训练的序列模型上」用在了音乐生成上；2020 年的 Human-centric Dialog Training via Offline RL（Jaques et al., 2020）把它带到了对话智能体。这些工作比 InstructGPT 早了好几年，核心动机一模一样：预训练模型的语言能力是宝贵的，RL 微调很容易把它毁掉，所以给它套一根皮带。

3. 三种 KL 估计器：k1 / k2 / k3

上一节最后那个 kl_approx = seq_logprob - ref_seq_logprob 能用，但它是三个可选估计器里最差的那个。这一节讲清楚为什么，以及为什么现在的开源实现清一色默认第三个。这套东西出自 John Schulman 的一篇短博客（Approximating KL Divergence），是任何要动 KL 惩罚的人都该读一遍的行业常识。

统一记号

沿用 Schulman 的写法：我们要估计 $\mathcal{D}_{\text{KL}}(p \Vert q)$，样本从 $p$ 采出来。定义比值

在 RLHF 的语境下，$p = \pi_\theta$（我们采样的策略），$q = \pi_{\text{ref}}$（参考模型），所以

这是一个逐 token 的标量，shape 为 $(B, T)$。三个估计器都是 $\log\rho$ 的函数：

各自的性质

$k_1 = -\log\rho$。这就是上一节代码里的 seq_logprob - ref_seq_logprob。它无偏——按定义 $\E_{z\sim p}[-\log\rho] = \E_p[\log\frac{p}{q}] = \mathcal{D}_{\text{KL}}(p\Vert q)$，一行就完事。缺点有两个：方差极大，以及单样本可以是负数。后者尤其烦人：KL 在数学上恒非负，但你的 $k_1$ 估计值在某个 token 上完全可能是 $-0.4$，因为策略在那个 token 上恰好比参考模型更不自信。一个可能为负的「惩罚项」意味着优化器有时会因为「离参考模型更远」而获得奖励，这在梯度上是纯噪声。

$k_2 = \tfrac{1}{2}(\log\rho)^2$。平方保证了恒非负，而且平方项对小偏差不敏感、对大偏差敏感——方差小很多。代价是有偏。它的来历是：$\mathcal{D}_{\text{KL}}$ 在两个分布接近时的二阶近似正好是 $\tfrac12 \E[(\log\rho)^2]$（Fisher 信息度规），所以当模型没跑远时它非常准，跑远了就开始偏。

$k_3 = (\rho - 1) - \log\rho$。这个是「两全其美」的那个。

一个具体的数值对比

拿两个 5 元词表上的分布做例子：策略 $p = (0.40, 0.25, 0.20, 0.10, 0.05)$，参考 $q = (0.30, 0.30, 0.20, 0.15, 0.05)$。真值 $\mathcal{D}_{\text{KL}}(p\Vert q) = 0.02895$。因为支撑集有限，三个估计器的期望和标准差可以精确算出来：

这张表把结论摆得很清楚：$k_1$ 的单样本噪声是真值的 8 倍多——你要平均几百个样本才能把这个数字看清楚，而且中间会出现负值。$k_2$ 和 $k_3$ 的噪声都降到了真值量级以下，差了将近一个数量级。$k_2$ 有一点点偏（这里只有 0.06%，两个分布很近时确实可以忽略），$k_3$ 干脆连偏都没有。所以选 $k_3$ 是几乎没有代价的免费午餐。

参考实现

下面改写自 _src/code/policy_gradients/loss.py。原文件把 log_ratio 定义为 $\log\pi_\theta - \log\pi_{\text{ref}}$（也就是 $-\log\rho$），这里为了和上面的推导对齐，显式写成 Schulman 记号：

import torch

def approx_kl(logp, logp_ref, mask, estimator="k3"):
    """逐 token 的 KL(pi_theta || pi_ref) 估计。
    logp, logp_ref: (B, T)  实际生成 token 在两个模型下的 log 概率
    mask:           (B, T)  1 = 该位置是模型生成的 token，0 = prompt / padding
    返回:           (B, T)
    改写自 _src/code/policy_gradients/loss.py 的 approx_kl1/2/3
    """
    # Schulman 记号: log_rho = log q - log p = log pi_ref - log pi_theta
    log_rho = logp_ref - logp

    if estimator == "k1":                       # 无偏，高方差，可为负
        kl = -log_rho
    elif estimator == "k2":                     # 有偏，低方差，恒 >= 0
        kl = 0.5 * log_rho.pow(2)
    elif estimator == "k3":                     # 无偏 + 恒 >= 0（默认）
        kl = log_rho.exp() - 1 - log_rho
    else:
        raise ValueError(estimator)

    return kl * mask


def masked_mean(t, mask, dim=-1, eps=1e-8):
    """只在 mask=1 的位置上求平均（照抄 loss.py）"""
    return (t * mask).sum(dim) / mask.sum(dim).clamp_min(eps)

序列级还是 token 级？

还有一个容易忽略的自由度：算完逐 token 的 $k$ 之后，怎么聚合。三种常见做法——

• 逐 token 求和（$\sum_t k_t$）：得到序列级的 KL，量纲上和「整条 completion 的 log 概率差」一致。长回复的 KL 天然更大，所以它隐含地惩罚长度。
• 逐 token 求均值（masked_mean，loss.py 的做法）：每条序列贡献相同权重，与长度解耦。
• 全 batch token 级均值（先求和再除以 batch 内总 token 数，DAPO 风格）：长序列的每个 token 权重相同。

这三种选择会改变 $\beta$ 的有效量级，差异可以到几十倍。所以跨代码库照抄 $\beta$ 是没有意义的——必须先确认对方的聚合方式和你一样。这也是下一节要展开的话题之一。

4. 加在奖励里，还是加在损失里？

这是一个在论文里几乎从不明说、但在代码里必须二选一的问题。原始公式写的是 $r = r_\theta - \beta\,\mathcal{D}_{\text{KL}}$——KL 被减在奖励上。但打开 2025 年之后的任何一个 GRPO 实现，你会看到 KL 是作为损失的一项直接加上去的。这两者不等价。

写法 A：把 KL 塞进奖励

这是 InstructGPT / 经典 PPO-RLHF 的做法。每个 token 位置 $t$ 都有一个奖励：

其中 $k_t$ 是第 3 节那个逐 token 的 KL 估计。注意奖励模型只在序列结束时给一个标量分数（稀疏奖励），而 KL 惩罚是逐 token 稠密的。这个 $\tilde r_t$ 序列随后被送进 GAE 算优势：

KL 惩罚在这里的效果是会向前传播的：位置 $t$ 上的一次大 KL，通过 GAE 的折扣求和，会压低 $t$ 之前所有位置的优势。直觉上这是对的——「你在第 300 个 token 上写出了参考模型绝不会说的话」这件事，应该让导致它的前 299 个 token 也一起负责。

写法 B：把 KL 加进损失

这是 GRPO 及其后继者的做法，也是 _src/code/policy_gradients/loss.py 里的写法：

# 摘自 _src/code/policy_gradients/loss.py 的 GRPOLoss.forward
ratio = (log_probs - experience.log_probs_old).exp()
unclipped = ratio * experience.advantages
clipped   = ratio.clamp(1 - clip_eps_lo, 1 + clip_eps_hi) * experience.advantages
policy_loss = -torch.min(unclipped, clipped)

if self.beta:                                   # beta = 0 时整块跳过
    kl_loss = get_approx_kl(self.kl_estimator, log_probs,
                            experience.log_probs_ref, experience.action_mask)
else:
    kl_loss = torch.tensor(0.0, device=log_probs.device)

loss = policy_loss + self.beta * kl_loss
loss = masked_mean(loss, mask=experience.action_mask, dim=-1).mean(dim=0)

这里的 advantages 是纯任务奖励算出来的（GRPO 里是组内标准化的奖励），KL 完全不参与优势计算，只是在最后作为一个独立的正则项加到损失上。

该选哪个

现代实现倒向 B 有两个原因。一是 GRPO 这一系根本没有 value function，写法 A 的载体消失了。二是 B 让 $\beta = 0$ 变成一个真正免费的开关——注意上面代码里 if self.beta: 那个判断，$\beta = 0$ 时连 get_approx_kl 都不调用。再往上一层，如果整个配方都不用 KL，你可以直接不加载参考模型，省下一整份权重的显存和每步一次的前向。对 70B+ 的模型来说这不是小钱。

5. 系数 β 怎么定：从反馈控制器回到常数

一开始它不是常数

把 LLM 拉进 RLHF 的第一篇论文（Fine-Tuning Language Models from Human Preferences, Ziegler et al., 2019）并没有固定 $\beta$。它做的事情更有工程味道：先定一个目标 KL（$\text{KL}_{\text{target}}$），然后用一个反馈控制器去追这个目标。

逐项拆解：

• $e_t$ 是相对误差——当前 KL 超出目标的比例。用相对量而不是绝对量，是为了让控制器在不同 KL 量级下行为一致。
• clip 到 $\pm 0.2$：单步最多认为「超了 20%」或「低了 20%」，防止某一步的 KL 尖峰把 $\beta$ 直接打飞。
• $\beta$ 的更新是乘性的（$\beta \leftarrow \beta(1 + K_\beta e)$），作者称之为「对数空间的比例控制器」。乘性更新的好处是 $\beta$ 恒为正，且在数量级之间平滑移动——$\beta$ 从 0.01 调到 0.1 和从 1 调到 10 是同一件事。
• $K_\beta = 0.1$ 是增益。KL 超标 20%（$e = 0.2$），$\beta$ 单步涨 2%。这是一个刻意调得很慢的控制器——它要跟踪的是趋势，不是噪声。

这个设计的实际价值在讲座里被点了出来：不同随机种子的 run 会落在同一个 KL 预算上，实验因此可比。这是一个被严重低估的好处。如果你固定 $\beta$，不同 seed / 不同数据混合的 run 会跑出完全不同的 KL 距离，你根本不知道 A 比 B 好是因为方法好还是因为它单纯跑得更远。固定 KL 预算之后，比较才有意义。

这个想法比 RLHF 老：PPO 原论文本身就有一个自适应 KL 惩罚的变体（KL 超过目标 1.5 倍就把 $\beta$ 翻倍，低于目标 1.5 分之一就减半）；受约束 RL 领域后来把这个框架讲得更明确，直接上了 PID 控制器（Responsive Safety in RL by PID Lagrangian Methods, Stooke et al., 2020）——比例项管当前误差，积分项消除稳态偏差，微分项抑制超调。这不是巧合：「在满足约束的前提下最大化奖励」是拉格朗日对偶问题，而 $\beta$ 就是那个拉格朗日乘子，乘子的更新天然是一个控制问题。

现代实践：静态小 $\beta$，或者干脆是 0

钟摆又摆了回来。TRL 的 AdaptiveKLController 在现代重写里被删掉了；open-instruct 今天用的是一个静态的 beta = 0.05，直接加在损失里（第 4 节的写法 B）。而在大量 RLVR 推理配方里，$\beta$ 干脆是 0——本仓库 _src/code/policy_gradients/configs/ 下的 GRPO、GSPO、CISPO、SAPO、DAPO、RLOO 配置全部默认 beta: 0.0。

为什么会这样？

1. 可验证奖励难以 hack。数学答案对就是对，代码单测过就是过。过优化的压力从「奖励模型被骗」变成了「格式坍缩 / 语言漂移」，而这类问题用别的手段（格式奖励、语言一致性检查、长度惩罚）更直接。
2. KL 惩罚要花钱买。它拖慢学习，压低最终分数。当过优化不是主要矛盾时，这笔钱就白花了。
3. 自适应控制器多了两个超参（$\text{KL}_{\text{target}}$ 和 $K_\beta$），而且引入了训练动力学上的耦合。当大家发现「静态小 $\beta$ 已经够用」之后，简化就发生了。

数量级速查

调 $\beta$ 的实操流程

如果你确实需要一个非零的 $\beta$，一个可操作的做法是：

1. 先跑 $\beta = 0$，把 KL 曲线记下来。你需要知道「不加约束时这个任务会跑多远」这个基线。
2. 确定你的 KL 预算。看 $\beta = 0$ 那条 run 在什么 KL 值附近开始出现质量退化（读 rollout 样本，别只看奖励），把这个值的一半左右定为目标。
3. 用「KL 项占 loss 的比例」反推 $\beta$。希望 KL 惩罚在训练中期贡献大约 5–20% 的总损失量级。已知目标 KL 和 policy loss 的量级，$\beta$ 就基本被定死了，不需要网格搜索一个数量级。
4. 确认聚合方式。第 3 节末尾提过：序列级求和 vs token 级均值，会让同一个 $\beta$ 的有效强度差几十倍。从别的代码库抄 $\beta$ 之前，先对齐这一点。

6. 参考模型：选谁、要不要更新、代价是多少

KL 惩罚里有两个自由度，$\beta$ 只是其中一个。另一个是 $\pi_{\text{ref}}$ 本身——它在论文里通常被一句「the SFT checkpoint」带过，但这个选择实际影响很大。

参考模型在约束什么

原文给的直觉很朴素：你正在训练的这个模型有一种「风格」，而你希望留在那种风格附近。注意这句话里的「风格」不是修辞——参考模型约束的确实主要是分布层面的东西：句长、句式、markdown 使用习惯、拒答倾向、语言选择、特殊 token 的使用频率。它不太约束「知识对不对」（那是奖励信号的活儿），但它非常有效地约束「话说得像不像人话」。

这解释了参考模型选谁的第一原则：选那个你满意其行为分布的 checkpoint。

静态 vs 移动的参考模型

标准做法是冻结：$\pi_{\text{ref}}$ 从头到尾是同一份权重。这带来一个必然的动力学——随着训练进行，KL 单调（或近似单调）增长，惩罚项越来越大，最终把奖励的增益抵消掉，训练自然停在某个平衡点。这个平衡点就是你的 KL 预算。

另一种做法是周期性更新参考模型：每 $N$ 步把当前策略拷贝成新的 $\pi_{\text{ref}}$。这时 KL 惩罚变成了一个「信赖域」——它只约束每段区间内的变化速度，不约束总位移。

参考模型的工程细节

几个在实现时必须处理的点：

• ref logprob 在 rollout 阶段就算好。参考模型是冻结的，同一批数据的 ref_logprobs 不会变。所以标准做法是在生成完 rollout、构造 Experience buffer 时就把它算完存进去（loss.py 里 experience.log_probs_ref 的来源），而不是在每个 inner epoch 的 loss 计算里重复前向。PPO 类算法一批数据要走 2–4 个 inner epoch，这一优化能省下 2–4 倍的参考模型算力。
• dropout 必须关。参考模型永远是 eval() 模式。策略模型在训练时如果开着 dropout，同一个序列在 policy 和 ref 下的 logprob 会有随机差异，直接污染 KL。现代 LLM 训练一般不开 dropout，但混合精度、attention kernel 的选择（FlashAttention vs SDPA）同样会引入不一致——第 0 步 KL 不为 0 就是这个问题的体检指标。
• 参考模型可以放在别的设备 / 用低精度。它不需要梯度和优化器状态，只需要一次前向。常见做法包括：把它 offload 到 CPU 分片、和 rollout 引擎共用一份权重、或者用 int8/fp8 加载。用低精度要谨慎——KL 是两个大数相减得到的小数，参考模型的精度损失会被放大。
• LoRA 的特殊便利。如果策略是在参考模型上加 LoRA 训的，那么「参考模型」就是关掉 adapter 的同一个模型。不需要第二份权重，只需要两次前向（一次开 adapter、一次关）。这是显存受限时非常实用的技巧。

DPO 系里的参考模型

直接对齐算法（Direct Alignment Algorithms, DAA）也要参考模型，但它出现在损失函数的定义里而不是作为一个可加的惩罚项：

因为 DPO 是完全 off-policy 的（数据是固定的偏好对），$\pi_{\text{ref}}$ 在这些数据上的 logprob 可以在训练开始前一次性预计算并缓存，训练时连参考模型都不用加载。这是 DPO 相比 PPO 在工程上便宜得多的原因之一。

7. 优化的形状：RL 是反向 KL，SFT 是前向 KL

前面六节讲的都是你主动加上去的惩罚：一个带系数的项，可以调大调小，可以关掉。这一节讲的是另一件事——优化器本身的形状。事实证明，SFT 和 RL 这两个我们天天用的目标函数，在数学上恰好就是 KL 散度的两个方向。而「方向」这件事，完全由样本从哪来决定。

SFT 就是前向 KL

设数据分布为 $\pi_\star$（在 SFT 语境下就是训练集里那些人写/模型写的 completion 的分布），我们训练的策略是 $\pi_\theta$。前向 KL 的定义是：

把期望拆成两项：

第一项只依赖数据分布，是它的负熵，对 $\theta$ 是常数。第二项加个负号就是负对数似然，也就是标准的 SFT 交叉熵损失。于是

常数不影响梯度也不影响最小值点，所以最小化 SFT 损失，字面意义上就是最小化到数据分布的前向 KL。这不是类比，是恒等式。

带惩罚的 RL 就是反向 KL

从我们的 RL 训练器实际优化的那个目标出发：

除以 $-\beta$ 把最大化变成最小化，并把两项并进一个期望：

引入配分函数 $Z(x) = \sum_y \pi_{\text{ref}}(y\mid x)\exp\!\big(\tfrac{1}{\beta}r(x,y)\big)$，加一项减一项 $\log Z(x)$，括号里的东西就变成了一个完整的 KL：

$\log Z(x)$ 不依赖 $\pi$，而 KL 非负且仅在两分布相等时为零。所以最优策略有闭式解：

两个方向的数值行为

反向 KL 的 mode-seeking 来自一个很简单的事实：期望是按 $\pi_\theta$ 自己的概率加权的。$\pi_\theta(y\mid x)\approx 0$ 的区域，无论 $\pi_\star$ 在那里有多少质量，对损失的贡献都接近 0。模型「看不见」自己不会生成的东西。而前向 KL 的期望按 $\pi_\star$ 加权，模型在目标有质量的地方必须跟上，否则损失发散。

8. 隐式正则化：为什么 RL 忘得比 SFT 少

前面所有内容讲的都是显式正则化——KL 惩罚、预训练梯度、margin loss，都是你手动写进目标函数的东西。但 2025–2026 年积累起来的一批实证工作揭示了另一件事：基于 RL 的后训练自带一层隐式正则化。这层保护来自 on-policy 优化的结构本身，不依赖任何显式工具——没有 KL 惩罚、没有 replay buffer，它照样在。

SFT 记忆，RL 泛化

后训练社区一个核心问题是：在单个任务上训练时，模型学到的是一条可迁移的规则，还是只是背下了训练分布的表面模式？SFT Memorizes, RL Generalizes（Chu et al., 2025）用一个受控实验直接回答了这个问题：把后训练方法（SFT vs RL）当成唯一变量，看分布外（out-of-distribution, OOD）泛化怎么变。

两个环境都内建了「规则变体」，训练用一套规则，评测换另一套：

• GeneralPoints：给四张扑克牌，用 $+ - \times \div$ 组合出目标数（默认 24）。OOD 测试换的是花牌计分规则——训练时 J/Q/K 都算 10，评测时 J=11、Q=12、K=13。
• V-IRL：真实城市街景的视觉导航，模型按语言指令沿路线行进、识别沿途地标。OOD 把动作空间从绝对方向（north、east）切成相对方向（left、right）。

结果在所有任务变体上一致：随着训练算力增加，RL 的 OOD 性能持续上升，SFT 的 OOD 性能持续下降——尽管 SFT 的分布内性能在涨。分化的幅度大得吓人：在纯语言输入的 V-IRL 上，OOD 逐步准确率从 80.8% 出发，RL 提升到 91.8%，SFT 崩塌到 1.3%。

1.3% 这个数字值得停下来想一想。它不是「没学会新规则」——没学会的话应该退回到基础模型的水平（80.8%）。它是把基础模型原本就有的空间推理能力给毁了：模型退化成了一张从指令短语到绝对方向的查找表，一旦指令换成相对方向，查找表整个失效。

为什么方向决定了遗忘：多模态才是关键

Retaining by Doing（Chen et al., 2025）问的是互补的问题：顺序训练多个任务时，模型还记得原来会的东西吗？答案是 RL 在目标任务上收益相当或更高，同时遗忘显著更少。而解释就是第 7 节那两个 KL 方向。

先说一个直觉上应该成立但实际是错的推理：前向 KL 是 mass-covering 的，所以 SFT 应该保住目标分布的所有模态、保留旧知识；反向 KL 是 mode-seeking 的，所以 RL 应该坍缩到一个高奖励模态、把别的都丢掉。因此 SFT 该忘得少。

但事实恰好相反。问题出在那个推理默认策略是单模态的。预训练 LLM 里装着无数个模态。

把这个图翻译成两句话：

• SFT（前向 KL）：样本来自目标 $\pi_\star$——一个固定的人写数据集。对每条样本我们问：我的模型给这个分配了多少概率？模型从不生成任何东西，它只学着模仿。mass-covering 的压力迫使策略把概率质量重新摊开，从而破坏已有知识。
• RL（反向 KL）：样本来自策略自己。对模型生成的每条 completion 我们问：它离奖励最优策略有多近？因为模型只在自己的生成结果上训练，更新被局限在它已经放了概率质量的地方——奖励信号告诉它这批生成里哪些该加强，概率往 $\pi_\star$ 挪，分布的其余部分纹丝不动。

RL's Razor：on-policy 采样本身就是正则化

RL's Razor（Shenfeld, Pari & Agrawal, 2026）从另一个角度给出了互补的解释。它的出发点是：对任何一个新任务，都存在很多个能拿到高分的策略。那么优化器会挑哪一个？论断是：

在新任务的众多高奖励解中，RL 这类 on-policy 方法内在地偏向那些在 KL 意义上离原策略最近的解。

作者的核心实证结果是一个惊人简洁的关系：

横跨多种 RL 和 SFT 的训练变体，遗忘量与「训练后策略 $\pi$ 相对初始策略 $\pi_0$ 的 KL 漂移」强相关，$R^2 = 0.96$。

令人意外的地方在 KL 是在新任务的输入分布上量的，不是在旧任务的留出数据上。你只需要拿新任务的 prompt，跑一遍两个模型，算个 KL，就能预测模型在完全没见过的旧任务上会掉多少分。这在实践上是一个非常便宜的仪表：

到底是哪个因素在起作用？

RL 和 SFT 差别很多，作者做了一个漂亮的消融，沿两条轴拆解：

1. 数据是 on-policy 还是 offline——样本是模型自己生成的，还是外部给定的。
2. 目标里有没有负梯度——RL 在样本得分低于基线时会有把概率推离该输出的梯度；SFT 只有正向强化（只在正确演示上提升概率）。

结论非常干净：on-policy vs offline 完全解释了泛化性能的差异，负梯度没有可辨识的影响。

为什么？on-policy 方法采样的是模型已经赋予了不可忽略概率的输出，所以每一步更新天然被约束在当前分布附近——你没法对一个自己永远不会生成的东西做梯度更新。而 SFT 训练在一个固定的外部分布上，这个分布可以离模型当前的输出任意远，每一步梯度都在把模型往那个遥远的目标拽，完全不管模型自己「相信」什么。

9. KL 之外：其余的正则化工具箱

后训练文献里，不少领先模型在自己的配方里塞了别的正则化手段。原文对这些内容的定位说得很坦率：它们是为了展示「领先模型是怎么把自己的配方调稳的」，而不是「这些工具在任何配方里都该用」。读这一节的正确姿势是当作案例集，而不是清单。

预训练梯度混合（InstructGPT）

另一种看待正则化的角度：你想约束的可能不是「离某个模型不要太远」，而是「离某个数据集不要太远」。InstructGPT 就是这么干的，动机原话是「为了修复在公开 NLP 数据集上的性能回退」。

把第 1 节的通用形式 $r = r_\theta - \lambda\, r_{\text{reg.}}$ 写成一个要最大化的目标函数（对 RL 策略采样、prompt $x$ 取自 RLHF 数据集、completion $y$ 由策略生成）：

然后加上一项：在预训练语料（或者别的什么语料）上采一批文档，给标准自回归下一 token 预测的对数似然一个正的权重：

第二项就是预训练损失，只不过符号翻过来当作要最大化的奖励。$\gamma$ 控制它的权重。这个配方在实现上意味着：每个训练步除了 RL 的 batch，还要额外过一个预训练 batch，做一次普通的语言建模前向反向。这也是它在 InstructGPT 论文里被叫作 PPO-ptx 的原因。

值得注意的是这个手段的方向：它是一个前向 KL 式的约束（样本来自固定数据集），加在一个反向 KL 的优化里。它想解决的问题——「RL 之后模型在传统 NLP 基准上掉分」——正是第 8 节讲的遗忘问题。而第 8 节告诉我们，这个问题的更深层原因其实是 SFT 阶段就埋下的，用更多前向 KL 去补，属于用同一类药治同一类病。这个手段在后续几代模型里基本消失了，可以作为「脚手架」的典型案例。

DPO 里混一项 NLL

Iterative Reasoning Preference Optimization（Pang et al., 2024）提出在 DPO 损失里加一个负对数似然项来平衡优化：

展开：

符号：$P_\theta$ 是可训练策略，$P_{\text{ref.}}$ 是冻结的参考模型（通常就是 SFT checkpoint），$(c_i^w, y_i^w)$ 和 $(c_i^l, y_i^l)$ 分别是 prompt $x_i$ 下的胜出与落败 completion（$c$ 是推理链，$y$ 是最终答案）。

两项的分工：第一项是标准 DPO 的 logistic 损失，用对数似然比之差 $\log\frac{P_\theta}{P_{\text{ref.}}}$ 拉开胜负样本的间距，$\beta$ 控制这个偏好信号能把模型从参考模型拽多远。第二项是对胜出 completion 的长度归一化 NLL 惩罚，权重 $\alpha$，作用是让被偏好的文本在绝对语言建模意义上保持高似然，而不只是相对落败样本更好。

奖励模型的 margin loss（Llama 2）

RLHF 栈的其他部分，「控制优化」这件事定义得远没有 RL 阶段清楚。大多数奖励模型除了标准的对比损失之外没有任何正则化。直接对齐算法则把 KL 正则塞进了 $\beta$ 里（第 8 章）。

Llama 2 给奖励模型训练提出了一个 margin loss：

$m(y_c, y_r)$ 是两个数据点之间的间距，来自两位标注员评分之差的数值化。实现方式是让标注员在数值量表上打分，或者用量化的排序方法比如 Likert 量表（第 10 章讲偏好数据时的那套量表）。

直觉：不是所有偏好对都一样确信。「A 明显好过 B」和「A 略微好过 B」在标准 BT 损失里贡献的梯度是一样的，模型被迫把两者都推到同样的分差。加了 margin 之后，标注员标「明显更好」的对，模型必须把分差拉到 $m$ 以上才算达标；标「差不多」的对，$m\approx 0$，稍微拉开就够了。这既减少了在噪声标注上的过拟合，也让奖励模型的输出尺度更有意义。

margin 这个思路在直接对齐文献里被用得很重：Reward-weighted DPO；RPO（Reward-aware Preference Optimization, Nemotron-4 340B, 2024）把奖励模型分数整合进 DPO 式的更新规则；REBEL（Reinforcement Learning via Regressing Relative Rewards, 2024）用回归损失的形式做奖励差值加权。

熵正则

经典 RL 里的标配（A3C、SAC 里的 entropy bonus）：在目标里加一项策略熵，鼓励模型保持随机性、不要过早坍缩到确定性策略。

在 LLM 的 RL 里，这个东西的地位很微妙。熵坍缩确实是真实且高频的失败模式：训着训着，模型对每个位置都极度自信，采样温度 1.0 生成出来的还是几乎一样的东西；group 内 rollout 全都一模一样，GRPO 的组内优势全变成 0，梯度归零，训练卡死。所以监控 token 级熵是 RLVR 训练的标准操作。

但直接加 entropy bonus 作为解药口碑并不好——它是一个无差别的力，会同时抬高「该确定的地方」（闭合括号、固定格式串）和「该多样的地方」（推理路径选择）的熵，容易把输出搞得更不连贯。社区更常见的替代手段是从别处入手：clip-higher（DAPO 那样放宽 clip 上界，让低概率 token 有机会被抬起来）、动态采样（丢掉组内全对或全错的 prompt）、提高采样温度、以及在数据侧保证难度分布合理。

权重平均与模型融合（model soup）

最后一类工具在形式上和前面完全不同：它不改目标函数，而是在参数空间里做平均，$\theta_{\text{merged}} = \sum_i w_i \theta_i$（$\sum_i w_i = 1$）。最简单的形式就是把若干 checkpoint 的权重直接算术平均。RLHF 语境下的三种典型用法：沿训练轨迹平均（平均后的模型必然落在各 checkpoint 之间，KL 漂移小于最远的那个）；把 RL 模型和参考模型插值，$\theta = (1-\alpha)\theta_{\text{ref}} + \alpha\theta_{\text{RL}}$，给你一个训练后的旋钮，在「对齐程度」和「通用能力保留」之间连续调节而不需重训；融合领域专家（数学、代码、对话分别 RL 后合并）。

本书在附录 C里把模型融合列为「创造强模型的关键工具之一」，评价是「一个强大且简单的工具，但如何为后续融合而准备一个模型，还没有清晰的最佳实践」（参见 What Matters for Model Merging at Scale?, 2024）。这个评价很准确：它在最终配方里几乎总能挤出一点收益，但属于炼丹术而非理论。

10. 2026：约束的锚点从「参考模型」移到「采样分布」

本章到这里为止讲的都是参考模型锚定的正则化：一个固定的 $\pi_{\text{ref}}$，一个反向 KL，一个系数 $\beta$。但 2026 年前沿的 agentic 配方正在做一件看起来矛盾的事——一边把 KL 惩罚彻底删掉，一边在别的地方加回更强的约束。理解这个转向是本章的收尾。

KL 惩罚正在消失

证据是明确的：

• GLM-5 直接把它移除了，理由是「为了加速 RL 的提升」。
• Kimi 也不用：K2 → K3 的配方里既没有 KL 惩罚，也根本没有参考策略。
• TMax（终端 agent 配方）把这笔账算给你看了：一个小的 KL 能减轻坍缩的严重程度，但会降低奖励，最终配方选 $\beta = 0$。

为什么工具使用逼着大家改

三个技术原因叠在一起：

1. 20 多轮的轨迹。一条 agentic rollout 不是「prompt → 一段回复」，而是「模型说一句 → 调工具 → 拿到结果 → 再说一句」循环二十几次。序列长度上万 token，而且中间大量 token 是工具返回的内容——那些 token 不是模型生成的，对它们算 KL 毫无意义，得小心地 mask 掉。轨迹越长，逐 token KL 的累积噪声越大，惩罚项的信噪比越差。
2. 异步 / partial rollout。为了让 GPU 不空转，现代训练框架允许 rollout 和训练异步进行：这批数据是用几步之前的权重采的，甚至一条轨迹的前半段和后半段用的是不同版本的权重。此时「策略」和「采样器」已经不是同一个东西了。
3. 训练引擎与推理引擎的数值不一致。rollout 用 vLLM / SGLang 生成，训练用 FSDP/Megatron 打分。同一份权重、同一条序列，两边算出来的 logprob就是不一样——不同的 kernel、不同的 batching、不同的数值精度累积。这个差异本身就构成一个 off-policy 的 gap。

结果是：真正致命的漂移不再是「离初始模型多远」，而是「训练时看到的分布，离采样时的分布多远」。TMax 的观测很具体——不稳定性在超过 10 个 assistant 轮次之后开始增加，5 轮以下则完全不出现。这不是一个「模型跑得太远」的问题，这是一个「重要性采样比值算不准」的问题。

新的约束长什么样：mask，而不是 clip

PPO 的逐 token 比值 $\rho_t = \frac{\pi_\theta(y_t)}{\pi_{\text{old}}(y_t)}$ 本来就是「训练策略与采样策略之间散度」的一个单样本、高噪声估计（注意这和第 3 节 $k_1$ 方差大的原因是同一个）。当 $\pi_{\text{old}}(y_t)$ 很小时，这个比值会剧烈爆炸——不是因为策略真的变了那么多，而是因为分母是个接近 0 的数。

DPPO（Divergence Proximal Policy Optimization, Qi et al., 2026）的做法是：不再用逐 token 比值做 clip，而是直接估计 rollout 策略与训练策略之间的散度（用二值 total variation），然后按这个散度屏蔽（mask）token。同一时期 GLM 的 IcePop、Kimi 的 log-ratio 区间做的是同一件事：把有问题的 token 的梯度直接置零，而不是把它们的贡献裁到边界值。

本章小结

速查表：KL 惩罚的每个自由度

要点清单

• 14 章是病，15 章是药。过优化的规律是「跑了多远」的函数而非「训了多少步」，所以 KL 被当成一笔可以计价的优化预算。
• KL 不是距离（不对称、不满足三角不等式），它是「用为 $Q$ 定制的编码去编 $P$ 的数据」的额外码长。行话里叫「KL 距离」是因为它作为「模型改了多少」的单一数字非常好用。
• KL 永远是估计出来的：精确 KL 要对整个词表求和，$(B,L,|V|)$ 的张量在现代规模下装不下。三个估计器里 $k_3$ 是免费的最优解——在本章那个数值例子里，$k_1$ 的单样本标准差是真值的 8.25 倍，$k_3$ 只有 0.92 倍，而两者同样无偏。
• 符号搞反是最高频的 bug，而且不会崩。两条自检：$k_3$ 逐元素 $\ge 0$；第 0 步 KL 精确为 0 然后单调爬升。
• $\beta$ 最初是控制器不是常数：目标 KL + 对数空间比例控制器（$K_\beta = 0.1$，误差 clip $\pm0.2$），好处是不同 seed 的 run 落在同一 KL 预算上、实验可比。现代实践回到静态小 $\beta$，或者干脆 0。
• DPO 的 $\beta$ 和 RL 的 $\beta$ 不是一回事：前者是隐式奖励定义里的温度（不能设 0），后者是显式惩罚项的价格（可以设 0）。但方向一致：$\beta$ 小 = 允许跑得远。
• SFT ⟺ 最小化前向 KL 到数据分布（恒等式，不是类比）；带惩罚的 RL ⟺ 最小化反向 KL 到奖励倾斜的参考策略 $\pi_\star \propto \pi_{\text{ref}}\exp(r/\beta)$——同一个 $\pi_\star$ 也是 DPO 推导的起点。
• 方向由「样本从哪来」决定：数据来 → 前向 → mass-covering；模型自己来 → 反向 → mode-seeking。这条轴同时统一了 SFT、蒸馏、RL 三件事。
• 隐式正则化是真实且可测的。SFT 在 V-IRL 上把 OOD 准确率从 80.8% 打到 1.3%（毁掉了基础模型已有的空间推理），RL 把它提到 91.8%。遗忘量与 KL 漂移的相关性 $R^2 = 0.96$，且这个 KL 在新任务数据上就能测——一个极其便宜的遗忘预警仪表。
• 消融结论：on-policy 数据完全解释了 RL 与 SFT 的泛化差异，负梯度没有可辨识贡献。所以「能 on-policy 就 on-policy」，即使 $\beta = 0$ 也已经拿到一层免费正则化。
• KL 之外的手段绝大多数是脚手架：预训练梯度混合（InstructGPT PPO-ptx）、DPO+NLL、Llama 2 的 margin loss、熵正则、权重平均。它们各自解决一个具体配方里的具体问题，下一代往往就被简化掉了。看到一堆正则项，先假设是拐杖。
• 2026 的转向：GLM-5 删掉 KL 惩罚以加速 RL，Kimi K2→K3 连参考策略都没有，TMax 实测「小 KL 减轻坍缩但降低奖励」后选了 $\beta=0$。约束的锚点从参考模型移到了采样分布（DPPO 的 TV mask、IcePop、log-ratio 区间）。
• 两层约束不要混淆：clip / mask 管每步步长（锚在采样策略，永远开着，管数值稳定）；KL-to-ref 管全程总位移（锚在固定参考模型，可以关掉，管行为退化）。

动手实验

本章没有独立的作业目录，但 homework/hw3-pg（策略梯度）的实验框架可以直接用来观察 KL 惩罚的行为——正则化的所有旋钮都在 _src/code/policy_gradients/ 里。

实验一：$\beta$ 扫描，看 KL 预算与奖励的权衡

基线配置 policy_gradients/configs/grpo.yaml 默认是 beta: 0.0、kl_estimator: kl3。复制三份，把 beta 分别设成 0.0 / 0.01 / 0.05 / 0.2：

# 参照 _src/code/CLAUDE.md 的运行方式
uv run python -m policy_gradients.train --config policy_gradients/configs/grpo.yaml

要盯的指标：

• KL 曲线 vs 奖励曲线。$\beta = 0$ 时 KL 应该持续爬升然后在某个区间游走；$\beta$ 越大，KL 越早进入平台，同时最终奖励越低。这条权衡曲线就是本章的全部内容的实验版本。
• 第 0 步的 KL 必须是 0（浮点误差量级）。不是 0 就说明 policy 和 ref 的前向路径不一致，先修这个再谈别的。
• 生成样本本身。$\beta = 0$ 且训练足够久时，去读 rollout——你会看到格式坍缩、重复、或者输出退化成固定模板。这是过优化的直接证据，而且它通常在奖励曲线还在涨的时候就已经发生了。

实验二：三个估计器的方差对比

把 kl_estimator 在 kl1 / kl2 / kl3 之间切换，固定 $\beta$ 和随机种子，把每步的 KL 值记录下来（不只是均值，还要记 batch 内的标准差）。你应该能重现第 3 节表格的定性结论：$k_1$ 的 batch 内标准差远大于另外两个，而且会出现负值；$k_2$ 和 $k_3$ 的均值在训练早期几乎重合、在 KL 变大之后开始分离（$k_2$ 偏低）。

加一行断言 assert (kl >= -1e-6).all() 到 approx_kl3 里，然后故意把 log_probs 和 log_probs_ref 调换位置，感受一下符号 bug 是多么安静地通过了所有类型检查。

实验三：测量 KL 漂移作为遗忘的代理指标

这个复现的是第 8 节 RL's Razor 的实操建议，用 homework/hw1-sft 的 SFT 流程做对照：

1. 在一个窄领域数据集上分别做 SFT 和 GRPO，训到目标任务性能相同（这一点很关键，不然比较没有意义）。
2. 用新任务的 prompt，测量微调后模型与初始模型之间的 KL 漂移。
3. 在一个完全无关的留出任务上评测两个模型，看掉了多少分。

预期观察：在目标任务性能匹配的前提下，SFT 的 KL 漂移显著大于 RL，而留出任务的掉分幅度与 KL 漂移正相关。小规模下噪声会比较大，但趋势应该看得出来。

延伸阅读

KL 控制的源头

• Sequence Tutor: Conservative Fine-Tuning of Sequence Generation Models with KL-control (2017) — LLM 之前就有 KL 控制。读它是为了看清这个技巧的动机与语言模型无关：任何「用 RL 微调一个宝贵的生成模型」的场景都需要它。
• Human-centric Dialog Training via Offline Reinforcement Learning (2020) — 把 KL 控制带到对话智能体，确立了它作为微调预训练模型的核心技术的地位。
• Fine-Tuning Language Models from Human Preferences (2019) — 第一篇 LLM + RLHF。本章第 5 节那个自适应 $\beta$ 控制器就出自这里，原始代码至今可读。
• Approximating KL Divergence (Schulman, 博客) — $k_1/k_2/k_3$ 的出处。全文不到两千字，是「碰 KL 惩罚的人必读」级别的行业常识。

正则化的具体配方

• InstructGPT: Training Language Models to Follow Instructions with Human Feedback (2022) — PPO-ptx 的预训练梯度混合项在这里，动机原话是「修复公开 NLP 数据集上的性能回退」。
• Llama 2: Open Foundation and Fine-Tuned Chat Models (2023) — 奖励模型的 margin loss，以及把标注员的 Likert 评分差转成 margin 的具体做法。
• Iterative Reasoning Preference Optimization (2024) — DPO+NLL。理解「DPO 只约束比值，所以两边概率会一起掉」这个问题的标准修补方案。
• Nemotron-4 340B Technical Report (2024) — RPO：把奖励模型分数直接整合进 DPO 式更新规则的 reward-aware 变体。
• REBEL: Reinforcement Learning via Regressing Relative Rewards (2024) — 用回归损失做奖励差值加权，margin 思路的另一种代数形式。
• Proximal Policy Optimization Algorithms (2017) — 原论文里的 adaptive KL penalty 变体（超目标 1.5 倍则 $\beta$ 翻倍），是控制器思路的更早版本。
• Responsive Safety in RL by PID Lagrangian Methods (2020) — 把「惩罚系数就是拉格朗日乘子，乘子更新就是控制问题」这个框架讲透，读完会觉得 $\beta$ 调参不再是玄学。
• What Matters for Model Merging at Scale? (2024) — 权重平均 / model soup 在规模上的系统研究，本书附录 C 引用的那篇。

隐式正则化：RL 为什么忘得少

• SFT Memorizes, RL Generalizes (2025) — 受控实验，把后训练方法当唯一变量。V-IRL 上 80.8% → 91.8%（RL）vs 80.8% → 1.3%（SFT）这组数字值得记住。
• Retaining by Doing: The Role of On-Policy Data in Mitigating Forgetting (2025) — 用前向/反向 KL 解释遗忘。核心洞察是「多模态分布上，mass-covering 反而更具破坏性」，颠覆了单模态直觉。
• RL's Razor: Why Online Reinforcement Learning Forgets Less (2026) — $R^2 = 0.96$ 的遗忘-KL 关系，以及「on-policy 数据完全解释差异、负梯度无影响」的消融。第 8 节那个便宜的遗忘预警指标就来自这里。

2026 的转向：约束采样分布

• Rethinking the Trust Region in LLM Reinforcement Learning (DPPO, 2026) — 用直接估计的散度 mask token，替代 PPO 的逐 token 比值 clip。读它能理解「比值是散度的高噪声单样本估计」这个视角。
• TMax: A Simple Recipe for Terminal Agents (2026) — 少见地把「加 KL 减轻坍缩但降低奖励」这笔账明确写出来的工作，也给出了「不稳定性随 assistant 轮次增长」的具体观测。
• GLM-5: From Vibe Coding to Agentic Engineering (2026) — 明确移除 KL 惩罚「以加速 RL 提升」，同时引入 IcePop 做梯度屏蔽。转向的完整案例。
• Kimi K3: Open Frontier Intelligence (2026) — 配方里既无 KL 惩罚也无参考策略，走得最彻底的一家。

相关章节

• 第 14 章 · 过优化 — 本章的问题定义在那里。不读那一章，本章的所有工具都不知道在防什么。
• 第 8 章 · 直接对齐 — $\pi_\star \propto \pi_{\text{ref}}\exp(r/\beta)$ 这个式子在那里被反解成 DPO 损失。同一个推导，两种用法。
• 第 7 章 · 推理与蒸馏 — 前向/反向 KL 在蒸馏语境下的第一次出场，「为什么反向 KL 更好」这个问题在那里被留到了本章。
• 第 6 章 · 策略梯度 — PPO 的 clip、GRPO 的组内优势、GAE，本章第 4 节讨论 KL 加在哪里时的全部背景。