思维树提示 (Tree-of-Thought)

从链到树：推理的进化

我们已经学过 Chain-of-Thought（CoT），它让 AI 沿着一条线性路径推理。Self-Consistency 让 AI 走多条路径然后投票。但这两种方法有一个共同的局限：它们不会回头。

一旦某一步推理出了问题，后面的步骤只能在错误的基础上继续。就像走迷宫时只能一直往前走，不能回头换条路。

Tree-of-Thought（ToT）解决了这个问题：它让 AI 在每一步都探索多个可能的方向，评估每个方向的前景，然后选择最有希望的继续，必要时还能回退。

CoT vs Self-Consistency vs ToT

特性	CoT	Self-Consistency	ToT
推理路径	1 条	N 条独立路径	树状分支路径
是否回退	不能	不能	可以
中间评估	没有	没有	每步都评估
搜索策略	无	无	BFS / DFS
适用问题	简单推理	有唯一答案的推理	复杂规划和决策
成本	低	中	高

用一个比喻来理解：

CoT：走迷宫时只走一条路，走到底看结果
Self-Consistency：走迷宫 5 次，每次随机走，看哪个出口被走到最多
ToT：走迷宫时在每个岔路口都派人探索，评估哪条路更有希望，集中力量走最好的路

ToT 的核心组件

1. 思维分解（Thought Decomposition）

把问题分解为多个中间步骤，每个步骤生成多个候选”思维”：

问题：设计一个用户注册流程

步骤 1 的候选思维：
├── 思维 A：先验证邮箱格式
├── 思维 B：先检查用户名是否存在
└── 思维 C：先收集所有信息再统一验证

步骤 2 的候选思维（基于步骤 1 的选择）：
├── 思维 D：发送验证码
├── 思维 E：发送确认链接
└── 思维 F：使用 OAuth 跳过验证

2. 思维评估（Thought Evaluation）

对每个候选思维进行评估，判断它是否值得继续探索：

评估标准：
- 这个思维是否朝着解决问题的方向前进？
- 从这个思维出发，能否到达最终答案？
- 这个思维是否引入了矛盾或错误？

评估结果：
- 有希望（继续探索）
- 不确定（暂时保留）
- 没希望（剪枝放弃）

3. 搜索策略（Search Algorithm）

BFS（广度优先搜索）

每一层都保留最好的 K 个思维，然后同时展开下一层：

第 1 层：生成 5 个思维 → 保留最好的 3 个
第 2 层：每个思维生成 5 个子思维（共 15 个）→ 保留最好的 3 个
第 3 层：每个思维生成 5 个子思维（共 15 个）→ 保留最好的 3 个
最终：从 3 个候选中选最好的

适合：步骤数较少但每步选择较多的问题。

DFS（深度优先搜索）

沿着一条路径深入探索，遇到死胡同就回退：

思维 A → 思维 A1 → 思维 A1a → 评估：没希望 → 回退
思维 A → 思维 A1 → 思维 A1b → 评估：有希望 → 继续
思维 A → 思维 A1 → 思维 A1b → 思维 A1b1 → 找到答案！

适合：搜索空间很大但正确路径较深的问题。

Prompt 模板实现

方法一：单 Prompt 模拟 ToT

最简单的方式是在一个 Prompt 中让 AI 模拟树搜索：

请用思维树方法解决以下问题。

问题：[你的问题]

请按以下步骤操作：

1. 将问题分解为 3-4 个关键步骤
2. 对每个步骤，生成 3 个不同的思路
3. 评估每个思路的可行性（好/一般/差）
4. 选择最好的思路继续
5. 如果某条路走不通，回退到上一步尝试其他思路
6. 最终给出最佳解决方案

格式要求：
## 步骤 1：[步骤描述]
- 思路 A：[描述] → 评估：[好/一般/差]
- 思路 B：[描述] → 评估：[好/一般/差]
- 思路 C：[描述] → 评估：[好/一般/差]
→ 选择：[选中的思路]

## 步骤 2：[步骤描述]
...

## 最终方案
[综合最佳路径的完整方案]

方法二：多轮对话实现 ToT

更精确的方式是通过多轮 API 调用实现：

import anthropic

client = anthropic.Anthropic()

def tree_of_thought(problem: str, breadth: int = 3, depth: int = 3) -> str:
    """BFS 方式的 Tree-of-Thought"""

    # 第一步：分解问题
    decompose_prompt = f"""将以下问题分解为 {depth} 个关键步骤，每个步骤用一句话描述。

问题：{problem}

输出格式（JSON）：
["步骤1描述", "步骤2描述", "步骤3描述"]"""

    steps = call_api(decompose_prompt)

    current_thoughts = [""]  # 初始状态

    for step_idx, step in enumerate(steps):
        all_candidates = []

        for thought in current_thoughts:
            # 生成候选思维
            generate_prompt = f"""问题：{problem}
当前进度：{thought if thought else "刚开始"}
当前步骤：{step}

请生成 {breadth} 个不同的思路来完成这一步。
每个思路要具体、可执行。

输出格式（JSON）：
["思路1", "思路2", "思路3"]"""

            candidates = call_api(generate_prompt)

            for candidate in candidates:
                new_thought = f"{thought}\n步骤{step_idx+1}：{candidate}"
                all_candidates.append(new_thought)

        # 评估并选择最好的 K 个
        evaluate_prompt = f"""问题：{problem}

以下是 {len(all_candidates)} 个候选方案，请评估每个方案的质量（1-10分），
选出最好的 {breadth} 个。

候选方案：
{format_candidates(all_candidates)}

输出格式（JSON）：
[{{"index": 0, "score": 8}}, ...]"""

        scores = call_api(evaluate_prompt)
        top_indices = sorted(scores, key=lambda x: x["score"], reverse=True)[:breadth]
        current_thoughts = [all_candidates[s["index"]] for s in top_indices]

    # 最终选择
    return current_thoughts[0]

