VRAM-Mathematik

Jede „läuft das auf meiner Karte“-Frage ist Arithmetik, keine Folklore.
Der Gesamt-VRAM sind die Gewichte, plus der KV-Cache, plus ein fester Block aus
Aktivierungen und Engine-Overhead. Wenn Sie Parameter mit Bits multiplizieren
können, können Sie eine Maschine bemessen, bevor Sie etwas dafür ausgeben. Diese
Seite liefert die Formel, Rechentabellen und eine 16-GB-Durchrechnung, die Sie für
jede Karte kopieren können.

Die Formel

total VRAM   = weights + KV cache + overhead
weights (GB) = parameters (B) × bits per weight ÷ 8
KV cache     = bytes per token × context length   (siehe [KV-Cache](/guide/kv-cache))
overhead     ≈ 1–2 GB (Aktivierungen, Treiberkontext, Buffer, Fragmentierung)

Effektive Bits pro Gewicht für die gängigen GGUF-Quants: Q4_K_M ≈ 4,8,
Q5_K_M ≈ 5,7, Q6_K ≈ 6,6, Q8_0 ≈ 8,5. Multiplizieren Sie Parameter damit, teilen
Sie durch 8, und Sie liegen innerhalb weniger Prozent der Dateigröße auf der Platte.

Faustregeln, die man sich merken sollte, in GB pro Milliarde Parameter:

• Q4_K_M ≈ 0,6 GB — das alltägliche Arbeitstier
• Q5_K_M ≈ 0,7 GB
• Q6_K ≈ 0,8 GB — für die meisten Augen nahezu verlustfrei
• Q8_0 ≈ 1,1 GB — transparent, grob doppelt so teuer wie Q4
• fp16/bf16 = 2,0 GB — Terrain für Training und ernsthaftes Fine-Tuning

Durchgerechnete Beispiele

Die KV-Cache-Größe hängt von der Architektur ab. Moderne GQA-Modelle liegen bei
fp16-KV grob bei 128–256 KB pro Token für die Klassen 8B–32B und bei rund 320 KB
für die 70B-Klasse. Die exakte Formel steht auf KV-Cache;
hier rechnen wir sie nur ein. Overhead wird mit 1,5 GB pro Zeile angesetzt.

Q4_K_M (~4,8 Bits pro Gewicht):

Q6_K (~6,6 Bits pro Gewicht):

Zwei Muster zum Verinnerlichen. Q6_K kostet ~35–40% mehr als Q4_K_M — oft der
Unterschied zwischen einer GPU-Klasse und der nächsten. Und KV bei 32k Kontext ist
kein Rundungsfehler: Bei kleinen Modellen rivalisiert es mit den Gewichten selbst.
Alte MHA-Designs (Llama-2-Ära) trugen 4–8× größere KV-Caches, weshalb 32k Kontext
früher exotische Hardware verlangte und GQA-Modelle nicht.

OOM beim Laden vs. OOM mitten in der Generierung

• Beim Laden: Schon die Gewichte übersteigen den freien VRAM. Die Engine
  verweigert den Start oder lagert Layer auf die CPU aus und robbt. Ehrlich,
  sofort, leicht zu diagnostizieren.
• Mitten in der Generierung: Die Gewichte passen, aber der KV-Cache wächst
  Token um Token. Eine frische Sitzung läuft fein; vierzig Runden später, nach
  einem RAG-Dump oder einer eingefügten Datei, frisst der Cache Ihre Reserve und
  der Prozess stirbt mitten in der Antwort. Das ist der hinterhältige Fall —
  bemessen Sie immer für den Kontext, den Sie tatsächlich erreichen werden, nicht
  für den ersten Prompt.

Sehen Sie es live geschehen:

watch -n1 nvidia-smi --query-gpu=memory.used,memory.total --format=csv

Bemessungs-Worksheet: die 16-GB-Durchrechnung

1. Nutzbares Budget: 16 GB × 0,85 ≈ 13,6 GB. Desktop, Browser und Treiber
   reservieren bereits 0,5–1 GB; 10–20% Reserve ist die Regel, kein Kosmetikpunkt.
2. Traum: 32B Q4_K_M — schon 19,2 GB Gewichte. Tot bei Ankunft.
3. Realistisch: 14B Q4_K_M bei 8k Kontext: 8,4 + 1,6 + 1,5 = 11,5 GB. Passt mit
   ~15% Reserve. Ausliefern.
4. Jetzt wollen Sie 32k Kontext: 8,4 + 6,4 + 1,5 = 16,3 GB. Über Budget.
5. Drei Fixes — wählen Sie einen oder kombinieren Sie:
   • KV-Cache auf q8_0 quantisieren: 6,4 → 3,2 GB, gesamt 13,1 GB. Rein.
   • Gewichte auf Q4_K_S oder IQ4_XS senken, was weitere ~0,5–1 GB spart.
   • Auf 8B Q6_K fallen: 6,6 + 4,2 + 1,5 = 12,3 GB, geräumig.

Dieselben fünf Schritte funktionieren für eine 8-GB-Karte, eine 24-GB-Karte oder
eine 48-GB-Dual-GPU-Kiste. Budgetieren, träumen, abziehen, anpassen.

Immer Reserve lassen

Engines allocieren Scratch-Buffer pro Batch-Slot, Fragmentierung sammelt sich über
einen lange laufenden Server, und Parallelität vervielfacht KV pro aktiver Anfrage.
Eine Konfiguration, die in einem einmaligen Benchtest „gerade so passt“, wird in
Produktion OOM gehen. 10–20% frei ist die Steuer fürs Obenbleiben. Was in jeder
Kartenklasse praktisch passt, steht in GPU-Klassen; warum die
Quant-Bits sind, wie sie sind, steht in Quantisierung.

Verwandt: Quantisierung · KV-Cache ·
GPU-Klassen