《AI Agent 技术原理与架构·决策、记忆与学习》6.2 元推理:什么时候该想

元推理不是“想得越多越好”,而是在不确定性、风险与难度信号下决定何时值得慢想。本节用十个小任务比较全快、全慢、不确定度门、风险门与事后最优的期望成本,拆解信号噪声、阈值误判与失败代价如何改变结论,并给出可落地的路由判据、审计要求与六条常见错误检查。

以下数字均为教学假设,不构成对任何真实系统或供应商的承诺。十个任务的难度、风险、成功率与成本都是固定参数,只用于展示元推理的计算方式。

上一节把决策分成快思考与慢思考两条路径。真正困难的问题不是“慢思考好不好”,而是“这一次该不该慢”。如果每个请求都慢想,延迟和成本会吞掉收益;如果永远快答,高风险任务的一次错误就可能抵消大量节省。元推理要回答的正是这个路由问题:在动作发生之前,用可观测的信号估计“再多想一步值不值”。

这一节不讨论模型内部如何产生思维链,只讨论架构层的一个决策:给定任务信号,选择快路径还是慢路径。读完之后,你应该能为自己的 Agent 写出一条可检查的路由规则,并知道它在什么条件下会失效。

从“要不要想”到元推理

一个常见的直觉是:任务越难,越应该多想。这个直觉只对了一半。慢想提高的是成功率,付出的是额外的计算、延迟和机会成本;是否值得,取决于失败会造成多大损失。

考虑三类任务:

  • W1 检索问答:答错可以重试,失败代价低,慢想的收益通常抵不过延迟预算。
  • W2 代码修复:失败可以回滚,但会浪费一次完整构建,慢想有一定价值。
  • W3 运维处置:重启或扩容不可逆,一次误操作的影响远高于多算几秒,慢想几乎总是值得。

所以元推理的输入至少有三类信号:不确定性(当前答案有多可能错)、风险(错了会怎样)、难度(慢想能把成功率提高多少)。只用一个信号做路由,必然在某个方向上误判。

机制:两档动作与期望成本

把元推理压缩成最小形式:每个任务有两个动作,快路径 $a_f$ 与慢路径 $a_s$。快路径成本低、成功率低;慢路径成本高、成功率高。任务还有一个失败代价 $c_{\text{fail}}$,由风险等级决定。

一次决策的期望成本是:

$$
\mathbb{E}[\text{cost} \mid a] = c(a) + (1 - p(a)) \cdot c_{\text{fail}}
$$

慢想相对快想的额外成本是 $\Delta c = c_s - c_f$,成功率增益是 $\Delta p = p_s - p_f$。只有当

$$
\Delta p \cdot c_{\text{fail}} > \Delta c
$$

时,慢想才划算。等价地,成功率增益必须超过盈亏平衡点:

$$
\Delta p > \frac{\Delta c}{c_{\text{fail}}}
$$

这个不等式解释了为什么“难”不是充分条件。难度影响 $\Delta p$,但风险决定 $c_{\text{fail}}$;同样的成功率增益,在低风险任务上可能一文不值,在高风险任务上却非常值钱。

实验中的参数如下(均为教学设定):

参数值
快路径成本1.0
慢路径成本4.0
低风险失败代价3.0
高风险失败代价20.0
快路径成功率$0.90 - 0.65 \times \text{difficulty}$,截断到 $[0.05, 0.95]$
慢路径成功率快路径成功率加 $0.25 + 0.45 \times \text{difficulty}$,上限 0.98

十个任务覆盖低风险与高风险各五个,难度从 0.08 到 0.90。不确定性信号并不等于真实难度:它带有噪声,用来模拟“模型自报置信”或“离线校准分数”的不完美。

最小实验:五种路由策略

实验比较五种在线策略和一个事后最优基线:

  1. 全快:从不慢想,作为成本下限与质量下限。
  2. 全慢:总是慢想,作为质量上限与成本上限。
  3. 不确定度门:不确定性超过 0.50 就慢想,完全不看风险。
  4. 风险+不确定度:只有高风险且不确定性超过 0.40 才慢想。
  5. 风险优先:高风险一律慢想,低风险一律快答。
  6. 事后最优:知道真实成功率,逐任务选择期望成本更低的一档。
