← Agents From First Principles

批评、修订与接受

通过有针对性的批评与修订改进一个候选,然后比较新旧版本,使运行时能够接受真正的进步、拒绝回归,并避免无尽的自我改写循环。

选择只能在其给定的候选之间做选择。一个强评估器可能认识到每个可用候选都很差,但它无法选出生成器从未产出过的正确答案。

这个限制变得实际,因为候选通常来自一个模型回答一个提示词,而这样的样本是相关的。当四个候选共享对证据的同一误读时,对它们排序仍可能产出一个自信的胜者,而共同的缺陷未被触及。

因此,当错误是系统性的时候,生成更多样本可能停止帮助。如果重复样本复现同一误读,额外广度创造的只是同一缺陷的更多版本,而非一条真正不同的绕行路线。本章处理的失败不只是缺乏替代方案。它是一个局部缺陷,为它生成另一个独立答案是低效的干预。

明显的回应是把草稿交还给模型并要求更好的东西。那产生了一个循环,而值得精确说明它为什么表现不佳:一条改进这个的指令没有命名目标,所以模型可以通过改变任何东西来满足它。

它通常改变的是文字。

文字变得更流畅, hedge 被加入,长度增长,而底层错误被原封不动地推进到一个现在看起来像被检查过的版本。

所以本章增加的机制不是一个更好的改写提示词。它是把一条模糊指令分离成三个阶段,每个阶段都可以独立检视和度量:

批评是缺陷假设。修订是针对那个假设的干预。接受门决定该干预是否配得上它的位置。

    flowchart TD
    D[当前版本] --> C[批评]
    C -->|无实质性缺陷| S[停止]
    C -->|缺陷假设| R[有针对性的修订]
    R --> E[评估旧版与新版]
    E -->|改进| A[接受:新版成为当前]
    E -->|未改进| B[拒绝:恢复旧版]
    A --> D
    B --> S
  

注意循环有两个出口,而只有一个产出改变的答案。

那种不对称是全部设计。一个没有拒绝出口的修订循环是一台积累修订者碰巧最后做了什么的机器。

这也给了反思一个不依赖任何关于模型内省主张的定义。

这里什么都不要求模型思考自己的思考。它要求一个诊断、一次干预和一次度量,而这三件产物要么作为运行时中独立可检视的对象存在,要么不存在。


1. 改变了除错误之外一切的改写

一个智能体被要求诊断一个间歇性故障。它回答说 API 大概返回 null,并建议在解析响应前加一个 null 检查。

随任务提供的证据说的却是别的东西:故障只在并发写入下出现,串行执行从不复现它,堆栈跟踪穿过共享可变状态。每一点都指向竞态,没有一点支持 null 响应。

让那个智能体改进它的答案,你可能得到第二个版本,解释说 API 可能在负载下间歇性返回 null,并建议增加防御性校验和更详细的日志。hedge 是新的。对负载的引用是新的。

诊断是相同的,而它仍被三件证据反驳。

请求中没有任何东西迫使模型说明第一个答案哪里错了。没有那个,满足"改进"的最便宜方式是表面的,而表面改变恰恰是流畅模型最可靠地产出的。

因此第一个改变是一个显式诊断步骤,在任何改写发生之前。

最高影响的缺陷是什么?什么证据支持那个主张?具体什么必须改变,什么必须幸存?

只有当这些问题在改写本身之外被分别回答后,修订才有可作用的对象。


2. 广度与深度回答不同的失败

候选选择章水平搜索,采样几个完整答案并比较它们。本章垂直搜索,停留在一个答案上并尝试有向修改。

    flowchart LR
    subgraph breadth [广度: 独立样本]
        P[提示词] --> A1[A]
        P --> B1[B]
        P --> C1[C]
        A1 --> SEL[选择]
        B1 --> SEL
        C1 --> SEL
    end
    subgraph depth [深度: 一条轨迹]
        V0[v0] -->|批评| V1[v1]
        V1 -->|批评| V2[v2]
    end
  

