Vai al contenuto
← Intelligenza artificiale avanzata · Lezione 41

Modulo 11 · Lezione 11.1

Quanto costa eseguire un modello

Le dimensioni di un modello influenzano memoria, tempo e possibilità d’uso. Il numero di parametri è un punto di partenza, ma non descrive da solo tutte le risorse necessarie.

Dove va la memoria

I pesi conservano i parametri. Le attivazioni sono risultati intermedi del calcolo. Nell’addestramento servono anche gradienti e stato dell’ottimizzatore. Durante la generazione autoregressiva può crescere la cache del contesto.

Un miliardo di parametri memorizzati a 16 bit richiede circa due miliardi di byte per i soli pesi, cioè circa 2 GB decimali. Non è la memoria totale richiesta per eseguire il sistema: vanno aggiunti gli altri componenti e il costo dell’implementazione.

Precisione numerica e quantizzazione

La precisione numerica riguarda come rappresentiamo i numeri. La quantizzazione usa insiemi di valori più limitati, spesso rappresentazioni intere a pochi bit con scale e altri metadati.

Ridurre i bit può diminuire memoria e trasferimenti. Può anche introdurre errori numerici e modificare le uscite. Il vantaggio in velocità dipende dall’hardware e dalle operazioni supportate: un modello più piccolo in memoria non è sempre più veloce.

Schema ed esempio

Quanti byte occupano i pesi?

FP32
4 GB
FP16
2 GB
INT8
1 GB
INT4
0,5 GB
Scala comune : 0–4 GB
Come leggerla. Per un miliardo di parametri: FP32 ≈ 4 GB, FP16 ≈ 2 GB, INT8 ≈ 1 GB, INT4 ≈ 0,5 GB. Sono soli pesi in GB decimali; scale, cache, attivazioni e runtime richiedono altra memoria.

Scegliere un compromesso

Per un assistente locale interessano memoria disponibile, lunghezza del contesto, latenza e qualità sui propri compiti. È utile confrontare la versione di riferimento con quella quantizzata sugli stessi esempi.

Con la distillazione, invece, si addestra un modello più piccolo usando anche segnali di un modello più grande. Cambia il modello appreso, mentre la quantizzazione cambia principalmente la rappresentazione numerica dei calcoli o dei pesi coinvolti.

Esempio svolto: il modello entra davvero in memoria?

Un modello ha un miliardo di parametri. Con quattro byte per parametro i soli pesi occupano 4 miliardi di byte, cioè 4 GB decimali, circa 3,73 GiB. Con due byte diventano 2 GB; con quattro bit teorici diventano 0,5 GB, prima di scale, metadati e strutture aggiuntive. Le barre della figura confrontano questo conto limitato ai pesi.

Durante l’inferenza devi considerare anche attivazioni, cache, buffer temporanei e runtime. Nell’addestramento si aggiungono gradienti e stati dell’ottimizzatore. Di conseguenza, “pesi da 4 GB” non significa “basta una scheda da 4 GB”. La memoria effettiva va misurata sul percorso di esecuzione previsto, compresi batch e lunghezza del contesto.

Per capire la quantizzazione, prendi valori 0,12, 0,27 e 0,94 e una griglia semplificata con passo 0,1. Arrotondando ottieni 0,1, 0,3 e 0,9: errori −0,02, +0,03 e −0,04. Una rete combina molti valori, perciò l’effetto finale non si deduce dal solo errore su una coordinata. Le implementazioni reali usano scale e formati specifici.

Prima di scegliere il formato

La versione a bassa precisione occupa meno memoria, ma impiega più tempo sul tuo processore. È impossibile?

Soluzione: No: dipende dai kernel disponibili, dalle conversioni e dall’hardware. Misura qualità, memoria e latenza nella configurazione reale. Ridurre i bit non garantisce da solo un’accelerazione.

Pratica guidata

Calcola la memoria necessaria. Per un miliardo di parametri confronta quattro byte, due byte e quattro bit per peso. Scrivi byte, GB decimali e componenti esclusi dal conto. Poi immagina batch e contesto più lunghi: quali componenti possono crescere anche se il file dei pesi resta identico?

Come procedere

  1. Otto bit fanno un byte. La memoria totale include allocazioni che non sono parametri del modello.

  2. Quattro bit sono mezzo byte: il conto ideale dei pesi è 0,5 miliardi di byte, prima dei metadati.

