🔢 mathematics

Analysis of Floating-Point Matrix Multiplication Computed via Integer Arithmetic

Il paper propone un metodo economico per stimare il numero minimo di slice intere necessarie per garantire una precisione desiderata nella moltiplicazione di matrici in virgola mobile tramite aritmetica intera, evidenziando come la scalatura delle righe e delle colonne influisca sull'accuratezza e confermando l'analisi attraverso esperimenti numerici su GPU NVIDIA.

Autori originali: Ahmad Abdelfattah, Jack Dongarra, Massimiliano Fasi, Mantas Mikaitis, Françoise Tisseur

Pubblicato 2026-03-30

📖 5 min di lettura🧠 Approfondimento

CC BY 4.0

Autori originali: Ahmad Abdelfattah, Jack Dongarra, Massimiliano Fasi, Mantas Mikaitis, Françoise Tisseur

Articolo originale sotto licenza CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Questa è una spiegazione generata dall'IA dell'articolo qui sotto. Non è stata scritta né approvata dagli autori. Per precisione tecnica, consulta l'articolo originale. Leggi il disclaimer completo

🧮 Il Problema: Costruire un Grattacielo con i Mattoncini LEGO

Immagina di dover costruire un grattacielo altissimo (un calcolo scientifico molto preciso) usando dei mattoncini LEGO.
I supercomputer moderni, quelli che fanno le previsioni meteo o simulano il clima, sono diventati incredibilmente veloci, ma hanno un "trucco": sono ottimizzati per usare mattoncini LEGO piccoli e semplici (precisione bassa o numeri interi) perché sono più veloci da maneggiare. Tuttavia, per costruire un grattacielo stabile, avresti bisogno di mattoncini grandi e complessi (precisione alta, come i numeri decimali standard).

Se usi solo i mattoncini piccoli, il grattacielo potrebbe crollare o essere storto. Se usi solo quelli grandi, il lavoro sarà lentissimo e il computer si surriscalderà.

💡 La Soluzione: La "Tecnica Ozaki" (o il Metodo dei Fette)

Gli autori di questo articolo (Abdelfattah, Dongarra e colleghi) stanno analizzando un metodo intelligente chiamato Schema di Ozaki. È come se dicessero: "Non possiamo usare i mattoncini grandi direttamente, ma possiamo usare i piccoli in modo furbo per ottenere lo stesso risultato!"

Ecco come funziona, passo dopo passo:

Tagliare la torta (Le "Fette"):
Invece di prendere un numero grande e complesso (come 3,14159265...), lo "scomponiamo" in tante piccole fette. Immagina di prendere un numero e dividerlo in parti intere (come 3) e parti decimali (0,1, 0,04, 0,001...).
Nel computer, questi numeri vengono trasformati in interi (numeri senza virgola) e "scomposti" in strati o fette (in inglese slices).
Il calcolo veloce:
Il computer usa i suoi acceleratori super-veloci (i "Tensor Cores" delle schede video NVIDIA) per moltiplicare queste fette intere. È come se usasse un robot che moltiplica velocemente i mattoncini LEGO semplici. Il risultato è esatto perché i numeri interi non hanno errori di arrotondamento.
Rimontare il puzzle:
Alla fine, il computer riassume tutte queste fette moltiplicate, rimettendo le virgole al posto giusto, per ottenere il risultato finale.

⚖️ Il Dilemma: Velocità vs. Precisione

Qui entra in gioco il cuore della ricerca: quante fette dobbiamo tagliare?

Poche fette (es. 3): Il calcolo è velocissimo, ma il risultato finale potrebbe essere un po' storto (impreciso). È come tagliare una torta in 3 fette: veloce, ma non vedi bene i dettagli.
Tante fette (es. 20): Il risultato è perfetto, ma ci vuole molto più tempo perché il robot deve fare più lavori. È come tagliare la torta in 20 fette: preciso, ma lento.

Gli autori hanno scoperto una regola d'oro: non serve tagliare tutte le fette allo stesso modo!
Se un ingrediente è "sporco" o difficile da gestire (matrici con numeri molto diversi tra loro, chiamati "mal scalati"), serve tagliarlo in tantissime fette. Se l'altro ingrediente è semplice, bastano poche fette. Questo permette di risparmiare tempo senza perdere precisione.

⚠️ L'Avvertimento: Quando il metodo fallisce

