Du öffnest Hugging Face, um ein lokales LLM auszuführen, und dasselbe Modell hat eine ganze Wand voller Dateien—Q4_K_M, Q5_K_S, GPTQ, AWQ, IQ3_M… und du erstarrst. Das ist die erste Mauer, gegen die die meisten laufen. Dieser Artikel beantwortet ganz praktisch: „Welche quantisierte Datei lade ich herunter, damit es läuft?" Was Quantisierung ist (das Konzept), überlassen wir einem anderen Artikel und konzentrieren uns hier auf die Formatwahl.

Wir behandeln, warum das Format von der Runtime bestimmt wird, das GGUF-Namensschema (Q4_K_M), die 4 Formate im Vergleich, wie man die Bit-Tiefe wählt und wie man Dateien findet. Die Kernpunkte vorweg. ① Das Format wird meist dadurch entschieden, „auf welcher Engine du es ausführst" (GGUF = llama.cpp/Ollama; GPTQ/AWQ = GPU-Engines wie vLLM). Q4_K_M bedeutet „4-Bit, K-quant, Größe M"—in den meisten Fällen der verbreitete Sweet Spot. ③ Im Zweifel mit Q4_K_M anfangen; auf Q5/Q6 hochgehen, wenn du das VRAM hast.

QUANTISIERUNGSFORMATE

Das Format bestimmt die Runtime

— entscheide zuerst die Engine, und die Dateiauswahl grenzt sich schnell ein

GGUF llama.cpp / Ollama / LM Studio = auch CPU, Mac, Teil-GPU (das einzige CPU-freundliche)
GPTQ vLLM / TGI / ExLlama = GPU (braucht Kalibrierung)
AWQ vLLM / TGI = GPU (schützt wichtige Gewichte über Aktivierungen)
EXL2 ExLlamaV2 = GPU (feinabgestufte Bit-Breite)

Die erste Frage lautet also „Auf welcher Engine führe ich es aus?" Lokal auf CPU/Mac → GGUF. GPU-Server für Geschwindigkeit → GPTQ/AWQ.

1. Warum quantisierte Dateien verwirren

Quantisierung bedeutet, die Gewichte eines Modells auf weniger Bits zu runden, um Größe und Speicher zu reduzieren (siehe was Quantisierung ist). Der Haken: Es gibt mehrere Methoden (Formate) für dieses Runden, und jede hat viele Varianten bei Bit-Tiefe und Granularität. Das Ergebnis: über 20 Dateien unter einem einzigen Modell auf Hugging Face.

Aber keine Sorge—die Wahl wird einfach, sobald du sie in zwei Schritte aufteilst: ① welches Format (= auf welcher Engine du es ausführst), dann ② welche Datei mit welcher Bit-Tiefe darin. Denke in dieser Reihenfolge.

2. Die zentrale Regel: Das Format bestimmt die Runtime

Der wichtigste Fakt: Eine quantisierte Datei läuft nur auf Engines, die ihr Format unterstützen. Entscheide also zuerst die Engine, und das Format ergibt sich fast automatisch.

FormatHaupt-EnginesHardwareKalibrierung
GGUFllama.cpp / Ollama / LM Studio / KoboldCppCPU, Mac, Teil-GPU (gemischt)Optional (imatrix)
GPTQGPTQModel (früher AutoGPTQ) / vLLM / TGI / ExLlamaGPUErforderlich
AWQAutoAWQ / vLLM / TGIGPUErforderlich
EXL2 / EXL3ExLlamaV2 / ExLlamaV3GPUErforderlich
bitsandbytes (NF4/INT8)Transformers (quantisiert beim Laden)GPUKeine (datenfrei)

Merk dir eines: GGUF ist das einzige „lokale Alleskönner"-Format, das auf CPU / Mac / Teil-GPU läuft; der Rest (GPTQ/AWQ/EXL2) ist im Grunde reines GPU. Also—

  • Ausführung auf deinem eigenen PC / Mac / CPU (Ollama oder LM Studio) → GGUF, ohne Frage.
  • Hoher Durchsatz auf einem GPU-Server (vLLM/TGI mit vielen Anfragen) → GPTQ oder AWQ.
  • Bit-Breite fein ausreizen auf einer einzelnen GPUEXL2/EXL3.
  • Schneller Test in Transformers (keine vorquantisierte Datei) → bitsandbytes (NF4).

3. GGUF-Namen entschlüsseln (Q4_K_M)

GGUF, das dir bei lokaler Nutzung am häufigsten begegnet, ist harmlos, sobald du die „Chiffre" im Dateinamen lesen kannst. Q4_K_M besteht aus drei Teilen.

Q4_K_M
Q4
Bit-Tiefe (nominal) = 4-Bit. Höhere Zahl = höhere Qualität, größere Datei.
K
K-quant (intelligente Quantisierung über Super-Blöcke). Ohne Zusatz / _0 / _1 sind veraltet.
M
S/M/L = small/medium/large. Wie stark einige wichtige Tensoren auf höhere Bits „hochgestuft" werden.

