《AI Agent 技术原理与架构·决策、记忆与学习》4.3 重规划:局部修复 vs 全盘重来

失效范围决定重规划策略。本节把计划看成带依赖的步骤图,用失效闭包界定局部修复的边界,并用规划成本、二次失败风险与回退成本计算局部修复和全盘重来的期望成本。实验显示小范围局部修复更优,范围扩大后全盘重来同时赢回成本与可靠性,最后在 W1/W2/W3 上给出不同策略与五条架构判据。

以下数字均为教学假设,不构成对任何真实系统或供应商的承诺。步骤数、单位成本与陈旧风险只用于展示计算方式,不代表任何生产环境的最优配置。

计划失败之后,Agent 面对的第一个问题不是“下一步做什么”,而是“哪些已经做过的事还算数”。回答错了,会出现两种典型事故:一种是明明只坏了一步,却把整条计划推倒重来,浪费了已经验证过的进度;另一种是只补了眼前那一步,却把依赖它的下游步骤留在原地,让一个局部错误扩散成系统性错误。

这一节把“重规划”拆成两个可计算的量:失效范围与策略成本。前者决定必须重做多少,后者决定局部修复和全盘重来哪个更划算。读完这一节,你应该能对一个重规划实现问出四个问题:失效闭包怎么算、局部修复的边界在哪、陈旧假设怎么检测、回退路径是否显式。

失效范围不是失败的那一步

计划通常不是一条直线,而是一张有依赖的图。修完数据库迁移脚本,依赖它的数据回填、索引重建、报表校验都可能失效;反过来,同一批里互不依赖的另一个任务可能完全不受影响。所以“哪一步失败了”不足以决定重做范围,真正需要的是失效闭包:失败步骤本身,加上所有直接或间接依赖它的步骤。

用集合语言写,给定依赖关系 $D$($s \to t$ 表示 $t$ 依赖 $s$)和失败集合 $F$,失效闭包 $C(F)$ 是包含 $F$ 且对反向依赖封闭的最小集合:

$$
C(F) = F \cup { t \mid \exists s \in C(F),\ s \to t }
$$

这个定义有两个工程含义。第一,闭包必须由机器可计算的依赖图得出,不能靠模型回忆“大概还影响了哪些文件”。第二,依赖图本身可能是残缺的;闭包算得再准,也只能覆盖你声明过的边。后者正是局部修复最大的风险来源。

对象含义常见错误
失败步骤直接报错或验证不通过的那一步把它当成全部失效范围
失效闭包失败步骤加全部传递依赖者只重跑直接下游一层
陈旧步骤依赖已变化、但未被重做的步骤默认未报错就是没受影响
回退路径局部修复失败后回到全盘重来的方式没有回退,只能人工介入

两种策略的成本结构

把计划写成 $n$ 个步骤,每个步骤的规划成本为 $c_p$,执行成本为 $c_e$。一次失败发生在第 $f$ 步,失效范围为 $k$ 步($1 \le k \le n$)。

局部修复只重规划并重执行这 $k$ 步,成本是 $k(c_p + c_e)$。但它有一个隐含假设:失效闭包是完整的。如果依赖图漏掉了一些耦合,残留的 $k$ 个步骤之间可能存在未被检查的关系。把这类漏检建模为“每对步骤以概率 $q$ 漏掉”,则至少漏掉一对的概率是:

$$
r(k) = 1 - (1-q)^{k(k-1)/2}
$$

局部修复的成功率因此是 $p^k(1-r(k))$,其中 $p$ 是单步成功率。若陈旧假设导致二次失败,还要加上回退成本:重规划全部 $n$ 步,再执行剩余 $k$ 步。

全盘重来重规划全部 $n$ 步,但只重执行剩余后缀,成本是 $n c_p + k c_e$,成功率是 $p^k$。它更贵,但没有陈旧假设。

