Aller au contenu
learn
Menu global

Candle, l'apprentissage automatique de Hugging Face en Rust — Mission

Pourquoi j’apprends ça

Section intitulée « Pourquoi j’apprends ça »

Le cours IX a écrit des algorithmes d’apprentissage automatique à la main en Rust, et le cours sur l’IA de GA a suivi des embeddings calculés en C# par ONNX Runtime. Entre les deux se trouve la question à laquelle ce cours répond : un programme Rust peut-il charger un modèle publié, l’exécuter, et même en entraîner un petit, sans Python et sans runtime natif à côté ?

Candle est la réponse de Hugging Face. C’est une bibliothèque de tenseurs avec différentiation automatique, un ensemble de couches et des implémentations de modèles connus, de BERT aux LLM quantifiés, le tout compilé dans ton binaire. Je veux savoir ce qu’elle fait sous les tenseurs, ce qu’elle coûte sur un CPU, où sont ses limites, et comment un service C# ou Java s’en servirait.

À qui s’adresse ce cours

Section intitulée « À qui s’adresse ce cours »

Tu écris du C# ou du Java, et tu connais les bases de Rust grâce au cours Rust : ownership, Result et ?, traits, Cargo. Tu connais les notions d’apprentissage automatique du cours IX : une perte, un gradient, la descente de gradient, les ensembles d’entraînement et de test. Ce cours ne les réexplique pas ; il renvoie vers elles.

Tu n’as pas besoin de Python ni de PyTorch. Quand la façon de faire de PyTorch aide, une leçon la montre à côté de celle de Candle, puisque la plupart du code de modèles que tu liras est écrit avec.

Candle, TorchSharp et DJL en un tableau

Section intitulée « Candle, TorchSharp et DJL en un tableau »
TorchSharp (C#) DJL (Java) Candle (Rust)
Un tenseur torch.Tensor, au-dessus de libtorch NDArray, au-dessus du moteur que tu choisis candle_core::Tensor, en Rust pur sur le CPU
Une erreur une exception une exception un Result pour chaque opération
Broadcasting implicite implicite explicite : broadcast_add
Gradients requires_grad, .grad s’accumule GradientCollector Var, backward renvoie un nouveau GradStore
Fichiers de modèle son propre format, et TorchScript le format du moteur safetensors, GGUF
Ce que tu livres une app .NET plus les paquets libtorch une app JVM plus les bibliothèques natives du moteur un binaire, ou un module WebAssembly

Sources : README de TorchSharp, README de DJL, README de Candle, et les leçons 1 à 4 pour la colonne Candle.

Candle, épinglé

Section intitulée « Candle, épinglé »

Le cours utilise la dernière version publiée sur crates.io, 0.11.0, sortie le 26 juin 2026. Ses sources sont le tag 0.11.0, commit 31f35b1, et chaque lien vers le code de Candle pointe là, pour que les numéros de ligne restent justes quand main avance. Cargo.toml épingle les crates :

[workspace.dependencies]
candle-core = "=0.11.0"
candle-nn = "=0.11.0"

Quand main a déjà corrigé quelque chose que les leçons rencontrent, elles le disent, avec le commit.

À la fin de ce cours, je saurai

Section intitulée « À la fin de ce cours, je saurai »
  • créer, remodeler, indexer et combiner des tenseurs, et lire les erreurs d’exécution de Candle ;
  • distinguer une vue d’une copie, et mesurer et régler ce qu’une opération coûte sur un CPU ;
  • calculer des gradients avec Var et backward, les vérifier, et entraîner un modèle avec ;
  • construire et entraîner un réseau avec candle-nn, et enregistrer et charger ses poids avec safetensors ;
  • télécharger un modèle depuis le Hub de Hugging Face à une révision épinglée, calculer des embeddings, et exécuter un LLM quantifié ;
  • servir un modèle en HTTP, dans un conteneur et dans le navigateur, et l’appeler depuis C# et Java ;
  • porter un petit modèle PyTorch vers Candle et vérifier que les deux donnent les mêmes sorties.

Plan

Section intitulée « Plan »
# Leçon Si tu connais PyTorch
1 Pourquoi Candle pip install torch, torch.cuda.is_available()
2 Tenseurs torch.tensor, view, indexation, broadcasting
3 Calcul et performance sur CPU contiguous(), torch.set_num_threads
4 Différentiation automatique requires_grad, backward(), .grad
5 candle-nn : modules, couches, optimiseurs, un petit réseau entraîné sur un jeu de données public nn.Module, nn.Linear, torch.optim
6 Formats et Hub : safetensors, VarBuilder, hf-hub, le cache, les licences des modèles torch.load, from_pretrained
7 Transformers en inférence : un modèle d’embeddings, les tokenizers, la similarité, comparés aux embeddings de GA transformers.AutoModel
8 LLM quantifiés : GGUF, tenseurs quantifiés, un petit modèle, l’échantillonnage llama.cpp, bitsandbytes
9 GPU : les features CUDA et Metal, en théorie, à vérifier .to("cuda")
10 Déploiement : un service HTTP avec axum, un binaire autonome, un conteneur, WebAssembly dans le navigateur TorchServe
11 Interopérabilité : appeler un modèle Candle depuis C# et depuis Java TorchSharp, DJL
12 Écrire son propre modèle : porter un petit modèle PyTorch et comparer les sorties —
— Journal

Les leçons 5 à 12 sont le plan ; il changera à mesure que les premières m’apprendront ce qui compte. La leçon 9 reste théorique parce que le GPU de la machine sur laquelle ce cours est écrit est réservé à d’autres travaux.

Ressources

Section intitulée « Ressources »