# file: agp_lab/meta_reasoning.py | write
# tier: 3
# verify: python3 -m unittest tests.test_meta_reasoning
"""元推理:用不确定性、风险与难度信号决定是否投入更多推理。

这里的“想”只有两档:快路径一次作答,慢路径多花计算换取更高成功率。
任务带有隐藏难度、风险等级和一个并不完美的难度/不确定度信号。实验比较
几种元推理策略的期望总成本,说明三件事:

1. 是否值得多想,取决于失败的代价,而不只取决于任务难不难;
2. 不确定性信号有噪声时,简单的“高不确定就多想”会同时误判两个方向;
3. 元推理的收益上限由事后最优策略给出,任何在线策略都只能逼近它。
"""
from __future__ import annotations

from dataclasses import dataclass
from typing import Callable

FAST_COST = 1.0
SLOW_COST = 4.0
LOW_RISK_PENALTY = 3.0
HIGH_RISK_PENALTY = 20.0


@dataclass(frozen=True)
class Task:
    name: str
    difficulty: float
    uncertainty: float
    high_risk: bool
    p_fast: float
    p_slow: float

    @property
    def failure_penalty(self) -> float:
        return HIGH_RISK_PENALTY if self.high_risk else LOW_RISK_PENALTY


@dataclass(frozen=True)
class Result:
    name: str
    success: float
    compute_cost: float
    failure_cost: float
    total_cost: float


def clamp(value: float, low: float, high: float) -> float:
    return max(low, min(high, value))


def make_task(
    name: str,
    difficulty: float,
    uncertainty: float,
    high_risk: bool,
) -> Task:
    if not name:
        raise ValueError("任务名不能为空")
    if not 0.0 <= difficulty <= 1.0:
        raise ValueError("difficulty 必须在 [0, 1] 内")
    if not 0.0 <= uncertainty <= 1.0:
        raise ValueError("uncertainty 必须在 [0, 1] 内")
    p_fast = clamp(0.90 - 0.65 * difficulty, 0.05, 0.95)
    p_slow = min(0.98, p_fast + 0.25 + 0.45 * difficulty)
    return Task(name, difficulty, uncertainty, high_risk, p_fast, p_slow)


def task_set() -> tuple[Task, ...]:
    """十个教学任务:难度、风险与信号噪声都是固定值。"""
    return (
        make_task("t01", 0.10, 0.12, False),
        make_task("t02", 0.20, 0.25, False),
        make_task("t03", 0.35, 0.42, False),
        make_task("t04", 0.50, 0.55, False),
        make_task("t05", 0.70, 0.66, False),
        make_task("t06", 0.08, 0.18, True),
        make_task("t07", 0.30, 0.35, True),
        make_task("t08", 0.55, 0.60, True),
        make_task("t09", 0.75, 0.78, True),
        make_task("t10", 0.90, 0.88, True),
    )


def expected_cost(task: Task, slow: bool) -> float:
    """一次决策的期望总成本:计算成本 + 失败概率 × 失败代价。"""
    if slow:
        return SLOW_COST + (1.0 - task.p_slow) * task.failure_penalty
    return FAST_COST + (1.0 - task.p_fast) * task.failure_penalty


def run_policy(
    tasks: tuple[Task, ...],
    name: str,
    decide_slow: Callable[[Task], bool],
) -> Result:
    if not tasks:
        raise ValueError("任务集合不能为空")
    successes = []
    compute = []
    failures = []
    for task in tasks:
        slow = decide_slow(task)
        probability = task.p_slow if slow else task.p_fast
        cost = SLOW_COST if slow else FAST_COST
        successes.append(probability)
        compute.append(cost)
        failures.append((1.0 - probability) * task.failure_penalty)
    count = len(tasks)
    return Result(
        name=name,
        success=sum(successes) / count,
        compute_cost=sum(compute) / count,
        failure_cost=sum(failures) / count,
        total_cost=(sum(compute) + sum(failures)) / count,
    )


def always_fast(task: Task) -> bool:
    return False


def always_slow(task: Task) -> bool:
    return True


def uncertainty_gate(task: Task) -> bool:
    """只看不确定度:高不确定就慢想,忽略风险。"""
    return task.uncertainty >= 0.50


def risk_and_uncertainty_gate(task: Task) -> bool:
    """高风险且不确定度超过阈值才慢想。"""
    return task.high_risk and task.uncertainty >= 0.40


def risk_only_gate(task: Task) -> bool:
    """只看风险:高风险一律慢想。"""
    return task.high_risk


def oracle(task: Task) -> bool:
    """事后最优:知道真实成功率,选期望成本更低的一档。"""
    return expected_cost(task, True) < expected_cost(task, False)


