WebAssembly 跨语言互操作:Rust 与 Python 的 Wasm 桥接实践

Rust入门基础 Rust是一种通用的编程语言,它可以让每个人编写可靠且高效的软件。Rust可以用来替换C/C++,Rust和它们具有同样的性能,但是很多常见的bug在编译时就可以被消灭。Rust能够保证内存安全(无需GC),并且易于维护、调试,代码既安全又高效。 阅读详情

WebAssembly 跨语言互操作:Rust 与 Python 的 Wasm 桥接实践

cover

一、跨语言协作的工程困境:为什么 FFI 不是最优解

数据科学团队用 Python 训练模型,后端团队用 Rust 构建服务——两个团队需要共享推理逻辑。传统方案是 FFI(Foreign Function Interface):Python 通过 ctypes/cffi 调用 Rust 编译的动态链接库。但 FFI 有三个痛点:跨平台编译复杂(Linux/macOS/Windows 各需一个 .so/.dylib/.dll)、ABI 不稳定(编译器版本或调用约定变化导致崩溃)、部署依赖多(目标机器需要安装正确的 glibc 版本)。WebAssembly 提供了一种更安全的跨语言互操作方案:Rust 编译为 .wasm,Python 通过 WASM 运行时加载执行,无需编译原生库,无需担心 ABI 兼容性。

graph TB
    A[Rust 推理逻辑] --> B{编译目标}
    B --> C[原生动态库 .so/.dylib/.dll<br/>FFI 方案]
    B --> D[WASM 模块 .wasm<br/>桥接方案]

    C --> E[Python ctypes 调用]
    E --> F[问题: ABI 不稳定<br/>跨平台编译复杂<br/>内存安全无保障]

    D --> G[Python wasmtime-py 加载]
    G --> H[优势: 平台无关<br/>沙箱隔离<br/>内存安全由 WASM 保证]

    H --> I[统一接口:<br/>输入 JSON → WASM → 输出 JSON]

二、Rust-Python WASM 桥接的底层机制

2.1 数据传递:共享内存 vs 拷贝

WASM 模块与宿主(Python)之间的数据传递有两种方式:通过 WASM 线性内存共享(零拷贝但需要手动管理偏移量),或通过函数参数/返回值传递(自动序列化但有拷贝开销)。对于推理场景,推荐使用共享内存传递大型张量,使用函数参数传递小型控制信息。

sequenceDiagram
    participant P as Python 宿主
    participant W as WASM 模块

    P->>W: 分配线性内存 (memory.grow)
    P->>W: 写入输入数据到内存偏移 0
    P->>W: 调用 infer(ptr=0, len=1024)
    W->>W: 从偏移 0 读取输入
    W->>W: 执行推理
    W->>W: 写入结果到内存偏移 1024
    W-->>P: 返回结果偏移 1024
    P->>W: 从偏移 1024 读取输出数据
    P->>W: 释放内存 (可选)

2.2 wasm-bindgen 与接口定义

wasm-bindgen 为 Rust 和 JavaScript 生成桥接代码,但不直接支持 Python。对于 Python 桥接,需要手动定义 WASM 导出函数接口,使用简单的 C 风格参数(整数、浮点数、内存指针),避免复杂的类型转换。

2.3 序列化策略:JSON vs 二进制

JSON 序列化开发简单但性能差(字符串解析开销),二进制序列化(如 MessagePack、bincode)性能好但需要两端共享 schema。推荐策略:控制信息用 JSON,张量数据用二进制共享内存。

三、生产级代码实现与最佳实践

3.1 Rust 侧 WASM 模块

use serde::{Deserialize, Serialize};

/// 推理请求(JSON 序列化)
#[derive(Serialize, Deserialize)]
pub struct InferRequest {
    pub model_name: String,
    pub input_shape: Vec<usize>,
    pub threshold: f32,
}

/// 推理响应(JSON 序列化)
#[derive(Serialize, Deserialize)]
pub struct InferResponse {
    pub output_shape: Vec<usize>,
    pub predictions: Vec<Prediction>,
    pub latency_us: u64,
}