C'è un "ma". Gli autori hanno scoperto che questo metodo funziona bene solo se i numeri sono "educati" (ben bilanciati).
Se provi a usare questo trucco su numeri che hanno un rapporto estremo (ad esempio, moltiplicare un numero gigante come un miliardo per un numero minuscolo come un milionesimo), il metodo può fallire.
È come se provassi a misurare la distanza tra due stelle usando un righello di carta: anche se tagli il righello in mille pezzettini, non riuscirai mai a misurare con precisione quella distanza enorme. In questi casi, il computer deve tornare a usare i metodi lenti tradizionali.

🚀 I Risultati Sperimentali: Cosa hanno visto sui nuovi computer?

Gli autori hanno testato questa idea sui computer più potenti al mondo (i nuovi chip NVIDIA Blackwell e Hopper).

Risultato: Su matrici "normali" (numeri casuali), il metodo è fino a 7 volte più veloce rispetto ai metodi tradizionali, mantenendo una precisione quasi perfetta se si scelgono il numero giusto di fette.
Il rovescio della medaglia: Su matrici "strane" (quelle con numeri molto diversi tra loro), il metodo diventa lento o impreciso se non si aumenta drasticamente il numero di fette, annullando il vantaggio di velocità.

🎯 In Sintesi: Cosa ci insegna questo studio?

Questo articolo ci dice che possiamo usare i computer moderni (progettati per l'Intelligenza Artificiale e i numeri semplici) anche per la scienza di precisione, MA dobbiamo essere molto attenti:

Non è una soluzione magica per tutto: Funziona benissimo se i dati sono "ordinati".
Serve intelligenza: Bisogna capire prima quanti "tagli" (fette) servono per ogni specifico problema. Non si può usare la stessa ricetta per tutti i piatti.
Il futuro: Se impariamo a gestire bene queste "fette", potremo usare i supercomputer del futuro per fare scoperte scientifiche molto più velocemente, senza dover aspettare che i chip diventino più potenti, ma semplicemente usando meglio quelli che abbiamo già.

In parole povere: È come imparare a cucinare con un robot da cucina velocissimo. Se sai come tagliare gli ingredienti (le fette), prepari un pranzo da chef in un attimo. Se sbagli il taglio, il pasto viene male, anche se il robot è velocissimo.

Titolo

Analisi della moltiplicazione di matrici in virgola mobile calcolata tramite aritmetica intera.

1. Il Problema

Le moderne supercomputer exascale (come El Capitan, Frontier, Aurora e JUPITER) raggiungono prestazioni elevatissime sfruttando acceleratori hardware progettati per carichi di lavoro di machine learning. Questi acceleratori (es. Tensor Core di NVIDIA, Matrix Core di AMD) offrono throughput fino a due ordini di grandezza superiori rispetto all'aritmetica in virgola mobile a 64 bit (binary64), ma sono ottimizzati per formati a precisione ridotta (bfloat16, float16) o per l'aritmetica intera (INT8, INT4).

Tuttavia, le applicazioni scientifiche tradizionali richiedono la precisione e l'accuratezza del binary64. L'uso diretto di hardware a bassa precisione o intero per calcoli scientifici porta a errori significativi. Esiste quindi un bisogno critico di algoritmi a precisione mista che possano ricostituire operazioni in virgola mobile ad alta precisione (binary64) utilizzando le unità di calcolo intero ad alta velocità disponibili, senza sacrificare l'accuratezza necessaria per la scienza.

2. Metodologia: Lo Schema di Ozaki con Aritmetica Intera

Il paper analizza e migliora una variante dello Schema di Ozaki, originariamente proposto per l'aritmetica in virgola mobile, adattandolo all'uso di unità di moltiplicazione-accumulo (MMA) intere.

Il metodo funziona in tre fasi principali:

Rappresentazione in Ponto Fisso a Blocchi: Le righe della matrice $A$ e le colonne della matrice $B$ vengono scalate individualmente. Per ogni riga $i$ di $A$ e colonna $j$ di $B$ , viene calcolato un fattore di scala ( $\alpha_i$ e $\beta_j$ ) basato sul valore massimo assoluto in quella riga/colonna. Questo trasforma implicitamente gli elementi in una rappresentazione a punto fisso dove tutti gli elementi di un blocco condividono la stessa scala (una potenza di 2).
Slicing (Frammentazione) in Interi: Le rappresentazioni a punto fisso vengono suddivise in "fette" (slices). Ogni fetta contiene un sottoinsieme di bit significativi. Se $t$ è il numero di bit per fetta, le matrici vengono scomposte in $s$ fette ( $A^{(\ell)}$ e $B^{(h)}$ ). Il prodotto di due fette può essere calcolato esattamente usando l'aritmetica intera, purché il formato di accumulo sia sufficientemente ampio.
Accumulazione: I prodotti parziali interi $A^{(\ell)}B^{(h)}$ vengono convertiti in virgola mobile e accumulati. L'algoritmo originale di Ootomo, Ozaki e Yokota calcola solo i prodotti dove la somma degli indici delle fette $\ell + h$ è inferiore a una soglia, riducendo il numero di operazioni.

3. Contributi Chiave

Gli autori apportano due contributi fondamentali:

Nuova Analisi dell'Errore:
- Viene derivata una nuova analisi dell'errore che identifica una condizione critica di fallimento: se le righe di $A$ o le colonne di $B$ sono mal scalate (ovvero, contengono elementi con ordini di grandezza molto diversi all'interno della stessa riga/colonna), l'errore di conversione in punto fisso può diventare enorme, rendendo l'algoritmo inaccurato indipendentemente dal numero di fette usate.
- Viene proposto un metodo economico per stimare il numero minimo di fette necessarie per raggiungere un livello di accuratezza desiderato, basandosi sui fattori di condizionamento delle righe/colonne ( $\kappa_A, \kappa_B$ ).
- L'analisi dimostra che è possibile utilizzare un numero diverso di fette per le due matrici ( $s_A \neq s_B$ ) senza perdita di accuratezza, ottimizzando le prestazioni quando una matrice è ben scalata e l'altra no.
Sperimentazione Numerica su Hardware Recente:
- Vengono condotti esperimenti su GPU NVIDIA Hopper (H100) e Blackwell (B200), inclusi accessi anticipati a hardware non ancora pubblico.
- Si confrontano implementazioni dello schema di Ozaki con le routine standard cublas (binary64 puro) e una nuova implementazione NVIDIA chiamata cuIMMA (emulazione FP64 tramite istruzioni IMMA).

