🔢 mathematics

Analysis of Floating-Point Matrix Multiplication Computed via Integer Arithmetic

Dit artikel presenteert een kosteneffectieve methode om het minimumaantal vermenigvuldigingen te schatten voor een nauwkeurige benadering van floating-point matrixvermenigvuldiging via gehele getallen, waarbij de analyse en experimenten op NVIDIA-GPU's de prestaties en beperkingen van deze techniek in verschillende schaalingscondities in kaart brengen.

Oorspronkelijke auteurs: Ahmad Abdelfattah, Jack Dongarra, Massimiliano Fasi, Mantas Mikaitis, Françoise Tisseur

Gepubliceerd 2026-03-30

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Ahmad Abdelfattah, Jack Dongarra, Massimiliano Fasi, Mantas Mikaitis, Françoise Tisseur

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

De Kern: Hoe maak je een dure, precieze berekening goedkoop?

Stel je voor dat je een enorme, ingewikkelde taak moet uitvoeren: het vermenigvuldigen van twee gigantische lijsten met cijfers (wiskundig: matrixvermenigvuldiging). Dit is de basis van bijna alle wetenschappelijke simulaties, van weersvoorspellingen tot het simuleren van een kernreactor.

Vroeger deden supercomputers dit met binary64 (dubbele precisie). Dit is als het gebruik van een gouden liniaal met honderden kleine streepjes. Het is extreem nauwkeurig, maar het is ook traag, zwaar en duur om te gebruiken.

Vandaag de dag zijn de snelste computers (zoals die van NVIDIA) echter gebouwd voor kunstmatige intelligentie (AI). AI heeft geen gouden liniaal nodig; het werkt prima met een houten liniaal met slechts een paar streepjes (lage precisie, zoals 8-bit getallen). Deze houten linialen zijn razendsnel en kunnen duizenden berekeningen per seconde doen.

Het probleem: Wetenschappers willen die snelheid van de AI-chips gebruiken voor hun precieze wetenschappelijke berekeningen, maar ze kunnen geen gouden liniaal vervangen door een houten liniaal zonder dat de resultaten fout worden.

De oplossing (De Ozaki-methode):
De auteurs van dit papier hebben een slimme truc bedacht. Ze zeggen: "Laten we de gouden liniaal niet vervangen, maar laten we de taak opsplitsen in kleine stukjes die we wel met de houten liniaal kunnen doen, en die we daarna weer samenvoegen."

Hoe werkt de truc? (De "Schaar en Plak" Analogie)

Stel je voor dat je een heel groot, complex schilderij (de uitkomst) moet maken, maar je hebt alleen dunne, goedkope stiftjes (de snelle, onnauwkeurige chips).

Opsplitsen (Slicing):
De auteurs nemen de twee grote lijsten met cijfers en snijden ze in dunne plakjes. Ze zeggen: "We gaan dit niet in één keer doen. We splitsen de getallen op in stukjes van 8 bits (zoals de chips kunnen)."
- Analogie: Het is alsof je een enorme, zware steen (het getal) breekt in kleine, lichte stenen die je makkelijk kunt tillen.
Berekenen met de snelle chips:
Nu gebruiken ze de snelle AI-chips om deze kleine stukjes met elkaar te vermenigvuldigen. Omdat de stukjes klein zijn, past het precies in de "houten liniaal" van de chip. Dit gaat supersnel.
Samenvoegen (Accumuleren):
De uitkomsten van al die kleine vermenigvuldigingen worden weer bij elkaar opgeteld in een "gouden pot" (de normale, precieze rekenmodule van de computer).
- Analogie: Je hebt duizenden kleine bakstenen gelegd. Nu tel je ze op tot een perfecte muur. Als je genoeg bakstenen gebruikt, is de muur net zo recht als die van een meesterbouwer.

De Grootte van het Probleem: Hoeveel plakjes heb je nodig?

Hier komt de belangrijkste ontdekking van dit papier.

De auteurs ontdekten dat het aantal plakjes (de "slices") cruciaal is.

Weinig plakjes: De berekening is supersnel, maar de muur wordt scheef (onjuist resultaat).
Veel plakjes: De muur is perfect recht, maar het kost eeuwen om alle bakstenen te leggen (te traag).

De verrassende ontdekking:
Niet alle getallen zijn even "moeilijk".

Sommige lijsten met cijfers zijn goed geordend (alle getallen zijn ongeveer even groot). Voor deze lijsten heb je maar een paar plakjes nodig.
Andere lijsten zijn chaotisch (sommige getallen zijn heel klein, andere gigantisch groot). Dit noemen ze "badly scaled" (slecht geschaald).

De analogie van de scheve vloer:
Stel je voor dat je een vloer moet betegelen.

Als de vloer vlak is (goed geschaald), kun je met grote tegels werken.
Als de vloer echter een enorme kuil heeft (slecht geschaald), dan moet je die kuil opvullen met duizenden kleine tegeltjes om hem vlak te krijgen. Als je daar grote tegels gebruikt, blijft de kuil zichtbaar en is de vloer scheef.

