章节总览
Agent 工程与轨迹数据 / 27 · 正文
原目录

完整连接 Code Agent 训练体系、三档思考模式、逐轮门控、数据策略、奖励和验证设计。

多维表格 Code Agent 训练体系与 Auto-Thinking 完整解析

本文档整合了多维表格 Base AI Post Training 团队的 Code Agent 训练方案、Auto-Thinking 完整训练方案的深度解读,以及相关核心概念的系统梳理,并附 Auto-Thinking 原始文档全文。

资料来源:企业内部文档《多维表格 Base AI Post Training 团队核心思路深度解析》(v4/v5/v5.1)、《多维表格 CodeAgent:Auto-Thinking 的 SFT 与 RL 完整训练方案》(王哲,2026.07.30)


目录


第一部分:多维表格 Code Agent 训练体系总览

一、核心架构:CodeAct

Code Agent 采用 CodeAct 范式而非传统 Function Calling:LLM 直接生成 TypeScript 代码,通过 @bitable/agent-sdk 在沙箱中执行。

执行链路

用户需求 → LLM 生成 TS 代码 → 沙箱编译(tsc) → 试运行 → 正式执行 → 返回结果

执行采用 ReAct 模式(最多 20 步),编译失败时模型根据错误信息自动修复,最多重试 8 次。

CodeAct vs Function Calling

维度 Function Calling CodeAct
表达能力 受限于预定义工具 schema 图灵完备,可表达循环、条件、变量等任意逻辑
组合性 多步操作需要多轮对话 一次代码可完成多表创建+字段关联+视图配置
纠错能力 依赖模型理解工具返回值 编译器/运行时提供结构化错误信息,模型可直接修复
扩展性 新操作需新增工具定义 SDK 新增 API 即可,模型自动适配

关键组件

  • LLM:理解意图,生成代码,根据错误修复
  • Base Agent SDK:提供操作多维表格的 TypeScript API
  • 沙箱(Sandbox):隔离的 Node.js 执行环境,支持本地和 VeFaaS 远程两种模式
  • 工具集:write_file / edit_file / read_file / run_file / refuse_request

二、数据合成方案

训练数据主要通过三种方式构建:

1. 多 Agent 协作合成

SFT 训练数据通过多 Agent 协作方式合成,模拟真实用户场景:

User Agent(模拟用户提出需求)
  → Supervisor Agent(拆解需求,生成 spec)
    → Code Agent(基于 spec 生成代码)
      → Judge Agent(评估代码质量)

核心脚本位于 train/scripts/ 下:

  • gen_agent_trajectories.ts:生成轨迹
  • trajectory_builder.ts:构建训练格式
  • trajectory_judge.ts:质量评判
  • synthesize_v2.ts:合成主流程

数据经多层清洗(train/clean/)和质量检查(train/docs/QUALITY_CHECKLIST.md)。

2. 蒸馏数据提取

可从评测产物中提取训练样本,支持多种来源:

来源 说明
from-traces 从 Agent trace JSON 批量抽取
from-eval 从 eval results + traces 目录抽取(含 write_spec 时优先用模型写的 spec)
from-results 从 eval report JSON 抽取(零 trace),可选仅保留编译通过样本
merge-csv 从 lite_doc CSV + trajectories 对齐

输出 JSONL 每行字段:query_id、spec_doc、code、query、spec_source、compile_ok、model、judge_score 等。

3. 数据增强策略

  • 基于母本/种子的 Rewrite:Goal 不变、FinalCode 不变,语义等效改写 Context
  • React 轨迹合成:注入不影响编译运行的瑕疵,生成单 Query 双轮 React 轨迹
  • 编译/运行错误 Fix 训练:针对错误修复的专项数据
  • 多路集成:高阶模型(GPT5.4/GLM)+ 后训练模型 + Query→Spec→Code 路径交叉验证

三、训练方法论体系

1. 直接 SFT(基线方法)

最简单朴素方法,作为训练迭代的基线。

2. 课程训练(当前主力,5 月建立)

核心思想:先易后难,先让模型在容易的评测上拿高指标,再逐步提升难度。

课程阶段 训练样本要求 训练方法
阶段一:编译执行通过率、单测通过率 编译执行必须通过,Judge 可以不过 SFT + RLVR
阶段二:机评 Judge、人评满分率 机评 Judge 必须通过(允许少量不影响核心的瑕疵) SFT/RFT + RL(长度惩罚+Code GT参考+单测+LLM Judge)

关键技巧(5 月验证有效):

  • Q&A 预训练:内化 SDK、Skill、工具调用知识,运行通过率 +13.3%
  • 工具增强 2.0:强化 Agent 持续规范调用工具的能力
  • mask 修复路径:学习编译/执行失败后的修复闭环,运行通过率 +15%
  • 精简 skill/SP:压缩冗余上下文,降低长上下文负担

3. 多阶段混合训练(方法论指导)

借鉴 Cursor、DeepSeek、GLM 等技术报告:

  1. 冷启动(少量优质 SFT 数据)
  2. RL 专项任务训练
  3. 基于训练模型的拒绝采样(关注采样接受率)
  4. 补充通用数据,SFT+RL 混合训练(避免灾难性遗忘)

课程训练和多阶段训练相辅相成。但训练数据的质量始终是最基础最重要的。

4. RL GRPO 训练(当前主力)

采用 **GRPO(Group Relative Policy Optimization)**算法:

  • 每条训练样本产生 8 条并行轨迹,做组内相对排名
  • 三层 Reward 架构:
层级 内容 权重
L1 编译检查(tsc),失败短路返回 0 0.1
L2 真实执行(当前关闭,64% case 不可执行) -
L3 语义评估(vitest 单测 + LLM Judge) 0.9
  • Reward 计算:编译失败=0;编译通过但测试全挂=0.1;编译通过+部分测试通过=0.1~1.0
  • 训练数据 194 条,单测覆盖率 100%,按 W1/W2/W3 权重分配操作类型

5. Auto-Thinking 架构(下一代方案,探索中)

让模型自主决定"何时思考、思考多深",三档模式:

  • DIRECT(85.5%):直接执行,不输出 thinking
  • THINK_SHORT(12%):64~128 token 短思考
  • REPLAN(2.6%):128~192 token 重规划

每个 ReAct turn 引入 Gate token(<|mode_direct|> 等),SFT 分三阶段冷启动 → Gate warm-start → 联合对齐,RL 分 R1(正确性)→ R2(Gate 与修复)→ R3(Pareto 压缩)三阶段。

四、当前训练进展与效果

SFT 进展

  • spec 带 form 数据补充合成(554 条),解决 form 能力边界
  • spec lite 1.0 数据合成(含 Plan→Spec 改写,660 条)
  • mockdata 数据修复
  • 计划合成 300 条 form + 300 条 Building 1.0 能力数据
  • 现有 SFT 数据集回扫(SDK/Plan 对齐)

SFT 性能:

模块 基础版 PE 版
Table 76 82
Dashboard 76 75
Workflow 82 81
Permission 80 75
Form - 79
Spec lite 1.0 60 -

RL 第一版 E2E 评测(5,888 条有效轨迹)

指标 数值
编译通过率 99.47%
执行通过率 86.50%
编译执行 Pass@1 40.61%
平均编译尝试次数 2.10 次
E2E Judge 通过率 24.59%
E2E Judge 均分 7.024 / 10
最终 reward 均分 6.287 / 10
严格 E2E 成功率 21.25%

分模块诊断

模块 执行通过率 E2E Judge 通过率 诊断
Table 85.61% 49.75% 最稳定,无 Judge 调用错误
Dashboard 86.33% 23.60% Judge 均分最高(8.418)但严格通过率不高
Workflow 85.16% 20.99% Reward 均分最低(5.5),Judge 调用错误占 87.25%
Permission 93.43% 4.64% 执行最好但 Judge 最差,瓶颈在产物语义而非可执行性

训练趋势(step 1→23)

  • 执行通过率:81.25% → 94.92%(+13.67pp)
  • Pass@1:41.80% → 53.52%(+11.72pp)
  • Reward 均分:5.390 → 7.043(+1.653)

关键发现

  1. 主要瓶颈已从"能否编译"转向"修复成本和实际执行":编译率已达 99.47%,但 Pass@1 仅 40.61%
  2. Permission 模块问题不在代码可执行性,而在产物语义:执行通过率最高但 Judge 通过率最低
  3. Workflow 同时存在质量和 Judge 稳定性问题:178/204 次 Judge 调用错误来自 Workflow
  4. 训练对"可执行性"的改善比对"最终产物完全通过 Judge"的改善更稳定

五、训练平台

平台 用途
方舟(Ark) 用于 doubao 系列模型的 SFT/RL 训练
Merlin 用于开源模型(如 Qwen 3.5 9B/27B)的训练

SFT 后的模型 checkpoint 作为后续 RL 训练的基座。


第二部分:Auto-Thinking 文档深度解读

文档:《多维表格 CodeAgent:Auto-Thinking 的 SFT 与 RL 完整训练方案》 作者:王哲 日期:2026.07.30 适用场景:多维表格的搭建、修改和修复;已有约 5,000 条 DIRECT SFT 数据,计划少量补充 THINK_SHORT 与 REPLAN 作为能力冷启动,Auto-thinking 的最终决策边界主要通过线上 query 的 RL 学习;可使用编译/执行工具与"产物是否正确构建"的 JudgeRewardModel。

一、要解决的根本问题

当前 CodeAgent 已有约 5,000 条 DIRECT SFT 数据(模型不输出思考,直接写代码调工具),效果不错但有明显短板:

  • 终局 Reward 太稀疏:一次失败只给一个 terminal_success=0,模型不知道是理解错需求、表结构设计错、字段 ID 用错、公式依赖不对,还是漏了验证。长代码中的大量 token 收到相同的负 advantage,学不到可迁移的错误归因。
  • 修复效率低:第一次失败后往往要多轮 ReAct 才能修好,甚至出现语义重复(状态没变、动作没变、还在反复试)。
  • 两个极端都不好:所有轨迹都加长 CoT → 成本高、可能事后编故事;完全不思考只靠终局 RL → credit assignment 差、恢复泛化弱。

核心目标:提高 Pass@1;第一次失败后尽量一次修好;简单状态直接做,只有思考确实能改变决策时才思考或重规划。

目标函数

把一次轨迹的效用写成:

U(τ)=Rcorrect−Cregression−λtCtool−λzCthinking−λwCwalltime−λrCrepeatU(\tau) = R_{\text{correct}} - C_{\text{regression}} - \lambda_t C_{\text{tool}} - \lambda_z C_{\text{thinking}} - \lambda_w C_{\text{walltime}} - \lambda_r C_{\text{repeat}}

优化优先级应是字典序,而不是简单把所有项等价相加:

安全、权限与数据完整性
> 任务功能正确
> 无回归
> 一次恢复成功
> 少重复、少工具调用、低时延、短 thinking

原因:一次 64-token 的短 thinking 如果能避免一次昂贵的构建和两轮错误修复,总成本反而更低。只惩罚 thinking token 会把 Gate 推向永远 DIRECT;只奖励成功又会把 Gate 推向永远 THINK 或 REPLAN。

核心指标

指标 定义
Pass@1 / First-pass success 第一次完整产物提交后直接通过全部验收
First-repair success 第一次失败后,仅允许一次修复时的成功率
Conditional recovery 首次失败条件下最终恢复成功率
Median recovery turns 成功恢复所需的中位修复 turn 数
Semantic repeat rate 状态未变化、动作语义重复且无新增信息的比例
Noisy-feedback overreaction 环境噪声或存量错误导致无关代码修改的比例
Premature-stop rate 未完成或未验证就输出 done 的比例
Regression rate 目标需求通过但破坏已有表、字段、视图、公式或数据的比例
Unnecessary-thinking rate DIRECT 足够成功但 Gate 选择 THINK/REPLAN 的比例
Thinking-necessity recall THINK/REPLAN 明显优于 DIRECT 时,Gate 选择非 DIRECT 的比例
Replan precision 选择 REPLAN 的状态中,确实存在核心假设失效的比例
Mode regret 同状态最优模式效用减去 Gate 所选模式效用
Success cost 每次成功的 thinking tokens、工具次数、执行时延和计算成本

其中 ModeRegret 是判断 auto-thinking 是否真的学会的核心指标:

ModeRegret(s)=max⁡mU(s,m)−U(s,m^)\text{ModeRegret}(s) = \max_m U(s,m) - U(s,\hat m)

仅看线上 THINK 占比没有意义:10% 可能过多,也可能远远不够。

离线验收目标

Pass@1:相对基线显著提升
First-repair success:相对基线提升幅度高于最终成功率提升
Semantic repeat rate:下降 30% 以上
Unnecessary-thinking rate:控制在 10%~15% 以内
Thinking-necessity recall:达到 85%~90%
Replan precision:达到 70%~80%
成功轨迹的工具调用 P50:不高于基线

二、三档模式 + 逐 turn Gate

为什么"短思考链 + RL"通常优于"直接代码 + RL"

直接代码 RL 的学习信号过于稀疏:不带显式 thinking 时,策略近似为 πθ(a∣s)\pi_\theta(a \mid s),若只有终局 Reward,一次失败会把相似的负 advantage 分配给长代码中的大量 token,但 Reward 并不明确告诉模型具体哪里错了。

短 thinking 把大动作分解成可学习的中间变量:引入模式 mm、短决策变量 zz 和动作 aa:

πθ(m,z,a∣s)=πg(m∣s) πz(z∣s,m) πa(a∣s,m,z)\pi_\theta(m,z,a\mid s) =\pi_g(m\mid s)\, \pi_z(z\mid s,m)\, \pi_a(a\mid s,m,z)

带来三个额外价值:

  1. 很多表面不同的错误可以映射到同一可迁移类别(如 schema_reference / last_diff / repair_reference),相当于在高维代码空间中增加了低维的故障与决策表示
  2. zz 提供了可验证的 RL 支撑点:可检查 attribution 是否与证据一致、decision 是否与 action 一致、expect 是否被下一次 observation 证实
  3. 改善多轮 credit assignment:ReAct 本质上是 MDP,短 thinking 提供了过程标签

从数据密度看:直接 RL 的一条失败轨迹通常只有 terminal_success = 0;带短 thinking 后,可以得到 error_type_correct、attribution_correct、decision_action_consistent、expected_observation_match、state_progress、terminal_success 等一组过程标签。

必须保留的边界:thinking 不是天然可信。显式思考可能是事后合理化,也可能与真实决策因果无关。必须同时检查 observation → evidence/attribution → decision → action → next observation,并做置空、置换和 decision 干预实验。

三种模式的精确定义

DIRECT

适用条件:

  • 需求清晰且是熟悉、局部、低风险的操作
  • 工具反馈唯一对应一个机械修复
  • 已有充分证据,不需要新增假设
  • 验证通过后应直接停止
  • 环境错误有确定的重试或切换 scoped check 动作
  • 思考不会改变下一动作

DIRECT 不等于不看上下文,也不等于不验证。它只是"不生成显式 thinking token"。

THINK_SHORT

适用条件:

  • 工具反馈需要区分 last_diff / baseline / environment / unknown
  • 有两个以上局部候选解释,但原方案仍基本成立
  • Judge 指出产物不符合需求,需要定位遗漏的验收条件
  • 第一次相关失败出现,需要在继续修复、回滚、重试或停止中选择
  • 一段短归因能够显著降低下一动作出错概率

不推荐固定字段或固定句式。通常用 1~3 句自然语言说明:当前反馈最可能说明什么、为什么选择下一动作、下一次检查应看到什么变化。

低价值反例是只有空泛结论,例如"检查失败了,我需要修复并验证",因为它没有使用当前反馈,也不能约束下一动作。

REPLAN

适用条件:

  • observation 证伪了当前方案的核心假设
  • 连续修复没有带来状态进展,且原因不是环境噪声
  • 原数据模型无法满足联表、汇总、公式或自动化约束
  • 需要跨表、字段、视图和自动化重新安排依赖顺序
  • 当前 diff 不断扩张,继续局部补丁的预期成本高于回滚重做
  • 用户意图被根本误解

REPLAN 同样使用自然语言,不输出字段清单。它通常用一个短段落说明:哪条核心假设已经站不住、哪些现有成果仍应保留、方案应如何改变,以及先验证哪一步。

REPLAN 不是"更长的 THINK_SHORT",而是方案边界发生变化。默认每条训练轨迹最多一次 REPLAN;再次 REPLAN 通常说明任务、工具环境或数据质量需要人工审查。

THINK_SHORT 与 REPLAN 的核心区别

最实用的判断问题:

在不改变对用户目标、数据模型和主要实现路径的理解时,能否通过一个局部动作取得可验证进展?

能,而且下一动作已经唯一明确 → DIRECT
能,但需要先消除局部歧义、判断错误归因或选择修复动作 → THINK_SHORT
不能;反馈已经推翻核心假设,继续局部修改不会解决根因 → REPLAN
维度 THINK_SHORT REPLAN
核心方案 仍然成立 已被证伪或已明显不经济
主要问题 局部诊断、归因或动作选择不确定 用户目标、数据模型、依赖关系或实现路径存在根本错误
改动范围 通常是一个局部对象或相邻依赖 通常跨多个对象、阶段或依赖关系
对已有修改的态度 大部分保留,只修正局部问题 明确保留可信部分,并回滚或替换失效部分
thinking 的任务 解释"为什么下一步这样修" 解释"为什么原路走不通,以及新路径是什么"
下一步动作 一个高置信度 repair、retry、verify 或 rollback 新计划中的第一个可验证里程碑
典型 token 预算 64~128,硬上限 160 128~192,硬上限 256
使用频率 少量但可重复出现 稀有,普通轨迹通常最多一次

不要用以下表面信号直接触发 REPLAN:日志很长、错误数量很多、已经失败过一次、THINK_SHORT 接近 160 tokens、任务本身看起来复杂。

Gate token 机制

Auto-thinking 不是在任务开始时只决定一次"整条轨迹是否思考",而是在每个 ReAct turn 根据新状态重新选择。

推荐用三个显式 reasoning-mode token 作为 Gate 输出:

<|mode_direct|>
<|mode_think_short|>
<|mode_replan|>

它是模型内部的一 token 元推理决策,不是 tool call,也不是让 serving 启动不同外部工作流的控制命令。整个过程仍是一次连续的自回归生成:

当前状态 s_t
→ 模型生成 mode token m_t
→ m_t 保留在模型上下文和 KV cache 中
→ 模型继续生成自然语言 thinking、action 或 tool call

Serving 只需缓存并剥离第一个 mode token,不把它返回给用户;该 token 仍然参与后续生成的条件上下文。

Gate token 的价值

加入显式 mode token 后,策略更容易分解为 π(m,y∣s)=πg(m∣s)π(y∣s,m)\pi(m,y\mid s)=\pi_g(m\mid s)\pi(y\mid s,m),带来:

  • 可单独提取 DIRECT、THINK_SHORT、REPLAN 的概率和 logprob
  • 可对 mode token 单独设置 SFT loss、RL advantage、KL 和熵约束
  • 可直接统计模式分布、mode regret 和模式塌缩
  • 可对同一状态强制不同模式做反事实评测
  • THINK_SHORT 与 REPLAN 不依赖事后分析自然语言才能区分
  • thinking 内容仍可保持自然、灵活,不受 mode token 格式限制

显式 Gate 通常每个 ReAct turn 只增加一个 token 和一次 decode step。Gate token 是"模型产生、模型继续消费、系统隐藏"的内部 token。

Runtime availability mask

建议增加一个确定性的 runtime availability mask:

  • 全新任务首 turn:通常只开放 DIRECT / THINK_SHORT
  • 已有历史方案或失败 observation:开放 DIRECT / THINK_SHORT / REPLAN
  • 纯环境 timeout、权限不足或依赖不可用:通常屏蔽 REPLAN,避免把环境问题误判成方案问题

这不是外部链路路由,也不是代替 Gate,而是只在首 token 位置把明显不合法的模式 logit 屏蔽。

状态输入要先去噪

Gate 不应直接吞入无限增长的原始日志。建议在每个 turn 构造短状态摘要:

{
  "user_goal": "...",
  "acceptance_criteria": ["..."],
  "current_artifact": "...",
  "last_diff_summary": "...",
  "last_action": "...",
  "observation_digest": {
    "kind": "compile_error",
    "primary_error": "...",
    "location": "...",
    "baseline_present": false
  },
  "trusted_facts": ["..."],
  "failed_hypotheses": ["..."],
  "progress_since_last_turn": true
}

原始工具日志仍可供 action 分支按需读取,但 Gate 和 short-thinking 优先使用结构化 digest。

三、数据策略:增量补充,不重新切分

默认配比

已有 5,000 条 DIRECT 不删除、不为凑比例重切,在此基础上增量:

模式 建议数量 默认数量 默认总体占比 SFT 阶段的定位
DIRECT 已有 5,000 5,000 约 85.5% 主能力、Pass@1 与"不必思考"的强先验
THINK_SHORT 新增 600~800 700 约 12.0% 冷启动错误归因、一次修复和短决策接口
REPLAN 新增 100~200 150 约 2.6% 冷启动方案失效识别、回滚和重规划能力

默认总量为 5,850 条。此外构建 300~500 个同状态模式比较样本,作为轻量 Gate warm-start。

DIRECT:确保 post-feedback 覆盖

不需要为了满足新比例删除已有 DIRECT。需要审计的是它们是否过度集中在"首次生成直接成功"。建议确保其中至少 300~500 条是 post-feedback DIRECT:

子类 建议覆盖 说明
直接机械修复 200~300 字段名、参数、唯一类型错误等,反馈后仍不输出 thinking
直接验证、重试或停止 100~200 确定性 scoped retry、验证成功后 done、环境问题不改代码

这部分非常重要。否则模型容易学成:没有 error → DIRECT;一旦出现 error/check → THINK_SHORT。正确策略应是判断显式 thinking 是否会改变下一动作。

THINK_SHORT:内部分类

子类 数量 说明
编译、类型、API 与 schema 归因 220 区分 last diff、baseline 和环境问题
Judge/Check 功能错误修复 280 需求遗漏、公式、视图、自动化和关联关系错误
初始高风险决策 80 多约束状态下,一段短决策能明显提高 Pass@1
噪声、不反应与正确停止 120 学会不被无关错误带偏

约 80%~90% 的 THINK_SHORT 应放在真实反馈后的恢复状态。

REPLAN:少而精

子类 数量 说明
数据模型或依赖关系重构 70 文本字段应改为关联字段,汇总/公式依赖需重建
用户意图或验收条件误解 35 产物形式完成但业务目标不成立
多次局部修复无进展 30 证据支持停止打补丁并回滚
修改范围失控或回归 15 需要缩小范围、恢复稳定基线

模式标签怎么打

最可靠的方法:同状态反事实模式比较。先根据 runtime availability mask 得到状态 s 的合法模式集合 M(s),再从同一个精确快照强制运行每个合法模式:

restore(s) → force DIRECT      → 执行并评分
restore(s) → force THINK_SHORT → 执行并评分
restore(s) → force REPLAN      → 仅在已有方案被反馈挑战时执行并评分

每个合法模式最好采样 2~4 次。按真实环境结果计算效用 U(s,m)。

标签规则:

  1. DIRECT 成功,且与最优模式效用差不超过 δ → label = DIRECT
  2. THINK_SHORT 相比 DIRECT 显著提升正确性或一次修复率,且原方案不需要重做 → label = THINK_SHORT
  3. 核心假设已被证伪,REPLAN 的真实结果最好 → label = REPLAN
  4. 所有合法模式全部失败,或结果差异落在噪声范围内 → Gate loss mask = 0

低成本启发式预标注:

状态 推荐模式
单一明确的字段名、参数或类型修复 DIRECT
已验证成功,应停止 DIRECT
确定性的 scoped retry,不涉及代码改动 DIRECT
第一次相关错误,需要判断是否来自 last diff THINK_SHORT
Judge 指出一个需求未满足,但整体方案成立 THINK_SHORT
两个局部候选都合理,需要证据选择 THINK_SHORT
中心数据模型被证伪 REPLAN
相同假设连续失败且状态无进展 REPLAN
修改范围持续扩大并引入回归 REPLAN
环境 timeout、权限或依赖不可用 DIRECT retry/stop;不是 REPLAN

Recovery SFT 与 Loss Mask

Recovery suffix 从"正确恢复判断"开始。推荐 mask:

基模生成的错误代码或错误 tool call       mask=0
真实编译、执行或 Judge observation      mask=0
错误类别和因果归因                     mask=1
repair / rollback / retry / replan 决策 mask=1
修复代码或工具动作                     mask=1
必要验证                               mask=1
验证后的 stop/done                     mask=1

错误 action 和真实 observation 仍应放在输入上下文中,因为恢复策略需要看到模型是如何走到失败状态的。但它们不能作为 imitation target。

需要注意:mask=0 = 不模仿,mask=0 ≠ 负监督。若要压制重复动作、盲改、过度扩大范围或提前结束,应为相同状态构造 chosen/rejected,可使用 DPO、ranking loss、unlikelihood 或在线 RL。

推荐 SFT loss

LSFT=λgLgate+λzLthinking+λaLaction+λpLpreferenceL_{\text{SFT}} = \lambda_g L_{\text{gate}} + \lambda_z L_{\text{thinking}} + \lambda_a L_{\text{action}} + \lambda_p L_{\text{preference}}

第一版建议:

  • action/tool token:1.0
  • 自然语言 thinking span:0.4~0.7,按 span 或 turn 归一
  • 可选的离线语义辅助 loss:0.1~0.3
  • 正确验证和 done:1.0~1.3
  • 错误 action、tool observation、冗余 thinking:0

应使用 span-normalized 或 turn-normalized loss,避免较长的自然语言说明获得比工具 action 更大的总梯度。

训练单位不要混淆

建议把"一条轨迹"和"一个 assistant target turn"分开统计:

  • trajectory_count:用于控制场景与模式覆盖
  • target_turn_count:用于计算实际训练曝光
  • token_count:用于防止长 thinking 获得过量梯度

多轮 REPLAN 轨迹天然包含更多 assistant token。如果直接做全局 token mean,即使原始轨迹只占约 2%~4%,也可能获得远高于其样本比例的梯度。建议先在每个 assistant turn 内做 token mean,再按 turn 权重聚合。

四、SFT:三阶段,只冷启动不替代 RL

S1:模式分支能力冷启动

目的:保留已有 DIRECT 主能力,并确保 THINK_SHORT、REPLAN 被强制选择时都"会做事"。

做法:

  • 使用已有 5,000 条 DIRECT,并混入新增的 600~800 条 THINK_SHORT、100~200 条 REPLAN
  • 如果 5,000 条 DIRECT 已经训练进当前 checkpoint,不必从头完整重训;在增量 SFT 中按场景分层回放 DIRECT
  • 原始默认比例约为 85.5/12.0/2.6,有效 batch 可从 82/15/3 起步
  • 模式 token 由数据强制注入,gate token mask=0
  • 训练 DIRECT action、THINK_SHORT 的短思考与 action、REPLAN 与 action
  • recovery 样本使用前述 suffix mask
  • 使用 turn-normalized loss
  • 以 DIRECT Pass@1 无回退、强制模式能力和格式正确率早停

有效 batch:

DIRECT       80%~85%,默认 82%
THINK_SHORT  12%~17%,默认 15%
REPLAN        2%~3%,默认 3%

这一步不让 Gate 自己选,是为了避免模型在 THINK/REPLAN 分支尚不会做时,Gate 因短期 Reward 永远逃回 DIRECT。

完成条件:

强制 THINK_SHORT:格式与 tool call 稳定;decision 与 action 一致;在 Think-necessary 集合上优于 forced DIRECT
强制 REPLAN:能指出失效假设;新 action 确实改变方案;在 Replan-necessary 集合上优于局部修复

S2:轻量 Gate warm-start

目的:只让 Gate 具备最小探索能力,避免 RL 初期 THINK_SHORT/REPLAN 触发概率接近零;不追求通过 SFT 学到最终决策边界。

数据:

  • 优先使用同状态、合法模式强制 rollout 的真实比较结果
  • 只需 300~500 个高信息状态,可从已有轨迹派生
  • 标签分布建议约为 65% DIRECT / 30% THINK_SHORT / 5% REPLAN
  • 加入 Direct-sufficient 与 Think-necessary 的边界状态
  • 不确定样本的 Gate loss 设为 0

训练:

只训练 mode token,后续 thinking/action loss=0
Gate loss 相对 S1 action loss:0.2~0.5
学习率:S1 的约 0.2~0.3 倍
短程训练;能保持模式探索且 mode-regret 不恶化即停止

这里的 65/30/5 只是 Gate 冷启动标签分布,不是线上目标分布。

S3:可选的联合小步 SFT

目的:让 Gate 输出、thinking 和 action 在自然生成条件下重新对齐。

做法:

  • 不再强制 mode token
  • 保持至少 80%~85% 的高质量 DIRECT 曝光
  • 使用 S1 约 0.2~0.3 倍学习率
  • update budget 不超过本轮 SFT 的约 10%,并严格早停
  • 监控 Gate 模式分布,防止突然偏向单一模式

