AI 终端助手:基于 Rust 的命令行智能 Agent 架构设计

DeepSeek-TUI:终端原生AI编程助手,Rust驱动的CLI Agent实战指南 CLI Agent 是指运行在命令行环境、具备自主推理与工具调用能力的AI编程代理,其核心原理基于ReAct(推理+行动)循环,通过本地化决策引擎实现低延迟、高确定性的代码理解与生成。相比Web IDE插件或远程API封装工具,CLI Agent的技术价值在于零GUI干扰、亚秒级响应、内存可控及深度集成开发者工作流。典型应用场景包括Rust项目错误诊断、自动化测试生成、文档补全与跨工具链协同(如Cargo/rust-analyzer/Playwright)。本文以DeepSeek-TUI为范例,详解其Rus 阅读详情

AI 终端助手:基于 Rust 的命令行智能 Agent 架构设计

cover

一、终端操作的"记忆负担":为什么开发者总是反复查命令

开发者的日常工作中,大量时间消耗在"查命令"上——Git 的高级操作、Docker 的网络配置、Kubernetes 的资源定义、awk/sed 的复杂用法。这些命令的语法并不难,但数量太多,人脑无法全部记住。传统解决方案是搜索引擎 + Stack Overflow,但搜索-阅读-试错的过程平均需要 3-5 分钟。

AI 终端助手的核心目标是"自然语言到命令的即时转换"——用户用自然语言描述意图,助手生成对应的终端命令并解释参数含义。但"生成命令"只是表面需求,更深层的挑战是"上下文感知"——助手需要理解当前目录结构、Git 状态、运行中的容器、最近的命令历史,才能生成真正可用的命令,而非泛泛的建议。

二、AI 终端助手的架构:意图解析、上下文感知与安全执行

flowchart TB
    A[用户输入: 自然语言] --> B[意图解析层]
    B --> B1[命令意图: 执行什么操作]
    B --> B2[目标意图: 操作什么对象]

    C[上下文采集] --> C1[当前目录: ls/git status]
    C --> C2[Git 状态: branch/diff/stash]
    C --> C3[运行环境: docker ps/kubectl get]
    C --> C4[命令历史: ~/.bash_history]

    B1 & B2 & C1 & C2 & C3 & C4 --> D[命令生成层]
    D --> D1[模板匹配: 高频命令直接匹配]
    D --> D2[LLM 生成: 复杂命令调用模型]

    D1 & D2 --> E[安全审查层]
    E --> E1[危险命令检测: rm/drop/force]
    E --> E2[参数合理性校验]
    E --> E3[用户确认: 高风险命令需确认]

    E1 & E2 & E3 --> F[执行与反馈]
    F --> F1[命令执行]
    F --> F2[输出解析与解释]
    F --> F3[错误诊断与修复建议]

三、AI 终端助手的 Rust 代码实现

3.1 上下文采集器

/**
 * 上下文采集器
 * 收集终端环境的当前状态,为命令生成提供上下文信息
 */
use std::process::Command;
use std::path::PathBuf;

#[derive(Debug, Clone)]
pub struct TerminalContext {
    pub current_dir: PathBuf,
    pub git_branch: Option<String>,
    pub git_status: Option<String>,
    pub running_containers: Vec<String>,
    pub recent_commands: Vec<String>,
    pub os_type: String,
}

impl TerminalContext {
    /// 采集当前终端上下文
    pub fn collect() -> Self {
        let current_dir = std::env::current_dir()
            .unwrap_or_else(|_| PathBuf::from("/"));

        let git_branch = Self::run_command(
            "git", &["rev-parse", "--abbrev-ref", "HEAD"]);

        let git_status = Self::run_command(
            "git", &["status", "--short"]);

        let running_containers = Self::run_command(
            "docker", &["ps", "--format", "{{.Names}}"])
            .map(|s| s.lines()
                .map(String::from)
                .collect())
            .unwrap_or_default();

        let recent_commands = Self::read_recent_history();

        let os_type = std::env::consts::OS.to_string();

        TerminalContext {
            current_dir,
            git_branch,
            git_status,
            running_containers,
            recent_commands,
            os_type,
        }
    }

