Comment ça apprend

L'erreur, mesurée

Au début, le modèle est aléatoire. Donne-lui "Le ciel est", il prédira "banane" avec autant de probabilité que "bleu". Ce qu'on veut, c'est qu'il prédise "bleu" (ou un mot plausible).

Pour l'amener là, il faut deux choses :

1. Une mesure de à quel point il se trompe.
2. Un mécanisme pour corriger ses paramètres dans la bonne direction.

C'est tout l'entraînement.

La cross-entropy, sans la formule

À chaque étape, on donne au modèle un morceau de texte. Il prédit le prochain token sous forme de distribution (chapitre 01). On regarde la probabilité qu'il a donnée au token réellement présent dans le texte. Si elle est haute, il a raison. Si elle est basse, il a tort.

La cross-entropy mesure cette erreur en log-probabilité :

Plus le modèle est confiant et correct, plus la loss est petite. Plus il est confiant et faux, plus la loss explose.

C'est une mesure cruelle : assigner 0,01% à la bonne réponse coûte beaucoup plus cher qu'assigner 10%. Le modèle apprend à éviter les certitudes fausses.

Descendre la pente

Une fois la loss calculée, comment ajuste-t-on les paramètres ?

Imagine la loss comme une surface dans un espace gigantesque (autant de dimensions que de paramètres : des milliards). Le modèle est un point sur cette surface. On veut qu'il descende vers les vallées.

L'algorithme s'appelle descente de gradient : à chaque pas, on calcule la direction de la pente la plus descendante (le gradient) et on bouge un peu dans cette direction.

Paramètres ← Paramètres − η × Gradient

η (eta) est le learning rate : la taille du pas. Trop petit, on n'avance pas. Trop grand, on saute par-dessus la vallée et on diverge.

La courbe de loss descend par paliers — chaque palier correspond à un nouveau motif que le modèle a fini d'apprendre. Les quatre régimes de learning rate exposent les pièges classiques : trop bas, le modèle stagne ; trop haut, il diverge.

Trois régimes à observer dans la visualisation :

• LR très faible (≤ 0.001) — la courbe descend, mais lentement. Le modèle apprend, mais on n'a pas le temps d'attendre.
• LR optimal (≈ 0.01) — descente régulière, asymptote basse. C'est l'objectif.
• LR trop élevé (≥ 0.05) — la loss oscille, voire diverge. Le modèle "saute" par-dessus les minima sans pouvoir s'y poser.

En pratique, on ajuste le learning rate dynamiquement pendant l'entraînement : warmup linéaire au début (pour ne pas tout casser), puis décroissance cosinus.

Adam : la descente, en mieux

L'équation Paramètres ← Paramètres − η × Gradient décrit la descente de gradient pure. En pratique, personne ne l'utilise telle quelle pour entraîner un LLM.

L'optimiseur de référence s'appelle Adam (et sa variante moderne AdamW). L'idée : au lieu d'avancer aveuglément dans la direction du gradient courant, on garde une mémoire de la direction moyenne récente (le momentum) et de la variance des mises à jour pour chaque paramètre.

• Les paramètres dont le gradient pointe systématiquement dans la même direction prennent des grands pas.
• Ceux qui oscillent (gradient bruité) prennent des petits pas.

Adam s'adapte donc automatiquement à chaque paramètre, là où SGD applique le même learning rate à tous. C'est plus stable, et ça converge bien plus vite en pratique. AdamW (la version la plus utilisée) ajoute en plus une régularisation appelée weight decay qui empêche les poids d'exploser au fil de l'entraînement.

Aujourd'hui, entraîner un LLM sans AdamW est aussi rare que coder en assembleur sans bonne raison.

Backpropagation, en une phrase

Pour calculer le gradient — c'est-à-dire savoir comment chaque paramètre influe sur la loss — on utilise la rétropropagation. C'est un algorithme qui propage l'erreur depuis la sortie vers l'entrée du réseau, couche par couche, en appliquant la règle de dérivation en chaîne.

Tu n'as pas besoin de comprendre la dérivation pour intuiter ce qui se passe. Pense-le comme :

"Si j'avais tourné ce bouton de 0,001 unité, est-ce que la loss aurait monté ou descendu, et de combien ?"

La réponse à cette question, pour chacun des milliards de boutons du modèle, en parallèle, c'est exactement ce que fait la backprop. C'est ce qui rend possible d'entraîner un modèle de 70 milliards de paramètres en une dizaine de jours sur un cluster.

Pré-entraînement = lire l'internet

Pour qu'un LLM apprenne quelque chose d'utile, il faut beaucoup de texte. Beaucoup beaucoup. Les modèles modernes voient :

