← DSPy From First Principles

搜索推理空间

从第一性原理推导出建立在推理状态之上的 MCTS,在 DSPy 中构建它,审视这棵树是否真的在分支;然后在两个模型上运行带预算的七策略对比——附带一个预言机泄漏对照——并把它确立的结论与它无法确立的结论分开。

一条路径就是一个决定

第 15 章里我们构建了一个智能体。它安全地获取仓库证据,检视了被允许检视的 文件,产出了一个诊断。

它错了。

也不算全错——这个智能体拿到了 0.60。它找到了相关代码,指出 service.py 引用了 item.cost,定位到了模型定义。然后它断定 Item 没有 cost 属性, 漏掉了最后一步关联:service.py 应该用 item.price。

工具运转正常,证据也都在。推理只差一步就到头了。

为什么?

这个智能体过早地押在了一条推理路径上。一旦它走上"Item 有哪些属性?“这条 路,就会一路走到结论,不再回头考虑别的可能。一个人类调试同样的代码时也许会 停一下:等等——也许服务用了错误的属性名。让我看看模型实际定义了什么。

这个停顿就是一次在推理状态上的搜索。而这正是本章要讲的内容。

到目前为止,你的进阶顺序是:

15  智能体也是程序
        ↓
    给程序工具

16  搜索、记忆与长上下文
        ↓
    决定检视哪些证据

17  搜索推理空间                ← 本章
        ↓
    决定沿哪条推理路径前进

18  别让优化器作弊
        ↓
    约束搜索被允许知道什么

第 15 章确立了行动,第 16 章确立了证据选择。现在我们面对下一个问题:如果 失败不再是因为拿不到证据,而是过早地押在一条推理路径上呢?

关于本章是什么,先说一句。和前面的实验章节一样,本章以一个被运行、被测量的 程序收尾。但与它们不同的是,头条结果是一个空结果,而全章最有用的一句话,讲的 是这个实验没能做出的一项测量:

第 17 章的证据状态

要素 状态
在 DSPy 中构建的推理搜索智能体 已完成 —— 生成、一个 LM 价值函数,以及反思(LATS 拥有的它都有,只差对着环境行动)
这棵树是否真的在搜索 已审计 —— 早期版本并不分支;发现并修复了四个缺陷;27 个单元测试
带预算的七策略对比,外加预言机(oracle)对照 已运行 —— 种子 17–19,三次重复,运行在一个本地 8B 模型(qwen3)和一个更强的托管模型(muse-spark-1.3-contributor)上;见 17.8
树搜索是否比 Best-of-N 更会分配预算 未测量 —— 公平的树实验臂从未花掉它们的预算(17.8.2);这是这个实验诚实的缺口

在你原本期待一张排行榜的地方,你会看到一个空结果:在这个实验夹具上,没有 任何一种策略比单次直接调用产生实质性的诊断改进。唯一的数值偏差来自 qwen3 的一次 Random Tree 重复,它因为显式点名 service.py 多拿了四分之一分——这 是基于规则的评估器的措辞效应,而不是搜索策略优势的证据。这里没有任何东西 声称树搜索胜过 Best-of-N,或者反思配得上它的成本——这次运行两者都测不了。 唯一站得住的主张是结构性的:一次搜索有多可信,取决于它的价值函数被允许看 到什么证据。


17.1 从链到树

让我们沿着已经构建过的推理策略,梳理一遍它们的演进。

Predict:一次续写

语言模型最简单的用法:产出一个答案,然后停下。

answer = dspy.Predict(GenerateAnswer)(context=evidence, trace=[])

这里没有任何搜索。一次采样就被当成最终结果。第 15 章的智能体是同一形状的 更复杂版本——一条更长的单路径,但仍然只是一条路径,一路走到结论,从不回头 重新考虑另一种框架。

Best-of-N:若干独立的续写

下一个自然的基线是独立采样:

results = []
for _ in range(num_candidates):
    result = cot_program(context=evidence)
    results.append(result)

best = max(results, key=score_diagnosis)

现在我们独立地生成多条完整路径。每条路径都从同一起点出发,各自跑到完成, 互不参考对方。然后我们挑出最好的那条。

这就是广度——但只存在于叶子上。路径之间从不互动。一个有希望的早期步骤,得 不到比一条死胡同更多的关注。

树搜索:续写的续写

如果我们能做到这些呢:

  1. 生成若干候选的下一步
  2. 评估哪条部分路径看起来有希望
  3. 把更多算力花在扩展有希望的路径上
  4. 从弱路径上回退

这就是在推理状态上的树搜索。

    graph TD
    A[起点:仓库证据] --> B[第 1 步:item.cost 缺失]
    A --> C[第 1 步:服务用了错误属性]
    A --> D[第 1 步:模型定义被改过]
    
    B --> E[第 2 步:检查 Item 字段]
    B --> F[第 2 步:检查 import]
    
    C --> G[第 2 步:对照 model.py]
    C --> H[第 2 步:追踪 service.py 用法]
    
    D --> I[第 2 步:git 历史]
    D --> J[第 2 步:schema 迁移]
    
    G --> K[第 3 步:price 还是 cost → 定位修复]
    E --> L[第 3 步:cost 确实缺失]
    
    style K fill:#2ecc71,color:white
    style L fill:#e74c3c,color:white
  

关键区别在于:部分路径在完成之前就会被评估,计算资源会被重新分配给树 上最有希望的区域。


17.2 推理状态

在构建搜索之前,我们得先定义搜索的对象是什么。

状态

一个状态是推理过程中的当前点。在我们的实现中:

class TraceStep(dspy.Signature):
    """Produce the next reasoning step given what is known."""
    context = dspy.InputField(desc="The repository evidence")
    trace = dspy.InputField(desc="Reasoning steps so far")
    reasoning = dspy.OutputField(desc="Next reasoning step")

状态包含:

  • context:来自第 15 章的冻结证据
  • trace:到目前为止走过的推理步骤序列

对于一个树节点,状态表示为:

class MCTSReasoningNode:
    def __init__(
        self,
        state: dict,
        trace: list[str] | None = None,
        parent: "MCTSReasoningNode" | None = None,
        depth: int = 0,
        node_id: str | None = None,
    ):
        self.state = state          # the accumulated state
        self.trace = trace or []    # path of reasoning steps to reach this state
        self.parent = parent        # parent node in tree
        self.children: list[MCTSReasoningNode] = []
        self.visits = 0             # times this node was selected
        self.reward = 0.0           # accumulated return through this node
        self.score = 0.0            # evaluation of just this node's state
        self.depth = depth
        self.id = node_id or str(uuid.uuid4())

这是有意为之的简单。轨迹就是一个字符串列表,状态就是一个字典。不需要任何 花哨的数据结构。

