Aller au contenu principal

Variantes de l’attention et compression du cache KV

Lors du décodage autorégressif, chaque nouveau jeton porte attention aux clés et aux valeurs de tous les jetons précédents ; des variantes comme l’attention à fenêtre glissante restreignent cette portée. Conserver ces clés et ces valeurs, c’est le cache KV. Il évite de les recalculer, mais sa mémoire croît linéairement avec la longueur de séquence et avec le nombre de séquences décodées en même temps (taille de lot) : dans l’exemple à 32 couches ci-dessous, une séquence de 4096 jetons demande 512 Mio de cache, et un contexte de 128K (32 fois 4096) en demande 16 Gio.

Avec de longs contextes ou de nombreuses séquences décodées en même temps, les octets lus dans le cache à chaque pas peuvent égaler ou dépasser ceux lus pour les poids ; avec un contexte court et une seule séquence, la lecture des poids domine encore.

Trois voies permettent d’alléger le cache : faire partager un même jeu de clés et de valeurs à plusieurs têtes de requête (moins de têtes KV), stocker pour chaque jeton une représentation plus étroite (une largeur de cache réduite), ou garder moins de jetons et les stocker à plus faible précision (moins de jetons en cache, ou moins précis). Les deux premières se décident à l’entraînement ; la troisième agit sur le cache d’un modèle existant.

MHA, GQA et MQA gardent huit têtes de requête et utilisent huit, quatre ou une paire de têtes clé-valeur.Voir l’image en grand

Partez des requêtes bleues. Au centre, deux requêtes partagent une paire clé-valeur ; à droite, toutes partagent la même. Le nombre de requêtes reste constant. À dimensions égales, le cache diminue parce qu’il contient moins de clés et de valeurs.

MHA et GQA​

La taille du cache dépend du nombre de têtes KV pour lesquelles chaque couche stocke des clés et des valeurs. Soit un modèle ayant LL couches, une longueur de séquence SS, nhn_h têtes de requête, nkvn_{kv} têtes KV, une dimension de tête dhd_h et bb octets par élément mis en cache. Les trois types d’attention ne diffèrent que par nkvn_{kv} :

  • L’attention multi-tête (MHA) utilise normalement nkv=nhn_{kv}=n_h : chaque tête de requête a sa propre tête KV.
  • L’attention à requête multiple (MQA) utilise une tête KV partagée par toutes les têtes de requête.
  • L’attention à requêtes groupées (GQA) se situe entre les deux : plusieurs têtes de requête partagent chaque tête KV.

En ignorant les surcoûts d’allocateur et de métadonnées, le cache KV pour une séquence est approximativement

2LSnkvdhb.2L S n_{kv} d_h b.

Autrement dit : pour chaque couche et chaque jeton, chaque tête KV stocke une clé et une valeur de dhd_h nombres chacune, d’où le facteur deux ; on multiplie ensuite par le nombre de couches, le nombre de jetons et le nombre d’octets par nombre.

Pour un exemple hypothétique avec L=32L=32, S=4096S=4096, nh=32n_h=32, nkv=8n_{kv}=8, dh=128d_h=128 et deux octets par élément, le calcul se déroule dans cet ordre :

Ce que l’on calculeExpressionRésultat
nombres stockés par jeton et par couche2×8×1282\times 8\times 1282 048
nombres par jeton sur les 32 couches2,048×322{,}048\times 3265 536
octets par jeton65,536×265{,}536\times 2131 072 octets, soit 128 Kio
total pour 4096 jetons131,072×4096131{,}072\times 4096536,870,912536{,}870{,}912 octets, soit 512 Mio

En MHA, chacune des 32 têtes de requête reçoit sa propre tête KV : nkvn_{kv} passe de 8 à 32 et le cache quadruple, à 2 Gio. Autrement dit, toutes les autres dimensions étant fixes, passer de MHA à GQA réduit le cache proportionnellement à nkv/nhn_{kv}/n_h, ici 8/328/32, soit un quart. Le cache croît aussi linéairement avec la concurrence : quatre séquences GQA de même longueur occupent elles aussi 2 Gio avant surcoûts. Ces chiffres ne couvrent que le cache ; les poids occupent leur propre mémoire.

