Rust异步流处理实战:async-stream深度解析

用Rust构建大模型推理引擎:从GGUF加载到OpenAI兼容API 大模型本地推理是AI工程落地的关键环节,而推理引擎的性能与可维护性直接影响部署成本和用户体验。Rust凭借内存安全、零成本抽象和强大的并发能力,正成为构建新一代推理引擎的热门选择。本文从推理引擎的核心概念出发,解析GGUF模型格式、量化加载、KV Cache、采样器等关键技术原理,并对比llama.cpp的实现思路,阐述Rust在构建高并发、可嵌入的本地推理服务中的独特优势。内容涵盖架构设计、最小实现骨架、OpenAI兼容接口与服务化部署,并结合批量任务和性能调优实践,帮助工程师在私有化场景下快速搭建稳定的 阅读详情

Rust异步流处理实战:async-stream深度解析

引言

在Rust异步编程中,流(Stream)是处理连续数据序列的核心概念。作为一名从Python转向Rust的后端开发者,我深刻体会到Rust在异步流处理方面的优势。async-stream库提供了简洁的语法来创建和处理异步数据流,是Rust异步编程的重要工具。

异步流核心概念

什么是Stream

Stream是异步版本的Iterator,具有以下特点:

  • 异步迭代:每次获取下一个元素可能需要等待
  • 惰性求值:只在需要时才产生数据
  • 组合性:支持多种操作符组合
  • 背压支持:通过poll机制实现流量控制

架构设计

┌─────────────────────────────────────────────────────────────┐
│                     Async Stream                           │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  数据源 → 流处理 → 过滤器 → 映射 → 收集器         │   │
│  │     ↓         ↓         ↓        ↓        ↓       │   │
│  │  生成    异步迭代   条件过滤   数据转换   结果收集 │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

环境搭建与基础配置

添加依赖

[dependencies]
async-stream = "0.3"
futures = "0.3"
tokio = { version = "1", features = ["full"] }

基本使用

use async_stream::stream;
use futures::StreamExt;

#[tokio::main]
async fn main() {
    let mut stream = stream! {
        yield 1;
        yield 2;
        yield 3;
    };

    while let Some(value) = stream.next().await {
        println!("Received: {}", value);
    }
}

异步生成器

use async_stream::stream;
use futures::StreamExt;
use std::time::Duration;

#[tokio::main]
async fn main() {
    let mut stream = stream! {
        for i in 0..5 {
            tokio::time::sleep(Duration::from_millis(100)).await;
            yield i;
        }
    };

    while let Some(value) = stream.next().await {
        println!("Received: {}", value);
    }
}

高级特性实战

流组合

use async_stream::stream;
use futures::StreamExt;

#[tokio::main]
async fn main() {
    let stream1 = stream! {
        yield 1;
        yield 2;
    };

    let stream2 = stream! {
        yield 3;
        yield 4;
    };

    let combined = stream1.chain(stream2);

    combined.for_each(|value| async move {
        println!("Combined: {}", value);
    }).await;
}

流过滤

use async_stream::stream;
use futures::StreamExt;

#[tokio::main]
async fn main() {
    let mut stream = stream! {
        yield 1;
        yield 2;
        yield 3;
        yield 4;
        yield 5;
    };

    let filtered = stream.filter(|&x| x % 2 == 0);

    filtered.for_each(|value| async move {
        println!("Filtered: {}", value);
    }).await;
}

流映射

use async_stream::stream;
use futures::StreamExt;

#[tokio::main]
async fn main() {
    let mut stream = stream! {
        yield 1;
        yield 2;
        yield 3;
    };

    let mapped = stream.map(|x| x * 2);

    mapped.for_each(|value| async move {
        println!("Mapped: {}", value);
    }).await;
}

实际业务场景

场景一:实时数据处理

use async_stream::stream;
use futures::StreamExt;
use std::time::Duration;

async fn generate_data() -> impl futures::Stream<Item = i32> {
    stream! {
        let mut counter = 0;
        loop {
            tokio::time::sleep(Duration::from_secs(1)).await;
            counter += 1;
            yield counter;
        }
    }
}

#[tokio::main]
async fn main() {
    let stream = generate_data();

    stream.for_each(|value| async move {
        println!("Real-time data: {}", value);
    }).await;
}

场景二:API响应流

use async_stream::stream;
use futures::StreamExt;

async fn fetch_pages() -> impl futures::Stream<Item = String> {
    stream! {
        for page in 1..=5 {
            let data = fetch_page(page).await;
            yield data;
        }
    }
}