#[derive(Serialize, Deserialize)]
pub struct Prediction {
    pub label: String,
    pub score: f32,
}

/// 全局推理引擎状态
static mut ENGINE: Option<InferenceEngine> = None;

struct InferenceEngine {
    models: std::collections::HashMap<String, Vec<u8>>,
}

#[no_mangle]
pub extern "C" fn init_engine() -> usize {
    unsafe {
        ENGINE = Some(InferenceEngine {
            models: std::collections::HashMap::new(),
        });
        0 // 返回码: 0 = 成功
    }
}

/// 加载模型到引擎
/// model_json_ptr: 模型配置 JSON 字符串在内存中的偏移
/// model_json_len: JSON 字符串长度
/// model_data_ptr: 模型二进制数据在内存中的偏移
/// model_data_len: 模型数据长度
#[no_mangle]
pub extern "C" fn load_model(
    model_json_ptr: *const u8,
    model_json_len: usize,
    model_data_ptr: *const u8,
    model_data_len: usize,
) -> usize {
    unsafe {
        if let Some(ref mut engine) = ENGINE {
            // 从 WASM 线性内存读取 JSON 配置
            let json_slice = std::slice::from_raw_parts(model_json_ptr, model_json_len);
            let config: InferRequest = match serde_json::from_slice(json_slice) {
                Ok(c) => c,
                Err(_) => return 1, // 解析失败
            };

            // 从 WASM 线性内存读取模型数据
            let model_data = std::slice::from_raw_parts(model_data_ptr, model_data_len).to_vec();
            engine.models.insert(config.model_name, model_data);
            0 // 成功
        } else {
            2 // 引擎未初始化
        }
    }
}

/// 执行推理
/// input_ptr: 输入张量数据在内存中的偏移
/// input_len: 输入数据长度
/// output_ptr: 输出缓冲区在内存中的偏移(由宿主预分配)
/// output_max_len: 输出缓冲区最大长度
/// 返回: 实际写入的字节数(0 表示失败)
#[no_mangle]
pub extern "C" fn infer(
    input_ptr: *const u8,
    input_len: usize,
    output_ptr: *mut u8,
    output_max_len: usize,
) -> usize {
    let start = std::time::Instant::now();

    unsafe {
        if let Some(ref engine) = ENGINE {
            // 读取输入 JSON
            let input_slice = std::slice::from_raw_parts(input_ptr, input_len);
            let request: InferRequest = match serde_json::from_slice(input_slice) {
                Ok(r) => r,
                Err(_) => return 0,
            };

            // 执行推理(简化示意)
            let response = InferResponse {
                output_shape: request.input_shape.clone(),
                predictions: vec![Prediction {
                    label: "positive".to_string(),
                    score: 0.95,
                }],
                latency_us: start.elapsed().as_micros() as u64,
            };

            // 序列化输出到缓冲区
            let output_bytes = match serde_json::to_vec(&response) {
                Ok(b) => b,
                Err(_) => return 0,
            };

            if output_bytes.len() > output_max_len {
                return 0; // 缓冲区不足
            }

            let output_slice = std::slice::from_raw_parts_mut(output_ptr, output_max_len);
            output_slice[..output_bytes.len()].copy_from_slice(&output_bytes);
            output_bytes.len()
        } else {
            0
        }
    }
}

/// 分配 WASM 线性内存(供宿主调用)
#[no_mangle]
pub extern "C" fn alloc(size: usize) -> *mut u8 {
    let mut buf = Vec::with_capacity(size);
    let ptr = buf.as_mut_ptr();
    std::mem::forget(buf); // 防止 Rust 释放内存
    ptr
}

/// 释放 WASM 线性内存
#[no_mangle]
pub extern "C" fn dealloc(ptr: *mut u8, size: usize) {
    unsafe {
        let _ = Vec::from_raw_parts(ptr, 0, size);
    }
}

3.2 Python 侧宿主运行时

"""Python WASM 推理宿主"""
import json
from wasmtime import Engine, Store, Module, Linker, WasiConfig, Memory