• 1 à 15 trillions de tokens en pré-entraînement
• Du texte filtré (Common Crawl, Wikipedia, livres, code, papiers)
• En passant plusieurs fois sur certaines parties (les meilleurs livres, plusieurs époques)

Pendant tout ce processus, la tâche est toujours la même : prédire le prochain token. Pas de question-réponse étiquetée, pas de "voici la bonne traduction", pas de récompense humaine. Juste du texte brut, et l'objectif de prédire la suite.

C'est ça qu'on appelle l'auto-supervision : la donnée fournit elle-même les "étiquettes". Pas besoin d'humains pour annoter — il suffit d'avoir du texte.

Batch size : combien d'exemples à la fois

On ne calcule jamais le gradient sur un seul exemple. On regroupe plusieurs séquences en un batch, on calcule le gradient moyen sur tout le batch, puis on met à jour les paramètres une seule fois.

Plus le batch est grand, plus le gradient est stable (moins de bruit), plus on peut utiliser un grand learning rate. Mais il faut suffisamment de mémoire GPU pour tout stocker.

Pour les LLMs modernes, le batch size effectif atteint plusieurs millions de tokens — souvent obtenu en combinant :

• Le batch local (par GPU) — limité par la VRAM.
• La gradient accumulation — calculer plusieurs petits batches et n'appliquer la mise à jour qu'à la fin.
• Le parallélisme de données — répartir le batch entre des dizaines, des centaines, parfois des milliers de GPUs.

Ce que les ingénieurs appellent le global batch size, c'est la quantité de données qui contribue à un seul pas d'optimisation. Pour GPT-4, on parle de millions de tokens par pas.

La donnée : la moitié du travail

On parle beaucoup de paramètres. On parle moins de la préparation des données — qui prend pourtant la moitié du temps de toute équipe sérieuse qui entraîne un modèle.

• Filtrage — éliminer le contenu de basse qualité (spam, pages d'erreur 404, contenu auto-généré, listes de produits sans contexte).
• Déduplication — retirer les doublons. Common Crawl contient beaucoup de copies des mêmes pages ; les laisser fait apprendre le modèle par cœur au lieu de généraliser.
• Mélange — équilibrer les sources (Wikipedia, livres, code, papiers scientifiques) selon leur valeur pédagogique, pas leur taille brute.
• Filtrage qualité — chez les meilleures équipes, un classifieur évalue chaque document pour ne garder que ce qui ressemble à du contenu de manuel ou d'article fouillé.
• Décontamination — vérifier que les benchmarks d'évaluation (MMLU, HumanEval…) ne fuitent pas dans le corpus d'entraînement.

Le résumé brutal d'un chercheur de Meta : « on passe 10 % du temps à entraîner le modèle, 90 % à préparer les données. »

C'est aussi pour ça que les meilleurs modèles ouverts (Llama, Mistral, DeepSeek) ne révèlent presque jamais le détail de leur recette de données : c'est leur principal avantage compétitif.

L'overfitting et la validation

Plus tu entraînes un modèle, plus il connaît son corpus par cœur. À un moment, il commence à mémoriser au lieu de généraliser. C'est l'overfitting.

Pour le détecter, on garde une partie du corpus à part — le validation set — sur lequel on n'entraîne pas. Pendant l'entraînement, on mesure la loss sur les deux. Tant que les deux descendent, tout va bien. Quand la loss de validation remonte alors que la loss d'entraînement continue à descendre, on commence à overfit. C'est le moment d'arrêter (ou d'augmenter la donnée, ou la régularisation).

Dans la visualisation, la courbe pointillée représente la loss de validation. Elle remonte légèrement à la fin — c'est exactement ça.

Compute = capacité

Une dernière chose. Pourquoi faut-il autant de paramètres et autant de données ? Parce que l'apprentissage suit des lois d'échelle (scaling laws) très régulières :

Loss = A × (Compute)^−α

Doubler le compute (paramètres × données × itérations) divise la loss par un facteur constant. La courbe est lisse, prévisible, sur 6 ordres de grandeur. C'est sur cette régularité que repose toute l'industrie : on sait à l'avance qu'investir 10× plus de GPU rapportera une amélioration mesurable.

On y revient en détail au chapitre 19 (lois d'échelle de Kaplan et Chinchilla) — y compris pourquoi GPT-3 était sous-entraîné en données et quel est le ratio optimal entre paramètres et tokens.

La suite

Le modèle pré-entraîné est maintenant un prédicteur de tokens très compétent. Il peut compléter n'importe quel texte avec un naturel saisissant. Mais ce n'est pas encore un assistant.

Avant d'arriver là, il y a une autre chose à comprendre : une fois la distribution prédite, comment choisit-on un token ? On revient sur ce point au chapitre suivant.

Mis à jour le 10 mai 2026