← Agents From First Principles

候选生成与选择

通过生成多个完整候选、用显式标准评估它们、并在替代方案之间做选择,超越单一有效提案——同时不混淆合法性与质量。

上一章建立了一道边界,阻止任意模型输出在未获得显式检查的情况下取得执行权威。它让一类失败变得可检视、可强制执行,但对另一类保持沉默。

假设模型被要求解决一个编码问题。一次运行产出了正确的补丁。下一次产出了一个看似合理但不完整的。第三次又产出了更好的东西。没有一个是畸形的,没有违反动作 schema,且每一个都会通过我们刚刚建立的那道边界。合法性与质量是不同属性。一个提案可以完全合法却仍是个糟糕的选择,这重新定位了不确定性而非消除它:

我们应该保留哪个合法提案?

本章增加的机制是最简单的答案:停止接受第一个提案,生成若干个,并把它们之间的选择变成运行时的显式部分。这通常被称为 Best-of-N。

模型没有变。我们花费更多推理时计算来创造替代方案,并把工程精力投入此前不可见的选择步骤——因为此前没有东西可供选择。而这件事值得用一章而非一段来讲的理由,是它创造的拆分:

把生成好候选的能力与识别好候选的能力分开。

它们是不同的能力,独立失败,而一旦分开就变得可度量。这个区分就是本章全部。


1. 从一次性基线开始

我们当前的系统只做一个提案:

def answer(prompt, llm):
    return llm(prompt)

这应该继续作为基线,也应该继续作为默认。不要因为若干次模型调用看起来更复杂就添加 Best-of-N——要因为基线有一个你能指认的失败才添加,比如输出质量在相同任务分布上波动太大。

所以在改变任何东西之前先记录基线。对每个任务,保留 task_id、success、latency、model_calls 和 tokens。这五个字段决定本章是否适用于你。

如果一次调用已经解决了几乎所有任务,采样八个答案买到的只有成本和延迟。如果一次调用不可靠但重复尝试往往包含好的解,Best-of-N 才有真正可利用的东西。第二个条件做了所有工作,而它值得被度量而非假设。


2. Best-of-N 是水平搜索

从同一起点生成若干完整候选:

def generate_candidates(prompt, llm, n=4):
    return [llm(prompt) for _ in range(n)]
    flowchart LR
    P[提示词] --> M[模型]
    M --> A[候选 A]
    M --> B[候选 B]
    M --> C[候选 C]
    M --> D[候选 D]
    A --> S[评估<br/>并选择]
    B --> S
    C --> S
    D --> S
  

这是本书中最小的搜索机制,值得命名其确切形状:Best-of-N 是在单一决策点上对完整提案的水平搜索。

这种精确性重要,因为后续两章构建的东西看起来相似但行为不同。批评与修订产生垂直深度——一个候选针对反馈反复精炼。轨迹搜索探索部分状态,在解题中途而非起点分叉。Best-of-N 两者都不做。它从一个状态采样完整替代方案并选出一个,这正是它属于这里如此早的原因:它不需要规划器、不需要记忆、不需要批评者、也不需要树。


3. 两份工作,以及区分它们的工具

假设我们生成四个候选,事后能分辨哪些真正正确:

情形 候选 什么失败了
1 A 错,B 正确,C 不完整,D 看似合理但错 若系统返回 D:选择器失败了,生成器做了它的工作
2 A 错,B 错,C 不完整,D 错 生成器失败了;选择器从未有机会

两种情形产出错误的最终答案。它们需要完全不同的工作——一周花在提示词多样性上,一周花在评估器上——单一成功数字无法区分它们。所以我们度量两件事。

oracle@N 问候选集是否包含一个满足外部成功标准的合格候选。它度量生成器为选择器创造的机会。资格重要。对普通文本候选,每个生成的候选都可能是合格的。对可执行动作,前一章的边界先适用:一个畸形、未授权或当前不可执行的动作不能仅因为否则看起来成功就算作选择器机会。

selection_gap@N 问选择器浪费了多少机会:

selection_gap@N = oracle@N − selected_success@N

两者都需要外部成功标准——代码用单元测试、数值问题用已知答案、结构化数据用基准真值夹具。有了它,整个工具约十五行:

from dataclasses import dataclass
from statistics import mean

@dataclass
class Candidate:
    value: str
    score: float | None = None
    eligible: bool = True
    verified_success: bool | None = None

