GGUF, GPTQ, AWQ : anatomie de trois façons de compresser un LLM

L’angle mort

Quand on compare des runtimes, on mesure des tokens par seconde. Quand on dimensionne une machine, on compte des gigaoctets. Nous avons consacré un dossier à chacune de ces deux questions, le comparatif des moteurs de service et le calcul de la VRAM nécessaire, et tous deux prennent le modèle quantifié comme un acquis : il tient dans tant de mémoire, il sort tant de tokens. Reste une question qui vient avant les deux et ne se lit ni en tokens par seconde ni en gigaoctets.

Prenez un modèle en poids flottants 16 bits. Pour le faire tourner ailleurs que sur un cluster, vous devez d’abord le passer en 4 bits. Là, trois grandes familles se présentent, et le choix ne se joue pas sur la taille du fichier, qui sera presque identique, ni sur la vitesse, qui dépendra surtout du noyau. Il se joue sur ce qui reste du modèle une fois compressé. Deux quantifications à 4 bits du même modèle, même empreinte, même classe de débit, ne gardent pas la même quantité d’intelligence, parce qu’elles n’attaquent pas de la même manière le seul problème qui compte en quantification quantification Réduction du nombre de bits codant chaque poids d'un modèle (de 16 bits vers 8, 4, voire moins). Elle divise l'empreinte mémoire d'autant, au prix d'une perte de précision contrôlée, sans changer le nombre de paramètres. Approfondir dans le glossaire : les valeurs aberrantes valeurs aberrantes Dans un LLM, une poignée de canaux dont les activations atteignent une magnitude démesurée, concentrées sur quelques dimensions. Ils portent une part disproportionnée de la qualité : les écraser sur une grille basse précision dégrade fortement le modèle, ce que toute quantification doit éviter. . Ce dossier démonte comment chacune s’y prend, parce que c’est cette construction, pas un tableau de scores, qui décide de ce que vous perdez.

Un format n’est pas un algorithme

Avant les mécanismes, une distinction qui sert de grille de lecture à tout le reste, et qu’on confond presque toujours parce que les trois noms circulent au même niveau.

GGUF GGUF GPT-Generated Unified Format. Format de fichier de llama.cpp qui stocke dans un seul fichier les tenseurs, leurs types de quantification, le vocabulaire et les métadonnées du modèle. Sa structure alignée permet de le lire par mmap : le modèle « démarre » en une fraction de seconde. Approfondir dans le glossaire est un conteneur. Un fichier unique où le type de quantification est une métadonnée inscrite tenseur par tenseur, à côté des poids, du vocabulaire et du gabarit de conversation. Rien n’y impose un schéma unique : un même fichier peut ranger une couche en 4 bits et sa voisine en 6, exactement comme un conteneur vidéo laisse chaque piste déclarer son propre codec. La déquantification est assurée par un noyau générique de llama.cpp qui lit ces métadonnées et sait décoder chaque type à la volée.

GPTQ GPTQ Algorithme de quantification post-entraînement des poids (3 à 4 bits). Il quantifie les poids un à un et compense l'erreur sur les poids restants via l'inverse de la Hessienne de la couche, pour préserver la sortie. Nécessite un corpus de calibration ; sa sortie se sert avec des noyaux comme Marlin. et AWQ AWQ Activation-aware Weight Quantization. Quantification 4 bits qui protège les ~1 % de canaux les plus importants, repérés par la magnitude des activations et non des poids, en les mettant à l'échelle avant l'arrondi. Sans reconstruction ni rétropropagation, donc robuste hors du domaine de calibration. sont des algorithmes. Leur sortie n’est pas un format à eux : ce sont des poids quantifiés rangés dans un fichier safetensors ordinaire, produits par une procédure qui a décidé, poids par poids, quelle valeur entière écrire. Le format de rangement, lui, est dicté en aval par le noyau CUDA qui exécutera ces poids.

