Verständnis der LLM VRAM-Anforderungen: Eine mathematische Tiefenanalyse

Die Bereitstellung von Large Language Models (LLMs) erfordert eine sorgfältige Berücksichtigung der GPU-Speicheranforderungen. Dieser Leitfaden erläutert die mathematischen Formeln zur Berechnung des VRAM-Verbrauchs für Inferenz und Training und verwendet das Modell Qwen3-VL-32B-Instruct als praktisches Beispiel.

Warum die Berechnung des VRAM wichtig ist

Bevor Sie ein LLM bereitstellen, müssen Sie entscheidende Fragen beantworten:

• Wie viel GPU-Speicher wird mein Modell verbrauchen?
• Kann ich dieses Modell auf meiner aktuellen Hardware ausführen?
• Welche Quantisierungsmethode bietet das beste Verhältnis zwischen Speicher und Leistung?
• Wie viele gleichzeitige Nutzer kann ich unterstützen?

Dieser Leitfaden liefert die mathematische Grundlage, um diese Fragen präzise zu beantworten.

Beispielmodell: Qwen3-VL-32B-Instruct

Wir verwenden Qwen3-VL-32B-Instruct als unser Referenzmodell in diesem Leitfaden. Dieses multimodale Modell vereint Bild- und Sprachfähigkeiten mit folgender Architektur:

Konfigurationsquelle: Die Modellkonfiguration wird aus dem Abschnitt text_config der Datei config.json des Modells auf Hugging Face Hub extrahiert.

Zentrale Speicherelemente

Der VRAM-Verbrauch für LLMs besteht aus vier Hauptkomponenten:

1. Model Weights Speicher

Der Basisspeicher, der zum Speichern der Modellparameter benötigt wird.

Model Weights (bytes) = Number of Parameters × Bytes per Parameter

Bytes pro Parameter hängen vom Datentyp (Quantisierungsstufe) ab:

Beispielrechnung für Qwen3-VL-32B:

Number of Parameters: 32,500,000,000 (32.5B)

float32:  32,500,000,000 × 4.0   = 130,000,000,000 bytes = 130.00 GB
float16:  32,500,000,000 × 2.0   = 65,000,000,000 bytes  = 65.00 GB
int8:     32,500,000,000 × 1.0   = 32,500,000,000 bytes  = 32.50 GB
int4:     32,500,000,000 × 0.5   = 16,250,000,000 bytes  = 16.25 GB

2. KV Cache Speicher

Der Key-Value Cache speichert Zwischenzustände der Attention für eine effiziente autoregressive Generierung. Dies ist die wichtigste dynamische Speichereinheit während der Inferenz.

KV Cache (bytes) = 2 × Batch Size × Sequence Length × Num Layers × Num KV Heads × Head Dimension × KV Data Type Size

Aufschlüsselung der Formel:

• 2×: Getrennter Speicher für Keys und Values
• Batch Size: Anzahl gleichzeitiger Anfragen
• Sequence Length: Maximale Kontextlänge (Eingabe + Ausgabe)
• Num Layers: Anzahl der Transformer-Blöcke
• Num KV Heads: Anzahl der Key-Value-Heads (8 für GQA in Qwen3-VL)
• Head Dimension: Größe jedes Attention-Heads (128)
• KV Data Type Size: Bytes pro Wert (typischerweise 2 für float16)

Beispielrechnung für Qwen3-VL-32B:

Szenario: 1 Nutzer, 8.192 Token-Kontext, float16 KV cache

Batch Size: 1
Sequence Length: 8,192 tokens
Num Layers: 64
Num KV Heads: 8 (Grouped Query Attention)
Head Dimension: 128
KV Data Type: float16 (2 bytes)

KV Cache = 2 × 1 × 8,192 × 64 × 8 × 128 × 2
         = 2 × 1 × 8,192 × 64 × 8 × 256
         = 2 × 1,073,741,824 bytes
         = 2,147,483,648 bytes
         = 2.00 GB

Skalierung mit Batch-Größe:

Skalierung mit Sequenzlänge:

3. Aktivierungsspeicher

Speicher, der für Zwischenberechnungen während der Forward-Passes benötigt wird.

PyTorch Activation Memory = Batch Size × Sequence Length × (18 × Hidden Size + 4 × Intermediate Size)

Beispielrechnung für Qwen3-VL-32B:

Scenario: 1 user, 8,192 token context

Batch Size: 1
Sequence Length: 8,192
Hidden Size: 5,120
Intermediate Size: 25,600

Activation Memory = 1 × 8,192 × (18 × 5,120 + 4 × 25,600)
                  = 8,192 × (92,160 + 102,400)
                  = 8,192 × 194,560
                  = 1,593,835,520 bytes
                  = 1.59 GB (base value)

Multiplikatoren für Datentypen:

Verschiedene Quantisierungsstufen haben unterschiedliche Aktivierungsspeicher-Bedarfe:

4. Nicht-PyTorch Speicher-Overhead

