Rust实战：AI与机器学习自动炒饭机器学习

基于Rust语言的AI/机器学习相关实例

以下是基于Rust语言的AI/机器学习相关实例，涵盖基础算法、框架应用和实际场景实现。内容整合自开源项目、社区案例和工具库文档，提供可直接运行的代码片段或项目参考。

基础机器学习算法

线性回归

use linreg::linear_regression;
let x: Vec<f64> = vec![1.0, 2.0, 3.0];
let y: Vec<f64> = vec![2.0, 4.0, 5.5];
let (slope, intercept): (f64, f64) = linear_regression(&x, &y).unwrap();

K-Means聚类

use smartcore::cluster::kmeans::*;
let data = vec![
    vec![1.0, 2.0], vec![1.1, 2.2], vec![0.9, 1.9],
    vec![5.0, 5.0], vec![5.1, 5.2], vec![4.9, 4.8]
];
let model = KMeans::fit(&data, 2, Default::default()).unwrap();

深度学习框架应用

使用Tch-rs（PyTorch绑定）

use tch::{nn, Device, Tensor};
struct Net { conv1: nn::Conv2D, fc1: nn::Linear }
let vs = nn::VarStore::new(Device::Cpu);
let net = Net { 
    conv1: nn::conv2d(&vs.root(), 1, 32, 5, Default::default()),
    fc1: nn::linear(&vs.root(), 1024, 10, Default::default())
};

ONNX模型推理

use tract_onnx::prelude::*;
let model = tract_onnx::onnx()
    .model_for_path("model.onnx")?
    .into_optimized()?
    .into_runnable()?;
let input = Tensor::from(arr1(&[1.0, 2.0]));
let output = model.run(tvec!(input))?;

NLP处理实例

文本情感分析

use rust_bert::pipelines::sentiment::SentimentModel;
let model = SentimentModel::new(Default::default())?;
let input = ["Rust is amazingly productive!"];
let output = model.predict(&input);

词向量提取

use finalfusion::prelude::*;
let embeddings = Embeddings::read_embeddings("model.fifu")?;
let embedding = embeddings.embedding("人工智能");

计算机视觉

OpenCV图像分类

use opencv::{dnn, prelude::*};
let net = dnn::read_net_from_onnx("resnet18.onnx")?;
let blob = dnn::blob_from_image(&image, 1.0, Size::new(224, 224), Scalar::all(0), false, false)?;
net.set_input(&blob, "", 1.0, Scalar::all(0))?;
let output = net.forward("")?;

YOLO目标检测

use darknet::image::Image;
let det = darknet::Detector::new("yolov4.cfg", "yolov4.weights", 0)?;
let img = Image::open("test.jpg")?;
let results = det.detect(&img, 0.5, 0.5);

强化学习

Q-Learning算法

use rsrl::domains::GridWorld;
use rsrl::policies::EGreedy;
let env = GridWorld::new();
let mut agent = QLearning::new(env.state_space(), env.action_space(), 0.99, 0.1);

以下是基于 AutumnAI/leaf 库的30个实例示例，涵盖张量操作、模型训练、层构建等核心功能。所有示例均以Rust编写，需确保已添加 leaf 依赖至 Cargo.toml：

[dependencies]
leaf = "0.2.0"  # 版本可能需调整

基础张量操作

use leaf::tensor::Tensor;

let tensor = Tensor::from_vec(vec![1.0, 2.0, 3.0], vec![3]);
let squared = tensor.map(|x| x * x);

let a = Tensor::from_vec(vec![1.0, 2.0], vec![2]);
let b = Tensor::from_vec(vec![3.0, 4.0], vec![2]);
let dot_product = a.dot(&b);

线性层构建

use leaf::layer::{Linear, Layer};
let linear_layer = Linear::new(10, 5);  // 输入10维，输出5维
let input = Tensor::rand(vec![1, 10]);
let output = linear_layer.forward(&input);

激活函数