Cette asymétrie n’est pas un détail de vocabulaire. Elle explique pourquoi GGUF prolifère en variantes et pourquoi GPTQ et AWQ convergent, pourquoi on ne charge pas un GGUF dans vLLM sans le payer cher, et pourquoi le premier règne sur le local quand les seconds règnent sur le serveur. Nous y reviendrons, mais gardez la formule : le format décrit un rangement, l’algorithme décrit une décision.

Le socle commun : quantifier, et le vrai problème

Quantifier un poids, c’est le ramener d’un flottant à un petit entier accompagné d’un facteur d’échelle : w ≈ échelle × q, où q tient sur 4 bits. Les trois familles le font par groupe de poids, typiquement 128 pour GPTQ et AWQ, 32 ou 256 pour GGUF, et jamais avec une échelle unique pour toute la matrice. La raison est mécanique : une seule échelle globale doit couvrir toute la dynamique de la matrice, donc s’étirer pour accommoder quelques poids extrêmes, ce qui écrase la résolution de tous les poids ordinaires. Une échelle locale par groupe recolle la grille au plus près de chaque paquet de valeurs, pour un surcoût de quelques bits.

Point crucial pour la suite : la déconversion vers le flottant n’a pas lieu à l’avance, elle se fait dans le noyau de calcul, juste avant la multiplication. Le décodage autorégressif d’un LLM est limité par la bande passante mémoire, pas par le calcul brut : sur une carte Ampere, le silicium peut faire cent à deux cents opérations flottantes dans le temps qu’il met à lire un octet. Lire des poids sur 4 bits au lieu de 16, puis les déquantifier sur la puce, c’est donc lire quatre fois moins de mémoire pour à peine plus de calcul. C’est ce qui rend la quantification rentable, et c’est aussi ce qui soude un fichier à un noyau, on y viendra.

Reste le problème central, celui que chaque méthode résout à sa façon. Dans un LLM, à partir de quelques milliards de paramètres, apparaissent des valeurs aberrantes : une poignée de canaux dont les activations ont une magnitude démesurée, jusqu’à cent cinquante mille par séquence sur un modèle de 13 milliards, mais concentrées sur moins d’une dizaine de dimensions. Ces canaux portent une part disproportionnée de la qualité. Les écraser sur une grille 4 bits calibrée pour les valeurs ordinaires détruit le modèle. Toute la quantification post-entraînement se résume à une question : comment ne pas sacrifier ces quelques valeurs qui comptent.

GPTQ : redistribuer l’erreur par la courbure

La première réponse remonte à une idée des années 1990 sur l’élagage des réseaux, la chirurgie cérébrale optimale (Optimal Brain Surgeon), reprise pour la quantification sous le nom d’OBQ puis rendue traitable à l’échelle des LLM par GPTQ. L’intuition est la suivante : quand vous forcez un poids sur la grille, vous introduisez une erreur, mais vous pouvez compenser cette erreur en ajustant les poids pas encore quantifiés, de sorte que la sortie de la couche reste la plus proche possible de l’originale. On ne cherche pas à préserver les poids un à un, on cherche à préserver ce qu’ils produisent.

Formellement, on minimise l’écart entre la sortie en pleine précision et la sortie quantifiée, ||WX − ŴX||², où X est un jeu d’activations de calibration. Cette perte est quadratique en les poids, et la quantité qui gouverne sa géométrie est sa Hessienne Hessienne Matrice des dérivées secondes d'une fonction, ici la courbure de l'erreur de sortie d'une couche par rapport à ses poids. Elle encode la sensibilité de la sortie à chaque poids et les corrélations entre poids ; son inverse indique comment redistribuer l'erreur de quantification. , sa matrice de courbure, qui vaut ici H = 2·X·Xᵀ. Il faut prendre un instant sur cet objet, parce que c’est lui qui fait tout le travail. La courbure mesure à quel point la sortie est sensible à une perturbation de chaque poids, et surtout comment les poids sont couplés entre eux à travers les activations qu’ils partagent : deux canaux d’entrée corrélés dans les données de calibration apparaissent liés dans H. Son inverse, H⁻¹, contient donc la recette de redistribution : quand on quantifie un poids, H⁻¹ indique dans quelle direction, et de combien, corriger les poids restants pour annuler au mieux l’effet sur la sortie.

