LLM-Hardwarerechner

KV-Cache

Bis zu 262144 für qwen3-*. Jenseits des nativen Kontexts sinkt die Qualität.

qwen3-32b · Q4_K_M · KV=Q8

Gewichte ~17.6 GB · KV 131 KB/token · benötigt ~36.8 GB für 131,072

Engpass: KV 47% / Gewichte 48% / overhead 5%

  • 2x RTX 3090max 131,07243-64 Token/s
  • RTX 4090 48GBmax 131,07229-43 Token/s

Dezimale Einheiten: 1 GB=109 Bytes1\,\text{GB} = 10^{9}\,\text{Bytes}, 1 KB=103 Bytes1\,\text{KB} = 10^{3}\,\text{Bytes}. Keine GiB/KiB.

CPU-Offload zählt nicht als Eignungsmodus. mmap beeinflusst nur die Ladezeit, nicht die VRAM-Berechnung.

Nur Dekodierschätzung. Prefill für große Kontexte wird nicht modelliert; bei sehr großen MoE-Modellen kann es der eigentliche Engpass sein.

decode-only estimate; anchors: llama.cpp single stream, 2026-09

Über diese Schätzungen

  • Einzelstrom-Dekodierung (Batch=1\text{Batch} = 1), kalibriert anhand von llama.cpp-Messungen aus 2026-09.
  • Dezimale Einheiten: 1 GB=109 Bytes1\,\text{GB} = 10^{9}\,\text{Bytes}. Geräte mit gemeinsamem Speicher reservieren 4 GB für das Betriebssystem.
  • MoE-Dekodierung liest nur aktive Experten; Faktor 0,35 wegen Latenzbegrenzung.
  • Q8-KV halbiert den Cachespeicher bei geringem Qualitätsverlust.

Über dieses Tool

Dieser Rechner schätzt, ob ein großes Sprachmodell auf eine bestimmte GPU oder einen Mac passt und wie schnell es Text erzeugen würde. Er richtet sich an alle, die Modelle lokal mit llama.cpp und ähnlichen Werkzeugen betreiben. Quantisierung speichert die Modellgewichte mit geringerer Genauigkeit, was den Speicherbedarf bei leichtem Qualitätsverlust senkt; für Q4_K_M setzt der Rechner 0,55 Byte pro Parameter an. Der KV-Cache enthält Attention-Daten für jedes Token im Kontext.

Zwei Hardwarewerte entscheiden über das Ergebnis. Die Speichergröße bestimmt, ob Gewichte und gewünschter Kontext überhaupt geladen werden können, die Speicherbandbreite, wie schnell danach Token entstehen. Eine Karte mit viel Speicher, aber geringer Bandbreite, etwa eine ältere Rechenzentrums-GPU, kann ein großes Modell aufnehmen und trotzdem langsam generieren.

So funktioniert es

Wähle unter „Hardware finden“ ein Modell, eine Quantisierung und die Genauigkeit des KV-Caches, gib dann die Kontextlänge und die minimale akzeptable Geschwindigkeit in Token pro Sekunde ein; YaRN ist optional. Das Tool listet passende Geräte mit Speicherbedarf und Geschwindigkeitsbereich auf. Unter „Meine Hardware prüfen“ wählst du ein Gerät, die zu vergleichenden Quantisierungen und einen Zielkontext und siehst, welche Modelle passen.

Der Speicherbedarf ergibt sich aus der Größe der Gewichte, dem KV-Cache für den gesamten Kontext und einem festen Overhead von 2 GB. Die Gewichte in GB sind Milliarden Parameter mal Byte pro Parameter: 0,55 für Q4_K_M, 0,65 für Q5_K_M, 0,75 für Q6_K, 1,07 für Q8_0 und 2,0 für BF16. Der Cache pro Token beträgt 2×L×Hkv×dhead2 \times L \times H_{kv} \times d_{head} Byte bei Q8 und das Doppelte bei FP16, wobei L die Zahl der Schichten ist. Die Decode-Geschwindigkeit wird als 50 % bis 75 % der effektiven Bandbreite geteilt durch die Größe der aktiven Gewichte geschätzt, mit niedrigeren Effizienzfaktoren für Hardware ohne CUDA wie AMD-GPUs und Apple-Chips.