def call_api(prompt: str) -> any:
    """调用 API 并解析 JSON 响应"""
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        temperature=0.7,
        messages=[{"role": "user", "content": prompt}]
    )
    import json
    return json.loads(response.content[0].text)

实战案例：24 点游戏

24 点游戏是 ToT 论文中的经典案例。给定 4 个数字，用加减乘除得到 24。

问题

数字：4, 7, 8, 8
目标：用 +, -, ×, ÷ 得到 24

CoT 的做法（线性推理）

让我试试：
4 × 7 = 28
28 - 8 = 20
20 + 8 = 28  ← 不对

再试：
8 × 8 = 64
64 ÷ 4 = 16
16 + 7 = 23  ← 不对

放弃...

ToT 的做法（树搜索）

步骤 1：选择两个数字进行运算
├── 4 + 7 = 11（剩余：11, 8, 8）→ 评估：一般
├── 4 × 7 = 28（剩余：28, 8, 8）→ 评估：有希望（28 接近 24）
├── 8 - 4 = 4（剩余：4, 7, 8）→ 评估：一般
├── 8 ÷ 4 = 2（剩余：2, 7, 8）→ 评估：一般
└── 8 × 8 = 64（剩余：64, 4, 7）→ 评估：有希望

选择继续探索：28,8,8 和 64,4,7

步骤 2（路径 A：28, 8, 8）：
├── 28 - 8 = 20（剩余：20, 8）→ 20 + 8 = 28 ✗
├── 28 + 8 = 36（剩余：36, 8）→ 36 - 8 = 28 ✗
└── 8 - 8 = 0（剩余：28, 0）→ 28 + 0 = 28 ✗
→ 这条路走不通，回退

步骤 2（路径 B：8 ÷ 4 = 2, 剩余 2, 7, 8）：
├── 7 - 2 = 5（剩余：5, 8）→ 5 × 8 = 40 ✗
├── 7 + 2 = 9（剩余：9, 8）→ 9 + 8 = 17 ✗
└── 2 × 7 = 14（剩余：14, 8）→ 14 + 8 = 22 ✗

重新探索：8 × (7 - 4) = 8 × 3 = 24 ✓ 找到了！

ToT 通过系统性搜索和回退，找到了 CoT 可能错过的答案。

适用场景

适合 ToT 的问题

规划问题：旅行规划、项目排期、资源分配
创意写作：故事大纲设计、多线叙事
数学谜题：24 点、数独、逻辑谜题
架构设计：系统设计中的方案对比
策略游戏：需要前瞻性思考的决策

不适合 ToT 的问题

简单问答：直接回答即可，不需要搜索
翻译任务：路径单一，没有分支
信息提取：从文本中提取信息，不需要推理
实时场景：ToT 耗时较长，不适合需要快速响应的场景

简化版 ToT Prompt

如果你不想写代码，可以用这个简化版 Prompt 在对话中使用 ToT：

我需要你用"思维树"方法来解决问题。

规则：
1. 在每个决策点，列出 3 个可能的方向
2. 简要评估每个方向的优劣
3. 选择最有前景的方向深入
4. 如果走入死胡同，明确说"回退"并尝试其他方向
5. 用缩进表示思维的层级关系

问题：[你的问题]

请开始探索：

实际效果

问题：为一个电商平台设计促销系统

第 1 层：促销类型设计
├── 方向 A：基于规则引擎的促销系统
│   优势：灵活、可配置  劣势：复杂度高
│   评估：★★★★☆
├── 方向 B：硬编码促销逻辑
│   优势：简单直接  劣势：难以扩展
│   评估：★★☆☆☆
└── 方向 C：基于 DSL 的促销描述语言
    优势：表达力强  劣势：学习成本高
    评估：★★★☆☆

→ 选择方向 A，继续深入

第 2 层：规则引擎设计（基于方向 A）
├── 方向 A1：使用现有规则引擎（如 Drools）
│   评估：★★★☆☆（引入外部依赖）
├── 方向 A2：自研轻量级规则引擎
│   评估：★★★★☆（可控性强）
└── 方向 A3：基于策略模式的规则组合
    评估：★★★★★（简单且灵活）

→ 选择方向 A3...

成本分析

ToT 的成本比 Self-Consistency 更高，因为它在每一步都需要多次 API 调用：

假设：3 层深度，每层 3 个分支，保留 top-2

第 1 层：生成 3 个思维 + 评估 = 2 次调用
第 2 层：2 × 3 个思维 + 评估 = 3 次调用
第 3 层：2 × 3 个思维 + 评估 = 3 次调用

总计：约 8 次 API 调用

方法	API 调用次数	适用场景
单次 CoT	1	简单推理
Self-Consistency (5次)	5	有唯一答案的推理
ToT (3层×3分支)	8-15	复杂规划和决策

建议：只在问题确实需要探索和回退时才使用 ToT。大多数日常任务用 CoT 或 Self-Consistency 就够了。

总结

Tree-of-Thought 是目前最强大的提示工程技巧之一，它把 AI 的推理从”线性思考”升级为”系统性搜索”。

核心要点：

在每个决策点生成多个候选方向
评估每个方向的前景
选择最好的继续，必要时回退
BFS 适合浅而宽的问题，DFS 适合深而窄的问题

好的思考不是一条直线，而是一棵树。每个分支都是一种可能，每次回退都是一次学习。ToT 让 AI 学会了”三思而后行”。

加载中...