    /// 执行命令并获取输出
    fn run_command(
        program: &str,
        args: &[&str],
    ) -> Option<String> {
        Command::new(program)
            .args(args)
            .output()
            .ok()
            .and_then(|o| {
                if o.status.success() {
                    Some(String::from_utf8_lossy(&o.stdout)
                        .trim()
                        .to_string())
                } else {
                    None
                }
            })
    }

    /// 读取最近的命令历史
    fn read_recent_history() -> Vec<String> {
        let home = std::env::var("HOME").unwrap_or_default();
        let history_path = PathBuf::from(home)
            .join(".bash_history");

        std::fs::read_to_string(&history_path)
            .unwrap_or_default()
            .lines()
            .rev()
            .take(20)
            .map(String::from)
            .collect()
    }

    /// 将上下文格式化为 LLM Prompt
    pub fn to_prompt_context(&self) -> String {
        let mut ctx = String::new();

        ctx.push_str(&format!(
            "当前目录: {}\n", self.current_dir.display()));
        ctx.push_str(&format!("操作系统: {}\n", self.os_type));

        if let Some(ref branch) = self.git_branch {
            ctx.push_str(&format!("Git 分支: {}\n", branch));
        }

        if let Some(ref status) = self.git_status {
            if !status.is_empty() {
                ctx.push_str(&format!("Git 状态:\n{}\n", status));
            }
        }

        if !self.running_containers.is_empty() {
            ctx.push_str(&format!(
                "运行中的容器: {}\n",
                self.running_containers.join(", ")));
        }

        if !self.recent_commands.is_empty() {
            ctx.push_str("最近命令:\n");
            for cmd in self.recent_commands.iter().take(5) {
                ctx.push_str(&format!("  {}\n", cmd));
            }
        }

        ctx
    }
}

3.2 命令生成与安全审查

/**
 * 命令生成器
 * 根据用户意图和上下文生成终端命令
 */
use regex::Regex;

#[derive(Debug)]
pub struct GeneratedCommand {
    pub command: String,
    pub explanation: String,
    pub risk_level: RiskLevel,
}

#[derive(Debug, PartialEq)]
pub enum RiskLevel {
    Safe,       // 只读操作
    Moderate,   // 写入操作但有回退路径
    Dangerous,  // 不可逆操作
}

pub struct CommandGenerator {
    /// 危险命令模式列表
    dangerous_patterns: Vec<Regex>,
}

impl CommandGenerator {
    pub fn new() -> Self {
        let dangerous_patterns = vec![
            Regex::new(r"rm\s+-rf\s+/").unwrap(),
            Regex::new(r"git\s+push\s+--force").unwrap(),
            Regex::new(r"DROP\s+TABLE").unwrap(),
            Regex::new(r"DELETE\s+FROM\s+\w+\s*;").unwrap(),
            Regex::new(r"kubectl\s+delete\s+namespace").unwrap(),
            Regex::new(r"docker\s+system\s+prune").unwrap(),
        ];

        CommandGenerator { dangerous_patterns }
    }

    /// 生成命令
    pub fn generate(
        &self,
        user_input: &str,
        context: &TerminalContext,
    ) -> GeneratedCommand {
        // 1. 尝试模板匹配(高频命令无需调用 LLM)
        if let Some(cmd) = self.template_match(user_input, context) {
            return cmd;
        }

        // 2. 调用 LLM 生成命令
        let prompt = self.build_prompt(user_input, context);
        let response = self.call_llm(&prompt);

        self.parse_llm_response(&response)
    }

    /// 高频命令模板匹配
    fn template_match(
        &self,
        input: &str,
        context: &TerminalContext,
    ) -> Option<GeneratedCommand> {
        let input_lower = input.to_lowercase();

        // Git 操作模板
        if input_lower.contains("撤销") && input_lower.contains("提交") {
            return Some(GeneratedCommand {
                command: "git reset --soft HEAD~1".to_string(),
                explanation: "撤销最近一次提交,保留修改在暂存区"
                    .to_string(),
                risk_level: RiskLevel::Moderate,
            });
        }

        if input_lower.contains("查看") && input_lower.contains("日志") {
            return Some(GeneratedCommand {
                command: "git log --oneline -20".to_string(),
                explanation: "查看最近 20 条提交记录".to_string(),
                risk_level: RiskLevel::Safe,
            });
        }

        // Docker 操作模板
        if input_lower.contains("进入") && input_lower.contains("容器") {
            if let Some(name) = context.running_containers.first() {
                return Some(GeneratedCommand {
                    command: format!("docker exec -it {} /bin/sh", name),
                    explanation: format!("进入容器 {}", name),
                    risk_level: RiskLevel::Safe,
                });
            }
        }

        None
    }

