《AI Agent 技术原理与架构·决策、记忆与学习》7.2 Self-Refine:自我批评的失效模式

让模型批评自己的输出看起来免费,实际有结构性的失效模式。本节用缺陷分层模型比较四种策略:不改进、同源自我批评、独立验证、先自我批评再独立验证。实验展示同源批评的收益集中在表层缺陷、会在正确输出上造成回退,并解释为什么独立验证通常优于自我批评。

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

“让模型先写,再让它自己批评自己改一版"听起来零成本、纯收益:不需要额外的模型,不需要额外的标注。但实验和经验都表明,自我批评(Self-Refine)有结构性的失效模式:收益集中在一类缺陷上,对另一类缺陷抓不住,而且会在本来正确的输出上造成回退。

这一节用缺陷分层模型把这些失效模式量化。缺陷分三类:表层(格式、拼写)、语义(需求理解、逻辑)、潜在(证据、边界条件)。同源批评对三类缺陷的捕捉率不同,独立验证换一个信息源,表现也不同。

同源批评的结构性弱点

同一个模型既生成又批评,意味着批评者看到的信息和生成者完全一样:同一个上下文、同一套推理偏好。因此它对"生成者犯的同类错误"也有同样的盲区。

把缺陷分层后,强弱分明:

缺陷层例子同源批评捕捉率独立验证捕捉率
表层格式、拼写、字段名高(0.80)高(0.75)
语义需求理解、逻辑中(0.30)高(0.70)
潜在证据、边界条件低(0.10)中(0.50)

同源批评在表层抓得准,越往语义和潜在层越弱。原因是结构性:表层缺陷是"文本与格式约定不符”,生成者和批评者都能对照同一份格式约定;语义和潜在缺陷是"理解与证据不符",批评者共享生成者的理解偏差,自然看不到。

批评还会造成回退

同源批评的第二个问题是:它不只是"不抓",还会在正确输出上动手。模型对本来正确的答案进行"改进",有时会把对的说错。这是自我批评特有的代价:独立验证者通常不修改输出,只给结论,所以不会引入回退;自我批评直接重写,重写就可能破坏原本正确的部分。

回退的大小可以建模成"脆弱度":越是本来就完美的输出,越没有可改进的空间,改动越容易变成破坏。

最小实验:四种策略

下面的实验用 10 个任务,每个任务带有表层、语义、潜在三类缺陷的数量和一个"脆弱度"。四种策略分别是:不改进、同源自我批评、独立验证、先自我批评再独立验证。

# file: agp_lab/self_refine.py | write
# tier: 3
# verify: python3 -m unittest tests.test_self_refine
"""Self-Refine:同源自我批评的收益与失效模式。

任务用三类缺陷描述:表层(格式、拼写)、语义(需求理解、逻辑)、潜在
(证据、边界条件)。同一模型既生成又批评时,对表层缺陷抓得准,对语义与
潜在缺陷存在共同盲区;批评还会在本来正确的输出上“改坏”一部分。独立验证
器换一个信息源,抓语义缺陷更强,也不会主动改稿。

实验比较四种策略的平均质量、改进任务数与回退任务数,说明三件事:

1. 同源批评的收益集中在表层缺陷,越靠近语义与潜在缺陷越弱;
2. 在已经正确的输出上强行自我修改,会产生净损失;
3. “先自我批评再独立验证”不一定优于“直接独立验证”,因为回退已经发生。
"""
from __future__ import annotations

from dataclasses import dataclass

DEFECT_WEIGHT = {"surface": 0.10, "semantic": 0.16, "latent": 0.22}
SELF_CATCH = {"surface": 0.80, "semantic": 0.30, "latent": 0.10}
INDEPENDENT_CATCH = {"surface": 0.75, "semantic": 0.70, "latent": 0.50}
SELF_REGRESSION_SCALE = 0.08


@dataclass(frozen=True)
class Task:
    name: str
    surface: int
    semantic: int
    latent: int
    brittle: float


def task_set() -> tuple[Task, ...]:
    return (
        Task("s01", 0, 0, 0, 0.90),
        Task("s02", 0, 0, 0, 1.00),
        Task("s03", 1, 0, 0, 0.20),
        Task("s04", 0, 2, 0, 0.30),
        Task("s05", 0, 1, 1, 0.20),
        Task("s06", 2, 1, 0, 0.80),
        Task("s07", 0, 0, 2, 0.10),
        Task("s08", 1, 1, 1, 0.50),
        Task("s09", 0, 2, 0, 0.60),
        Task("s10", 1, 0, 0, 0.30),
    )


