Rust错误处理新范式:anyhow vs thiserror 深度对比,选型建议一文讲透

Rust错误处理:thiserror与anyhow库对比与实践指南 错误处理是编程语言的核心机制之一,Rust通过Result类型和Error trait提供了独特的解决方案。不同于Java的异常机制,Rust要求显式处理所有可能的错误,这带来了更好的安全性但也增加了复杂度。thiserror和anyhow是两个广泛使用的Rust错误处理库,分别代表了强类型和动态类型两种哲学。thiserror适合需要精确错误类型的库开发场景,而anyhow则简化了应用层的错误处理。理解它们的原理和适用场景,能帮助开发者编写更健壮的Rust代码,特别是在从Java等语言迁移到Rust时。这 阅读详情

第一章:Rust错误处理新范式概述

Rust 的错误处理机制在系统编程语言中独树一帜,摒弃了传统异常机制,转而采用类型驱动的显式错误处理方式。这种设计不仅提升了程序的可靠性,还增强了编译期的错误检测能力。通过 Result<T, E> 类型,开发者必须主动处理可能的失败路径,从而避免了隐式崩溃或未捕获异常的问题。

核心设计理念

  • 显式性优先:所有可能出错的操作都返回 Result 类型,迫使调用者处理错误
  • 零成本抽象:错误处理不依赖运行时栈展开,性能开销可控
  • 组合性强大:通过 ? 操作符和迭代器等特性实现优雅的错误传播

典型代码模式

// 读取文件并解析内容
use std::fs;
use std::io;

fn read_config(path: &str) -> Result {
    let content = fs::read_to_string(path)?; // ? 自动传播错误
    Ok(content.trim().to_string())
}

// 调用示例
match read_config("config.txt") {
    Ok(config) => println!("配置加载成功: {}", config),
    Err(e) => eprintln!("配置加载失败: {}", e),
}
上述代码展示了 Rust 中典型的错误处理流程:read_to_string 返回 Result<String, io::Error>,使用 ? 操作符将错误自动向上传递,最终由 match 表达式完成分支处理。

错误类型的演进趋势

现代 Rust 项目倾向于使用更高级的错误处理库,如 thiserror 和 anyhow,以简化错误定义与传播:
场景推荐工具优势
定义错误类型thiserror声明式宏生成错误实现
应用级错误传播anyhow无需定义枚举,支持上下文添加

第二章:anyhow 错误处理实践与原理

2.1 anyhow 的设计理念与适用场景

简化错误处理流程
anyhow 是 Rust 中用于提升错误处理体验的第三方库,其核心设计理念是减少样板代码,让开发者专注于业务逻辑。通过统一的 Result<T, anyhow::Error> 类型,可自动传播和转换各类错误。
use anyhow::Result;

fn read_config() -> Result<String> {
    std::fs::read_to_string("config.json")
        .map_err(|e| anyhow!("Failed to read file: {}", e))
}
上述代码利用 anyhow::Result 省去了定义具体错误类型的繁琐过程。map_err 将底层 std::io::Error 转换为上下文丰富的 anyhow 错误,便于调试。
适用场景分析
  • 快速原型开发中避免复杂错误类型设计
  • 二进制程序主函数返回错误(支持 .context() 添加上下文)
  • 内部服务模块间调用的错误聚合

2.2 快速上手:在项目中集成 anyhow

添加依赖到 Cargo.toml
在项目的 Cargo.toml 文件中引入 anyhow 作为依赖项,这是集成的第一步:

[dependencies]
anyhow = "1.0"
该配置会自动下载并链接最新稳定版的 anyhow 库,支持开箱即用的动态错误类型。
在代码中使用 Result 类型
推荐将函数返回类型统一为 anyhow::Result<T>,以简化错误传播:

use anyhow::Result;

fn read_config(path: &str) -> Result {
    let content = std::fs::read_to_string(path)?;
    Ok(content)
}
此处 ? 操作符可自动将标准库错误转换为 anyhow::Error,无需手动映射。泛型 T 表示成功时返回的具体类型,如 String。

2.3 anyhow 的上下文注入与错误链追踪