    /// 安全审查:检测危险命令
    pub fn safety_check(&self, command: &str) -> RiskLevel {
        for pattern in &self.dangerous_patterns {
            if pattern.is_match(command) {
                return RiskLevel::Dangerous;
            }
        }

        // 检查是否包含写入操作
        let write_patterns = [
            "rm ", "delete", "drop", "truncate",
            "push", "deploy", "apply",
        ];
        for pat in &write_patterns {
            if command.to_lowercase().contains(pat) {
                return RiskLevel::Moderate;
            }
        }

        RiskLevel::Safe
    }

    /// 构建 LLM Prompt
    fn build_prompt(
        &self,
        user_input: &str,
        context: &TerminalContext,
    ) -> String {
        format!(
            "你是一个终端命令助手。根据用户意图和当前上下文,\
             生成对应的终端命令。\n\n\
             ## 当前上下文\n{}\n\
             ## 用户意图\n{}\n\n\
             ## 输出格式\n\
             命令: <生成的命令>\n\
             解释: <命令参数说明>",
            context.to_prompt_context(),
            user_input,
        )
    }

    fn call_llm(&self, prompt: &str) -> String {
        // 调用 LLM API(省略实现)
        String::new()
    }

    fn parse_llm_response(&self, response: &str) -> GeneratedCommand {
        // 解析 LLM 响应(简化实现)
        let command = response.lines()
            .find(|l| l.starts_with("命令:"))
            .map(|l| l.trim_start_matches("命令:").trim().to_string())
            .unwrap_or_default();

        let explanation = response.lines()
            .find(|l| l.starts_with("解释:"))
            .map(|l| l.trim_start_matches("解释:").trim().to_string())
            .unwrap_or_default();

        let risk_level = self.safety_check(&command);

        GeneratedCommand {
            command,
            explanation,
            risk_level,
        }
    }
}

四、AI 终端助手的安全风险与上下文局限

命令注入风险:LLM 生成的命令可能包含恶意代码——如果用户输入被精心构造,LLM 可能生成包含命令替换($(...))或管道链(| rm -rf /)的危险命令。安全审查层必须对所有生成的命令做模式匹配检查,拒绝包含已知危险模式的命令。

上下文采集的性能开销:每次用户输入都采集上下文(执行 git status、docker ps 等命令)会增加 200-500ms 的延迟。建议对上下文做缓存——每 30 秒刷新一次,而非每次输入都重新采集。

LLM 幻觉的命令:LLM 可能生成语法错误或不存在的命令参数。例如 git commit -m "message" --amend 看似合理但实际语义矛盾。建议在执行前对生成的命令做语法校验(--dry-run 或 --help 检查),或使用命令补全库验证参数合法性。

隐私与敏感信息:上下文采集可能包含敏感信息(如数据库连接字符串、API Key)。将这些信息发送给 LLM 存在泄露风险。建议在上下文发送前做脱敏处理——替换所有匹配密钥模式的字符串为 [REDACTED]。

五、总结

AI 终端助手的核心架构是"意图解析 + 上下文感知 + 安全审查"三层模型。高频命令使用模板匹配(低延迟、确定性),复杂命令调用 LLM(高延迟、灵活性)。安全审查层是必选项——所有生成的命令必须经过危险模式检测,高风险命令需用户确认。上下文采集建议做缓存(30 秒刷新),发送给 LLM 前做脱敏处理。落地时从高频 Git/Docker 命令模板开始,验证模板匹配的覆盖率后再引入 LLM 生成。

补充落地建议:围绕“AI 终端助手:基于 Rust 的命令行智能 Agent 架构设计”继续推进时,应把验收标准写成可执行清单。性能类方案要给出基准数据,架构类方案要给出故障隔离方式,AI 类方案要给出质量评估和人工兜底策略。每一次迭代都应回答三个问题:收益是否可量化,失败是否可回滚,维护成本是否被团队接受。

