思维树ToT：结构化推理Prompt技巧

可视化演示

展示ToT将问题分解为树状思维分支、评估各分支得分并选择最优推理路径的过程，逐步查看三个阶段。

思维树概述 —— 从单行道的短视到岔路口的权衡

还记得前面那位森林探险队长吗？一个固执的旅人只会挑一条路走到底，而探险队长却会在每个岔路口停下来，摊开路线图，评估多条岔路的前景再继续。普通Prompt是前者，思维链CoT（Chain of Thought）也只是让旅人“走得更稳的单行道”，而思维树ToT则是那个真正的探险队长——它把一条路的思考升级为一片树林的规划。

思维树最早由普林斯顿大学与谷歌DeepMind的团队在2023年提出，核心思想非常朴素：既然大模型在复杂推理时经常“一条路走到黑”，那我们就主动让它在每个关键节点生成多个候选思路，自己评估这些思路的价值，再选择性地继续深入。这样，模型就有了“退路”和“备选方案”，不再害怕走错路。

从技术上讲，ToT将推理过程抽象为一棵搜索树：树的根节点是原始问题，叶子节点是最终答案，中间节点是部分解（中间思维）。每个节点存储一个“状态”——即到目前为止已经得出的结论。模型的推理任务，变成了在这棵树上寻找一条从根到叶的价值最高的路径。

$$\displaystyle \pi^* = \arg\max_{\pi \in \text{Tree}(p)} \sum_{s \in \pi} V(s)$$

1. Tree(p)：从问题 $p$ 出发能展开的全部思维路径集合，等价于探险队长画出的整张路线示意图。

$$\text{Tree}(p) = \{\text{所有从根到叶子的思维路径}\}$$

2. π（路径）：一条从根节点走到叶子节点的连续思维链，代表一种完整的解题方案。

$$\pi = \{s_0, s_1, \dots, s_n\}$$

3. V(s)：每个思维节点的评分，表示走到这一步的把握有多大，分数越高这条路越有希望。

$$V(s) \in [0,1]$$

4. argmax：在所有候选路径中挑出累计分数最高的一条，这就是最终采用的推理路线。

$$\arg\max_{\pi} \sum_{s \in \pi} V(s)$$

所以ToT的本质，不是让模型“多想想”，而是让它“多想几条路、比较后选一条”。这就像探险家不需要每条路都走完，但至少要在岔路口认真观望过、比较过。这种“生成—评估—搜索”的循环，才是思维树与普通Prompt最大的分野。

思维节点定义 —— 探险地图上的路标

探险队长在森林里做记号时，不会只写“走到哪了”，而是会记录“我是怎么走到这里的”——比如“先绕过巨石，再跨过溪流”。思维树中的思维节点（Thought）正是这样的路标：它不是孤立的结论，而是包含了原始问题与所有已采取步骤的完整状态。

一个思维节点 $s_t$ 本质上是一个状态表示：原始问题加上已经走过的中间步骤。比如在解数学应用题时，模型先设未知数、再列方程、再化简，每一步都是一个新节点。节点的粒度（granularity）非常关键：如果粒度太粗，比如“再想想下一步怎么做”，模型等于没有引导；如果粒度太细，比如“把 2+3 的每一位拆开分析”，又会造成大量无效计算。好的节点粒度应该像探险路线上的关键地标——既不会太稀疏让人迷路，也不会太密集让人疲惫。

$$\displaystyle s_t = (p, a_1, a_2, \dots, a_{t-1})$$

1. s_t：第 $t$ 个思维节点，代表当前推理进行到哪一步，等价于地图上的第 $t$ 个路标。

$$s_t = \text{第 } t \text{ 时刻的推理状态}$$

2. p：原始问题，始终不变的问题起点，是路标的“锚点”。

$$p = \text{原始问题}$$

3. a_i（中间步骤）：前 $t-1$ 步已经采取的具体动作，记录路径历史。

$$a_i = \text{第 } i \text{ 步的思维动作}$$