La règle de mise à jour le dit en une ligne : après avoir quantifié le poids q, on propage sur les autres une correction δ = −(erreur sur q) / [H⁻¹]_qq × H⁻¹_{:,q}. Le dénominateur [H⁻¹]_qq normalise par la courbure locale du poids qu’on vient de figer ; le vecteur H⁻¹_{:,q} donne la direction de report. On comprend au passage pourquoi la calibration est indispensable : sans un jeu d’activations réelles X, la Hessienne H = X·Xᵀ n’existe pas, et on ne sait ni quels poids sont sensibles ni comment ils se compensent.

Le prix de l’exactitude serait prohibitif : quantifier un modèle de 175 milliards de paramètres par la méthode exacte prendrait des mois. GPTQ le ramène à quelques heures sur une seule carte par trois compromis. Il quantifie les colonnes dans un ordre fixe et partagé par toutes les lignes de la matrice, ce qui permet de ne factoriser H qu’une fois au lieu d’une fois par ligne, et gagne trois ordres de grandeur. Il précalcule H⁻¹ par une décomposition de Cholesky, plus stable numériquement. Et il ajoute un amortissement sur la diagonale, H⁻¹ = (2·X·Xᵀ + λI)⁻¹ avec λ à environ 1 % de la diagonale moyenne, pour garder la matrice inversible. Le corpus de calibration tient dans 128 segments de 2048 tokens tirés de données génériques, choisis justement pour ne rien contenir de spécifique à une tâche. Ce choix a un revers, que l’approche suivante prend pour cible : GPTQ ajuste sa reconstruction sur ce corpus, et peut donc s’y surajuster.

AWQ : protéger les canaux que trahissent leurs activations

AWQ part d’une observation empirique brutale. Si vous gardez en pleine précision seulement 1 % des poids d’un modèle, bien choisis, la dégradation à 3 bits s’effondre : sur un modèle de 6,7 milliards de paramètres, la perplexité retombe de 43,2 à 13,0. Tout est dans « bien choisis ». Le geste contre-intuitif d’AWQ, c’est que ces canaux saillants ne se repèrent pas à la magnitude des poids, mais à celle des activations qui les traversent. La logique est directe : un poids ne compte que par ce qu’il produit, et un poids qui multiplie systématiquement des activations de forte magnitude pèse lourd dans la sortie, donc son erreur de quantification est amplifiée d’autant. Sélectionner les canaux par la magnitude des poids, ou au hasard, n’aide presque pas ; les sélectionner par les activations, si.

Garder 1 % des poids en flottant poserait un problème matériel : un mélange de précisions au sein d’une même matrice est pénible à servir efficacement. AWQ contourne l’obstacle sans jamais sortir du 4 bits uniforme, par une identité simple. Multiplier un canal de poids saillant par un facteur s, et diviser l’activation correspondante par le même s, laisse le produit WX inchangé : WX = (W·diag(s)) · (diag(s)⁻¹·X). Mais un poids agrandi avant quantification tombe plus finement sur la grille, donc son erreur relative diminue. On a protégé le canal saillant sans le sortir du format, en déplaçant la difficulté vers l’activation, qui l’encaisse mieux. Le facteur s se déduit de la magnitude d’activation par canal, réglé par un seul exposant α qu’une recherche sur grille d’une vingtaine de valeurs suffit à fixer ; au-delà d’un certain point, agrandir davantage les canaux saillants dégrade les autres, et l’optimum se situe autour de s = 2.

Ce qui distingue AWQ, c’est ce qu’il ne fait pas. Pas de rétropropagation, pas de reconstruction séquentielle, pas de Hessienne : une mise à l’échelle en forme close suivie d’un simple arrondi au plus proche. Il en tire deux propriétés. Il est peu coûteux à produire. Et comme il ne reconstruit rien sur le corpus de calibration, il ne s’y surajuste pas : quand on change la distribution de calibration, sa perplexité ne bouge que de 0,5 à 0,6 point, là où la méthode à compensation d’erreur dérive de 2,3 à 4,9. Cette robustesse hors-domaine est son vrai avantage, et il tient à sa simplicité. Le prix de cette simplicité, c’est qu’AWQ n’expose presque aucun bouton : un point de fonctionnement, 4 bits, groupe de 128, et l’exposant α. Retenez-le, il répond à moitié à la question des variantes.

