思维链到思维树：2025 AI Agent任务分解与自主决策的技术演进
一、从链式思考到树状推理的范式转变
1.1 思维链(CoT)的基础实现
python
复制代码
from typing import List, Dict
import openai
class ChainOfThought:
def __init__(self, model="gpt-4"):
self.model = model
self.memory = []
def generate_step(self, prompt: str, context: List[str] = None) -> str:
"""生成单个思维步骤"""
messages = [
{"role": "system", "content": "请逐步思考并解决问题。"},
{"role": "user", "content": prompt}
]
if context:
for step in context:
messages.append({"role": "assistant", "content": step})
response = openai.ChatCompletion.create(
model=self.model,
messages=messages,
temperature=0.7
)
return response.choices[0].message.content
def solve_problem(self, initial_prompt: str, max_steps: int = 5) -> List[str]:
"""执行完整的思维链推理"""
steps = []
current_prompt = initial_prompt
for _ in range(max_steps):
step = self.generate_step(current_prompt, steps)
steps.append(step)
# 检查是否已经得出结论
if self._is_conclusion(step):
break
# 更新prompt继续思考
current_prompt = "基于前面的思考，下一步应该做什么？"
return steps
def _is_conclusion(self, text: str) -> bool:
"""判断文本是否包含结论"""
conclusion_keywords = ["因此", "所以", "最终", "结论是"]
return any(keyword in text for keyword in conclusion_keywords)
1.2 思维树(ToT)的基础架构
python
复制代码
class TreeNode:
def __init__(self, content: str, parent=None):
self.content = content # 当前节点的思考内容
self.parent = parent # 父节点
self.children = [] # 子节点
self.value = 0.0 # 节点评估价值
self.visited = 0 # 访问次数
def add_child(self, child_content: str):
"""添加子节点"""
child = TreeNode(child_content, self)
self.children.append(child)
return child
def is_leaf(self) -> bool:
"""判断是否为叶节点"""
return len(self.children) == 0
class TreeOfThought:
def __init__(self, model="gpt-4"):
self.model = model
self.root = None
self.best_path = []
def generate_thoughts(self, node: TreeNode, breadth: int = 3) -> List[TreeNode]:
"""生成多个可能的思考分支"""
prompt = f"""当前思考：{node.content}
请生成{breadth}个可能的后续思考方向，每个方向用一句话描述：
1. """
response = openai.ChatCompletion.create(
model=self.model,
messages=[{"role": "user", "content": prompt}],
temperature=0.9,
n=1
)
# 解析生成的思考方向
thoughts_text = response.choices[0].message.content
thoughts = [t.split(". ")[1] for t in thoughts_text.split("\n") if ". " in t]
# 创建子节点
for thought in thoughts[:breadth]:
node.add_child(thought)
return node.children
def evaluate_thought(self, node: TreeNode) -> float:
"""评估思考节点的价值"""
prompt = f"""请评估以下思考的价值，给出0-1之间的评分：
思考内容：{node.content}
上下文：{self._get_path_to_root(node)}
评分标准：
- 相关性：与问题解决的关联程度
- 创新性：是否提供了新视角
- 可行性：是否可操作
请直接返回评分数字："""
response = openai.ChatCompletion.create(
model=self.model,
messages=[{"role": "user", "content": prompt}],
temperature=0.3,
max_tokens=5
)
try:
score = float(response.choices[0].message.content.strip())
return max(0.0, min(1.0, score))
except:
return 0.5
def _get_path_to_root(self, node: TreeNode) -> str:
"""获取从根节点到当前节点的路径"""
path = []
current = node
while current:
path.append(current.content)
current = current.parent
return " -> ".join(reversed(path))
二、高级思维树算法实现
2.1 蒙特卡洛树搜索(MCTS)增强版
python
复制代码
import math
import random
from collections import defaultdict
class MCTSEnhanced:
def __init__(self, tree: TreeOfThought, exploration_weight=1.0):
self.tree = tree
self.exploration_weight = exploration_weight
self.node_stats = defaultdict(lambda: {'value': 0, 'visits': 0})
def search(self, iterations: int = 100):
"""执行蒙特卡洛树搜索"""
for _ in range(iterations):
# 选择阶段
node = self._select(self.tree.root)
# 扩展阶段
if not node.is_leaf():
node = self._expand(node)
# 模拟阶段
reward = self._simulate(node)
# 回溯阶段
self._backpropagate(node, reward)
# 返回最佳路径
return self._get_best_path(self.tree.root)
def _select(self, node: TreeNode) -> TreeNode:
"""选择阶段：从根节点开始，选择最有潜力的子节点"""
while not node.is_leaf():
# 选择UCB值最高的子节点
unexplored = [c for c in node.children if self.node_stats[id(c)]['visits'] == 0]
if unexplored:
return random.choice(unexplored)
def ucb(n: TreeNode) -> float:
stats = self.node_stats[id(n)]
exploit = stats['value'] / stats['visits']
explore = math.sqrt(math.log(self.node_stats[id(node)]['visits']) / stats['visits'])
return exploit + self.exploration_weight * explore
node = max(node.children, key=ucb)
return node
def _expand(self, node: TreeNode) -> TreeNode:
"""扩展阶段：为节点生成新的子节点"""
if not node.children:
self.tree.generate_thoughts(node)
return random.choice(node.children)
def _simulate(self, node: TreeNode) -> float:
"""模拟阶段：从当前节点随机模拟到叶节点"""
current = node
depth = 0
max_depth = 5
while depth < max_depth and not current.is_leaf():
current = random.choice(current.children)
depth += 1
return self.tree.evaluate_thought(current)
def _backpropagate(self, node: TreeNode, reward: float):
"""回溯阶段：更新路径上的节点统计信息"""
current = node
while current:
stats = self.node_stats[id(current)]
stats['visits'] += 1
stats['value'] += reward
current = current.parent
def _get_best_path(self, node: TreeNode) -> List[str]:
"""获取最佳路径"""
path = []
current = node
while current and current.children:
# 选择访问次数最多的子节点
current = max(current.children, key=lambda n: self.node_stats[id(n)]['visits'])
path.append(current.content)
return path
2.2 基于大语言模型的启发式搜索
python
复制代码
class HeuristicSearch:
def __init__(self, tree: TreeOfThought, model="gpt-4"):
self.tree = tree
self.model = model
self.pruned_nodes = set()
def beam_search(self, beam_width: int = 3, max_depth: int = 5) -> List[str]:
"""束搜索算法"""
current_level = [self.tree.root]
best_path = []
for depth in range(max_depth):
next_level = []
for node in current_level:
if id(node) in self.pruned_nodes:
continue
# 生成或获取子节点
if not node.children:
self.tree.generate_thoughts(node, breadth=beam_width*2)
# 评估子节点
for child in node.children:
child.value = self.tree.evaluate_thought(child)
# 选择最有价值的子节点
sorted_children = sorted(node.children, key=lambda x: -x.value)
next_level.extend(sorted_children[:beam_width])
if not next_level:
break
# 选择当前层最有价值的路径
current_level = sorted(next_level, key=lambda x: -x.value)[:beam_width]
best_node = current_level[0]
best_path = self._get_path_to_node(best_node)
return best_path
def heuristic_prune(self, node: TreeNode, threshold: float = 0.3):
"""启发式剪枝"""
if node.is_leaf():
return
# 评估所有子节点
for child in node.children:
child.value = self.tree.evaluate_thought(child)
# 剪枝低价值分支
max_value = max(c.value for c in node.children)
for child in node.children:
if child.value < max_value * threshold:
self._mark_pruned(child)
def _mark_pruned(self, node: TreeNode):
"""标记节点为已剪枝"""
self.pruned_nodes.add(id(node))
for child in node.children:
self._mark_pruned(child)
def _get_path_to_node(self, node: TreeNode) -> List[str]:
"""获取到节点的路径"""
path = []
current = node
while current.parent:
path.append(current.content)
current = current.parent
path.reverse()
return path
三、动态任务分解系统
3.1 层次化任务分解器
python
复制代码
class HierarchicalTaskDecomposer:
def __init__(self, model="gpt-4"):
self.model = model
self.max_depth = 4
self.min_complexity = 0.2
def decompose(self, task: str, current_depth=0) -> dict:
"""递归分解任务"""
if current_depth >= self.max_depth:
return {"task": task, "subtasks": [], "is_leaf": True}
# 评估任务复杂度
complexity = self._assess_complexity(task)
if complexity < self.min_complexity:
return {"task": task, "subtasks": [], "is_leaf": True}
# 生成子任务
subtasks = self._generate_subtasks(task)
# 递归分解子任务
decomposed = []
for subtask in subtasks:
decomposed.append(self.decompose(subtask, current_depth+1))
return {
"task": task,
"subtasks": decomposed,
"is_leaf": False,
"complexity": complexity
}
def _assess_complexity(self, task: str) -> float:
"""评估任务复杂度(0-1)"""
prompt = f"""请评估以下任务的复杂度，给出0-1之间的评分：
任务：{task}
评分标准：
- 0.2: 非常简单的任务，可以直接执行
- 0.5: 需要2-3个步骤完成
- 0.8: 需要多个步骤和决策
- 1.0: 非常复杂，需要深入分析和规划
请直接返回评分数字："""
response = openai.ChatCompletion.create(
model=self.model,
messages=[{"role": "user", "content": prompt}],
temperature=0.2,
max_tokens=5
)
try:
return float(response.choices[0].message.content.strip())
except:
return 0.5
def _generate_subtasks(self, task: str) -> List[str]:
"""生成子任务列表"""
prompt = f"""将以下复杂任务分解为3-5个更小的子任务：
主任务：{task}
请按以下格式返回：
1. 第一项子任务
2. 第二项子任务
3. 第三项子任务"""
response = openai.ChatCompletion.create(
model=self.model,
messages=[{"role": "user", "content": prompt}],
temperature=0.7
)
# 解析生成的子任务
lines = response.choices[0].message.content.split("\n")
subtasks = [line.split(". ")[1] for line in lines if ". " in line]
return subtasks[:5] # 最多返回5个子任务
3.2 动态执行引擎
python
复制代码
class DynamicExecutionEngine:
def __init__(self, decomposer, executor):
self.decomposer = decomposer
self.executor = executor
self.state = {}
self.execution_tree = {}
def execute_task(self, root_task: str):
"""执行动态任务分解与执行"""
self.execution_tree = self.decomposer.decompose(root_task)
return self._execute_node(self.execution_tree)
def _execute_node(self, node: dict):
"""递归执行任务节点"""
if node["is_leaf"]:
# 执行叶子任务
result = self.executor.execute(node["task"], self.state)
node["result"] = result
node["status"] = "completed"
return result
# 执行子任务
intermediate_results = []
for subtask in node["subtasks"]:
try:
result = self._execute_node(subtask)
intermediate_results.append(result)
self.state.update(result)
except Exception as e:
# 动态调整任务分解
if self._should_replan(subtask, str(e)):
new_plan = self._replan(subtask, str(e))
result = self._execute_node(new_plan)
intermediate_results.append(result)
self.state.update(result)
else:
raise
# 整合子任务结果
combined_result = self._combine_results(intermediate_results)
node["result"] = combined_result
node["status"] = "completed"
return combined_result
def _should_replan(self, failed_node: dict, error: str) -> bool:
"""判断是否需要重新规划"""
prompt = f"""任务执行失败，请判断是否需要重新分解任务：
原始任务：{failed_node['task']}
错误信息：{error}
已收集的上下文：{self.state}
请回答"需要"或"不需要"，并简要说明原因：
判断："""
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[{"role": "user", "content": prompt}],
temperature=0.3
)
decision = response.choices[0].message.content[:2]
return "需要" in decision
def _replan(self, failed_node: dict, error: str) -> dict:
"""重新规划失败的任务"""
prompt = f"""原始任务分解失败，请提供新的分解方案：
原始任务：{failed_node['task']}
错误信息：{error}
已收集的上下文：{self.state}
请将任务重新分解为3-5个不同的子任务：
1. """
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[{"role": "user", "content": prompt}],
temperature=0.7
)
# 解析新的子任务
lines = response.choices[0].message.content.split("\n")
new_subtasks = [line.split(". ")[1] for line in lines if ". " in line]
# 创建新的分解节点
new_node = {
"task": failed_node["task"],
"subtasks": [],
"is_leaf": False,
"retry": True
}
for subtask in new_subtasks[:5]: # 最多5个子任务
new_node["subtasks"].append({
"task": subtask,
"subtasks": [],
"is_leaf": True
})
return new_node
def _combine_results(self, results: List[dict]) -> dict:
"""整合多个子任务的结果"""
combined = {}
for result in results:
combined.update(result)
return combined
四、自主决策系统实现
4.1 多专家投票决策机制
python
复制代码
class MultiExpertDecisionSystem:
def __init__(self, experts: List[str], model="gpt-4"):
self.experts = experts # 不同领域的专家prompt
self.model = model
self.decision_history = []
def make_decision(self, context: str, options: List[str]) -> dict:
"""基于多专家投票做出决策"""
expert_opinions = []
# 收集各专家意见
for expert in self.experts:
prompt = f"""作为{expert}，请根据以下上下文做出最佳决策：
上下文：{context}
可选方案：
{chr(10).join(f"{i+1}. {opt}" for i, opt in enumerate(options))}
请按以下格式回答：
推荐方案：[选项编号]
理由：[您的分析]"""
response = openai.ChatCompletion.create(
model=self.model,
messages=[{"role": "user", "content": prompt}],
temperature=0.7
)
text = response.choices[0].message.content
try:
choice = int(text.split("推荐方案：")[1][0]) - 1
reason = text.split("理由：")[1].strip()
except:
choice = 0
reason = "解析失败"
expert_opinions.append({
"expert":