class WasmInferenceBridge:
    """Rust-Python WASM 推理桥接"""

    def __init__(self, wasm_path: str):
        self.engine = Engine()
        self.store = Store(self.engine)

        # 配置 WASI
        wasi_config = WasiConfig()
        self.store.set_wasi(wasi_config)

        # 加载 WASM 模块
        self.module = Module.from_file(self.engine, wasm_path)
        self.linker = Linker(self.engine)
        self.linker.define_wasi()

        # 实例化
        self.instance = self.linker.instantiate(self.store, self.module)

        # 获取导出函数
        self._init = self.instance.exports(self.store)["init_engine"]
        self._load_model = self.instance.exports(self.store)["load_model"]
        self._infer = self.instance.exports(self.store)["infer"]
        self._alloc = self.instance.exports(self.store)["alloc"]
        self._dealloc = self.instance.exports(self.store)["dealloc"]
        self._memory = self.instance.exports(self.store)["memory"]

        # 初始化引擎
        self._init(self.store)

    def load_model(self, model_name: str, model_data: bytes):
        """加载模型到 WASM 引擎"""
        config = json.dumps({"model_name": model_name, "input_shape": [], "threshold": 0.5}).encode()

        # 在 WASM 内存中分配空间
        config_ptr = self._alloc(self.store, len(config))
        model_ptr = self._alloc(self.store, len(model_data))

        # 写入数据到 WASM 线性内存
        memory_data = self._memory.data_ptr(self.store)
        for i, byte in enumerate(config):
            memory_data[config_ptr + i] = byte
        for i, byte in enumerate(model_data):
            memory_data[model_ptr + i] = byte

        # 调用加载函数
        result = self._load_model(
            self.store, config_ptr, len(config), model_ptr, len(model_data)
        )

        # 释放临时内存
        self._dealloc(self.store, config_ptr, len(config))

        if result != 0:
            raise RuntimeError(f"模型加载失败: 错误码 {result}")

    def infer(self, request: dict) -> dict:
        """执行推理"""
        input_json = json.dumps(request).encode()

        # 分配输入缓冲区
        input_ptr = self._alloc(self.store, len(input_json))
        output_ptr = self._alloc(self.store, 65536)  # 64KB 输出缓冲区

        # 写入输入数据
        memory_data = self._memory.data_ptr(self.store)
        for i, byte in enumerate(input_json):
            memory_data[input_ptr + i] = byte

        # 调用推理函数
        output_len = self._infer(
            self.store, input_ptr, len(input_json), output_ptr, 65536
        )

        if output_len == 0:
            raise RuntimeError("推理执行失败")

        # 读取输出数据
        output_bytes = bytes(
            memory_data[output_ptr + i] for i in range(output_len)
        )

        # 释放内存
        self._dealloc(self.store, input_ptr, len(input_json))
        self._dealloc(self.store, output_ptr, 65536)

        return json.loads(output_bytes.decode())


# 使用示例
if __name__ == "__main__":
    bridge = WasmInferenceBridge("target/wasm32-wasi/release/inference.wasm")

    # 加载模型
    with open("model.onnx", "rb") as f:
        bridge.load_model("sentiment", f.read())

    # 执行推理
    result = bridge.infer({
        "model_name": "sentiment",
        "input_shape": [1, 128],
        "threshold": 0.5
    })
    print(f"推理结果: {result}")

3.3 构建与部署

# Cargo.toml
[package]
name = "wasm-inference"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"

[profile.release]
opt-level = "z"
lto = true
strip = true
# 编译为 WASI 目标
rustup target add wasm32-wasi
cargo build --target wasm32-wasi --release

# Python 侧安装依赖
pip install wasmtime

# 运行
python bridge.py

四、WASM 跨语言桥接的架构权衡

4.1 WASM 桥接 vs FFI vs gRPC

维度FFI (ctypes)WASM 桥接gRPC
跨平台差(需编译多平台 .so)优(一个 .wasm 全平台)优(协议无关)
安全性差(段错误风险)优(沙箱隔离)优(进程隔离)
性能最优(直接调用)中(约 10-20% 开销)低(网络 + 序列化)
部署复杂度高(依赖 glibc)低(单文件)中(需要服务端)
调试难度高(段错误难定位)中(WASM trap 有栈追踪)低(HTTP 可观测)

