自动微分

由 ndarray 提供支持的张量和可微操作。

Cargo.toml

如果你使用基本的线性代数运算，尤其是矩阵乘法，blas 功能对于加速这些运算非常重要。

[dependencies]
autograd = {"<version>", features = ["blas", "<blas-implementation-choice>"] }

<blas-implementation-choice> 必须是以下之一（另请参阅 blas-src)：

• accelerate 仅适用于 macOS
• intel-mkl 仅适用于 Intel/AMD CPU。包含向量化数学（VM）运算
• openblas

功能

反向模式自动微分

这里我们只是计算 z = 2x^2 + 3y + 1 的偏导数。

use autograd as ag;
use ag::tensor_ops::*;

ag::run(|ctx: &mut ag::Context<_>| {
   let x = ctx.placeholder("x", &[]);
   let y = ctx.placeholder("y", &[]);
   let z = 2.*x*x + 3.*y + 1.;

   // dz/dy
   let gy = &grad(&[z], &[y])[0];
   println!("{:?}", gy.eval(ctx));   // => Ok(3.)

   // dz/dx（需要填充占位符 `x`）
   let gx = &grad(&[z], &[x])[0];
   let feed = ag::ndarray::arr0(2.);
   println!("{:?}", ctx.evaluator().push(gx).feed(x, feed.view()).run()[0]);  // => Ok(8.)

   // ddz/dx（再次对 `z` 求导）
   let ggx = &grad(&[gx], &[x])[0];
   println!("{:?}", ggx.eval(ctx));  // => Ok(4.)
});

神经网络

该 crate 包含多种受 tensorflow/theano 启发的低级功能，用于训练神经网络。 由于计算图只需要最少的堆内存分配，因此即使对于复杂的网络，开销也很小。

// 使用多层感知器对 MNIST 数字进行分类
use autograd as ag;
use ag::optimizers::adam::Adam;
use ag::tensor_ops::*;
use ag::prelude::*;

let mut env = ag::VariableEnvironment::new();

let rng = ag::ndarray_ext::ArrayRng::<f32>::default();

// 在此环境中注册变量。
env.name("w").set(rng.glorot_uniform(&[28 * 28, 10]));
env.name("b").set(ag::ndarray_ext::zeros(&[1, 10]));

let adam = Adam::default("my_adam", env.default_namespace().current_var_ids(), &mut env);

for epoch in 0..3 {  // 在 2.7GHz Intel Core i5 上每轮耗时约 0.11 秒
   env.run(|ctx| {
       let x = ctx.placeholder("x", &[-1, 28*28]);
       let y = ctx.placeholder("y", &[-1]);
       let w = ctx.variable("w");
       let b = ctx.variable("b");
       let z = matmul(x, w) + b;
       let mean_loss = reduce_mean(sparse_softmax_cross_entropy(z, &y), &[0], false);
       let grads = &grad(&[mean_loss], &[w, b]);

       // let mut feeder = ag::Feeder::new();
       // feeder.push(x, x_batch).push(y, y_batch);
       // adam.update(&[w, b], grads, ctx, feeder);
   });
}

抽象

use autograd as ag;
use ag::tensor_ops::*;
use ag::ndarray;

// `Tensor::map()`
ag::run(|ctx| {
    let x = ones(&[2, 3], ctx);
    // 应用 ndarray 的方法
    let y = x.map(|x| x.fold_axis(ndarray::Axis(0), 0.0, |acc, x| acc + x));
    let z = x.map(|x| ag::ndarray_ext::zeros(x.shape()));
});

// 钩子
ag::run(|ctx| {
    let x: ag::Tensor<f32> = ones(&[2, 3], ctx).show_shape();
    let y: ag::Tensor<f32> = ones(&[2, 3], ctx).raw_hook(|x| println!("{}", x));
});

有关详细信息，请参阅 文档 或 示例

rust-autograd 快速上手指南

rust-autograd 是一个基于 ndarray 的 Rust 自动微分库，支持反向模式自动微分和神经网络训练，灵感来源于 TensorFlow 和 Theano。

环境准备

• 操作系统：Linux、macOS 或 Windows
• Rust 版本：建议使用最新稳定版（可通过 rustup 安装）
• 前置依赖：
  • 若需加速线性代数运算（如矩阵乘法），需启用 blas 特性并选择对应的 BLAS 实现：
    • accelerate：仅限 macOS
    • intel-mkl：仅限 Intel/AMD CPU，包含向量数学运算
    • openblas：跨平台通用

安装步骤

在项目的 Cargo.toml 中添加依赖（以 openblas 为例）：

[dependencies]
autograd = { version = "<version>", features = ["blas", "openblas"] }

替换 <version> 为 crates.io 上的最新版本号。

如需使用国内镜像加速构建，可配置 .cargo/config.toml：

[source.crates-io]
replace-with = 'ustc'

[source.ustc]
registry = "sparse+https://mirrors.ustc.edu.cn/crates.io-index/"

基本使用

以下示例演示如何计算函数 $ z = 2x^2 + 3y + 1 $ 的偏导数：

use autograd as ag;
use ag::tensor_ops::*;

ag::run(|ctx: &mut ag::Context<_>| {
    let x = ctx.placeholder("x", &[]);
    let y = ctx.placeholder("y", &[]);
    let z = 2.*x*x + 3.*y + 1.;

    // 计算 dz/dy
    let gy = &grad(&[z], &[y])[0];
    println!("{:?}", gy.eval(ctx));   // 输出: Ok(3.)

    // 计算 dz/dx（需提供 x 的值）
    let gx = &grad(&[z], &[x])[0];
    let feed = ag::ndarray::arr0(2.);
    println!("{:?}", ctx.evaluator().push(gx).feed(x, feed.view()).run()[0]);  // 输出: Ok(8.)

    // 计算二阶导数 ddz/dx
    let ggx = &grad(&[gx], &[x])[0];
    println!("{:?}", ggx.eval(ctx));  // 输出: Ok(4.)
});

该库还支持构建神经网络、自定义张量操作及钩子函数，更多用法请参考 官方文档 或 示例代码。