这两个式子解释了一个常被忽略的事实:局部修复的成本优势来自少规划,而不是少执行。失效范围越大,省下的规划成本越少,而陈旧风险按 $k(k-1)/2$ 增长。优势消失的速度比直觉快得多。

变量局部修复全盘重来
规划步骤数$k$$n$
执行步骤数$k$$k$
成功率$p^k(1-r(k))$$p^k$
二次失败处理回退到全盘重来不存在
主要风险失效闭包不完整浪费已验证进度

最小实验:让失效范围从 1 走到 8

下面的实验固定 $n=8$、$p=0.95$、$q=0.02$、$c_p=c_e=1$,让失效范围从 1 逐步走到 8,计算两种策略的期望成本与成功率。代码同时实现了一个通用的失效闭包函数,供依赖图使用。

# file: agp_lab/replanning.py | write
# tier: 3
# verify: python3 -m unittest tests.test_replanning
"""重规划的最小成本模型:局部修复 vs 全盘重来。

把计划看成一串有依赖的步骤。一次失败会通过依赖关系传播失效范围:
直接失效的步骤加上所有传递依赖它的步骤。局部修复只重规划失效范围内的
步骤;全盘重来重规划整条计划。局部修复更便宜,但它对失效范围的估计
可能不完整,残留的陈旧步骤会以一定概率导致二次失败。

模型只回答一个问题:在多长的失效范围上,哪种策略的期望成本更低。
所有参数均为教学假设,不是生产测量值。
"""
from __future__ import annotations

from dataclasses import dataclass

# 每个步骤的规划成本与执行成本(教学单位)。
PLAN_COST_PER_STEP = 1.0
EXEC_COST_PER_STEP = 1.0

# 每对“本应一起检查却没有检查”的步骤带来的陈旧风险。
STALE_RISK_PER_PAIR = 0.02

DEFAULT_STEPS = 8
DEFAULT_STEP_SUCCESS = 0.95


def invalidation_closure(dependencies: dict[str, set[str]], failed: set[str]) -> set[str]:
    """返回失败步骤的失效闭包:failed 本身加上所有传递依赖它们的步骤。

    dependencies[node] 是 node 依赖的节点集合。依赖边方向为
    “被依赖者 -> 依赖者”,因此失效沿反向依赖传播。
    """
    closure = set(failed)
    changed = True
    while changed:
        changed = False
        for node, deps in dependencies.items():
            if node in closure:
                continue
            if deps & closure:
                closure.add(node)
                changed = True
    return closure


def staleness_risk(scope: int, per_pair: float = STALE_RISK_PER_PAIR) -> float:
    """局部修复在 scope 个步骤上漏检一对耦合的概率折算。

    scope 个步骤之间最多有 scope*(scope-1)/2 对潜在耦合;每对独立漏检
    概率为 per_pair,至少漏掉一对的概率为 1-(1-per_pair)^pairs。
    """
    if scope < 0:
        raise ValueError("scope 不能为负")
    if not 0.0 <= per_pair <= 1.0:
        raise ValueError("per_pair 必须在 [0, 1] 内")
    pairs = scope * (scope - 1) // 2
    return 1.0 - (1.0 - per_pair) ** pairs


def local_repair(
    total_steps: int,
    scope: int,
    step_success: float = DEFAULT_STEP_SUCCESS,
    per_pair: float = STALE_RISK_PER_PAIR,
) -> tuple[float, float]:
    """局部修复的(期望成本, 成功率)。

    成本 = 失效范围内的规划与执行 + 二次失败后回退全盘重来的期望成本。
    """
    if total_steps <= 0:
        raise ValueError("total_steps 必须为正")
    if not 1 <= scope <= total_steps:
        raise ValueError("scope 必须在 [1, total_steps] 内")
    risk = staleness_risk(scope, per_pair)
    direct_cost = scope * (PLAN_COST_PER_STEP + EXEC_COST_PER_STEP)
    fallback = total_steps * PLAN_COST_PER_STEP + scope * EXEC_COST_PER_STEP
    cost = direct_cost + risk * fallback
    success = step_success**scope * (1.0 - risk)
    return cost, success


