Module 1 — Ce que change réellement le passage à l'échelle

Le cours 12 a présenté le Transformer, celui qui produit un vecteur pour chaque jeton d'une séquence. Ce module ouvre le cours par une question qui paraît naïve mais qui décide de tout : pourquoi rendre un tel modèle plus grand ? Un projet réel — un assistant de support client en français — sert de fil rouge tout au long des dix modules. Pour ce premier module, la décision qui nous occupe est le choix du modèle : ouvert ou propriétaire, 7 milliards ou 70 milliards de paramètres.

Trois axes d'échelle, pas un seul

Quand on dit qu'un modèle « grandit », on mélange en fait trois grandeurs qui n'évoluent pas ensemble : le nombre de paramètres $N$, le volume de jetons d'entraînement $D$ et le calcul total $C$ mesuré en FLOP. Un modèle deux fois plus gros entraîné sur les mêmes données n'est pas forcément deux fois meilleur ; il peut même être moins bon parce qu'il n'a pas vu assez d'exemples pour peupler ses paramètres supplémentaires.

Le cours 12 a établi que le calcul par jeton d'un Transformer est proche de $6N$ pour l'entraînement, ce qui donne l'approximation utilisée partout :

$$C \approx 6 \cdot N \cdot D.$$

Pour un modèle de 7 milliards de paramètres entraîné sur 2 000 milliards de jetons, le calcul total atteint environ $8{,}4 \times 10^{22}$ FLOP. Ce chiffre paraît abstrait ; il correspond à peu près à un mois d'occupation d'un millier d'accélérateurs modernes. C'est cette contrainte matérielle qui rend le préentraînement des LLM inaccessible à la plupart des équipes, et qui justifie l'existence même des modèles ouverts.

Chronologie : de GPT-2 à aujourd'hui

Une chronologie très resserrée aide à voir où l'on en est.

Année	Modèle représentatif	Paramètres	Ce qui a changé
2019	GPT-2	1,5 milliard	Génération cohérente à quelques centaines de jetons
2020	GPT-3	175 milliards	Apprentissage en contexte devient utilisable
2022	ChatGPT (dérivé)	≈ 175 milliards	Alignement par RLHF, produit grand public
2023	LLaMA, Mistral	7 à 70 milliards	Modèles ouverts compétitifs
2024-2026	Familles ouvertes	7 à 400 milliards	Diversité de licences, mélange d'experts, contextes longs

Ce qui a changé n'est pas uniquement la taille : c'est le rapport entre taille et données, la qualité du filtrage, l'alignement post-préentraînement (module 4) et, plus récemment, la mise en service à coût raisonnable (module 8). Un modèle ouvert de 7 milliards de 2026 dépasse largement GPT-3 de 2020, malgré vingt-cinq fois moins de paramètres. La conclusion pratique : la génération d'un modèle compte souvent plus que sa taille brute.

L'apprentissage en contexte, la nouveauté majeure

Le fait remarquable, apparu vers GPT-3, est que le modèle apprend une tâche à la volée à partir d'exemples placés dans son invite, sans aucune mise à jour de poids. C'est l'apprentissage en contexte, aussi appelé apprentissage à quelques exemples.

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

nom = "meta-llama/Meta-Llama-3-8B-Instruct"
tok = AutoTokenizer.from_pretrained(nom)
modele = AutoModelForCausalLM.from_pretrained(nom, torch_dtype=torch.bfloat16, device_map="auto")

invite = (
    "Classe le sentiment (positif, neutre, négatif).\n"
    "Message : « Livraison en retard, mais produit correct. »\n"
    "Sentiment : neutre\n"
    "Message : « Service au top, je recommande. »\n"
    "Sentiment : positif\n"
    "Message : « Colis abîmé et remboursement refusé. »\n"
    "Sentiment :"
)

entrees = tok(invite, return_tensors="pt").to(modele.device)
sortie = modele.generate(**entrees, max_new_tokens=4, do_sample=False)
print(tok.decode(sortie[0][entrees["input_ids"].shape[1]:], skip_special_tokens=True))