轨迹

trace 是到达当前状态所走过的路径。它就是推理历史:

trace = [
    "service.py calls item.cost on line 42",
    "model.py defines Item with a price field on line 18",
    "Checking if cost is aliased... no alias found",
]

轨迹中的每个元素,都是语言模型生成的一步推理。轨迹定义了我们在搜索空间中 的位置。

子节点

一个子节点通过以下步骤创建:

  1. 取当前的状态与轨迹
  2. 让 LM 产出下一步推理
  3. 用延长后的轨迹创建一个新节点
def _predict_next(self, node: MCTSReasoningNode) -> dspy.Prediction:
    """Generate the next reasoning step given node's state."""
    return self.reasoning(context=node.state["context"], trace=node.trace)

这是搜索中生成的那一半。LM 负责提出,树结构决定哪些提议会被扩展。


17.3 选择、扩展、评估、回传

MCTS(蒙特卡洛树搜索)由四个操作构成。让我们从第一性原理把每一个都推导出来。

选择:下一份算力该花在哪里?

在任意时刻,树上都有许多前沿节点——也就是可能被扩展的节点。我们的算力预算 是有限的(LM 调用很贵)。我们需要一条策略来决定下一个扩展哪个节点。

最简单的策略:总是扩展当前得分最高的节点。这是贪心的,只利用不探索。 如果当前最好的路径其实是条死胡同,我们就会把整个预算浪费在它上面。

相反的策略:均匀随机地扩展节点。这能广泛探索,却会把预算浪费在明显走不通的 路径上。

我们想要的是:在探索与利用之间取得平衡。把更多算力花在有希望的路径上, 同时保留足够的探索,以便发现更好的路径。

这就是 UCT 选择规则所处理的探索与利用问题。对一个子节点而言,通常的形式使 用的是父节点的访问次数,而不是一个全局的树计数器:

def _select(self, node: MCTSReasoningNode) -> MCTSReasoningNode:
    """Select a leaf node for expansion using UCT."""
    while node.children and not self._is_terminal(node):
        if len(node.children) < self.branching_factor:
            # This node hasn't been fully expanded yet
            return node
        # Move to best child according to UCT
        node = max(node.children, key=lambda c: self.uct_value(c))
    return node

两种情形:

  1. 节点的子节点少于 branching_factor → 扩展它(再加一个子节点)
  2. 节点已完全扩展 → 按 UCT 下降到最好的子节点

这给了我们一个固定的分支上限:一个节点可以不断获得子节点,直到达到 branching_factor;此后选择只沿着它已有的子节点下降。这不是通常意义上的渐进 加宽(progressive widening)。渐进加宽会让允许的子节点数量本身随访问次数增 长;这个实现只是把宽度封顶在一个配置值上。

扩展:生成新状态

选中一个叶节点之后,我们生成一个子节点:

def _expand(self, node: MCTSReasoningNode) -> MCTSReasoningNode:
    """Create a new child node by generating the next reasoning step."""
    prediction = self._predict_next(node)
    new_trace = node.trace + [prediction.reasoning]
    new_state = {**node.state, "last_step": prediction.reasoning}
    
    child = MCTSReasoningNode(
        state=new_state,
        trace=new_trace,
        parent=node,
        depth=node.depth + 1,
    )
    node.children.append(child)
    return child

子节点的轨迹是父节点的轨迹加上一步新的推理。子节点的状态是父节点的状态再 加上这一步。子节点的深度比父节点大一。

推理生成器就是在这里被调用的。在一个最小实现里,一次未命中缓存的扩展消耗一 次生成调用。这还不是一次模拟的全部推理成本:评估可能还会调用一个由模型支撑 的评分器,最终答案的合成也可能需要再一次模型调用。实验必须统计全部推理 工作,而不只是推理生成器跟踪的那些调用。

评估:这条部分路径有多好?

扩展之后,我们要给新节点打一个分。在完整的 MCTS 中,这通常涉及从新节点跑 到一个终止状态的模拟(rollout)。在我们更简单的版本里,我们直接评估这条部分 路径:

def _evaluate(self, node: MCTSReasoningNode) -> float:
    """Evaluate a reasoning state and return a numeric score."""
    prediction = self.score_fn(
        context=node.state["context"],
        trace=node.trace,
    )
    return float(prediction.score)

在一个干净的教学实现里,搜索时的评估器本身就是一个 DSPy 签名(Signature) ——ScoreReasoning,完整代码见 17.5 节。要记住的要点是:如果那个评分器由模 型支撑,每一次节点评估都是一次模型调用,预算核算必须把它算进去(17.4 节)。

回传:传播证据

评估完一个节点之后,我们把分数沿树向后传播:

def _backpropagate(self, node: MCTSReasoningNode, reward: float) -> None:
    """Propagate reward from this node up to the root."""
    current: MCTSReasoningNode | None = node
    while current is not None:
        current.visits += 1
        current.reward += reward
        current = current.parent

被评估节点的每个祖先都会得到:

  • 多一次访问(它们也算"参与"了这次模拟)
  • 奖励累加到它们的累积奖励上

这意味着一个节点的平均奖励(reward / visits)反映了所有经过它的路径的平均 质量。如果一个节点通向好的结果(得分高的子节点和孙节点),它的平均奖励就上 升;如果它通向死胡同,平均奖励就下降。

树深处的信息就是这样回传上来,引导浅层的选择的。


17.4 搜索循环

把它们全部放在一起:

def run(self, context: dict, **kwargs) -> MCTSAgentResult:
    """Run MCTS over reasoning paths."""
    self._reset_state()
    root = self._create_root(context)
    root.id = "root"
    self._all_nodes.append(root)

    for simulation in range(self.num_simulations):
        # BUDGET CHECK: stop if we've exceeded LM call budget
        if self.lm_call_count >= self.max_lm_calls:
            self._log_info(f"LM call budget reached: {self.lm_call_count}")
            break
        
        # 1. SELECT
        leaf = self._select(root)
        
        # 2. CHECK TERMINAL
        if self._is_terminal(leaf):
            self._backpropagate(leaf, leaf.score)
            continue
        
        # 3. EXPAND
        child = self._expand(leaf)
        self._all_nodes.append(child)
        
        # 4. EVALUATE
        score = self._evaluate(child)
        child.score = score
        
        # 5. BACKUP
        self._backpropagate(child, score)
        
        # 6. EARLY STOP CHECK
        if self.early_stop_threshold and score >= self.early_stop_threshold:
            self._log_info(f"Early stop at simulation {simulation + 1}: score {score:.3f}")
            break
    
    # After search: find best paths
    return self._finalize_result(root)