Confronta la soluzione

I pesi ideali occupano 4 × 10⁹, 2 × 10⁹ e 0,5 × 10⁹ byte, cioè 4, 2 e 0,5 GB decimali. Mancano scale della quantizzazione, runtime, buffer, attivazioni e cache; in training anche gradienti e stati dell’ottimizzatore. Batch e contesto possono far crescere soprattutto cache e attivazioni. La riduzione del file non garantisce accelerazione: conversioni e kernel disponibili entrano nei tempi.

Prova su un caso nuovo

Per il progetto RAG, prepara un confronto fra due configurazioni locali a parità di domande e contesto. Registra memoria misurata, latenza e risposte supportate; separa stima dei soli pesi e picco osservato.

Controllo del tuo elaborato: Unità e perimetro di ogni misura sono espliciti; la memoria necessaria all’esecuzione è distinta da quella dei soli pesi.

Dalla pratica al laboratorio

L’approfondimento misura una versione piccola e quantizzata. I valori del laboratorio valgono per quel runtime: usa il tuo calcolo della memoria per capire che cosa misurare su un altro modello, senza scalare automaticamente i tempi.

Controlla il ragionamento

Scegli una risposta e leggi la spiegazione.

I pesi quantizzati entrano nella memoria disponibile. Quale verifica manca prima di stabilire se l’inferenza funzionerà?

La capacità dipende dal percorso di esecuzione, dal formato e dal runtime. Riporta separatamente conto teorico dei pesi e picco misurato.

Rileggi la spiegazione

Approfondimento tecnico facoltativo

Derivazioni e laboratorio

Lezione 11.1. Riprendiamo il decoder del modulo 5. Prima di ottimizzarlo definiamo quale quantità ridurre e quale degrado accettare. Spazio dei tensori, picco di memoria del processo e tempo di inferenza sono misure diverse.

Fare il conto prima del benchmark

Il decoder ha 19.456 parametri float32: i tensori del suo stato occupano 19.456·4=77.824 byte. Non è la memoria del processo Python: mancano runtime, oggetti, allocator, attivazioni e cache. Non è neppure la dimensione esatta di un file serializzato, che contiene metadati e altri overhead.

Durante un training Adam in float32, una stima dei soli stati persistenti è sedici byte per parametro: pesi, gradienti e due momenti, ciascuno da quattro byte. Vanno aggiunte attivazioni conservate per il backward e memoria temporanea. Mixed precision, copie master, sharding e implementazione dell’ottimizzatore possono cambiare il conto: la formula non va applicata fuori dalle sue ipotesi.

Il costo del calcolo dipende invece dalle operazioni e dalla loro organizzazione. Il tempo può essere limitato dalla capacità di calcolo oppure dai trasferimenti. Una stima inferiore elementare è max(FLOP/potenza, byte/banda), ignorando latenza, dipendenze e overhead. Questa idea aiuta a formulare ipotesi; il benchmark deve stabilire quale limite conta davvero nella configurazione scelta.

Quantizzazione simmetrica per riga

Per ogni riga di una matrice W scegliamo una scala positiva e rappresentiamo i pesi con interi:

qmax = 2^(b−1) − 1
s_i = max_j |W_ij| / qmax
q_ij = clip(round(W_ij / s_i), −qmax, qmax)
Ŵ_ij = s_i q_ij

Una riga nulla usa una protezione numerica per evitare divisioni per zero. Con questa scala, senza saturazione dovuta a errori numerici, l’errore di arrotondamento per elemento è al più sᵢ/2. Una scala per riga si adatta meglio a righe con ampiezze diverse rispetto a una sola scala globale, ma richiede più metadati.

L’errore dell’uscita lineare è Δy=(Ŵ−W)x. Quindi ||Δy|| ≤ ||Ŵ−W||·||x|| per norme compatibili. Un piccolo errore dei pesi può amplificarsi su input grandi o attraverso più strati; non basta controllare il bound locale. La letteratura sulla quantizzazione per inferenza intera tratta anche il rapporto fra rappresentazione e operazioni efficienti.

Che cosa implementa il laboratorio

Sostituiamo tutte le matrici Linear con buffer int8 e scale float32; embedding e normalizzazioni restano float32. Nel forward i pesi vengono dequantizzati e usati da F.linear in virgola mobile. Questo verifica la rappresentazione e il suo errore, ma non implementa un kernel di moltiplicazione int8.

