KV-Cache-Tensordecomposition: Wo Low-Rank-Kompression mathematisch tot ist (und wo nicht)

Alle paar Monate verspricht eine Produktankündigung KV-Cache-Kompression „gratis" — halbiere deinen Cache, behalte deine Qualität. Der Mechanismus ist meist eine Variante der Niedrigrang-Approximation: Keys und Values in einen kleineren latenten Raum projizieren oder Basen über Köpfe oder Layer teilen und beim Lesen rekonstruieren. Manchmal veröffentlicht der Anbieter Perplexity-Deltas, die harmlos aussehen; manchmal berichten Nutzer, dass das komprimierte Modell drei Turns in ein langes Gespräch hinein still den Faden verliert. Ein Mathe-Papier vom September 2026 ist der Vorschlagshammer, der klärt, auf welcher Seite dieser Trennlinie man steht — denn es fragt nicht mehr „welcher Kompressionsalgorithmus ist der beste", sondern die Frage, die zuerst kommen muss: welche Achsen des KV-Cache sind überhaupt komprimierbar?¹

Das Papier ist Tensor Decomposition of Transformer Key-Value Caches: Spectral Structure and Format Comparison (arXiv:2609.28029, math.NA, eingereicht am 23. September 2026, von Rahul Krishnan und Volker Schulz)¹. Was es tut, ist systematisch und ungewöhnlich ehrlich: echte KV-Caches aus zwei Produktionsmodellen extrahieren — Mistral-7B-v0.3 (Grouped-Query-Attention, 32 Layer, 8 KV-Köpfe, Kopfdimension 128) und Llama-2-13B (Multi-Head-Attention, 40 Layer) —, den Cache entlang jeder seiner vier Achsen entfalten, das Singulärwertspektrum jeder Entfaltung messen und dann vier Standard-Tensordekompositionen (Tucker, CP, Tensor Train, t-SVD) bei gleichem Speicher fitten. Jede Aussage unten ist gelabelt: papierverifiziert, wo ich sie im Papier gelesen habe; eigene Nachrechnung, wo wir die Arithmetik geprüft haben; Simulation, wo die Zahl aus einem synthetischen Modell stammt, das den Mechanismus isoliert.

Der KV-Cache ist ein vierwegiger Tensor, und seine Achsen sind nicht gleichberechtigt

Beim autoregressiven Decoding hält der KV-Cache in jeder Schicht für jedes vergangene Token und jeden Attention-Kopf einen Key-Vektor und einen Value-Vektor. Stapelt man die Cache-Slices der Layer, entsteht ein Tensor vierter Ordnung mit den Achsen Köpfe, Tokens, Features (die per-Kopf-Featuredimension, bei beiden untersuchten Modellen 128) und Layern — das Papier gruppiert benachbarte Layer, die Layer-Achse meint also die Anzahl gruppierter Layer, nicht alle 32 oder 40 auf einmal². Eine Tensordekomposition nutzt Korrelationen über mehrere Achsen gleichzeitig; welche Dekomposition die richtige ist, hängt vollständig davon ab, wo diese Korrelationen tatsächlich liegen.

Das erste Ergebnis des Papiers ist eine saubere Zweiteilung der vier Achsen — eine „Mode-Count-Dichotomie"²:

• Token-Achse: komprimierbar. Die Entfaltung der Key-Caches entlang der Tokens fällt um mehrere Größenordnungen; substanzielle Rangreduktion ist bei kleinem Fehler verfügbar.
• Feature-Achse: komprimierbar für Keys, fast inkomprimierbar für Values. Bei Keys lässt das Feature-Spektrum Rangabschnitt zu; bei Values bleibt es nahezu flach.
• Kopf-Achse: praktisch vollrangig. Die Kopf-Entfaltung braucht ihren vollen Rang bei jeder im Papier getesteten Fehlerschwelle. Jeder Kopf trägt vergleichbare Energie; Köpfe zu beschneiden kostet echten Fehler — konsistent mit der Per-Kopf-Outlier-Struktur, die auch aggressive Attention-Kompression überdauert: jeder Kopf ist ein eigener Informationskanal, keine redundante Kopie seiner Nachbarn.
• Layer-Achse (Gruppen): praktisch vollrangig. Dasselbe Bild über gruppierte Layer — die kleinste Singulärrichtung allein trägt mehr Energie als jedes praktische Fehlerbudget.

