🤖 machine learning

CubicQuant: Parametric Non-Uniform Codebooks for High-Throughput LLM Inference with 1-8-Bit Weights

CubicQuant introduit un format scalaire non uniforme paramétrique qui associe des codes de magnitude espacés uniformément à des niveaux de reconstruction adaptatifs via une courbe cubique monotone, permettant une inférence LLM en 1-8 bits efficace avec une erreur de reconstruction réduite par rapport aux quantifications entières uniformes et aux flottants à précision finie tout en maintenant une exécutabilité directe sur GPU.

Auteurs originaux : Xuetian Gao

Publié 2026-08-10

📖 9 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Xuetian Gao

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous essayiez de faire tenir une bibliothèque massive de livres dans un petit sac à dos. Dans le monde de l'intelligence artificielle, ces « livres » sont les milliards de nombres (appelés poids) qui composent un grand modèle de langage (LLM) — le genre d'IA qui écrit des histoires, répond à des questions et discute avec vous. Pour que ces modèles d'IA fonctionnent rapidement sur les ordinateurs, les scientifiques tentent de réduire la taille de ces nombres, un processus appelé quantification. Considérez cela comme la compression d'une photo haute définition en un fichier plus petit afin qu'elle se charge rapidement sur votre téléphone.

Cependant, il s'agit d'un équilibre délicat. Si vous réduisez trop les nombres ou de manière trop rigide, vous perz les détails importants, et l'IA commence à commettre des erreurs stupides. Si vous les gardez trop grands, l'ordinateur est submergé et fonctionne lentement. Traditionnellement, les scientifiques ont utilisé deux méthodes principales pour réduire la taille de ces nombres : la Quantification Uniforme, qui est comme une règle avec un espacement parfaitement égal (simple mais rigide), et le Nombre à Virgule Flottante (Floating-Point), qui est comme une règle flexible qui s'étire par endroits et se contracte ailleurs (plus flexible mais plus difficile à utiliser). La grande question a toujours été : pouvons-nous avoir un format qui soit aussi flexible que la règle extensible mais aussi facile à utiliser que la simple ?

C'est ici qu'intervient une nouvelle méthode appelée CubicQuant. C'est comme inventer une règle magique capable de changer de forme, qui peut se courber pour s'adapter exactement à la forme des données qu'elle mesure, tout en restant assez simple pour être lue instantanément par un ordinateur. Le chercheur derrière ce papier, Xuetian « Elliot » Gao, propose un système qui utilise une courbe mathématique spéciale (une courbe cubique) pour décider comment emballer ces nombres. Au lieu de forcer chaque groupe de nombres dans une ligne droite et rigide, CubicQuant permet aux « marques de la règle » de se regrouper là où les données sont denses et de s'écarter là où elles sont éparses, tout en maintenant les données étroitement emballées dans une grille régulière.

Le papier conclut que cette approche fonctionne étonnamment bien. Lorsqu'ils l'ont testée sur différents types de distributions de données (comme la courbe en cloche d'une distribution normale ou les pics aigus d'une distribution de Laplace), CubicQuant a réduit l'erreur de reconstruction des nombres originaux de manière significative — jusqu'à 28,14 % de mieux que les méthodes standards pour certains types de données. Il a également montré que ce format peut être exécuté directement sur les cartes graphiques modernes (GPU) sans avoir besoin de tout décompresser au préalable, ce qui est une victoire majeure pour la vitesse. Cependant, l'auteur prend soin de noter que, bien que les chiffres soient excellents dans les simulations et les tests isolés, ils n'ont pas encore prouvé que cela rend l'IA plus « intelligente » ou plus rapide dans une application réelle complète, comme discuter avec un utilisateur. Les résultats sont prometteurs et mathématiquement fondés, mais le test final pour savoir si cela change le monde de l'IA reste à venir.

La Magie de la « Règle à Changement de Forme »

Pour comprendre pourquoi CubicQuant est une avancée majeure, examinons comment il résout le « Problème du Sac à Dos » de l'IA.

Les anciennes méthodes : Rigide vs Désordonné
Imaginez que vous avez un sac de billes de différentes tailles. Vous voulez les emballer dans une boîte.

