Quantization stores a model's weights in fewer bits — float32 down to int8 or int4 — so it gets smaller and faster, for a small accuracy cost. The tool above shows the geometry: a coarser grid, fewer levels, weights snapping to the nearest one.

Where you meet it

• Running a 7B+ LLM on a laptop, a single consumer GPU, or a phone.
• Hugging Face loaders — load_in_8bit, load_in_4bit, GPTQ, AWQ — and GGUF files for llama.cpp.
• Edge / on-device inference, where int8 matmul on the accelerator is the whole point.
• QLoRA: fine-tuning a 4-bit base model on one GPU instead of a cluster.

What it does

Inference doesn't need full floating-point precision. Quantization maps each weight from a wide float range onto a small set of integers, keeping just enough resolution to preserve behaviour. You trade a controlled amount of numerical accuracy for roughly 4× less memory (fp32 → int8) and faster, cheaper math.

Fewer bits only buy speed if your hardware has the int kernels — otherwise you just shipped a smaller model that runs no faster.

How it works

A float tensor is mapped to integers with a scale and a zero-point. The scale is the step size between two integer levels; the zero-point is the integer that represents the real value 0:

scale = (max - min) / (qmax - qmin)
x_q   = round(x / scale) + zero_point      # quantize
x     = scale * (x_q - zero_point)         # dequantize (approx.)

With b bits there are 2^b levels: int8 gives 256 steps, int4 only 16. Memory is linear in bits, so int8 is ~4× smaller than fp32 and int4 ~8×. Integer matmul also runs faster on hardware that supports it. Two ways to get there:

• Post-Training Quantization (PTQ) — quantize an already-trained model. Fast, no retraining; a calibration pass over sample data picks good scales. Small accuracy drop. GPTQ and AWQ are PTQ.
• Quantization-Aware Training (QAT) — simulate the rounding during training so the model learns weights that survive it. More accurate at very low bit-widths, but needs the full training pipeline and is expensive.

Watch out

Go deeper

• Hugging Face — Quantization overview (methods compared)
• Hugging Face — bitsandbytes (LLM.int8 8-bit & QLoRA 4-bit)
• Hugging Face — GPTQ (post-training 4-bit)
• Dettmers et al. — LLM.int8() (outlier-aware 8-bit, arXiv)
• Dettmers et al. — QLoRA (4-bit NF4 fine-tuning, arXiv)

Quantisierung speichert die Gewichte eines Modells in weniger Bits — float32 runter auf int8 oder int4 — dadurch wird es kleiner und schneller, gegen einen kleinen Genauigkeitsverlust. Das Tool oben zeigt die Geometrie: ein gröberes Raster, weniger Stufen, Gewichte rasten auf die nächste.

Wo es vorkommt

• Ein 7B+-LLM auf einem Laptop, einer einzelnen Consumer-GPU oder dem Handy laufen lassen.
• Hugging-Face-Loader — load_in_8bit, load_in_4bit, GPTQ, AWQ — und GGUF-Dateien für llama.cpp.
• Edge- / On-Device-Inferenz, wo int8-Matmul auf dem Beschleuniger der ganze Sinn ist.
• QLoRA: ein 4-bit-Basismodell auf einer GPU feintunen statt auf einem Cluster.

Was es tut

Inferenz braucht keine volle Fließkomma-Präzision. Quantisierung bildet jedes Gewicht aus einem breiten Float-Bereich auf eine kleine Menge ganzer Zahlen ab — gerade genug Auflösung, um das Verhalten zu erhalten. Man tauscht einen kontrollierten Anteil numerischer Genauigkeit gegen rund 4× weniger Speicher (fp32 → int8) und schnellere, billigere Rechnung.

Weniger Bits bringen nur Speed, wenn deine Hardware die Int-Kernels hat — sonst hast du nur ein kleineres Modell, das gleich langsam läuft.

Wie es funktioniert

Ein Float-Tensor wird mit einer Skala (scale) und einem Zeropoint auf ganze Zahlen abgebildet. Die Skala ist die Schrittweite zwischen zwei Integer-Stufen; der Zeropoint ist die ganze Zahl, die den reellen Wert 0 darstellt:

scale = (max - min) / (qmax - qmin)
x_q   = round(x / scale) + zero_point      # quantisieren
x     = scale * (x_q - zero_point)         # dequantisieren (approx.)

Mit b Bits gibt es 2^b Stufen: int8 liefert 256 Schritte, int4 nur 16. Der Speicher ist linear in Bits, also ist int8 ~4× kleiner als fp32 und int4 ~8×. Integer-Matmul läuft zudem schneller auf Hardware, die es unterstützt. Zwei Wege dorthin:

• Post-Training Quantization (PTQ) — ein bereits trainiertes Modell quantisieren. Schnell, kein Retraining; ein Kalibrierungs-Durchlauf über Beispieldaten wählt gute Skalen. Geringer Genauigkeitsverlust. GPTQ und AWQ sind PTQ.
• Quantization-Aware Training (QAT) — das Runden schon während des Trainings simulieren, sodass das Modell Gewichte lernt, die es überstehen. Genauer bei sehr kleinen Bitbreiten, braucht aber die volle Trainings-Pipeline und ist teuer.

Worauf achten

Mehr dazu

• Hugging Face — Quantization-Überblick (Methoden im Vergleich)
• Hugging Face — bitsandbytes (LLM.int8 8-bit & QLoRA 4-bit)
• Hugging Face — GPTQ (Post-Training 4-bit)
• Dettmers et al. — LLM.int8() (ausreißerbewusste 8-bit, arXiv)
• Dettmers et al. — QLoRA (4-bit-NF4-Feintuning, arXiv)