4.2 数据传递的性能瓶颈

JSON 序列化/反序列化是主要性能瓶颈。对于大型张量(如 224×224×3 的图像),JSON 编码后体积膨胀 3-4 倍,解析耗时可能超过推理本身。优化方案:张量数据通过共享内存直接传递,控制信息用 JSON。

4.3 适用边界与禁用场景

适用场景:

  • Python 调用 Rust 的高性能计算逻辑
  • 需要跨平台部署的推理服务
  • 多语言团队协作的共享组件

禁用场景:

  • 极低延迟场景(FFI 直接调用更快)
  • 需要操作系统原生 API 的场景(WASI 接口有限)
  • 大规模张量数据传递(共享内存管理复杂,不如 gRPC 流式传输)

五、总结

WASM 跨语言桥接的核心价值是"一次编译,到处运行"——Rust 编译为 .wasm 后,Python、Node.js、Go 等任何支持 WASM 运行时的语言都可以调用,无需为每个平台编译原生库。安全性是额外收益:WASM 沙箱隔离避免了 FFI 的段错误风险。但性能开销(约 10-20%)和数据传递瓶颈(JSON 序列化)是实际限制。对于推理场景,推荐混合策略:控制信息用 JSON 序列化,张量数据用共享内存零拷贝传递。WASM 桥接不是 FFI 的替代品,而是跨平台、安全优先场景下的更优选择。

WebAssembly 针对各种语言如何生成wasm 阅读详情

相关推荐

rust教程 第一章 —— 初识rust

本文主要的目的就是认识一下rust这门语言的基本概念

余识- 5万+

Rust语言

Rust 是一门系统级别的编程语言。Rust 由 Graydon Hoare 开发并在被 Mozilla 实验室收购后发扬光大。

m0_72572822的博客 8827

攻克TypeError: Cannot read properties of undefined (reading ‘NormalModule‘)的四种实战策略

本文详细解析了`TypeError: Cannot read properties of undefined (reading 'NormalModule')`错误的四种实战解决策略。从版本一致性检查、包管理器优化到依赖替换和构建环境配置,帮助开发者快速定位和解决Webpack构建过程中的常见问题,提升开发效率。

weixin_42523670的博客 244

Rust编程语言入门教程(一)-什么是Rust

Rust编程语言入门教程(一) 什么是Rust rust 发展历史 应用环境 为什么选择Rust 新项目用Rust还是Go?

西京刀客 2万+

Linux:在使用UEFI固件的计算机上内核是如何被启动的

启动计算机通常不是一件难事:按下电源键,稍等片刻,你就能看到一个登录界面,再输入正确的密码,就可以开启一天的网上冲浪之旅了。但偶尔这件事没那么顺利,有时候迎接你的不是熟悉的登录界面,而是一个令人生畏的命令提示符界面,一闪一闪的提示符告诉你:“你碰到麻烦了”。于是你对着错误提示查找解决方法,按照网页上的步骤,你对着提示符输入并执行了几条你完全不理解的命令,计算机又能正常启动了,但同时你发现你那存有大学舍友糗照的硬盘分区被清空了。

imred的专栏 3069

带隙基准电路设计实战:从HSPICE仿真到Virtuoso版图全流程解析

在模拟集成电路设计中,基准电压源是确保系统精度与稳定性的核心模块。其基本原理在于巧妙结合具有正、负温度系数的电压,通过加权求和实现近似零温度系数的稳定输出,这一特性对于高精度数据转换器、电源管理芯片等至关重要。从工程实践角度,利用HSPICE进行深入的直流工作点、温度扫描和工艺角仿真,是验证电路性能、优化温度系数和电源抑制比的关键步骤。而借助Cadence Virtuoso进行版图实现时,必须重点关注电阻与BJT的匹配布局、敏感节点的保护以及电源完整性设计,以确保设计意图在硅片上得以准确呈现。通过完整的从前

weixin_29181861的博客 289

WebAssembly前沿技术与跨语言互操作:打破语言边界的实践指南

