混合推理论文（思考+非思考）

self-route

“最后一个 token + 全部层拼接” → 送给线性 Router 做二分类（Short vs Long）

with torch.no_grad():
    outputs = model.generate(**inputs, max_new_tokens=200, output_hidden_states=True)
    # outputs.hidden_states: tuple of L tensors, shape (batch, seq, d)
h_all = torch.stack(outputs.hidden_states)        # (L, B, T, d)
h_last = h_all[:, :, -1, :]                       # (L, B, d)
H_cap = h_last.transpose(0, 1).flatten(start_dim=1)  # (B, L*d)
logit = router(H_cap)    

label构造

条件	标签 yi	说明
Short-CoT 正确	1	模型用短链就能做对 → 让 Router 学会“这个问题我能搞定”
Short-CoT 错误 且 Long-CoT 正确	0	短链做不对、长链才能做对 → 必须走 Long 路线
Short-CoT 错误 且 Long-CoT 也错误	丢弃	两种链都错，说明问题超模型上限或数据噪声，不拿来训 Router

ThinkSwitcher

1. 构造训练信号
   对每个训练问题 q：
   – 用 Short-CoT prompt（空 ）采样 k=8 条回答 → 算通过率 y_SC
   – 用 Long-CoT prompt（默认）采样 k=8 条回答 → 算通过率 y_LC
   得到伪标签 (y_SC, y_LC) ∈ [0,1]²，无需人工标注。
2. 提取输入 embedding
   把问题 q 送进同一个 LRM，取最后一层 hidden state 的均值（或 CLS）作为固定长度向量 x_q；维度随 backbone 变大而增大，但仍远小于模型本身。
3. 训练轻量级 Switcher
   Switcher = 5 层 MLP（ReLU+BN+Dropout），最后一层输出 2 维
   [ŷ_SC, ŷ_LC] = f_φ(x_q)
   损失 = MSE(ŷ_SC, y_SC) + MSE(ŷ_LC, y_LC) + λ·MSE(ŷ_LC−ŷ_SC, y_LC−y_SC)
   直接优化“准确率差”的预测，保证路由决策可靠。
4. 推理路由规则
   if ŷ_LC − ŷ_SC ≥ τ (τ∈{0.03,0.04,0.05} 按模型大小调)
   → 用 Long-CoT prompt
   else
   → 用 Short-CoT prompt（空 think 块）
   一条 query 只跑一次 MLP（<14 M FLOPs），相比 LLM 解码（>75 T FLOPs）可忽略。

AutoL2S

AutoL2S 的“路由”不是外挂分类器，而是让模型自己在生成第一个 token 时从词汇表里二选一：

• 先输出 <EASY> → 走 Short-CoT 捷径
• 先输出 <Long Trigger> → 走完整 Long-CoT
  整个决策被压缩成一次 next-token 预测，零额外模块、零阈值调参、零推理开销。

详细流程

1. 训练数据构造
   同一问题 q 准备两条回答：

   • Long：DeepSeek-R1 生成的完整 CoT
   • Short：Qwen2.5-Math-7B + 拒绝采样得到的正确且最短 CoT

   把两条回答拼成一条序列，中间用特殊 token 隔开：

   Question <EASY> Long-CoT <Answer Trigger> ans <Short Trigger> Short-CoT <Answer Trigger> ans
   

   如果一个问题只有 Long 才能答对，则去掉 <EASY> 和 Short 部分，让它只能走 Long 路径。

2. 监督微调
   用普通语言模型损失（cross-entropy）训练基座模型（Qwen2.5-3/7B）去逐 token 复现上述拼接序列。
   模型在训练阶段就学会：

   • 看到简单题 → 先输出 <EASY> → 继续抄 Short 路径
   • 看到难题 → 直接输出 <Long Trigger> → 抄 Long 路径

3. 推理阶段（自动路由）
   给定新问题，模型自回归生成：

   • 若第一个特殊 token 抽到 <EASY> → 自动切换到 Short 模式（后面用 <Short Trigger> 引导）
   • 若抽到 <Long Trigger> → 走默认 Long 模式
     路由决策 = 一次 vocab 采样，耗时 < 1 ms，不引入任何外置网络或阈值。

Self-Braking Tuning

Self-Braking Tuning（SBT）没有外挂路由模块，而是把“要不要继续想”直接做成模型内部的一步 next-token 决策：
当模型在 <think> 里生成一句自然语言“刹车”提示语（例如 “Wait, I’ve verified my answer, no need to continue…”）时，立即结束思维链并给出答案。
因此 routing 被内化成一个自回归生成任务，由模型自己学会在合适时机“踩刹车”。