循环的每一次迭代就是一次搜索模拟。在这个基础版本里,它包含一次扩展调用加一 次评估——而 17.5 节还会在这里加上第三次 LM 调用:当评估分数低时的一次反思。 如果 ScoreReasoning 由模型支撑,那么在最终答案合成之前,每次模拟就已经有两 到三次模型调用了。在为本章审计的源实现中,calls_used 统计的是生成器调用, 并没有把评分或反思路径内部的模型工作算进去。因此,对于本章后面的实验,预算 必须按模型调用总次数、token 或墙钟成本来定义,而不是信任某一个内部计数器。

让我们把完整流程可视化:

    sequenceDiagram
    participant S as 搜索控制器
    participant LM as 语言模型
    participant SC as 评分器
    participant T as 树

    S->>T: 选择叶节点
    T-->>S: 返回选中的节点
    
    S->>LM: 生成下一步 (context, trace)
    LM-->>S: 新的推理步骤
    
    S->>T: 添加子节点
    
    S->>SC: 给新节点打分 (context, 延长后的轨迹)
    SC-->>S: 分数 0.0 - 1.0
    
    S->>T: 回传分数
    T-->>S: 更新祖先
    
    Note over S: 继续下一次模拟<br/>或在超出预算时停止
  

这就是整个算法。四个简单操作,组合在一个循环里。复杂性藏在细节里——怎么选择、 怎么评估、怎么平衡探索——但核心结构是简单的。


17.5 用 DSPy 构建它

让我们把完整的智能体构建出来。与 LM 交互的签名用 DSPy,树的机制用普通 Python。

签名

import dspy

class TraceStep(dspy.Signature):
    """Produce the next reasoning step for diagnosing a repository issue."""
    context = dspy.InputField(desc="The repository evidence")
    trace = dspy.InputField(desc="Reasoning steps taken so far")
    reflections = dspy.InputField(desc="Lessons from earlier failed paths; may be empty")
    reasoning = dspy.OutputField(desc="Next reasoning step to investigate")

class ScoreReasoning(dspy.Signature):
    """Evaluate how promising a reasoning path is."""
    context = dspy.InputField(desc="The repository evidence")
    trace = dspy.InputField(desc="Reasoning steps taken so far")
    score = dspy.OutputField(desc="Float score 0-1 for this reasoning path")

class Reflect(dspy.Signature):
    """Given a reasoning path that scored poorly, state one concrete lesson for
    the next attempt. Do not restate the answer; name the wrong assumption."""
    context = dspy.InputField(desc="The repository evidence")
    failed_trace = dspy.InputField(desc="A low-scoring reasoning path")
    failed_score = dspy.InputField(desc="Its score, 0-1")
    lesson = dspy.OutputField(desc="One sentence: what this path got wrong")

class GenerateAnswer(dspy.Signature):
    """Generate the final diagnosis based on the best reasoning path."""
    context = dspy.InputField(desc="The repository evidence")
    trace = dspy.InputField(desc="Best reasoning path found")
    diagnosis = dspy.OutputField(desc="Final diagnosis")

四个 LM 角色:生成下一步(TraceStep)、给一条部分路径估值 (ScoreReasoning)、对死胡同进行反思(Reflect),以及合成最终答 案(GenerateAnswer)。生成、估值与反思都在搜索期间运行;合成只在最后运 行一次。这个清单里唯一缺少的 LATS 角色是行动——这些签名没有一个接触环境 ——17.6 节会回到这一点。

智能体类

class MCTSDiagnosisAgent:
    def __init__(
        self,
        lm: dspy.LM | None = None,
        branching_factor: int = 3,
        max_depth: int = 4,
        num_simulations: int = 12,
        ucb_weight: float = 1.41,
        early_stop_threshold: float = 0.85,
        max_lm_calls: int = 20,
        top_k_leaves: int = 3,
        reflect: bool = True,
        reflect_threshold: float = 0.4,
    ):
        # Set up DSPy with the documented public configuration API
        dspy.configure(lm=lm)

        self.reasoning = dspy.ChainOfThought(TraceStep)
        self.score_fn = dspy.Predict(ScoreReasoning)
        self.reflect_fn = dspy.Predict(Reflect)
        self.answer_fn = dspy.ChainOfThought(GenerateAnswer)

        # Search parameters
        self.branching_factor = branching_factor
        self.max_depth = max_depth
        self.num_simulations = num_simulations
        self.ucb_weight = ucb_weight
        self.early_stop_threshold = early_stop_threshold
        self.max_lm_calls = max_lm_calls
        self.top_k_leaves = top_k_leaves
        self.reflect = reflect
        self.reflect_threshold = reflect_threshold

        # State tracking
        self.lm_call_count = 0
        self._all_nodes: list[MCTSReasoningNode] = []
        self._node_lookup: dict[str, MCTSReasoningNode] = {}
        self._reflections: list[str] = []
        self._total_visits = 0

构造函数设置了:

  • 用于生成、评分、反思与答案合成的 DSPy 预测器
  • 搜索超参数,包括反思是否开启,以及分数低于多少时会对一条路径进行反思
  • 状态跟踪(LM 调用计数、节点、访问次数、累积的反思)

这个智能体用 DSPy 的 ChainOfThought 做生成与答案合成,用 Predict 做评分 与反思。需要多步推理的地方用 CoT;需要单一判断的地方用 Predict。

搜索方法

def _reset_state(self) -> None:
    """Reset MCTS internal state."""
    self.lm_call_count = 0
    self._all_nodes = []
    self._node_lookup = {}
    self._reflections = []
    self._total_visits = 0
    self._lm_cache: dict[tuple, dspy.Prediction] = {}

def _predict_next(self, node: MCTSReasoningNode) -> dspy.Prediction:
    """Generate the next reasoning step given node's state."""
    cache_key = (json.dumps(node.state, sort_keys=True), tuple(node.trace))
    if cache_key in self._lm_cache:
        return self._lm_cache[cache_key]

    self.lm_call_count += 1
    result = self.reasoning(
        context=node.state["context"],
        trace=node.trace,
        reflections=self._reflections,
    )
    self._lm_cache[cache_key] = result
    return result

注意 (state, trace) 上的缓存。它会让兄弟节点的扩展返回完全相同的子节点, 而且——一旦下面加入反思——它还会奉上一个在搜索学到任何东西之前就生成的续 写。17.7 节正是出于这些原因把它移除了。

完整的运行循环:

def run(self, context: dict, **kwargs) -> MCTSAgentResult:
    """Run MCTS search over reasoning paths."""
    self._reset_state()
    root = self._create_root(context)
    root.id = "root"
    self._all_nodes.append(root)
    self._node_lookup[root.id] = root

    for simulation in range(self.num_simulations):
        # Budget check
        if self.lm_call_count >= self.max_lm_calls:
            self._log_info(f"LM call budget reached: {self.lm_call_count}")
            break
        
        # 1. Selection
        leaf = self._select(root)
        
        # 2. Terminal check
        if self._is_terminal(leaf):
            self._backpropagate(leaf, leaf.score)
            continue
        
        # 3. Expansion
        child = self._expand(leaf)
        self._all_nodes.append(child)
        self._node_lookup[child.id] = child
        
        # 4. Evaluation
        score = self._evaluate(child)
        child.score = score
        
        # 5. Backup
        self._backpropagate(child, score)
        
        # 6. Early stop
        if self.early_stop_threshold and score >= self.early_stop_threshold:
            self._log_info(f"Early stop at simulation {simulation + 1}")
            break
    
    # Generate final answer from best path
    return self._finalize_result(root)

选出最佳路径

搜索结束之后,我们需要提取最好的推理路径,并生成最终答案:

def _finalize_result(self, root: MCTSReasoningNode) -> MCTSAgentResult:
    """Extract best paths and generate final answer."""
    # Find top paths by score
    scored_paths = []
    for node in self._all_nodes:
        if node.trace and node.score > 0:
            scored_paths.append({
                "node_id": node.id,
                "trace": node.trace,
                "score": node.score,
                "visits": node.visits,
                "depth": node.depth,
                "children_count": len(node.children),
            })
    
    scored_paths.sort(key=lambda x: x["score"], reverse=True)
    top_paths = scored_paths[: self.top_k_leaves]

    # Generate the final answer from the best path
    best_path = top_paths[0] if top_paths else None
    if best_path:
        answer = self.answer_fn(
            context=root.state["context"],
            trace=best_path["trace"],
        )
    else:
        answer = None

    return MCTSAgentResult(
        best_diagnosis=answer.diagnosis if answer else "",
        best_trace=best_path["trace"] if best_path else [],
        top_k_paths=top_paths,
        total_nodes=len(self._all_nodes),
        total_simulations=self.num_simulations,
        generator_calls=self.lm_call_count,
        # ... total scorer calls, tokens, latency, tree statistics
    )

注意最后那条注释。generator_calls 统计的是 self.reasoning 发出的调用。 它没有统计 _evaluate 里的评分器调用、下面加入的反思调用,或最后的 answer_fn 调用。任何只用 generator_calls 表达的预算,都会低估真实的推理成 本——这一点 17.4 节已经指出,而 17.8 节必须围绕它来设计。

反思:从死胡同中学习

到目前为止,Best-of-N 和朴素的树共享一个弱点:一条失败的路径没有教会搜索任 何东西。来自兄弟节点的下一次扩展,起点正是失败路径用过的那个上下文,于是可 能径直走进同一个错误。LATS 用反思闭合了这个回路——当一条轨迹得分很差 时,模型写下为什么,而这条笔记会加入之后每次扩展都会看到的上下文。

教学用的智能体用上面的 Reflect 签名和一个方法把反思加进来:

def _reflect(self, node: MCTSReasoningNode) -> None:
    """Record one lesson from a poorly scored path."""
    self.lm_call_count += 1
    lesson = self.reflect_fn(
        context=node.state["context"],
        failed_trace=node.trace,
        failed_score=node.score,
    ).lesson
    self._reflections.append(lesson.strip())

_predict_next 已经把 self._reflections 传给生成器(见上文)。循环里唯一 的改动,是在低分之后、回传之前调用 _reflect:

        score = self._evaluate(child)
        child.score = score
        if self.reflect and score < self.reflect_threshold:
            self._reflect(child)
        self._backpropagate(child, score)

有两件事必须保持诚实。反思意味着更多的模型调用——每条坏路径一次——所以它和 评分一样必须进入预算核算;一次开启反思的 MCTS 运行与一次不开反思的运行是成 本不同的条件,17.8 节把它们当作不同的实验臂来处理。而且反思本身也是一个可能 出错的 LM 输出。搜索把它加进生成器读取的上下文;从不把它加进价值函数,也不 把它当作约束。它改变的是被尝试什么,而不是什么算好——这与第 14 章为 GEPA 的反馈通道划出的是同一条边界。


17.6 这个智能体是什么——不是什么

让我们准确地说清楚我们构建的是什么。

这个智能体是什么

这是一个在推理状态上的树搜索。它使用:

  • 一个语言模型来生成候选的下一步推理(TraceStep)
  • 树状结构的状态,同时容纳多条推理路径
  • 用 UCT 平衡探索与利用
  • 一个由模型支撑、在搜索期间被消费的价值函数(ScoreReasoning → _evaluate → 回传 → UCT)
  • 反思:一条失败的路径产出一条教训,供之后的扩展阅读(Reflect)
  • 反向传播,把证据从树的深处移到浅层的选择处

这个智能体不是什么

这不是完整的 LATS(Language Agent Tree Search),而差距如今只剩一件事 了。LATS 把 MCTS 与 LM 推理、一个 LM 价值函数、自我反思,以及对着环境行动 结合在一起。这里的智能体拥有前三者:

LATS 组件 这个智能体
LM 下一步生成 ✅ TraceStep
树状态 + UCT 选择 ✅
引导搜索的 LM 价值函数 ✅ ScoreReasoning,由 UCT 消费
反向传播、预算、早停 ✅
搜索期间的自我反思 ✅ Reflect
对着环境行动 ❌ 没有工具,搜索过程中没有观察

这里的每个节点都是一个想法。在 LATS 中,一个节点可以是一个动作——调用一 个工具、读一个文件、跑一个测试——而它的子节点以真正返回的观察为条件。那才是 第 15 章的工具智能体跑在这棵树里,而那是一个真正更大的构建:搜索按环境返回的 东西分支,而不只是按模型想象的东西。本章有意停在离那一步还差一个台阶的地方。 给推理搜索加上工具,是自然而然的下一个项目,不是一段话能带过的。

关键区分:搜索时价值与事后评估

这一小节的要点关乎价值函数在数据流中的位置,而不是它叫什么名字。

教学用的智能体有一个搜索时价值函数。ScoreReasoning 在 _evaluate() 内部运行,它的结果沿树回传,UCT 消费这些回传的奖励来决定接下来往哪里搜索:

ScoreReasoning → _evaluate() → node.score → _backpropagate() → UCT 选择

触发本章的那个源实现,还带有一个单独命名的 ValueEstimator。它看起来像 LATS 论文里的价值函数,但它在搜索之后运行一次,作用于选中的轨迹:

ValueEstimator → (只在搜索之后运行) → 给选中的答案打分

搜索里没有任何东西读取它的输出。按照第 5 章的规则——追踪究竟是谁在消费一个 价值——ValueEstimator 是一个名字有误导性的事后评估。一个组件只有在选择规则 依赖它时,才算搜索策略的一部分。