如果短期资源有限,可以先保留最关键的观测指标,包括处理耗时、失败率、资源占用和人工介入次数。等这些指标稳定后,再扩展自动化能力。这样的节奏更慢,但风险更低,也更符合生产级技术文章强调的工程可验证性。

DeepSeek-TUI:基于MCP协议的Rust终端编程Agent MCP(Model Context Protocol)是一种面向大模型工程化应用的上下文通信协议,旨在让AI理解代码在项目中的位置、依赖与变更状态。其核心原理是将文件路径、Git状态、终端历史等元信息结构化注入模型请求,从而突破传统CLI工具缺乏上下文感知的瓶颈。该协议显著提升模型在真实开发场景中的准确性与可执行性,尤其适用于无GUI服务器、CI/CD流水线及嵌入式开发等受限环境。结合Rust构建的高性能运行时与DeepSeek-v4-pro等专业模型深度适配,MCP驱动的终端Agent已逐步成为开发者在命 阅读详情

相关推荐

Rust实现的本地化终端AI编程助手:DeepSeek-V4 CLI深度解析

终端AI编程助手是近年来开发者工具演进的关键方向,其核心在于将大语言模型能力无缝嵌入命令行工作流,实现低延迟、高隐私、强可控的代码协同。技术原理上依赖轻量级量化模型(如GGUF格式)与原生系统I/O的深度耦合,绕过HTTP中转和GUI层抽象,以Rust等系统语言保障内存安全与实时响应。相比云端Copilot类工具,它在离线环境、带宽受限场景及政企合规需求下展现出独特技术价值。典型应用场景包括SSH远程调试、tmux/nvim终端内即时代码补全、Git上下文感知的命令生成等。本文聚焦于DeepSeek-V4-

weixin_34034670的博客 387

用 Rust 构建 AI 命令行助手——从 API 调用到智能 Agent 的工程实践

AI 驱动的命令行工具将大语言模型的理解能力与系统级操作结合,让用户用自然语言完成原本需要记忆复杂语法的操作。核心架构包含意图解析、命令生成、安全校验和执行反馈四个层次,每一层都需要针对性的工程处理。Rust 在这个场景中提供了关键的工程保障:异步运行时处理 LLM API 的网络延迟,类型系统在编译期捕获接口错误,零成本抽象保证工具本身的启动速度。先实现单轮对话的最小可用版本,验证 LLM 到命令的转换链路加入白名单校验和用户确认机制,确保安全性引入本地命令缓存,对高频操作跳过 LLM 调用。

no1coder的博客 5531

Herdr:AI编码时代的多Agent终端管理工具实战指南

终端多路复用器是现代开发环境中的核心工具,通过进程管理和会话持久化技术,实现在单一终端界面内并行运行多个任务。在AI编码时代,开发者经常需要同时协调多个AI助手(如Claude Code、Codex等)完成复杂任务,传统终端工具难以有效管理这些智能体的状态和输出。Herdr作为专门为AI编码场景设计的终端调度中心,采用Rust语言开发,提供颜色编码状态显示和Socket API编排能力,解决了多Agent并行开发中的窗口切换和状态监控难题。该工具支持会话持久化和批量任务编排,特别适合远程服务器部署和自动化工

注重长远 天天积累 cqujsjcyj 527

AI 命令行工具开发:用 Rust 构建智能 Agent,从 API 调用到工具链编排

// 工具定义:描述一个可供 Agent 调用的工具/// 工具执行结果/// 工具注册表:管理所有可用工具// 注册文件搜索工具description: "在指定目录中搜索包含关键词的文件".to_string(),({"directory": { "type": "string", "description": "搜索目录" },"keyword": { "type": "string", "description": "搜索关键词" }},}),});

no1coder的博客 1396

深入解析poi-tl自定义表格渲染插件中的多级子循环实现

本文深入解析了poi-tl自定义表格渲染插件中的多级子循环实现,详细介绍了其在处理复杂业务数据时的核心价值、实现原理及实战技巧。通过多级子循环机制,开发者可以高效地将层级数据结构渲染到Word表格中,显著提升代码简洁性和维护效率。文章还分享了性能优化和异常处理经验,帮助开发者更好地应用该插件。