def compare_policies(tasks: tuple[Task, ...]) -> list[Result]:
    policies = (
        ("全快", always_fast),
        ("全慢", always_slow),
        ("不确定度门", uncertainty_gate),
        ("风险+不确定度", risk_and_uncertainty_gate),
        ("风险优先", risk_only_gate),
        ("事后最优", oracle),
    )
    return [run_policy(tasks, name, decide) for name, decide in policies]


def break_even_gain(extra_cost: float, penalty: float) -> float:
    """慢想相对快想至少要提高多少成功率,期望成本才不亏。"""
    if extra_cost < 0:
        raise ValueError("额外成本不能为负")
    if penalty <= 0:
        raise ValueError("失败代价必须为正")
    return extra_cost / penalty


if __name__ == "__main__":
    tasks = task_set()
    baseline = next(item for item in compare_policies(tasks) if item.name == "事后最优")
    print(f"{'策略':<12}{'成功率':>8}{'计算成本':>10}{'失败成本':>10}{'总成本':>10}{'与最优差':>10}")
    for result in compare_policies(tasks):
        regret = result.total_cost - baseline.total_cost
        print(
            f"{result.name:<12}{result.success:>8.3f}{result.compute_cost:>10.3f}"
            f"{result.failure_cost:>10.3f}{result.total_cost:>10.3f}{regret:>10.3f}"
        )
    print()
    print(
        "低风险盈亏平衡增益: "
        f"{break_even_gain(SLOW_COST - FAST_COST, LOW_RISK_PENALTY):.3f}; "
        "高风险: "
        f"{break_even_gain(SLOW_COST - FAST_COST, HIGH_RISK_PENALTY):.3f}"
    )

运行:

cd private/labs/agp-lab
python3 -m agp_lab.meta_reasoning

输出:

策略               成功率      计算成本      失败成本       总成本      与最优差
全快             0.612     1.000     4.865     5.865     2.670
全慢             0.979     4.000     0.250     4.250     1.055
不确定度门          0.872     2.500     1.263     3.763     0.568
风险+不确定度        0.778     1.900     1.545     3.445     0.250
风险优先           0.819     2.500     0.731     3.231     0.036
事后最优           0.806     2.200     0.995     3.195     0.000

低风险盈亏平衡增益: 1.000; 高风险: 0.150

这张表有几个反直觉之处,值得逐条拆开。

第一,全慢的质量最高,但不是最优。 它的成功率 0.979,明显高于事后最优的 0.806,可总成本 4.250 也高于 3.195。多出来的质量主要买在低风险任务上:那里失败代价只有 3.0,慢想多花的 3.0 计算成本几乎必然亏本。低风险的盈亏平衡增益是 1.000,意味着慢想必须把成功率提高 100 个百分点才回本,这在数学上不可能。

第二,不确定度门同时误判了两个方向。 它把低风险但高不确定的 t04、t05 送去慢想,浪费计算;又因为 t07 的不确定性只有 0.35,漏掉了这个高风险且慢想明显划算的任务。它最终的成功率 0.872 甚至高于事后最优,但总成本 3.763 比最优高 0.568。质量更高不等于决策更好,因为质量不是唯一目标。

第三,风险优先几乎贴近最优,但仍有系统性偏差。 它的总成本只比事后最优高 0.036,原因不是风险信号好,而是这组参数下高风险任务的慢想收益普遍超过成本。它仍然会对 t06 这类“高风险但很容易”的任务过度慢想:t06 的慢想成功率高,但只比快路径高 0.132,乘以 20 的失败代价是 2.64,低于 3.0 的额外计算成本,因此事后最优选择快答。风险优先多花了这笔钱。

第四,阈值不是越保守越好。 风险+不确定度策略看起来更谨慎,却因为漏掉 t07 而多付出失败成本,总成本 3.445 高于风险优先的 3.231。加一个信号不等于加一分准确;信号有噪声时,多一个与结论弱相关的条件,可能只是多一个误判来源。

这四条结论只在给定参数下成立。换一组成本或失败代价,最优策略会变。形式模型的价值不是背结论,而是让你能算出当前参数下的盈亏平衡点,并检查路由规则有没有越过它。

边界与失败模式

元推理模型很小,失败模式却很具体。

