VRAM-Rechner

Schätze den VRAM-Bedarf der GPU für LLM-Inferenz, vollständiges Fine-Tuning, LoRA-Training und GGUF-Quantisierung. Berechne Modellgewichte, KV-Cache, Optimizer-Zustände und Framework-Overhead von Grund auf und prüfe, welche GPUs zu deiner Workload passen. Kostenlos, sofort und vollständig privat.

VRAM Calculator

Estimate GPU VRAM requirements for LLM inference, full fine-tuning, LoRA training, and GGUF quantisation. Model weights, KV cache, activations, optimizer states, and framework overhead - all calculated from first principles in your browser.

Model Preset

32 layers · 8 KV heads · head dim 128

Model Architecture

Parameters (Billions)

Transformer Layers

KV Heads (GQA)

Head Dimension

Workload Mode

Weights + KV cache + minimal activations. Smallest footprint.

Weight Precision

Context & Batch

Sequence Length

tokens

51264K128K

Batch Size

reqs

13264

Compare Against GPU

Total VRAM Required

16.57 GB

for inference

8.03B params · FP16 · seq 4,096 · batch 1

Model Weights

14.96 GB

KV Cache

512 MB

Activations

31 MB

Overhead

1.08 GB

NVIDIA RTX 4090 (24 GB) (24 GB)

✅ Fits on a single GPU (69.0% VRAM used)

Single GPU ✓

VRAM Usage16.57 GB / 24 GB (69.0%)

On-prem dev/inference, small models

VRAM Breakdown

Model Weights14.96 GB (90.3%)

KV Cache512 MB (3.0%)

Activations31 MB (0.2%)

Framework Overhead1.08 GB (6.5%)

Precision Comparison (Same Config)

Precision	Weights	Total VRAM	Fits 24 GB?
FP32	29.91 GB	33.14 GB	✗ No
FP16 Selected	14.96 GB	16.57 GB	✓ Yes
BF16	14.96 GB	16.57 GB	✓ Yes
FP8	7.48 GB	8.55 GB	✓ Yes
INT8	7.48 GB	8.55 GB	✓ Yes
INT4	3.74 GB	4.54 GB	✓ Yes

GPU Compatibility

GPU	VRAM	GPUs Needed	Status
NVIDIA RTX 4090 (24 GB)Selected On-prem dev/inference, small models	24 GB	1×	Single GPU
NVIDIA A10G (24 GB) Inference & ML serving	24 GB	1×	Single GPU
NVIDIA L4 (24 GB) Cost-efficient inference	24 GB	1×	Single GPU
NVIDIA RTX 3090 (24 GB) Budget on-prem inference	24 GB	1×	Single GPU
Apple M4 Pro (24 GB unified) Mac inference, small models	24 GB	1×	Single GPU
NVIDIA A100 40 GB Training medium models, inference	40 GB	1×	Single GPU
NVIDIA L40S (48 GB) Inference, multi-modal workloads	48 GB	1×	Single GPU
NVIDIA A40 (48 GB) Inference & fine-tuning	48 GB	1×	Single GPU
Apple M4 Max (48 GB unified) Mac inference, light fine-tuning	48 GB	1×	Single GPU
NVIDIA H100 / H100 PCIe (80 GB) LLM training & production inference	80 GB	1×	Single GPU
NVIDIA A100 80 GB LLM fine-tuning & inference	80 GB	1×	Single GPU
AMD MI250X (128 GB) Large-scale HPC & LLM training	128 GB	1×	Single GPU
Apple M4 Ultra (128 GB unified) On-device Mac inference	128 GB	1×	Single GPU
NVIDIA H200 SXM (141 GB) Largest LLM inference & training	141 GB	1×	Single GPU
AMD MI300X (192 GB) Very large model inference & training	192 GB	1×	Single GPU
NVIDIA RTX 3080 (10 GB) Small model inference only	10 GB	2×	2× Multi-GPU
NVIDIA RTX 4070 (12 GB) Light inference, LoRA tuning	12 GB	2×	2× Multi-GPU
NVIDIA V100 (16 GB) Legacy workloads	16 GB	2×	2× Multi-GPU
NVIDIA RTX 4080 (16 GB) Consumer dev, small inference	16 GB	2×	2× Multi-GPU

