Quantification

Réduire la précision des poids d'un modèle pour le rendre plus léger, plus rapide et utilisable sur du matériel grand public.

7 min de lecture

#inférence
#mémoire
#déploiement

En une phrase

La quantification, c’est réduire la précision des nombres qui composent un modèle d’IA pour qu’il prenne moins de place en mémoire et réponde plus vite, un peu comme compresser une photo.

L’analogie

Une photo prise avec un appareil professionnel pèse 50 Mo à l’état brut. Convertie en JPEG, elle tombe à 5 Mo : à l’œil nu la différence est presque invisible, mais le fichier devient facile à stocker et à envoyer partout.

La quantification fait ça aux poids d’un LLM : des nombres très précis deviennent des nombres arrondis, et le modèle garde l’essentiel de ses capacités en pesant beaucoup moins.

Comment ça marche

La précision se mesure en bits

La place que prend un poids dépend de la précision avec laquelle on l’écrit.

Format	Espace par poids	Un modèle 8B
FP32 (32 bits)	4 octets	~32 Go
FP16 / BF16 (16 bits)	2 octets	~16 Go
8 bits	~1 octet	~8,5 Go
4 bits	~0,6 octet	~4,9 Go

FP16 et BF16 tiennent tous deux en 16 bits, mais BF16 sacrifie des décimales pour garder l’amplitude du FP32 : c’est lui qui s’est imposé, un débordement faisant plus de dégâts qu’un arrondi.

Un modèle de 8 milliards de paramètres en 16 bits réclame donc 16 Go, plus que la mémoire vidéo d’une carte ordinaire ; en 4 bits il tombe sous 5 Go et tient sur un portable. Un 70 milliards descend de 280 Go en FP32 à 43 Go : trop pour une carte grand public, mais deux cartes de 24 Go ou un Mac à 64 Go y suffisent, là où il fallait un serveur.

Le principe : arrondir par blocs

Les poids sont découpés en blocs — 32 valeurs dans les formats simples, 256 dans les K-quants de llama.cpp. Chaque bloc reçoit son facteur d’échelle : un nombre gardé en précision haute, qui dit ce que vaut « un cran » ici. Un poids ne stocke plus que son numéro de cran — 16 sur 4 bits, 256 sur 8 — et se relit en multipliant ce cran par l’échelle de son bloc. Procéder par blocs évite qu’une poignée de valeurs extrêmes écrase la finesse des autres.

Ces échelles coûtent de la place : « 4 bits » n’en fait donc jamais exactement 4, et llama.cpp mesure 4,89 bits par poids pour la variante Q4_K_M, tenseurs sensibles laissés en meilleure précision compris.

Pourquoi c’est aussi plus rapide

Écrire un mot oblige la machine à relire tous les poids depuis sa mémoire, et c’est ce transfert, pas le calcul, qui fixe la cadence (voir Inférence). Moins d’octets à déplacer, moins d’attente : sur Llama 3.1 8B, llama.cpp mesure 29 mots par seconde en 16 bits contre 72 en Q4_K_M. La lecture de ta question, elle, ne gagne rien : cette phase bute sur le calcul, et chaque poids doit maintenant être reconstitué avant usage.

Ce qu’on perd, et comment on le mesure

La mesure de référence est la perplexité : on fait relire au modèle un texte inédit et on regarde à quel point chaque mot le surprend. Plus l’écart avec la version non compressée est petit, moins la quantification se voit.

8 bits : indiscernable de l’original à l’usage
5 et 4 bits : le palier raisonnable, et le réglage par défaut à peu près partout
3 bits et en dessous : la marche devient brutale ; à 2 bits le modèle écrit encore mais perd le fil

Les méthodes que tu croiseras

Les K-quants de llama.cpp (Q4_K_M, Q5_K_M, Q8_0…) : la famille de l’inférence locale, emballée dans des fichiers GGUF.
GPTQ (Frantar et al., 2022) : arrondit les poids un à un en corrigeant au passage l’erreur déjà commise. Le papier descend un modèle de 175 milliards de paramètres à 3 ou 4 bits en quatre heures de GPU.
AWQ (Lin et al., 2023) : environ 1 % des canaux de poids portent l’essentiel du résultat. Plutôt que de les garder en précision haute — mélanger deux formats ralentit le matériel —, AWQ les met à l’échelle avant l’arrondi puis compense.

Quantifier après coup, ou pendant l’entraînement

Le cas courant est la quantification post-entraînement : on arrondit un modèle fini, sans rien réapprendre. C’est ce que font GPTQ, AWQ et l’outil de llama.cpp.

