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

Voici des notes d'apprentissage sur la quantification — la technique qui permet à des modèles d'IA de plusieurs milliards de paramètres de fonctionner 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 = 8 bits regroupés = 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ⁿ ? Chaque bit supplémentaire double le nombre de combinaisons possibles — comme un menu à choix multiples : 3 questions avec 2 options chacune donnent 2×2×2 = 8 combinaisons.

Tailles de mémoire, pour référence :

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

2. Les formats de nombres utilisés en IA

Un modèle d'IA n'est en réalité que des milliards de nombres, appelés « poids ». Le format dans lequel on les stocke détermine à la fois la précision de chaque nombre et l'espace qu'il occupe.

FP = floating point (virgule flottante) — un nombre avec une virgule décimale (3,14, -2,71...). INT = integer (entier) — un nombre entier, obtenu par arrondi.

FP16 vs INT8/INT4 — pas la même logique

• FP16 réduit la précision (moins de décimales) mais conserve une gamme de valeurs possibles énorme.
• INT8/INT4 réduit le nombre de valeurs possibles — chaque nombre doit être forcé dans une liste petite et fixe (disons 256 ou 16 valeurs).

Impact concret sur la taille du modèle

Pour un modèle illustratif de 13 milliards de paramètres (≈26 Go en FP16) :

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

Chaque palier vers le bas divise approximativement l'empreinte par deux — ce qui explique exactement pourquoi la quantification est ce qui rend possible l'exécution de grands modèles en dehors d'un centre de données.

3. Pourquoi INT8 = 256 valeurs, INT4 = 16 valeurs

Avec n bits, chacun valant 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 possibles — c'est pourquoi l'écart entre 4 et 8 bits est énorme (16 → 256, et non pas simplement « le double »).

4. Le processus de quantification, étape par étape

Quantifier, c'est arrondir des nombres qui existent déjà pour qu'ils tiennent dans moins de bits.

Étape 1 — Mesurer la plage des poids d'origine

Regarder les valeurs minimale et maximale dans le modèle (par ex., -5,2 à +8,7).

Étape 2 — Calculer le facteur d'échelle

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

Exemple pour INT8 : (8,7 - (-5,2)) / 256 ≈ 0,055

Étape 3 — Arrondir chaque nombre

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

Exemple : 3,14159265 / 0,055 ≈ 57,1 → 57

Étape 4 — Enregistrer le résultat

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

Les deux approches principales

La plupart des outils grand public utilisent le PTQ — c'est le choix par défaut pragmatique quand on part des poids déjà entraînés par quelqu'un d'autre.

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

Le point clé : personne ne calcule les poids depuis zéro. Ils existent déjà, entraînés par l'organisation qui a construit 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 sous forme de fichiers .safetensors
   → publiés sur Hugging Face

LES QUANTIFICATEURS (quelques heures de travail)
   1. Téléchargent les fichiers originaux
   2. Ouvrent chaque fichier, lisent les nombres déjà entraînés
   3. Arrondissent chaque nombre au format cible (Q4, Q8...)
   4. Enregistrent sous forme de fichiers .gguf (ou 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é, juste un téléchargement

En code simplifié, l'étape d'arrondi proprement dite 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. Outils et méthodes de quantification courants

Décoder le nom des fichiers GGUF (par ex. 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 = ~4 bits par nombre en moyenne

Le K-quant est plus intelligent qu'un arrondi uniforme : il conserve plus de bits pour les poids qui comptent le plus et compresse davantage le reste — dans un esprit similaire à AWQ.

7. Analogies qui aident à retenir

• La quantification, c'est comme compresser une photo : on perd un peu de détail, mais le fichier est bien plus petit et se charge bien plus vite.
• FP32 → INT4, c'est comme résumer un livre : le manuscrit original (FP32) devient un résumé condensé (INT4) — toujours lisible, juste moins détaillé.
• Unsloth/AWQ/GPTQ agissent comme un éditeur : ils prennent le « manuscrit » (les poids originaux d'un laboratoire) et publient une version condensée, prête à l'emploi. Il ne reste plus qu'à télécharger le résultat fini.