Aller au contenu
EN 4 QUESTIONSTrouver mon modèle
IA locale · guide expert · 14 min de lecture

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

La quantification range chaque paramètre d'un modèle sur 8, 4 bits ou moins au lieu de 16, ce qui divise sa taille et accélère l'écriture. Ce guide explique le principe, lit les noms des formats et chiffre la perte de précision d'après les mesures publiées.

Illustration du thème IA locale

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.

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).

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.
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.
  1. Téléchargez et lancez la version choisie en écrivant l’étiquette complète :
ollama run qwen3:8b-q8_0
  1. Vérifiez ce qui est installé : la ligne quantization de ollama show donne le format.
ollama show qwen3:8b-q8_0
Terminal sombre : la commande ollama show gemma4:26b affiche notamment parameters 25.8B et quantization Q4_K_M.
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 27Ballégée à 4 bits, 18,6 Goscore 83,1
  2. Gemma 4 31B ITallégée à 4 bits, 21,4 Goscore 75,5
  3. Qwen3.6 27Ballégée à 4 bits, 19,2 Goscore 75,5
  4. Muse Glimmerallégée à 4 bits, 20,7 Goscore 73,9
  5. Gemma 4 26B A4Ballégée à 4 bits, 17,9 Goscore 73,1

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 →Les modèles qui tournent en local →

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

Sur mini lab AI, un guide du même auteur reprend ce sujet pour monter son atelier d'IA à la maison.

Tous les guides →

Sources

  1. github.com, lue le
  2. github.com, lue le
  3. huggingface.co, lue le
  4. arxiv.org, lue le
  5. ollama.com, lue le
  6. docs.ollama.com, lue le
  7. docs.ollama.com, lue le
  8. lmstudio.ai, lue le