17.7 在测量之前先把搜索修好

这个规模的实现正是有趣 bug 藏身的地方,其中几个会悄悄地让建立在这个智能体之 上的任何对比作废。每一类缺陷都会产出看似合理的输出和看似合理的轨迹,而实际 做的事并不是代码看上去在做的事。

问题 1:缓存让分支塌缩

_predict_next 方法按 (state, trace) 做缓存:

cache_key = (json.dumps(node.state, sort_keys=True), tuple(node.trace))
if cache_key in self._lm_cache:
    return self._lm_cache[cache_key]

当同一个父节点再次被扩展时,(state, trace) 这个键完全相同,于是每次兄弟调 用都返回第一个被缓存的续写。得到的不是三个不同的子节点,而是:

父节点
├── 子节点 A(想法 1)
├── 子节点 B(想法 2)
└── 子节点 C(想法 3)

我们得到的是:

父节点
├── 子节点 A(想法 1)
├── 子节点 A(想法 1)  ← 重复
└── 子节点 A(想法 1)  ← 重复

17.1 节的树图仍然渲染得出来;而它底下的搜索,却在重复同一个子节点。画出一棵 树,并不意味着你在探索一棵树——这正是 17.7 存在的全部理由。

修复:不要按 (state, trace) 记忆化兄弟采样。当请求是"再给我同一个续写” 时,缓存才是对的;而扩展要的是来自同一个父节点的另一个候选续写。

移除这个缓存,让多样性成为可能;但它不保证多样性。在确定性或低方差的生成下, 两次全新的调用仍可能返回同一个续写。因此,一个真正的搜索实验需要一条显式的兄 弟多样性策略——例如受控采样或多次生成——并且必须报告 unique_traces 和重复 率,而不是假定三次调用就创建了三条分支。

问题 2:奖励被重复计数

早期版本的 _evaluate() 把分数直接加到了节点上:

def _evaluate(self, node: MCTSReasoningNode) -> float:
    score = float(self.score_fn(context=node.state["context"], trace=node.trace).score)
    node.reward += score          # BUG: _backpropagate adds it again
    return score

接着 run() 调用 _backpropagate(child, score),它从子节点一路走到根,在每个 节点上加上 reward。因此被评估的节点收到它的分数两次——一次来自 _evaluate,一次来自 _backpropagate——而它的祖先只收到一次。相对于其他所有 节点,它的平均奖励被抬高了,UCT 会过度选择它下面的子树。

修复:_evaluate 返回分数,不做任何修改。_backpropagate 是 reward 和 visits 唯一发生变化的地方:

def _evaluate(self, node: MCTSReasoningNode) -> float:
    return float(self.score_fn(context=node.state["context"], trace=node.trace).score)

def _backpropagate(self, node: MCTSReasoningNode, reward: float) -> None:
    current = node
    while current is not None:
        current.visits += 1
        current.reward += reward
        current = current.parent

现在,被评估的节点和它的每个祖先都恰好得到一次分数。

问题 3:UCB 权重为 0 并不意味着零

当前代码:

ucb_weight or self.ucb_weight

这里有 bug,因为 0 or self.ucb_weight 返回的是 self.ucb_weight。你无法用 ucb_weight=0 来表示"纯利用"。

修复:

weight = self.ucb_weight if ucb_weight is None else ucb_weight

现在:

  • ucb_weight=None → 使用默认值
  • ucb_weight=0 → 纯利用(没有探索加成)
  • ucb_weight=1.41 → 标准的 UCB 平衡
  • ucb_weight=3.0 → 激进的探索

问题 4:每次运行的状态没有被完全重置

为本章审计的源实现,在开始一次新搜索之前,只重置了运行范围状态的一部分。上 面的教学类用了不同的字段名,但不变量是一样的:计数器、节点、查找表、缓存,以 及迄今最优状态,都必须属于一次运行,而不是 Python 对象的生命周期。

如果同一个智能体实例在没有清空这些可变状态的情况下被复用,后面的一个条件 就可能从前面的条件继承调用预算的消耗、树节点、缓存的输出,或选择状态。这会 同时污染行为和测量。

修复:运行会修改的每个字段,都在 run() 开头重置,而不只是在 __init__ 里:

def _reset_state(self) -> None:
    self.lm_call_count = 0
    self._all_nodes = []
    self._node_lookup = {}
    self._total_visits = 0
    self._lm_cache = {}
    self._best_so_far = None
    self._t0 = time.perf_counter()

这样一来,一个智能体实例就可以安全地在下面对比的各个条件之间复用——这一点很 重要,因为该对比会在一个进程里让它跑过其中好几个条件。


17.8 运行带预算的搜索实验

先讲设计——条件、预算核算、指标、泄漏对照——再讲它产生的两次运行。两次运行 用同一套脚手架;第二次只改了模型。

实际上有两个问题:

问题 A:更多的推理时算力对这个诊断任务有帮助吗?

而在花掉那份额外算力的前提条件下:

问题 B:树搜索是否比更简单的多候选策略更会分配预算?

不要把这两个问题混为一谈。一次调用的直接基线是有用的,但它并不是一个与十二次 扩展的树算力相当的对手。事实证明(17.8.4),这次运行回答了 A,却回答不了 B。

实验条件

条件 策略 搜索/生成预算
Direct 一个答案,无显式搜索 1 次生成
ChainOfThought 一个带推理的答案 1 次生成
Best-of-N 相互独立的完整候选 12 次生成
Greedy Tree 树扩展,无探索加成 12 次扩展
MCTS 树扩展 + UCT 12 次扩展
MCTS − reflection 同上,reflect=False 12 次扩展
Random Tree 采用真正随机的子节点选择策略的树扩展 12 次扩展

公平的策略对比主要是 Best-of-N vs. Greedy Tree vs. MCTS vs. Random Tree, 因为这些条件得到相同的扩展预算。Direct 和 ChainOfThought 告诉我们,相比一次调 用的基线,额外的测试时算力买到了什么。MCTS − reflection 这个实验臂只隔离 一件事:反思调用是否挣回了它的额外成本,还是树搜索自己就在完成工作。

只看扩展次数仍然不够。MCTS 条件还会花掉评分器调用和反思调用;每个条件都以一 次合成调用收尾。要把生成、评分、反思与合成调用分别记录,外加总 token 和延迟, 并把质量对照总推理成本来比较——而不是对照扩展次数。

指标

对每个条件,记录:

@dataclass
class ExperimentResult:
    condition: str
    final_diagnosis_score: float
    semantic_failures: list[str]
    generation_calls: int
    scorer_calls: int
    reflection_calls: int
    synthesis_calls: int
    tokens_used: int
    latency_seconds: float
    nodes_created: int
    unique_nodes: int
    unique_traces: int
    max_depth_reached: int
    duplicate_rate: float
    best_path_score: float
    chosen_path_score: float
    trajectories: list[dict]