Trois exemples suffisent à conditionner le modèle sur la tâche. Aucun gradient n'a été calculé, aucun poids n'a bougé. La performance monte souvent au niveau d'un modèle affiné sur quelques centaines d'exemples, sans jamais toucher au modèle. C'est ce phénomène qui a transformé la manière de développer avec les LLM : on passe du couple « données annotées + entraînement » au couple « invite + exemples », au moins pour les prototypes.

Capacités émergentes, un débat de mesure

La littérature a beaucoup parlé de « capacités émergentes » : des tâches sur lesquelles un modèle passe brusquement de zéro à une performance utile une fois franchi un certain seuil de calcul. L'exemple classique est l'arithmétique à plusieurs chiffres, longtemps mauvaise puis soudain correcte.

Une partie de cette émergence tient au choix de la métrique. Une note d'exactitude stricte — la réponse est juste ou fausse — cache une amélioration continue de la vraisemblance de la bonne réponse. Un article influent de 2023 a montré qu'en remplaçant l'exactitude par une métrique lisse, la courbe redevient régulière et la « discontinuité » disparaît. Cela ne veut pas dire que rien n'émerge, mais qu'il faut se méfier des seuils tranchés annoncés dans les billets de blog.

Ne pas confondre corrélation d'échelle et cause

Une courbe de performance qui monte avec la taille du modèle ne dit pas ce qui, dans le modèle, produit le progrès. Souvent, un doublement de la taille s'accompagne d'un doublement des données et d'un meilleur filtrage : trois causes emmêlées. Les études les plus solides gardent deux axes constants et ne font varier que le troisième, ce que les acteurs privés ne publient presque jamais.

Ouvert contre propriétaire : la décision du fil rouge

Pour notre assistant de support, deux voies sont ouvertes.

• Un modèle propriétaire, appelé par API : coût par million de jetons, latence stable, mise à jour transparente, mais dépendance à un fournisseur et données envoyées à l'extérieur.
• Un modèle ouvert de 7 à 8 milliards de paramètres en licence permissive : contrôle total, coût variable selon le trafic, mais responsabilité de la mise en service et des mises à jour.

Le critère décisif dépasse la performance brute. Trois questions suffisent en général :

1. Les messages contiennent-ils des données personnelles qui ne peuvent pas quitter l'infrastructure ?
2. Le trafic est-il assez régulier pour amortir une machine dédiée, ou bien très pointu ?
3. L'équipe a-t-elle la compétence pour maintenir un service GPU en production ?

Le module 10 chiffrera précisément ces arbitrages ; retenons pour l'instant qu'un modèle ouvert de 8 milliards, servi avec vLLM sur un accélérateur unique, traite plusieurs dizaines de requêtes par seconde à des coûts qui deviennent compétitifs dès quelques milliers de conversations quotidiennes.

Le bon test au démarrage

Avant de choisir la taille et la licence, prenez cinquante messages réels du service client et faites deux essais aveugles : le modèle ouvert de 8 milliards avec un affinage léger, et le modèle propriétaire par API. La différence perçue par un opérateur humain est presque toujours plus faible que ce que suggèrent les jeux de référence publics.

En résumé

• Trois grandeurs — paramètres $N$, jetons $D$ et calcul $C$ — évoluent ensemble mais pas dans les mêmes proportions ; la relation $C \approx 6 N D$ fixe le budget.
• Un modèle ouvert récent de 7 milliards dépasse un modèle propriétaire de 175 milliards de la génération précédente ; la génération pèse souvent plus que la taille brute.
• L'apprentissage en contexte permet de conditionner un modèle sur une tâche par quelques exemples dans l'invite, sans aucun entraînement, et c'est le vrai changement qualitatif apporté par l'échelle.
• Les capacités dites « émergentes » sont réelles mais dépendent de la métrique : une exactitude stricte crée des seuils que des mesures lisses effacent.

Module suivant : ce qui se passe pendant le préentraînement lui-même, comment les données sont préparées et pourquoi la loi de Chinchilla contraint la taille des modèles.