这些不是竞争哲学,它们之间的选择源于第一次尝试通常的样子:

条件 通常倾向广度 通常倾向深度
第一次尝试根本上错误 是 较少
第一次尝试接近但有缺陷 有时浪费 是
几种真正不同的策略都合理 是 有时
一个实质性缺陷可以定位 较不重要 是
应保留现有正确工作 较弱保证 强契合
改进可以度量 选择需要 接受门需要
延迟预算紧张 更容易并行 本质上串行

延迟那一行最常被忘记。

Best-of-N 通常可以并行花费其生成计算,而修订是因果串行的,因为每次修订都依赖关于上一版本的反馈。在足够并行容量下,生成 N 个独立候选因此可以接近单次生成的挂钟延迟,而 N 次依赖的修订轮仍大致是 N 个串行步骤。provider 限制、批处理、候选长度和评估器成本可以改变实际比率。

有两个条件应该阻止你使用修订。

如果客观环境反馈已经识别了修复,应用修复而不是让模型描述它。如果批评者和评估器共享同一代理偏见,循环会高效而安静地优化那个偏见,这比不运行它更糟。

两种策略可以组合,稍后的轨迹搜索章通过在部分轨迹而非完成答案上分叉来推广两者。本章的输入是一个已经赢得选择的单一候选。


3. 批评是缺陷假设,不是裁决

有一个要避免的诱人推理:批评者说 X 错了,因此 X 错了。

批评者是另一个会犯错的组件,通常是另一次对产出草稿的同一类模型的调用。因此它的输出不因其生成在后而获得特殊权威。提供更强外部证据的批评者可能比原生成器更有信息,但批评本身仍需赢得信任。

把它命名为假设不是修辞上的软化。

它改变代码,因为缺陷假设需要附上支持证据、可与阈值比较的严重度、以及可否证它的下游测试。把批评当作即时裁决会恰好跳过那些检查。

因此一个值得采取行动的批评携带五个字段:什么看起来错了、什么证据支持该主张、它有多严重、什么应该改变、以及什么必须在改变中幸存。

from dataclasses import dataclass
from enum import StrEnum

class DefectCategory(StrEnum):
    UNSUPPORTED_CLAIM = "unsupported_claim"
    MISSING_EVIDENCE = "missing_evidence"
    CONTRADICTION = "contradiction"
    CONSTRAINT_VIOLATION = "constraint_violation"
    INCORRECT_REFERENCE = "incorrect_reference"
    VERBOSITY = "verbosity"

@dataclass(frozen=True)
class Critique:
    category: DefectCategory
    target: str
    defect: str
    evidence: tuple[str, ...]
    revision_actions: tuple[str, ...]
    preserve: tuple[str, ...] = ()
    severity: int = 0

    @property
    def defect_key(self) -> tuple[DefectCategory, str]:
        return self.category, self.target

category 字段给缺陷一个用于遥测和比较的稳定词汇,而 target 标识缺陷适用于何处。自由文本缺陷描述作为标识太不稳定,但仅类别太粗糙:两个不同的矛盾可以发生在同一答案的两个不同部分。因此 (category, target) 成为运行时的稳定缺陷键。它粗糙到可以跨修订比较,又具体到避免把同一类别的每个缺陷当作同一问题。

对于调试示例,一个真实的批评读作:类别 CONTRADICTION,目标 failure diagnosis,缺陷答案断言 null 响应失败,而提供的证据描述的是一个依赖时间的失败,证据故障只在重叠写入期间出现、串行执行成功、堆栈跟踪穿过共享状态,动作移除 null 响应诊断并解释为什么时间证据指向竞态,保留日志建议和 300 字限制。

把它与一个报告答案可以改进准确性和清晰度的批评者比较。

第二个版本不是更弱的批评。它根本不是一个批评,因为没有随之而来的干预,也没有任何东西可能被发现是错的。


4. 优先使用运行时自己能获得的证据

