当Yao等人用深度优先搜索让GPT-4在24点游戏上从4%飙升至74%时，Long的强化学习控制器正默默地在自对弈中进化；而Hulbert仅用一段提示词，就把整个ToT框架塞进了单次对话。
同样指向“树”，三种实现，三种哲学。
2023年，三个独立研究团队几乎同时发现“GPT类模型光靠变大已不够聪明”，并分别用不同方法（搜索/强化学习/提示词）提出了“思维树”解决方案——这不是巧合，而是整个学术界对“大模型需要真正的推理能力”这一共识的集体爆发。
核心依据链条：
天花板证据：GPT-4+思维链在24点游戏上仅4%成功率（Yao, 2023）
时间重合：Yao（5.17）、Long（5.13）、Hulbert（5月）三篇独立工作同时出现
问题同源：都指向CoT无回溯/无探索/无全局评估的致命缺陷
路径各异：分别用经典搜索、强化学习、提示工程解决——说明共识已形成，而非偶然撞车
历史定位：标志着推理时计算（Test-time Computation）成为新Scaling Law的开端
阅读了相关资料感觉很有价值，在此文对比这三条路线的核心思想、本质差异，以及它们共同指向的未来。
一、同根生：三棵树共同回答的问题
在进入差异之前，我们先确认它们为什么都被称为“思维树”。
1.1 思维链的“致命妥协”
思维链（Chain-of-Thought）让模型“逐步思考”，但它的底层实现仍是从左到右的贪心解码：
text
问题 → 步骤1 → 步骤2 → ... → 答案
没有回头路，没有备选方案，没有全局评估。
1.2 三棵树的共同信仰
Yao、Long、Hulbert的工作共享以下核心假设：
| 共同立场 | 对CoT的批判 |
|---|---|
| 思维应作为探索单元 | CoT在词元级别探索，ToT在“想法”级别探索 |
| 必须支持回溯 | 人类解题会试错、会回头，模型也应如此 |
| 需要全局评估机制 | 局部最优≠全局最优 |
| 搜索空间应显式建模 | 复杂问题本质是搜索问题，而非映射问题 |
这是三篇论文的“最大公约数”。而它们的分野，从“如何搜索”开始。
二、三条路线：DFS、RL、单次提示
2.1 Yao et al. (2023)：经典搜索算法回归
核心思想：将问题求解建模为树搜索，用BFS/DFS/集束搜索遍历。
技术实现：
-
思维分解：把问题切成若干“思维步骤”
-
思维生成：采样或提议产生候选
-
状态评估：用LLM给候选打分（分类或数值）
-
搜索算法：BFS（宽度优先）或DFS（深度优先）
关键代码逻辑（伪代码）：
python
def solve_with_bfs(problem, beam_size=5):
candidates = [initial_state]
for depth in range(max_steps):
new_candidates = []
for state in candidates:
thoughts = generate_thoughts(state, k=beam_size)
for thought in thoughts:
value = evaluate_thought(thought)
new_candidates.append((thought, value))
# 保留得分最高的beam_size个
candidates = top_k(new_candidates, beam_size)
return best_candidate
本质：把LLM当作搜索问题的“启发式函数”——生成候选靠LLM，打分靠LLM，但搜索策略是写死的。
优势：简单、可控、可解释 局限：搜索策略不学习，无法从数据中进化
2.2 Long (2023)：强化学习驱动的“神经搜索”
核心思想：搜索策略不应该是硬编码的，而应该是学出来的。
技术实现：
-
用一个ToT控制器（一个小型神经网络）决定：
-
当前节点是否需要扩展
-
扩展几个分支
-
是否回溯
-
回溯到哪一层
-
-
控制器通过强化学习训练：
-
状态：当前树的拓扑结构 + 节点评估值
-
动作：扩展/回溯/终止
-
奖励：最终答案的正确与否
-
关键洞察：
即使LLM本身是冻结的，ToT控制器仍可在自对弈中不断进化——就像AlphaGo学会的不仅是落子，更是何时弃子。
类比理解：
-
Yao：给LLM一张地图，告诉它“用广度优先搜索”
-
Long：给LLM一张地图，让它自己学会怎么看地图
优势：策略可进化，可能发现人类未曾写出的搜索模式 局限：需要训练数据，实现复杂度高
2.3 Hulbert (2023)：提示词级别的“蒸馏”
核心思想：整个ToT框架可以蒸馏进一段提示词。
技术实现（原文提示词）：
text
假设三位不同的专家来回答这个问题。
所有专家都写下他们思考这个问题的第一个步骤，然后与大家分享。
然后，所有专家都写下他们思考的下一个步骤并分享。
以此类推，直到所有专家写完他们思考的所有步骤。
只要大家发现有专家的步骤出错了，就让这位专家离开。
请问：[问题]
本质：用提示词模拟多智能体协作与树搜索。
这为什么有效？
-
角色扮演激活LLM的“多视角生成”能力
-
分步骤约束强制思维分解
-
“专家离开”机制模拟剪枝与回溯
-
全部发生在单次对话的上下文窗口中
优势：
-
零成本（无需改代码、无需训练）
-
即插即用（任何对话模型都可尝试）
-
单次调用，低延迟
局限：
-
受限于上下文窗口长度
-
树规模被显式限制（三位专家、若干步骤）
-
无真正的状态追踪，本质是“模拟”
三、横向对比：三棵树的完整画像和代码研读
| 维度 | Yao et al. (2023) | Long (2023) | Hulbert (2023) |
|---|---|---|---|
| 发表形式 | NeurIPS 2023 | 预印本 | 社区笔记/LinkedIn |
| 搜索策略 | BFS/DFS/集束（硬编码） | RL训练的控制器 | 提示词模拟 |
| 是否需训练 | 否 | 是（控制器需训练） | 否 |
| 是否改模型 | 否 | 否（仅控制层） | 否 |
| 调用模式 | 多轮LLM调用 | 多轮LLM调用 | 单次提示 |
| 可进化性 | 无 | 强（自对弈） | 无 |
| 实现成本 | 中（需编排） | 高（需RL pipeline） | 极低 |
| 适用场景 | 对确定性要求高的任务 | 长期演化的AI系统 | 快速原型、轻量探索 |
| 论文/代码 | ✅ 开源 | 未广泛公开 | ✅ 提示词公开 |
Yao 路线：BFS/DFS + LLM 打分器
🧩 LangChain 原生实现（最推荐）
python
# -*- coding: utf-8 -*-
"""
Yao et al. (2023) 思维树实现
核心：BFS搜索 + LLM作为生成器/评估器
依赖：langchain>=0.1.0, openai>=1.0.0
"""
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
from typing import List, Tuple, Any
import itertools
class TreeOfThoughtsYao:
"""Yao风格ToT：硬编码搜索策略 + LLM启发式"""
def __init__(self, llm: ChatOpenAI, beam_size: int = 3, max_steps: int = 5):
self.llm = llm
self.beam_size = beam_size # BFS宽度 / 集束大小
self.max_steps = max_steps # 树的最大深度
def solve_24_game(self, numbers: List[int]) -> str:
"""
24点游戏专用求解器
论文核心实验：从4% -> 74%的奥秘
"""
# 1. 提议提示：生成下一步候选
propose_prompt = PromptTemplate(
template="""你是一位24点游戏专家。
输入：{numbers}
可能的下一步（使用格式：表达式 = 结果，剩余数字）：
- """,
input_variables=["numbers"]
)
# 2. 价值提示：评估候选路径
value_prompt = PromptTemplate(
template="""评估这些数字是否能算出24点：
{numbers}
请只输出以下三者之一：确定 / 可能 / 不可能""",
input_variables=["numbers"]
)
# BFS搜索主循环
candidates = [(numbers, f"初始: {numbers}", 1.0)]
for step in range(self.max_steps):
new_candidates = []
for state, history, _ in candidates:
# 生成思维
thoughts = self._generate_thoughts(state, propose_prompt)
for thought in thoughts:
# 评估思维
value = self._evaluate_thought(thought["remaining"], value_prompt)
# 只保留"确定"或"可能"
if value in ["确定", "可能"]:
new_candidates.append((
thought["remaining"],
history + f"\n→ {thought['expr']}",
1.0 if value == "确定" else 0.5
))
# 集束剪枝：保留top-k
candidates = sorted(new_candidates, key=lambda x: x[2], reverse=True)[:self.beam_size]
# 检查是否达成目标
for remaining, history, _ in candidates:
if len(remaining) == 1 and remaining[0] == 24:
return history + "\n✅ 成功得到24点！"
return "❌ 未找到解法"
def _generate_thoughts(self, numbers: List[int], prompt: PromptTemplate) -> List[dict]:
"""调用LLM生成候选思维"""
response = self.llm.invoke(prompt.format(numbers=numbers))
thoughts = []
for line in response.content.strip().split('\n'):
if '=' in line and '剩余' in line:
# 解析格式："4 + 9 = 13（剩余：10 13 13）"
expr_part = line.split('（')[0].strip()
remain_part = line.split('剩余：')[1].split('）')[0]
thoughts.append({
"expr": expr_part,
"remaining": [int(x) for x in remain_part.split()]
})
return thoughts
def _evaluate_thought(self, numbers: List[int], prompt: PromptTemplate) -> str:
"""调用LLM评估思维价值"""
response = self.llm.invoke(prompt.format(numbers=numbers))
return response.content.strip()
# ============= 使用示例 =============
if __name__ == "__main__":
llm = ChatOpenAI(model="gpt-4", temperature=0.7)
solver = TreeOfThoughtsYao(llm, beam_size=5)
result = solver.solve_24_game([4, 9, 10, 13])
print(result)
这段代码就像请了三位数学高手来帮你算24点，但用了非常巧妙的分工：
第一步，让高手们各自想一步——比如“4+9=13，还剩10、13、13”或者“10-4=6，还剩6、9、13”等等。 第二步，让另一位裁判评估每条路有没有希望——如果发现“这条路绝对算不出24”，就直接砍掉；如果“有可能”，就留下来。 第三步，只保留最有希望的那三五条路，让高手们继续往下想。 循环往复，直到有人真正算出24。
这套方法的厉害之处：它不是只让GPT“顺着一条道走到黑”（思维链，成功率4%），而是每走一步都看看哪条路更有可能，只探索最有希望的分支——结果成功率直接飙升到74%。 简单说就是：不一条路走到黑，而是边走边看，边看边选。
Long 路线：RL 控制器 + ToT 搜索策略学习
简化版强化学习控制器架构
python
# -*- coding: utf-8 -*-
"""
Long (2023) 思维树强化学习版本
核心思想：搜索策略不应硬编码，而应通过RL学习
注：完整实现需配合RL框架（如Ray RLlib），此处展示控制器核心结构
"""
import numpy as np
from typing import List, Dict, Any, Tuple
from dataclasses import dataclass
from enum import Enum
class SearchAction(Enum):
"""控制器的动作空间"""
EXPAND = 0 # 扩展当前节点
BACKTRACK = 1 # 回溯到父节点
TERMINATE = 2 # 终止当前分支
CONTINUE = 3 # 继续深度搜索
@dataclass
class TreeNode:
"""思维树的节点"""
thought: str
value: float
children: List['TreeNode']
parent: 'TreeNode' = None
depth: int = 0
visit_count: int = 0
class RLToTController:
"""
ToT控制器：用小型神经网络决策搜索策略
即使冻结LLM，控制器仍可通过RL持续进化
"""
def __init__(self, llm, state_dim=128, action_dim=4):
self.llm = llm # 冻结的大模型
self.controller = self._build_controller(state_dim, action_dim)
self.memory = [] # 经验回放
def _build_controller(self, state_dim, action_dim):
"""
简化的控制器网络
论文中未开源具体结构，此为合理推测架构
"""
import torch.nn as nn
return nn.Sequential(
nn.Linear(state_dim, 256),
nn.ReLU(),
nn.Linear(256, 128),
nn.ReLU(),
nn.Linear(128, action_dim),
nn.Softmax(dim=-1)
)
def encode_state(self, tree: TreeNode) -> np.ndarray:
"""
状态编码：树的拓扑结构 + 节点评估值
- 当前深度
- 兄弟节点数量
- 当前节点价值
- 子树未探索比例
- 搜索历史熵
"""
state = np.zeros(128)
state[0] = tree.depth / 10.0 # 归一化深度
state[1] = len(tree.children) / 5.0 # 分支因子
state[2] = tree.value # 评估价值
state[3] = tree.visit_count / 20.0 # 访问次数
# 更多特征编码...
return state
def select_action(self, state: np.ndarray, epsilon=0.1) -> SearchAction:
"""ε-贪心策略：探索或利用"""
if np.random.random() < epsilon:
return SearchAction(np.random.randint(4))
with torch.no_grad():
state_tensor = torch.FloatTensor(state).unsqueeze(0)
probs = self.controller(state_tensor)
action_idx = probs.argmax().item()
return SearchAction(action_idx)
def learn_from_episode(self, episode_data: List[Tuple]):
"""
从一次完整搜索任务中学习
奖励设计：最终答案正确 +1，搜索效率 +0.1/步，无效回溯 -0.5
"""
# 此处为简化示意，完整需PPO/DQN等算法
states, actions, rewards = zip(*episode_data)
# ... 更新控制器网络
def search_with_rl(self, problem: str, max_depth=10) -> str:
"""
RL驱动的ToT搜索
控制器自主决定：何时扩展、何时回溯、何时终止
"""
root = TreeNode(thought=problem, value=0.5, children=[], depth=0)
current = root
path = [root]
for step in range(100): # 最大交互步数
state = self.encode_state(current)
action = self.select_action(state)
if action == SearchAction.EXPAND:
# LLM生成思维
thoughts = self.generate_thoughts(current.thought)
for t in thoughts:
value = self.evaluate_thought(t)
node = TreeNode(t, value, [], current, current.depth+1)
current.children.append(node)
# 移动到最佳子节点
if current.children:
current = max(current.children, key=lambda n: n.value)
path.append(current)
elif action == SearchAction.BACKTRACK:
# 回退到父节点
if current.parent:
current = current.parent
path.pop()
elif action == SearchAction.TERMINATE:
# 终止该分支
break
# ... 检查是否到达目标
return self.extract_solution(root)
这段代码像是教一个只会按说明书办事的新手，慢慢变成能自己判断“什么时候该深挖、什么时候该回头”的老手。
最浅的一层：它让AI不再死板地按固定套路搜索，而是自己学会决策——比如遇到难题时知道“这条路再想想”，走进死胡同时知道“退回去换条路”。
中间一层：它用了一个小型神经网络当“指挥员”，大模型依然是那个知识渊博但不会规划的执行者，指挥员通过试错学习（强化学习）逐渐掌握搜索策略——就像AlphaGo自己学会下棋一样。
最深的一层：这意味着即使大模型本身不再更新，整个系统依然可以越用越聪明。指挥员从每一次成功/失败的任务中吸取经验，不断优化“何时扩展、何时回溯”的判断力。 一句话本质：把“怎么思考”这件事本身，也变成了可以学习的能力。
Hulbert 路线：单次提示模拟多专家树搜索
生产级提示词模板
python
# -*- coding: utf-8 -*-
"""
Hulbert (2023) 思维树提示词实现
核心：单次对话内模拟多专家协作 + 树搜索 + 回溯剪枝
特点：零成本、即插即用、单次调用
"""
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
class TreeOfThoughtsHulbert:
"""Hulbert风格：提示词即算法"""
@staticmethod
def get_prompt_template() -> PromptTemplate:
"""完整ToT提示词模板（中英双语）"""
template = """假设{num_experts}位不同的专家来回答这个问题。
所有专家都写下他们思考这个问题的第一个步骤，然后与大家分享。
然后，所有专家都写下他们思考的下一个步骤并分享。
以此类推，直到所有专家写完他们思考的所有步骤。
只要大家发现有专家的步骤出错了，就让这位专家离开。
请严格遵守以下规则：
1. 每位专家每次只说一个步骤
2. 步骤必须具体、可执行
3. 专家离开后不再参与后续讨论
4. 最终答案必须由至少一位幸存的专家给出
现在请解决以下问题：
{question}
请以如下格式输出：
【专家1】
第1步：...
第2步：...
...
【专家2】
第1步：...
第2步：...
...
幸存专家：【专家X】
最终答案：...
"""
return PromptTemplate(
template=template,
input_variables=["question", "num_experts"]
)
@staticmethod
def for_code_generation() -> PromptTemplate:
"""代码生成专用版ToT提示词"""
template = """假设{num_experts}位资深工程师共同解决这个编程问题。
每位工程师都：
1. 先分析需求，写下核心难点
2. 设计架构方案
3. 编写关键代码片段
4. 进行复杂度分析
过程中，如果发现某位工程师的思路存在明显缺陷，就请他离开。
问题：
{question}
要求：
- 使用Python 3.10+
- 包含异常处理
- 添加中文注释
- 给出时间复杂度
输出格式：
【工程师A】
思路：...
代码：
```python
...
幸存者：【工程师X】
最终解决方案：
python
```
...
```
"""
return PromptTemplate(
template=template,
input_variables=["question", "num_experts"]
)
text
```
@staticmethod
def for_decision_making() -> PromptTemplate:
"""商业决策专用版ToT提示词"""
template = """模拟{num_experts}位不同背景的顾问（战略、财务、技术、运营）分析以下决策：
```
{question}
每位顾问需要：
第1步：识别该决策的关键风险与机遇
第2步：提出初步建议方案
第3步：量化评估投入产出
第4步：给出最终立场（支持/反对/修改）
若某顾问的数据明显错误或逻辑矛盾，其他顾问可要求其离场。
最终输出一份综合建议报告。"""
return PromptTemplate(
template=template,
input_variables=["question", "num_experts"]
)
这段代码就像一个不需要任何额外成本、拿来就能用的模板。
最浅的一层：它不写任何复杂的搜索算法，只是让GPT在脑子里模拟“三个专家开会”——每人分步思考、互相监督，发现谁错了就请他离场，最后幸存者给出答案。相当于把“树搜索”整个压缩进了一段提示词里。
中间一层：它针对不同场景准备了定制化“会议剧本”——写代码时模拟三位工程师（分析需求→架构→编码）、做决策时模拟四位顾问（战略/财务/技术/运营）。你只需要填问题，剩下的“多人协作推理”全交给提示词。
最深的一层：它和Yao、Long放在一起，构成了一个完整的选型决策树——没预算、要快、只是试试水？无脑选Hulbert，一行代码不写、零成本启动；等验证有效、需要规模化，再迁移到Yao的工程化方案；如果有长期进化需求，再考虑Long的RL路线。
本质：这是门槛最低的思维树——不需要懂搜索算法，不需要写训练代码，只需要会写提示词。
⚖️ 四、终极对比：选型决策树
# -*- coding: utf-8 -*-
"""
三条路线选型决策引擎
根据你的约束条件自动推荐
"""
class ToTSelector:
"""思维树路线选择器"""
@staticmethod
def recommend(
has_training_budget: bool, # 是否有训练预算
latency_sensitive: bool, # 是否延迟敏感
need_controllable: bool, # 是否需要完全可控
task_depth: int, # 任务所需推理深度
daily_volume: int, # 日调用量
) -> dict:
"""
根据业务场景推荐ToT路线
返回：推荐方案 + 理由 + 示例代码索引
"""
score = {"yao": 0, "long": 0, "hulbert": 0}
# 规则1：训练资源
if not has_training_budget:
score["long"] -= 100 # 没资源别碰RL
score["yao"] += 10
score["hulbert"] += 20
# 规则2：延迟要求
if latency_sensitive:
score["hulbert"] += 50 # 单次调用胜出
score["yao"] -= 30 # 多轮调用延迟高
score["long"] -= 40 # 延迟最高
# 规则3：控制需求
if need_controllable:
score["yao"] += 30 # 硬编码最可控
score["long"] -= 20 # RL策略难解释
# 规则4：任务复杂度
if task_depth > 5:
score["yao"] += 20 # BFS/DFS擅长深树
score["hulbert"] -= 30 # 上下文窗口受限
# 规则5：规模化
if daily_volume > 10000:
score["yao"] += 10 # LangChain已工程化
score["hulbert"] += 20 # 单次调用成本低
# 返回决策
winner = max(score, key=score.get)
recommendations = {
"yao": {
"路线": "Yao et al. (2023) - 经典搜索",
"代码": "本文件第一部分",
"理由": "适合确定性任务，可控性强，已大规模工程化",
"成本估算": f"每日{daily_volume}次请求 ≈ {daily_volume * task_depth * 5}次LLM调用"
},
"long": {
"路线": "Long (2023) - RL增强搜索",
"代码": "本文件第二部分",
"理由": "适合长期演进系统，策略可学习，需训练基础设施",
"成本估算": "训练成本约$2000+，推理成本同Yao"
},
"hulbert": {
"路线": "Hulbert (2023) - 单次提示模拟",
"代码": "本文件第三部分",
"理由": "零成本启动，延迟最低，适合快速验证",
"成本估算": f"每日{daily_volume}次请求 = {daily_volume}次LLM调用"
}
}
return recommendations[winner]
# ============= 使用示例 =============
if __name__ == "__main__":
# 场景1：初创公司，快速验证24点游戏效果
decision = ToTSelector.recommend(
has_training_budget=False,
latency_sensitive=True,
need_controllable=False,
task_depth=4,
daily_volume=100
)
print("🏆 推荐：", decision["路线"])
print("📌 理由：", decision["理由"])
print("🔧 代码位置：", decision["代码"])
# 输出：
# 🏆 推荐： Hulbert (2023) - 单次提示模拟
# 📌 理由： 零成本启动，延迟最低，适合快速验证
# 🔧 代码位置： 本文件第三部分
🔮 四、三条路线的未来演进
站在2026年回看这三篇几乎同期的工作，我们可以清晰地看到它们各自预言的未来。
4.1 Yao路线 → 工程化与框架集成
Yao的方法因其简单、确定、可控，率先被工程化：
-
LangChain、LlamaIndex均已集成ToT模块
-
成为复杂Agent任务中的标准编排模式
-
演进方向：更高效的评估策略（如用小模型打分）
预言兑现：搜索+LLM已成为Agent系统的默认范式。
4.2 Long路线 → 神经符号系统的曙光
Long的方法虽然实现成本高，但它指向更具野心的目标：
-
让LLM系统在推理过程中学习
-
搜索策略任务自适应
-
终极形态：AlphaGo式的推理大模型
预言兑现中：
-
OpenAI o1系列的内部搜索策略很可能是学习而来，而非硬编码
-
“推理时计算”成为Scaling Law的新维度
4.3 Hulbert路线 → 提示词工程的极致
Hulbert的方法看似“取巧”，却揭示了一个深刻事实：
很多算法思想可以直接“编译”进提示词。
这启发了后续大量工作：
-
“角色扮演即算法”范式（多智能体辩论、模拟法庭）
-
提示词即代码（Prompt-as-Code）
-
元提示（Meta-Prompting）的兴起
预言兑现：2024-2025年涌现的“提示词框架”，本质都是Hulbert路线的系统化。
五、一个有启发性的决策框架
如果你今天要构建一个需要复杂推理的LLM应用，三棵树怎么选？
选Yao模式（多轮BFS/DFS）当：
-
任务有明确的步骤边界（如24点、填字游戏）
-
正确性优先，可接受较高延迟
-
你需要完全可控的搜索过程
选Long模式（RL控制器）当：
-
你在构建长期演化的AI系统
-
你有持续产生的任务数据
-
你愿意投入训练基础设施
选Hulbert模式（单次提示模拟）当：
-
快速验证ToT是否对任务有效
-
延迟敏感，只能调用一次LLM
-
树规模较小（≤5个分支，≤3层深度）
一个实用的混合策略：
-
先用Hulbert提示词快速验证ToT对该任务是否有效
-
若有效且需上线，用Yao模式重写为多轮调用系统
-
若数据持续积累且性能有瓶颈，考虑Long模式
六、结语：树的隐喻与思维的未来
Yao、Long、Hulbert的三棵树，其实对应着AI研究的三条母题：
| 路线 | 母题 | 代表 |
|---|---|---|
| Yao | 算法即程序 | 经典符号AI |
| Long | 策略即学习 | 强化学习 |
| Hulbert | 能力即提示 | 提示工程 |
有趣的是，它们都不需要修改模型参数——全部发生在推理层。
这暗示着一个更大的趋势：
下一代AI系统的突破，未必来自更大的模型，而来自“我们如何用模型”的更聪明方式。
附录：论文与资源快速索引
python
# -*- coding: utf-8 -*-
"""
复制以下链接到浏览器
"""
class ToTResources:
"""论文、代码、提示词合集"""
YAO = {
"title": "Tree of Thoughts: Deliberate Problem Solving with Large Language Models",
"paper": "https://arxiv.org/abs/2305.10601",
"code": "https://github.com/princeton-nlp/tree-of-thoughts",
"venue": "NeurIPS 2023",
"citations": "1200+"
}
LONG = {
"title": "Tree of Thoughts with Reinforcement Learning",
"paper": "https://arxiv.org/abs/2305.08291",
"code": "未正式开源",
"venue": "arXiv预印本",
"note": "RL控制器思路已被OpenAI o1系列借鉴"
}
HULBERT = {
"title": "Tree-of-Thought Prompting",
"paper": "社区笔记，无正式论文",
"code": "https://github.com/kyegomez/tree-of-thoughts",
"venue": "社区实现",
"note": "提示词模板已被LangChain收录"
}
@classmethod
def print_all(cls):
"""打印所有资源"""
for name, info in cls.__dict__.items():
if not name.startswith("_"):
print(f"\n📌 {name}")
for k, v in info.items():
print(f" {k}: {v}")
# 使用
ToTResources.print_all()
如果这篇文章对你有启发，欢迎点赞、收藏、转发。评论区欢迎交流：你在实际项目中尝试过哪种ToT？效果如何？
关于作者：一个正在求职的Java开发者/AI应用开发者，坚持通过项目实践和技术写作提升自己。GitHub: [@yangziyue](Yzy000000 | 掘金: @Wiittch
