[email protected]

Grundlagen · Lokale KI für Unternehmen

LLM-Quantisierung erklärt: FP8, NVFP4, AWQ, GPTQ und GGUF

Hinweis zum Inhalt: Versionen, Befehle und Preise können sich ändern. Bitte prüfen Sie kritische Schritte vor dem produktiven Einsatz eigenständig. Dieser Leitfaden ersetzt keine individuelle Fach-, Rechts- oder Steuerberatung.

Welches Modell in welchem Format auf Ihre Hardware passt? WZ-IT richtet lokale Sprachmodelle auf eigener Infrastruktur ein, wählt Modell und Quantisierung passend zu GPU, Kontextlänge und Nutzerzahl und prüft die Qualität mit Ihren eigenen Aufgaben. LLM-Hosting ansehen · Managed GPU-Server ansehen · AI Cube ansehen · Termin vereinbaren

Ob ein Sprachmodell auf eine GPU passt und wie viele Anfragen es gleichzeitig bedient, entscheidet sich zu einem großen Teil an der Zahlenpräzision. Ein Modell mit 32 Milliarden Parametern belegt in BF16 rund 66 GB, als 4-Bit-Variante weniger als ein Drittel davon. Dazwischen liegen Formate mit unterschiedlichen Annahmen über Hardware und Software: FP8, NVFP4, MXFP4, AWQ, GPTQ und GGUF. Dieser Artikel ordnet die Formate ein, zeigt, welche GPU welches Format nativ beschleunigt, und erklärt, wie der KV-Cache in die Rechnung eingeht. Stand Oktober 2026.

Inhaltsverzeichnis

Was Quantisierung bei LLMs bedeutet

Sprachmodelle werden heute meist in BF16 veröffentlicht, also mit 16 Bit je Parameter. Quantisierung bildet diese Werte auf ein Format mit weniger Bits ab, typischerweise 8 oder 4 Bit. Damit die kleinen Zahlen den ursprünglichen Wertebereich abdecken, speichern alle Verfahren zusätzlich Skalierungsfaktoren, je Tensor, je Kanal oder je Block aus wenigen Werten.

Drei Dinge lassen sich quantisieren, und die Kurzschreibweise zeigt, was gemeint ist:

Bezeichnung Gewichte Aktivierungen Typisches Beispiel
W8A8 8 Bit 8 Bit FP8 auf Ada, Hopper, Blackwell
W4A16 4 Bit 16 Bit AWQ, GPTQ, INT4
W4A4 4 Bit 4 Bit NVFP4 auf Blackwell
KV-Cache - - FP8-KV-Cache in vLLM, q8_0 in Ollama

Der Nutzen hat zwei Seiten. Erstens sinkt der Speicherbedarf der Gewichte, das Modell passt auf kleinere oder weniger GPUs. Zweitens liest die GPU beim Erzeugen jedes Tokens alle aktiven Gewichte aus dem Speicher. Kleinere Datentypen verbrauchen weniger Speicherbandbreite, was laut vLLM-Dokumentation zu LLM Compressor gerade bei speichergebundenen Lasten oft höheren Durchsatz bedeutet. Ob zusätzlich die Rechenoperation in niedriger Präzision läuft (W8A8, W4A4), hängt davon ab, ob die GPU dafür Tensor Cores hat.

Wie sich Gewichte, KV-Cache und Overhead zum gesamten VRAM-Bedarf addieren, rechnet GPU und VRAM für LLMs dimensionieren durch.

Die Formate im Überblick

Format Bits je Gewicht Art Kalibrierdaten Hauptsächlich genutzt mit Native Rechenwerke
BF16 / FP16 16 Gleitkomma nein allen Engines alle aktuellen GPUs
FP8 (E4M3) 8 Gleitkomma optional vLLM ab Ada Lovelace (CC 8.9), Hopper, Blackwell
INT8 W8A8 8 Ganzzahl ja vLLM ab Turing laut vLLM
NVFP4 rund 4,5 inkl. Skalen Gleitkomma, Block 16 ja vLLM Blackwell
MXFP4 4 plus Skala je 32 Werte Gleitkomma, Block 32 je nach Modell gpt-oss in vLLM, llama.cpp Blackwell
AWQ rund 4 plus Skalen Ganzzahl, gruppenweise ja vLLM W4A16, Rechnung in 16 Bit
GPTQ 4 oder 8 plus Skalen Ganzzahl, gruppenweise ja vLLM W4A16, Rechnung in 16 Bit
GGUF Q8_0 / Q4_K_M 8,5 / 4,89 Ganzzahl, blockweise optional (imatrix) llama.cpp, Ollama CPU, GPU, Apple Silicon