Beispiel

Für qwen3-32b mit Q4_K_M und Q8-KV-Cache belegen die Gewichte 32×0,55=17,632 \times 0{,}55 = 17{,}6 GB, der Cache 131,072 KB pro Token. Auf einer RTX 4090 mit 24 GB passen nach 2 GB Overhead und 0,5 GB Reserve etwa 29.754 Token Kontext, ein Ziel von 32.768 Token wird also verfehlt. Die geschätzte Decode-Geschwindigkeit liegt bei 28,6 bis 43,0 Token pro Sekunde.

Nimm nun llama3.3-70b mit Q4_K_M auf einem M4 Max mit 128 GB Unified Memory. Die Gewichte brauchen 70×0,55=38,570 \times 0{,}55 = 38{,}5 GB und der Q8-Cache 163,84 KB pro Token, sodass ein Kontext von 32.768 Token insgesamt etwa 45,9 GB erfordert; selbst der volle native Kontext von 131.072 Token passt nach der Reserve von 4 GB. Der Engpass ist die Geschwindigkeit: Die Schätzung liegt nur bei etwa 5,0 bis 7,4 Token pro Sekunde, weil jedes Token alle 38,5 GB Gewichte über 546 GB/s Bandbreite lesen muss.

Annahmen und Grenzen

Die Schätzungen gelten nur für Single-Stream-Decoding und sind an llama.cpp-Messungen kalibriert; die Verarbeitungszeit des Prompts wird nicht modelliert. Der Speicher wird in dezimalen Gigabyte gerechnet, mit festem Overhead von 2 GB und einer Reserve von 0,5 GB bei dedizierten GPUs bzw. 4 GB bei Geräten mit Unified Memory. CPU-Offload und teilweise Passung werden nicht berücksichtigt. Modell- und Hardwarelisten sind feste Kataloge, und die tatsächliche Geschwindigkeit hängt von Treibern und Einstellungen ab.

Häufig gestellte Fragen

Wie viel VRAM brauche ich, um ein LLM lokal auszuführen?

Ungefähr die Größe der quantisierten Gewichte plus den KV-Cache für deine Kontextlänge plus etwas Overhead. Eine 4-Bit-Quantisierung braucht allein für die Gewichte etwas mehr als ein halbes Gigabyte pro Milliarde Parameter, ein 32B-Modell also etwa 18 GB vor dem Kontext. Lange Kontexte summieren sich schnell, prüfe also den Cache-Wert für deine Ziellänge, bevor du Hardware kaufst.

Was bedeutet Q4_K_M?

Q4_K_M ist ein GGUF-Quantisierungstyp von llama.cpp, der die meisten Gewichte mit etwa 4 Bit im K-Quant-Verfahren speichert und einige Tensoren genauer belässt. Er ist ein verbreiteter Standard, weil er Dateigröße und Ausgabequalität gut ausbalanciert. Q5_K_M und Q6_K bewahren bei größerer Datei mehr Details, Q8_0 liegt qualitativ nahe am Originalmodell.

Warum begrenzt die Speicherbandbreite die Generierungsgeschwindigkeit?

Beim Erzeugen einzelner Token muss die Hardware für jedes Token alle aktiven Gewichte aus dem Speicher lesen. Token pro Sekunde entsprechen daher grob der Speicherbandbreite geteilt durch die Größe der aktiven Gewichte. Deshalb läuft eine kleinere Quantisierung auf derselben Maschine schneller, und für lokalen Chat zählt die Bandbreite mehr als die reine Rechenleistung.

Warum brauchen Mixture-of-Experts-Modelle viel Speicher, laufen aber schnell?