Estimation Notes: VRAM estimates use the standard formula: weights × bytes/param + KV cache (2 × layers × KV-heads × head-dim × seq-len × batch × FP16 bytes) + framework overhead (7%). Training estimates include Adam optimizer states and gradients. Actual usage varies by runtime (vLLM, llama.cpp, Transformers), quantisation method, and model architecture specifics. Always leave 10-15% VRAM headroom. All calculations run locally in your browser.

Warum unseren VRAM-Rechner nutzen

LLM-Hardware ohne Messung des GPU-Speichers zu planen führt oft zu überdimensionierten Karten oder zu Out-of-Memory-Fehlern (OOM) im Produktivbetrieb. Dieser Rechner verwendet die echte VRAM-Formel statt grober Faustregeln, damit du GPUs vor Miete oder Kauf sicher dimensionieren kannst.

Wähle zwischen Inferenz, vollständigem Fine-Tuning, LoRA-Training und GGUF-Quantisierung: Jeder Modus nutzt die passende Formel und aktualisiert Gewichte, KV-Cache, Optimizer-Zustände und Framework-Overhead sofort.

Berechnungen von Grund auf: Gewichte, KV-Cache, Aktivierungen, Optimizer-Zustände, Gradienten und Framework-Overhead statt Schätzungen.
Vollständig privat: Deine Konfigurationen werden im Browser berechnet und nie an einen Server gesendet.
Inferenz-, Fine-Tuning-, LoRA- und GGUF-Modus, jeweils mit eigener VRAM-Formel.
Kompatibilitätstabelle mit 19 GPUs, darunter H100, A100, RTX 4090, AMD MI300X und Apple Silicon.

Typische Anwendungsfälle

Von der Hardware-Auswahl bis zur Trainingsplanung: In diesen Szenarien spart eine verlässliche VRAM-Schätzung Zeit und Geld.

GPU für die LLM-Inferenz wählen: prüfen, ob ein 70B-Modell auf eine einzelne A100 mit 80 GB passt oder zwei GPUs braucht.
Fine-Tuning-Läufe planen: vollständiges Fine-Tuning mit Adam braucht oft das 3- bis 6-Fache des Inferenzbedarfs.
KV-Cache für lange Kontexte optimieren: sehen, wie viel zusätzlicher VRAM von 4K auf 32K oder 128K Tokens nötig ist.
Die passende GGUF-Quantisierung wählen: Q4, Q5 und Q8 samt Kompromiss aus Qualität und Speicher vergleichen.
Modelle auf Consumer-Hardware ausführen: wissen, welche quantisierten Modelle in 12, 16 oder 24 GB VRAM passen.
LoRA-Trainingsbudget planen: sehen, wie der gewählte Rang den Speicherbedarf beeinflusst.

Wie VRAM berechnet wird und wo die Grenzen liegen

VRAM ist der Speicher der Grafikkarte, nicht der System-RAM: Gewichte, KV-Cache, Aktivierungen und Framework-Puffer müssen gleichzeitig in dieses feste Budget passen. Der Bedarf hängt von Parameteranzahl, numerischer Präzision, Sequenzlänge und Batch-Größe sowie der Art der Workload ab (Inferenz, Training oder LoRA). Wir nutzen dieselben Formeln, die vLLM, Transformers und llama.cpp intern anwenden.

Der Rechner liefert Schätzungen auf Ingenieursniveau, keine exakten Messungen: Der reale Verbrauch kann um ±10-20 % abweichen, je nach Runtime, Modellimplementierung, CUDA-Graph-Capture und Speicherfragmentierung. Alle Berechnungen laufen lokal in deinem Browser.