这四个调用计数是有意分开的。“MCTS 用了 12 次扩展"和"MCTS 发起了 31 次模型调 用"都是真的,而只有后者才能与 Best-of-N 的 12 相比。

final_diagnosis_score 是一个仅供评估的量。它可以在一个条件结束之后,把 最终诊断与已知答案作比较,但不能被用来在 Best-of-N 候选之间做选择,也不能被用 来引导一次公平的树搜索。那些决策必须使用同一个可采信的价值策略、不看参考答 案,而所有这些评分器调用都属于成本核算。17.9 节的预言机实验臂是刻意设计的例 外,正因如此,它的结果在构造上就是无效的。

unique_traces 指标同样重要。它告诉我们,树搜索是真的探索了多样的路径,还 是只是把同一条路径复制了多次。

数据

复用第 15 章那个坏掉的仓库作为测试用例。证据包是冻结的——只有相关代码摘录, 再无其他——而正确诊断是已知的:Item 定义了 price,而 service.py 用的却 是 item.cost。正因如此,分数才有意义。它同时也是 n=1:一个缺陷,一个仓库, 正是第 15 章在它所测量的那个智能体上就已经指出的范围限制。

脚手架

def run_experiment(condition: str, evidence: dict, lm: dspy.LM) -> ExperimentResult:
    if condition == "direct":
        # Direct answer
        result = dspy.Predict(GenerateAnswer)(
            context=evidence, trace=[]
        )
        return evaluate_direct(result)
    
    elif condition == "cot":
        # Single ChainOfThought path
        result = dspy.ChainOfThought(GenerateAnswer)(
            context=evidence, trace=[]
        )
        return evaluate_cot(result)

    elif condition == "best_of_n":
        # N independent CoT paths
        paths = []
        for _ in range(12):
            pred = dspy.ChainOfThought(GenerateAnswer)(
                context=evidence, trace=[]
            )
            paths.append(pred)

        # Selection must use the same admissible value policy as the
        # tree conditions. These scorer calls count toward total cost.
        scored_paths = [
            (admissible_score_path(evidence, pred), pred)
            for pred in paths
        ]
        best = max(scored_paths, key=lambda item: item[0])[1]
        return evaluate_path(best)
    
    elif condition == "greedy_tree":
        agent = MCTSDiagnosisAgent(
            lm=lm,
            ucb_weight=0.0,  # pure exploitation
            branching_factor=3,
            num_simulations=12,
        )
        return evaluate_agent(agent)
    
    elif condition == "mcts":
        agent = MCTSDiagnosisAgent(
            lm=lm,
            ucb_weight=1.41,
            branching_factor=3,
            num_simulations=12,
        )
        return evaluate_agent(agent)

    elif condition == "random_tree":
        agent = RandomTreeDiagnosisAgent(
            lm=lm,
            branching_factor=3,
            num_simulations=12,
        )
        return evaluate_agent(agent)

evaluate_agent 运行智能体,用已知答案为它的诊断打分,并且——关键在于——把 评分器调用、合成调用、token 和延迟与分数一并记录下来,好让"12 次扩展"无法掩 藏一个实际上花了 Best-of-N 三倍模型调用的树条件。

17.8.1 Qwen3 基线运行

第一次运行用了与全书其余部分相同的本地模型:ollama_chat/qwen3:latest,一个 8B 模型,think=False,生成温度 0.7,评分温度 0.0。三次重复,种子 17–19。产 物:.artifacts/dspy-book/ch17_reasoning_search/。

三次重复的均值:

条件 最终分数 模型调用 Token 延迟 树深度
Direct 0.75 1 378 4s —
ChainOfThought 0.75 1 505 5s —
Best-of-N 0.75 24 11,686 56s —
Greedy Tree 0.75 3 1,457 7s 1
MCTS 0.75 3 1,419 7s 1
MCTS − reflection 0.75 3 1,435 7s 1
Random Tree 0.83 3 1,428 7s 1
Oracle MCTS (无效 — 17.9) 0.75 25 6,562 28s 2–3

每个公平策略都落在 0.75 上。这个 0.75 并不是错误的诊断:每个公平实验臂都正确 地指出了 Item 定义了 price,而 service.py 读取的是 item.cost。差掉的 那四分之一分,来自基于规则的评估器对文件名字面的执着——它要求显式点出字符串 service.py,而 qwen3 的诊断描述了位置却没有引用它。Random Tree 的 0.83 是三 次重复中的一次(种子 18),它的措辞恰好点到了文件名;另外两次得 0.75。那是采 样噪声,不是策略效应。

Best-of-N 花了 24 次模型调用和大约 11.7k token,才达到树实验臂用 3 次调用、约 1.4k token 就达到的同一个 0.75——也是一次 Direct 调用用一次调用就达到的那个 0.75。在这个实验夹具上、用这个模型,额外的推理时算力什么也没买到。

17.8.2 为什么公平的树立刻就停了下来

正是这个发现,决定了这场对比的其余部分还能说多少。

每一次公平的树运行——Greedy、MCTS、MCTS − reflection、Random——记录下来的形 态都一样:nodes_created = 2、max_depth_reached = 1、unique_traces = 1, 一次生成调用、一次评分调用、一次合成调用。一次扩展,一次打分,一次合成。十二 次模拟的预算从未被用起来。

原因是搜索循环里的早停规则:当可采信的搜索时分数越过 early_stop_threshold (0.85)时就停下来。评分器给最初那次扩展打了 0.95–1.0——推理已经足够好——于 是循环在第 1 次模拟之后就退出了。分支因子 3 从未被用上。UCT 从未在兄弟节点之 间做选择。反思没有低分可以回应,从未触发。

所以,这次运行中的公平树实验臂并不是对树搜索的测量。它们测量的是"扩展一次、 打分一次、停下”。在这里,Greedy / MCTS / Random 这些标签无法区分,因为区分它 们的代码路径从未运行。

有两种办法能让这场对比真正检验预算分配,而两种都没有被采用:

  • 关闭早停,转而施加一个固定的调用预算;或者
  • 换用一个足够难的实验夹具,使第一次扩展无法越过阈值。

两者都会改变实验。它们都不是你可以悄悄拧动的旋钮;每一次都是一次公开的设计变 更,需要自己的运行和自己的报告。

17.8.3 用 Muse Spark 做更强模型的重复实验

协议被冻结——同一个实验夹具与指纹、同样四个签名、同样的评分器可采信规则、同 样的 0.85 阈值、同样的预算、同样的种子——只有一样变了:模型。 muse-spark-1.3-contributor,一个更强的托管模型(opencode-zen Responses API,reasoning_effort low),同时承担生成与搜索时评分两个角色。三次重复,种 子 17–19。产物:.artifacts/dspy-book/ch17_reasoning_search/muse-go-full/。