GGUF : un menu de recettes de blocs

Passons au conteneur, et à sa profusion. Un fichier GGUF range les poids par blocs, et c’est dans la structure de ces blocs que tout se joue. Les types historiques prennent des blocs de 32 poids avec une échelle flottante partagée : Q4_0 est symétrique, w = échelle × q ; Q4_1 ajoute un décalage par bloc pour les distributions asymétriques, w = échelle × q + minimum. Simple, mais l’échelle coûte cher rapportée à 32 poids.

L’invention qui a fait décoller GGUF pour l’inférence locale, ce sont les k-quants, apparus mi-2023. Le principe tient dans une quantification des échelles elles-mêmes. On regroupe les poids en super-blocs de 256, subdivisés en sous-blocs, et l’échelle de chaque sous-bloc n’est plus stockée en flottant : elle est elle-même quantifiée sur 4 à 8 bits, puis remise à l’échelle par un unique facteur flottant valable pour tout le super-bloc. Le calcul qui justifie ce double étage vaut d’être fait. Une échelle flottante 16 bits pour un sous-bloc de 16 poids coûterait à elle seule un bit par poids, rien qu’en métadonnées. En quantifiant ces échelles et en n’en gardant qu’une en flottant par super-bloc de 256, ce surcoût tombe à une fraction de bit. C’est exactement ce qui permet à Q2_K de tenir à 2,56 bits par poids sans s’effondrer, ou à Q4_K d’afficher 4,5 bits effectifs là où un 4 bits naïf plus ses échelles en coûterait davantage.

Vient alors le vrai cœur de la prolifération : la précision mixte par tenseur. Un fichier étiqueté Q4_K_M n’est pas uniformément en Q4_K. Une fonction de llama.cpp choisit un type par tenseur selon son rôle et sa position dans le réseau. Les tenseurs jugés sensibles, les projections de valeurs de l’attention et les descentes de couches feed-forward, sont promus en Q6_K ; les autres restent en Q4_K. La sélection des couches à promouvoir suit une heuristique explicite, lisible dans le code : les premières et dernières couches, plus une couche sur trois au milieu, ce qui promeut environ la moitié des tenseurs concernés. Les suffixes _S, _M, _L ne sont rien d’autre que trois réglages d’agressivité de cette promotion, du plus économe au plus généreux. Chaque combinaison de type de bloc et de politique de promotion est un point supplémentaire sur la courbe taille-qualité, et c’est là toute la réponse : un « Q » de plus, c’est une recette de plus, pas un algorithme de plus.

Un dernier étage descend encore plus bas, les i-quants. Sous 3 bits, l’échelle par bloc ne suffit plus, et GGUF passe à une quantification par dictionnaire : au lieu de stocker une valeur par poids, on stocke un index vers un vecteur pré-calculé de plusieurs poids, piochés sur un réseau régulier de points bien répartis dans l’espace, dans la lignée des travaux QuIP# sur le réseau E8. Là, la calibration redevient nécessaire, et GGUF l’introduit par une matrice d’importance. Plutôt que de minimiser une erreur de reconstruction uniforme, on la pondère par les statistiques d’activation collectées sur un texte de calibration, <activation²> par colonne, ce qui revient à dire au quantificateur quels poids il a le droit de malmener et lesquels il doit préserver. Sous 3 bits, cette matrice n’est plus optionnelle : sans elle, les types IQ2 produisent, selon les mots de leur auteur, du bruit.