Also Q4_K_M = „4-Bit K-quant, Größe M (einige Tensoren hochgestuft, um Qualität zu schützen)." Die effektiven Bits liegen etwas über dem Label (z. B. Q4_K ≈ 4,5 bpw).

Zwei weitere Begriffe bewahren dich davor, den Faden zu verlieren.

  • Die IQ-Familie (IQ2_XS, IQ3_M usw.) = I-quants: eine neuere, codebuchbasierte Linie, die bei gleicher Bit-Tiefe noch kleiner werden kann. Aber die Inferenz ist schwerer, und sie brauchen praktisch die imatrix von unten. Ein Trumpf für „Ich muss das unbedingt ins VRAM bekommen."
  • imatrix (importance matrix / Wichtigkeitsmatrix): Man schickt einen Kalibrierungstext durch das Modell, um zu messen, welche Gewichte wichtig sind, und schützt dann diese bei niedriger Bit-Tiefe zuerst. Optional bei K-quants, praktisch erforderlich bei I-quants. Mit imatrix gebaute GGUFs halten sich bei niedrigen Bits besser.

4. Die 4 Formate im Vergleich (GGUF/GPTQ/AWQ/EXL2)

Hier der Charakter jedes wichtigen Formats, GPU-Formate eingeschlossen.

GGUF

Das einzige Format, das auf CPU/Mac/gemischt läuft. Der llama.cpp-Standard. Flexibel mit K-quant/I-quant/imatrix. Erste Wahl für lokale private Nutzung.

GPTQ

Der GPU-4-Bit-Standard. Minimiert den schichtweisen Fehler per Kalibrierung. Schnell auf vLLM/TGI. Inzwischen abgelöst durch GPTQModel.

AWQ

Schützt „wichtige Gewichte", indem es die Aktivierungen betrachtet (activation-aware). GPU, nur Gewichte, 4-Bit. Weit verbreitet auf vLLM/TGI.

EXL2 / EXL3

Bit-Breite als Bruchzahl festlegen (z. B. 4,5 bpw). Nur ExLlama, GPU. EXL3 ist eine neuere QTIP-basierte Linie, die noch reift.

💡 GPTQ vs AWQ (kurz gefasst): GPTQ „minimiert den Rekonstruktionsfehler Schicht für Schicht," während AWQ „die Aktivierungsverteilung betrachtet, um die wichtigen ~1 % der Gewichte zu schützen." Welches gewinnt, hängt vom Modell, der Bit-Breite und der Implementierung ab, also ist keines pauschal besser. Nimm einfach das, was deine gewählte Engine unterstützt.

5. Welche Datei / Bit-Tiefe wählen

Sobald das Format feststeht, kommt als Nächstes die Bit-Tiefe. Am Beispiel von GGUF hier eine praktische Leiter für „im Zweifel nimm das" (die Zahlen sind Näherungswerte und variieren je nach Modell und Build).

DateiRolleWann wählen
Q4_K_MDer verbreitete Sweet Spot (Ollamas Standard für viele Modelle)Im Zweifel. In der Regel die beste Balance aus Größe/Qualität
Q5_K_M / Q6_KNäher an voller QualitätDu hast VRAM übrig und willst noch eine Stufe höher
Q8_0Nahezu verlustfrei, aber nicht empfohlenSelten nötig (viel mehr RAM/langsamer für einen winzigen Qualitätsgewinn)
IQ2 / IQ3 (I-quant)Bei sehr niedrigen Bits hineinquetschenNur wenn du ein großes Modell zwingend ins VRAM bekommen musst

Als Faustregel sagt man oft, dass etwa 4,5–5 Bits pro Gewicht (Q4_K–Q5_K) das „leckere" Band sind (eine Heuristik). Oberhalb von Q6 verlangsamen sich die Qualitätsgewinne, und Q8_0 oder FP16 kosten viel Speicher und Geschwindigkeit für kaum einen Unterschied—das ist der praktische Konsens. Fang an, indem du Q4_K_M ausführst, auf Q5/Q6 hochgehst, wenn es sich knapp anfühlt, und auf IQ absteigst, wenn es nicht passt, und feinjustierst im Verlauf. Zur Abschätzung des benötigten VRAM siehe Hardware-Anforderungen für lokale LLMs.

6. Dateien auf Hugging Face und Ollama finden

Auf Hugging Face filterst du GGUF mit library=gguf oder gehst zum Repo eines Quant-Repackagers. Zum Zeitpunkt des Schreibens veröffentlichen bartowski und mradermacher aktiv GGUFs (inklusive imatrix-Builds)—aber die Aktivität von Repackagern ändert sich, also prüfe das neueste Upload-Datum. (TheBlokes einst maßgebliche Repos existieren noch, aber neue Uploads sind weitgehend eingestellt.) Um eigene zu konvertieren, funktioniert der offizielle gguf-my-repo-Space.