三次重复的均值,两个模型并排:

条件 qwen3 分数 qwen3 调用 qwen3 token Muse 分数 Muse 调用 Muse token
Direct 0.75 1 378 1.00 1 616
ChainOfThought 0.75 1 505 1.00 1 667
Best-of-N 0.75 24 11,686 1.00 24 16,352
Greedy Tree 0.75 3 1,457 1.00 3 1,884
MCTS 0.75 3 1,419 1.00 3 1,800
MCTS − reflection 0.75 3 1,435 1.00 3 1,835
Random Tree 0.83 3 1,428 1.00 3 1,930
Oracle MCTS (无效 — 17.9) 0.75 25 6,562 1.00 25 9,598

更强的模型抬高了天花板。每个公平策略都干净地拿到 1.00——Muse 的诊断显式点名 了 service.py,通过了那条此前扣掉 qwen3 分数的评估标准。而且每个公平策略拿 到 1.00 的方式同样平等:Direct 用一次调用、大约三秒;Best-of-N 用 24 次调 用、约 16k token、66–83 秒;树实验臂介于两者之间。“搜索"与"一次直接调用"之间 的差距恰好为零。

17.8.2 的早停行为精确复现:两个节点、深度 1、一条唯一轨迹,每次公平树运行一 次生成调用。更强的模型和较弱的模型一样,在第一次扩展就越过了 0.85 阈值,于是 公平的树再一次从未搜索。

17.8.4 对比仍然无法告诉我们什么

这次运行回答了问题 A,把问题 B 留在了开放状态。

问题 A——额外的推理时算力对这个诊断任务有帮助吗? 测量了两次:没有。在两 个模型上,每个策略的得分都与单次直接调用相同。Best-of-N 的 24 次调用和树的 3 次调用,相比 Direct 的 1 次什么也没买到。

问题 B——树搜索是否比 Best-of-N 更会分配固定预算? 未测量。公平的树实验臂 从未花掉它们的预算(17.8.2),所以根本没有预算分配行为可供比较。任何形如 “MCTS ≈ Best-of-N”、“MCTS 胜过 Best-of-N"或"MCTS 输给 Best-of-N"的陈述,都得 不到这次运行的支持——能够区分这些结果的条件根本没有执行。

这次运行确实确立的,准确地说是这些:

  • 修复后的机制在停止规则允许时,能够进行真正的树探索:预言机实验臂在全部十二 次模拟中都达到了深度 2–3,每次运行产出九到十二条唯一轨迹。由于那个实验臂由 预言机引导,这些轨迹只确立了评测框架的行为,而不是公平搜索的性能。
  • 在这一个实验夹具上(n = 1),对两个能力相差一代的模型而言,完全不用搜索也 能达到正确的诊断。
  • 预算诚实成立:成本列是真实的,按调用类型分别计数,Best-of-N 相比树实验臂 8 倍的调用次数没有被"12 次扩展"掩盖。
  • 模型之间 0.75 → 1.00 的变化是评估标准的效应(对文件名的字面执着),不是某个 模型对这个缺陷推理得更好的证据;两者都识别出了它。

它绝不能被读作:关于反思的证据(反思在公平实验臂里从未触发)、关于重复率的一 般性证据(这里是 0.00,但有一次预言机重复在温度 0.7 下达到了 0.25),或者树搜 索在一般意义上不必要的证据。诚实的范围只有一句话:在这个实验夹具上、用这两 个模型,树搜索是不必要的,因为这个任务不需要搜索。


17.9 为什么预言机引导的搜索是无效证据

17.8 的对比还带着一个额外的条件,而且是概念上最重要的那一个。它也是那一个必 须在运行之前就标记为无效、而不是之后的条件。

这个设置运行了两次 MCTS:

# A: Fair search
fair_agent = MCTSDiagnosisAgent(
    lm=lm,
    ucb_weight=1.41,
    branching_factor=3,
    num_simulations=12,
)
# ScoreReasoning sees only admissible evidence

# B: Oracle-guided search
class OracleScoreReasoning(dspy.Signature):
    """Score reasoning path using known answer."""
    context = dspy.InputField()
    trace = dspy.InputField()
    known_answer = dspy.InputField()
    score = dspy.OutputField(desc="Score comparing trace to known answer")

oracle_agent = MCTSDiagnosisAgent(
    lm=lm,
    ucb_weight=1.41,
    branching_factor=3,
    num_simulations=12,
)
oracle_agent.score_fn = dspy.Predict(OracleScoreReasoning)
# The oracle scorer sees the reference answer

预言机评分器把每条推理路径与已知的正确答案作比较,按路径离答案有多近来打分。 在两次运行中,它都做到了公平实验臂从未能做到的那件事:它搜索了。由于早停被刻 意关闭,三次重复都跑满了十二次模拟,构建了十三个节点,达到深度 2–3,产出九到 十二条唯一推理轨迹——两个模型上都是如此。它的最终诊断分数在 Muse 上是 1.00, 在 qwen3 上是 0.75,与公平实验臂完全一致。

作为关于可部署智能体的证据,这个结果毫无价值,而理由并不取决于这个数字。 无论它得多少分,这个条件都是无效的:

  1. 搜索时价值函数拥有在推理时并不存在的信息。
  2. 搜索并没有在发现答案;它是在被引导向一个被递给它的目标。
  3. 它产出的任何分数衡量的都是泄漏的强度,而不是推理的质量。

这正是加入这个条件的全部意义。它不是为了产出一个数字。它是为了让这场对比里有 一个已知无效的实验臂——一个其结果必须按原则丢弃的对照——紧挨着公平实验臂放 着,以此提醒人们:价值函数能看到什么,是实验有效性的一部分。

一个被允许消费推理时无法获得的信息的搜索程序,无论它的输出看起来多好,都无 法为可部署的程序提供有效证据。

这正是第 18 章随后在整个优化回路的尺度上做出的同一个论证,只是用 288 个构造出 来的攻击替代了一个设计好的对照。本节是它小而锋利的实例:实验防火墙不只是为优 化器和检索器准备的——它是为任何拥有价值函数的东西准备的,推理搜索也包括在内。

预言机实验臂配得上它的位置,还有第二个理由。它是两次运行中唯一真正花掉了搜索 预算的条件,因此它是唯一的直接证据,证明 17.7 里修复过的机制确实能探索一棵树 ——十三个节点、多达十二条不同轨迹、深度 3——而不是像有 bug 的版本那样塌缩成一 个子节点。评测框架是能工作的。它只是在公平实验臂里无事可做。


17.10 当更强的模型让搜索变得无关紧要

