Tree of Thoughts: Deliberate Problem Solving with Large Language Models

为什么这篇论文重要

Chain of Thought（CoT）让 LLM “想几步再回答”——但只有一条线性思路。 Tree of Thoughts（ToT）让 LLM 同时探索多条思路，自我评估，必要时回溯—— 像人类下棋 / 玩拼图一样深度思考。

这是 o1 / DeepSeek R1 等推理模型的思想前身—— 2023 年还需要外部循环框架，2024 后这种”深度思考”被内嵌进模型本身。

一个例子：24 点游戏

给 4 个数字（如 3, 5, 8, 13），用 +, -, ×, ÷ 凑出 24。

3, 5, 8, 13
   ↓
(分支 1)  3 + 5 = 8     → 剩下: 8, 8, 13     →  8 × 8 = 64, ÷13 = ... 不行
(分支 2)  13 - 5 = 8     → 剩下: 3, 8, 8     →  3 × 8 = 24, ÷8 = 3, +0 = 不行
(分支 3)  3 × 5 = 15     → 剩下: 8, 13, 15   →  尝试...
...

ToT 让 LLM 同时生成多种第一步，评估每个分支的可能性，扩展看好的分支，剪枝看差的。

结果：GPT-4 在 24 点上：

• CoT：4% 成功率
• ToT：74% 成功率

框架的四个组件

ToT 把”思考问题”形式化为搜索一棵思路树，需要 4 个组件：

1. Thought 分解

把任务分成可枚举的”思路步”。比如 24 点 = 三步运算。

2. Thought generator

LLM 生成”下一步可能的思路”（每节点几个候选子节点）。

def generate_thoughts(state, k=3):
    prompt = f"Given numbers {state}, generate {k} possible next operations."
    return llm(prompt).split('\n')

3. State evaluator

LLM 自己评估当前思路是否有希望：

def evaluate(state):
    prompt = f"On a scale of 1-10, how likely is this state to lead to 24?"
    return float(llm(prompt))

这是 ToT 的关键创新——LLM 不仅是生成器，也是评估器。

4. 搜索算法

BFS、DFS、beam search 等经典搜索算法应用到思路树上。

def tree_of_thoughts(problem, max_depth=4, beam_width=5):
    states = [initial_state(problem)]
    for depth in range(max_depth):
        candidates = []
        for state in states:
            for thought in generate_thoughts(state, k=3):
                next_state = apply(state, thought)
                score = evaluate(next_state)
                candidates.append((next_state, score))
        # Beam search: 保留 top-k
        candidates.sort(key=lambda x: -x[1])
        states = [c[0] for c in candidates[:beam_width]]
    return best_terminal(states)

三个 ToT 测试任务

1. Game of 24（24 点）

4% → 74%（GPT-4）

2. Creative Writing（创意写作）

要求生成 4 段连贯文字，每段以指定句子结尾。 ToT 输出更连贯（人类评价）。

3. Mini Crosswords（迷你填字游戏）

5×5 网格，给定线索填词。 CoT: 16% → ToT: 60%（按单词正确率）

与 CoT / ReAct 对比

局限和成本

计算成本暴涨

ToT 每个搜索步要 LLM 多次调用：

• 生成多个候选（k 次）
• 评估每个候选（k 次）
• … 一棵树有上百个节点

实际成本是 CoT 的 10-100 倍—— 所以 ToT 适合高价值、可负担多 token 的任务（解题、复杂规划）。

任务必须可分解

24 点天然分成三步，填字也有自然边界。 但有些任务（创意叙事、自由对话）很难分解——ToT 不一定能用。

评估可靠性

LLM 自己评估自己的中间状态 是否合理—— 有时 evaluation step 本身就是错的，导致剪掉了好的分支或保留了死胡同。

ToT 的真正遗产

2024+ 的推理模型（OpenAI o1 / o3 / DeepSeek R1）继承了 ToT 的核心思想：

训练模型在内部生成长思维链，包含探索、评估、回溯。

但不需要外部框架——这些行为内置在模型权重里。 用户只需正常调用 API，模型自己就会”深度思考”。

ToT 的”外部循环”被蒸馏进了模型本身——这是 LLM 演化的典型模式。

ToT 在工业界

虽然推理模型让 ToT 的”显式框架”使用减少，但思想仍广泛用于：

• LangGraph 的 ReAct + 搜索扩展
• AutoGen 的多 agent debate
• Claude Code / Cursor 在难任务上的多方案对比
• Devin 等编程 agent 的”试多个方法”模式

一个最小 ToT 实现

import heapq

def tot_solve(problem, llm, max_depth=4, k=3, beam=5):
    # 初始状态
    states = [(0, problem, [])]  # (negative_score, state, path)

    for depth in range(max_depth):
        candidates = []
        for neg_score, state, path in states:
            if is_terminal(state):
                return state, path

            # 生成 k 个候选
            thoughts = llm(f"Given {state}, suggest {k} next steps.")
            for thought in thoughts:
                new_state = apply(state, thought)
                # LLM 自己打分
                score = float(llm(f"Score 1-10: how promising is {new_state}?"))
                heapq.heappush(candidates, (-score, new_state, path + [thought]))

        # 保留 top-beam
        states = heapq.nsmallest(beam, candidates)

    return None

推荐配套阅读

• HelloAI: L4-02 Prompt 进阶（CoT / Self-Consistency / ToT 速查）+ L4-04 Agent
• ToT 原论文（arXiv:2305.10601）
• Chain of Thought 原论文（2022）—— ToT 的前身
• OpenAI o1 论文 —— ToT 思想被内化的延续