Pourquoi chaque mot suivant reste bon marché à générer. · Source

Pour ajouter un mot, il devrait relire tout le chat. Il ne le fait pas.

Un chatbot débite des mots presque aussi vite que tu les lis. Mais pour choisir chaque mot suivant, un modèle est conçu pour revoir tout ce qui a été dit jusque-là. Refais ça de zéro à chaque mot, et une longue conversation avancerait au ralenti. Elle ne rampe pas : elle coule. L'astuce qui la fait couler, c'est toute l'histoire ici.

Chaque nouveau mot relit tous les mots d'avant. Ça s'accumule.

\sum_{t=1}^{n} t = \frac{n(n+1)}{2} \approx \frac{n^2}{2}

Un modèle écrit un mot à la fois, et pour choisir chacun il revoit tout le préfixe. Le mot 2 relit le 1, le mot 100 relit le 99, le mot 1000 relit le 999. Comme un standard rebranché à la main à chaque appel : le même câblage refait encore et encore. Additionne tout ce retravail et le coût grimpe avec le carré de la longueur : double le chat, quadruple le travail.

Mais le passé ne change jamais. Alors pourquoi le recalculer ?

k_j = x_j W_K, \qquad v_j = x_j W_V

Quand le modèle transforme un mot antérieur en les deux choses dont l'attention a besoin — une Key et une Value — celles-ci ne dépendent que de ce mot. Les mots ajoutés ensuite ne peuvent pas revenir les modifier. Comme une empreinte de main pressée dans le ciment frais : dès qu'il prend, elle est figée pour de bon. On la calcule une fois, et c'est réglé.

Alors sauvegarde-les. Tiens une table évolutive de Keys et de Values.

\mathrm{Attn} = \mathrm{softmax}\!\left(\frac{q_t\,K_{1:t}^{\top}}{\sqrt{d}}\right) V_{1:t}

Ne refais pas le passé — stocke-le. Chaque Key et Value que le modèle calcule tombe dans une table qui grandit. Pour écrire le mot suivant, il forme une Query neuve et la confronte à toute cette table sauvegardée. Comme la mise en place d'un chef : prépare chaque ingrédient une fois, puis attrape simplement ce qu'il te faut. Cette table, c'est le KV cache.

Maintenant chaque nouveau mot est bon marché : encode-en un, jette un œil au reste.

\underbrace{O(d^2)}_{\text{one new word}} + \underbrace{O(t\,d)}_{\text{the glance}} \;\ll\; \underbrace{O(t\,d^2)}_{\text{re-encode all } t}

Avec la table sauvegardée, ajouter un mot ne coûte presque rien. Le modèle n'encode que ce seul mot — un coût constant, aussi longue que soit la conversation — puis jette un œil rapide sur les lignes en cache. Comme goudronner une route : tu ne refais pas les kilomètres derrière toi, tu ajoutes de l'enrobé frais seulement sur le front d'avancée. Le coûteux ré-encodage de tout le préfixe disparaît tout simplement.

Le hic : cette table ne fait que grandir. La mémoire est la nouvelle facture.

\text{cache bytes} = 2 \cdot L \cdot n \cdot d_{\text{model}} \cdot b

Tu as acheté de la vitesse avec de l'espace. Le cache stocke deux vecteurs par couche, pour chaque mot jusqu'ici — et il ne fait qu'enfler à mesure que la conversation avance. Pour les longs contextes, il explose en gigaoctets, et c'est ça, pas le calcul, qui devient le mur. Comme un randonneur qui ne pose jamais rien : les notes qui te gardent rapide s'entassent aussi sur ton dos, pas après pas.

Lis le prompt une fois. Puis diffuse — un mot bon marché à la fois.

Voilà le KV cache : échanger de la mémoire contre du temps, pour que le passé ne soit jamais recalculé. Il scinde le travail en deux — lis tout ton prompt en une passe parallèle pour remplir la table, puis diffuse chaque mot en ajoutant une seule ligne et en jetant un œil en arrière. Comme un train de marchandises : tu ne le reconstruis pas pour aller plus loin — tu attelles un wagon de plus et tu continues.

Il peut ajouter à sa mémoire. Il ne peut jamais la réviser.

🌱 Le cache est en ajout seul. Chaque mot que le modèle a vu est figé à l'instant où il tombe — gardé parfaitement, jamais réécrit, comme un disque gravé une seule fois et seulement rejoué. Et chaque nouvelle pensée doit encore revoir tout cela. Alors, une mémoire à laquelle on ne peut qu'ajouter — jamais corriger, jamais raccourcir — est-ce une forme de liberté, ou un poids qui ne peut que croître ?