Maschinelles Lernen mit Rust: Überblick über Bibliotheken für ML und Data Science

Maschinelles Lernen mit Rust: Moderne Bibliotheken und Werkzeuge

Die Sprache Rust, bekannt für ihre Leistung und Speichersicherheit, hält zunehmend Einzug in den Bereich des maschinellen Lernens (ML). Obwohl das ML-Ökosystem in Rust jünger ist als in Python, bietet es bereits ausgereifte Lösungen zum Erstellen, Trainieren und Bereitstellen von Modellen. In diesem Artikel betrachten wir die wichtigsten Bibliotheken, die es ermöglichen, Aufgaben des maschinellen Lernens in Rust zu lösen, und geben praktische Beispiele.

Warum Rust für maschinelles Lernen?

Rust bietet einzigartige Vorteile:

• Leistung: Kompilierter Rust-Code ist vergleichbar schnell wie C/C++, was für das Training großer Modelle entscheidend ist.
• Sicherheit: Das Ownership- und Borrowing-System schließt ganze Fehlerklassen aus (data races, null pointers).
• Plattformunabhängigkeit: Lässt sich einfach für WebAssembly, mobile Geräte und eingebettete Systeme kompilieren.
• Integration mit Python: Hochleistungsmodule können in Rust geschrieben und über PyO3 aus Python aufgerufen werden.

Wichtige Bibliotheken für ML in Rust

1. Linfa — Das Schweizer Taschenmesser für ML

Linfa ist das Äquivalent zu scikit-learn für Rust. Es bietet eine einheitliche Schnittstelle für Standardalgorithmen. Unterstützt werden:

• Lineare und logistische Regression
• Support Vector Machines (SVM)
• Clusteranalyse (K-Means, DBSCAN)
• Dimensionsreduktionsverfahren (PCA)
• Entscheidungsbäume und Random Forest

Beispiel einer linearen Regression mit Linfa:

use linfa::prelude::*;use linfa_linear::LinearRegression;use ndarray::Array2;

fn main() -> Result<(), Box<dyn std::error::Error>> {    // Erstellen synthetischer Daten: 100 Punkte, 3 Merkmale    let x = Array2::random((100, 3), rand::distributions::Uniform::new(-1.0, 1.0));    let true_weights = arr2(&[[2.0], [-1.0], [0.5]]);    let y = x.dot(&true_weights) + 0.1; // Rauschen hinzufügen

    let dataset = Dataset::new(x, y);        // Modell trainieren    let model = LinearRegression::default().fit(&dataset)?;        // Modellkoeffizienten    println!("Gewichte: {:?}", model.params());        // Vorhersage    let predicted = model.predict(&dataset);    println!("MSE: {:?}", predicted.mean_squared_error(&dataset)?);        Ok(())}

2. Burn — Modernes Framework für Deep Learning

Burn ist ein flexibles Framework für neuronale Netze, vollständig in Rust geschrieben. Seine Besonderheiten:

• Unterstützung für GPU (CUDA, Vulkan, Metal, WebGPU)
• Automatische Differenzierung (autograd)
• Flexibles Backend-System (torch, ndarray, wgpu)
• Dynamische Berechnungsgraphen
• Export nach ONNX

Beispiel eines einfachen neuronalen Netzes mit Burn:

use burn::tensor::{Tensor, backend::Backend};use burn::nn::{Linear, Relu, Sequential};

// Netzwerkarchitektur definierenstruct MyModel<B: Backend> {    linear1: Linear<B>,    linear2: Linear<B>,    activation: Relu,}

impl<B: Backend> MyModel<B> {    fn new(device: &B::Device) -> Self {        Self {            linear1: Linear::new(784, 256, device),            linear2: Linear::new(256, 10, device),            activation: Relu::new(),        }    }        fn forward(&self, input: Tensor<B, 2>) -> Tensor<B, 2> {        let x = self.linear1.forward(input);        let x = self.activation.forward(x);        self.linear2.forward(x)    }}

fn main() {    // CPU-Backend verwenden (ndarray)    type MyBackend = burn::backend::NdArray;    let device = Default::default();        let model = MyModel::<MyBackend>::new(&device);    let input = Tensor::<MyBackend, 2>::ra