技术细节

1. 数据构造：先给每条长 CoT 打分

   • 结构效率 ηₛ = 首次答对步数 / 总步数
   • 语言冗余 κₜ = 出现“Wait / Let me double-check / Another way…”等 marker 的比例
   • Overthink Score = 0.9×(1−ηₛ) + 0.1×κₜ
     得分高于阈值 τ（≈0.2）即被判为“过思考”样本。

2. 两种截断策略（= 两种 routing 标签）

   • SBT-E（Exact）：保留 Foundation Solution + 第一条 Evolution Solution，后面全部 mask；在截断处人工插入一句自然语言“刹车”语。
   • SBT-D（Dynamic）：逐步计算 Overthink Score，一旦 > τ₁ 就停止保留，τ₁~τ₂ 之间的片段只做 loss-mask；同样在边界插入“刹车”语。

3. 训练方式
   用标准 next-token 交叉熵损失微调基座模型，被 mask 的冗余段不参与梯度回传。
   模型因此学会：

   • 如果问题简单 → 很快给出答案并自然说出“time to end the thinking”；
   • 如果问题复杂 → 继续演进，直到自我确认足够才说出刹车句。

4. 推理阶段（= 路由执行）
   实时生成 <think> 内容，一旦解码到“刹车”句（或语义等价）就立即插入 </think> 并转 Answer 模式；无需任何外部分类器、阈值或额外前向计算。
   整个“路由”成本 = 0，因为刹车句本身就是模型词汇表里的普通 token。

τ1和τ2

τ₁（主阈值）：
用于判断是否停止保留推理步骤。
当逐步计算某个推理步骤的 Overthink Score 超过 τ₁ 时，就不再继续保留后续步骤（即停止“有效推理”段的构建）。
τ₂（次阈值）：
用于定义**冗余段（masked segment）**的结束位置。
从 τ₁ 开始，继续收集后续步骤，直到 Overthink Score 超过 τ₂ 为止。
这些步骤不会被用于计算损失（loss masking），但模型仍能看到它们，从而学习识别“冗余推理”的模式。

TLDR

和AutoL2S类似，但是添加了动态权重训练

1. 动态重加权训练
   每 32 步在验证集上测一次：
   如果当前平均 token 长度 > 目标上限 → 提高 样本采样权重 λ₁
   如果当前平均 准确率 < 目标下限 → 提高 样本采样权重 λ₂
   权重更新用指数移动平均，保证平滑。

Qwen3

阶段	目标	方法
Stage 1	冷启动思考能力	用长链式思维（CoT）数据微调
Stage 2	强化推理能力	用 RL（GRPO）训练数学/代码任务
Stage 3	融合非思考模式	用混合数据（思考+非思考）微调
Stage 4	通用能力提升	用通用 RL 提升格式遵循、指令遵循、工具使用等能力

第四步，general rl中实现对于think和非think模型的通用控制

Llama-Nemotron

Llama-Nemotron 把“开/关思考”做成一条系统提示（system prompt），推理时把
detailed thinking on 或 detailed thinking off
放在最前面，模型就自动进入长 CoT 或短回答模式——零外置网络、零额外参数、零路由开销。

具体实现

1. 训练阶段
   同一批 prompt 生成两份答案：

   • A 份加 detailed thinking on → 用 DeepSeek-R1 产生长 CoT（含 <think>…</think>）。
   • B 份加 detailed thinking off → 用 Llama-3.1-Nemotron-70B-Instruct 产生简洁回复（不含思考标签）。
     两条样本成对喂给模型，用普通 next-token 损失训练，让它学会看到指令就切换风格。

2. 推理阶段
   用户或下游系统只需在输入最前面插入：

   detailed thinking on      // 进入长链推理模式  
   或  
   detailed thinking off     // 进入快速回答模式  
   

   模型内部靠自回归注意力识别该提示，自动生成 <think>… 或直接给出简短答案；无需任何外部分类器、阈值或额外前向计算。

3. 效果验证
   表 3/4/5 显示：

   • 同一套权重，on 模式在 AIME/GPQA 上得分接近 DeepSeek-R1；
   • off 模式在 IFEval、Arena-Hard 等通用任务上与原 Llama-3.3-70B 持平，同时 token 数减少 50 % 以上。

KAT-V1

1. 数据：think off数据/智能体强化学习生成的think on数据
2. 小模型MTP蒸馏大模型
3. Step-SRPO强化学习：Step-SRPO =「先判断该不该想，再想/答得好不好」两步都给奖励，让 KAT-V1 学会精准开关思考模式，在不损失精度的前提下显著减少 token 消耗