Het papier laat zien dat als je een matrix hebt met zo'n "kuil" (slecht geschaalde rijen of kolommen), je extreem veel plakjes nodig hebt om een nauwkeurig resultaat te krijgen. Als je dat niet doet, wordt de berekening onbruikbaar.

Wat hebben ze getest?

De auteurs hebben dit getest op de allernieuwste NVIDIA-chips (de Blackwell B200, die in 2025 uitkwam).

Snelheid: Met de "slechte" instelling (weinig plakjes) waren ze 7,6 keer sneller dan de oude methode. Maar de resultaten waren onnauwkeurig.
Nauwkeurigheid: Als ze genoeg plakjes gebruikten (7 of 8), was de snelheid nog steeds goed, maar was het resultaat net zo nauwkeurig als de oude, trage methode.
De valkuil: Ze maakten een test met "slecht geschaalde" matrices (zoals de kuil in de vloer). Zelfs met veel plakjes faalde de methode soms. Dit betekent dat je altijd eerst moet kijken of je data goed is voordat je deze snelle methode gebruikt.

Conclusie voor de leek

Dit papier is als een handleiding voor het bouwen van een snelle auto met onderdelen van een racefiets.

De boodschap: Je kunt de razendsnelle AI-chips van vandaag gebruiken voor wetenschappelijke berekeningen, maar je moet slim zijn.
De waarschuwing: Je kunt niet zomaar alles versnellen. Als je data "slecht" is (te veel variatie in grootte), moet je de snelheid terugdraaien en meer "plakjes" gebruiken, anders krijg je een verkeerd antwoord.
De toekomst: De auteurs hebben een formule bedacht om te voorspellen hoeveel "plakjes" je nodig hebt voordat je begint. Dit helpt wetenschappers om de snelheid van AI te gebruiken zonder hun resultaten te verpesten.

Kortom: Het is een slimme manier om de snelheid van de toekomst te huren voor de precisie van het verleden, mits je de regels van het spel goed begrijpt.

Titel: Analyse van drijvende-kommamatrixvermenigvuldiging berekend via geheeltallige arithmetiek

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

1. Probleemstelling

Moderne supercomputers (zoals El Capitan, Frontier, Aurora en JUPITER) bereiken exascale-prestaties door hardware-versnellers te gebruiken die oorspronkelijk zijn ontworpen voor machine learning-workloads. Deze versnellers (zoals NVIDIA Tensor Cores en AMD Matrix Cores) bieden extreme doorvoersnelheden voor lage precisie (bijv. INT8, FP16, BF16) en integer-arithmetiek, maar hun prestaties voor standaard IEEE 754 binary64 (double precision) drijvende-kommabewerkingen nemen af of worden zelfs niet meer ondersteund.

Voor wetenschappelijke simulaties is echter vaak hoge precisie (binary64) vereist. De uitdaging is om deze hoge precisie-berekeningen efficiënt uit te voeren op hardware die is geoptimaliseerd voor lage precisie en integer-bewerkingen. Bestaande methoden voor gemengde precisie (mixed-precision) zijn vaak complex of niet optimaal afgestemd op de nieuwste integer-matrixvermenigvuldigings-eenheden (MMA).

2. Methodologie: Het Integer Ozaki-schema

Het artikel analyseert en verbetert een strategie, de Ozaki-scheme, die matrixvermenigvuldiging ($C = AB$) recast als een reeks integer-producten.

Principe: De matrices $A$ en $B$ worden opgesplitst in "slices" (schijven) van geheeltallige representaties.
1. Schaalverdeling: De rijen van $A$ en kolommen van $B$ worden geschaald naar een blokgewijze vast-kommavorm (block fixed-point) met een macht van 2 als schalingsfactor ( $\alpha_i$ en $\beta_j$ ).
2. Bit-splitsing: De geschaalde waarden worden opgesplitst in slices van $t$ bits. Deze slices worden als geheeltallen ( $I_t$ ) behandeld.
3. Integer-vermenigvuldiging: De productmatrices van de slices ( $A^{(\ell)}B^{(h)}$ ) worden exact berekend met behulp van de snelle integer MMA-eenheden op de GPU.
4. Accumulatie: De resultaten worden opgesomd in drijvende-kommavorm (floating-point) om het eindresultaat te verkrijgen.
Optimalisatie: Het artikel bespreekt varianten waarbij niet alle $s \times s$ combinaties van slices worden berekend, maar alleen die waarvoor $\ell + h \leq s + 1$ , om de rekentijd te verminderen. Er wordt ook gekeken naar het accumuleren van producten met dezelfde schaal in integer-arithmetiek voordat ze naar floating-point worden omgezet, om fouten te minimaliseren.

3. Belangrijkste Bijdragen