def full_replan(
    total_steps: int,
    scope: int,
    step_success: float = DEFAULT_STEP_SUCCESS,
) -> tuple[float, float]:
    """全盘重来的(成本, 成功率):重规划全部步骤,只重执行剩余后缀。"""
    if total_steps <= 0:
        raise ValueError("total_steps 必须为正")
    if not 1 <= scope <= total_steps:
        raise ValueError("scope 必须在 [1, total_steps] 内")
    if not 0.0 <= step_success <= 1.0:
        raise ValueError("step_success 必须在 [0, 1] 内")
    cost = total_steps * PLAN_COST_PER_STEP + scope * EXEC_COST_PER_STEP
    return cost, step_success**scope


@dataclass(frozen=True)
class Row:
    scope: int
    local_cost: float
    full_cost: float
    local_success: float
    full_success: float
    cheaper: str
    more_reliable: str


def compare(
    total_steps: int = DEFAULT_STEPS,
    step_success: float = DEFAULT_STEP_SUCCESS,
    per_pair: float = STALE_RISK_PER_PAIR,
) -> list[Row]:
    """比较失效范围 1..total_steps 上的两种策略。"""
    rows: list[Row] = []
    for scope in range(1, total_steps + 1):
        local_cost, local_success = local_repair(total_steps, scope, step_success, per_pair)
        full_cost, full_success = full_replan(total_steps, scope, step_success)
        cheaper = "local" if local_cost <= full_cost else "full"
        if abs(local_success - full_success) < 1e-12:
            better = "tie"
        elif local_success > full_success:
            better = "local"
        else:
            better = "full"
        rows.append(
            Row(
                scope=scope,
                local_cost=local_cost,
                full_cost=full_cost,
                local_success=local_success,
                full_success=full_success,
                cheaper=cheaper,
                more_reliable=better,
            )
        )
    return rows


if __name__ == "__main__":
    print(f"{'失效范围':<8}{'局部成本':>10}{'全盘成本':>10}"
          f"{'局部成功率':>12}{'全盘成功率':>12}{'成本更优':>10}")
    for row in compare():
        print(
            f"{row.scope:<8}{row.local_cost:>10.3f}{row.full_cost:>10.3f}"
            f"{row.local_success:>12.3f}{row.full_success:>12.3f}{row.cheaper:>10}"
        )

运行:

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

输出:

失效范围          局部成本      全盘成本       局部成功率       全盘成功率      成本更优
1            2.000     9.000       0.950       0.950     local
2            4.200    10.000       0.884       0.902     local
3            6.647    11.000       0.807       0.857     local
4            9.370    12.000       0.722       0.815     local
5           12.378    13.000       0.632       0.774     local
6           15.660    14.000       0.543       0.735      full
7           19.186    15.000       0.457       0.698      full
8           22.912    16.000       0.377       0.663      full

这张表有三个交叉点,每个都对应一个架构决策。

成本交叉点在 $k=6$。 失效范围为 5 时,局部修复还要 12.378,全盘重来要 13;到 6 时局部修复涨到 15.660,全盘重来反而降到 14。原因是全盘重来的规划成本固定为 8,执行成本随剩余后缀线性下降;局部修复的成本却同时受执行步数和二次失败回退概率推动。范围一大,局部修复省下的规划成本抵不过回退风险。

可靠性交叉点在 $k=1$ 之后。 只有失效范围为 1 时,两种策略的成功率相同,都是 0.950。从 $k=2$ 开始,局部修复的成功率就低于全盘重来,因为陈旧风险 $r(k)$ 开始非零。到 $k=8$ 时,局部修复的 0.377 与全盘重来的 0.663 相差 28.6 个百分点。