async fn fetch_page(page: u32) -> String {
    format!("Page {} data", page)
}

#[tokio::main]
async fn main() {
    let stream = fetch_pages();

    stream.for_each(|page| async move {
        println!("Fetched: {}", page);
    }).await;
}

场景三:日志流处理

use async_stream::stream;
use futures::StreamExt;
use std::time::Duration;

#[derive(Debug)]
struct LogEntry {
    level: String,
    message: String,
}

async fn log_stream() -> impl futures::Stream<Item = LogEntry> {
    stream! {
        yield LogEntry {
            level: "INFO".to_string(),
            message: "Application started".to_string(),
        };
        
        tokio::time::sleep(Duration::from_millis(500)).await;
        
        yield LogEntry {
            level: "WARN".to_string(),
            message: "High memory usage".to_string(),
        };
    }
}

#[tokio::main]
async fn main() {
    let stream = log_stream();

    stream.for_each(|log| async move {
        println!("[{}] {}", log.level, log.message);
    }).await;
}

性能优化

流缓冲

use async_stream::stream;
use futures::StreamExt;

#[tokio::main]
async fn main() {
    let stream = stream! {
        for i in 0..10 {
            yield i;
        }
    };

    let buffered = stream.buffer_unordered(3);

    buffered.for_each(|value| async move {
        println!("Buffered: {}", value);
    }).await;
}

流合并

use async_stream::stream;
use futures::{StreamExt, select};
use std::time::Duration;

#[tokio::main]
async fn main() {
    let stream1 = stream! {
        tokio::time::sleep(Duration::from_millis(100)).await;
        yield "Stream 1";
    };

    let stream2 = stream! {
        tokio::time::sleep(Duration::from_millis(50)).await;
        yield "Stream 2";
    };

    futures::pin_mut!(stream1, stream2);

    loop {
        select! {
            value = stream1.next() => {
                if let Some(v) = value {
                    println!("Got: {}", v);
                } else {
                    break;
                }
            }
            value = stream2.next() => {
                if let Some(v) = value {
                    println!("Got: {}", v);
                } else {
                    break;
                }
            }
        }
    }
}

总结

async-stream为Rust开发者提供了简洁的异步流处理能力。通过yield语法,可以轻松创建异步数据流。从Python开发者的角度来看,Rust的Stream概念类似于Python的async_generator,但具有更好的类型安全和性能。

在实际项目中,建议合理使用流操作符来组合和处理数据,并注意背压控制以避免内存溢出。

Codex兼容API接入Ollama本地大模型实战指南 Codex API是OpenAI定义的代码生成标准接口,其核心原理在于结构化消息交互、流式响应与函数调用支持;技术价值体现在低延迟、上下文可控及敏感代码不出域,为金融、政企等强合规场景提供安全可审计的AI编程底座;典型应用场景包括VS Code离线补全、CI/CD嵌入式代码检查及多模型热切换开发工作流。本文聚焦Ollama作为轻量本地模型运行时,结合FastAPI封装Codex兼容层,解决国内镜像源配置、Node.js流式通信兼容、Metal/Vulkan硬件加速启用等工程落地关键问题。 阅读详情

相关推荐

AI Agent框架选型实战:LangChain、AutoGen与LlamaIndex生产级对比

AI Agent并非抽象概念,而是嵌入工业质检、金融风控等真实场景的可部署系统。其核心在于将大语言模型(LLM)与工具调用、记忆管理、流式响应、安全沙箱等能力可靠集成。框架选型本质是权衡控制力、可观测性与长期演进成本:LangChain以函数式编排降低原型门槛但调试墙高;AutoGen通过角色驱动消息总线提升协作可解释性;LlamaIndex则聚焦RAG垂直场景,在文档检索精度与性能上建立优势。真实压测显示,错误传播率、P99延迟与内存驻留峰值等硬指标差异远超文档描述——这些决定能否‘敢上生产’的关键细节,

weixin_30653023的博客 519

基于Rust与CUDA构建高性能大模型推理引擎:从原理到实践

在深度学习推理部署领域,性能优化与系统稳定性是核心诉求。CUDA作为NVIDIA GPU的并行计算平台,通过其丰富的生态库(如cuBLAS、cuDNN)为模型计算提供了接近硬件的极致加速能力,是处理大规模张量运算的事实标准。其技术价值在于能够充分发挥Tensor Core等专用硬件特性,显著提升推理吞吐量,适用于需要低延迟、高并发的在线服务场景。与此同时,现代系统编程语言Rust凭借其编译期内存安全保证、零成本抽象和无畏并发等特性,为构建高可靠推理服务提供了坚实基础,有效避免了传统C++方案中常见的内存错误

