Lexique

Tous les termes techniques utilisés dans les chapitres. Survole un mot souligné dans un chapitre pour obtenir une définition rapide ; cette page contient les versions longues.

Adam: L’optimiseur le plus courant en deep learning moderne. Il garde des moyennes mobiles du gradient et du gradient au carré.; Combine le momentum (premier moment) avec une mise à l’échelle adaptative par dimension (second moment). Corrige le biais des deux. C’est l’optimiseur par défaut pour les transformers. AdamW est Adam avec un weight decay appliqué en dehors du gradient.
Alignement: Le travail qui transforme un prédicteur de prochain token en assistant utile : SFT, puis RLHF ou DPO sur préférences humaines.
Attention: Le mécanisme qui permet à un token de regarder d’autres tokens. Il calcule une somme pondérée de vecteurs de valeur.; Attention scalée par produit scalaire : A = softmax(QKᵀ / √d_k) · V. Q, K, V sont des projections de l’entrée. La matrice d’attention softmaxée indique, pour chaque token, combien il puise dans chacun des autres.
Attention multi-têtes: Plusieurs têtes d’attention en parallèle, chacune avec ses projections Q/K/V, puis concaténées et reprojetées.
Autograd: La différentiation automatique : la machinerie qui enregistre chaque opération de la passe avant et la rejoue à l’envers pour calculer les gradients, sans jamais les dériver à la main.; Chaque opération connaît sa dérivée locale. L’autograd les enchaîne par la règle de la chaîne, en ordre inverse. `loss.backward()` en PyTorch, c’est un appel à ce rejeu. L’annexe en construit une version minuscule pour que cet appel cesse d’être magique.
Batch: Un groupe d’exemples traités ensemble dans une même passe avant et arrière. Un batch plus gros donne un gradient moins bruité et exploite mieux le matériel, au prix de la mémoire.
Bigramme: Une paire de tokens consécutifs. C’est l’unité de contexte la plus simple qu’un modèle de langage puisse utiliser.; Un modèle bigramme donne une probabilité à un token uniquement à partir du token juste avant lui : P(w_t | w_{t-1}). Il ne voit pas plus loin qu’une position, mais c’est déjà un modèle de langage fonctionnel.
Byte-Pair Encoding (BPE): Méthode de tokenization qui part des caractères et fusionne progressivement la paire adjacente la plus fréquente.; À l’origine un algorithme de compression de données (1994). Utilisé par GPT-2/3/4 et la plupart des LLM modernes. Les fusions découvrent la morphologie : des suffixes comme « ing » ou « ed » émergent naturellement comme sous-mots fréquents.
Cache KV: Les clés et valeurs déjà calculées pour les tokens précédents, stockées pour que générer le token suivant coûte une nouvelle requête contre le cache au lieu de tout recalculer.; Sans cache, générer n tokens coûte O(n³) au total, puisque chaque étape ré-attend sur tout le préfixe. Avec un cache, chaque étape est en O(n) — c’est pour ça que le deuxième token d’une réponse arrive bien plus vite que le premier. Le prix, c’est la mémoire : le cache grandit linéairement avec le contexte.
Checkpoint: Un instantané sauvegardé des poids du modèle (plus l’état de l’optimiseur, si tu veux reprendre). C’est ce qui te permet d’arrêter un entraînement, de l’évaluer, de le fine-tuner ou de le livrer.
Connexion résiduelle: output = input + sublayer(input). Elle aide les gradients à circuler dans des piles profondes.
Corpus: Le texte utilisé pour entraîner, inspecter ou évaluer un modèle de langage. Une phrase, un livre, ou des milliards de mots récupérés sur le web.
Décodage glouton: Toujours prendre le token le plus probable. Déterministe et localement optimal — ce qui est exactement pourquoi il boucle et produit un texte plat.
Descente de gradient: Procédure d’optimisation : soustraire un petit multiple du gradient aux paramètres à chaque étape.
Distribution de probabilité: Une liste de valeurs positives qui somment à 1, une par résultat possible. La sortie d’un modèle de langage est une telle distribution sur le vocabulaire.
Dropout: Mettre à zéro une fraction aléatoire des activations pendant l’entraînement, pour que le réseau ne puisse s’appuyer sur aucune unité en particulier. Un régularisateur ; désactivé à l’inférence.
Échantillonnage: Tirer une valeur aléatoire selon une distribution de probabilité. Dans un modèle de langage, choisir le prochain token en tirant un nombre contre la sortie du modèle.; Les stratégies d’échantillonnage (greedy, temperature, top-k, top-p) répondent toutes à la même question — étant donné une distribution sur le vocabulaire, quel token émet-on ? — mais arbitrent différemment entre déterminisme et diversité.
Échantillonnage top-k: Ne garder que les k tokens les plus probables, renormaliser, puis échantillonner. Coupe la longue traîne de tokens invraisemblables qui seraient sinon tirés de temps en temps.
Embedding: Un vecteur dense et de faible dimension qui représente un token. Les mots utilisés dans des contextes proches finissent avec des vecteurs proches.; Les embeddings remplacent l’encodage one-hot des tokens par des vecteurs continus qui capturent des relations sémantiques. La géométrie de l’espace d’embeddings est porteuse de sens : certaines directions encodent des traits comme le genre, le registre ou la formalité.
Embedding positionnel: Un vecteur ajouté à l’embedding de chaque token pour encoder *où* il se trouve dans la séquence. Sans lui, l’attention verrait la phrase comme un sac de tokens sans ordre.; L’attention est équivariante par permutation : mélange l’entrée, la sortie se mélange pareil. La position doit donc être injectée explicitement. GPT-2 apprend un vecteur par position (une simple table) ; les modèles récents utilisent souvent RoPE, qui fait tourner requêtes et clés d’un angle proportionnel à la position et s’étend mieux aux longs contextes.
Encodage one-hot: Un vecteur rempli de zéros avec un seul 1 à la position du token. Simple, mais très gaspilleur.
Entraînement: Ajuster les paramètres d’un modèle pour qu’il fasse mieux son travail sur un jeu de données. Pour un modèle de langage, cela revient à baisser la loss next-token sur le jeu d’entraînement.; Entraîner un bigramme se résume à incrémenter des compteurs. Entraîner un réseau de neurones, c’est faire tourner la descente de gradient sur des millions à des billions de paramètres. La boucle — mesurer son erreur, changer quelque chose pour la réduire, recommencer — est la même.
Entropie: Mesure d’étalement d’une distribution de probabilité. H = -Σ p log p. Une entropie basse veut dire concentrée sur peu de résultats ; haute, presque uniforme.
Entropie croisée: La loss standard pour la classification : −Σ y·log(p). Elle s’accorde naturellement avec softmax et sigmoïde.
Époque: Un passage complet sur le jeu d’entraînement. Les grands modèles de langage en terminent rarement une seule : ils tirent des batches dans un flux et comptent des steps.
Fenêtre de contexte: Le nombre maximal de tokens sur lesquels le modèle peut porter attention d’un coup. Tout ce qui en sort lui est invisible : il n’y a pas de mémoire au-delà de la fenêtre.
Fine-tuning: Poursuivre l’entraînement d’un modèle pré-entraîné sur un jeu de données plus petit et ciblé, pour qu’il se spécialise sans réapprendre la langue depuis zéro.
Forme d’entrée: Les dimensions du tenseur d’entrée d’une couche de réseau de neurones. Par exemple, [batch_size, sequence_length] pour du texte.
GELU: Approximation lisse de ReLU utilisée dans les transformers. En gros x·Φ(x), où Φ est la CDF gaussienne.
Génération: Produire une nouvelle séquence de tokens en échantillonnant le modèle un pas à la fois. Chaque token émis devient l’entrée du pas suivant.
Gradient: Vecteur des dérivées partielles de la loss par rapport aux paramètres. Il indique dans quel sens ajuster chaque paramètre.
Hors vocabulaire: Un token ou une paire jamais observée à l’entraînement. Un modèle non lissé ne peut pas lui donner de probabilité.
Hyperparamètre: Un nombre qui contrôle l’entraînement mais n’est pas appris par l’optimiseur : learning rate, batch size, taille cachée, dropout, etc. C’est toi qui les fixes.
Inférence: Faire tourner un modèle entraîné sur de nouvelles entrées pour obtenir des prédictions. L’inverse de l’entraînement : aucun paramètre ne bouge.
Jeu de validation: Portion des données que le modèle ne voit jamais pendant l’entraînement. Sert à estimer la perplexité (ou tout autre score) sur des données qu’il n’a pas pu mémoriser.; Un split typique : 80 % entraînement / 10 % validation / 10 % test. La validation guide les décisions pendant le développement (quels hyperparamètres ? quand arrêter ?) ; le test n’est touché qu’une fois à la fin pour reporter un chiffre final.
Kneser-Ney: Un lissage plus fin qui retire une petite masse aux transitions vues et la redistribue via un repli mieux pensé qu’uniforme.
Learning rate: Le scalaire qui multiplie chaque pas de descente de gradient. Trop petit et l’entraînement traîne ; trop grand et la loss diverge. L’hyperparamètre le plus important.
Lissage: Famille de techniques qui donnent une probabilité positive à chaque transition possible, même jamais vue à l’entraînement.; Sans lissage, un modèle n-gramme s’effondre à perplexité = ∞ dès qu’il rencontre une transition inédite sur le jeu de validation. Laplace add-α et Kneser-Ney sont les deux méthodes classiques.
Lissage de Laplace: Le lissage le plus simple : ajouter une constante α à chaque cellule de la table de comptage avant de normaliser.
LLM (large language model): Un modèle de langage avec assez de paramètres et de données d’entraînement pour produire du texte cohérent sur plusieurs paragraphes. Les LLM modernes sont des transformers avec des milliards à des billions de paramètres.; Il n’y a pas de seuil exact de taille — « large » est une cible mouvante. En pratique, le terme couvre les modèles de langage à base de transformer à partir de quelques centaines de millions de paramètres, entraînés sur des centaines de milliards de tokens.
Logits: Les scores bruts, non normalisés, produits par le modèle — un par token du vocabulaire. Le softmax les transforme en probabilités ; avant ça, ce sont des réels quelconques.; La dernière couche produit un logit par token du vocabulaire, pour chaque position. Rien n’en fait encore une probabilité : ils peuvent être négatifs et leur somme ne vaut pas 1. L’échantillonnage agit sur les logits (la température les divise) puis sur les probabilités qui en découlent (top-k et top-p les filtrent).
Loi de scaling: Observation empirique : la qualité progresse de façon prévisible avec les paramètres, les tokens d’entraînement et le compute.
LoRA: Low-Rank Adaptation. Fine-tune un modèle sans réentraîner ses poids : on fige W et on apprend une petite mise à jour A·B.
Loss: Un nombre qui dit à quel point le modèle se trompe sur la bonne réponse. L’entraînement la minimise.; Pour un modèle de langage, la loss par token est typiquement −log(probabilité) attribuée par le modèle au vrai prochain token. Sa somme ou moyenne sur une séquence donne un nombre comparable par token. La cross-entropy est la formulation standard.
Masque causal: Contrainte qui empêche le token i de voir les tokens futurs j > i pendant l’entraînement.
Masque de loss: Un vecteur de 0 et de 1, un par token, qui dit quelles positions contribuent à la loss. En SFT, les tokens du prompt reçoivent 0 et ceux de la réponse 1.
MLP (perceptron multicouche): Deux couches linéaires ou plus empilées avec des non-linéarités entre elles. Peut apprendre des frontières non linéaires.
Modèle de langage: Un modèle qui attribue une probabilité au token suivant à partir des tokens précédents. La génération est un échantillonnage répété de cette probabilité.; Tous les LLM modernes sont des modèles de langage : on leur donne une séquence de tokens, ils produisent une distribution de probabilité sur le vocabulaire. Le bigramme du chapitre 1, le transformer du chapitre 10 et GPT-4 partagent cette interface — seule la fonction au milieu change.
Momentum: Astuce qui accumule une vitesse issue des gradients récents. Elle lisse la trajectoire quand les pas se renforcent.
Multiplication matricielle: (A · B)[i,j] = Σ_k A[i,k] · B[k,j]. Le cœur arithmétique de chaque couche de réseau de neurones ; les GPU modernes et Apple Silicon ont des chemins dédiés pour l’accélérer.
Neurone: Somme pondérée des entrées suivie d’une non-linéarité : σ(Σ w_i·x_i + b). La plus petite unité apprenable d’un réseau.
Normalisation de couche: Normalise le vecteur d’activation de chaque token à moyenne 0 et écart-type 1. Stabilise les échelles entre couches.
Optimiseur: La règle qui transforme les gradients en mises à jour de paramètres. SGD soustrait le gradient ; le momentum l’accumule ; Adam le met à l’échelle paramètre par paramètre selon son amplitude récente.
Paramètre: Un des nombres apprenables du modèle. Les LLM modernes en ont des milliards à des billions ; le bigramme du chapitre 1 en a |vocab|² (un par cellule de la table de comptage).
Partage de poids (weight tying): Partager une seule matrice entre l’embedding de tokens et la projection de sortie. Économise vocab_size × n_embd paramètres, en général sans coût de qualité.
Perplexité: Moyenne géométrique de l’inverse des probabilités sur une séquence. Elle baisse quand le modèle donne de fortes probabilités aux tokens observés.; Reportée comme exp(moyenne de la log-vraisemblance négative). Métrique d’évaluation classique pour les modèles de langage. Une perplexité de 50 signifie que le modèle est, en moyenne, aussi indécis que s’il devait choisir uniformément entre 50 tokens équiprobables.
Prefill: La première passe, où tout le prompt est traité d’un coup pour remplir le cache KV. Elle détermine le temps jusqu’au premier token ; le décodage token par token qui suit est bien moins cher.
Quantification: Stocker les poids en entiers basse précision (INT8, INT4) plutôt qu’en floats. Réduit taille et coût d’inférence.
Query / Key / Value: Trois projections de l’entrée utilisées par l’attention. Les queries demandent, les keys annoncent, les values contribuent.
ReLU: Rectified linear unit : max(0, x). La non-linéarité standard dans beaucoup de réseaux modernes.
Réseau feed-forward: Le MLP par token à l’intérieur d’un bloc transformer : deux couches linéaires séparées par une non-linéarité, appliquées indépendamment à chaque position. C’est là que vivent la plupart des paramètres du modèle.
Rétropropagation: Algorithme qui calcule le gradient de la loss par rapport à chaque paramètre en remontant la règle de chaîne à travers les opérations du réseau.
SFT (fine-tuning supervisé): Fine-tuning sur des paires prompt/réponse écrites par des humains, pour qu’un prédicteur de token brut apprenne la forme d’une réponse. L’étape la moins chère et la plus rentable pour passer du modèle de base à l’assistant.; L’astuce qui fait marcher le SFT, c’est le masque de loss : la loss ne compte que sur les tokens de la réponse, jamais sur ceux du prompt. Le modèle apprend à *produire* des réponses, pas à répéter des questions.
Sigmoïde: Fonction σ(x) = 1 / (1 + e^(-x)) qui ramène n’importe quel réel dans (0, 1).
Similarité cosinus: Mesure de l’alignement entre deux vecteurs : cos(a, b) = (a · b) / (‖a‖·‖b‖).
Skip-gram: Algorithme qui apprend des embeddings en rapprochant le vecteur d’un mot central des vecteurs de ses voisins.
Softmax: Normalise un vecteur de réels en distribution de probabilité : exp(x_i) / Σ exp(x_j).
Sous-mot: Un token plus court qu’un mot mais plus long qu’un caractère. C’est la granularité vers laquelle BPE converge.
Surapprentissage: Quand un modèle mémorise ses données d’entraînement au lieu d’apprendre le motif derrière. La signature : la loss d’entraînement continue de baisser pendant que la loss de validation remonte.
Taille de bloc: Longueur maximale de contexte utilisée pendant l’entraînement. Elle fixe combien de tokens d’historique le modèle peut voir.
Température: Un diviseur appliqué aux logits avant le softmax. Sous 1, la distribution se resserre (plus sûr, plus répétitif) ; au-dessus, elle s’aplatit (plus surprenant, moins cohérent).; La température 0 est le cas limite : la distribution s’effondre sur son maximum et l’échantillonnage devient un argmax. C’est le bouton de génération le plus utile, et le premier à toucher quand la sortie est soit trop fade, soit délirante.
Template de chat: Le format exact qui sépare les tours système, utilisateur et assistant. Le modèle n’a aucune notion de rôle — c’est le template qui rend l’alternance visible pour lui.
Token: L’unité de base qu’un modèle lit et écrit. Souvent un sous-mot, parfois un mot, parfois un caractère.; La tokenization est la première étape d’un pipeline de modèle de langage. Les tokenizers par espaces coupent les mots ; les tokenizers BPE apprennent une granularité entre mots et caractères.
Token de départ: Le premier token (ou un court prompt) que tu donnes à un modèle de langage pour démarrer la génération. Tout ce qui suit est échantillonné.
Tokenizer: La fonction qui découpe le texte brut en tokens. Du plus naïf (espaces + minuscules) aux schémas appris comme BPE.
Top-p (échantillonnage nucleus): Garder le plus petit ensemble de tokens dont les probabilités somment à p, renormaliser, puis échantillonner. Contrairement au top-k, la taille de cet ensemble s’adapte à la confiance du modèle.
Transformer: Architecture composée de blocs empilés attention multi-têtes + FFN avec résidus et layer norms. Dominante pour les LLM depuis 2017.
Vocabulaire: L’ensemble des tokens distincts qu’un modèle peut lire ou produire. Sa taille va d’environ 80 en caractères à près de 100 000 pour les tokenizers modernes.
Warmup: Faire monter le learning rate depuis presque zéro sur les premières centaines de steps. Les premiers gradients sont grands et mal calibrés ; le warmup les empêche de détruire les poids initiaux.