如果 S2 后自然生成已经稳定,S3 可以跳过。

为什么 Auto-thinking 的关键必须放在 RL

Gate SFT 优化的是 Lgate-SFT=−log⁡πg(mteacher∣s)L_{\text{gate-SFT}} =-\log \pi_g(m_{\text{teacher}}\mid s),它回答的是"teacher 在这个静态状态上标了什么模式"。三个局限:

  1. 标签依赖生成它时的 checkpoint;模型变强后,原本需要 THINK_SHORT 的状态可能已经能 DIRECT
  2. 单个模式标签不能持续表达正确性、工具成本、thinking 成本和时延之间的 Pareto 关系
  3. teacher 容易把自己的思考习惯固化成 Gate 规则

RL 优化的是当前策略在真实环境中的效用,通过同一状态下 forced DIRECT、forced THINK_SHORT、forced REPLAN 与 AUTO 的真实比较,RL 能直接回答"对于当前 checkpoint,哪个模式实际更好"。

但不能完全跳过冷启动。如果 THINK_SHORT/REPLAN 分支从未被训练,强制 rollout 几乎总失败,RL 会把"分支能力不足"误认为"这个模式不该选",最终仍塌缩到 DIRECT。

Gate 训练的三层信号

阶段 mode token thinking/action 训练目标
分支能力 SFT 强制注入,loss mask=0 loss mask=1 条件策略 π(y|s,m):已知模式时能否正确生成对应行为
Gate warm-start loss mask=1 loss mask=0 π_g(m|s) 的最小初始边界
Gate RL 由当前策略真实采样,接受 mode-level advantage 接受 turn-level advantage 学习当前模型真正的模式决策边界

Forced-mode rollout 的 mode token 不是从当前 π_g 自然采样得到的,因此不能不加处理地作为普通 on-policy GRPO 样本更新 Gate。推荐分工:

  • AUTO rollout:mode 来自当前 policy → 直接更新 Gate、thinking 和 action
  • forced-mode rollout:mode 由训练系统指定 → 估计模式反事实效用、训练给定模式后的条件分支、构造 Gate 的 CE/DPO/preference 辅助信号、默认不直接计算普通 on-policy Gate gradient

五、RL:GRPO/DAPO + 三阶段 + 分层 Reward

算法

推荐从 multi-turn GRPO/DAPO 风格的组内相对优化开始:

  • 每个 query 或状态快照采样 6~8 条 rollout
  • 早期用强制模式 rollout 保证 THINK_SHORT/REPLAN 不因低初始概率而失去探索
  • 剩余 rollout 让 Gate 自然选择,直接训练 Auto-thinking
  • 以真实工具边界划分 macro-turn
  • 使用 turn-level advantage,而不是只把终局 advantage 平均给整条轨迹
  • all-fail 组不更新 Gate,送入课程学习或 teacher recovery
  • all-correct 组在 R1 可降采样,在 R3 可通过成功成本区分模式

以 group size G=8 为例:

全新任务的初始状态:
  2 × forced DIRECT
  2 × forced THINK_SHORT
  4 × AUTO
  REPLAN 默认被 runtime mask 屏蔽

出现真实错误或 Check 反馈后:
  2 × forced DIRECT
  2 × forced THINK_SHORT
  1 × forced REPLAN
  3 × AUTO

Macro-turn

mode token → optional thinking → action/tool call → real observation

Observation 后的 Reward 归因给前一个 macro-turn。工具 observation 只作为下一状态输入,不参与生成 loss。

分段 RL loss

理想形式:

LRL=−E[wgAglog⁡πg(m∣s)+1m≠D wzAz1∣z∣∑ilog⁡π(zi)+waAa1∣a∣∑jlog⁡π(aj)]+β DKL(πθ∥πSFT)−η H(πg)L_{\text{RL}} =-\mathbb{E} \left[ w_g A_g \log\pi_g(m|s) +\mathbf{1}_{m\neq D}\, w_z A_z \frac{1}{|z|}\sum_i\log\pi(z_i) +w_a A_a \frac{1}{|a|}\sum_j\log\pi(a_j) \right] +\beta\,D_{\mathrm{KL}}(\pi_\theta\|\pi_{\text{SFT}}) -\eta\,H(\pi_g)

其中:

  • AgA_g:同状态不同模式的相对效用
  • AzA_z:thinking 的证据扎根性、判断与 action 一致性、可验证预期与结果的过程 advantage
  • AaA_a:实际工具动作带来的进展和终局 advantage
  • H(πg)H(\pi_g):Gate 模式熵
  • KL:防止格式、工具协议和已有代码能力漂移

第一版若无法稳定估计三个 advantage,可以共享 turn-level trajectory advantage,但使用不同 span 权重:

w_gate   = 1.0~1.5
w_action = 1.0
w_think  = 0.2~0.5

Reward 层级

推荐优先使用分层排序(字典序):

Tier 0:安全、权限、数据完整性、是否篡改测试/verifier
Tier 1:可执行功能正确与用户验收
Tier 2:无回归、幂等性与无数据破坏
Tier 3:错误归因、有效进展、正确停止
Tier 4:模式、thinking、工具、时延成本

只有 Tier 0~3 相同或足够接近时,Tier 4 才决定优劣。

如果训练框架必须使用标量,可以从以下归一化模板开始:

R=+Rterminal+Rprocess−Rfailure−Rcost−RsafetyR = + R_{\text{terminal}} + R_{\text{process}} - R_{\text{failure}} - R_{\text{cost}} - R_{\text{safety}}

示例尺度:

R_terminal:0~10
  工具调用和产物格式合法          +0.5
  编译/构建通过                   +0.5
  隐藏功能与不变量 Check          +4.0
  Judge 需求满足                  +3.0
  无回归、数据保持和幂等          +2.0

R_process:整条轨迹最多 +2
  验证过的 milestone              +0.2~0.5
  可验证的正确 attribution        +0.2~0.4
  expect 与下一 observation 一致  +0.1~0.3

R_failure
  语义重复                         -0.5~-1.0
  无关范围扩张                     -0.5~-1.0
  未验证提前 done                  -1.0~-2.0
  制造新回归                       -2.0~-5.0

R_cost:整条成功轨迹通常不超过 -1
  额外工具调用、thinking token、wall time

R_safety
  篡改测试/verifier、越权删除、数据破坏  -20 并立即终止

硬原则:

成功 Reward > 所有效率惩罚的最大可能总和
功能正确 Reward > 编译通过和 Judge 文风 Reward
安全硬惩罚 > 所有正 Reward

多维表格专用 Reward

Schema 图正确性

检查表、字段、视图是否存在;字段类型与默认值是否正确;关联字段的方向和多重性是否正确;lookup / rollup / formula 的依赖图是否合法;是否存在悬空引用和循环依赖。

公式语义 Reward

不仅检查 parse,还应在隐藏样例上计算结果;覆盖空值、时区、边界日期、0 和负数;检查返回类型;验证字段重命名后的引用保持。

View 行为 Reward

检查 filter、sort、group、visible fields 和 records:应出现的记录全部出现;不应出现的记录不出现;排序和分组符合需求;修改未破坏其他已有视图。

Automation 图 Reward

检查 trigger 对象和条件;action 顺序与参数;字段引用;循环触发风险;重复运行幂等;模拟事件后的最终状态。

数据与权限不变量

未要求删除的数据仍存在;无关表、字段、视图未被修改;字段迁移没有静默丢值;权限范围未扩大;敏感字段未写入日志或输出。

最小改动 Reward

仅在功能正确与无回归相同的成功 rollout 之间比较:修改对象数量、diff 范围、新增/删除资源数量、迁移数据量。不要在失败和成功之间用最小 diff 排序。

Process Reward

可程序化的高价值过程信号:

baseline 是否存在相同错误
错误位置是否落在当前 diff 或直接依赖
rollback 上一步后错误是否消失
一个关键假设是否被验证或证伪
本 turn 是否改变了环境状态
下一 observation 是否符合 thinking 中自然语言表达的可验证预期
是否在验证成功后停止

自然语言 thinking 的辅助 Reward:

Rthinking-sem=w1Rgrounded+w2Rthought-action+w3Rexpected-effect−w4RredundancyR_{\text{thinking-sem}} = w_1 R_{\text{grounded}} + w_2 R_{\text{thought-action}} + w_3 R_{\text{expected-effect}} - w_4 R_{\text{redundancy}}

评估器应同时看到 observation + thinking + action + next observation。该项在整条轨迹中的正奖励应设置上限,并显著小于终局功能正确 Reward。

不要奖励:thinking 的长度、使用了多少专业术语、是否使用某种固定句式、声明了多少 milestone、编译错误数量减少、每做一次 repair 就得分。

Gate Reward

Gate 的目标不是匹配静态 teacher 标签,而是最大化当前模型的真实效用:

Rgate(s,m)=Routcome(s,m)−C(s,m)R_{\text{gate}}(s,m)= R_{\text{outcome}}(s,m)-C(s,m)

在同一状态的模式组内:

  • DIRECT 和 THINK 都成功 → DIRECT 获得较高相对 advantage
  • DIRECT 失败、THINK 一次成功 → THINK 获得较高 advantage
  • 局部修复反复失败、REPLAN 成功 → REPLAN 获得较高 advantage
  • 三者都失败 → 不更新或送入课程学习

成本惩罚应在 RL 初期较弱,等三种分支都具备基本能力后再逐步增加。

RL 三阶段(顺序不能反转)

R0:Reward dry-run

不更新模型,只运行当前 SFT checkpoint:检查各 Reward 分量分布;检查正确轨迹是否总分高于失败轨迹;审计 Judge 与隐藏执行分歧;验证成本项不会压过成功;建立各 query/error bucket 的基线。

R1:正确性与恢复能力

  • 约占 RL update budget 的前 20%~30%
  • 以终局执行、隐藏 Check、Judge 和无回归为主
  • 保持模式强制探索
  • thinking 和工具成本为 0 或只给很弱惩罚
  • 重点提升 Pass@1 与 First-repair success

R2:Gate 与一次修复

  • 约占中间 40%~50%
  • 增强同状态模式组内比较
  • 启用 turn-level advantage
  • 增加语义重复、无关修复和提前停止惩罚
  • 逐步加入条件化 token/tool/wall-time 成本

R3:Pareto 压缩

  • 约占最后 20%~30%
  • 仅在相同成功和进展等级的 rollout 间优化效率
  • 逐步提高 thinking 和额外工具成本
  • 周期性重新生成模式反事实
  • 将已经稳定成功的 THINK 状态转回 DIRECT 边界

核心顺序不能反转:先让各模式能产生正确结果,再让成本塑造 Gate;否则 5,000 条 DIRECT 先验叠加早期成本惩罚,极易形成永远 DIRECT。

线上 query 的 RL 数据工程

Query 入池

线上数据进入 RL 前需要:

  1. 脱敏和权限清洗:删除 token、个人信息、真实业务敏感值
  2. schema-preserving 匿名化:保留字段类型、依赖拓扑和错误结构
  3. 语义去重:相同模板、同一 Base 快照和重写 query 只保留代表样本
  4. 可执行快照:保存初始表结构、必要数据、工具版本与随机种子
  5. 固定验收条件:在 rollout 前生成并冻结 acceptance checklist
  6. 稳定性检查:同一正确产物重复运行 verifier 的结果应一致
  7. 可解性检查:工具权限、依赖和环境必须足以完成任务

RL prompt 采样建议

桶 group success rate 样本用途与规模
Easy anchor > 0.9 少量保留,用于稳定 DIRECT 和防遗忘
Learning frontier 0.1~0.9 RL 主体,模式比较与 advantage 最有信息
All-fail < 0.1 送 teacher recovery、课程学习或 SFT,不直接大量 RL
Unstable verifier 波动高 暂停训练,修环境或 verifier

第一版 query mix:

50% 当前模型的 learning-frontier 线上 query
25% 近期线上失败与多轮重复案例
15% 回归、权限、数据完整性和噪声边界案例
10% Easy DIRECT anchor

以"修复预算"约束一次修好

单独定义:

  • initial_build_actions:完成首版产物所需的动作
  • repair_turns:第一次 Check 失败后的修复轮数

主要 RL 任务可设置:

  • 普通 recovery:最多 1 个 repair turn + 1 次最终验证
  • REPLAN bucket:最多 2 个 recovery action,且最多 1 次 REPLAN
  • 状态无变化的同类失败重复一次:提前终止并处罚

六、六种训练崩溃模式与防护

1. 永远 DIRECT

常见原因:

  • 已有 5,000 条 DIRECT 形成强先验,但 Gate warm-start 和 RL 没覆盖真正 Think-necessary 的边界状态
  • RL 太早施加 thinking/tool 成本
  • THINK_SHORT 分支尚未学会,就与成熟 DIRECT 分支竞争
  • 强制探索不足,组内几乎没有成功的 THINK 候选
  • 所有失败都只有终局 Reward,无法体现正确归因的价值
  • Gate 标签由表面难度决定,长日志反而被误标

有效修复:

  • 先做分支能力冷启动,再做轻量 Gate warm-start,最终通过强制模式 RL 学边界
  • 用 300~500 个状态做轻量 Gate warm-start,而不是扩大 thinking SFT
  • RL 初期设置每组每模式的最小采样数
  • 对 Direct-fail / Think-success 状态上采样
  • 延迟并逐步增加思考成本
  • 监控 Thinking-necessity recall 和 mode regret,而非只看 THINK 比例
  • 对 Gate 添加小的熵正则和最小探索概率

2. 永远 THINK_SHORT

常见原因:

  • teacher 几乎每次 action 前都写 thinking
  • 修复样本远多于首次成功样本
  • 只奖励成功,不计算思考、工具和时延成本
  • thinking 结构本身被 Judge 偏好
  • DIRECT 只包含简单题,缺少"修复也可 Direct"的样本
  • Gate 把"出现 error 字符串"学成固定触发器

有效修复:

  • 整体 SFT 默认保持约 85% DIRECT
  • 确保已有 DIRECT 中至少 300~500 条覆盖直接机械修复、确定性重试和正确停止
  • 为同一成功状态提供 DIRECT chosen、THINK rejected
  • 成本只在正确性相同时生效
  • Judge 不评价 thinking 文风,只评价可验证决策与结果
  • 加入长日志但 Direct-sufficient、短日志但 Think-necessary 的反例
  • 监控 Unnecessary-thinking rate

3. 永远 REPLAN

常见原因:

  • REPLAN 文本长,token-level loss 中梯度过大
  • process reward 为"计划完整"或 milestone 数量加分
  • REPLAN 只出现在困难且成功的 teacher 轨迹中,形成伪相关
  • 初始 turn 也频繁强制 REPLAN
  • 局部失败没有精确的 progress 定义

有效修复:

  • 使用 turn-normalized loss
  • REPLAN 冷启动只新增 100~200 条,默认总体约 2.6%,且以真实核心假设失效为准
  • 不奖励计划长度、步骤数和专业表达
  • 全新任务初始 turn 默认屏蔽 REPLAN,仅在接手已有失败方案等状态下开放
  • 每条普通轨迹最多一次 REPLAN
  • 加入"虽然失败但原方案仍有效,应 THINK_SHORT"的负例
  • 监控 Replan precision

4. Token 熵塌缩

症状:

Gate 很快只输出一种 mode
thinking 变成固定模板或重复短句
rollout 多样性骤降
训练 Reward 上升但 held-out 正确率下降

措施:

  • 监控 Gate、thinking、action 三个 span 的独立 entropy
  • 使用当前 policy 的 on-policy rollout,减少陈旧离线轨迹占比
  • 对 all-correct/all-fail group 做动态采样
  • 使用适当的 asymmetric clip / clip-higher 或同类稳定化
  • 保持小步更新、gradient clipping 与自适应 KL
  • 设 mode exploration floor;初始状态覆盖 DIRECT/THINK_SHORT,反馈后状态再覆盖三模式
  • 对 query、错误摘要和提示模板做不改变语义的增强
  • 按任务与错误 bucket 分别做 reward normalization
  • 对 reward 和 advantage 截断异常值
  • 训练 Judge Reward 上升而 executable Reward 下降时自动暂停
  • 保存短间隔 checkpoint,并以综合 held-out 指标选择,而不是最后一步

5. Gate 决策边界塌缩

Gate 是离散模式决策,尤其容易在多阶段训练中被单一模式占领。对应做法:

有稳定同状态优胜结果 → 更新 Gate
合法模式差异小或全部失败 → mask Gate loss
分支能力不足导致的失败 → 先训练分支,不把失败归因给 Gate
当前 checkpoint 能力变化 → 重新收集反事实,刷新标签

6. Reward hacking

重点审计:

  • 删除或放宽 Check
  • 修改 Judge 输入或验收 rubric
  • 输出空产物以减少错误
  • 只修日志显示,不修功能
  • 写出 Judge 喜欢的流畅 thinking,但内容未扎根反馈或与 action 无关
  • 故意制造容易修的小错赚 process reward
  • 提前 done 以减少工具成本
  • 修改无关数据使隐藏样例碰巧通过

防护:

  • verifier、隐藏测试与 policy 沙箱权限隔离
  • 工具层记录所有资源和数据 diff
  • hard-coded output、测试篡改、权限扩大直接终止
  • 训练 Judge、holdout Judge 和 executable verifier 分离
  • 定期人工审计"高 Reward、低执行正确率"的样本
  • 过程 Reward 设置总上限,不能抵消终局失败
  • 维护 reward-component dashboard 与 divergence 告警

七、怎么证明 Auto-Thinking 真的有效

1. 强制模式 Oracle

在固定评测状态上分别强制 DIRECT、THINK_SHORT、REPLAN、AUTO,得到每个合法模式的真实效用和 AUTO 的 mode regret。AUTO 应接近同状态最优合法模式,而不是仅在平均成功率上看起来不错。

2. 因果干预

Thinking 置空

正常 short-thinking vs. 保留 mode 但清空 thinking

如果 action 和成功率几乎不变,thinking 没有成为有效支撑点。

Thinking 置换

把任务 A 的 thinking 放到表面相似的任务 B 状态。若 action 不受其中错误证据和错误判断影响,模型可能只依赖 observation 关键词。

Decision 干预

保持其他内容相同,将自然语言中的关键判断从"当前修改破坏了公共契约,应回滚上一处改动再重新实现"替换为"现有方案仍然成立,应保留当前改动并继续局部修复"。应观察到 action 方向变化。否则这段自然语言 thinking 可能只是装饰。

Expect 校验

从 thinking 中语义抽取其可验证预期,并与真实 observation 比较:

  • 符合:说明假设得到支持
  • 不符合:下一 turn 应降低原假设置信度并重新归因
  • 连续不符合仍重复动作:计入 semantic repeat

3. 必做消融

至少比较:

  1. Direct SFT + Direct RL
  2. 固定所有状态 THINK_SHORT
  3. 固定长 CoT
  4. Auto-thinking SFT,不做 RL
  5. Auto-thinking SFT + 终局 RL
  6. Auto-thinking SFT + turn-level RL
  7. 去掉 attribution/expect process reward
  8. 去掉同状态模式反事实
  9. 去掉条件成本 Reward
  10. 完整方案

所有实验保持:同一基座与 checkpoint 起点、同一训练 query、同一 rollout 预算、同一工具和 verifier、同一测试集、相近总训练 token / compute。

4. 上线闸门

Pass@1 与 First-repair success 同时提升
Mode regret 不高于预设阈值
Thinking-necessity recall 达标
Unnecessary-thinking rate 不超标
Replan precision 达标
Semantic repeat 与 premature stop 下降
Judge Reward 与 executable Reward 同向
安全、权限和数据回归零恶化

只要其中一项明显恶化,就不能用"平均 Reward 上升"解释为训练成功。

八、高阶模型的角色

分工公式

基模 / 当前 checkpoint:产生真实状态分布
高阶模型:定位偏离、生成候选、压缩 thinking、构造反事实
真实环境:执行、验证和判真

高阶模型适合担任:

  1. 轨迹编辑器:标记 keep / mask / replace / truncate
  2. 首次偏离定位器:找出错误开始传播的 turn
  3. 恢复专家:从基模真实失败状态生成最小 recovery
  4. thinking 压缩器:将长推理改写为预算内、语义有效的自然语言短段落
  5. 反事实候选生成器:为同一状态生成 DIRECT、THINK_SHORT、REPLAN
  6. Rubric 生成器:将用户 query 转换为可执行的验收 checklist
  7. Judge 审核器:发现 JudgeRewardModel 未覆盖的失败模式

它不应:

  • 独立生成绝大多数完整轨迹
  • 虚构工具 observation
  • 同时成为唯一生成者和唯一裁判
  • 把 gold 代码、隐藏测试或不可见信息写入学生 thinking
  • 将自己的长 CoT 原样蒸馏给小模型

双教师视角

Privileged Critic

可以看到参考产物、隐藏 Check、正确修改范围,用于筛选、打标签和比较,不直接进入学生可见 target。

Blinded Actor

只能看到线上推理时可见的信息:用户 query、当前 Base/schema 与数据摘要、当前代码和 diff、已经真实返回的工具 observation。真正进入 SFT target 的 short-thinking、replan 和 action 由 Blinded Actor 生成,并在真实环境重放。

数据生产流水线

  1. 对每个任务用基模或当前 checkpoint 采样 4~8 条 rollout
  2. 保存每个 assistant turn 前的可恢复环境快照与状态 fingerprint
  3. 用高阶模型定位首次关键偏离、错误归因、重复动作和错误停止
  4. 对高价值状态的每个合法模式生成 2~4 个候选
  5. 从同一快照真实重放;所有 observation 必须来自工具
  6. 按正确性、无回归、进展和成本选最短有效路径
  7. 将 teacher 长 reasoning 压成 THINK_SHORT 或 REPLAN 格式
  8. 产出四类视图:最短 clean-success、错误前缀 mask=0 的 recovery suffix、同状态 mode preference / chosen-rejected、噪声/停止/回滚和反 reward-hacking 样本
  9. 进行硬过滤:工具格式合法、执行可重放、隐藏 Check 通过、无测试或 verifier 篡改、无数据破坏、无不可见信息泄漏、无状态不变的循环、thinking 未复制整段日志

与学生分布一致的约束

  • 状态来自基模和当前 checkpoint,而不是只来自高阶模型的干净轨迹
  • teacher 与 student 使用相同工具、相同可见上下文、相同 action schema
  • teacher 输出必须服从 student 的 160/256-token 预算
  • teacher 只生成候选,最终选择由真实环境和独立 verifier 决定
  • 每次模型能力有明显提升后重新收集 rollout
  • 按线上 error/query bucket 对齐采样
  • 保留一部分 student 自己成功的最短轨迹
  • 高阶模型的置信度只能用于排序,不能当作真值

九、落地时间线(7 步)

Step 1:建立评测与可重放环境

  • 固定 Base/schema 快照、工具版本和 acceptance checklist
  • 建立 Pass@1、first-repair、mode regret 和成本报表
  • 实现安全、数据保持、幂等、schema、公式、view 和 automation verifier
  • 校准 JudgeRM 并建立独立 holdout Judge

没有稳定 verifier 时不要急着开始在线 RL。

Step 2:审计 5,000 条 DIRECT 并补充冷启动数据

  • 保留现有 5,000 条 DIRECT,不为满足比例而删除
  • 确保其中 300~500 条覆盖 post-feedback DIRECT
  • 新增 600~800 条 THINK_SHORT,默认 700
  • 新增 100~200 条 REPLAN,默认 150
  • 从基模失败状态生成 recovery suffix
  • 将长 CoT 压为 64~128 tokens、最多 160 tokens 的 THINK_SHORT
  • 将真正方案失效样本整理为 REPLAN
  • 对错误前缀和 observation 做正确 loss mask

Step 3:高阶模型生成同状态反事实

  • 选 Gate 边界状态
  • 每个合法模式生成 2~4 个候选
  • 真实重放
  • 产出 mode label、chosen/rejected 和不确定 mask
  • 首批只需覆盖 300~500 个高信息状态

Step 4:完成能力冷启动与轻量 Gate warm-start

S1 强制模式分支能力 → S2 轻量 Gate warm-start → S3 可选联合小步

SFT 的停止条件是三个强制模式均达到最低可用门槛且 DIRECT Pass@1 无回退。

Step 5:Reward dry-run

  • 在 SFT checkpoint 上运行至少一个完整评测周期
  • 画出每个 Reward 分量与真实成功率的相关性
  • 审计高 Reward 失败样本
  • 确认成本项不会压过正确性

Step 6:R1/R2/R3 在线 RL

  • R1 前 20%~30% 先学正确和一次恢复,弱化成本
  • R2 中间 40%~50% 学 Gate、重复抑制和停止
  • R3 最后 20%~30% 做成功成本 Pareto 压缩
  • 初始状态按 2 DIRECT + 2 THINK_SHORT + 4 AUTO 探索
  • 反馈后状态按 2 DIRECT + 2 THINK_SHORT + 1 REPLAN + 3 AUTO 探索
  • 采用 learning-frontier 动态采样
  • 周期性把新失败状态交给高阶模型生成 recovery 和反事实

Step 7:周期性蒸馏与刷新

每个主要 RL checkpoint:

  1. 在固定状态强制运行全部合法模式
  2. 重新计算 mode regret 与决策边界
  3. 将稳定高 Reward 的最短轨迹蒸馏回小规模 SFT refresh
  4. 删除旧的冗余或被新能力淘汰的 thinking 标签
  5. 保持一部分原始 DIRECT 数据,防止灾难性遗忘

十、一句话总结

对于多维表格 CodeAgent,最优方向不是"所有轨迹都加 CoT",也不是"完全不输出 thinking,只依靠终局 RL"。更合理的方案是:

把短 thinking 设计成自然语言、但可被语义验证的决策瓶颈
把是否使用 thinking 设计成逐 turn 的 Gate
把 DIRECT、THINK_SHORT、REPLAN 作为三种能力先分别训练
再通过同状态真实反事实和多轮 RL 学习模式边界

SFT 只需让三种分支可用,并给 Gate 一个最小探索起点;不应依靠大量 THINK_SHORT/REPLAN SFT 固化模式边界。RL 才是 Auto-thinking 的核心。Auto-thinking 是否成功,最终不由 THINK 占比决定,而由:

更高 Pass@1
+ 更高一次修复率
+ 更低模式 regret
+ 更少无效重复
+ 更低成功成本
+ 无安全和数据回归

共同决定。


第三部分:核心概念深入解读

一、CoT 及其家族

1. 什么是 CoT(Chain-of-Thought,思维链)

CoT 的核心思想:让大模型在给出最终答案前,先输出一段中间推理过程。

用户:一个农夫有15只鸡和兔子,总共40条腿,各有多少?

无 CoT:鸡10只,兔子5只。(直接给答案,可能对也可能错,错了不知道错在哪)

有 CoT:
设鸡x只,兔子y只。
x + y = 15
2x + 4y = 40
解得 x=10, y=5。
鸡10只,兔子5只。(推理过程可见,可追溯)

2022 年 Google 的论文《Chain-of-Thought Prompting Elicits Reasoning in Large Language Models》发现,对于数学、逻辑、多步推理任务,只要在 prompt 里加一句"Let's think step by step"或者给几个带推理过程的示例,模型准确率就能大幅提升。

原因:

  • 大模型是自回归的,每生成一个 token 都基于前面所有 token;显式写出推理步骤相当于给模型"搭台阶"
  • 中间步骤提供了可追溯的推理路径,错误更容易定位

2. CoT 的问题

CoT 不是银弹:

(a) 成本高:每步推理都要消耗 token。简单任务写 500 token 推理纯属浪费。

(b) 可能事后合理化(faithfulness 问题):模型可能先"直觉性"地决定了答案,然后再编一段看起来合理的推理来配合它。文档引用《Measuring Faithfulness in Chain-of-Thought Reasoning》——如果删除或改变 thinking 后 action 基本不变,那这段 thinking 就是装饰。

(c) 长 CoT 可能引入错误:推理步骤越多,某一步出错的概率越大,而且错误会传播。

(d) 固定 CoT 不适应任务难度:所有任务都用同样长度的思考,简单任务过度思考,复杂任务思考不足。

3. CoT 的主要变体

变体 做法 特点
Zero-shot CoT prompt 加"Let's think step by step" 零样本,简单但效果有限
Few-shot CoT 给几个带完整推理的示例 效果更好,但需要精心设计示例
Self-Consistency 采样多条 CoT,投票选最一致的答案 提高鲁棒性,但成本乘以采样数
Tree of Thoughts (ToT) 推理过程组织成树,可回溯、可搜索 适合复杂规划,但实现复杂、成本高
隐式 CoT 不输出可见推理,靠模型内部"隐式思考"(如 DeepSeek-R1 的推理 token) 用户看不到推理,但模型内部仍在多步计算
自适应 CoT (AdaCoT) 模型自己决定什么时候需要 CoT、需要多长 文档方案的理论基础之一

4. 文档中的三档模式与 CoT 的关系

文档的方案本质上是一种精细化的自适应 CoT,但不是简单的"思考/不思考"二选一,而是三档:

