AI驱动的智能Agent工具链:从任务分解到多步推理的自动化执行

【入门篇】第六章 OpenClaw 深度解析:Agent 任务执行流程 这篇文章深入解析了OpenClaw的任务执行机制。OpenClaw采用"模型负责决策,系统负责执行"的设计,由Gateway、Agent执行逻辑、模型提供方和工具系统四个核心组件协同工作。 用户请求从进入系统到返回结果,依次经过Gateway接收转换、任务解析理解意图、大模型规划步骤、工具执行操作、整理结果返回五个阶段。文章强调,AI Agent与传统聊天系统的核心区别在于:Agent不仅能生成文本,还能通过工具执行任务。理解这套流程是构建复杂自动化系统的基础。 阅读详情

AI驱动的智能Agent工具链:从任务分解到多步推理的自动化执行

cover

一、从命令行工具到智能Agent:为什么"手动编排"是效率瓶颈

用 Rust 写命令行工具是一件很爽的事——编译器帮你挡住了大部分内存安全问题,clap 库让参数解析变得优雅。但当工具链越来越多,问题就来了:每个工具只做一件事,复杂任务需要手动串联多个工具的输入输出。比如"分析这个仓库的代码质量",需要先跑 cargo clippy,再跑 cargo test,然后收集覆盖率,最后生成报告——每一步都要人工判断上一步的输出是否正常。

AI Agent 的核心价值在于:将多步任务编排交给大模型的推理能力。用户只需描述目标,Agent 自动分解子任务、选择工具、处理异常、汇总结果。这不是简单的脚本自动化——Agent 需要根据中间结果动态调整执行策略,这要求工具链具备结构化的输入输出接口和可观测的执行状态。

二、Agent工具链的架构与推理流程

flowchart TB
    A[用户目标描述] --> B[任务分解器]
    B --> C[工具选择器]
    C --> D[工具执行器]
    D --> E[结果评估器]
    E -->|任务完成| F[结果汇总]
    E -->|需要继续| C
    E -->|遇到异常| G[异常处理器]
    G -->|重试/换工具| C

    subgraph 工具注册表
        H[cargo_clippy] --> C
        I[cargo_test] --> C
        J[git_log] --> C
        K[file_reader] --> C
    end

    subgraph 推理上下文
        L[已执行步骤] --> B
        L --> C
        L --> E
        M[中间结果] --> B
        M --> E
    end

Agent 的执行循环是"分解→选择→执行→评估"的迭代过程。任务分解器将用户目标拆解为子任务列表,工具选择器为每个子任务匹配最合适的工具,工具执行器调用工具并收集结构化输出,结果评估器判断当前进度——任务完成则汇总输出,未完成则继续循环。关键设计点在于:工具的输入输出必须是结构化的(JSON Schema),这样 Agent 才能自动解析和传递中间结果。

三、Rust实现的Agent工具链框架

3.1 工具注册与Schema定义

use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::HashMap;

/// 工具的输入输出 Schema 定义
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ToolSchema {
    pub name: String,
    pub description: String,
    pub input_schema: Value,   // JSON Schema
    pub output_schema: Value,  // JSON Schema
}

/// 工具执行结果
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ToolResult {
    pub success: bool,
    pub output: Value,
    pub error: Option<String>,
    pub execution_time_ms: u64,
}

/// 工具 Trait:所有可注册的工具必须实现
#[async_trait::async_trait]
pub trait Tool: Send + Sync {
    fn schema(&self) -> ToolSchema;
    async fn execute(&self, input: Value) -> ToolResult;
}

/// 工具注册表
pub struct ToolRegistry {
    tools: HashMap<String, Box<dyn Tool>>,
}

impl ToolRegistry {
    pub fn new() -> Self {
        Self {
            tools: HashMap::new(),
        }
    }