成本更优不等于应该选。 在 $k=5$ 时局部修复仍便宜 0.622 个单位,但成功率低 14.2 个百分点。如果一次任务失败的代价远高于几个规划单位,这个“更便宜”没有意义。实验里的成本只包含规划、执行和回退,不含任务失败的业务损失;真实决策必须把失败代价加进来。

还有一个容易被表格掩盖的假设:$r(k)$ 用的是均匀的每对漏检概率。真实系统里,关键依赖漏一次就可能致命,非关键依赖漏十次也无所谓。把 $q$ 换成按依赖边加权的风险,结论的方向不变,但交叉点的位置会移动。不要记住 $k=6$ 这个数字,要记住交叉点由成本结构决定。

落到三条负载

三条负载对重规划的要求完全不同,不能套同一个策略。

负载失效范围特征推荐策略关键约束
W1 检索问答只读、步骤少、失败可重试局部修复或直接重试引用一致性;重试不能改变已引用的事实
W2 代码修复依赖链长,测试与构建传播失效小范围局部修复,范围大时切分支重来必须能回滚到干净分支;测试是最终判据
W3 运维处置动作不可逆,副作用已发生优先全盘重来或人工审批失效范围包含已执行副作用;不能靠“补一步”掩盖

W1 的局部修复通常最安全,因为动作只读,最坏结果是多查一次。W2 的关键是先算清代码依赖与测试影响面:改一个函数可能只影响三个测试,也可能影响整个构建。W3 则相反,失效范围不只是“还要做哪些步骤”,还包括“已经做的哪些副作用需要补偿”;这类补偿往往不能由局部修复自动完成。

重规划的判据

把上面的分析压缩成五条可检查的判据:

判据合格的样子不合格的样子
失效闭包由依赖图计算,可列出每个受影响步骤靠模型回忆“大概影响哪些文件”
局部边界明确哪些步骤重规划、哪些复用只重做报错的那一步
陈旧检测复用步骤带版本或前置条件校验默认“没报错就没受影响”
回退路径局部修复失败可自动切全盘重来失败后只能人工介入
成本口径含规划、执行、回退与失败代价只比较调用次数或 token

这五条也解释了为什么“重规划”不是提示词里加一句“如果失败就重新计划”。它是一个有状态、有依赖图、有回退路径的运行时机制。模型可以提出修复方案,但失效闭包、复用边界和回退决策必须由运行时计算。

小结

  • 重规划的第一步是算失效闭包,不是重写计划;失败的那一步通常只是闭包的一部分。
  • 局部修复省的是规划步骤,不是执行步骤;失效范围越大,省下的越少,陈旧风险越高。
  • 实验里成本交叉点在 $k=6$:小范围局部修复更便宜,大范围全盘重来同时赢回成本与可靠性。
  • 成本更优不等于应该选;失败代价必须进入决策口径。
  • W1 可局部重试,W2 要看依赖与测试影响面,W3 必须把已执行副作用纳入失效范围。
  • 重规划是运行时机制:闭包可计算、边界可复用、陈旧可检测、回退可执行。

阅读导航:上一节:4.2 HTN/PDDL · 下一节:5.1 树搜索与 Beam 。

常见错误与边界

  1. 把失败步骤当失效范围。 失败的那一步只是入口;依赖它的下游步骤才是大部分重做成本。
  2. 只重跑直接下游一层。 失效会沿依赖链传递;只补一层,等于把问题推给下一次运行。
  3. 把局部修复当免费。 它省下规划成本,但引入了陈旧假设风险;范围越大,风险增长越快。
  4. 没有回退路径。 局部修复失败后如果只能人工介入,期望成本里就漏掉了最贵的一段。
  5. 用统一策略处理三条负载。 W1 可以重试,W2 需要回滚,W3 涉及不可逆副作用;同一套阈值不成立。
  6. 把交叉点当固定数字。 实验里的 $k=6$ 只属于这组参数;成本结构变了,交叉点就会移动。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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