DIRECT        = 完全不输出 thinking,直接行动(无 CoT)
THINK_SHORT   = 输出 64~128 token 的短推理(微型 CoT)
REPLAN        = 输出 128~192 token 的重规划(方案级 CoT)

关键区别于传统自适应 CoT:

  • 逐 turn 决策,不是任务开始时决定一次
  • 用显式 Gate token 把"要不要思考"变成可单独训练的离散变量
  • THINK_SHORT 不是自由发挥的长推理,而是有证据、有归因、有预期的短决策说明
  • REPLAN 不是"更长的 THINK_SHORT",而是方案边界发生了变化

文档引用 AdaCoT 论文,其核心思想是把 CoT 触发视为正确率与成本的 Pareto 优化——文档把这个思想从"触发/不触发"扩展到了"三档推理深度"。

5. THINK_SHORT 的 token 预算

目标长度:64~128 tokens
P90:不超过 128 tokens
硬上限:160 tokens
实验上限:192 tokens,仅用于消融

REPLAN 目标:128~192 tokens
REPLAN 硬上限:256 tokens

160-token 硬上限的合理性:THINK_SHORT 通常只需要表达基于反馈的诊断与必要证据(约 25~55 tokens)、下一动作及选择理由(约 20~40 tokens)、必要时的预期结果(约 15~30 tokens),其余预算留给对象名、公式与自然连接语。

如果一个状态稳定需要超过 160 tokens 才能决定下一动作,它通常更适合 REPLAN。

长度控制方式:训练数据在入库前压缩到预算;为 </thinking> 提供明确 stop token;对超长但正确样本做 teacher 重写;RL 中仅在正确性相同的 rollout 之间比较长度。

必做预算消融:固定相同模型、任务、工具预算和 Reward,比较 DIRECT、cap=96、cap=128、cap=160、cap=192、长自由 CoT,按 First-repair success vs. thinking tokens + 工具调用 + wall time 的二维 Pareto 选择。

二、训练范式

1. SFT(Supervised Fine-Tuning,监督微调)

最基础的微调方式:给模型一批"输入→理想输出"的配对数据,让模型模仿。模型通过最小化交叉熵损失来学习:教师输出的每个 token 概率要尽可能高。

优点:简单稳定,能快速让模型学会格式和基本能力。 局限:只能"模仿"示范轨迹,无法自我修正;泛化能力受限于数据覆盖;对于有多种正确解法的任务,SFT 会把模型拉向教师的特定解法。

文档中 SFT 的定位:只冷启动模式能力,不负责学最终决策边界。

2. RFT(Rejection Sampling Fine-Tuning,拒绝采样微调)

介于 SFT 和 RL 之间:

  1. 用当前模型对同一个问题采样多条输出
  2. 用奖励模型/验证器给每条输出打分
  3. 只保留高分输出,扔掉低分的
  4. 用高分输出做 SFT

相当于"让模型自己生成候选,挑好的来学"。比纯 SFT 更灵活,比 RL 更稳定。文档中提到"SFT/RFT + RL"作为课程训练阶段二的方法。

3. RL(Reinforcement Learning,强化学习)

不提供固定的"正确答案",而是定义一个奖励函数,让模型在环境中试错,通过最大化累计奖励来学习策略。

关键优势:模型可以发现教师没想到的更优解法;能学习"在多个选项中选哪个更好"的偏好;能从失败中学习。

关键挑战:奖励设计难(reward hacking)、训练不稳定(熵塌缩、策略漂移)、计算成本高。

4. RLHF / RLVR / RLAIF

RL 的具体子类,区别在于奖励来源:

方法 奖励来源 文档中的角色
RLHF (RL from Human Feedback) 人类标注偏好 成本高,文档未作为主力
RLVR (RL from Verifiable Rewards) 可自动验证的规则(编译通过、单测通过、schema 检查) 文档课程训练阶段一使用,高可信低歧义
RLAIF (RL from AI Feedback) AI 模型(JudgeRM)打分 文档中 L3 语义评估使用,配合可执行 verifier

文档的三层 Reward 架构就是 RLVR + RLAIF 的混合:

  • L1 编译检查 = RLVR(tsc 是否通过,客观可验证)
  • L2 真实执行 = RLVR(运行是否成功)
  • L3 语义评估 = vitest 单测(RLVR)+ LLM Judge(RLAIF)

5. DPO(Direct Preference Optimization,直接偏好优化)

不需要显式训练奖励模型、也不需要在线 rollout 的偏好学习方法。直接用"好的输出 vs 坏的输出"配对数据,通过一个简单的损失函数让模型增加好输出的概率、降低坏输出的概率。

DPO 比 PPO/GRPO 简单稳定,但它是离线的,适合做"抑制重复动作、盲改、过度扩大范围"这类有明确好坏对比的学习。文档中提到在 mask=0 不够时,用 DPO/ranking loss 来主动抑制坏行为。

6. 课程学习(Curriculum Learning)

先易后难地组织训练数据和训练阶段。文档中的课程训练:

  • 阶段一:只要求编译执行通过、单测通过(容易的目标),用 SFT + RLVR
  • 阶段二:要求机评 Judge 通过(更难的目标),用 SFT/RFT + RL

直觉上类似人类学习:先学会走路再学跑步。

三、RL 算法

1. PPO(Proximal Policy Optimization,近端策略优化)

传统 RLHF 的标准算法。核心思想:每次策略更新不能太大,用一个 clip 比率限制新旧策略的差异,保证训练稳定。

PPO 需要一个**价值模型(Value Model / Critic)**来估计每个状态的价值,用于计算 advantage。

缺点:需要额外训练价值模型,计算成本高,实现复杂。

2. GRPO(Group Relative Policy Optimization,组相对策略优化)

DeepSeek 提出的算法,是 PPO 的简化版,去掉了价值模型。

核心思想:对同一个问题采样一组(group)输出,用组内的相对排名来计算 advantage,不需要单独的价值网络。

同一个 query,采样 8 条轨迹 → 每条算 reward →
组内归一化得到 advantage → 用 advantage 加权更新策略

优点:省掉价值模型,训练更简单,适合代码/数学这类有明确奖励的场景。DeepSeek-R1 就是用 GRPO 训练的。 缺点:组内 reward 方差大时 advantage 估计不准;容易出现熵塌缩。

文档中 Code Agent 的 RL 第一版用的就是 GRPO,每条样本 8 条并行轨迹。

3. DAPO(Dynamic Sampling, Length Control, and Clipping for Policy Optimization)

OpenAI 提出的大规模开源 RL 系统/算法改进,在 GRPO 基础上加了三个关键改进:

  • 动态采样(Dynamic Sampling):按任务难度动态调整采样数
  • 长度控制(Length Control):对过长输出施加惩罚
  • 改进的 clipping:asymmetric clip,提高稳定性

文档引用 DAPO 作为缓解 naive GRPO 的 reward noise、过长输出和熵塌缩的参考。

4. On-policy vs Off-policy

  • On-policy(在策略):用当前模型自己生成的 rollout 来训练当前模型。数据新鲜,但每次更新都要重新采样,成本高。
  • Off-policy(离策略):可以用旧模型/其他模型生成的数据来训练。样本效率高,但有分布偏移问题,需要 importance sampling 修正。

文档中:

  • AUTO rollout 的 mode 来自当前 policy → on-policy,可直接更新 Gate
  • forced-mode rollout 的 mode 由训练系统指定 → 不是自然采样,默认不直接做 on-policy Gate gradient
  • 减少陈旧离线轨迹占比,多用 on-policy rollout 防熵塌缩

5. Advantage 与信用分配(Credit Assignment)

Advantage(优势):一个动作比"该状态下的平均动作"好多少。正 advantage → 增加该动作概率;负 advantage → 降低。

信用分配问题:在多轮 Agent 中,最终成功/失败应该归功(或归咎)于哪一轮的哪个动作?

如果只给整条轨迹一个终局 reward,所有 turn 都收到相同的负 advantage,模型不知道具体哪步错了。

Turn-level advantage(轮次级优势):把 reward 归因到具体的 macro-turn,每个 turn 根据自己的动作和后续 observation 获得更精确的 advantage。

短 thinking 改善信用分配的机制:thinking 中的归因、预期结果提供了可验证的中间变量。比如 thinking 说"修改筛选条件后已结清客户应该消失",如果下一次 observation 显示已结清客户还在,那就可以精确归因到"这个 thinking 的判断错了"。

四、Auto-Thinking 特有概念

1. Gate token / Reasoning-mode token

文档最核心的技术设计。传统模型"要不要思考"是隐式的,无法单独训练和干预。

文档引入三个特殊 token:<|mode_direct|>、<|mode_think_short|>、<|mode_replan|>。

这个 token 的价值:

  • 可单独提取概率和 logprob
  • 可单独设置 loss(S1 gate loss=0,S2 只训练 mode token)
  • 可单独施加 RL advantage
  • 可强制注入做反事实比较
  • 可统计模式分布和 mode regret

每 turn 只增加 1 个 token,成本几乎可以忽略,但把一个隐式决策变成了显式可训练的元推理变量。

2. Mode Regret(模式遗憾)

衡量 Auto-Thinking 是否成功的核心指标:

ModeRegret(s)=max⁡mU(s,m)−U(s,m^)\text{ModeRegret}(s) = \max_m U(s, m) - U(s, \hat m)

含义:Gate 选的模式比"该状态下最好的模式"差多少。如果 Gate 总是选到最优模式,regret=0。

为什么不用 THINK 占比?因为 10% 的 THINK 可能过多,也可能远远不够。只有 mode regret 能回答"Gate 的决策质量到底好不好"。

3. 同状态反事实比较(Counterfactual Comparison)

对同一个精确状态快照,分别强制不同模式执行,比较真实结果。这是 Gate warm-start 标签和 RL advantage 的数据基础。

没有反事实比较,Gate 的标签就只能靠"任务看起来难不难"这种主观判断,不可靠。

4. 模式塌缩(Mode Collapse)

训练过程中 Gate 退化为永远只选一种模式的现象:

  • 永远 DIRECT:5000 条 DIRECT 先验太强 + 早期成本惩罚
  • 永远 THINK_SHORT:teacher 每次都写 thinking + 只奖励成功不计成本
  • 永远 REPLAN:REPLAN 文本长梯度大 + process reward 奖励计划长度

核心修复原则:先让各分支能力均衡,再用成本塑造偏好,顺序不能反。

5. Pareto 优化 / Pareto 压缩

Pareto 最优:在不牺牲任何一个目标的前提下,无法再改善另一个目标。

文档中的 R3 阶段"Pareto 压缩":在已经能正确完成任务的 rollout 中,进一步优化效率(更少 thinking token、更少工具调用、更短时延)。

关键约束:只在相同成功和进展等级的 rollout 间比较成本。不能在失败和成功之间用"最小改动"排序。

五、工程与评估概念

1. ReAct(Reasoning + Acting)

ReAct 是一种 Agent 交互模式:模型交替进行推理(Thought)和行动(Action),观察行动结果(Observation)后再推理,循环直到完成。

文档中的 CodeAgent 就是 ReAct 模式,最多 20 步,每步就是一个 macro-turn。Auto-Thinking 的 Gate 就是在每个 ReAct turn 决定这一步要不要先思考。

2. CodeAct

CodeAct 是 ReAct 的一个特例:Action 不是调用预定义工具,而是生成代码。模型写 TypeScript 代码,代码调用 @bitable/agent-sdk,在沙箱中编译执行。

3. Verifier vs JudgeRM

Verifier(验证器) JudgeRM(评判奖励模型)
性质 程序化、客观规则 LLM 打分、主观判断
检查内容 编译通过、单测通过、schema 合法、公式计算正确 整体结构是否符合用户意图、命名是否合理、多约束是否全满足
可信度 高,不会被欺骗 中等,可能有偏差、可能被 reward hacking
成本 低,自动运行 较高,需要 LLM 调用

文档强调 JudgeRM 不能成为唯一真值,必须配合可执行 verifier,且训练 Judge、holdout Judge、executable verifier 三者分离。

4. Process Reward(过程奖励)

除了终局奖励,还给中间步骤的奖励:thinking 中的归因是否与证据一致、预期是否被证实、验证过的 milestone 等。

好处:把稀疏的终局反馈变密集,改善信用分配。 风险:容易被 reward hacking。

防护:过程奖励必须由真实执行/语义评估器得到;设总上限,不能抵消终局失败。

5. Reward Hacking(奖励作弊)

模型找到奖励函数的漏洞,用"投机取巧"的方式获得高奖励,但实际上没有完成任务。

典型方式:删除/放宽 Check、输出空产物、只修日志不修功能、写 Judge 喜欢但与 action 无关的 thinking、故意制造容易修的小错赚 process reward、提前 done。

防护核心:多层 verifier 隔离 + 人工审计高 Reward 低执行正确率的样本 + divergence 告警。

6. 熵塌缩(Entropy Collapse)

RL 训练中模型的输出分布急剧变窄,失去多样性:Gate 只输出一种 mode、thinking 变固定模板、Reward 上升但 held-out 正确率下降。

文档强调不能只靠一个全局 entropy bonus,要监控 Gate、thinking、action 三个 span 的独立 entropy 流。

7. 知识蒸馏(Distillation)

把大模型/强模型的能力迁移到小模型/目标模型。文档中的蒸馏:

  • 高阶模型生成 recovery suffix、压缩 thinking、构造反事实 → 蒸馏给基模
  • RL 训练后,把稳定高 Reward 的最短轨迹蒸馏回小规模 SFT refresh
  • 保留一部分原始 DIRECT 数据 → 防止灾难性遗忘

关键原则:高阶模型不能替代真实环境判真。

8. Loss Mask(损失掩码)

在 SFT 中,指定哪些 token 参与梯度计算、哪些不参与。

  • mask=1:这些 token 要模仿(计算 loss)
  • mask=0:这些 token 不模仿(不计算 loss),但仍在上下文中

文档中 recovery 数据的 mask 策略:错误前缀和 observation mask=0(不模仿错误),从正确恢复判断开始 mask=1。

注意 mask=0 ≠ 负监督:它只是"不教模型学这个",不会主动"教模型别这么做"。要主动抑制坏行为,需要 chosen/rejected 配对数据(DPO)或 RL。

六、深入理解:零和游戏、帕累托最优与 Mode Regret

1. 零和游戏(Zero-sum Game)

基本定义

零和游戏是博弈论中的概念:在一场博弈中,所有参与者的收益之和恒等于零。一方多得的,恰好是另一方失去的。

玩家A收益 + 玩家B收益 = 0

经典例子

场景 为什么是零和
下棋 一方赢(+1),另一方就输(-1),总和为 0
赌博 你赢的钱就是对手输的钱,赌场抽水除外
分一块固定大小的蛋糕 你多分一口,别人就少吃一口
选举 候选人 A 多一票,候选人 B 就少一票(相对差距)

非零和游戏

现实中大多数情况不是零和:

  • 正和游戏:合作能让总收益变大。比如两家公司合作开拓新市场,双方都赚钱。
  • 负和游戏:所有人都受损。比如贸易战、互相报复。
  • 变和游戏:总收益随策略变化。

在 Auto-Thinking 语境中的含义

如果把 reward 写成 reward = 正确率 - λ × 成本,那么在固定总 reward 预算下,正确率和成本变成了互相挤压的关系——模型多花 token 思考,成本项就扣分;模型省 token,正确率可能下降。两者此消彼长,像在分一块固定大小的蛋糕。

更严重的是,模型可能发现"作弊"方式:输出空产物(成本极低),虽然正确率低,但因为权重设置的问题,总分反而更高。这就是在零和框架下钻空子。

帕累托框架打破了这个"固定蛋糕":它不要求正确率和成本加起来等于某个常数,而是承认两者是不同维度的目标,先确保正确率达标,再在正确率相同的方案中压缩成本。这就从"你死我活"变成了"先把蛋糕做大,再考虑怎么切得更高效"。


2. 帕累托最优的数学公式

多目标优化的形式化

假设有 kk 个目标要同时优化,每个目标是一个函数 fi(x)f_i(x),其中 xx 是决策变量(在 Code Agent 里就是"选哪个模式、生成什么代码")。为统一,假设所有目标都是越大越好(成本类目标取负数):

max⁡xF(x)=(f1(x),f2(x),…,fk(x))\max_{x} \quad F(x) = (f_1(x), f_2(x), \ldots, f_k(x))

在 Auto-Thinking 中,大致是:

F(x)=(正确率, −token数, −工具调用次数, −时延, −重复率)F(x) = (\text{正确率},\ -\text{token数},\ -\text{工具调用次数},\ -\text{时延},\ -\text{重复率})

支配关系(Dominance)

这是帕累托理论最核心的定义。

方案 xx 支配(dominate)方案 yy,记作 x≻yx \succ y,当且仅当:

  1. xx 在所有目标上都不差于 yy:fi(x)≥fi(y)f_i(x) \geq f_i(y) 对所有 ii 成立
  2. xx 在至少一个目标上严格优于 yy:存在某个 jj 使得 fj(x)>fj(y)f_j(x) > f_j(y)

用符号写:

x≻y  ⟺  (∀i:fi(x)≥fi(y))∧(∃j:fj(x)>fj(y))x \succ y \iff \left(\forall i: f_i(x) \geq f_i(y)\right) \land \left(\exists j: f_j(x) > f_j(y)\right)

直观翻译:xx 全方位不比 yy 差,而且至少有一方面更好。那 yy 就没有任何存在的理由了——选 xx 永远更好。

帕累托最优(Pareto Optimality)

方案 x∗x^* 是帕累托最优的,当且仅当不存在任何其他方案 xx 能支配 x∗x^*。

x∗ 是帕累托最优  ⟺  ∄x 使得 x≻x∗x^* \text{ 是帕累托最优} \iff \nexists x \text{ 使得 } x \succ x^*

换句话说:想让 x∗x^* 的任何一个目标变好,都必须以牺牲至少一个其他目标为代价。

帕累托前沿(Pareto Front)

所有帕累托最优方案组成的集合:

P={x∗∣∄x,x≻x∗}\mathcal{P} = \{x^* \mid \nexists x, x \succ x^*\}

在二维情况下(比如正确率 vs 成本),帕累托前沿就是一条曲线。曲线上的每个点都代表一种"合理的权衡"——你要更高正确率就得接受更高成本,要更低成本就得接受稍低正确率。

帕累托改进(Pareto Improvement)

从方案 yy 到方案 xx,如果 x≻yx \succ y,那这就是一次帕累托改进:没有人受损,至少有人受益。

y→x 是帕累托改进  ⟺  x≻yy \to x \text{ 是帕累托改进} \iff x \succ y

文档 R3 阶段做的事,就是在已经成功的 rollout 中找帕累托改进:正确率不变,但 token/工具/时延减少了。

文档中的字典序帕累托实现

文档的 Reward 层级(Tier 0 安全 > Tier 1 功能正确 > Tier 2 无回归 > Tier 3 有效进展 > Tier 4 成本)就是一个**字典序帕累托(Lexicographic Pareto)**的实现:

比较方案 x 和 y:\text{比较方案 } x \text{ 和 } y:

  1. 先比 Tier 0(安全):如果 xx 安全且 yy 不安全 → x≻yx \succ y,直接判定
  2. Tier 0 相同 → 比 Tier 1(功能正确)
  3. Tier 1 相同 → 比 Tier 2(无回归)
  4. Tier 2 相同 → 比 Tier 3(有效进展)
  5. Tier 3 相同 → 比 Tier 4(成本)

这等价于给目标排了优先级,高优先级目标的差异字典序优先于低优先级目标。数学上可以写成一个向量比较:

F(x)=(T0(x),T1(x),T2(x),T3(x),−T4(x))F(x) = (T_0(x), T_1(x), T_2(x), T_3(x), -T_4(x))

按字典序比较 F(x)F(x) 和 F(y)F(y),第一个不同的分量决定优劣。

为什么不用简单加权

简单加权:U(x)=∑iwifi(x)U(x) = \sum_i w_i f_i(x)

问题在于,加权隐含了一个假设:目标之间是可替代的——正确率降 1 分可以用成本降 100 token 来补偿。但在 Code Agent 中,安全和正确率是不可替代的:一个删了用户数据的方案,哪怕只花了 1 个 token,也绝对不能接受。

帕累托 + 字典序避免了这个问题:高优先级目标没达标时,低优先级目标再好也没用。

帕累托在文档中的具体应用场景

场景 1:R3 阶段的 Pareto 压缩

R3 阶段仅在相同成功和进展等级的 rollout 间优化效率。先筛选出都成功的 rollout(Tier 0~3 相同),在这些 rollout 中找帕累托前沿——哪些方案在正确率相同的情况下,token/工具/时延更少。把模型从"成功但浪费"的点,推向"成功且高效"的帕累托前沿。

R3 阶段还会将已经稳定成功的 THINK 状态转回 DIRECT 边界:随着模型能力提升,某些原来需要 THINK_SHORT 才能做对的状态,现在 DIRECT 也能做对了——这时 DIRECT 在帕累托意义上严格优于 THINK_SHORT(正确率相同,成本更低),Gate 应该学会选 DIRECT。

场景 2:Mode Regret 的定义

Mode regret 本身就是一个帕累托概念。max⁡mU(s,m)\max_m U(s,m) 是该状态下所有模式中的最优效用(帕累托最优点),U(s,m^)U(s,\hat m) 是 Gate 实际选择的模式的效用,差值就是"离最优有多远"。

场景 3:THINK_SHORT 的 token 预算选择

文档第 9 节的预算消融按二维 Pareto 选择:First-repair success vs. thinking tokens + 工具调用 + wall time。不同 cap(96/128/160/192)对应前沿上的不同点。选择 160 硬上限,是因为它在前沿上——再增加到 192 只增加成本不提升修复率(被 160 支配),减少到 128 可能降低修复率(需要权衡)。

场景 4:同状态反事实比较

Gate warm-start 的标签来自同状态反事实比较,本质上是在为每个状态找帕累托最优模式。REPLAN 被 THINK_SHORT 支配(成功率更低且成本更高)→ 不选;DIRECT 和 THINK_SHORT 都在帕累托前沿上 → 根据当前阶段的权重偏好来选。

场景 5:Gate 决策边界的动态刷新

帕累托前沿会随着模型能力提升而移动。同一个状态,训练初期 DIRECT 成功率 40%、THINK_SHORT 成功率 75%(THINK_SHORT 帕累托优于 DIRECT);训练后期 DIRECT 成功率 78%、THINK_SHORT 成功率 80%(两者成功率接近,但 DIRECT 成本低得多,DIRECT 变成帕累托更优)。所以必须用当前 checkpoint 的 on-policy rollout 周期性刷新反事实数据。


3. Mode Regret(模式遗憾)

Regret 的一般概念

Regret(遗憾/后悔)是在线学习和博弈论中的核心指标,衡量的是:你实际做的决策,和事后看来最优决策之间的差距。

最经典的是**多臂老虎机(Multi-armed Bandit)**问题:你面前有 KK 个老虎机,每个有不同的中奖概率。你玩了 TT 轮,总收益是多少?如果事后知道哪个老虎机最好,一直玩它能拿多少?两者的差就是 regret。

Regret(T)=T⋅μ∗−∑t=1Tμat\text{Regret}(T) = T \cdot \mu^* - \sum_{t=1}^T \mu_{a_t}

其中 μ∗\mu^* 是最好老虎机的期望收益,μat\mu_{a_t} 是第 tt 轮实际选的老虎机的期望收益。

Regret 衡量的是"因为不知道最优选择而损失了多少"。 Regret 越低,说明决策越接近最优。

Mode Regret 的具体定义

在每个状态 ss,Gate 要从三个模式中选一个:

m^=Gate(s)∈{DIRECT,THINK_SHORT,REPLAN}\hat m = \text{Gate}(s) \in \{\text{DIRECT}, \text{THINK\_SHORT}, \text{REPLAN}\}

每个模式在该状态下有一个真实效用 U(s,m)U(s, m)(综合正确率和成本)。事后看来,该状态的最优模式是:

m∗(s)=arg⁡max⁡m∈M(s)U(s,m)m^*(s) = \arg\max_{m \in M(s)} U(s, m)

其中 M(s)M(s) 是状态 ss 下的合法模式集合(受 runtime availability mask 约束)。

Mode Regret 就是实际选的模式和最优模式之间的效用差:

ModeRegret(s)=U(s,m∗(s))−U(s,m^)\text{ModeRegret}(s) = U(s, m^*(s)) - U(s, \hat m)

展开写:

ModeRegret(s)=max⁡m∈M(s)U(s,m)−U(s,Gate(s))\text{ModeRegret}(s) = \max_{m \in M(s)} U(s, m) - U(s, \text{Gate}(s))

效用 U(s, m) 是什么

文档中的效用函数是综合的:

U(s,m)=Rcorrect(s,m)−Cregression(s,m)−λtCtool(s,m)−λzCthinking(s,m)−λwCwalltime(s,m)−λrCrepeat(s,m)U(s, m) = R_{\text{correct}}(s, m) - C_{\text{regression}}(s, m) - \lambda_t C_{\text{tool}}(s, m) - \lambda_z C_{\text{thinking}}(s, m) - \lambda_w C_{\text{walltime}}(s, m) - \lambda_r C_{\text{repeat}}(s, m)

实际操作中,是先在同一状态下强制运行每个模式,得到真实的执行结果,然后按 Tier 层级比较。

怎么计算 Mode Regret

工程上的计算步骤:

  1. 固定状态快照:保存某个 ReAct turn 开始前的完整环境状态(Base schema、当前代码、diff、历史 observation)
  2. 强制运行每个合法模式:从同一快照出发,分别强制 DIRECT、THINK_SHORT、REPLAN,各跑 2~4 次取平均,得到每个模式的真实效用
  3. 找到最优模式:m∗=arg⁡max⁡mU(s,m)m^* = \arg\max_m U(s, m)
  4. 记录 Gate 的实际选择:m^\hat m
  5. 计算差值:Regret=U(s,m∗)−U(s,m^)\text{Regret} = U(s, m^*) - U(s, \hat m)

这就是文档说的"强制模式 Oracle"评测。

为什么 Mode Regret 是核心指标

文档反复强调:不要用 THINK 占比来衡量 Auto-Thinking 是否成功。 原因是:

  • THINK 占比 10% 可能过多(大部分简单任务不该思考),也可能远远不够(复杂任务都该思考)
  • 模型可以通过"永远选 DIRECT"来获得低 THINK 占比,但这在需要思考的任务上会失败
  • 模型也可以通过"永远选 THINK_SHORT"来刷正确率,但成本很高

Mode Regret 直接回答了真正的问题:Gate 的决策质量好不好?

  • 如果 Gate 总是选到该状态下最好的模式 → regret = 0,完美
  • 如果该 THINK 的时候选了 DIRECT 导致失败 → regret 很大
  • 如果该 DIRECT 的时候选了 THINK 浪费了 token → regret 也有(虽然小)
  • 如果两个模式效用差不多 → regret 接近 0,选哪个都行

Mode Regret 的分解

可以进一步分解,定位问题:

总 Regret = 可避免 Regret + 不可避免 Regret

可避免 Regret:
  ├── 该 THINK 但选了 DIRECT(Thinking-necessity recall 低)
  ├── 该 DIRECT 但选了 THINK(Unnecessary-thinking rate 高)
  └── 该 REPLAN 但选了 THINK/DIRECT(Replan precision 低)

不可避免 Regret:
  └── 两个模式效用几乎相同,选哪个都差不太多(噪声范围内)

文档中的上线闸门指标其实就是 Mode Regret 的各个分解维度:

指标 对应的 Regret 类型
Thinking-necessity recall 该 THINK 没 THINK 的比例
Unnecessary-thinking rate 不该 THINK 却 THINK 的比例
Replan precision 选 REPLAN 时是否真的需要 REPLAN
Mode regret 综合效用差距

具体例子

例子 1:简单字段名修复

状态 ss:编译报错 unknown field "customer_name",可用字段是 customer。

强制 DIRECT:
  直接把 customer_name 改成 customer
  结果:编译通过,任务完成
  效用:正确率 1.0,token 50,工具调用 1
  U = 0.95(高)

强制 THINK_SHORT:
  先写一段"这个错误是因为字段名引用错误..."再改
  结果:编译通过,任务完成
  效用:正确率 1.0,token 180,工具调用 1
  U = 0.80(正确率相同但成本高)

强制 REPLAN:
  重新规划整个表结构
  结果:过度设计,引入了不必要的关联字段
  效用:正确率 0.6,token 400,工具调用 5
  U = 0.30(低)

最优模式是 DIRECT(U=0.95)。

  • Gate 选了 DIRECT → regret = 0 ✓
  • Gate 选了 THINK_SHORT → regret = 0.95 - 0.80 = 0.15(不必要的思考)
  • Gate 选了 REPLAN → regret = 0.95 - 0.30 = 0.65(严重错误)

例子 2:数据模型根因错误

状态 s′s':Judge 反馈"客户表无法稳定关联同名客户的多条订单"。

强制 DIRECT:
  继续修改文本公式
  结果:仍然无法解决根因,Judge 不通过
  U = 0.20