Quellen: vLLM, FP8 W8A8, vLLM, Quantization, NVIDIA, Introducing NVFP4, llama.cpp, quantize. Die GGUF-Werte gelten für Llama 3.1 8B laut llama.cpp-Messung; bei anderen Modellen weichen sie leicht ab.

Zu beachten: Die Übersichtstabelle der vLLM-Dokumentation endet in der Spalte Hopper (Stand Oktober 2026). Blackwell ist auf den Seiten der einzelnen Verfahren aufgeführt, etwa bei FP8 W8A8 und INT4 W4A16.

FP8: der Standard ab Ada und Hopper

FP8 halbiert den Speicherbedarf gegenüber BF16. Für Inferenz ist vor allem E4M3 verbreitet: 1 Vorzeichenbit, 4 Exponentenbits, 3 Mantissenbits, Werte bis ±448. Die Variante E5M2 hat mehr Wertebereich (bis ±57.344), aber weniger Genauigkeit (vLLM, FP8 W8A8).

Merkmal Wert laut vLLM-Dokumentation
Rechnung in FP8 (W8A8) GPUs mit Compute Capability ab 8.9: Ada Lovelace, Hopper, Blackwell
Ältere GPUs ab Compute Capability 7.5 (Turing) nur Gewichte in FP8 (W8A16, Marlin)
Speicherersparnis Faktor 2 gegenüber 16 Bit
Durchsatz bis zu Faktor 1,6
Genauigkeit „minimal impact on accuracy"

FP8 ist für vLLM auf aktuellen NVIDIA-GPUs der naheliegende Ausgangspunkt, weil viele Hersteller offizielle FP8-Checkpoints veröffentlichen. Ein Beispiel ist Qwen3-8B-FP8 mit blockweiser FP8-Quantisierung in Blöcken von 128 × 128. vLLM erkennt solche Checkpoints anhand der quantization_config und lädt sie ohne weitere Parameter. Mit --quantization fp8_per_tensor oder fp8_per_block rechnet vLLM ein BF16-Modell außerdem beim Laden in FP8 um, ohne vorab quantisierten Checkpoint (vLLM, Online Quantization). Für produktive Systeme ist ein geprüfter Checkpoint, etwa aus llm-compressor, die nachvollziehbarere Variante.

NVFP4 und MXFP4: 4 Bit als Gleitkommazahl

NVFP4 ist NVIDIAs 4-Bit-Format für Blackwell. Jeder Wert ist eine 4-Bit-Gleitkommazahl (E2M1, Wertebereich etwa -6 bis +6). Je 16 Werte teilen sich einen Skalierungsfaktor in FP8 (E4M3), zusätzlich gibt es einen FP32-Faktor je Tensor. Mit den Skalen ergeben sich rund 4,5 Bit je Wert (NVIDIA, Introducing NVFP4).

Merkmal NVFP4 MXFP4 (OCP Microscaling)
Datentyp je Wert FP4 E2M1 FP4 E2M1
Blockgröße 16 Werte 32 Werte
Skala je Block FP8 E4M3 E8M0 (Zweierpotenz)
Zusätzliche Skala FP32 je Tensor keine
Speicher laut NVIDIA rund 3,5-mal kleiner als FP16, 1,8-mal kleiner als FP8 -
Bekanntes Beispiel NVFP4-Checkpoints von NVIDIA und Red Hat gpt-oss-20b und gpt-oss-120b

Die kleineren Blöcke und die feinere FP8-Skala sollen den Rundungsfehler gegenüber MXFP4 senken. Native FP4-Rechenwerke bringen die Tensor Cores der fünften Generation mit, also Blackwell-GPUs wie die RTX PRO 4000 und RTX PRO 6000 Blackwell sowie der GB10-Chip.