在 Rust 错误处理生态中,anyhow 库通过上下文注入机制显著提升了错误的可追溯性。开发者可以使用 .context() 方法为错误附加语义化信息,从而构建清晰的调用链。
上下文注入示例
use anyhow::Result;

fn read_config() -> Result<String> {
    std::fs::read_to_string("config.json")
        .context("failed to read config file")
}
上述代码中,.context() 将底层 I/O 错误包装并附加描述,形成结构化上下文。当错误向上抛出时,调用者能获取完整的路径信息。
错误链追踪机制
anyhow 自动维护错误链(error chain),通过迭代器可逐层访问:
  • 根因(source):原始错误类型
  • 中间上下文:各层注入的提示信息
  • 最终呈现:支持 Display 格式化输出完整链条
该机制结合 Result<T, anyhow::Error> 类型,实现轻量级、高表达力的错误传播模式。

2.4 实战案例:构建可调试的 CLI 工具

在开发命令行工具时,良好的调试能力是保障稳定性的关键。通过引入结构化日志和分级日志级别,可以显著提升问题排查效率。
使用 Zap 构建日志系统
package main

import (
    "go.uber.org/zap"
)

func main() {
    logger, _ := zap.NewDevelopment()
    defer logger.Sync()

    logger.Info("启动 CLI 工具", zap.String("version", "1.0"))
    logger.Debug("调试模式已启用")
}
该代码使用 Uber 的 Zap 库创建开发模式日志器,自动输出时间、文件名和行号。Info 级别用于常规运行提示,Debug 仅在调试时显示,便于追踪执行流程。
命令行参数与调试开关
  • --debug:启用详细日志输出
  • --config:指定配置文件路径
  • --verbose:增加进度反馈信息
通过标志位控制日志级别,使工具在生产与调试环境中灵活切换。

2.5 性能分析与使用注意事项

性能调优关键点
在高并发场景下,合理配置连接池和超时参数至关重要。建议设置合理的 MaxIdleConns 和 MaxOpenConns 以避免资源耗尽。
db.SetMaxOpenConns(100)
db.SetMaxIdleConns(10)
db.SetConnMaxLifetime(time.Hour)
上述代码设置了数据库连接池的最大打开连接数、空闲连接数及连接最长生命周期,有效防止连接泄漏并提升复用效率。
常见使用陷阱
  • 未关闭查询结果集可能导致内存泄漏
  • 长时间运行的事务会阻塞其他操作
  • 忽略错误检查可能掩盖潜在问题
监控建议
定期采集数据库指标如查询延迟、连接数等,有助于及时发现性能瓶颈。

第三章:thiserror 枚举错误定义深度解析

3.1 thiserror 的声明式错误定义机制

声明式宏简化错误类型定义
在 Rust 中,thiserror 通过派生宏实现声明式错误定义,开发者只需为枚举或结构体标注 #[error] 属性,即可自动生成错误消息和 Error trait 实现。

use thiserror::Error;

#[derive(Error, Debug)]
pub enum DataError {
    #[error("数据解析失败: {source}")]
    ParseError {
        #[from]
        source: std::io::Error,
    },
    #[error("无效输入: {0}")]
    InvalidInput(String),
}
上述代码中,#[error(...)] 定义了格式化错误消息,{source} 自动引用内部错误源,实现上下文透传。使用 #[from] 可自动实现 From trait,简化错误转换逻辑。
优势对比传统方式
相比手动实现 Display 和 Error trait,thiserror 显著减少样板代码,提升可维护性。其机制基于编译期代码生成,不引入运行时开销。

3.2 自定义错误类型的构建与扩展

在Go语言中,通过实现 error 接口可构建自定义错误类型,提升错误语义清晰度。
基础结构定义
type AppError struct {
    Code    int
    Message string
}

func (e *AppError) Error() string {
    return fmt.Sprintf("[%d] %s", e.Code, e.Message)
}
该结构体嵌入错误码与描述信息,Error() 方法满足 error 接口要求,实现多态处理。
错误分类管理
  • ValidationError:用于输入校验失败
  • NetworkError:网络通信异常
  • DatabaseError:持久层操作错误
