🔢 mathematics

Analysis of Floating-Point Matrix Multiplication Computed via Integer Arithmetic

Ce papier propose une méthode peu coûteuse pour estimer le nombre minimal de tranches entières nécessaire afin d'atteindre une précision donnée lors du calcul de produits matriciels flottants via l'arithmétique entière, tout en analysant les compromis performance-précision et l'impact du mauvais conditionnement des lignes et colonnes sur des accélérateurs matériels modernes comme les cœurs tensoriels NVIDIA.

Auteurs originaux : Ahmad Abdelfattah, Jack Dongarra, Massimiliano Fasi, Mantas Mikaitis, Françoise Tisseur

Publié 2026-03-30

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Ahmad Abdelfattah, Jack Dongarra, Massimiliano Fasi, Mantas Mikaitis, Françoise Tisseur

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

🌟 Le Grand Défi : Faire de la haute couture avec des ciseaux de cuisine

Imaginez que vous êtes un architecte de superordinateurs (les plus puissants au monde). Votre objectif est de construire des bâtiments (des simulations scientifiques) d'une précision absolue, comme un gratte-ciel qui ne tremble pas d'un millimètre. Pour cela, vous avez besoin d'outils de mesure ultra-précis (l'arithmétique en virgule flottante 64 bits, ou binary64).

Cependant, les constructeurs de puces (comme NVIDIA) ont changé leur façon de travailler. Pour répondre à la demande explosive de l'Intelligence Artificielle, ils fabriquent désormais des outils de construction beaucoup plus rapides, mais un peu "bricolés" (l'arithmétique en entiers ou en faible précision). Ces outils sont des milliers de fois plus rapides, mais ils ne savent pas mesurer les microns, seulement les centimètres.

Le problème : Comment construire un gratte-ciel de haute précision avec des outils qui ne savent pas mesurer finement ?

✂️ La Solution : La technique du "Découpage en Tranches" (Ozaki)

Les auteurs de ce papier, Ahmad Abdelfattah et son équipe, expliquent une astuce ingénieuse appelée le schéma d'Ozaki. Au lieu d'essayer de forcer les outils rapides à faire un travail de précision (ce qui est impossible), ils découpent le problème en petits morceaux gérables.

Voici l'analogie du Puzzle Géant :