Das Papier nennt die letzten beiden indexartig (Definition 3.1 im Papier): Ein Modus ist indexartig auf Fehlerniveau ε, wenn die kleinste Singulärwert seiner Entfaltung mehr als ε² der quadrierten Energie trägt — dann kann keine Approximation mit abgesenktem Rang entlang dieses Modus den relativen Fehler ε erreichen. Das ist keine Aussage über einen bestimmten Algorithmus; es folgt aus dem Satz von Eckart–Young–Mirsky, angewandt auf die Modus-Entfaltung, und ist formatagnostisch: das Papier zeigt, dass die gemessenen Fehler erzwungener Ränge innerhalb weniger Prozent an diese untere Schranke heranreichen². Keine Schlauheit im Kompressor hebt sie auf.

Warum das ein Anti-Hype-Vorschlagshammer ist

Nun auf die Produktlandschaft kartieren. Cross-Layer-KV-Sharing, Head-Mixing-Projektionen, „acht Köpfe in einen latenten Raum mergen" — die ganze Familie der „über Köpfe oder Layer komprimieren"-Versprechen betreibt Rangreduktion entlang von Achsen, deren gemessene Spektren flach sind. Die Ablation des Papiers macht die Kosten konkret: Den Layer-Gruppen-Rang nur eine Stufe unter Vollrang zu erzwingen (auf Mistral-Gruppen 4 → 3) verdreifacht fast den Key-Rekonstruktionsfehler, und die Halbierung des Kopf-Rangs erzeugt einen vergleichbaren Sprung. Schlimmer: Die erzwungenen Konfigurationen verbessern sich kaum, wenn das Speicherbudget von 2x- auf 4x-Kompression gelockert wird — der abgeschnittene Rang, nicht das Budget, setzt den Fehlerfloor, und zusätzlicher Speicher kauft ihn nicht zurück³.

Wenn ein Anbieter also Qualitätsverluste durch einen Kopf- oder Layer-Misch-Kompressor meldet, ist dieser Verlust kein Bug der Implementierung, keine Frage besserer Kalibrierungsdaten oder mehr Trainingsaufwand. Es ist das flache Spektrum der Kopf- und Layer-Achsen, das sich durchsetzt. Die ehrliche Lektüre des Papiers für Käufer von Kompressionssystemen:

1. Entlang Tokens und Features komprimieren, Keys zuerst. Dort liegt die Niedrigrang-Struktur.
2. Nicht über Köpfe oder gruppierte Layer mischen bei moderaten Fehlertoleranzen; die Mathematik sagt, dass der Verlust strukturell ist.
3. Keys und Values brauchen getrennte Rangbudgets — das Value-Spektrum ist überall flacher, und beide zusammen zu budgetieren verschwendet Key-Kompressibilität (eine „K/V-Asymmetrie", die das Papier auf die Rollen der Projektionsmatrizen W_V und W_K zurückführt: Values müssen Energie über Features streuen, um Inhalt unter beliebigen Attention-Gewichtungen zu erhalten; Keys brauchen nur wenige diskriminative Richtungen zum Scoring⁴).
4. Keys vor RoPE komprimieren, nicht danach. Die positionsabhängige Rotation des Rotary Embedding flattet die Token- und Feature-Spektren; Post-RoPE-Keys verlieren 41 %–64 % ihrer Pre-RoPE-Kompressibilität auf beiden Modellen⁴.

Die Einschränkung schneidet in beide Richtungen, und das Papier nennt sie selbst: Alle Rekonstruktionssweeps nutzen eine einzige Sequenzlänge (1.024 Tokens, WikiText-2-Validierungsabschnitte), die Spektren decken zwei Modelle ab, und „praktisch vollrangig" ist eine Aussage auf praktischen Fehlerniveaus, keine ewige Konstante. Extreme Toleranzen, andere Architekturen, deutlich längere Kontexte können abweichen; ob die Token-Struktur beim inkrementellen Generieren besteht, bleibt ausdrücklich offen³. Vollrangig bei 1 % Fehler ist nicht vollrangig bei 50 % Fehler. Aber jedes „gratis 2x"-Versprechen auf dem Markt lebt exakt im Fehlerregime, in dem die Kopf- und Layer-Achsen als inkompressibel zertifiziert sind.

Tucker gewinnt, weil es die vollrangigen Modi in Ruhe lassen kann

Angesichts der Spektren ist der Formatvergleich fast deterministisch. Das Papier fittet Tucker, CP, Tensor Train und t-SVD auf jeden Layer beider Modelle bei gleichem Speicher über Kompressionsverhältnisse von 2x bis 5x. Ergebnis: Tucker erreicht den niedrigsten Rekonstruktionsfehler bei jedem Verhältnis auf beiden Modellen (CP wurde auf Llama-2-13B weggelassen, weil das Fitten bei gleichem Speicher den Speicher des Versuchs-GPUs überstieg; die Llama-Reihenfolge ist Tucker, dann t-SVD, dann TT)⁵.

Der Grund ist strukturell, kein Tuning-Zufall. Tuckers multilineare Ränge sind pro Modus und unabhängig wählbar — der Allokator kann die Kopf- und Layer-Ränge auf Vollrang pinnen, für diese Faktoren nichts speichern (ein vollrangiger Tucker-Faktor ist die Identität und kann aus dem Speicher entfallen) und das gesamte Budget auf die Token- und Feature-Achsen verwenden, wo der Abfall wirklich liegt. CP zwingt alle Modi auf einen gemeinsamen Rang — Tensor komprimieren heißt dann auch, die Kopf-Achse abzuschneiden. Tensor Train fädelt eine Kette durch alle Modi und zahlt an jeder Verbindung einen Bond-Rang. t-SVD wendet abgeschnittene SVDs auf Frontal-Slices bei jeder Frequenz an und zieht die Kopf-Struktur in jeden Abschnitt hinein. Alle drei müssen Budget — und Fehler — für Achsen ausgeben, die nichts herzugeben haben.

Und das Papier lässt die Empfehlung „pinne einfach die vollrangigen Modi" nicht als Folklore stehen: Theorem 5.1, das Mode-Pinning-Theorem, liefert eine hinreichende Bedingung, allein aus den gemessenen Modus-Spektren prüfbar (ein Worst-Case-Argument über Austauschkosten gegen die Restenergie des Modus), unter der der optimale Lagrange-Rangallokator einen Modus nachweisbar auf Vollrang hält. Auf jeder getesteten Kopf-Modus-Konfiguration beider Modelle über die Verhältnisse 2x–5x hält das Zertifikat — das Papier meldet es erfüllt auf allen 160 Mistral- und allen 224 Llama-Kopf-Konfigurationen, plus der großen Mehrheit der Layer-Gruppen-Zellen⁶. Das ist der Teil, den Praktiker verinnerlichen sollten: Man kann die Modus-Spektren des eigenen Modells messen (eine SVD pro Entfaltung, billig) und im Voraus zertifizieren, welche Achsen ein Rangallokator sich weigert abzuschneiden — bevor man irgendetwas fittet.

Keys und Values wollen verschiedene Formate

Der Formatsweep des Papiers birgt eine weitere Asymmetrie, die erst gegen zweidimensionale Baselines sichtbar wird. Gegen Per-Kopf-SVD und gegen Cross-Layer-2D-Faktorisierungen im Stil von Palu und xKV spaltet sich die bevorzugte Darstellung an der K/V-Grenze⁷:

• Keys: 2D-Entfaltungen gewinnen. Der Key-Tensor fällt entlang beider großer Achsen (Tokens und Features) stark ab, also ist eine Matrixfaktorisierung, die ihr gesamtes Budget auf diese beiden Achsen konzentriert, am effizientesten. Cross-Layer-2D (xKV-Stil) ist ab 3x am niedrigsten.
• Values: vierwegiger Tucker gewinnt. Das Value-Feature-Spektrum ist nahezu flach, 2D-Faktorisierungen stoßen an ihren Fehlerfloor; Tucker umgeht ihn, indem er kompakte Basen über Köpfe teilt und unabhängige Ränge pro Modus vergibt. Tucker-4D schlägt Tucker-3D und beide 2D-Baselines bei jedem getesteten Verhältnis auf Values.

Die praktische Lehre ist nicht „Tucker überall", sondern: das optimale Cache-Format hängt von der Achse und vom Tensor ab — 2D für Keys, 4-Wege-Tucker für Values, in jedem Fall vollrangig gepinnte Köpfe und Layer. Eine einzige Kompressorarchitektur, identisch auf K und V angewandt, lässt in einem der beiden Qualität liegen.

Die Mathematik modellieren: Mixed-Rank-Spektren und die Kosten der Kompression eines vollrangigen Modus

Die Spektrumstabellen des Papiers sind auf echten Caches aus zwei Checkpoints gemessen. Mistral-7B-v0.3 liegt offen auf HuggingFace, seine Zahlen sind damit grundsätzlich für Leser nachrechenbar (das Papier verweist auch auf sein Code-Repositorium)⁸; Llama-2-13B (meta-llama/Llama-2-13b-hf) liegt hinter Metas Lizenzvereinbarung — gegated, „aus öffentlichen Gewichten nachrechenbar" gilt also nur für Leser mit genehmigtem Zugang, und das sagen wir klipp und klar, statt so zu tun, als sei es offen.

Um den Mechanismus ohne den Download mehrerer GB Gewichte sichtbar zu machen, hier ein synthetischer KV-ähnlicher Tensor, gebaut mit der Dichotomie des Papiers: Niedrigrang-Struktur entlang Tokens und Features, vollrangiges (flachspektrumiges) Kopf- und Layer-Mixing. Alles Folgende ist eine Simulation — sie isoliert die Lineare Algebra, sie reproduziert nicht die gemessenen Zahlen des Papiers.

import numpy as np
rng = np.random.default_rng(42)
 
# ---------- (a) synthetischer KV-Cache-ähnlicher 4-Wege-Tensor ----------
H, S, F, L = 8, 512, 128, 4      # Köpfe, Tokens, Features, Layer-Gruppen (Mistral-7B-v0.3-ähnlich)
r_token, r_feat = 16, 24        # Niedrigrang-Struktur Token/Feature; Köpfe/Layer vollrangig
T = np.empty((H, S, F, L))
for h in range(H):
    for l in range(L):
        Ut = rng.standard_normal((S, r_token)); Wt = rng.standard_normal((F, r_feat))
        C  = rng.standard_normal((r_token, r_feat)) / (1.0 + np.arange(r_token)[:, None])**2
        T[h, :, :, l] = (Ut @ C @ Wt.T) * (1.0 + 0.3 * rng.standard_normal())
T += 0.01 * rng.standard_normal(T.shape)
 
def rel_err(X, T): return np.linalg.norm(X - T) / np.linalg.norm(T)
 
def unfold(T, ax):
    return np.moveaxis(T, ax, 0).reshape(T.shape[ax], -1)
 
# ---------- (b) SVD-Spektren pro Modus: die zwei Klassen ----------
print(f"tensor shape (heads, tokens, features, layer groups) = {T.shape}")
for name, ax in [('heads', 0), ('tokens', 1), ('features', 2), ('groups', 3)]:
    s = np.linalg.svd(unfold(T, ax), compute_uv=False)
    e = s**2 / (s**2).sum()
    cum = np.cumsum(e)
    r95, r99 = int(np.searchsorted(cum, 0.95) + 1), int(np.searchsorted(cum, 0.99) + 1)
    print(f"{name:9s} dim={T.shape[ax]:4d}  SV/SV1[:4]={np.round(s[:4]/s[0], 3)}  "
          f"rank(95%)={r95:3d}  rank(99%)={r99:3d}  min-SV energy={e[-1]:.5f}")

tensor shape (heads, tokens, features, layer groups) = (8, 512, 128, 4)
heads     dim=   8  SV/SV1[:4]=[1.    0.946 0.942 0.861]  rank(95%)=  8  rank(99%)=  8  min-SV energy=0.07563
tokens    dim=512  SV/SV1[:4]=[1.    0.938 0.831 0.804]  rank(95%)= 36  rank(99%)= 69  min-SV energy=0.00000
features  dim=128  SV/SV1[:4]=[1.    0.933 0.866 0.818]  rank(95%)= 32  rank(99%)= 57  min-SV energy=0.00001
groups    dim=   4  SV/SV1[:4]=[1.    0.854 0.83  0.825]  rank(95%)=  4  rank(99%)=  4  min-SV energy=0.21968

Die letzte Spalte lesen. Die Kopf- und Layer-Entfaltungen brauchen ihre volle Dimension, um überhaupt 95 % der Energie zu erreichen — die kleinsten Singulärwerte tragen 7,6 % bzw. 22 % der Energie, jede Abschneidung unter Vollrang zahlt also sofort. Die Token- und Feature-Entfaltungen erreichen 95 % der Energie bei Rang 36 von 512 bzw. 32 von 128. Zwei Spektrumsklassen, exakt wie in Tabelle 1 des Papiers — hier per Konstruktion, dort per Messung.

Jetzt der Teil, der „warum ist die Kompression eines vollrangigen Modus nicht gratis" beantwortet: ein Speicher-gematchter Sweep von ST-HOSVD (sequenziell abgeschnittener Tucker) mit zwei Armen. Im gepinnten Arm bleiben Kopf- und Layer-Faktoren vollrangig — als weggelassene Identitätsfaktoren gespeichert —, und das Budget geht vollständig in die Token- und Feature-Ränge. Im erzwungenen Arm wird der Kopf-Rang zuerst halbiert (der „Köpfe mergen"-Zug), und der Allokator verteilt das frei gewordene Budget optimal. Beide Arme haben dasselbe Speicherbudget.