17.8 的两次运行并在一起,构成一个观察;值得谨慎地陈述,因为这里很容易说过头。

在这个实验夹具上:

  • 较弱的模型(qwen3,8B)在每种策略下第一次尝试就得到了正确诊断,额外的搜索 没有抬高分数;
  • 更强的模型(muse-spark-1.3-contributor)也一样,只是天花板更高。

两个模型在这里都不需要搜索,因为这个任务并不要求搜索。证据包是冻结的而且很 小,缺陷只是一个属性名不匹配,一次直接生成就足以点出它。搜索是在相互竞争的推 理路径之间分配算力;当第一条路径就抵达了答案,就没有东西需要分配了。

这个实验展示了搜索复杂度不必要的一个重要情形:证据已经在上下文里,缺陷是局部 的,一次生成就足以识别它。这种形态的任务,可能根本不值得显式的树搜索。在这次 实验中,被早停的公平树实验臂用了三次模型调用,Direct 用一次,而刻意无效的预 言机对照用了大约二十五次。从这个角度看,17.7 的审计反而更重要,而不是更不 重要:如果你要为搜索基础设施付费,你得知道搜索是真的——而且你需要一个能让它 挣回成本的任务。

这个实验没有展示的——四条范围护栏:

  • 不是“MCTS 等于 Best-of-N”。公平实验臂从未花掉预算;这场对比没有运行。
  • 不是“MCTS 比 Best-of-N 更高效”。同样的理由。树用的调用更少,只是因为它们 提前停了,而不是因为它们更聪明地分配了预算。
  • 不是“反思没有增加任何价值”。反思在公平实验臂里从未触发;这次运行对它正反 两面都不含任何信息。
  • 不是“树搜索不必要”。它在这个实验夹具上、用这两个模型是不必要的。一个更 难的缺陷、一个更大的证据空间,或一个需要串联多次推理的任务,都可能改变这张 表的每一行。

一般的教训关乎实验设计,而不是 MCTS:在为搜索付费之前,先确认这个任务不是 “一条推理路径就已经够了"的任务。 当 Direct 的得分与 MCTS 相同时,有意思的 问题不是"哪种搜索策略赢”——而是"我们为什么在搜索”。


通常会出什么错

这份实现和两次运行给出了一张实用的诊断表:

症状 可能原因 修复
树上有大量重复轨迹 (state, trace) 上的缓存阻碍了多样性 移除缓存;让 LM 生成新鲜样本
c=0 的 UCT 仍在探索 ucb_weight or default 把 0 当作假值 用 None 检查:weight if ucb_weight is not None else default
节点分数被抬高 _evaluate 和 _backpropagate 重复计数 只有 _backpropagate 修改奖励
搜索找到了绝佳路径,最终答案却没用它 价值函数与答案生成器不对齐 确保 GenerateAnswer 收到真正最好的轨迹
搜索质量在各次运行之间差异巨大 生成的随机性主导了搜索策略 固定并记录采样配置;重复这场对比;把温度或 n 当作公开的实验变量,而不是悄悄调整它们
LM 调用超出预算 评分与反思也消耗 LM 调用 为所有 LM 交互编预算——生成、评分、反思、合成——而不只是扩展
反思不起作用 教训太笼统(“仔细检查代码”) 阅读记录下来的教训;收紧 Reflect 签名,要求点名错误的假设;与 reflect=False 实验臂对比
找到了最好的路径却没有被选中 选择基于访问次数而不是分数 最终选择用分数,搜索策略用访问次数

本章小结

MCTS 不会让模型推理正确。它把推理时的计算分配给它的价值函数所偏好的那些推理 路径。

如果价值函数追踪的是任务,这很有用。如果价值函数有盲区,搜索就会把算力集中 在盲区周围。如果价值函数能看到参考答案,那就不是搜索推理得更好——而是实验在 泄漏。

这与优化器那几章的结构相同,只是应用到了一个新对象上:

优化器各章                  本章

程序候选                     推理候选
      ↓                           ↓
   指标                       搜索时价值
      ↓                           ↓
   选择                           选择
      ↓                           ↓
得分更高的候选               得分更高的候选

对象不同,危险相同:搜索不知道真理;搜索只知道奖励。

这就把本章放进了本书最后一段"搜索之物"的弧线里:

搜索程序状态                第 11–14 章
搜索环境/动作               第 15 章
搜索证据                    第 16 章
搜索推理状态                第 17 章  ← 本章
保护一切搜索                第 18 章
晋升                        第 19 章
组装一切                    第 20 章

本章开头的证据状态就是摘要:智能体已经建成,它的搜索行为经过 27 个单元测试的 审计,七策略对比也已运行——种子 17–19,三次重复,两个模型。对比返回了一个空 结果。在这个冻结的 cost-vs-price 实验夹具上,无论是一个 8B 本地模型还是一个 更强的托管模型,每种策略都达到了与单次直接调用相同的实质性诊断。qwen3 分数上 那点微小的波动,来自生成的措辞是否显式点名了 service.py,而不是来自不同的诊 断。而且这次运行根本无法检验它的第二个问题:公平的树实验臂从未花掉它们的搜索 预算,因为价值函数在第一次扩展时就满足了。

这不是一个令人失望的结果;这是一个精确的结果。它说明本章的分量落在审计上 ——17.7 和 17.8.2。看起来像搜索的源代码,仍然必须当作因果图来读:缓存可能让分 支塌缩,一个单独命名的事后 ValueEstimator 不会仅仅因为存在就引导搜索, ucb_weight=0 可能悄悄地没能关闭探索,而过期的运行状态可能污染下一个条件。一 场看起来像策略对比的实验,也仍然必须检查那些策略是否真的运行了——在这里它们 没有。17.9 的预言机条件展示了另一面:对比的有效性取决于真正的搜索时价值函数 被允许看到什么。一个搜索策略有多正当,取决于引导它的那个函数能获得多少证据。 下一章会在优化、工具、检索、记忆与推理搜索上封闭这条边界。

一个带有成文调用预算、轨迹缓存和定时评估策略的生产级推理搜索系统,摘录在第 21 章附录中。


延伸阅读

  • Tree of Thoughts(Yao et al., 2023):把审慎推理作为对思维树的搜索引 入。(arXiv:2305.10601)
  • Reasoning with Language Model is Planning with World Model(Hao et al., 2023):RAP 把推理当作规划,并使用 MCTS。 (arXiv:2305.14992)
  • Language Agent Tree Search(Zhou et al., 2023):LATS 把 MCTS 与 LM 推 理、行动和价值函数结合在一起。 (arXiv:2310.04406)
  • Monte Carlo Tree Search: A Review(Browne et al., 2012):MCTS 的权威综 述。(IEEE)