@dataclass
class RunRecord:
    task_id: str
    candidates: list[Candidate]
    winner_index: int

    def require_verified_labels(self) -> None:
        unknown = [
            i
            for i, candidate in enumerate(self.candidates)
            if candidate.eligible and candidate.verified_success is None
        ]
        if unknown:
            raise ValueError(
                f"verified labels required for eligible candidates: {unknown}"
            )

    @property
    def oracle_success(self) -> bool:
        """Did the generator produce an eligible successful candidate?"""
        self.require_verified_labels()
        return any(
            c.eligible and c.verified_success is True
            for c in self.candidates
        )

    @property
    def selected_success(self) -> bool:
        """Did the selector return an eligible successful candidate?"""
        winner = self.candidates[self.winner_index]

        if not winner.eligible:
            return False
        if winner.verified_success is None:
            raise ValueError("selected candidate has not been externally verified")

        return winner.verified_success

def oracle_at_n(runs: list[RunRecord]) -> float:
    return mean(r.oracle_success for r in runs)

def selected_at_n(runs: list[RunRecord]) -> float:
    return mean(r.selected_success for r in runs)

def selection_gap(runs: list[RunRecord]) -> float:
    return oracle_at_n(runs) - selected_at_n(runs)

这些指标刻意在外部成功标签存在之前不可用。None 意思是尚未确立,而非失败。对可执行候选,在 oracle@N 和 selection_gap@N 能被诚实地计算之前,可能需要隔离执行或预览。

现在在一系列 N 上运行完成的记录,把两条曲线放在一起读:

N oracle@N selected_success@N selection_gap@N
1 61% 61% 0 pp
2 72% 68% 4 pp
4 83% 74% 9 pp
8 89% 73% 16 pp

单独读 oracle@N 系统看起来在改进。读被选中的成功则在 N=4 后停止改进,然后下降。读选择差距,诊断变得无歧义:在 N=8 时生成器 89% 的时间在产出成功选项,而选择器未能捕捉十六个百分点的可用机会。

大差距说停止让生成器更有创意;答案已经在那里;修复选择。差距小而 oracle 成功低说相反:选择器做得和候选集所允许的一样好,所以改进生成。这是本章的主要调试工具,后续章节将其形状复用于工具路由、记忆召回和搜索剪枝。

生成许多候选并用独立验证器排序它们是成熟的模式;Cobbe et al. 生成了许多数学解并训练验证器在其中选择,这是把生成与选择视为不同能力的特别干净的实例。[1]


4. 构建最小的 Best-of-N 系统

机制本身需要一个生成器、一个评估器和一个 argmax:

from typing import Callable

def best_of_n(
    prompt: str,
    generate: Callable[[str], str],
    score: Callable[[str, str], float],
    n: int = 4,
) -> tuple[Candidate, list[Candidate]]:
    if n < 1:
        raise ValueError("n must be at least 1")

    candidates = [Candidate(value=generate(prompt)) for _ in range(n)]

    for candidate in candidates:
        candidate.score = score(prompt, candidate.value)

    winner = max(candidates, key=lambda c: c.score)
    return winner, candidates

注意它返回每个候选,而不只是胜者。这不是便利——它使 §3 的工具可被计算。一个只返回胜者的函数已经毁掉了区分情形 1 和情形 2 所需的证据。


5. 应该用什么评估候选?

选择器只和使用得好的信号一样好,而没有一个单一最佳评估器。然而,有一个有用的偏好顺序:有外部任务证据就用它,然后是确定性任务特定指标,然后是行为经过验证的学习评分器,最后是有已度量局限的 LLM 评审器。

这不是绝对层级——有些任务真正需要主观判断。它存在是为了防止一个特定错误:让语言模型去判断环境能直接测量的东西。

直接任务证据在任务提供它时通常是最强评估器。如果代码有真正度量所需行为的测试,运行它们。如果数值答案有精确预言机,计算它。如果硬约束能被确定性地检查,检查它。这不让评估器无懈可击。测试可能不完整,基准可能是弱代理。第 10 章将直接处理那个验证问题。对选择来说,即时规则更窄:

当证据可用时,优先使用关于任务的证据而非模型对任务的看法。

对纯输出,那证据可能便宜获得。对改变环境的候选,评估必须保持候选隔离:候选 A 不能改变候选 B 被判定的状态。后续轨迹搜索章节使环境隔离显式化;这里一个预览函数足以保持该要求:

确定性指标在目标属性可直接计算时有效——延迟、约束覆盖率、输出大小,或任何作为候选函数而非对它的看法:

def score_constraint_coverage(candidate) -> float:
    return sum(check(candidate) for check in required_checks)

