KV Cache
Ein KV-Cache speichert die Schlüssel und Werte vorheriger Tokens, damit ein Transformer sie nicht erneut berechnen muss. Das beschleunigt die LLM-Generierung. So funktioniert er und so viel Speicher benötigt er.
Ein KV-Cache (Key-Value-Cache) speichert die Schlüssel- und Wertvektoren, die die Aufmerksamkeitslayer eines Transformers für frühere Tokens bereits berechnet haben. So müssen diese Vektoren bei der Erzeugung des nächsten Tokens nicht erneut berechnet werden. Große Sprachmodelle (LLMs) erzeugen Text ein Token nach dem anderen, und jedes neue Token muss allen vorherigen Tokens Aufmerksamkeit schenken. Mit einem KV-Cache berechnet jeder Generierungsschritt Schlüssel und Werte nur für das neueste Token und liest die übrigen aus dem Speicher. Dadurch werden lange Antworten praktikabel. Der Nachteil ist der Speicherbedarf: Der Cache wächst mit jedem Token und benötigt bei langen Kontexten oder beim Serving mit großen Batches oft mehr GPU-Speicher als die Modellgewichte.
So funktioniert der KV-Cache#
In jedem Aufmerksamkeits-Layer wird jedes Token auf eine Query, einen Schlüssel und einen Wert abgebildet. Die Query eines Tokens wird mit den Schlüsseln aller Tokens verglichen, die es sehen kann. Die daraus entstehenden Gewichte kombinieren deren Werte zur Ausgabe. In einem Decoder-only-LLM kann ein Token nur sich selbst und vorherige Tokens sehen. Daher ändern sich die Schlüssel und Werte vergangener Tokens nach ihrer Berechnung nicht mehr. Die Generierung läuft deshalb in zwei Phasen ab. In der Prefill-Phase verarbeitet das Modell die gesamte Eingabeaufforderung parallel und füllt den Cache. In der Decode-Phase erzeugt es pro Schritt ein Token und fügt dessen Schlüssel und Wert dem Cache hinzu, bis es ein End-of-Sequence-Token ausgibt oder eine Längenbegrenzung erreicht:
Das Prefill wird durch die Rechenleistung begrenzt, da dabei große Matrixmultiplikationen für viele Tokens gleichzeitig ausgeführt werden. Das Decoding wird durch die Speicherbandbreite begrenzt, da bei jedem Schritt der gesamte Cache und alle Modellgewichte gelesen werden, um ein einzelnes Token zu erzeugen.
Warum die Generierung dadurch schneller wird#
Ohne Cache würde Schritt t Schlüssel und Werte für alle bis dahin erzeugten t Tokens erneut berechnen. Dadurch wächst der Gesamtaufwand quadratisch mit der Ausgabelänge. Mit dem Cache fügt jeder Schritt pro Layer einen Schlüssel und einen Wert hinzu. Das folgende Beispiel mit einem einzelnen Attention-Head decodiert eine Sequenz aus 10 Tokens mit Cache und vergleicht die letzte Ausgabe mit einer vollständigen Neuberechnung:
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))}")Es gibt Same output: True und cached 10, recomputed 55 aus: Der Cache liefert ein identisches Ergebnis und projiziert dabei jedes Token nur einmal. Ohne Cache wären es 1 + 2 + ... + 10 Projektionen, wenn jeder Schritt von vorn beginnen würde.
KV-Cache im Vergleich zu verwandten Konzepten#
- Prompt-Caching: Behält den KV-Cache eines gemeinsam verwendeten Präfixes einer Eingabeaufforderung, etwa eines langen System-Prompts oder Dokuments, und verwendet ihn für separate Anfragen wieder. Spätere Anfragen überspringen dadurch diesen Teil des Prefills.
- Modellgewichte: Die festen Parameter, die beim Training gelernt werden und von allen Anfragen gemeinsam genutzt werden. Ein KV-Cache gehört zu einer einzelnen Sequenz und wird verworfen, wenn diese Sequenz endet.
- Einbettungen: Die Vektoren, die jedes Token beim Eintritt in das Modell darstellen. Jeder Layer leitet seine eigenen Schlüssel und Werte aus dem verborgenen Zustand des Tokens ab. Ein Cache enthält daher pro Token und Layer einen Schlüssel und einen Wert.
- Semantisches Caching: Speichert vollständige Antworten und gibt sie bei ähnlichen späteren Anfragen zurück, sodass das Modell gar nicht erst ausgeführt werden muss.
KV-Cache in Bildverarbeitungsmodellen#
Bild-Sprach-Modelle (VLMs) wandeln ein Bild in Hunderte oder Tausende visuelle Tokens um, und diese Tokens gelangen wie Text in den KV-Cache, sodass ein einzelnes hochauflösendes Bild genauso viel Cache belegen kann wie mehrere Textseiten. Bei Modellen zur Verarbeitung von Videostreams steigt der Cache-Bedarf mit jedem Frame ebenfalls an. Metas SAM 2, das im Python-Paket von Ultralytics läuft, nutzt für die Videosegmentierung einen ähnlichen Cache: Die Speicherbank von SAM 2 speichert kodierte Merkmale früherer Frames, und der Aufmerksamkeitsmechanismus ruft diese Merkmale beim Segmentieren jedes neuen Frames aus der Speicherbank ab, wodurch Objekte auch bei Verdeckungen weiterverfolgt werden, ohne frühere Frames erneut zu verarbeiten.
Speicherbedarf und Möglichkeiten, ihn zu senken#
Der Cache enthält für jedes Token, jeden Layer und jeden Key-Value-Head zwei Vektoren: einen Schlüssel und einen Wert. Seine Größe beträgt daher 2 × Layer × KV-Heads × Head-Dimension × Bytes pro Wert × Tokens. Bei Llama 2 7B in FP16 mit 32 Layern, 32 Heads und einer Head-Dimension von 128 sind das 512 KiB pro Token oder 2 GiB für eine Sequenz mit 4.096 Tokens. Serving-Systeme verwenden mehrere Verfahren, um mehr Sequenzen im Speicher unterzubringen:
- Grouped-Query-Attention (GQA): Mehrere Query-Heads verwenden gemeinsam einen Key-Value-Head. Llama 3 8B verwendet 8 KV-Heads für 32 Query-Heads und reduziert so den Cache auf 128 KiB pro Token.
- PagedAttention: Speichert den Cache in Blöcken fester Größe, ähnlich wie Seiten im virtuellen Speicher. Dadurch wird der Speicher mit zunehmender Sequenzlänge zugewiesen. Die Technik wurde zusammen mit der vLLM-Serving-Engine eingeführt und steigerte den Durchsatz gegenüber früheren Systemen um das 2- bis 4-Fache.
- KV-Cache-Quantisierung: Speichert Schlüssel und Werte in FP8 oder INT8 statt FP16 und halbiert so die Cache-Größe.
- Gleitfenster-Aufmerksamkeit: Jeder Layer berücksichtigt nur die neuesten Tokens. Dadurch wird der Cache auf die Fenstergröße begrenzt.
- Multi-Head-Latent-Attention (MLA): Komprimiert Schlüssel und Werte vor dem Caching zu einem kleinen gemeinsamen latenten Vektor. Bei DeepSeek-V2 verringerte sich der KV-Cache dadurch im Vergleich zum früheren Modell DeepSeek 67B um 93,3 %.