在让模型发明批评之前,先问缺陷能否被度量。很多可以,而每一个可以的缺陷都是运行时应该自己检测而非委托给概率性调用的缺陷。

域 可用的直接证据 需要模型批评
代码 测试、类型检查器、编译器、基准、堆栈跟踪 设计令人困惑;抽象错误
结构化数据 schema 校验、必填字段、不变量 字段已填充但语义错误
事实主张 来源查找、数据库查询、原始证据 论证遗漏最强反证
对照规范的文字 长度、必填章节、格式 强调与所述意图矛盾

一个模型报告一个函数可能未通过测试,严格弱于一个运行时报告 test_parse_date 在第 84 行失败。

第一个是关于环境能直接检查的东西的猜测。第二个是该检查产出的具体观察。动作边界出于不同理由确立了同一条规则:运行时能确定性执行的工作不应仅为了获得关于它的意见而委托给模型。

模型批评属于右列,在那里失败难以编码为检查。

一个论证可能遗漏关键证据、一个解释可能内部不一致、一个答案可能满足每条所述约束同时违反其背后的意图。那些是真实缺陷,没有断言库能检测到它们。

这也是研究文献最有用的地方,因为它对局限异常直接。

Self-Refine 表明来自单一模型的迭代反馈和精炼在一系列任务上改进输出。[1] Constitutional AI 使用显式书面原则在更大的训练过程中驱动批评与修订。[2] CRITIC 展示了一个自我修正设置,其中批评通过外部工具落地,其结果强调外部反馈的价值而非仅依赖内部模型判断。[3]

对照之下,Huang et al. 报告在推理任务上的内在自我修正可能无法改进表现并可能主动降低它,[4] 而 Kamoi et al. 的综述区分了这些情形并得出结论:反馈源的可靠性是区分它们的关键。[5]

放在一起读,这些结果暗示一个工程区分。

外部证据可以给批评一个原始生成不包含的独立信号。测试、检索到的来源、编译器错误和其他环境观察可以以无根自我评估不能的方式约束批评。

工程后果是在类型中保持证据源可见,这就是 Critique.evidence 存在的原因,也是空证据元组是一个值得记录的信号的原因。


5. 一次一个缺陷,或干脆没有

假设批评者返回八个问题:太冗长、证据弱、遗漏边界情况、命名差、无支持主张、结论不清、顺序错误、遗漏 caveat。让修订者修复全部八个,你没有请求修订。你请求了一个新答案,原始答案作为灵感提供。

结果在两个方向上都不可解释。

如果它分数更高,你无法分辨八个改变中哪个起作用;如果它分数更低,你无法分辨哪个破坏了它。循环花费了一次模型调用,却什么都没学到用于指导下一次。

按严重度排序不需要另一次修订调用,而针对最高影响缺陷进行修订使结果干预更容易解释。

默认是一个实质性缺陷、一次有针对性的干预、一次度量、一个结论。有些缺陷因果耦合,不能合理地独立修复。当那样发生时,只把必须一起改变的最小集合分组,并把它当作一个被测试的干预。

回滚也因此变得简单,因为只有一个被提出的干预需要接受或丢弃。

批评者还需要一种方式说没有什么值得修复,而它需要是一个不同的值而非缺失:

class NoMaterialDefect:
    """The critic looked and found nothing worth another revision."""

NO_MATERIAL_DEFECT = NoMaterialDefect()
Verdict = Critique | NoMaterialDefect

为此返回 None 会把两种不同情况折叠成一种。

一个检查了草稿并发现它没问题的批评者是成功,而一次解析失败的批评者调用是错误,无法区分两者的运行时会为一个损坏的组件报告健康证明。

同样的推理产生了动作边界的标记拒绝类型,它在这里适用是因为同样的理由:一个结果类型应该记录发生了什么,而不只是有事情没发生。

没有这个逃生舱,一个预算为三的循环会对一个已经正确的答案执行三次修订,因为还有一次模型调用可用,而代码里没有任何东西阻止它。