# ---------- (c) Tucker bei gleichem Speicher: Kopf-Modus gepinnt vs. halbiert ----------
def tucker_pin_tf(T, r_s, r_f):
    """ST-HOSVD, nur Token (Modus 1) und Feature (Modus 2) abgeschnitten; Köpfe+Layer voll."""
    M1 = np.transpose(T, [1, 0, 2, 3]).reshape(S, -1)
    U1 = np.linalg.svd(M1, full_matrices=False)[0][:, :r_s]
    core = (U1.T @ M1).reshape(r_s, H, F, L)
    M2 = np.transpose(core, [2, 0, 1, 3]).reshape(F, -1)
    U2 = np.linalg.svd(M2, full_matrices=False)[0][:, :r_f]
    c2 = (U2.T @ M2).reshape(r_f, r_s, H, L)
    X = np.transpose((U2 @ c2.reshape(r_f, -1)).reshape(F, r_s, H, L), [1, 2, 0, 3])
    X = (U1 @ X.reshape(r_s, -1)).reshape(S, H, F, L)
    return np.transpose(X, [1, 0, 2, 3])
 
def tucker_force_head(T, r_h, r_s, r_f):
    """Gleiches Budget, aber Kopf-Modus zuerst auf r_h abgeschnitten (Spektrum-Floor greift)."""
    M0 = T.reshape(H, -1)
    U0 = np.linalg.svd(M0, full_matrices=False)[0][:, :r_h]
    Tp = (U0.T @ M0).reshape(r_h, S, F, L)
    M1 = np.transpose(Tp, [1, 0, 2, 3]).reshape(S, -1)
    U1 = np.linalg.svd(M1, full_matrices=False)[0][:, :r_s]
    core = (U1.T @ M1).reshape(r_s, r_h, F, L)
    M2 = np.transpose(core, [2, 0, 1, 3]).reshape(F, -1)
    U2 = np.linalg.svd(M2, full_matrices=False)[0][:, :r_f]
    c2 = (U2.T @ M2).reshape(r_f, r_s, r_h, L)
    X = np.transpose((U2 @ c2.reshape(r_f, -1)).reshape(F, r_s, r_h, L), [1, 2, 0, 3])
    X = (U1 @ X.reshape(r_s, -1)).reshape(S, r_h, F, L)
    X = np.transpose(X, [1, 0, 2, 3])
    return np.einsum('ij,jsfl->isfl', U0, X)
 