GQA est un choix architectural fait pendant l’entraînement, pas un commutateur sans perte applicable à des poids arbitraires. La recette de l’article GQA regroupe les têtes clé-valeur d’un modèle multi-tête existant, puis poursuit l’entraînement avec environ 5 % du calcul de pré-entraînement d’origine. Le modèle GQA obtenu approche la qualité multi-tête à une vitesse proche de MQA.

Ce que le cache KV conserve pendant la génération

Chaque nouveau token ajoute une clé et une valeur par tête K/V dans chaque couche. Choisissez comment les têtes de requête partagent les têtes K/V, puis avancez dans le décodage.

Attention
Élément du cache

32 têtes de requête → 8 têtes K/V

123456789101112

token 12Décodage du token 12 : ajouter une ligne (128 Kio sur toutes les couches), puis la nouvelle requête lit les 12 lignes : 1,5 Mio pour cette séquence.

une ligne = 2 (K et V) × 32 couches × 8 têtes K/V × 128 × 2 o = 128 Kio

À une longueur de contexte réelle

Séquences simultanées
Cache KV
512 Mio
4 096 × 1 × 128 Kio
Lu à chaque pas de décodage
512 Mio
par séquence, pour chaque nouveau token
Par rapport à MHA
25%
8 / 32 têtes K/V
0 o32 Gio64 Gio032K64K96K128KMHA · 64 GioGQA · 16 GioMQA · 2 Gio

Avec 1 séquence(s) simultanée(s), le cache GQA dépasse ces poids (14,9 Gio) à partir de 122 071 tokens de contexte.

Forme de l’exemple hypothétique de la note : 32 couches, 32 têtes de requête, dimension de tête 128. La ligne des poids de 8 milliards de paramètres est une taille supposée. Les surcoûts d’allocation et les activations ne sont pas comptés.

Quand la réutilisation est-elle exacte ?​

Un cache n’est réutilisable tel quel que si les clés et valeurs des anciens tokens restent identiques à l’arrivée d’un nouveau token. Un modèle causal remplit cette condition : ajouter un token ne modifie pas les représentations antérieures, et chaque couche ne calcule que les nouvelles positions. Deux requêtes qui commencent de la même façon peuvent donc partager ce morceau de cache : c’est l’origine du cache de préfixe des runtimes. Si le préfixe tokenisé, les poids (adaptateurs compris) ou les indices de position diffèrent en un point, ou si un token ancien est modifié, tous les états mis en cache à partir de là deviennent invalides.

La spéculation en arbre étend ce problème aux branches candidates : les isoler et conserver les états KV et comprimés correspondant au chemin accepté.

Attention latente multi-tête​

GQA économise le cache en stockant moins de têtes. DeepSeek-V2 a introduit l’attention latente multi-tête (MLA), qui prend un autre chemin : au lieu de mettre en cache les tenseurs complets de clés et de valeurs par tête, le modèle apprend une représentation latente de dimension plus faible, ne garde en cache que ce court vecteur pour chaque jeton et le reprojette en clés et valeurs par tête au moment voulu. Des parties du chemin des clés utilisées pour l’information de position rotative (RoPE) restent distinctes, sous la forme d’un petit morceau à part, car la rotation dépendante de la position ne peut pas simplement être incorporée dans une projection fixe.

Une comparaison simplifiée de la largeur du cache est :

Largeur MHA/GQA par jeton et par couche≈2nkvdh,Largeur MLA par jeton et par couche≈dc+dR,\begin{aligned} \text{Largeur MHA/GQA par jeton et par couche} &\approx 2n_{kv}d_h,\\ \text{Largeur MLA par jeton et par couche} &\approx d_c+d_R, \end{aligned}

où dcd_c est la largeur latente compressée et dRd_R la largeur découplée des clés rotatives. Dit autrement, la largeur MHA/GQA croît avec le nombre de têtes KV, tandis que MLA stocke un vecteur latent et une clé de position, quel que soit le nombre de têtes.

Avec la configuration donnée dans l’article DeepSeek-V2 : 60 couches, 128 têtes d’attention de 128 dimensions chacune, largeur latente dc=512d_c=512 et largeur de clé rotative dR=64d_R=64. Le tableau suppose deux octets par nombre :

