以下数字为教学示例,不构成对任何真实系统或供应商的承诺。
“让 Agent 多想一点"听起来总是对的,实际上不是。对简单任务多花 8 秒、4 倍成本去"深思”,收益是负的;对困难任务只花 0.5 秒快速作答,失败率会高到不可接受。问题的关键不是"想还是不想",而是知道该想还是不该想。
这一节用双过程(dual-process)框架讨论这个问题:快路径便宜、快,但成功率随难度下降;慢路径贵、慢,但在高难度上更好。一个阈值路由器按难度信号在两者之间选择。实验比较全快、全慢、按阈值路由三种策略,以及一个"逐档选最优"的 oracle 上界。
双过程的代价结构
两个路径各有形状:
| 路径 | 成本 | 延迟 | 成功率 |
|---|---|---|---|
| 快路径 | 低 | 低 | 简单任务高,难任务低 |
| 慢路径 | 高 | 高 | 高难度任务更好 |
快路径不是"差",是在不同难度上衰减得更快。慢路径也不是"好",是在高难度上才值回票价。双过程设计的目标不是全快或全慢,而是让每一档难度的任务走效用更高的路径。
阈值路由
最简单的双过程实现是阈值路由:估一个难度信号,低于阈值走快路径,高于阈值走慢路径。难度信号可以是模型自评的置信度、任务的特征维度,或外部指标(比如这次查询包含多少个约束)。
阈值路由有两条天然的性质:
- 只有一个参数(阈值),容易调、容易解释;
- 切换点集中,不会出现同一档难度时而快时而慢。
但阈值路由的质量取决于信号的质量:信号把任务分错档,路由就把任务分错路径。信号太粗(比如"所有问题都难"),阈值路由退化成全慢。
最小实验:六档难度的路由
下面的实验把任务按难度 1..6 分成六档,每档有固定的任务数(共 40 个)。快路径成功率 0.95 − 0.12·难度(下限 0.25),慢路径 0.55 + 0.075·难度(上限 0.99)。阈值从 1 扫到 7,覆盖"全慢"到"全快"。
# file: agp_lab/dual_process.py | write
# tier: 3
# verify: python3 -m unittest tests.test_dual_process
"""快思考与慢思考的路由实验。
任务按难度 1..6 分成六档,每档有固定的任务数量。快路径便宜、快,但难度
越高成功率越低;慢路径贵、慢,但在高难度上成功率更高。路由器按一个
难度信号做阈值决策:信号低于阈值走快路径,否则走慢路径。
实验比较“全快”“全慢”“按阈值路由”三种策略的期望成功率、平均成本、
平均延迟与期望效用。所有参数均为教学假设,不是生产测量值。
"""
from __future__ import annotations
from dataclasses import dataclass
DIFFICULTIES = (1, 2, 3, 4, 5, 6)
COUNTS = (4, 8, 10, 8, 6, 4) # 共 40 个任务
VALUE = 12.0
FAILURE_COST = 8.0
FAST_COST = 0.5
SLOW_COST = 4.0
FAST_LATENCY = 1.0
SLOW_LATENCY = 8.0
def fast_success(difficulty: int) -> float:
"""快路径成功率:难度越高越低,下限 0.25。"""
if difficulty not in DIFFICULTIES:
raise ValueError(f"未知难度: {difficulty}")
return max(0.25, 0.95 - 0.12 * difficulty)
def slow_success(difficulty: int) -> float:
"""慢路径成功率:难度越高越高,上限 0.99。"""
if difficulty not in DIFFICULTIES:
raise ValueError(f"未知难度: {difficulty}")
return min(0.99, 0.55 + 0.075 * difficulty)
def utility(success: float, cost: float) -> float:
return success * VALUE - (1.0 - success) * FAILURE_COST - cost
@dataclass(frozen=True)
class PolicyResult:
name: str
success: float
cost: float
latency: float
utility: float
slow_share: float
def _aggregate(name: str, choices: list[tuple[int, bool]]) -> PolicyResult:
total = sum(COUNTS)
success = 0.0
cost = 0.0
latency = 0.0
slow_count = 0
for difficulty, slow in choices:
count = COUNTS[difficulty - 1]
probability = slow_success(difficulty) if slow else fast_success(difficulty)
success += count * probability
cost += count * (SLOW_COST if slow else FAST_COST)
latency += count * (SLOW_LATENCY if slow else FAST_LATENCY)
slow_count += count if slow else 0
success /= total
cost /= total
latency /= total
return PolicyResult(
name=name,
success=success,
cost=cost,
latency=latency,
utility=utility(success, cost),
slow_share=slow_count / total,
)
def route(threshold: int) -> PolicyResult:
"""阈值策略:难度 >= threshold 走慢路径。threshold=1 全慢,7 全快。"""
if not 1 <= threshold <= max(DIFFICULTIES) + 1:
raise ValueError("threshold 必须在 [1, 7] 内")
choices = [(difficulty, difficulty >= threshold) for difficulty in DIFFICULTIES]
label = "always_slow" if threshold == 1 else (
"always_fast" if threshold == max(DIFFICULTIES) + 1 else f"route>={threshold}"
)
return _aggregate(label, choices)
def oracle() -> PolicyResult:
"""逐档选择效用更高的路径,作为路由质量的上界。"""
choices = []
for difficulty in DIFFICULTIES:
fast = utility(fast_success(difficulty), FAST_COST)
slow = utility(slow_success(difficulty), SLOW_COST)
choices.append((difficulty, slow > fast))
return _aggregate("oracle", choices)
def sweep() -> list[PolicyResult]:
return [route(threshold) for threshold in range(1, max(DIFFICULTIES) + 2)]
def best_policy() -> PolicyResult:
return max(sweep(), key=lambda result: (result.utility, -result.cost))
if __name__ == "__main__":
print(f"{'策略':<12}{'成功率':>10}{'成本':>8}{'延迟':>8}"
f"{'效用':>8}{'慢路径占比':>12}")
for result in sweep():
print(
f"{result.name:<12}{result.success:>10.3f}{result.cost:>8.2f}"
f"{result.latency:>8.2f}{result.utility:>8.2f}"
f"{result.slow_share:>12.2f}"
)
bound = oracle()
print(
f"{bound.name:<12}{bound.success:>10.3f}{bound.cost:>8.2f}"
f"{bound.latency:>8.2f}{bound.utility:>8.2f}"
f"{bound.slow_share:>12.2f}"
)
运行:
cd private/labs/agp-lab
python3 -m agp_lab.dual_process
输出:
策略 成功率 成本 延迟 效用 慢路径占比
always_slow 0.804 4.00 8.00 4.08 1.00
route>=2 0.825 3.65 7.30 4.84 0.90
route>=3 0.827 2.95 5.90 5.58 0.70
route>=4 0.780 2.08 4.15 5.53 0.45
route>=5 0.704 1.38 2.75 4.71 0.25
route>=6 0.618 0.85 1.70 3.51 0.10
always_fast 0.544 0.50 1.00 2.38 0.00
oracle 0.827 2.95 5.90 5.58 0.70
这张表有四个要点。
全快和全慢都不是答案。 always_fast 成本最低但成功率只有 0.544,效用 2.38;always_slow 成功率 0.804 但成本 4.00、延迟 8.00,效用只有 4.08。两端的共同问题是"对一半任务用错了路径"。
最佳阈值是 route>=3。 它把难度 3 及以上的 70% 任务交给慢路径,成功率 0.827、成本 2.95、延迟 5.90,效用 5.58。注意它和 oracle 的效用完全相同、成功率完全相同——这不是巧合,而是说明:在这组参数下,难度 1 和 2 走快、3 及以上走慢就是逐档最优,阈值路由恰好达到了 oracle 上界。
效果不是单调的。 route>=3(0.827)比 route>=2(0.825)成功率更高、成本还更低。把难度 2 的任务也送去慢路径,花了更多钱,成功率反而略降(0.825 < 0.827)。难度 2 的慢路径成功率低于难度 3 的慢路径,但成本都是 4.00;把预算花在难度 2 上,边际收益是负的。路由的价值在于把慢路径留给真正受益的任务,而不是"越多慢越好"。
延迟跟着慢路径占比走。 延迟 1.70 对应慢路径占比 0.10,延迟 5.90 对应 0.70。延迟几乎是慢路径占比的线性函数。如果你的延迟预算只有 3 秒,route>=5(1.70)可能是唯一可行的选择,即使它的效用不是最高。延迟是约束,不是可以优化掉的目标。
信号质量决定上限
阈值路由的成败取决于难度信号。信号错配时:
| 信号问题 | 表现 | 后果 |
|---|---|---|
| 信号太乐观 | 困难任务被判简单,走快路径 | 成功率虚高,失败率失控 |
| 信号太悲观 | 简单任务被判困难,走慢路径 | 成本、延迟全面上涨 |
| 信号不稳定 | 同一任务两次分档不同 | 路由抖动,无法回归 |
oracle 是"信号完美"的上界;真实信号只会比它差。工程上需要做的是离线度量信号与难度的相关性,而不是假设难度估计可靠。
双过程与元推理的分工
双过程和下一节的元推理容易混淆。简单区分:
- 双过程:路由是显式的、可调的,由系统规则决定走哪条路径;
- 元推理:模型自己判断"该不该多想",判断本身来自模型输出。
双过程把"该走哪条路"从模型手里拿过来,变成一个可配置的架构决策。它牺牲了一点灵活性(不能用模型判断),换来的是确定性(同样输入同样路径)和可审计性(路由记录可回放)。对可靠性要求高的场景,这通常是更稳的选择。
架构含义
双过程对架构有三个直接约束:
- 快慢路径要有同一接口。 调用方不关心走哪条,只关心拿到结果;切换由路由层完成。
- 难度信号要可测。 路由决策要记录信号值,才能事后度量信号质量。
- 阈值按负载配置。 W1 的阈值和 W3 的阈值不同;全局一个阈值会让某类负载受损。
第 2 条最常被跳过。不记录"为什么这条走了快路径",就没法知道是路由正确还是信号失效。
架构判据
| 判据 | 合格的样子 | 不合格的样子 |
|---|---|---|
| 快慢分层 | 两种路径显式存在 | 一个模型应付所有难度 |
| 阈值可调 | 按负载配置切换点 | 固定"难的多想" |
| 信号可测 | 记录信号值事后校验 | 信号是黑盒 |
| 延迟有约束 | 路由选择受延迟预算约束 | 只看效用不看延迟 |
| 路由可审计 | 每次选择有记录 | 无法回放路由决策 |
“延迟有约束"是双过程实验里最容易被忘的一条。效用 5.58 的路由延迟 5.90 秒,如果用户只能等 3 秒,这个"最优"路由根本不可用。双过程的选型永远要同时满足效用和延迟两个约束。
小结
- 快慢路径各有形状:快路径衰减更快,慢路径在难任务上才值回票价。
- 阈值路由用一个参数在两条路径间切换;信号质量决定路由上限。
- 全快和全慢都浪费一半任务;最佳阈值把慢路径留给真正受益的难度。
- 路由效果不单调:把简单任务送去慢路径,花钱多而收益为负。
- 延迟是硬约束,不是能被效用优化掉的目标。
- 双过程是显式路由,元推理是模型自评;可审计要求让双过程更稳。
阅读导航:上一节:5.3 搜索何时值得:成本/质量判据 · 下一节:6.2 元推理:什么时候该想 。
常见错误与边界
- 全快或全慢。 两端都浪费一半任务;正确做法是按难度分路径。
- 越多慢越好。 把简单任务也送去慢路径,边际收益为负,效果还更差。
- 信号不可测。 不记录难度信号,路由错与对都无法判断。
- 只看效用不看延迟。 延迟是硬约束;超预算的路由再"最优"也不可用。
- 全局一个阈值。 W1 与 W3 的难度分布不同,全局阈值会压垮其中一类。
- 把双过程当元推理。 显式路由和模型自评是两种决策机制,别混在一起。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。