WebAssembly的跨语言互操作正在从实验走向实用。Rust和JavaScript的互操作已经成熟,组件模型为更广泛的语言组合提供了标准化的路径。但GC语言的互操作、调试工具和版本兼容性仍然是待解决的挑战。我的建议是:从Rust+JavaScript的双语言组合开始,这是最成熟的路径。等组件模型和WASI Preview2稳定后,再扩展到更多语言。跨语言互操作的价值在于"用最合适的语言做最合适的事",但前提是互操作的成本不能超过收益。

no1coder的博客 5110

ubuntu20.04安装Qt5.15.2并配置环境

qt官方取消了离线安装的方式,所以推荐在线安装,当然,如果想要自己通过源码编译也可以,参考官方文档:https://wiki.qt.io/Building_Qt_5_from_Git。 在线安装: 1.到官方网站下载:wget https://download.qt.io/official_releases/online_installers/qt-unified-linux-x64-online.run 2.修改文件权限:chmod 777 qt-unified-linux-x64-online.run

f120854632的博客 8808

WebAssembly 跨语言互操作:AI 推理引擎的编译与嵌入

WebAssembly 的跨语言互操作为 AI 推理引擎的部署提供了统一的中间格式:源语言编译为 WASM 字节码,任何支持 WASM 的运行时都可以直接执行。核心机制包括的双向桥接(Rust ↔ JavaScript)、宿主函数导入(WASM 调用宿主能力)、以及 Wasmer/Wasmtime 的嵌入运行时(Rust 宿主中执行 WASM 模块)。三个关键工程决策:模型权重外置避免 WASM 二进制膨胀、宿主函数导入实现 GPU 和网络等能力扩展、共享内存避免跨边界数据拷贝。

no1coder的博客 1054

AD9914数字斜坡模式使用

类似的,如果DRG输出处于负斜率斜坡中间,DRCTL引脚由逻辑0变为逻辑1,那么DRG会立即切换成正斜率参数,恢复在两个限值之间振荡输出。当两个非驻留位同时设置时,每次DRG输出达到编程设定的上限值或下限值后(假定DRG过输出使能位(0x01[13])已设置),DROVER信号会产生一个正脉冲(两个DDS时钟周期)。不过,在非驻留操作中,DRG输出不一定保持在上下限值。例如,设置数字斜坡非驻留高位,则当达到上限值时,DRG会自动(立即)跳到下限值(这一过程并非以斜坡方式返回下限值,而是直接跳至下限值)。

wangjie36的博客 3866

基于Simulink的六旋翼无人机动力分配仿真建模示例

六旋翼无人机概述特点:高冗余度、增强的负载能力和更好的故障容忍性。关键组件电机与螺旋桨:提供升力和推力。电调(ESC):控制电机转速。IMU(惯性测量单元):包括加速度计和陀螺仪,用于姿态估计。飞控板:处理传感器数据并生成控制信号。应用场景:航拍摄影、农业监测、物流配送等。仿真目标搭建一个简化的六旋翼无人机动力分配模型,涵盖电机驱动、姿态控制及位置控制过程。分析不同条件下的性能指标(如响应时间、稳定性等),并探讨六旋翼无人机的设计优化。

xiaoheshang_123的博客 485

AI 模型编译与跨语言互操作:WebAssembly 前沿技术解析

WebAssembly 为 AI 模型的跨平台部署提供了一种可移植的编译目标。通过 ONNX 中间表示和 WASM 后端,可以将训练好的模型编译为可在浏览器、服务器和边缘设备上运行的字节码。Rust + wasm-bindgen 的工具链使得推理模块的开发和导出相对便捷。但 WASM AI 编译的性能瓶颈是客观存在的——计算速度约为原生的 30%-40%,内存限制在 4GB 以内,跨语言调用有固定开销。在实际项目中,WASM AI 编译应定位为轻量级模型的跨平台部署方案,而非高性能推理的替代品。

no1coder的博客 1467

【如何利用扩展卡尔曼滤波解决跟踪毫米波雷达目标】