AttentionNombres par jeton et par couchePar jeton, 60 couches4096 jetons
MHA avec les mêmes têtes2×128×128=32,7682\times 128\times 128=32{,}7683,75 Mio15 Gio
MLA512+64=576512+64=57667,5 Kio270 Mio

MLA stocke par jeton environ cinquante-sept fois moins de nombres qu’une MHA de même forme (32,768÷576≈5732{,}768\div 576\approx 57). Ses 576 nombres sont même inférieurs aux 2 048 par couche de l’exemple GQA à 8 têtes KV ; l’article le formule ainsi : un cache équivalent à une GQA de seulement 2,25 groupes (2×2.25×128=5762\times 2.25\times 128=576).

Comme GQA, MLA se décide à l’entraînement : les projections de compression et de reconstruction sont apprises, et les résultats publiés concernent des modèles entraînés avec cette architecture.

À l’exécution, on règle la longueur, la précision et le cache de préfixe​

La structure de l’attention est fixée à l’entraînement ; qui exécute le modèle ne peut pas la changer. On peut en revanche changer les deux autres nombres de la formule : combien de tokens le cache garde (SS) et combien d’octets occupe chaque valeur (bb), ainsi que le recalcul ou non d’un début identique.

RéglageComment le réglerCoût
Longueur de contexteOllama utilise 4096 tokens par défaut ; on la change avec OLLAMA_CONTEXT_LENGTH ou num_ctx dans la requête. llama.cpp utilise -c, où 0 signifie la longueur enregistrée dans le modèle. mlx-lm passe à un cache tournant de taille fixe avec --max-kv-sizetrop court, l’entrée est tronquée ; plus le cache tournant est petit, moins il prend de mémoire et plus la qualité baisse
Précision du cacheOLLAMA_KV_CACHE_TYPE d’Ollama : q8_0 occupe environ la moitié du f16 par défaut, q4_0 environ le quart ; il faut Flash Attention et le réglage s’applique à tous les modèles. llama.cpp utilise -ctk et -ctv, f16 par défaut, avec q8_0, q4_0 et d’autres. vLLM règle le FP8 avec kv_cache_dtypeplus la précision baisse, plus les scores d’attention dérivent ; la documentation de vLLM signale que les couches à fenêtre glissante et similaires sont plus sensibles à la quantification du cache
Cache de préfixele serveur de llama.cpp active --cache-prompt par défaut ; vLLM utilise enable_prefix_caching=Truen’économise que le préremplissage, pas la génération token par token ; un début différent ne peut pas en profiter

Avec l’exemple GQA ci-dessus : 128 Kio par token donnent 4 Gio à 32K de contexte ; q8_0 ramène cela à environ 2 Gio et q4_0 à environ 1 Gio. La répartition du budget d’une machine entre poids et cache se trouve dans le déploiement sur un appareil.

Compresser un cache existant​

Une autre famille de méthodes de recherche laisse l’architecture entraînée intacte et supprime des tokens du cache. SnapKV note les positions antérieures avec l’attention d’une fenêtre d’observation placée en fin de prompt et ne garde que les clés et valeurs les mieux notées. PyramidKV donne aux couches des budgets de cache différents selon la répartition de leur attention. La mémoire économisée vient du stockage de moins de tokens, au risque de supprimer un passage bref mais décisif.

Ce qu’il faut mesurer​

Pour un déploiement concret, consignez :

  1. le modèle exact, l’architecture d’attention et le dtype du cache ;
  2. la longueur du prompt, la longueur générée et le nombre de séquences simultanées ;
  3. la mémoire GPU et hôte de pointe ;
  4. le temps de préremplissage, le temps jusqu’au premier jeton et le débit de décodage ;
  5. la réussite de la tâche sur des cas à long contexte exigeant des informations situées à différentes positions ;
  6. le comportement après éviction du cache, quantification ou déport vers le CPU.

L’adéquation mémoire et la qualité des réponses préservée nécessitent des tests distincts : un modèle qui annonce une longue fenêtre de contexte peut ne pas tenir sur le matériel disponible, tandis qu’une méthode économisant le cache qui tient en mémoire peut encore échouer à la tâche.

Explorer les liensOuvrir le réseau