weixin_33734785的博客 489

Sobel原理及计算过程详解

该算子包含两组3x3的矩阵,分别为横向及纵向,将之与图像作平面卷积,即可分别得出横向及纵向的亮度差分近似值。首先,我们需要构建一个Sobel算子,通常是一个 3x3 的矩阵。Sobel算子可以分别计算水平和垂直方向的梯度值,然后将两者合并得到总梯度值。索贝尔算子(Sobel operator)主要用作边缘检测,在技术上,它是一离散性差分算子,用来运算图像亮度函数的灰度近似值。所以,我们假设选择图像矩阵中的点A(1, 1),即第二行第二列的元素,对应的。接下来,我们将使用Sobel算子计算这个点的梯度值。

2301_76461741的博客 1万+

用 Rust 构建智能命令行工具:从 Agent 调用到流式输出

AI 驱动的 CLI 工具将自然语言理解能力注入了传统命令行,核心架构由交互层、Agent 层和工具层构成。Agent 层的循环机制——发送消息、解析工具调用、执行工具、反馈结果——是整个系统的运转核心。生产级实现需要重点解决三个工程问题:流式响应的 SSE 解析与实时渲染、工具调用的结构化解析与容错、以及 Agent 循环的上下文管理与超时控制。

no1coder的博客 5382

关于爱思唯尔官方Latex模版参考文献不是按照引用顺序编号,乱序问题

接下来使用工具打开cas-model2-names.bst文件,全词匹配搜索。其他期刊的模版也是一样的操作,把规定序号的规则的。爱思唯尔给的Latex模版大概文件结构如此。发现是按照第一作者的姓氏的大写字母排序。命令行给注释掉,小写的sort可别注释。

weixin_42748439的博客 5116

用 Rust 构建 AI 命令行工具:从 ONNX Runtime 到智能 Agent 的实战路径

Rust 构建 AI 命令行工具的核心路径是:通过 ONNX Runtime 的ortcrate 加载模型进行推理,结合 trait-based 的工具抽象实现 Agent 调度。Rust 在部署体积、启动速度和内存控制方面相比 Python 有显著优势,但模型生态和开发效率是主要短板。适用场景集中在推理端部署和资源受限环境,不适合模型训练和快速实验阶段。项目初期需要验证 ONNX 模型转换的可行性,避免后期返工。

no1coder的博客 5282

Open3D 点云DBSCAN聚类算法

DBSCAN(Density-Based Spatial Clustering of Applications with Noise)是一种基于密度的聚类算法,能够识别任意形状的聚类,并处理噪声数据。

纵马踏花向自由 1835

高通Camx功能feature分析之八:高通NCS服务之架构和初始化

本文介绍了高通NCS(NONCameraSensor)服务的架构与初始化流程。NCS服务通过QMI接口访问非相机传感器,为CameraEIS、AEC等算法节点提供陀螺仪、加速度计等传感器数据支持。文章详细解析了NCS服务的分层架构,包括客户端、服务端、QSEE接口实现等组件,并重点分析了初始化过程中获取传感器列表、查询能力等关键步骤。通过camxsetting.xml中的enableNCSService开关控制服务启动,初始化过程涉及QSEE单例创建、传感器能力查询等核心操作。后续文章将继续深入讲解相关技术

931

用 Rust 打造 AI 命令行工具:从零构建智能 Agent 的工程实践

Rust 构建 AI 驱动的命令行工具,在编译产物分发、运行时安全、FFI 性能三个维度上具有显著优势。核心架构围绕输入解析、意图理解、任务编排和执行反馈四层展开,每一层都有明确的技术选型考量。安全是 AI Agent CLI 的首要约束——任何自主执行能力都必须与确认机制配合。本地推理与远程 API 的混合策略是平衡延迟与准确率的现实方案,但实现复杂度较高。对于刚接触 Rust 的开发者,建议从远程 API 调用模式入手,验证意图识别的准确率后再考虑引入本地模型。

no1coder的博客 1468

【ITS模型】基于MATLAB的ITS宽带短波信道模型的建模和仿真

