# Quantification : Q4, Q8, ce qu'on gagne et ce qu'on perd

> Q4_K_M, Q8_0, F16 : comment un modèle local est compressé, combien de mémoire on gagne, ce que mesure la perte de précision, et quelle version choisir.

- Niveau : Expert
- Thème : IA locale
- Durée : 14 minutes
- Systèmes : Mac, Windows, Linux
- Publié le 17 novembre 2026, relu le 17 novembre 2026
- Auteur : Ulrich Rozier
- Page : https://quelleia.com/guides/quantification/

Un modèle d'IA est, pour l'essentiel, une très longue liste de nombres : ses paramètres, ou poids. À la sortie de l'entraînement, chacun occupe 16 bits, soit 2 octets. Un modèle de 8 milliards de paramètres pèse donc autour de 16 Go, trop pour la plupart des ordinateurs. La quantification range ces nombres sur moins de bits (8, 4, parfois 2) pour faire tenir le modèle dans moins de mémoire, au prix d'un peu de précision.

## À quoi ça sert

- **Faire tenir un modèle dans sa machine.** La version à 4 bits d'un modèle prend un peu moins du tiers de la place de sa version complète.
- **Écrire plus vite.** Un modèle relit ses paramètres à chaque mot qu'il produit : moins d'octets à relire, c'est une génération plus rapide (le guide sur la vitesse détaille le calcul).
- **Choisir en connaissance de cause.** Les catalogues d'Ollama et de LM Studio proposent chaque modèle en plusieurs versions aux noms codés (`q4_K_M`, `q8_0`, `fp16`) : savoir les lire évite de prendre la plus lourde par réflexe, ou la plus légère par erreur.

## Comment ça marche

On ne réduit pas les poids un par un au hasard. Les formats GGUF de llama.cpp, qu'utilisent Ollama et LM Studio, découpent chaque matrice du modèle en petits blocs de poids voisins, de 32 ou 256 valeurs. Chaque bloc garde un facteur d'échelle commun, et chaque poids devient un petit entier. Au calcul, on retrouve une valeur approchée en multipliant l'entier par l'échelle.