学习评分器在属性真实但不可直接计算时适用。运行时只需要一个稳定接口——score = scorer(prompt, candidate)——这意味着评分器可以替换或重训练而不触及智能体。

LLM 评审器是最后手段,对开放语言任务真正有用。它也是概率性评估器而非基准真值,接下来两节认真对待这一点。


6. 逐点与成对选择是不同的决定

逐点评分器独立评估每个候选,我们取最大值。成对选择器转而问 A 和 B 哪个更好?,这在绝对分数难以校准但相对偏好容易表达时有帮助。

最简单的循环赛是一个折叠:

def tournament(candidates, prefer):
    winner = candidates[0]

    for challenger in candidates[1:]:
        winner = prefer(winner, challenger)

    return winner

那段代码隐藏了两个值得了解的性质。结果可能依赖比较顺序,因为折叠不是顺序不变的,除非 prefer 是真正的排序。偏好可能是循环的——A 优于 B、B 优于 C、C 优于 A——这种情况下根本不存在排序,循环赛只是报告它碰巧结束的那个循环入口。

所以成对不意味着客观。它改变决定的形式,不改变其可靠性。


7. LLM 评审器是要度量的组件,不是预言机

给评审器候选 A 和 B,它选择 A。反转顺序,先展示 B。若偏好翻转,评估器在响应位置而非质量——而关于 LLM-as-a-judge 的研究文献已记录位置、冗长和自我增强偏见等局限。[3]

这检测起来很便宜。评估两种顺序并记录一致性:

def symmetric_preference(a, b, judge):
    forward = judge(a, b)
    reverse = judge(b, a)

    if forward == "A" and reverse == "B":
        return a

    if forward == "B" and reverse == "A":
        return b

    return None

那个 None 是该函数的重要部分。它意味着评估器在此控制下未确立稳定偏好,所以运行时保留该不确定性而非发明一个胜者。评审器分歧是一个度量,它告诉你在此任务上可以多大程度信任这个选择器。把它折叠成抛硬币就把证据变成了虚假确定性,而由此产生的数字在你此后保留的每条日志里看起来都会像一个自信的决定。


8. 候选数量与候选多样性是不同的变量

四次生成不一定给你四个想法:

A: use a dictionary cache
B: cache the result in a dictionary
C: use a dict as a cache
D: store previous results in a dictionary

那是四次采样和大约一个策略。oracle@N 几乎不会动,因为采样四次探索了同一区域。

多样性可以用精确重复率、词汇相似度、嵌入相似度或显式策略标签来检视——哪种指标合适取决于任务。它们都近似同一个问题:

额外采样探索了解空间的一个有意义不同的部分吗?

明显的杠杆是温度,值得小心对待。升高温度可能产生真正不同的方法;同样可能产生更多低质量和无效候选,以基线质量换取分散度。把它当作对两条曲线都有可度量影响的实验参数,而非治疗同质性的药。

更可控的选择是结构化地请求多样性:

strategies = [
    "Solve directly and minimally.",
    "Look for edge cases first.",
    "Try a data-structure-oriented solution.",
    "Try a correctness-first solution.",
]

def generate_diverse(prompt, llm):
    return [llm(f"{prompt}\n\nApproach: {strategy}") for strategy in strategies]

现在运行时已创建了显式的预期多样性来源,而非仅依赖解码噪声。这不保证结果候选有意义地不同——模型仍可能把多个提示词坍缩到同一策略——这就是为什么上面的多样性度量仍然必要。重要的改进是多样性现在是一个受控实验变量,而非仅仅是采样的副作用。


9. 更多候选可能产出更差的被选中答案

这一点容易错过,也是 §3 度量两条曲线而非一条的理由。

假设评分器对自信、冗长的回答有轻微偏好,即使它们包含微妙错误。在 N=2 时,两个候选都不太可能利用那个弱点。在 N=32 时,生成器有三十二次机会产出一个对代理评分极高但对真实任务更差的东西。增加 N 能改善可用的最佳候选,同时退化实际被选中的候选。更大的候选集创造了更多真正的机会,但也创造了更多产出利用评估器不完美之物的答案的机会。这就是代理过度优化,并非假想。Gao、Schulman 和 Hilton 对包括 Best-of-N 采样的奖励模型直接研究了它:随着对不完美代理的优化压力增加,代理奖励与真实质量发散了。[4]

绝不假设被选质量随 N 单调上升。度量这条曲线。

§3 的表格恰好展示了这种形状——oracle 在 N=8 仍在攀升,而被选成功已经翻越顶点。在 1、2、4、8 和 16 上扫描 N 并记录两条曲线。


