Guides IA · 11 min de lecture

Qu'est-ce que la quantification en IA ? Comment les modèles 4 bits et 8 bits économisent la mémoire

La quantification stocke les poids d'un modèle d'IA sur 4 ou 8 bits pour économiser la mémoire. Découvrez les compromis de précision et la place de GGUF.

Un réseau cristallin lumineux et lâche à gauche se resserre en un amas de blocs plus denses à droite, sur fond sombre, sans texte ni logo

La quantification en IA est une technique de compression qui stocke les poids d’un modèle, et parfois ses activations, sur moins de bits afin de réduire ses besoins en mémoire. En passant de poids sur 16 bits à une quantification sur 8 ou 4 bits, un modèle de 8B passe d’environ 16GB à environ 8GB ou 4–5GB pour les seuls poids, au prix d’une certaine perte de précision en échange d’une empreinte plus réduite.

Lorsque j’examine des fiches de modèles en vue d’un déploiement local, les mêmes étiquettes reviennent sans cesse : 8 bits, 4 bits, GPTQ, AWQ et GGUF. Chacune désigne une manière différente de représenter les nombres dans un réseau neuronal afin que le modèle tienne sur un seul GPU, un ordinateur portable ou une instance de serveur plus petite.

Comment la quantification d’un modèle réduit-elle la mémoire nécessaire ?

La quantification réduit la mémoire nécessaire en diminuant le nombre de bits attribués à chaque paramètre dans les matrices de poids du modèle. En novembre 2026, l’aperçu de la quantification de Hugging Face indique que les modèles sont généralement chargés en bf16, soit 2 octets par paramètre. Selon la règle indicative de Hugging Face pour les seuls poids, un modèle de 8B paramètres nécessite environ 16GB pour ses poids en bf16, environ 8GB en 8 bits et environ 4–5GB en 4 bits.

Cet exemple de 8B est une règle indicative pour les seuls poids, et non un budget VRAM complet pour l’inférence. La mémoire réellement nécessaire au service comprend aussi les activations, les frais de fonctionnement et le cache clé-valeur qui conserve l’historique de l’attention sur votre prompt et la sortie. Si vous prévoyez de servir de longs contextes, notre guide sur le cache KV explique pourquoi la mémoire augmente avec la longueur de la séquence.

D’un point de vue purement arithmétique, chaque réduction de la largeur en bits diminue le nombre brut d’octets nécessaires par paramètre :

Format de précision Stockage par paramètre (calcul) Empreinte relative des poids par rapport à BF16
FP32 4 octets 2x
FP16 / BF16 2 octets 1x
FP8 / INT8 1 octet 0.5x
FP4 / INT4 / 4 bits de type NVFP4 0.5 octet 0.25x (plus les frais du format)

Ces nombres d’octets décrivent un calcul brut de stockage, pas une mesure comparative du temps réel d’exécution ou de la qualité des sorties. Toutes choses égales par ailleurs, passer de BF16 à 8 bits divise par deux la mémoire des poids, tandis que passer de BF16 à 4 bits la réduit à environ un quart. La fourchette de 4–5GB pour un modèle de 8B tient compte des métadonnées de quantification et des frais du format. Comme l’indique Hugging Face, moins de bits entraînent une certaine perte de précision et chaque méthode de quantification propose un compromis différent entre mémoire, vitesse et précision.

Deux façons de charger les modèles quantifiés en pratique

Les checkpoints quantifiés entrent dans une chaîne d’inférence ou de fine-tuning selon deux procédures de chargement distinctes, suivant que la compression se produit à la volée ou à l’avance.

  1. Quantifier un checkpoint en pleine précision pendant son chargement. Dans Hugging Face Transformers, vous transmettez un objet de configuration de quantification à from_pretrained avec un checkpoint standard. Par exemple, la documentation officielle montre comment charger meta-llama/Llama-3.1-8B-Instruct en 4 bits en transmettant BitsAndBytesConfig(load_in_4bit=True, ...). La plupart des méthodes à la charge n’utilisent pas de données d’étalonnage ; GPTQ fait exception, car il s’étalonne sur un jeu de données pendant le chargement du modèle.
  2. Charger un checkpoint déjà quantifié. Lorsqu’un checkpoint a déjà été compressé et enregistré, vous le chargez sans transmettre de nouvelle configuration de quantification. Transformers lit les détails de quantification dans le fichier config.json du dépôt ou dans un fichier GGUF nommé. Les méthodes comme AWQ, AutoRound, AQLM, compressed-tensors et GGUF ne prennent en charge que cette procédure dans Transformers : vous partez d’un checkpoint quantifié au préalable avec la bibliothèque propre à la méthode. C’est ainsi que sont distribuées de nombreuses versions présentées dans les modèles à poids ouverts en 2026.