4. 组合关系：完整状态 = 问题 + 全部历史。不同走法导致不同状态，这就是为什么同一个“位置”会存在多个不同节点。

$$s_t = (p, a_1, \dots, a_{t-1})$$

理解了节点的定义，就能理解为什么ToT可以支持“回溯”：因为每个节点都保存了完整的历史，探险队长可以随时沿着路标退回上一个岔路口，选择另一条候选路重走，而不至于在茫茫森林里彻底迷路。

多分支生成 —— 岔路口伸出多条候选路

探险队长不会在岔路口只朝一个方向迈步，他会先向几个方向各探几步再决定。思维树也一样：在每个节点上，模型不能只生成一个“下一步”，而要主动生成多个候选分支。这些分支就像是岔路口伸向不同方向的若干条路。

生成分支的方式通常有两种：一种是“采样式生成”，让模型基于当前状态，用较高的温度（temperature）采样 $K$ 个不同的中间思维；另一种是“建议式生成”，直接让模型扮演提议者，一口气提出 $K$ 种可能的下一步方案。为了保持分支间的多样性，还可以在提示词中要求“给出思路差异较大的候选方案”，避免模型生成三个换汤不换药的相似版本。

$$\displaystyle s_{t+1}^{(i)} \sim \mathrm{LLM}_\theta(\cdot \mid s_t, g), \quad i=1,2,\dots,K$$

1. LLM_θ：大语言模型本身，参数为 θ。它在这里扮演“候选思路生成器”的角色。

$$\mathrm{LLM}_\theta(\cdot \mid \text{上下文})$$

2. 条件概率：模型生成下一个思维的前提条件是当前状态 $s_t$——不同的路标位置，看到的岔路自然不同。

$$\text{候选思维} \sim \mathrm{LLM}_\theta(\cdot \mid s_t)$$

3. g（生成指令）：提示词中明确要求“生成多个候选”的部分，例如“请给出3种不同的解法思路”。

$$g = \text{"请生成 } K \text{ 个差异化候选分支"}$$

4. K（分支数）：每个节点生成的候选数量。通常 3-5 个为宜，太少缺乏选择空间，太多增加评估负担。

$$i = 1, 2, \dots, K$$

分支生成的本质，是给推理过程注入“自由度”。模型不再被逼着在每一步做唯一的选择，而是可以保留多个可能性。这就像探险家在不确定时不会急着锁定一条路，而是先让多条路线都保留在候选名单上，交给下一步的评估环节去裁决。

节点状态评估 —— 侦察兵的望远镜

有了多条候选路线，探险队长就需要一个“侦察兵”去判断每条路的前景。思维树里的评估器就是这位侦察兵：它负责对每个思维节点打分，告诉搜索算法“这条路值得继续走，那条路最好尽早放弃”。

评估的实现方式非常灵活。最直接的是“LLM评估”：把当前状态发给大模型，让它给出一个 0 到 1 之间的分数并附带理由；也可以是“投票评估”：让多个独立模型分别对状态进行二分类判断，再统计乐观比例作为得分；还可以是“规则评估”：用确定性的规则检查状态的性质，比如在24点游戏中检查中间结果是否是24的因子。选择哪种评估方式，取决于任务是否拥有可量化的中间反馈。

$$\displaystyle V(s) = \frac{1}{M} \sum_{j=1}^{M} \hat{V}_j(s)$$

1. V(s)：状态 $s$ 的最终价值分数，越高代表该节点的前景越好。

$$V(s) = \text{状态 } s \text{ 的价值}$$

2. 每个评估者打分：第 $j$ 个评估者对状态 $s$ 给出一个信任或成功概率。

$$\hat{V}_j(s) \in [0,1]$$

3. 平均汇总：所有评估者的分数取平均，消除单一评估者的随机噪声。

$$V(s)=\frac{1}{M}\sum_{j=1}^{M}\hat{V}_j(s)$$

评估的好坏直接决定了搜索的方向。如果侦察兵看走了眼，把好路标成废路、把死路标成捷径，整个搜索就会南辕北辙。所以在实际使用中，评估器的设计往往比分支生成更关键——它决定了“眼光”的准确度。

