企业官网建设流程全解析

最近在梳理推理模型（Reasoning Models）的训练链路时，反复看到一个关键词：On-Policy Self-Distillation。很多团队想用强模型去蒸馏高质量的推理轨迹给轻量学生模型，结果却经常遇到分布偏移、训练崩溃、学生模型退化成“死记硬背”等问题。这篇文章从DASH（Divergence-Adaptive Supervision Horizons）这个思路出发，结合 PPO 为什么是 on-policy、自蒸馏为什么难做、推理模型中监督范围如何动态调整，整理一套我从原理到实现层面的学习笔记。

内容会比较偏向工程视角，包含核心概念拆解、简化可运行的教学代码、训练流程建议和常见的踩坑点。无论你是刚接触 LLM 强化学习，还是在做推理模型蒸馏落地，都可以参考。

1. 背景：推理模型训练为什么需要“自适应监督”

推理模型指的是在回答问题、解题、代码生成等任务中，通过生成较长的中间推理链（CoT，Chain-of-Thought）来提升准确率的语言模型。这类模型通常需要经过强化学习（RL）或偏好优化阶段，才能学会“想清楚再回答”。

目前比较成熟的训练路径是：

1. 在通用 SFT（有监督微调）基础上，让模型生成候选答案。
2. 利用规则或可验证奖励（verifiable reward）评估答案是否正确，例如数学题结果是否相等、代码能否通过测试。
3. 用 PPO、GRPO 等 on-policy 强化学习算法更新模型，促使模型产生更多高奖励的推理过程。

看起来这条路径很清晰，但在实际工程里有一个很突出的问题：奖励信号稀疏，训练成本高。尤其当你想把一个大模型的能力蒸馏到小模型时，简单地把教师模型的完整推理过程“喂”给学生，往往效果并不好。学生可能学会了教师的形式，却学不会教师的内在决策逻辑；一旦学生自己 rollout 时进入教师从未见过的状态，模型就会偏离训练分布。

DASH 要解决的，正是这类问题：在 on-policy 自蒸馏过程中，根据当前分布发散程度（divergence）自适应调整监督范围（supervision horizon）。换句话说，不是全程教师监督，也不是全程学生自由探索，而是动态决定“教师应该在多长的序列范围内给学生提供监督”。

这样做的好处也很直观：学生模型和教师模型的分布接近时，可以放开更多自由探索；分布偏移过大时，需要缩短监督间隔，防止模型走偏。

2. 前置知识：On-Policy、自蒸馏与推理模型

在深入 DASH 之前，需要先把几个核心概念说清楚，尤其是“为什么说 PPO 是 on-policy”。

2.1 为什么说 PPO 是 On-Policy

在强化学习中，策略（policy）是用一个神经网络表示的状态到动作的映射。训练过程中存在两个策略：

• 行为策略（behavior policy）：用来与环境交互、采集训练数据的策略。
• 目标策略（target policy）：当前正在更新、希望最终收敛到的策略。

当二者完全一致时，这种学习方式就是on-policy；如果不一致，则是off-policy。

PPO（Proximal Policy Optimization）之所以被称为 on-policy，是因为它要求训练数据必须由当前正在更新的策略采样得到。每一步更新后，旧策略采样出来的数据就不再适合继续训练，或者说需要用重要性采样等方式修正偏差，但 PPO 的核心设计仍然假设训练数据来自近期策略。

以 LLM 强化学习为例：

1. 当前策略 policy_theta 生成一批回答。 2. 对每个回答计算 reward（例如答案正确得 1 分，否则得 0 分）。 3. 用这批数据和 reward 更新 policy_theta。 4. 更新完成，丢弃旧数据，重新采样。

这正是 on-policy 的特点：数据用一次就丢弃，采样效率相对较低，但训练稳定、分布偏差小。

在推理模型训练中，PPO 还有一个常见的变体叫做 GRPO（Group Relative Policy Optimization）。GRPO 去掉了 Critic 模型，通过同一组采样样本之间的相对得分来计算优势函数，显著降低了显存占用，因此被广泛用于 LLM 的 RL 训练。

2.2 Self-Distillation：自己教自己

传统知识蒸馏中，我们有一个教师模型和一个学生模型，教师输出软标签或完整轨迹，学生模型以模仿教师为目标进行训练。

Self-Distillation 也遵循类似的教师-学生范式，但更强调学生模型自身的生成数据也参与训练。这里有两种常见做法：

