大模型程序性知识实战--ReAct:推理与行动交替的执行程序

目录
- 从纯思考到思考加行动
- ReAct循环的结构:轨迹、观察与回灌
- 行动空间设计:给模型哪些可执行动作
- 观察结果的回灌格式与信息密度
- 循环的终止条件与防护
- ReAct的失效模式与对策
- 与思维链和工具调用的关系
- 实战:最小可用的ReAct执行引擎
摘要
ReAct 把程序性执行从"想完再做"升级为"想一步、做一步、看结果、再想":推理步与行动步在轨迹中交替,观察结果回灌后驱动下一步。本文拆解 ReAct 循环结构、行动空间设计、观察回灌格式、终止防护与失效模式,给出最小可用的 ReAct 执行引擎代码。
1. 从纯思考到思考加行动
1.1 纯思维链的盲区
思维链只能操作模型权重里已有的知识:不知道的 API、过时的配置、需要实时查询的状态,思维链编不出来。纯推理遇到"缺信息"的任务时只有两条路——凭幻觉补齐(危险)或承认失败(无用)。
图:纯推理与ReAct在缺信息任务上的分岔
图下解读:ReAct 的本质改进是把"行动"作为程序性执行的原语:推理决定做什么,行动改变世界或获取信息,观察把真实结果带回轨迹。知识与事实从"回忆"变成"查询",幻觉的根子被釜底抽薪。
1.2 推理步与行动步的分工
| 步类型 | 职责 | 输出 |
|---|---|---|
| 思考(Thought) | 分析现状、规划下一步、解读观察 | 一段推理文本 |
| 行动(Action) | 调用工具改变或查询 | 工具调用 |
| 观察(Observation) | 执行结果 | 工具输出回灌 |
三步构成一个循环单元:思考解释"为什么做",行动执行"做什么",观察提供"结果如何"。分工明确后,每一步都可单独审计(思考是否合理、行动是否得当、观察是否被正确解读)。
1.3 交替执行的收益
交替执行(而非先想完再做完)让模型在信息增量到达时修正路线:查询结果推翻预设时,下一个思考步立即调整计划。这与第 12 篇规划执行的"计划修正"同源,只是粒度更细——每一步行动后都有修正机会。
2. ReAct循环的结构:轨迹、观察与回灌
2.1 轨迹的构成
ReAct 的执行轨迹是"思考-行动-观察"三元组的序列。轨迹既是模型的输入(前几轮三元组进上下文),也是输出的格式约定(新三元组按同样格式续写)。
图:一轮ReAct循环的信息流
图下解读:一轮循环的信息流闭合:轨迹喂给模型,模型产出思考与行动,行动改变环境,观察回到轨迹。循环的出口只有 finish(显式)与防护终止(强制),观察永远回到轨迹而不是直接进答案。
// 来源:自实现 / react_trace.txt(ReAct轨迹格式)
Thought 1: 任务是查某仓库最近的release版本。
我需要先搜索仓库主页。
Action 1: web_search["repo-name latest release"]
Observation 1: 搜索结果显示 v2.4.1 于本月发布…
Thought 2: 搜索结果可信但需交叉验证,
查看仓库的 releases 页面。
Action 2: web_fetch["https://github.com/repo/releases"]
Observation 2: 页面列出 v2.4.1 …
Thought 3: 两个来源一致,可以给出答案。
Action 3: finish["v2.4.1"]
轨迹格式的工程要点:编号连续(便于引用与审计)、每段有类型前缀(解析器可切分)、行动带参数(可重放)。格式在提示词里用示例锚定(第 1 篇的少样本杠杆)。
2.2 轨迹的增长与窗口预算
每轮循环轨迹加一段三元组,长任务的轨迹会吃满窗口。轨迹管理两层:近端原样保留(最近三五轮),远端摘要压缩(已完成子任务的轨迹折叠成一行结论)。
| 区域 | 内容 | 处理 |
|---|---|---|
| 近端 | 最近几轮三元组原文 | 保留完整 |
| 远端 | 早期轮次 | 折叠为结论行 |
| 系统 | 任务描述与行动空间 | 固定头部 |
折叠的单位是"已完成子任务":查询 A 的四轮轨迹压成"查询A:结果X"一行,细节按需重查。这与第 3 篇压缩策略的原则一致(过程可丢、结论必留)。
2.3 观察回灌的实现
# 来源:自实现 / react_trace_mgr.py(轨迹管理与回灌)
import json
class TraceManager:
"""ReAct轨迹的追加、折叠与渲染"""
def __init__(self, max_recent: int = 5):
self.rounds: list[dict] = []
self.max_recent = max_recent
def add_round(self, thought: str, action: str,
observation: str):
self.rounds.append({"n": len(self.rounds) + 1,
"thought": thought,
"action": action,
"observation": observation})
def _fold(self, r: dict) -> str:
"""远端轮次折叠为一行结论"""
obs_head = r["observation"][:60].replace("\n", " ")
return (f"轮{r['n']}(已完成):{r['action'][:40]}"
f" → {obs_head}")
def render(self) -> str:
if len(self.rounds) <= self.max_recent:
parts = [f"Thought {r['n']}: {r['thought']}\n"
f"Action {r['n']}: {r['action']}\n"
f"Observation {r['n']}: {r['observation']}"
for r in self.rounds]
return "\n\n".join(parts)
cut = len(self.rounds) - self.max_recent
folded = "\n".join(self._fold(r)
for r in self.rounds[:cut])
recent = "\n\n".join(
f"Thought {r['n']}: {r['thought']}\n"
f"Action {r['n']}: {r['action']}\n"
f"Observation {r['n']}: {r['observation']}"
for r in self.rounds[cut:])
return f"[早期轨迹(已折叠)]\n{folded}\n\n{recent}"
if __name__ == "__main__":
tm = TraceManager(max_recent=2)
for i in range(4):
tm.add_round(f"思考{i+1}", f"search[{i+1}]",
f"结果{i+1}")
print(tm.render()[:300])
源码说明:TraceManager 用"近端原文加远端折叠"管理轨迹增长:折叠行保留动作与观察头部(结论必留),近端轮次完整原文。渲染输出直接作为下一轮生成的上下文,轨迹增长有界。
3. 行动空间设计:给模型哪些可执行动作
3.1 行动空间的三条设计原则
图:行动空间三原则与反例
图下解读:三条原则各防一类失败:覆盖闭环防"没有工具只好编",粒度适中防单步太碎或太粗,描述带边界防相似动作选择混乱。与第 8 篇工具协议的工具集设计同构,质量标准一致。
| 原则 | 内容 | 反例 |
|---|---|---|
| 覆盖闭环 | 常用子任务都有对应动作 | 缺动作导致模型硬编 |
| 粒度适中 | 动作对应一个可验证单元 | 太细(点按钮级)或太粗(完成项目级) |
| 描述带边界 | 每个动作写清何时用何时不用 | 相似动作间摇摆 |
行动空间与第 8 篇(工具协议)的工具集设计同构:ReAct 的 Action 就是工具调用,行动空间即工具集,质量标准一致。
3.2 行动的注册与描述
# 来源:自实现 / action_space.py(行动空间注册)
from dataclasses import dataclass
@dataclass
class Action:
name: str
description: str # 何时用、何时不用
params: dict # 参数schema简表
fn: object # 执行函数
class ActionSpace:
"""行动空间的注册、渲染与查找"""
def __init__(self):
self._actions: dict[str, Action] = {}
def register(self, action: Action):
self._actions[action.name] = action
def get(self, name: str) -> Action | None:
return self._actions.get(name)
def render(self) -> str:
lines = []
for a in self._actions.values():
p = ", ".join(f"{k}:{v}" for k, v in a.params.items())
lines.append(f"- {a.name}({p}): {a.description}")
return "\n".join(lines)
if __name__ == "__main__":
space = ActionSpace()
space.register(Action(
"search", "检索文档。用于查事实;已知路径时改用read。",
{"query": "str"}, lambda query: f"结果:{query}"))
space.register(Action(
"finish", "提交最终答案。确认信息充分后使用。",
{"answer": "str"}, lambda answer: answer))
print(space.render())
源码说明:ActionSpace 的 render 把行动清单渲染进提示词,description 写"何时用、何时不用"(与第 8 篇 schema 说明书同一标准)。finish 动作显式存在——终止也是一种行动,模型通过调用 finish 表达"信息已充分",比依赖隐式停止更可控。
3.3 行动空间的规模控制
行动空间超过十五个后,模型在相似动作间的选择错误率上升(第 8 篇的工具集规模规律同样适用)。压缩手段:合并语义重叠动作、按任务类型动态裁剪(数据任务只挂数据类动作)、低频动作收进"高级"分组按需展示。
4. 观察结果的回灌格式与信息密度
4.1 观察的清洗与截断
工具输出可能是几万行的网页或日志,直接回灌会淹没轨迹。观察回灌走三步:清洗(去噪声)、压缩(保关键段)、标注(附元信息)。
图:观察回灌的三步压缩管线
图下解读:三步管线的目标是在"信息保真"与"轨迹预算"之间取平衡:清洗去掉的、压缩省下的都是噪声,标注保留的是判定所需的元信息(成功与否、数据来源)。
| 输出类型 | 回灌策略 |
|---|---|
| 搜索结果 | Top-3 条目加摘要 |
| 网页文本 | 正文抽取加头尾截断 |
| 命令输出 | 退出码加尾部N行 |
| API响应 | 结构化字段抽取 |
4.2 观察回灌的实现
# 来源:自实现 / observation_feeder.py(观察回灌的清洗与压缩)
import re
def feed_observation(raw: str, kind: str,
budget: int = 800) -> str:
"""按输出类型把工具结果压缩为观察文本"""
if kind == "search":
lines = [l for l in raw.splitlines() if l.strip()]
return "\n".join(lines[:3])[:budget]
if kind == "command":
ok = "退出码0" if raw.endswith("\n0") or "成功" in raw \
else "退出码非0"
tail = "\n".join(raw.splitlines()[-10:])
return f"[{ok}]\n{tail}"[:budget]
if kind == "web":
text = re.sub(r"<[^>]+>", "", raw) # 剥标签
text = re.sub(r"\s+", " ", text).strip()
return text[:budget] + ("…" if len(text) > budget else "")
return raw[:budget]
if __name__ == "__main__":
web = "<html><body>" + "正文内容" * 200 + "</body></html>"
print(feed_observation(web, "web", budget=50))
cmd = "running tests...\n3 passed\n0"
print(feed_observation(cmd, "command"))
源码说明:feed_observation 按类型分派压缩策略:搜索保 Top-3、命令保退出码与尾部(错误在尾部)、网页剥标签取正文。预算参数控制观察的最大信息密度,保证轨迹不被单次观察撑爆。
4.3 观察失败的表达
工具执行失败时,观察必须如实回灌失败信息而不是静默或编造:"查询超时,未获得结果"比空字符串好,比假装成功好得多。失败观察驱动下一个思考步调整路线(换工具、改参数、放弃该路径),这是 ReAct 容错性的来源。
5. 循环的终止条件与防护
5.1 终止的三条路径
图:ReAct循环的三条终止路径
图下解读:显式终止(finish)是理想路径,防护终止(步数、token 上限)是工程必需,外部终止保留轨迹供续跑。防护触发时走软着陆:注入"总结已获得的信息并给出当前最佳答案"的指令,让循环带着产出退出而不是空手而归。
5.2 循环防护的实现
# 来源:自实现 / react_guard.py(循环步数与重复防护)
from collections import Counter
class ReactGuard:
"""步数上限与重复行动防护"""
def __init__(self, max_steps: int = 12,
repeat_threshold: int = 3):
self.max_steps = max_steps
self.repeat_threshold = repeat_threshold
self.action_log: list[str] = []
def check(self, action_sig: str) -> tuple[bool, str]:
if len(self.action_log) >= self.max_steps:
return False, "步数超限,请总结现有信息"
self.action_log.append(action_sig)
top = Counter(self.action_log).most_common(1)[0]
if top[1] >= self.repeat_threshold:
return False, (f"动作{action_sig}已重复{top[1]}次,"
"请更换策略或finish")
return True, ""
if __name__ == "__main__":
g = ReactGuard(repeat_threshold=3)
for i in range(4):
ok, msg = g.check("search[同一个词]")
print(f"第{i+1}次:{'放行' if ok else msg}")
源码说明:ReactGuard 双闸:步数上限(绝对兜底)加重复行动检测(同签名连续三次即打转)。防护触发不硬中断,返回"建议语"进提示词让模型自我纠正——防护的形态是引导而非掐断(与第 7 篇循环防护同构)。
5.3 防护触发的软着陆
| 触发 | 软着陆动作 |
|---|---|
| 步数超限 | 注入总结指令,产出现有结论 |
| 重复行动 | 注入换路指令,附已试路径清单 |
| 观察连续失败 | 注入降级指令,改用保守答案 |
软着陆的产出(部分结论加未决事项)比空手终止有价值得多——用户至少拿到"查到哪一步、还差什么"。
6. ReAct的失效模式与对策
6.1 四类典型失效
| 失效 | 表现 | 对策 |
|---|---|---|
| 行动依赖幻觉 | 调用不存在的API或参数 | 行动空间显式列举加校验拒绝 |
| 观察忽视 | 无视观察继续原计划 | 思考步强制引用上一观察 |
| 循环打转 | 同类行动反复无进展 | 重复检测加换路指令(第 5 节) |
| 过早终止 | 信息不足就 finish | finish 前强制自检清单 |
图:四类失效的检测信号与拦截位置
图下解读:失效检测分两层:行动校验层拦"结构性错误"(未知行动、非法参数,程序判定零成本),轨迹审计层拦"行为性错误"(忽视观察、打转、过早终止)。两层都走回灌纠正而不是终止循环。
6.2 观察忽视的强制纠正
“思考步必须引用上一轮观察"是低成本的强制约束:解析思考文本,若未包含上一观察的关键词(实体、数值),回灌提示"请基于上一步观察结果继续”。这一招把"凭记忆推理"拉回"凭事实推理"。
6.3 过早终止的自检清单
finish 前的自检清单(写进行动描述或提示词):答案的每个要素都有观察支撑吗?有没有更权威的来源未查?不确定性是否已声明?清单把"何时算查完了"从模型感觉变成可核对标准。
7. 与思维链和工具调用的关系
7.1 ReAct 是思维链的行动扩展
图:三种执行形态的光谱关系
图下解读:三种形态是任务光谱上的选择而非竞争:封闭知识推理用纯思维链,开放信息任务用 ReAct,结构化操作流用纯工具调用。选择的标准只有一个——任务需要多少外部信息。
| 维度 | 纯思维链(第 1 篇) | ReAct | 纯工具调用(第 8 篇) |
|---|---|---|---|
| 步骤内容 | 推理 | 推理加行动 | 行动 |
| 信息来源 | 权重记忆 | 权重加实时观察 | 实时观察 |
| 适用任务 | 封闭知识推理 | 开放信息任务 | 结构化操作流 |
ReAct 是思维链的"接世界"版本:思考步就是思维链,行动步把思维链接上工具。三者不是竞争关系而是任务光谱上的不同选择。
7.2 与现代工具调用协议的融合
现代 API 的原生函数调用(第 8 篇)承担了 ReAct 的 Action 层:模型输出结构化 tool_calls 而非文本格式的 Action 行。融合后的形态是"结构化 ReAct":思考仍是自由文本(或专用推理通道),行动走函数调用协议,观察走结果回灌。工程收益:行动解析零成本、格式漂移风险归零。
7.3 何时退回纯思维链
不需要外部信息的封闭推理任务,ReAct 的行动步是纯开销(每次调用的时间与token)。任务路由的标准:问题能否仅凭权重内知识作答?能则纯思维链,不能则 ReAct。路由器可以是简单规则(问题类型分类)也可以是模型自判(提示词里授权模型直接作答)。
8. 实战:最小可用的ReAct执行引擎
8.1 引擎的组装
图:ReAct执行引擎的组件串联
图下解读:五个组件串成完整引擎:轨迹管理、模型生成、行动执行、观察回灌、防护检查。全部组件来自本篇实现,总装约八十行即得可运行的 ReAct 引擎。
# 来源:自实现 / react_engine.py(最小ReAct执行引擎)
import json
from react_trace_mgr import TraceManager
from action_space import ActionSpace, Action
from observation_feeder import feed_observation
from react_guard import ReactGuard
class ReactEngine:
"""思考-行动-观察交替的最小执行引擎"""
def __init__(self, model_fn, space: ActionSpace,
max_steps: int = 12):
self.model = model_fn
self.space = space
self.trace = TraceManager(max_recent=4)
self.guard = ReactGuard(max_steps=max_steps)
def _prompt(self, task: str) -> str:
return (f"任务:{task}\n\n可用行动:\n"
f"{self.space.render()}\n\n执行轨迹:\n"
f"{self.trace.render()}\n\n"
"请输出下一步:先Thought,再Action(JSON:"
'{"name":..., "params":...})。'
"信息充分时调用finish。")
def run(self, task: str) -> str:
while True:
reply = self.model(self._prompt(task))
thought, action = self._parse(reply)
if action["name"] == "finish":
return action["params"].get("answer", "")
act = self.space.get(action["name"])
if act is None:
self.trace.add_round(
thought, json.dumps(action, ensure_ascii=False),
"[错误] 未知行动,请从可用行动中选择")
continue
ok, advice = self.guard.check(action["name"])
if not ok:
self.trace.add_round(
thought, action["name"],
f"[防护] {advice}")
continue
raw = act.fn(**action.get("params", {}))
obs = feed_observation(str(raw), kind="search")
self.trace.add_round(thought, action["name"], obs)
@staticmethod
def _parse(reply: str) -> tuple[str, dict]:
import re
thought = ""
m = re.search(r"Thought\s*\d*[::](.+?)(?=Action|$)",
reply, re.S)
if m:
thought = m.group(1).strip()
m = re.search(r"\{.*\}", reply, re.S)
action = json.loads(m.group()) if m else \
{"name": "finish", "params": {"answer": reply[-200:]}}
return thought, action
if __name__ == "__main__":
space = ActionSpace()
space.register(Action("search", "查询资料",
{"query": "str"},
lambda query: f"{query}的结果: 42"))
space.register(Action("finish", "提交答案",
{"answer": "str"},
lambda answer: answer))
script = [
'Thought 1: 需要查询。\nAction 1: {"name": "search", "params": {"query": "答案"}}',
'Thought 2: 拿到42。\nAction 2: {"name": "finish", "params": {"answer": "42"}}',
]
it = iter(script)
engine = ReactEngine(lambda p: next(it), space)
print("最终答案:", engine.run("查询某问题的答案"))
源码说明:ReactEngine 串起完整循环:模型输出解析出思考与行动(未知行动回灌错误重选),防护层守步数与重复,观察经压缩回灌,finish 显式终止。脚本化模型便于测试——真实部署时换 API 客户端即可。
8.2 指标与监控
| 指标 | 定义 | 健康值 |
|---|---|---|
| 平均循环轮数 | 每任务的三元组轮数 | 与任务复杂度匹配 |
| 行动有效率 | 行动被防护或校验拒绝的占比 | 低于一成 |
| 观察利用率 | 思考步引用观察的比例 | 高于九成 |
| 软着陆占比 | 防护终止而非finish的占比 | 低于一成 |
8.3 与后续篇目的衔接
| 衔接点 | 说明 | 所属篇 |
|---|---|---|
| 自我修正 | 失败观察升级为修复回路 | 第 3 篇 |
| 技能库 | 成功轨迹沉淀为程序片段 | 第 6 篇 |
| 经验沉淀 | 轨迹反思为可复用经验 | 第 7 篇 |
| 验证器 | finish 答案过验证器再交付 | 第 9 篇 |
总结
ReAct 把程序性执行从"想完再做"升级为"想一步做一步看结果":思考步规划、行动步执行、观察步回灌,交替循环让模型在信息增量到达时修正路线,缺信息任务从"凭记忆硬编"变成"实时查询"。行动空间三原则(覆盖闭环、粒度适中、描述带边界)与工具协议设计同构,finish 显式化让终止可控。观察回灌按类型分派压缩策略(搜索保Top-3、命令保尾部、网页剥标签),失败观察如实回灌是容错的来源。防护双闸(步数上限加重复行动检测)配软着陆(总结现有信息退出),防护的形态是引导而非掐断。四类失效各有拦截层:未知行动走校验、忽视观察走强制引用、打转走换路指令、过早终止走自检清单。引擎约八十行总装,行动有效率高于九成、软着陆占比低于一成是健康线。
外部引用
- Yao 等《ReAct: Synergizing Reasoning and Acting in Language Models》:https://arxiv.org/abs/2210.03629
- Yao 等《Tree of Thoughts: Deliberate Problem Solving with Large Language Models》:https://arxiv.org/abs/2305.10601
- Shinn 等《Reflexion: Language Agents with Verbal Reinforcement Learning》:https://arxiv.org/abs/2303.11366
- OpenAI Function Calling 指南:https://platform.openai.com/docs/guides/function-calling
- Anthropic Tool Use 文档:https://docs.claude.com/en/docs/agents-and-tools/tool-use/overview
- Wang 等《A Survey on Large Language Model based Autonomous Agents》:https://arxiv.org/abs/2308.11432
- Anthropic《Building effective agents》:https://www.anthropic.com/engineering/building-effective-agents
- Press 等《Measuring and Narrowing the Compositionality Gap in Language Models》(Self-Ask):https://arxiv.org/abs/2210.03350
更多推荐


所有评论(0)