vLLM lädt NVFP4-Checkpoints aus NVIDIA Model Optimizer und aus llm-compressor (vLLM, NVIDIA Model Optimizer). Beim Start wählt vLLM einen passenden GEMM-Kernel. Fehlt auf der GPU ein nativer FP4-Kernel, fällt vLLM auf W4A16 über Marlin zurück und protokolliert eine Warnung; der Speichervorteil bleibt, der Rechenvorteil entfällt. Welcher Kernel tatsächlich aktiv ist, steht im Startprotokoll und gehört bei jeder Inbetriebnahme geprüft.

MXFP4 ist vor allem durch gpt-oss bekannt geworden: Die MoE-Gewichte wurden laut Modellkarte bereits im Post-Training mit MXFP4 quantisiert, alle veröffentlichten Benchmarks beziehen sich auf diese Variante. gpt-oss-120b läuft damit auf einer einzelnen 80-GB-GPU, gpt-oss-20b mit 16 GB Speicher.

Zur Qualität gibt es Herstellerangaben, keine unabhängige Garantie:

Quelle Modell / Größe Angabe
NVIDIA DeepSeek-R1-0528, FP8 gegen NVFP4 1 % oder weniger Abweichung auf sieben Benchmarks
Red Hat 70 bis 235 Mrd. Parameter rund 99 % der BF16-Genauigkeit
Red Hat rund 30 Mrd. Parameter 97 bis 99 %
Red Hat 7 bis 14 Mrd. Parameter rund 95 bis 98 %

Die Tendenz ist eindeutig: Große Modelle und MoE-Modelle vertragen 4 Bit besser als kleine dichte Modelle.

AWQ und GPTQ: 4-Bit-Gewichte mit Kalibrierung

AWQ und GPTQ sind keine Datentypen, sondern Verfahren, die Gewichte nach dem Training (Post-Training Quantization) meist in 4-Bit-Ganzzahlen umrechnen. Beide nutzen eine kleine Menge Kalibriertexte, um die Rundungsfehler gezielt klein zu halten. Die Aktivierungen bleiben in 16 Bit (W4A16).

Merkmal GPTQ AWQ
Veröffentlichung Frantar et al., ICLR 2023 Lin et al., MLSys 2024 (Best Paper)
Grundidee Gewichte schichtweise runden und Fehler mit Näherung zweiter Ordnung ausgleichen Wichtige Kanäle anhand der Aktivierungen erkennen und vor dem Runden skalieren
Bitbreite 3, 4 oder 8 Bit meist 4 Bit
Werkzeug heute GPTQModel, llm-compressor llm-compressor (AutoAWQ ist laut vLLM veraltet)
vLLM-Kernel Marlin, Machete Marlin

Die AWQ-Autoren zeigen, dass schon der Schutz von rund 1 % der wichtigsten Gewichte den Quantisierungsfehler deutlich senkt. GPTQ quantisierte laut Paper ein Modell mit 175 Mrd. Parametern in etwa vier GPU-Stunden auf 3 bis 4 Bit.

In vLLM sind AWQ und GPTQ laut Hardware-Tabelle auf Turing, Ampere, Ada und Hopper unterstützt, GPTQ auch auf Volta. Die INT4-Seite nennt als Rechenplattform Ampere, Ada Lovelace, Hopper und Blackwell (vLLM, INT4 W4A16). Für GPUs ohne FP4-Rechenwerke sind AWQ und GPTQ damit die gängigen 4-Bit-Formate. Auf Blackwell ist NVFP4 eine Alternative, sofern ein Checkpoint verfügbar ist.

GGUF: das Format von llama.cpp und Ollama

GGUF ist das Dateiformat von llama.cpp. Es enthält Gewichte, Tokenizer und Metadaten in einer Datei und bringt eigene Quantisierungstypen mit. Gebräuchlich sind die K-Quants (etwa Q4_K_M, Q5_K_M, Q6_K) und die I-Quants für sehr niedrige Bitbreiten. Eine Importance Matrix (imatrix) aus Kalibriertexten senkt laut llama.cpp den Qualitätsverlust; gemessen wird er dort über Perplexity und KL-Divergenz.

Messwerte aus der llama.cpp-Dokumentation für Llama 3.1 8B:

Typ Bits je Gewicht Größe (GiB)
F16 16,0 14,96
Q8_0 8,50 7,95
Q6_K 6,56 6,14
Q5_K_M 5,70 5,33
Q4_K_M 4,89 4,58
IQ3_M 3,76 3,52
IQ2_M 2,93 2,74

Ollama nutzt GGUF als Modellformat. Laut Ollama-Dokumentation quantisiert Ollama GGUF-Modelle beim Import nicht; die Quantisierung erfolgt vorher mit llama-quantize. GGUF läuft auf CPU, NVIDIA- und AMD-GPUs sowie Apple Silicon und kann Schichten zwischen GPU und Arbeitsspeicher aufteilen. Das macht es zur ersten Wahl für Einzelplatz und kleine Installationen. vLLM unterstützt GGUF nur über ein separates Plugin und bezeichnet die Unterstützung als „highly experimental and under-optimized" (vLLM, GGUF). Für vLLM sind FP8, NVFP4, AWQ oder GPTQ die passenden Formate. Die Abwägung zwischen beiden Engines vertieft vLLM vs. Ollama.

Speicherbedarf an einem Beispiel

Qwen3-32B hat rund 32,8 Mrd. Parameter (Apache 2.0). Der Speicherbedarf der Gewichte ergibt sich aus Parameterzahl mal Bits je Gewicht geteilt durch 8:

Format Bits je Gewicht (gerechnet) Gewichte, gerundet
BF16 16 rund 66 GB
FP8 8 rund 33 GB
GGUF Q8_0 8,5 rund 35 GB
GGUF Q4_K_M 4,89 rund 20 GB
NVFP4 4,5 rund 18 GB
INT4 (AWQ/GPTQ, Gruppe 128) etwas über 4 rund 17 GB

Das sind Rechenwerte. Reale Dateien weichen ab, weil einzelne Schichten wie Embeddings oder die Ausgabeschicht oft in höherer Präzision bleiben.

Die Tabelle zeigt die Abstufung: In BF16 braucht das Modell eine Karte mit 96 GB, in FP8 passt es dort mit viel Raum für den KV-Cache. Eine 24-GB-Karte trägt es nur in 4 Bit, und dann bleiben für KV-Cache und Laufzeit nur wenige Gigabyte.

KV-Cache quantisieren

Neben den Gewichten belegt der KV-Cache Speicher: Für jedes Token im Kontext speichert jede Schicht Keys und Values. Der Bedarf je Token ist:

KV je Token = 2 × Schichten × KV-Köpfe × Kopfdimension × Bytes je Wert

Für Qwen3-32B (64 Schichten, 8 KV-Köpfe, Kopfdimension 128 laut config.json) ergibt das:

KV-Cache-Typ Je Token 32.768 Tokens 10 Anfragen à 32.768 Tokens
BF16 256 KiB rund 8,6 GB rund 86 GB
FP8 128 KiB rund 4,3 GB rund 43 GB

Der KV-Cache wächst mit Kontextlänge und Parallelität, nicht mit der Quantisierung der Gewichte. Ein 4-Bit-Modell mit langem Kontext und vielen Nutzern kann deshalb mehr Speicher für den Cache als für die Gewichte brauchen.

vLLM: --kv-cache-dtype fp8 (oder fp8_e4m3, fp8_e5m2) speichert den Cache in FP8. Ohne Kalibrierung setzt vLLM alle Skalierungsfaktoren auf 1,0; empfohlen sind kalibrierte Faktoren über llm-compressor. Mit dem Backend Flash Attention 3 werden zusätzlich die Queries in FP8 gerechnet (vLLM, Quantized KV Cache).

Ollama: OLLAMA_KV_CACHE_TYPE erlaubt f16 (Standard), q8_0 (rund halber Speicher, laut Dokumentation meist ohne spürbaren Qualitätsunterschied) und q4_0 (rund ein Viertel, kleiner bis mittlerer Präzisionsverlust, bei langem Kontext eher spürbar). Voraussetzung ist Flash Attention, die Einstellung gilt global für alle Modelle (Ollama FAQ).

Welches Format für welche Hardware