搜索策略 —— 遍历探险地图的方法

探险队长拿到了路线图和各路的情报，接下来就要制定遍历策略：先走哪条路？走到多深？什么时候换路？思维树中最常用的两种策略是广度优先搜索（BFS）和深度优先搜索（DFS）。

BFS的思路是：逐层推进——先把第1层的所有候选分支都生成并评估一遍，保留得分较高的若干个，再进入第2层继续。这种策略适合深度较浅但分支规则明确的任务，比如24点游戏，每一步的候选有限，逐层铺开更稳妥。DFS的思路是：沿一条路径一直走到最深处，如果走不通就回溯到最近的岔路口换一条路。这种策略适合路径很深的推理任务，比如代码调试或数学证明，一条路深挖比漫山遍野乱逛更高效。

$$\displaystyle s_{\text{next}} = \arg\max_{s \in \text{frontier}} \big( V(s) + \alpha \cdot \text{depth}(s) \big)$$

1. frontier（前沿集合）：所有已生成但尚未继续扩展的节点，类似于探险队笔记本上“待勘察路线”的清单。

$$\text{frontier} = \{s : s \text{ 已生成且未扩展}\}$$

2. V(s)：节点的评估分数，来自上一节的评估环节，是选路的首要依据。

$$V(s) = \text{状态价值分数}$$

3. α · depth(s)：深度惩罚项。α 为正数时奖励深挖，为负数时鼓励先铺开。用来平衡“深度”与“广度”。

$$\alpha \cdot \text{depth}(s) = \text{深度调节项}$$

在实际的ToT实现中，BFS通常会设置一个“束宽”（beam width），每一层只保留分数最高的若干个节点继续扩展，这本身就是一种剪枝。DFS则更依赖回溯机制：当某条路径走到头或评估分过低时，回到最近的合法父节点换一个分支。剪枝和回溯并不是独立的技术，而是融入搜索策略中的天然组件——就像探险家既会规划路线，也会果断放弃死路。

终止条件 —— 何时收网

探险队长不会在森林里无限期地逛下去，他需要明确的收网标准。思维树的搜索同样需要终止条件：什么时候停止生成分支，宣布找到了答案？

最理想的终止条件是“目标达成”——存在某个叶子节点，其状态明确满足了问题的要求。比如24点游戏凑出了24，或数学题求出了最终解。但在很多开放任务中，“目标达成”本身不好判定，这时就需要备用条件。第二个常用条件是“深度上限”：预先设定最大步数，到达 $D_{\max}$ 就停止，选当前分数最高的路径作为答案。这样至少保证推理不会无限循环。第三个条件是“资源约束”：调用LLM的次数或token预算用完了就停止，这是工程实践中非常现实的约束。

$$\displaystyle \text{stop} = \big( V(s_t) \ge \tau \big) \ \text{or} \ (t = D_{\max})$$

1. τ（阈值）：一个可接受的分数门槛。当某个节点的评分达到这个数值，就认为找到了满意的答案。

$$\tau = \text{可接受的分数阈值}$$

2. D_max（深度上限）：允许展开的最大推理步数，防止搜索无限延伸。

$$D_{\max} = \text{最大搜索深度}$$

3. 逻辑或（or）：两个条件任一满足即触发停止。这是“尽早收网”原则的数学表达。

$$\text{条件1: } V(s_t)\ge\tau \quad \text{或} \quad \text{条件2: } t = D_{\max}$$

终止条件的设计体现了ToT的实用主义：既要足够灵敏以抓住正确解，又要足够保守以避免无限的资源消耗。这就像探险家的“黄昏原则”——太阳落山前无论如何都要回到营地，不论是否找到宝藏。

Prompt编写 —— 给探险家写攻略手册

前面讲了那么多理论，实际操作时，这些机制都需要通过一段精心设计的Prompt来激活。思维树的Prompt不是一段简单的指令，而是一份完整的“探险攻略”，通常包含四个模块：角色设定、步骤分解、分支生成指令和评估指令。