orig = H * S * F * L
r_h = H // 2
print(f"\nmatchter Speicher-Sweep, Original = {orig:,} Skalare, Kopfdim {H} erzwungen auf {r_h}")
for ratio in (2, 4, 8):
    budget = orig / ratio
    best_p = best_f = None
    for r_s in range(32, S + 1, 16):
        rf = (budget - r_s * S) / (r_s * H * L + F)      # gepinnt: Kern + 2 Faktoren
        r_f = max(1, min(F, int(rf)))
        st = r_s * r_f * H * L + r_s * S + r_f * F
        if st > budget: continue
        e = rel_err(tucker_pin_tf(T, r_s, r_f), T)
        if best_p is None or e < best_p[0]: best_p = (e, (r_s, r_f), st)
    for r_s in range(32, S + 1, 16):
        for r_f in range(16, F + 1, 16):
            st = r_h * r_s * r_f * L + r_h * H + r_s * S + r_f * F  # + Kopffaktor
            if st > budget: continue
            e = rel_err(tucker_force_head(T, r_h, r_s, r_f), T)
            if best_f is None or e < best_f[0]: best_f = (e, (r_s, r_f), st)
    print(f"ratio {ratio:>2}x Budget {int(budget):>7,}:  gepinnt (H,L voll) Fehler {best_p[0]:.4f}  "
          f"Ränge {best_p[1]}  |  erzwungen head={r_h} Fehler {best_f[0]:.4f}  Ränge {best_f[1]}")