Die Formatwahl folgt aus Compute Capability, Speichergröße und Speicherbandbreite der GPU. Die Hardwaredaten stammen von NVIDIA (CUDA GPUs, RTX PRO 4000 Blackwell, RTX PRO 6000 Blackwell Max-Q, DGX Spark Hardware), Stand Oktober 2026:

Hardware Speicher Bandbreite Compute Capability FP8 FP4 nativ
RTX PRO 4000 Blackwell 24 GB GDDR7 ECC 672 GB/s 12.0 ja ja
RTX PRO 6000 Blackwell Max-Q 96 GB GDDR7 ECC 1.792 GB/s 12.0 ja ja
GB10 (AI Cube) 128 GB LPDDR5x, gemeinsam für CPU und GPU 273 GB/s 12.1 ja ja
Zum Vergleich: L40S, RTX 4090 (Ada) - - 8.9 ja nein
Zum Vergleich: Ampere (A100, RTX 30) - - 8.0 / 8.6 nur Gewichte nein

Daraus ergeben sich typische Ausgangspunkte:

Szenario Naheliegendes Format Begründung
24 GB, Modelle bis rund 8 Mrd. Parameter BF16 oder FP8 mit FP8-KV-Cache Gewichte klein, viel Platz für Cache und Nutzer
24 GB, Modelle mit 14 bis 32 Mrd. Parametern 4 Bit: NVFP4, AWQ oder GPTQ nur so passen die Gewichte, Kontext begrenzt
96 GB, dichte Modelle bis rund 70 Mrd. Parameter FP8 Qualität nah an BF16, Raum für KV-Cache
96 GB, große MoE-Modelle NVFP4 oder MXFP4 (gpt-oss) Gewichte passen nur in 4 Bit
AI Cube mit GB10, 128 GB 4-Bit-Formate (MXFP4, NVFP4, GGUF Q4_K_M) großer Speicher, aber 273 GB/s Bandbreite; weniger Bits je Gewicht heißt mehr Tokens pro Sekunde
Ältere GPUs ohne FP8 (Ampere) AWQ oder GPTQ, FP8 nur als W8A16 keine FP8-Rechenwerke

Die Grenzen sind fließend und hängen vom Modell ab. Welche Modelle auf 128 GB Unified Memory sinnvoll laufen, zeigt LLM-Modelle auf 128 GB Unified Memory, den Betrieb von gpt-oss-120b auf dem AI Cube beschreibt der Beitrag gpt-oss-120b auf dem AI Cube. Ein Praxisbeispiel für FP8 auf zwei 96-GB-Karten ist Qwen 122B mit vLLM auf zwei RTX PRO 6000. Wann ein Modell auf mehrere GPUs verteilt wird, behandelt Multi-GPU-Inferenz ohne NVLink.

Qualitätsverlust messen statt schätzen

Herstellerzahlen beziehen sich auf öffentliche Benchmarks wie MMLU, GPQA oder HumanEval. Sie zeigen die Richtung, aber nicht, wie sich ein quantisiertes Modell bei deutschen Vertragsklauseln, strukturierten Ausgaben oder Werkzeugaufrufen verhält. Gerade bei kleinen Modellen und bei 4 Bit lohnt ein eigener Vergleich.

Ein sauberer Vergleich hat vier Schritte:

  1. Referenz festlegen. Das Modell in BF16 oder FP8 auf denselben Aufgaben laufen lassen.
  2. Aufgaben aus dem Alltag wählen. 50 bis 200 echte Anfragen mit erwarteten Antworten, dazu Fälle mit JSON-Ausgabe oder Tool-Calls, wenn das System sie nutzt.
  3. Gleich konfigurieren. Gleicher Prompt, gleiche Temperatur, gleiche Kontextlänge; nur das Format ändert sich.
  4. Abweichungen auswerten. Nicht nur Treffer zählen, sondern auch Formatfehler, abgebrochene Antworten und Ausreißer prüfen.

Für standardisierte Benchmarks nutzt die vLLM-Dokumentation lm-evaluation-harness. llama.cpp bringt mit llama-perplexity ein Werkzeug für Perplexity und KL-Divergenz gegenüber dem Original mit. Bei RAG-Systemen gehört die Antwortqualität mit Quellen in die Messung, wie in RAG-Qualität messen beschrieben.