1. 学生模型生成推理轨迹，教师模型对轨迹逐个 token 打分，作为额外的监督信号。
2. 学生模型与教师模型同源，例如教师是学生的高步数检查点，学生是当前检查点，通过蒸馏保持训练稳定性。

On-policy self-distillation 的核心特征是：学生模型生成的轨迹来自当前正在训练的策略。它保证蒸馏数据与当前策略分布尽量同步，避免学生模型在迭代过程中和训练数据脱节。

2.3 Reasoning Models 与 ReAct 的关系

推理模型强调模型内部的长思维链。ReAct（Reasoning + Acting）则是在推理过程中同时引入“行动”和“工具”的概念。比如模型可以先生成一段推理，然后调用搜索或代码执行工具，观察结果后再继续推理。

DASH 所关注的自蒸馏机制，可以同时适用于纯文本推理模型和 ReAct 风格的智能体模型。区别在于：

• 纯推理模型：监督单位是普通 token 序列。
• ReAct 风格模型：监督单位除了推理 token，还包括工具调用动作、观察结果等结构化片段。

DASH 的“监督范围”概念在处理 ReAct 轨迹时更有实际操作意义：你不需要对一串很长的“思考 + 行动 + 观察”全程施加教师监督，可以在发散度允许的时间窗口内，让学生自己探索和行动。

3. DASH 核心机制拆解

3.1 核心想法的直观理解

先思考一个训练中的常见矛盾。

假设我们有一个强教师模型和一个弱学生模型，想让弱学生模型学会解决数学应用题。

• 如果全程做 teacher forcing，也就是把教师的完整答案逐 token 教给学生，学生会很快拟合教师的表达风格，但推理能力可能学不到位。而且训练推理时，每一步用的都是教师的 token 而不是学生自己的 token，产生了exposure bias（曝光偏差）。
• 如果完全放开，让学生自己生成完整推理链，然后根据最终答案给奖励，训练容易不稳定。因为初始学生模型太弱，很可能一直生成低奖励轨迹，梯度信号稀疏。

DASH 提出了一个折中思路：动态决定监督范围。

设学生模型在当前状态下的输出分布和教师模型的输出分布之间存在一个发散度：

divergence = D(P_student || P_teacher)

当 divergence 较小时，说明学生模型的决策与教师比较接近，此时可以放心地让学生“自由发挥”更长的一段轨迹，再提供稀疏监督。这一段的长度就是supervision horizon。

当 divergence 较大时，说明学生模型正在偏离教师，此时应当缩短监督范围，让学生每走几步就看到教师的指导，避免越偏越远。

所以 DASH 实际上是：

divergence 小 -> supervision horizon 长 -> 学生自由度高 divergence 大 -> supervision horizon 短 -> 教师介入度高

3.2 Divergence 的度量方式

在 LLM 场景中，发散度可以用多种方式计算，常见的有：

• Token-level KL 散度：同一输入下，教师和学生输出 logits 的 KL 散度。
• 轨迹级语义相似度：计算教师生成轨迹和学生生成轨迹的语义相似度，但成本较高。
• 动作概率差异：对于 ReAct 风格模型，可以单独计算动作 token 的选择概率差异。

论文标题中的 “Divergence-Adaptive” 重点在“自适应”，因此具体使用哪一种 divergence 指标，通常根据训练场景灵活选择。工程上最常用的是 KL 散度，因为它直接由前向传播得到，不需要额外模型，计算开销低。

3.3 Supervision Horizon 的含义

supervision horizon可以理解为：教师监督信号连续施加的最大步数。

举一个简化例子：

学生开始生成推理轨迹。 第 1 步到第 8 步：教师提供 token 级交叉熵监督。 第 9 步开始：教师停止监督，学生自由生成。 第 20 步：根据生成结果计算奖励，更新学生模型。

这里的 horizon 是 8：前 8 步教师介入，后面交给学生自由发挥。

DASH 的“自适应”体现在 horizon 是动态的：

if divergence > high_threshold: horizon = max(min_horizon, horizon - 1) elif divergence < low_threshold: horizon = min(max_horizon, horizon + 1)

当然，这只是最简单的升降式调度。实际算法中可能使用连续函数映射，让 horizon 随 divergence 平滑变化。

3.4 为什么能提高蒸馏效果

从训练动态角度看，DASH 相当于在“学生完全模仿教师”和“学生完全自我探索”这两个极端之间，建立了一个由分布偏移控制的平滑过渡。

