smallbard

Articles · Fonctionnement interne des IA · série terminée

Smallem : un LLM en Rust et CUDA, à partir de zéro

Cette série raconte la construction d'un modèle de langage de type GPT, écrit en Rust, dont chaque calcul sur GPU est fait par un kernel écrit à la main. Elle suit l'ordre dans lequel le projet a été construit : chaque article ajoute une brique, la teste, puis mesure ce qu'elle apporte.

Sommaire

  1. 1

    Le projet et ses règles

    Le but, les contraintes, la route

  2. 2

    Un premier kernel sur le GPU

    L'environnement CUDA Rust et l'exemple vecadd

  3. 3

    Des données et un premier modèle

    Le corpus, les tokens, le bigramme, la perte

  4. 4

    Un tenseur sur CPU

    Formes, pas, broadcasting, matmul, softmax

  5. 5

    Les mêmes opérations sur GPU

    Les kernels, un par opération

  6. 6

    La rétropropagation

    Un autograd à tape, vérifié par différences finies

  7. 7

    Un premier réseau qui apprend

    Paramètres, couches, optimiseurs, MLP

  8. 8

    L'attention et le Transformer

    L'architecture GPT, pièce par pièce

  9. 9

    Entraîner, sauvegarder, générer

    Un vrai entraînement, et GPT-2 chargé dans notre code

  10. 10

    Des sous-mots et un entraînement à l'échelle

    Le tokeniseur BPE et un modèle de 30 millions de paramètres

  11. 11

    Rendre le GPU rapide

    Matmul par tuiles, Tensor Cores, cache de génération

  12. 12

    Trois pièces modernes, et comment mesurer une idée

    RMSNorm, SwiGLU, RoPE, et le bruit d'un entraînement

  13. 13

    L'attention latente : compresser le cache

    MLA, le RoPE découplé, et un résultat négatif disséqué

  14. 14

    Un mélange d'experts

    Aiguillage, experts clairsemés, équilibrage de la charge

  15. 15

    Prédire plus loin, optimiser autrement

    La prédiction multi-token et l'optimiseur Muon

  16. 16

    À durée égale

    Les comparaisons refaites à la minute, Muon rendu rentable, deux idées d'après DeepSeek-V4

  17. 17

    L'attention fusionnée

    Le softmax en ligne, des kernels sur Tensor Cores, et la fin du mur de mémoire

  18. 18

    Bilan

    Ce qui marche, ce qui reste, ce qu'on a appris

Les chiffres en un coup d'œil

Perte de validation, en nats par octet de texte (plus c'est bas, mieux le modèle prédit) :

ModèleArticlePerte
Hasard uniforme35,55
Bigramme32,53
MLP à contexte fixe71,90
GPT de 0,8 million de paramètres, octets91,36
GPT de 11 millions de paramètres, octets91,20
GPT de 30 millions de paramètres, sous-mots100,94

Temps d'un pas d'entraînement du plus gros modèle sur une RTX 3090 : 652 ms au départ, 157 ms à la fin de l'article 11.

Les articles 12 à 15 comparent des variantes d'architecture sur un budget court et fixe (16 minutes). De 1,000 pour l'architecture GPT-2, la perte passe à 0,959 avec RoPE, à 0,940 avec un mélange d'experts, à 0,925 avec l'optimiseur Muon, et à 0,900 en entraînant simplement 2,3 fois plus longtemps.

L'article 16 reprend ces comparaisons à durée égale. Une seule idée y bat la référence : Muon, une fois son orthogonalisation réécrite, avec 0,882 en 36 minutes. L'article 17 écrit l'attention fusionnée : 16 % de débit en plus, et des contextes de 8 192 positions dans 7 Gio.

Bibliographie

Les travaux originaux sur lesquels s'appuie la série. Chacun est aussi cité dans l'article où son idée est expliquée.

Les fondations :

Les pièces modernes :

DeepSeek :

Après DeepSeek-V4 :

L'attention fusionnée :