    pub fn register<T: Tool + 'static>(&mut self, tool: T) {
        let schema = tool.schema();
        self.tools.insert(schema.name.clone(), Box::new(tool));
    }

    pub fn get(&self, name: &str) -> Option<&Box<dyn Tool>> {
        self.tools.get(name)
    }

    /// 生成所有工具的描述,供 Agent 推理使用
    pub fn tool_descriptions(&self) -> Vec<Value> {
        self.tools.values().map(|t| {
            let schema = t.schema();
            serde_json::json!({
                "name": schema.name,
                "description": schema.description,
                "input_schema": schema.input_schema,
            })
        }).collect()
    }
}

3.2 任务分解与工具选择的Agent循环

use anyhow::Result;

/// Agent 的推理上下文
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentContext {
    pub goal: String,
    pub executed_steps: Vec<ExecutedStep>,
    pub intermediate_results: HashMap<String, Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExecutedStep {
    pub tool_name: String,
    pub input: Value,
    pub output: ToolResult,
    pub timestamp: String,
}

/// Agent 主循环
pub struct Agent {
    registry: ToolRegistry,
    llm_client: LlmClient,
    max_iterations: usize,
}

impl Agent {
    pub fn new(registry: ToolRegistry, llm_client: LlmClient) -> Self {
        Self {
            registry,
            llm_client,
            max_iterations: 10,
        }
    }

    /// 执行用户目标
    pub async fn run(&self, goal: &str) -> Result<Value> {
        let mut context = AgentContext {
            goal: goal.to_string(),
            executed_steps: Vec::new(),
            intermediate_results: HashMap::new(),
        };

        for iteration in 0..self.max_iterations {
            // 构造 Prompt:包含目标、已执行步骤、可用工具
            let prompt = self.build_prompt(&context);

            // 调用 LLM 获取下一步行动
            let action = self.llm_client
                .get_next_action(&prompt, &self.registry.tool_descriptions())
                .await?;

            match action.action_type {
                ActionType::CallTool => {
                    let tool_name = &action.tool_name;
                    let tool_input = &action.tool_input;

                    // 执行工具
                    let tool = self.registry.get(tool_name)
                        .ok_or_else(|| anyhow::anyhow!("工具未注册: {}", tool_name))?;

                    let result = tool.execute(tool_input.clone()).await;

                    // 记录执行步骤
                    context.executed_steps.push(ExecutedStep {
                        tool_name: tool_name.clone(),
                        input: tool_input.clone(),
                        output: result.clone(),
                        timestamp: chrono::Utc::now().to_rfc3339(),
                    });

                    // 如果工具执行成功,保存中间结果
                    if result.success {
                        context.intermediate_results.insert(
                            format!("step_{}", iteration),
                            result.output.clone(),
                        );
                    }
                }

                ActionType::Finish => {
                    // Agent 判断任务已完成
                    return Ok(action.final_output.unwrap_or(Value::Null));
                }

                ActionType::Error => {
                    // Agent 遇到无法处理的情况
                    anyhow::bail!(
                        "Agent 报告错误: {}",
                        action.error_message.unwrap_or_default()
                    );
                }
            }
        }

        anyhow::bail!("Agent 超过最大迭代次数 ({}),任务未完成", self.max_iterations)
    }

    fn build_prompt(&self, context: &AgentContext) -> String {
        format!(
            "目标: {}\n\n已执行步骤:\n{}\n\n可用工具:\n{}\n\n\
             请决定下一步行动:调用工具或报告完成。",
            context.goal,
            serde_json::to_string_pretty(&context.executed_steps).unwrap_or_default(),
            serde_json::to_string_pretty(&self.registry.tool_descriptions()).unwrap_or_default(),
        )
    }
}

3.3 具体工具实现示例:Cargo Clippy 工具

pub struct CargoClippyTool;

#[async_trait::async_trait]
impl Tool for CargoClippyTool {
    fn schema(&self) -> ToolSchema {
        ToolSchema {
            name: "cargo_clippy".to_string(),
            description: "运行 cargo clippy 检查代码质量,返回警告和错误列表".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "project_path": {
                        "type": "string",
                        "description": "Cargo 项目路径"
                    },
                    "fix": {
                        "type": "boolean",
                        "description": "是否自动修复可修复的警告"
                    }
                },
                "required": ["project_path"]
            }),
            output_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "warnings": { "type": "array", "items": { "type": "object" } },
                    "errors": { "type": "array", "items": { "type": "object" } },
                    "warning_count": { "type": "integer" },
                    "error_count": { "type": "integer" }
                }
            }),
        }
    }

    async fn execute(&self, input: Value) -> ToolResult {
        let start = std::time::Instant::now();
        let project_path = input["project_path"].as_str().unwrap_or(".");
        let fix = input["fix"].as_bool().unwrap_or(false);

        let mut cmd = tokio::process::Command::new("cargo");
        cmd.arg("clippy")
            .arg("--message-format=json")
            .current_dir(project_path);

        if fix {
            cmd.arg("--fix").arg("--allow-dirty");
        }

        match cmd.output().await {
            Ok(output) => {
                let stdout = String::from_utf8_lossy(&output.stdout);
                let (warnings, errors) = parse_clippy_output(&stdout);

                ToolResult {
                    success: errors.is_empty(),
                    output: serde_json::json!({
                        "warnings": warnings,
                        "errors": errors,
                        "warning_count": warnings.len(),
                        "error_count": errors.len(),
                    }),
                    error: if errors.is_empty() { None } else {
                        Some(format!("发现 {} 个错误", errors.len()))
                    },
                    execution_time_ms: start.elapsed().as_millis() as u64,
                }
            }
            Err(e) => ToolResult {
                success: false,
                output: Value::Null,
                error: Some(format!("执行 cargo clippy 失败: {}", e)),
                execution_time_ms: start.elapsed().as_millis() as u64,
            },
        }
    }
}

