《AI Agent 技术原理与架构·决策、记忆与学习》6.1 双过程:快思考与慢思考

同一个 Agent 不该用同一套模型处理所有任务:简单的用快路径,难的用慢路径。本节把任务按难度分档,用阈值路由实验比较全快、全慢与按阈值路由的成功率、成本、延迟与期望效用,说明快慢路径的切换点取决于难度信号的质量,并给出元推理之外的架构判据。

以下数字为教学示例,不构成对任何真实系统或供应商的承诺。

“让 Agent 多想一点"听起来总是对的,实际上不是。对简单任务多花 8 秒、4 倍成本去"深思”,收益是负的;对困难任务只花 0.5 秒快速作答,失败率会高到不可接受。问题的关键不是"想还是不想",而是知道该想还是不该想。

这一节用双过程(dual-process)框架讨论这个问题:快路径便宜、快,但成功率随难度下降;慢路径贵、慢,但在高难度上更好。一个阈值路由器按难度信号在两者之间选择。实验比较全快、全慢、按阈值路由三种策略,以及一个"逐档选最优"的 oracle 上界。

双过程的代价结构

两个路径各有形状:

路径成本延迟成功率
快路径低低简单任务高,难任务低
慢路径高高高难度任务更好

快路径不是"差",是在不同难度上衰减得更快。慢路径也不是"好",是在高难度上才值回票价。双过程设计的目标不是全快或全慢,而是让每一档难度的任务走效用更高的路径。

阈值路由

最简单的双过程实现是阈值路由:估一个难度信号,低于阈值走快路径,高于阈值走慢路径。难度信号可以是模型自评的置信度、任务的特征维度,或外部指标(比如这次查询包含多少个约束)。

阈值路由有两条天然的性质:

  1. 只有一个参数(阈值),容易调、容易解释;
  2. 切换点集中,不会出现同一档难度时而快时而慢。

但阈值路由的质量取决于信号的质量:信号把任务分错档,路由就把任务分错路径。信号太粗(比如"所有问题都难"),阈值路由退化成全慢。

最小实验:六档难度的路由

下面的实验把任务按难度 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 是"信号完美"的上界;真实信号只会比它差。工程上需要做的是离线度量信号与难度的相关性,而不是假设难度估计可靠。

双过程与元推理的分工

双过程和下一节的元推理容易混淆。简单区分:

  • 双过程:路由是显式的、可调的,由系统规则决定走哪条路径;
  • 元推理:模型自己判断"该不该多想",判断本身来自模型输出。

双过程把"该走哪条路"从模型手里拿过来,变成一个可配置的架构决策。它牺牲了一点灵活性(不能用模型判断),换来的是确定性(同样输入同样路径)和可审计性(路由记录可回放)。对可靠性要求高的场景,这通常是更稳的选择。

架构含义

双过程对架构有三个直接约束:

  1. 快慢路径要有同一接口。 调用方不关心走哪条,只关心拿到结果;切换由路由层完成。
  2. 难度信号要可测。 路由决策要记录信号值,才能事后度量信号质量。
  3. 阈值按负载配置。 W1 的阈值和 W3 的阈值不同;全局一个阈值会让某类负载受损。

第 2 条最常被跳过。不记录"为什么这条走了快路径",就没法知道是路由正确还是信号失效。

架构判据

判据合格的样子不合格的样子
快慢分层两种路径显式存在一个模型应付所有难度
阈值可调按负载配置切换点固定"难的多想"
信号可测记录信号值事后校验信号是黑盒
延迟有约束路由选择受延迟预算约束只看效用不看延迟
路由可审计每次选择有记录无法回放路由决策

“延迟有约束"是双过程实验里最容易被忘的一条。效用 5.58 的路由延迟 5.90 秒,如果用户只能等 3 秒,这个"最优"路由根本不可用。双过程的选型永远要同时满足效用和延迟两个约束。

小结

  • 快慢路径各有形状:快路径衰减更快,慢路径在难任务上才值回票价。
  • 阈值路由用一个参数在两条路径间切换;信号质量决定路由上限。
  • 全快和全慢都浪费一半任务;最佳阈值把慢路径留给真正受益的难度。
  • 路由效果不单调:把简单任务送去慢路径,花钱多而收益为负。
  • 延迟是硬约束,不是能被效用优化掉的目标。
  • 双过程是显式路由,元推理是模型自评;可审计要求让双过程更稳。

阅读导航:上一节:5.3 搜索何时值得:成本/质量判据 · 下一节:6.2 元推理:什么时候该想 。

常见错误与边界

  1. 全快或全慢。 两端都浪费一半任务;正确做法是按难度分路径。
  2. 越多慢越好。 把简单任务也送去慢路径,边际收益为负,效果还更差。
  3. 信号不可测。 不记录难度信号,路由错与对都无法判断。
  4. 只看效用不看延迟。 延迟是硬约束;超预算的路由再"最优"也不可用。
  5. 全局一个阈值。 W1 与 W3 的难度分布不同,全局阈值会压垮其中一类。
  6. 把双过程当元推理。 显式路由和模型自评是两种决策机制,别混在一起。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图