6. 修订是补丁,不是改写

给定一个缺陷假设,修订者的指令是以最小方式改变当前草稿以解决这个具体缺陷,同时保留列出的内容。从 Critique 构建的修订提示词因此携带任务、当前草稿、缺陷、证据、要求的动作、保留清单和任何全局约束。

保留清单是最常被遗漏的字段,它防止这些循环的特征性失败。

一个只被告知什么错了的修订者会乐意通过重新生成整个答案来修复它,丢弃三个正确章节以修复一个错误段落。分数甚至可能上升,这使损失不可见。

保留是可检查的,所以检查它:

from typing import Callable

def preservation_violations(
    old: str,
    new: str,
    preserve: tuple[str, ...],
    holds: Callable[[str, str], bool],
) -> tuple[str, ...]:
    return tuple(
        constraint
        for constraint in preserve
        if holds(old, constraint) and not holds(new, constraint)
    )

holds 谓词由调用者提供,因为什么算作保留一个 API 签名与什么算作保留字数限制不同。

注意双重条件。一个旧版本已经违反的属性不是保留回归,所以修订者不应因丢失已经不存在的东西而被责怪。但保留约束和硬输出要求不同。

  • 一条保留规则问:先前成立的东西被破坏了吗?
  • 一条硬要求问:被提议的版本现在满足这个条件吗?

当两者都存在时,接受门应检查两者。只有先前成立之后停止成立的约束才是这次修订破坏了某物的证据。这给了循环一个与分数无关的拒绝理由。一个修复了目标缺陷、改进了评估、同时毁掉 API 签名的修订是一次失败的修订,门应该用那些词说出来。


7. 修订必须配得上它的位置

一个总是保留最新版本的循环是一台回归机器。

算术无情。从 0.84 开始,让批评者找到一个真实弱点,让修订者在引入两个更小问题的同时修复它,到达 0.76。重复三次。

回滚必须是算法的一部分,而非操作者的干预。每次修订都是一个被提议的补丁,当前版本保持当前直到有东西取代它。

def accept_revision(old: Candidate, new: Candidate, *, margin: float) -> bool:
    if old.verified_success != new.verified_success:
        return bool(new.verified_success)
    if old.score is None or new.score is None:
        return False
    return new.score - old.score >= margin

这个门在从选择章继承的两个 Candidate 值之间决定,这不只是类型兼容性的问题。

一个候选同时有 score(评估器产出的代理)和 verified_success(记录外部验证是否确立了成功)。当新旧版本在那个更强信号上不同时,代理输了。

考虑另一种排序会做什么。

一个修订让测试套件通过但在评分表上得分更低,可能被拒绝而让一个读起来更好但不能工作的版本胜出。

当两个候选有相同的验证状态——都未验证、都是已验证失败、或都是已验证成功——布尔信号不能区分它们,所以门回退到度量的代理裕量。因此层级是:存在更强区分证据时使用它;否则比较较弱信号,而不假装它成了基准真值。

margin 参数不是装饰,下一节解释它的值从何而来。


8. 评估器是组件,不是预言机

把某物称为评估器不能让它正确,有两个失败模式重要到值得直接度量。

第一个是偏见。

如果评估器奖励长度,修订者会发现这一点而无需改变任何权重,因为接受门是一种选择压力,修订者针对它生成候选。每次被接受的修订都是评估器偏好的,所以针对偏好冗长评估器运行的循环可靠地收敛于冗长。

系统没有东西损坏,而输出每轮都在变差。

第二个是噪声。

如果对同一文本的重复评估变化约 0.02,那么从 0.840 到 0.845 的上升不是改进的证据,接受它就是接受一次抛硬币。

与其盲目选择裕量,度量重复评分变化并用它确立一个实用噪声底:

def evaluator_margin(
    evaluate: Callable[[str, str], float],
    task: str,
    samples: list[str],
    *,
    repeats: int = 5,
    k: float = 2.0,
) -> float:
    if not samples:
        raise ValueError("at least one calibration sample is required")
    if repeats < 2:
        raise ValueError("repeats must be at least 2")
    if k < 0:
        raise ValueError("k must be non-negative")

    noise = [
        statistics.pstdev(
            [evaluate(task, sample) for _ in range(repeats)]
        )
        for sample in samples
    ]
    return k * max(noise)

这是启发式校准,不是统计置信保证。它度量所测试评估器配置下的可重复性。它不检测系统性偏见,而一个确定性评估器可能有零重复方差同时仍然一致地错。

对同一未改文本多次评分把评估器方差与草稿之间的真实差异隔离开,而取样本间最坏情况避免在评估器最简单的输入上校准。门然后要求改进大于仪器自己能制造的量。

在绝对评分校准不佳的地方,成对比较可能更容易解释,因为任务保持固定而只有两个版本变化。它不自动更可靠。上一章表明成对评审器可能表现出顺序效应和循环偏好,所以同样的控制仍然适用。存在客观环境信号时,它高于两者。


9. 三个角色,三个调试面

同一个底层模型可以服务所有三次调用。但角色仍应是独立调用,因为一个要求模型审查答案、改进它并报告它是否更好的单一提示词,返回一团三种独立失败在其中不可区分的文字。

    flowchart TD
    D[当前版本] --> C[批评者<br/>哪个缺陷?]
    C --> R[修订者<br/>什么改变?]
    R --> E[评估器<br/>有帮助吗?]
    E --> G{接受门}
    G -->|接受| N[新当前版本]
    G -->|拒绝| O[恢复上一版]
    C -.measured by.-> M1[检出率<br/>误报率]
    R -.measured by.-> M2[依从性<br/>保留率]
    E -.measured by.-> M3[噪声<br/>排序一致性]
    classDef model fill:#e8eef7,stroke:#4a6fa5
    classDef runtime fill:#f2f2f2,stroke:#888
    class C,R,E model
    class G,N,O runtime
  

批评者和修订者通常是模型调用。评估器是一个独立组件,其实现可以是确定性的、学习的或基于模型的。因此重要的边界不是三个模型喂给一个门。而是:

        会犯错的诊断
    → 会犯错的干预
    → 独立表示的评估
    → 确定性接受策略

这里,独立意味着诊断、干预和评估在运行时有不同的输入、输出和所有权;它不意味着它们的错误在统计上独立。对多个角色使用同一模型可能留下相关的盲点,这就是为什么只要任务允许就优先使用外部落地的评估。

让责任分别表示给了每一个自己的调试面。

考虑两个都产出糟糕修订的系统。

在第一个中,批评者针对了错误的缺陷而修订者忠实地执行了指令。在第二个中,批评者识别了真实缺陷而修订者改了别的。

两者在端到端分数中看起来一样,而它们需要相反的修复:一个需要更好的批评提示词,另一个需要更紧的修订约束。一个叫 reflection failed 的单一指标无法告诉你你拥有的是哪一个。

对不同角色使用不同模型可能减少相关盲点,它也增加成本、延迟和另一个配置轴。固定任务集和评估器并度量它是否有帮助,而不是假设异构性是免费的改进。


10. 终止、振荡与预算

运行时状态章正式处理进度和停止。本章只需要足够的控制来保持循环有限并使其停止理由显式。六个有用的终止条件是:

终止理由 它告诉你什么
no_material_defect 批评者检查了草稿,没发现值得修复的
low_severity 缺陷存在但排在花费一次调用之下
repeated_defect 同一缺陷键最近返回过;循环可能在循环而非收敛
preservation_broken 修订修复了目标但损坏了受保护的东西
not_improved 提案未通过门,上一版保持
budget_exhausted 修订额度已用尽;未再尝试批评

那张表是一个类型而非文档,原因与动作边界把拒绝阶段变成 enum 相同:

class Termination(StrEnum):
    NO_MATERIAL_DEFECT = "no_material_defect"
    LOW_SEVERITY = "low_severity"
    REPEATED_DEFECT = "repeated_defect"
    PRESERVATION_BROKEN = "preservation_broken"
    NOT_IMPROVED = "not_improved"
    BUDGET_EXHAUSTED = "budget_exhausted"

只有最后一个是限制而非诊断。

以任何其他方式结束的运行都告诉了你关于其组件的信息。一个频繁达到 budget_exhausted 的系统值得调查。它可能表明批评者继续发现实质性缺陷、成功的修订暴露更多缺陷,或者仅仅是配置的预算对任务分布来说太小。

振荡值得特别注意,因为它看起来像活动。

一个报告冗长、然后无支持主张、然后又是冗长、然后又是无支持主张的循环没有向任何东西收敛。每次修订重新引入前一次移除的缺陷,循环会把全部预算花在用一种交换另一种上。

检测这一点是 Critique 同时携带类别和目标的原因。类别提供封闭词汇;目标区分同一缺陷类的不同实例。比较最近的 defect_key 值给运行时一个廉价的复发信号,而不假装一个类别中的每个缺陷都相同。这是随单次计算生灭的工作状态,不是记忆;选择性召回章处理必须超越产生它的调用而存活的信息。

预算为三不是普适常数。

重要的是无界修订不是设计,且这个数字写在读者能找到的某处。


11. 循环,以及为什么它的历史就是结果

以上一切组装成一个函数。它操作的类型来自前一章,而辅助函数做了有趣的工作,所以循环本身主要是命名出口的序列。

from dataclasses import dataclass, replace
from enum import StrEnum
from typing import Callable
import statistics

@dataclass(frozen=True)
class Revision:
    version: int
    candidate: Candidate
    critique: Critique | None
    accepted: bool

@dataclass(frozen=True)
class RevisionRun:
    task: str
    history: tuple[Revision, ...]
    termination: Termination

    @property
    def final(self) -> Candidate:
        return [r.candidate for r in self.history if r.accepted][-1]

    @property
    def defect_path(self) -> tuple[tuple[DefectCategory, str], ...]:
        return tuple(
            revision.critique.defect_key
            for revision in self.history
            if revision.critique is not None
        )

    @property
    def net_gain(self) -> float | None:
        first, last = self.history[0].candidate, self.final
        if first.score is None or last.score is None:
            return None
        return last.score - first.score

回滚是一个属性而非分支。

final 返回最后一个通过门的候选,所以被拒绝的提案作为证据留在历史中而从不成为答案,也没有独立的恢复步骤会被忘记。

def improve(
    task: str,
    start: Candidate,
    critique_fn: Callable[[str, Candidate], Verdict],
    revise_fn: Callable[[str, Candidate, Critique], Candidate],
    evaluate_fn: Callable[[str, str], float],
    verify_fn: Callable[[str, str], bool | None] | None,
    holds: Callable[[str, str], bool],
    *,
    budget: int = 3,
    min_severity: int = 3,
    margin: float = 0.03,
) -> RevisionRun:
    current = start
    history = [Revision(0, current, None, True)]
    seen: list[tuple[DefectCategory, str]] = []

    def stop(reason: Termination) -> RevisionRun:
        return RevisionRun(task, tuple(history), reason)

    for version in range(1, budget + 1):
        verdict = critique_fn(task, current)
        if isinstance(verdict, NoMaterialDefect):
            return stop(Termination.NO_MATERIAL_DEFECT)
        if verdict.severity < min_severity:
            return stop(Termination.LOW_SEVERITY)
        if verdict.category in seen[-2:]:
            return stop(Termination.REPEATED_DEFECT)
        if verdict.defect_key in seen[-2:]:
            return stop(Termination.REPEATED_DEFECT)

        seen.append(verdict.defect_key)

        proposed = revise_fn(task, current, verdict)
        if preservation_violations(
            current.value, proposed.value, verdict.preserve, holds
        ):
            history.append(Revision(version, proposed, verdict, False))
            return stop(Termination.PRESERVATION_BROKEN)

        verified = (
            verify_fn(task, proposed.value)
            if verify_fn is not None
            else None
        )

        scored = replace(
            proposed,
            score=evaluate_fn(task, proposed.value),
            verified_success=verified,
        )

        accepted = accept_revision(current, scored, margin=margin)

        history.append(Revision(version, scored, verdict, accepted))
        if not accepted:
            return stop(Termination.NOT_IMPROVED)
        current = scored

    return stop(Termination.BUDGET_EXHAUSTED)