matched-storage sweep, original = 2,097,152 scalars, head dim 8 forced to 4
ratio  2x budget 1,048,576:  pinned (H,L full) err 0.0130  ranks (224, 128)  |  forced head=4 err 0.6222  ranks (400, 128)
ratio  4x budget 524,288:  pinned (H,L full) err 0.0411  ranks (128, 108)  |  forced head=4 err 0.6222  ranks (192, 128)
ratio  8x budget 262,144:  pinned (H,L full) err 0.0837  ranks (80, 82)  |  forced head=4 err 0.6224  ranks (112, 96)

Zwei Dinge fallen auf, beide spiegeln die Ablation aus Abschnitt 5.3 des Papiers auf echten Caches. Erstens: Pinning funktioniert — mit unangetasteten Kopf- und Layer-Modi steigt der Fehler sanft, wenn das Budget sinkt (1,3 % → 8,4 % von 2x bis 8x), weil das Budget nur Achsen abschneidet, die Abfallüberschuss haben. Zweitens: Der erzwungene Arm ist flach — 62,2 % Fehler bei jedem Budget, denn sobald der Kopf-Rang unter Vollrang liegt, ist die Energie der verworfenen Richtungen unwiederbringlich, egal wie viel Token- und Feature-Rang man mit dem freigemachten Budget kauft. Den Fehlerfloor setzt der Rang, nicht der Speicher — der Speicher-Regler arbeitet nicht mehr. Diese flache Linie ist die lineare-algebraische Signatur hinter jedem enttäuschenden Head-Mixing-Kompressor-Demo.

