Rust 错误处理高级应用指南

Rust错误处理:thiserror与anyhow实战指南 错误处理是系统编程中的核心概念,Rust通过Result类型实现了显式错误传播机制。不同于传统的异常处理,这种设计需要开发者明确处理所有潜在错误,从而提升代码可靠性。在工程实践中,错误处理库如thiserror和anyhow通过提供类型安全的错误抽象和上下文增强能力,大幅降低了开发复杂度。thiserror适用于需要精确错误类型的库开发场景,而anyhow则擅长快速原型开发和应用层错误处理。两者的组合使用能有效覆盖从底层基础设施到上层业务逻辑的全栈开发需求,特别适合网络服务、文件解析器等需要严格错误分类的场 阅读详情

Rust 错误处理高级应用指南

1. 错误处理基础

Rust 的错误处理模型基于 Result 类型,它允许我们优雅地处理可能失败的操作。

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10.0, 2.0) {
        Ok(result) => println!("Result: {}", result),
        Err(error) => println!("Error: {}", error),
    }
}

2. 自定义错误类型

2.1 使用枚举定义错误类型

use std::fmt;

#[derive(Debug)]
enum MathError {
    DivisionByZero,
    NegativeSquareRoot,
}

impl fmt::Display for MathError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            MathError::DivisionByZero => write!(f, "Division by zero"),
            MathError::NegativeSquareRoot => write!(f, "Negative square root"),
        }
    }
}

impl std::error::Error for MathError {}

fn divide(a: f64, b: f64) -> Result<f64, MathError> {
    if b == 0.0 {
        Err(MathError::DivisionByZero)
    } else {
        Ok(a / b)
    }
}

fn sqrt(x: f64) -> Result<f64, MathError> {
    if x < 0.0 {
        Err(MathError::NegativeSquareRoot)
    } else {
        Ok(x.sqrt())
    }
}

fn main() {
    match divide(10.0, 2.0) {
        Ok(result) => println!("Division result: {}", result),
        Err(error) => println!("Division error: {}", error),
    }
    
    match sqrt(-1.0) {
        Ok(result) => println!("Square root result: {}", result),
        Err(error) => println!("Square root error: {}", error),
    }
}

2.2 使用 thiserror 库

use thiserror::Error;

#[derive(Error, Debug)]
enum MathError {
    #[error("Division by zero")]
    DivisionByZero,
    #[error("Negative square root: {0}")]
    NegativeSquareRoot(f64),
}

fn divide(a: f64, b: f64) -> Result<f64, MathError> {
    if b == 0.0 {
        Err(MathError::DivisionByZero)
    } else {
        Ok(a / b)
    }
}

fn sqrt(x: f64) -> Result<f64, MathError> {
    if x < 0.0 {
        Err(MathError::NegativeSquareRoot(x))
    } else {
        Ok(x.sqrt())
    }
}

fn main() {
    match divide(10.0, 2.0) {
        Ok(result) => println!("Division result: {}", result),
        Err(error) => println!("Division error: {}", error),
    }
    
    match sqrt(-1.0) {
        Ok(result) => println!("Square root result: {}", result),
        Err(error) => println!("Square root error: {}", error),
    }
}

3. 错误传播

3.1 使用 ? 运算符

use std::fs::File;
use std::io::Read;

fn read_file(path: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}

fn main() {
    match read_file("file.txt") {
        Ok(content) => println!("File content: {}", content),
        Err(error) => println!("Error: {}", error),
    }
}

3.2 错误转换

use std::fs::File;
use std::io::Read;
use thiserror::Error;

#[derive(Error, Debug)]
enum AppError {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
    #[error("Custom error: {0}")]
    Custom(String),
}

fn read_file(path: &str) -> Result<String, AppError> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}

fn main() {
    match read_file("file.txt") {
        Ok(content) => println!("File content: {}", content),
        Err(error) => println!("Error: {}", error),
    }
}

4. 高级错误处理技巧

4.1 错误链

use std::fs::File;
use std::io::Read;
use thiserror::Error;