def weighted_defects(task: Task) -> float:
    if task.surface < 0 or task.semantic < 0 or task.latent < 0:
        raise ValueError("缺陷数不能为负")
    return (
        task.surface * DEFECT_WEIGHT["surface"]
        + task.semantic * DEFECT_WEIGHT["semantic"]
        + task.latent * DEFECT_WEIGHT["latent"]
    )


def quality(
    task: Task,
    surface_left: float,
    semantic_left: float,
    latent_left: float,
    regression: float = 0.0,
) -> float:
    if min(surface_left, semantic_left, latent_left) < 0:
        raise ValueError("剩余缺陷数不能为负")
    if not 0.0 <= regression <= 1.0:
        raise ValueError("regression 必须在 [0, 1] 内")
    remaining = Task(task.name, surface_left, semantic_left, latent_left, task.brittle)
    return 1.0 - weighted_defects(remaining) - regression


def initial_quality(task: Task) -> float:
    return quality(task, task.surface, task.semantic, task.latent)


def after_catch(task: Task, catch: dict[str, float]) -> tuple[float, float, float]:
    """按类别比例计算期望剩余缺陷数;这是期望值实验,不是单次抽样。"""
    surface = task.surface * (1.0 - catch["surface"])
    semantic = task.semantic * (1.0 - catch["semantic"])
    latent = task.latent * (1.0 - catch["latent"])
    return surface, semantic, latent


def self_regression(task: Task) -> float:
    return SELF_REGRESSION_SCALE * task.brittle


def refine(task: Task, strategy: str) -> float:
    if strategy == "none":
        return initial_quality(task)
    if strategy == "self":
        surface, semantic, latent = after_catch(task, SELF_CATCH)
        return quality(task, surface, semantic, latent, self_regression(task))
    if strategy == "independent":
        surface, semantic, latent = after_catch(task, INDEPENDENT_CATCH)
        return quality(task, surface, semantic, latent, 0.0)
    if strategy == "self_then_independent":
        surface, semantic, latent = after_catch(task, SELF_CATCH)
        caught = Task(task.name, surface, semantic, latent, task.brittle)
        surface, semantic, latent = after_catch(caught, INDEPENDENT_CATCH)
        return quality(task, surface, semantic, latent, self_regression(task))
    raise ValueError(f"未知策略: {strategy}")


@dataclass(frozen=True)
class Summary:
    name: str
    mean_quality: float
    delta: float
    improved: int
    regressed: int
    unchanged: int


def summarize(tasks: tuple[Task, ...], strategy: str) -> Summary:
    if not tasks:
        raise ValueError("任务集合不能为空")
    scores = []
    improved = regressed = unchanged = 0
    for task in tasks:
        before = initial_quality(task)
        after = refine(task, strategy)
        scores.append(after)
        if after > before + 1e-12:
            improved += 1
        elif after < before - 1e-12:
            regressed += 1
        else:
            unchanged += 1
    mean = sum(scores) / len(tasks)
    baseline = sum(initial_quality(task) for task in tasks) / len(tasks)
    return Summary(strategy, mean, mean - baseline, improved, regressed, unchanged)


def compare_strategies(tasks: tuple[Task, ...]) -> list[Summary]:
    return [
        summarize(tasks, "none"),
        summarize(tasks, "self"),
        summarize(tasks, "independent"),
        summarize(tasks, "self_then_independent"),
    ]


if __name__ == "__main__":
    tasks = task_set()
    print(f"{'策略':<22}{'平均质量':>10}{'相对初始':>10}{'改进':>6}{'回退':>6}{'不变':>6}")
    for summary in compare_strategies(tasks):
        print(
            f"{summary.name:<22}{summary.mean_quality:>10.4f}"
            f"{summary.delta:>+10.4f}{summary.improved:>6}{summary.regressed:>6}"
            f"{summary.unchanged:>6}"
        )
    print()
    print("同源批评在正确输出上的回退示例:")
    for task in tasks:
        if task.surface == task.semantic == task.latent == 0:
            print(
                f"  {task.name}: 初始 {initial_quality(task):.3f} -> "
                f"自我批评后 {refine(task, 'self'):.3f}"
            )

运行:

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

输出:

策略                          平均质量      相对初始    改进    回退    不变
none                      0.7500   +0.0000     0     0    10
self                      0.7932   +0.0432     8     2     0
independent               0.9099   +0.1599     8     0     2
self_then_independent     0.8952   +0.1452     8     2     0

同源批评在正确输出上的回退示例:
  s01: 初始 1.000 -> 自我批评后 0.928
  s02: 初始 1.000 -> 自我批评后 0.920

这张表是自我批评失效模式的完整证据。

同源批评只有 0.0432 的提升。 它抓得住表层缺陷,但语义和潜在缺陷漏得多,最终平均质量 0.7932。10 个任务里 8 个有改进、2 个回退,但净提升很小。这不是"自我批评没用",而是"自我批评只解决了容易解决的那部分"。

独立验证提升 0.1599,是同源的三倍多。 独立验证者换一个信息源,抓语义和潜在缺陷更强,平均质量 0.9099,且 0 回退。注意它依然有 2 个"不变"——独立验证对已经正确的任务不做改动,所以不会变坏。

先自我批评再独立验证反而更差。 self_then_independent 的平均质量 0.8952,低于直接独立验证的 0.9099。为什么?因为自我批评先发生了回退(2 个任务被改坏),独立验证者接手的已经是受损的版本,回退被继承下来。叠加自我批评在独立验证之前,不是加成,是把自我批评的损失固化了。

回退发生在最不该发生的地方。 s01 和 s02 是初始质量 1.000 的完美输出,自我批评把它们改成 0.928 和 0.920。对完美的输出"改进",是纯粹的破坏。这正是自我批评最反直觉的地方:它伤害的不是差的输出,而是最好的输出。

什么时候自我批评有用

上面的证据不意味着自我批评一无是处。它的适用条件很窄,但存在:

  • 缺陷主要是表层的:格式、字段名、拼写,同源批评高效且便宜;
  • 不允许新增模型:没有独立验证器的预算,自我批评是唯一选项;
  • 能容忍回退:输出会被再次审查,坏一版可接受。

反过来,语义和潜在缺陷占比高的任务、输出直接上生产无需再审的任务,自我批评的风险大于收益。用缺陷分层先做一次归类,比盲目套模板更可靠。

架构含义

自我批评对架构有三个直接约束:

  1. 批评者与生成者要独立。 同源批评共享偏差;独立验证者即使弱一点,信息源不同也有价值。
  2. 批评要分级。 表层批评可以直接改,语义与潜在批评要引用证据,不能"凭感觉改"。
  3. 修改要可回滚。 自我批评重写输出前保留原始版本,回退时能回退,而不是只能接受。

第 1 条是核心。实验里独立验证不是"更强的自我批评",而是"信息源不同的验证";它的收益来自偏差去相关,不是来自模型更强。

架构判据

判据合格的样子不合格的样子
来源独立批评者与生成者不同源同一个模型自问自答
批评分级表层/语义/潜在分开处理一律"重新写一版"
回退可控保留原文,坏版可回滚覆盖原始输出
收益可测分缺陷层统计改进只报"平均变好"
边界声明明确哪些缺陷层不适用声称自我批评总有效

“回退可控"最容易落实也最常被跳过。一个 original 字段的成本几乎为零,却能决定"自我批评坏了"是否可恢复。

小结

  • 同源批评共享生成者的偏差,表层缺陷抓得准,语义与潜在缺陷漏得多。
  • 自我批评不只会漏,还会在正确输出上造成回退,伤害最好的输出。
  • 独立验证换信息源,抓深层缺陷更强,且不引入回退。
  • 先自我批评再独立验证不是加成:自我批评的回退会被继承。
  • 自我批评只在表层缺陷为主、无验证器预算、能容忍回退时适用。
  • 批评要分级、修改要可回滚,架构才能把损失降到最低。

阅读导航:上一节:7.1 Reflexion:失败回看与反思注入 · 下一节:7.3 验证器与奖励黑客防线 。

常见错误与边界

  1. 让同一个模型自评。 同源批评共享偏差,深层缺陷必然漏。
  2. 一律重写。 表层缺陷才适合直接改;语义缺陷要引用证据再动。
  3. 覆盖原文。 自我批评坏一版后无法回退,损失固化。
  4. 只报平均变好。 平均提升掩盖"8 个改进 2 个回退"的结构;要分层统计。
  5. 叠加自我批评。 在独立验证前先自我批评,回退会被继承,不如直接独立验证。
  6. 声称自我批评总有效。 它的适用条件是表层缺陷为主、容忍回退、无独立预算。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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