Quantization‑Aware Training: Ein Guide, um die lokale Inferenz von Gemma 4 zu verbessern

Was ist Quantisierung?

Quantisierung ist eine Modellkompressions‑Technik, die die Präzision der Modellgewichte reduziert. 

Große Sprachmodelle werden üblicherweise in hochpräzisen Formaten wie BF16 oder FP16 gespeichert. Das erhält die Qualität, erfordert aber viel Speicher. Quantisierung wandelt diese Gewichte in Formate mit weniger Bits um, etwa 8‑Bit oder 4‑Bit, sodass das Modell weniger VRAM nutzt und lokal leichter läuft. Hugging Face weist darauf hin, dass 8‑Bit‑Quantisierung den Speicherbedarf ungefähr halbieren kann, während 4‑Bit ihn noch weiter senkt.

Der Kompromiss: Geringere Präzision kann die Ausgabequalität mindern, besonders wenn das Modell nicht für die Quantisierung optimiert wurde. Vereinfacht gesagt: BF16 und FP16 liefern meist die beste Qualität, brauchen aber mehr Speicher; 8‑Bit‑Modelle sind kleiner und halten die Qualität oft gut; 4‑Bit‑Modelle sind deutlich kleiner, können aber an Genauigkeit oder Stabilität einbüßen. 

Für lokale Inferenz lohnt sich dieser Trade‑off oft, weil dadurch größere Modelle auf Consumer‑GPUs laufen können, statt teure Rechenzentrums‑Hardware zu benötigen.

Was ist Quantization‑Aware Training?

Quantization‑Aware Training (QAT) bezeichnet eine Trainingsmethode, bei der das Modell während des Trainings oder der Feinabstimmung ein Niedrigpräzisions‑Verhalten simuliert. So bleibt das Modell nach der Quantisierung stabiler und kann bei niedrigen Bitbreiten lokal besser performen.

Wodurch unterscheidet sich QAT?

Der übliche Ansatz, die Post‑Training‑Quantisierung, komprimiert ein Modell erst nach dem Training. Das ist einfach und praktisch, aber das Modell kann Qualität verlieren, weil es nicht darauf trainiert wurde, mit Niedrigpräzisions‑Gewichten umzugehen. 

Laut der Google AI Edge‑Dokumentation ist Post‑Training‑Quantisierung ein Konvertierungsschritt, der die Modellgröße reduziert und die Latenz verbessert – meist mit nur geringen Genauigkeitsverlusten. Die endgültige Qualität hängt jedoch weiterhin vom Modell und der Quantisierungsstufe ab. 

Quantization‑Aware Training, kurz QAT, verfolgt einen anderen Ansatz. Statt erst nach dem Training zu quantisieren, simuliert QAT während des Trainings oder der Feinabstimmung Niedrigpräzisions‑Verhalten. So lernt das Modell, auch nach der Umwandlung in ein kleineres Format stabil zu bleiben. Das minimiert den Qualitätsverlust bei der Kompression.

Darum ist Gemma 4 QAT für lokale KI so spannend. Das Modell ist mit Blick auf Quantisierung gebaut, kann also mehr von der ursprünglichen Qualität bewahren und gleichzeitig weniger Speicher nutzen. Für Nutzerinnen und Nutzer mit Consumer‑GPUs bedeutet das bessere Stabilität bei niedriger Bitbreite, geringeren VRAM‑Verbrauch und insgesamt praxisnähere lokale Inferenz.

Schritt 1: Abhängigkeiten installieren und llama.cpp bauen

Bevor wir die Modelle herunterladen, richten wir die lokale Laufzeit ein. Dieses Tutorial wurde auf einer Maschine mit NVIDIA RTX 4090 und 24 GB VRAM getestet. Wir verwenden llama.cpp als Inferenz‑Runtime, GGUF als Modellformat und die UD-Q4_K_XL‑quantisierten Modelldateien.

Getestetes Setup:

• GPU: NVIDIA RTX 4090
• VRAM: 24 GB
• Runtime: llama.cpp
• Modellformat: GGUF
• Quantisierung: UD-Q4_K_XL

Wir vergleichen diese zwei Unsloth‑GGUF‑Modelle:

• unsloth/gemma-4-12B-it-GGUF
• unsloth/gemma-4-12B-it-qat-GGUF

Prüfe zuerst, ob deine GPU verfügbar ist.

nvidia-smi

Installiere anschließend die System‑Pakete, die für den Build von llama.cpp benötigt werden.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y

Klonen wir das offizielle llama.cpp‑Repository.

git clone https://github.com/ggml-org/llama.cpp

