《AI Agent 技术原理与架构·决策、记忆与学习》5.3 搜索何时值得:成本/质量判据

前两节讲了搜索怎么做,这一节讲什么时候根本不该搜。搜索用预算换成功率,但成功率提升递减、成本线性增长。本节用期望效用把成功率、失败代价与搜索成本折成一个数字,演示为每条任务算出最优预算,并给出“边际增益为负就不搜”的判据与适用边界,避免为低概率高成本任务过度搜索。

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

前两节回答了"从哪里搜、怎么选路径",这一节回答一个更前置的问题:这条任务要不要搜。搜索不是免费的——它花预算、花延迟,换的是成功率。如果快路径的成功率已经够高,搜索的收益就是递减的;如果失败代价很低,搜索省下的损失也有限。

这一节把搜索建模成"快路径 + 可选预算"的两段式,用期望效用把成功率、失败代价与搜索成本折成一个数字,然后给出判据:当搜索的边际增益为负,就停止加预算。

搜索的成本结构

模型只有两条路:快路径直接给答案,慢路径花预算做搜索。三条基本事实决定一切:

  1. 成功率提升递减:预算翻倍,成功率提升不是翻倍,而是趋近上限;
  2. 成本线性增长:预算每加一单位,成本加固定值;
  3. 失败有代价:失败不是"没得分",而是返工、事故或误操作。

这三条合起来的意思是:存在一个最优预算,超过它,多花的成本买不来等值的成功率;甚至存在一个预算点,超过它总效用开始下降。

期望效用怎么算

把收益、失败代价与成本折成一个数字:

$$
U = s \cdot V - (1 - s) \cdot C - \text{cost}
$$

其中 $s$ 是成功率,$V$ 是成功价值,$C$ 是失败代价,cost 是搜索成本。这个公式的好处是让不同方案可以比较:快路径是一个点,每个预算是一个点,直接比效用大小。

效用公式里三个量缺一不可。只看成功率,你会为 99.9% 花掉所有预算;只看成本,你会错过搜索带来的收益;不看失败代价,你会低估搜索对高风险任务的价值。

最小实验:三档难度

下面的实验把任务分成 easy(快路径 0.90)、medium(0.65)、hard(0.40)三档,为每档计算最优预算,并打印 medium 档的完整预算曲线。

# file: agp_lab/search_cost.py | write
# tier: 3
# verify: python3 -m unittest tests.test_search_cost
"""搜索何时值得:预算、成功率与成本的最小判据。

模型只有两条路:快路径直接给答案,慢路径花预算做搜索。搜索预算越高,
成功率越高,但提升是递减的;成本随预算线性增长。把成功率、失败代价和
搜索成本折成一个期望效用,就能算出每条任务的最优预算,以及“搜索的
边际收益是否够付它的成本”。

所有参数均为教学假设,不是生产测量值。
"""
from __future__ import annotations

import math
from dataclasses import dataclass

VALUE = 10.0          # 一次成功的任务价值
FAILURE_COST = 8.0    # 一次失败的返工 / 事故代价
FAST_COST = 0.5       # 快路径的固定成本
STEP_COST = 0.05      # 每个搜索预算单位的成本
SEARCH_SCALE = 6.0    # 搜索预算的收益尺度
MIN_GAIN = 1.0        # 采纳搜索所需的最小期望收益(10% 的任务价值)

BUDGETS = (0, 1, 2, 4, 8, 16, 32, 64)


def search_success(fast_success: float, budget: int, scale: float = SEARCH_SCALE) -> float:
    """给定快路径成功率与搜索预算,返回搜索后的成功率。

    budget=0 时等于快路径成功率;预算增大时以指数方式逼近 1。
    """
    if not 0.0 <= fast_success <= 1.0:
        raise ValueError("fast_success 必须在 [0, 1] 内")
    if budget < 0:
        raise ValueError("budget 不能为负")
    if scale <= 0:
        raise ValueError("scale 必须为正")
    success = fast_success + (1.0 - fast_success) * (1.0 - math.exp(-budget / scale))
    return min(success, 1.0 - 1e-9)


def utility(success: float, cost: float) -> float:
    """期望效用:成功收益 − 失败代价 − 成本。"""
    if not 0.0 <= success <= 1.0:
        raise ValueError("success 必须在 [0, 1] 内")
    if cost < 0:
        raise ValueError("cost 不能为负")
    return success * VALUE - (1.0 - success) * FAILURE_COST - cost