La Quantification Uniforme est comme utiliser une boîte avec des étagères fixes et espacées de manière égale. Si vos billes sont toutes de la même taille, c'est parfait. Mais si vous avez un mélange de petits cailloux et de gros rochers, soit vous gaspillez de l'espace pour les rochers, soit vous écrasez les cailloux. C'est simple et rapide, mais cela ne s'adapte pas à la forme de vos objets.
Les Codebooks Appris (Learned Codebooks) sont comme engager un emballeur professionnel qui examine chaque bille et moule une étagère sur mesure pour elle. C'est incroyablement efficace, mais c'est lent, désordonné et nécessite beaucoup de notes supplémentaires (métadonnées) pour se souvenir de l'emplacement de chaque chose. C'est difficile pour un ordinateur à lire rapidement.

La Solution CubicQuant
CubicQuant offre le meilleur des deux mondes. Il utilise un codebook paramétrique non uniforme. C'est une façon sophistiquée de dire qu'il utilise une « règle à changement de forme ».

Au lieu d'étagères fixes, il utilise une ligne courbe et lisse (une courbe cubique) pour décider de l'emplacement des étagères.
Cette courbe est contrôlée par seulement deux paramètres de forme et un facteur d'échelle pour chaque petit groupe de poids (un « groupe »).
Considérez cela comme une règle flexible qui peut se courber. Si les données sont regroupées près de zéro (comme de nombreux petits nombres), la règle se courbe pour placer plus de « graduations » (niveaux de reconstruction) juste là. Si les données sont dispersées dans les queues de distribution, la règle s'étire.
Crucialement, cette courbure est contrôlée par une formule simple. L'ordinateur n'a pas besoin d'une immense table de correspondance ; il calcule simplement la courbe à la volée. Cela permet de garder les données étroitement emballées (comme un flux d'entiers régulier) tout en permettant de s'adapter aux statistiques locales du modèle d'IA.

Comment cela fonctionne : La stratégie du « Groupe »

Le papier explique que les poids du modèle d'IA sont divisés en petits groupes (comme des groupes de 128 ou 256 nombres). Pour chaque groupe, CubicQuant calcule :

Une Échelle (Scale) : Quelle est la taille globale des nombres dans ce groupe.
Deux Coefficients de Forme (a et b) : Ils indiquent à la courbe comment se courber. L'un contrôle la pente initiale, et l'autre contrôle la courbure.

Cela signifie que même si l'ensemble du modèle possède des milliards de nombres, l'ordinateur n'a besoin de stocker qu'une infime quantité d'informations supplémentaires (métadonnées) pour chaque groupe afin de savoir comment « courber » la règle pour ce segment spécifique. Le papier note que pour une taille de groupe de 128, cela n'ajoute que 0,5 bit de surcharge par poids (en plus de la charge utile de 4 bits), ce qui est très efficace.

Les Résultats : Moins d'Erreurs, Même Vitesse

Le chercheur a mené des expériences pour voir comment cette nouvelle règle se compare aux anciennes. Il a testé trois types de distributions de données :

Uniforme : Données réparties uniformément.
Gaussienne : La classique « courbe en cloche » (la plupart des choses sont moyennes, peu sont extrêmes).
Laplace : Une distribution avec un pic aigu et des queues lourdes (beaucoup de petits nombres, mais quelques très grands extrêmes).

Les conclusions :

Pour les données Uniformes : Comme les données sont déjà régulières, la règle flexible n'aide pas beaucoup. Elle performe de la même manière que la règle rigide.
Pour les données Gaussiennes et de Laplace : C'est là que CubicQuant excelle. Parce que ces distributions ont beaucoup de nombres regroupés près de zéro et moins dans les queues, la règle flexible peut regrouper les « graduations » près de zéro pour mieux capturer les détails.
- Sur les données Gaussiennes, il a réduit l'erreur de 13,49 % par rapport à la méthode standard.
- Sur les données de Laplace, l'amélioration était encore plus grande, atteignant 28,14 %.
- Il a également battu les meilleurs formats à « virgule flottante » (qui sont déjà assez flexibles) de 6,27 % à 9,44 % selon la largeur de bits.

Le papier souligne que ce sont des simulations et des preuves mathématiques de la qualité de la reconstruction des nombres. Il ne prétend pas encore que cela rend l'IA plus intelligente ou meilleure dans ses réponses (perplexité, raisonnement, etc.). La « qualité » des réponses de l'IA reste une question ouverte.