![Le principe de la quantification par blocs, sur huit poids inventés pour l'exemple. Les vrais blocs en comptent 32 ou 256 selon le format.](https://quelleia.com/guides/quantification/schema-bloc.svg)

*Le principe de la quantification par blocs, sur huit poids inventés pour l'exemple. Les vrais blocs en comptent 32 ou 256 selon le format.*

L'échelle et, selon le format, un minimum par bloc coûtent quelques bits de plus. C'est pourquoi un format dit « 4 bits » pèse en moyenne un peu plus de 4 bits par poids. La documentation de Hugging Face décrit ainsi les formats GGUF de llama.cpp :

| Format | Organisation | Bits par poids |
| --- | --- | --- |
| Q8_0 | blocs de 32 poids, une échelle par bloc | 8,5 en moyenne (mesuré par llama.cpp) |
| Q6_K | super-blocs de 16 blocs de 16 poids | 6,5625 |
| Q5_K | super-blocs de 8 blocs de 32 poids, échelle et minimum par bloc | 5,5 |
| Q4_K | super-blocs de 8 blocs de 32 poids, échelle et minimum par bloc | 4,5 |
| Q3_K | super-blocs de 16 blocs de 16 poids | 3,4375 |
| Q2_K | super-blocs de 16 blocs de 16 poids | 2,625 |

### Lire le nom d'un format

- **Le chiffre après le Q** donne le nombre de bits des petits entiers : `Q8`, `Q6`, `Q4`…
- **`_0` et `_1`** désignent les premiers formats de llama.cpp, que la documentation de Hugging Face classe comme anciens. `Q8_0` reste proposé dans les catalogues d'Ollama et de LM Studio.
- **`_K`** marque les formats à super-blocs, venus après les premiers.
- **La lettre finale `S`, `M` ou `L`** choisit un dosage. Tout le modèle n'est pas réduit au même nombre de bits, et certaines parties gardent un format plus précis. D'où les 4,89 bits par poids en moyenne de `Q4_K_M`, contre 4,67 pour `Q4_K_S`, mesurés par llama.cpp.
- **`IQ`** désigne des formats qui s'appuient sur une « matrice d'importance » (imatrix), qui indique quels poids préserver en priorité. Ils vont de 1 à 4 bits.
- **`F16`, `BF16` ou `fp16`** désignent la version complète, sans quantification.

## Ce qu'on gagne

Le projet llama.cpp publie le même modèle, Llama 3.1 8B, mesuré dans chaque format. La taille baisse avec les bits, et la vitesse d'écriture monte.

![Llama 3.1 8B en trois versions : taille du fichier et vitesse de génération mesurées par le projet llama.cpp (tableau de son outil de quantification).](https://quelleia.com/guides/quantification/schema-trois-versions.svg)

*Llama 3.1 8B en trois versions : taille du fichier et vitesse de génération mesurées par le projet llama.cpp (tableau de son outil de quantification).*

Sur ce modèle, passer de la version complète (14,96 Gio) à `Q4_K_M` (4,58 Gio) divise la taille par plus de trois, et la génération passe de 29 à 72 jetons par seconde. La lecture de la demande, elle, ne s'accélère pas : elle dépend de la puissance de calcul plus que de la mémoire, et le même tableau la montre à peu près stable d'un format à l'autre.

Pour vos calculs de mémoire, QUELLE IA compte 0,6 Go par milliard de paramètres à 4 bits, 1,05 Go à 8 bits et 2 Go en version complète, plus 15 % pour la conversation.

## Ce qu'on perd

La perte se mesure surtout par la **perplexité** : on fait lire au modèle un texte de référence et on mesure à quel point chaque mot suivant le surprend. Plus elle est basse, mieux le modèle prédit. llama.cpp publie, pour chaque format, la hausse de perplexité par rapport à la version d'origine, sur Llama 3 8B :

| Format | Taille | Hausse de perplexité |
| --- | --- | --- |
| Q8_0 | 7,96 Go | +0,0026 |
| Q6_K | 6,14 Go | +0,0217 |
| Q5_K_M | 5,33 Go | +0,0569 |
| Q4_K_M | 4,58 Go | +0,1754 |
| Q4_K_S | 4,37 Go | +0,2689 |
| Q3_K_M | 3,74 Go | +0,6569 |
| Q2_K | 2,96 Go | +3,5199 |

La hausse reste très faible jusqu'à `Q5_K_M`, se lit nettement à 4 bits et grimpe en flèche à 2 bits. Une étude publiée en novembre 2024 et acceptée à la conférence ACL 2025 arrive au même ordre de grandeur, sur la famille Llama 3.1 et plus de 500 000 évaluations : la quantification à 8 bits y est quasiment sans perte, et les poids à 4 bits (dans un autre format que ceux de llama.cpp) restent proches du 8 bits.

Ces chiffres sont des moyennes sur un texte de référence, pour un seul modèle. L'effet varie d'un modèle et d'une tâche à l'autre, et aucun benchmark du classement de QUELLE IA ne le mesure modèle par modèle.

> Bon à savoir : le score d'un modèle sur QUELLE IA est mesuré sur sa version complète. Sur les pages machines, le site compte la version la plus complète qui tient et ne descend pas sous 4 bits.

## Choisir sa version étape par étape

### Dans Ollama

1. Ouvrez la page du modèle sur ollama.com/library, puis l'onglet des étiquettes (Tags).
2. Repérez la taille voulue, puis le suffixe de version : `-q4_K_M`, `-q8_0` ou `-fp16`. Sans suffixe, l'étiquette courte pointe vers une version choisie par défaut : `qwen3:8b` est la même que `qwen3:8b-q4_K_M` (même identifiant dans le catalogue).

![Extrait de la page ollama.com des étiquettes de qwen3 : trois lignes, qwen3:8b-q4_K_M de 5,2 GB, qwen3:8b-q8_0 de 8,9 GB et qwen3:8b-fp16 de 16 GB, toutes avec un contexte de 40K et une entrée texte.](https://quelleia.com/guides/quantification/catalogue-qwen3-versions.webp)

*Trois versions de Qwen3 8B dans le catalogue d'Ollama, capturé le 17 novembre 2026 : 5,2 Go en Q4_K_M, 8,9 Go en Q8_0, 16 Go en FP16.*

3. Téléchargez et lancez la version choisie en écrivant l'étiquette complète :

```bash
ollama run qwen3:8b-q8_0
```

4. Vérifiez ce qui est installé : la ligne `quantization` de `ollama show` donne le format.

```bash
ollama show qwen3:8b-q8_0
```

![Terminal sombre : la commande ollama show gemma4:26b affiche notamment parameters 25.8B et quantization Q4_K_M.](https://quelleia.com/guides/quantification/terminal-show.webp)

*ollama show sur le mini-PC Linux de QUELLE IA, le 17 novembre 2026 : la ligne quantization dit quelle version est installée.*

### Dans LM Studio

1. Dans l'onglet Discover, cherchez le modèle.
2. Dans la liste des fichiers, comparez les versions `Q3_K_S`, `Q4_K_M`, `Q8_0`… LM Studio conseille 4 bits ou plus quand la machine le permet.
3. Téléchargez celle qui laisse de la marge à votre mémoire pour la conversation.

### Une règle simple

- Prenez **la version la plus précise qui tient** avec de la marge : `Q8_0` si la place le permet, `Q6_K` ou `Q5_K_M` ensuite.
- **`Q4_K_M`**, la version servie par défaut pour de nombreux modèles du catalogue d'Ollama, convient quand la mémoire est juste.
- Ne descendez **sous 4 bits** que pour faire entrer un modèle bien plus grand, en sachant que la perte grimpe vite.

Voici, pour une machine de 32 Go, les modèles les mieux classés qui y tiennent et la version qui entre, d'après l'édition de la semaine.

**Les meilleurs modèles pour une machine de 32 Go**

1. [Qwen 3.8 27B](https://quelleia.com/modeles/qwen-3-8-27b/) : score 83,1 (allégée à 4 bits, 18,6 Go)
2. [Gemma 4 31B IT](https://quelleia.com/modeles/gemma-4-31b-it/) : score 75,5 (allégée à 4 bits, 21,4 Go)
3. [Qwen3.6 27B](https://quelleia.com/modeles/qwen3-6-27b/) : score 75,5 (allégée à 4 bits, 19,2 Go)
4. [Muse Glimmer](https://quelleia.com/modeles/muse-glimmer/) : score 73,9 (allégée à 4 bits, 20,7 Go)
5. [Gemma 4 26B A4B](https://quelleia.com/modeles/gemma-4-26b-a4b/) : score 73,1 (allégée à 4 bits, 17,9 Go)

Mémoire utile retenue : 30 Go, celle des machines suivies de 32 Go. Score IA de l'édition du 16 novembre 2026, version la plus complète qui tient.
[Quel modèle sur ma machine](https://quelleia.com/local/)
[Les modèles qui tournent en local](https://quelleia.com/classement/locaux/)

## Quantifier aussi la mémoire de la conversation

La fenêtre de contexte occupe elle aussi de la mémoire, dans ce qu'on appelle le cache K/V. Ollama peut la quantifier avec la variable `OLLAMA_KV_CACHE_TYPE`, quand Flash Attention est actif :

- `f16`, le réglage par défaut, le plus précis ;
- `q8_0`, qui prend environ moitié moins de mémoire avec une perte très faible, d'après la documentation d'Ollama ;
- `q4_0`, environ le quart, avec une perte plus visible sur les longs contextes.

Le réglage vaut pour tous les modèles à la fois. Ollama prévient que certains modèles, comme ceux de la famille Qwen2, y sont plus sensibles que d'autres. Pour l'essayer sous Linux :

1. Tapez `sudo systemctl edit ollama`.
2. Sous `[Service]`, ajoutez la ligne `Environment="OLLAMA_KV_CACHE_TYPE=q8_0"`. Ollama active Flash Attention tout seul quand le matériel le permet ; `Environment="OLLAMA_FLASH_ATTENTION=1"` le force.
3. Enregistrez, puis `sudo systemctl daemon-reload` et `sudo systemctl restart ollama`.
4. Relancez le modèle et comparez la colonne `SIZE` de `ollama ps` avant et après, à contexte égal.

Sur Mac, la même variable se pose avec `launchctl setenv OLLAMA_KV_CACHE_TYPE q8_0`, puis on relance l'application.

## Pour aller plus loin

- [Quel modèle sur ma machine](https://quelleia.com/local/)
- [Les modèles qui tournent en local](https://quelleia.com/classement/locaux/)
- [Glossaire](https://quelleia.com/glossaire/)
- [Ollama](https://quelleia.com/logitheque/ollama/)
- [Lm studio](https://quelleia.com/logitheque/lm-studio/)
- [La vitesse d'un modèle local : débit mémoire et experts](https://quelleia.com/guides/vitesse-locale.md) (guide, nerd)
- [Quel modèle d'IA pour ma machine, de 8 à 128 Go](https://quelleia.com/guides/quel-modele-pour-ma-machine.md) (guide, amateur)
- [Sur mini lab AI](https://minilabai.com/guides/choisir-son-modele-local/) : un guide du même auteur, qui va plus loin

## Sources

- https://github.com/ggml-org/llama.cpp/blob/master/tools/quantize/README.md (lue le 17 novembre 2026)
- https://github.com/ggml-org/llama.cpp/blob/master/tools/quantize/quantize.cpp (lue le 17 novembre 2026)
- https://huggingface.co/docs/hub/gguf (lue le 17 novembre 2026)
- https://arxiv.org/abs/2411.02355 (lue le 17 novembre 2026)
- https://ollama.com/library/qwen3/tags (lue le 17 novembre 2026)
- https://docs.ollama.com/faq (lue le 17 novembre 2026)
- https://docs.ollama.com/cli (lue le 17 novembre 2026)
- https://lmstudio.ai/docs/app/basics/download-model (lue le 17 novembre 2026)
