up:: 2026 - AI Coding related:: quantisierung
Quantisierung – Mathematik & Mechanik
Wie funktioniert Quantisierung eigentlich genau? Basierend auf Julia Turc's Erklärung – mit Analogien und Beispielen.
Die Grundidee: Eimer statt Wassertropfen
Stell dir vor, du misst Wasser. Du könntest jeden einzelnen Tropfen zählen (super präzise, aber aufwändig). Oder du verwendest Eimer: "ungefähr 3 Eimer voll" (weniger präzise, aber praktisch).
Quantisierung = Werte in Eimer sortieren.
Originalwerte: 0.127, 0.389, 0.412, 0.856, 0.901
↓ ↓ ↓ ↓ ↓
Eimer (0-9): 1 4 4 9 9
Die Werte 0.389 und 0.412 landen im gleichen Eimer (4). Information geht verloren – aber wir sparen massiv Speicher.
Begriffe: FP, Full Precision, Half Precision
Kurze Begriffsklärung, weil's oft verwirrt:
| Begriff | Bedeutet | Bits | | ------- | -------- | ---- | | FP | Floating Point (Fließkommazahl) | – | | FP32 | Floating Point 32-bit | 32 | | FP16 | Floating Point 16-bit | 16 | | BF16 | Brain Float 16 (Google-Variante) | 16 | | Full Precision | Meist Synonym für FP32 | 32 | | Half Precision | Meist Synonym für FP16 | 16 |
FP ≠ Full Precision – aber FP32 = Full Precision. Verwirrend, aber so hat sich's eingebürgert.
Warum sind Integer so viel effizienter?
Analogie: Taschenrechner vs. Wissenschaftlicher Rechner
Integer sind wie ein simpler Taschenrechner: Er kennt nur ganze Zahlen, ist aber blitzschnell.
Floats sind wie ein wissenschaftlicher Rechner: Er kann 3.14159265... speichern, braucht aber mehr Knöpfe und denkt länger nach.
Technisch gesehen
| Operation | Integer | Float | | --------- | ------- | ----- | | Wie gespeichert? | Direkt als Binärzahl | Kompliziert: Vorzeichen + Exponent + Mantisse | | Addition | 1 Taktzyklus | 3-4 Taktzyklen | | Warum? | Simples XOR + Carry | Exponenten angleichen, addieren, normalisieren |
Konkretes Beispiel: Die Zahl 42
Als Integer (8 bit): 00101010
Als Float (32 bit): 01000010 00101000 00000000 00000000
↑ ↑
Sign/Exp Mantisse...
4× so viele Bits, und jede Rechenoperation ist komplexer!
Das Quantisierungs-Rezept: Schritt für Schritt
Schritt 1: Bereich festlegen (Clipping Range)
Zuerst schauen wir: Welche Werte kommen in meinem Modell überhaupt vor?
Beispiel: Alle Gewichte eines Layers liegen zwischen -1.0 und +1.0
Das ist unsere "Clipping Range" [-1.0, 1.0]
Schritt 2: Eimer definieren
Für INT4 (4 bit) haben wir 16 mögliche Werte: -8 bis +7
Eimer: -8 -7 -6 -5 -4 -3 -2 -1 0 +1 +2 +3 +4 +5 +6 +7
| | | | | | | | | | | | | | | |
Real-Werte: -1.0 0.0 +1.0
Schritt 3: Scale berechnen
Scale = Wie viel "echte Einheit" passt in einen Eimer?
Scale = (1.0 - (-1.0)) / (7 - (-8))
= 2.0 / 15
= 0.133...
→ Jeder Eimer repräsentiert ~0.133 Einheiten des Originalwerts
Schritt 4: Quantisieren
Formel:Eimer = round(Originalwert / Scale)
Beispiel: Wert 0.42
Eimer = round(0.42 / 0.133) = round(3.16) = 3
→ 0.42 landet in Eimer 3
Schritt 5: Dequantisieren (zurückrechnen)
Formel:Rekonstruierter Wert = Eimer × Scale
Rekonstruiert = 3 × 0.133 = 0.399
→ Aus 0.42 wurde 0.399 – Fehler von 0.021
Das ist der Preis der Quantisierung: Wir verlieren Präzision.
Symmetric vs. Asymmetric: Wann wird's komplizierter?
Symmetric (einfacher Fall)
Wenn die Werte schön symmetrisch um 0 verteilt sind (-1 bis +1), ist alles simpel. Die 0 bleibt die 0.
Asymmetric (z.B. nach ReLU)
ReLU-Aktivierungen sind immer ≥ 0. Dann sieht's so aus:
Originalwerte: [0.0 ... 1.0]
Eimer: [-8 ... +7]
Problem: Wo landet die 0?
Hier brauchen wir einen Zero Point – einen Offset, der sagt "Eimer -2 entspricht dem echten Wert 0".
Calibration: Woher wissen wir die Clipping Range?
Für Gewichte: Easy – die stehen fest nach dem Training. Min/Max ablesen, fertig.
Für Aktivierungen: Tricky – die ändern sich je nach Input!
Lösung: Wir lassen ein paar hundert Beispiele durch das Modell laufen und schauen, welche Werte tatsächlich vorkommen. Das dauert je nach Modell Minuten bis Stunden.
Der Fixed-Point Trick
Problem: Unser Scale (z.B. 0.133) ist ein Float. Wenn wir damit multiplizieren, war die ganze Quantisierung umsonst!
Lösung: Wir zerlegen den Scale clever:
0.133 ≈ 0.532 × 2^(-2)
↑ ↑
"Große Zahl" "Bit-Shift"
- 0.532 speichern wir als Integer (z.B. 532)
- × 2^(-2) ist nur "schiebe 2 Bits nach rechts" – superschnell!
Wo lohnt sich Quantisierung am meisten?
Der echte Bottleneck: Speicher, nicht Rechnen
Auf modernen GPUs ist das Rechnen oft gar nicht das Problem. Das Problem ist: Daten vom Speicher zur GPU schaufeln.
FP16 Modell: 30 GB über den Bus schieben
INT4 Modell: 8 GB über den Bus schieben
↑
Das macht den eigentlichen Unterschied!
Matrix-Multiplikation
LLMs bestehen hauptsächlich aus riesigen Matrix-Multiplikationen (4000×4000 und größer). Das sind Milliarden von Operationen – jede kleine Ersparnis summiert sich.
Granularität: Wie fein tunen?
Wir können unterschiedlich viele Scale/Zero-Point Werte verwenden:
| Granularität | Beschreibung | Trade-off | | ------------ | ------------ | --------- | | Per Network | Ein Scale für alles | Schnell, aber ungenau | | Per Layer | Ein Scale pro Layer | Guter Kompromiss | | Per Matrix | Ein Scale pro Gewichtsmatrix | Besser | | Per Row | Ein Scale pro Zeile | Beste Qualität, mehr Overhead |
Siehe auch: quantisierung