RevisionRun 返回历史而非字符串的原因是,一个修订循环可以在每个有趣的方式上失败,同时仍返回一个看似合理的最终答案。

读输出告诉你关于批评者是否发现真实缺陷、修订者是否据此行动、门是否捕获了回归、或循环是否只是振荡到预算耗尽——什么都没有。

轨迹告诉你全部四个,而它只是一元组。


12. 植入缺陷分别度量批评者和修订者

自然发生的缺陷不带标签,这使得批评质量难以评估又容易被错误评估。读五个批评并判断它们深思熟虑,度量的是它们的流畅度。改为构建受控基准。取正确的答案,在每个中植入恰好一个已知错误,并记录它属于哪个类别。这个基准度量组件在受控条件下能否检测并修复已知缺陷类。它不确立那些缺陷自然发生的频率,也不确立合成损坏是否匹配真实失败的完整分布。

@dataclass(frozen=True)
class PlantedDefect:
    clean: str
    corrupted: str
    category: DefectCategory

@dataclass(frozen=True)
class CriticScore:
    cases: int
    detected: int
    correct_category: int
    clean_cases: int
    false_positives: int

    @property
    def detection_rate(self) -> float:
        return self.detected / self.cases if self.cases else 0.0

    @property
    def category_accuracy(self) -> float:
        return (
            self.correct_category / self.detected
            if self.detected
            else 0.0
        )

    @property
    def false_positive_rate(self) -> float:
        return (
            self.false_positives / self.clean_cases
            if self.clean_cases
            else 0.0
        )

def score_critic(
    cases: list[PlantedDefect],
    critique_fn: Callable[[str, Candidate], Verdict],
    task: str,
) -> CriticScore:
    detected = right = alarms = 0

    for case in cases:
        verdict = critique_fn(task, Candidate(case.corrupted))
        if isinstance(verdict, Critique):
            detected += 1
            right += verdict.category is case.category

        clean_verdict = critique_fn(task, Candidate(case.clean))
        if isinstance(clean_verdict, Critique):
            alarms += 1

    return CriticScore(
        cases=len(cases),
        detected=detected,
        correct_category=right,
        clean_cases=len(cases),
        false_positives=alarms,
    )

把批评者同时对干净版本和损坏版本运行,是使基准有区分力的原因,而 CriticScore 把检出率、类别准确率和误报率暴露为那些计数上的属性。

一个对一切回应 needs more detail 的批评者在检出率上得完美的 1.0,在误报率上得灾难性的 1.0,这正是仅检出基准会隐藏的诊断。

同一基准通过完全绕过批评者来隔离修订者。

把损坏草稿连同已知缺陷、其证据、要求的动作和保留清单交给修订者,然后问三个有可检查答案的问题:指定缺陷是否消失、保留约束是否幸存、以及是否有别的东西被破坏?

那为修订者单独产出依从性、保留率和回归率。没有这个分离,一个弱批评者使一个强修订者看起来无用,而修复被应用到错误的组件上。


13. 消融测试机制是否值得

单个指标说一个组件是否工作。

消融测试机制在被评估的任务分布上是否值得它的成本,它在这里特别有用,因为本章的每个阶段都可以独立移除。

系统 诊断 修订 接受
一次性 无 无 无
朴素改写 无 无目标 最新胜出
批评并改写 结构化 无目标 最新胜出
门控修订 结构化 有目标 新旧对照
有界循环 结构化 有目标 门加预算