fn parse_clippy_output(raw: &str) -> (Vec<Value>, Vec<Value>) {
    let mut warnings = Vec::new();
    let mut errors = Vec::new();

    for line in raw.lines() {
        if let Ok(msg) = serde_json::from_str::<Value>(line) {
            let level = msg["level"].as_str().unwrap_or("");
            match level {
                "warning" => warnings.push(msg),
                "error" => errors.push(msg),
                _ => {}
            }
        }
    }

    (warnings, errors)
}

四、Agent工具链的局限性与工程权衡

LLM 推理的不可靠性:大模型可能选择错误的工具、构造无效的输入参数、或在任务未完成时提前报告完成。每次工具调用的 LLM 推理成本约 500-2000 tokens,10 步任务的推理成本约 5000-20000 tokens。对于确定性高的任务,硬编码的脚本编排比 Agent 更可靠且成本更低。

工具输出的解析鲁棒性:工具的输出格式可能因版本升级、环境差异而变化。Cargo Clippy 的 JSON 输出格式在不同版本间有细微差异,解析器需要容忍这些变化。建议在工具层做严格的 Schema 校验,而非在 Agent 层做。

迭代深度与成本控制:Agent 的最大迭代次数是安全阀,但 10 次迭代可能不足以完成复杂任务,也可能在简单任务上浪费 LLM 调用。生产环境需要根据任务复杂度动态调整迭代上限,并设置 token 预算。

错误恢复的策略选择:工具执行失败时,Agent 可以重试、换工具、或调整参数。但 LLM 的错误恢复策略不可预测——可能陷入"重试→失败→重试"的死循环。建议在 Agent 循环中加入退避机制:同一工具连续失败 3 次后强制跳过。

五、总结

