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