动态扩展能力
支持通过接口组合添加上下文:
type ContextualError interface {
    error
    Context() map[string]interface{}
}
此模式便于日志追踪与错误归因,增强系统可观测性。

3.3 实战案例:为库设计健壮的公开 API 错误体系

在构建可复用的库时,错误处理是决定其易用性与健壮性的关键。一个清晰、一致的错误体系能让调用者快速定位问题并做出响应。
定义统一的错误接口
建议通过接口抽象错误类型,便于扩展和断言:
type APIError interface {
    Error() string
    Code() int
    Message() string
}
该接口规范了所有公开错误的行为,使上层逻辑能以统一方式解析错误语义。
分层错误分类
使用枚举式结构管理错误码,避免魔法值:
  • NetworkError: 网络不可达或超时
  • ValidationError: 参数校验失败
  • AuthError: 认证或权限问题
每个错误实例携带上下文信息,如请求ID、时间戳,便于追踪。
错误透传与封装
对外暴露前应将底层错误映射为公共APIError,防止内部实现细节泄露,同时保留原始错误用于日志分析。

第四章:anyhow 与 thiserror 协同与选型策略

4.1 二者核心差异对比:场景与权衡

在分布式系统设计中,强一致性与最终一致性模型的选择直接影响系统的可用性与数据可靠性。
数据同步机制
强一致性要求写操作完成后所有读操作立即可见,适用于金融交易等高敏感场景。而最终一致性允许短暂的数据延迟,提升系统吞吐与容错能力。
维度强一致性最终一致性
延迟高低
可用性较低高
典型应用银行转账社交动态推送
func writeData(key, value string) {
    // 强一致性:需等待所有副本确认
    if waitForAllReplicas {
        sync.WaitGroup{}.Wait()
    }
    // 最终一致性:仅主节点确认即返回
    respondToClient()
}
上述代码体现写入策略差异:强一致性等待所有副本同步完成,而最终一致性优先响应客户端,后台异步传播更新。

4.2 混合使用模式:库与应用层的最佳实践

在现代软件架构中,合理划分库(Library)与应用层(Application Layer)的职责是提升可维护性的关键。通过将通用逻辑封装为独立库,应用层可专注于业务流程编排。
职责分离原则
  • 库应提供无状态、高内聚的功能模块,如数据校验、加密服务
  • 应用层调用库能力,处理用户请求、事务控制和异常转换
依赖注入示例

// 应用层通过接口依赖底层库
type UserService struct {
    validator *validation.Library
}
func (s *UserService) Register(email string) error {
    if !s.validator.IsValidEmail(email) { // 调用库方法
        return ErrInvalidEmail
    }
    // 执行注册逻辑
}
上述代码中,UserService 不直接实现校验逻辑,而是复用验证库,降低耦合度。参数 email 由应用层传入,库仅负责返回校验结果,清晰划分边界。

4.3 错误透传、转换与边界处理技巧

在分布式系统中,错误的透传需谨慎处理,避免暴露底层细节。应统一错误码体系,将内部异常转换为对外可读的业务错误。
错误转换示例
func handleError(err error) *ErrorResponse {
    switch {
    case errors.Is(err, sql.ErrNoRows):
        return &ErrorResponse{Code: "NOT_FOUND", Message: "资源未找到"}
    case errors.Is(err, context.DeadlineExceeded):
        return &ErrorResponse{Code: "TIMEOUT", Message: "服务超时,请重试"}
    default:
        return &ErrorResponse{Code: "INTERNAL", Message: "系统内部错误"}
    }
}
上述代码展示了如何将底层数据库或上下文错误映射为标准化响应。errors.Is 提供了语义比较能力,确保类型判断准确。
边界条件处理策略
  • 输入校验前置,防止非法数据进入核心逻辑
  • 对空切片、nil 指针等常见边界值做防御性判断
  • 设置合理的超时与重试机制,避免雪崩效应

4.4 典型架构中的选型决策路径