10. 额外推理实际买到了什么

Best-of-N 不让底层模型更聪明。它改变的是围绕一个决策花费的计算量,而账单分几部分到来。在最简单的非批处理实现中,八个生成的候选加八个逐点 LLM 评审需要十六次模型调用。成对循环赛再加 N − 1 次比较。来自 §7 的对称评审再加倍。

所以重要的度量不只是准确度:追踪被选中的已验证成功、oracle@N、选择差距、模型调用、token、延迟、以及每次已验证成功任务的成本。分母重要,因为用大量计算乘数换取小成功增加的方法,即使标题准确度更高,也可能是错误的系统。

最近关于测试时计算的工作从研究角度阐述了同样的更广泛观点:更多推理时计算可以改进性能,但有用的分配取决于问题和方法,简单地增加固定 Best-of-N 预算不自动是计算最优的。[5]

额外成功是额外推理买到了什么?


11. 动作边界仍适用于每个候选

当 Best-of-N 选择动作而非最终文本时,前一章的契约不会消失——它运行 N 次。

假设四个候选动作回来:一个合法、一个有 schema 错误、一个未授权、一个合法。把四个排序为等价候选是类别错误,因为它们中两个根本无法执行。边界先来,只有被接受的动作到达排序器:

    flowchart LR
    R[原始候选] --> B{完整动作边界}
    B -->|合格| A[合格候选集]
    B -.rejected, by stage.-> T[拒绝计数]
    A --> K[排序]
    K --> E[执行]
  

在代码中,复用前一章的 Decision 联合和 Stage enum:

from collections import Counter

def accepted_candidates(
    raw_candidates,
    policy,
    context,
) -> tuple[list[Action], Counter]:
    accepted, rejected = [], Counter()

    for raw in raw_candidates:
        decision = prepare_action(raw, policy, context)

        if isinstance(decision, Accepted):
            accepted.append(decision.action)
        else:
            rejected[decision.stage] += 1

    return accepted, rejected

返回拒绝计数器花一行代码,立见成效。一次运行中八个候选有六个在 Stage.SCHEMA 失败,那是穿着选择问题外衣的提示词或 schema 问题,没有该计数器它看起来和八个都合法而选择器选错了的运行一模一样。

计数器是聚合,不是轨迹。生产遥测仍应保留每个原始候选及其 Decision,以便 SCHEMA 失败的高峰可以被检视而非仅被计数。§14 保持那条更强的规则:先保留候选级证据,再从中派生聚合。

对可执行候选,排序因此只发生在完整动作边界之后:

representation
→ schema
→ semantics
→ authorization
→ preconditions
→ eligible candidate set
→ ranking

12. 邻近机制及其区别

这个领域的三种技术在对话中被互换使用,实践中不可互换:

机制 探索什么 结果如何选择
Best-of-N 完整候选 在评估器下排序合格候选
自一致性 多条推理路径 聚合最终答案的一致性
批评与修订 对一个候选的有向修改 在接受标准下比较修订版与原版

自一致性是有趣的近邻。它像 Best-of-N 一样采样多条推理路径,然后聚合结果答案的一致性,而非用独立质量分数排序每个完整候选。对可提取离散答案的任务,这往往简化为选择被采样路径最大份额支持的答案。当答案可比较且一致性对正确性有信息量时它有效;当模型自信且一致地错时它会静默失败。

批评与修订又不同。它不生成独立完整替代方案,而是从一个候选开始、提案一个具体缺陷、针对该缺陷有向修改。这产生一个新要求:证据证明尝试的纠正确实改进了候选。批评者提案什么错了;它无权决定自己的修复成功了。

    flowchart TB
    subgraph BoN[Best-of-N: 广度]
        direction LR
        P[提示词] --> A1[A] & B1[B] & C1[C]
        A1 & B1 & C1 --> S[选择]
    end
    subgraph CR[批评与修订: 有向深度]
        direction LR
        P2[提示词] --> A0[A0] -->|批评| A2[A1] -->|批评| A3[A2]
    end
  

一个从固定起点探索广度。另一个给单条工作线增加有向深度。下一章构建第二个。


13. 一个有用的实验

本章最干净的测试固定底层模型,只变化 N。对受控试点,取一个带有外部基准真值的小任务集——二十个带单元测试的短 Python 函数足以让机制可见——并在 1、2、4 和 8 上运行 N,存储每个候选而非只存胜者。不要把二十个任务当作生产基准。这里的目的是暴露曲线的形状并验证诊断按预期行事,然后再扩大评估。