Auf Ollama folgen die Tags dem Muster model:size-variant-quant.

# Kein Tag = der Standard (Q4_K_M für viele Modelle)
ollama pull llama3.1

# Den Quant explizit wählen
ollama pull llama3.1:8b-instruct-q5_K_M
ollama pull qwen2.5-coder:7b-instruct-q8_0

# Verfügbare Tags siehe ollama.com/library/<model>/tags

Der eigentliche Workflow besteht also aus drei Zügen: Engine entscheiden → auf ihr Format eingrenzen → die Datei mit der Bit-Tiefe wählen, die in dein VRAM passt. Beherrsche das, und die 20-Dateien-Wand schüchtert dich nicht mehr ein. Zum tatsächlichen Ausführen siehe wie man ein lokales LLM ausführt und den Ollama-Leitfaden.

Zusammenfassung

Ein Quantisierungsformat zu wählen sind zwei Schritte. Zuerst ① auf welcher Engine du es ausführst—lokal CPU/Mac → GGUF; GPU-Server für Geschwindigkeit → GPTQ/AWQ; fein abgestimmte Bit-Breite auf einer GPU → EXL2; schneller Transformers-Test → bitsandbytes. Die oberste Regel: ein Format läuft nur auf Engines, die es unterstützen.

Dann ② die Bit-Tiefe. GGUFs Q4_K_M bedeutet „4-Bit, K-quant, Größe M"—der verbreitete Standard. Im Zweifel Q4_K_M → (wenn Platz ist) Q5/Q6 → (wenn es nicht passt) IQ. Orientiere dich an der Heuristik des „leckeren Bands" bei ~4,5–5 bpw und justiere während des Betriebs. imatrix-Builds halten sich bei niedrigen Bits besser. Verwandt: was Quantisierung ist, wie man ein lokales LLM ausführt, Hardware-Anforderungen, beste lokale Modelle, Ollama-Leitfaden.

FAQ

F. Welche Datei soll ich denn nun wählen?
A. Entscheide zuerst „auf welcher Engine du es ausführst." Eigener PC oder Mac (Ollama/LM Studio) → GGUF; ein GPU-Server (vLLM/TGI) → GPTQ oder AWQ. Dann zur Bit-Tiefe: im Zweifel Q4_K_M (gute Balance aus Größe/Qualität und Ollamas Standard für viele Modelle). Mit VRAM übrig Q5_K_M/Q6_K; nur wenn du ein großes Modell zwingend unterbringen musst, ziehe IQ2/IQ3 in Betracht.

F. Was bedeutet Q4_K_M?
A. Drei Teile. Q4 = ~4-Bit (höhere Zahl = höhere Qualität, größere Datei), K = K-quant (intelligente Quantisierung über Super-Blöcke; ohne Zusatz oder _0/_1 sind veraltet) und M = Größe medium (S/M/L gibt an, wie stark einige wichtige Tensoren auf höhere Bits hochgestuft werden). Die effektiven Bits liegen einen Tick über dem Label (Q4_K ≈ 4,5 bpw).

F. Wie unterscheiden sich GGUF und GPTQ/AWQ?
A. Durch die Runtime (Hardware), die sie unterstützen. GGUF ist das einzige „lokale Alleskönner"-Format, das auf CPU, Mac und Teil-GPU läuft, für llama.cpp/Ollama. GPTQ und AWQ sind GPU-first und eignen sich für hohen Durchsatz auf vLLM/TGI. Sie unterscheiden sich auch in der Methode (GPTQ minimiert den schichtweisen Fehler; AWQ schützt wichtige Gewichte über Aktivierungen), aber keines ist pauschal besser. Nimm einfach das, was deine Engine unterstützt.

F. Wie unterscheidet sich IQ (I-quant) von einem normalen Q4?
A. Es kann bei gleicher Bit-Tiefe noch kleiner werden (eine neuere, codebuchbasierte Methode). Im Gegenzug ist die Inferenz etwas schwerer, und es braucht praktisch eine imatrix, um die Qualität zu halten. Sein Einsatz ist ein Trumpf für „Ich muss ein großes Modell ins VRAM bekommen." Wenn es normal passt, ist ein K-quant wie Q4_K_M einfacher zu handhaben.

F. Sind Q8_0 oder FP16 nicht höherwertig? Warum „nicht empfohlen"?
A. Sie sind tatsächlich nahezu verlustfrei, aber sie fressen weit mehr Speicher und laufen langsamer für nur einen winzigen Qualitätsgewinn gegenüber Q5/Q6. Selbst die llama.cpp-Community empfiehlt sie nicht für den Normalgebrauch. In der Praxis ist etwa 4,5–5 bpw (Q4_K–Q5_K) das „leckere" Band, und von dort gehst du nach Bedarf hoch oder runter (die Zahlen sind Näherungswerte und variieren je nach Modell/Build).