1.软件版本 MATLAB2010b 2.本算法理论知识 对短波信道建模具有里程碑意义的是沃特森在1970年发表的一篇文章,文章中提出了一种静态模型,并在大气中进行了实验验证。 此静态模型可以描述为高斯散射增益抽头延迟线模型,即Watterson模型。 Watterson信道模型是经典的窄带短波信道模型,在这个模型中,信道衰落是瑞利幅度分布,而在每种传播模式中多普勒扩展的功率谱满足高斯分布。Watterson模型没有定义延时扩展的形状,认为各个多径传输模式中不存在延时扩展。其...

FPGA/MATLAB学习教程/源码/项目合作开发 2758

当命令行遇上AI:用Rust打造你的第一个智能Agent工具

用Rust构建AI Agent工具,核心不是"调API",而是工具编排、状态管理和安全边界的设计。Rust的类型系统和所有权模型,在编译期就能帮你挡住很多运行时错误。虽然学习曲线陡峭,但当你看到Agent稳定运行一整天不出内存泄漏时,会觉得这些付出是值得的。我还在继续完善这个项目,下一步计划加入插件系统和WASM运行时支持。如果你也在做类似的事情,欢迎交流。我们都是在摸索中前进,重要的是保持真诚,保持动手。

no1coder的博客 5194

UE5接入在线直播视频源,如hls(m3u8)格式

UE5接入在线直播视频源

专注GIS开发 9508

【100%通过率】2024华为OD机试真题E卷 C++语言 实现【流浪地球】

流浪地球计划在赤道上均匀部署了N个转向发动机,按位置顺序编号为0~N-1。 1) 初始状态下所有的发动机都是未启动状态; 2) 发动机起动的方式分为“手动启动”和“关联启动”两种方式; 3) 如果在时刻1一个发动机被启动,下一个时刻2与之相邻的两个发动机就会被“关联启动”; 4) 如果准备启动某个发动机时,它已经被启动了,则什么都不用做; 5) 发动机0与发动机N-1是相邻; 地球联合政府准备挑选某些发动机在某些时刻进行“手动启动”,当然最终所有的发动机都会被启动。 哪些发动机最晚被启动呢?

MISAYAONE的博客 4213

AI 驱动的命令行工具:用 Rust 构建智能 Agent 的工程实践

AI 驱动的命令行工具将自然语言理解能力与系统级操作能力结合,是 Agent 落地的高价值场景。Rust 的类型安全和异步能力使其成为构建此类工具的合适语言。先实现最小可用的流式对话 CLI,验证 API 调用链路和终端渲染逐步添加 Tool Call 支持,从安全的只读工具(文件搜索、代码查询)开始实现上下文持久化,支持跨会话的对话连续性引入意图分类层,精确命令走本地路径,模糊意图走 LLM 解析在工具执行层加入安全沙箱和确认机制,防止 Prompt Injection 导致的危险操作。

no1coder的博客 1039

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

智能命令行:用 Rust 构建 AI 驱动的 Agent 工具链

本文从 CLI 工具的智能化需求出发,深入剖析了 AI Agent 的推理-行动循环机制,并用 Rust 实现了一个可扩展的 Agent 运行时。Agent 的本质是"推理-行动"循环,而非单次 API 调用。每次工具结果都应注入上下文,让 LLM 基于最新状态决策。Rust 的 trait 系统天然适合工具注册与分发,让异步工具的实现保持一致接口。必须设置重试上限和超时保护,防止 Agent 陷入死循环或工具卡死。

no1coder的博客 5028

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

深度学习工具包 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 驱动的 CLI 命令行工具开发:基于 Rust 与 Clap 打造从零到一的智能 Agent 终端

自学 Rust 的过程虽然笨拙,但每解决一个编译报错,都是一次“啊哈时刻(Aha Moment)”。理解clap在编译期强类型解析参数的优势,掌握tokio异步运行时与 Rust 所有权的物理转移逻辑,我们就能从零构建出体积小巧、响应极速、安全无死角的企业级 AI CLI 工具。

no1coder的博客 5238

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

AI 驱动的 Rust 开发:构建命令行智能 Agent 的架构与实现