Eine Ehrlichkeitsanmerkung zur Simulation: Der erzwungene Arm profitiert hier leicht davon, dass das Kopf-Mixing eine orthogonal-artige Projektion ist, die die verlorene Energie über überlebende Richtungen verteilt. Echte Caches, deren Köpfe unabhängigen Inhalt tragen (die indexartige Definition des Papiers), erreichen denselben Floor über dieselbe Eckart–Young-Restenergie. Die Zahlen oben sind konstruktionsabhängig; die Form des Arguments — flacher Floor gegen sanft steigende Kurve — ist es nicht.

Ich habe eine Live-Messung einer echten KV-Entfaltung aus Mistral-7B-v0.3 erwogen (Range-Read der K-Projektion via safetensors, SVD eines Kurzprompt-Caches), aber verworfen: Der Checkpoint ist ein Multi-GB-Download für ein einzelnes illustratives Spektrum, und die gemessenen Tabellen des Papiers plus diese Simulation zeigen den Mechanismus bereits. Leser mit lokal gecachtem Modell können die Spektren des Papiers mit dem Code der Autoren reproduzieren⁸.

Was Montag damit anfangen kann

Für alle, die KV-Cache-Kompression bauen oder kaufen, übersetzt sich das Papier in eine kurze Checkliste:

1. Fragen, welche Achsen der Kompressor abschneidet. Token-/Feature-Abschnitt ist spektral begründet; Kopf-/Layer-Abschnitt bei moderatem Fehler kämpft gegen einen vollrangigen Modus. Wenn ein „gratis 2x"-Angebot Köpfe oder Layer mischt: die Modus-Spektren verlangen.
2. Die eigenen Spektren messen, bevor irgendwas getunt wird — das Mode-Pinning-Zertifikat ist mit einer SVD pro Modus-Entfaltung prüfbar, und Eigenheiten des Modells (GQA-Kopfzahlen, Layer-Gruppierung) verschieben die Konstanten, nicht die Dichotomie. Das ist dieselbe „erst messen, dann tunen"-Disziplin wie beim Working-Set-Sizing für Prefix-Caches (siehe auch das KV-Cache-Glossar).
3. Keys und Values getrennt budgetieren. Values brauchen grob den doppelten Token-Rang der Keys bei gleichem Fehler; ein gemeinsamer Rang verschwendet die eine Seite oder hungert die andere aus⁴.
4. Keys vor RoPE komprimieren — 41 %–64 % der Key-Kompressibilität verdunsten nach der Rotation⁴.
5. Die Speicherökonomie im Kopf behalten. KV-Cache-Kompression ist keine Ästhetikübung; Cache-Bytes sind der bindende Constraint für die Batchgröße und damit die Serving-Kosten — dieselbe HBM-Knappheits-Arithmetik, die eine glaubhafte 2x-Reduktion überhaupt erst wert macht.

Die tiefe Ironie dieses Papiers ist angenehm: Dieselbe Mathematik, die den „komprimiere alles"-Hype tötet, sagt auch genau, wo Kompression wirklich funktioniert — entlang Tokens und Features, Keys vor RoPE, Values in Tucker-Form, Köpfe und Layer in Ruhe gelassen, zertifiziert durch ein Theorem. Das ist nützlicher als jeder Vendor-Benchmark, denn anders als ein Benchmark sagen die Spektren einem auch, was das nächste Modell tun wird — und sie waren die ganze Zeit billig zu messen.