Bibliothèques pour l'apprentissage automatique en Rust…

Apprentissage automatique en Rust : bibliothèques et outils modernes

L'écosystème de l'apprentissage automatique a longtemps été exclusivement associé à Python. Cependant, Rust, grâce à ses performances, sa sécurité mémoire et ses frais généraux nuls, s'intègre de plus en plus dans la boîte à outils ML. Dans cet article, nous passerons en revue les bibliothèques clés pour l'apprentissage automatique en langage Rust, qui permettent de construire, entraîner et déployer des modèles avec une efficacité inaccessible aux langages interprétés.

Pourquoi Rust pour l'apprentissage automatique ?

Rust offre trois avantages majeurs pour le ML :

Performances — la vitesse d'exécution du code est comparable à celle du C/C++.
Sécurité — le système de possession (ownership) élimine des classes entières d'erreurs mémoire.
Parallélisme — un modèle de threads intégré sans courses aux données.

Cependant, Rust ne cherche pas à remplacer Python dans la partie recherche. Son créneau est l'environnement de production, les systèmes embarqués, les services à forte charge et le calcul en périphérie (edge computing).

1. Linfa — un ensemble complet d'algorithmes ML classiques

Le projet linfa (équivalent de scikit-learn pour Rust) fournit une structure modulaire pour les tâches d'apprentissage supervisé et non supervisé. La bibliothèque est activement développée avec le soutien de la communauté Rust-ML.

Composants principaux de Linfa

linfa-clustering — K-Means, DBSCAN, Gaussian Mixture
linfa-linear — régression linéaire et logistique
linfa-svm — machines à vecteurs de support
linfa-trees — arbres de décision et forêt aléatoire
linfa-nn — méthodes des plus proches voisins

Exemple : régression linéaire avec Linfa

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

fn main() {    // Données d'entraînement : (x, y)    let x = array![[1.0], [2.0], [3.0], [4.0]];    let y = array![2.0, 4.0, 6.0, 8.0];

    // Création du jeu de données    let dataset = Dataset::new(x, y);

    // Entraînement du modèle    let model = LinearRegression::default().fit(&dataset).unwrap();

    // Prédiction pour x=5    let pred = model.predict(&array![[5.0]]);    println!("Prédiction : {}", pred);}

2. Burn — framework d'apprentissage profond avec support GPU

Burn est un framework moderne pour les réseaux de neurones, écrit en Rust. Il prend en charge la différenciation automatique, le travail sur GPU via WGPU et Vulkan, ainsi que l'exportation vers ONNX.

Fonctionnalités clés de Burn

Graphes de calcul dynamiques et statiques
Backends : Torch, WGPU, Ndarray, Fusion
Optimiseurs intégrés (Adam, SGD, AdamW)
Support des convolutions 1D, 2D, 3D

Exemple : perceptron simple avec Burn

use burn::tensor::{Tensor, backend::Backend};use burn::nn::{Linear, LinearConfig};use burn::module::Module;

#[derive(Module)]struct MLP<B: Backend> {    layer1: Linear<B>,    layer2: Linear<B>,}

impl<B: Backend> MLP<B> {    fn new(device: &B::Device) -> Self {        Self {            layer1: LinearConfig::new(2, 16).init(device),            layer2: LinearConfig::new(16, 1).init(device),        }    }

    fn forward(&self, input: Tensor<B, 2>) -> Tensor<B, 2> {        let x = self.layer1.forward(input).relu();        self.layer2.forward(x)    }}

3. Candle — framework minimaliste de Hugging Face

Développé par l'équipe de Hugging Face, Candle est conçu pour la simplicité et la rapidité. Il n'utilise pas CUDA (uniquement CPU et Metal), ce qui le rend idéal pour l'inférence sur Mac et les appareils edge.