首先是角色设定：让模型扮演一个“善于分解问题的探险队长”，为后续的结构化思考定下基调。其次是步骤分解：明确要求模型把问题拆解为多个子阶段，每阶段只解决一个子问题。然后是分支生成指令：要求每一步给出多个候选方案，并强调方案之间要有足够的差异性。最后是评估指令：要求模型对每个候选方案打分，说明理由，再选择得分最高的继续。这四个模块可以组成一个可复用的Prompt模板。

$$\displaystyle P_{\text{ToT}} = \underbrace{P_{\text{role}}}_{\text{角色}} + \underbrace{P_{\text{step}}}_{\text{步骤}} + \underbrace{P_{\text{branch}}}_{\text{分支指令}} + \underbrace{P_{\text{eval}}}_{\text{评估指令}}$$

1. 角色设定：把模型锚定成具有结构化思维习惯的角色，激活其规划能力。

$$P_{\text{role}} = \text{"你是一位善于分解问题的探险队长"}$$

2. 步骤分解：要求模型显式地列出子问题清单，而不是一口气给出最终答案。

$$P_{\text{step}} = \text{"请按以下步骤逐层解决问题"}$$

3. 分支指令：明确规定每个节点生成多少个候选方案，并强调多样性。

$$P_{\text{branch}} = \text{"每一步列出 3 种差异化的候选思路"}$$

4. 评估指令：要求对每个候选打分并附理由，然后依据分数做选择。

$$P_{\text{eval}} = \text{"给每个候选打分（0-1），并解释理由"}$$

一个实际的ToT Prompt模板可以长这样：

这样一段Prompt，就把“探索多条路径、评估、择优、回溯”的完整流程内化到了模型的推理过程中。探险队长不再只是“想想”，而是有了明确的行动手册。

你是一位善于拆解复杂问题的资深探险队长。任务：{用户的问题}请遵循以下流程：1. 先把问题拆解为 3 个关键子步骤。2. 对当前子步骤，给出 3 个不同的候选解法。3. 对每个候选解法打分（0-1），评估可行性与风险。4. 选择最高分候选继续，若发现该路不可行，返回第 2 步换一个候选。5. 抵达最终答案后，简述你走过的路径。

实例应用 —— 丛林实战手册

理论说得再多，不如看一场实战。思维树最强的领域，是那些拥有明确搜索空间、可以分步验证中间结果的复杂任务。我们来看三个最典型的应用场景。

数学推理是最经典的应用场景。比如解一道多项式方程，模型每一步的化简结果都可以被验证是否等价。用ToT时，模型在每个化简步骤生成多个不同的变形思路，评估哪个方向离标准形更近，从而避免在错误的代数方向上越走越远。逻辑谜题同样适合ToT，比如经典的“狼羊菜过河”问题：每一步都有多种可行的运送方案，模型需要评估每种方案是否会让某个角色被吃，从而剪掉非法分支。策略规划任务，比如让AI在一个网格世界上规划一条从起点到终点的安全路线，每一步移动都涉及障碍和陷阱，ToT的多分支探索能力可以显著降低“碰壁”概率。

$$\displaystyle \text{Answer} = \text{decode}(\pi^*) = a_n$$

1. π*（最优路径）：搜索完成后得到的累计价值最高的那条思维路径。

$$\pi^* = \arg\max_{\pi}\sum_{s\in\pi}V(s)$$

2. decode（解码）：把路径上的节点序列转化为人类可读的形式，输出最终回答。

$$\text{decode: } s_0 \to s_1 \to \cdots \to s_n$$

3. a_n（答案叶子）：路径终点的叶子节点，承载着最终的解题结论。

$$\text{Answer} = a_n$$