Méthodes de quantification courantes : bitsandbytes, GPTQ, AWQ et GGUF

Les méthodes courantes de quantification des modèles diffèrent par le moment où elles effectuent la compression, les largeurs en bits et les matériels ciblés qu’elles prennent en charge, ainsi que par leur destination : chaînes Transformers ou environnements d’exécution locaux autonomes.

Méthode / format Procédure dans Transformers Largeurs en bits / type numérique Matériel dans la documentation HF Point opérationnel clé
bitsandbytes Quantifier au chargement ou charger un modèle enregistré 4 bits et 8 bits CUDA, XPU, HPU, CPU Sans étalonnage ; prend en charge le fine-tuning
GPTQ Préquantifié ou étalonné au chargement 4 bits (int4 vers fp16 à la volée) CUDA, XPU, CPU Nécessite un jeu d’étalonnage ; utiliser GPT-QModel
AWQ Préquantifié uniquement 4 bits CUDA, XPU, CPU Préserve les poids importants grâce aux activations
GGUF Préquantifié uniquement (gguf_file) 1 bit à 8 bits CUDA, MPS, XPU, CPU Fichier unique ; standard dans llama.cpp et Ollama
NVFP4 / FP8 à granularité fine Quantifier au chargement (selon le matériel) Flottant 4 bits / 8 bits GPU NVIDIA (NVFP4 sur Blackwell) Représentation à virgule flottante

bitsandbytes

Le guide de sélection des méthodes de Hugging Face recommande bitsandbytes pour faire tenir un modèle dans moins de mémoire avec un minimum de configuration. Il quantifie en 4 ou 8 bits au chargement sans jeu d’étalonnage, fonctionne sur CUDA, XPU, HPU et CPU, et prend en charge l’enregistrement comme le fine-tuning. Selon la documentation bitsandbytes, le mode 8 bits utilise LLM.int8() et divise par deux la mémoire des poids. Le mode 4 bits permet QLoRA, qui comprime les poids en 4 bits tout en gardant le modèle entraînable grâce à l’ajout d’un petit ensemble de poids entraînables d’adaptation de faible rang (LoRA).

GPTQ

GPTQ est une méthode de quantification après entraînement qui comprime indépendamment chaque ligne d’une matrice de poids afin de minimiser l’erreur de reconstruction. Selon la documentation GPTQ de Hugging Face, les poids sont quantifiés en int4 puis restaurés en fp16 à la volée pendant l’inférence. Cela peut réduire la mémoire utilisée d’un facteur 4, car les poids int4 sont déquantifiés dans un noyau fusionné plutôt que dans la mémoire globale du GPU ; des largeurs en bits inférieures prennent aussi moins de temps à communiquer. La quantification GPTQ nécessite un jeu de données d’étalonnage et un tokenizer, comme dans GPTQConfig(bits=4, dataset="c4", tokenizer=tokenizer) dans la documentation. Transformers ne prend plus en charge AutoGPTQ et dirige les utilisateurs vers GPT-QModel.

AWQ

AWQ, pour Activation-aware Weight Quantization, vise à protéger le petit sous-ensemble de poids qui compte le plus pour la qualité des sorties. Comme l’explique la documentation AWQ de Hugging Face, AWQ préserve une petite fraction des poids importants pour les performances du LLM afin de comprimer un modèle en 4 bits avec une dégradation minimale des performances. Dans Transformers, AWQ est uniquement préquantifié et charge des checkpoints créés avec llm-awq ou autoawq.

GGUF

GGUF est un format à fichier unique qui regroupe les poids, la configuration et le tokenizer d’un modèle dans un seul fichier au lieu d’utiliser un fichier config.json distinct. C’est pourquoi Transformers demande un argument gguf_file explicite. Dans les outils locaux comme llama.cpp et Ollama, GGUF est le format des fichiers portant des étiquettes comme Q4_K_M et prend en charge les poids préquantifiés de 1 à 8 bits sur CUDA, MPS, XPU et CPU.

