Comprendre la quantification des modèles d'IA : des bits au GGUF

Voici quelques notes de travail sur la quantification, la technique qui permet à des modèles de plusieurs milliards de paramètres de tourner sur du matériel grand public plutôt que dans un centre de données.

1. Bits et octets : les bases

Un bit est la plus petite unité d'information : 0 ou 1, comme un interrupteur. Un octet vaut 8 bits, soit 256 combinaisons possibles.

1 bit   = 2 choix      = 2¹
4 bits  = 16 choix     = 2⁴
8 bits  = 256 choix    = 2⁸
16 bits = 65 536 choix = 2¹⁶

Pourquoi 2ⁿ ? Parce que chaque bit supplémentaire double le nombre de combinaisons. C'est le principe du questionnaire à choix multiples : 3 questions à 2 réponses possibles donnent 2 × 2 × 2 = 8 combinaisons.

Pour mémoire, les ordres de grandeur :

1 octet = 8 bits
1 Ko = 1 000 octets
1 Mo = 1 000 Ko
1 Go = 1 000 Mo

2. Les formats numériques utilisés en IA

Un modèle d'IA n'est rien d'autre que des milliards de nombres, appelés « poids ». Le format de stockage détermine à la fois la précision de chaque nombre et la place qu'il occupe.

FP, pour floating point, désigne un nombre à virgule (3,14 ; −2,71…). INT, pour integer, désigne un nombre entier, obtenu par arrondi.

FP16 et INT8/INT4 : deux logiques différentes

• FP16 réduit la précision — moins de décimales — mais conserve une étendue de valeurs considérable.
• INT8/INT4 réduit le nombre de valeurs disponibles : chaque nombre doit être ramené à une liste réduite et fixe, de 256 ou 16 valeurs par exemple.

L'effet sur la taille du modèle

Prenons un modèle de 13 milliards de paramètres, soit environ 26 Go en FP16 :

FP32 : 13 Md × 4 octets   = 52 Go
FP16 : 13 Md × 2 octets   = 26 Go
INT8 : 13 Md × 1 octet    = 13 Go
INT4 : 13 Md × 0,5 octet  = 6,5 Go

Chaque palier divise l'empreinte mémoire par deux, ou presque. C'est précisément ce qui rend possible l'exécution de grands modèles hors d'un centre de données.

3. Pourquoi INT8 donne 256 valeurs et INT4 seulement 16

Avec n bits valant chacun 0 ou 1, le nombre total de combinaisons est 2ⁿ.

INT4 = 2⁴ = 16 valeurs   (0000 à 1111)
INT8 = 2⁸ = 256 valeurs  (00000000 à 11111111)

Chaque bit supplémentaire double le nombre de combinaisons. D'où l'écart considérable entre 4 et 8 bits : on passe de 16 à 256, et non pas simplement du simple au double.

4. La quantification pas à pas

Quantifier, c'est arrondir des nombres existants pour qu'ils tiennent dans moins de bits.

Étape 1 — Mesurer l'étendue des poids d'origine

On relève les valeurs minimale et maximale du modèle, par exemple −5,2 et +8,7.

Étape 2 — Calculer le facteur d'échelle

facteur d'échelle = (max − min) / nombre de valeurs disponibles

Pour INT8 : (8,7 − (−5,2)) / 256 ≈ 0,055.

Étape 3 — Arrondir chaque nombre

nombre quantifié = ARRONDI(nombre d'origine / facteur d'échelle)

Par exemple : 3,14159265 / 0,055 ≈ 57,1 → 57.

Étape 4 — Enregistrer le résultat

Le nouveau modèle, plus léger, est prêt à être chargé.

Les deux grandes approches

La plupart des outils grand public s'appuient sur le PTQ : c'est le choix pragmatique lorsqu'on part de poids déjà entraînés par quelqu'un d'autre.

5. D'où viennent les poids à quantifier ?

Le point essentiel : personne ne recalcule les poids de zéro. Ils existent déjà, entraînés par l'organisation qui a conçu le modèle — Google, Meta, etc. — et stockés dans des fichiers .safetensors.

LE LABORATOIRE (des mois d'entraînement)
   Poids aléatoires → entraînement sur des milliards de tokens → poids finaux
   → enregistrés en BF16 dans des fichiers .safetensors
   → publiés sur Hugging Face

LES QUANTIFICATEURS (quelques heures de travail)
   1. Téléchargent les fichiers d'origine
   2. Ouvrent chaque fichier et lisent les nombres déjà entraînés
   3. Arrondissent chaque nombre au format visé (Q4, Q8…)
   4. Enregistrent en fichiers .gguf, ou dans un autre format quantifié
   → publiés sur Hugging Face

VOUS
   Téléchargez directement le fichier déjà quantifié
   → aucun calcul de votre côté, un simple téléchargement

Simplifiée à l'extrême, l'étape d'arrondi ressemble à ceci :

model = load_model("some-lab/some-model")  # already-trained weights
for layer_name, weight_tensor in model.named_parameters():
    min_val, max_val = weight_tensor.min(), weight_tensor.max()
    scale = (max_val - min_val) / 16       # 16 = possible values in INT4
    quantized_weight = round(weight_tensor / scale)
    save(layer_name, quantized_weight, scale)

6. Les outils et méthodes les plus courants

Déchiffrer un nom de fichier GGUF, par exemple Q4_K_M

Q4_K_M
│ │ │
│ │ └─ M = Medium (variante de qualité : S/M/L)
│ └─── K = « K-quant » : mélange les niveaux de précision selon l'importance des poids
└───── 4 = environ 4 bits par nombre, en moyenne

Le K-quant fait mieux qu'un arrondi uniforme : il conserve davantage de bits pour les poids qui pèsent le plus et comprime plus fortement les autres, dans le même esprit qu'AWQ.

7. Trois analogies pour retenir

• Quantifier, c'est comme compresser une photo : on perd un peu de détail, mais le fichier devient bien plus léger et se charge bien plus vite.
• Passer de FP32 à INT4, c'est comme résumer un livre : le manuscrit d'origine devient un résumé condensé, toujours lisible, simplement moins détaillé.
• Unsloth, AWQ ou GPTQ jouent le rôle de l'éditeur : ils prennent le « manuscrit », c'est-à-dire les poids d'origine du laboratoire, et en publient une version condensée, prête à l'emploi. Il ne reste plus qu'à télécharger le produit fini.