Anche la variante a quattro bit usa un elemento int8 per peso: restringe i valori a −7…7 senza impacchettare due valori per byte. Non dimezza quindi lo storage rispetto agli otto bit. Entrambe le varianti occupano 27.888 byte di stato tensoriale, incluse scale, bias e parametri non quantizzati: circa il 35,8% della base. Il picco del forward include anche i pesi ricostruiti temporaneamente.

Scegliere con un limite di degrado

Prima del confronto fissiamo due criteri sullo sviluppo: aumento NLL massimo 0,02 e perdita di al più una risposta di stato su ventidue. Fra candidati ammissibili scegliamo il minor numero di byte; a parità scegliamo più bit. Questa regola non usa il test.

Variante NLL sviluppo Stati corretti Byte dello stato
Float32 0,886976 22/22 77.824
Otto bit 0,887184 22/22 27.888
Quattro bit in storage int8 0,891210 22/22 27.888

Entrambe passano, ma la regola seleziona otto bit. Sul test la NLL passa da 0,888938 a 0,888806 e lo stato resta corretto su 22/22. Il lieve miglioramento non dimostra una superiorità generale della quantizzazione: è il risultato di questa perturbazione su un campione molto piccolo e già usato nel percorso didattico.

Un bilancio di memoria con ipotesi verificabili

Per il decoder, la stima Adam tutta float32 dei quattro tensori persistenti è 19.456·16=311.296 byte. I momenti possono essere creati soltanto al primo aggiornamento e i gradienti possono essere liberati: la fase in cui misuri conta. Il picco può includere inoltre buffer dell’ottimizzatore, copie transitorie e attivazioni; sommare i parametri non misura automaticamente il massimo residente.

Nell’attenzione implementata esplicitamente, la matrice dei punteggi ha forma [B,H,T,T]: con float32 richiede 4BHT² byte per strato, prima di considerare softmax, backward e altri tensori. Raddoppiare T quadruplica questa voce. Implementazioni che evitano di materializzare tutta la matrice cambiano il conto; non applicare questa formula a qualunque kernel soltanto perché calcola attenzione. L’attivazione di un feed-forward di ampiezza d_ff ha invece scala B·T·d_ff.

Il checkpointing delle attivazioni conserva meno intermedi e li ricalcola durante il backward. Riduce una parte della memoria scambiandola con calcolo aggiuntivo; non elimina pesi e stati dell’ottimizzatore. Lo sharding agisce su altre voci e comporta comunicazione. Prima di scegliere una tecnica, identifica la voce dominante e misura la stessa fase del programma prima e dopo.

Costruzione guidata della quantizzazione

Parti da una sola matrice: salva scale e interi, ricostruisci i pesi e controlla l’errore massimo per riga. Confronta quindi l’uscita su input fissati e soltanto dopo sostituisci tutte le Linear del modello. Conta i byte effettivi di ogni buffer, incluse le scale; un’etichetta «4 bit» non dice come è codificato il tensore.

Infine applica il criterio di degrado sullo sviluppo e misura il test con la configurazione congelata. Per valutare un kernel quantizzato vero occorre un nuovo esperimento che specifichi backend, dtype di accumulo, hardware e forme dei tensori. La dequantizzazione del nostro codice è deliberatamente leggibile; il suo risultato non è un benchmark di quel kernel.

Esercizi

  1. Per una riga con massimo assoluto 1,27 e otto bit, calcola scala ed errore massimo di arrotondamento.

Soluzione: qmax=127, scala 0,01, errore al più 0,005 senza saturazione. L’errore dell’uscita dipende anche dagli input e dalla somma dei contributi.

  1. Il file del modello è più piccolo. Puoi affermare che il servizio usa la stessa frazione di RAM?

Soluzione: No. Runtime, attivazioni, cache e dequantizzazione possono dominare o cambiare il picco. Bisogna misurare la memoria del processo e dichiarare cosa si include.

  1. Perché la variante a quattro bit non viene selezionata?

Soluzione: Nel formato implementato occupa gli stessi byte di quella a otto bit. La regola di parità preferisce la precisione maggiore. Attribuirle un vantaggio di memoria richiederebbe implementare e misurare l’impacchettamento.

Prosegui con batching e latenze.

Tengo corsi di programmazione, analisi dati e intelligenza artificiale per aziende ed enti di formazione, in aula e da remoto. Scopri come insegno e quali materiali uso a lezione.