Le Découpage (Slicing) : Imaginez que vous devez multiplier deux énormes tableaux de nombres. Au lieu de le faire d'un coup, vous découpez chaque tableau en plusieurs "tranches" (comme des tranches de saucisson).
- Chaque tranche contient une partie des chiffres importants.
- La première tranche a les chiffres les plus gros (les plus importants).
- Les tranches suivantes ont des chiffres de plus en plus petits (les détails fins).
Le Calcul Rapide (Entiers) : Vous prenez ces tranches et vous les faites multiplier par les outils ultra-rapides de la puce (les "Tensor Cores"). Comme les tranches sont petites et bien définies, les outils rapides peuvent faire le calcul exactement, sans erreur, comme si c'était une simple addition de Lego.
Le Recollage (Accumulation) : Une fois toutes les tranches multipliées, vous devez remettre le puzzle ensemble. C'est ici que l'ordinateur utilise ses outils de précision (l'arithmétique classique) pour additionner tous ces petits résultats partiels et reconstruire le tableau final.

⚖️ Le Compromis : Vitesse vs Précision

C'est là que réside le cœur de la recherche. Le nombre de tranches que vous choisissez détermine tout :

Peu de tranches (ex: 3) : C'est super rapide ! Mais vous risquez d'oublier les détails fins. Le résultat est approximatif. C'est comme dessiner un portrait avec seulement 3 coups de pinceau : on reconnaît le visage, mais ce n'est pas parfait.
Beaucoup de tranches (ex: 18) : Le résultat est extrêmement précis, presque parfait. Mais c'est lent, car il faut faire beaucoup plus de calculs. C'est comme peindre un portrait avec 18 couches de peinture : magnifique, mais cela prend beaucoup de temps.

🔍 La Découverte Majeure : Attention aux "Matériaux Déformés"

Le papier révèle un piège caché. Cette technique fonctionne très bien si les nombres que vous manipulez sont "bien rangés" (de taille similaire).

Mais imaginez que vous essayiez de mesurer la taille d'un éléphant et celle d'une fourmi avec la même règle, en découpant la fourmi en tranches minuscules.

Si votre matrice (votre tableau de nombres) contient des valeurs énormes et des valeurs minuscules mélangées (ce qu'on appelle une mauvaise mise à l'échelle), la technique échoue.
L'analogie : C'est comme essayer de peser un grain de sable posé sur un camion de 10 tonnes avec une balance de cuisine. Le grain de sable est "noyé" dans le poids du camion. Peu importe combien de tranches vous faites, le grain de sable disparaît dans l'erreur d'arrondi.

Les auteurs montrent que pour ces cas "déséquilibrés", il faut parfois un nombre énorme de tranches pour retrouver la précision, ce qui annule tout l'avantage de vitesse.

🚀 Les Résultats sur les Puces Réelles

L'équipe a testé cela sur les toutes dernières puces NVIDIA (les modèles Hopper et le tout nouveau Blackwell).

Le verdict : Pour des problèmes "normaux" (comme ceux utilisés en intelligence artificielle), la méthode est un succès retentissant. Elle peut être 7 fois plus rapide que la méthode classique tout en restant assez précise pour la plupart des besoins.
La nuance : Pour les problèmes scientifiques très sensibles (comme la météo ou la physique nucléaire) où les nombres sont très déséquilibrés, il faut être très prudent. Parfois, il faut utiliser plus de tranches pour l'un des tableaux que pour l'autre, une astuce que les auteurs ont mise au point pour gagner du temps sans perdre en précision.

🏁 En Résumé

Ce papier nous dit :

"Nous avons trouvé un moyen de faire des calculs scientifiques ultra-précis en utilisant les super-puces rapides faites pour l'IA. C'est comme transformer un marteau-piqueur en outil de chirurgie en le découpant en petits morceaux. C'est génial et très rapide, mais attention : si vos données sont trop désordonnées (trop de grands et de petits nombres mélangés), l'outil peut se tromper. Il faut donc savoir doser le nombre de 'tranches' pour ne pas perdre de temps ni de précision."

C'est une avancée majeure pour l'avenir du calcul scientifique sur les supercalculateurs de demain.

1. Problématique

L'essor des supercalculateurs exascale (comme El Capitan, Frontier, Aurora) repose sur des accélérateurs matériels (GPU) optimisés pour le calcul à basse précision, principalement destinés au machine learning (formats comme TensorFloat-32, bfloat16, INT8). Bien que ces formats offrent un débit supérieur de plusieurs ordres de grandeur par rapport à l'arithmétique double précision (binary64), ils manquent de la précision requise pour les simulations scientifiques traditionnelles.

Le défi consiste à intégrer efficacement ces accélérateurs dans le calcul scientifique en utilisant des techniques de précision mixte. L'objectif est de recréer des opérations à haute précision (binary64) en s'appuyant sur des unités de calcul entières rapides (Tensor Cores NVIDIA, Matrix Cores AMD).

Une méthode prometteuse, le schéma d'Ozaki, consiste à décomposer les matrices flottantes en tranches entières, à effectuer des multiplications exactes sur ces tranches, puis à accumuler les résultats en virgule flottante. Cependant, la version récente de ce schéma utilisant l'arithmétique entière (proposée par Ootomo, Ozaki et Yokota) soulève des questions critiques :

Comment déterminer le nombre optimal de tranches pour garantir une précision donnée sans sacrifier la performance ?
Le schéma est-il robuste face à des matrices mal conditionnées ou mal mises à l'échelle ?
Quelles sont les limites de précision sur les architectures GPU les plus récentes (Blackwell) ?

2. Méthodologie

Les auteurs proposent une analyse théorique et expérimentale approfondie du schéma d'Ozali basé sur l'arithmétique entière.

Analyse d'Erreur Théorique

L'analyse décompose l'erreur totale en deux sources :

Erreur de troncature : Due à la décomposition des matrices flottantes en tranches entières (slices). Les auteurs montrent que cette erreur dépend fortement du conditionnement des lignes de A et des colonnes de B. Si une ligne de A ou une colonne de B contient des éléments de magnitudes très différentes (mauvaise mise à l'échelle), l'erreur relative peut devenir énorme, même avec un grand nombre de tranches.
Erreur d'arrondi : Due à l'accumulation des produits partiels en virgule flottante.

Les auteurs dérivent de nouvelles bornes d'erreur qui introduisent des facteurs de conditionnement ( $\kappa_A$ et $\kappa_B$ ). Ils démontrent que pour maintenir une précision cible, le nombre de tranches ( $s_A$ et $s_B$ ) doit être ajusté dynamiquement en fonction de ces facteurs. Une contribution majeure est la proposition d'utiliser des nombres de tranches différents pour les matrices A et B, permettant d'optimiser le compromis performance/précision.

Stratégies d'Accumulation

L'article analyse différentes stratégies d'accumulation des produits partiels $A^{(\ell)}B^{(h)}$ :

Accumulation directe en virgule flottante.
Accumulation intermédiaire en arithmétique entière (selon les diagonales de même facteur d'échelle) pour réduire le nombre d'opérations flottantes, comme suggéré par Uchino et al.

Expérimentations Numériques

Les auteurs ont mené des expériences sur :

Des matrices aléatoires avec différents niveaux de mise à l'échelle (paramètre $\phi$ contrôlant la dynamique).
Des matrices provenant de la collection anymatrix utilisées dans des factorisations LU par blocs.
Des implémentations réelles sur GPU NVIDIA H100 (Grace-Hopper) et Blackwell B200 (accès anticipé).
Comparaison entre une implémentation standard cublas (binary64) et une nouvelle implémentation NVIDIA cuIMMA (émulation via instructions IMMA entières).

3. Contributions Clés

Nouvelle Analyse d'Erreur : Une analyse rigoureuse montrant que le schéma peut échouer catastrophiquement si les matrices sont mal mises à l'échelle, indépendamment du nombre de tranches utilisé, à moins d'augmenter considérablement ce nombre.
Estimation Inexpensive du Nombre de Tranches : Une méthode pour estimer le nombre minimal de tranches nécessaire pour atteindre une précision prescrite, basée sur le calcul rapide des facteurs d'échelle ( $\alpha_i, \beta_j$ ) et des conditionnements locaux.
Flexibilité des Tranches : La démonstration qu'il est possible d'utiliser un nombre de tranches différent pour A et B ( $s_A \neq s_B$ ) sans perte de précision, ce qui permet d'optimiser les performances lorsque seule l'une des matrices est mal conditionnée.
Benchmarks sur Hardware de Pointe : Premiers résultats de performance et de précision sur l'architecture NVIDIA Blackwell (B200), incluant l'évaluation de la bibliothèque cuIMMA (émulation FP64 via IMMA).

4. Résultats

Impact de la Mise à l'Échelle : Sur des matrices mal conditionnées (ex: rapport de magnitudes $10^{100}$ ), le schéma nécessite un nombre de tranches prohibitif (plus de 20) pour atteindre la précision machine, rendant l'approche potentiellement inefficace par rapport au calcul natif.
Optimisation par Blocs LU : Dans le contexte de la résolution de systèmes linéaires ($Ax=b$) via une factorisation LU par blocs, les résultats montrent que pour certaines matrices, on peut réduire le nombre de tranches sur l'une des matrices (ex: 1 tranche) tout en maintenant 8 tranches sur l'autre, sans dégrader la précision globale. Cela valide la stratégie de tranches asymétriques.
Performance sur GPU :
- Sur le H100, l'émulation avec 3 tranches offre un speedup de ~2.4x mais avec une perte de précision inacceptable ( $10^{-10}$ vs $10^{-19}$ ).
- Sur le B200, grâce à un ratio de performance INT8/binary64 beaucoup plus élevé (112.5x), l'émulation avec 7 tranches atteint une précision comparable à cublas tout en offrant un speedup significatif.
- Cependant, pour des matrices mal conditionnées, même 18 tranches ne suffisent pas à garantir la précision sur le B200, confirmant la sensibilité de l'algorithme à la dynamique des données.
Stabilité des Algorithmes Supérieurs : L'utilisation d'une émulation avec un nombre de tranches insuffisant (ex: 7 au lieu de 8) dans des algorithmes de haut niveau (comme la décomposition en valeurs propres DSYEVD) peut entraîner une perte de stabilité (orthogonalité des vecteurs propres), soulignant que le nombre de tranches ne peut pas être déterminé uniquement par des benchmarks GEMM isolés.

5. Signification et Conclusion

Ce travail établit que le schéma d'Ozaki basé sur l'arithmétique entière est une voie prometteuse pour exploiter la puissance des nouveaux accélérateurs GPU dans le calcul scientifique, mais ce n'est pas une solution universelle.

Limites : L'approche ne remplace pas l'arithmétique binary64 native, surtout pour les matrices mal conditionnées ou nécessitant une gestion stricte des valeurs spéciales IEEE 754 (NaN, infinis, zéros négatifs) que le schéma actuel ne gère pas correctement.
Avenir : La clé de l'adoption de cette technologie réside dans la capacité à estimer dynamiquement le nombre de tranches nécessaire en fonction des propriétés des matrices d'entrée. Les auteurs soulignent que les benchmarks de performance standard (comme HPL) doivent évoluer pour intégrer ces analyses de précision conditionnelle avant d'adopter massivement ces méthodes d'émulation.

En résumé, l'article fournit les fondements théoriques et pratiques pour utiliser judicieusement l'arithmétique entière dans le calcul scientifique, en mettant en garde contre les pièges liés à la mise à l'échelle des données et en proposant des stratégies d'optimisation adaptatives.