KV Cache
Una cache KV memorizza chiavi e valori dei token precedenti, così un Transformer evita di ricalcolarli e accelera la generazione degli LLM. Come funziona e quanto costa in memoria.
Una cache KV (cache chiave-valore) memorizza i vettori chiave e valore che i livelli di attenzione di un transformer hanno già calcolato per i token precedenti, così non devono essere ricalcolati quando il modello genera il token successivo. I modelli linguistici di grandi dimensioni (LLMs) generano testo un token alla volta, e ogni nuovo token deve prestare attenzione a tutti i token che lo precedono. Con una cache KV, a ogni passaggio di generazione si calcolano chiavi e valori solo per il token più recente e si leggono dalla memoria quelli restanti, rendendo praticabili le risposte lunghe. Il costo è la memoria: la cache cresce con ogni token e spesso occupa più memoria GPU dei pesi del modello nei casi di contesto lungo o servizio con batch elevati.
Come funziona la cache KV#
In ogni livello di attenzione, ogni token viene proiettato in una query, una chiave e un valore. La query di un token viene confrontata con le chiavi di tutti i token che può vedere, e i pesi risultanti combinano i loro valori nell'output. In un LLM solo decoder, un token può vedere solo se stesso e i token precedenti, quindi le chiavi e i valori dei token passati non cambiano una volta calcolati. La generazione procede quindi in due fasi. Nella fase di prefill, il modello elabora l'intero prompt in parallelo e riempie la cache. Nella fase di decodifica, genera un token per passaggio e aggiunge alla cache la chiave e il valore di quel token, fino a emettere un token di fine sequenza o raggiungere un limite di lunghezza:
Il prefill è limitato dalla capacità di calcolo, perché esegue grandi moltiplicazioni di matrici su molti token alla volta. La decodifica è limitata dalla larghezza di banda della memoria, perché ogni passaggio legge l'intera cache e tutti i pesi del modello per produrre un singolo token.
Perché accelera la generazione#
Senza una cache, il passaggio t ricalcolerebbe chiavi e valori per tutti i t token generati fino a quel momento, facendo crescere il lavoro totale in modo quadratico rispetto alla lunghezza dell'output. Con la cache, ogni passaggio aggiunge una chiave e un valore per livello. L'esempio con una singola testa qui sotto decodifica una sequenza di 10 token con una cache e confronta l'output finale con un ricalcolo completo:
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))}")Stampa Same output: True e cached 10, recomputed 55: la cache produce un risultato identico proiettando ogni token una sola volta, invece di eseguire 1 + 2 + ... + 10 proiezioni se ogni passaggio ripartisse da capo.
Cache KV e concetti correlati#
- Cachizzazione dei prompt: conserva la cache KV di un prefisso di prompt condiviso, come un lungo prompt di sistema o un documento, e la riutilizza tra richieste separate, così le richieste successive saltano quella parte del prefill.
- Pesi del modello: i parametri fissi appresi durante l'addestramento e condivisi da ogni richiesta. Una cache KV appartiene a una singola sequenza e viene eliminata al termine della sequenza.
- Embedding: i vettori che rappresentano ogni token quando entra nel modello. Ogni livello ricava le proprie chiavi e i propri valori dallo stato nascosto del token, quindi una cache contiene una chiave e un valore per token e per livello.
- Cachizzazione semantica: memorizza risposte complete e le restituisce per query successive simili, evitando del tutto di eseguire il modello.
Cache KV nei modelli visivi#
I modelli di visione e linguaggio (VLMs) trasformano un'immagine in centinaia o migliaia di token visivi, che entrano nella cache KV come i token di testo, perciò una singola immagine ad alta risoluzione può occupare tanta cache quanta ne occupano diverse pagine di testo. I modelli video in streaming subiscono lo stesso aumento a ogni fotogramma. SAM 2 di Meta, che viene eseguito tramite il pacchetto Python di Ultralytics, utilizza un meccanismo di cache simile per la segmentazione video: la sua banca di memoria memorizza le caratteristiche codificate dei fotogrammi precedenti e l'attenzione alla memoria le legge durante la segmentazione di ogni nuovo fotogramma, mantenendo il tracciamento degli oggetti anche durante le occlusioni senza rielaborare i fotogrammi precedenti.
Costo in memoria e come ridurlo#
La cache contiene due vettori, una chiave e un valore, per ogni token, livello e testa key-value; le sue dimensioni sono quindi 2 × livelli × teste KV × dimensione della testa × byte per valore × token. Per Llama 2 7B in FP16, con 32 livelli, 32 teste e una dimensione della testa di 128, si tratta di 512 KiB per token, ovvero 2 GiB per una sequenza di 4.096 token. I sistemi di serving usano diverse tecniche per fare spazio a più sequenze in memoria:
- Attenzione a query raggruppate (GQA): diverse teste di query condividono una testa key-value. Llama 3 8B usa 8 teste KV per 32 teste di query, riducendo la cache a 128 KiB per token.
- PagedAttention: memorizza la cache in blocchi di dimensione fissa, come le pagine della memoria virtuale, così la memoria viene allocata man mano che crescono le sequenze. Introdotta con il motore di serving vLLM, ha aumentato il throughput di 2–4× rispetto ai sistemi precedenti.
- Quantizzazione della cache KV: memorizza chiavi e valori in FP8 o INT8 anziché FP16, dimezzando la cache.
- Attenzione a finestra scorrevole: ogni livello presta attenzione solo ai token più recenti, limitando la cache alla dimensione della finestra.
- Attenzione latente multi-testa (MLA): comprime chiavi e valori in un piccolo vettore latente condiviso prima di memorizzarli nella cache. In DeepSeek-V2, ha ridotto la cache KV del 93,3% rispetto al precedente modello DeepSeek 67B.










