Quantisierung (Modell-Quantisierung)

1. Überblick über das Konzept und das Systemproblem

Ursprüngliche Sprachmodelle werden im Format von Gleitkommazahlen mit hoher Präzision (FP16 oder BF16) trainiert, wobei jeder variable Parameter 16 Bit (2 Bytes) belegt. Für den Betrieb eines modernen offenen Modells mit 70 Milliarden Parametern (z. B. Llama 3.3 70B) sind allein für das Laden der statischen Gewichte erforderlich: $$70 \times 10^9 \times 2 \text{ Bytes} \approx 140 \text{ GB VRAM}$$

Dies macht die Inferenz auf Consumer-Hardware unmöglich: Ingenieure benötigen einen Server mit mindestens zwei NVIDIA A100 Grafikkarten (80GB), deren Kosten über 30.000 USD liegen. Darüber hinaus wird die Geschwindigkeit der Token-Generierung durch die Speicherbandbreite (Memory Bandwidth) begrenzt, die gezwungen ist, 140 GB Daten pro generiertem Symbol zu übertragen.

Model Quantization (Modellquantisierung) ist eine mathematische Methode zur Optimierung und Kompression neuronaler Netze. Anstelle von 16-Bit-Zahlen werden die Gewichte in 8-Bit-, 4-Bit- oder sogar 2-Bit-Ganzzahlen oder optimierte Gleitkommaformate abgebildet. Die Quantisierung komprimiert das Modell um das 2–4-fache, sodass 70B-Modelle auf erschwinglichen Grafikkarten oder Laptops mit praktisch keinem Qualitätsverlust bei der Codegenerierung ausgeführt werden können.

2. Architektonische Taxonomie und mentales Modell

Die Landschaft der Quantisierungstechnologien wird nach Tiefe der Analyse und Zielhardwareumgebung klassifiziert:

┌─────────────────────────────────────────────────────────────┐
│                 QUANTIZATION METHODS TAXONOMY               │
├─────────────────────────────────────────────────────────────┤
│ 1. Post-Training Quantization (PTQ - Без повторного навчання)│
├─────────────────┬───────────────────────────┬───────────────┤
│ GGUF (K-quants) │ AWQ (Activation-aware)    │ FP8 (Native)  │
│ • llama.cpp     │ • Захист 1% важливих вагів│ • NVIDIA Ada/ │
│ • CPU / Metal   │ • NVIDIA Tensor Cores     │   Hopper/vLLM │
│ • Q4_K_M, Q5_K  │ • 4-бітний інференс (W4A16│ • Zero loss   │
├─────────────────┴───────────────────────────┴───────────────┤
│ 2. Quantization-Aware Training (QAT - Навчання зі стисненням)│
└─────────────────────────────────────────────────────────────┘

1. GGUF K-Quants (llama.cpp Ökosystem):
   • Verwendet blockweise Skalierung (Block-wise scaling). Wichtige Attention-Layer bleiben in höherer Bit-Tiefe (5–6 Bit), während weniger kritische Feed-Forward-Layer auf 4 Bit quantisiert werden. Ideal geeignet für Apple Silicon (Metal) und Systemspeicher (RAM).
2. AWQ (Activation-Aware Weight Quantization):
   • Identifiziert die fehlerempfindlichsten Gewichte („Outlier Weights“, ca. 1% des Gesamtvolumens) basierend auf einem Kalibrierungsdetaset und belässt sie ohne aggressive Quantisierung. Dies verhindert die Zerstörung der Logik in 4-Bit-Modellen auf NVIDIA-Grafikkarten.
3. Hardwareformat FP8 (E4M3 / E5M2):
   • Natives 8-Bit-Gleitkommaformat, das hardwareseitig von NVIDIA H100 Chips und RTX 4090 unterstützt wird. Ermöglicht eine Verdopplung der Matrixberechnungsgeschwindigkeit (GEMM) ohne jeglichen Verlust an Perplexität.
4. KV-Cache-Quantisierung (KV Cache Quantization):
   • Komprimierung der Kontextgeschichte von FP16 auf INT8 oder INT4, was es ermöglicht, Kontextfenster von 128k Tokens ohne Speicherüberlauf beizubehalten.

3. Technischer Pipeline und interne Mechanik

Der Lebenszyklus der Post-Training-Quantisierung eines Modells:

1. Analyse der Ausgangsgewichte (FP16 Base Model): Das Skript liest Tensoren im SafeTensors-Format mit hoher Präzision ein.
2. Kalibrierung der Verteilung (Calibration Phase): Durch das Modell wird eine kleine Textstichprobe geleitet (z. B. 512 Code-Sequenzen). Der Algorithmus erfasst die Amplitude der Aktivierungen in jedem Layer.
3. Mathematische Skalierung und Verschiebung: Der Bereich reeller Zahlen $[x_{\min}, x_{\max}]$ wird auf einen diskreten Ganzzahlbereich abgebildet (z. B. $[-8, 7]$ für INT4): $$q = \text{round}\left(\frac{x}{S}\right) + Z$$ wobei $S$ der Skalierungsfaktor (Scale) und $Z$ der Nullpunkt (Zero-point) ist.
4. Packen in einen Binärcontainer: Die quantisierten Gewichte werden blockweise gepackt (z. B. Blöcke von 32 oder 256 Zahlen) zusammen mit ihren lokalen Skalierungskoeffizienten und in einer .gguf- oder .safetensors-Datei gespeichert.
5. Dequantisierung on-the-fly (On-the-fly Dequantization): Während der Token-Generierung lesen die Beschleuniger-Kerne sofort die komprimierten 4-Bit-Gewichte aus dem Speicher und entpacken sie in Registern für schnelle Multiplikationen.

4. Praktische Engineering-Szenarien in der Produktion

01. Deployment von Llama 3.3 70B auf zwei Consumer-Grafikkarten

Ein Ingenieur baut einen Unternehmensserver für ein Entwicklungsteam:

• Das ursprüngliche FP16-Modell erfordert 140 GB VRAM (ein teurer Server mit 8 GPUs wäre nötig).
• Nach der Quantisierung auf AWQ 4-bit reduziert sich die Modellgröße auf 38 GB.
• Das Modell passt problemlos in eine Kombination aus zwei RTX 3090 Karten (24 GB + 24 GB = 48 GB VRAM) und liefert eine Geschwindigkeit von 30 Tokens/s für das gesamte Team bei einem Budget von 1.500 USD.

02. Hochlastservicing auf einem H100-Cluster im FP8-Format

Ein Fintech-Unternehmen verarbeitet Tausende Anfragen pro Sekunde über vLLM:

• Die Modelle werden in das FP8-Format konvertiert.
• Die Durchsatzkapazität des Clusters verdoppelt sich dank der hardwareseitigen FP8 Tensor Cores, während die Mietkosten für AWS/Lambda Labs Cloud-Ressourcen um 50% sinken.

03. Ausführung eines 32B Coding-Modells auf einem MacBook Pro

Ein Entwickler führt Qwen 2.5 Coder 32B unterwegs aus:

• Die Datei im Format qwen2.5-coder-32b-instruct-q4_k_m.gguf belegt nur 19 GB auf der Festplatte.
• Das Modell wird in den Unified Memory des Laptops (36 GB RAM) geladen und verbraucht minimal Akkuenergie bei hoher Antwortgeschwindigkeit.

5. Fallstricke, häufige Fehler und Sicherheit

• Extremes Überquantisieren (Quantization Cliff): Der Versuch, ein Modell unter 3 Bit zu komprimieren (z. B. Q2_K), führt zu einem abrupten Zusammenbruch der Semantik: Das Modell beginnt schließende Klammern im Code zu ignorieren, endlose Schleifen zu generieren und den Kontext zu verlieren.
• Falsche Formatwahl für spezifische Hardware: Der Versuch, GGUF-Modelle auf einem Cluster aus Server-Grafikkarten unter hoher Multithreading-Last auszuführen, ist deutlich langsamer als die Verwendung spezialisierter Engines wie vLLM mit AWQ- oder FP8-Formaten.
• Genauigkeitsverlust bei kritischen mathematischen Berechnungen: Wenn das Modell für komplexe numerische Simulationen verwendet wird, kann naive 4-Bit-Quantisierung Rundungsfehler in den Ausgabeergebnissen akkumulieren.
• Ungeeignete Kalibrierungsdaten: Wenn das Modell unter Verwendung eines Kalibrierungsdetaset quantisiert wurde, das nur englische Belletristik enthielt, können seine Fähigkeiten zur Rust-Codeerstellung oder zum Verständnis anderer Sprachen erheblich beeinträchtigt werden.