def fast_utility(fast_success: float) -> float:
    return utility(fast_success, FAST_COST)


@dataclass(frozen=True)
class BudgetRow:
    budget: int
    success: float
    cost: float
    utility: float
    gain_over_fast: float
    marginal_gain: float


def curve(fast_success: float, budgets: tuple[int, ...] = BUDGETS) -> list[BudgetRow]:
    """输出每个预算档位的成功率、成本与相对快路径的收益。"""
    baseline = fast_utility(fast_success)
    rows: list[BudgetRow] = []
    previous = baseline
    for budget in budgets:
        success = search_success(fast_success, budget)
        cost = FAST_COST + budget * STEP_COST
        value = utility(success, cost)
        rows.append(
            BudgetRow(
                budget=budget,
                success=success,
                cost=cost,
                utility=value,
                gain_over_fast=value - baseline,
                marginal_gain=value - previous,
            )
        )
        previous = value
    return rows


@dataclass(frozen=True)
class Decision:
    fast_success: float
    best_budget: int
    best_success: float
    best_cost: float
    best_utility: float
    gain_over_fast: float
    should_search: bool


def decide(
    fast_success: float,
    budgets: tuple[int, ...] = BUDGETS,
    min_gain: float = MIN_GAIN,
) -> Decision:
    """选择期望效用最高的预算;增益不足 min_gain 时建议不搜索。"""
    if min_gain < 0:
        raise ValueError("min_gain 不能为负")
    rows = curve(fast_success, budgets)
    best = max(rows, key=lambda row: (row.utility, -row.budget))
    return Decision(
        fast_success=fast_success,
        best_budget=best.budget,
        best_success=best.success,
        best_cost=best.cost,
        best_utility=best.utility,
        gain_over_fast=best.gain_over_fast,
        should_search=best.gain_over_fast >= min_gain,
    )


if __name__ == "__main__":
    levels = (("easy", 0.90), ("medium", 0.65), ("hard", 0.40))
    print(f"{'难度':<8}{'快路径':>8}{'最优预算':>10}{'成功率':>10}"
          f"{'成本':>8}{'效用提升':>10}{'搜索':>6}")
    for name, fast_success in levels:
        decision = decide(fast_success)
        print(
            f"{name:<8}{fast_success:>8.2f}{decision.best_budget:>10}"
            f"{decision.best_success:>10.3f}{decision.best_cost:>8.2f}"
            f"{decision.gain_over_fast:>10.2f}"
            f"{'yes' if decision.should_search else 'no':>6}"
        )
    print()
    print(f"{'预算':<6}{'成功率':>10}{'成本':>8}{'效用':>8}{'边际增益':>10}")
    for row in curve(0.65):
        print(
            f"{row.budget:<6}{row.success:>10.3f}{row.cost:>8.2f}"
            f"{row.utility:>8.2f}{row.marginal_gain:>10.2f}"
        )

运行:

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

输出:

难度           快路径      最优预算       成功率      成本      效用提升    搜索
easy        0.90         8     0.974    0.90      0.93    no
medium      0.65        16     0.976    1.30      5.06   yes
hard        0.40        16     0.958    1.30      9.25   yes

预算           成功率      成本      效用      边际增益
0          0.650    0.50    3.20      0.00
1          0.704    0.55    4.12      0.92
2          0.749    0.60    4.89      0.77
4          0.820    0.70    6.07      1.18
8          0.908    0.90    7.44      1.37
16         0.976    1.30    8.26      0.82
32         0.998    2.10    7.87     -0.39
64         1.000    3.70    6.30     -1.57

这张表是"搜索何时值得"的完整答案。

easy 不值得搜。 快路径 0.90,搜索到预算 8 能把成功率提到 0.974,效用提升只有 0.93,低于采纳阈值(任务价值的 10%),判为 no。快路径已经够好的任务,搜索是纯开销。

hard 最值得搜。 快路径 0.40 意味着 60% 的任务会失败;搜索到 16 把成功率提到 0.958,效用提升 9.25。失败代价高 + 快路径差 = 搜索收益大,这是搜索最该发生的组合。