成本模型错。 上面的 $\Delta c$ 只算了一次推理的账单。真实系统里还有排队、超时重试、占用并发配额和用户等待的代价;如果慢路径把 p95 推出预算,它的真实成本远高于账单。路由决策必须使用含延迟与资源占用的成本,而不是单纯的 token 价格。

不确定性信号未校准。 模型自报的“我有 80% 把握”通常不是概率。把自报置信直接塞进期望成本公式,会把路由建立在错误的数值上。可用的信号应该是离线校准后的分数、检索覆盖率、工具返回的完整性标记,或者多次采样的一致性;并且要有校准曲线和拒答阈值作为证据。

风险分类漏判。 元推理通常先用分类器判断风险等级,再决定是否慢想。如果风险分类器把“不可逆的退款”误判为低风险,再好的路由规则也救不回来。高风险动作应该默认走最保守路径,并保留人工审批,而不是把全部责任交给一个概率阈值。

慢想不一定有效。 公式假设 $p_s > p_f$,但同源模型的多想可能只是在同一个错误方向上重复。对 W2 这类需要外部证据的任务,慢想必须绑定新的工具调用、测试执行或独立验证,否则只是更长的错误推理。

路由本身有成本。 计算不确定性、判断风险、估计难度都要额外的模型调用或规则执行。如果路由开销接近一次快路径,那么“省下来的思考”可能还不够支付路由。

单步模型不覆盖长任务。 这里只决定一次是否慢想。真实 Agent 会在几十步里反复遇到这个决策,前面慢想得到的中间结论可能让后面不再需要慢想,也可能因为上下文被压缩而失效。多步元推理需要把信念状态和剩余预算一起纳入。

架构含义

把上面的机制落到系统,至少有五条要求:

  1. 把路由做成显式组件。 不要用一句“必要时深入思考”的提示词代替路由。路由器的输入、阈值、输出和降级路径都应该是可检查的配置。
  2. 用期望成本而不是难度做目标。 路由分数至少包含成功率增益、额外成本与失败代价三项;没有失败代价的任务,默认不值得慢想。
  3. 把风险等级作为一等输入。 可逆性、影响范围、是否需要审批,应该由工具 schema 或动作策略声明,而不是让模型临场判断。
  4. 记录路由决策与事后结果。 每次路由要留下信号、阈值、选择了哪条路径、实际成功率与成本。没有这些记录,你无法判断阈值该往哪边调。
  5. 给慢想设预算与降级。 慢路径也要有 token、时间、步数上限;达到上限时返回带不确定性标记的部分结果,而不是无限延长。

这五条也可以用判据表来检查:

判据合格的样子不合格的样子
信号不确定性、风险、难度分开采集并校准只看模型自报置信
目标期望成本 = 计算 + 失败概率 × 影响只追求成功率
风险不可逆动作默认慢路径并审批风险由模型临场判断
审计每次路由记录信号、阈值、结果只记录最终答案
预算慢路径有上限和降级结果慢想无边界

小结

  • 元推理的核心不是“多想”,而是“在什么条件下多想才划算”。
  • 是否慢想由成功率增益、额外成本和失败代价共同决定;难度只是其中一个输入。
  • 低风险任务的盈亏平衡增益可能高到不可能达到,高风险任务则相反。
  • 只按不确定度路由会同时过度慢想和漏掉该慢想的任务;多一个噪声信号不一定更好。
  • 风险优先在特定参数下接近最优,但它仍会对“高风险但很容易”的任务过度慢想。
  • 生产系统里要把路由做成显式组件,记录决策与结果,并给慢路径设置预算和降级。

阅读导航:上一节:6.1 双过程:快思考与慢思考 · 下一节:6.3 延迟/质量/成本的三角 。

常见错误与边界

  1. 把“难”等同于“该想”。 难度只影响慢想的收益,不决定失败代价;低风险难题慢想仍然可能亏本。
  2. 把模型自报置信当概率。 未校准的置信分数会让期望成本公式输出看似精确、实际错误的路由。
  3. 忽略失败代价。 只比较成功率和 token 成本,等于假设所有错误一样便宜;W3 的一次误操作可能抵消整月的节省。
  4. 全站统一阈值。 不同负载的延迟预算、失败代价和可逆性不同,同一个阈值不可能同时适合 W1、W2、W3。
  5. 只优化质量。 全慢策略在这组实验里质量最高,但总成本比事后最优高 1.055;质量不是唯一目标。
  6. 不记录路由结果。 没有信号、选择与事后结果的对应关系,阈值调整只能靠猜,也无法做反事实评估。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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