cunfuxiao7305的博客 957

大模型网关与CLI接入实战:OpenAI/Anthropic协议兼容方案

大模型网关是统一调度多厂商LLM服务的核心中间件,其本质是应用层协议感知的翻译器与策略引擎,而非简单反向代理。它通过动态重写请求体结构、智能映射认证头、流式SSE事件标准化等机制,解决OpenAI与Anthropic等主流API在messages语义、system字段位置、鉴权方式及响应格式上的深层不兼容问题。技术价值在于实现CLI工具‘零改造’接入——如codex-cli、zcode-cli可共存于同一网关下,仅需切换base_url与api_key即可调用不同后端模型。典型应用场景包括企业私有化AI中台

weixin_29061041的博客 293

async-stream:Rust异步流编程的终极指南与快速入门

**async-stream** 是 Rust 生态中一款强大的异步流处理库,它让开发者能够使用直观的 `async & await` 语法创建和操作异步流,极大简化了异步数据序列的处理逻辑。无论是处理网络连接、文件流还是实时数据,async-stream 都能提供简洁高效的解决方案,帮助开发者轻松构建响应式应用。 ## 🚀 为什么选择 async-stream?异步流编程的核心优势 在 R

gitblog_00474的博客 1038

自动驾驶仿真:基于Carsim开发的加速度请求模型

1、自动驾驶行业中,算法端对于纵向控制的功能预留接口基本都是加速度,我们需要给控制器仿真加速度的信号,控制器才会实现对纵向功能的控制。2、Carsim或者其他动力学软件,主要提供者节气门开度和主缸压力进行控制。我们在进行联合仿真时,往往都要通过PID的方式将请求加速度转换成对应的节气门开度与主缸压力传给动力学软件进行闭环控制。

zataji的博客 6919

SAP PP CSAP_MAT_BOM_MAINTAIN ECN 增加组件

SAP PP CSAP_MAT_BOM_MAINTAIN ECN 增加组件。

GAVIN 412

async-stream核心原理深度解析:从yield到Stream的魔法实现

你是否曾经想过,在Rust的异步编程中,如何像使用生成器一样优雅地创建流?今天,我将为你深入解析**async-stream**这个强大的异步流库的核心原理。通过本文,你将理解从简单的`yield`关键字到完整的`Stream`实现的魔法转换过程!🚀 ## 什么是async-stream? **async-stream**是一个Rust库,它允许你使用`async`和`await`语法来创建

gitblog_00596的博客 824

窥秘Windows 10:SAM密码破解

Windows 10作为广受欢迎的操作系统,拥有一套强大的安全措施来保护用户账号和数据安全。然而,有时候我们需要了解更多关于密码破解的知识,以加强我们的防护措施。本文将深入探讨如何突破Windows 10的SAM密码,以便更好地了解密码安全性并加强系统的保护。

Sgirll的博客 6846

Rust pcap与tokio集成:异步网络数据包处理新方案

在网络开发领域,高效处理数据包是构建高性能应用的关键。Rust语言的pcap库结合tokio异步运行时,为开发者提供了一套强大的异步网络数据包处理解决方案,让网络监控、分析和处理变得更加高效和灵活。 ## 为什么选择Rust pcap与tokio集成? Rust pcap库是一个功能全面的网络数据包捕获工具,而tokio则是Rust生态中最流行的异步运行时之一。将两者结合,能够充分发挥Rust

gitblog_00633的博客 315

切比雪夫插值

切比雪夫插值是一种基于切比雪夫节点的多项式插值方法,其优势是减少插值误差(特别是龙格现象:表现为高维插值时在边缘处插值误差骤增)。本文对其基本操作进行说明。

平和少年的博客 1648

期货套利策略(二)

接上一篇期货套利策略,随着对期货套利策略的深入了解,我发现套利策略不是那么好做的。下面将会讲碰到的一些问题。 上一篇文章中没有考虑滑点的问题,这里我们把滑点问题考虑进去。这里先说一些天勤api的买入点,天琴的买入点是当前K线的收盘价。碰到数据传输问题,还有计算等各方面问题,实际情况是无法在当前K线的收盘价买入的。这里我们把这方面问题考虑进去,利用api.wait_update()调到下一个k线数据...

qq_31611005的博客 1714

Rust智能体框架深度实战:Rig的架构哲学与性能优化最佳实践

