KV Cache
Un cache KV stocke les clés et les valeurs des jetons précédents afin qu’un Transformer n’ait pas à les recalculer, ce qui accélère la génération des LLM. Découvre son fonctionnement et son coût mémoire.
Un cache KV (cache clé-valeur) stocke les vecteurs de clé et de valeur que les couches d’attention d’un Transformer ont déjà calculés pour les jetons précédents, afin de ne pas les recalculer lors de la génération du jeton suivant. Les grands modèles de langage (LLM) produisent du texte un jeton à la fois, et chaque nouveau jeton doit prêter attention à tous ceux qui le précèdent. Avec un cache KV, chaque étape de génération calcule les clés et les valeurs uniquement pour le jeton le plus récent et lit les autres en mémoire, ce qui rend les longues réponses réalisables. Le coût est la mémoire : le cache grandit avec chaque jeton et occupe souvent plus de mémoire GPU que les poids du modèle en contexte long ou en serving à grand lot.
Fonctionnement du cache KV#
Dans chaque couche d’attention, chaque jeton est projeté en une requête, une clé et une valeur. La requête d’un jeton est comparée aux clés de tous les jetons auxquels il peut accéder, et les poids obtenus combinent leurs valeurs pour produire la sortie. Dans un LLM décodeur seul, un jeton ne peut voir que lui-même et les jetons précédents ; les clés et les valeurs des jetons passés ne changent donc plus une fois calculées. La génération se déroule ainsi en deux phases. Lors de la phase de préremplissage, le modèle traite toute l’invite en parallèle et remplit le cache. Lors de la phase de décodage, il génère un jeton par étape et ajoute la clé et la valeur de ce jeton au cache, jusqu’à ce qu’il émette un jeton de fin de séquence ou atteigne une limite de longueur :
Le préremplissage est limité par le calcul, car il exécute simultanément de grandes multiplications matricielles sur de nombreux jetons. Le décodage est limité par la bande passante mémoire, car chaque étape lit tout le cache et tous les poids du modèle pour produire un seul jeton.
Pourquoi cela accélère la génération#
Sans cache, l’étape t recalculerait les clés et les valeurs de tous les t jetons générés jusque-là ; le travail total augmente donc de façon quadratique avec la longueur de sortie. Avec le cache, chaque étape ajoute une clé et une valeur par couche. L’exemple à une seule tête ci-dessous décode une séquence de 10 jetons avec un cache et compare la sortie finale à un recalcul complet :
import torch
torch.manual_seed(0)
d = 64
w_q, w_k, w_v = torch.randn(3, d, d) / d**0.5 # one attention head's projections
tokens = torch.randn(10, d) # embeddings of a 10-token sequence
# Decode token by token: project only the newest token and append it to the cache
k_cache, v_cache = torch.empty(0, d), torch.empty(0, d)
for x in tokens:
k_cache = torch.cat([k_cache, (x @ w_k)[None]])
v_cache = torch.cat([v_cache, (x @ w_v)[None]])
out_cached = torch.softmax((x @ w_q) @ k_cache.T / d**0.5, dim=-1) @ v_cache
# Without a cache, the last step re-projects keys and values for all 10 tokens
k_full, v_full = tokens @ w_k, tokens @ w_v
out_full = torch.softmax((tokens[-1] @ w_q) @ k_full.T / d**0.5, dim=-1) @ v_full
print(f"Same output: {torch.allclose(out_cached, out_full, atol=1e-5)}")
print(f"Key/value projections over 10 steps: cached {len(tokens)}, recomputed {sum(range(1, len(tokens) + 1))}")Le programme affiche Same output: True et cached 10, recomputed 55 : le cache donne un résultat identique en projetant chaque jeton une seule fois, au lieu d’effectuer 1 + 2 + ... + 10 projections si chaque étape repartait de zéro.
Cache KV et concepts associés#
- Mise en cache des invites : conserve le cache KV d’un préfixe d’invite partagé, comme une longue invite système ou un document, et le réutilise pour plusieurs requêtes distinctes. Les requêtes suivantes ignorent ainsi cette partie du préremplissage.
- Poids du modèle : les paramètres fixes appris pendant l’entraînement et partagés par toutes les requêtes. Un cache KV appartient à une séquence et est supprimé lorsque celle-ci se termine.
- Intégrations : les vecteurs qui représentent chaque jeton lorsqu’il entre dans le modèle. Chaque couche dérive ses propres clés et valeurs de l’état caché du jeton ; un cache contient donc une clé et une valeur par jeton et par couche.
- Mise en cache sémantique : stocke des réponses entières et les renvoie pour des requêtes ultérieures similaires, en ignorant complètement le modèle.
Cache KV dans les modèles de vision#
Les modèles vision-langage (VLM) transforment une image en centaines ou milliers de jetons visuels, qui entrent dans le cache KV comme du texte. Une seule image haute résolution peut donc occuper autant de cache que plusieurs pages de texte. Les modèles vidéo en continu subissent la même croissance à chaque image. Le SAM 2 de Meta, disponible dans le package Python Ultralytics, applique un cache similaire à la segmentation vidéo : sa banque mémoire stocke les caractéristiques encodées des images précédentes, et l’attention mémoire les consulte lors de la segmentation de chaque nouvelle image, assurant le suivi des objets malgré les occultations sans retraiter les images passées.
Coût mémoire et moyens de le réduire#
Le cache contient deux vecteurs, une clé et une valeur, par jeton pour chaque couche et chaque tête clé-valeur ; sa taille est donc de 2 × couches × têtes KV × dimension de tête × octets par valeur × jetons. Pour Llama 2 7B en FP16, avec 32 couches, 32 têtes et une dimension de tête de 128, cela représente 512 Kio par jeton, soit 2 Gio pour une séquence de 4 096 jetons. Les systèmes de service utilisent plusieurs techniques pour faire tenir davantage de séquences en mémoire :
- Attention à requêtes groupées (GQA) : plusieurs têtes de requête partagent une tête clé-valeur. Llama 3 8B utilise 8 têtes KV pour 32 têtes de requête, réduisant le cache à 128 Kio par jeton.
- PagedAttention : stocke le cache en blocs de taille fixe, comme des pages de mémoire virtuelle, afin d’allouer la mémoire au fur et à mesure que les séquences grandissent. Introduite avec le moteur de service vLLM, cette technique a multiplié le débit par 2 à 4 par rapport aux systèmes antérieurs.
- Quantification du cache KV : stocke les clés et les valeurs en FP8 ou INT8 plutôt qu’en FP16, divisant ainsi le cache par deux.
- Attention à fenêtre glissante : chaque couche ne prête attention qu’aux jetons les plus récents, ce qui plafonne le cache à la taille de la fenêtre.
- Attention latente multi-tête (MLA) : compresse les clés et les valeurs en un petit vecteur latent partagé avant leur mise en cache. Dans DeepSeek-V2, cette technique a réduit le cache KV de 93,3 % par rapport au modèle DeepSeek 67B précédent.