可以说，凡是“中间步骤可以被评估、错误可以被发现、多条路可以比较”的任务，ToT都能派上用场。而如果一个任务没有可评估的中间状态、每一步也不存在明显分支，那么ToT的优势就无法发挥——这时候老老实实用CoT反而更高效。

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-"""迷你思维树ToT演示：24点游戏 + 分支生成 + 评估 + 束搜索"""  class ThoughtNode:    """思维树节点：记录数字状态、表达式与父节点"""     def __init__(self, numbers, expr, parent=None):        self.numbers = numbers        self.expr = expr        self.parent = parent        self.score = 0.0     def trace(self):        """从根到当前节点的完整表达式链路"""        chain = []        node = self        while node:            chain.append(node.expr)            node = node.parent        return " -> ".join(reversed(chain))  def evaluate(numbers, target=24):    """启发式评分：数字离目标越近分数越高"""    if len(numbers) == 1:        return 1.0 / (1.0 + abs(numbers[0] - target))    best = 0.0    n = len(numbers)    for i in range(n):        for j in range(i + 1, n):            a, b = numbers[i], numbers[j]            candidates = [a + b, abs(a - b), a * b]            if abs(b) > 1e-9:                candidates.append(a / b)            if abs(a) > 1e-9:                candidates.append(b / a)            for v in candidates:                best = max(best, 1.0 / (1.0 + abs(v - target)))    return best  def gen_thoughts(node, target):    """分支生成：任选两个数字做四则运算，生成所有子思维"""    children = []    n = len(node.numbers)    for i in range(n):        for j in range(i + 1, n):            a, b = node.numbers[i], node.numbers[j]            rest = [node.numbers[k] for k in range(n) if k != i and k != j]            ops = [(a + b, "(%d+%d)" % (a, b)),                   (a - b, "(%d-%d)" % (a, b)),                   (a * b, "(%d*%d)" % (a, b))]            if abs(b) > 1e-9:                ops.append((a / b, "(%d/%d)" % (a, b)))            for val, expr in ops:                child = ThoughtNode(sorted(rest + [val]), expr, node)                child.score = evaluate(child.numbers, target)                children.append(child)    return children  def tree_search(numbers, target=24, max_depth=5, beam=4):    """ToT主流程：生成分支 -> 评估 -> 束搜索保留Top-k -> 剪枝"""    root = ThoughtNode(numbers, str(numbers))    root.score = evaluate(numbers, target)    frontier = [root]    for _depth in range(max_depth):        next_frontier = []        for node in frontier:            if len(node.numbers) == 1 and abs(node.numbers[0] - target) < 1e-9:                return node.trace()            next_frontier.extend(gen_thoughts(node, target))        # 评估剪枝：按分数保留前 beam 个节点        next_frontier.sort(key=lambda n: n.score, reverse=True)        frontier = next_frontier[:beam]    if frontier:        return frontier[0].trace()    return "未找到解法"  if __name__ == "__main__":    start_numbers = [1, 2, 3, 4]    solution = tree_search(start_numbers, max_depth=5, beam=4)    print("题目：", start_numbers)    print("ToT搜索到的解法链路：", solution)

1. class ThoughtNode:思维树节点，相当于探险地图上的一个路标，记录到达该状态时的数字列表和表达式。
2. def trace(self):从当前节点沿父指针回溯到根，拼出完整表达式链，还原整条思考路径。
3. def evaluate(numbers, target=24):启发式评估器，扮演“侦察兵”角色：距离目标越近的中间状态分数越高。
4. candidates = [a+b, abs(a-b), a*b]对每一对数字列举可能的四则运算结果，生成候选子思维。
5. child.score = evaluate(child.numbers, target)每个新生成的分支节点立即被打分，为后续剪枝做准备。
6. next_frontier.sort(key=lambda n: n.score, reverse=True)评估择优：对所有候选节点按分数从高到低排序。
7. frontier = next_frontier[:beam]束搜索剪枝：只保留分数最高的 beam 个节点，其余分支被丢弃。
8. for _depth in range(max_depth):设置了深度上限，防止搜索无限延伸，对应ToT的终止条件。
9. return node.trace()找到目标状态后，沿链路回溯输出完整解法，如同探险家整理路线报告。

常见误区

面试题