Systembedingter Speicher-Overhead für CUDA-Kontext, cuBLAS und andere Framework-Komponenten.

Non-PyTorch Memory = 1,024 MB = 1.00 GB (constant)

Dies ist ein fester Overhead, der unabhängig von der Modellgröße oder der Batch-Konfiguration ist.

Vollständige Inferenz-Speicherformel

Durch die Kombination aller Komponenten ergibt sich der gesamte für die Inferenz benötigte VRAM:

Total Inference VRAM = (Model Weights + KV Cache + Non-PyTorch Memory + Activations) / GPU Utilization

GPU-Auslastungsfaktor: Wird typischerweise auf 0,9 (90%) gesetzt, um eine Sicherheitsmarge für Speicherfragmentierung und unerwartete Spitzen zu bieten.

Beispiel: Qwen3-VL-32B Inferenz (int8 Quantisierung)

Konfiguration:

• Quantisierung: int8 (1 Byte pro Parameter)
• Batch-Größe: 1 user
• Sequenzlänge: 8.192 Tokens
• KV Cache Datentyp: float16
• GPU-Auslastung: 0,9

Schritt-für-Schritt-Berechnung:

1. Model Weights:
   32,500,000,000 × 1 byte = 32,500,000,000 bytes = 32.50 GB

2. KV Cache (float16):
   2 × 1 × 8,192 × 64 × 8 × 128 × 2 = 2,147,483,648 bytes = 2.00 GB

3. Activations (int8 uses 1.0× multiplier):
   1 × 8,192 × (18 × 5,120 + 4 × 25,600) × 1.0 = 1,593,835,520 bytes = 1.59 GB

4. Non-PyTorch Memory:
   1,024 MB = 1.00 GB

5. Total (before GPU utilization adjustment):
   32.50 + 2.00 + 1.59 + 1.00 = 37.09 GB

6. Adjusted for GPU Utilization (90%):
   37.09 / 0.9 = 41.21 GB

Ergebnis: Sie benötigen ungefähr 42 GB VRAM, um Qwen3-VL-32B in int8-Quantisierung mit 8k Kontext für einen einzelnen Nutzer auszuführen.

Beispiel: Qwen3-VL-32B Inferenz (int4-Quantisierung)

Konfiguration:

• Quantisierung: int4 (0,5 Byte pro Parameter)
• Batch-Größe: 4 Nutzer
• Sequenzlänge: 8.192 Tokens
• KV Cache Datentyp: float16
• GPU-Auslastung: 0,9

Schritt-für-Schritt-Berechnung:

1. Model Weights:
   32,500,000,000 × 0.5 bytes = 16,250,000,000 bytes = 16.25 GB

2. KV Cache (float16, batch=4):
   2 × 4 × 8,192 × 64 × 8 × 128 × 2 = 8,589,934,592 bytes = 8.00 GB

3. Activations (int4 uses 1.0× multiplier, batch=4):
   4 × 8,192 × (18 × 5,120 + 4 × 25,600) × 1.0 = 6,375,342,080 bytes = 6.38 GB

4. Non-PyTorch Memory:
   1,024 MB = 1.00 GB

5. Total (before GPU utilization adjustment):
   16.25 + 8.00 + 6.38 + 1.00 = 31.63 GB

6. Adjusted for GPU Utilization (90%):
   31.63 / 0.9 = 35.14 GB

Ergebnis: Sie benötigen ungefähr 36 GB VRAM, um Qwen3-VL-32B in int4-Quantisierung mit 8k Kontext für 4 gleichzeitige Nutzer auszuführen.

Speicheranforderungen für das Training

Das Training erfordert deutlich mehr Speicher als die Inferenz aufgrund von:

• Gradienten: Gleiche Größe wie die Modellgewichte
• Optimizer States: 2× Modellgewichte (für Adam-Optimizer)
• Größerer Aktivierungsspeicher: ~1,5× Inferenz-Aktivierungen
• Trainings-Overhead: 30% Sicherheitsreserve

Hinweis (Annahmen): Die Speicherberechnungen für das Training in diesem Abschnitt gehen von einem Standard-In-GPU-Training aus und berücksichtigen KEINE speichersparenden oder bandbreitenoptimierenden Techniken wie CPU/NVMe-Auslagerung, Sliding-Window- oder Chunked-Attention, spezialisierte Low-Memory-Optimierer oder ZeRO-ähnliche Partitionierung, aggressives Gradient-Checkpointing über den oben verwendeten Basis-Multiplikator hinaus oder benutzerdefinierte Attention-Kernels, die die KV-Speicherung verändern. Wenn Sie planen, eine dieser Methoden zu verwenden, können die erwarteten VRAM-Anforderungen deutlich geringer ausfallen und sollten für Ihre spezifische Konfiguration neu berechnet werden.

Aufschlüsselung:

• 3× Modellgewichte: Gewichte + Gradienten + Optimizer States (Adam)
• 1,3×: Trainingsaufwand-Faktor (30% Puffer)

