Repository Public
1import type { TemplateDef } from "../types";2import { T, pickSources } from "./shared";34const r = String.raw;56/** Sequence lengths at which the two exact sums below are evaluated. */7const LENGTHS = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024];8/** Query–key scores computed in one layer to generate n tokens, re-encoding the prefix each time: Σ t(t+1)/2 = n(n+1)(n+2)/6. */9const scoresWithoutCache = (n: number) => (n * (n + 1) * (n + 2)) / 6;10/** Same count with a KV cache, one new query per step: Σ t = n(n+1)/2. */11const scoresWithCache = (n: number) => (n * (n + 1)) / 2;1213export const kvCache: TemplateDef = {14 id: "kv-cache",15 category: "ai",16 title: { fr: "Cache clés-valeurs et génération autorégressive", en: "KV cache and autoregressive generation" },17 description: {18 fr: "Pourquoi recalculer toute la séquence à chaque jeton est un gaspillage, ce qui est mis en cache, ce que l'on gagne en calcul et ce que cela coûte en mémoire.",19 en: "Why recomputing the whole sequence for every token is wasteful, what gets cached, what is gained in computation and what it costs in memory.",20 },21 build: (locale) => {22 const t = T(locale);23 return {24 schemaVersion: 1,25 metadata: {26 title: t("Le cache clés-valeurs : générer sans tout recalculer", "The KV cache: generating without recomputing everything"),27 slug: t("cache-cles-valeurs", "kv-cache"),28 locale,29 summary: t(30 "Un modèle de langage génère un jeton à la fois. Le cache clés-valeurs conserve, pour chaque couche, les clés et les valeurs des jetons déjà traités : on échange du calcul contre de la mémoire.",31 "A language model generates one token at a time. The key–value cache keeps, for every layer, the keys and values of the tokens already processed: computation is traded for memory.",32 ),33 topics: [t("IA", "AI"), t("Inférence", "Inference")],34 tags: [t("cache KV", "KV cache"), t("génération autorégressive", "autoregressive generation"), "attention", t("inférence", "inference"), t("mémoire", "memory"), "LLM"],35 level: "intermediate",36 kind: "explainer",37 objectives: [38 t("Expliquer pourquoi les clés et les valeurs des jetons passés ne changent pas d'une étape à l'autre.", "Explain why the keys and values of past tokens do not change from one step to the next."),39 t("Dire précisément ce qui est mis en cache, et ce qui ne l'est pas.", "State precisely what is cached, and what is not."),40 t("Comparer le coût de génération avec et sans cache.", "Compare the cost of generation with and without a cache."),41 t("Estimer la mémoire occupée par le cache pour une configuration donnée.", "Estimate the memory taken by the cache for a given configuration."),42 ],43 example: true,44 },45 theme: { preset: "scientific-light", accent: "teal" },46 blocks: [47 { id: "h-title", type: "heading", level: 1, eyebrow: t("Inférence · Modèles de langage", "Inference · Language models"), text: t("Le cache clés-valeurs : générer sans tout recalculer", "The KV cache: generating without recomputing everything") },48 {49 id: "intro-lead", type: "paragraph", lead: true,50 text: t(51 "Un modèle de langage écrit **un jeton à la fois** : chaque nouveau jeton est ajouté à la séquence, qui sert d'entrée à l'étape suivante. Appliqué naïvement, ce procédé refait à chaque étape presque tout le travail de l'étape précédente. Le cache clés-valeurs (*KV cache*) supprime cette redondance en mémorisant ce qui ne changera plus.",52 "A language model writes **one token at a time**: each new token is appended to the sequence, which becomes the input of the next step. Applied naively, this redoes at every step almost all the work of the previous one. The key–value cache (KV cache) removes that redundancy by remembering what will no longer change.",53 ),54 },55 {56 id: "eq-autoregressive", type: "equation", span: 6, label: t("Génération autorégressive", "Autoregressive generation"), derivation: "standard",57 latex: r`p(x_1, \dots, x_n) = \prod_{t=1}^{n} p(x_t \mid x_1, \dots, x_{t-1})`,58 explanation: t(59 "La probabilité d'une séquence se décompose en une chaîne de prédictions du prochain jeton. Générer, c'est tirer $x_t$ de cette loi conditionnelle, l'ajouter au contexte, et recommencer.",60 "The probability of a sequence factorises into a chain of next-token predictions. Generating means drawing $x_t$ from this conditional distribution, appending it to the context, and starting again.",61 ),62 variables: [63 { symbol: "x_t", meaning: t("Jeton à la position $t$", "Token at position $t$") },64 { symbol: "n", meaning: t("Longueur de la séquence", "Length of the sequence"), unit: t("jetons", "tokens") },65 ],66 },67 {68 id: "c-ideas", type: "cards", span: 6, columns: 2,69 items: [70 { icon: "warning", tone: "red", title: t("Le gaspillage", "The waste"), text: t("Sans cache, l'étape $t$ retraite les $t$ jetons du contexte pour n'en produire qu'un seul.", "Without a cache, step $t$ reprocesses all $t$ context tokens to produce just one.") },71 { icon: "lock", tone: "blue", title: t("L'invariant", "The invariant"), text: t("Grâce au masque causal, ce qui a été calculé pour un jeton passé ne dépend pas des jetons suivants.", "Because of the causal mask, what was computed for a past token does not depend on later tokens.") },72 { icon: "memory", tone: "teal", title: t("Le cache", "The cache"), text: t("On garde, par couche, les clés et les valeurs de chaque jeton déjà vu.", "For each layer, the keys and values of every token already seen are kept.") },73 { icon: "scale", tone: "amber", title: t("Le prix", "The price"), text: t("Une mémoire qui croît linéairement avec la longueur du contexte.", "Memory that grows linearly with context length.") },74 ],75 },7677 { id: "h-why", type: "heading", level: 2, text: t("Pourquoi le recalcul est inutile", "Why recomputation is pointless") },78 {79 id: "p-invariant", type: "paragraph", span: 6,80 text: t(81 "Dans un décodeur, l'auto-attention est **masquée** : la position $i$ ne consulte que les positions $j \\le i$[^vaswani2017]. Par conséquent, la représentation du jeton $i$, à chaque couche, ne dépend que des jetons $1$ à $i$. Ajouter un jeton $t+1$ à la fin ne modifie donc **rien** de ce qui a été calculé pour les positions $1$ à $t$ : ni leurs états cachés, ni leurs clés, ni leurs valeurs.",82 "In a decoder, self-attention is **masked**: position $i$ only looks at positions $j \\le i$[^vaswani2017]. Consequently the representation of token $i$, at every layer, depends only on tokens $1$ to $i$. Appending a token $t+1$ at the end therefore changes **nothing** of what was computed for positions $1$ to $t$: not their hidden states, not their keys, not their values.",83 ),84 },85 {86 id: "eq-step", type: "equation", span: 6, label: t("Attention pour le seul nouveau jeton", "Attention for the new token only"), derivation: "derived", sourceIds: ["vaswani2017"],87 latex: r`o_t = \mathrm{softmax}\!\left(\frac{q_t\, K_{1:t}^{\top}}{\sqrt{d_k}}\right) V_{1:t}, \qquad K_{1:t} = \begin{bmatrix} K_{1:t-1} \\ k_t \end{bmatrix},\quad V_{1:t} = \begin{bmatrix} V_{1:t-1} \\ v_t \end{bmatrix}`,88 explanation: t(89 "C'est la dernière ligne de l'équation d'attention habituelle[^vaswani2017]. Il suffit d'une requête, celle du nouveau jeton ; $K_{1:t-1}$ et $V_{1:t-1}$ sont lus dans le cache, puis on y ajoute $k_t$ et $v_t$.",90 "This is the last row of the usual attention equation[^vaswani2017]. A single query is enough, that of the new token; $K_{1:t-1}$ and $V_{1:t-1}$ are read from the cache, then $k_t$ and $v_t$ are appended to it.",91 ),92 variables: [93 { symbol: "q_t,\\, k_t,\\, v_t", meaning: t("Requête, clé et valeur du nouveau jeton, dans une couche donnée", "Query, key and value of the new token, in a given layer") },94 { symbol: "K_{1:t-1},\\, V_{1:t-1}", meaning: t("Clés et valeurs des jetons précédents : le contenu du cache", "Keys and values of the previous tokens: the content of the cache") },95 { symbol: "o_t", meaning: t("Sortie de l'attention à la position $t$", "Attention output at position $t$") },96 { symbol: "d_k", meaning: t("Dimension des clés", "Dimension of the keys") },97 ],98 },99100 { id: "h-how", type: "heading", level: 2, text: t("Une étape de génération avec cache", "One generation step with a cache") },101 {102 id: "d-kv", type: "diagram", span: 8, kind: "flow", direction: "LR", routing: "orthogonal",103 title: t("Préremplissage, puis décodage jeton par jeton", "Prefill, then token-by-token decoding"),104 caption: t(105 "Le schéma montre une couche ; chaque couche du modèle possède son propre cache. Seul le nouveau jeton traverse le réseau.",106 "The diagram shows one layer; every layer of the model has its own cache. Only the new token goes through the network.",107 ),108 alt: t(109 "Schéma en deux zones. Préremplissage : l'invite entière traverse le modèle en une seule passe parallèle, ce qui remplit le cache avec les clés et les valeurs de tous ses jetons. Décodage : le dernier jeton généré est converti en vecteur, projeté en requête, clé et valeur ; la clé et la valeur sont ajoutées au cache ; la requête est comparée à toutes les clés du cache ; le résultat passe par le réseau à propagation avant, donne les scores du vocabulaire, puis un jeton est échantillonné et renvoyé en entrée de l'étape suivante.",110 "Two-zone diagram. Prefill: the whole prompt goes through the model in a single parallel pass, filling the cache with the keys and values of all its tokens. Decode: the last generated token is turned into a vector and projected into a query, a key and a value; the key and value are appended to the cache; the query is compared with all the keys in the cache; the result goes through the feed-forward network and yields vocabulary scores, then a token is sampled and fed back as the input of the next step.",111 ),112 groups: [113 { id: "g-prefill", label: t("Préremplissage · une fois", "Prefill · once"), tone: "amber" },114 { id: "g-decode", label: t("Décodage · à chaque jeton", "Decode · for every token"), tone: "blue" },115 ],116 nodes: [117 { id: "n-prompt", label: t("Invite", "Prompt"), sublabel: t("tous les jetons connus", "all tokens known"), shape: "note", tone: "neutral", icon: "document", group: "g-prefill" },118 { id: "n-prefill", label: t("Passe parallèle", "Parallel pass"), sublabel: t("toutes les positions à la fois", "all positions at once"), shape: "round", tone: "amber", icon: "bolt", group: "g-prefill" },119 { id: "n-cache", label: t("Cache K, V", "K, V cache"), sublabel: t("par couche, positions 1 à t", "per layer, positions 1 to t"), shape: "cylinder", tone: "teal", icon: "memory" },120 { id: "n-token", label: t("Dernier jeton", "Latest token"), shape: "pill", tone: "neutral", icon: "token", group: "g-decode" },121 { id: "n-embed", label: t("Plongement + position", "Embedding + position"), shape: "round", tone: "neutral", group: "g-decode" },122 { id: "n-proj", label: t("Projections q, k, v", "Projections q, k, v"), sublabel: t("pour ce seul jeton", "for this token only"), shape: "round", tone: "blue", group: "g-decode" },123 { id: "n-attn", label: t("Attention", "Attention"), sublabel: t("1 requête × t clés", "1 query × t keys"), shape: "round", tone: "blue", icon: "eye", group: "g-decode" },124 { id: "n-ffn", label: t("Propagation avant", "Feed-forward"), sublabel: t("une seule position", "one position only"), shape: "round", tone: "green", group: "g-decode" },125 { id: "n-logits", label: t("Scores du vocabulaire", "Vocabulary scores"), shape: "rect", tone: "neutral", icon: "chart", group: "g-decode" },126 { id: "n-sample", label: t("Échantillonnage", "Sampling"), shape: "diamond", tone: "violet", group: "g-decode" },127 { id: "n-next", label: t("Nouveau jeton", "New token"), shape: "pill", tone: "green", icon: "sparkles", group: "g-decode" },128 ],129 edges: [130 { id: "e-prompt-prefill", from: "n-prompt", to: "n-prefill", tone: "amber" },131 { id: "e-prefill-cache", from: "n-prefill", to: "n-cache", tone: "amber", label: t("remplit", "fills") },132 { id: "e-token-embed", from: "n-token", to: "n-embed", tone: "blue" },133 { id: "e-embed-proj", from: "n-embed", to: "n-proj", tone: "blue" },134 { id: "e-proj-cache", from: "n-proj", to: "n-cache", tone: "teal", label: t("ajoute k, v", "appends k, v") },135 { id: "e-proj-attn", from: "n-proj", to: "n-attn", tone: "blue", label: "q" },136 { id: "e-cache-attn", from: "n-cache", to: "n-attn", tone: "teal", style: "dashed", label: t("lit K, V", "reads K, V") },137 { id: "e-attn-ffn", from: "n-attn", to: "n-ffn", tone: "blue" },138 { id: "e-ffn-logits", from: "n-ffn", to: "n-logits", tone: "blue", label: t("après la dernière couche", "after the last layer") },139 { id: "e-logits-sample", from: "n-logits", to: "n-sample", tone: "blue" },140 { id: "e-sample-next", from: "n-sample", to: "n-next", tone: "green" },141 { id: "e-loop", from: "n-next", to: "n-token", tone: "green", style: "dotted", label: t("étape suivante", "next step") },142 ],143 legend: [144 { label: t("Préremplissage du cache par l'invite", "Cache prefill by the prompt"), tone: "amber", shape: "arrow" },145 { label: t("Calcul fait pour le nouveau jeton", "Computation done for the new token"), tone: "blue", shape: "arrow" },146 { label: t("Écriture dans le cache", "Write to the cache"), tone: "teal", shape: "arrow" },147 { label: t("Lecture du cache", "Read from the cache"), tone: "teal", shape: "dashed" },148 { label: t("Boucle autorégressive", "Autoregressive loop"), tone: "green", shape: "dashed" },149 ],150 animation: {151 steps: [152 { title: t("1. Préremplir", "1. Prefill"), text: t("L'invite est connue d'avance : ses jetons sont traités en parallèle, et leurs clés et valeurs sont rangées dans le cache de chaque couche.", "The prompt is known in advance: its tokens are processed in parallel, and their keys and values are stored in each layer's cache."), nodes: ["n-prompt", "n-prefill", "n-cache"], edges: ["e-prompt-prefill", "e-prefill-cache"] },153 { title: t("2. Projeter le nouveau jeton", "2. Project the new token"), text: t("Seul le dernier jeton entre dans le réseau. Chaque couche en calcule la requête, la clé et la valeur.", "Only the latest token enters the network. Each layer computes its query, key and value."), nodes: ["n-token", "n-embed", "n-proj"], edges: ["e-token-embed", "e-embed-proj"] },154 { title: t("3. Compléter le cache", "3. Extend the cache"), text: t("La clé et la valeur du nouveau jeton sont ajoutées à la suite des précédentes.", "The new token's key and value are appended after the previous ones."), nodes: ["n-proj", "n-cache"], edges: ["e-proj-cache"] },155 { title: t("4. Une requête contre toutes les clés", "4. One query against all keys"), text: t("L'attention compare la requête aux $t$ clés du cache : $t$ scores, au lieu de $t(t+1)/2$.", "Attention compares the query with the $t$ keys in the cache: $t$ scores, instead of $t(t+1)/2$."), nodes: ["n-proj", "n-cache", "n-attn"], edges: ["e-proj-attn", "e-cache-attn"] },156 { title: t("5. Terminer la couche", "5. Finish the layer"), text: t("Le réseau à propagation avant ne traite qu'une position. On répète les étapes 2 à 5 pour chaque couche.", "The feed-forward network processes a single position. Steps 2 to 5 are repeated for every layer."), nodes: ["n-attn", "n-ffn"], edges: ["e-attn-ffn"] },157 { title: t("6. Choisir le jeton suivant", "6. Pick the next token"), text: t("La dernière couche donne les scores du vocabulaire ; un jeton est échantillonné et devient l'entrée de l'étape suivante.", "The last layer yields the vocabulary scores; a token is sampled and becomes the input of the next step."), nodes: ["n-ffn", "n-logits", "n-sample", "n-next", "n-token"], edges: ["e-ffn-logits", "e-logits-sample", "e-sample-next", "e-loop"] },158 ],159 },160 },161 {162 id: "cmp-cached", type: "comparison", span: 4,163 caption: t("Ce qui est conservé, et ce qui ne l'est pas.", "What is kept, and what is not."),164 columns: [165 { title: t("Mis en cache", "Cached"), tone: "teal" },166 { title: t("Recalculé à chaque étape", "Recomputed at each step"), tone: "blue" },167 ],168 rows: [169 { label: t("Quoi", "What"), cells: [t("Clés $K$ et valeurs $V$ de chaque jeton passé, dans chaque couche", "Keys $K$ and values $V$ of every past token, in every layer"), t("Requête, clé et valeur du nouveau jeton ; poids d'attention ; scores du vocabulaire", "Query, key and value of the new token; attention weights; vocabulary scores")] },170 { label: t("Pourquoi", "Why"), cells: [t("Elles ne dépendent pas des jetons futurs", "They do not depend on future tokens"), t("Ils dépendent du nouveau jeton", "They depend on the new token")] },171 { label: t("Requêtes passées", "Past queries"), cells: [t("Non conservées : elles ne resserviront pas", "Not kept: they will never be used again"), "—"] },172 ],173 },174 {175 id: "sim-kv", type: "simulation", kind: "kv-cache", seed: 3,176 params: { prompt: 4, newTokens: 8, layers: 4 }, config: {},177 title: t("Générer avec et sans cache", "Generate with and without a cache"),178 caption: t("Simulation à but pédagogique : elle compte des opérations sur un modèle jouet, elle ne mesure pas la vitesse d'un système réel.", "Teaching simulation: it counts operations on a toy model; it does not measure the speed of a real system."),179 alt: t(180 "Simulation interactive qui génère une séquence jeton par jeton et affiche, à chaque étape, les positions recalculées sans cache (toutes) et avec cache (seulement la dernière), ainsi que la taille du cache qui augmente d'une ligne par jeton.",181 "Interactive simulation that generates a sequence token by token and shows, at each step, the positions recomputed without a cache (all of them) and with a cache (only the last one), together with the cache size growing by one row per token.",182 ),183 },184185 { id: "h-cost", type: "heading", level: 2, text: t("Ce que l'on gagne en calcul", "What is gained in computation") },186 {187 id: "eq-complexity", type: "equation", span: 6, label: t("Scores d'attention pour générer n jetons (une couche)", "Attention scores to generate n tokens (one layer)"), derivation: "derived",188 latex: r`\underbrace{\sum_{t=1}^{n} \frac{t(t+1)}{2} = \frac{n(n+1)(n+2)}{6} = O(n^{3})}_{\text{without cache}} \qquad \underbrace{\sum_{t=1}^{n} t = \frac{n(n+1)}{2} = O(n^{2})}_{\text{with cache}}`,189 explanation: t(190 "Sans cache, l'étape $t$ recalcule l'attention causale sur $t$ jetons, soit $t(t+1)/2$ scores requête-clé ; avec cache, elle n'en calcule que $t$. Le réseau à propagation avant suit la même logique : $t$ positions par étape sans cache, une seule avec.",191 "Without a cache, step $t$ recomputes causal attention over $t$ tokens, that is $t(t+1)/2$ query–key scores; with a cache it computes only $t$. The feed-forward network follows the same logic: $t$ positions per step without a cache, a single one with it.",192 ),193 variables: [194 { symbol: "n", meaning: t("Nombre de jetons générés (invite vide, pour simplifier)", "Number of tokens generated (empty prompt, for simplicity)"), unit: t("jetons", "tokens") },195 { symbol: "t", meaning: t("Indice de l'étape de génération", "Index of the generation step") },196 ],197 },198 {199 id: "ch-complexity", type: "chart", span: 6, kind: "line", dataKind: "synthetic",200 title: t("Scores d'attention cumulés, par couche", "Cumulative attention scores, per layer"),201 caption: t(202 "Valeurs calculées à partir des deux sommes exactes ci-contre (échelles logarithmiques). Ce sont des décomptes d'opérations, pas des temps mesurés.",203 "Values computed from the two exact sums alongside (logarithmic scales). These are operation counts, not measured times.",204 ),205 alt: t(206 "Graphique en échelles logarithmiques du nombre cumulé de scores d'attention en fonction du nombre de jetons générés, de 1 à 1024. La courbe sans cache croît comme le cube de la longueur, la courbe avec cache comme son carré ; l'écart entre les deux s'élargit régulièrement et atteint un facteur de 342 à 1024 jetons.",207 "Log-scale chart of the cumulative number of attention scores against the number of generated tokens, from 1 to 1024. The curve without a cache grows as the cube of the length, the curve with a cache as its square; the gap between them widens steadily and reaches a factor of 342 at 1024 tokens.",208 ),209 x: { label: t("Jetons générés", "Tokens generated"), type: "number", scale: "log", min: 1, max: 1024 },210 y: { label: t("Scores requête-clé cumulés", "Cumulative query–key scores"), scale: "log", min: 1 },211 series: [212 { name: t("Sans cache", "Without cache"), tone: "red", points: LENGTHS.map((n) => ({ x: n, y: scoresWithoutCache(n) })) },213 { name: t("Avec cache", "With cache"), tone: "teal", points: LENGTHS.map((n) => ({ x: n, y: scoresWithCache(n) })) },214 ],215 },216217 { id: "h-memory", type: "heading", level: 2, text: t("Ce que cela coûte en mémoire", "What it costs in memory") },218 {219 id: "eq-memory", type: "equation", span: 6, label: t("Taille du cache", "Size of the cache"), derivation: "derived",220 latex: r`M = 2 \cdot B \cdot L \cdot n \cdot h_{kv} \cdot d_{\text{head}} \cdot b`,221 explanation: t(222 "Le facteur 2 compte les clés et les valeurs. Dans l'attention multi-tête classique, $h_{kv} \\cdot d_{\\text{head}} = d_{\\text{model}}$. La taille est **linéaire** en $n$ : c'est le compromis inverse de celui du calcul.",223 "The factor 2 counts keys and values. In standard multi-head attention, $h_{kv} \\cdot d_{\\text{head}} = d_{\\text{model}}$. The size is **linear** in $n$: the opposite trade-off to that of computation.",224 ),225 variables: [226 { symbol: "M", meaning: t("Mémoire occupée par le cache", "Memory taken by the cache"), unit: t("octets", "bytes") },227 { symbol: "B", meaning: t("Nombre de séquences traitées en parallèle", "Number of sequences processed in parallel") },228 { symbol: "L", meaning: t("Nombre de couches", "Number of layers") },229 { symbol: "n", meaning: t("Longueur du contexte en cache", "Length of the cached context"), unit: t("jetons", "tokens") },230 { symbol: "h_{kv}", meaning: t("Nombre de têtes de clés-valeurs", "Number of key–value heads") },231 { symbol: r`d_{\text{head}}`, meaning: t("Dimension d'une tête", "Dimension of one head") },232 { symbol: "b", meaning: t("Octets par nombre (2 en demi-précision)", "Bytes per number (2 in half precision)"), unit: t("octets", "bytes") },233 ],234 },235 {236 id: "co-example", type: "callout", span: 6, tone: "example", title: t("Exemple de calcul (configuration hypothétique)", "Worked example (hypothetical configuration)"),237 text: t(238 "Prenons $L = 32$ couches, $d_{\\text{model}} = 4096$, un contexte de $n = 8192$ jetons, en demi-précision ($b = 2$), pour une seule séquence :\n\n$M = 2 \\times 32 \\times 8192 \\times 4096 \\times 2 = 2^{32}$ octets, soit **4 Gio**.\n\nServir 16 séquences de cette longueur en parallèle demanderait 64 Gio pour le seul cache. Ces dimensions sont choisies pour l'exemple et ne décrivent pas un modèle particulier.",239 "Take $L = 32$ layers, $d_{\\text{model}} = 4096$, a context of $n = 8192$ tokens, in half precision ($b = 2$), for a single sequence:\n\n$M = 2 \\times 32 \\times 8192 \\times 4096 \\times 2 = 2^{32}$ bytes, that is **4 GiB**.\n\nServing 16 sequences of that length in parallel would take 64 GiB for the cache alone. These dimensions are chosen for the example and do not describe any particular model.",240 ),241 },242 {243 id: "c-mitigations", type: "cards", span: 8, columns: 3,244 items: [245 { icon: "merge", tone: "violet", title: t("Partager les têtes", "Share the heads"), text: t("L'attention multi-requête partage les clés et les valeurs entre toutes les têtes, ce qui réduit fortement la taille de ces tenseurs[^shazeer2019]. L'attention à requêtes groupées en garde un nombre intermédiaire[^ainslie2023].", "Multi-query attention shares keys and values across all heads, greatly reducing the size of those tensors[^shazeer2019]. Grouped-query attention keeps an intermediate number of them[^ainslie2023].") },246 { icon: "table", tone: "teal", title: t("Paginer la mémoire", "Page the memory"), text: t("Le cache de chaque requête grandit et rétrécit sans cesse. L'allouer par blocs, à la manière de la mémoire virtuelle, limite la fragmentation et permet de le partager entre requêtes[^kwon2023].", "Each request's cache keeps growing and shrinking. Allocating it in blocks, in the manner of virtual memory, limits fragmentation and lets it be shared between requests[^kwon2023].") },247 { icon: "link", tone: "amber", title: t("Réutiliser un préfixe", "Reuse a prefix"), text: t("Deux requêtes qui commencent par les mêmes jetons ont le même cache pour ce préfixe : on peut le calculer une fois et le réutiliser.", "Two requests starting with the same tokens have the same cache for that prefix: it can be computed once and reused.") },248 ],249 },250 {251 id: "co-limit", type: "callout", span: 4, tone: "warning", title: t("Le cache ne rend pas l'attention gratuite", "The cache does not make attention free"),252 text: t(253 "Chaque nouveau jeton doit encore consulter **toutes** les clés du cache : le coût d'une étape reste proportionnel à la longueur du contexte. Et tout changement au milieu du contexte invalide le cache à partir de ce point, puisque les positions suivantes en dépendaient.",254 "Each new token must still look at **all** the keys in the cache: the cost of one step stays proportional to context length. And any change in the middle of the context invalidates the cache from that point on, since the later positions depended on it.",255 ),256 },257 {258 id: "code-loop", type: "code", language: "pseudo",259 caption: t("Boucle de génération avec cache, pour un modèle à L couches.", "Generation loop with a cache, for a model with L layers."),260 code: [261 "cache = [empty(K, V) for layer in 1..L]",262 "",263 "# Prefill: the whole prompt in one parallel pass",264 "h = embed(prompt)",265 "for layer in 1..L:",266 " q, k, v = project(layer, h)",267 " cache[layer].append(k, v)",268 " h = block(layer, q, cache[layer].K, cache[layer].V, causal_mask=True)",269 "token = sample(logits(h[last]))",270 "",271 "# Decode: one token at a time",272 "while token != END:",273 " h = embed(token) # a single position",274 " for layer in 1..L:",275 " q, k, v = project(layer, h)",276 " cache[layer].append(k, v) # the cache grows by one row",277 " h = block(layer, q, cache[layer].K, cache[layer].V)",278 " token = sample(logits(h))",279 ].join("\n"),280 },281282 { id: "h-check", type: "heading", level: 2, text: t("Vérifier sa compréhension", "Check your understanding") },283 {284 id: "quiz-encoder", type: "quiz", span: 6,285 question: t(286 "Pourquoi le cache clés-valeurs ne s'applique-t-il pas tel quel à un encodeur bidirectionnel, où chaque position consulte toute la séquence ?",287 "Why does the KV cache not apply as is to a bidirectional encoder, in which every position looks at the whole sequence?",288 ),289 choices: [290 { text: t("Parce qu'ajouter un jeton modifierait les représentations de tous les jetons précédents, donc leurs clés et leurs valeurs.", "Because appending a token would change the representations of all earlier tokens, hence their keys and values."), correct: true, explanation: t("Exact : sans masque causal, les positions passées dépendent des positions futures ; rien n'est stable à mettre en cache.", "Correct: without a causal mask, past positions depend on future ones; nothing is stable enough to cache.") },291 { text: t("Parce qu'un encodeur n'a ni clés ni valeurs.", "Because an encoder has no keys or values."), correct: false, explanation: t("Il en a : toute couche d'attention calcule des requêtes, des clés et des valeurs.", "It does: every attention layer computes queries, keys and values.") },292 { text: t("Parce que le cache occuperait trop de mémoire.", "Because the cache would take too much memory."), correct: false, explanation: t("La mémoire n'est pas en cause ; c'est la validité même du cache qui disparaît.", "Memory is not the issue; it is the very validity of the cache that disappears.") },293 ],294 },295 {296 id: "acc-faq", type: "accordion", span: 6,297 items: [298 {299 title: t("Le cache change-t-il le texte généré ?", "Does the cache change the generated text?"),300 text: t(301 "Non. C'est une optimisation exacte : on obtient les mêmes clés et les mêmes valeurs que si on les recalculait, aux arrondis numériques près. La distribution du prochain jeton est identique.",302 "No. It is an exact optimisation: the keys and values obtained are the same as if they were recomputed, up to numerical rounding. The next-token distribution is identical.",303 ),304 },305 {306 title: t("Pourquoi le premier jeton arrive-t-il plus lentement que les suivants ?", "Why does the first token arrive more slowly than the following ones?"),307 text: t(308 "Avant de produire le premier jeton, le modèle doit traiter toute l'invite pour remplir le cache : c'est le préremplissage, dont la durée augmente avec la longueur de l'invite. Les jetons suivants ne demandent chacun qu'une étape de décodage.",309 "Before producing the first token, the model must process the whole prompt to fill the cache: this is the prefill, whose duration grows with prompt length. Each following token only needs one decoding step.",310 ),311 },312 {313 title: t("Erreur fréquente : croire que l'on met en cache les poids d'attention", "Common mistake: thinking attention weights are cached"),314 text: t(315 "Les poids d'attention du nouveau jeton sont recalculés à chaque étape, puisqu'ils dépendent de sa requête. Ce qui est conservé, ce sont les **entrées** de ce calcul qui ne changent pas : les clés et les valeurs des jetons passés.",316 "The attention weights of the new token are recomputed at every step, since they depend on its query. What is kept are the **inputs** of that computation that do not change: the keys and values of past tokens.",317 ),318 },319 {320 title: t("Sert-il aussi à l'entraînement ?", "Is it used during training too?"),321 text: t(322 "Non. À l'entraînement, toute la séquence cible est connue : le masque causal permet de prédire toutes les positions en une seule passe parallèle. Le cache n'a d'intérêt qu'à l'inférence, où les jetons arrivent un par un[^shazeer2019].",323 "No. During training the whole target sequence is known: the causal mask allows all positions to be predicted in a single parallel pass. The cache only matters at inference, where tokens arrive one by one[^shazeer2019].",324 ),325 },326 ],327 },328 { id: "refs", type: "references", title: t("Références", "References") },329 ],330 sources: pickSources("vaswani2017", "shazeer2019", "ainslie2023", "kwon2023"),331 claims: [332 { id: "cl-mask", status: "sourced", sourceIds: ["vaswani2017"], blockId: "p-invariant", text: t("Dans le décodeur, le masquage empêche une position de consulter les positions suivantes.", "In the decoder, masking prevents a position from attending to subsequent positions.") },333 { id: "cl-invariant", status: "derived", sourceIds: ["vaswani2017"], blockId: "p-invariant", text: t("Les clés et les valeurs d'un jeton passé ne changent pas quand on ajoute des jetons à la suite : conséquence du masque causal, appliqué couche après couche.", "The keys and values of a past token do not change when tokens are appended: a consequence of the causal mask, applied layer after layer.") },334 { id: "cl-complexity", status: "derived", blockId: "eq-complexity", text: t("Par couche, générer n jetons demande de l'ordre de n³ scores d'attention sans cache et n² avec cache (sommes de t(t+1)/2 et de t).", "Per layer, generating n tokens takes on the order of n³ attention scores without a cache and n² with one (sums of t(t+1)/2 and of t).") },335 { id: "cl-memory", status: "derived", blockId: "eq-memory", text: t("La taille du cache est proportionnelle au nombre de couches, à la longueur du contexte, à la dimension des clés-valeurs et à la taille du lot.", "The cache size is proportional to the number of layers, the context length, the key–value dimension and the batch size.") },336 { id: "cl-mqa", status: "sourced", sourceIds: ["shazeer2019", "ainslie2023"], blockId: "c-mitigations", text: t("Partager les clés et les valeurs entre les têtes (attention multi-requête ou à requêtes groupées) réduit la taille des tenseurs à charger lors du décodage incrémental.", "Sharing keys and values across heads (multi-query or grouped-query attention) reduces the size of the tensors to load during incremental decoding.") },337 { id: "cl-paged", status: "sourced", sourceIds: ["kwon2023"], blockId: "c-mitigations", text: t("En service, la mémoire du cache de chaque requête est volumineuse et varie dynamiquement ; une gestion par pages réduit le gaspillage et permet le partage entre requêtes.", "In serving, each request's cache memory is large and changes dynamically; paged management reduces waste and allows sharing between requests.") },338 ],339 };340 },341};342