AutoThink

AutoThink 用“省略号 prompt”当开关 + 三阶段 RL 奖励函数，让模型自己学会“什么时候该想、该想多久”，而不是人工指定或一刀切地剪枝。下面按“提示 → 奖励 → 三阶段 → 推理”四张图帮你梳理。

---

1️⃣ 省略号 prompt：把“想/不想”做成可学习的随机开关

• 标准 R1-style 模板
  <think>\n → 模型必写长 CoT
• 作者只加 3 个token：
  <think>\n...\n
  效果：同一模型同一条 prompt，有时立刻 </think>（skip），有时写 1000+ token（think）。
  → 证明模型本来就有潜在双模态，只是缺乏反馈信号来按难度调度。

---

2️⃣ 奖励函数：两条主线、四个数值

用两个布尔量拼出 4 种结果，给不同的即时奖励：

think	correct	奖励	说明
0	1	+2	不思考还能对，最省算力，重赏
1	1	+1	思考后对，正常赏
1	0	0	思考后仍错，不赏不罚
0	0	−1	不思考还错，重罚

后续三阶段都在这个“4 格表”上做加减法，不再靠人工标注长短 CoT。

---

3️⃣ 三阶段 RL：先稳住双模 → 再提正确率 → 再剪冗余

阶段	目标	奖励设计要点	关键技巧
S1 防坍缩	让“想/不想”同时存在，避免模型全押单边	在 S0 奖励上加batch 级平衡系数 δ：当批里 think 比例 z>γ 就压低 think 奖励，反之亦然	线性软惩罚，γ=0.5, λ=2
S2 提性能	在每种模式内把答案做对	退回 S0 原始奖励，不再平衡，给足上下文预算	上下文 8K→16K→24K 逐段放大
S3 剪长度	对的前提下越短越好；错的前提下越长越好（方便自检）	长度归一化 y=(L−μ)/σ，正确样本加 −α·y，错误样本加 +β·y	α=β=0.05，指数衰减

算法底座：全程用 GRPO（group PPO）（G=8 条轨迹/题），token 级 importance sampling + clip。

---

4️⃣ 推理阶段：难度感知自动调度

• 训练后模型在真正困难的 AIME/Olympiad 上仍有 80–90 % think 率；
• 在简单的 MATH500 上 think 率降到 30 %；
• token 用量↓52 %，平均准确率↑6.4 %（1.5B 结果）。

---

5️⃣ 一张脑图总结

省略号 prompt ──► 随机双模 rollout
        │
        ├─S1 batch-balance ──► 双模共存（不坍缩）
        ├─S2 纯正确率奖励 ──► 各模态内“做对”
        └─S3 长度-aware ──► 对则短、错则长
              │
              ▼
         难度感知 think 率
         ↓token ↑acc

→ 核心区别：不是“硬剪”也不是“硬 prompt”，而是让模型自己在 RL 里学会调度思考预算，这就是 AutoThink 对“think 调节”的最简洁答案。

AdaCoT

AdaCoT 把“要不要写 CoT”当成帕累托最优权衡问题，用「SFT 先学双模 → PPO 调惩罚系数 → Selective Loss Masking 防坍缩」三招，让 15B-MoE 模型在生产流量上把 CoT 触发率压到 3.2%，token 省 69%，复杂题仍接近满分。
1️⃣ 目标：把「写不写 CoT」形式化成帕累托优化

• 性能轴 P(θ)：15 套基准平均分
• 成本轴 T(θ)：CoT 触发率（非空即 1）
• 单标量目标
  max θ λP·P(θ) − λT·T(θ)
  通过调 λP/λT 直接滑动帕累托前沿，无需人工定阈值。

2️⃣ 数据：先让辅助模型打“要不要 CoT”标签

• 用内部 15B 教师按 9 条原则（多步/跨域/创意…）给 40 万 query 打 label。
• SFT 数据：67 % 样本带完整 CoT；33 % 给空 <think></think>。
• RL 数据：40 % 需要 CoT，降低数学域比重，防分布偏。

3️⃣ 训练流水线：SFT → 两阶段 PPO（可验证域 + 通用域）