边际增益会变负。 medium 档的曲线看得很清楚:预算从 8 加到 16,效用从 7.44 升到 8.26(+0.82);从 16 加到 32,效用反而降到 7.87(−0.39)。成功率确实还在涨(0.976 → 0.998),但多花的成本超过了多避免的失败。这就是"最优预算"的含义:不是成功率最高的预算,是效用最高的预算。

最优预算 vs 最大预算

三个容易混淆的概念:

概念定义用途
最大预算允许的上限运行时兜底,防失控
最优预算效用最高的档位事前规划,决定分配
边际增益每加一档的效用变化事中判断,是否该停

最大预算管"绝对不能超过",最优预算管"应该花多少",边际增益管"还要不要继续"。三者不必相等:最优预算通常远小于最大预算。把最大预算当默认预算,等于把兜底当方案,会在大部分任务上过度搜索。

关键判据:边际增益为负就停

工程上最可用的判据是一条简单规则:当边际增益为负,停止加预算。判断过程是:

  1. 用历史数据估快路径成功率;
  2. 用固定成本模型算每个预算档的期望效用;
  3. 找到效用峰值,超过峰值的预算不采;
  4. 事前定一个最小增益阈值,低于它不启用搜索。

第 4 条防止"有点提升就搜"。提升 0.5% 但延迟翻倍,通常不值得;阈值把"统计上有效"和"业务上值得"分开。

搜索决策的边界

这个判据有三个必须承认的边界:

  1. 成功率估计可能不准。 快路径成功率来自历史或人工估计,偏差会直接改变最优预算。
  2. 失败代价因任务而异。 W3 的失败代价远高于 W1;用全局一个 $C$ 会系统性误导。
  3. 延迟成本没有进效用。 效用公式里没有延迟项;延迟敏感任务要在成本里显式加权。

第 3 点对 Agent 很关键。效用公式把"成本"当成了钱和算力,但时间也是资源。如果一个搜索让 W1 的 p95 从 8 秒涨到 30 秒,即使效用数字变正,用户也会流失。延迟应该作为一项独立的约束,而不是被效用吸收。

架构含义

搜索决策对架构有三个直接约束:

  1. 快路径要可测。 没有快路径成功率的历史统计,最优预算就是拍脑袋。
  2. 成本模型要存在。 每个搜索预算档的成本必须能算,否则无法构造效用曲线。
  3. 决策是事前的。 在启动任务前决定"搜不搜、搜到哪档",运行中只做边际增益检查。

第 3 条把"搜索预算"和"运行时可配"分开:事前定最优预算,事中检查边际增益,事后审计实际花销。三层分离,搜索决策才可回归。

架构判据

判据合格的样子不合格的样子
效用可算成功率、失败代价、成本都有数只说"搜得更深更准"
最优预算按档位扫描取效用峰值固定一个预算常数
边际检查事中看边际增益一口气跑满预算
延迟入账时间作为约束或加权成本效用里只有钱
阈值显式最小增益可配有提升就搜

“边际检查"是可以自动化的:每条任务在预算档之间迁移时检查效用变化,为负就停。这比"固定预算"稳健得多,因为它跟着任务难度走。

小结

  • 搜索用预算换成功率,但成功率提升递减、成本线性增长,所以存在最优预算。
  • 期望效用把成功率、失败代价与成本折成一个可比较的数字。
  • easy 任务不值得搜,hard 任务最值得搜:快路径越差、失败代价越高,搜索收益越大。
  • 最优预算不是成功率最高的预算,是效用最高的预算;超过它效用反而下降。
  • 最大预算管上限,最优预算管分配,边际增益管停止。
  • 延迟是独立约束不是效用的一项;成功率估计不准会直接歪曲最优预算。

阅读导航:上一节:5.2 MCTS:价值估计与探索 · 下一节:6.1 双过程:快思考与慢思考 。

常见错误与边界

  1. 预算越大越好。 边际增益会变负;超过最优档,多花的成本买不来等值成功率。
  2. 只看成功率。 不看失败代价与成本,99.9% 的目标会吃掉所有预算。
  3. 把最大预算当默认。 兜底不是方案;最优预算通常远小于上限。
  4. 全局一个失败代价。 W3 与 W1 的代价差一个数量级,用全局 C 会系统性误判。
  5. 效用里没有延迟。 延迟是独立约束;时间敏感任务按效用决策会流失用户。
  6. 事后才定预算。 没有历史成功率与成本模型,最优预算只能靠拍脑袋。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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