Gib Parameteranzahl und Präzision ein: Ein 7B-Modell belegt in FP16 etwa 14 GB, in INT4 etwa 3,5 GB.
Addiere den KV-Cache aus Layer-, KV-Head-, Head-Dimension-, Sequenzlängen- und Batch-Werten; GQA verkleinert ihn stark.
Addiere beim Training Gradienten und Adam-Optimizer-Zustände: rund 12 zusätzliche Bytes pro Parameter beim vollständigen Fine-Tuning.
Addiere den Framework-Overhead: Wir reservieren 7 % für PyTorch, CUDA und Speicherfragmentierung.

Häufig gestellte Fragen

Ein VRAM-Rechner schätzt den GPU-Speicher, der zum Laden und Ausführen eines großen Sprachmodells nötig ist. Er berechnet den Speicher für die Modellgewichte (Parameter × Bytes pro Präzision), den KV-Cache (aus Sequenzlänge, Batch-Größe und Attention-Architektur), die Aktivierungen und beim Training die Optimizer-Zustände und Gradienten. Alles läuft in deinem Browser, ohne Daten hochzuladen.

Die Parameteranzahl steht meist im Modellnamen (7B, 70B, 405B). Exakte Werte findest du in der config.json des Modells auf Hugging Face unter dem Feld "num_parameters". Unsere Presets enthalten genaue Parameterzahlen für beliebte Modelle wie Llama 3.1, Qwen2.5, Mistral und Gemma 2.

Beim vollständigen Fine-Tuning muss die GPU die Modellgewichte, Gradienten-Tensoren gleicher Größe und den Adam-Optimizer-Zustand speichern (erster Moment, zweiter Moment und FP32-Master-Gewichte), was rund 12 zusätzliche Bytes pro Parameter bedeutet. Für ein 7B-Modell in BF16 braucht die Inferenz ~14 GB, das vollständige Training aber ~60-80 GB.

Der KV-Cache speichert die Attention-Schlüssel und -Werte aller vorherigen Tokens. Seine Größe = 2 × Layer × KV-Heads × Head-Dimension × Sequenzlänge × Batch-Größe × Bytes. Er wächst linear mit dem Kontext: von 4K auf 128K Tokens bedeutet das den 32-fachen Wert. GQA reduziert die KV-Heads und verkleinert den Cache deutlich.

Der GGUF-Modus berechnet den Gewichtsspeicher als Parameter × (Quantisierungsbits / 8) Bytes. Der KV-Cache wird unabhängig von der Gewichtsquantisierung immer in FP16 gespeichert. Q4_K_M (≈4 Bit) ist der beliebteste Kompromiss aus Qualität und Speichereffizienz für llama.cpp- und Ollama-Nutzer.

GQA reduziert die Anzahl der Key- und Value-Heads auf einen Bruchteil der Query-Heads. Da der KV-Cache mit den KV-Heads skaliert, kann GQA ihn um das 4-Fache oder mehr verkleinern. Llama 3.1 nutzt 8 KV-Heads gegenüber 32 Query-Heads. Gib num_key_value_heads aus der config.json für genaue Schätzungen ein.

In FP16 benötigt ein 70B-Modell etwa 140 GB allein für die Gewichte und passt auf zwei H100 mit 80 GB. In INT4 sinken die Gewichte auf ~35 GB und passen auf eine einzelne H100. Die GPU-Kompatibilitätstabelle zeigt die minimale GPU-Anzahl für jede Karte deiner Konfiguration.

Der Rechner verwendet die theoretische Standardformel, auf der alle Runtimes basieren. Die Paged Attention von vLLM kann 5-15 % Overhead hinzufügen. llama.cpp speichert Gewichte im Memory-Mapping und kann größere Modelle ausführen. Der Puffer von 7 % deckt die meisten Unterschiede zwischen Runtimes ab. Validiere immer mit einem kleinen Testlauf vor dem Produktivbetrieb.

Ja. Der VRAM-Rechner läuft vollständig in deinem Browser. Architekturparameter, Präzisionen und Kontexteinstellungen werden lokal auf deinem Gerät verarbeitet und nie an einen Server gesendet. Konto oder Registrierung sind nicht nötig.