搜索推理空间
从第一性原理推导出建立在推理状态之上的 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)
现在我们独立地生成多条完整路径。每条路径都从同一起点出发,各自跑到完成, 互不参考对方。然后我们挑出最好的那条。
这就是广度——但只存在于叶子上。路径之间从不互动。一个有希望的早期步骤,得 不到比一条死胡同更多的关注。
树搜索:续写的续写
如果我们能做到这些呢:
- 生成若干候选的下一步
- 评估哪条部分路径看起来有希望
- 把更多算力花在扩展有希望的路径上
- 从弱路径上回退
这就是在推理状态上的树搜索。
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",
]
轨迹中的每个元素,都是语言模型生成的一步推理。轨迹定义了我们在搜索空间中 的位置。
子节点
一个子节点通过以下步骤创建:
- 取当前的状态与轨迹
- 让 LM 产出下一步推理
- 用延长后的轨迹创建一个新节点
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
两种情形:
- 节点的子节点少于
branching_factor→ 扩展它(再加一个子节点) - 节点已完全扩展 → 按 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,与公平实验臂完全一致。
作为关于可部署智能体的证据,这个结果毫无价值,而理由并不取决于这个数字。 无论它得多少分,这个条件都是无效的:
- 搜索时价值函数拥有在推理时并不存在的信息。
- 搜索并没有在发现答案;它是在被引导向一个被递给它的目标。
- 它产出的任何分数衡量的都是泄漏的强度,而不是推理的质量。
这正是加入这个条件的全部意义。它不是为了产出一个数字。它是为了让这场对比里有 一个已知无效的实验臂——一个其结果必须按原则丢弃的对照——紧挨着公平实验臂放 着,以此提醒人们:价值函数能看到什么,是实验有效性的一部分。
一个被允许消费推理时无法获得的信息的搜索程序,无论它的输出看起来多好,都无 法为可部署的程序提供有效证据。
这正是第 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)