在构建分布式系统时,技术选型需基于业务场景、扩展性与维护成本综合权衡。高并发读写场景下,通常优先考虑最终一致性模型。
数据同步机制
常见方案包括双写、消息队列异步同步和数据库日志捕获(如Debezium)。其中,基于Kafka的消息队列具备高吞吐与解耦优势。
  1. 明确数据一致性级别:强一致、因果一致或最终一致
  2. 评估延迟容忍度与容错需求
  3. 选择匹配的中间件与协议(如gRPC vs REST)

// 示例:使用Kafka进行数据变更传播
producer.Send(&Message{
    Topic: "user-updates",
    Value: []byte(updatedUserJSON), // 序列化用户更新
})
// 异步解耦服务间依赖,提升系统可伸缩性
上述代码实现将用户更新事件发布至Kafka主题,下游服务订阅该主题并更新本地视图,适用于跨微服务的数据同步场景。

第五章:总结与 Rust 错误处理未来趋势

错误处理的演进方向
Rust 的错误处理机制正朝着更简洁、更安全的方向发展。`?` 操作符的广泛应用减少了样板代码,而 `anyhow` 和 `thiserror` 等第三方库进一步提升了开发效率。
  • anyhow::Result<T> 适用于应用层,简化错误传播
  • thiserror::Error 用于定义可扩展的自定义错误类型
  • Rust 1.80+ 对 try 块的支持正在实验中,允许在非异步上下文中统一处理错误
实际工程中的最佳实践
在微服务架构中,结合 thiserror 定义领域错误并映射到 gRPC 状态码:
use thiserror::Error;
use tonic::Status;

#[derive(Error, Debug)]
pub enum UserServiceError {
    #[error("用户不存在")]
    NotFound,
    #[error("数据库错误: {0}")]
    Database(#[from] sqlx::Error),
}

impl From<UserServiceError> for Status {
    fn from(e: UserServiceError) -> Self {
        match e {
            UserServiceError::NotFound => Status::not_found("user not found"),
            UserServiceError::Database(_) => Status::internal("internal error"),
        }
    }
}
未来语言级改进
Rust 团队正在探索更直观的错误语法,例如:
→ 提案中的 try {} 表达式允许块级错误短路 → 更强的错误类型推导减少泛型标注负担 → 编译器对错误链(error chain)的可视化支持
特性当前状态预期影响
native try blocks实验性统一同步/异步错误处理模式
improved error diagnostics稳定中增强缩短调试周期
anyhow_playground:易于使用的简单示例代码和thiserror 使用简单的示例代码anyhow和thiserror 我什么时候应该选择anyhow ? 我什么时候需要thiserror ? 您能给我看一个使用它们的快速代码示例吗? 这是我一次回答这些问题的尝试。 立即下载

相关推荐

win11本地部署openclaw实操第5集-X11图形化界面搭建,让WSL2“看见”世界

本文介绍了在WSL2中实现图形界面(GUI)的方法。由于WSL2默认没有图形界面,需要使用X11服务器作为"翻译显示器",将Linux程序的图形指令渲染到Windows窗口中。推荐使用VcXsrv作为X11服务器,详细说明了其安装和配置步骤,包括选择"One large window"显示模式、禁用访问控制等关键设置。随后在Ubuntu中安装轻量级xfce4桌面环境,并通过设置DISPLAY环境变量将图形输出指向VcXsrv。最终通过startxfce4命令成功在Vc

weixin_44626085的博客 812

Rust 错误处理库: thiserror 和 anyhow

writeln!;writeln!}")?;Ok(())#[error]宏生成Display, #[from]宏处理from实现source()转换std::error::error。总之,我们已经探索了thiserror 和 anyhow库的独特特性,并讨论了每个库的优点。通过选择合适的工具,Rust开发人员可以大大简化错误处理并增强代码的可维护性。thiserror简化实现自定义错误类型,thiserror对于库开发来说是理想的,其中提供的宏对程序员非常友好。

neweastsun的专栏 1967

航测倾斜摄影如何用Smart3D(ContextCapture)处理大疆无人机照片生成三维模型