AI 驱动的智能 Agent 工具链将"手动编排多工具"升级为"描述目标自动执行"的模式。核心架构是"工具注册 + Agent 推理循环 + 结构化输入输出",Agent 通过 LLM 推理自动分解任务、选择工具、处理异常。但 Agent 不是万能的——LLM 推理不可靠、工具输出解析需要鲁棒性、迭代深度需要成本控制、错误恢复可能陷入死循环。落地建议:确定性任务用脚本编排,只有需要动态决策的任务才用 Agent;工具层做严格的 Schema 校验;设置最大迭代次数和 token 预算;同一工具连续失败 3 次后强制跳过;每次 Agent 执行记录完整日志,便于回溯和调优。

Agent驱动的RPA——实在Agent(智能体):自动化时代的新引擎 它不仅是处理工具,更是拥有独立思考和认知功能的智能体,能深入思考、逻辑推断,甚至自我反思,展现超越传统技术的智能。在实际应用中,AI Agent与RPA的结合为企业实现业务智能化和自动化提供了强大的支持,实在智能的TARS-RPA-Agent已成功应用于多个行业场景,实现了从单纯的人工操作向智能化自动化的转变。此外,实在Agent智能体还能将业务用户的指令转化为自动化流程执行,用户只需简单指令,它便能自主拆解任务,成为“生成式,懂业务的智能数字员工”,减轻工作负担,提升工作效率和准确性。 阅读详情

相关推荐

Agent Orchestration:为什么推理正在变成“连接问题”?

你能感觉到它“智能”,但一旦让它执行一个 10 步以上的流程,它就像掉线一样失去协调能力。当上下文滚雪球式变大,模型必须频繁在 10 万 token 的语境里跳来跳去,就像一个人不断翻聊天记录找信息,自然会变慢、变乱。如果你也在构建智能体、数字员工或多模型工作流,欢迎留言交流你的系统设计难题,也欢迎告诉我你希望下一篇写些什么。擅长“编排”,不擅长“持久化”。当连接被重建,智能才能真正从“点”变成“面”,从“演示级”变成“生产级”。如果你把 step1 换成调用大模型,就能得到一个真实的“智能体节点”。

aifs2025的博客 905

一文讲清:LLM 如何驱动 AI 智能体(AI Agent)?

随着大语言模型(LLM)的成熟,AI 智能体(AI Agent)正在从简单的自动化脚本,演变为能够理解目标、拆解任务并自主决策的智能系统。本文围绕“LLM 如何驱使智能体”这一核心问题,用通俗语言讲清 LLM 在智能体中的关键作用,包括任务理解、智能体工作流规划、工具调用与执行决策等,并结合真实应用场景,帮助读者理解为什么没有 LLM,就没有真正可用的 AI 智能体。

xy040115的博客 1858

基于视觉驱动的AI智能体网页自动化:agent-browser项目实战解析

在自动化测试、数据抓取和RPA流程中,传统DOM驱动的脚本(如Selenium)依赖脆弱的元素选择器,难以应对动态网页和复杂视觉渲染。视觉驱动(Vision-Driven)的智能体技术应运而生,它结合了大型语言模型(LLM)的视觉理解与浏览器自动化能力,通过“观察-思考-行动”的循环,让AI能像真人一样“看懂”网页截图并执行操作。这种架构解决了传统RPA灵活性差、爬虫难以处理动态内容的痛点,尤其适用于电商比价、复杂表单填写和跨系统数据录入等场景。本文以agent-browser项目为例,深入探讨了如何利用G

weixin_30460489的博客 930

AI Agent:您的智能自动化新伙伴

AI Agent是一种能够感知其环境、进行自主决策并采取行动以实现特定目标的软件程序。您可以将其想象成一个拥有“大脑”(通常由大型语言模型驱动)、能够使用“工具”(如API、数据库)并拥有“记忆”(短期和长期)的智能体。它们被设计为能够自主地为用户完成复杂的、多步骤的任务。AI Agent可以在没有人为干预的情况下独立运作和做决策。它们致力于实现用户设定的具体目标。AI Agent能够通过传感器或数字输入感知其所处的环境,并与外部系统进行交互。

weixin_40264313的博客 1013

从代码生成到任务执行:Pi Agent如何重塑AI驱动的开发工作流

