智能Agent的规划与推理:从ReAct到Tree-of-Thought的任务分解策略

AI Agent规划与推理:从ReAct到ToT,构建可靠智能体的核心技术 在人工智能领域,智能体(Agent)的规划与推理能力是其实现自主决策和复杂任务处理的核心。其基本原理是让系统能够分解目标、评估状态、制定步骤序列,并在执行过程中动态调整策略,从而超越简单的指令-反应模式。这一技术价值在于将大语言模型的强大生成能力与结构化思维过程相结合,显著提升了任务执行的可靠性、可解释性和适应性。在应用场景上,规划与推理技术广泛应用于智能客服、自动化流程、创意生成、复杂问题求解等领域,是构建能够在开放环境中可靠工作的智能助手的关键。本文深入探讨了实现这一能力的两种主流范式:ReAct(Re 阅读详情

智能Agent的规划与推理:从ReAct到Tree-of-Thought的任务分解策略

cover

一、Agent"迷路"的困境:复杂任务下的推理坍塌

大语言模型驱动的 Agent 在单步决策中表现尚可,但面对多步骤、多分支的复杂任务时,推理链常常在中途断裂或陷入循环。一个典型场景:让 Agent 完成"调研某技术方案并输出对比报告",它可能在第一步就迷失方向——是先搜索资料,还是先确定评估维度?即使开始了推理,也容易在中间步骤偏离目标,产生"幻觉行动"或重复调用同一工具。

根本原因在于:LLM 的自回归生成本质上是线性的,而复杂任务需要树状或图状的推理结构。ReAct(Reasoning + Acting)范式通过交替"思考-行动-观察"缓解了部分问题,但在长链推理中仍会累积误差。Tree-of-Thought(ToT)将推理空间扩展为搜索树,却带来了计算成本的指数增长。如何在推理深度与计算效率之间找到平衡,是构建可靠 Agent 的核心挑战。

二、推理范式演进:从线性链到搜索树的底层机制

2.1 三种推理范式的对比

graph TD
    A[LLM 推理范式] --> B[Chain-of-Thought<br/>线性链式推理]
    A --> C[ReAct<br/>思考-行动-观察循环]
    A --> D[Tree-of-Thought<br/>树状搜索推理]

    B --> B1[优点: 简单直接]
    B --> B2[缺点: 无法回溯纠错]

    C --> C1[优点: 可与环境交互]
    C --> C2[缺点: 单路径易陷入局部最优]

    D --> D1[优点: 可探索多分支回溯]
    D --> D2[缺点: 计算成本指数增长]

    B2 --> E[核心问题:<br/>推理路径不可回溯]
    C2 --> E
    D2 --> F[核心问题:<br/>搜索空间爆炸]

2.2 ReAct 的执行循环

ReAct 的核心是一个有限状态机:Thought → Action → Observation → Thought → ...。每一步的 Thought 是对当前状态的推理,Action 是选择并执行工具,Observation 是工具返回的结果。关键约束在于:每一步只能基于当前上下文窗口中的信息做决策,而上下文窗口的容量是有限的。

当推理链超过 10 步以上,早期关键信息可能被截断或稀释,导致 Agent "遗忘"初始目标。这并非模型能力不足,而是推理架构的固有缺陷——线性链无法表达"如果这条路走不通,回到分叉点尝试另一条路"的回溯逻辑。

2.3 Tree-of-Thought 的搜索策略

ToT 将每一步推理扩展为多个候选分支,通过评估函数对每个分支打分,选择最有前景的路径继续探索。搜索策略包括:

  • BFS(广度优先):每层保留 top-k 分支,逐层扩展。适合解空间较浅但宽度大的任务。
  • DFS(深度优先):沿一条路径深入到底,遇到死胡同回溯。适合解空间深但分支少的任务。
  • A* 启发式搜索:结合当前代价与启发式估计,优先扩展最有前景的节点。

ToT 的代价是:每扩展一层,LLM 调用次数乘以分支因子 b。3 层深度、分支因子 5 的搜索需要 125 次 LLM 调用,这在生产环境中几乎不可接受。

三、混合推理引擎:ReAct + 剪枝 ToT 的生产级实现

# hybrid_agent.py — 混合推理引擎
# 设计意图:结合 ReAct 的高效执行与 ToT 的回溯能力,
# 在关键决策点启用树搜索,其余步骤走线性推理

from dataclasses import dataclass, field
from enum import Enum
from typing import Optional
import json


class ReasoningMode(Enum):
    REACT = "react"          # 线性推理模式
    TOT_BFS = "tot_bfs"      # 广度优先树搜索
    TOT_DFS = "tot_dfs"      # 深度优先树搜索


@dataclass
class ThoughtNode:
    """推理树节点:记录思考内容、评估分数与子节点"""
    thought: str
    score: float = 0.0
    action: Optional[str] = None
    observation: Optional[str] = None
    children: list = field(default_factory=list)
    parent: Optional['ThoughtNode'] = None
    is_pruned: bool = False


class HybridReasoningAgent:
    """混合推理 Agent:在关键决策点切换推理模式"""

    def __init__(self, llm_client, tools: dict, config: dict = None):
        self.llm = llm_client
        self.tools = tools
        self.config = config or {
            "max_react_steps": 15,       # ReAct 最大步数
            "tot_branch_factor": 3,      # ToT 分支因子(控制搜索宽度)
            "tot_max_depth": 3,          # ToT 最大搜索深度
            "prune_threshold": 0.3,      # 剪枝阈值:低于此分数的分支直接丢弃
            "confidence_threshold": 0.7, # 低于此置信度时切换到 ToT 模式
        }
        self.root = None
        self.reasoning_trace = []  # 完整推理轨迹,用于调试与可观测性

    def _call_llm(self, prompt: str, temperature: float = 0.0) -> str:
        """调用 LLM,统一入口便于替换模型与追踪调用"""
        response = self.llm.chat(
            messages=[{"role": "user", "content": prompt}],
            temperature=temperature,
        )
        return response.choices[0].message.content

    def _evaluate_thought(self, thought: str, goal: str) -> float:
        """评估推理分支的质量,返回 [0, 1] 分数"""
        eval_prompt = f"""评估以下推理步骤对目标的相关性和合理性。

目标: {goal}
推理步骤: {thought}

请从以下维度打分(0-1):
1. 相关性:该步骤是否直接服务于目标?
2. 可行性:该步骤提出的行动是否可执行?
3. 信息增益:该步骤是否能带来新的有用信息?

只输出一个 0 到 1 之间的数字,不要其他内容。"""
        score_str = self._call_llm(eval_prompt, temperature=0.0)
        try:
            score = float(score_str.strip())
            return max(0.0, min(1.0, score))
        except ValueError:
            return 0.5  # 解析失败时给中等分数

    def _should_switch_to_tot(self, thought: str, goal: str) -> bool:
        """判断当前推理步骤是否需要切换到树搜索模式"""
        confidence_prompt = f"""判断以下推理步骤的确定性程度。

目标: {goal}
当前推理: {thought}

如果该步骤的后续路径明确且唯一,输出 "HIGH"。
如果存在多种可能的后续方向且难以选择,输出 "LOW"。
只输出 HIGH 或 LOW。"""
        result = self._call_llm(confidence_prompt, temperature=0.0).strip()
        return result.upper() == "LOW"

    def react_step(self, goal: str, history: list) -> ThoughtNode:
        """执行一步 ReAct 推理"""
        prompt = f"""你是一个智能 Agent,正在完成以下目标:{goal}

历史步骤:
{self._format_history(history)}

请输出下一步的思考和行动,格式如下:
THOUGHT: [你的推理过程]
ACTION: [工具名称](参数)

可用工具: {list(self.tools.keys())}"""
        response = self._call_llm(prompt, temperature=0.0)
        thought, action = self._parse_react_response(response)

        node = ThoughtNode(thought=thought, action=action)
        if action:
            tool_name, args = self._parse_action(action)
            if tool_name in self.tools:
                node.observation = self.tools[tool_name](**args)
        return node

    def tot_search(self, goal: str, current_state: str,
                   mode: ReasoningMode = ReasoningMode.TOT_BFS) -> ThoughtNode:
        """执行 Tree-of-Thought 搜索"""
        self.root = ThoughtNode(thought=current_state)
        branch_factor = self.config["tot_branch_factor"]
        max_depth = self.config["tot_max_depth"]
        prune_threshold = self.config["prune_threshold"]

        if mode == ReasoningMode.TOT_BFS:
            return self._tot_bfs(goal, self.root, branch_factor,
                                 max_depth, prune_threshold)
        else:
            return self._tot_dfs(goal, self.root, branch_factor,
                                 max_depth, prune_threshold)

    def _tot_bfs(self, goal: str, root: ThoughtNode,
                 branch_factor: int, max_depth: int,
                 prune_threshold: float) -> ThoughtNode:
        """广度优先 ToT 搜索:逐层扩展并剪枝"""
        current_level = [root]

        for depth in range(max_depth):
            next_level = []
            for node in current_level:
                # 为每个节点生成 branch_factor 个候选推理分支
                candidates = self._generate_branches(
                    goal, node.thought, branch_factor
                )
                for thought in candidates:
                    score = self._evaluate_thought(thought, goal)
                    child = ThoughtNode(
                        thought=thought, score=score, parent=node
                    )
                    # 剪枝:低分分支直接丢弃,减少搜索空间
                    if score >= prune_threshold:
                        node.children.append(child)
                        next_level.append(child)
                    else:
                        child.is_pruned = True
                        self.reasoning_trace.append(
                            f"[PRUNE] depth={depth} score={score:.2f} "
                            f"thought={thought[:50]}..."
                        )

            if not next_level:
                break
            # 每层只保留 top-k 分支,控制搜索宽度
            next_level.sort(key=lambda n: n.score, reverse=True)
            current_level = next_level[:branch_factor]

        # 选择全局最优路径
        return self._select_best_path(root)

    def _tot_dfs(self, goal: str, node: ThoughtNode,
                 branch_factor: int, max_depth: int,
                 prune_threshold: float, depth: int = 0) -> ThoughtNode:
        """深度优先 ToT 搜索:沿最有前景的路径深入"""
        if depth >= max_depth:
            return node

        candidates = self._generate_branches(
            goal, node.thought, branch_factor
        )
        scored = []
        for thought in candidates:
            score = self._evaluate_thought(thought, goal)
            if score >= prune_threshold:
                child = ThoughtNode(
                    thought=thought, score=score, parent=node
                )
                node.children.append(child)
                scored.append(child)

        # 按分数降序排列,优先探索最有前景的分支
        scored.sort(key=lambda n: n.score, reverse=True)

        for child in scored:
            result = self._tot_dfs(
                goal, child, branch_factor, max_depth,
                prune_threshold, depth + 1
            )
            # 如果找到高分解,立即返回(早停机制)
            if result.score >= 0.9:
                return result

        return scored[0] if scored else node

    def _generate_branches(self, goal: str, current: str,
                           count: int) -> list[str]:
        """为当前状态生成多个候选推理分支"""
        prompt = f"""目标: {goal}
当前状态: {current}

请生成 {count} 种不同的下一步推理方向,每种一行,格式:
1. [推理方向1]
2. [推理方向2]
3. [推理方向3]

确保每种方向有本质区别,不要只是措辞变化。"""
        response = self._call_llm(prompt, temperature=0.7)
        branches = []
        for line in response.strip().split("\n"):
            line = line.strip()
            if line and line[0].isdigit():
                # 去除序号前缀
                content = line.lstrip("0123456789. ").strip()
                if content:
                    branches.append(content)
        return branches[:count]

    def _select_best_path(self, root: ThoughtNode) -> ThoughtNode:
        """从推理树中选择得分最高的叶节点路径"""
        best_node = root
        best_score = root.score

        def traverse(node: ThoughtNode):
            nonlocal best_node, best_score
            if not node.children:  # 叶节点
                # 路径总分 = 各节点分数的加权平均
                path_score = self._path_average_score(node)
                if path_score > best_score:
                    best_score = path_score
                    best_node = node
            for child in node.children:
                traverse(child)

        traverse(root)
        return best_node

    def _path_average_score(self, leaf: ThoughtNode) -> float:
        """计算从根到叶节点的路径平均分"""
        scores = []
        node = leaf
        while node is not None:
            if node.score > 0:
                scores.append(node.score)
            node = node.parent
        return sum(scores) / len(scores) if scores else 0.0

    def run(self, goal: str) -> dict:
        """执行完整的混合推理流程"""
        history = []
        step = 0

        while step < self.config["max_react_steps"]:
            # 执行一步 ReAct
            node = self.react_step(goal, history)
            history.append(node)
            step += 1

            # 检查是否需要切换到 ToT 模式
            if self._should_switch_to_tot(node.thought, goal):
                self.reasoning_trace.append(
                    f"[SWITCH] Step {step}: 切换到 ToT 模式"
                )
                best_path = self.tot_search(
                    goal, node.thought, ReasoningMode.TOT_BFS
                )
                # 将 ToT 找到的最优路径合并回 ReAct 历史
                path_nodes = self._reconstruct_path(best_path)
                history.extend(path_nodes)
                step += len(path_nodes)

            # 检查是否已完成目标
            if self._is_goal_reached(node.thought, goal):
                break

        return {
            "goal": goal,
            "steps": step,
            "history": [
                {"thought": n.thought, "action": n.action,
                 "observation": n.observation}
                for n in history
            ],
            "trace": self.reasoning_trace,
        }

    def _is_goal_reached(self, thought: str, goal: str) -> bool:
        """判断目标是否已达成"""
        check_prompt = f"""判断以下推理是否已经完成了目标。

目标: {goal}
最新推理: {thought}

如果目标已完成,输出 YES。否则输出 NO。只输出 YES 或 NO。"""
        result = self._call_llm(check_prompt, temperature=0.0).strip()
        return result.upper() == "YES"

    def _reconstruct_path(self, leaf: ThoughtNode) -> list[ThoughtNode]:
        """从叶节点回溯重建路径(排除根节点)"""
        path = []
        node = leaf
        while node.parent is not None and node.parent.parent is not None:
            path.append(node)
            node = node.parent
        path.reverse()
        return path

    @staticmethod
    def _format_history(history: list) -> str:
        """格式化历史步骤为可读文本"""
        lines = []
        for i, node in enumerate(history):
            lines.append(f"Step {i+1}: THOUGHT: {node.thought}")
            if node.action:
                lines.append(f"  ACTION: {node.action}")
            if node.observation:
                lines.append(f"  OBSERVATION: {node.observation[:200]}")
        return "\n".join(lines) if lines else "(无历史步骤)"

    @staticmethod
    def _parse_react_response(response: str) -> tuple:
        """解析 ReAct 格式的响应"""
        thought = ""
        action = ""
        for line in response.split("\n"):
            if line.startswith("THOUGHT:"):
                thought = line.replace("THOUGHT:", "").strip()
            elif line.startswith("ACTION:"):
                action = line.replace("ACTION:", "").strip()
        return thought, action

    @staticmethod
    def _parse_action(action: str) -> tuple:
        """解析工具调用格式:tool_name(arg1=val1, arg2=val2)"""
        if "(" not in action:
            return action, {}
        tool_name = action.split("(")[0].strip()
        args_str = action.split("(")[1].rstrip(")")
        try:
            args = json.loads(f"{{{args_str}}}")
        except json.JSONDecodeError:
            args = {}
        return tool_name, args

四、推理深度与计算成本的权衡:三种模式的适用边界

混合推理引擎的核心 Trade-off 在于推理质量与 LLM 调用次数的矛盾:

推理模式LLM 调用次数适用场景失败模式
纯 ReActO(n),n 为步数路径明确的线性任务长链累积误差,无法回溯
纯 ToT-BFSO(b^d),b 为分支因子,d 为深度解空间浅但宽的决策计算成本爆炸,延迟过高
混合模式O(n + b^k),k 为关键决策点数复杂但局部可线性化的任务关键决策点识别不准

混合模式的三个关键参数调优建议:

  1. confidence_threshold(置信度阈值):设为 0.7 是经验值。降低阈值会让 Agent 更频繁切换到 ToT,增加成本但提高决策质量;提高阈值则相反。在工具调用结果确定性高的场景(如数据库查询),可以提高到 0.85;在开放式推理场景(如方案设计),应降低到 0.6。

  2. tot_branch_factor(分支因子):3 是成本与覆盖率的平衡点。分支因子为 2 时,搜索空间太小容易遗漏最优解;为 5 时,LLM 调用次数增长 4 倍但边际收益递减。

  3. prune_threshold(剪枝阈值):0.3 是激进剪枝策略。在计算资源充裕时可以降低到 0.2,保留更多候选分支;在延迟敏感场景可以提高到 0.5,快速收敛。

禁用场景:当 LLM 的单次调用延迟超过 2 秒时,ToT 模式的用户体验极差(3 层 BFS 可能需要 30 秒以上),此时应退化为纯 ReAct 并通过更好的 Prompt 设计弥补推理能力的不足。

五、总结

智能 Agent 的推理能力取决于推理架构与任务复杂度的匹配程度。纯线性推理(ReAct)在路径明确的任务中高效可靠,但面对分支决策时容易陷入局部最优;纯树搜索(ToT)提供了回溯能力,但计算成本在深度和宽度上指数增长。混合策略的关键洞察是:并非每一步都需要搜索,只在置信度低的关键决策点启用树搜索,其余步骤走线性推理。

落地路线建议:先用纯 ReAct 跑通任务流程,收集推理失败的 case;分析失败模式,识别出需要回溯的关键决策点;在关键点插入 ToT 搜索,配合剪枝和早停控制成本;持续监控 LLM 调用次数与任务成功率,调整置信度阈值和分支因子。推理架构没有银弹,只有与任务特征匹配的合理权衡。

AI Agent工程师面试指南:推理框架与系统设计 AI Agent工程师是当前技术领域的热门岗位,涉及构建具备自主感知、决策和行动能力的智能体系统。其核心技术包括自然语言处理、多步任务规划和工具调用等。在推理框架方面,Chain-of-Thought(CoT)通过展示推理过程提升问题解决能力,而ReAct框架结合推理与行动,实现复杂任务的逐步解决。这些技术广泛应用于客服系统、RAG(检索增强生成)等场景,显著提升系统的智能化水平。AI Agent工程师需掌握LLM底层原理、系统工程能力及创新思维,以满足企业日益增长的技术需求。 阅读详情

相关推荐

AI智能体实战:从LLM到规划推箱子,揭秘复杂推理架构

最近,AI领域最火热的新闻是什么?是某个大模型又刷新了某个学术榜单,还是某个AI公司发布了参数更大的新模型?都不是。真正在开发者社区和科技媒体中引发广泛讨论的,是一个看似“幼稚”的问题: 为什么世界上最前沿的AI,比如GPT-4o、Claude 3.5 Sonnet,会被用来测试“推箱子”和“移动红点”这类简单的游戏? 这听起来像是一个冷笑话。我们投入了海量算力、数据和顶尖人才研发出的“智能”,最终却用来玩几十年前的小游戏?很多开发者第一反应是:这太浪费了,也太“小儿科”了。AI难道不应该去解决癌症、写诗作

hck341204的专栏 397

智能体的规划与推理

它推广了流行的“链式思维(Chain of Thought,CoT)”方法,通过允许模型探索作为解决问题中间步骤的连贯文本单元("思想"),使模型能够考虑多种不同的推理路径并自我评估选择。智能体的规划与推理能力是其实现复杂任务的核心,其中Chain-of-Thought(CoT,思维链)、Tree-of-Thought(ToT,思维树)和ReAct框架是三种关键技术。CoT技术显著提升了大型语言模型解决复杂问题的能力,通过展示推理过程增强了模型的可解释性,是当前AI解释性和可靠性研究的重要方向之一。

夏天又到了的专栏 1106

AI Agent架构全解析:从感知到行动的智能体构建指南

人工智能体(AI Agent)作为能够感知环境、自主决策并执行行动的软件实体,其核心架构通常包含感知、认知、行动与评估等关键层次。在技术实现上,大语言模型(LLM)提供了强大的推理基础,而检索增强生成(RAG)等技术则有效扩展了其知识边界与实时信息处理能力。从工程实践角度看,构建一个实用的AI Agent需要解决工具调用、记忆管理、安全护栏等核心问题,其价值在于能够将复杂的用户指令转化为一系列自动化操作,从而在智能客服、自动化研究、个人助手等场景中显著提升效率。本文以“智能研究助手”为例,深入剖析了基于Re

weixin_34007020的博客 450

LLM Agent规划能力构建:从任务分解到动态调整的五大核心维度

在人工智能与自然语言处理领域,大型语言模型(LLM)驱动的智能体(Agent)正成为技术应用的前沿。其核心能力在于将复杂目标转化为可执行动作序列的规划过程,这直接决定了智能体的自主性与实用性。规划的本质是任务分解与路径寻优,涉及从抽象指令到具体步骤的映射,以及根据环境反馈的动态调整。这一能力的技术价值在于将LLM的推理潜能转化为结构化、可重复的解决方案,从而在自动化工作流、智能助手、复杂问题求解等场景中发挥关键作用。本文聚焦于构建LLM Agent规划能力的五个核心维度,深入探讨了任务分解、规划策略、动态调

weixin_30471561的博客 377

AI Agent设计范式解析:从反思式到多智能体协作的实践指南

在人工智能领域,智能体(Agent)设计范式正经历从被动工具到主动伙伴的转变。其核心原理在于赋予大语言模型自主规划、执行与反思的能力,通过结构化工作流扩展AI的应用边界。这一技术价值体现在能够处理复杂任务、调用外部工具并实现自我优化,显著提升自动化水平。在应用场景上,Agent广泛应用于个人助手、自动化工作流、技术调研、多系统集成等领域。本文聚焦于四种主流设计范式:反思式(Reflection)Agent通过“执行-观察-反思”循环实现自我改进;工具使用式(Tool Use)Agent整合外部API如搜索与

读书、思考、生活 475

Agent 开发设计模式(Agentic Design Patterns )第 17 章:Reasoning Techniques

将复杂问题分解为多个子问题,从而提升模型在数学、逻辑、常识推理等任务上的表现。,形成“思考-行动-观察”循环,使模型具备动态交互能力。3. Workflow-Level Prompt优化。,通过生成并执行代码来完成复杂计算或逻辑任务。1. Block-Level Prompt优化。:CoT 是一种提示工程方法,:ToT 是 CoT 的扩展,,并通过评估机制选择最优路径。2. Workflow拓扑优化。,即使模型较小也能超越大模型。,避免单一模型的偏差与局限。:模型在生成内容后,

shiter编写程序的艺术 432

AI Agent 核心算法:任务规划(Planning)的深度技术解析

摘要:本文探讨了AI Agent任务规划的关键技术与演进路径,指出规划能力是模型从语言理解迈向自主决策的核心瓶颈。文章系统分析了四代规划算法:Chain-of-Thought的线性推理、ReAct的推理-行动循环、Tree of Thoughts的多路径搜索、以及LLM+P的符号规划融合,揭示了不同范式在数学本质(如POMDP求解、树搜索复杂度)和工程实现上的差异。通过代码示例和对比表格,展示了各方法的适用场景与优化方向,为构建高效Agent提供技术参考。

心有猛虎细嗅蔷薇 614

1篇2章7节:ReAct 提示词技术与提示工程三大方法的协同进化

本文聚焦提示工程中的 ReAct(Reason & Act) 技术,解析其“先推理、后行动、再反馈”的闭环机制,以及与 Step-back 和 Tree of Thoughts(ToT) 的关系与差异。文章通过代码示例与应用场景,展示了 ReAct 如何通过工具调用、信息检索和动态规划解决 LLM “知识过时”与“缺乏执行力”的问题,并进一步总结三大方法在 创意生成、复杂推理与任务执行 中的优势互补,为 AI Agent 与自主系统的发展提供了方向性参考。

MD Code 429

10个AI Agent架构解析:AI-fundermentals中的智能体设计秘籍

AI Agent作为人工智能领域的前沿技术,正在深刻改变我们与机器交互的方式。本文将深入解析AI-fundermentals项目中10种核心智能体架构,从基础的反射模式到复杂的多智能体协作,带您全面掌握智能体设计的精髓。无论您是AI初学者还是希望构建生产级智能系统的开发者,这些经过实战验证的架构模式都将为您提供宝贵的设计思路和技术选型指南。 ## 1. Reflection(反思/自我批判):智

gitblog_00055的博客 387

【虚幻引擎】UE4初学者系列教程基础篇-全中文新手入门教程(UE5系列继续更新)

菜单栏菜单栏当中有文件、编辑、窗口帮助。文件当中可以进行一个关卡的新建、关卡的打开、关卡的保存还有就是打包项目,(项目大于关卡,项目里面可能有几百个关卡),这是比较常用的几个,这里可以看到打包当中有安卓端HTML5端,IOS端linux,还有就是TVOS(苹果电视)、windows的一些端口的一些设置。还可以打开最近打开的项目。关卡编辑器:工具栏3.3 “模式”面板保存所有:ctrl+shift+s(有的软件截屏也是这个按键需要注意)3.4 “内容浏览器”面板缩放:ctr+鼠标滚轮3.5.视口面板。

qq_45206556的博客 2万+

openclaw + ollama本地模型 + 飞书平台 windows平台部署教程

本教程将指导您在 Windows 10/11 环境下,通过 Ollama 运行本地模型,并结合 OpenClaw 接入飞书,搭建一个完全本地化的 AI 助手。

专注于技术研发行业技术主要有AI人工智能视觉识别、物联网技术、电商平台、app原生技术、微信小程序、鸿蒙语言开发、办公企业oa、ERP等,致力于做东半球最优秀的程序员 2178

AI智能体通用规划:从任务分解到反思循环的工程实践

智能体规划是AI领域实现复杂任务自动化的核心技术,其核心原理在于将高层目标通过任务分解转化为可执行的行动序列。这一过程涉及对任务依赖关系的推理、工具的动态组合调用以及对执行结果的持续评估与调整,其技术价值在于赋予AI系统解决开放域、多步骤复杂问题的能力。在应用场景上,通用规划智能体可广泛应用于智能客服、自动化数据分析、个性化行程设计等领域。本文聚焦于AI智能体规划,深入探讨了层次化任务分解、动态工具检索等关键技术,并针对规划-执行-反思闭环中的常见陷阱提供了优化策略,为构建鲁棒的智能体系统提供了实践指导。

weixin_30628077的博客 370

NXP S32K5 MCU如何赋能Zonal架构与软件定义汽车?

汽车电子架构正从分布式ECU向域集中、再向Zonal分区架构演进,核心驱动力在于线束简化、算力下沉与软件分层解耦。区域控制器作为物理区域的“调度员”,需要同时满足实时响应、功能安全、多网络协议转换和OTA升级等要求,这使MCU与SoC的选型成为系统工程的关键决策。MCU凭借确定性的微秒级启动、低功耗、丰富的IO控制以及成熟的ASIL-D认证路径,仍是区域控制器的主流选择。NXP S32K5正是面向这一场景发布的系列MCU:它集成多核锁步、CAN-XL、TSN以太网、硬件安全模块与双Bank Flash,补齐

weixin_28721917的博客 359

LLM Agent架构解析:从ReAct框架到实战构建智能体系统

在人工智能领域,智能体(Agent)技术正成为连接大语言模型与实际应用的关键桥梁。其核心原理在于通过规划、决策与执行的闭环,使模型从被动应答转向主动完成任务。ReAct(推理-行动)框架是实现这一转变的主流范式,它引导模型进行链式思考并调用工具与环境交互。这种架构的技术价值在于将静态知识转化为动态工作流,显著提升了AI系统的自主性和实用性。在应用场景上,智能体广泛适用于自动化调研、数据分析、客户服务等需要多步骤处理的复杂任务。本文聚焦于LLM Agent的架构设计与工程实现,深入探讨了其记忆管理、工具集成及

weixin_34014555的博客 321

【MATLAB强化学习工具箱】学习笔记--在Simulink环境中训练智能体Create Simulink Environment and Train Agent

Simulink中便于搭建各类动力学与控制模型,通过将原有的控制器替换为AI控制器,可以方便使用已有模型,提供增量效果。 本节的重点是如何引入Simulink模型作为env,其他的内容在之前的文章中已有说明。 以水箱模型watertank为例,如下图所示: 采用PI控制器,控制效果如下所示: 将此PI控制器替换为神经网络控制器后,系统架构如下图所示: 具体替换策略如下所示: (1)删去PID控制器; (2)增加RL Agent模块; (3)观测器模块: 观测向量为:,其中...

bear_miao的博客 1万+

rk3588调试imx415记录

分享适配imx415的软件配置以及一些关键的调试命令

m0_60805802的博客 2892

AI Agent架构全解析:从意图理解到任务执行的智能闭环

在人工智能领域,智能体(Agent)是实现任务自动化的核心技术范式。其核心原理在于构建一个能够感知、规划、执行与反思的自主系统。通过大语言模型驱动的意图理解与任务分解,智能体可将模糊的用户指令转化为可执行的具体步骤。技术价值在于突破了传统脚本的僵化限制,实现了对复杂、动态任务的适应性处理。在应用场景上,智能体广泛应用于智能客服、自动化流程、数据分析与报告生成等领域。本文聚焦于AI Agent的完整架构闭环,深入剖析了其从任务规划、工具调用到评估反思的核心工作流,并结合ReAct模式与工具调用框架等热词,提供

weixin_34221775的博客 329

YOLOv11改进 | 损失函数改进篇 | 2024最新高质量的目标检测边界框回归损失Unified-IoU、FocalUIoU、FocalInvUIoU(设置动态epoch参数)

本文给大家带来的改进机制是最近新提出的高质量的目标检测边界框回归损失,其通过动态调整模型对不同质量预测框的关注,优化目标检测中的边界框回归精度。UIoU引入了FocalBox方法,通过缩放预测框与真实框分配权重,并采用了退火策略(引入动态参数epoch),逐渐将模型的注意力从低质量预测框转移到高质量预测框,平衡了训练速度与检测精度。其还有一定的解决样本不平衡问题,同时该损失函数可以和现有的任何边界框回归损失函数进行结合,例如ShapeIoU和其结合可以形成二次创新,它是一种类似于之前的Inner的机制.

Snu77的博客 4591

AI Agent 系统设计:从单轮对话到多步推理的架构演进

规划模块:将高层目标分解为可执行的子任务或步骤序列。这可以是简单的思维链(Chain-of-Thought),也可以是复杂的任务分解树。任务分解:将模糊的用户需求转化为明确、可执行的动作序列。路径规划:在多个可能的执行路径中选择最优或最可行的方案。动态调整:根据执行结果和环境变化实时调整计划。记忆模块:为 Agent 提供上下文和历史感知能力。短期记忆:当前对话或任务的上下文,通常以对话历史的形式存在。长期记忆:通过向量数据库、图数据库等存储和检索的过往经验、领域知识、用户偏好。工作记忆。

2601_96493715的博客 377

基于Qt C++开发一款国产化的福昕风格PDF编辑工具

QString text = QInputDialog::getText(this, "文本批注", "输入批注内容:", QLineEdit::Normal, "", &ok);QString savePath = QFileDialog::getSaveFileName(this, "保存加密PDF", "", "PDF文件 (*.pdf)");QAction* zoomInAct = new QAction(QIcon::fromTheme("zoom-in"), "放大", this);

寒寒豆豆软件公司的博客 239

YOLOv8自定义训练:车牌识别全流程(从标注到推理,附可视化代码)

车牌检测全流程实践指南 摘要:本文详细介绍了基于YOLOv8的车牌检测完整实现方案。针对车牌检测中的三大难点(小目标、多角度、光照变化),提供了从数据准备到模型部署的全流程解决方案。重点包括:1)数据采集与标注规范;2)针对小目标的YOLOv8模型优化配置;3)K-means锚框聚类方法;4)训练参数调优策略。通过实际验证,该方法可获得95%以上的检测准确率,并附有完整的代码实现和可视化工具,便于开发者快速复现应用。 (字数:149字)

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 851