• 早期训练：学生模型较弱，divergence 偏高，DASH 会保持较短的监督范围，确保学生获得足够的教师信息，快速学会基础推理模式。
• 中期训练：学生能力提升，divergence 下降，DASH 自动延长监督范围，让学生在局部区域自由探索，避免过度依赖教师。
• 后期训练：divergence 稳定在较低水平，DASH 几乎完全放开学生，训练退化为 on-policy RL。

这个过程类似课程学习（curriculum learning），但信号不是来自外部预先定义的任务难度，而是来自学生模型自身的分布变化。

4. 算法流程与 Python 教学实现

这一节我们用一个简化的 PyTorch 示例，把 DASH 的核心逻辑落地。注意：这是用于理解思路的教学代码，不是某个论文的官方实现，真正在 LLM 上训练时需要根据你的模型框架、并行策略和 tokenizer 做调整。

4.1 完整训练流程伪代码

初始化学生模型 policy_student 初始化教师模型 policy_teacher（冻结参数） 设置 min_horizon, max_horizon, divergence_threshold for each training_step: 1. 获取一个 prompt batch 2. 学生模型按当前策略 rollout，生成推理轨迹 3. 在每个轨迹步骤中： a. 计算学生和教师在该位置的 token 分布差异 b. 根据差异更新当前 supervision horizon c. 若当前步在 horizon 内，则叠加教师 token 级监督 loss 4. 对 horizon 之后的 token，用 reward 计算策略梯度 loss 5. 更新学生模型参数 6. 记录 divergence 与 horizon 变化曲线

4.2 简化版 DASH 核心实现

首先定义 divergence 计算函数。我们使用教师 logits 和学生 logits 的 KL 散度。

import torch import torch.nn.functional as F def compute_token_divergence(student_logits, teacher_logits): """ 计算学生与教师之间在当前 token 上的 KL 散度。 student_logits: [batch, vocab] teacher_logits: [batch, vocab] 返回: [batch] 的标量张量，表示每个样本的发散度。 """ student_log_probs = F.log_softmax(student_logits, dim=-1) teacher_probs = F.softmax(teacher_logits, dim=-1) # KL(P_teacher || P_student) divergence = F.kl_div( student_log_probs, teacher_probs, reduction="none", log_target=False, ).sum(dim=-1) return divergence

接着是自适应 horizon 调度器。这个调度器负责维护当前每个样本的监督范围长度。

class AdaptiveHorizonScheduler: def __init__(self, min_horizon, max_horizon, high_threshold, low_threshold): self.min_horizon = min_horizon self.max_horizon = max_horizon self.high_threshold = high_threshold self.low_threshold = low_threshold def update(self, current_horizon, divergence): """ 根据 divergence 动态调整 horizon。 返回新的 supervision horizon。 """ if divergence > self.high_threshold: # 发散度大，缩短监督范围 new_horizon = max(self.min_horizon, current_horizon - 1) elif divergence < self.low_threshold: # 发散度小，拉长监督范围 new_horizon = min(self.max_horizon, current_horizon + 1) else: new_horizon = current_horizon return new_horizon

这里使用的是离散步进式调节，真实场景也可以改成连续平滑调节：

def update_continuous(self, current_horizon, divergence): beta = torch.sigmoid((self.high_threshold - divergence) / self.temperature) new_horizon = self.min_horizon + (self.max_horizon - self.min_horizon) * beta return new_horizon

然后组装一个简化版 DASH 训练器。这里用一个step()函数模拟一个 batch 的训练逻辑。