在每个合格候选的外部成功标签被收集后,计算 oracle@N、被选成功、选择差距、候选多样性、模型调用、token、延迟和每次已验证成功的成本,并按顺序问四个问题:

  1. oracle@N 增长吗? 若没有,额外生成没产生新机会——采样是冗余的,§8 是该看的地方。
  2. 被选成功跟随 oracle@N 吗? 若没有,选择器在留下好候选,§5 至 §7 是该看的地方。
  3. 选择差距随 N 增长吗? 若是,增加的搜索暴露评估器弱点的速度快于创造机会的速度——§9 的失败。
  4. 改进是否值得计算? 若不值得,使用更小的 N,或回到一次性。

每个问题路由到本章不同节,这是使实验值得运行的特性。Best-of-8 scored 76% 哪也不路由。


14. 保留诊断的遥测

以上全部依赖于保留证据,§3 的 RunRecord 已包含该机制所需的选择轨迹。序列化它对本章的诊断已足够:

record = {
    "task_id": run.task_id,
    "n": len(run.candidates),
    "winner_index": run.winner_index,
    "rejected_by_stage": dict(rejected),
    "candidates": [
        {
            "value": c.value,
            "score": c.score,
            "eligible": c.eligible,
            "verified_success": c.verified_success,
        }
        for c in run.candidates
    ],
}

从这一条记录,你可以在数周后重建:正确候选是否可用、选择器选了哪个、分数差距多大、候选是否近似重复、以及被选中的答案是否真的正确。

只存储最终答案,那些问题全都无法回答。在选择时刻丢弃候选级证据是构建一个后来无法分解失败的系统的容易方法:诊断所需的信息曾经存在,在保留成本最低的时刻被扔掉了。


15. 更深的教训

到目前为止每一章都取了一个不可见发生的决策,给了它名字、契约和度量。第一章把模型调用与自适应循环分开。第二章把提案与可执行权威分开。这一章把生成与选择分开。

增加的东西从来不是"四次模型调用"。它是一个推理失败的新位置。一个坏结果现在可以归因于候选生成不佳、候选多样性不足、评估器弱、错误处理平局或循环的选择规则、或代理过度优化——五种不同的缺陷,过去是一种无差别的智能体搞错了。

暴露隐藏决策,给它契约,度量拥有它的机制。

这是本书其余部分重复的模式,§3 的双曲线工具给它一个可复用的诊断形状。当我们到了工具路由、记忆召回和搜索剪枝时,我们会用不同的中间阶段问同样的问题:正确的东西是否可用,系统是否保留了它并选择了它?


研究渊源

本章从第一性原理构建,但几个研究线索确立了机制的谱系与失败模式。

  1. Cobbe et al. — Training Verifiers to Solve Math Word Problems (2021). 生成许多候选解并训练验证器排序,提供了生成与选择作为不同能力的特别干净的实例。https://arxiv.org/abs/2110.14168

  2. Wang et al. — Self-Consistency Improves Chain of Thought Reasoning in Language Models (ICLR 2023). 采样多样推理路径并聚合答案一致性;与 Best-of-N 相关但有用恰恰因为其选择规则不同。https://arxiv.org/abs/2203.11171

  3. Zheng et al. — Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena (2023). 研究 LLM 评审器并记录位置、冗长和自我增强偏见等局限。https://arxiv.org/abs/2306.05685

  4. Gao, Schulman & Hilton — Scaling Laws for Reward Model Overoptimization (2022/2023). 证明优化不完美奖励代理(包括通过 Best-of-N 采样)最终会使代理分数与真实质量分离。https://arxiv.org/abs/2210.10760

  5. Snell et al. — Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters (2024). 研究推理时计算分配,将计算感知方法与固定 Best-of-N 基线比较。https://arxiv.org/abs/2408.03314

下一章:批评、修订与接受

Best-of-N 给系统广度。它能尝试 A、B、C、D 并保留其选择机制偏好的候选。当评估器好时,那可能是可用的最佳候选;选择差距之所以存在,正是因为这两件事不保证一致。Best-of-N 不能做的是问 A 为什么失败,或 B 需要什么才能工作。

那是下一个缺失的机制。当第一个候选接近但错时,扔掉它并采样另一个独立答案丢弃了我们拥有的最有用的东西:关于一个具体缺陷的具体证据。下一章检视那个缺陷、做有向修订、把修订与原版比较、以及——关键地——决定是否保留它。那最后一步是大多数这种想法的实现出错的地方。

Best-of-N 问保留哪个完整提案。下一章问关于一个提案失败的证据能否告诉我们如何改进它。