LLM-Quantisierung: 160-GB-Modelle auf dem Laptop mit minimalem Qualitätsverlust laufen lassen
Modelle wie Qwen-3-Coder-Next mit 80 Milliarden Parametern belegen 159,4 GB Speicherplatz. Quantisierung verringert die Modellgröße um das Vierfache und beschleunigt die Inferenz um das Zweifache – mit nur einem Verlust von 5–10 % an Qualität. Dadurch wird es für Endnutzer möglich, große LLMs auf herkömmlicher Hardware zu nutzen, ohne dabei die Leistung einzubüßen.
Parameter und ihr Einfluss auf die Modellgröße
Parameter – also Gewichte in einem neuronalen Netzwerk – bestimmen den Speicherbedarf eines LLMs. Jeder Parameter wird als Gleitkommazahl gespeichert. Die einfachste Einheit: Eingabe mal Gewicht ergibt Ausgabe. Reale Modelle verfügen über Hunderte von Schichten mit Tausenden von Knoten, was zu Milliarden von Parametern führt.
Ein Beispiel: Ein Netzwerk mit 2 Eingaben, 3 Schichten à 4 Knoten und 2 Ausgaben hat 64 Parameter. Vergrößert man dies auf Hunderttausende von Knoten, entstehen Billionen von Gewichten. Histogramme beliebter Modelle zeigen, dass 99 % der Werte nahe bei null liegen, im Bereich [-0,5; 0,5].
Zahlenrepräsentation im Speicher
Computer speichern float32: 1 Vorzeichenbit, 8 Exponentenbits, 23 Mantissabits. Bereich ±3,4×10³⁸ mit 7 signifikanten Stellen. Die Verteilung ist ungleichmäßig – dichter um null, spärlicher an den Rändern. Das passt perfekt zu LLMs, bei denen die Gewichte klein sind.
Float16: 1+5+10 Bits, Präzision 3–4 Dezimalstellen, Bereich ±65.504. Bfloat16 (1+8+7): großer Bereich, 2–3 Dezimalstellen. Float8/Float4 sind experimentell, mit 3–4 Mantissabits.
Sinuskurve-Näherung: float32 ist glatt; float4 wirkt stufenartig mit deutlichen Fehlern.
Prinzipien der Quantisierung
Quantisierung ist eine verlustbehaftete Kompression: Fließkommazahlen werden auf einen kleineren Wertebereich abgebildet. Einfaches Runden (auf die nächste ganze Zahl) von bfloat16 auf float4 zerstört das Modell: Die Gewichte werden null, die Ausgabe ist null. Warum? Der Bereich von float4 [-3;3] passt nicht zu typischen Gewichten [-0,89;0,16].
Symmetrische Quantisierung
Skaliert Daten in ganzzahlige Bereiche. Formel: Skalierung = max_abs / (2^(bits-1) - 1). Quantisieren: round(value / scale), Dequantisieren: quantized * scale.
Beispielcode in JavaScript:
function quantize({ values, bits }) {
const vmax = Math.max(...values.map(Math.abs));
const qmax = 2 ** (bits - 1) - 1;
const scale = vmax / qmax;
return {
values: values.map((v) => Math.round(v / scale)),
scale,
};
}
function dequantize({ values, scale }) {
return values.map((v) => v * scale);
}Für values = [-0,89, 0,16, 0,08, -0,13, 0,16, -0,54], bits=4:
- quantisiert: [-7,1,1,-1,1,-4], Skalierung≈0,127
- dequantisiert: [-0,89,0,127,0,127,-0,127,0,127,-0,509]
- Durchschnittlicher Fehler: 18%
Ausgabe des Modells nach 4-Bit-Quantisierung: 30 % Abweichung vom Original, aber 4-fach geringerer Speicherbedarf.
Asymmetrische Quantisierung
Verbessert die symmetrische Quantisierung durch getrennte Behandlung von Min und Max. Bereich [min, max] wird auf [qmin, qmax] abgebildet. Formel:
- offset = min
- scale = (max - min) / (qmax - qmin)
- quantized = round((value - offset) / scale)
Dies nutzt den Speicher effizient: Bei schiefen Daten (mehr negative Werte) wird die positive Seite nicht verschwendet. Der durchschnittliche Fehler sinkt auf 5–10 %.
Anwendung auf Tensoren: pro Kanal oder Gruppe quantisieren (Gruppen-Quantisierung), um Aktivierungsfehler zu minimieren.
Bewertung der Qualität nach Quantisierung
Messung der Perplexität auf einer Validierungsdatenmenge oder task-spezifischer Metriken (BLEU, ROUGE). Benchmarks:
- Qwen-3-Coder-Next 4-Bit: +7 % Perplexität gegenüber FP16
- Geschwindigkeit: x2 auf GPU ohne Tensor-Kerne
| Format | Größe (GB) | Perplexität | Geschwindigkeit (Tokens/Sek.) |
|--------|-----------|------------|-----------------------------|
| FP16 | 159,4 | 1,00 | 1,0 |
| INT8 | 39,8 | 1,05 | 1,8 |
| INT4 | 19,9 | 1,09 | 2,1 |
Wichtige Erkenntnisse
- Quantisierung reduziert die Modellgröße um das 4- bis 8-fache, ohne Neutrainieren.
- Verwende symmetrische Quantisierung für symmetrische Daten; asymmetrische für schief verteilte Verteilungen.
- Gruppen-Quantisierung (Gruppen zu je 128 Elementen) bietet ein Gleichgewicht zwischen Genauigkeit und Geschwindigkeit.
- Standardmäßig unterstützt in llama.cpp, bitsandbytes: INT4/INT8.
- Teste auf Nachfolgetasks: Programmierung, Fragen & Antworten.
— Editorial Team
Noch keine Kommentare.