在AI辅助编程领域,代码生成工具如Claude Code和Codex通过智能补全和片段生成,显著提升了开发者的编码效率。其核心原理是基于大规模代码语料训练,实现上下文感知的代码建议。这类工具的技术价值在于降低重复性编码负担,让开发者更专注于架构设计和逻辑实现。然而,随着开发流程复杂度的增加,单纯的代码生成已无法满足项目初始化、多步骤调试、自动化测试等复合场景的需求。此时,任务驱动的自主智能体(Agent)技术应运而生,它能够理解高级别任务描述,自主规划并调用命令行、版本控制、文件系统等工具链执行完整操作。P

weixin_30443731的博客 491

AI人工智能代理工作流 AI Agent WorkFlow:在自动化检查中的应用

AI人工智能代理工作流 AI Agent WorkFlow:在自动化检查中的应用 1. 背景介绍 1.1 人工智能发展现状 随着人工智能技术的快速发展,AI已经在各行各业得到广泛应用。从智能

AI天才研究院 1725

收藏必备!从零构建金融智能Agent系统:大模型驱动的任务分解与并行执行指南

文章详细介绍了金融领域智能Agent系统的构建方法,包括意图识别、任务分解、依赖管理和并行执行等核心组件。通过大模型、意图识别和工具使用的协同配合,实现复杂金融问题的自动化处理,并提供高效、准确的数据分析和决策支持。文章还提供了具体的代码实现和业务场景案例,帮助开发者快速构建金融智能Agent系统。1. 理解层(Understanding Layer)2. 推理层(Reasoning Layer)3. 生成层(Generation Layer) 2.2 Agent架构设计模式 2.2.1 多Agent协作架

AI大模型的博客 789

Halcon棋盘格畸变矫正

通常我们使用的相机都是带有一定的畸变的,只是畸变的大小不同。对于我们常见的测量项目来说,对测量精度的要求很高,通常从相机镜头上进行优化,但是即使镜头优化或者成本原因,造成图像仍有一定的畸变时,我们就可是使用棋盘格标定板,进行畸变矫正。

m0_51559565的博客 3398

【深度收藏】从单一智能体到多智能体协作:AI Agent与Agentic AI全解析

Agentic AI 是一种新兴的智能架构,其利用多个专业化 Agent 协作来实现复杂且高层次的目标。这些系统由模块化的 Agent 组成,每个 Agent 负责更广泛目标的一个独特子组件,并通过集中式协调器或去中心化协议进行协调。这种结构标志着从单一 Agent 架构中通常观察到的原子化、响应式行为的概念转变,转向为一种以动态 Agent 间协作为特征的系统级智能形式。

优快云_430422的博客 1373

DSP28335与Vofa+上位机通信实战:SCIb配置避坑指南(附完整代码)

本文提供DSP28335与Vofa+上位机通信的实战指南,重点解析SCIb模块配置的常见问题与解决方案。针对研旭开发板的硬件连接、波特率精确计算、FIFO高效使用以及FireWater协议封装进行了详细说明,并附有完整代码,帮助开发者快速实现实时数据可视化与波形分析,提升调试效率。

weixin_29172963的博客 152

实战|验证码突破思路

漏洞成因:由于逻辑设计缺陷,可绕过验证,比如直接删除COOKIE或验证码参数可绕过、当验证不通过清空session时,验证码参数值为空时绕过等。测试方法:抓包,删除验证码字段,查看是否可以成功发送抓包,正常流程下,记录验证码后的数据包,替换目标包中内容,直接发送,查看是否可以直接绕过验证码案例:Step1.输入正确账户信息和错误验证码,登录时抓包Step2.删除COOKIEStep3.客户端登陆成功。

weixin_46239998的博客 8106

RWKV-7 (1.5B World)轻量级Agent框架:基于Tool Calling的多步任务执行