深入解析ReAct模式:大模型Agent的核心循环引擎与工程实践

在大模型应用开发中,Agent模式是实现复杂任务自动化与智能交互的关键架构范式。其核心原理在于赋予模型自主规划、决策与执行的能力,通过结构化的工作流协调多个功能模块。ReAct(Reasoning-Acting)作为Agent模式的一种经典实现,将推理与行动解耦,形成一个动态的、可迭代的思考-行动循环。这种机制的技术价值在于,它不仅提升了任务处理的透明度和可解释性,还通过工具调用(Function Call)实现了与外部环境(如数据库、API、知识库)的实时交互,从而解决纯生成模型在信息获取和操作执行上的局

weixin_33721427的博客 412

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

ReAct架构:让AI智能体从“答题机”到“执行者”的范式跃迁

在人工智能领域,智能体(Agent)是实现自主决策与环境交互的核心技术范式。其核心原理在于通过感知、规划、行动与学习的循环,赋予机器解决复杂任务的能力。这一技术价值在于突破了传统“指令-响应”模式的局限,使AI能够处理模糊、多步骤的开放性问题,从而在自动化办公、数据分析、智能助手等应用场景中发挥巨大作用。本文聚焦于实现智能体的关键架构——ReAct(Reasoning + Acting),它通过显式化的“思考-行动-观察”循环,将大语言模型的推理能力与外部工具的执行能力紧密结合,是构建可靠、可解释智能体的主

