Entraîner un petit modèle de langage — en local

Tu peux entraîner un petit modèle de langage sur un ordinateur portable ordinaire. Ce guide est un parcours pratique — jeu de données, modèle, boucle d'entraînement, évaluation — construit par-dessus les chapitres de The Loss Curve.

1. Choisir la taille

Deux boutons déterminent ce que « petit » veut dire :

• La taille du modèle. La référence du cours fait ~14 millions de paramètres : 6 couches Transformer, 6 têtes, dimension d'embedding 384, taille de bloc 256. S'entraîne confortablement sur CPU.
• La taille du jeu de données. Quelques mégaoctets de texte donnent une sortie lisible. Quelques dizaines et le modèle s'améliore nettement ; à quelques centaines, l'architecture minuscule sature.

Pour situer : GPT-2 small fait 124 millions de paramètres, entraînés sur environ 40 Go de texte. Tu vises à peu près un dixième des paramètres et un quarante-millième des données. La qualité ne suivra pas, mais l'entraînement tiendra sur ta machine.

2. Préparer les données

Le chapitre 11 — préparer un dataset charge un corpus, le tokenise avec le tokenizer BPE entraîné au chapitre 3, construit une séparation train/validation, et sauvegarde les tokens dans data/train.bin et data/val.bin.

C'est la partie ingrate, mais la sauter fait mal partout ensuite. Les choix de tokenisation (taille de vocabulaire, traitement des retours à la ligne, octets ou caractères) verrouillent tout le reste de l'entraînement.

3. Écrire le modèle

Le chapitre 12 — le code minimal écrit un décodeur GPT complet. Six blocs Transformer. AdamW. Cross-entropy. Partage de poids entre les embeddings et la tête de sortie.

config = GPTConfig(
    vocab_size=10000,
    block_size=256,
    n_layer=6,
    n_head=6,
    n_embd=384,
    dropout=0.0,
)
model = GPT(config)

Voilà toute la spécification de l'architecture.

4. Entraîner

Le chapitre 13 — la boucle d'entraînement livre la boucle :

• échantillonnage par batches de paires (entrée, cible) depuis train.bin
• AdamW avec weight decay 0,1 et betas (0,9 / 0,95)
• montée en température du learning rate puis décroissance en cosinus
• clipping du gradient à 1,0
• loss de validation tous les N pas
• checkpoint sauvegardé sur la meilleure validation

La visualisation du chapitre 13 trace la loss d'entraînement contre celle de validation en direct. Tu peux la lire comme un clinicien : surapprentissage, sous-apprentissage, learning rate trop haut ou trop bas, chacun a sa forme caractéristique.

5. Lire la courbe de loss

La courbe d'entraînement est le diagnostic le plus important dont tu disposes. The Loss Curve tire son nom de ce fait.

• Les deux courbes descendent en parallèle : l'entraînement est sain, le modèle a encore de la marge, continue.
• La validation s'aplatit pendant que l'entraînement continue de descendre : surapprentissage. Arrête, ou trouve plus de données.
• Les deux s'aplatissent haut : modèle sous-dimensionné, ou learning rate trop bas.
• La loss part en pic ou diverge : explosion du gradient. Baisse le learning rate ou renforce le clipping.

Le chapitre 13 déroule chaque cas avec des exemples concrets.

6. Générer

Une fois entraîné, le chapitre 14 — génération et échantillonnage transforme le modèle en générateur de texte, avec température, top-K et top-P. Le même checkpoint produira des sorties radicalement différentes selon les réglages — ça vaut la peine d'expérimenter avant de décider que le modèle est « fini ».

7. Charger des modèles pré-entraînés plus gros

Si ton modèle minuscule ne suffit pas, le chapitre 15 montre que la même architecture peut faire tourner GPT-2 124M avec les poids d'OpenAI — des ordres de grandeur plus gros, et ça tient encore sur un portable. Ensuite le chapitre 17 lui apprend à suivre des instructions et le chapitre 21 en livre une variante spécialisée.

Le chemin entre un modèle de 14M que tu as entraîné et un modèle de 124M que tu as fine-tuné, c'est un chapitre de plus et un téléchargement de 500 Mo.

8. La suite

• Pour une vue d'ensemble : Construire un LLM depuis zéro.
• Pour la visite PyTorch complète : Tutoriel LLM en PyTorch.
• Pour l'instruction tuning de ton modèle : le chapitre 17 et le guide LoRA.