以下数字为教学示例,不构成对任何真实系统或供应商的承诺。
“让模型先写,再让它自己批评自己改一版"听起来零成本、纯收益:不需要额外的模型,不需要额外的标注。但实验和经验都表明,自我批评(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 条是核心。实验里独立验证不是"更强的自我批评",而是"信息源不同的验证";它的收益来自偏差去相关,不是来自模型更强。
架构判据
| 判据 | 合格的样子 | 不合格的样子 |
|---|---|---|
| 来源独立 | 批评者与生成者不同源 | 同一个模型自问自答 |
| 批评分级 | 表层/语义/潜在分开处理 | 一律"重新写一版" |
| 回退可控 | 保留原文,坏版可回滚 | 覆盖原始输出 |
| 收益可测 | 分缺陷层统计改进 | 只报"平均变好" |
| 边界声明 | 明确哪些缺陷层不适用 | 声称自我批评总有效 |
“回退可控"最容易落实也最常被跳过。一个 original 字段的成本几乎为零,却能决定"自我批评坏了"是否可恢复。
小结
- 同源批评共享生成者的偏差,表层缺陷抓得准,语义与潜在缺陷漏得多。
- 自我批评不只会漏,还会在正确输出上造成回退,伤害最好的输出。
- 独立验证换信息源,抓深层缺陷更强,且不引入回退。
- 先自我批评再独立验证不是加成:自我批评的回退会被继承。
- 自我批评只在表层缺陷为主、无验证器预算、能容忍回退时适用。
- 批评要分级、修改要可回滚,架构才能把损失降到最低。
阅读导航:上一节:7.1 Reflexion:失败回看与反思注入 · 下一节:7.3 验证器与奖励黑客防线 。
常见错误与边界
- 让同一个模型自评。 同源批评共享偏差,深层缺陷必然漏。
- 一律重写。 表层缺陷才适合直接改;语义缺陷要引用证据再动。
- 覆盖原文。 自我批评坏一版后无法回退,损失固化。
- 只报平均变好。 平均提升掩盖"8 个改进 2 个回退"的结构;要分层统计。
- 叠加自我批评。 在独立验证前先自我批评,回退会被继承,不如直接独立验证。
- 声称自我批评总有效。 它的适用条件是表层缺陷为主、容忍回退、无独立预算。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。