本文介绍了如何在星图GPU平台上自动化部署RWKV-7 (1.5B World)轻量级Agent框架,实现基于Tool Calling的多步任务执行功能。该框架特别适合智能客服场景,能够自动分解复杂查询、调用工具并整合结果,显著提升服务效率与响应速度。

weixin_35995661的博客 482

Linux | Ubuntu18.04安装RTX 4060显卡驱动完整教程

本节详细介绍了如何在ubuntu18系统安装4060显卡的驱动。

九七的博客 5161

AI Agent 基于大模型的人工智能代理

大语言模型的浪潮推动了 AI Agent 相关研究快速发展,AI Agent 是当前通往 AGI 的主要探索路线。大模型庞大的训练数据集中包含了大量人类行为数据,为模拟类 人的交互打下了坚实基础;另一方面,随着模型规模不断增大,大模型涌现出了上 下文学习能力、推理能力、思维链等类似人类思考方式的多种能力。将大模型作为 AI Agent 的核心大脑,就可以实现以往难以实现的将复杂问题拆解成可实现的子任 务、类人的自然语言交互等能力。

m0_59164304的博客 1859

使用蒙特卡洛模拟方法在MATLAB中估算居里温度: 一个详细而通俗的指南

居里温度是磁性材料失去磁性的温度。但是,计算机模拟为我们提供了一个在理论和实验之间的桥梁,使我们能够在不进行实际测量的情况下估计这一重要参数。在下一部分,我们将详细介绍蒙特卡洛迭代的核心代码,以及如何使用它来模拟磁性材料中原子的行为。在估算居里温度的上下文中,我们将使用蒙特卡洛方法来模拟磁性材料中的原子或分子的行为。通过使用蒙特卡洛方法,我们可以在MATLAB中估算居里温度,从而为理论研究和实验设计提供有价值的信息。:我们使用的是一个有限的尺寸的网格模型,这可能导致一些大小效应,特别是在接近居里温度时。

qq_38334677的博客 979

Xilinx差分原语-IBUFGDS与OBUFGDS FPGA

它将差分信号转换为单端信号,并将其输入到FPGA的逻辑片上。它将单端信号转换为差分信号,并将其输出到FPGA的引脚。在FPGA设计中,差分信号是一种常见的信号传输方式,用于提高抗噪性和抑制共模噪声。Xilinx是一家知名的FPGA供应商,提供了许多差分原语,其中包括IBUFGDS和OBUFGDS。通过使用Xilinx的差分原语,如IBUFGDS和OBUFGDS,可以实现差分信号的输入和输出。这些差分原语提供了方便且可靠的接口,使得在FPGA设计中处理差分信号变得更加简单和高效。是差分输入信号的端口,

git_database727的博客 2096

【人工智能】AI Agent 工作流及产品介绍

AI Agent 的工作流程是一个 “感知→思考→行动→学习” 的智能闭环。目前该领域处于爆发期,既有像 LangChain / AutoGen 这样的强大开发框架,也有 AutoGPT / BabyAGI 这样的概念先驱,更有 GPTs 这样的易用平台和 Devin 这样的专业领域标杆。优秀的 Agent 产品正在从实验走向实用,在客服、编程、数据分析、个人助理等多个领域展现出巨大潜力。衡量 Agent 好坏的核心在于其自主完成任务、有效使用工具、动态规划调整和持续学习进化的能力。

2401_85116933的博客 1290

标准测试测试数据STDF学习笔记

本文介绍了STDF(Standard Test Data Format)文件的结构与解析方法。首先详细说明了STDF记录的组成,包括记录头类型(REC_TYP和REC_SUB)、数据类型定义、时间日期格式以及无效数据标识。重点分析了25种主要记录类型的功能、数据内容和出现位置,如FAR、MIR、MRR等关键记录。然后介绍了基于pystdf开源工具的解析方法,包括自带脚本的使用和自编程解析流程,通过事件驱动机制处理数据流。特别指出测试数据是按照PIR→PTR/MPR/FTR→PRR的循环模式组织。文章为ATE