L’autre voie est l’entraînement conscient de la quantification (QAT) : le modèle voit ses poids arrondis pendant qu’il apprend, et s’en accommode. Google a publié des Gemma 3 en QAT en avril 2025, avec une chute de perplexité réduite de moitié en 4 bits et un 27B passant de 54 à 14,1 Go. Le prix est un entraînement de plus : l’affaire de qui publie le modèle, pas de qui le télécharge.

À ne pas confondre avec QLoRA, qui n’entraîne rien de quantifié : il gèle le modèle en 4 bits et n’apprend que de petits adaptateurs à côté (voir LoRA).

Visualisation

Choisis une taille de modèle, puis fais glisser le curseur de FP32 à Q2_K. Les barres grises sont douze poids d’origine, les colorées ce qu’il en reste une fois chacun ramené au cran le plus proche : seize crans en Q4_K_M, quatre en Q2_K ; l’écart entre les deux, c’est ce que la compression jette. À partir de Q8_0 les deux barres se confondent — l’« indiscernable » de la liste ci-dessus, rendu littéral. La jauge du bas suit la mémoire, repères à 8, 24 et 140 Go.

Les bits par poids affichés sont ceux que llama.cpp a mesurés sur un Llama 3.1 8B, échelles comprises : c’est pourquoi Q2_K y vaut 3,16 bits et non 2. Ils sont appliqués tels quels aux trois tailles, alors qu’ils bougent un peu d’un modèle à l’autre. Les pourcentages de qualité, eux, restent des repères et non des mesures.

Taille du modèle Précision : Q4_K_M (4,89 bits par poids)

Poids du modèle, arrondis en direct (16 crans par bloc)

valeur d'origine après quantification

L'analogie de la photo

4.9 Go mémoire estimée

−85 % vs FP32 (32 Go)

~95 % qualité estimée*

8 Go 24 Go 140 Go

*Repères pédagogiques indicatifs, pas des benchmarks.

Dans la vraie vie

Tu télécharges un modèle avec Ollama ou LM Studio : c’est presque à coup sûr un GGUF quantifié en 4 ou 5 bits, sans que rien te le dise.
Sur Hugging Face, un même modèle paraît en une dizaine de variantes — Q4_K_M, Q8_0, IQ3_XS… — dont le nom annonce la place qu’elles prendront.
Un LLM qui tourne sur un téléphone n’existe que grâce à elle.
Les fournisseurs y passent aussi : Meta a servi Llama 3.1 405B en 8 bits pour le faire tenir sur un seul serveur de huit cartes H100, en laissant l’attention et les premières et dernières couches en 16 bits.

Idées reçues

« Un modèle quantifié devient bête. » En 8 bits la perte est imperceptible, en 4 bits elle reste faible sur la plupart des tâches. Le papier LLM.int8() a montré dès 2022 qu’un modèle de 175 milliards de paramètres tournait en 8 bits sans dégradation mesurable.
« On peut descendre à 1 ou 2 bits sans trop y perdre. » Pas après coup : sous 3 bits la qualité décroche vite, et les formats étiquetés « 1 bit » en pèsent deux une fois les échelles comptées. Ce qui marche, c’est de viser la basse précision dès l’entraînement — BitNet b1.58 (Microsoft, 2025) tient ses 2 milliards de poids sur trois valeurs, −1, 0 et +1. Le seuil ne porte pas sur les bits, mais sur le moment où on décide.
« La quantification enlève des poids. » Non : leur nombre ne bouge pas d’un seul, c’est la place de chacun qui rétrécit. Retirer des poids porte un autre nom, l’élagage (pruning) — une technique distincte, qu’on peut combiner à celle-ci.

Pour aller plus loin

Un guide visuel sur la quantification — Grootendorst, trad. Loïck Bourdois, 2025 (FR) : cinquante schémas, de la virgule flottante aux modèles ternaires.
LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale — Dettmers et al., 2022 (EN) : le 8 bits sans perte à 175 milliards de paramètres.
GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers — Frantar et al., ICLR 2023 (EN) : descendre à 3 ou 4 bits en quelques heures.
AWQ: Activation-aware Weight Quantization — Lin et al., 2023 (EN) : le 1 % de poids qui compte, et sa mise à l’échelle.
Le README de llama-quantize — llama.cpp (EN) : bits par poids, taille et débit mesurés pour chaque variante, K-quants et I-quants.
Gemma 3 QAT Models — Google, 2025 (EN) : le QAT en pratique, chiffres à l’appui.