Une réserve importante concerne spécifiquement Transformers : Hugging Face indique que la plupart des modèles GGUF sont déquantifiés en pleine précision lors de leur chargement dans Transformers et utilisent autant de mémoire qu’un modèle non quantifié, à l’exception d’un cas limité utilisant MPS et des noyaux sur certains modèles Qwen3.5. Ce comportement appartient au chargeur GGUF de Transformers ; les environnements locaux comme llama.cpp et Ollama sont conçus pour exécuter directement les poids GGUF quantifiés.

Formats à virgule flottante de faible largeur : FP8, NVFP4 et MXFP8

La quantification sur peu de bits s’étend aussi aux formats à virgule flottante, qui diffèrent des formats entiers comme INT8 et INT4. Le guide de sélection de Hugging Face répertorie FP8 à granularité fine, MXFP4 et NVFP4, qui quantifie au chargement dans le format flottant 4 bits de NVIDIA sur les GPU Blackwell. Des dizaines d’autres techniques existent également, dont torchao, HQQ et compressed-tensors, toutes répertoriées dans le guide de sélection de Transformers.

Quelle différence entre quantification des seuls poids et quantification complète ?

La quantification des seuls poids comprime les matrices de paramètres stockées tout en laissant les activations et le cache KV en précision supérieure, sauf si ces éléments sont quantifiés séparément. De nombreuses chaînes d’inférence courantes en GGUF 4 bits ou à poids seuls conservent les poids sur peu de bits en mémoire et déquantifient ou calculent les multiplications matricielles dans un format plus large.

Pendant la génération de longs textes, les activations et le cache KV continuent de consommer de la RAM GPU ou système en plus des poids. Hugging Face documente la quantification du cache KV comme une étape d’optimisation distincte pour les longues séquences. L’architecture influence aussi la mémoire totale : même dans les architectures parcimonieuses décrites dans notre explication de Mixture of Experts, tous les experts routés et partagés doivent résider en mémoire, même si seule une fraction s’exécute par token.

En quoi la quantification après entraînement diffère-t-elle de l’entraînement natif sur peu de bits ?

La quantification après entraînement part d’un checkpoint haute précision terminé et le comprime ensuite, tandis que l’entraînement natif sur peu de bits entraîne et déploie directement le modèle dans des formats numériques de faible largeur. GPTQ, AWQ, la plupart des conversions GGUF et bitsandbytes au chargement relèvent de la première catégorie et acceptent une certaine erreur de conversion après le préentraînement et l’alignement.

L’entraînement natif sur peu de bits supprime cette étape de conversion après entraînement. Un exemple actuel est Inkling 2 Mini, publié par Thinking Machines Lab le 20 novembre 2026. Selon l’annonce officielle d’Inkling 2 Mini et sa fiche de modèle, ce modèle de 26.4B paramètres occupe environ 20GB en mémoire et a été entraîné en NVFP4 4 bits dans ses couches d’experts pour toutes les passes avant, du préentraînement à l’apprentissage par renforcement, ainsi qu’en MXFP8 8 bits pour les passes avant des quatre dernières couches.

Thinking Machines Lab indique que les poids d’Inkling 2 Mini sont déployés dans la même précision numérique que celle utilisée pour leur entraînement — 20 couches en NVFP4 et 4 en MXFP8 — et qu’il n’y a donc aucune perte de conversion due à la quantification. Cela signifie qu’aucune précision n’est perdue en convertissant après entraînement un checkpoint BF16 terminé en 4 bits ; ce n’est pas une comparaison avec un jumeau BF16 distinct. Les recommandations matérielles de l’équipe préconisent Apple silicon avec au moins 32GB de mémoire, des GPU avec au moins 32GB de VRAM ou un seul NVIDIA DGX Spark.

Quelle approche de quantification convient à votre flux de travail ?

