Construire un LLM depuis zéro — le parcours par le code

The Loss Curve est un cours gratuit et interactif qui te fait construire un modèle de langage façon GPT depuis zéro. Chaque chapitre associe une explication courte à du code que tu peux exécuter — d'abord dans ton navigateur, puis en local dans ton propre projet my-llm/. À la fin, tu as un modèle qui fonctionne et que tu comprends parce que tu en as écrit chaque partie.

1. Pourquoi « depuis zéro » change tout

Les frameworks comme Hugging Face Transformers sont excellents pour livrer. Ce sont de mauvais professeurs. Quand model = AutoModelForCausalLM.from_pretrained("gpt2") tient en une ligne, tout ce qu'il y a en dessous reste opaque.

Construire depuis zéro, c'est l'arbitrage inverse. C'est plus lent, et le modèle obtenu est bien plus petit que ce que tu mettrais en production. Mais les pièces cessent d'être magiques. Tu peux répondre à une question comme « pourquoi ce softmax est-il divisé par √d_k ? » avec le souvenir du moment où tu l'as tapé.

2. Les six parties du cours

Le cours se découpe en six parties. Chacune se termine sur un artefact exécutable, sauvegardé dans ton projet local my-llm/.

• Partie I — Démarrer le projet (chapitres 1 à 4). Tokens, bigrammes, tokenizer BPE, embeddings. La première pièce d'un vrai LLM, c'est un tokenizer entraîné sur tes données.
• Partie II — Le faire apprendre (chapitres 5 à 7). Un seul neurone avec un poids entraînable ; puis un MLP ; puis les optimiseurs (SGD, momentum, Adam). Tu arrêtes de compter et tu commences à descendre des gradients.
• Partie III — Construire le Transformer (chapitres 8 à 10). Une tête d'attention, le multi-têtes, les résidus, la LayerNorm, le feed-forward — assemblés dans le bloc que GPT empile.
• Partie IV — Entraîner et utiliser le LLM (chapitres 11 à 16). Vrai jeu de données, modèle PyTorch en 150 lignes, boucle d'entraînement, stratégies d'échantillonnage, puis les poids de GPT-2 124M chargés dans l'architecture que tu as écrite.
• Partie V — Le rendre utile (chapitres 17 à 21). Instruction tuning, fine-tuning LoRA, quantification INT8, un REPL de chat avec cache KV, et un projet final qui livre un assistant spécialisé.
• Partie VI — Annexes (optionnel). La rétropropagation dérivée à la main ; RLHF et DPO expliqués.

3. Ce que tu auras à la fin

• ton propre tokenizer BPE, entraîné sur tes données
• un bloc Transformer écrit par toi en ~150 lignes de PyTorch
• un petit GPT entraîné depuis zéro sur ta machine
• la même architecture chargée avec les vrais poids GPT-2 124M
• un chatbot instruction-tuné auquel tu peux parler
• le tout dans un seul projet my-llm/ qui t'appartient

Aucun format propriétaire, aucune dépendance en ligne : les artefacts sont de simples fichiers .py et des checkpoints PyTorch que tu peux lire, modifier et livrer.

4. Prérequis

• être à l'aise pour lire du JavaScript ou du Python — les cellules du navigateur sont en JS, le projet local est en Python
• une machine avec Python 3.11 ou plus (le chapitre 0 couvre l'installation sur Mac, Windows et Linux)
• de la patience. Tu peux finir en un week-end en sautant les approfondissements ; compte une semaine si tu prends le temps de jouer réellement avec chaque cellule.

Tu n'as pas besoin d'un bagage mathématique au-delà de l'algèbre du lycée. Le cours dérive les maths au moment où elles comptent et renvoie à l'annexe sur la rétropropagation quand ça ne tient pas dans le fil du texte.

5. Commencer

Ouvre le chapitre 1 — le modèle le plus idiot qui existe. C'est 18 minutes de lecture plus quelques minutes d'exécution, et ça se termine avec la première pièce de my-llm/ livrée : un compteur de bigrammes, le modèle de langage fonctionnel le plus simple qui soit. Tous les chapitres suivants s'appuient dessus.

Si tu préfères voir l'ensemble d'abord, la liste complète des chapitres est ici.