Critère	GGUF	GPTQ	AWQ
Nature	conteneur (type par tenseur)	algorithme (poids en safetensors)	algorithme (poids en safetensors)
Unité de base	super-bloc de 256 (k-quants)	groupe de 128	groupe de 128
Attaque des aberrants	précision mixte par tenseur	report d'erreur (Hessienne)	mise à l'échelle par activation
Calibration	optionnelle (imatrix, requise sous 3 bits)	requise (128 × 2048 tokens)	requise (magnitudes d'activation)
Noyau, runtime	ggml générique ; llama.cpp, Ollama, LM Studio	Marlin, Machete, exllama ; vLLM, TGI, SGLang	Marlin, exllama ; vLLM, SGLang
Cible	grand public, CPU et GPU, memory-bound	GPU serveur	GPU serveur, on-device

Pourquoi le zoo d’un côté, la poignée de l’autre

On peut maintenant répondre en entier à la question de départ. GGUF prolifère parce qu’ajouter une variante y coûte presque rien : le type étant une métadonnée par tenseur décodée par un noyau générique, une nouvelle recette n’est qu’une nouvelle politique de blocs et de promotion, qu’un contributeur propose par une pull request. La culture du projet, tournée vers l’inférence à la marge sur du matériel grand public hétérogène et limité par la mémoire, valorise justement cette granularité : chaque demi-bit gagné compte quand on cherche à faire tenir un modèle dans la RAM d’un portable, et multiplier les points sur la frontière taille-qualité est un service rendu, pas une dette. Son auteur le dit sans détour : plus de quants, c’est un contrôle plus fin du compromis taille contre qualité, au prix du code à maintenir.

GPTQ et AWQ vivent dans l’économie inverse. Leur vitesse ne vient pas de l’algorithme mais du noyau qui exécute les poids : Marlin Marlin Noyau CUDA de multiplication matricielle mixte 4 bits par 16 bits (IST Austria), taillé pour approcher la limite de bande passante mémoire sur GPU Ampere et au-delà. Il exécute les poids quantifiés GPTQ/AWQ ; son successeur Machete vise les GPU Hopper. sur cartes Ampere et Ada, Machete sur Hopper, taillés pour approcher la limite de bande passante. Ces noyaux sont écrits à la main pour une disposition mémoire précise, un empaquetage d’entiers et un rangement d’échelles donnés. Ajouter une variante, ce n’est pas ajouter une recette, c’est écrire un nouveau noyau CUDA hautement optimisé, un investissement qui ne se rentabilise que sur GPU de datacenter. L’écosystème converge donc sur un point de fonctionnement dominant, 4 bits en groupe de 128, servi vite. AWQ pousse la logique à l’extrême : sa valeur tient dans un unique 4 bits robuste, il n’a aucune raison d’en exposer d’autres.

Cette même soudure entre format et noyau explique qu’on ne mélange pas les deux mondes. Un fichier quantifié est rangé pour le noyau qui l’attend ; un autre noyau doit d’abord le repacker. vLLM sait techniquement charger du GGUF, mais il doit en traduire la disposition à l’exécution, et le résultat est sans appel : sur le même banc, un GGUF y tourne à 93 tokens par seconde quand le format natif en délivre 461. Le mainteneur de vLLM chiffre autrement le coût de ce grand écart : six mille lignes de noyaux CUDA spécifiques à GGUF, pour un usage de l’ordre de 0,1 % de sa base. À l’inverse, un même modèle AWQ passe de 68 à 741 tokens par seconde selon qu’on le sert avec le noyau naïf ou avec Marlin. Le format ne décide pas seulement de la qualité : il décide de qui saura le faire courir.

Ce que la calibration fait à votre modèle, et à vos comparaisons

Reste à trancher la question que tout le monde pose : lequel garde le mieux le modèle ? La réponse honnête est qu’il n’y a pas de vainqueur universel à 4 bits, et que la manière dont on l’a longtemps cru est instructive. L’idée reçue « AWQ est meilleur que GPTQ » a été réfutée frontalement par une étude à plus de 500 000 évaluations sur la famille Llama-3.1 : à réglage égal, les deux se tiennent sur les tests académiques, et GPTQ passe même devant sur les tâches réelles comme le code, à condition de le régler correctement. La croyance venait de comparaisons où GPTQ était mal paramétré. Ce que garde AWQ, c’est ce que sa construction lui donne et rien de plus : la robustesse quand la distribution d’usage s’éloigne de la calibration. GGUF, de son côté, tire de sa matrice d’importance un gain net sous 3 bits et marginal au-dessus de Q4_K_M. Trois constructions, trois régimes où chacune brille, aucune qui domine partout.

L’horizon : sous la frontière du flottant natif

Tout ce que nous venons de décrire quantifie les poids et laisse les activations en 16 bits. C’est un choix, et il est en train d’être contesté par le haut. Le datacenter migre vers des formats flottants basse précision que le silicium sait désormais calculer nativement, le NVFP4 et le MXFP4 des cartes Blackwell, dont nous avons détaillé la mécanique dans notre dossier sur les précisions FP8 et FP4. Là où GPTQ, AWQ et GGUF sont un étage logiciel qui range des entiers pour un matériel qui ne connaît que le flottant 16 bits, le FP4 FP4 Format à virgule flottante 4 bits, frontière 2026 de l'inférence à haut débit. Quatre fois moins de mémoire que le FP16, mais une portée dynamique très étroite : ne tient qu'avec un scaling fin via formats à blocs (MXFP4, NVFP4). Approfondir dans le glossaire natif calcule directement dans le format compressé. Sur ce terrain, le trio ressemble déjà au vieux monde.

Il y a pourtant une raison précise pour laquelle il ne va pas disparaître du local de sitôt, et elle est matérielle. Le FP4 natif n’est pleinement exploitable que sur le Blackwell de datacenter. Le Blackwell grand public, une RTX 5090 par exemple, retombe sur un chemin qui décompresse les poids vers un noyau entier à la Marlin : il gagne la mémoire, pas le débit. Tant que le silicium sous les bureaux n’accélérera pas le FP4 pour de bon, l’INT4 post-entraînement restera le format du local, porté par deux avantages que le datacenter dédaigne : un fichier unique à télécharger, et aucune calibration lourde à faire tourner.

Autour du trio, enfin, une génération de méthodes déplace les lignes sur des axes qu’il n’occupe pas. Les rotations de Hadamard, QuaRot et SpinQuant, dispersent les valeurs aberrantes avant quantification et rendent possible le 4 bits sur les activations aussi, pas seulement les poids. Les quantifications par treillis, QTIP et son implémentation EXL3, repoussent la frontière sous 4 bits, jusqu’à des modèles encore cohérents à 1,6 bit par poids. HQQ supprime la calibration. Le QAT QAT Quantization-Aware Training. Plutôt que de comprimer un modèle déjà entraîné (et d'en subir la perte de précision), on le réentraîne brièvement en simulant la quantification, pour qu'il apprenne à vivre en basse précision (souvent int4). Réduit fortement la dégradation par rapport à une quantification post-entraînement naïve. agit en amont, à l’entraînement, et Google livre déjà des GGUF entraînés ainsi pour Gemma. Aucune ne remplace le trio ; elles s’y greffent, réutilisant ses briques, la rotation avant GPTQ, le report d’erreur dans EXL3.

La vraie question que ce dossier laisse ouverte n’est donc pas « lequel choisir aujourd’hui », mais ce qui survivra quand le matériel grand public saura enfin calculer le flottant 4 bits nativement. Le point de fonctionnement des algorithmes serveur pourrait alors fondre dans le format natif. Mais la distinction qui a structuré tout ce texte, un conteneur qui range des bits d’un côté, un algorithme soudé à son noyau de l’autre, elle, ne dépend d’aucune génération de silicium. Elle décrira encore le partage entre celui qu’on télécharge en un fichier et celui qu’on sert derrière une API, longtemps après que le 4 bits d’aujourd’hui aura vieilli.

Sources et méthode

Gel rédactionnel : 11 juillet 2026. Étiquettes : fait vérifié (source primaire), estimation crédible (analyse tierce cohérente), hypothèse (raisonnement assumé). Ce dossier documente la construction des formats, pas un comparatif de scores : chaque chiffre de qualité est un instantané dépendant du modèle, du banc et du noyau.

GPTQ et la compensation par la Hessienne

• Fait : GPTQ, Frantar et al., arXiv 2210.17323 (ICLR 2023) : objectif ||WX−ŴX||², Hessienne H = 2XXᵀ (verbatim Section 3), règle de mise à jour OBS/OBQ, ordre fixe partagé (« trois ordres de grandeur »), Cholesky, amortissement (2XXᵀ+λI)⁻¹, calibration 128 × 2048 tokens de C4, 175 Md en ~4 h-GPU. Lignée OBS : Hassibi & Stork, NeurIPS 1992.
• Fait : damping λ ≈ 1 % de la diagonale moyenne, act-order/desc_act, defaults d’implémentation (GPTQModel, wrapper HF) : docs Transformers/GPTQModel, consultées le 11 juillet 2026. Outillage 2026 : AutoGPTQ archivé le 11 avril 2025, successeur GPTQModel.

AWQ et la mise à l’échelle par activation

• Fait : AWQ, Lin et al., arXiv 2306.00978 (MLSys 2024) : 0,1 à 1 % de canaux saillants, sélection par la magnitude d’activation (PPL 43,2 → 13,0), invariance WX=(W·diag(s))(diag(s)⁻¹X), recherche sur grille de 20, optimum s≈2. Robustesse hors-domaine +0,5 à 0,6 PPL contre +2,3 à 4,9 pour GPTQ (Figure 6). Pas de rétropropagation ni de reconstruction (verbatim). AutoAWQ archivé le 11 mai 2025, repris par llm-compressor.

GGUF, k-quants, i-quants

• Fait : format conteneur, type par tenseur, alignement 32 octets pour mmap : spec ggml (github.com/ggml-org/ggml, gguf.md).
• Fait : quants legacy (blocs de 32, Q4_0 symétrique / Q4_1 affine) et k-quants (super-blocs de 256, échelles à deux niveaux, Q2_K 2,56 bpw à Q6_K 6,56 bpw) : PR #1684 d’ikawrakow (5 juin 2023), structures et static_assert de ggml-common.h.
• Fait : précision mixte par tenseur, heuristique use_more_bits (premières et dernières couches, une sur trois), promotion attn_v et ffn_down en Q6_K pour Q4_K_M : src/llama-quant.cpp (verbatim).
• Fait : i-quants (codebook, réseau E8, lignée QuIP# arXiv 2402.04396) et matrice d’importance pondérant l’erreur par <activation²>, rendue obligatoire sous 3 bits : PR #4773, #4861, #4897. Justification de la prolifération (« contrôle plus fin du compromis taille-qualité », cible edge) : Discussion #5063.

Fidélité, noyaux, verrouillage

• Fait : pas de vainqueur universel, réfutation de « AWQ meilleur que GPTQ » : Kurtic et al., « Give Me BF16 or Give Me Death », arXiv 2411.02355 (ACL 2025), plus de 500 000 évaluations sur Llama-3.1.
• Fait : noyaux Marlin (arXiv 2408.11743, ~4× jusqu’à batch 16-32) et Machete (Hopper) ; coût de maintenance GGUF dans vLLM (RFC #39583, ~6000 lignes CUDA, ~0,1 % d’usage).
• Estimation : AWQ 68 → 741 tok/s selon le noyau, GGUF 93 vs 461 tok/s dans vLLM : banc tiers (Qwen2.5-32B, billet de blog non relu), cité avec son périmètre.

Valeurs aberrantes et horizon

• Fait : outliers émergents (magnitude ≥ 6, à partir de ~6,7 Md de paramètres) : LLM.int8(), arXiv 2208.07339. SmoothQuant, arXiv 2211.10438.
• Fait : FP natif Blackwell (NVFP4 blocs de 16, MXFP4 blocs de 32) : voir notre dossier FP8/FP4. Hypothèse étayée : Blackwell grand public (SM120) en fallback Marlin weight-only, issues vLLM #30135 et #31085 (décembre 2025).
• Fait : QuaRot (arXiv 2404.00456), SpinQuant (arXiv 2405.16406), QTIP (arXiv 2406.11235) et EXL3 (exllamav3), HQQ (Mobius Labs), QAT Gemma 3 (Google, avril 2025).