Les « Deux Voies » pour exécuter l'IA

L'un des aspects les plus intéressants de CubicQuant est qu'il prend en charge deux manières différentes d'exécuter l'IA sur un ordinateur, et il s'adapte parfaitement aux deux :

Voie Model-Dtype : L'ordinateur reconstruit les nombres exactement tels qu'ils sont (en utilisant des calculs à virgule flottante). C'est bon pour la précision.
Voie Dynamic-A8 : L'ordinateur mappe les nombres vers un format d'entier standard de 8 bits (INT8) à la volée. C'est excellent pour la vitesse car les ordinateurs modernes possèdent des composants matériels spéciaux (Tensor Cores) qui sont extrêmement rapides pour effectuer des calculs avec des entiers de 8 bits.

Le papier montre que CubicQuant peut être « ajusté » pour fonctionner efficacement pour les deux voies en même temps. C'est comme concevoir une clé qui s'adapte à deux serrures différentes. Le chercheur a constaté que pour de petites tâches, la méthode standard est plus rapide, mais à mesure que la tâche devient plus importante (plus de lignes de données), la voie Dynamic-A8 devient nettement plus rapide (jusqu'à 4,46x plus rapide dans certains tests sur un GPU NVIDIA H200).

Ce qu'il ne fait pas (La liste des « Non »)

Il est important de savoir ce que CubicQuant ne fait pas, selon le papier :

Ce n'est pas une solution miracle pour l'intelligence de l'IA. Le papier stipule explicitement qu'ils n'ont pas mesuré si cela rend l'IA plus intelligente ou meilleure pour suivre des instructions. C'est une question future.
Ce n'est pas une accélération universelle. Les gains de vitesse dépendent fortement de la forme des données et du type de puce informatique. Pour des tâches très petites, la méthode standard pourrait rester plus rapide.
Cela ne résout pas le problème de la « Persistance de l'Activation ». Le chercheur a tenté de garder les nombres compressés en mémoire entre les étapes pour économiser de l'espace, mais cela a en réalité ralenti les choses car l'ordinateur passait trop de temps à gérer les données. Il a donc écarté cette option pour le moment.

En Résumé

CubicQuant est une nouvelle façon ingénieuse de compacter les poids de l'IA qui utilise une courbe mathématique simple pour s'adapter à la forme des données. Il offre un compromis idéal : il est assez flexible pour capturer les détails mieux que les méthodes rigides, mais assez simple pour s'exécuter rapidement sur les ordinateurs modernes. Les mathématiques sont solides, les simulations montrent de grandes améliorations de précision, et les premiers tests de vitesse sur des GPU puissants sont prometteurs. Mais comme tout nouvel outil, il doit être davantage testé dans le monde réel pour voir s'il transforme véritablement la façon dont nous construisons et utilisons l'IA. Pour l'instant, il est un candidat très sérieux pour la prochaine génération de modèles d'IA efficaces.

Résumé Technique : CubicQuant

Énoncé du Problème

L'inférence des grands modèles de langage (LLM) nécessite un équilibre entre deux objectifs concurrents : les niveaux de reconstruction des poids quantifiés doivent s'adapter aux variations des statistiques locales des poids du modèle (qui suivent souvent des distributions non uniformes comme Gaussienne ou de Laplace), tout en restant une représentation compacte et régulière pour une exécution directe sur le matériel GPU à haut débit.

Les méthodes de quantification scalaire existantes occupent des points distincts sur ce spectre de compromis :

Quantification Entière Uniforme : Offre un empaquetage dense et une arithmétique simple mais restreint chaque groupe à une grille linéaire, échouant ainsi à capturer efficacement les distributions de poids non uniformes.
Nombre à Virgule Flottante à Basse Précision (ex: FP8) : Redistribue les niveaux via une structure exposant-mantisse fixe, favorisant une plage dynamique prédéterminée mais manquant de flexibilité pour des statistiques de poids spécifiques.
Codebooks Appris : Gagnent en flexibilité en apprenant tous les niveaux, mais souffrent d'un décodage irrégulier, de structures de métadonnées complexes et d'un mauvais alignement avec les chemins de produit scalaire standards des GPU.

Le défi est de créer un format qui conserve la régularité des codes entiers pour une exécution GPU efficace, tout en permettant aux niveaux de reconstruction de s'adapter de manière paramétrique aux statistiques locales des poids.

Méthodologie : CubicQuant

CubicQuant introduit un format scalaire non uniforme paramétrique qui préserve un flux de codes entiers denses tout en adaptant les niveaux de reconstruction indépendamment au sein de chaque groupe de poids.

1. Représentation

Payload (Charge utile) : Les poids sont stockés sous forme de codes entiers signés ( $k$ ) allant de $-M$ à $M$ (où $M = 2^{B-1}-1$ pour une largeur de bits $B$ ). Le format supporte des payloads de 1 à 8 bits.
Fonction de Niveau Paramétrique : Au lieu d'une grille linéaire, les niveaux de reconstruction sont déterminés par une courbe cubique monotone. Pour une magnitude normalisée $t = |k|/M$ $t = ∣ k ∣/ M$ , la fonction de reconstruction est :
$q(t) = t [a + t (b + ct)]$
où $c = 1 - a - b$ $c = 1 - a - b$ .
- Paramètres : Chaque groupe stocke deux coefficients de forme sans dimension ( $a, b$ ) et une échelle FP32 ( $s$ ).
- Contraintes : La courbe est contrainte à être monotone ( $q'(t) > 0$ ) et satisfait $q(0)=0$ et $q(1)=1$ . Cela garantit un zéro exact et des extrémités exactes ( $\pm s$ ).
- Cas Particulier : La quantification entière symétrique uniforme est un cas spécial exact de cette famille où $a=1, b=0$ .

2. Métadonnées et Stockage

Groupement : Les poids sont divisés en groupes de taille $G$ .
Métadonnées : Chaque groupe stocke une échelle FP32 et deux coefficients de forme FP16.
Largeur Effective : Le stockage total par poids est de $B + 64/G$ bits. Ce coût explicite de métadonnées contraste avec les métadonnées cachées dans les moyennes au niveau du modèle ou les tables de recherche complexes.

3. Objectifs d'Ajustement (Fitting)

Le document définit deux stratégies d'ajustement principales :

Objectif de Référence Continu : Minimise l'erreur quadratique moyenne (MSE) entre les poids originaux et les niveaux de reconstruction continus de Cubic. C'est un estimateur sans données (data-free), basé uniquement sur les poids.
Objectif Sensible au Porteur Dynamic-A8 : Pour supporter l'exécution avec des activations INT8 quantifiées dynamiquement, l'objectif d'ajustement est modifié pour minimiser l'erreur conjointe de la reconstruction continue et de sa projection sur une grille de porteur INT8 signée ( $r(k) = \text{round}(127 \cdot \text{sign}(k) \cdot q(|k|/M))$ ). Cela permet à un seul checkpoint sérialisé de servir à la fois les chemins d'exécution du type de données du modèle (model-dtype) et de Dynamic-A8.

4. Exécution GPU

CubicQuant évite de matérialiser des tenseurs de poids à pleine précision. À la place, il emploie un décodage et calcul fusionnés :

Reconstruction Locale au Tile : Les noyaux GPU chargent les payloads compactés et les métadonnées de groupe, reconstruisent les niveaux (via des tables de recherche ou une évaluation de forme de Horner), et les consomment immédiatement dans les boucles de produit scalaire.
Double Voie :
- Chemin Model-Dtype : Reconstruit les valeurs continues pour les activations FP16/BF16.
- Chemin Dynamic-A8 : Mappe les niveaux reconstruits vers des porteurs INT8 pour des produits scalaires entiers, en accumulant dans INT32 avant le rescalage.
Sélection de Noyau : L'implémentation utilise une sélection de noyau dépendante de la forme et du dispositif (ex: GEMV étroit vs pavage dense) pour optimiser les performances à travers différentes lignes et largeurs de bits.

Contributions Clés

Famille de Codebooks Paramétriques : Une famille de codebooks scalaires non uniformes symétriques à deux paramètres qui contient la quantification entière signée uniforme comme un cas spécial exact.
Format Compact : Un format de checkpoint couvrant des poids de 1 à 8 bits avec une mise à l'échelle FP32 et un surcoût de stockage en circuit fermé ( $B + 64/G$ bits/poids).
Procédures d'Ajustement : Une procédure d'ajustement de référence par groupe et un objectif sensible au porteur Dynamic-A8, tous deux séparables des estimateurs d'erreur plus riches basés sur les données.
Exécution GPU Directe : Implémentation de noyaux de poids compactés pour les activations de type modèle et Dynamic-A8, avec étalonnage dépendant du dispositif.
Preuves Analytiques et Empiriques : Dérivation de la distorsion de la population sous les distributions Uniforme, Gaussienne et de Laplace, ainsi que des mesures préliminaires de noyaux sur H200.

Résultats

Analyse de la Distorsion Théorique

Distribution Uniforme : La grille linéaire (Uniform INT) est l'optimale pour la population. CubicQuant égale cette performance, confirmant qu'il ne dégrade pas les performances pour les données uniformes.
Distributions Gaussienne et de Laplace :
- CubicQuant surpasse significativement la quantification entière uniforme découpée de manière optimale.
- Il récupère 84,8 % à 96,1 % de l'écart entre les entiers uniformes et le codebook Lloyd-Max optimal pour les distributions Gaussiennes (W4–W8).
- Il récupère 91,4 % à 96,9 % de l'écart pour les distributions de Laplace.
- Il surpasse les meilleurs formats à virgule flottante énumérés (ex: E2M5) pour toutes les largeurs de bits testées pour ces distributions.

Expériences sur Groupes Finis

Dans les expériences avec $G=128$ et 15 360 échantillons :

Performance W4 : Par rapport aux entiers uniformes à 4 bits optimaux et découpés, CubicQuant a réduit l'erreur quadratique moyenne (RMSE) de reconstruction de :
- 3,90 % sur les échantillons Uniformes.
- 13,49 % sur les échantillons Gaussiens.
- 28,14 % sur les échantillons de Laplace.
Comparaison avec FP : Par rapport au meilleur format à virgule flottante énuméré à 4 bits, les réductions étaient de 3,90 % (Uniforme), 9,44 % (Gaussienne) et 6,27 % (Laplace).
Mécanisme : Les gains sur les données Uniformes proviennent de l'adaptation aux fluctuations d'échantillons finis au sein des groupes, bien que l'optimum de la population soit linéaire.

Performance des Noyaux (H200)

Croisement Dépendant de la Charge de Travail : Des mesures préliminaires sur un GPU H200 révèlent un point de croisement entre l'exécution Model-Dtype (A16) et Dynamic-A8.
- Pour les GEMV étroits (petits nombres de lignes, $M=1$ ), l'exécution Model-Dtype est plus rapide en raison de coûts de configuration plus faibles.
- À mesure que le nombre de lignes augmente ( $M \ge 16$ ), Dynamic-A8 devient préférable, avec des accélérations allant de 1,6x à 4,4x selon la largeur de bits et la forme.
Résultat Négatif : Une conception de "porteur d'activation persistant" expérimentale (garder les activations INT8 entre les opérateurs) a échoué à améliorer les performances en raison des dépassements de synchronisation et de réduction par rapport aux économies de bande passante.

Signification et Revendications

L'article affirme établir la promesse de représentativité et le caractère exécutable du format CubicQuant.

Adaptabilité sans Complexité : CubicQuant démontre qu'une courbe paramétrique compacte peut récupérer une grande partie de l'adaptabilité d'un codebook libre sans abandonner le flux de bits scalaire régulier requis pour une exécution GPU efficace.
Compatibilité de Double Voie : Le format supporte avec succès à la fois l'exécution continue du type de données du modèle et l'exécution entière basée sur Dynamic-A8 à partir d'une seule représentation sérialisée.
Portée Modeste : L'auteur déclare explicitement que le papier ne revendique pas :
- Des améliorations de la qualité du modèle en aval (la perplexité, le raisonnement, etc. n'ont pas été mesurés).
- Un gain de vitesse de bout en bout universel ; la performance dépend de la charge de travail.
- Une applicabilité générale à toutes les générations de GPU (les preuves sont limitées à Hopper/H200).
- Que l'estimateur de référence sans données est supérieur aux méthodes basées sur les activations ou de second ordre ; le format est conçu pour être compatible avec elles.

En résumé, CubicQuant offre un juste milieu entre les grilles fixes et les codebooks libres, fournissant une approche paramétrique, mathématiquement fondée, de la quantification des poids qui est directement exécutable sur les architectures GPU modernes.