ReAct 模式的 Agent 架构将 LLM 的推理能力与系统工具的执行能力结合,实现了命令行工具的智能化。Rust 在构建这类系统时,类型系统和所有权模型为工具调用的安全性提供了编译期保障。Agent 的可靠性依赖于三个工程约束:迭代次数上限、执行超时控制、参数强制校验。工具注册表的设计将工具描述与执行逻辑分离,使得 LLM 可以通过描述选择工具,而调度器通过安全等级控制执行权限。Agent 模式适合交互式探索场景,在需要确定性的自动化场景中应谨慎使用。

no1coder的博客 1127

Rust AI 工具链:从命令行到 Agent,用 Rust 构建智能开发工具

Rust 在 AI 工具开发中的核心优势是零依赖分发、快速启动和内存安全。架构上,AI 工具分为用户交互、任务编排、AI 调用和工具执行四个层次。SSE 流式输出的增量解析是 AI 调用层的关键技术点。主要工程挑战包括 API 兼容性、流式重试、Token 计数和 Function Calling 的类型安全。Rust AI 工具的开发成本高于 Python,但在分发体验和运行稳定性上有明显优势。适合需要分发给终端用户、嵌入 CI/CD 或长时间运行的 Agent 场景。

no1coder的博客 5103

AI 驱动的 CLI 工具开发:用 Rust 构建智能命令行 Agent

用 Rust 构建智能 CLI Agent 的核心思路是"双通道输入":保留传统 CLI 的精确性,增加 NLU 的便利性。本文的关键实践为:用 clap 处理结构化命令、用大模型 API 解析自然语言意图、用 Rust 类型系统区分读写操作保证安全、用缓存和降级策略控制延迟和成本。这不是一个"成熟方案",而是一个学习过程中的记录——NLU 的延迟和安全沙箱是当前最大的挑战,后续会尝试本地模型和更严格的权限控制。

no1coder的博客 4589

AI 驱动的命令行工具:从 CLI 到智能 Agent 的构建实践

AI 驱动的 CLI 工具将"指令-执行"模式升级为"意图-翻译-执行-反馈"循环。落地建议:第一,简单翻译任务用单次 LLM 调用,多步骤任务才启动 Agent 循环;第二,危险命令黑名单 + 用户确认是安全底线,不能省略;第三,Agent 在沙箱环境中执行,限制文件系统和网络访问;第四,每步验证执行结果,LLM 幻觉生成的错误命令必须被捕获和纠正。智能 CLI 不是让用户不再学命令行,而是让命令行的学习曲线更平缓。

no1coder的博客 4967

openpilot 驾驶辅助完整指南

openpilot 是一套开源驾驶辅助系统。点火、上车、系好安全带后按下方向盘上的巡航键,三十秒内它会完成车型识别、CAN 总线握手与摄像头标定,随后仪表出现车道居中指示,车辆开始跟随前车并保持在车道中央。 ## openpilot 是什么:L2 辅助而非自动驾驶 openpilot 是运行在 comma 车机上的开源驾驶辅助系统,提供自适应巡航(ACC)与自动车道居中(ALC),并内置驾驶员

gitblog_00110的博客 1002

jcode适合你吗?6个维度快速评估这款最智能的终端AI Agent

jcode 是一款用 Rust 编写的开源**终端 AI Agent**(终端编程智能体),自称是"最省内存、最智能"的终端 Agent 运行框架(harness)。在决定装不装它之前,本文从**性能占用、记忆系统、多智能体协作、模型兼容、自开发、生态**6 个维度快速评估它,帮你判断 jcode 是否适合你的使用场景。 ## 维度一:性能与内存占用——终端AI Agent横评数据 ⚡ 这是

gitblog_00933的博客 639

新一代终端工具 Warp:重新定义命令行体验

介绍我最近发现的一款智能命令行终端 Warp。阅读原文请转到:https://jimmysong.io/blog/warp-modern-terminal-tool/最近,我在尝试各种终端工具时发现了一个令人耳目一新的产品——Warp[1]。这是一款专为开发者设计的现代终端工具,它不仅颠覆了我们对传统命令行工具的认知,还以智能化的交互体验显著提升了生产力。本文将介绍 Warp 的核心功能,并对比传...

ServiceMesher 2922
上一篇: 非科班转码 Rust 学习路径:从零基础到写出第一个可用工具的 180 天
下一篇: WASM + AI 生态全景:边缘智能部署的技术栈、运行时与跨语言互操作实践
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值