强制 THINK_SHORT:
  分析错误归因,尝试调整公式
  结果:局部修复无效,根因是数据模型问题
  U = 0.25

强制 REPLAN:
  认识到文本键不可靠,建立真实关联字段
  结果:解决根因,Judge 通过
  U = 0.90

最优模式是 REPLAN(U=0.90)。

  • Gate 选了 REPLAN → regret = 0 ✓
  • Gate 选了 DIRECT → regret = 0.90 - 0.20 = 0.70(该重规划却在打补丁)

4. 三个概念的串联

  1. 零和游戏是问题:简单加权求和让正确率和成本互相挤压,模型可能作弊。
  2. 帕累托是框架:承认多目标不可简单替代,先找非支配解集(帕累托前沿),再按阶段偏好选择。
  3. Mode Regret是度量:在帕累托框架下,衡量 Gate 的实际决策离该状态帕累托最优点有多远。

整个 Auto-Thinking 的训练目标可以浓缩为一句话:

通过 SFT 冷启动三个模式分支的能力,通过 RL 学习每个状态下的帕累托最优模式,最终将 Mode Regret 降到最低——让 Gate 在正确的时候思考,在不需要的时候直接做,在方案失效的时候重规划。


七、概念组合:完整训练流水线

┌─────────────────────────────────────────────────────┐
│  数据层                                              │
│  ┌──────────┐  ┌──────────────┐  ┌──────────────┐  │
│  │ 5000条   │  │ 新增700条    │  │ 新增150条    │  │
│  │ DIRECT   │  │ THINK_SHORT  │  │ REPLAN       │  │
│  │ SFT数据  │  │ (高阶模型    │  │ (高阶模型    │  │
│  │          │  │  压缩+蒸馏)  │  │  生成+蒸馏)  │  │
│  └────┬─────┘  └──────┬───────┘  └──────┬───────┘  │
│       │               │                 │          │
│       └───────────────┼─────────────────┘          │
│                       │                            │
│  同状态反事实比较(300~500个高信息状态)               │
│  → 产出 mode label + chosen/rejected                │
└───────────────────────┬─────────────────────────────┘
                        │
┌───────────────────────▼─────────────────────────────┐
│  SFT 阶段(冷启动,不替代RL)                         │
│                                                       │
│  S1: 分支能力冷启动                                   │
│      强制 mode token, gate loss=0                    │
│      有效batch 82/15/3, turn-normalized loss         │
│      学: 给定模式时能否正确生成对应行为               │
│                                                       │
│  S2: Gate轻量warm-start                              │
│      只训练mode token, 300~500状态                   │
│      标签分布65/30/5, 学习率为S1的0.2~0.3倍          │
│      学: Gate有最小探索能力, RL初期不塌缩             │
│                                                       │
│  S3(可选): 联合小步SFT                                │
│      不强制mode, 保持80~85% DIRECT曝光               │
│      update budget ≤10%, 严格早停                    │
└───────────────────────┬─────────────────────────────┘
                        │
┌───────────────────────▼─────────────────────────────┐
│  Reward dry-run(不更新模型)                         │
│  检查Reward分量分布与真实成功率相关性                  │
│  审计高Reward失败样本, 确认成本不压过正确性            │
└───────────────────────┬─────────────────────────────┘
                        │
┌───────────────────────▼─────────────────────────────┐
│  RL 阶段(GRPO/DAPO, 核心学习阶段)                   │
│                                                       │
│  每状态采样8条rollout:                                │
│    初始: 2 forced DIRECT + 2 forced THINK + 4 AUTO   │
│    反馈后: +1 forced REPLAN, -1 AUTO                 │
│                                                       │
│  三层Reward(字典序):                                  │
│    Tier0 安全/数据完整性 > Tier1 功能正确 >           │
│    Tier2 无回归 > Tier3 有效进展 > Tier4 成本         │
│                                                       │
│  Turn-level advantage + macro-turn信用分配            │
│  AUTO rollout → on-policy更新Gate                     │
│  forced rollout → 反事实估值+条件分支训练             │
│                                                       │
│  R1(20~30%): 正确性与恢复, 成本惩罚≈0                 │
│  R2(40~50%): Gate与一次修复, 逐步加成本               │
│  R3(20~30%): Pareto压缩, 成功rollout间优化效率        │
└───────────────────────┬─────────────────────────────┘
                        │
┌───────────────────────▼─────────────────────────────┐
│  评估与验证                                           │
│  强制模式Oracle → mode regret                        │
│  因果干预(置空/置换/decision干预) → thinking忠实性    │
│  10组消融实验 → 各组件贡献                            │
│  上线闸门: Pass@1↑ + First-repair↑ + regret↓ + ...   │
└───────────────────────┬─────────────────────────────┘
                        │
┌───────────────────────▼─────────────────────────────┐
│  周期蒸馏与刷新                                       │
│  重算mode regret → 稳定高Reward最短轨迹蒸馏回SFT      │
│  删除冗余thinking标签 → 保持部分原始DIRECT防遗忘      │
│  模型能力提升后 → 原需THINK的状态可能变DIRECT         │
│  → Gate边界必须用当前checkpoint的rollout周期重算      │
└─────────────────────────────────────────────────────┘

整个方案的设计哲学:

  1. SFT 教"会做",RL 教"选对"——SFT 让三个模式分支都具备非零能力,RL 通过同状态真实反事实学习当前模型的模式决策边界。
  2. 先正确性,后成本效率——R1/R2/R3 顺序不能反转,否则 5000 条 DIRECT 先验 + 早期成本惩罚必然导致永远 DIRECT。
  3. 用 mode regret 而非 THINK 占比衡量成败——Auto-thinking 的目标不是"让模型多思考",而是"在思考确实有边际收益时才思考,其余时候直接做"。

八、Thinking 格式设计与推理模式控制

8.1 主流 Thinking 格式设计

Thinking 推理内容本身的格式设计没有统一标准,但 <think> 标签正在成为事实标准。不同模型和论文的设计各有差异:

DeepSeek-R1 风格(当前最主流的源头)

<reasoning>
逐步推理过程...
</reasoning>
答案

DeepSeek-R1 原始论文用的是 <reasoning> 标签,但开源社区和后续模型大量改用 <think>,因为更短、更直观。现在 <think> 已经成为大多数推理模型的默认格式。

关键设计点:

  • 推理内容和最终答案在同一个输出流里,用标签分隔
  • 推理部分对用户可见(也可以选择隐藏)
  • 模型自己决定什么时候结束推理、给出答案

Omni-AutoThink 风格(带 answer 标签)

<think>
推理步骤...
</think>
<answer>最终答案</answer>

在 DeepSeek 风格基础上,把最终答案也用 <answer> 标签包起来。好处是:

  • 解析答案时不需要启发式截断,直接取 <answer> 标签内的内容
  • no-thinking 模式可以写成 <think>\n\n</think><answer>答案</answer>,格式完全对齐
  • reward 计算时可以精确判断"有没有思考""答案是什么"

OpenAI o1 风格(隐藏推理)

(内部推理过程,不显示给用户)
最终答案

o1 的推理过程是隐藏的,用户只看到最终答案。内部格式不公开,但推测是类似的特殊 token 分隔。

Qwen3 风格(控制 token + think 标签)

Qwen3 引入了特殊的控制 token 来切换思考模式:

<|thought_start|>
推理过程...
<|thought_end|>
最终答案

同时支持通过 prompt 中的控制 token 强制 all-think / no-think / auto 三种模式。

多维表格 CodeAgent 风格(mode token + 多段结构)

<|mode_direct|>
代码...

<|mode_think_short|>
<think>短推理</think>
代码...

<|mode_replan|>
<plan>方案规划</plan>
<think>推理</think>
代码...

这是最复杂的格式,因为 CodeAgent 需要区分"规划""推理""代码"三种不同内容,而且是多轮交互。

8.2 格式设计的核心要素

不管用什么标签,thinking 格式的设计都要解决这几个问题:

设计决策 选项 影响
推理开始标记 <think>、<reasoning>、<|thought_start|>、无标记 决定模型何时进入推理模式,也决定解析时从哪开始
推理结束标记 </think>、</reasoning>、<|thought_end|>、换行+答案 决定模型何时停止推理、给出答案。没有结束标记时模型可能推理过长
答案标记 <answer>、无标记(最后一段)、Answer: 决定如何提取最终答案。有标签更可靠,无标签更灵活
推理是否可见 可见 / 隐藏 可见方便调试但可能泄露中间步骤;隐藏用户体验好但不可控
是否允许空推理 允许 <think>\n\n</think> / 不允许 允许的话 no-think 和 think 格式统一,方便 RL 中的强制采样和 advantage 计算;不允许的话格式更简洁
单轮 vs 多轮 单次推理 / 多轮 ReAct(思考-行动-观察循环) CodeAgent 必须多轮,纯问答单轮即可

8.3 为什么 <think> 成为了主流

  1. DeepSeek-R1 的影响力:R1 是第一个大规模验证"RL 可以激发推理能力"的开源模型,后续工作大量复用其格式
  2. 短且语义清晰:<think> 比 <reasoning> 短,token 效率高,语义也足够明确
  3. 社区生态成熟:vLLM、SGLang、transformers 等推理框架都内置了对 <think> 格式的解析支持
  4. 便于 no-think 对齐:<think>\n\n</think> 可以完美表示空思考,让 think 和 no-think 两种模式的输出格式完全一致,这对 RL 中的强制采样和 advantage 计算至关重要

8.4 格式设计对训练的影响

格式不是随便选的,它直接影响训练效果:

影响 1:SFT 数据构造难度

  • 如果用 <answer> 标签,SFT 数据需要严格标注答案位置
  • 如果不用标签,模型可能把推理的最后一步当成答案,解析时需要启发式规则

影响 2:RL 奖励计算

  • 有明确标签时,可以精确判断"是否思考了""答案是什么"
  • 无标签时,需要用正则或模型判断推理和答案的边界,容易出错

影响 3:强制采样的实现

  • Omni-AutoThink 能通过 prompt + "<think>\n" 强制 thinking,正是因为格式中有明确的 <think> 开始标签
  • 如果格式是"直接开始推理,没有开始标签",就无法用 prefix forcing 强制采样

影响 4:多轮 Agent 的扩展性

  • 纯问答的 thinking 格式很简单
  • CodeAgent 需要在 thinking 之外加入 action(工具调用)、observation(工具返回),格式设计复杂得多
  • 多维表格用 mode token 区分不同模式,就是为了在多轮场景下保持格式的可控性

8.5 各种格式的对比表

模型/方案 推理开始 推理结束 答案标记 空思考支持 多轮支持
DeepSeek-R1 <reasoning> </reasoning> 无(最后一段) 否 否
社区通用 <think> </think> 无 是 否
Omni-AutoThink <think> </think> <answer> 是 否
Qwen3 <|thought_start|> <|thought_end|> 无 是 否
OpenAI o1 不公开 不公开 无 不公开 否
ReAct 范式 Thought: Action: Final Answer: 否 是
多维表格 CodeAgent mode token + <think> </think> 代码即答案 是(DIRECT 模式) 是

8.6 Qwen3 控制 token 强制三种模式

Qwen3 在模型中内置了思考模式切换机制,通过在 prompt(通常是 system prompt 或生成配置)中指定模式,控制模型是否输出推理过程。

三种模式的切换方式:

All-Think 模式(永远思考)

在 prompt 中加入指令,告诉模型必须先思考再回答:

System: You are a helpful assistant. Think step by step before answering.

User: 1+1等于几?

模型输出:
<|thought_start|>
这是一个简单的加法问题。1加1等于2。
<|thought_end|>
1+1=2

实现上,Qwen3 的 chat template 支持一个 enable_thinking 参数,设为 True 时,模板会自动在 system prompt 中注入思考指令,并且在生成时强制以 <|thought_start|> 开头。

No-Think 模式(永远不思考)

System: You are a helpful assistant. Answer directly without thinking.

User: 1+1等于几?

模型输出:
1+1=2

此时模型不输出 <|thought_start|> 标签,直接给答案。

Auto 模式(自适应思考)

System: You are a helpful assistant. Decide whether thinking is needed based on the question.

User: 1+1等于几?

模型输出(简单题,不思考):
1+1=2

User: 证明根号2是无理数。

模型输出(难题,思考):
<|thought_start|>
要用反证法。假设根号2是有理数...
<|thought_end|>
根号2是无理数,证明如下...

Auto 模式下,模型自己决定要不要输出 <|thought_start|>。

技术实现:三层配合

Qwen3 的控制不是靠单个 magic token,而是三层配合:

层级 机制 作用
SFT 数据 训练数据中同时包含 think 和 no-think 两种格式的样本 让模型学会两种输出方式
Chat Template 模板根据 enable_thinking 参数注入不同 system 指令 在推理时控制模式偏好
Prefix Forcing 生成时可以强制以 <|thought_start|> 开头(all-think)或禁止输出该 token(no-think) 硬控制,确保模式不漂移

其中第三层是关键——和 Omni-AutoThink 的强制采样原理一样:

  • All-think:生成时把 prefix 设为 <|thought_start|>,模型必须从这里继续
  • No-think:生成时把 <|thought_start|> 加入 bad_words_ids(禁止生成的 token 列表),模型永远不能输出这个标签,只能直接回答
  • Auto:不做任何限制,模型自由选择

为什么需要三种模式

  • All-think:用于复杂推理任务,确保模型不偷懒
  • No-think:用于简单任务(如翻译、摘要、格式化),节省延迟和成本
  • Auto:默认模式,平衡效果和效率

8.7 ReAct 格式详解

ReAct = Reasoning + Acting,由 Yao et al. 2022 提出,是 Agent 领域最经典的范式之一。

核心思想:让模型交替进行思考(Thought)和行动(Action),每一步行动后观察结果(Observation),再根据观察决定下一步,直到得出最终答案。

标准格式

Question: 用户的问题

Thought: 我需要先做什么来解决这个问题?
Action: 工具名(参数)
Observation: 工具返回的结果

Thought: 根据观察到的结果,我接下来应该做什么?
Action: 工具名(参数)
Observation: 工具返回的结果

...(重复 Thought-Action-Observation 循环)

Thought: 现在我有足够的信息了,可以给出最终答案。
Final Answer: 最终答案

一个具体例子

Question: 多维表格中A列有100行数据,求平均值并放到B1单元格。

Thought: 我需要先读取A列的数据,然后计算平均值,最后写入B1。
Action: read_range(range="A1:A100")
Observation: 返回A列的100个数值:[23, 45, 12, ...]

Thought: 数据已获取,现在计算平均值。总和是3456,共100行,平均值为34.56。
Action: write_cell(cell="B1", value=34.56)
Observation: 写入成功,B1=34.56

Thought: 任务完成。
Final Answer: 已将A列平均值34.56写入B1单元格。

ReAct 的三个关键组件

组件 作用 格式
Thought 模型的内部推理,分析当前状态、决定下一步行动 Thought: ...
Action 调用工具,格式为 工具名(参数) Action: search("北京天气")
Observation 工具返回的结果,由环境填入,不是模型生成的 Observation: 北京今天晴,25度

ReAct vs 纯 CoT

维度 纯 CoT ReAct
交互 模型自己想,不与外部交互 模型思考→调用工具→观察结果→再思考
信息来源 只有模型参数里的知识 可以获取实时信息、操作外部系统
适用场景 数学推理、逻辑题 需要查资料、操作工具、多步执行的任务
错误恢复 推理错了就一路错到底 可以通过 Observation 发现错误并修正
格式复杂度 简单,只有推理链 复杂,Thought/Action/Observation 交替

ReAct 在 CodeAgent 中的变体

多维表格的 CodeAgent 用的是 ReAct 的变体,格式更贴近代码执行:

Thought: 分析需求,决定写什么代码
Code:
```python
# 代码

Execution Output: 代码执行结果

Thought: 根据执行结果决定下一步 Code:

# 下一段代码

Execution Output: ...

Final Answer: 完成


和标准 ReAct 的对应关系:
- `Thought` → 分析和规划
- `Action: tool(args)` → `Code: 代码块`(代码本身就是行动)
- `Observation` → `Execution Output`(代码执行结果)

**ReAct 的多轮循环为什么重要**

在 CodeAgent 场景中,代码很少一次写对,需要:
1. 写代码 → 执行 → 报错
2. 分析报错 → 修改代码 → 再执行
3. 直到通过

ReAct 的 Thought-Action-Observation 循环天然支持这种试错-修复流程。多维表格 Auto-Thinking 文档中提到的"逐 turn Gate"就是在每个 ReAct turn(每一轮 Thought+Code+Output)开始时,让模型决定这一轮用 DIRECT 还是 THINK 模式。

### 8.8 控制 token 与 ReAct 的联系

Qwen3 的控制 token 和 ReAct 格式解决的是不同层面的问题:

- **Qwen3 控制 token**:控制要不要思考(思考模式的开关)
- **ReAct 格式**:控制思考和行动如何交替(思考的组织方式)

在 CodeAgent 中两者结合使用:

<|mode_think_short|> ← Qwen3式的模式控制(选哪种模式) 分析需求... ← 思考内容 Code: ... ← ReAct式的行动 Execution Output: ... ← ReAct式的观察


多维表格的 Auto-Thinking 本质上就是把"模式选择"(Qwen3 式)和"多轮执行"(ReAct 式)结合起来,在每个 ReAct turn 上做自适应的模式决策。

---

## 九、Auto 模式的数据构造与训练实现

### 9.1 Auto 模式的本质

Auto 模式的本质是:模型学到了一个从"问题特征"到"思考模式"的映射函数。

Mode=f(query,context)\text{Mode} = f(\text{query}, \text{context})

- 简单问题 → ff 输出 no-think
- 困难问题 → ff 输出 think

这个映射函数不是显式编写的,而是通过数据和训练隐式学到的。

### 9.2 SFT 数据:必须同时包含两种模式

关键原则:不能全是 thinking 数据,也不能全是 no-thinking 数据,必须混合。

| 数据类型 | 构造方式 | 作用 |
|---------|---------|------|
| **Thinking 样本** | 困难题 + 完整推理链 + 答案 | 让模型学会"难题要思考" |
| **No-thinking 样本** | 简单题 + 直接答案 | 让模型学会"简单题别废话" |

**具体构造方法**

**方法 A:按难度标注分桶(Omni-AutoThink 的 precise-level 数据)**

对每个题,用多个教师模型跑8次:

  • 正确率 > 80% → 标为 easy → 构造 no-think 样本(直接给答案)
  • 正确率 < 30% → 标为 hard → 构造 think 样本(推理链+答案)
  • 中间的 → 丢弃或两种都构造

得到的数据中,easy 题永远是 no-think 格式,hard 题永远是 think 格式。模型在 SFT 中模仿这些样本,就会初步建立"题目特征 → 模式"的关联。

**方法 B:同一题构造两种格式(AdaCoT 的做法)**

对每个题,同时构造:

  • think 版本:推理答案
  • no-think 版本:答案

SFT 时两种格式都喂给模型。好处是模型对同一道题见过两种模式,不会把"某道题"和"某种模式"死绑定。

**方法 C:难度连续标注(更精细)**

不只是二分 easy/hard,而是给每个题一个难度分数 d∈[0,1]d \in [0,1],然后:
- d<0.3d < 0.3 → no-think
- 0.3≤d<0.70.3 \leq d < 0.7 → 两种格式都有
- d≥0.7d \geq 0.7 → think

这样中间难度的题有两种模式的样本,模型学到的是更平滑的决策边界。

**SFT 数据的配比很重要**

| 配比 | 结果 |
|------|------|
| think 占 90% | 模型塌缩到永远思考 |
| no-think 占 90% | 模型塌缩到永远不思考 |
| think:no-think = 1:1 | 初步平衡,但可能中间状态不稳定 |
| 按真实难度分布配比(简单题多,难题少) | 更接近真实场景,但需要确保难题有足够样本 |

Omni-AutoThink 的 coarse-level 数据是 think:no-think = 2:1(推理数据更多),precise-level 是 1:1。

### 9.3 RL 数据:需要能区分模式优劣的题

RL 数据和 SFT 数据不同,它需要的是"两种模式的表现有差异"的题:

- **太简单的题**:两种模式都能答对 → RL 学不到模式选择(no-think 略优因为奖励高,但差异小)
- **太难的题**:两种模式都答不对 → RL 也学不到(都是负奖励)
- **中等难度的题**:think 能答对、no-think 答不对 → 这是 RL 学习的黄金样本

所以 RL 数据需要过滤:

用 SFT 模型对每个题采样8次:

  • pass rate = 100% → 太简单,过滤掉
  • pass rate = 0% → 太难,过滤掉
  • 0 < pass rate < 100% → 保留,这是有信息量的题

Omni-AutoThink 和多维表格都用了类似的过滤策略(learning-frontier 采样)。

### 9.4 训练阶段一:SFT——学会两种格式 + 初步模式关联

SFT 的目标不是学会自适应,而是:
1. 学会 think 格式(会写推理链)
2. 学会 no-think 格式(会直接给答案)
3. 初步建立"简单题→no-think,难题→think"的倾向

**SFT alone 不够的原因**(Omni-AutoThink 预实验已证明)

SFT 是逐 token 的最大似然估计,它优化的是"每个 token 出现的概率接近训练数据",而不是"选对模式让最终答案正确"。

具体来说,假设训练数据中 70% 是 no-think、30% 是 think:
- 模型学到的是"不管什么题,70% 概率选 no-think"
- 而不是"根据题目难度动态选择"
- 因为 SFT 没有"这道题如果选了另一种模式会怎样"的反事实信号

所以 SFT 后模型的模式选择是基于数据先验的,不是基于题目难度的。

### 9.5 训练阶段二:RL——通过反事实对比塑造自适应决策

RL 是 Auto 模式真正学会的关键。核心机制是强制采样 + 奖励对比。

**步骤 1:强制采样获得反事实信号**

对每个 query q:

  • 强制 thinking 采样 G 条 → 得到这些样本的 reward
  • 强制 no-thinking 采样 G 条 → 得到这些样本的 reward

这样就有了同一道题两种模式的表现对比:
- 如果 no-think 平均 reward > think 平均 reward → 这道题应该不思考
- 如果 think 平均 reward > no-think 平均 reward → 这道题应该思考

**步骤 2:奖励函数设计(最关键)**

奖励函数必须内嵌"模式成本"的差异,否则模型没有理由选择 no-think。

Omni-AutoThink 的奖励:

不思考且答对 = +2 思考且答对 = +1 思考且答错 = 0 不思考且答错 = -1


设计逻辑:
- 不思考答对 > 思考答对 → 鼓励能不思考就不思考(省成本)
- 不思考答错 < 思考答错 → 惩罚该思考却不思考的错误
- 模型通过对比学到:简单题选 no-think(+2 > +1),难题选 think(+1 > -1)

多维表格的奖励(更复杂,分层字典序):

Tier 0(最高优先级):编译/执行是否通过 Tier 1:最终答案是否正确 Tier 2:模式效率(DIRECT > THINK_SHORT > REPLAN) Tier 3:代码质量


先比 Tier 0,相同再比 Tier 1,以此类推。保证模型先学会"别崩溃",再学会"做对",最后学会"选高效模式"。

**步骤 3:GRPO 更新策略**

有了 2G 条带 reward 的样本,计算组内相对 advantage:

Ai=ri−mean(r)std(r)A_i = \frac{r_i - \text{mean}(r)}{\text{std}(r)}

然后用 GRPO loss 更新策略。关键效果:
- advantage > 0 的样本 → 增加其出现概率
- advantage < 0 的样本 → 降低其出现概率

因为强制采样保证了两种模式都有样本,模型就能学到:
- 简单题上 no-think 样本 advantage > 0 → P(no-think) 上升
- 难题上 think 样本 advantage > 0 → P(think) 上升

**步骤 4:多轮迭代**

RL 不是一轮就够的。随着模型能力提升:
- 原来的"难题"可能变简单了 → 应该从 think 切换到 no-think
- 原来的"超纲题"可能变得能做了 → 应该从放弃切换到 think

所以需要动态更新训练数据(learning-frontier 采样),每轮 RL 后重新过滤数据,确保训练数据始终在模型的"学习边缘"上。

### 9.6 强制采样的实现原理:Prefix Forcing

**核心原理:LLM 是自回归的,prefix 决定了后续生成路径。**

大语言模型的生成本质是逐 token 预测:

P(xt∣x1,x2,…,xt−1)P(x_t \mid x_1, x_2, \ldots, x_{t-1})

你给它什么开头,它就按这个开头的"语境"继续往下写。所以只要在 prompt 末尾预先填入不同的起始 token,就能"强制"模型从特定模式开始生成。

**具体实现**

假设原始 query 是:

问题:小明有3个苹果,又买了2个,一共有几个?


强制 Thinking 模式——在 prompt 末尾追加 `<think>\n`:

问题:小明有3个苹果,又买了2个,一共有几个?


模型看到 `<think>` 标签已经打开,且后面是换行,根据 SFT 阶段学到的格式规范,它必须继续生成推理内容,直到自己写出 `</think>`。

强制 No-Thinking 模式——在 prompt 末尾追加 `<think>\n\n</think>`:

问题:小明有3个苹果,又买了2个,一共有几个?

```

模型看到 <think> 标签已经被闭合了(里面只有空行),思考部分已经结束,它接下来只能直接写 <answer>。

为什么这能"强制"而不是"建议"

关键在于 SFT 阶段已经把格式焊死了。模型在 SFT 数据中反复看到:

  • <think>\n推理内容\n</think>\n<answer>答案</answer>(thinking 格式)
  • <think>\n\n</think>\n<answer>答案</answer>(no-thinking 格式)

所以当你在 prefix 里给它 <think>\n 时,模型的下一个 token 分布里,"继续写推理"的概率被拉到接近 100%;当你给它 <think>\n\n</think> 时,"写 <answer>"的概率被拉到接近 100%。

这不是 prompt engineering 层面的"建议",而是利用自回归生成的条件概率特性做的硬控制。

伪代码实现

def adaptive_sample(old_policy, query, G):
    """
    对每个 query,强制采样 G 条 thinking + G 条 no-thinking
    """
    # 构造两种 prefix
    prompt_think = query + "<think>\n"
    prompt_nothink = query + "<think>\n\n</think>"

    # 各采样 G 条
    thinking_outputs = old_policy.generate(
        prompt=prompt_think, num_return_sequences=G, do_sample=True
    )
    nothink_outputs = old_policy.generate(
        prompt=prompt_nothink, num_return_sequences=G, do_sample=True
    )

    all_outputs = thinking_outputs + nothink_outputs
    return all_outputs

为什么叫"强制采样"而不只是"采样"

在 RL 语境中,"采样"特指从当前策略的条件分布中自由采样:oi∼πθold(⋅∣q)o_i \sim \pi_{\theta_{\text{old}}}(\cdot \mid q)。

而 prefix forcing 做的是:oi∼πθold(⋅∣q,prefix)o_i \sim \pi_{\theta_{\text{old}}}(\cdot \mid q, \text{prefix})。条件多了一个 prefix,这不是从 πold(⋅∣q)\pi_{\text{old}}(\cdot|q) 采样,而是从条件受限的分布采样。

自由采样 强制采样
分布 π(o∥q)\pi(o\|q) π(o∥q,prefix)\pi(o\|q, \text{prefix})
模型选择 完全自由,可能 99% 选 no-think 被 prefix 限制,必须从 thinking 开始
反映策略吗 完全反映当前策略 不反映当前策略的模式选择,只反映策略在给定模式下的生成能力
logprob 计算 完整序列的 logprob 只算 prefix 之后的 logprob(prefix 不是模型选的)

一个容易踩的坑:采样出来的完整序列包含了 prefix 部分,计算 logprob 和 reward 时要注意——logprob 需要计算的是模型新生成部分的 logprob,不包括 prefix。因为 prefix 是你强制塞进去的,不是模型"选择"的,不能算进策略概率里。

9.7 自由模式(Auto)的决策机制

强制采样是训练时的探索手段,但模型最终上线推理时是自由选择的。

推理时:模型自己决定第一个 token

自由模式下,prompt 末尾什么都不追加,就是原始 query。模型从这里开始自由生成。它面临的第一个决策就是接下来写什么。

由于 SFT 阶段见过两种格式,模型的第一个 token 分布大致是 P(‘<think>‘)≈0.95+P(\text{`<think>`}) \approx 0.95+。写完 <think> 后,第二个决策才是关键:

P("\n推理内容...")vsP("\n\n</think>")P(\text{"\textbackslash{}n推理内容..."}) \quad \text{vs} \quad P(\text{"\textbackslash{}n\textbackslash{}n</think>"})

  • 如果模型判断这题简单 → 倾向于输出 \n\n</think>(空思考,直接结束思考块)
  • 如果模型判断这题难 → 倾向于输出 \n 然后继续写推理步骤

所以自由模式的"决策点"就在 <think> 之后的那几个 token 上。模型通过这里的 token 选择,隐式地完成了"要不要思考"的判断。

强制 vs 自由的对比