4. Risultati Sperimentali

Matrici Mal Scalate: Gli esperimenti confermano l'analisi teorica. Per matrici con un ampio intervallo dinamico (es. $\kappa_D = 10^{40}$ ), anche un numero elevato di fette ( $s=18$ ) non è sufficiente per ottenere accuratezza binary64. L'errore cresce esponenzialmente con lo squilibrio di scala.
Flessibilità delle Fette: Nel contesto della fattorizzazione LU a blocchi per risolvere sistemi lineari, si è osservato che per molte matrici reali è possibile ridurre il numero di fette per una delle due matrici (es. 1 fetta per una, 8 per l'altra) senza degradare la soluzione finale, migliorando le prestazioni.
Prestazioni su GPU Blackwell:
- Su GPU Hopper (H100), l'emulazione con 7 fette è più lenta dell'implementazione binary64 nativa a causa del rapporto prestazioni INT8/binary64 non sufficientemente alto.
- Su GPU Blackwell (B200), il rapporto prestazioni INT8/binary64 è molto alto (112.5x). Qui, l'emulazione con 7 fette supera le prestazioni di cublas mantenendo un'accuratezza indistinguibile.
- Tuttavia, per algoritmi di livello superiore (es. risolutori di autovalori), è stato necessario aumentare le fette a 8 per garantire la stabilità numerica, suggerendo che il numero ottimale di fette dipende dall'algoritmo specifico e non solo dalla moltiplicazione di matrici isolata.

5. Significato e Conclusioni

Il lavoro dimostra che lo schema di Ozaki basato su aritmetica intera è una strategia promettente per sfruttare l'hardware moderno per il calcolo scientifico ad alta precisione. Tuttavia, pone dei limiti importanti:

Non è un sostituto universale: Non può sostituire l'aritmetica binary64 nativa per matrici mal scalate senza un costo computazionale proibitivo (numero di fette eccessivo).
Gestione dei casi speciali: L'implementazione attuale non gestisce correttamente valori speciali IEEE 754 come zeri negativi, infiniti o NaN.
Ottimizzazione Dinamica: La chiave per l'adozione pratica risiede nella capacità di stimare dinamicamente il numero di fette necessario in base alle proprietà delle matrici in input (scalabilità), permettendo di bilanciare prestazioni e accuratezza.

In sintesi, il paper fornisce gli strumenti teorici e pratici per utilizzare efficientemente le nuove unità di calcolo intero nelle GPU per applicazioni scientifiche, ma avverte che l'accuratezza non è garantita a priori e dipende criticamente dalle proprietà dei dati in ingresso.