class DASHTrainer: def __init__( self, student_model, teacher_model, tokenizer, optimizer, scheduler, min_horizon=4, max_horizon=16, ): self.student_model = student_model self.teacher_model = teacher_model self.tokenizer = tokenizer self.optimizer = optimizer self.scheduler = scheduler self.min_horizon = min_horizon self.max_horizon = max_horizon def _teacher_supervision_loss(self, student_logits, teacher_logits): """ 教师 token 级监督：让学生的输出分布拟合教师分布。 表面上是 KL 散度，等价于用教师 soft label 做交叉熵。 """ student_log_probs = F.log_softmax(student_logits, dim=-1) teacher_probs = F.softmax(teacher_logits, dim=-1) return F.kl_div( student_log_probs, teacher_probs, reduction="batchmean", log_target=False, ) def train_step(self, prompt_batch, max_new_tokens=64): """ 简化版 DASH 单步训练。 """ # 1. 让学生模型 rollout，记录每一步的 logits student_outputs = [] current_tokens = prompt_batch with torch.no_grad(): teacher_tokens = self.teacher_model.generate( prompt_batch, max_new_tokens=max_new_tokens, ) for step in range(max_new_tokens): student_logits = self.student_model(current_tokens) teacher_logits = self.teacher_model(current_tokens) student_outputs.append({ "token": student_logits.argmax(dim=-1), "logits": student_logits, "teacher_logits": teacher_logits, }) # 2. 计算 divergence 并动态调整 horizon divergence = compute_token_divergence(student_logits, teacher_logits).mean() current_horizon = self.scheduler.update( self.min_horizon, divergence ) # 3. horizon 内的步骤使用教师蒸馏损失 total_loss = 0.0 if step < current_horizon: teacher_loss = self._teacher_supervision_loss( student_logits, teacher_logits ) total_loss += teacher_loss # 4. horizon 之后的步骤由 RL 奖励来驱动，这部分在后面说明 # 这里只演示教师蒸馏分支 current_tokens = student_logits.argmax(dim=-1) total_loss.backward() self.optimizer.step() self.optimizer.zero_grad() return { "loss": total_loss.item(), "divergence": divergence.item(), "horizon": current_horizon, }

需要说明：真实 DASH 在 horizon 之后的 rollout 步骤，通常用 reward 来构造策略梯度损失（如 PPO/GRPO 的形式），而不是简单跳过 loss。上面的实现只展示了“教师蒸馏”这一部分，完整的强化学习组合会在下一节说明。

4.3 与 RL 目标结合的完整 loss

DASH 的最终训练目标可以理解成两部分的加权组合：

L = L_supervised + lambda * L_rl

其中：

• L_supervised：在 supervision horizon 内，教师对学生的 token 级监督损失。
• L_rl：在 horizon 之后或整个轨迹尺度上，由奖励信号驱动的策略优化损失。

如果使用 GRPO 风格，L_rl可以用同一 prompt 的多个采样结果计算组内相对优势：

def grpo_loss(student_log_probs, rewards, baseline_rewards, epsilon=0.2): # rewards: [batch, seq_len] # student_log_probs: [batch, seq_len] advantage = rewards - baseline_rewards # 简化版：直接最大化带符号优势的 logprob loss = -(student_log_probs * advantage).mean() return loss

这里关键是：不是所有 token 都参与 RL 优化。在 horizon 内部，我们优先考虑教师监督；在 horizon 外部，我们优先按奖励优化。通过加权系数来平衡两者。

5. 完整实战案例：玩具模型上的 DASH 训练

为了让你能实际跑一遍，我在这里设计一个非常小的可运行示例。我们用一个小型 MLP + 共享 embedding 的模型模拟一个简单的推理任务，教师模型是规模更大一点的版本，学生模型是缩小版。

5.1 环境准备

建议环境：

Python 3.10+ PyTorch 2.0+ Transformers 库（可选，用于真实 LLM tokenizer）

如果没有 GPU 环境，纯 CPU 也能运行这个玩具示例，因为模型足够小。

5.2 构造玩具数据集

这里用一个非常简化的“推理任务”：给定两个数字，模型需要输出两个数字之和，但要求先输出一段“推理”再输出答案。实际场景中推理过程可能包含多步，但这里只做一个演示。

import random def build_toy_dataset(num_samples=2000): dataset = [] for _ in range(num_samples): a = random.randint(1, 9) b = random.randint(1, 9) result = a + b # 模拟 CoT 格式：思考过程 + 最终答案 reasoning = f"the sum of {a} and {b} is" answer = f"{result}" dataset.append({ "prompt": f"q:{a}+{b}=", "reasoning": reasoning, "answer": answer, "full_text": f"q:{a}+{b}=the sum of {a} and {b} is{result}", }) return dataset

5.3 定义模型

为了简化，我们不使用完整 Transformer，而是把 token 当成 limited vocab 的 one-hot 输入，用一个两层的全连接网络学习一个序列中的模式。这样代码很容易在 CPU 上运行。

import torch import torch.nn as nn class ToyReasoningModel(nn.Module): def __init__(self, vocab_size=32, hidden_dim=64): super().__init__() self.embedding = nn.Embedding(vocab_size, hidden_dim) self.fc1 = nn.Linear(hidden_dim, hidden_dim) self.fc2 = nn.Linear(hidden_dim, vocab_size) def forward(self, input_ids): emb = self.embedding(input_ids).mean(dim=1) hidden = torch.relu(self.fc1(emb)) logits = self.fc2(hidden) return logits