Nieuwe Foutanalyse:
De auteurs presenteren een nieuwe foutanalyse die aantoont dat het algoritme kan falen of inefficiënt wordt als de rijen van $A$ of kolommen van $B$ slecht geschaald zijn (d.w.z. als er grote verschillen zijn in de grootte van elementen binnen dezelfde rij/kolom).
- Ze introduceren een maatstaf $\kappa_A$ en $\kappa_B$ die de schaalvariatie kwantificeert.
- De analyse toont aan dat bij slechte schaling het aantal benodigde slices exponentieel kan toenemen om een gewenste nauwkeurigheid te behalen.
Flexibele Slice-aantallen:
In tegenstelling tot eerdere werk dat uitging van een gelijk aantal slices voor beide matrices, stelt de analyse voor om een verschillend aantal slices ( $s_A$ en $s_B$ ) te gebruiken voor $A$ en $B$ .
- Dit biedt een goedkope strategie om het aantal benodigde integer-vermenigvuldigingen te minimaliseren zonder in te leveren op nauwkeurigheid, mits de slecht geschaalde matrix meer slices krijgt dan de goed geschaalde.
Voorspelling van Slice-aantal:
De auteurs bieden een methode om het minimale aantal slices te schatten dat nodig is voor een specifieke nauwkeurigheidsdrempel, gebaseerd op de data-gedreven waarden van $\kappa_A$ en $\kappa_B$ .
Uitgebreide Experimenten:
- Simulaties in MATLAB en tests op de nieuwste NVIDIA GPU's (GH200/Grace-Hopper en Blackwell B200).
- Evaluatie van het algoritme in hogere niveau-algoritmen, zoals blok-LU-factorisatie en symmetrische eigenvaardoplossers.

4. Resultaten

Invloed van Schaling:
Experimenten met slecht geschaalde matrices (waarbij elementen binnen een rij/kolom een groot dynamisch bereik hebben) tonen aan dat standaard configuraties (bijv. 8 slices) onvoldoende zijn. Voor extreme schaling (bijv. $\kappa_D = 10^{40}$ ) wordt het algoritme onnauwkeurig, zelfs met 18 slices. Dit bevestigt de theoretische analyse dat slechte schaling de prestaties en nauwkeurigheid ernstig beïnvloedt.
Prestaties op Hardware:
- Op de Blackwell B200 GPU (met een zeer hoge ratio tussen INT8 en FP64 prestaties) kan de geëmuleerde FP64-matrixvermenigvuldiging (met 7 slices) 7,6x sneller zijn dan de native FP64 implementatie (cublas), terwijl de nauwkeurigheid vergelijkbaar blijft.
- Op de GH200 is de snelheidswinst kleiner (2,4x) en soms zelfs negatief als te veel slices worden gebruikt om de nauwkeurigheid te waarborgen.
Hogere Niveau Algoritmen:
Bij het oplossen van lineaire systemen (LU-factorisatie) en het vinden van eigenwaarden blijkt dat het aantal slices niet universeel kan worden gekozen. Voor sommige matrices volstaat een asymmetrische verdeling (bijv. 1 slice voor $A$ , 8 voor $B$ ) om de nauwkeurigheid te behouden, wat de efficiëntie ten goede komt. Echter, voor hogere niveau-algoritmen zoals eigenvaardoplossers, is vaak een hoger aantal slices (bijv. 8) nodig dan voor een simpele GEMM-benchmark om stabiliteit te garanderen.
Beperkingen:
Het huidige algoritme ondersteunt geen speciale IEEE 754-waarden zoals NaNs, oneindigheden of negatieve nullen, wat het gebruik in robuuste wetenschappelijke software beperkt.

5. Betekenis en Conclusie

Dit onderzoek is van groot belang voor de toekomst van wetenschappelijk rekenen op exascale-systemen. Het toont aan dat het mogelijk is om binary64-nauwkeurigheid te behouden op hardware die primair is ontworpen voor lage precisie en integer-bewerkingen, mits de algoritmen slim worden aangepast.

Kernboodschap: De Ozaki-scheme is een veelbelovende aanpak, maar vereist een data-gedreven aanpak. Een vast aantal slices is niet voldoende; het aantal slices moet worden afgestemd op de schaling van de invoermatrices.
Toekomstperspectief: Hoewel het algoritme in gunstige omstandigheden enorme snelheidswinsten biedt, is het geen volledige vervanging voor native FP64-hardware, vooral vanwege de gevoeligheid voor slecht geschaalde data en het gebrek aan ondersteuning voor speciale waarden. Verdere onderzoek is nodig om deze beperkingen weg te nemen en de integratie in standaard wetenschappelijke bibliotheken (zoals LAPACK) te faciliteren.

Samenvattend biedt dit papier een cruciale theoretische basis en praktische richtlijnen voor het gebruik van integer-arithmetiek om hoge precisie matrixberekeningen op de nieuwste generatie GPU's uit te voeren.