固定模型、任务集、采样设置和评估器,然后记录已验证成功、质量分数、回归率、模型调用、延迟和每次已验证成功的成本,覆盖所有五行。

重要的比较来自相邻行。

第二行对第三行回答结构化诊断是否击败了通用改写指令。第三行对第四行回答接受门是否真的防止了回归,这是最可能被假设而非测试的主张。第四行对第五行回答第二次和第三次修订是否买够了以证明它们的串行延迟。

那些是有数字答案的窄问题,它们取代了"反思让智能体更好"这个主张。

鉴于文献在某些设置中直接与该主张矛盾,[4][5] 一个无法展示自己消融的系统没有资格做这个主张。


14. 我们赢得了什么

选择章能对模型碰巧产出的东西排序。本章能在足够严格的条件下改变它,使干预可归因:一个已诊断的目标,或必须一起改变的最小因果耦合集;一次有针对性的修订;一次对照它提议替代的版本的度量;以及一个拒绝出口,在干预未赢得其位置时保留上一版本。

那是一个小机制,它买一件具体的东西。改进不再是某种我们希望从客气请求中涌现的东西,而是运行时可以接受、拒绝并事后解释的。它也清楚地暴露了下一个局限。到目前为止每个机制都假设候选已存在,并问如何判断或修复它。当任务可以被合理地作为单个候选尝试时这有效,当工作本身有依赖、前置条件和一个必须在执行开始前表示的顺序时这失败。

一个被要求迁移 schema、调和两个数据集或修复跨越四个文件的 bug 的智能体,产出的不是值得批评的有缺陷答案。它在检查之前就编辑、在第二步之前执行第四步,并在第六步重新发现一个它本应在开始就解决的约束。

没有批评循环能修复那个,因为缺陷不在答案里。

它在工作的顺序里。


研究渊源

本章是工程重建而非综述,下面的参考是有选择的。每一个被引用都是因为本章机制依赖它确立的东西,而两个批判性结果与三个正面结果一样承重。

  1. Madaan et al. — Self-Refine: Iterative Refinement with Self-Feedback (NeurIPS 2023). 生成一个输出,从同一模型获得反馈,并反复精炼;这是迭代反馈循环可以改进结果这一基本主张的来源。
    https://arxiv.org/abs/2303.17651

  2. Bai et al. — Constitutional AI: Harmlessness from AI Feedback (2022). 使用显式书面原则在更大的训练程序中产生批评与修订,这是给批评者一个陈述标准而非泛泛改进指令的先例。
    https://arxiv.org/abs/2212.08073

  3. Gou et al. — CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing (ICLR 2024). 通过外部工具而非内部判断路由批评,这是优先使用运行时能自己获得的证据的直接来源。
    https://arxiv.org/abs/2305.11738

  4. Huang et al. — Large Language Models Cannot Self-Correct Reasoning Yet (ICLR 2024). 报告没有外部反馈的内在自我修正可能无法改进推理并可能降低它,这就是为什么本章的循环默认拒绝。
    https://arxiv.org/abs/2310.01798

  5. Kamoi et al. — When Can LLMs Actually Correct Their Own Mistakes? A Critical Survey of Self-Correction of LLMs (TACL 2024). 区分自我修正的形式,并识别反馈可靠性与实验设计为区分成功案例与其余案例的关键。
    https://arxiv.org/abs/2406.01297

下一章:规划与执行

到目前为止构建的机制都在一个完成候选上操作。它们假设工作的形状足够明显,模型可以一次尝试,这适用于数量惊人的任务,而对其余任务严重失败。

下一章在任何工作被执行之前就表示工作本身,把智能体打算做的与它现在正在做的分开。

困难在于计划是另一个模型产出的产物,所以它需要与其他一切相同的待遇:一个显式表示、一条在提案与执行之间的边界,以及一种在计划停止匹配它所针对的世界时注意到它的方法。