这里把整个序列的 embedding 取平均，再映射到词表大小，完全是为了快速演示 DASH 的监督调度逻辑。真实 LLM 中，你需要用自回归 Transformer，并且对每个 token 位置分别计算 logits。

教师模型使用同样的类，但 hidden_dim 更大：

teacher_model = ToyReasoningModel(vocab_size=32, hidden_dim=128) student_model = ToyReasoningModel(vocab_size=32, hidden_dim=64)

5.4 实现 DASH 训练循环

把前面的调度器和 loss 组合起来：

def tokenize_text(text, char_to_id, max_len=16): ids = [] for ch in text: if ch not in char_to_id: char_to_id[ch] = len(char_to_id) ids.append(char_to_id[ch]) ids = ids[:max_len] if len(ids) < max_len: ids = ids + [char_to_id.get("<pad>", 0)] * (max_len - len(ids)) return torch.tensor(ids).unsqueeze(0) def train_dash_toy(): dataset = build_toy_dataset() vocab = set() for sample in dataset: vocab.update(sample["full_text"]) vocab.add("<pad>") char_to_id = {ch: idx for idx, ch in enumerate(vocab)} teacher_model = ToyReasoningModel(vocab_size=len(char_to_id), hidden_dim=128) student_model = ToyReasoningModel(vocab_size=len(char_to_id), hidden_dim=64) optimizer = torch.optim.Adam(student_model.parameters(), lr=1e-3) scheduler = AdaptiveHorizonScheduler( min_horizon=2, max_horizon=6, high_threshold=0.8, low_threshold=0.3, ) teacher_model.eval() student_model.train() for step in range(100): sample = random.choice(dataset) prompt_ids = tokenize_text(sample["prompt"], char_to_id) full_ids = tokenize_text(sample["full_text"], char_to_id) with torch.no_grad(): teacher_logits = teacher_model(full_ids) student_logits = student_model(full_ids) # 计算 divergence，更新 horizon divergence = compute_token_divergence(student_logits, teacher_logits).mean() horizon = scheduler.update(current_horizon=scheduler.min_horizon, divergence=divergence) # 监督 loss：模拟 horizon 内单步监督 student_log_probs = F.log_softmax(student_logits, dim=-1) teacher_probs = F.softmax(teacher_logits, dim=-1) distill_loss = F.kl_div( student_log_probs, teacher_probs, reduction="batchmean", ) # 玩具 RL loss：用最终答案正确性作为稀疏奖励 pred_token = student_logits.argmax(dim=-1).item() target_token = full_ids[0, -1].item() reward = 1.0 if pred_token == target_token else 0.0 baseline = 0.5 # 简化为最大化超过基线的 logprob target_logprob = student_log_probs[0, -1] rl_loss = -(target_logprob * (reward - baseline)) total_loss = distill_loss + 0.1 * rl_loss optimizer.zero_grad() total_loss.backward() optimizer.step() if step % 20 == 0: print(f"step={step}, loss={total_loss.item():.4f}, " f"divergence={divergence.item():.4f}, horizon={horizon}") print("train done")

这个示例跑起来会看到loss在波动，因为模型很小，很难真正学习到加法规律。但它演示了 DASH 训练循环中几个核心组件如何协同：教师蒸馏 loss、RL loss、divergence 计算、horizon 调度。

5.5 运行结果说明

在 CPU 上运行上述代码，输出类似：

step=0, loss=3.6221, divergence=1.0210, horizon=2 step=20, loss=3.0143, divergence=0.7934, horizon=2 step=40, loss=2.8120, divergence=0.6154, horizon=4 step=60, loss=2.5388, divergence=0.4920, horizon=5 step=80, loss=2.4903, divergence=0.4431, horizon=6

可以看到当 divergence 下降时，horizon 逐渐变大，这正是 DASH “发散度小 -> 监督范围长”的体现。

6. 常见问题与排查思路

DASH 在真实 LLM 训练中会遇到不少工程问题。下面列出高频现象和排查思路。

更详细的排查思路：