本篇内容主要介绍Smart3D(ContextCapture)处理大疆无人机数据操作步骤 详细步骤如下 1.拷贝大疆无人机航拍的完整照片 2.打开Smart3D(ContextCapture)软件新建一个工程 3.影像选择项下选择添加影像 4.检查影像是否可以正常打开 5.提交空三计算,名称默认即可(不能带文字或字符) 6.没有控制点就默认选择 7.第一次空三默认设置 8.完成设置提交空三计算 9.打开引擎端开始计算 10.空三计算完成 11.查看空三质量报告是否有问题 12.空三没有

Miss程晨 1万+

std::io::Error, thiserror和anyhow

理清前后的脉络之后, 就可以看到thiserror和anyhow的作用就是帮我们简化大量的模板代码. 是对我们手动实现自己的错误的抽象. 这样也能理解crate中功能的作用了.

yhb_csdn的博客 1608

创龙 瑞芯微 RK3588 国产工业开发板—Qt交叉编译环境搭建与GPU图形渲染实战

本文详细介绍了在创龙RK3588国产工业开发板上搭建Qt交叉编译环境并利用GPU进行图形渲染的完整实战流程。文章从环境准备入手,讲解了交叉编译工具链的配置,并提供了命令行与Qt Creator两种编译方法。通过部署运行和自启动设置,确保程序在板卡上稳定运行。最后,通过OpenGL案例实战,展示了如何调用RK3588的GPU进行高效图形渲染,释放其图形处理潜力,适用于工业HMI、智能终端等高要求图形界面开发。

weixin_28278377的博客 451

从理论到代码:蒙特卡洛法在光学散射模拟中的应用全解析(Matlab 2014a版)

本文详细解析了蒙特卡洛法在光学散射模拟中的应用,从数学原理到Matlab 2014a实现。通过模拟光子随机游走过程,精确描述光在浑浊介质中的传输特性,提供完整的源码实现和性能优化技巧,适用于生物医学光学、大气遥感等领域。

rum55的博客 630

Rust错误处理

Rust错误处理

alex wang的博客 995

SAP 分期付款,付款条件的要件定义方法