Baue nun llama.cpp mit aktivierter CUDA‑Unterstützung. Dadurch laufen die Modellschichten auf der GPU statt nur auf der CPU.

cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF \
    -DGGML_CUDA=ON

Kompiliere die benötigten Binaries.

cmake --build llama.cpp/build \
    --config Release \
    -j \
    --clean-first \
    --target llama-cli llama-mtmd-cli llama-server llama-gguf-split

Nach dem Build ist das Haupt‑Binary, das wir nutzen, llama-server. Damit können wir das GGUF‑Modell lokal ausführen und eine OpenAI‑kompatible API bereitstellen, die wir mit curl abfragen. 

Schritt 2: Gemma 4 12B Non‑QAT‑ und QAT‑Modelle herunterladen 

Jetzt, da llama.cpp bereit ist, laden wir beide Gemma‑4‑12B‑Varianten von Hugging Face. Wir holen das reguläre Instruction‑Tuning‑Modell und die QAT‑Version im GGUF‑Format.

Installiere zuerst die Hugging Face Hub‑CLI mit schnellerem Download‑Support.

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transfer

Aktiviere High‑Performance‑Xet‑Downloads.

export HF_XET_HIGH_PERFORMANCE=1

Lade das reguläre Gemma 4 12B Instruction‑Modell im GGUF‑Format.

hf download unsloth/gemma-4-12B-it-GGUF \
  --local-dir models/gemma-4-12B-it-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-Q4_K_XL*"

Lade als Nächstes die QAT‑Version im gleichen Quantisierungsformat.

hf download unsloth/gemma-4-12B-it-qat-GGUF \
  --local-dir models/gemma-4-12B-it-qat-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-Q4_K_XL*"

Die --include‑Flags sorgen dafür, dass wir nur die für dieses Tutorial benötigten Dateien laden, statt das gesamte Repository zu ziehen. Hier laden wir die UD-Q4_K_XL‑GGUF‑Modelldateien und die mmproj-BF16‑Dateien, die vom Modellpaket genutzt werden. 

Überprüfe nach dem Download, dass beide Modellordner existieren.

ls models

Erwartete Ausgabe:

gemma-4-12B-it-GGUF
gemma-4-12B-it-qat-GGUF

Jetzt stehen sowohl das Non‑QAT‑ als auch das QAT‑Modell lokal bereit, und wir können sie mit llama-server bereitstellen.

Schritt 3: Non‑QAT‑Modell mit llama‑server starten

Wir starten mit dem regulären Gemma 4 12B Instruction‑Modell. Das liefert uns eine Basis, um es später mit der QAT‑Version unter gleichen Bedingungen zu vergleichen.

Starte das Non‑QAT‑Modell mit llama-server.