笛卡尔坐标系(非极坐标系):使用两个垂直的轴(通常是x轴和y轴)来确定一个点的位置。你沿着这两个轴移动确定的距离来找到这个点。极坐标系:使用一个角度和一个距离来确定一个点的位置。首先,你转到一个特定的方向(角度),然后沿着那个方向移动确定的距离来找到这个点。希望这个例子能帮助你理解两种坐标系的基本概念!

小秋 AI SLAM 入门实战教程 885

WebAssembly 前沿:AI 模型编译优化与跨语言互操作的工程实践

WebAssembly 为 AI 模型的跨平台部署提供了统一的编译目标,wasi-nn 规范通过委托加速弥合了 WASM 与原生代码的性能差距。但模型体积、加载时间和序列化开销仍是工程落地的核心挑战。从 ONNX Runtime Web 入手,使用预量化的轻量模型验证端到端流程启用 WASM SIMD 加速,矩阵运算性能可提升 2-4 倍使用和 LTO 优化 WASM 模块体积大规模张量传递使用零拷贝视图,避免 JSON 序列化模型分片加载和浏览器缓存是解决加载时间的必要手段。

no1coder的博客 5313

199、运动控制中的行业应用:微纳运动控制(压电陶瓷)

这篇文章分享了微纳运动控制中压电陶瓷应用的实战经验。作者通过半导体封装设备调试案例,揭示了压电陶瓷的非线性特性(迟滞效应和蠕变)对纳米级定位的影响,并指出微纳运动控制本质是"材料控制"而非单纯的电机控制。文章详细介绍了迟滞补偿的核心策略(PI模型)、闭环控制建议(滑模控制替代传统PID)、传感器选型要点(电容式位移传感器)以及调试中的常见问题(地线环路、机械谐振等)。最后给出实用建议:硬件选型比算法更重要,调试工具要专业,并强调微纳运动控制80%取决于对材料特性的理解。全文以工程师视角呈现,包含代码示例和血

m0_50546716的博客 47

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

WASM 推理引擎:跨语言互操作与模型运行时设计

本文从模型部署的碎片化问题出发,设计了基于 WASM 的推理引擎架构,并用 Rust + Wasmtime 实现了核心框架。WASM 的沙箱隔离和跨平台特性,使其适合多租户 AI 平台和边缘推理场景,但性能和内存限制约束了适用范围。共享内存模型避免了模型权重的序列化开销,是 WASM 推理引擎的关键优化。模块化推理管线(预处理-推理-后处理分离)支持独立更新和热部署。跨语言互操作通过二进制权重格式实现,Python 训练 → Rust 编译 → WASM 推理的流程已可走通。

no1coder的博客 4912

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

WebAssembly组件模型:从接口定义到跨语言调用的互操作架构

// 计算器接口/// 运算类型add,subtract,multiply,divide,/// 计算结果ok(f64),/// 计算器配置/// 执行计算/// 获取配置/// 设置配置/// 计算器世界(World = 接口集合)WebAssembly Component Model 通过 WIT 接口定义和 Canonical ABI 实现了类型安全的跨语言互操作,将 WASM 从"可移植汇编"升级为"可组合模块系统"。

no1coder的博客 4831

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

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

如何利用Wasm3实现多语言交互:WebAssembly接口类型终极指南

Wasm3是一个快速的WebAssembly解释器和通用WASM运行时,它通过WebAssembly接口类型(WIT)和WASI标准,极大简化了不同编程语言之间的交互。本文将详细介绍Wasm3如何打破语言壁垒,实现无缝的跨语言通信。 ## 为什么选择Wasm3进行多语言交互? WebAssembly作为一种低级二进制指令格式,原本设计用于在网页中安全高效地运行代码。而Wasm3作为轻量级且高性

gitblog_00342的博客 758

WASM Component Model:跨语言组件互操作的前沿实践

/ 定义计算器组件的接口// 计算结果记录// 为什么用 record 而非多个返回值:// record 有命名字段,调用方// 不需要记住位置顺序;// 多个返回值在跨语言时// 容易混淆// 是否精确// 计算耗时(微秒)// 计算器接口// 为什么用 interface 而非// 直接在 world 中定义:// interface 可以被多个 world// 复用,也可以被其他组件导入// 批量计算// 获取支持的运算符// 导出计算器接口。