阶段	目的	奖励设计要点	关键技术
SFT warm-up	让模型先会“双模”	空 think 给 0 损失，完整 think 给负对数	统一 tag 格式，保证采样一致性
RL-Math	在可验证题上磨触发边界	R = Rbase − α1·Pmiss − α2·Pover − γ·Pfmt	Selective Loss Masking：把 <think> 后第 1 个 token 的梯度 mask，防分布坍缩
RL-General	滑动 λP/λT 探帕累托前沿	同上，α1∈[0.1,0.3], α2∈[0,0.1] 系统扫描	用 RM+Verifier 双信号，长度惩罚仅对正确样本

4️⃣ Selective Loss Masking（SLM）（核心 trick）

• 问题：数学域几乎“全要 CoT”，后期 PPO 会把决策 token 压成永远 1 → 坍缩。
• 做法：policy gradient 求和时跳过决策 token（think 后首 token）的梯度；模型仍能学答案质量，但触发比例被锚定到 SFT 分布。
• 效果：ablation 显示 SLM 把触发精度从 0.50 → 0.94，F1 从 0.67 → 0.81。

5️⃣ 结果：一条新帕累托曲线
生产流量（1000 条真实 query）

• Full-CoT 基线：触发 100 %，均长 377 token
• AdaCoT-Exp2：触发 3.2 %，均长 117 token（↓69 %），F1=0.814，复杂题准确率无降。

15 套基准平均

• Exp2：62.8 % 分 vs 65.0 % 满分基线，少用 47 % CoT；
• Exp4：64.4 % 分，触发 67 %，已贴满分边界。

一张脑图带走

省略号/人工标签 → SFT 双模预热
        ↓
PPO + 可验证奖励 → 磨“触发边界”
        ↓
SLM 屏蔽决策 token → 防坍缩
        ↓
调 α1/α2 → 滑动帕累托前沿
        ↓
生产：3 % 触发，省 70 % token，复杂题照样 90+

→ AdaCoT 最大亮点：把“写不写 CoT”做成连续优化变量，而不是手工规则；用单模型就能在“极简-满分”之间任意滑动，部署时按预算挑一个 checkpoint 即可。

AdaptThink

AdaptThink 用「约束优化 + 重要性采样」两步 RL，让同一个 1.5 B/7 B 推理模型自己学会“简单题直接答，难题才开想”，在 GSM8K、MATH500、AIME2024 上平均省 50 % token 且再涨 2 % 准确率。

1️⃣ 动机：NoThinking 在简单题已足够好

• 空 <think></think> 触发「直接写答案」模式，在 MATH500 L1-L3 上准确率≈Thinking，长度-80 %。
• 只有 L4-L5 才需要长 CoT。
  → 把「选模式」变成可学习的难度感知决策。

2️⃣ 约束优化：让模型「能关就关」，但不准掉分
目标：
max θ 𝔼x,y∼πθ 𝟙{y₁=} （尽可能 NoThinking）
s.t. 𝔼x,y∼πθ R(x,y) ≥ 𝔼x,y′∼πθ_ref R(x,y′) （精度不低于参考）

转成惩罚形式：
A(x,y)= 𝟙{y₁=}·δ + R(x,y) − R̄_ref(x)
δ>0 是「省 token 奖金」；δ 越大，越倾向关想。

用 PPO 更新，但只在决策 token 处给奖金/罚款，后面内容 token 照常强化 → 模型必须「关想也能写对」。

3️⃣ 重要性采样：解决冷启动「永远开想」
初始 πθ 几乎采不到 NoThinking → 梯度为零。
做法：
πIS(y₁)= 0.5 放  + 0.5 放 w_start（如 “Alright”）
后续 token 仍按 πθ 采样。
训练 batch 里强制 50 % 关想样本，保证两种模式都能学。

4️⃣ 结果：一条新帕累托曲线

模型	数据集	精度变化	长度变化	NoThinking 比例
1.5 B	GSM8K	+4.1 %	−51 %	87 %
1.5 B	MATH500	+1.4 %	−63 %	77 %
1.5 B	AIME2024	+1.6 %	−45 %	40 %
7 B	平均	+2.3 %	−40 %	83 %

• δ 从 0→0.1，NoThinking 比例 50 %→90 %，长度继续掉，精度仍高于纯 Thinking。
• 对比 7 条「只在 Thinking 里剪长度」的 SOTA 基线，AdaptThink 长度最短，精度最高。

一张脑图带走

空 think 触发 NoThinking → 简单题长度-80 % 精度不掉
        ↓
约束优化：A=δ·𝟙{关想}+Acc−Acc_ref  （δ 控制省 token 奖金）
        ↓
重要性采样：batch 内 50 % 强制关想，冷启动消失
        ↓
PPO 更新：决策 token 得奖金，内容 token 照常强化
        ↓