./llama.cpp/llama-server \
  -m models/gemma-4-12B-it-GGUF/*UD-Q4_K_XL*.gguf \
  --host 0.0.0.0 \
  --port 8001 \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Damit läuft ein lokaler OpenAI‑kompatibler Server unter http://localhost:8001.

Öffne ein weiteres Terminal und sende eine Anfrage an den lokalen Server.

time curl http://localhost:8001/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "gemma-4-12B-it",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful local AI assistant."
    },
    {
      "role": "user",
      "content": "Explain why quantization-aware training is useful for running LLMs on consumer GPUs."
    }
  ],
  "temperature": 1.0,
  "top_p": 0.95,
  "max_tokens": 512
}'

In diesem Befehl nutzen wir den lokalen /v1/chat/completions‑Endpunkt im OpenAI‑kompatiblen Format. Die Eingabe bittet das Modell, Quantization‑Aware Training zu erklären. max_tokens ist auf 512 gesetzt, damit beide Modellvarianten mit derselben Ausgabelänge getestet werden. 

In unserem RTX‑4090‑Test ergab das Non‑QAT‑Modell folgende Zeiten:

• Prompt‑Tokens: 40
• Completion‑Tokens: 512
• Prompt‑Geschwindigkeit: 510,22 Tokens/Sek.
• Generierungsgeschwindigkeit: 94,65 Tokens/Sek.
• Gesamtzeit: 5,516 Sek.

GPU‑Speichernutzung:

9247 MiB / 24564 MiB

Das liefert die Basisleistung für das reguläre Gemma 4 12B. Im nächsten Schritt starten wir die QAT‑Version mit identischer Konfiguration und vergleichen die Ergebnisse.

Schritt 4: QAT‑Modell starten und testen

Jetzt führen wir die QAT‑Variante von Gemma 4 12B mit denselben llama-server‑Einstellungen aus. Beende vorher den Non‑QAT‑Server, da beide Befehle denselben Port verwenden.

Starte das QAT‑Modell.

./llama.cpp/llama-server \
  -m models/gemma-4-12B-it-qat-GGUF/*UD-Q4_K_XL*.gguf \
  --host 0.0.0.0 \
  --port 8001 \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Damit läuft das QAT‑Modell am selben OpenAI‑kompatiblen Endpunkt, http://localhost:8001.

Sende nun denselben Test‑Prompt an das QAT‑Modell.

time curl http://localhost:8001/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "gemma-4-12B-it-qat",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful local AI assistant."
    },
    {
      "role": "user",
      "content": "Explain why quantization-aware training is useful for running LLMs on consumer GPUs."
    }
  ],
  "temperature": 1.0,
  "top_p": 0.95,
  "max_tokens": 512
}'

In unserem RTX‑4090‑Test ergab das QAT‑Modell folgende Zeiten:

1. Prompt‑Tokens: 40
2. Completion‑Tokens: 512
3. Prompt‑Geschwindigkeit: 593,93 Tokens/Sek.
4. Generierungsgeschwindigkeit: 101,65 Tokens/Sek.
5. Gesamtzeit: 5,114 Sek.

GPU‑Speichernutzung:

8627 MiB / 24564 MiB

Du kannst auch die lokale Server‑URL (http://localhost:8001) kopieren und im Browser öffnen:

Das öffnet die integrierte llama.cpp‑Web‑UI – eine einfache, ChatGPT‑ähnliche Oberfläche, um das lokale Modell zu testen. So kannst du direkt im Browser mit dem QAT‑Modell chatten, Prompts ausprobieren und das Modell als täglichen lokalen KI‑Assistenten nutzen. 

QAT vs. Non‑QAT: Ergebnisse vergleichen

Nachdem wir beide Modelle mit demselben Prompt und denselben Server‑Einstellungen getestet haben, können wir die Leistung auf der RTX 4090 direkt vergleichen.

In diesem Lauf war das QAT‑Modell sowohl schneller als auch sparsamer als die Non‑QAT‑Variante. Es benötigte 620 MiB weniger VRAM – rund 6,7 % weniger Speicher. Für lokale Inferenz ist das hilfreich, denn jeder eingesparte MiB zählt, wenn große Modelle auf Consumer‑GPUs laufen.

Das QAT‑Modell generierte zudem schneller Tokens – von 94,65 Tokens/Sek. auf 101,65 Tokens/Sek. Das entspricht einem Plus von etwa 7,4 % und verkürzte die Zeit von 5,516 Sekunden auf 5,114 Sekunden.

Im Alltag fühlte sich das QAT‑Modell reaktionsschneller und flüssiger an. Auch die Antwortqualität wirkte in diesem Test stabiler – genau dafür ist QAT gedacht: Es hilft dem Modell, Niedrigbit‑Quantisierung mit weniger Qualitätsverlust zu verkraften, während Speicher‑ und Geschwindigkeitsvorteile der Kompression erhalten bleiben.

Fazit

Google treibt die lokale KI‑Community stark voran. Mit Modellen wie Gemma 4 und Techniken wie QAT wird der Traum, leistungsfähige KI komplett offline und sogar auf Consumer‑Hardware auszuführen, Realität. 

Das Spannende ist: Es geht nicht nur darum, Modelle zu verkleinern. Mit QAT verzichten wir nicht einfach auf Qualität, damit das Modell passt. Wir erhalten Modelle, die speziell für Niedrigbit‑Formate ausgelegt sind – das verbessert die gesamte lokale KI‑Experience. In diesem Test war die QAT‑Variante schneller, sparsamer und flüssiger als die Non‑QAT‑Version.

Ich freue mich jetzt darauf, die MTP‑Version des Modells zu testen, die die Geschwindigkeit möglicherweise nochmals deutlich, vielleicht sogar um den Faktor 2, steigern kann. Damit ließe sich noch mehr meines Workflows auf lokale KI verlagern. Ich könnte das Modell lokal ausführen, mit Tools wie OpenCode verbinden und Projektdateien direkt mit einem privaten lokalen Assistenten bearbeiten.

Diese neue Welle lokaler KI verändert unseren Blick auf KI‑Systeme. Aufgaben, die früher große Cloud‑Setups brauchten – besonders multimodale Workflows mit Text‑, Bild‑ und Videoeingaben – werden nach und nach auf lokalen Maschinen möglich. Für Entwickler, Forschende und Builder, denen Privatsphäre, Tempo und Kontrolle wichtig sind, ist das eine äußerst spannende Richtung.