weixin_30458043的博客 320

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

01 - 从0到1搞懂AI Agent!一文看懂智能体的前世今生与核心架构

最近半年,AI Agent(智能体)这个词火得一塌糊涂。打开技术社区,铺天盖地都是Agent相关的文章;打开招聘网站,Agent开发工程师的薪资水涨船高。但说实话,很多同学对Agent的理解还停留在“ChatGPT套壳”的层面。作为一个从传统开发转型AI的过来人,我深知这种迷茫——明明有编程基础,却不知道Agent到底是什么、能做什么、怎么学。这篇文章,就是写给这样的你。我会用最通俗的语言、最清晰的逻辑,带你从零开始搞懂AI Agent。框架学习曲线灵活性适合场景LangChain中等。

H.J.J的博客 1109

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

从零拆解ReAct架构:构建会思考的AI Agent核心原理与实践

在AI应用开发领域,智能体(Agent)已成为连接大语言模型与现实世界任务的关键技术。其核心在于模拟人类的决策过程,通过循环的推理与行动来解决问题。ReAct(Reasoning + Acting)架构正是这一思想的经典实现范式,它通过“思考-行动-观察”的循环,让AI在行动前进行规划,在行动后依据结果调整策略,从而克服了传统方法中“仅行动”的盲目性与“仅推理”的局限性。该架构的价值在于为AI赋予了处理复杂、多步、依赖实时信息任务的能力,广泛应用于智能问答、自动化工作流和数据分析等场景。本文将以**提示工程

weixin_33805992的博客 355

AI Agent大师之路:从认知架构到自主智能体的完整设计哲学

2025年,AI Agent不再是实验室里的新鲜概念,而是正在重塑软件工程、自动化运维、金融交易、科研探索等领域的核心生产力工具。但真正的"Agent大师"与普通调用者的区别,不在于谁用了更先进的模型,而在于谁深刻理解Agent的认知架构、规划机制、工具使用范式与记忆系统。

m0_64363449的博客 297
上一篇: Rust 闭包与 Fn Trait 体系:从捕获模式到零成本抽象的底层机制
下一篇: Rust 所有权与生命周期实战:结构体字段借用与生命周期标注的精妙约束
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值