no1coder的博客 1167

如何用Rust和WebAssembly构建高性能Web应用:从入门到实战

Rust和WebAssembly(Wasm)的组合正在彻底改变Web应用开发,让开发者能够用系统级语言编写高性能前端代码。本指南将带你从基础概念到实战开发,掌握这一强大技术栈的核心工具与最佳实践,轻松构建闪电般快速的Web应用。 ## 为什么选择Rust+WebAssembly? WebAssembly作为一种低级二进制格式,为Web平台带来了接近原生的执行性能。而Rust凭借其内存安全、零成

gitblog_00951的博客 999

WASM 的 GC 提案:对 Rust 编译到 WASM 意味着什么

WASM GC 提案主要服务于 GC 语言(Java、Dart、Kotlin),让它们编译到 WASM 时不用自带 GC runtime,体积大幅缩小。短期:Rust 继续用线性内存 + dlmalloc/wee_alloc。体积优化靠 wee_alloc + wasm-opt,不需要等 GC 提案。中期:如果 Rust 编译器支持生成 WASM GC 类型(arrayref),可以替代 dlmalloc,减少约 10KB 代码。但这需要编译器团队的大量工作。长期。

no1coder的博客 4541

OpenFang wasm-expert 技能全解析:从 WASI 服务端模块到浏览器集成的 WebAssembly 实战指南

本指南以 OpenFang 内置 `wasm-expert` 专家技能为主体,系统讲解 WebAssembly 的编译、WASI 系统接口、Component Model(组件模型)与浏览器集成等核心主题。读者将掌握在 OpenFang Agent 生态中编译 Rust/C 到 Wasm、构建带 WIT 接口的可组合组件、并用 `wasm-opt`/`wasm-tools` 优化交付产物的完整技术

gitblog_00003的博客 1106

在 Wasm 里跑 Wasm:基于 wasm-bindgen 与 js-sys 实现模块嵌套实例化

本文讲解 wasm-bindgen 仓库中 `examples/wasm-in-wasm` 示例的核心思路:借助 `js-sys` crate 提供的 `WebAssembly` 绑定,在一个已运行于浏览器的 Rust/Wasm 模块内部,再去实例化另一个独立的 Wasm 模块,并调用其导出函数、操纵其导出内存。读完本文,你将掌握 `include_bytes!` 内嵌字节码、`WebAssemb

gitblog_01096的博客 798

w2c2:终极WebAssembly转C编译器指南 - 如何将WASM模块转换为高性能可移植C代码

w2c2是一款强大的WebAssembly转C编译器,能够将WebAssembly模块转换为高性能、可移植的C代码。它为开发者提供了一种简单高效的方式,让WebAssembly程序能够在各种平台上运行,极大地扩展了WebAssembly的应用范围。 ## 什么是w2c2? w2c2是一个开源项目,全称为"WebAssembly to C",正如其名,它的核心功能是将WebAssembly(WA

gitblog_01086的博客 920

基于Rust与WebAssembly的浏览器端字体引擎Taetype-WASM实战指南

字体渲染是Web开发中处理文本显示的核心技术,其原理涉及字体文件的解析、字形轮廓的提取与光栅化。传统方案依赖操作系统字体引擎,存在跨平台差异大、可控性低等局限。WebAssembly(WASM)技术为高性能计算密集型任务提供了接近原生的执行效率,结合Rust语言的内存安全特性,成为实现高性能前端库的黄金组合。这一技术组合的价值在于能将复杂的字体解析与渲染逻辑完全迁移至浏览器沙箱内执行,从而赋予开发者对字体渲染过程的完全控制权,并确保跨平台一致性。其应用场景广泛覆盖了需要动态字体处理、高定制化渲染的在线设计工

weixin_34341117的博客 358
上一篇: AI 驱动的命令行工具:基于 Rust 构建智能 Shell 补全与历史推荐引擎
下一篇: WebAssembly AI 插件:浏览器端 ONNX Runtime 推理与 Rust 模型封装
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论 4
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值