1. Qu'est-ce que Burn et pourquoi l'utiliser ?

Burn est un framework moderne de deep learning écrit en Rust. Il offre une suite complète d'outils pour créer, entraîner et déployer des réseaux de neurones, avec un accent sur la performance, la sécurité mémoire et la flexibilité. Contrairement aux frameworks traditionnels comme PyTorch ou TensorFlow, Burn exploite tous les avantages de Rust : abstractions à coût zéro, garanties de sécurité à la compilation et absence de garbage collector. Cela en fait un choix idéal pour les systèmes où la performance prévisible et une faible consommation de ressources sont cruciales — par exemple, en robotique, systèmes embarqués, serveurs à forte charge et appareils edge.

Burn propose une architecture unique basée sur le concept de "neutralité du backend". Cela signifie que le même code peut s'exécuter sur CPU (via son propre moteur tensoriel), GPU (via CUDA/WGPU), et à l'avenir sur des accélérateurs spécialisés. Le framework prend en charge la différenciation automatique, les optimiseurs (Adam, SGD, AdamW), les fonctions de perte, les couches (Linear, Conv2d, BatchNorm, Dropout, etc.), ainsi que des datasets intégrés et un DataLoader. Une caractéristique clé est la possibilité de compiler des modèles en bibliothèques statiques pour un déploiement sans dépendances à Python ou au runtime CUDA.

Pourquoi utiliser Burn ? Premièrement, pour les projets nécessitant une performance maximale et un contrôle précis de la mémoire. Deuxièmement, pour créer des solutions multiplateformes fonctionnant sur CPU, GPU et même WebAssembly. Troisièmement, pour un déploiement sécurisé de modèles en production, où les erreurs d'exécution (comme les pointeurs nuls ou les incompatibilités de type) sont inacceptables. Burn est activement développé par la communauté et est déjà utilisé dans des domaines tels que la vision par ordinateur, le NLP, les systèmes de recommandation et l'apprentissage par renforcement.

2. Installation

Pour installer Burn, vous avez besoin de Rust (version 1.75 ou plus récente recommandée). Si Rust n'est pas encore installé, utilisez rustup.

Créez un nouveau projet et ajoutez les dépendances dans Cargo.toml :

cargo new mon_projet_burn
cd mon_projet_burn

Ajoutez dans Cargo.toml :

[dependencies]
burn = { version = "0.15", features = ["ndarray"] }  # pour CPU
# ou pour GPU (CUDA) :
# burn = { version = "0.15", features = ["cuda"] }
# ou pour WGPU (GPU multiplateforme) :
# burn = { version = "0.15", features = ["wgpu"] }

Exécutez ensuite :

cargo build

Pour utiliser CUDA, vous aurez besoin du CUDA Toolkit 11.x ou 12.x. Pour WGPU, vous aurez besoin de Vulkan, Metal ou DirectX 12 (selon votre système d'exploitation).

3. Démarrage rapide — exemple minimal fonctionnel

Créons un réseau de neurones simple pour une tâche de régression sur des données synthétiques. Cet exemple illustre les étapes principales : définition du modèle, création des données, entraînement et inférence.

use burn::{
    module::Module,
    nn::{Linear, Relu},
    tensor::{backend::Backend, Tensor},
    train::{Adam, Learner},
    data::dataloader::DataLoaderBuilder,
};

// Définition de la structure du modèle
#[derive(Module, Debug)]
struct MonModele {
    linear1: Linear,
    linear2: Linear,
    activation: Relu,
}

impl MonModele {
    fn new() -> Self {
        Self {
            linear1: Linear::new(1, 16),
            linear2: Linear::new(16, 1),
            activation: Relu::new(),
        }
    }

    fn forward(&self, input: Tensor) -> Tensor {
        let x = self.linear1.forward(input);
        let x = self.activation.forward(x);
        se