use leaf::layer::ReLU;
let relu = ReLU::new();
let activated = relu.forward(&Tensor::from_vec(vec![-1.0, 0.5], vec![2]));

损失函数

use leaf::loss::MSE;
let loss_fn = MSE::new();
let prediction = Tensor::from_vec(vec![0.8, 0.2], vec![2]);
let target = Tensor::from_vec(vec![1.0, 0.0], vec![2]);
let loss = loss_fn.forward(&prediction, &target);

优化器使用

use leaf::optimizer::SGD;
let mut optimizer = SGD::new(0.01);  // 学习率0.01
optimizer.update(&mut linear_layer.parameters());

完整模型训练

use leaf::model::Model;
struct MyModel { layer1: Linear, layer2: Linear }
impl Model for MyModel {
    fn forward(&self, x: &Tensor) -> Tensor {
        let x = self.layer1.forward(x);
        self.layer2.forward(&x)
    }
}
let model = MyModel { layer1: Linear::new(10, 5), layer2: Linear::new(5, 1) };

数据批处理

let batch = Tensor::stack(&[
    Tensor::from_vec(vec![1.0, 2.0], vec![2]),
    Tensor::from_vec(vec![3.0, 4.0], vec![2])
], 0);

保存与加载模型

model.save("model.bin").unwrap();
let loaded = MyModel::load("model.bin").unwrap();

GPU加速（需特性支持）

#[cfg(feature = "cuda")]
let tensor_gpu = Tensor::from_vec(vec![1.0, 2.0], vec![2]).to_gpu();

自定义层实现

use leaf::layer::Layer;
struct CustomLayer;
impl Layer for CustomLayer {
    fn forward(&self, x: &Tensor) -> Tensor {
        x.map(|v| v * 0.5)
    }
}

梯度检查

let x = Tensor::from_vec(vec![1.0], vec![1]).requires_grad(true);
let y = &x * &x;
y.backward();
let grad = x.grad();

基于 LaurentMazare/tch-rs

以下是基于 LaurentMazare/tch-rs（Rust 的 PyTorch 绑定库）的实用示例，涵盖张量操作、模型训练和推理等场景。每个示例均以代码片段形式呈现，并附带简要说明。

基础张量操作

创建张量

use tch::Tensor;
let tensor = Tensor::from_slice(&[1, 2, 3, 4]);
println!("{:?}", tensor);

创建一维张量并打印。

随机张量

let rand_tensor = Tensor::randn(&[2, 3], (tch::Kind::Float, tch::Device::Cpu));

生成 2x3 的随机正态分布张量。

张量运算

let a = Tensor::from_slice(&[1.0, 2.0]);
let b = Tensor::from_slice(&[3.0, 4.0]);
let sum = a + b;

逐元素加法。

自动微分与梯度

计算梯度

let x = Tensor::from(2.0).requires_grad(true);
let y = x * x;
y.backward();
let grad = x.grad();

计算 $y = x^2$ 在 $x=2$ 处的导数。

线性回归参数更新

let w = Tensor::randn(&[1], (tch::Kind::Float, tch::Device::Cpu)).requires_grad(true);
let b = Tensor::zeros(&[1], (tch::Kind::Float, tch::Device::Cpu)).requires_grad(true);
let lr = 0.01;
let loss = (y_pred - y_true).pow(2).sum();
loss.backward();
tch::no_grad(|| {
    w += -lr * w.grad();
    b += -lr * b.grad();
});

手动实现梯度下降更新。

神经网络构建

定义简单模型

use tch::nn;
struct Net {
    fc1: nn::Linear,
    fc2: nn::Linear,
}
impl Net {
    fn new(vs: &nn::Path) -> Net {
        Net {
            fc1: nn::linear(vs, 784, 128, Default::default()),
            fc2: nn::linear(vs, 128, 10, Default::default()),
        }
    }
    fn forward(&self, x: &Tensor) -> Tensor {
        x.view(&[-1, 784]).apply(&self.fc1).relu().apply(&self.fc2)
    }
}

构建一个两层全连接网络。

加载预训练模型