7  🔤 Transformers et Représentations du Langage

// ==========================================
// _ojs_bridge.qmd — OJS Global Namespace Bridge
//
// Include ONCE at the top of each chapter index.qmd:
//   {{< include ../../assets/_ojs_bridge.qmd >}}
//
// window.aptitek is set by an async `<script type="module">` in the page
// header (_quarto.yml include-in-header). That import may resolve AFTER
// OJS starts executing, causing `aptitek` to be undefined.
//
// Fix: return a Promise from this cell. OJS suspends all downstream cells
// until the promise resolves — the built-in, idiomatic solution for async
// dependencies in Observable JS.
//
// ✅ Zero-maintenance: adding a new export to index.js barrel is
//    instantly available — no edits to this file ever needed.
// ✅ Race-condition-safe: downstream cells never see undefined.
// ✅ Anti-double-definition: only ONE OJS name (`aptitek`) is defined.
// ==========================================
aptitek = {
  if (window.aptitek) return window.aptitek;
  return new Promise(resolve => {
    const check = () =>
      window.aptitek
        ? resolve(window.aptitek)
        : requestAnimationFrame(check);
    check();
  });
}

7.1 Représentations Statistiques du Langage

Pour qu’un modèle lise du texte, il faut d’abord transformer les mots en nombres. Les premières méthodes font cela très simplement : elles comptent les mots, un peu comme on résume un document par son inventaire.

🔍 Lecture technique

L’enjeu fondamental du Traitement du Langage Naturel (NLP) réside dans la conversion du langage humain en une forme numérique exploitable. Avant l’avènement des plongements neuronaux, cette conversion s’appuyait sur la fréquence d’occurrence des mots — une quantification du sens par le comptage. Ces méthodes posent les bases conceptuelles essentielles pour comprendre pourquoi les représentations denses sont nécessaires (Murel and Kavlakoglu 2025; Mayurji 2024).

7.1.1 L’Hypothèse Distributionnelle

Un mot se comprend souvent par ses voisins. Si deux mots apparaissent dans les mêmes types de phrases, ils ont probablement des sens proches.

🔍 Détails théoriques

Toute représentation vectorielle de texte repose sur l’hypothèse distributionnelle de Harris (1954), reformulée par Lenci (2018) : les mots apparaissant dans des contextes similaires partagent des significations apparentées. Cette hypothèse transforme un problème sémantique (que signifie ce mot ?) en un problème statistique (dans quel contexte ce mot apparaît-il ?). Sa puissance est qu’elle permet d’inférer la sémantique sans annotation humaine — la co-occurrence fait office de supervision implicite.

7.1.2 Bag-of-Words

Le Bag-of-Words transforme un texte en sac de mots : il garde ce qui apparaît, mais oublie l’ordre. C’est utile pour compter vite, mais dangereux dès que l’ordre change le sens.

🔍 Détails techniques

Le Bag-of-Words (BoW) est le modèle le plus simple : chaque document devient un vecteur de dimension |\mathcal{V}| (taille du vocabulaire), où la coordonnée i est le nombre d’occurrences du mot w_i dans le document. La représentation est complètement agnostique à l’ordre : “le chien a mordu l’homme” et “l’homme a mordu le chien” ont le même vecteur BoW (Murel and Kavlakoglu 2025).

Les limites du BoW sont structurelles :

• Domination des stopwords : Les mots fonctionnels (“le”, “de”, “est”) dominent les fréquences et masquent les mots informatifs (Mayurji 2024).
• Perte de l’agencement : L’ordre syntaxique, porteur de sens (sujet/objet, négation), est totalement ignoré.
• Insensibilité à la composition : “not bad” (positif) contient “bad” (négatif) — le modèle ne peut distinguer les deux.
• Explosion dimensionnelle : Pour un corpus courant, |\mathcal{V}| \sim 10^5 à 10^6, produisant des vecteurs extrêmement creux (sparse).

7.1.3 Pondération TF-IDF

TF-IDF améliore le comptage brut : un mot compte plus s’il est fréquent dans ce document, mais rare dans les autres. C’est comme repérer les mots qui signent vraiment l’identité d’un texte.

🔢 Formule TF-IDF

Le Term Frequency-Inverse Document Frequency (TF-IDF) raffine le BoW en introduisant une pondération qui équilibre la représentativité locale et le pouvoir discriminant global (Lesieutre and Achour 2026; Chiny 2026) :

\text{TF-IDF}(w, d, \mathcal{D}) = \underbrace{\frac{f(w, d)}{|d|}}_{\text{TF}} \times \underbrace{\log\frac{|\mathcal{D}|}{|\{d' \in \mathcal{D} : w \in d'\}|}}_{\text{IDF}}

• TF (Term Frequency) : Fréquence normalisée du mot w dans le document d. Mesure la représentativité locale.
• IDF (Inverse Document Frequency) : Logarithme du ratio entre le nombre total de documents et ceux contenant w. Les mots présents dans tous les documents (\text{IDF} \approx 0) sont filtrés ; les mots rares reçoivent un poids élevé.

🔍 Empreinte Documentaire

Un expert légiste identifie une personne non pas par les traits communs à tous les humains (deux yeux, un nez), mais par les particularités distinctives (empreinte digitale, iris). Le TF-IDF applique la même logique : les mots ubiquitaires (“le”, “et”) sont invisibles car sans pouvoir distinctif, tandis que les mots rares et spécifiques (“photosynthèse”, “rétropropagation”) deviennent les “empreintes” d’un document.

7.1.4 Limites Communes et Transition vers les Espaces Denses

BoW et TF-IDF restent des méthodes de comptage. Elles voient que deux mots sont différents, mais pas forcément qu’ils veulent dire presque la même chose.

🔍 Limites techniques

Malgré son efficacité computationnelle, le TF-IDF partage avec le BoW des limitations fondamentales :

• Synonymie non gérée : “voiture” et “automobile” ont des vecteurs entièrement orthogonaux, malgré leur sémantique identique.
• Polysémie ignorée : “avocat” (juriste vs fruit) a un seul vecteur, quel que soit le contexte.
• Creux structurel : Les matrices document-terme sont creuses à 99%+ — inefficaces pour les modèles d’apprentissage profond.
• Incapacité à la généralisation OOV : Un mot absent du vocabulaire d’entraînement est totalement invisible.

Ces limitations ont précipité la recherche vers les espaces vectoriels denses, où chaque mot est représenté dans un espace continu de dimension réduite capturant des relations sémantiques par géométrie (Meurisse 2025).

📊 BoW vs TF-IDF

import { CORPUS_LABELS } from "../../assets/js/simulations/bow-tfidf.js"
viewof bow_doc  = Inputs.select(CORPUS_LABELS, { label: "Document" })
viewof bow_mode = Inputs.radio(["bow", "tfidf"], { value: "bow", label: "Méthode", format: x => x === "bow" ? "Bag-of-Words" : "TF-IDF" })

import { updateBowTfIdfViz } from "../../assets/js/simulations/bow-tfidf.js"

_bowTfIdf = {
  updateBowTfIdfViz(document.getElementById("bow-tfidf-container"), {
    docIndex: CORPUS_LABELS.indexOf(bow_doc),
    mode: bow_mode
  });
}

7.2 Plongements Denses

Un embedding place les mots sur une carte : des mots proches par le sens deviennent proches dans l’espace. “chat” et “chien” se retrouvent voisins, tandis que “moteur” part ailleurs.

🔍 Lecture technique

La rupture technologique des plongements denses (dense embeddings) permet de représenter chaque mot dans un espace continu de dimension réduite (typiquement 100 à 300), contre |\mathcal{V}| \sim 10^5 pour le BoW. La sémantique devient géométrie : deux mots sémantiquement proches sont voisins dans cet espace (Rong 2014; Pennington, Socher, and Manning 2014).