Außerdem zählt die Lizenz: Eine quantisierte Variante ist aus dem Originalmodell abgeleitet und unterliegt in der Regel weiterhin dessen Lizenzbedingungen. Mehr dazu in LLM-Lizenzen für kommerzielle Nutzung.

Was das für Ihr Projekt heißt

Quantisierung ist kein Feinschliff am Ende, sondern Teil der Hardwareentscheidung. Wer weiß, welches Modell in welchem Format laufen soll, kann die GPU-Größe, die Kontextlänge und die Zahl gleichzeitiger Nutzer belastbar planen. Wer zuerst die Hardware kauft, legt damit die möglichen Formate fest.

Wir richten Modelle mit vLLM oder Ollama ein, wählen das Format passend zur GPU, prüfen im Startprotokoll, welcher Kernel tatsächlich läuft, und vergleichen die quantisierte Variante mit Ihren eigenen Aufgaben gegen die Referenz. Grundlage sind Managed GPU-Server von WZ-IT mit NVIDIA RTX PRO 4000 Blackwell (24 GB GDDR7 ECC) oder RTX PRO 6000 Blackwell Max-Q (96 GB GDDR7 ECC) und der AI Cube mit 128 GB Unified Memory. Support, Beratung und Implementierung durch WZ-IT.

Die Modellwahl selbst behandelt Welches LLM selbst hosten?, den gesamten Speicherbedarf GPU und VRAM für LLMs dimensionieren. Den Unterschied zwischen Inferenz und Training erklärt Inferenz vs. Training, den Vergleich der Inferenz-Engines der Beitrag vLLM, Ollama und llama.cpp im Vergleich.

Lieber betreiben lassen?

Sie möchten Lokale KI für Unternehmen nicht selbst betreiben? WZ-IT übernimmt Einrichtung, Betrieb und Wartung - datenschutzorientiert aus Deutschland.

Anfrage

Lokale KI für Ihren Einsatz einordnen

Starten Sie mit dem AI Cube oder lassen Sie eine individuelle KI-Plattform, Wissensanbindung oder Integration einordnen.

  • Sie sprechen direkt mit Timo und Robin, den technisch Verantwortlichen
  • Fachliche Einschätzung Ihrer Situation
  • Konkrete nächste Schritte für Infrastruktur, Software oder KI

Das Gespräch ist kostenfrei und unverbindlich.

Timo und Robin habe ich als engagierte und professionelle Gesprächspartner kennengelernt, die für einen Kunden so einiges möglich machen, das erst mal unmöglich scheint. Ich fühlte mich sehr gut beraten. Die angebotenen Leistungen haben mich sehr überzeugt.
Andrea PawlowskiCommunications Manager, Golem.de, Deutschland
Timo und Robin, Gründer von WZ-IT

Lokale KI für Ihren Einsatz einordnen

Timo und Robin habe ich als engagierte und professionelle Gesprächspartner kennengelernt, die für einen Kunden so einiges möglich machen, das erst mal unmöglich scheint. Ich fühlte mich sehr gut beraten. Die angebotenen Leistungen haben mich sehr überzeugt.
Andrea PawlowskiCommunications Manager, Golem.de, Deutschland

Häufig gestellte Fragen

Antworten auf die wichtigsten Fragen

Wissen

Mehr zu Lokale KI für Unternehmen

Alle Lokale KI für Unternehmen-Artikel

Kunden aus Mittelstand, Industrie und öffentlicher Hand, in Deutschland und international

  • Stadtwerke Brühl
  • DGHO e.V.
  • solarwerkstatt berlin
  • Krüger Dirndl
  • ABCO Water Systems
  • Golem.de
  • EVADXB
  • nextGYM
  • AInergy
  • ml&s
  • Odiseo Solutions
  • Annota
  • ARGE
  • SweetConnect GmbH
  • Aphy AG
  • CORGOS
  • Rekorder
  • SolidProof
  • Yonju
  • Keymate
  • Paritel
  • Mr. Clipart
  • Millenium
  • Negosh
  • Führerscheinmacher
  • BTI
  • Deutsche Gesellschaft für Datenschutz
Kundenstimmen ansehen