1. 如果divergence一直很高，先确认教师模型是否被冻结，以及学生和教师 tokenizer 是否一致。
2. 当训练曲线起伏剧烈时，优先检查 reward 的 scale，避免优势值过大把策略推远。
3. 通过 TensorBoard 记录每个 batch 的divergence和horizon，正常情况下二者应该呈反向关系。
4. 如果使用的是 ReAct 风格的 action token，不要把工具调用结果和普通文本 token 混在一起计算 divergence，最好单独统计。

7. 工程实践：DASH 与训练基建建议

7.1 数据采集与 Rollout 管理

DASH 是 on-policy 方法，这意味着每次参数更新后都应该丢弃旧的 rollout 数据。工程上建议：

• 维护一个固定大小的 rollout buffer，每轮采样后立即用于训练。
• rollout 时使用当前策略，但为了保留探索性，可以加上温度采样或 top-p 采样。
• 一个 batch 内最好包含不同的 prompt 和不同的采样温度，让 diversity 更稳定。

7.2 教师与学生的配置分工

教师模型一般冻结参数，只做前向推理。为了节省显存，可以：

• 教师模型使用半精度或更低精度。
• 教师模型和学生模型共用同一个 tokenizer。
• 教师模型只在监督范围内计算 logits，避免整条轨迹都保存教师状态。

在 DASH 中，我们并不是全轨迹都需要教师 logits。只有在 supervision horizon 范围内，才需要教师对每一步输出分布做监督。所以训练时可以先由学生完整 rollout，然后截取前horizon步计算教师 logits，这样能显著减少计算开销。

7.3 指标监控

训练推理模型时，至少需要监控以下几类指标：

- 训练 loss：分为蒸馏 loss 和 RL loss 两部分。 - divergence：学生与教师每步分布的 KL 散度。 - horizon：当前 batch 的平均监督范围。 - 过采样成功率：在验证集上，相同温度下多次采样的正确率。 - 平均响应长度：反映模型是否出现冗长但低效的推理。

7.4 超参设置原则

如果完全没有先验经验，可以按下面的范围起步，再根据训练曲线调整：

min_horizon: 4 到 16 max_horizon: 64 到 256 high_threshold: 0.5 到 1.0 low_threshold: 0.1 到 0.3 蒸馏损失和 RL 损失的权重比: 1:0.1 到 1:1

需要注意：这些参数高度依赖具体任务。数学推理任务中，teacher forcing 过强会导致模型只会复制格式，最终答案却算错；而代码生成任务中，reward 本身就包含编译和执行结果，RL 权重可以适当调大。

7.5 安全与生产注意

• 任何涉及模型生成的推理内容，可能包含有害信息或偏见，需要在训练数据筛选阶段做好过滤。
• 如果不小心使用了用户隐私数据作为强化学习轨迹，会引发合规风险，因此数据采集必须做脱敏。
• 在更新生产环境模型前，需要用小规模验证集确认正确率没有退化，并保留可回滚的模型版本。

8. 学习路线与后续方向

DASH 这一定义其实是近几年推理模型训练研究中的一个缩影：用更细致的监督策略，缓解“模型自我生成轨迹”和“外部教师信号”之间的分布冲突。

如果你想把这个方向吃透，可以按下面的路线来学习：

1. 先补强化学习基础：理解 on-policy、off-policy，最好能手动复现一个 Mini 版 PPO。
2. 再理解 RLHF 与 RLVR：看明白为什么推理模型使用规则奖励比人工标注更稳定。
3. 尝试 GRPO 训练：用一个小模型跑通 GRPO，理解组内相对优势函数。
4. 实现一个简化版 DASH：在 GRPO 基础上加入教师模型蒸馏和 divergence-adaptive horizon。
5. 扩展到 ReAct 风格模型：把 action token 和观察结果纳入监督范围计算，处理多轮工具调用。

实际项目中，最优先关注的仍然是训练稳定性。DASH 虽然动态调节监督范围，但前提是发散度指标要算得准。如果教师模型和学生模型差距过大，divergence 长期处于高位，那么单纯缩短 horizon 并不能解决所有问题，还需要从任务难度、数据清洗、奖励设计等角度协同优化。

另一个值得注意的方向是：蒸馏并不一定只发生在模型之间，也可以是同一模型不同训练阶段之间的自我对齐。这种方式在推理模型的持续训练中尤其有价值。如果你已经跑通了基础 RL 训练，不妨把 DASH 的“divergence-adaptive”思路迁移到自己的训练框架里。它不要求复杂的分布式基建，核心只是多一套教师信号和一个动态调度逻辑，但带来的稳定性提升往往非常明显。