多维表格 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 等技术报告:
- 冷启动(少量优质 SFT 数据)
- RL 专项任务训练
- 基于训练模型的拒绝采样(关注采样接受率)
- 补充通用数据,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)
关键发现
- 主要瓶颈已从"能否编译"转向"修复成本和实际执行":编译率已达 99.47%,但 Pass@1 仅 40.61%
- Permission 模块问题不在代码可执行性,而在产物语义:执行通过率最高但 Judge 通过率最低
- Workflow 同时存在质量和 Judge 稳定性问题:178/204 次 Judge 调用错误来自 Workflow
- 训练对"可执行性"的改善比对"最终产物完全通过 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;第一次失败后尽量一次修好;简单状态直接做,只有思考确实能改变决策时才思考或重规划。
目标函数
把一次轨迹的效用写成:
优化优先级应是字典序,而不是简单把所有项等价相加:
安全、权限与数据完整性
> 任务功能正确
> 无回归
> 一次恢复成功
> 少重复、少工具调用、低时延、短 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 是否真的学会的核心指标:
仅看线上 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 时,策略近似为 ,若只有终局 Reward,一次失败会把相似的负 advantage 分配给长代码中的大量 token,但 Reward 并不明确告诉模型具体哪里错了。
短 thinking 把大动作分解成可学习的中间变量:引入模式 、短决策变量 和动作 :
带来三个额外价值:
- 很多表面不同的错误可以映射到同一可迁移类别(如
schema_reference / last_diff / repair_reference),相当于在高维代码空间中增加了低维的故障与决策表示 - 提供了可验证的 RL 支撑点:可检查 attribution 是否与证据一致、decision 是否与 action 一致、expect 是否被下一次 observation 证实
- 改善多轮 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 后,策略更容易分解为 ,带来:
- 可单独提取 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)。
标签规则:
- DIRECT 成功,且与最优模式效用差不超过 δ → label = DIRECT
- THINK_SHORT 相比 DIRECT 显著提升正确性或一次修复率,且原方案不需要重做 → label = THINK_SHORT
- 核心假设已被证伪,REPLAN 的真实结果最好 → label = REPLAN
- 所有合法模式全部失败,或结果差异落在噪声范围内 → 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
第一版建议:
- 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 优化的是 ,它回答的是"teacher 在这个静态状态上标了什么模式"。三个局限:
- 标签依赖生成它时的 checkpoint;模型变强后,原本需要 THINK_SHORT 的状态可能已经能 DIRECT
- 单个模式标签不能持续表达正确性、工具成本、thinking 成本和时延之间的 Pareto 关系
- 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
理想形式:
其中:
- :同状态不同模式的相对效用
- :thinking 的证据扎根性、判断与 action 一致性、可验证预期与结果的过程 advantage
- :实际工具动作带来的进展和终局 advantage
- :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_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:
评估器应同时看到 observation + thinking + action + next observation。该项在整条轨迹中的正奖励应设置上限,并显著小于终局功能正确 Reward。
不要奖励:thinking 的长度、使用了多少专业术语、是否使用某种固定句式、声明了多少 milestone、编译错误数量减少、每做一次 repair 就得分。
Gate Reward
Gate 的目标不是匹配静态 teacher 标签,而是最大化当前模型的真实效用:
在同一状态的模式组内:
- 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 前需要:
- 脱敏和权限清洗:删除 token、个人信息、真实业务敏感值
- schema-preserving 匿名化:保留字段类型、依赖拓扑和错误结构
- 语义去重:相同模板、同一 Base 快照和重写 query 只保留代表样本
- 可执行快照:保存初始表结构、必要数据、工具版本与随机种子
- 固定验收条件:在 rollout 前生成并冻结 acceptance checklist
- 稳定性检查:同一正确产物重复运行 verifier 的结果应一致
- 可解性检查:工具权限、依赖和环境必须足以完成任务
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. 必做消融
至少比较:
- Direct SFT + Direct RL
- 固定所有状态 THINK_SHORT
- 固定长 CoT
- Auto-thinking SFT,不做 RL
- Auto-thinking SFT + 终局 RL
- Auto-thinking SFT + turn-level RL
- 去掉 attribution/expect process reward
- 去掉同状态模式反事实
- 去掉条件成本 Reward
- 完整方案
所有实验保持:同一基座与 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、构造反事实
真实环境:执行、验证和判真
高阶模型适合担任:
- 轨迹编辑器:标记 keep / mask / replace / truncate
- 首次偏离定位器:找出错误开始传播的 turn
- 恢复专家:从基模真实失败状态生成最小 recovery
- thinking 压缩器:将长推理改写为预算内、语义有效的自然语言短段落
- 反事实候选生成器:为同一状态生成 DIRECT、THINK_SHORT、REPLAN
- Rubric 生成器:将用户 query 转换为可执行的验收 checklist
- 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 生成,并在真实环境重放。
数据生产流水线
- 对每个任务用基模或当前 checkpoint 采样 4~8 条 rollout
- 保存每个 assistant turn 前的可恢复环境快照与状态 fingerprint
- 用高阶模型定位首次关键偏离、错误归因、重复动作和错误停止
- 对高价值状态的每个合法模式生成 2~4 个候选
- 从同一快照真实重放;所有 observation 必须来自工具
- 按正确性、无回归、进展和成本选最短有效路径
- 将 teacher 长 reasoning 压成 THINK_SHORT 或 REPLAN 格式
- 产出四类视图:最短 clean-success、错误前缀 mask=0 的 recovery suffix、同状态 mode preference / chosen-rejected、噪声/停止/回滚和反 reward-hacking 样本
- 进行硬过滤:工具格式合法、执行可重放、隐藏 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:
- 在固定状态强制运行全部合法模式
- 重新计算 mode regret 与决策边界
- 将稳定高 Reward 的最短轨迹蒸馏回小规模 SFT refresh
- 删除旧的冗余或被新能力淘汰的 thinking 标签
- 保持一部分原始 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 之间:
- 用当前模型对同一个问题采样多条输出
- 用奖励模型/验证器给每条输出打分
- 只保留高分输出,扔掉低分的
- 用高分输出做 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 是否成功的核心指标:
含义: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. 帕累托最优的数学公式
多目标优化的形式化
假设有 个目标要同时优化,每个目标是一个函数 ,其中 是决策变量(在 Code Agent 里就是"选哪个模式、生成什么代码")。为统一,假设所有目标都是越大越好(成本类目标取负数):
在 Auto-Thinking 中,大致是:
支配关系(Dominance)
这是帕累托理论最核心的定义。
方案 支配(dominate)方案 ,记作 ,当且仅当:
- 在所有目标上都不差于 : 对所有 成立
- 在至少一个目标上严格优于 :存在某个 使得
用符号写:
直观翻译: 全方位不比 差,而且至少有一方面更好。那 就没有任何存在的理由了——选 永远更好。
帕累托最优(Pareto Optimality)
方案 是帕累托最优的,当且仅当不存在任何其他方案 能支配 。
换句话说:想让 的任何一个目标变好,都必须以牺牲至少一个其他目标为代价。
帕累托前沿(Pareto Front)
所有帕累托最优方案组成的集合:
在二维情况下(比如正确率 vs 成本),帕累托前沿就是一条曲线。曲线上的每个点都代表一种"合理的权衡"——你要更高正确率就得接受更高成本,要更低成本就得接受稍低正确率。
帕累托改进(Pareto Improvement)
从方案 到方案 ,如果 ,那这就是一次帕累托改进:没有人受损,至少有人受益。
文档 R3 阶段做的事,就是在已经成功的 rollout 中找帕累托改进:正确率不变,但 token/工具/时延减少了。
文档中的字典序帕累托实现
文档的 Reward 层级(Tier 0 安全 > Tier 1 功能正确 > Tier 2 无回归 > Tier 3 有效进展 > Tier 4 成本)就是一个**字典序帕累托(Lexicographic Pareto)**的实现:
- 先比 Tier 0(安全):如果 安全且 不安全 → ,直接判定
- Tier 0 相同 → 比 Tier 1(功能正确)
- Tier 1 相同 → 比 Tier 2(无回归)
- Tier 2 相同 → 比 Tier 3(有效进展)
- Tier 3 相同 → 比 Tier 4(成本)
这等价于给目标排了优先级,高优先级目标的差异字典序优先于低优先级目标。数学上可以写成一个向量比较:
按字典序比较 和 ,第一个不同的分量决定优劣。
为什么不用简单加权
简单加权:
问题在于,加权隐含了一个假设:目标之间是可替代的——正确率降 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 本身就是一个帕累托概念。 是该状态下所有模式中的最优效用(帕累托最优点), 是 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)**问题:你面前有 个老虎机,每个有不同的中奖概率。你玩了 轮,总收益是多少?如果事后知道哪个老虎机最好,一直玩它能拿多少?两者的差就是 regret。
其中 是最好老虎机的期望收益, 是第 轮实际选的老虎机的期望收益。
Regret 衡量的是"因为不知道最优选择而损失了多少"。 Regret 越低,说明决策越接近最优。
Mode Regret 的具体定义
在每个状态 ,Gate 要从三个模式中选一个:
每个模式在该状态下有一个真实效用 (综合正确率和成本)。事后看来,该状态的最优模式是:
其中 是状态 下的合法模式集合(受 runtime availability mask 约束)。
Mode Regret 就是实际选的模式和最优模式之间的效用差:
展开写:
效用 U(s, m) 是什么
文档中的效用函数是综合的:
实际操作中,是先在同一状态下强制运行每个模式,得到真实的执行结果,然后按 Tier 层级比较。
怎么计算 Mode Regret
工程上的计算步骤:
- 固定状态快照:保存某个 ReAct turn 开始前的完整环境状态(Base schema、当前代码、diff、历史 observation)
- 强制运行每个合法模式:从同一快照出发,分别强制 DIRECT、THINK_SHORT、REPLAN,各跑 2~4 次取平均,得到每个模式的真实效用
- 找到最优模式:
- 记录 Gate 的实际选择:
- 计算差值:
这就是文档说的"强制模式 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:简单字段名修复
状态 :编译报错 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:数据模型根因错误
状态 :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. 三个概念的串联
- 零和游戏是问题:简单加权求和让正确率和成本互相挤压,模型可能作弊。
- 帕累托是框架:承认多目标不可简单替代,先找非支配解集(帕累托前沿),再按阶段偏好选择。
- 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周期重算 │
└─────────────────────────────────────────────────────┘
整个方案的设计哲学:
- SFT 教"会做",RL 教"选对"——SFT 让三个模式分支都具备非零能力,RL 通过同状态真实反事实学习当前模型的模式决策边界。
- 先正确性,后成本效率——R1/R2/R3 顺序不能反转,否则 5000 条 DIRECT 先验 + 早期成本惩罚必然导致永远 DIRECT。
- 用 mode regret 而非 THINK 占比衡量成败——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
最重要的六条原则:
<thinking>应是简短、自然且有证据的决策说明,不使用固定字段表单,也不是自由发挥的长篇思考。- 错误 action 和工具 observation 作为上下文保留,但在 SFT 中
loss mask=0;从正确的恢复判断开始训练 recovery suffix。 mask=0只是"不模仿错误",不会主动抑制重复;同状态偏好数据或 RL 才能教会模型"不要再这么做"。- 高阶模型负责标注、纠错、压缩和生成候选,基模负责产生真实失败状态,真实环境负责最终判真。
- Reward 必须按"安全与数据完整性 > 功能正确 > 无回归 > 有效进展 > 成本"排序;不能用省 token、少工具调用换取错误答案。
- SFT 只冷启动模式能力和最小 Gate 探索,Auto-thinking 的主要训练责任放在同状态反事实 RL。
1. 训练目标与评测口径
1.1 目标函数不是"少思考",而是"以最低总代价正确完成"
把一次轨迹的效用写成:
优化优先级应是字典序,而不是简单把所有项等价相加:
安全、权限与数据完整性
> 任务功能正确
> 无回归
> 一次恢复成功
> 少重复、少工具调用、低时延、短 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 是判断 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 时,策略近似为 。s 是用户需求、当前多维表格状态、代码和工具反馈,a 是一整段代码或工具动作。若只有终局 Reward:
一次失败会把相似的负 advantage 分配给长代码中的大量 token,但 Reward 并不明确告诉模型:是理解错了用户需求、是表结构设计错了、是字段 ID 或类型用错了、是公式依赖关系不对、是工具反馈与当前修改无关,还是仅仅漏了一次必要验证。
模型仍然可能通过直接 RL 提升能力,因此"无 thinking 的 RL 只是对齐"并不完全准确;但在动作空间很大、终局反馈稀疏、多轮状态不断变化的 CodeAgent 中,它更容易学到局部输出偏好,而不是可迁移的错误归因和恢复策略。
2.2 短 thinking 把大动作分解成可学习的中间变量
引入模式 m、短决策变量z 和动作a:
其中:m:DIRECT、THINK_SHORT 或 REPLAN;z:一段短自然语言决策说明;a:实际代码修改或工具调用。
边缘化后仍然能表达直接策略:
虽然 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 后,策略更容易分解为 。它不会凭空增加推理能力,但会把"是否思考、采用何种深度"和"具体思考内容"分开,从而带来:
- 可单独提取 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 权重聚合:
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)。
标签规则:
- DIRECT 成功,且与最优模式效用差不超过 δ → label = DIRECT
- THINK_SHORT 相比 DIRECT 显著提升正确性或一次修复率,且原方案不需要重做 → label = THINK_SHORT
- 核心假设已被证伪,REPLAN 的真实结果最好 → label = REPLAN
- 所有合法模式全部失败,或结果差异落在噪声范围内 → 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
第一版建议:
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 优化的是 。它回答的是"teacher 在这个静态状态上标了什么模式"。即使标签来自真实执行,它仍然存在三个局限:
- 标签依赖生成它时的 checkpoint;模型变强后,原本需要 THINK_SHORT 的状态可能已经能 DIRECT。
- 单个模式标签不能持续表达正确性、工具成本、thinking 成本和时延之间的 Pareto 关系。
- teacher 容易把自己的思考习惯固化成 Gate 规则,例如"见 error 必 THINK"或"复杂需求必 REPLAN"。
RL 优化的是当前策略在真实环境中的效用:
通过同一状态下 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:
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、构造反事实
真实环境:执行、验证和判真
高阶模型适合担任:
- 轨迹编辑器:标记
keep / mask / replace / truncate - 首次偏离定位器:找出错误开始传播的 turn
- 恢复专家:从基模真实失败状态生成最小 recovery
- thinking 压缩器:将长推理改写为预算内、语义有效的自然语言短段落
- 反事实候选生成器:为同一状态生成 DIRECT、THINK_SHORT、REPLAN
- Rubric 生成器:将用户 query 转换为可执行的验收 checklist
- 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 可落地的数据生产流水线
- 对每个任务用基模或当前 checkpoint 采样 4~8 条 rollout。
- 保存每个 assistant turn 前的可恢复环境快照与状态 fingerprint。
- 用高阶模型定位首次关键偏离、错误归因、重复动作和错误停止。
- 对高价值状态的每个合法模式生成 2~4 个候选。
- 从同一快照真实重放;所有 observation 必须来自工具。
- 按正确性、无回归、进展和成本选最短有效路径。
- 将 teacher 长 reasoning 压成 THINK_SHORT 或 REPLAN 格式。
- 产出四类视图:最短 clean-success、错误前缀 mask=0 的 recovery suffix、同状态 mode preference / chosen-rejected、噪声/停止/回滚和反 reward-hacking 样本。
- 进行硬过滤:工具格式合法、执行可重放、隐藏 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 前需要:
- 脱敏和权限清洗:删除 token、个人信息、真实业务敏感值
- schema-preserving 匿名化:保留字段类型、依赖拓扑和错误结构
- 语义去重:相同模板、同一 Base 快照和重写 query 只保留代表样本
- 可执行快照:保存初始表结构、必要数据、工具版本与随机种子
- 固定验收条件:在 rollout 前生成并冻结 acceptance checklist
- 稳定性检查:同一正确产物重复运行 verifier 的结果应一致
- 可解性检查:工具权限、依赖和环境必须足以完成任务
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_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 可以写成:
评估器应同时看到 observation + thinking + action + next observation,而不是只根据 thinking 的文风独立打分。该项在整条轨迹中的正奖励应设置上限,并显著小于终局功能正确 Reward。
不要奖励:thinking 的长度;使用了多少专业术语;是否使用某种固定句式或是否逐项覆盖模板字段;声明了多少 milestone;编译错误数量减少;每做一次 repair 就得分。
11.5 Gate Reward
Gate 的目标不是匹配静态 teacher 标签,而是最大化当前模型的真实效用:
在同一状态的模式组内:
- 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
理想形式:
其中:
A_g:同状态不同模式的相对效用A_z:thinking 的证据扎根性、判断与 action 一致性、可验证预期与结果的过程 advantageA_a:实际工具动作带来的进展和终局 advantageH(π_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 必做消融
至少比较:
- Direct SFT + Direct RL
- 固定所有状态 THINK_SHORT
- 固定长 CoT
- Auto-thinking SFT,不做 RL
- Auto-thinking SFT + 终局 RL
- Auto-thinking SFT + turn-level RL
- 去掉 attribution/expect process reward
- 去掉同状态模式反事实
- 去掉条件成本 Reward
- 完整方案
所有实验保持:同一基座与 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:
- 在固定状态强制运行全部合法模式
- 重新计算 mode regret 与决策边界
- 将稳定高 Reward 的最短轨迹蒸馏回小规模 SFT refresh
- 删除旧的冗余或被新能力淘汰的 thinking 标签
- 保持一部分原始 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
+ 更少无效重复
+ 更低成功成本
+ 无安全和数据回归
共同决定。
参考资料
- ReAct: Synergizing Reasoning and Acting in Language Models
- Let's Verify Step by Step
- DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning
- Training Software Engineering Agents and Verifiers with SWE-Gym
- Agent-RLVR: Training Software Engineering Agents via Guidance and Environment Rewards
- Reinforcing Multi-Turn Reasoning in LLM Agents via Turn-Level Credit Assignment
- StepCoder: Improve Code Generation with Reinforcement Learning from Compiler Feedback
- From Patches to Trajectories: Privileged Process Supervision for Software-Engineering Agents
- AdaCoT: Pareto-Optimal Adaptive Chain-of-Thought Triggering via Reinforcement Learning
- Omni-AutoThink: Adaptive Multimodal Reasoning via Reinforcement Learning
- DAPO: An Open-Source LLM Reinforcement Learning System at Scale
- Understanding and Preventing Entropy Collapse in RLVR with On-Policy Entropy Flow Optimization
- Reward Hacking in Rubric-Based Reinforcement Learning
- Measuring Faithfulness in Chain-of-Thought Reasoning