歌颂苦难的行为是无耻的; 1516

揭秘AI Agent开发全流程:新手如何快速上手并实现自动化任务

auto-generated

ByteGlow的博客 900

YOLOv11安卓端部署终极指南:从训练到NCNN移植,30分钟搞定手机实时检测!

本文详细介绍了YOLOv11模型在安卓设备上的NCNN部署全流程。主要内容包括:1) 环境配置要求(Python3.8+、PyTorch、NCNN框架等);2) COCO2017数据集准备与配置;3) 模型训练建议(使用RTX3090,50-100个epoch);4) 模型导出转换步骤(ONNX格式转换、NCNN优化);5) 安卓端实现的关键优化(快速sigmoid实现、纯C++NMS等)。项目在安卓CPU模式下可实现20FPS的稳定检测,并提供了激活函数选择、模型量化等性能调优建议。通过参考多个开源项目,

FJN110的博客 1727

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

AI Agent 在自动化测试中的落地实践:从“脚本执行”到“智能测试工程师”

大模型技术正在推动AIAgent在自动化测试领域的应用升级,使从固定脚本执行转向具备理解、规划和自适应能力的智能测试系统。文章分析了AIAgent相比传统测试工具的优势:通过自然语言生成测试用例、动态适应UI变化、智能分析失败原因等。典型架构包含任务输入、大模型推理、工具执行等五层模块,可有效解决维护成本高、覆盖不足等痛点。当前AIAgent仍面临稳定性、业务理解深度等挑战,建议采用渐进式落地策略,与现有测试框架结合形成人机协同体系。未来测试团队的核心将转向构建智能测试体系,实现AI执行与人工决策的优势互补

2601_96268389的博客 1583

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

探讨 ‘RPA + Agent’:利用 LangChain 驱动网页自动化(Playwright)执行复杂的跨站任务

我们将之前编写的Playwright异步函数封装为LangChain Agent可用的同步Tools。由于LangChain Agent通常是同步执行的,我们需要一个机制来运行异步Playwright函数。一个常见的方法是使用。

weixin_41455464的博客 1392

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

AI Agent:基于大模型的人工智能代理

AI Agents竞争就是未来很重要的方向。我们大部分人都优势应该不是大模型,但可以是AI Agents,也就是在配套技术上面有很多的优势,才能使得他做任何一个业务的完成度极大地提升了。

瓦罗兰特顶级C位的博客 938

AI Agent可观测性:破解多步推理黑盒

本文探讨AI Agent在多步推理任务中面临的“黑盒”挑战,系统介绍可观测性(Observability)的核心概念、技术栈与实践方法,旨在为开发者提供一套破解Agent内部决策过程、提升系统可靠性与调试效率的工程指南。定义:指对Agent内部状态、决策逻辑、工具使用、与环境的交互过程进行系统性的记录、追踪、度量和可视化的能力。三大支柱(借鉴传统可观测性)Logging(日志):记录Agent每一步的原始输入、输出、内部思考(Chain-of-Thought)、工具调用及其参数与结果。

zhanghaofaowhrql的博客 353

智联工坊实战:多工具协同Agent,让AI像人类一样规划与执行复杂任务

单工具Agent只能“回答”,多工具协同Agent才能“解决”。本文以智联工坊设备故障闭环处理为场景,从零搭建一个能完成“查手册→查排班→查备件→生成工单”完整任务链的多工具协同Agent。深入拆解任务分解、链式编排、中间结果传递三大核心能力,并记录调试过程中遇到的“嵌套JSON”与“Markdown代码块”两大实战坑点。全源码将开源,请关注更新情况。

20多年IT老兵|制造业数据架构与AI落地|全流程亲手实践|源码同步开源 1176
上一篇: WASM 组件模型与 AI 推理插件的动态加载:从模块隔离到能力组合
下一篇: WebAssembly组件模型:从接口定义到跨语言调用的互操作架构
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论 18
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值