#[derive(Error, Debug)]
enum AppError {
    #[error("Failed to read file: {0}")]
    ReadFile(#[from] std::io::Error),
    #[error("Failed to parse content: {0}")]
    ParseContent(#[from] std::num::ParseIntError),
}

fn read_and_parse(path: &str) -> Result<i32, AppError> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    let number: i32 = content.trim().parse()?;
    Ok(number)
}

fn main() {
    match read_and_parse("number.txt") {
        Ok(number) => println!("Parsed number: {}", number),
        Err(error) => {
            println!("Error: {}", error);
            if let Some(source) = error.source() {
                println!("Source error: {}", source);
            }
        }
    }
}

4.2 错误处理与 Option

fn find_element<T: PartialEq>(slice: &[T], target: &T) -> Option<usize> {
    slice.iter().position(|x| x == target)
}

fn find_element_or_error<T: PartialEq + std::fmt::Debug>(slice: &[T], target: &T) -> Result<usize, String> {
    find_element(slice, target)
        .ok_or_else(|| format!("Element {:?} not found", target))
}

fn main() {
    let numbers = [1, 2, 3, 4, 5];
    
    match find_element_or_error(&numbers, &3) {
        Ok(index) => println!("Found element at index: {}", index),
        Err(error) => println!("Error: {}", error),
    }
    
    match find_element_or_error(&numbers, &6) {
        Ok(index) => println!("Found element at index: {}", index),
        Err(error) => println!("Error: {}", error),
    }
}

4.3 自定义错误处理函数

use std::fs::File;
use std::io::Read;

fn handle_error<E: std::error::Error>(error: E) {
    eprintln!("Error: {}", error);
    if let Some(source) = error.source() {
        eprintln!("Source: {}", source);
    }
}

fn read_file(path: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}

fn main() {
    if let Err(error) = read_file("file.txt") {
        handle_error(error);
    }
}

5. 实际应用场景

5.1 文件操作

use std::fs::File;
use std::io::{Read, Write};
use thiserror::Error;

#[derive(Error, Debug)]
enum FileError {
    #[error("Failed to open file: {0}")]
    Open(#[from] std::io::Error),
    #[error("Failed to read file: {0}")]
    Read(#[from] std::io::Error),
    #[error("Failed to write file: {0}")]
    Write(#[from] std::io::Error),
}

fn read_file(path: &str) -> Result<String, FileError> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}

fn write_file(path: &str, content: &str) -> Result<(), FileError> {
    let mut file = File::create(path)?;
    file.write_all(content.as_bytes())?;
    Ok(())
}

fn main() {
    match read_file("input.txt") {
        Ok(content) => {
            println!("Read content: {}", content);
            if let Err(error) = write_file("output.txt", &content) {
                eprintln!("Error writing file: {}", error);
            }
        },
        Err(error) => {
            eprintln!("Error reading file: {}", error);
        },
    }
}

5.2 网络请求

use reqwest::Error;
use thiserror::Error;

#[derive(Error, Debug)]
enum ApiError {
    #[error("Request failed: {0}")]
    Request(#[from] Error),
    #[error("Invalid response")]
    InvalidResponse,
}

async fn fetch_data() -> Result<String, ApiError> {
    let response = reqwest::get("https://api.example.com/data").await?;
    if response.status().is_success() {
        let data = response.text().await?;
        Ok(data)
    } else {
        Err(ApiError::InvalidResponse)
    }
}

#[tokio::main]
async fn main() {
    match fetch_data().await {
        Ok(data) => println!("Fetched data: {}", data),
        Err(error) => eprintln!("Error: {}", error),
    }
}

5.3 数据库操作

use sqlx::postgres::PgPool;
use thiserror::Error;

#[derive(Error, Debug)]
enum DbError {
    #[error("Database connection failed: {0}")]
    Connection(#[from] sqlx::Error),
    #[error("Query failed: {0}")]
    Query(#[from] sqlx::Error),
}

async fn get_users() -> Result<Vec<(i32, String)>, DbError> {
    let pool = PgPool::connect("postgres://postgres:password@localhost/test").await?;
    let rows = sqlx::query!("SELECT id, name FROM users").fetch_all(&pool).await?;
    let users: Vec<(i32, String)> = rows.into_iter().map(|row| (row.id, row.name)).collect();
    Ok(users)
}

#[tokio::main]
async fn main() {
    match get_users().await {
        Ok(users) => {
            for (id, name) in users {
                println!("User: {} - {}", id, name);
            }
        },
        Err(error) => {
            eprintln!("Error: {}", error);
        },
    }
}

6. 最佳实践

  1. 使用 Result 类型:对于可能失败的操作,使用 Result 类型返回错误信息。
  2. 自定义错误类型:使用枚举定义自定义错误类型,使错误信息更加清晰。
  3. 使用 thiserror 库:使用 thiserror 库简化错误类型的定义。
  4. 使用 ? 运算符:使用 ? 运算符传播错误,使代码更加简洁。
  5. 错误转换:使用 From trait 实现错误类型之间的转换。
  6. 错误链:使用错误链提供更详细的错误信息。
  7. 错误处理与 Option:使用 ok_or_else 等方法在 Option 和 Result 之间转换。
  8. 自定义错误处理函数:创建通用的错误处理函数,统一处理错误。

7. 总结

Rust 的错误处理模型基于 Result 类型,它提供了一种优雅、类型安全的方式来处理可能失败的操作。通过掌握错误处理的高级应用,我们可以编写更加健壮、可维护的代码。

在实际应用中,错误处理可以用于文件操作、网络请求、数据库操作等多种场景,大大提高代码的可靠性和可维护性。

希望本文对你理解和应用 Rust 错误处理有所帮助!

【Rust错误处理】Rust错误处理机制详解与应用实战 在 Rust 中,错误处理是一个核心特性,它通过 Result 和 Option 类型以及 panic! 机制来管理错误和异常情况。Rust 的错误处理强调显式性和安全性,避免了传统异常机制的隐式控制流问题。 Rust 主要有两种错误处理方式:可恢复错误和不可恢复错误。 阅读详情

相关推荐

【Rust UDP编程】rust udp编程方法解析与应用实战

Rust标准库通过std::net模块提供了UDP网络编程支持,主要类型包括: UdpSocket:UDP套接字的主要类型 SocketAddr:表示IP地址和端口号的组合

景天科技苑 4万+

TDengine Rust连接器全面指南

TDengine Rust连接器(`taos`)是专为Rust开发者设计的官方数据库连接工具,它提供了与TDengine时序数据库交互的完整功能集。本文将详细介绍该连接器的特性、使用方法及最佳实践。 ## 核心特性 1. **多协议支持**: - 原生TCP协议连接 - WebSocket协议连接 - 支持SSL/TLS加密 2. **全面功能覆盖**: - 标准SQ...

gitblog_01058的博客 601

别再到处找模型了!手把手教你将TI、ADI官网的SPICE模型导入LTspice(附路径避坑指南)

本文详细介绍了如何将TI、ADI官网的SPICE模型导入LTspice的全流程,包括模型获取、路径配置、符号生成等关键步骤,并提供了路径避坑指南。通过实战案例和技巧分享,帮助电子工程师高效利用外部元器件模型进行电路仿真,提升设计效率。

weixin_42535703的博客 408

Rust 复杂数库 `num-complex` 使用指南

Rust 复杂数库 num-complex 使用指南 项目介绍 num-complex 是一个 Rust 语言的库,专门用于处理复数运算。这个库是 num 项目的一部分,提供了复数的创建、操作和数学运算功能。它支持基本的复数运算,如加、减、乘、除,以及更高级的运算,如幂运算和三角函数。 项目快速启动 安装 首先,在你的 Rust 项目中添加 num-complex 作为依赖项。编辑 Cargo.t...

gitblog_00756的博客 502

大开眼界的十大开源人工智能项目

这是一个强大的开源工具,能让你在不同框架之间自由切换,无需重写代码。它是一个开源工具,能用简单的SQL语言同时处理数据和AI模型,让一切变得有序而高效。Rasa是我开发智能聊天机器人时的首选,它让你轻松掌控机器人对话的每个细节。我经常用它快速验证模型在不同框架下的表现,省去了大量烦躁的调试过程。最近发现的Vapi是一个以API方式提供的语音AI工具,开发者友好程度超乎想象。KNIME是一个以拖拽方式构建数据分析流程的开源工具,仿佛是数据界的乐高积木。它像个忠诚的守门员,确保你的模型始终健康运行。

wjianwei666的专栏 1108

股票交易接口TDX量化下单接口

对于需要同时操作多只股票的投资者而言,这一功能可以一次性处理多个交易指令,大大提高了交易的效率。通过回测,投资者可以发现策略中的不足之处,进而进行优化和调整,提高策略的可靠性。根据通达信提供的安装指南,下载相应的安装程序并进行安装。这包括设置交易账户的相关信息,如账户名、密码等,以及连接到正确的交易服务器。不同的情况可能会有不同的标准,有的可能要求账户使用达到一定的时长,有的可能对账户内的资产金额有最低要求。可以通过接口提供的监控功能或者第三方工具,实时查看交易状态、交易数据等信息,确保交易按照预期进行。

2401_88470113的博客 1291

adsb_deku社区贡献指南:如何提交PR、修复bug与参与功能开发

adsb_deku是一个用Rust编写的ADS-B解码器和终端雷达应用,它能帮助开发者和航空爱好者解析1090MHz频率上的ADS-B信号,追踪空中航班。本指南将详细介绍如何参与adsb_deku项目的社区贡献,包括提交PR、修复bug和参与功能开发的完整流程。 ## 准备工作:环境搭建与代码获取 ### 1. 安装必要工具 在开始贡献前,确保你的开发环境中已安装: - Rust 1.84.0

gitblog_00715的博客 210

科研绘图必备:Adobe Illustrator 高效排版技巧全解析

本文详细解析了Adobe Illustrator在科研绘图中的高效排版技巧,帮助科研人员提升论文图表质量。从图片预处理、统计图表优化到精准对齐和期刊投稿前的终极检查,全面覆盖AI在科研绘图中的关键应用场景,确保图表符合期刊要求,提升投稿成功率。

weixin_26767391的博客 347

rust 笔记 高级错误处理

虽然标准库定义了大量的错误类型,但是一个严谨的项目,光使用这些错误类型往往是不够的,例如我们可能会为暴露给用户的错误定义相应的类型。当自定义类型实现该特征后,该类型就可以作为 Err 来使用。实际上,自定义错误类型只需要实现 Debug 和 Display 特征即可,source 方法是可选的,而 Debug 特征往往也无需手动实现,可以直接通过 derive 来派生最简单的错误// AppError 是自定义错误类型,它可以是当前包中定义的任何类型,在这里为了简化,我们使用了单元结构体作为例子。

个人博客,记录了本人学习的各种有趣的技术。 2725

TPAMI 2024 | 面向大型城市场景的快速建筑实例代理重建

大规模城市场景(特别是建筑物)的数字化是一个长期存在的开放问题,这归因于数据获取方面的挑战,如场景覆盖不完整、缺乏语义、规划路径的效率和可靠性低。在本文中,我们针对从航拍图像中重建城市建筑的问题,提出了一个有效的工作流程和一些新颖的算法,用于大型城市场景中高效的3D建筑实例代理重建。具体来说,我们提出了一种基于学习的新型方法,用于从航拍图像中进行城市建筑的实例分割,然后通过基于投票的算法将多视图实例信息融合到稀疏点云中(使用标准结构从运动管道重建)。我们的方法实现了从点云中对建筑实例进行有效的实例分割。

小白学视觉 322

Triton server的部署、构建、backend插件机制代码梳理、模型加载、自定义C++backend流程

Triton inference server的部署、构建、backend机制代码详细梳理、模型加载过程、自定义C++backend流程.

C/C++、嵌入式开发、深度学习算法、模型部署与推理优化 474

从leetcode-rust学习Rust错误处理:Result和Option的实战应用指南

Rust语言以其强大的内存安全和错误处理机制而闻名,其中`Result`和`Option`类型是Rust错误处理的核心。通过分析leetcode-rust项目中的实际代码,我们可以深入理解这些机制如何在实际编程中应用。本文将带你从实战角度掌握Rust错误处理的最佳实践,帮助你编写更安全、更健壮的代码。🚀 ## 为什么Rust错误处理如此重要? 在传统编程语言中,错误处理往往依赖于异常机制或返

gitblog_01022的博客 484

【AI大模型:前沿】46、AI+无人机:智能飞行革命全景指南——从技术突破到行业应用与未来趋势

AI+无人机的融合不仅是技术迭代,更是“空间生产力”的革命——它将人类活动范围从地面拓展至低空,重构物流、农业、应急等行业的生产方式。当前,技术突破(如多模态感知、群体智能)与法规松绑(超视距飞行许可)正加速产业化,预计2030年全球低空经济市场规模将突破万亿美元。技术层:轻量化AI模型、边缘-云端协同、安全冗余系统;应用层:垂直领域解决方案(如电网AI巡检、精准农业);生态层:无人机巢建设、空管系统、数据服务平台。

2025博客之星Top81。专注AI工程化与架构实战。从分布式思维到模型部署,用工程化视角为你厘清AI落地的真实路径。 5614

Rufus 制作U盘启动盘在Windows 7打不开:3.22为什么是最后一个版本

Rufus 是 Windows 上最常用的 U 盘格式化和 U 盘启动盘制作工具。但自 4.0(2023.04.26 发布)起它不再支持 Windows 7——老系统上双击 4.x 安装包,桌面没有任何反应,连错误弹窗都没有。3.22 是最后一个能在 Windows 7 上完整运行的版本。这个边界划在哪、对你意味着什么,下面一次说清。 ## 版本对照:3.22、4.0、4.15 分别发生了什么

gitblog_00837的博客 1079

PCL 利用RANSAC改进的ICP算法

本文介绍了一种基于RANSAC改进的ICP点云配准算法。算法原理部分阐述了在ICP迭代过程中使用RANSAC剔除错误匹配点对的方法。

点云侠的博客 197

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

Rust的错误处理

Rust中的错误处理: ps:笔者是个刚接触Rust的菜鸟,本文也只是自己的一点粗浅的看法,如果有什么不对的地方欢迎指出,也希望能给大家一点小小的帮助 这下面两篇文章都是关于Rust的错误处理的文章: https://lotabout.me/2017/rust-error-handling/ https://zhuanlan.zhihu.com/p/25506762 错误处理,目前接触最多的是Op...

qq_36544196的博客 3587

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

【Rust】错误处理机制

Rust 通过明确区分可恢复错误和不可恢复错误,提供了高效且安全的错误处理方式。Rust 要求开发者在编写代码时考虑错误的可能性,并采取相应的措施。Rust 通过其强大的类型系统和错误处理机制,帮助开发者在编译时捕获和处理这些错误,从而提高程序的健壮性。不可恢复错误是指那些无法通过程序逻辑恢复的错误,通常是由于程序中的 bug 导致的。在决定是尝试恢复错误还是停止执行时,开发者需要权衡错误的性质和程序的稳定性。在这个示例中,我们尝试访问一个超出数组边界的元素,这将导致程序立即停止执行,并打印出错误信息。

qq_61867911的博客 1339

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

深度学习工具包 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")

REA 逆向分析提示词写法:3 个场景模板 + 4 个避坑点

很多人第一次用 REA(reverse-engineer-anything,一个把 AI Agent 接到二进制、JavaScript/Electron 应用、.NET 程序集分析能力上的开源工具)时,都会踩同一个坑:给 Agent 一句"帮我分析一下这个 App",Agent 来回追问三轮,最后吐出一堆"这个功能可能是……"——全是猜测,没有一条能追溯到具体代码。问题不在工具,在提示词。 RE

gitblog_00734的博客 1078

Rust 错误处理详解

Rust错误处理机制详解:基于Result和panic!的显式设计。Result<T,E>枚举用于可恢复错误,提供match、unwrap、?操作符等多种处理方式;panic!处理不可恢复错误。文章还介绍了Option<T>处理值缺失,并展示了自定义错误类型和错误传播的实战示例。Rust通过这种显式、类型安全的方式强制开发者处理潜在错误,构建健壮可靠的程序。

本博客分享软硬件一体化开发实战。硬件涵盖 PCB 设计、STM32 等 MCU 底层开发;软件包含 C++、Rust,Qt/QML、PyQt、Slint、TouchGFX、LVGL 各类 GUI 框架。方便软硬件开发者查阅学习。欢迎关注! 874
上一篇: Rust 异步编程高级应用指南
下一篇: Rust 文件 IO 操作高级应用指南
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值