7.2.1 Word2Vec

Word2Vec apprend en jouant à deviner : soit il devine un mot à partir de ses voisins, soit il devine les voisins à partir du mot. À force de jouer, il construit une carte utile du vocabulaire.

🔍 Détails techniques

Introduit par Mikolov et al. (2013), Word2Vec s’entraîne non pas à compter des co-occurrences mais à prédire : soit le mot cible depuis son contexte (CBOW — Continuous Bag-of-Words), soit les mots du contexte depuis le mot cible (Skip-gram) (Rong 2014).

Architecture CBOW vs Skip-gram :

• CBOW : La représentation moyenne des mots du contexte \{w_{t-k}, \ldots, w_{t+k}\} prédit le mot central w_t. Rapide, adapté aux grandes données.
• Skip-gram : Le mot central w_t prédit chaque mot de contexte w_{t+j} pour j \in [-k, k] \setminus \{0\}. Plus performant pour les mots rares.

La Distinction Cruciale : Matrice W et Matrice W’ :

Word2Vec maintient deux matrices de poids : \mathbf{W} \in \mathbb{R}^{|\mathcal{V}| \times d} (vecteurs d’entrée v_w) et \mathbf{W'} \in \mathbb{R}^{d \times |\mathcal{V}|} (vecteurs de sortie v'_w). La mise à jour de \mathbf{W'} via le Softmax standard est prohibitivement coûteuse (O(|\mathcal{V}|) par gradient). Deux optimisations clés (Rong 2014) :

• Negative Sampling : Au lieu de normaliser sur tout le vocabulaire, on tire k “exemples négatifs” (mots aléatoires) et on optimise une approximation binaire.
• Hierarchical Softmax : Encode le vocabulaire dans un arbre de Huffman, réduisant la complexité de O(|\mathcal{V}|) à O(\log |\mathcal{V}|).

L’interaction entre v_w et v'_w durant l’entraînement crée un effet de “traction” ou “poussée” géométrique. C’est cet effet cumulatif qui génère les relations sémantiques arithmétiques célèbres :

\mathbf{v}(\text{Roi}) - \mathbf{v}(\text{Homme}) + \mathbf{v}(\text{Femme}) \approx \mathbf{v}(\text{Reine})

7.2.2 Co-occurrences GloVe

GloVe regarde le corpus avec plus de recul : il ne se contente pas d’une fenêtre locale, il cherche les grands motifs de co-occurrence entre les mots.

🔢 Objectif GloVe

GloVe (Pennington et al. 2014) adopte une approche complémentaire en modélisant explicitement les statistiques globales de co-occurrence (Pennington, Socher, and Manning 2014). Plutôt que de prédire localement le contexte, GloVe minimise la différence entre le produit scalaire des vecteurs et le logarithme de la fréquence de co-occurrence sur l’ensemble du corpus :

\mathcal{L}_{\text{GloVe}} = \sum_{i,j} f(X_{ij}) \left(v_i^T v_j + b_i + b_j - \log X_{ij}\right)^2

où X_{ij} est le nombre de co-occurrences des mots i et j dans une fenêtre de contexte, et f est une fonction de pondération diminuant le poids des co-occurrences très fréquentes. GloVe capture les associations globales que Word2Vec, entraîné localement, peut manquer.

7.2.3 Granularité FastText

FastText ne regarde pas seulement le mot entier : il regarde aussi ses petits morceaux. Cela lui permet de fabriquer une représentation pour un mot jamais vu, à partir de fragments déjà connus.

🔍 Détails techniques

Word2Vec et GloVe traitent chaque mot comme une unité atomique — un mot absent du vocabulaire d’entraînement (Out-Of-Vocabulary, OOV) ne peut pas être représenté. FastText (Bojanowski et al. 2017) résout ce problème en décomposant les mots en n-grammes de caractères (Bojanowski et al. 2017) :

Le vecteur du mot w est la somme des vecteurs de ses n-grammes de caractères : \mathbf{v}(w) = \sum_{g \in \mathcal{G}(w)} \mathbf{z}_g

Ainsi, le vecteur de “apprentissage” est construit depuis “<app”, “app”, “ppr”, “pre”, …, “age>”. Un mot inconnu (“réapprentissage”) peut être représenté depuis ses fragments connus.

Le Cas du Hangeul Coréen et le Modèle misK :

Cette granularité morphologique est vitale pour les langues agglutinantes. En Hangeul coréen, les caractères sont des syllabes composées de consonnes et voyelles. Une faute de frappe ne déplace pas une lettre — elle brise la structure syllabique, rendant le mot méconnaissable pour un modèle basé sur les mots entiers. Le modèle misK (Kwon et al. 2020) répond à ce défi via un CNN avec Channel Attention (Kwon et al. 2020) :

Plutôt que de sommer linéairement les sous-mots comme FastText, misK utilise l’attention pour sélectionner et accentuer dynamiquement les fragments morphologiques les plus informatifs selon le contexte. Les tests sur des textes coréens bruités montrent que la version fine-tunée (misK-ft) surpasse les benchmarks Word2Vec et FastText en présence d’erreurs structurelles (Kwon et al. 2020).

🌐 Comparatif des Plongements Statiques

Modèle	Apprentissage	Forces	Limites
Word2Vec	Prédiction locale (contexte)	Rapide, relations analogiques	OOV, un vecteur/mot
GloVe	Co-occurrence globale	Statistiques globales	OOV, un vecteur/mot
FastText	N-grammes de caractères	OOV résolu, morphologie	Un vecteur/mot (statique)

La limite commune à ces trois modèles : le vecteur d’un mot est statique — “avocat” a toujours le même vecteur, qu’il désigne le juriste ou le fruit. Cette polysémie est la motivation fondamentale du passage aux plongements contextuels (ELMo, BERT).

🌐 Visualiseur — Espace des Plongements 2D

import { ANALOGY_OPTIONS } from "../../assets/js/simulations/word-embeddings.js"
viewof emb_analogy = Inputs.select(ANALOGY_OPTIONS, { value: ANALOGY_OPTIONS[0], label: "Analogie" })

import { updateEmbeddingViz } from "../../assets/js/simulations/word-embeddings.js"

_embViz = {
  updateEmbeddingViz(
    document.getElementById("embedding-chart-container"),
    emb_analogy === ANALOGY_OPTIONS[0] ? "" : emb_analogy
  );
}

7.3 ELMo et les Plongements Contextuels

ELMo corrige une limite importante : un mot n’a pas toujours le même sens. Le vecteur de “avocat” doit changer selon qu’on parle d’un tribunal ou d’une salade.

🔍 Lecture technique

La limitation fondamentale de Word2Vec, GloVe et FastText est leur caractère statique : chaque mot reçoit un vecteur unique, indépendamment de son contexte phrastique. “avocat” dans “je consulte mon avocat” et “avocat” dans “j’ajoute de l’avocat à ma salade” ont exactement le même plongement. ELMo (Embeddings from Language Models, Peters et al. 2018) introduit la dynamicité contextuelle (Peters et al. 2018).

7.3.1 Architecture biLM

ELMo lit la phrase dans les deux sens : de gauche à droite et de droite à gauche. C’est comme comprendre un mot avec ce qui vient avant et ce qui vient après.

🔢 Architecture biLM

ELMo repose sur un biLM (bidirectional Language Model) profond qui entraîne deux LSTMs indépendants — l’un traitant la séquence de gauche à droite, l’autre de droite à gauche — pour maximiser conjointement la log-vraisemblance des deux directions (Peters et al. 2018) :

\mathcal{L}_{\text{biLM}} = \sum_{k=1}^{N} \left[\log p(w_k | w_1, \ldots, w_{k-1}; \theta_{\text{fwd}}) + \log p(w_k | w_{k+1}, \ldots, w_N; \theta_{\text{bwd}})\right]

À chaque token, le modèle produit L + 1 représentations (une par couche LSTM plus les embeddings de tokens initiaux). Le plongement ELMo final est une combinaison pondérée apprise de toutes ces représentations :

\text{ELMo}_k^{\text{task}} = \gamma^{\text{task}} \sum_{j=0}^{L} s_j^{\text{task}} \mathbf{h}_{k,j}^{\text{biLM}}

📈 Couches ELMo

import { ELMO_TASK_OPTIONS } from "../../assets/js/simulations/word-embeddings.js"
viewof elmo_task = Inputs.select(ELMO_TASK_OPTIONS, { label: "Tâche NLP" })

import { updateElmoViz } from "../../assets/js/simulations/word-embeddings.js"

_elmoViz = {
  updateElmoViz(document.getElementById("elmo-chart-container"), elmo_task);
}

7.3.2 Spécialisation des Couches par Niveau d’Abstraction

Les couches basses repèrent surtout la forme et la grammaire. Les couches hautes comprennent davantage le sens. Selon la tâche, on ne veut pas toujours écouter les mêmes couches.

🔍 Détails par couche

Un résultat clé de Peters et al. est la spécialisation hiérarchique des couches du biLM (Peters et al. 2018) :

• Couches inférieures (proche des tokens) : Encodent principalement la syntaxe — morphologie, étiquetage grammatical (POS tagging). Ces représentations sont utiles pour la Reconnaissance d’Entités Nommées (NER).
• Couches supérieures : Encodent principalement la sémantique contextuelle — désambiguïsation du sens des mots (Word Sense Disambiguation, WSD). Ces couches sont plus utiles pour l’analyse de sentiment et la compréhension de texte.

Ce gradient d’abstraction justifie l’approche de combinaison pondérée : selon la tâche cible, le modèle apprend à pondérer différemment les couches syntaxiques vs sémantiques.

7.3.3 Paramètre Gamma et Biais de Régularisation

ELMo ajoute des réglages pour doser l’influence de chaque couche. L’idée est de mélanger les informations sans laisser une seule couche prendre toute la place.

🔍 Hyperparamètres

Deux hyperparamètres critiques gouvernent l’adaptation d’ELMo à une tâche cible (Peters et al. 2018) :

• \gamma^{\text{task}} : Un scalaire global qui re-normalise l’amplitude des représentations biLM par rapport aux couches spécifiques à la tâche. Essentiel pour harmoniser les distributions entre le biLM pré-entraîné et les couches de fine-tuning.
• \lambda (régularisation L2) : Force les poids de mélange s_j^{\text{task}} à rester proches de l’uniforme (s_j = \frac{1}{L+1}). Un \lambda trop faible conduit à sur-spécialiser sur une couche ; trop élevé empêche l’adaptation.

7.3.4 L’Étude QUINE

Un modèle pré-entraîné connaît bien la langue générale, mais pas forcément le vocabulaire d’un domaine très spécialisé. Pour un petit corpus technique, il faut souvent l’adapter.

🔍 Étude de cas

Une analyse sur le corpus philosophique QUINE (Zhou et Bloem, 2021) apporte une nuance pédagogique cruciale. Contre-intuitivement, ELMo pré-entraîné sur données générales (E_{\text{pre}}) obtient des performances inférieures à Word2Vec fine-tuné sur ce domaine spécifique pour plusieurs tâches (Zhou and Bloem 2021) :

E_{\text{pré-entraîné}} < E_{\text{Word2Vec fine-tuné}} \quad \text{(petit corpus spécialisé)}

Le modèle pré-entraîné “parle” la langue générale, pas la langue philosophique. Cependant, la combinaison hybride restaure la supériorité :

E_{\text{mix}} = \alpha \cdot E_{\text{ELMo}} + (1 - \alpha) \cdot E_{\text{Word2Vec}}

avec un “point d’équilibre” (sweet point) pour \alpha \in [0.3, 0.4] : l’apport sémantique contextuel d’ELMo et la précision lexicale de Word2Vec sur petit domaine se complètent de façon optimale (Zhou and Bloem 2021).

Leçon : Un modèle pré-entraîné sur des données générales n’est pas une solution universelle pour les petits corpus spécialisés sans étape d’adaptation. C’est le principe fondateur du fine-tuning, développé au chapitre 8.

7.3.5 Limites et Transition vers les Transformers

ELMo comprend mieux le contexte que Word2Vec, mais il lit encore les séquences pas à pas. Les Transformers vont accélérer et enrichir cette lecture grâce à l’attention.

🔍 Limites techniques

Malgré sa dynamicité contextuelle, ELMo souffre de deux limitations structurelles que les Transformers surmontent :

1. Traitement séquentiel : Les LSTMs imposent un traitement mot à mot, limitant la parallélisation et les dépendances à très longue distance.
2. Bidirectionnalité indépendante : Les deux directions (gauche-droite, droite-gauche) sont entraînées séparément et combinées linéairement — ce n’est pas une vraie compréhension bidirectionnelle simultanée. BERT résoudra ce problème via le masquage (MLM).

7.4 Pipeline des Transformers

Avant qu’un Transformer puisse raisonner sur du texte, il faut transformer la phrase en une suite de petits morceaux numériques. Le pipeline fait ce travail : découper, convertir en vecteurs, puis ajouter l’ordre.

🔍 Lecture technique

Avant d’entrer dans le mécanisme d’attention, le texte brut subit un pipeline de préparation critique qui conditionne toute la chaîne de traitement. Ce pipeline n’est pas un détail technique anodin : c’est souvent le véritable goulot d’étranglement des performances, tant en termes de qualité des représentations que d’efficacité computationnelle (Rijn 2026; Hugging Face nd).

7.4.1 Tokenisation du Texte

La tokenisation découpe le texte en pièces manipulables. Un mot rare peut être coupé en sous-mots, comme “anti” + “constitution” + “nellement”, pour éviter de bloquer sur un mot jamais vu.

🔍 Stratégies de tokenisation

La tokenisation convertit une séquence de caractères bruts en une séquence de tokens discrets ayant chacun un identifiant entier dans le vocabulaire \mathcal{V}. Trois stratégies principales coexistent, chacune résolvant différemment le compromis OOV/taille de vocabulaire.

BPE (Byte-Pair Encoding) :

BPE construit le vocabulaire itérativement en fusionnant la paire de symboles la plus fréquente. Partant du caractère, il crée progressivement des sous-mots fréquents. GPT-2 et RoBERTa utilisent BPE. Un mot inconnu est toujours décomposable en sous-mots vus à l’entraînement — le problème OOV est éliminé au niveau caractère (Hugging Face nd; Kudo 2018).

WordPiece :

Variante de BPE utilisée par BERT, WordPiece fusionne les paires maximisant la probabilité des données — pas simplement la fréquence. Les sous-mots non-initiaux sont préfixés de “##” pour distinguer les continuations des débuts de mot (Hadis nd).

SentencePiece :

Opère directement sur les caractères Unicode sans pré-tokenisation par espaces, permettant un traitement uniforme du japonais, du chinois, et des langues sans espaces. Utilisé par T5 et LLaMA. La segmentation est apprise par BPE ou unigram LM (Kudo 2018).

Algorithme	Modèle	Avantage
BPE	GPT-2, RoBERTa	Simple, fréquences brutes
WordPiece	BERT	Optimisation probabiliste
SentencePiece	T5, LLaMA	Multilingue, sans pré-tokenisation

🔤 Tokenizer BPE

viewof bpe_text = Inputs.textarea({
  label: "Texte à tokeniser :",
  value: "L'apprentissage profond comprend-il anticonstitutionnellement ?",
  rows: 2
})

import { createTokenizerDemoPanel } from "../../assets/js/simulations/tokenization.js"
createTokenizerDemoPanel(bpe_text)

7.4.2 Des Indices aux Vecteurs

Une fois les tokens numérotés, le modèle remplace chaque numéro par un vecteur dense. C’est comme remplacer un code-barres par une fiche descriptive numérique.

🔍 Détails techniques

Chaque token t_i \in \{1, \ldots, |\mathcal{V}|\} est mappé vers un vecteur dense \mathbf{e}_i \in \mathbb{R}^{d_{\text{model}}} via une table d’embeddings (matrice \mathbf{E} \in \mathbb{R}^{|\mathcal{V}| \times d_{\text{model}}}). Cette opération est un lookup : \mathbf{e}_i = \mathbf{E}[t_i, :] (ApX Machine Learning nd; Nedjimi 2025).

En pratique, pour traiter un batch de séquences de longueurs variables, on utilise des structures comme EmbeddingBag qui agrège plusieurs vecteurs en un seul. Des vecteurs d’indices (idxs) et des pointeurs de segments (ptrs) indiquent les frontières entre séquences dans le batch, permettant un traitement efficace des séquences de longueurs hétérogènes.

7.4.3 Défis Matériels des Lookups

Chercher des embeddings peut être lent : le modèle saute partout dans une grande table mémoire. Même si le calcul semble simple, l’accès aux données devient le vrai bouchon.

🔍 Goulot matériel

Les opérations de lookup d’embeddings constituent un goulot d’étranglement matériel majeur sur les architectures GPU standard (Siracusa et al. 2025) :

• Accès mémoire irréguliers : Les GPUs optimisent pour les accès mémoire coalesced (contigus). Les lookups d’embeddings sont par nature aléatoires — pour un batch de 32 séquences, on tire 32×512 indices aléatoires dans une table pouvant faire plusieurs gigas.

• Faible intensité opérationnelle : Un vecteur d’embedding de dimension 768 ne représente que 768 multiplications — insuffisant pour masquer la latence mémoire du H100. Le ratio calcul/mémoire est catastrophiquement bas (bound mémoire, pas compute).

• Découplage traversée/exécution : Les architectures CPU/GPU traditionnelles couplent l’accès mémoire et le calcul dans le même pipeline, créant des bulles de stall quand les accès sont irréguliers.

Le compilateur Ember résout ce problème via une architecture DAE (Decoupled Access-Execute) avec un TMU (Tensor Marshaling Unit) dédié aux lookups — voir la section sur l’optimisation architecturale.

7.4.4 Ajout de l’Encodage Positionnel

Le Transformer regarde les tokens en parallèle, donc il faut lui dire où chaque morceau se trouve dans la phrase. L’encodage positionnel ajoute cette information d’ordre.

🔍 Formulation

Le Transformer traite tous les tokens en parallèle — contrairement aux RNNs, il ne perçoit naturellement aucune notion d’ordre. L’encodage positionnel est additionné aux embeddings de tokens pour injecter cette information d’ordre :

\mathbf{x}_i = \mathbf{e}_i + \mathbf{p}_i

où \mathbf{p}_i est la représentation de la position i. Le choix de \mathbf{p}_i — sinusoïdal fixe, appris, ou rotatif (RoPE) — a des conséquences profondes sur la capacité du modèle à généraliser à des séquences plus longues que celles vues à l’entraînement. Cette question est l’objet des deux sections suivantes.

7.5 Restaurer l’Ordre

Un Transformer lit tous les mots en même temps. C’est rapide, mais il perd naturellement l’ordre ; l’encodage positionnel lui donne une boussole pour savoir qui vient avant qui.

🔍 Lecture technique

Le mécanisme d’attention est par construction invariant par permutation : si l’on réordonne les tokens d’une séquence, les scores d’attention changent mais la logique de calcul reste identique. Sans information positionnelle, “le chat mange la souris” et “la souris mange le chat” sont traitées de façon équivalente. L’encodage positionnel est le correctif architectural à cette cécité ordonnancielle (Kazemnejad 2019; ExplainingAI nd).

7.5.1 Critères d’un Encodage Idéal

Un bon encodage de position doit donner une signature différente à chaque place, tout en aidant le modèle à comprendre les distances entre les mots.

🔍 Critères techniques

Selon Kazemnejad (2019), un encodage positionnel optimal doit satisfaire quatre propriétés (Kazemnejad 2019) :

Critère	Description	Violation → Problème
Unicité	Chaque position a une signature distincte	Collisions sémantiques entre positions
Distance cohérente	La distance entre encodages dépend de l’écart relatif, pas de la position absolue	Le modèle ne peut apprendre les distances relatives
Généralisation	Fonctionne pour des séquences plus longues que celles vues à l’entraînement	Échec sur contextes longs
Déterminisme	Encodage fixe, sans paramètre aléatoire	Instabilité à l’inférence

🌊 Matrice Positionnelle

viewof pe_seq_len  = Inputs.range([4, 64],  { value: 32, step: 4,  label: "Longueur de séquence" })
viewof pe_d_model  = Inputs.range([8, 64],  { value: 32, step: 8,  label: "Dimension d" })
viewof pe_highlight = Inputs.range([0, 63], { value: 0,  step: 1,  label: "Position t" })

import { updatePEViz } from "../../assets/js/simulations/positional-encoding.js"

_peViz = {
  updatePEViz(
    document.getElementById("pe-heatmap-container"),
    document.getElementById("pe-line-container"),
    { seqLen: pe_seq_len, dModel: pe_d_model, highlightPos: Math.min(pe_highlight, pe_seq_len - 1) }
  );
}

7.5.2 Encodage Sinusoïdal

L’encodage sinusoïdal ressemble à une horloge à plusieurs aiguilles : certaines tournent vite pour les petites distances, d’autres lentement pour les grandes positions.

🔢 Formule sinusoïdale

Vaswani et al. (Attention Is All You Need, 2017) proposent un encodage fixe basé sur des fonctions sinusoïdales à fréquences géométriques (Kazemnejad 2019; Azazi 2025) :

\text{PE}(t, 2k) = \sin\!\left(\frac{t}{10000^{2k/d}}\right), \qquad \text{PE}(t, 2k+1) = \cos\!\left(\frac{t}{10000^{2k/d}}\right)

pour t la position et k = 0, 1, \ldots, d/2 - 1.

Intuition des fréquences géométriques :

Chaque paire de dimensions (2k, 2k+1) oscille à une fréquence \omega_k = 10000^{-2k/d} :

• Les premières dimensions (k \approx 0) oscillent rapidement — elles encodent la parité et les distances très courtes (comme l’aiguille des secondes).
• Les dernières dimensions (k \approx d/2) oscillent très lentement — elles encodent la structure globale de la séquence (comme l’aiguille des heures).

L’encodage entier fonctionne comme une horloge multi-échelle : la position t est le vecteur de l’état de toutes les aiguilles simultanément.

Propriété de Translation Linéaire :

L’élégance fondamentale de cet encodage est que \text{PE}(t + \phi) est une transformation linéaire de \text{PE}(t) : il existe une matrice de rotation \mathbf{M}_\phi telle que (Kazemnejad 2019; Fleetwood 2024) :

\begin{pmatrix} \text{PE}(t+\phi, 2k) \\ \text{PE}(t+\phi, 2k+1) \end{pmatrix} = \begin{pmatrix} \cos(\omega_k\phi) & \sin(\omega_k\phi) \\ -\sin(\omega_k\phi) & \cos(\omega_k\phi) \end{pmatrix} \begin{pmatrix} \text{PE}(t, 2k) \\ \text{PE}(t, 2k+1) \end{pmatrix}

Cette propriété permet au mécanisme d’attention d’apprendre à repérer des distances relatives fixes simplement en apprenant une rotation appropriée dans ses matrices de clés/requêtes.

Somme vs Concaténation :

Ajouter la position au vecteur du mot garde une taille fixe. C’est plus économique que coller un second vecteur à côté.

🔍 Détail d’architecture

Le choix de sommer l’encodage aux embeddings (plutôt que de concaténer) est une décision d’efficacité : la dimension du modèle reste constante (d_{\text{model}}), sans surcoût. Le modèle apprend à isoler l’information positionnelle dans certaines dimensions de l’espace (Kazemnejad 2019).

7.5.3 Positions Apprises

Certains modèles apprennent une table de positions, comme une liste de places numérotées. Cela marche bien dans la longueur prévue, mais pas au-delà.

🔍 Détails techniques

BERT et les premiers GPT remplacent l’encodage sinusoïdal fixe par des embeddings de position appris : une table \mathbf{P} \in \mathbb{R}^{T_{\max} \times d} dont les lignes sont optimisées par rétropropagation comme n’importe quel autre paramètre (Happy 2026).

Avantage : La flexibilité d’apprentissage permet au modèle d’adopter la structure positionnelle optimale pour la tâche.

Limite critique : Ces embeddings souffrent d’une incapacité à l’extrapolation. Un modèle BERT entraîné sur 512 tokens n’a jamais vu la position 513 — le paramètre correspondant n’existe pas et l’inférence échoue. Le modèle est strictement limité à T_{\max} tokens.

7.5.4 ALiBi pour Longueur Variable

ALiBi ne donne pas une fiche à chaque position. Il ajoute plutôt une pénalité avec la distance : plus deux tokens sont éloignés, moins ils sont favorisés au départ.

🔢 Formule ALiBi

Pour résoudre l’incapacité à l’extrapolation, ALiBi (Press et al. 2021) adopte une approche radicalement différente : au lieu d’encoder la position dans les embeddings, elle ajoute directement un biais linéaire à chaque score d’attention en fonction de la distance (Press, Smith, and Lewis 2021; Sarkar 2025) :

a_{ij} = \frac{\mathbf{q}_i \cdot \mathbf{k}_j}{\sqrt{d}} - m \cdot |i - j|

où m est une pente fixe dépendante de la tête d’attention. Les tokens distants reçoivent un biais négatif croissant, induisant une décroissance naturelle de l’attention avec la distance. Ce biais n’implique aucun paramètre appris, et la formule s’applique à toute longueur — ALiBi extrapole naturellement au-delà de T_{\max} d’entraînement (SambaNova 2023).

Cependant, ALiBi impose une hypothèse forte : les tokens distants sont a priori moins pertinents. Pour les tâches nécessitant une attention soutenue à longue portée (code, raisonnement mathématique), cette hypothèse n’est pas toujours vérifiée — ce qui motive RoPE.

7.6 Géométrie Rotationnelle RoPE

RoPE encode la position en faisant tourner les vecteurs. Deux mots proches ne sont pas seulement placés à des endroits différents : leur écart devient un angle que l’attention peut lire directement.

🔍 Lecture technique

RoPE (Rotary Position Embedding, Su et al. 2021) représente l’état de l’art des encodages positionnels pour les LLMs modernes (LLaMA, Llama 2, Mistral, Gemma). Son élégance réside dans l’injection de l’information de position relative directement dans le produit scalaire d’attention, via une rotation dans l’espace des nombres complexes (June 2023; Krasser 2022).

7.6.1 L’Objectif Fonctionnel

L’objectif de RoPE est simple : l’attention doit surtout connaître la distance entre deux tokens, pas seulement leurs numéros absolus dans la phrase.

🔢 Objectif mathématique

Soit f(\mathbf{q}, m) la transformation de la requête \mathbf{q} à la position m, et f(\mathbf{k}, n) la transformation de la clé \mathbf{k} à la position n. RoPE cherche à construire f telle que le produit scalaire \langle f(\mathbf{q}, m), f(\mathbf{k}, n) \rangle soit une fonction de \mathbf{q}, \mathbf{k}, et de la distance relative m - n uniquement (June 2023; Krasser 2022) :

\langle f(\mathbf{q}, m), f(\mathbf{k}, n) \rangle = g(\mathbf{q}, \mathbf{k}, m - n)

Cette propriété garantit que l’attention capturée entre deux tokens dépend de leur écart relatif, pas de leurs positions absolues — ce qui améliore la généralisation à différentes longueurs de séquence.

🔄 Rotation RoPE

viewof rope_sentence = Inputs.text({
  label: "Phrase :",
  value: "Le chat mange la souris dans la cuisine.",
  placeholder: "Tapez une phrase..."
})

viewof rope_theta = Inputs.range([5, 45], {
  label: "Sensibilité θ (°/token)",
  value: 15, step: 1
})

rope_tokens = rope_sentence.trim().split(/\s+/).map((w, i) => ({ id: i, word: w }))

{
  window.d3 = window.d3 || d3;
  const tokens = rope_tokens;
  const theta = rope_theta;
  const VW = 380, VH = 380;
  const cx = VW / 2, cy = VH / 2, R = 145;

  const svg = d3.create("svg")
    .attr("viewBox", `0 0 ${VW} ${VH}`)
    .attr("preserveAspectRatio", "xMidYMid meet")
    .style("width", "100%").style("max-width", "420px")
    .style("height", "auto").style("display", "block").style("margin", "0 auto")
    .style("background", "var(--sol-base03)").style("border-radius", "12px");

  // Grid circles
  [0.5, 1].forEach(f => {
    svg.append("circle")
      .attr("cx", cx).attr("cy", cy).attr("r", R * f)
      .attr("fill", "none").attr("stroke", "var(--sol-base02)").attr("stroke-width", 1);
  });

  // Degree ticks
  for (let deg = 0; deg < 360; deg += 30) {
    const rad = deg * Math.PI / 180;
    svg.append("line")
      .attr("x1", cx + (R - 8) * Math.sin(rad)).attr("y1", cy - (R - 8) * Math.cos(rad))
      .attr("x2", cx + R * Math.sin(rad)).attr("y2", cy - R * Math.cos(rad))
      .attr("stroke", "var(--sol-base01)").attr("stroke-width", 1);
  }

  // Get two "selected" tokens — always 0 and 1 for the static base view
  // We'll make the first two tokens highlighted
  const selA = 0, selB = Math.min(1, tokens.length - 1);

  // Plot all tokens
  tokens.forEach((t, i) => {
    const angle = i * theta * (Math.PI / 180);
    const x = cx + R * Math.sin(angle);
    const y = cy - R * Math.cos(angle);
    const isA = i === selA, isB = i === selB;

    // Dot
    svg.append("circle")
      .attr("cx", x).attr("cy", y).attr("r", isA || isB ? 7 : 4)
      .attr("fill", isA ? "var(--sol-blue)" : isB ? "var(--sol-red)" : "var(--sol-base01)")
      .attr("stroke", isA || isB ? "var(--sol-base3)" : "none").attr("stroke-width", 1.5);

    // Label for selected tokens
    if (isA || isB) {
      const col = isA ? "var(--sol-blue)" : "var(--sol-red)";
      const lx = cx + (R + 20) * Math.sin(angle);
      const ly = cy - (R + 20) * Math.cos(angle);
      const g = svg.append("g").attr("transform", `translate(${lx},${ly})`);
      const tlen = t.word.length * 6 + 12;
      g.append("rect").attr("x", -tlen / 2).attr("y", -10).attr("width", tlen).attr("height", 20)
        .attr("rx", 4).attr("fill", col);
      g.append("text").attr("text-anchor", "middle").attr("dy", ".35em")
        .attr("fill", "var(--sol-base3)").attr("font-size", "11px").attr("font-weight", "700")
        .style("font-family", "var(--font-code)").text(t.word);
    }
  });

  // Arrows from center for A and B
  [selA, selB].forEach(idx => {
    const angle = idx * theta * (Math.PI / 180);
    const x = cx + R * Math.sin(angle);
    const y = cy - R * Math.cos(angle);
    const col = idx === selA ? "var(--sol-blue)" : "var(--sol-red)";
    svg.append("line")
      .attr("x1", cx).attr("y1", cy).attr("x2", x).attr("y2", y)
      .attr("stroke", col).attr("stroke-width", 3).attr("stroke-linecap", "round");
  });

  // Arc showing relative angle
  const radA = selA * theta * (Math.PI / 180);
  const radB = selB * theta * (Math.PI / 180);
  const arcGen = d3.arc().innerRadius(R - 18).outerRadius(R + 4)
    .startAngle(Math.min(radA, radB)).endAngle(Math.max(radA, radB));
  svg.append("path").attr("transform", `translate(${cx},${cy})`).attr("d", arcGen())
    .attr("fill", "var(--sol-yellow)").attr("opacity", 0.3);

  // Center dot
  svg.append("circle").attr("cx", cx).attr("cy", cy).attr("r", 5).attr("fill", "var(--sol-base1)");

  const dist = Math.abs(selA - selB);
  const totalAngle = dist * theta;

  // Info overlay
  const infoX = 10, infoY = 10;
  const info = svg.append("g");
  info.append("rect").attr("x", infoX).attr("y", infoY).attr("width", 175).attr("height", 60)
    .attr("rx", 6).attr("fill", "var(--sol-base02)").attr("opacity", 0.9);
  info.append("text").attr("x", infoX + 8).attr("y", infoY + 20)
    .attr("fill", "var(--sol-base1)").attr("font-size", "10px").style("font-family", "var(--font-code)")
    .text(`θ = ${theta}° / token`);
  info.append("text").attr("x", infoX + 8).attr("y", infoY + 36)
    .attr("fill", "var(--sol-yellow)").attr("font-size", "11px").attr("font-weight", "700")
    .style("font-family", "var(--font-code)")
    .text(`Déphasage Δ = ${totalAngle}°`);
  info.append("text").attr("x", infoX + 8).attr("y", infoY + 52)
    .attr("fill", "var(--sol-base01)").attr("font-size", "9.5px").style("font-family", "var(--font-code)")
    .text(`${tokens[selA]?.word} ↔ ${tokens[selB]?.word} (|Δm|=${dist})`);

  return svg.node();
}

7.6.2 Dérivation en Dimension 2

En deux dimensions, RoPE ressemble à une aiguille qui tourne sur un cadran. La position du token détermine l’angle de rotation.

🔢 Dérivation 2D

En dimension d = 2, représentons \mathbf{q} = (q_0, q_1) comme un nombre complexe q = q_0 + iq_1. La transformation RoPE est simplement une multiplication par une phase complexe (June 2023) :

f(q, m) = q \cdot e^{im\theta}

Le produit scalaire (partie réelle du produit de f(\mathbf{q}, m) et du conjugué de f(\mathbf{k}, n)) devient :

\text{Re}[f(q, m) \cdot \overline{f(k, n)}] = \text{Re}[q \cdot \bar{k} \cdot e^{i(m-n)\theta}]

Le terme e^{i(m-n)\theta} démontre que l’information de position est purement relative — seul l’écart m - n apparaît dans le produit scalaire, jamais les positions absolues m ou n séparément.

7.6.3 Généralisation aux Hautes Dimensions

En grande dimension, le modèle utilise plusieurs petites horloges en parallèle. Certaines tournent vite pour les détails proches, d’autres lentement pour les longues distances.

🔢 Rotation par paires de dimensions

Pour un vecteur de dimension d, RoPE décompose l’espace en d/2 paires de dimensions indépendantes. Chaque paire (2i-1, 2i) est traitée comme un plan 2D où s’applique une rotation d’angle m\theta_i, avec des fréquences décroissantes (June 2023; Kazemnejad et al. 2023) :

\theta_i = 10000^{-2i/d}

Sous forme matricielle, la transformation de la requête \mathbf{q} à la position m est :

\mathbf{R}(m) \mathbf{q} = \begin{pmatrix} \cos(m\theta_1) & -\sin(m\theta_1) & & \\ \sin(m\theta_1) & \cos(m\theta_1) & & \\ & & \ddots & \\ & & & \cos(m\theta_{d/2}) & -\sin(m\theta_{d/2}) \\ & & & \sin(m\theta_{d/2}) & \cos(m\theta_{d/2}) \end{pmatrix} \mathbf{q}

La matrice \mathbf{R}(m) est orthogonale et creuse — elle préserve la norme des vecteurs (les rotations ne changent pas la magnitude) et peut être calculée efficacement.

7.6.4 Optimisation par Complexes

Dans LLaMA, RoPE est calculé de manière efficace en exploitant les nombres complexes. L’idée mathématique reste la même, mais l’implémentation évite des calculs inutiles.

🔍 Détails d’implémentation

L’implémentation de RoPE dans LLaMA est un exemple de co-design mathématique/logiciel (Touvron et al. 2023; Prabhakaran 2025). Plutôt que des multiplications de matrices 2D pour chaque paire, on exploite la correspondance avec les nombres complexes :

1. precompute_freqs_cis : Précalcule pour chaque position m et fréquence \theta_i la valeur e^{im\theta_i} sous forme polaire complexe (cosinus + i×sinus). Ce précalcul est fait une fois et réutilisé pour toutes les couches.

2. apply_rotary_emb : Réinterprète les paires de dimensions réelles (q_{2i-1}, q_{2i}) comme des nombres complexes q_{2i-1} + i \cdot q_{2i}, puis applique la rotation par multiplication complexe élément par élément :

(\text{Re}[q \cdot e^{im\theta}], \, \text{Im}[q \cdot e^{im\theta}])

Cette multiplication complexe est 2× plus efficace que la multiplication matricielle 2D correspondante, et exploite les instructions SIMD modernes qui traitent naturellement des paires de flottants.

7.6.5 Extrapolation de Contexte et LongRoPE

RoPE peut fonctionner au-delà des longueurs vues à l’entraînement, mais il faut souvent réajuster ses fréquences. LongRoPE étire ces horloges pour gérer des contextes beaucoup plus longs.

🔍 Long contexte

Un avantage majeur de RoPE sur les embeddings appris est sa capacité d’extrapolation : la définition de la rotation est valide pour tout m, même les positions non vues à l’entraînement (Ding et al. 2024; AI Paper Slop nd). En pratique, cependant, des fréquences d’interpolation ou de ré-échelonnage sont nécessaires pour dépasser significativement T_{\max}.

LongRoPE (Ding et al. 2024) étend les modèles Llama au-delà de 2 millions de tokens en ajustant non-uniformément les fréquences de rotation selon la dimension : les dimensions basses (haute fréquence) sont étirées différemment des dimensions hautes (basse fréquence), permettant une extrapolation fine-granulaire sans dégradation des performances sur courtes séquences (Ding et al. 2024).

🔄 Résumé Comparatif des Encodages Positionnels

Méthode	Type	Extrapolation	Paramètres	Modèles
Sinusoïdal	Absolu, fixe	Partielle	0	Transformer original
Appris	Absolu, appris	Non	T_{\max} \times d	BERT, GPT-2
ALiBi	Relatif, fixe	Oui (linéaire)	0	MPT, BLOOM
RoPE	Relatif, fixe	Oui (si rééchelonné)	0	LLaMA, Mistral, Gemma

RoPE offre le meilleur compromis : pas de paramètres supplémentaires, information relative pure dans le produit scalaire, et extrapolation possible via ré-échelonnage des fréquences.

7.7 Anatomie du Bloc Attention

L’attention permet à chaque mot de demander : “quels autres mots m’aident à comprendre mon rôle dans cette phrase ?” C’est le cœur du Transformer.

🔍 Lecture technique

Le bloc d’attention est l’unité de calcul fondamentale du Transformer. Contrairement aux convolutions qui capturent les corrélations locales, l’attention permet à chaque token d’interagir directement avec tous les autres tokens de la séquence — quel que soit leur éloignement. C’est ce mécanisme de connectivité globale qui distingue fondamentalement les Transformers des RNNs et CNNs (June 2023; Kämäräinen nd).

🧱 Architecture Globale d’un Bloc Transformer (Encodeur)

import { initTransformerBlock } from "../../assets/js/simulations/attention.js"
_block_flow = initTransformerBlock("#plot-transformer-block", invalidation)

🕸️ Flux de Calcul de l’Attention (Q, K, V)

import { initAttentionFlow } from "../../assets/js/simulations/attention.js"
_attn_flow = initAttentionFlow("#plot-attention-flow", invalidation)

7.7.1 La Triade Q, K, V

Q, K et V ressemblent à un système de recherche : la Query pose une question, la Key indique ce que chaque token peut offrir, et la Value contient l’information à récupérer.

🔢 Projections Q, K, V

Pour chaque token i dans la séquence, l’attention compute trois vecteurs dérivés par projection linéaire de l’embedding \mathbf{x}_i \in \mathbb{R}^{d_{\text{model}}} (June 2023) :

\mathbf{q}_i = \mathbf{W}_Q \mathbf{x}_i, \quad \mathbf{k}_i = \mathbf{W}_K \mathbf{x}_i, \quad \mathbf{v}_i = \mathbf{W}_V \mathbf{x}_i (voir le Glossaire)

• \mathbf{x}_i \in \mathbb{R}^{d_{\text{model}}} : le vecteur d’embedding du i-ème token de la séquence.
• \mathbf{W}_Q, \mathbf{W}_K, \mathbf{W}_V : les matrices de projection linéaire apprises pour les requêtes, clés et valeurs.
• Query \mathbf{q}_i : La “requête” du token i — ce qu’il cherche dans le contexte.
• Key \mathbf{k}_j : La “signature” du token j — ce qu’il offre comme information.
• Value \mathbf{v}_j : Le contenu informationnel du token j.

7.7.2 Le Scaled Dot-Product Attention

L’attention compare les requêtes et les clés : plus elles se ressemblent, plus le token correspondant est écouté. Ensuite, le modèle fait une moyenne pondérée des valeurs utiles.

🔢 Formule d’attention

Le score d’attention entre token i (position de requête) et token j (position de clé) est le produit scalaire normalisé (Kämäräinen nd) :

a_{ij} = \frac{\mathbf{q}_i \cdot \mathbf{k}_j}{\sqrt{d_k}}

La normalisation par \sqrt{d_k} (dimension des clés) est cruciale : sans elle, les produits scalaires croissent en O(d_k) en magnitude, poussant le Softmax dans ses zones de saturation à gradient quasi-nul. Après softmax, on obtient les poids d’attention \alpha_{ij} = \text{softmax}(a_{ij}), et la sortie est l’agrégation pondérée des valeurs :

\text{Attention}(\mathbf{Q}, \mathbf{K}, \mathbf{V}) = \text{softmax}\!\left(\frac{\mathbf{Q}\mathbf{K}^T}{\sqrt{d_k}}\right) \mathbf{V} (voir le Glossaire)

• \mathbf{Q}, \mathbf{K}, \mathbf{V} : matrices regroupant les vecteurs requêtes, clés et valeurs de toute la séquence.
• \mathbf{K}^T : transposée de la matrice des clés (indiquant la transposition par l’exposant T).
• \text{softmax}(\cdot) : fonction d’activation normalisant les scores en probabilités (les poids d’attention).
• \sqrt{d_k} : facteur d’échelle, racine carrée de la dimension des clés.

🔍 Carte d’Attention

attn_sentence = [
  { id: 0, word: "Le"     },
  { id: 1, word: "féroce" },
  { id: 2, word: "chien"  },
  { id: 3, word: "a"      },
  { id: 4, word: "mordu"  },
  { id: 5, word: "l'"     },
  { id: 6, word: "homme"  }
]

attn_matrix = [
  [0.80, 0.15, 0.05, 0.00, 0.00, 0.00, 0.00],
  [0.10, 0.60, 0.30, 0.00, 0.00, 0.00, 0.00],
  [0.05, 0.25, 0.50, 0.05, 0.15, 0.00, 0.00],
  [0.00, 0.00, 0.10, 0.40, 0.50, 0.00, 0.00],
  [0.00, 0.00, 0.35, 0.05, 0.20, 0.05, 0.35],
  [0.00, 0.00, 0.00, 0.00, 0.00, 0.70, 0.30],
  [0.00, 0.00, 0.05, 0.00, 0.25, 0.10, 0.60]
]

mutable attn_activeQ = 4

import { renderSelfAttention } from "../../assets/js/simulations/attention.js"
renderSelfAttention(d3, { tokens: attn_sentence, matrix: attn_matrix, activeQuery: attn_activeQ, onSelectQuery: (index) => { mutable attn_activeQ = index; } })

7.7.3 Sous-Espaces Parallèles

Une seule tête d’attention ne suffit pas toujours. Plusieurs têtes permettent au modèle de regarder la phrase sous plusieurs angles : grammaire, référence, thème, relation longue distance.

🔢 Formule multi-tête

Plutôt qu’une seule attention globale, l’architecture Transformer utilise H têtes d’attention parallèles, chacune opérant dans un sous-espace de dimension d_k = d_{\text{model}} / H (Kämäräinen nd) :

\text{MultiHead}(\mathbf{Q}, \mathbf{K}, \mathbf{V}) = \text{Concat}(\text{head}_1, \ldots, \text{head}_H) \mathbf{W}_O (voir le Glossaire)

• H : nombre de têtes d’attention indépendantes travaillant en parallèle.
• \text{Concat}(\cdot) : opération de concaténation des sorties de toutes les têtes.
• \mathbf{W}_O : matrice de projection de sortie recombinante.

Chaque tête apprend à se focaliser sur un type différent de dépendance : certaines têtes capturent la syntaxe (sujet-verbe), d’autres la coréférence (pronom-antécédent), d’autres encore les relations sémantiques thématiques. La concaténation des sorties puis la projection \mathbf{W}_O recombinent ces représentations parallèles.

7.7.4 Stabilisation du Bloc

Un bloc Transformer ne contient pas seulement l’attention. Il ajoute aussi des raccourcis, de la normalisation et un petit réseau MLP pour stabiliser et enrichir les représentations.

🔍 Composants de stabilisation

Autour du bloc d’attention, trois composants stabilisent le flux d’information dans les réseaux profonds (Kämäräinen nd) :

Connexions Résiduelles :

\mathbf{x}' = \mathbf{x} + \text{Attention}(\mathbf{x})

Les connexions de saut (skip connections) préservent l’identité du signal original, empêchant la dégradation du gradient dans les réseaux profonds (problème de vanishing gradient vu au chapitre 2). En termes de représentation, elles garantissent que chaque couche ajoute de l’information plutôt que de la transformer entièrement.

Normalisation :

Deux variantes coexistent : LayerNorm (BERT, GPT-2) normalise sur les dimensions du modèle ; RMSNorm (LLaMA) normalise uniquement par la racine quadratique de la moyenne des carrés, sans centrage. RMSNorm est 15-20% plus rapide tout en préservant la stabilité.

MLP (Feed-Forward Network) :

Après l’attention (qui capture les relations entre tokens), un MLP effectue un raffinement des caractéristiques dans l’espace latent de chaque token indépendamment. La structure standard est une expansion-contraction :

\text{FFN}(\mathbf{x}) = \text{GELU}(\mathbf{x}\mathbf{W}_1 + \mathbf{b}_1)\mathbf{W}_2 + \mathbf{b}_2 (voir le Glossaire)

• \text{GELU}(\cdot) : fonction d’activation non linéaire.
• \mathbf{W}_1, \mathbf{b}_1 : poids et biais de la première couche linéaire (expansion de dimension).
• \mathbf{W}_2, \mathbf{b}_2 : poids et biais de la seconde couche linéaire (contraction de dimension).

avec d_{\text{ff}} = 4 d_{\text{model}} typiquement. Le MLP est responsable de 2/3 des paramètres du Transformer — c’est là que réside la “mémoire factuelle” du modèle.

7.7.5 Optimisation Matérielle

À grande échelle, comprendre l’attention ne suffit pas : il faut aussi l’exécuter vite. Certaines optimisations séparent la lecture des embeddings et le calcul pour éviter que le matériel attende la mémoire.

🔍 Détails matériel/compilateur

La précision mathématique de l’attention ne suffit pas — l’efficacité d’exécution conditionne la scalabilité. Sur les architectures GPU standard, les opérations de lookup d’embeddings (décrites en section précédente) constituent un goulot d’étranglement que le compilateur Ember résout via l’architecture DAE (Decoupled Access-Execute) (Siracusa et al. 2025) :

Le TMU (Tensor Marshaling Unit) :

Une unité physiquement séparée du cœur de calcul, dédiée exclusivement à la traversée des structures de données et au regroupement (marshaling) des embeddings. Pendant que le TMU prépare les vecteurs, le cœur de calcul exécute l’attention sur les données déjà streamées.

Optimisations du Compilateur Ember :

Ember utilise une représentation intermédiaire SLC IR (Structured Lookup-Compute) pour trois optimisations clés (Siracusa et al. 2025) :

1. Vectorisation (Arm SVE) : Utilisation automatique d’unités vectorielles larges avec gestion intelligente des masques.
2. Buffering d’Embedding : Un jeton ee (end-of-embedding) signale la fin d’un vecteur, permettant au CPU de générer les positions positionnelles localement sans dépendre du TMU.
3. Alignement de Queue : Padding des scalaires pour maintenir l’alignement des lignes de cache et éviter les chargements vectoriels désalignés.

Résultat : Un gain moyen de 5,8× sur les opérations d’embedding, avec une efficacité énergétique 4× supérieure aux GPUs traditionnels sur ces opérations spécifiques (Siracusa et al. 2025). Ce co-design matériel-logiciel transforme une opération limitée par la latence mémoire en un flux continu haute performance.

AI Paper Slop. nd. “Mathematical Limitations of RoPE in Long Context Transformers.” Youtube.

ApX Machine Learning. nd. “Input Embedding Layer Transformation.” URL.

Azazi, Yasmeen Asaad. 2025. “Why Do We Need Both Sin and Cos in Positional Encoding? - DeepLearning.AI Community.” URL.

Bojanowski, Piotr, Edouard Grave, Armand Joulin, and Tomas Mikolov. 2017. “Enriching Word Vectors with Subword Information.” arXiv Preprint arXiv:1607.04606v2. [PDF].

Chiny. 2026. “TF-IDF: Pondérer l’importance Des Mots Pour Mieux Représenter Le Texte - Chiny.me.” [URL].

Ding, Yiran, Li Lyna Zhang, Chengruidong Zhang, Yuanyuan Xu, Ning Shang, Jiahang Xu, Fan Yang, and Mao Yang. 2024. “LongRoPE: Extending LLM Context Window Beyond 2 Million Tokens.” Microsoft Research. PDF.

ExplainingAI. nd. “Positional Encoding in Transformer | Sinusoidal Positional Encoding Explained.” Youtube.

Fleetwood, Christopher. 2024. “You Could Have Designed State of the Art Positional Encoding.” URL.

Hadis. nd. “How WordPiece Tokenization Works? | Python in Plain English.” URL.

Happy, S L. 2026. “A Guide to Positional Embeddings: Absolute (APE) Vs. Relative (RPE) - ML Digest.” URL.

Hugging Face. nd. “Byte-Pair Encoding Tokenization.” URL.

———. nd. “Tokenization Algorithms.” URL.

June, Florian. 2023. “An in-Depth Exploration of Rotary Position Embedding (RoPE).” URL.

Kämäräinen, Joni-Kristian. nd. “Introduction to Sequence Modeling with Transformers.” Tampere University, nd. PDF.

Kazemnejad, Amirhossein. 2019. “Transformer Architecture: The Positional Encoding.” URL.

Kazemnejad, Amirhossein, Inkit Padhi, Karthikeyan Natesan Ramamurthy, Payel Das, and Siva Reddy. 2023. “The Impact of Positional Encoding on Length Generalization in Transformers.” arXiv:2305.19466, May. URL.

Krasser, Martin. 2022. “A Gentle Introduction to Rotary Position Embedding.” URL.

Kudo, Taku. 2018. “Subword Regularization: Improving Neural Network Translation Models with Multiple Subword Candidates.” In ACL Anthology. PDF.

Kwon, Ohjoon, Dohyun Kim, Soo-Ryeon Lee, Junyoung Choi, and SangKeun Lee. 2020. “Handling Out-of-Vocabulary Problem in Hangeul Word Embeddings.” In ACL Anthology. [PDF].

Lesieutre, Kevin, and Youssef Achour. 2026. “TF-IDF (Term Frequency-Inverse Document Frequency) - Lexique SEO | Cuik.” [URL].

Mayurji. 2024. “Why Tf-Idf Is More Effective Than Bag-of-Words? - Blogs.” [URL].

Meurisse, Stéphane. 2025. “Comprendre TF-IDF : Approche Théorique - Code and Cortex !” [URL].

Murel, Jacob, and Eda Kavlakoglu. 2025. “Qu’est-Ce Qu’un Sac de Mots ? | IBM.” [URL].

Nedjimi, Ayi. 2025. “Embeddings Vs Tokens : Guide Pratique Cybersecurite.” Ayi NEDJIMI Consultants. PDF.

Pennington, Jeffrey, Richard Socher, and Christopher D. Manning. 2014. “GloVe: Global Vectors for Word Representation.” In Empirical Methods in Natural Language Processing (EMNLP). [PDF].

Peters, Matthew E., Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. 2018. “Deep Contextualized Word Representations.” arXiv Preprint arXiv:1802.05365v2. [PDF].

Prabhakaran, Selva. 2025. “Positional Embeddings: RoPE & ALiBi Explained (Python).” URL.

Press, Ofir, Noah A. Smith, and Mike Lewis. 2021. “Train Short, Test Long: Attention with Linear Biases Enables Input Length Extrapolation.” University of Washington & Facebook AI Research. PDF.

Rijn, Roy van. 2026. “The Anatomy of an LLM | Interactive Visual Guide to How Language Models Work.” URL.

Rong, Xin. 2014. “Word2vec Parameter Learning Explained.” arXiv. [PDF].

SambaNova. 2023. “ALiBi Deep Dive: Interpolation Vs. Extrapolation.” URL.

Sarkar, Abhik. 2025. “ALiBi: Attention with Linear Biases.” URL.

Siracusa, Marco, Olivia Hsu, Victor Soria-Pardos, Joshua Randall, Arnaud Grasset, Eric Biscondi, Doug Joseph, et al. 2025. “Ember: A Compiler for Embedding Operations on Decoupled Access-Execute Architectures.” Barcelona Supercomputing Center & Stanford University. PDF.

Touvron, Hugo, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timothee Lacroix, Baptiste Rozière, et al. 2023. “LLaMA: Open and Efficient Foundation Language Models.” Meta AI. PDF.

Zhou, Wei, and Jelke Bloem. 2021. “Comparing Contextual and Static Word Embeddings with Small Philosophical Data.” In ACL Anthology. [PDF].