L'addestramento e il ragionamento di grandi modelli spesso coinvolgono il concetto di accuratezza, e ne sono molti tipi, e sono anch'essi suddivisi in diversi formati allo stesso livello di accuratezza. Inoltre, esistono anche i concetti di multi-precisione e precisione mista in scenari pratici.
Precisione comune
Accuratezza in virgola mobile: doppia precisione (FP64), precisione singola (FP32, TF32), mezza precisione (FP16, BF16), precisione a 8 bit (FP8), accuratezza a 4 bit (FP4, NF4)
Accuratezza della quantificazione: INT8, INT4 (anche INT3/INT5/INT6)
Un numero in virgola mobile è composto da tre parti: bit di segno, esponenziale e mantissa. Più grande è il bit esponenziale, più ampio è l'intervallo di numeri che può essere rappresentato. Più grande è la cifra della mantissa, maggiore è la precisione del numero.
La tabella lo riassume come segue
| formato | bit simbolico | Bit esponenziale | Decimale | Cifre totali | | FP64 | 1 | 11 | 52 | 64 | | FP32 | 1 | 8 | 23 | 32 | | TF32 | 1 | 8 | 10 | 19 | | BF16 | 1 | 8 | 7 | 16 | | FP16 | 1 | 5 | 10 | 16 | | FP8 E4M3 | 1 | 4 | 3 | 8 | | FP8 E5M2 | 1 | 5 | 2 | 8 | | FP4 | 1 | 2 | 1 | 4 |
FP32: Numero in virgola mobile a 32 bit, 4 byte per dato
TF32: numero in virgola mobile a 19 bit, ogni dato corrisponde a 2 byte
FP16: numero in virgola mobile a 16 bit, 2 byte per dato
BF16: numero in virgola mobile a 16 bit, ciascun dato è di 2 byte
Int8: intero a 8 bit, ogni dato rappresenta 1 byte
Int4: interi a 4 bit, ogni dato corrisponde a 0,5 byte
Perché tanta precisione
Per il costo e la precisione. Sappiamo tutti che un'alta precisione è sicuramente più accurata, ma comporterà anche costi di calcolo e storage più elevati. Una precisione inferiore riduce la precisione dei calcoli ma può migliorare l'efficienza e le prestazioni computazionali. Quindi una varietà di precisioni diverse ti permette di scegliere quella più adatta in situazioni diverse.
La doppia precisione è più precisa dell'espressione a precisione singola, ma occupa il doppio dello spazio di archiviazione e richiede più tempo per essere calcolata.
Perché i modelli grandi devono essere quantificati?
1. Ridurre l'uso della memoria
I modelli grandi solitamente utilizzano numeri in virgola mobile a 32 bit (FP32) o numeri in virgola mobile a 16 bit (FP16) per rappresentare pesi e valori di attivazione. Attraverso la quantizzazione, questi valori ad alta precisione possono essere convertiti in rappresentazioni a bassa precisione (ad esempio, interi a 8 bit, INT8), riducendo significativamente lo spazio di archiviazione del modello. Questo è importante per la distribuzione su dispositivi a risorse limitate come dispositivi mobili, sistemi embedded, ecc.
2. Accelerare la velocità di ragionamento
I modelli quantizzati possono funzionare in modo più efficiente sull'hardware. Molti hardware moderni (come GPU, TPU, NPU, ecc.) dispongono di un supporto specializzato per l'ottimizzazione per calcolo a bassa precisione, consentendo operazioni di quantizzazione più rapide. Inoltre, i calcoli a bassa precisione spesso comportano meno operazioni su bit, riducendo la complessità computazionale e accelerando così l'inferenza.
3. Ridurre il consumo energetico
Il modello quantizzato non solo riduce la necessità di risorse di calcolo, ma riduce anche il consumo energetico. Questo è particolarmente importante per dispositivi alimentati a batteria come smartphone, dispositivi IoT, ecc., dove un basso consumo energetico significa una maggiore durata della batteria.
4. Dispositivi edge facili da distribuire
Molti grandi modelli sono stati inizialmente addestrati e distribuiti nel cloud, ma con lo sviluppo dell'edge computing, sempre più scenari applicativi richiedono che i modelli vengano distribuiti su dispositivi edge. Con una potenza di calcolo limitata e risorse di archiviazione sui dispositivi edge, la quantizzazione può aiutare questi modelli a funzionare in modo più efficiente sui dispositivi edge.
5. Ridurre i requisiti di banda
Nel processo di inferenza distribuita o aggiornamenti del modello, la quantizzazione può ridurre la larghezza di banda richiesta per il trasferimento del modello. Questo è utile per ambienti con larghezza di banda di rete limitata, come i dispositivi IoT in aree remote.
6. Mantenere le prestazioni del modello
Sebbene la quantizzazione introduca una certa perdita di precisione, le prestazioni originali del modello possono essere in gran parte preservate attraverso metodi di quantizzazione appropriati (come la quantizzazione a precisione mista, la quantizzazione post-addestramento, l'addestramento alla percezione quantitativa, ecc.). Pertanto, nelle applicazioni pratiche, la quantificazione può trovare un buon equilibrio tra prestazioni ed efficienza.
Riferimento della memoria
| digitare | Ogni miliardo di parametri deve occupare memoria | | float32 | 4G | | FP16/BF16 | 2G | | int8 | 1G | | int4 | 0,5G |
FP64 (Doppia Precisione)
La virgola mobile a 64 bit, tipicamente un formato binario a doppia precisione definito dalla IEEE 754, ha:
Simbolo a 1 cifra
Indice a 11 cifre
52 decimali
Intervallo: ~2,23e-308... ~1,80e308 con precisione decimale completa 15-17.
Uso:
Questo formato viene utilizzato per calcoli scientifici che richiedono alta precisione.
Non viene tipicamente utilizzato per i calcoli di deep learning.
Supporto software:
Rappresenta il doppio tipo nella maggior parte dei sistemi C/C++.
Supportato da TensorFlow (ad esempio tf.float64) / PyTorch (ad esempio torch.float64 o torch.double).
Supporto hardware:
Tipicamente supportato nelle CPU x86.
La maggior parte delle GPU, soprattutto quelle da gaming, inclusa la serie RTX, è fortemente limitata nelle prestazioni FP64 (di solito 1/32 delle prestazioni FP32 invece che 1/2).
Le recenti GPU senza restrizioni supportate da FP64 includono GP100/100/102/104 su Tesla P40/P4 e Quadro GP100, GV100 su Tesla V100/Quadro GV100/Titan V, e la recentemente annunciata GA100 in A100 (curiosamente, la nuova architettura Ampere ha una terza generazione) rispetto ai Tensor Core abilitati FP64 Ora è incluso il nuovo processore FP64 conforme all'IEEE, che offre 2,5 volte le prestazioni FP64 del V100.
FP32 (Massima accuratezza)
Questo formato è da tempo un punto di riferimento per il deep learning. Un altro formato IEEE 754, a virgola mobile a precisione singola, ha:
Simbolo a 1 cifra
Indice a 8 cifre
23 decimali
Idealmente, sia l'addestramento che l'inferenza dovrebbero essere effettuati in FP32, ma FP32 è il doppio più lento di FP16/BF16, quindi nella pratica si usano spesso metodi di precisione mista, dove i pesi FP32 sono usati come esatto "peso master", i pesi FP16/BF16 vengono usati per calcoli di propagazione avanti e indietro per migliorare la velocità di addestramento, e infine i pesi sovrani FP32 vengono aggiornati con gradienti FP16/BF16 nella fase di aggiornamento del gradiente.
Durante l'allenamento, il peso sovrano è sempre FP32. In pratica, i pesi a mezza precisione spesso forniscono una precisione simile a FP32 durante l'inferenza - perché pesi esatti FP32 sono necessari solo quando il gradiente del modello viene aggiornato. Questo significa che possiamo usare pesi a mezza precisione durante l'inferenza, così possiamo ottenere lo stesso risultato con solo metà della memoria GPU.
Intervallo: ~1,18e-38... ~3,40e38 con una precisione di 6-9 decimali significativi.
Uso:
Il tipo standard di calcolo per reti neurali da molto tempo. Pesi, attivazioni e altri valori nelle reti neurali sono da tempo predefiniti su FP32.
Per molti calcoli scientifici, specialmente quelli iterativi, l'accuratezza non è sufficiente, portando all'accumulo di errori.
Supporto software:
Rappresenta il tipo float sulla maggior parte dei sistemi C/C++.
Supportato da TensorFlow (ad esempio tf.float32) / PyTorch (ad esempio torch.float32 o torch.float).
Supporto hardware:
Tipicamente supportato nelle CPU x86.
Tipicamente supportata da GPU NVIDIA/AMD.
FP16 (Precisione a metà)
Analogamente, il formato standard IEEE 754, il formato a virgola mobile a mezza precisione, ha:
Simbolo a 1 cifra
Indice a 5 cifre
10 decimali
Il numero FP16 ha un intervallo numerico molto più basso rispetto a FP32. Pertanto, FP16 è a rischio di overflow (quando usato per rappresentare numeri molto grandi) e underflow (quando usato per rappresentare numeri molto piccoli). Ad esempio, quando si fa 10k * 10k, il risultato finale dovrebbe essere 100M, che FP16 non può rappresentare perché il numero massimo che FP16 può rappresentare è 64k. Quindi si ottiene NaN (Non un Numero) nei calcoli delle reti neurali, perché i calcoli vengono fatti in ordine stratificato e batch, quindi una volta che NaN appare, tutti i calcoli precedenti vengono distrutti. In generale, questo può essere mitigato con la scala delle perdite, ma questo approccio non sempre funziona.
Portata: ~5.96e−8 (6.10e−5) ... 65504, con un'accuratezza di 4 cifre decimali significative.
Uso:
Il deep learning tende a usare FP16 invece di FP32, poiché i calcoli a bassa precisione sembrano non essere rilevanti per le reti neurali. La precisione extra non serve a nulla, e allo stesso tempo è più lenta, richiede più memoria e rallenta la comunicazione.
Può essere usato per l'addestramento, solitamente con addestramento a precisione mista (TensorFlow/PyTorch).
Può essere utilizzato per la quantizzazione post-addestramento per accelerare l'inferenza (TensorFlow Lite). Altri formati utilizzati per la quantizzazione post-addestramento includono interi INT8 (interi a 8 bit), INT4 (4 bit) e persino INT1 (valori binari).
Supporto software:
Attualmente non sono nello standard C/C++ (ma esiste una breve proposta di float). Alcuni sistemi C/C++ supportano __fp16 tipi. Altrimenti, può essere utilizzato con librerie speciali.
Supportato in TensorFlow (ad esempio tf.float16) / PyTorch (ad esempio torch.float16 o torch.half).
Supporto hardware:
Le CPU x86 non sono supportate (come tipo unico).
Il supporto sulle vecchie GPU da gaming è scarso (prestazioni 32/1 per FP64, vedi il post sulle GPU per maggiori dettagli). Attualmente è ben supportata su GPU moderne, come la serie NVIDIA RTX.
BFLOAT16 (Precisione a Mezzo)
Un altro formato a 16 bit originariamente sviluppato da Google si chiama "Brain Floating Point Format", o "bfloat16" in breve. Il nome deriva da Google Brain.
L'IEEE FP16 originale fu progettato senza considerare applicazioni di deep learning e la sua gamma dinamica era troppo ristretta. BFLOAT16 risolve questo problema, offrendo la stessa gamma dinamica dell'FP32.
Pertanto, BFLOAT16 hanno:
Simbolo a 1 cifra
Indice a 8 cifre
7 decimali
Il formato bfloat16 è troncato in IEEE 754 FP32, consentendo una rapida conversione da e da IEEE 754 FP32. Quando si converte al formato bfloat16, i bit esponenziali vengono preservati, mentre i campi di mantissa possono essere ridotti tramite troncamento.
Intervallo: ~1.18e-38... ~3.40e38 con 3 decimali significative.
Uso:
Ora sembra che stia sostituendo FP16. A differenza di FP16, che spesso richiede un elaboramento speciale tramite tecniche come il loss scaling, BF16 è quasi un sostituto diretto di FP32 durante l'addestramento e l'esecuzione di reti neurali profonde.
Supporto software:
Non nello standard C/C++. Può essere utilizzato con librerie speciali.
Supportato in TensorFlow (ad es. tf.bfloat16) / PyTorch (ad esempio torch.bfloat16).
TF32
TensorFloat-32 o TF32 è la nuova modalità matematica nelle GPU NVIDIA A100.
Utilizzando le stesse mantisse a 10 bit della matematica a mezza precisione (FP16), il TF32 dimostra di avere abbastanza margine per soddisfare i requisiti di precisione dei carichi di lavoro dell'IA. E TF32 utilizza lo stesso indice a 8 bit di FP32, quindi può supportare lo stesso intervallo numerico.
Tecnicamente, è un formato a 19 bit. Pensalo come a un BFLOAT16 di precisione estesa, come "BFLOAT19" o a una precisione diminuita come FP32.
Quindi, TF32 ha:
Simbolo a 1 cifra
Indice a 8 cifre
10 decimali
Il vantaggio di TF32 è che ha lo stesso formato di FP32. Nel calcolo del prodotto interno con TF32, la mantissa dell'operando di ingresso viene arrotondata da 23 a 10 bit. Gli operandi di arrotondamento vengono moltiplicati esattamente e accumulati in normale FP32.
Il Tensor Core di TF32 funziona con input FP32 e genera risultati in FP32 senza modifiche di codice. Le operazioni non matriciali continuano a utilizzare FP32. Questo offre un modo semplice per accelerare i dati di input/output FP32 nei framework di deep learning e nell'HPC.
Intervallo: ~1.18e-38... ~3.40e38 con una precisione di 4 decimali significative.
Uso:
Una delle cose migliori di TF32 è che ha bisogno solo del supporto del compilatore al livello più profondo, cioè all'interno del compilatore CUDA. Il resto del codice mostra FP32 con meno precisione, ma con la stessa gamma dinamica. Usare TF32 serve principalmente a fare chiamate alla libreria per verificare se funziona correttamente. La presenza del TF32 permette plug-in rapidi, sfruttando la velocità dei Tensor Core senza troppo lavoro.
Formati come FP16 e BFLOAT16 richiedono ulteriori aggiustamenti perché coinvolgono layout di bit diversi. Ma l'uso di questi formati riduce la larghezza di banda della memoria, permettendo un'esecuzione più rapida.
Per confronto, le prestazioni massime dell'A100 sono:
FP32 senza nuclei tensoriali: 19,5 TFLOPS
Nuclei tensoriali TF32: 156 TFLOPS (quindi usare TF32 invece di FP32 rende facile aumentare la velocità).
Nuclei tensoriali FP16/BF16: 312 TFLOPS (quindi, un passaggio ragionevole a FP16/BF16 può portare maggiori guadagni di velocità, ma a un costo maggiore).
Supporto software:
Non nello standard C/C++.
CUDA 11 supportato.
Supporto hardware:
GPU: NVIDIA A100 è il primo modello supportato
FP8
Introdotta dalla GPU H100, consente una maggiore moltiplicazione e convoluzione matriciale, ma con una precisione inferiore.
I tipi di dati FP100 supportati da H8 sono in realtà due tipi di dati diversi che possono essere utilizzati per diverse parti dell'addestramento delle reti neurali:
E4M3 - consiste in 1 bit simbolico, 4 bit esponenziali e 3 decimali. Può immagazzinare fino a +/-448 e nan.
E5M2 - consiste in 1 bit di segno, 5 bit esponenziali e 2 decimali. Può memorizzare valori fino a +/-57344, +/-inf e nan. Il compromesso dell'aumentare la gamma dinamica è che i valori memorizzati sono meno accurati.
Struttura dei tipi di dati in virgola mobile. Tutti i valori visualizzati (in FP16, BF16, FP8 E4M3 e FP8 E5M2) sono la rappresentazione più fedele del valore 0,3952.
Entrambi i tipi possono essere utilizzati durante l'addestramento di una rete neurale. In generale, l'attivazione e i pesi in avanti richiedono maggiore precisione, quindi è meglio utilizzare il tipo di dati E4M3 durante il passaggio in avanti. Tuttavia, nella retropropagazione, il gradiente che scorre attraverso la rete è generalmente meno suscettibile a perdite di precisione ma richiede un range dinamico più elevato. Pertanto, è meglio memorizzarli utilizzando il formato dati E5M2. L'H100 TensorCore supporta qualsiasi combinazione di questi tipi come input, permettendoci di memorizzare ogni tensore con la precisione preferita.
Riferimento:
Il login del link ipertestuale è visibile.
Il login del link ipertestuale è visibile. |
Pubblicato il 10-03-2025 14:22:34
|
|
|
|