效果：平均省 50 % token，再涨 2 % 精度，难度-触发率自动相关

→ AdaptThink 核心贡献：首次把「开/关想」做成可学习的约束优化变量，而不是手工规则或后剪枝；用单模型就能在「极简-满分」之间任意滑动，部署时按预算挑 δ 即可。

HGPO

首次把「要不要想」做成可学习的混合策略：先 Hybrid-SFT 冷启动双模态，再用 HGPO-RL 按题难度动态选 Thinking/No-Thinking，1.5 B/7 B 模型在 15 套基准上**平均省 30-40 % token，准确率再涨 7-9 %，**简单题关想，难题自动开想。

1️⃣ 问题：LRM 对「Hello」也写 3 k token

• 人类：简单问题 System-1 秒答，复杂问题 System-2 深思。
• 现有 LRM：全部 Thinking，过度思考→延迟↑、成本↑、体验↓。

2️⃣ 目标：一个模型，自适应选 Thinking vs No-Thinking
形式化：
π(q)∈{⊢(Thinking), ⊬(No-Thinking)}，最大化期望效用
U(q,a)=Accuracy−λ·Length

3️⃣ 两阶段训练

阶段	目的	数据 & 目标	关键技术
I. HFT 冷启动	让模型同时会双模，防坍缩	1.7 M 混合语料 Think：R1 蒸馏数学/代码 No-Think：WildChat 日常问答	统一 <think>…</think> <no_think>…</no_think> 格式
II. HGPO-RL	学什么时候选哪一模	76 k 查询，每 query 采样 2×2 回答	组间+组内双奖励 GRPO 估计优势，PPO 更新

4️⃣ HGPO 细节（核心）

1. 采样：同一 query 生成 N/2 Thinking + N/2 No-Thinking。
2. 奖励分配
   • 组间 rinter：哪一模平均分高即赢，赢者 1 输者 0（加 margin δ）。
   • 组内 rintra：每模内部最好答案得 1，其余 0。
3. 优势估计
   At = GRPO(rintra) + 𝟙{mode token}·α·GRPO(rinter)
   → 决策 token（/<no_think>）直接感受「选模」优劣。
4. 目标
   JHGPO = PPO-clip(πθ/πold, At) − β·KL(πθ‖πref)

5️⃣ 新指标：Hybrid Accuracy (HAcc)
用 RM 给双模回答打分 → 把分高或分同且更短的模当作 gt；
模型自选模与 gt 一致的比例即 HAcc，专测「会不会选」。

6️⃣ 结果（1.5 B/7 B 平均）

对比基准	精度提升	长度节省	HAcc
DeepSeek-R1-Distill	+9.2 % / +7.1 %	−30 % / −40 %	—
HFT-DPO	+10.3 % / +13.6 % (AIME24)	再−15 %	93.8 %↑

• 难度感知：MATH500 L1 想率 20 % → L5 想率 95 %，自动对齐。
• 跨域迁移：仅用数学+通用做 RL，代码任务 MBPP 再涨 11 %，DPO/RFT 反而掉分。
• 模型规模：7 B 越大越想省 token（想率↓），1.5 B 能力弱反而多想（想率↑），符合直觉。

7️⃣ 一张脑图带走

空想模板 → HFT 双模冷启动
     ↓
HGPO-RL：组间比“哪模更好”，组内比“谁答更对”
     ↓
决策 token 直接收奖励 → 模型学会“简单题关想，难题开想”
     ↓
生产：平均省 35 % token，精度再涨 8 %，延迟减半

→ LHRM 把「想/不想」做成可滑动的高效-质量旋钮，部署时按业务需求选 δ 即可，无需维护两套模型。

Reference

[1] Self-Route:http://arxiv.org/abs/2505.20664
[2]ThinkSwitcher:http://arxiv.org/abs/2505.14183
[3]AutoL2S:http://arxiv.org/abs/2505.22662
[4]Self-Braking Tuning:http://arxiv.org/abs/2505.14604
[5]TLDR:http://arxiv.org/abs/2506.02678
[6]Qwen3:https://arxiv.org/abs/2505.09388
[7]Llama-Nemotron:http://arxiv.org/abs/2505.00949
[8]KAT-V1:http://arxiv.org/abs/2507.08297
[9]AutoThink:http://arxiv.org/abs/2505.10832
[10]AdaCoT:http://arxiv.org/abs/2505.11896
[11]AdaptThink:http://arxiv.org/abs/2505.13417
[12]HGPO:http://arxiv.org/abs/2505.14631