Beispiel: Qwen3-VL-32B Training (float16)

Konfiguration:

• Quantisierung: float16 (2 Bytes pro Parameter)
• Batch Size: 1
• Sequenzlänge: 8.192 Tokens
• GPU-Auslastung: 0,9

Schritt-für-Schritt-Berechnung:

1. Model Weights (×3 for training):
   32,500,000,000 × 2 bytes × 3 = 195,000,000,000 bytes = 195.00 GB

2. KV Cache (float16):
   2 × 1 × 8,192 × 64 × 8 × 128 × 2 = 2,147,483,648 bytes = 2.00 GB

3. Activations (float16 uses 1.0× multiplier, ×1.5 for training):
   1 × 8,192 × (18 × 5,120 + 4 × 25,600) × 1.0 × 1.5 = 2,390,753,280 bytes = 2.39 GB

4. Non-PyTorch Memory:
   1,024 MB = 1.00 GB

5. Subtotal:
   195.00 + 2.00 + 2.39 + 1.00 = 200.39 GB

6. Apply Training Overhead (×1.3):
   200.39 × 1.3 = 260.51 GB

7. Adjusted for GPU Utilization (90%):
   260.51 / 0.9 = 289.45 GB

Ergebnis: Sie benötigen ungefähr 290 GB VRAM, um Qwen3-VL-32B in float16 mit 8k Kontext und Batch-Größe 1 zu trainieren.

Vergleichstabelle GPU Speicher

Hier finden Sie einen umfassenden Vergleich für Qwen3-VL-32B über verschiedene Quantisierungsmethoden hinweg:

Konfiguration: Batch-Größe 1, Sequenzlänge 8.192 Tokens, GPU-Auslastung 0,9

Praktische GPU-Empfehlungen

Basierend auf den obigen Berechnungen finden Sie hier geeignete GPU-Konfigurationen für Qwen3-VL-32B:

Inferenzbereitstellung

Trainingsbereitstellung

Key Takeaways

1. Model Weights Scale Linearly: Doubling parameters doubles weight memory
2. KV Cache Scales with Context: Longer contexts exponentially increase memory
3. Batch Size Multiplies KV Cache: Each concurrent user adds KV cache overhead
4. Quantization Dramatically Reduces Memory: int4 uses ~1/8th the memory of float32
5. Training Needs ~3-4× Inference Memory: Due to gradients and optimizer states
6. GPU Utilization Buffer is Critical: Always reserve 10-20% safety margin

Erweiterte Überlegungen

Auswirkungen von Grouped Query Attention (GQA)

Qwen3-VL-32B verwendet Grouped Query Attention mit 8 KV Heads anstelle von 64 Query Heads. Dadurch wird der KV-Cache-Speicher im Vergleich zu standardmäßiger Multi-Head Attention um das 8-fache reduziert:

Standard MHA: 64 KV heads → KV Cache = 16.00 GB (8k context, float16)
GQA (Qwen3): 8 KV heads → KV Cache = 2.00 GB (8k context, float16)

Memory Savings: 14.00 GB (87.5% reduction)

Skalierung für langen Kontext

Qwen3-VL-32B unterstützt bis zu 262k Tokens. So skaliert der KV-Cache:

Quantisierung des KV-Caches

Die Verwendung von fp8 für den KV-Cache kann den Speicherverbrauch halbieren:

float16 KV Cache (8k, batch=1): 2.00 GB
fp8 KV Cache (8k, batch=1): 1.00 GB

Savings: 50% memory reduction with minimal quality loss

Fazit

Eine genaue Berechnung des VRAM ist entscheidend für eine effiziente Bereitstellung von LLMs. Durch das Verständnis der mathematischen Grundlagen:

1. Wählen Sie die richtige Quantisierung für Ihren Qualitäts-Speicher-Kompromiss
2. Planen Sie die Skalierung des KV-Cache bei gleichzeitigen Nutzern und Kontextlänge
3. Berücksichtigen Sie Trainings-Overhead bei Feinabstimmung
4. Wählen Sie geeignete GPUs aus basierend auf den tatsächlichen Anforderungen
5. Berücksichtigen Sie immer Sicherheitsmargen, um OOM-Fehler zu vermeiden

Verwenden Sie diese Formeln, um die Speicheranforderungen für jedes Hugging Face Modell abzuschätzen, indem Sie die Konfigurationsparameter extrahieren und die in diesem Leitfaden gezeigten Berechnungen anwenden.

Referenzen und Werkzeuge

• Modellkonfiguration: Qwen3-VL-32B-Instruct config.json
• Hugging Face Hub: Modell-Metadaten und Parameteranzahl über die API verfügbar
• GPU-Spezifikationen: Prüfen Sie die Herstellerangaben für genaue VRAM-Kapazitäten
• Quantisierungsverfahren: GPTQ, AWQ, GGUF für verschiedene Präzisionsstufen