在当今AI应用开发领域,Rust语言凭借其卓越的内存安全性和零成本抽象特性,正成为构建高性能智能体系统的首选。Rig框架作为基于Rust的模块化LLM应用构建工具,为开发者提供了从简单聊天机器人到复杂多智能体系统的完整解决方案。本文将深入探讨Rig的架构设计哲学、性能优化策略以及在实际生产环境中的最佳实践。 ## 架构设计哲学:模块化与可扩展性的平衡 Rig框架的核心设计理念围绕着**模块化架

gitblog_01190的博客 362

河洛理数【陈抟】每月月卦推演每日运卦

Step2:每卦中的日爻遇到二十四节气中的当日为节(月初)或气(月中)的时候,所代表的日期需要变更。正常来说,屯卦分别代表初一到初六,但是由于当月初二时立秋节,所以初爻就不能作为初一、而是要作为立秋节开始时(文中还精算到了立秋是从初二的午时开始),如下。说的代表月运的基础卦上进行当月日卦的推演方式。老样子,我们还是按照书中举得例子卦在这边进行一步步的推演,最后做总结。Step1:从月卦爻下一爻开始,自下而上,进行五个爻的爻变,新推演的每个卦代表六天,如下。假设当月月卦是即济卦,月爻在二爻,如图所示(

Daniel专栏 764

Oh My Zsh 主题选型与终端美化完整指南

Oh My Zsh 是一个社区驱动的 Zsh 配置框架,自带 140+ 主题和 300+ 插件。改一行 `ZSH_THEME` 配置,就能彻底改变终端的外观与信息密度。本文帮你按真实使用维度快速选到合适的主题,并完成终端美化落地。 ## 快速上手:3 步完成安装与切换 1. **获取框架**:克隆仓库到主目录 ```bash git clone https://gitcode.co

gitblog_00548的博客 326

SAP_ABAP_MM_BAPI清单案例教程——采购发票校验/预制_BAPI_INCOMINGINVOICE_PARK_MIRO

SAP ABAP BAPI_INCOMINGINVOICE_PARK BAPI 采购发票预制 采购发票校验 代码模版

java_zhong1990的专栏 1966

【Android调试】高通adb识别不到设备的完整排查指南:从驱动到端口一步到位

本文系统梳理高通(Qualcomm)平台Android设备adb无法识别的完整排查流程。从最基础的USB连接检查开始,到Windows设备管理器中驱动状态的判断、高通USB驱动的正确安装与更新方法,再到adb端口被占用、USB调试未开启、驱动签名校验失败等高频场景的解决方案。每一步均配截图和操作命令,文末附常见报错速查表,适合做系统开发、刷机调试或者Android Framework bringup时遇到adb不通的工程师快速定位。

weixin_44081096的博客 286

Rust+CUDA推理引擎bw24:挑战llama.cpp的极致GPU性能优化

大语言模型推理引擎是部署已训练模型的核心软件框架,其核心原理在于高效加载模型权重并执行前向传播计算。通过优化计算图调度和内存管理,推理引擎能显著提升硬件利用率,其技术价值在于降低部署门槛并提升服务响应速度。在应用场景上,推理引擎广泛应用于AI助手、代码生成和实时对话系统。本文聚焦于新兴的bw24项目,它采用Rust+CUDA技术栈,针对NVIDIA GPU进行深度优化,特别在网络热词NVFP4等新型低精度格式上进行了底层适配,旨在为追求极致推理性能的开发者提供现代化、高性能的替代方案。

weixin_30527423的博客 434

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

LiteLLM Messages Interceptors 深度解析:在 Anthropic /v1/messages 路径实现短路拦截与 Advisor 编排

**导读**:LiteLLM 在 Anthropic Messages 兼容入口(`/v1/messages`)内置了一套名为 Messages Interceptors 的短路过载机制——它们在后端真实调用之前执行,并可用自研逻辑**完全替换**原有的后端调用。本指南以 [interceptors/README.md](https://link.gitcode.com/i/1f925f9da56

gitblog_00717的博客 742

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

编程语言如何塑造开发者思维:从范式到架构的深度解析

编程范式是指导软件开发的根本方法论,它定义了解决问题的基本世界观。面向对象编程以对象为核心构建系统模型,函数式编程强调纯函数与不可变数据,而过程式编程则关注线性步骤控制。这些范式不仅影响代码组织方式,更深刻塑造了开发者的思维路径。从技术价值看,理解不同范式能帮助开发者选择最适合问题域的工具,避免思维定式,提升代码的适应性与可维护性。在实际应用场景中,Java的严格类型系统培养了严谨的接口设计思维,Python的灵活语法鼓励快速原型开发,而函数式思维在处理并发与数据管道时展现出独特优势。本文通过具体代码对比,

weixin_33895516的博客 388

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

GitHub热点项目实操诊断:避坑指南与协议兼容性解析

GitHub热点项目并非单纯流量现象,而是AI边缘化、开发体验安全化与网络协议演进(如QUIC全面启用)三重技术趋势的具象体现。理解其底层原理——如HTTP/3握手失败导致的‘github打不开’、SSH替代HTTPS的降级策略、以及离线优先LLM工具对CPU推理栈的依赖——是实现稳定访问与高效复现的关键。本文聚焦真实工程场景中的典型障碍:环境依赖陷阱(如libusb缺失)、协议兼容问题(QUIC中间设备丢包)、配置错位(TLS版本不匹配)及密钥管理漏洞,提供可验证的绕过方案与诊断框架,助力开发者从被动跟风

weixin_30715523的博客 326

Rocket 响应机制完全指南:Responder 特质、内建响应器与类型安全 URI

本指南基于 Rocket(Rust 的 Web 框架)官方指南《Responses》一章展开,系统讲解 `Responder` 特质的工作方式、内置响应器的使用与组合、自定义响应器的派生方法,以及 `uri!` 类型安全 URI 宏的完整用法。读完本文,你将掌握从返回普通字符串到实现实时 SSE 流、WebSocket、JSON 序列化与模板渲染的完整响应开发技能,并能借助 `uri!` 在编译期

gitblog_00981的博客 360

Claude Opus 4.7 + TopRouter:开箱即用的高可靠AI推理实践指南

大语言模型推理能力正从‘能用’迈向‘敢用’的关键阶段。Claude Opus 4.7 代表当前长程推理与工程化代码生成的前沿水平,其核心价值在于稳定性提升、上下文耐受增强及对现代开发栈(如Poetry、GitHub Actions、Kubernetes Operator)的原生理解。TopRouter 并非简单API代理,而是封装了重试熔断、智能分片、流式解析与上下文管理的企业级推理网关,显著降低AI集成中的胶水代码成本与运维风险。本文聚焦Python开发者真实落地场景,覆盖环境配置避坑、超长文档处理、生产

weixin_30698297的博客 406

Part 2: Models(模型)做好软件测试你要学习这些

本文介绍了LangChain支持的多种模型类型及其特点。主要内容包括: 模型类型概览 分为基础语言模型(BaseLanguageModel)及其子类:传统语言模型(LLM)、聊天模型(ChatModel)和嵌入模型(Embeddings) 推荐优先使用Chat Models而非传统LLMs Chat Models详解 通过不同角色消息(System/Human/AI)与LLM交互 详细参数说明:模型名称、温度、最大token数等 调用方法: invoke:同步单次调用 batch:同步批量调用 stream

lw的博客 718

编程语言如何影响开发者生产力与设计思维

编程语言不仅是语法工具,更是塑造开发者认知模式、设计决策和工程效率的核心载体。其抽象层级、语法噪音、类型系统与工具链协同能力,共同决定了代码的可读性、可维护性与错误发现时机。例如,C#的async/await降低异步心智负担,F#的模式匹配强化状态建模严谨性,Rust的所有权机制在编译期拦截内存隐患——这些并非炫技,而是对‘人机协作效率’的底层优化。在微服务、实时处理、数据科学等多元场景中,语言选型实为问题域测绘:用最贴合语义表达与运行约束的工具,减少无谓摩擦。老赵点滴的实践启示正在于此:回归语言本质,方能

dejz8829的专栏 318

03 大模型核心开发框架

如果是java选手,学习过langchain4j,上手这部分内容应该很快。先详细看看课程目标建立对 LangChain 的整体认识,知道它是什么、解决什么问题、在 AI 应用开发里处于什么位置。理解 LangChain 在 1.x 时代的产品边界、包结构、版本演进,以及它与LangGraph、LangSmith、Deep Agents 的关系。建立对 Model I/O、Chains、Memory、Retrieval、Tools/Agents、Callbacks 这六类教学视角的整体认知。

Misnearch的博客 398

组网第63课:安全域划分——Trust/Untrust/DMZ、区域模型、与 VLAN 的关系

一组接口 + 一组策略 + 一条默认拒绝。一组接口:这个域包含哪些物理口、VLAN、子接口;一组策略:这个域到别的域放行什么、拒绝什么;一条默认拒绝:没写进策略的,一律不通。第三条最关键。没有默认拒绝,前面划的域全是装饰。

qq_36765170的博客 572
上一篇: Rust并发编程实战:Crossbeam Channel深度解析
下一篇: Rust序列化实战:Serde深度解析
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值