Le choix dépend de votre environnement d’exécution, de votre matériel et de votre besoin éventuel de fine-tuning ou de simple inférence. Chaque méthode propose des compromis différents entre mémoire, vitesse et précision selon les tâches ; aucune largeur en bits ne convient donc à toutes les charges de travail.

  • Choisissez bitsandbytes pour charger un checkpoint existant en pleine précision en 4 ou 8 bits avec un minimum de configuration, ou pour effectuer du fine-tuning avec QLoRA.
  • Choisissez GPTQ ou AWQ pour obtenir un checkpoint 4 bits déjà étalonné ou tenant compte des activations, conçu pour l’inférence.
  • Choisissez GGUF pour un checkpoint portable en un seul fichier destiné à des environnements locaux comme llama.cpp ou Ollama.
  • Choisissez des checkpoints natifs sur peu de bits lorsqu’un développeur fournit des poids entraînés directement en NVFP4, FP8 ou MXFP8.

Vérifiez toujours la licence du modèle avant de convertir ou de redistribuer des poids quantifiés, et prévoyez une marge mémoire pour le cache KV et les frais d’exécution. Si votre objectif est de réduire les factures d’inférence cloud plutôt que de faire tenir les poids sur du matériel local, consultez les stratégies de prompts et de routage dans notre guide pour réduire les coûts des API d’IA.

FAQ

La quantification en 4 bits réduit-elle toujours sensiblement la qualité ?

Aucune règle unique ne prédit l’effet exact de la quantification en 4 bits sur la qualité pour tous les modèles et toutes les tâches. Selon la documentation de Hugging Face, moins de bits coûtent un peu de précision et chaque méthode propose un compromis différent entre mémoire, vitesse et précision. Des méthodes comme AWQ et GPTQ cherchent à limiter l’erreur grâce à la prise en compte des activations ou à l’étalonnage, tandis que la largeur en bits, l’architecture du modèle et la charge de travail influencent le résultat.

Pourquoi un modèle 8B en 4 bits nécessite-t-il plus de 4–5GB de VRAM au total ?

Le chiffre de 4–5GB pour un modèle 8B en 4 bits est une règle indicative de Hugging Face pour les seuls poids, pas un budget complet de service. L’exécution nécessite aussi de la mémoire pour les activations, les frais d’exécution et le cache KV qui grandit avec la longueur du prompt et de la génération. Quantifier les poids réduit l’empreinte statique du modèle, mais les longs contextes exigent toujours une planification mémoire distincte.

Quelle différence entre GGUF et GPTQ ou AWQ ?

GGUF est un format à fichier unique qui regroupe poids, configuration et tokenizer pour des environnements locaux comme llama.cpp et Ollama, et prend en charge les checkpoints préquantifiés de 1 à 8 bits. GPTQ et AWQ sont des méthodes de quantification en 4 bits généralement stockées dans des checkpoints sous forme de répertoire avec un fichier config.json ; GPTQ étalonne chaque ligne de matrice de poids et AWQ préserve les poids critiques en fonction des activations.

Charger un fichier GGUF dans Transformers économise-t-il de la mémoire ?

La plupart des fichiers GGUF n’économisent pas de mémoire lorsqu’ils sont chargés avec Hugging Face Transformers. Selon l’aperçu de la quantification de Hugging Face, la plupart des modèles GGUF sont déquantifiés en pleine précision au chargement dans Transformers et occupent autant de mémoire qu’un modèle non quantifié, hormis une exception limitée avec un noyau MPS sur certains modèles Qwen3.5. Les applications locales comme llama.cpp et Ollama évitent ce comportement de Transformers.

Qu’est-ce que NVFP4 par rapport à la quantification INT4 ?

NVFP4 est le format à virgule flottante 4 bits de NVIDIA pris en charge sur le matériel Blackwell, tandis qu’INT4 représente les poids sous forme d’entiers sur 4 bits. Les deux formats stockent chaque paramètre sur 0.5 octet et réduisent de façon similaire le stockage brut des poids à la quantification entière en 4 bits. Les formats flottants comme NVFP4 et MXFP8 8 bits peuvent aussi être utilisés directement pendant l’entraînement et le déploiement, comme pour Inkling 2 Mini de Thinking Machines Lab.

Sources

Écrit par

Chunyu Cai

Chunyu Cai est le directeur général de Lotook, LLC et un entrepreneur qui écrit sur les modèles d’IA, les agents et leur influence sur le travail au quotidien. Chunyu Cai est titulaire d’un master de l’établissement Imperial College London.