Bienvenue dans cet atelier pratique dédié à l’un des concepts les plus importants de l’intelligence artificielle moderne : l’architecture Transformer. Ces modèles sont le moteur de la révolution de l’IA générative, propulsant des outils que vous utilisez peut-être quotidiennement, comme ChatGPT.
Pour passer de la simple utilisation à une véritable compréhension, il est essentiel de maîtriser leurs mécanismes internes. C’est l’objectif de la série d’exercices qui suit. Conçue comme un parcours d’apprentissage progressif pour débutants, elle vous guidera pas à pas à travers les concepts fondamentaux : de la manière dont le texte est transformé en nombres (tokenisation et embeddings) jusqu’au cœur battant du système, le fameux mécanisme d’auto-attention. À la fin de cette série, vous aurez bâti une intuition solide sur le fonctionnement interne des LLMs
Exercice 1 : Le Sac de Mots (Bag-of-Words)
Exercice
Considérez la phrase suivante : « Le chat dort et le chien dort ». En utilisant le modèle “Sac de Mots” (Bag-of-Words), comment cette phrase serait-elle représentée sous forme de vecteur, en comptant la fréquence de chaque mot ?
Solution
Vocabulaire : {Le, chat, dort, et, chien}
Vecteur de fréquence : {le: 2, chat: 1, dort: 2, et: 1, chien: 1}
Ce qui peut être représenté par le vecteur numérique : [2, 1, 2, 1, 1]
Explication
Le modèle “Sac de Mots” est l’une des approches les plus simples pour représenter du texte numériquement. Il fonctionne en trois étapes :
Tokenisation : On décompose la phrase en mots (tokens) : “Le”, “chat”, “dort”, “et”, “le”, “chien”, “dort”.
Création du vocabulaire : On liste tous les mots uniques, sans répétition : {“Le”, “chat”, “dort”, “et”, “chien”}.
Vectorisation : Pour chaque mot du vocabulaire, on compte son nombre d’apparitions dans la phrase d’origine. Le mot “Le” apparaît 2 fois, “chat” 1 fois, “dort” 2 fois, etc. Le vecteur final représente ces fréquences. Notez que ce modèle perd complètement l’ordre et le contexte des mots.
Exercice 2 : Limites du Sac de Mots et Avantages des Embeddings
Exercice
Quelle est la principale faiblesse du modèle “Sac de Mots” que les “Word Embeddings” (plongements de mots) cherchent à résoudre ?
Solution
La principale faiblesse du modèle “Sac de Mots” est qu’il ne capture aucune relation sémantique (de sens) entre les mots. Pour lui, les mots “roi” et “reine” sont aussi différents que les mots “roi” et “banane”. Les “Word Embeddings” résolvent ce problème en représentant les mots par des vecteurs denses dans un espace où la distance et la direction entre les vecteurs capturent leur relation sémantique.
Explication
Les embeddings, comme ceux de Word2Vec, apprennent des représentations vectorielles où les mots ayant des contextes similaires dans un grand corpus de textes se retrouvent proches dans l’espace vectoriel. Par exemple, le vecteur de “reine” sera très proche de celui de “roi”. On peut même y effectuer des opérations mathématiques, comme la célèbre analogie : vecteur(“roi”) – vecteur(“homme”) + vecteur(“femme”) ≈ vecteur(“reine”). Cette capacité à capturer le sens est fondamentale pour les modèles de langage modernes.
Exercice 3 : L'innovation clé de l'architecture Transformer
Exercice
Quel est le mécanisme central introduit par le papier “Attention Is All You Need” qui a révolutionné le traitement du langage et qui est au cœur de l’architecture Transformer ?
Solution
Le mécanisme de l’auto-attention (self-attention).
Explication
Avant les transformeurs, les modèles comme les RNN et LSTM traitaient les séquences mot par mot, ce qui rendait difficile la capture de dépendances à longue distance et limitait la parallélisation des calculs. L’auto-attention permet au modèle de peser l’importance de tous les autres mots de la séquence pour chaque mot qu’il traite. Il peut ainsi regarder l’ensemble de la phrase en une seule fois et déterminer quelles parties du contexte sont les plus pertinentes pour comprendre un mot donné, peu importe leur distance. C’est cette capacité à gérer le contexte globalement qui a rendu les transformeurs si puissants.
Exercice 4 : Tokenisation par sous-mots (Subword Tokenization)
Exercice
Pourquoi les LLMs modernes comme GPT utilisent-ils une tokenisation par sous-mots (ex: BPE, WordPiece) plutôt qu’une tokenisation par mots entiers ? Donnez deux avantages majeurs.
Solution
Gestion du vocabulaire : Elle permet de gérer un vocabulaire de taille fixe et raisonnable. Les mots rares ou nouveaux peuvent être décomposés en sous-mots connus, évitant ainsi les tokens “inconnus” (out-of-vocabulary).
Partage de sens : Elle capture les relations morphologiques. Des mots comme “manger”, “mangeons”, “mangeaient” seront décomposés en une racine commune (“mang”) et des terminaisons, permettant au modèle de comprendre qu’ils sont liés.
Explication
Une tokenisation par mots entiers nécessiterait un vocabulaire gigantesque pour couvrir toutes les formes d’un mot (pluriels, conjugaisons) et les mots rares. La tokenisation par sous-mots est un compromis intelligent : les mots fréquents restent un seul token (“le”, “chat”), tandis que les mots plus rares ou complexes sont décomposés en unités plus petites et récurrentes. Par exemple, “anticonstitutionnellement” pourrait devenir [“anti”, “constitution”, “nellement”], des pièces que le modèle a probablement déjà vues dans d’autres contextes.
Exercice 5 : Tokenisation pratique avec Hugging Face
Exercice
En utilisant la bibliothèque transformers de Hugging Face, montrez le code Python simple pour tokeniser la phrase “L’IA transforme le monde.” avec le tokenizer camembert-base et affichez les input_ids résultants.
Solution
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("camembert-base")
phrase = "L'IA transforme le monde."
inputs = tokenizer(phrase)
input_ids = inputs["input_ids"]
print(f"Phrase: {phrase}")
print(f"Input IDs: {input_ids}")
# La sortie sera quelque chose comme :
# Phrase: L'IA transforme le monde.
# Input IDs: [5, 144, 2531, 12028, 121, 622, 6, 4]
Explication
from transformers import AutoTokenizer : On importe la classe nécessaire.
tokenizer = AutoTokenizer.from_pretrained(“camembert-base”) : On charge un tokenizer pré-entraîné, ici CamemBERT, un modèle français.
tokenizer(phrase) : On applique le tokenizer à notre phrase. Il la nettoie, la décompose en tokens selon son vocabulaire appris, et convertit ces tokens en identifiants numériques (input_ids).
Le résultat [5, 144, 2531, 12028, 121, 622, 6, 4] est la séquence de nombres qui sera effectivement envoyée au modèle. Chaque nombre correspond à un token spécifique dans le vocabulaire du tokenizer. Les tokens 5 et 6 sont souvent des tokens spéciaux comme <s> (début de séquence) et </s> (fin de séquence).
Exercice 6 : Les trois étages principaux d'un Transformer
Exercice
Nommez et décrivez brièvement les trois étages principaux par lesquels passe une information dans un LLM de type Transformer, de l’entrée de texte brute à la sortie finale.
Solution
Étage d’Entrée (Tokenisation et Embedding) : Le texte brut est converti en tokens, puis chaque token est transformé en un vecteur numérique (embedding) qui capture son sens. Un embedding de position est ajouté pour informer le modèle de l’ordre des mots.
Pile de Blocs Transformer : C’est le cœur du modèle. Les vecteurs passent à travers une série de blocs Transformer identiques. Chaque bloc affine la représentation des vecteurs en utilisant des mécanismes d’auto-attention et des réseaux de neurones feed-forward pour enrichir chaque token avec le contexte de toute la séquence.
Tête du Modèle (Model Head) : C’est la couche de sortie. Elle prend les vecteurs finaux, affinés par les blocs, et les projette dans un espace de sortie spécifique à la tâche. Pour la génération de texte, elle produit une distribution de probabilité sur l’ensemble du vocabulaire pour prédire le prochain mot.
Explication
Cette architecture en trois parties est modulaire et puissante. L’étage d’entrée prépare les données. La pile de blocs (le “moteur”) analyse et contextualise ces données en profondeur. La tête de sortie adapte le résultat à une tâche précise (génération, classification, etc.).
Exercice 7 : L'importance de l'embedding de position
Exercice
Le mécanisme d’auto-attention traite tous les mots d’une phrase simultanément, sans notion d’ordre inhérente. Comment un Transformer sait-il alors si le mot “chat” est au début ou à la fin de la phrase “Le chat poursuit la souris” ?
Solution
Grâce aux embeddings de position (positional embeddings).
Explication
Avant d’entrer dans le premier bloc Transformer, un vecteur représentant la position de chaque token dans la séquence (position 1, position 2, etc.) est ajouté au vecteur d’embedding du token lui-même. Cette “information de position” est conservée et utilisée tout au long du traitement dans les blocs. Sans cela, les phrases “Le chat poursuit la souris” et “La souris poursuit le chat” seraient vues comme identiques par le mécanisme d’attention, car elles contiennent les mêmes mots. L’embedding de position est donc crucial pour préserver l’ordre séquentiel de l’information.
Exercice 8 : Composants d'un Bloc Transformer
Exercice
Un bloc Transformer standard est composé de deux sous-couches principales. Quelles sont-elles ?
Solution
Une couche d’auto-attention multi-têtes (Multi-Head Self-Attention).
Un réseau de neurones feed-forward (Position-wise Feed-Forward Network).
Explication
Chaque bloc applique ces deux opérations en séquence.
L’auto-attention permet aux tokens d’interagir les uns avec les autres et de s’échanger de l’information contextuelle. C’est l’étape où le modèle “lit” la phrase et comprend les relations entre les mots.
Le réseau feed-forward traite ensuite chaque token de manière isolée pour approfondir sa représentation, en s’appuyant sur l’information contextuelle qu’il vient de recevoir. On peut voir cela comme une étape de “réflexion” ou de traitement plus profond sur chaque mot enrichi de son contexte. Des connexions résiduelles et des normalisations de couche sont également utilisées autour de ces deux sous-couches pour stabiliser l’apprentissage.
Exercice 9 : Le but de l'auto-attention
Exercice
En termes simples, que calcule le mécanisme d’auto-attention pour un mot donné dans une phrase ?
Solution
Il calcule un “score d’attention” ou de pertinence entre ce mot et tous les autres mots de la phrase (y compris lui-même). Ce score détermine à quel point le modèle doit “prêter attention” à chaque autre mot pour mieux comprendre le mot actuel.
Explication
Imaginez que vous lisiez le mot “il” dans la phrase “Le robot est fatigué car il a beaucoup travaillé”. Pour comprendre à qui “il” se réfère, le mécanisme d’auto-attention va calculer des scores élevés entre “il” et “robot”, indiquant une forte connexion. Les scores avec “fatigué” ou “travaillé” seront également importants. En revanche, le score entre “il” et “Le” sera probablement faible. Le résultat final est une nouvelle représentation du mot “il” qui est enrichie par les informations des mots les plus pertinents de la phrase.
Exercice 10 : Les vecteurs Clé, Requête et Valeur (K, Q, V)
Exercice
Dans le mécanisme d’auto-attention, chaque embedding de mot est projeté en trois vecteurs distincts : Requête (Query), Clé (Key) et Valeur (Value). Quelle est l’analogie commune utilisée pour expliquer leur rôle ?
Solution
L’analogie d’une recherche dans une base de données ou une bibliothèque.
Requête (Query) : C’est ce que vous cherchez. C’est le mot actuel qui essaie de trouver du contexte.
Clé (Key) : Ce sont les “étiquettes” ou “mots-clés” de tous les autres mots de la phrase. La requête est comparée à chaque clé pour trouver une correspondance.
Valeur (Value) : C’est le contenu réel, l’information que chaque mot détient. Une fois que la requête a trouvé les clés les plus pertinentes, on récupère les valeurs correspondantes.
Explication
Pour un mot donné, sa Requête est comparée (via un produit scalaire) à la Clé de tous les autres mots. Le résultat de cette comparaison donne le score d’attention. Ces scores sont ensuite utilisés pour pondérer les vecteurs Valeur de tous les mots. Ainsi, la nouvelle représentation du mot est une somme pondérée des Valeurs de toute la phrase, où les poids sont déterminés par la compatibilité Requête-Clé.
Exercice 11 : Calcul simplifié d'un score d'attention
Exercice
Supposons que pour la phrase “le robot pense”, le vecteur Requête (Q) du mot “pense” soit [1, 0] et le vecteur Clé (K) du mot “robot” soit [0.8, 0.6]. Calculez le score d’attention brut (avant normalisation) entre ces deux mots en utilisant le produit scalaire.
Solution
Score = Q · K = (1 * 0.8) + (0 * 0.6) = 0.8 + 0 = 0.8
Explication
Le calcul du score d’attention est la première étape du mécanisme. La méthode la plus courante est le produit scalaire (dot product) entre le vecteur Requête du mot qui “regarde” et le vecteur Clé du mot qui est “regardé”.
Q_pense = [1, 0]
K_robot = [0.8, 0.6]
Score(pense, robot) = Q_pense · K_robot
Le calcul est (1 * 0.8) + (0 * 0.6) = 0.8.
Un score plus élevé indique une plus grande pertinence. Ce calcul serait répété pour Q_pense avec les Clés de tous les autres mots de la phrase.
Exercice 12 : Rôle de la fonction Softmax
Exercice
Après avoir calculé les scores d’attention bruts pour un mot avec tous les autres mots de la séquence, quelle fonction mathématique est appliquée et quel est son but ?
Solution
La fonction Softmax. Son but est de convertir les scores bruts (qui peuvent être n’importe quel nombre positif ou négatif) en une distribution de probabilité, c’est-à-dire une série de poids positifs dont la somme est égale à 1.
Explication
Les scores bruts (ex: 0.8, 0.1, 5.2) sont difficiles à interpréter. La fonction Softmax les transforme en un ensemble de poids clairs, par exemple [0.15, 0.05, 0.80]. Cela signifie que pour comprendre le mot actuel, le modèle doit accorder 15% de son “attention” au premier mot, 5% au deuxième, et 80% au troisième. Ces poids sont ensuite utilisés pour faire une moyenne pondérée des vecteurs Valeur, créant ainsi la nouvelle représentation contextualisée du mot.
Exercice 13 : L'attention Multi-Têtes (Multi-Head Attention)
Exercice
Lors de la génération de texte (inférence), un LLM génère un mot à la fois. Quel mécanisme d’optimisation courant, lié à l’attention, permet d’accélérer considérablement ce processus en évitant des calculs redondants ?
Solution
Le cache Clé-Valeur (KV Cache).
Explication
Pour générer le 10ème mot d’une phrase, le modèle doit calculer l’attention en se basant sur les 9 mots précédents. Pour générer le 11ème mot, il doit se baser sur les 10 mots précédents. Sans optimisation, il recalculerait à chaque étape les vecteurs Clé (K) et Valeur (V) pour tous les mots déjà générés. Le KV Cache consiste à stocker en mémoire les vecteurs K et V des tokens précédents. Ainsi, à chaque nouvelle étape de génération, le modèle n’a besoin de calculer que les vecteurs K et V pour le tout dernier token, puis il les ajoute au cache et calcule l’attention sur l’ensemble. Cela évite une énorme quantité de calculs répétitifs et rend l’inférence beaucoup plus rapide.
Exercice 15 : Le concept de Mixture of Experts (MoE)
Exercice
Certains modèles très larges (comme Mixtral) utilisent une architecture “Mixture of Experts” (MoE). Quel est le principe de base de cette approche et son principal avantage ?
Solution
Le principe de base est de remplacer certaines couches denses (comme les réseaux feed-forward) par plusieurs réseaux plus petits appelés “experts”. Pour chaque token, un “routeur” sélectionne un petit sous-ensemble d’experts (souvent 2 ou 3) pour le traiter.
L’avantage principal est une efficacité de calcul massive : le modèle peut avoir un très grand nombre de paramètres au total (ce qui augmente sa capacité de connaissance), mais pour chaque token, seule une fraction de ces paramètres est activée.
Explication
Un modèle MoE est comme une équipe de spécialistes. Au lieu de demander à toute l’équipe de travailler sur chaque problème (chaque token), un répartiteur intelligent envoie le problème uniquement aux quelques spécialistes les plus pertinents. Cela permet de construire des modèles gigantesques en termes de paramètres stockés, tout en gardant un coût de calcul (FLOPs) pour l’inférence comparable à celui de modèles denses beaucoup plus petits. C’est une manière d’augmenter la “connaissance” du modèle sans augmenter proportionnellement le temps de calcul.