Ein Mixture-of-Experts-Modell muss alle Experten im Speicher halten, nutzt pro Token aber nur wenige davon. Der Speicherbedarf richtet sich nach den gesamten Parametern, die Decode-Geschwindigkeit nach der kleineren Zahl aktiver Parameter. So braucht qwen3-30b-a3b Speicher für 30 Milliarden Parameter, liest pro Token aber nur etwa 3 Milliarden.

Warum weichen meine gemessenen Token pro Sekunde von der Schätzung ab?

Die Schätzung ist ein Bereich, der auf Single-Stream-Decoding mit llama.cpp kalibriert ist; andere Software, Treiber, Batchgrößen und thermische Grenzen verschieben die echten Werte nach oben oder unten. Die Prompt-Verarbeitung wird nicht modelliert, daher kommt bei langen Prompts Wartezeit vor dem ersten Token hinzu. Wird ein Teil des Modells in den Arbeitsspeicher ausgelagert, sinkt die Geschwindigkeit weit unter die Schätzung, denn der Rechner berücksichtigt nur Fälle, in denen das Modell vollständig in den Speicher passt.

Link mit deinen Werten

Hänge diese Parameter an die Adresse dieser Seite an, um sie mit bereits ausgefüllten Werten zu öffnen, etwa um eine Berechnung zu teilen oder aus einem KI-Assistenten darauf zu verlinken. Das Ergebnis wird im Browser berechnet: Das HTML der Seite zeigt ein Beispiel mit den Standardwerten, und das Tool setzt das Attribut data-url-params, sobald die Werte aus dem Link übernommen sind.

ParameterWertWenn nicht angegeben
modeBerechnungeiner von: need, hardwareStandard: need
modelModelleiner von: qwen3-8b, qwen3-14b, qwen3-30b-a3b, qwen3-32b, llama3.1-8b, llama3.3-70b, qwen3-235b-a22b, qwen3-480b-a22b, qwen3-4b, gpt-oss-20b, gpt-oss-120b, deepseek-r1-distill-qwen-32b, qwen3-coder-30b-a3b, phi-4, qwen2.5-coder-32b; verwendet bei mode = needStandard: qwen3-32b
quantQuantisierungeiner von: Q4_K_M, Q5_K_M, Q6_K, Q8_0, BF16; verwendet bei mode = needStandard: Q4_K_M
context_tokensKontext (Token)ganze Zahl; erlaubt ≥ 0; verwendet bei mode = needStandard: 131072
min_tokens_per_sMin. Token/sZahl; erlaubt ≥ 0; verwendet bei mode = needStandard: 20
hardwareHardwareeiner von: rtx_3090, rtx_4090, rtx_4090_48gb, rtx_5090, tesla_p40, tesla_p100_16gb, tesla_v100_32gb, mi50_32gb, 2x_rtx_3090, m4_pro, m5_pro, m5_max, m4_max, m3_ultra, dgx_spark_gb10, dgx_station_gb300; verwendet bei mode = hardwareStandard: rtx_4090
quantsQuantisierungenWerte durch Kommas getrennt: 2,4,4,6; verwendet bei mode = hardwareStandard: Q4_K_M,Q8_0
target_context_tokensZielkontextganze Zahl; erlaubt ≥ 0; verwendet bei mode = hardwareStandard: 131072
kv_cacheKV-Cacheeiner von: q8, fp16Standard: q8
yarn_tokensYaRN (optional)ganze Zahl; erlaubt 1–262144optional

Beispiele

  • ?model=llama3.3-70b&quant=Q5_K_M&context_tokens=32768&kv_cache=fp16&min_tokens_per_s=15
  • ?hardware=m4_max&quants=Q4_K_M,Q6_K&target_context_tokens=65536

Schreibe Dezimalzahlen mit Punkt. Kodiere ein Leerzeichen als %20, + als %2B, # als %23 und & als %26.

Ergebniselemente: [data-result-block="llm-hardware"]