以上内容做好后,可以在F-02或者F-60里看设置后的结果。找到相关路径选择【维护支付条件】点击进入后,选择【新条目】再设置一个总的支付规则,注意这里【付款条款】一定要选择。例:默认付款条件SP00,改成刚定义好的0028即可。将刚才基础创建的付款条件,以以下方式录入,注意。028A- 30天到期,过账日期基础。028B- 60天到期,过账日期基础。028C- 90天到期,过账日期基础。目的:新建支付条款(本次以。的选择,然后保存后,完成。,【基准日期缺省值】选择。基础创建好了以后,选择【

晴天的博客分享技术知识 2938

【Rust每周一库】anyhow和thiserror - 错误处理库

前言之前我们借助讲解failure库,详细说明的Rust错误处理的哲学,这有助于我们理解今天的主题,anyhow和thiserrorAnyhow提供了一个anyhow::Error t...

Rust语言学习交流 5317

Cadence IC618/Spectre231安装避坑指南:详解环境变量配置与License管理那些事儿

本文深入解析Cadence IC618/Spectre231安装过程中的环境变量配置与License管理难题,提供从变量冲突解决到高效License管理的实用方案。针对常见的64位标识冲突、路径污染及License服务器连接问题,给出具体诊断步骤和优化建议,帮助用户构建稳定可靠的EDA环境。

weixin_33737134的博客 621

Unity Shader之路(一)什么是Unity Shader?

Unity Shader前言什么是UnityShaderUnity Shader和材质的关系 前言 众所周知,要想当游戏开发工程师,Unity中的Shader编写不得不摸,这一系列文章我将描写我的Shader学习之路,致敬冯乐乐的书Unity Shader入门精要,此篇什么是Unity Shader?希望能给后人一点方向 我们刚开始接触Unity的时候,总是会遇到材质,但是不了解材质都是什么,为什么可以在很多材质中选择,为什么有时候选择了其他材质后就不能达到我们想要的结果,为什么资源商店有那么多的材质,山.

TurboQ珞珈 2242

Rust 错误处理常用 crate - thiserror 与 anyhow

`thiserror` crate 为标准库的 `std::error::Error` trait 提供了一系列的派生宏。使用这个库可以更加方便快捷的定义自定义错误类型。

编程回响 1192

Ultralytics 框架中predict 与 track 的区别

在 Ultralytics 框架中,predict 和 track 是两种不同的推理方法,分别用于目标检测(或分割、姿态估计)和目标跟踪任务。

浩瀚之水的专栏 1127

Rust错误处理终极指南:thiserror vs anyhow 两大神器深度对比

在Rust编程中,错误处理是构建健壮应用程序的关键环节。**thiserror**和**anyhow**作为Rust生态系统中最受欢迎的两个错误处理库,分别针对不同的使用场景提供了优雅的解决方案。本文将为你提供完整的对比指南,帮助你在项目中做出明智的选择。 ## 📊 快速决策:何时选择thiserror vs anyhow ### **thiserror - 库开发者的首选** 当你在开发供

gitblog_00708的博客 831

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

jre9下载 jdk9

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

终极指南:error-chain与其他Rust错误处理库对比:anyhow、thiserror、snafu

在Rust生态系统中,错误处理是一个至关重要的主题,而error-chain作为一个老牌的错误处理库,为开发者提供了一套完整的解决方案。本文将深入对比error-chain与当前流行的anyhow、thiserror和snafu库,帮助您选择最适合您项目的错误处理策略。无论您是Rust新手还是经验丰富的开发者,这篇文章都将为您提供实用的见解和指导。 ## 📊 Rust错误处理库全景图 Rus

gitblog_01042的博客 855

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

Rust错误处理:anyhow与thiserror对比与实践

错误处理是系统编程中的核心概念,Rust通过Result类型实现了显式错误处理机制。不同于传统的异常处理,这种范式在编译期强制错误检查,显著提升了代码可靠性。anyhow和thiserror作为Rust生态中的热门错误处理库,分别针对应用层和库层提供了优化解决方案。anyhow采用动态错误类型实现快速原型开发,而thiserror通过过程宏生成类型安全的错误定义。在Web服务、命令行工具等应用场景中,合理选择错误处理策略能有效平衡开发效率与代码质量。本文深入解析这两个库的设计哲学,并分享实际项目中的最佳实践

weixin_30938149的博客 400

OV9734 DATASHEET,完整规格书

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

Crate 级错误类型与 Result 别名:用 thiserror 打造生产级 Rust 错误处理(Rust for C Programmers)

本文是 RustTraining 仓库《Rust for C# Programmers》([csharp-book](https://link.gitcode.com/i/d9ef08e718d26557254402f4ac2a0678))第九章进阶篇的深度展开,核心讲解生产级 Rust 项目中最关键的错误处理模式:用 `thiserror` 定义一个 crate 级的错误枚举、通过 `Resul

gitblog_00431的博客 690

Rust 错误处理实战指南:从 Python 异常到 Result、`?` 运算符与 thiserror(RustTraining python-book 第 9 章深度解析)

> 本文基于 RustTraining 仓库 [python-book/src/ch09-error-handling.md](https://link.gitcode.com/i/535210b47a9ddc8915335be13542a9f0) 展开,它是《Rust for Python Programmers》完整训练指南(见 [python-book/src/ch00-introducti

gitblog_00343的博客 199

RustTraining 之 C/C++ 开发者错误处理最佳实践:Option、Result、`?` 运算符与 thiserror 生产级模式

> **本文定位**:面向从 C/C++ 迁移到 Rust 的开发者,基于 RustTraining 项目中《Rust for C/C++ Programmers》一书的第 9 章配套深度篇([c-cpp-book/src/ch09-1-error-handling-best-practices.md](https://link.gitcode.com/i/8c7f72d209b6075f48c1

gitblog_00298的博客 268

Rust 错误处理与验证:从“恐慌”到“可恢复”的工程艺术

在专业实践中,我们很少直接返回或 `serdejson::Error。为什么?因为这些错误类型对调用者来说“语义过低”。调用者不想知道你内部用的是 \serde_on还是simd_json`,他只想知道“为什么我的配置加载失败了”。这就是自定义错误枚举的用武之地。thiserror库是这一实践的黄金标准,它允许我们通过派生宏(Derive Macro)快速创建功能完备的错误类型。语义化远比一个通用的serde_json::Error` 更有意义。#[from]:自动实现了和,使得?

jdjbdss的博客 1365

Rust 错误处理完全指南:从 Result 到自定义错误类型

本文深入解析Rust的错误处理机制,重点介绍了Result和Option类型的用法,以及?运算符的工作原理。通过对比其他语言的异常处理方式,突出Rust显式错误处理的优势。文章详细讲解如何设计自定义错误类型(包括简单枚举、实现标准trait和使用thiserror/anyhow库),并提供了错误处理最佳实践和实战案例(HTTP客户端、数据验证器等)。最后讨论了panic的合理使用场景和自定义处理方式,总结Rust错误处理的核心优势:类型安全、零成本抽象和强制显式处理。

seven_1243096140的博客 1117

DeepFilterNet 语音增强快速指南:如何让 48kHz 嘈杂音频恢复干净人声

开视频会议时,同事的键盘声、头顶的空调嗡鸣全挤进你的麦克风,对方听得直皱眉。DeepFilterNet 语音增强框架就是为解决这个问题而生:它基于深度滤波做噪声抑制,支持 48kHz 全频带音频,实时链路最低 20ms 延迟。下面花十分钟,从一条命令到原理、选型与进阶,把它讲透。 ## 一、「初见」:三步跑通第一条降噪命令 想尽快听到效果,走 Python 路线最快。装好依赖后,对一段 48k

gitblog_00670的博客 211

VS Code + Rust 开发环境配置全攻略:从安装到调试实战

在现代软件开发中,集成开发环境(IDE)的配置与工具链的整合是提升开发效率的关键环节。通过语言服务器协议(LSP)等核心技术,IDE能够提供智能代码补全、实时错误检查和深度调试支持,从而降低认知负担、加速开发反馈循环。对于Rust这类强调内存安全和零成本抽象的系统编程语言,一个强大的开发环境尤为重要,它能帮助开发者更好地应对所有权、生命周期等复杂概念。本文将聚焦于如何将Visual Studio Code(VS Code)与Rust工具链深度集成,通过配置rust-analyzer语言服务器和CodeLLD

weixin_34409357的博客 520

Rust Patterns 速查卡(Summary & Reference Card)精读:一本可随身携带的 Rust 模式决策手册

> **导读**:本文以《Rust Patterns & Engineering How-Tos》训练书附录 [Summary and Reference Card](https://link.gitcode.com/i/b076546b7637b69197814217201ea288) 为骨架,系统梳理"遇到 X 问题该用哪个 Rust 模式"的决策路径、Trait Bound 速查表、生命周期

gitblog_01038的博客 199

AI 加 Rust:一个月的学习数据复盘,看进步曲线和下一阶段目标

7 月,一个自学编程的人,靠着 Rust + AI 的基本组合,在一个月里做出了一个能用的 AI CLI 工具、写了 30 篇博客、积累了 47 条踩坑笔记。这个成绩放到半年前我自己都不会信——那时候我还在背"什么是 HTTP 协议"。7 月之前,我是"在学习 Rust"。7 月之后,我是"用 Rust 做事"。从学习到做事,这个心理身份的转换,才是这一个月最重要的变化。进步是阶梯式的,不是线性的。在低效期不要慌——你可能正在为下一个飞跃打基础。"+ AI + Rust"不是妥协,是优势组合。

no1coder的博客 4734

Rust for C Programmers 开篇:C 开发者为什么要学 Rust——性能、内存安全与类型系统的全面对比

> **导读**:本文是 RustTraining 仓库中《Rust for C# Programmers》训练课程的第一章(对应 [csharp-book/src/ch01-introduction-and-motivation.md](https://link.gitcode.com/i/52113490a41f4809f02df27ba59fcc58))。课程面向具备 C#/.NET 经验的

gitblog_00052的博客 636
上一篇: 为什么Rust的类型系统能杜绝空指针?深入剖析Option与Result类型
下一篇: Rust线程安全揭秘:如何用所有权系统避免数据竞争?
BytePerch
博客等级 码龄1年 164粉丝 1971原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值