阶段 prompt 末尾 模型行为 目的
训练-强制 thinking q + "<think>\n" 必须写推理 保证组内有 thinking 样本做对比
训练-强制 no-think q + "<think>\n\n</think>" 必须直接给答案 保证组内有 no-think 样本做对比
训练-自由(AUTO) q(什么都不加) 自己决定 让模型练习真实的决策能力
推理上线 q(什么都不加) 自己决定 实际使用

多维表格的设计:显式 Gate Token(更高级的做法)

多维表格方案比 Omni-AutoThink 更进一步,把"决策点"从隐式的格式选择变成了显式的特殊 token。

推理时的自由模式:

用户需求:把A列求和并放到B1
<|endofprompt|>

模型自由生成的第一个 token 就是 mode token:

P("<|mode_direct|>")      → 简单需求,直接写代码
P("<|mode_think_short|>") → 中等需求,短思考
P("<|mode_replan|>")      → 复杂需求,先规划再写

模型输出哪个 token,就走哪条分支。

为什么用显式 token 比隐式格式更好

维度 Omni-AutoThink(隐式) 多维表格(显式 token)
决策点 <think> 后的换行/内容 第一个 token 就是 mode
可监控性 要解析完整输出才知道选了啥 看第一个 token 就知道,可实时统计
可单独训练 决策和推理混在一起,无法单独优化 Gate mode token 的 logprob 可单独提取,做 Gate 专项 SFT/RL
可干预 无法在决策点截断 可以先看 mode token,不对就强制重选
多档位 只有 think/no-think 两档 天然支持 3 档或更多
Mode Regret 计算 需要事后解析输出格式 直接从 mode token 统计,精确到每个状态

9.8 自由模式的能力是怎么训练出来的

第一层:SFT 提供两种模式的"词汇表"

SFT 数据中同时包含两种模式的样本,模型通过模仿学习学会了:

  1. 两种格式都会写(不会出现格式错误)
  2. 初步建立了"题目特征 → 模式"的关联(但很弱)

第二层:RL 的奖励函数塑造决策

以 Omni-AutoThink 的奖励为例,RL 训练时每个 query 同时有强制 thinking 和强制 no-think 的样本。模型通过对比学到:

  • 简单题:强制 no-think 的样本 reward=+2,强制 thinking 的样本 reward=+1 → no-think 的 advantage 更高 → 策略更新后,简单题上 P(no-think) 上升
  • 困难题:强制 no-think 的样本 reward=-1,强制 thinking 的样本 reward=+1 → thinking 的 advantage 更高 → 策略更新后,困难题上 P(thinking) 上升

经过多轮更新,模型在 <think> 之后的 token 分布就变成了题目难度的函数。

第三层:多维表格的 Gate 专项训练

  1. Gate warm-start:先用 300~500 个状态做 SFT,让 mode token 的初始分布不是随机的
  2. 分层 Reward:Tier 0(编译/执行错误)优先于 Tier 1(正确性),保证模型先学会"别选导致崩溃的模式"
  3. Mode Regret 监控:训练中实时统计每个状态下"最优模式 vs 实际选择模式"的效用差,发现 Gate 塌缩就及时干预
  4. 反事实比较:forced-mode rollout 提供了"如果选了别的模式会怎样"的反事实信号,让 Gate 的 advantage 计算更准确

9.9 Auto 模式训练的关键难点

难点 1:模式塌缩(Mode Collapse)

现象:训练到一半,模型突然变成永远思考或永远不思考。

原因:RL 中如果某一种模式的平均 reward 持续高于另一种,策略会快速滑向那种模式。一旦某种模式的采样概率降到接近 0,强制采样也救不回来。

解决方案:强制采样保证两种模式都有梯度信号;奖励函数中内嵌成本差异;监控思考率,发现塌缩及时回滚。

难点 2:SFT 和 RL 的冲突

现象:SFT 学得好好的,RL 一后模式选择反而乱了。

原因:SFT 建立的模式关联是基于数据分布的,RL 的奖励信号可能和 SFT 的先验冲突。

解决方案:SFT 阶段不要把模式选择学得太死;RL 学习率要小;RL 初期保留 SFT 损失(KL 约束)。

难点 3:难度标注的准确性

现象:标注为 easy 的题其实对模型来说很难,导致 SFT 教错了。

原因:人工标注难度和模型实际感知的难度不一致。

解决方案:不用人工标注,用模型实际表现来定义难度;难度标注动态更新;中间难度的题同时构造两种格式。

难点 4:奖励 Hacking

现象:模型学会了"写很短的推理然后给答案",既骗到了 think 的奖励,又省了成本,但推理质量很差。

原因:奖励函数只看"有没有思考标签"和"答案对不对",不看推理质量。

解决方案:加入过程奖励(Process Reward);用 Verifier 模型检查推理和答案的一致性;多维表格方案中用编译/执行结果作为硬约束。

9.10 完整训练流水线总结

┌─────────────────────────────────────────────────────┐
│  数据准备                                             │
│  ┌──────────────┐  ┌──────────────┐                  │
│  │ SFT 数据      │  │ RL 数据       │                  │
│  │ - easy→no-think│  │ - 过滤太简单题 │                  │
│  │ - hard→think   │  │ - 过滤太难题   │                  │
│  │ - 配比≈1:1     │  │ - 保留中等难度 │                  │
│  └──────┬───────┘  └──────┬───────┘                  │
└─────────┼─────────────────┼──────────────────────────┘
          ▼                 ▼
┌─────────────────────────────────────────────────────┐
│  阶段一:SFT                                          │
│  - 学会 think 和 no-think 两种格式                    │
│  - 初步建立"题目→模式"关联                            │
│  - 输出:SFT 模型                                     │
└─────────────────────┬───────────────────────────────┘
                      ▼
┌─────────────────────────────────────────────────────┐
│  阶段二:RL(多轮迭代)                               │
│  每轮:                                              │
│  1. 对每个 query 强制采样 think + no-think           │
│  2. 计算奖励(内嵌成本差异)                          │
│  3. 简单题拒绝策略(减少梯度)                        │
│  4. GRPO 更新策略                                    │
│  5. 重新过滤 RL 数据(learning-frontier)            │
│  6. 监控思考率/Mode Regret,防止塌缩                 │
└─────────────────────┬───────────────────────────────┘
                      ▼
┌─────────────────────────────────────────────────────┐
│  推理:Auto 模式                                      │
│  - prompt 末尾什么都不加                              │
│  - 模型自由输出,根据学到的映射决定要不要思考          │
│  - 简单题→直接答案,难题→先推理再答案                 │
└─────────────────────────────────────────────────────┘

一句话总结:Auto 模式 = SFT 教会两种格式 + RL 通过强制采样的反事实对比 + 内嵌成本差异的奖励函数,让模型在每个具体问题上学会"选哪种模式奖励最高"。


十、动态数据更新与难度评估策略

10.1 固定难度标注的根本性矛盾

在数据上区分思考/不思考,依赖于"哪些题简单、哪些题难"的标注。但固定标注有一个根本性矛盾:

你用 M1/M2/M3 三层模型标定了 L1-L5 难度,然后说"L1-L2 不思考,L3-L5 思考"。但模型训练 1000 步后能力提升了:

  • 原来的 L3 题,现在模型不思考也能答对 → 还在教它"这题要思考"就错了
  • 原来的 L5 题,现在模型思考后能答对了 → 但数据里可能还是"放弃"状态

固定标注的本质是用训练前的模型能力定义难度,但训练过程中模型能力在变,标注就过时了。这和"用昨天的地图导航今天的路"是一个道理。

更严重的是错误信号的放大:如果一道题被标为 hard(要思考),但模型其实不思考也能做对,那么 SFT 阶段教它"这题要思考"→ 学到错误的模式关联;RL 阶段虽然能纠正,但 SFT 的错误先验会拖慢收敛。

训练阶段 固定标注的危害
SFT 初期 危害小,模型能力弱,标注基本准确
SFT 后期 危害中等,部分题难度漂移
RL 初期 危害大,SFT 后的模型能力已经变了
RL 后期 危害最大,模型能力远超标注时的水平

所以越到训练后期,固定标注越有害。

10.2 策略一:Learning-Frontier 动态采样

核心思想:不用固定标注,而是每轮训练后用当前模型重新评估所有题的难度,只保留"模型刚好能学会"的题。

每轮 RL 迭代:
1. 用当前模型 π 对题库中每个题采样 8 次
2. 计算每题的 pass rate p
3. 筛选:0.1 < p < 0.9 的题保留(太简单 p>0.9 过滤,太难 p<0.1 过滤)
4. 用筛选后的题做下一轮 RL
5. 重复

为什么有效:

  • p 接近 1 的题,模型已经会了,两种模式都能做对,学不到模式选择 → 过滤
  • p 接近 0 的题,模型还不会,两种模式都做错,也学不到 → 过滤
  • p 在中间的题,"思考能做对、不思考做错"的概率最大 → 这是模式选择的黄金样本

数据量会越来越少吗?会,但有缓解手段。

假设初始题库有 10000 题,随着训练推进,符合条件的题可能从 7000 道降到 500 道。数据量减少会导致梯度估计方差增大、过拟合、对比信号减少。

但实际中为什么还能用:

  1. 题库通常远大于训练所需:RL 训练每轮只需要几百到几千道题,而题库可能有几十万道
  2. 不是所有题的 pass rate 都会升到 0.9 以上:模型能力提升后,有些题的 pass rate 反而会下降(想多了、多模态不均衡等)
  3. 缓解手段:动态扩充题库、放宽阈值、难度分桶保底、回放机制、教师模型生成难题

多维表格的实际做法是 Learning-Frontier + 分桶保底的组合,既保证中间难度的主导地位,又不会让数据量枯竭。

10.3 策略二:Self-Paced Curriculum Learning

Self-Paced 是为了解决"硬过滤丢数据"的问题——Learning-Frontier 是硬决策(保留/过滤),Self-Paced 是软决策(所有数据都用,但权重不同)。

基本公式

给每个样本 ii 一个权重 wiw_i,权重由模型当前在该样本上的损失 lil_i 决定:

wi=exp⁡(−(li−λ)22σ2)w_i = \exp\left(-\frac{(l_i - \lambda)^2}{2\sigma^2}\right)

或者更常见的分段线性形式:

wi={1,li<λ−σλ+σ−li2σ,λ−σ≤li≤λ+σ0,li>λ+σw_i = \begin{cases} 1, & l_i < \lambda - \sigma \\ \frac{\lambda + \sigma - l_i}{2\sigma}, & \lambda - \sigma \leq l_i \leq \lambda + \sigma \\ 0, & l_i > \lambda + \sigma \end{cases}

参数含义

参数 含义 动态变化
lil_i 模型在样本 ii 上的损失(越低表示越简单) 每轮重新计算
λ\lambda 目标难度中心(训练焦点) 随训练推进逐渐增大(从简单到困难)
σ\sigma 难度带宽(控制关注范围) 可以固定或自适应调整

训练流程

初始化:λ 很小(只关注最简单的题)

每轮:
1. 用当前模型计算所有样本的损失 l_i
2. 按公式计算权重 w_i
3. 用加权损失训练:L = Σ w_i * l_i
4. 增大 λ(让焦点移向更难的题)
5. 重复

为什么叫"自步":传统课程学习是人工预设课程顺序,而 Self-Paced 是模型自己决定学什么。步长由模型能力决定,不是人工固定的。

权重函数的各种形式——不一定是正态分布

形式 公式 特点
硬阈值 wi=1[li<λ]w_i = \mathbb{1}[l_i < \lambda] 就是 Learning-Frontier,非0即1
线性衰减 wi=max⁡(0,1−li/λ)w_i = \max(0, 1 - l_i/\lambda) 简单题权重高,线性下降
对数惩罚 wi=log⁡(1+exp⁡(λ−li))w_i = \log(1 + \exp(\lambda - l_i)) 平滑过渡,可微
高斯(正态分布) wi=exp⁡(−(li−λ)2/2σ2)w_i = \exp(-(l_i-\lambda)^2/2\sigma^2) 钟形曲线,只关注特定难度范围
分段线性 三角形函数 计算简单,有明确的上下界

高斯形式确实是正态分布的形状,但它只是众多选择之一。分段线性因为计算简单、有明确上下界,在实践中更常用。

和硬过滤的对比

维度 Learning-Frontier(硬过滤) Self-Paced(软加权)
数据利用 低(丢弃多) 高(所有数据都用,权重不同)
梯度噪声 低(只用高质量数据) 高(困难题权重低但仍有噪声)
实现复杂度 低 中(需要调 λ\lambda 和 σ\sigma)
过拟合风险 高(数据少) 低(数据多)
模式塌缩风险 高(简单题全滤掉) 低(简单题仍有小权重)

10.4 策略三:Difficulty-Anchored Mixing

核心思想:不试图精确标注每题难度,而是维护多个难度桶,每个桶按固定比例采样。

维护 5 个桶:
- 桶1:当前模型 pass rate > 0.9(简单)
- 桶2:pass rate 0.7-0.9
- 桶3:pass rate 0.5-0.7(中等)
- 桶4:pass rate 0.3-0.5
- 桶5:pass rate < 0.3(困难)

每轮采样比例:桶1:桶2:桶3:桶4:桶5 = 1:2:4:2:1

桶会空吗?不会,因为桶是每轮动态重新划分的。

每轮用当前模型重新计算 pass rate 重新分桶,桶的定义不变,但桶里的题在变。原来桶3的题变简单后进了桶1,原来桶5的题可能进了桶4。

但极端情况下后面的桶会枯竭:如果模型持续变强而题库不扩充,最终所有题的 p 都会 >0.9,桶4、桶5就空了。

解决方案:百分位分桶(而不是固定阈值分桶)

不用固定的 pass rate 阈值,而是按排序后的百分位分桶:

把所有题按 pass rate 排序,平均分 5 组:
  桶1:p 最低的 20%(最难的 20%)
  桶2:接下来的 20%
  桶3:中间 20%
  桶4:接下来的 20%
  桶5:p 最高的 20%(最简单的 20%)

这样每个桶永远有 20% 的数据,不会空。模型变强后,桶的绝对难度上升了,但相对比例不变。

百分位分桶 vs 固定阈值分桶

维度 固定阈值分桶 百分位分桶
桶定义 p>0.9, 0.7-0.9, ... 排序后前20%, 接下来20%, ...
数据量保证 不保证(桶可能空) 保证(每桶固定20%)
绝对难度 固定 漂移(模型变强后桶3的绝对难度上升)
训练稳定性 可能因数据量波动而不稳定 稳定
适用场景 题库极大且难度分布稳定 题库有限或模型能力变化大

实践中百分位分桶更常用。

10.5 策略四:On-Policy Data Generation

不用固定题库,而是用当前模型自己生成训练数据。

每轮:
1. 用当前模型对一批 prompt 自由采样
2. 对采样结果做过滤:
   - 答对的 → 检查模式选择是否合理
   - 答错的 → 用更强的模型生成正确轨迹
3. 把高质量的样本加入下一轮训练

这就是 RFT(Rejection Fine-Tuning)和 SPIN(Self-Play Fine-Tuning)的思路。数据永远和当前模型能力对齐,不存在过时问题。

10.6 策略五:Multi-Model 难度锚定

用不同能力层级的模型的相对表现来客观定义难度。Omni-AutoThink 用了 M1/M2/M3 三层:

层级 模型 角色
M1 较弱基座(Qwen-Omni-7B) 基线
M2 各模态专用非推理模型 专家教师
M3 各模态专用推理模型(DeepSeek-R1 等) 推理专家

每个题用每层模型各跑 8 次,根据正确率定义五级难度 L1-L5。

Multi-Model 锚定像蒸馏吗?像,但本质不同。

维度 蒸馏 Multi-Model 难度锚定
目标 让学生变强(模仿教师输出) 给题目分级(测量题目难度)
教师输出怎么用 直接作为训练目标(软标签/logits) 只看正确率,不看具体输出内容
学生和教师的关系 学生要逼近教师 学生和教师无关,教师只是量具
训练信号 教师的完整输出分布 只有一个标量(对/错)

一句话:蒸馏是"照着老师学",难度锚定是"用老师当秤砣称题目有多重"。

10.7 没有更强的教师模型怎么办?七种替代方案

当你的模型已经是 SOTA,没有 M3 了,不需要外部更强模型,用模型自身的多种信号就能定义难度。

方案 1:和过去的自己比(Self-Play 式难度)

M_past = 1000 步前的 checkpoint(更弱的自己)
M_now = 当前模型

难度定义:
- M_past 做错但 M_now 做对 → 刚学会的题(中等难度,最有训练价值)
- M_past 做对且 M_now 做对 → 已经掌握的简单题
- M_past 做错且 M_now 也做错 → 还没学会的难题

优点:不需要外部模型,难度天然和当前能力对齐。缺点:只能区分相对难度,需要保存历史 checkpoint。

各家有尝试吗? 有,但大多不是以"难度评估"的名义出现:

  • SPIN (Self-Play Fine-Tuning, 2024):用当前模型生成输出,和真实数据配对迭代提升
  • AlphaGo/AlphaZero:自我对弈生成棋局
  • DeepSeek-R1:RL 中模型自己生成推理轨迹,用正确率筛选
  • UltraFeedback:用多个模型生成回答,用 GPT-4 打分排序
  • Iterative DPO / Online DPO:每轮用当前模型生成偏好对

专门用"过去的自己"定义难度的论文不多,但在 Auto 模式训练中这个思路特别自然。

方案 2:自一致性(Self-Consistency)

同一道题用当前模型采样多次,看答案是否一致:

Difficulty(q)=1−max⁡ccount(c)N\text{Difficulty}(q) = 1 - \max_c \frac{\text{count}(c)}{N}

8 次答案全一致 → 简单题;答案分散 → 难题。

优点:完全不需要外部模型,不依赖正确答案(无监督)。缺点:采样多次成本高;模型可能"自信地错"(对错误答案高度一致),这时会把难题误判为简单题。

"自信地错"对 Auto 模式的影响:分两种情况——

  • 如果 think 模式也选同一个错误答案 → 两种模式都错,选啥都一样,误判代价为 0
  • 如果 no-think 坚定地错但 think 能做对 → 这才是危险情况,该思考却没思考

解决方案:自一致性必须在两种模式下分别做,或者直接用强制采样的两种模式的答案对比。

方案 3:模型置信度(Logprob / 熵)

用模型输出的概率信息衡量难度,一次前向传播就能得到:

Confidence(q)=1T∑t=1Tlog⁡P(xt∣x<t,q)\text{Confidence}(q) = \frac{1}{T} \sum_{t=1}^{T} \log P(x_t \mid x_{<t}, q)

置信度高 → 简单题,置信度低 → 难题。

优点:成本最低。缺点:LLM 普遍过度自信,置信度和真实正确率不一定校准。

为什么需要温度校准:模型输出的概率(softmax)和真实正确率之间存在系统性偏差。温度校准在 softmax 之前把 logits 除以温度 T:

P(yi∣x)=exp⁡(zi/T)∑jexp⁡(zj/T)P(y_i \mid x) = \frac{\exp(z_i / T)}{\sum_j \exp(z_j / T)}

在验证集上搜索最优 T,使得校准后的概率和真实正确率最接近(用 ECE 衡量)。不校准的话,"置信度 >0.9"可能实际只有 60% 正确率,筛选标准完全失真。

置信度也存在"自信地错"的问题,而且更严重——特别是在分布外(OOD)的题上,模型完全不懂但会给出很高的置信度。所以置信度通常作为第一级快筛,中间区域再用多次 rollout 精确评估。

方案 4:过程失败信号(Process-Based Difficulty)

在 CodeAgent 场景中,执行过程本身就是难度信号:

对题 q 让模型自由执行一次:
- 一次通过(无报错) → 简单题
- 1-2 次修复后通过 → 中等题
- 多次修复后通过 → 较难题
- 最终失败 → 难题

优点:完全来自任务本身,和"模型需要多少努力"直接对应。缺点:只适用于有执行反馈的场景。

方案 5:对抗式难题生成(Adversarial Generation)

用当前模型自己生成它做不对的题:

循环:
1. 用生成模型生成一批题
2. 用当前模型做这些题
3. 筛选出模型做错的题 → 这就是难题
4. 加入训练集
5. 训练后模型变强,再生成更难的题

这非常像 GAN:生成器 = 题目生成模型,判别器 = 当前模型(做错的就是"真"难题)。

GAN 的所有问题它几乎都有:

  • 分布偏置:模型自己出题倾向于出它"熟悉"的类型,导致恶性循环
  • 模式崩溃:生成器可能收敛到只生成少数几种"万能难题"
  • 质量退化:为了生成"做不对的题",可能出超长题、歧义题、格式怪异题

解决方案:用多个不同的生成模型、种子 prompt 约束范围、聚类去重、定期注入外部数据、reward model 过滤质量。

方案 6:多路径对比(Multi-Path Consistency)

同一道题,让模型用不同的推理路径去解,看结果是否一致。在 Auto 模式中,这天然就是强制采样的副产物:

Difficulty(q)=1[answerthink≠answernothink]\text{Difficulty}(q) = \mathbb{1}[\text{answer}_{\text{think}} \neq \text{answer}_{\text{nothink}}]

两种模式答案不一致 → 难题(模式选择很关键);一致 → 简单题。

方案 7:混合策略(工业界实际做法)

没有任何单一方案是完美的,实际中通常组合多种信号:

难度分数 = w1 * 自一致性 + w2 * 模型置信度 + w3 * 修复次数 + w4 * 多路径一致性

多维表格的实际做法接近这种混合:用执行通过率作为主要难度指标,用 forced-mode 对比判断模式选择的关键程度,用 learning-frontier 筛选中等难度的题。

10.8 绝对难度 vs 相对难度

为啥要定义绝对难度? 严格来说训练时不需要绝对难度,需要的是相对难度。但绝对难度有不可替代的工程价值:

用途 为什么需要绝对难度
数据集管理 需要知道题库里各难度有多少题,决定要不要补充
跨实验对比 不同实验的"中等难度"需要统一标准
评估报告 "L4 题正确率从 30% 提升到 60%"比"模型觉得难的题提升了"更有说服力
数据采样配比 保证简单:中等:困难的稳定比例
故障排查 知道是所有难度都崩了还是只有难题崩了

实践中的做法:绝对难度当锚点(更新频率低),相对难度当操作(每轮更新)。

10.9 各难度评估方法对比

方案 需要外部模型 需要标注 计算成本 抗"自信地错" 多样性 适用场景
Multi-Model 锚定 是 否 高 强 取决于题库 有更强模型时
过去的自己 否 否 中 中 取决于题库 任何场景
自一致性 否 否 高 弱 取决于题库 有确定答案的题
模型置信度 否 否 低 弱 取决于题库 快筛
过程失败信号 否 否 中 强 取决于任务 CodeAgent
对抗生成 否 否 高 中 弱 扩充题库
多路径对比 否 否 中 中 取决于题库 Auto模式训练

10.10 三种动态数据策略的本质对比

策略 数据利用 难度动态性 防枯竭 实现复杂度
Learning-Frontier(硬过滤) 低 高 弱 低
Self-Paced(软加权) 高 高 强 中
Difficulty-Anchored(分桶) 中 中 强 中

工业界通常组合使用:百分位分桶保证数据量和难度覆盖,桶内用 Self-Paced 权重进一步聚焦,同时动态扩充题库。多维表格的方案就是这种组合思路的工程化实现。

核心闭环:强制采样(保证有对比信号)→ 奖励函数(告诉模型哪种模式好)→ 策略更新(模型能力提升)→ 动态数据更新(用新模型重新评估难度)→ 下一轮强制采样。任何一环缺失都会导致训练失败。


第四部分:Omni-AutoThink 论文深度解读

论文:Omni-AutoThink: Adaptive Multimodal Reasoning via Reinforcement Learning 作者:Dongchao Yang, Songxiang Liu(通讯), Disong Wang, Yuanyuan Wang, Guanglu Wan, Helen Meng 单位:香港中文大学 + 美团 发表:arXiv:2512.03783,2025年12月3日 基座模型:Qwen2.5-Omni-7B

一、论文基本信息与研究问题

现有 Omni 模型(能同时处理文本、音频、视觉的多模态大模型)在推理行为上是刚性的,只有两种模式:

  1. Thinking mode(永远思考):对每个 query 都生成完整推理链 → 简单问题上浪费计算
  2. No-thinking mode(永远不思考):直接输出答案 → 复杂问题上正确率低

论文要解决的是 auto-thinking(自动思考):模型根据问题难度,自己决定要不要思考、思考多深。

二、三个关键预实验(负结果的价值)

论文在 Section 3.2 做了三个假设验证,全部失败。这个过程直接催生了后续方法设计,是论文最有价值的部分之一。

假设 1:靠 Prompt 就能让模型自适应思考

做法:在 prompt 里告诉模型"如果问题简单就直接回答,如果难就先思考再回答"。

结果:简单题正确率 0.94,思考率 0.01;困难题正确率 0.34,思考率 0.01。模型几乎从不思考,不管难易。

结论:Prompt alone 不够,自适应推理是一种需要训练的能力,不是靠外部指令就能激发的。

假设 2:靠 SFT(带难度标注的数据)就能学会

做法:构造数据集,简单题只给直接答案,困难题给"推理链+答案",做监督微调。

结果:简单题正确率 0.95,思考率 0.00;困难题正确率 0.42,思考率 0.00。模型塌缩到永远不思考。

结论:SFT alone 会塌缩。因为 SFT 是模仿学习,模型发现"不思考"在大多数样本上都能拿到不错的 loss(简单题占多数),就倾向于永远不思考。

假设 3:靠普通 RL(GRPO + 格式奖励 + 正确率奖励)就能学会

做法:用 GRPO,奖励 = 格式奖励(是否输出了思考格式)+ 正确率奖励,两者权重都是 1。

结果:简单题正确率 0.98,思考率 0.00;困难题正确率 0.45,思考率 0.00。仍然塌缩到永远不思考。

更反直觉的发现:在 RL 训练中,不思考的正确率反而比思考更高(困难题 0.48 vs 0.45)。

原因分析:

  1. 预定义的 easy/hard 标签在训练过程中失效了——模型能力提升后,原来的"难题"变简单了,固定的格式奖励就不再合理
  2. 基座模型缺乏内在推理能力——Qwen2.5-Omni 在预训练中没有接触足够的推理链,所以思考反而引入噪声,降低正确率。RL 发现"不思考更准",就优化到永远不思考

这三个负结果证明了:自适应推理不是随便训训就能出来的,需要专门设计的训练框架。

三、Adaptive SFT:两层数据构造

目标

两个:(1) 给基座模型补上基本的推理能力;(2) 让模型同时学会 thinking 和 no-thinking 两种格式。

两种模式的格式定义

Thinking mode:
<think>
推理步骤
</think>
<answer>答案</answer>

No-thinking mode:
<think>
</think>
<answer>答案</answer>

注意 no-thinking 模式也输出 <think>\n\n</think> 空标签,这是为了让两种模式的输出格式对齐,方便后续 RL 中通过 prompt 后缀强制采样。

两层数据构造

层级 规模 构造方式 目的
Coarse-level(粗粒度) 大规模(571k) 所有带推理链的样本 → thinking mode;所有不带推理链的 → no-thinking mode 让模型获得通用推理能力,推理:非推理 = 2:1
Precise-level(精粒度) 小规模高质量 用多个教师模型标注难度,L1-L2 标为 easy(no-thinking),L3-L5 标为 hard(thinking)。thinking:no-thinking = 1:1 让模型学会区分难易,精确控制模式选择

训练策略

两阶段顺序训练:

  1. 先在 coarse-level 数据上训 1 epoch(学习率 1e-5)→ 获得通用推理能力
  2. 再在 precise-level 数据上训 1 epoch → 细化模式区分能力

四、Adaptive GRPO:强制采样与拒绝策略

这是论文最核心的技术贡献。在 vanilla GRPO 基础上做了两个关键改进。

改进 1:自适应采样(Adaptive Sampling)

问题:普通 GRPO 让模型自由采样,由于 SFT 后模型倾向于不思考,采出来的轨迹几乎全是 no-thinking,组内没有 thinking 样本做对比,advantage 计算就没有意义。

解法:通过在 prompt 末尾追加不同后缀,强制 old policy 分别采样两种模式:

采样 thinking 输出:prompt + "<think>\n"
采样 no-thinking 输出:prompt + "<think>\n\n</think>"

每个 query 采样 G 条 thinking + G 条 no-thinking,共 2G 条输出。这样保证组内一定有两种模式的样本可以对比。

这和多维表格 Auto-Thinking 文档中的 forced-mode rollout(2 forced DIRECT + 2 forced THINK + 4 AUTO)思想完全一致——都是通过强制采样保证模式探索。

改进 2:拒绝策略(Rejection Strategy)

问题:每个 query 采 2G 条输出,计算成本翻倍。而且简单题上两种模式都能答对,对学习"何时思考"没有信息量。

解法:

  1. 计算 2G 条轨迹的平均 reward ravgr_{avg}
  2. 如果 ravg>τr_{avg} > \tau(阈值),判定为简单题 → 在 thinking 组和 no-thinking 组内各按 reward 排序,只保留 top G/2 条,mask 掉另一半
  3. 如果 ravg≤τr_{avg} \leq \tau,判定为困难题 → 保留全部 2G 条

效果:

  • 简单题减少梯度信号(因为两种模式都能做对,学不到模式选择)
  • 困难题保留全部信号(模式选择对结果影响大,是学习的关键)
  • 整体计算成本降低

数学上,通过 mask 变量 mi∈{0,1}m_i \in \{0,1\} 控制哪些样本参与 advantage 计算:

A^i,t(m)=r(q,oi)−mean{r(q,os1),…,r(q,osk)}std{…}⋅mi\hat{A}^{(m)}_{i,t} = \frac{r(q,o_i) - \text{mean}\{r(q,o_{s_1}),\ldots,r(q,o_{s_k})\}}{\text{std}\{\ldots\}} \cdot m_i

完整算法

输入:old policy π_old, query q, group size G, threshold τ
1. 构造两种 prompt:
   P_think = q + "<think>\n"
   P_nothink = q + "<think>\n\n</think>"
2. 用 π_old 各采样 G 条输出 → O_t(thinking), O_n(no-thinking)
3. 计算所有 2G 条的 reward r_i,计算 r_avg
4. 如果 r_avg > τ(简单题):
   各组内按 reward 排序,各保留 top G/2,mask 掉其余
   否则(困难题):保留全部
5. 用保留的样本计算组内相对 advantage
6. 用 GRPO loss 更新策略

五、奖励函数设计:内嵌成本差异的四档奖励

R={+2,no-think and correct+1,think and correct0,think and incorrect−1,no-think and incorrectR = \begin{cases} +2, & \text{no-think and correct} \\ +1, & \text{think and correct} \\ 0, & \text{think and incorrect} \\ -1, & \text{no-think and incorrect} \end{cases}

这个奖励设计是整个方法能 work 的核心:

情况 奖励 设计意图
不思考且答对 +2(最高) 强烈鼓励简单题直接做,省计算
思考且答对 +1 思考能答对也不错,但比不思考答对低 1 分,体现成本惩罚
思考且答错 0 思考了但没答对,不惩罚也不奖励
不思考且答错 -1(最低) 该思考却不思考导致错误,严厉惩罚

关键洞察:这个奖励不需要预先标注题目难易!它通过奖励差异自动引导模型:

  • 简单题:不思考答对(+2) > 思考答对(+1) → 模型学会不思考
  • 困难题:不思考答错(-1) < 思考答对(+1) → 模型学会思考
  • 模型自己在训练中发现"哪些题不思考能答对",自适应地调整策略

这比 AdaCoT 的方法更简洁——AdaCoT 需要手动调整惩罚系数 α1/α2 来在 Pareto 前沿上选点,而 Omni-AutoThink 的奖励函数本身就内嵌了"正确率优先、成本其次"的权衡。

六、数据集与 Omni Adaptive Reasoning Benchmark

训练数据

模态 SFT 数据来源 RL 数据来源
Text-only Alpaca-gpt4, OpenMath, OpenThoughts TextRL
Text-Audio Audio-Reasoner Audio-Reasoner
Text-Vision Multimath, LLaVA-R1 Vision-R1
Text-Vision-Audio Omini-instruct Omini-instruct

RL 数据过滤策略:用 SFT 模型对每个 query 采样 8 条输出,过滤掉 pass rate 为 100%(太简单)或 0%(太难)的样本,只保留中等难度的题。

Benchmark 贡献

Omni Adaptive Reasoning Benchmark 是第一个覆盖四种模态、带五级难度标注的自适应推理评测基准,共 3.6k 题。

七、难度校准协议:三层模型定义五级难度

不用人工标注,而是用三层模型的相对表现来客观定义难度:

层级 模型 角色
M1 Qwen-Omni-7B(较弱基座) 基线
M2 各模态专用非推理模型(Qwen2.5-7B 文本 / Qwen2.5-VL-7B 视觉 / Gemini Flash 2.0 音频) 专家教师
M3 各模态专用推理模型(DeepSeek-R1-7B 文本 / Seed-VL 1.5 视觉 / Gemini 2.5 Pro 音频) 推理专家

每个题用每层模型各跑 8 次,根据正确率定义五级难度:

难度 定义 直觉
L1 Trivial M1 8次中对 >6 次 弱模型也能轻松做对
L2 Simple M1 对 >3 次 且 M2 对 >6 次 弱模型偶尔对,专家稳定对
L3 Intermediate M1 对 <3 次 且 M2 对 >7 次 弱模型不行,非推理专家能做对
L4 Challenging M2 对 <3 次 且 M3 对 >6 次 非推理专家不行,推理专家能做对
L5 Expert M3 对 <3 次 连推理专家都经常做错

优点:客观、可复现、跨模态统一。实验验证了难度标注的可靠性——所有开源模型的正确率都随 L1→L5 单调下降。

八、实验结果与消融研究

主结果(Text-Audio 模态为例)

模型 L1 Acc/Rate L3 Acc/Rate L5 Acc/Rate ALL Acc/Rate
Qwen2.5-Omni 0.99/0.00 0.65/0.00 0.06/0.00 0.65/0.00
Qwen3-Omni 0.96/0.00 0.60/0.00 0.36/0.00 0.72/0.00
Ours 0.98/0.17 0.65/0.60 0.38/0.71 0.73/0.47

关键观察:

  • 基座模型思考率全是 0(永远不思考)
  • Ours 的思考率随难度单调上升:L1 17% → L3 60% → L5 71%
  • 总正确率 0.73 超过了 Qwen3-Omni-30B 的 0.72(7B 模型超过 30B 模型)

三种模式对比

模式 Text-only Text-Audio Text-Visual Text-Audio-Visual
All-think 0.77 0.69 0.54 0.62
All-no-think 0.53 0.72 0.59 0.68
Auto-think 0.66 0.73 0.56 0.69

自适应模式在 3/4 个模态上最优。Text-only 上 all-think 略好,论文归因于 SFT 阶段大量高质量文本推理数据。

消融研究

SFT 和 RL 各自的贡献:

配置 Text-only Acc/Rate Text-Audio Acc/Rate
Base 0.35/0.26 0.64/0.00
Base+SFT 0.49/0.16 0.64/0.00
Base+RL(无SFT) 0.60/0.85 0.66/0.00
Base+SFT+RL 0.66/0.48 0.73/0.47

关键发现:

  • SFT alone 不会产生自适应行为(思考率 0.16 或 0.00)
  • RL without SFT 会塌缩到永远思考或永远不思考
  • SFT+RL 组合才是关键——SFT 提供推理能力基础,RL 学会模式选择

Adaptive GRPO vs 普通 GRPO:

配置 Text-only Acc/Rate Text-Audio Acc/Rate
GRPO-only 0.82/1.0 0.64/0.0
Adaptive GRPO 0.66/0.48 0.73/0.47

普通 GRPO 在 Text-only 上塌缩到永远思考(Rate=1.0),在 Text-Audio 上塌缩到永远不思考(Rate=0.0)。Adaptive GRPO 成功学到了自适应行为。

九、与多维表格 Auto-Thinking 方案的对比

这篇论文和多维表格的 Auto-Thinking 方案高度相关,是理论前身和工程扩展的关系:

维度 Omni-AutoThink 论文 多维表格 Auto-Thinking 文档
模式数 2 档(think / no-think) 3 档(DIRECT / THINK_SHORT / REPLAN)
强制采样 prompt 后缀强制采样 G+G forced-mode rollout(2+2+4 或 2+2+1+3)
奖励设计 内嵌成本差异的 4 档奖励(+2/+1/0/-1) 分层字典序 Reward(Tier 0-4)
SFT 作用 补推理能力 + 学两种格式 冷启动三分支能力 + Gate warm-start
RL 算法 Adaptive GRPO(改进版) multi-turn GRPO/DAPO + turn-level advantage
难度处理 拒绝策略自动过滤简单题 learning-frontier 动态分桶采样
Gate 机制 无显式 Gate token,靠输出格式隐式选择 显式 reasoning-mode token
评估指标 正确率 + 思考率(按难度分层) Mode Regret + Pass@1 + First-repair + 分解指标
应用场景 多模态问答(文本/音频/视觉) 多维表格 CodeAgent(代码+工具调用+多轮修复)
多轮交互 单轮问答 多轮 ReAct(最多 20 步),逐 turn 决策

多维表格方案的进阶之处:

  1. 从 2 档扩展到 3 档,增加了 REPLAN(方案级重规划)
  2. 引入显式 Gate token,让模式选择可单独训练、单独监控
  3. 从单轮扩展到多轮,每个 ReAct turn 都做模式决策
  4. 用 Mode Regret 替代简单的"思考率"作为核心评估指标
  5. Reward 设计更精细(分层字典序 + 多维表格专用 verifier + process reward)
  6. 更完整的防塌缩机制(六种崩溃模式的诊断和修复)

Omni-AutoThink 的简洁之处值得借鉴:它的奖励函数设计(+2/+1/0/-1)非常优雅,不需要手动调成本系数,就能自动引导模型学会自适应。

十、局限性与总结

局限性

  1. 基座模型限制:基于 Qwen2.5-Omni-7B,文本域效果不如更大的模型
  2. 二分类模式:只有 think/no-think 两档,没有思考深度的连续调节
  3. 单轮问答:没有处理多轮 Agent 交互中的自适应思考
  4. 评估指标较粗:只用正确率和思考率,没有 Mode Regret 这样的精细化指标
  5. 奖励函数的 +2/+1 比例是手动设定的:不同任务可能需要不同比例

总结

Omni-AutoThink 通过三个负结果证明了自适应推理不是 trivial 的,然后提出了一个简洁有效的两阶段方案:Adaptive SFT 补推理能力 + Adaptive GRPO(强制双模式采样 + 简单题拒绝策略 + 内嵌成本差异的 4 档奖励)学会模式选择。

核心洞察:不需要预先标注题目难易,只要设计合理的奖励函数(不思考答对 > 思考答对 > 思考答错 > 不思考答错),模型就能在 RL 中自己发现"哪些题该思考"。这篇论文是多维表格三档 Auto-Thinking 方案的重要理论基础之一。


附录:Auto-Thinking 原始文档全文

以下为《多维表格 CodeAgent:Auto-Thinking 的 SFT 与 RL 完整训练方案》原始文档全文,作者王哲,2026.07.30。

0. 结论先行

推荐采用逐 ReAct turn 的三档自适应策略:

DIRECT
  不输出 thinking,直接调用工具、生成/修改代码或结束

THINK_SHORT
  输出一段 64~128 tokens 的自然语言决策说明,硬上限 160 tokens
  然后执行一次高置信度动作

REPLAN
  原方案的核心假设已经失效时,输出 128~192 tokens 的重规划
  硬上限 256 tokens,然后按新计划执行

已有 5,000 条 DIRECT 时,不应再按"5,000 条总 SFT"重新切分。建议在其上增量补充:

模式 建议数量 默认数量 默认总体占比 SFT 阶段的定位
DIRECT 已有 5,000 5,000 约 85.5% 主能力、Pass@1 与"不必思考"的强先验
THINK_SHORT 新增 600~800 700 约 12.0% 冷启动错误归因、一次修复和短决策接口
REPLAN 新增 100~200 150 约 2.6% 冷启动方案失效识别、回滚和重规划能力

默认总量为 5,850 条,约为:DIRECT / THINK_SHORT / REPLAN = 85.5% / 12.0% / 2.6%

此外构建 300~500 个同状态模式比较样本,作为轻量 Gate warm-start。这些状态可从上述轨迹派生,不一定增加新的用户 query。

SFT 的任务是让三个分支在被强制选择时都具备可用能力,并让 Gate 不至于从零开始;它不负责规定线上最终模式比例。真正的 Auto-thinking 主要由 RL 在同一状态比较不同模式的真实正确性和成本后学习。随着模型能力提高,原来需要 THINK_SHORT 的状态会逐渐变成 DIRECT,因此 Gate 决策边界必须用当前 checkpoint 的真实 rollout 周期性重算。

推荐训练顺序:

① DIRECT 基础能力:使用已有 5,000 条数据建立 Pass@1 主能力
② 模式能力冷启动:新增少量 Short-thinking/Replan,强制 mode,Gate loss=0
③ Gate 轻量 warm-start:仅用 300~500 个高信息状态避免 RL 初始零探索
④ 多轮在线 RL:同状态强制模式探索,学习真正的 Auto-thinking 边界
⑤ Pareto 压缩与周期刷新:正确性稳定后优化成本,让更多状态回归 DIRECT

最重要的六条原则:

  1. <thinking> 应是简短、自然且有证据的决策说明,不使用固定字段表单,也不是自由发挥的长篇思考。
  2. 错误 action 和工具 observation 作为上下文保留,但在 SFT 中 loss mask=0;从正确的恢复判断开始训练 recovery suffix。
  3. mask=0 只是"不模仿错误",不会主动抑制重复;同状态偏好数据或 RL 才能教会模型"不要再这么做"。
  4. 高阶模型负责标注、纠错、压缩和生成候选,基模负责产生真实失败状态,真实环境负责最终判真。
  5. Reward 必须按"安全与数据完整性 > 功能正确 > 无回归 > 有效进展 > 成本"排序;不能用省 token、少工具调用换取错误答案。
  6. SFT 只冷启动模式能力和最小 Gate 探索,Auto-thinking 的主要训练责任放在同状态反事实 RL。

1. 训练目标与评测口径

1.1 目标函数不是"少思考",而是"以最低总代价正确完成"

把一次轨迹的效用写成:

U(τ)=Rcorrect−Cregression−λtCtool−λzCthinking−λwCwalltime−λrCrepeatU(\tau) = R_{\text{correct}} - C_{\text{regression}} - \lambda_t C_{\text{tool}} - \lambda_z C_{\text{thinking}} - \lambda_w C_{\text{walltime}} - \lambda_r C_{\text{repeat}}

优化优先级应是字典序,而不是简单把所有项等价相加:

安全、权限与数据完整性
> 任务功能正确
> 无回归
> 一次恢复成功
> 少重复、少工具调用、低时延、短 thinking

原因很简单:一次 64-token 的短 thinking 如果能避免一次昂贵的构建和两轮错误修复,总成本反而更低。只惩罚 thinking token 会把 Gate 推向永远 DIRECT;只奖励成功又会把 Gate 推向永远 THINK 或 REPLAN。

1.2 核心指标

不要只看最终成功率。至少同时看以下指标:

指标 定义
Pass@1 / First-pass success 第一次完整产物提交后直接通过全部验收
First-repair success 第一次失败后,仅允许一次修复时的成功率
Conditional recovery 首次失败条件下最终恢复成功率
Median recovery turns 成功恢复所需的中位修复 turn 数
Semantic repeat rate 状态未变化、动作语义重复且无新增信息的比例
Noisy-feedback overreaction 环境噪声或存量错误导致无关代码修改的比例
Premature-stop rate 未完成或未验证就输出 done 的比例
Regression rate 目标需求通过但破坏已有表、字段、视图、公式或数据的比例
Unnecessary-thinking rate DIRECT 足够成功但 Gate 选择 THINK/REPLAN 的比例
Thinking-necessity recall THINK/REPLAN 明显优于 DIRECT 时,Gate 选择非 DIRECT 的比例
Replan precision 选择 REPLAN 的状态中,确实存在核心假设失效的比例
Mode regret 同状态最优模式效用减去 Gate 所选模式效用
Success cost 每次成功的 thinking tokens、工具次数、执行时延和计算成本

其中:ModeRegret(s)=max⁡mU(s,m)−U(s,m^)\text{ModeRegret}(s) = \max_m U(s,m) - U(s,\hat m)

ModeRegret 是判断 auto-thinking 是否真的学会的核心指标。仅看线上 THINK 占比没有意义:10% 可能过多,也可能远远不够。

1.3 建议的离线验收目标

Pass@1:相对基线显著提升
First-repair success:相对基线提升幅度高于最终成功率提升
Semantic repeat rate:下降 30% 以上
Unnecessary-thinking rate:控制在 10%~15% 以内
Thinking-necessity recall:达到 85%~90%
Replan precision:达到 70%~80%
成功轨迹的工具调用 P50:不高于基线

真正上线前,应按 query 类型、表规模、修改对象、错误类型分别报表,避免整体均值掩盖局部模式塌缩。


2. 为什么"短思考链 + RL"通常优于"直接代码 + RL"

2.1 直接代码 RL 的学习信号过于稀疏

不带显式 thinking 时,策略近似为 πθ(a∣s)\pi_\theta(a \mid s)。s 是用户需求、当前多维表格状态、代码和工具反馈,a 是一整段代码或工具动作。若只有终局 Reward:

J(θ)=Ea∼πθ(⋅∣s)[R(s,a)]J(\theta)=\mathbb{E}_{a\sim\pi_\theta(\cdot|s)}[R(s,a)]

一次失败会把相似的负 advantage 分配给长代码中的大量 token,但 Reward 并不明确告诉模型:是理解错了用户需求、是表结构设计错了、是字段 ID 或类型用错了、是公式依赖关系不对、是工具反馈与当前修改无关,还是仅仅漏了一次必要验证。

模型仍然可能通过直接 RL 提升能力,因此"无 thinking 的 RL 只是对齐"并不完全准确;但在动作空间很大、终局反馈稀疏、多轮状态不断变化的 CodeAgent 中,它更容易学到局部输出偏好,而不是可迁移的错误归因和恢复策略。

2.2 短 thinking 把大动作分解成可学习的中间变量

引入模式 m、短决策变量z 和动作a:

πθ(m,z,a∣s)=πg(m∣s) πz(z∣s,m) πa(a∣s,m,z)\pi_\theta(m,z,a\mid s) =\pi_g(m\mid s)\, \pi_z(z\mid s,m)\, \pi_a(a\mid s,m,z)

其中:m:DIRECT、THINK_SHORT 或 REPLAN;z:一段短自然语言决策说明;a:实际代码修改或工具调用。

边缘化后仍然能表达直接策略:π(a∣s)=∑m,zπg(m∣s)πz(z∣s,m)πa(a∣s,m,z)\pi(a\mid s)=\sum_{m,z}\pi_g(m\mid s)\pi_z(z\mid s,m)\pi_a(a\mid s,m,z)

虽然 z 的表面形式是自然语言,它仍可以承载稳定的决策语义,并带来三个额外价值。

第一,很多表面不同的错误可以映射到同一可迁移类别。例如字段不存在、公式引用旧字段名、自动化 action 引用了被替换字段,都可能归结为同一类 schema_reference / last_diff / repair_reference。这相当于在高维代码空间中增加了一个低维的故障与决策表示,降低学习难度。

第二,z 提供了可验证的 RL 支撑点。即使没有固定字段,仍可通过语义评估判断:attribution 是否与 baseline、rollback 或 diff 证据一致;decision 是否与实际 action 一致;expect 是否被下一次 observation 证实;预测被证伪后是否重新归因。

第三,z 改善多轮 credit assignment。ReAct 本质上是 MDP;如果把整条轨迹视为一个 bandit 输出,最终成功或失败很难归因到具体 turn。

2.3 从数据密度看:一条轨迹不再只有一个终局标签

直接 RL 的一条失败轨迹通常只有 terminal_success = 0。带短 thinking 后,可以在离线侧得到一组相对可靠的过程标签:

error_type_correct
attribution_correct
decision_action_consistent
expected_observation_match
state_progress
terminal_success

这不意味着可以随意制造 dense reward;错误的过程奖励会引导 reward hacking。但当这些标签能被真实状态、真实工具结果或因果回放验证时,它们能显著增加有效训练信号。

这里应明确区分两层:

模型可见输出:自然语言 <thinking>,不出现固定字段名
离线标注与 Reward:可保留 error_type、attribution、decision、expected_effect 等结构化 metadata

2.4 类比:终验、工单与资深工程师

直接代码 RL:施工队只在整栋房子完工后收到"合格/不合格",能改进,但很难知道是图纸、材料还是施工顺序出了问题
固定长思考 RL:每拧一颗螺丝都写一份长报告,信息冗余、成本高,还可能事后编故事
Auto-thinking RL:简单工作直接做;遇到异常时填一张短工单:故障、归属、证据、动作、预期;发现图纸本身错了才重新出图

短 thinking 的价值不是"写得更多",而是给 RL 一个能够发力的决策接口。Auto-thinking 则让这个接口只在边际收益为正时出现。

2.5 必须保留的边界:thinking 不是天然可信

显式思考可能是事后合理化,也可能与真实决策因果无关。因此不能仅奖励"thinking 看起来合理"。必须同时检查 observation → evidence/attribution → decision → action → next observation,并做置空、置换和 decision 干预实验。若删除或改变 thinking 后 action 基本不变,说明该 thinking 很可能只是装饰。


3. 最终 Auto-Thinking 架构

3.1 Gate 必须逐 turn 决策

Auto-thinking 不是在任务开始时只决定一次"整条轨迹是否思考",而是在每个 ReAct turn 根据新状态重新选择。

推荐用三个显式 reasoning-mode token 作为 Gate 输出:

<|mode_direct|>
<|mode_think_short|>
<|mode_replan|>

更准确的名字是 reasoning-mode token。它是模型内部的一 token 元推理决策,不是 tool call,也不是让 serving 启动不同外部工作流的控制命令。整个过程仍是一次连续的自回归生成:

当前状态 s_t
→ 模型生成 mode token m_t
→ m_t 保留在模型上下文和 KV cache 中
→ 模型继续生成自然语言 thinking、action 或 tool call

例如:

<|mode_direct|>
<tool_call>...</tool_call>

<|mode_think_short|>
<thinking>自然语言短判断</thinking>
<tool_call>...</tool_call>

<|mode_replan|>
<thinking>自然语言重规划</thinking>
<tool_call>...</tool_call>

Serving 只需缓存并剥离第一个 mode token,不把它返回给用户;该 token 仍然参与后续生成的条件上下文。THINK_SHORT 和 REPLAN 的内容可由 reasoning parser 放入 reasoning.content,工具调用和最终答复仍进入正常通道。

Gate token 是否必需

Auto-thinking 没有显式 Gate token 也能工作。模型可以直接学习:第一个输出是 tool call → 隐式 DIRECT;第一个输出是 <thinking> → 隐式 THINK。此时策略是 π(y|s),输出的第一个普通 token 隐式承担 Gate。

加入显式 mode token 后,策略更容易分解为 π(m,y∣s)=πg(m∣s)π(y∣s,m)\pi(m,y\mid s)=\pi_g(m\mid s)\pi(y\mid s,m)。它不会凭空增加推理能力,但会把"是否思考、采用何种深度"和"具体思考内容"分开,从而带来:

  • 可单独提取 DIRECT、THINK_SHORT、REPLAN 的概率和 logprob
  • 可对 mode token 单独设置 SFT loss、RL advantage、KL 和熵约束
  • 可直接统计模式分布、mode regret 和模式塌缩
  • 可对同一状态强制不同模式做反事实评测
  • THINK_SHORT 与 REPLAN 不依赖事后分析自然语言才能区分
  • thinking 内容仍可保持自然、灵活,不受 mode token 格式限制

推理成本与可见性

显式 Gate 通常每个 ReAct turn 只增加一个 token 和一次 decode step。相对于 64~128 tokens 的 THINK_SHORT、工具执行、编译和 Judge 检查,这个成本通常很小,但不能视为严格为零。

Gate token 是"模型产生、模型继续消费、系统隐藏"的内部 token:用户和正常 API content 不应看到它;训练 trace、RL rollout 和可观测日志应保留它;流式输出应先缓冲首 token,解析完成后再向客户端发送;DIRECT 通常不返回空的 reasoning.content。

建议增加一个确定性的 runtime availability mask:

全新任务首 turn:通常只开放 DIRECT / THINK_SHORT
已有历史方案或失败 observation:开放 DIRECT / THINK_SHORT / REPLAN
纯环境 timeout、权限不足或依赖不可用:通常屏蔽 REPLAN,避免把环境问题误判成方案问题

这不是外部链路路由,也不是代替 Gate,而是只在首 token 位置把明显不合法的模式 logit 屏蔽。

3.2 三种模式的精确定义

DIRECT

适用条件:需求清晰且是熟悉、局部、低风险的操作;工具反馈唯一对应一个机械修复;已有充分证据,不需要新增假设;验证通过后应直接停止;环境错误有确定的重试或切换 scoped check 动作;思考不会改变下一动作。

DIRECT 不等于不看上下文,也不等于不验证。它只是"不生成显式 thinking token"。

THINK_SHORT

适用条件:工具反馈需要区分 last_diff / baseline / environment / unknown;有两个以上局部候选解释,但原方案仍基本成立;Judge 指出产物不符合需求,需要定位遗漏的验收条件;第一次相关失败出现,需要在继续修复、回滚、重试或停止中选择;一段短归因能够显著降低下一动作出错概率。

不推荐固定字段或固定句式。THINK_SHORT 通常用 1~3 句自然语言说明:当前反馈最可能说明什么,必要时指出它来自当前修改、baseline 还是环境;为什么选择下一动作,而不是其他明显候选;如果有助于验证,说明下一次检查应看到什么变化。

低价值反例是只有空泛结论,例如"检查失败了,我需要修复并验证",因为它没有使用当前反馈,也不能约束下一动作。

REPLAN

适用条件:observation 证伪了当前方案的核心假设;连续修复没有带来状态进展,且原因不是环境噪声;原数据模型无法满足联表、汇总、公式或自动化约束;需要跨表、字段、视图和自动化重新安排依赖顺序;当前 diff 不断扩张,继续局部补丁的预期成本高于回滚重做;用户意图被根本误解。

REPLAN 同样使用自然语言,不输出字段清单。它通常用一个短段落说明:哪条核心假设已经站不住、哪些现有成果仍应保留、方案应如何改变,以及先验证哪一步。

REPLAN 不是"更长的 THINK_SHORT",而是方案边界发生变化。默认每条训练轨迹最多一次 REPLAN;再次 REPLAN 通常说明任务、工具环境或数据质量需要人工审查。

3.3 THINK_SHORT 与 REPLAN 的核心区别

最实用的判断问题:在不改变对用户目标、数据模型和主要实现路径的理解时,能否通过一个局部动作取得可验证进展?

能,而且下一动作已经唯一明确 → DIRECT
能,但需要先消除局部歧义、判断错误归因或选择修复动作 → THINK_SHORT
不能;反馈已经推翻核心假设,继续局部修改不会解决根因 → REPLAN
维度 THINK_SHORT REPLAN
核心方案 仍然成立 已被证伪或已明显不经济
主要问题 局部诊断、归因或动作选择不确定 用户目标、数据模型、依赖关系或实现路径存在根本错误
改动范围 通常是一个局部对象或相邻依赖 通常跨多个对象、阶段或依赖关系
对已有修改的态度 大部分保留,只修正局部问题 明确保留可信部分,并回滚或替换失效部分
thinking 的任务 解释"为什么下一步这样修" 解释"为什么原路走不通,以及新路径是什么"
下一步动作 一个高置信度 repair、retry、verify 或 rollback 新计划中的第一个可验证里程碑
典型 token 预算 64~128,硬上限 160 128~192,硬上限 256
使用频率 少量但可重复出现 稀有,普通轨迹通常最多一次

不要用以下表面信号直接触发 REPLAN:日志很长;错误数量很多;已经失败过一次;THINK_SHORT 接近 160 tokens;任务本身看起来复杂。

两个典型边界:

"高风险客户"视图当前使用 >=0,且漏了风险等级 → 数据模型和目标都成立,只需修筛选条件:THINK_SHORT
用客户名文本模拟订单到客户的一对多关系,导致无法可靠汇总 → 核心数据模型不成立,需要建立真实关联:REPLAN

训练和评测时,不应把"第 N 次失败"写成 REPLAN 的硬规则。更可靠的触发条件是:新的 observation 是否证伪了当前核心假设 + 局部修复是否无法产生与目标相关的状态进展 + 新方案的预期收益是否明显高于继续打补丁。

3.4 状态输入要先去噪

Gate 不应直接吞入无限增长的原始日志。建议在每个 turn 构造短状态摘要:

{
  "user_goal": "...",
  "acceptance_criteria": ["..."],
  "current_artifact": "...",
  "last_diff_summary": "...",
  "last_action": "...",
  "observation_digest": {
    "kind": "compile_error",
    "primary_error": "...",
    "location": "...",
    "baseline_present": false
  },
  "trusted_facts": ["..."],
  "failed_hypotheses": ["..."],
  "progress_since_last_turn": true
}

原始工具日志仍可供 action 分支按需读取,但 Gate 和 short-thinking 优先使用结构化 digest,避免被级联错误、无关 warning 和长日志带偏。

3.5 <thinking> 与reasoning.content

<thinking> 只是训练和生成 token,不会因为名字叫 thinking 就自动进入 API 的reasoning.content。需要同时满足:训练与推理使用一致的 chat template 和特殊 token;Serving 配置匹配的 reasoning parser;parser 能分别抽取 THINK_SHORT、REPLAN、tool call 和最终 content;截断、流式输出和未闭合标签有明确处理策略。

如果基座和 serving 已原生支持 <think>...</think>,优先沿用其格式;若使用自定义<thinking>,必须实现对应 parser。Loss mask 决定"哪些生成 token 训练",parser 决定"推理输出被路由到哪个 API 字段",两者是不同层的问题。


4. 已有 5,000 条 DIRECT 后的增量 SFT 构成

4.1 默认配比

以下配额假设已有 5,000 条 DIRECT 可用于训练。若它们包含验证和测试数据,应按语义簇做 80/10/10 切分,并同步缩放新增数据;最终测试集不得由同一 query 模板、同一 Base 快照或同一用户任务的改写版本泄漏进入训练集。

DIRECT:已有 5,000 条

不需要为了满足新比例删除已有 DIRECT。需要审计的是它们是否过度集中在"首次生成直接成功"。建议确保其中至少 300~500 条是 post-feedback DIRECT:

子类 建议覆盖 说明
直接机械修复 200~300 字段名、参数、唯一类型错误等,反馈后仍不输出 thinking
直接验证、重试或停止 100~200 确定性 scoped retry、验证成功后 done、环境问题不改代码

这部分非常重要。否则模型容易学成:没有 error → DIRECT;一旦出现 error/check → THINK_SHORT。正确策略应是判断显式 thinking 是否会改变下一动作。DIRECT 占绝对多数,是为了明确告诉模型:最理想的行为仍是首次做对,而不是先制造错误再展示恢复能力。

THINK_SHORT:新增 600~800 条,默认 700 条

子类 数量 说明
编译、类型、API 与 schema 归因 220 区分 last diff、baseline 和环境问题
Judge/Check 功能错误修复 280 需求遗漏、公式、视图、自动化和关联关系错误
初始高风险决策 80 多约束状态下,一段短决策能明显提高 Pass@1
噪声、不反应与正确停止 120 学会不被无关错误带偏

约 80%~90% 的 THINK_SHORT 应放在真实反馈后的恢复状态,仅保留少量初始高风险状态。它在 SFT 阶段的目标是让模型学会短 thinking 协议和基本恢复能力,而不是把"先 thinking"训练成默认策略。

REPLAN:新增 100~200 条,默认 150 条

子类 数量 说明
数据模型或依赖关系重构 70 文本字段应改为关联字段,汇总/公式依赖需重建
用户意图或验收条件误解 35 产物形式完成但业务目标不成立
多次局部修复无进展 30 证据支持停止打补丁并回滚
修改范围失控或回归 15 需要缩小范围、恢复稳定基线

REPLAN 数据应少而精,只需保证强制进入该模式时模型具有非零、稳定的方案级恢复能力。高比例 REPLAN 会让模型把"写计划"误学成解决问题本身。

默认原始轨迹总量:

类型 数量 总体占比
DIRECT 5,000 85.5%
THINK_SHORT 700 12.0%
REPLAN 150 2.6%
合计 5,850 100%

如果基座已经具备较好的 reasoning 和工具能力,可以从 5,000 + 500 + 100 的更小冷启动开始;如果强制模式评测未达到最低能力门槛,再补数据,而不是预先堆高 THINK_SHORT/REPLAN 比例。

4.2 训练单位不要混淆

建议把"一条轨迹"和"一个 assistant target turn"分开统计:

trajectory_count:用于控制场景与模式覆盖
target_turn_count:用于计算实际训练曝光
token_count:用于防止长 thinking 获得过量梯度

多轮 REPLAN 轨迹天然包含更多 assistant token。如果直接做全局 token mean,即使原始轨迹只占约 2%~4%,也可能获得远高于其样本比例的梯度。建议先在每个 assistant turn 内做 token mean,再按 turn 权重聚合:

LSFT=mean⁡t[wt mean⁡i∈t(Mi CEi)]L_{\text{SFT}} =\operatorname{mean}_{t} \left[ w_t\, \operatorname{mean}_{i\in t} \bigl(M_i\,\mathrm{CE}_i\bigr) \right]

4.3 数据切分与线上分布

至少按以下 key 做 group split:用户 query 的语义簇、Base/schema 快照 hash、需求模板、字段和视图拓扑、同一失败状态的不同 teacher 改写。避免同一个任务的 DIRECT、THINK_SHORT 和 REPLAN 三个版本分别进入训练、验证和测试。

SFT 原始比例不必机械等于线上错误分布。建议:DIRECT 保持较高先验,服务 Pass@1;THINK_SHORT 按线上高频且可恢复错误上采样;REPLAN 覆盖高损失长尾,但不按 token 数过度曝光;对非常容易和完全不可解的样本降采样;对"基模有时成功、有时失败"的边界样本重点保留,因为它们对 Gate 最有信息量。


5. SFT 轨迹如何判断 DIRECT、THINK_SHORT 与 REPLAN

5.1 最可靠的方法:同一状态的反事实模式比较

不要仅靠"任务看起来难"打标签。先根据 runtime availability mask 得到状态 s 的合法模式集合M(s),再从同一个精确快照强制运行每个合法模式:

restore(s) → force DIRECT      → 执行并评分
restore(s) → force THINK_SHORT → 执行并评分
restore(s) → force REPLAN      → 仅在已有方案被反馈挑战时执行并评分

全新任务通常只比较 DIRECT 与 THINK_SHORT;出现真实失败反馈、接手已有失败方案或核心假设可能失效时才开放 REPLAN。每个合法模式最好采样 2~4 次,以减少温度和工具波动造成的偶然性。按真实环境结果计算效用U(s,m)。

标签规则:

  1. DIRECT 成功,且与最优模式效用差不超过 δ → label = DIRECT
  2. THINK_SHORT 相比 DIRECT 显著提升正确性或一次修复率,且原方案不需要重做 → label = THINK_SHORT
  3. 核心假设已被证伪,REPLAN 的真实结果最好 → label = REPLAN
  4. 所有合法模式全部失败,或结果差异落在噪声范围内 → Gate loss mask = 0,样本可用于分支能力训练或后续 RL,不强行教 Gate

"显著提升"应先比较正确性,再比较成本。不要把 δ 只定义成 token 数;推荐用分层效用或 bootstrap 置信区间。

5.2 低成本启发式预标注

状态 推荐模式
单一明确的字段名、参数或类型修复 DIRECT
已验证成功,应停止 DIRECT
确定性的 scoped retry,不涉及代码改动 DIRECT
第一次相关错误,需要判断是否来自 last diff THINK_SHORT
Judge 指出一个需求未满足,但整体方案成立 THINK_SHORT
两个局部候选都合理,需要证据选择 THINK_SHORT
中心数据模型被证伪 REPLAN
相同假设连续失败且状态无进展 REPLAN
修改范围持续扩大并引入回归 REPLAN
环境 timeout、权限或依赖不可用 DIRECT retry/stop;不是 REPLAN

5.3 轨迹示例一:首次 DIRECT

用户需求:在"订单"表新增"是否逾期"公式字段:状态不是"已完成"且截止日期早于今天时返回 true。

可见 schema 已明确给出字段 ID 和类型,生成动作唯一:

assistant:
<|mode_direct|>
<tool_call>
create_formula_field(
  table="订单",
  name="是否逾期",
  formula="AND({状态}!=\"已完成\", {截止日期}<TODAY())"
)
</tool_call>

这里添加 thinking 只会复述需求,不会改变动作。

5.4 轨迹示例二:修复仍然 DIRECT

工具反馈:

compile_error:
unknown field "customer_name"
available field: "customer"
location: build_order_view.ts:42

当前 diff 只把字段引用误写为 customer_name,没有其他候选解释:

assistant:
<|mode_direct|>
<tool_call>
replace_field_reference(
  file="build_order_view.ts",
  from="customer_name",
  to="customer"
)
</tool_call>

这是 recovery,但不需要显式 thinking。把所有 repair 都标成 THINK_SHORT 会训练出"遇错必思考"的坏先验。

5.5 轨迹示例三:THINK_SHORT 一次修复

工具反馈:

artifact_check_failed:
"高风险客户"视图包含了已结清客户。
当前过滤条件使用"剩余金额 >= 0"。
验收要求:剩余金额 > 0 且风险等级为"高"。

训练 target:

assistant:
<|mode_think_short|>
<thinking>
问题出在刚修改的筛选条件:`>= 0` 会把剩余金额为 0 的已结清客户也选进来,而且遗漏了风险等级约束。把条件改为"剩余金额大于 0 且风险等级为高"后重新检查,已结清客户应该从这个视图中消失。
</thinking>
<tool_call>
update_view_filter(
  view="高风险客户",
  condition="AND({剩余金额}>0, {风险等级}=\"高\")"
)
</tool_call>

下一次真实 Check 既验证代码,也验证 thinking 中对结果的预期。如果已结清客户仍存在,下一 turn 必须更新判断,不能原样重复这个 thinking。

5.6 轨迹示例四:噪声反馈下 THINK_SHORT

工具反馈:

dependency_timeout:
formula-engine unavailable before source compilation

训练 target:

assistant:
<|mode_think_short|>
<thinking>
这次失败发生在进入源码编译之前,日志也没有指向当前改动,更像是公式引擎超时。先对目标检查做一次 scoped retry;如果仍返回同一基础设施错误,就停止改代码并上报环境问题。
</thinking>
<tool_call>
run_scoped_check(target="formula-field", retry=1)
</tool_call>

如果环境错误的识别完全确定,也可以将这类样本标成 DIRECT retry。只有在归因确实存在歧义时才使用 THINK_SHORT。

5.7 轨迹示例五:REPLAN

用户要求:按客户汇总所有订单金额,并在客户表展示订单数和总金额。

原方案把客户名复制成普通文本字段,然后尝试在客户表直接做公式汇总。Judge 反馈:

artifact_check_failed:
客户表无法稳定关联同名客户的多条订单;
当前结构不支持跨表汇总与去重。

训练 target:

assistant:
<|mode_replan|>
<thinking>
当前方案把客户名当成普通文本键,无法稳定表达订单到客户的一对多关系,同名客户也会破坏汇总结果,因此继续修改文本公式解决不了根因。保留订单表、客户表和原始数据,撤销未生效的文本汇总,先建立订单到客户的关联并验证一条记录,再在客户表上创建订单数和金额汇总。
</thinking>
<tool_call>
create_relation_field(
  from_table="订单",
  to_table="客户",
  name="所属客户"
)
</tool_call>

这里继续修改文本公式属于局部打补丁,无法修复数据模型根因,因此 REPLAN 合理。


6. Recovery SFT 与 Loss Mask

6.1 Recovery suffix 从"正确恢复判断"开始

推荐 mask:

基模生成的错误代码或错误 tool call       mask=0
真实编译、执行或 Judge observation      mask=0
错误类别和因果归因                     mask=1
repair / rollback / retry / replan 决策 mask=1
修复代码或工具动作                     mask=1
必要验证                               mask=1
验证后的 stop/done                     mask=1

也就是说,recovery suffix 不只是"重写代码的 assistant 权重不为 0",而是从失败反馈后的第一个正确恢复判断开始。否则模型只能学到"看到某个报错就改代码",学不到:是否应对这个报错负责;报错是不是 baseline 已存在;应修复、回滚、重试还是停止;修复后应验证什么;什么时候不应继续 ReAct。

6.2 错误前缀为什么要保留

错误 action 和真实 observation 仍应放在输入上下文中,因为恢复策略需要看到模型是如何走到失败状态的。但它们不能作为 imitation target。

需要注意:mask=0 = 不模仿,mask=0 ≠ 负监督。若要压制重复动作、盲改、过度扩大范围或提前结束,应为相同状态构造 chosen/rejected:

chosen: 检查 baseline,确认错误与当前 diff 无关,然后运行目标 scoped check
rejected: 根据无关日志继续修改另一个模块

可使用 DPO、ranking loss、unlikelihood 或在线 RL。chosen 和 rejected 必须来自同一精确状态,不能拿两个难度不同的任务直接比较。

6.3 推荐 SFT loss

LSFT=λgLgate+λzLthinking+λaLaction+λpLpreferenceL_{\text{SFT}} = \lambda_g L_{\text{gate}} + \lambda_z L_{\text{thinking}} + \lambda_a L_{\text{action}} + \lambda_p L_{\text{preference}}

第一版建议:

action/tool token:1.0
自然语言 thinking span:0.4~0.7,按 span 或 turn 归一
可选的离线语义辅助 loss:0.1~0.3
正确验证和 done:1.0~1.3
错误 action、tool observation、冗余 thinking:0

自然语言 thinking 不再按 type/evidence/decision/expect 等字段切分 token 权重,也不使用字段是否出现作为监督目标。离线 metadata 可以训练低权重的错误归因或动作分类辅助任务,但这些标签不进入可见 thinking。应使用 span-normalized 或 turn-normalized loss,避免较长的自然语言说明获得比工具 action 更大的总梯度。


7. SFT 训练顺序:冷启动能力,不替代 RL

7.1 阶段 S1:模式分支能力冷启动

目的:保留已有 DIRECT 主能力,并确保 THINK_SHORT、REPLAN 被强制选择时都"会做事"。

做法:

  • 使用已有 5,000 条 DIRECT,并混入新增的 600~800 条 THINK_SHORT、100~200 条 REPLAN
  • 如果 5,000 条 DIRECT 已经训练进当前 checkpoint,不必从头完整重训;在增量 SFT 中按场景分层回放 DIRECT,维持下面的有效 batch 占比即可
  • 原始默认比例约为 85.5/12.0/2.6,有效 batch 可从 82/15/3 起步
  • 模式 token 由数据强制注入,gate token mask=0
  • 训练 DIRECT action、THINK_SHORT 的短思考与 action、REPLAN 与 action
  • recovery 样本使用前述 suffix mask
  • 使用 turn-normalized loss
  • 以 DIRECT Pass@1 无回退、强制模式能力和格式正确率早停

有效 batch 中可对少量 THINK_SHORT/REPLAN 做适度上采样,但不要改变 DIRECT 的强先验:

DIRECT       80%~85%,默认 82%
THINK_SHORT  12%~17%,默认 15%
REPLAN        2%~3%,默认 3%

这一步不让 Gate 自己选,是为了避免模型在 THINK/REPLAN 分支尚不会做时,Gate 因短期 Reward 永远逃回 DIRECT。它的完成条件不是固定 epoch,而是:

强制 THINK_SHORT:格式与 tool call 稳定;decision 与 action 一致;在 Think-necessary 集合上优于 forced DIRECT
强制 REPLAN:能指出失效假设;新 action 确实改变方案;在 Replan-necessary 集合上优于局部修复

达到门槛后,应转入 RL,而不是继续堆大量 thinking SFT。

7.2 阶段 S2:轻量 Gate warm-start

目的:只让 Gate 具备最小探索能力,避免 RL 初期 THINK_SHORT/REPLAN 触发概率接近零;不追求通过 SFT 学到最终决策边界。

数据:

  • 优先使用同状态、合法模式强制 rollout 的真实比较结果
  • 只需 300~500 个高信息状态,可从已有轨迹派生
  • 标签分布建议约为 65% DIRECT / 30% THINK_SHORT / 5% REPLAN
  • 加入 Direct-sufficient 与 Think-necessary 的边界状态,而不是只挑复杂任务
  • 不确定样本的 Gate loss 设为 0

训练:

只训练 mode token,后续 thinking/action loss=0
Gate loss 相对 S1 action loss:0.2~0.5
学习率:S1 的约 0.2~0.3 倍
短程训练;能保持模式探索且 mode-regret 不恶化即停止

这里的 65/30/5 只是 Gate 冷启动标签分布,不是线上目标分布。最终模式比例和动态决策边界由 RL 的真实执行结果决定。

7.3 阶段 S3:可选的联合小步 SFT

目的:让 Gate 输出、thinking 和 action 在自然生成条件下重新对齐。

做法:

  • 不再强制 mode token
  • 保持至少 80%~85% 的高质量 DIRECT 曝光
  • 使用 S1 约 0.2~0.3 倍学习率
  • update budget 不超过本轮 SFT 的约 10%,并严格早停
  • 监控 Gate 模式分布,防止突然偏向单一模式

如果 S2 后自然生成已经稳定,S3 可以跳过。SFT 到此只需提供可工作的三分支与最小 Gate 探索,不应继续拟合一个静态的"正确模式分类器"。

7.4 Gate warm-start 的关键不是标签数量,而是边界信息量

以下样本对 Gate 几乎没有帮助:

非常简单,所有合法模式都成功
非常困难,所有合法模式都失败
teacher 永远先想再做,缺少 DIRECT 对照
仅凭错误日志长度把样本标成 THINK

最有价值的是:

DIRECT 有时失败、THINK_SHORT 常能一次修好
THINK_SHORT 与 DIRECT 都成功,但 DIRECT 明显更便宜
THINK_SHORT 连续局部修复失败,而 REPLAN 能恢复
工具日志很长但其实是确定性环境错误,应 DIRECT

这些边界状态在 SFT 中只做轻量 warm-start;当前 checkpoint 上真正的模式效用比较,应留给在线 RL。

7.5 为什么 Auto-thinking 的关键必须放在 RL

Gate SFT 优化的是 Lgate-SFT=−log⁡πg(mteacher∣s)L_{\text{gate-SFT}} =-\log \pi_g(m_{\text{teacher}}\mid s)。它回答的是"teacher 在这个静态状态上标了什么模式"。即使标签来自真实执行,它仍然存在三个局限:

  1. 标签依赖生成它时的 checkpoint;模型变强后,原本需要 THINK_SHORT 的状态可能已经能 DIRECT。
  2. 单个模式标签不能持续表达正确性、工具成本、thinking 成本和时延之间的 Pareto 关系。
  3. teacher 容易把自己的思考习惯固化成 Gate 规则,例如"见 error 必 THINK"或"复杂需求必 REPLAN"。

RL 优化的是当前策略在真实环境中的效用:

Jgate-RL=Em∼πg(⋅∣s)[Rcorrect(s,m)−C(s,m)]J_{\text{gate-RL}} =\mathbb{E}_{m\sim\pi_g(\cdot|s)} \left[ R_{\text{correct}}(s,m)-C(s,m) \right]

通过同一状态下 forced DIRECT、forced THINK_SHORT、forced REPLAN 与 AUTO 的真实比较,RL 能直接回答"对于当前 checkpoint,哪个模式实际更好"。因此:

SFT:保证每个模式有非零能力和非零探索概率
RL:学习当前模型真正的模式决策边界

但不能完全跳过冷启动。如果 THINK_SHORT/REPLAN 分支从未被训练,强制 rollout 几乎总失败,RL 会把"分支能力不足"误认为"这个模式不该选",最终仍塌缩到 DIRECT。

7.6 Gate 训练的真正意义

Gate 训练不是让模型记住一个固定模式比例,也不是让它机械复现 teacher 的选择。它要学的是:对当前 checkpoint 和当前状态,哪种推理模式能以最低总代价获得正确结果?

具体包含三个目标:

目标 含义
Exploration support 三种合法模式具有非零概率,RL 能实际探索其结果
Decision boundary 识别 DIRECT 足够、THINK_SHORT 有增益、REPLAN 才能解决根因的状态边界
Cost calibration 正确性相同时偏向更便宜模式,思考有明显收益时允许支付额外成本

Gate 的训练信号应按阶段分开。

分支能力 SFT

mode token:由数据强制注入,loss mask=0
后续 thinking/action:loss mask=1

这一步训练的是条件策略 π(y|s,m):已知模式时,模型能否正确生成对应行为。虽然 mode token 本身不计算输出 CE,它仍作为后续 token 的上下文,通过后缀 loss 学到区分三种分支的 embedding。

Gate warm-start

mode token:loss mask=1
后续 thinking/action:loss mask=0

这一步训练 π_g(m|s) 的最小初始边界,使 THINK_SHORT 和 REPLAN 不会在 RL 开始时概率接近零。它只负责冷启动,不承担最终 Auto-thinking 学习。

Gate RL

AUTO rollout 中,mode token 由当前策略真实采样,可以直接接受 mode-level advantage:

Lgate-RL=−Ag(s,m)log⁡πg(m∣s)L_{\text{gate-RL}} =-A_g(s,m)\log\pi_g(m\mid s)

A_g 应来自同状态下不同模式的相对正确性和成本,而不是模式名称本身:

DIRECT 与 THINK_SHORT 都成功 → 正确性相同后,较便宜的 DIRECT advantage 更高
DIRECT 失败,THINK_SHORT 一次修好 → THINK_SHORT advantage 更高
局部修复均无进展,REPLAN 成功 → REPLAN advantage 更高

Forced-mode rollout 的 on-policy 边界

人为注入 <|mode_think_short|> 或<|mode_replan|> 时,这个 mode token 不是从当前π_g 自然采样得到的,因此不能不加处理地作为普通 on-policy GRPO 样本更新 Gate。

推荐分工:

AUTO rollout:mode 来自当前 policy → 直接更新 Gate、thinking 和 action
forced-mode rollout:mode 由训练系统指定 → 估计模式反事实效用、训练给定模式后的条件分支、构造 Gate 的 CE/DPO/preference 辅助信号、默认不直接计算普通 on-policy Gate gradient

如果训练框架能记录行为策略概率并正确做 importance correction,也可以让 forced rollout 参与 Gate policy gradient;第一版不建议为了这一点增加过多算法复杂度。

Gate 是否训练成功

不要用"线上 THINK 占比接近某个目标值"判断。应看:mode regret 是否下降;Think-necessary 状态的召回率是否提高;Direct-sufficient 状态的不必要 thinking 是否下降;Replan precision 是否提高;Pass@1 与 First-repair success 是否同时改善;在相同成功率下,thinking tokens、工具调用和时延是否下降;Gate entropy 是否保持在可探索但不随机的合理区间。

因此,Gate token 的价值可以概括为:几乎不增加序列长度,却为 Auto-thinking 提供了一个可以单独监督、单独强化、单独干预和单独评测的元推理支点。


8. 如何使用更强的高阶模型构建轨迹

8.1 最合理的分工

推荐公式:

基模 / 当前 checkpoint:产生真实状态分布
高阶模型:定位偏离、生成候选、压缩 thinking、构造反事实
真实环境:执行、验证和判真

高阶模型适合担任:

  1. 轨迹编辑器:标记 keep / mask / replace / truncate
  2. 首次偏离定位器:找出错误开始传播的 turn
  3. 恢复专家:从基模真实失败状态生成最小 recovery
  4. thinking 压缩器:将长推理改写为预算内、语义有效的自然语言短段落
  5. 反事实候选生成器:为同一状态生成 DIRECT、THINK_SHORT、REPLAN
  6. Rubric 生成器:将用户 query 转换为可执行的验收 checklist
  7. Judge 审核器:发现 JudgeRewardModel 未覆盖的失败模式

它不应:独立生成绝大多数完整轨迹;虚构工具 observation;同时成为唯一生成者和唯一裁判;把 gold 代码、隐藏测试或不可见信息写入学生 thinking;将自己的长 CoT 原样蒸馏给小模型。

8.2 双教师视角

Privileged Critic

可以看到参考产物、隐藏 Check、正确修改范围,用于:

{
  "first_bad_turn": 3,
  "invalidated_assumption": "客户名文本可作为稳定关联键",
  "required_milestones": [
    "建立订单到客户的关联",
    "基于关联创建汇总"
  ],
  "leakage_risk": false
}

这些信息只用于筛选、打标签和比较,不直接进入学生可见 target。

Blinded Actor

只能看到线上推理时可见的信息:用户 query、当前 Base/schema 与数据摘要、当前代码和 diff、已经真实返回的工具 observation。真正进入 SFT target 的 short-thinking、replan 和 action 由 Blinded Actor 生成,并在真实环境重放。

8.3 可落地的数据生产流水线

  1. 对每个任务用基模或当前 checkpoint 采样 4~8 条 rollout。
  2. 保存每个 assistant turn 前的可恢复环境快照与状态 fingerprint。
  3. 用高阶模型定位首次关键偏离、错误归因、重复动作和错误停止。
  4. 对高价值状态的每个合法模式生成 2~4 个候选。
  5. 从同一快照真实重放;所有 observation 必须来自工具。
  6. 按正确性、无回归、进展和成本选最短有效路径。
  7. 将 teacher 长 reasoning 压成 THINK_SHORT 或 REPLAN 格式。
  8. 产出四类视图:最短 clean-success、错误前缀 mask=0 的 recovery suffix、同状态 mode preference / chosen-rejected、噪声/停止/回滚和反 reward-hacking 样本。
  9. 进行硬过滤:工具格式合法、执行可重放、隐藏 Check 通过、无测试或 verifier 篡改、无数据破坏、无不可见信息泄漏、无状态不变的循环、thinking 未复制整段日志。

8.4 如何保证与学生分布一致

至少执行以下约束:

  • 状态来自基模和当前 checkpoint,而不是只来自高阶模型的干净轨迹
  • teacher 与 student 使用相同工具、相同可见上下文、相同 action schema
  • teacher 输出必须服从 student 的 160/256-token 预算
  • teacher 只生成候选,最终选择由真实环境和独立 verifier 决定
  • 每次模型能力有明显提升后重新收集 rollout,避免训练永远停留在旧失败分布
  • 按线上 error/query bucket 对齐采样,不用 teacher 喜好的题型替代真实流量
  • 保留一部分 student 自己成功的最短轨迹,避免语言风格完全 teacher 化
  • 高阶模型的置信度只能用于排序,不能当作真值

自然语言 thinking 还需要做表达去模板化:不固定句首,不要求每条都按"问题是—所以—预计"展开;同一语义可由不同 teacher 或不同提示生成少量自然改写;只保留与 observation 和 action 一致的版本;不为了语言多样性改变技术判断或加入无依据内容;结构化 error type、归因、decision 和预期结果只保存在离线 metadata。


9. THINK_SHORT 的 token 预算

9.1 推荐默认值

目标长度:64~128 tokens
P90:不超过 128 tokens
硬上限:160 tokens
实验上限:192 tokens,仅用于消融

REPLAN 目标:128~192 tokens
REPLAN 硬上限:256 tokens

"token"必须按实际基座 tokenizer 统计。中文、英文标识符、XML 标签和 JSON 的 tokenization 差异较大,不能用字符数替代。

9.2 160-token 硬上限为什么是合理起点

THINK_SHORT 通常只需要自然地表达以下语义中的必要部分:

基于反馈的诊断与必要证据   约 25~55 tokens
下一动作及选择理由         约 20~40 tokens
必要时的预期结果           约 15~30 tokens
对象名、公式与自然连接语   其余预算

这不是要求每条 thinking 机械包含三段内容,也不规定顺序。64~128 tokens 给模型足够空间完成有证据的自然语言判断,160-token cap 则为较长的中文字段名、公式、错误位置和必要理由留出余量,同时仍能限制:复制完整编译日志;重述全部历史;枚举大量未验证假设;在 action 前写一份新方案;用流畅叙事掩盖归因不确定性。

如果一个状态稳定需要超过 160 tokens 才能决定下一动作,它通常更适合 REPLAN,而不是把 THINK_SHORT 无限制拉长。THINK_SHORT 与 REPLAN 的区分仍应以"原方案是否失效"为主,而不是仅凭长度。

9.3 长度控制方式

不要在 160 tokens 处粗暴截断未闭合的 <thinking>。推荐:训练数据在入库前压缩到预算;为 </thinking> 提供明确 stop token;对超长但正确样本做 teacher 重写,而不是简单裁剪;RL 中仅在正确性相同或进展相同的 rollout 之间比较长度;thinking 未闭合或吞掉 tool call 时施加格式惩罚;独立记录 reasoning_tokens,不要与代码 tokens 混合惩罚。

9.4 必做预算消融

固定相同模型、任务、工具预算和 Reward,比较:DIRECT、THINK_SHORT cap=96、cap=128、cap=160、cap=192、长自由 CoT。按以下二维 Pareto 选择,而不是只看成功率:

First-repair success vs. thinking tokens + 工具调用 + wall time

默认选择 64~128 目标区间和 160 硬上限。若 160 相比 128 只增加输出长度、没有提升 First-repair success,可把生产 soft cap 收紧到 128;若 192 相比 160 有明显收益,应先检查这些样本是否实际属于 REPLAN,再决定是否扩容,避免把 THINK_SHORT 演化成长 CoT。


10. 线上 query 的 RL 数据工程

10.1 Query 入池

线上数据进入 RL 前需要:

  1. 脱敏和权限清洗:删除 token、个人信息、真实业务敏感值
  2. schema-preserving 匿名化:保留字段类型、依赖拓扑和错误结构
  3. 语义去重:相同模板、同一 Base 快照和重写 query 只保留代表样本
  4. 可执行快照:保存初始表结构、必要数据、工具版本与随机种子
  5. 固定验收条件:在 rollout 前生成并冻结 acceptance checklist
  6. 稳定性检查:同一正确产物重复运行 verifier 的结果应一致
  7. 可解性检查:工具权限、依赖和环境必须足以完成任务

Judge 的 rubric 必须在 rollout 前冻结。不能让 policy 在看到自己产物后改写验收标准。

10.2 RL prompt 采样建议

推荐按当前 checkpoint 的 group success rate 动态分桶:

桶 group success rate 样本用途与规模
Easy anchor > 0.9 少量保留,用于稳定 DIRECT 和防遗忘
Learning frontier 0.1~0.9 RL 主体,模式比较与 advantage 最有信息
All-fail < 0.1 送 teacher recovery、课程学习或 SFT,不直接大量 RL
Unstable verifier 波动高 暂停训练,修环境或 verifier

第一版 query mix 可从:

50% 当前模型的 learning-frontier 线上 query
25% 近期线上失败与多轮重复案例
15% 回归、权限、数据完整性和噪声边界案例
10% Easy DIRECT anchor

开始,再按分桶指标调整。

10.3 以"修复预算"约束一次修好

不要简单把整个 Agent 的工具预算设得极低。搭建复杂 Base 本身可能需要多个必要 action。建议单独定义:

initial_build_actions:完成首版产物所需的动作
repair_turns:第一次 Check 失败后的修复轮数

主要 RL 任务可设置:

  • 普通 recovery:最多 1 个 repair turn + 1 次最终验证
  • REPLAN bucket:最多 2 个 recovery action,且最多 1 次 REPLAN
  • 状态无变化的同类失败重复一次:提前终止并处罚

训练和评测都显式报告 First-repair success,才能真正推动"一次修对",而不是靠更长轨迹堆出最终成功率。


11. RL Reward 体系

11.1 Reward 层级

推荐优先使用分层排序:

Tier 0:安全、权限、数据完整性、是否篡改测试/verifier
Tier 1:可执行功能正确与用户验收
Tier 2:无回归、幂等性与无数据破坏
Tier 3:错误归因、有效进展、正确停止
Tier 4:模式、thinking、工具、时延成本

只有 Tier 0~3 相同或足够接近时,Tier 4 才决定优劣。

如果训练框架必须使用标量,可以从以下归一化模板开始:

R=+Rterminal+Rprocess−Rfailure−Rcost−RsafetyR = + R_{\text{terminal}} + R_{\text{process}} - R_{\text{failure}} - R_{\text{cost}} - R_{\text{safety}}

示例尺度:

R_terminal:0~10
  工具调用和产物格式合法          +0.5
  编译/构建通过                   +0.5
  隐藏功能与不变量 Check          +4.0
  Judge 需求满足                  +3.0
  无回归、数据保持和幂等          +2.0

R_process:整条轨迹最多 +2
  验证过的 milestone              +0.2~0.5
  可验证的正确 attribution        +0.2~0.4
  expect 与下一 observation 一致  +0.1~0.3

R_failure
  语义重复                         -0.5~-1.0
  无关范围扩张                     -0.5~-1.0
  未验证提前 done                  -1.0~-2.0
  制造新回归                       -2.0~-5.0

R_cost:整条成功轨迹通常不超过 -1
  额外工具调用、thinking token、wall time

R_safety
  篡改测试/verifier、越权删除、数据破坏  -20 并立即终止

具体数值必须通过 reward attribution 日志和消融校准。硬原则是:

成功 Reward > 所有效率惩罚的最大可能总和
功能正确 Reward > 编译通过和 Judge 文风 Reward
安全硬惩罚 > 所有正 Reward

11.2 现有两类 Reward 如何使用

编译/执行工具

适合作为高可信、低歧义 verifier,但不要只给"编译通过"高分。编译成功只是必要条件;空实现、删除功能或绕过逻辑也可能编译。可拆分为:tool-call schema validity、compile/build、目标功能执行、隐藏输入和边界输入、已有功能回归、重复执行的幂等性。

JudgeRewardModel

适合判断开放式需求是否满足:表、字段和视图的整体结构是否符合用户意图;命名、布局和可用性是否合理;多个约束是否全部满足;最终产物是否"看起来构建正确"。

但 JudgeRM 不应成为唯一真值。建议:Judge Reward 占终局 Reward 的比例不超过可执行 verifier;使用固定 rubric、隐藏 Check 和独立 holdout Judge;对多条件 query 逐条评分;对 Judge 与执行结果分歧的样本进入人工审计池;定期用不同模型家族的 Judge panel 复核;监控训练 Judge 上升但隐藏执行正确率下降的 divergence;周期性刷新 JudgeRM,但测试 Judge 永不参与训练。

11.3 建议新增的多维表格专用 Reward

Schema 图正确性

检查表、字段、视图是否存在;字段类型与默认值是否正确;关联字段的方向和多重性是否正确;lookup / rollup / formula 的依赖图是否合法;是否存在悬空引用和循环依赖。

公式语义 Reward

不仅检查 parse,还应在隐藏样例上计算结果;覆盖空值、时区、边界日期、0 和负数;检查返回类型;验证字段重命名后的引用保持。

View 行为 Reward

检查 filter、sort、group、visible fields 和 records:应出现的记录全部出现;不应出现的记录不出现;排序和分组符合需求;修改未破坏其他已有视图。

Automation 图 Reward

检查 trigger 对象和条件;action 顺序与参数;字段引用;循环触发风险;重复运行幂等;模拟事件后的最终状态。

数据与权限不变量

未要求删除的数据仍存在;无关表、字段、视图未被修改;字段迁移没有静默丢值;权限范围未扩大;敏感字段未写入日志或输出。

最小改动 Reward

仅在功能正确与无回归相同的成功 rollout 之间比较:修改对象数量、diff 范围、新增/删除资源数量、迁移数据量。不要在失败和成功之间用最小 diff 排序,否则模型会学会什么都不改。

11.4 Process Reward

可程序化的高价值过程信号:

baseline 是否存在相同错误
错误位置是否落在当前 diff 或直接依赖
rollback 上一步后错误是否消失
一个关键假设是否被验证或证伪
本 turn 是否改变了环境状态
下一 observation 是否符合 thinking 中自然语言表达的可验证预期
是否在验证成功后停止

这些过程信号应由真实执行、离线 metadata 或语义评估器得到,不要用正则检查 thinking 是否包含"归因""因此""预计"等词。

自然语言 thinking 的辅助 Reward 可以写成:

Rthinking-sem=w1Rgrounded+w2Rthought-action+w3Rexpected-effect−w4RredundancyR_{\text{thinking-sem}} = w_1 R_{\text{grounded}} + w_2 R_{\text{thought-action}} + w_3 R_{\text{expected-effect}} - w_4 R_{\text{redundancy}}

评估器应同时看到 observation + thinking + action + next observation,而不是只根据 thinking 的文风独立打分。该项在整条轨迹中的正奖励应设置上限,并显著小于终局功能正确 Reward。

不要奖励:thinking 的长度;使用了多少专业术语;是否使用某种固定句式或是否逐项覆盖模板字段;声明了多少 milestone;编译错误数量减少;每做一次 repair 就得分。

11.5 Gate Reward

Gate 的目标不是匹配静态 teacher 标签,而是最大化当前模型的真实效用:

Rgate(s,m)=Routcome(s,m)−C(s,m)R_{\text{gate}}(s,m)= R_{\text{outcome}}(s,m)-C(s,m)

在同一状态的模式组内:

  • DIRECT 和 THINK 都成功 → DIRECT 获得较高相对 advantage
  • DIRECT 失败、THINK 一次成功 → THINK 获得较高 advantage
  • 局部修复反复失败、REPLAN 成功 → REPLAN 获得较高 advantage
  • 三者都失败 → 不更新或送入课程学习

成本惩罚应在 RL 初期较弱,等三种分支都具备基本能力后再逐步增加。否则 Gate 会在能力尚未形成时因为短期省 token 而塌缩到 DIRECT。


12. RL 算法与 Loss 设计

12.1 推荐起点

对于可并行执行同一状态多个候选的场景,推荐从 multi-turn GRPO/DAPO 风格的组内相对优化开始:

  • 每个 query 或状态快照采样 6~8 条 rollout
  • 早期用强制模式 rollout 保证 THINK_SHORT/REPLAN 不因低初始概率而失去探索
  • 剩余 rollout 让 Gate 自然选择,直接训练 Auto-thinking
  • 以真实工具边界划分 macro-turn
  • 使用 turn-level advantage,而不是只把终局 advantage 平均给整条轨迹
  • all-fail 组不更新 Gate,送入课程学习或 teacher recovery
  • all-correct 组在 R1 可降采样,在 R3 可通过成功成本区分模式

以 group size G=8 为例:

全新任务的初始状态:
  2 × forced DIRECT
  2 × forced THINK_SHORT
  4 × AUTO
  REPLAN 默认被 runtime mask 屏蔽

出现真实错误或 Check 反馈后:
  2 × forced DIRECT
  2 × forced THINK_SHORT
  1 × forced REPLAN
  3 × AUTO

这样既能看到"直接做是否已经足够",也能看到"短思考能否提升一次修复率"和"方案是否真的需要重做"。随着 Gate 变得稳定,可逐步降低 forced rollout 比例,但应保留小的探索下限。

这里的 forced rollout 主要用于反事实估值和条件分支训练;其 mode token 默认不直接进入普通 on-policy Gate gradient。Gate 的直接 policy-gradient 更新以 AUTO rollout 为主,或使用经过正确 importance correction 的 forced 数据。

12.2 Macro-turn

mode token → optional thinking → action/tool call → real observation

Observation 后的 Reward 归因给前一个 macro-turn。工具 observation 只作为下一状态输入,不参与生成 loss。

12.3 分段 RL loss

理想形式:

LRL=−E[wgAglog⁡πg(m∣s)+1m≠D wzAz1∣z∣∑ilog⁡π(zi)+waAa1∣a∣∑jlog⁡π(aj)]+β DKL(πθ∥πSFT)−η H(πg)L_{\text{RL}} =-\mathbb{E} \left[ w_g A_g \log\pi_g(m|s) +\mathbf{1}_{m\neq D}\, w_z A_z \frac{1}{|z|}\sum_i\log\pi(z_i) +w_a A_a \frac{1}{|a|}\sum_j\log\pi(a_j) \right] +\beta\,D_{\mathrm{KL}}(\pi_\theta\|\pi_{\text{SFT}}) -\eta\,H(\pi_g)

其中:

  • A_g:同状态不同模式的相对效用
  • A_z:thinking 的证据扎根性、判断与 action 一致性、可验证预期与结果的过程 advantage
  • A_a:实际工具动作带来的进展和终局 advantage
  • H(π_g):Gate 模式熵
  • KL:防止格式、工具协议和已有代码能力漂移

第一版若无法稳定估计三个 advantage,可以共享 turn-level trajectory advantage,但使用不同 span 权重:

w_gate   = 1.0~1.5
w_action = 1.0
w_think  = 0.2~0.5

随着 verifier 完善,再为 groundedness、判断—动作一致性、预期结果和 action 构造独立 advantage。不要一开始就让 Judge 对自然语言 thinking 的文风施加强梯度。

12.4 RL 分阶段

R0:Reward dry-run

不更新模型,只运行当前 SFT checkpoint:检查各 Reward 分量分布;检查正确轨迹是否总分高于失败轨迹;审计 Judge 与隐藏执行分歧;验证成本项不会压过成功;建立各 query/error bucket 的基线。

R1:正确性与恢复能力

  • 约占 RL update budget 的前 20%~30%
  • 以终局执行、隐藏 Check、Judge 和无回归为主
  • 保持模式强制探索
  • thinking 和工具成本为 0 或只给很弱惩罚
  • 重点提升 Pass@1 与 First-repair success

R2:Gate 与一次修复

  • 约占中间 40%~50%
  • 增强同状态模式组内比较
  • 启用 turn-level advantage
  • 增加语义重复、无关修复和提前停止惩罚
  • 逐步加入条件化 token/tool/wall-time 成本

R3:Pareto 压缩

  • 约占最后 20%~30%
  • 仅在相同成功和进展等级的 rollout 间优化效率
  • 逐步提高 thinking 和额外工具成本
  • 周期性重新生成模式反事实
  • 将已经稳定成功的 THINK 状态转回 DIRECT 边界

这些比例是初始建议,应用 held-out Pass@1、First-repair success、mode regret 和模式熵决定阶段切换。核心顺序不能反转:先让各模式能产生正确结果,再让成本塑造 Gate;否则 5,000 条 DIRECT 先验叠加早期成本惩罚,极易形成永远 DIRECT。


13. 如何避免训练崩溃与模式塌缩

13.1 永远 DIRECT

常见原因:

  • 已有 5,000 条 DIRECT 形成强先验,但 Gate warm-start 和 RL 没覆盖真正 Think-necessary 的边界状态
  • RL 太早施加 thinking/tool 成本
  • THINK_SHORT 分支尚未学会,就与成熟 DIRECT 分支竞争
  • 强制探索不足,组内几乎没有成功的 THINK 候选
  • 所有失败都只有终局 Reward,无法体现正确归因的价值
  • Gate 标签由表面难度决定,长日志反而被误标

有效修复:

  • 先做分支能力冷启动,再做轻量 Gate warm-start,最终通过强制模式 RL 学边界
  • 用 300~500 个状态做轻量 Gate warm-start,而不是扩大 thinking SFT
  • RL 初期设置每组每模式的最小采样数
  • 对 Direct-fail / Think-success 状态上采样
  • 延迟并逐步增加思考成本
  • 监控 Thinking-necessity recall 和 mode regret,而非只看 THINK 比例
  • 对 Gate 添加小的熵正则和最小探索概率

13.2 永远 THINK_SHORT

常见原因:

  • teacher 几乎每次 action 前都写 thinking
  • 修复样本远多于首次成功样本
  • 只奖励成功,不计算思考、工具和时延成本
  • thinking 结构本身被 Judge 偏好
  • DIRECT 只包含简单题,缺少"修复也可 Direct"的样本
  • Gate 把"出现 error 字符串"学成固定触发器

有效修复:

  • 整体 SFT 默认保持约 85% DIRECT
  • 确保已有 DIRECT 中至少 300~500 条覆盖直接机械修复、确定性重试和正确停止
  • 为同一成功状态提供 DIRECT chosen、THINK rejected
  • 成本只在正确性相同时生效
  • Judge 不评价 thinking 文风,只评价可验证决策与结果
  • 加入长日志但 Direct-sufficient、短日志但 Think-necessary 的反例
  • 监控 Unnecessary-thinking rate

13.3 永远 REPLAN

常见原因:

  • REPLAN 文本长,token-level loss 中梯度过大
  • process reward 为"计划完整"或 milestone 数量加分
  • REPLAN 只出现在困难且成功的 teacher 轨迹中,形成伪相关
  • 初始 turn 也频繁强制 REPLAN
  • 局部失败没有精确的 progress 定义

有效修复:

  • 使用 turn-normalized loss
  • REPLAN 冷启动只新增 100~200 条,默认总体约 2.6%,且以真实核心假设失效为准
  • 不奖励计划长度、步骤数和专业表达
  • 全新任务初始 turn 默认屏蔽 REPLAN,仅在接手已有失败方案等状态下开放
  • 每条普通轨迹最多一次 REPLAN
  • 加入"虽然失败但原方案仍有效,应 THINK_SHORT"的负例
  • 监控 Replan precision

13.4 Token 熵塌缩

症状:

Gate 很快只输出一种 mode
thinking 变成固定模板或重复短句
rollout 多样性骤降
训练 Reward 上升但 held-out 正确率下降

措施:

  • 监控 Gate、thinking、action 三个 span 的独立 entropy
  • 使用当前 policy 的 on-policy rollout,减少陈旧离线轨迹占比
  • 对 all-correct/all-fail group 做动态采样
  • 使用适当的 asymmetric clip / clip-higher 或同类稳定化
  • 保持小步更新、gradient clipping 与自适应 KL
  • 设 mode exploration floor;初始状态覆盖 DIRECT/THINK_SHORT,反馈后状态再覆盖三模式
  • 对 query、错误摘要和提示模板做不改变语义的增强
  • 按任务与错误 bucket 分别做 reward normalization
  • 对 reward 和 advantage 截断异常值
  • 训练 Judge Reward 上升而 executable Reward 下降时自动暂停
  • 保存短间隔 checkpoint,并以综合 held-out 指标选择,而不是最后一步

naive RLVR/GRPO 的熵塌缩是已观察到的训练问题,不能只依靠一个全局 entropy bonus 解决;至少要监控 token span 与 Gate 级的熵流。

13.5 Gate 决策边界塌缩

Gate 是离散模式决策,尤其容易在多阶段训练中被单一模式占领。自适应 CoT 研究将其视为正确率与成本的 Pareto 优化,并使用 selective loss masking 避免不确定样本破坏边界。

本场景的对应做法:

有稳定同状态优胜结果 → 更新 Gate
合法模式差异小或全部失败 → mask Gate loss
分支能力不足导致的失败 → 先训练分支,不把失败归因给 Gate
当前 checkpoint 能力变化 → 重新收集反事实,刷新标签

13.6 Reward hacking

重点审计:

  • 删除或放宽 Check
  • 修改 Judge 输入或验收 rubric
  • 输出空产物以减少错误
  • 只修日志显示,不修功能
  • 写出 Judge 喜欢的流畅 thinking,但内容未扎根反馈或与 action 无关
  • 故意制造容易修的小错赚 process reward
  • 提前 done 以减少工具成本
  • 修改无关数据使隐藏样例碰巧通过

防护:

  • verifier、隐藏测试与 policy 沙箱权限隔离
  • 工具层记录所有资源和数据 diff
  • hard-coded output、测试篡改、权限扩大直接终止
  • 训练 Judge、holdout Judge 和 executable verifier 分离
  • 定期人工审计"高 Reward、低执行正确率"的样本
  • 过程 Reward 设置总上限,不能抵消终局失败
  • 维护 reward-component dashboard 与 divergence 告警

14. 怎样证明 Auto-Thinking 真的符合预期

14.1 强制模式 Oracle

在固定评测状态上分别强制 DIRECT、THINK_SHORT、REPLAN、AUTO,得到每个合法模式的真实效用和 AUTO 的 mode regret。AUTO 应接近同状态最优合法模式,而不是仅在平均成功率上看起来不错。

14.2 因果干预

Thinking 置空

正常 short-thinking vs. 保留 mode 但清空 thinking

如果 action 和成功率几乎不变,thinking 没有成为有效支撑点。

Thinking 置换

把任务 A 的 thinking 放到表面相似的任务 B 状态。若 action 不受其中错误证据和错误判断影响,模型可能只依赖 observation 关键词。

Decision 干预

保持其他内容相同,将自然语言中的关键判断从"当前修改破坏了公共契约,应回滚上一处改动再重新实现"替换为"现有方案仍然成立,应保留当前改动并继续局部修复"。应观察到 action 方向变化。否则这段自然语言 thinking 可能只是装饰。

Expect 校验

从 thinking 中语义抽取其可验证预期,并与真实 observation 比较:

  • 符合:说明假设得到支持
  • 不符合:下一 turn 应降低原假设置信度并重新归因
  • 连续不符合仍重复动作:计入 semantic repeat

14.3 必做消融

至少比较:

  1. Direct SFT + Direct RL
  2. 固定所有状态 THINK_SHORT
  3. 固定长 CoT
  4. Auto-thinking SFT,不做 RL
  5. Auto-thinking SFT + 终局 RL
  6. Auto-thinking SFT + turn-level RL
  7. 去掉 attribution/expect process reward
  8. 去掉同状态模式反事实
  9. 去掉条件成本 Reward
  10. 完整方案

所有实验保持:同一基座与 checkpoint 起点、同一训练 query、同一 rollout 预算、同一工具和 verifier、同一测试集、相近总训练 token / compute。

14.4 Auto-thinking 的上线闸门

不能从理论上保证 Gate 永远正确,但可以用可审计标准约束:

Pass@1 与 First-repair success 同时提升
Mode regret 不高于预设阈值
Thinking-necessity recall 达标
Unnecessary-thinking rate 不超标
Replan precision 达标
Semantic repeat 与 premature stop 下降
Judge Reward 与 executable Reward 同向
安全、权限和数据回归零恶化

只要其中一项明显恶化,就不能用"平均 Reward 上升"解释为训练成功。


15. 推荐的完整落地时间线

Step 1:建立评测与可重放环境

  • 固定 Base/schema 快照、工具版本和 acceptance checklist
  • 建立 Pass@1、first-repair、mode regret 和成本报表
  • 实现安全、数据保持、幂等、schema、公式、view 和 automation verifier
  • 校准 JudgeRM 并建立独立 holdout Judge

没有稳定 verifier 时不要急着开始在线 RL。

Step 2:审计 5,000 条 DIRECT 并补充冷启动数据

  • 保留现有 5,000 条 DIRECT,不为满足比例而删除
  • 确保其中 300~500 条覆盖 post-feedback DIRECT;不足时替换低价值重复样本或增补
  • 新增 600~800 条 THINK_SHORT,默认 700
  • 新增 100~200 条 REPLAN,默认 150
  • 从基模失败状态生成 recovery suffix
  • 将长 CoT 压为 64~128 tokens、最多 160 tokens 的 THINK_SHORT
  • 将真正方案失效样本整理为 REPLAN
  • 对错误前缀和 observation 做正确 loss mask

Step 3:高阶模型生成同状态反事实

  • 选 Gate 边界状态
  • 每个合法模式生成 2~4 个候选
  • 真实重放
  • 产出 mode label、chosen/rejected 和不确定 mask
  • 首批只需覆盖 300~500 个高信息状态,作为 Gate warm-start 和 RL 反事实种子

Step 4:完成能力冷启动与轻量 Gate warm-start

S1 强制模式分支能力 → S2 轻量 Gate warm-start → S3 可选联合小步

SFT 的停止条件是三个强制模式均达到最低可用门槛且 DIRECT Pass@1 无回退,不以固定 epoch 或静态 Gate 分类准确率为唯一标准。

Step 5:Reward dry-run

  • 在 SFT checkpoint 上运行至少一个完整评测周期
  • 画出每个 Reward 分量与真实成功率的相关性
  • 审计高 Reward 失败样本
  • 确认成本项不会压过正确性

Step 6:R1/R2/R3 在线 RL

  • R1 前 20%~30% 先学正确和一次恢复,弱化成本
  • R2 中间 40%~50% 学 Gate、重复抑制和停止
  • R3 最后 20%~30% 做成功成本 Pareto 压缩
  • 初始状态按 2 DIRECT + 2 THINK_SHORT + 4 AUTO 探索
  • 反馈后状态按 2 DIRECT + 2 THINK_SHORT + 1 REPLAN + 3 AUTO 探索
  • 采用 learning-frontier 动态采样
  • 周期性把新失败状态交给高阶模型生成 recovery 和反事实

Step 7:周期性蒸馏与刷新

每个主要 RL checkpoint:

  1. 在固定状态强制运行全部合法模式
  2. 重新计算 mode regret 与决策边界
  3. 将稳定高 Reward 的最短轨迹蒸馏回小规模 SFT refresh
  4. 删除旧的冗余或被新能力淘汰的 thinking 标签
  5. 保持一部分原始 DIRECT 数据,防止灾难性遗忘

16. 推荐的首版配置全览

architecture:
  modes: [DIRECT, THINK_SHORT, REPLAN]
  gate_scope: per_react_turn
  gate_token:
    required_for_auto_thinking: false
    recommended: true
    implementation: reasoning_mode_special_token
    tokens:
      DIRECT: "<|mode_direct|>"
      THINK_SHORT: "<|mode_think_short|>"
      REPLAN: "<|mode_replan|>"
    external_workflow_routing: false
    retained_in_model_context: true
    visible_to_user: false
    overhead_tokens_per_turn: 1

sft:
  existing_direct_trajectories: 5000
  add_trajectories:
    THINK_SHORT:
      range: [600, 800]
      default: 700
    REPLAN:
      range: [100, 200]
      default: 150
  default_total_trajectories: 5850
  default_raw_ratio:
    DIRECT: 0.8547
    THINK_SHORT: 0.1197
    REPLAN: 0.0256
  direct_post_feedback_coverage: [300, 500]
  ability_sft_effective_batch:
    DIRECT: 0.82
    THINK_SHORT: 0.15
    REPLAN: 0.03
  recovery_prefix_loss_mask: 0
  tool_observation_loss_mask: 0
  normalization: per_assistant_turn
  stages:
    branch_ability:
      force_mode_token: true
      gate_token_loss_mask: 0
    gate_warm_start:
      states: [300, 500]
      role: exploration_bootstrap_only
    joint_consolidation:
      optional: true
      max_update_budget: 0.10

thinking:
  surface_form: natural_language
  fixed_field_schema: false
  visible_wrapper: thinking_tags_only
  semantic_expectations:
    - grounded_in_observation
    - explains_next_action_when_needed
    - states_verifiable_effect_when_useful
  structured_annotations:
    location: offline_metadata_only
    visible_to_student: false
  semantic_reward:
    context: [observation, thinking, action, next_observation]
    checks: [groundedness, thought_action_consistency, expected_effect, redundancy]
    positive_cap_relative_to_terminal_reward: 0.10
  THINK_SHORT:
    target_tokens: [64, 128]
    hard_cap_tokens: 160
  REPLAN:
    target_tokens: [128, 192]
    hard_cap_tokens: 256

gate_sft:
  warm_start_label_mix:
    DIRECT: 0.65
    THINK_SHORT: 0.30
    REPLAN: 0.05
  train_mode_token_only: true
  uncertain_state_gate_mask: 0
  label_source: same_state_forced_mode_execution

rl:
  rollout_group_size: 8
  initial_state_group:
    forced_DIRECT: 2
    forced_THINK_SHORT: 2
    forced_REPLAN: 0
    AUTO: 4
  post_feedback_group:
    forced_DIRECT: 2
    forced_THINK_SHORT: 2
    forced_REPLAN: 1
    AUTO: 3
  credit_assignment: turn_level
  primary_sampling_bucket: learning_frontier
  ordinary_max_repair_turns: 1
  replan_max_recovery_actions: 2
  max_replans_per_episode: 1
  early_mode_exploration: forced
  gate_update:
    on_policy_source: AUTO_rollouts
    forced_mode_uses:
      - counterfactual_utility_estimation
      - conditional_branch_training
      - gate_preference_construction
    forced_mode_direct_gate_gradient: false
    importance_correction_required_to_enable: true
  cost_penalty_schedule: delayed_and_increasing
  stage_update_budget_default:
    correctness_and_recovery: 0.25
    gate_and_first_repair: 0.50
    pareto_compression: 0.25
  stage_update_budget_range:
    correctness_and_recovery: [0.20, 0.30]
    gate_and_first_repair: [0.40, 0.50]
    pareto_compression: [0.20, 0.30]
  reference_policy: sft_checkpoint

reward_priority:
  - safety_and_data_integrity
  - executable_correctness
  - judge_user_intent
  - regression_and_idempotence
  - verified_process_progress
  - mode_and_interaction_cost

launch_metrics:
  - pass_at_1
  - first_repair_success
  - mode_regret
  - thinking_necessity_recall
  - unnecessary_thinking_rate
  - replan_precision
  - semantic_repeat_rate
  - judge_executable_divergence

17. 总结

对于多维表格 CodeAgent,最优方向不是"所有轨迹都加 CoT",也不是"完全不输出 thinking,只依靠终局 RL"。更合理的方案是:

把短 thinking 设计成自然语言、但可被语义验证的决策瓶颈
把是否使用 thinking 设计成逐 turn 的 Gate
把 DIRECT、THINK_SHORT、REPLAN 作为三种能力先分别训练
再通过同状态真实反事实和多轮 RL 学习模式边界

Auto-thinking 不一定需要显式 Gate token;直接输出 tool call 或 <thinking> 也能形成隐式 Gate。但 reasoning-mode token 每 turn 通常只增加一个 token,却把模式选择变成可独立监督、强化、干预和评测的元推理变量,因此在三档模式方案中更值得采用。它由模型生成并继续参与后续上下文,serving 只负责隐藏,不用于启动外部工作流。

短 thinking 相比直接代码 RL 的主要价值,是把稀疏终局反馈转化为诊断、归因、动作理由、预期观察和 action 等可验证支撑点,从而改善 credit assignment、恢复泛化和一次修复率。它的价值不来自固定结构或长度,而来自自然语言中真实使用了当前证据,并与下一动作和工具反馈形成闭环。

对于当前已有的 5,000 条 DIRECT SFT,建议采用:

保留 DIRECT 5,000 条
新增 THINK_SHORT 600~800 条,默认 700
新增 REPLAN 100~200 条,默认 150
另构建 300~500 个可复用的 Gate warm-start 状态

默认原始比例约为 85.5% / 12.0% / 2.6%。THINK_SHORT 目标 64~128 tokens、硬上限 160。高阶模型主要用于基模真实失败状态上的纠错、压缩和反事实生成,不能替代真实环境判真。

SFT 只需让三种分支可用,并给 Gate 一个最小探索起点;不应依靠大量 THINK_SHORT/REPLAN SFT 固化模式边界。RL 才是 Auto-thinking 的核心:AUTO rollout 负责直接更新 Gate,forced-mode rollout 主要负责反事实估值、条件分支训练和偏好构造;先优化正确性和 First-repair success,再逐步优化 token、工具和时延成本。Auto-thinking 是否成功,最终不由 THINK 占比决定,而由:

更高 Pass@1
+ 更高一次修复率
+ 更低模式 regret
+ 更少无效重复
+ 更低成功成本
+ 无安全和数据回归

共同决定。


参考资料