Chapitres · dans l’ordre de lecture
Tous les chapitres
Chaque chapitre est un artefact fonctionnel que tu peux manipuler, avec un texte court qui explique ce que tu viens de faire. Ils se construisent les uns sur les autres ; lis-les dans l’ordre.
Partie 0 — Avant de commencer
chap. 0
Python, venv, PyTorch — la toolchain locale. À sauter si tu as déjà un Python 3.11+ et que pip install torch est un réflexe.
Partie 1 — Démarrer le projet
chap. 1-4
Tokens, bigrammes, BPE, embeddings. Tu démarres le projet local et construis les premières pièces d’un modèle de langage.
01
Le modèle le plus idiot qui existe
Démarre ton projet LLM local, puis construis le modèle de langage le plus simple possible : un générateur bigramme que tu peux lancer sur ta machine.
18 min
02
Compter ne suffit pas
Ajoute un jeu de validation, du lissage et un vrai score à ton bigramme local au lieu de laisser les paires inconnues casser la génération.
15 min
03
Entraîne tes propres tokens
Entraîne un petit tokenizer BPE dans le navigateur, puis sauvegarde le code du tokenizer et ses merges dans ton projet LLM local.
16 min
04
Donner du sens aux mots
Transforme les ids de tokens en vecteurs, entraîne de petits embeddings skip-gram et ajoute les premiers poids appris à ton projet local.
16 min
Partie 2 — Le faire apprendre
chap. 5-7
Neurone simple, MLP, optimiseurs. Le modèle arrête de compter et commence à progresser grâce aux gradients.
05
Un neurone qui apprend
Construis un neurone entraînable, dérive son gradient et ajoute la première étape d’apprentissage à ton code local.
16 min
06
Empiler les couches
Assemble des neurones en couches, écris une passe avant de MLP et étends ton module de réseau de neurones local au-delà d’une seule ligne.
14 min
07
La descente de gradient en direct
Ouvre les optimiseurs, compare SGD, momentum et Adam, puis ajoute l’état de l’optimiseur à ton projet local.
15 min
Partie 3 — Construire le transformer
chap. 8-10
Attention, têtes multiples, connexions résiduelles, puis le bloc transformer complet utilisé par les LLM modernes.
08
Une tête d’attention à la main
Écris Q, K, V, les scores causaux, le softmax et les valeurs pondérées, puis ajoute le cœur de l’attention à ton modèle local.
18 min
09
Multi-têtes et résidus
Combine les têtes, normalise les flux résiduels et rapproche ton code d’attention local d’un bloc transformer empilable.
14 min
10
Le bloc transformer complet
Assemble attention, résidus et couches feed-forward dans le premier squelette de modèle local proche de GPT.
16 min
Partie 4 — Entraîner et utiliser le LLM
chap. 11-16
Préparer les données, passer à PyTorch, entraîner un petit GPT, charger les poids GPT-2 dans le même code, générer, et lire honnêtement ses échecs.
11
Préparer un dataset
Remplace les chaînes jouets par un vrai corpus, tokenize-le et écris train.bin / val.bin dans le projet local démarré au chapitre 1.
16 min
12
Le code minimal
Remplace le squelette lisible en listes par un modèle PyTorch compact qui garde la même architecture et peut réellement s’entraîner.
15 min
13
La boucle d’entraînement
Entraîne le modèle PyTorch local sur data/train.bin, écris des checkpoints et génère le premier texte de ton propre modèle.
16 min
14
Génération et sampling
Transforme le checkpoint entraîné en générateur local contrôlable avec température, top-k et top-p sampling.
12 min
15
Charger les vrais poids
Reprends ton code transformer du chapitre 12, mappe les noms de paramètres GPT-2, et charge les 124M de paramètres pré-entraînés d’OpenAI dans ton propre modèle.
14 min
16
Pourquoi ton modèle parle mal
Compare ton modèle local aux systèmes de frontière, puis trace les chemins pratiques qui peuvent vraiment créer de la valeur.
13 min
Partie 5 — Le rendre utile, moins cher et utilisable
chap. 17-21
Instruction-tuning, LoRA, quantification, boucle de chat, et un capstone où tu livres un assistant spécialisé de bout en bout.
17
Donner des instructions à ton modèle
Fine-tune le checkpoint du chapitre 13 sur un petit dataset prompt/completion pour qu’il réponde réellement aux instructions, au lieu de continuer en pseudo-shakespearien.
16 min
18
Fine-tuning avec LoRA
Spécialise ton modèle entraîné à bas coût avec LoRA, la voie pratique pour adapter un comportement sans payer un réentraînement complet.
12 min
19
Quantification simple
Réduis ton checkpoint local et son coût d’inférence avec la quantification INT8, puis vois jusqu’où vont les méthodes de production.
10 min
20
Parler à ton modèle
Emballe ton checkpoint entraîné dans une petite boucle de chat en terminal pour finir avec un modèle que tu peux vraiment prompter.
12 min
21
Livrer quelque chose d’utile
Choisis un domaine étroit, écris 150 exemples SFT, fine-tune GPT-2 small, évalue, et termine le livre avec un assistant spécialisé qui marche.
22 min
Partie 6 — Appendices
optionnel
Approfondissements optionnels qui complètent le chemin principal : dérivations mathématiques et explications de concepts utilisés sans être déballés.
22
Appendice · La backprop à la main
Dérive la backprop sur un réseau à 2 couches étape par étape, puis vérifie le résultat contre loss.backward() de PyTorch pour que la magie cesse d’être magique.
14 min
23
Appendice · RLHF et DPO
Promenade conceptuelle dans l’apprentissage par préférences — reward models, la boucle RLHF, et DPO comme alternative en une seule loss. Le troisième axe de l’alignement, en bref.
12 min