La matematica
dietro l'IA

L'IA moderna, in particolare i modelli linguistici di grandi dimensioni, i generatori di immagini e i sistemi di classificazione, poggia su una base matematica sorprendentemente compatta. Tutto, da ChatGPT che genera una frase a Stable Diffusion che produce un'immagine, si riduce al livello più basso alle stesse operazioni: moltiplicazione di matrici, funzioni non lineari e discesa del gradiente. La sofisticazione sta nel modo in cui queste primitive vengono combinate e scalate.

Questo articolo sviluppa la matematica a partire dai principi primi. Cominciamo con l'algebra lineare e la teoria della probabilità, passiamo all'ottimizzazione basata sul calcolo differenziale, costruiamo il formalismo delle reti neurali, deriviamo la backpropagation e arriviamo al meccanismo di attenzione e all'architettura transformer su cui si basa ogni grande modello linguistico del 2026. Nessuna scorciatoia: ogni equazione viene derivata o spiegata a partire dalle sue componenti.

Prerequisiti: dimestichezza con l'algebra delle superiori e con la notazione di base dell'analisi (derivate, regola della catena). Tutto il resto viene costruito qui.

1.1 Vettori e spazi vettoriali

Un vettore è una lista ordinata di numeri. Nell'IA i vettori rappresentano tutto: una parola, una porzione di immagine, una preferenza dell'utente, uno stato nascosto. Un vettore x nello spazio reale n-dimensionale si scrive:

L'insieme ℝⁿ è uno spazio vettoriale: è chiuso rispetto all'addizione e alla moltiplicazione per uno scalare, ha un vettore nullo e soddisfa gli otto assiomi degli spazi vettoriali. È questa struttura algebrica a rendere l'algebra lineare applicabile al machine learning: i layer delle reti neurali sono applicazioni lineari tra spazi vettoriali.

1.1.1 Il prodotto scalare e la similarità del coseno

Il prodotto scalare di due vettori x, y ∈ ℝⁿ è:

dove θ è l'angolo tra i vettori. Il prodotto scalare misura l'allineamento: è massimo quando x e y puntano nella stessa direzione (cos θ = 1), nullo quando sono perpendicolari (cos θ = 0) e minimo quando sono antiparalleli (cos θ = -1). Questa interpretazione geometrica è alla base dei meccanismi di attenzione: il prodotto scalare tra una query e una key misura quanto «si prestano attenzione» a vicenda.

La similarità del coseno normalizza il prodotto scalare dividendolo per il prodotto delle norme dei vettori:

La similarità del coseno è ampiamente usata nell'NLP per misurare la similarità semantica tra word embedding: i vettori che rappresentano parole di significato simile si raggruppano nello spazio degli embedding e hanno una similarità del coseno vicina a 1.

1.2 Matrici e trasformazioni lineari

Una matrice W ∈ ℝᵐˣⁿ rappresenta una trasformazione lineare da ℝⁿ a ℝᵐ. Moltiplicazione matrice-vettore:

È l'operazione centrale di un layer di rete neurale. Ogni riga W_i· è un vettore di pesi; l'output y_i è il prodotto scalare dell'i-esima riga con l'input x. La matrice W codifica ciò che il layer ha imparato: quali combinazioni lineari delle feature di input calcolare.

1.2.1 Moltiplicazione di matrici

Date le matrici A ∈ ℝᵐˣⁿ e B ∈ ℝⁿˣᵖ, il loro prodotto C = AB ∈ ℝᵐˣᵖ ha elementi:

La moltiplicazione di matrici non è commutativa (in generale AB ≠ BA) ma è associativa: A(BC) = (AB)C. Il costo computazionale della moltiplicazione di una matrice m×n per una matrice n×p è O(mnp), il costo dominante nelle grandi reti neurali. Per un transformer con dimensione nascosta d = 4096 che elabora una sequenza di 2048 token, una singola moltiplicazione di matrici costa O(2048 × 4096 × 4096) ≈ 34 miliardi di operazioni.

1.2.2 Trasposta e matrici simmetriche

La trasposta W^ᵀ di una matrice W scambia righe e colonne: (W^ᵀ)_ij = W_ji. Proprietà fondamentali: (AB)^ᵀ = B^ᵀA^ᵀ, (W^ᵀ)^ᵀ = W. Una matrice simmetrica soddisfa W = W^ᵀ.

La matrice dei pesi di attenzione QK^ᵀ/√d_k nei transformer viene calcolata come prodotto di matrici che coinvolge una trasposta — la matrice delle query Q ∈ ℝˢˣᵈ moltiplicata per la trasposta della matrice delle key K^ᵀ ∈ ℝᵈˣˢ, ottenendo una matrice s×s di pesi di attenzione, dove s è la lunghezza della sequenza.

1.3 Autovalori, autovettori e SVD

Un vettore v è un autovettore della matrice A se:

dove λ è l'autovalore corrispondente. Gli autovettori sono le direzioni che la matrice A scala senza ruotarle. L'insieme di tutti gli autovalori è lo spettro di A e ne caratterizza il comportamento: gli autovalori grandi amplificano le direzioni corrispondenti, quelli piccoli le attenuano.

La decomposizione ai valori singolari (SVD) generalizza l'autodecomposizione alle matrici non quadrate:

dove U ∈ ℝᵐˣᵐ e V ∈ ℝⁿˣⁿ sono matrici ortogonali (rotazione/riflessione) e Σ ∈ ℝᵐˣⁿ è diagonale con elementi non negativi σ₁ ≥ σ₂ ≥... ≥ σᵣ (i valori singolari). La SVD si usa nella compressione dei pesi: l'approssimazione a rango ridotto W_k = U_k Σ_k V_k^ᵀ, che usa solo i k valori singolari più grandi, fornisce la migliore approssimazione di rango k di W in norma di Frobenius — la base del fine-tuning LoRA (Low-Rank Adaptation).

1.4 Norme e regolarizzazione

La norma L2 (norma euclidea) di un vettore x ∈ ℝⁿ:

La norma di Frobenius di una matrice W ∈ ℝᵐˣⁿ:

Le norme quantificano la «dimensione» di vettori e matrici. Nell'ottimizzazione, aggiungere una penalità sulla norma alla funzione di loss — la regolarizzazione — penalizza i pesi grandi e previene l'overfitting. La regolarizzazione L2 (weight decay) aggiunge λ‖W‖²_F alla loss, facendo decadere i pesi verso zero durante l'addestramento.

2.1 Distribuzioni di probabilità

Una distribuzione di probabilità P su uno spazio campionario discreto X assegna P(x) ≥ 0 a ogni esito x ∈ X, con Σ_x P(x) = 1. La modellazione del linguaggio è esattamente questo: stimare una distribuzione sulle sequenze di token.

Per le variabili continue, la funzione di densità di probabilità (PDF) f(x) soddisfa f(x) ≥ 0 e ∫f(x)dx = 1. La probabilità di un intervallo è P(a ≤ X ≤ b) = ∫_a^b f(x)dx.

2.1.1 La distribuzione softmax

La funzione softmax converte un vettore di logit reali z ∈ ℝⁿ in una distribuzione di probabilità:

Proprietà: tutti gli output sono positivi, la loro somma è 1 (una distribuzione di probabilità valida) e i logit grandi corrispondono a probabilità vicine a 1, mentre quelli piccoli a valori prossimi a 0. Lo scaling con la temperatura modifica questo comportamento: softmax(z/T); per T → 0 tende all'argmax (one-hot), per T → ∞ tende alla distribuzione uniforme. I modelli linguistici campionano da questa distribuzione a ogni passo di generazione.

Il problema della stabilità numerica: exp(z) va in overflow per z grandi. La soluzione standard consiste nel sottrarre il massimo prima dell'esponenziazione:

2.2 Teoria dell'informazione

2.2.1 Entropia di Shannon

L'entropia H(P) di una distribuzione P ne misura l'incertezza, ossia il contenuto informativo medio di un esito:

L'entropia è massima quando P è uniforme (massima incertezza) ed è minima (= 0) quando P è deterministica. Una moneta equilibrata ha H = 1 bit; un dado a sei facce ha H = log₂(6) ≈ 2,58 bit. L'entropia di una lingua misura quanti bit per token servono per codificarla.

2.2.2 Entropia incrociata e divergenza KL

L'entropia incrociata (cross-entropy) H(P, Q) misura la lunghezza attesa del codice quando si usa la distribuzione Q per codificare campioni della distribuzione vera P:

È la loss di addestramento standard per la classificazione e la modellazione del linguaggio: P è la distribuzione vera delle etichette (one-hot), Q è la distribuzione prevista dal modello. Minimizzare l'entropia incrociata equivale a massimizzare la log-verosimiglianza dei dati secondo il modello.

La divergenza KL D_KL(P‖Q) misura quanto Q differisce da P:

La divergenza KL è nulla se e solo se P = Q quasi ovunque, ed è positiva altrimenti (disuguaglianza di Gibbs). Non è simmetrica: D_KL(P‖Q) ≠ D_KL(Q‖P). Compare nell'addestramento RLHF: il termine di penalità KL che impedisce al modello ottimizzato con fine-tuning di allontanarsi troppo dal modello base è D_KL(π_θ ‖ π_ref).

2.2.3 Perplexity

La perplessità (perplexity) è l'esponenziale della loss di entropia incrociata ed è la metrica standard per valutare i modelli linguistici:

Intuitivamente, la perplessità è la dimensione effettiva del vocabolario tra cui il modello sceglie a ogni passo. Una perplessità di 20 significa che il modello è, in media, incerto quanto lo sarebbe scegliendo uniformemente tra 20 opzioni equiprobabili. I modelli linguistici più avanzati raggiungono una perplessità di 3–8 sui benchmark standard.

2.3 Il teorema di Bayes

Il teorema di Bayes è il fondamento del machine learning probabilistico:

dove θ sono i parametri del modello, D sono i dati osservati, P(θ|D) è la probabilità a posteriori, P(D|θ) è la verosimiglianza, P(θ) è la probabilità a priori e P(D) = ∫P(D|θ)P(θ)dθ è la verosimiglianza marginale (evidenza). La stima di massima verosimiglianza (MLE) massimizza P(D|θ), ignorando il prior. La stima del massimo a posteriori (MAP) massimizza P(θ|D) ed equivale alla MLE con una regolarizzazione proporzionale a -log P(θ).

Il deep learning moderno usa di solito MLE/MAP anziché un'inferenza bayesiana completa, perché calcolare la distribuzione a posteriori su miliardi di parametri è computazionalmente intrattabile. La stima dell'incertezza negli LLM resta un problema di ricerca aperto.

3.1 Derivate e gradiente

La derivata di una funzione scalare f: ℝ → ℝ nel punto x misura il tasso di variazione istantaneo:

Per una funzione f: ℝⁿ → ℝ (come una funzione di loss), il gradiente ∇f ∈ ℝⁿ è il vettore delle derivate parziali:

Il gradiente punta nella direzione di massima salita. Muoversi nella direzione opposta al gradiente fa quindi scendere la funzione di loss: è la base della discesa del gradiente.

3.1.1 Jacobiana ed hessiana

Per una funzione a valori vettoriali f: ℝⁿ → ℝᵐ, la matrice jacobiana J ∈ ℝᵐˣⁿ contiene tutte le derivate parziali del primo ordine: J_ij = ∂f_i/∂x_j. La jacobiana dell'output di un layer rispetto al suo input è centrale nella backpropagation.

La matrice hessiana H ∈ ℝⁿˣⁿ di una funzione scalare contiene tutte le derivate parziali del secondo ordine: H_ij = ∂²f/(∂x_i ∂x_j). L'hessiana caratterizza la curvatura del paesaggio della loss: un'hessiana definita positiva indica un minimo locale, definita negativa un massimo locale, indefinita un punto di sella.

3.1.2 La regola della catena

La regola della catena è il fondamento matematico della backpropagation. Per le funzioni composte g(f(x)):

Per le funzioni a valori vettoriali, la regola della catena multivariata usa le jacobiane:

Una rete neurale è una composizione di funzioni: L(θ) = loss(fₙ(...f₂(f₁(x; W₁)); Wₙ)). La regola della catena, applicata ricorsivamente lungo questa composizione, calcola ∂L/∂W_i per ogni layer i — questa applicazione ricorsiva è la backpropagation.

3.2 La discesa del gradiente e le sue varianti

3.2.1 Discesa stocastica del gradiente

La discesa del gradiente classica aggiorna i parametri θ nella direzione opposta al gradiente:

dove η è il learning rate. Calcolare il gradiente esatto sull'intero dataset è costoso: O(N) passaggi in avanti per ogni passo. La discesa stocastica del gradiente (SGD) lo approssima usando un mini-batch B ⊂ D di dimensione b:

Il gradiente del mini-batch è uno stimatore non distorto del gradiente completo: E[g_B] = ∇L. La sua varianza diminuisce all'aumentare della dimensione del batch b: Var(g_B) = σ²/b.

3.2.2 Momentum

Il momentum accumula un vettore velocità v nella direzione delle componenti persistenti del gradiente:

Con β ∈ [0,9; 0,99], il momentum calcola di fatto una media dei gradienti su 1/(1-β) passi: 10 passi con β = 0,9, 100 passi con β = 0,99. Questo accelera la convergenza lungo le dimensioni piatte e smorza le oscillazioni lungo quelle ripide.

3.2.3 Adam: Adaptive Moment Estimation

Adam (Kingma & Ba, 2015) mantiene learning rate adattivi per ciascun parametro, tenendo traccia sia del momento primo (media) sia del momento secondo (varianza non centrata) dei gradienti:

Iperparametri tipici: β₁ = 0,9; β₂ = 0,999; ε = 10⁻⁸; η = 3×10⁻⁴. Il learning rate effettivo per ciascun parametro è η/√v̂_t: i parametri con varianza del gradiente elevata ricevono passi effettivi più piccoli, quelli con varianza bassa passi più grandi.

3.2.4 Pianificazione del learning rate

Di solito il learning rate η non viene mantenuto costante. Le pianificazioni più comuni includono warmup lineare + decadimento a coseno (usato nella maggior parte del preaddestramento dei transformer), cosine annealing con riavvii e decadimento polinomiale. La fase di warmup è cruciale per i modelli grandi: all'inizializzazione le stime del gradiente sono rumorose e un learning rate iniziale elevato può destabilizzare l'addestramento.

4.1 Il layer feedforward

Un singolo layer di rete neurale calcola una trasformazione lineare seguita da una funzione di attivazione non lineare σ:

dove W ∈ ℝᵐˣⁿ è la matrice dei pesi, b ∈ ℝᵐ è il vettore dei bias, x ∈ ℝⁿ è l'input e h ∈ ℝᵐ è lo stato nascosto. Senza σ, impilare più layer equivarrebbe a un'unica trasformazione lineare. La funzione di attivazione rompe questa linearità e rende le reti profonde capaci di rappresentare funzioni esponenzialmente più complesse.

4.2 Funzioni di attivazione

4.2.1 ReLU e varianti

Proprietà: computazionalmente banale, gradiente pari a 0 (x < 0) oppure 1 (x > 0), produce attivazioni sparse, non satura per valori positivi. Problema: la «dying ReLU» — i neuroni con x < 0 hanno gradiente nullo e non possono riprendersi.

GeLU (Gaussian Error Linear Unit), usata in GPT e BERT:

SwiGLU, usata in LLaMA/PaLM, è una variante con gating:

4.2.2 Sigmoide e tangente iperbolica

Entrambe soffrono del problema dei gradienti che svaniscono nelle reti profonde: per |x| >> 0 il gradiente σ'(x) = σ(x)(1-σ(x)) → 0, e i gradienti si annullano esponenzialmente mentre si propagano all'indietro. È stato il principale ostacolo all'addestramento delle reti profonde prima della ReLU e delle connessioni residue.

4.3 Percettroni multistrato (MLP)

Un MLP con L layer calcola:

Il teorema di approssimazione universale (Hornik, 1989) afferma che un MLP con un solo layer nascosto sufficientemente ampio può approssimare qualsiasi funzione continua su un dominio compatto con precisione arbitraria. Tuttavia, per molte classi di funzioni le reti profonde sono esponenzialmente più efficienti in termini di parametri rispetto a quelle poco profonde.

4.4 Backpropagation

La backpropagation calcola ∂L/∂W per ogni matrice dei pesi W di una rete neurale, applicando la regola della catena all'indietro lungo il grafo computazionale.

Definiamo i segnali di errore (gradienti a monte):

La ricorrenza della backpropagation:

# Forward pass
def forward(x, layers):
    activations = [x]
    pre_activations = []
    for W, b in layers:
        z = W @ activations[-1] + b
        pre_activations.append(z)
        activations.append(relu(z))
    return activations, pre_activations

# Backward pass
def backward(loss_grad, activations, pre_acts, layers):
    delta = loss_grad
    grads = []
    for l in reversed(range(len(layers))):
        W, b = layers[l]
        dW = delta @ activations[l].T  # ∂L/∂W
        db = delta.sum(axis=1)         # ∂L/∂b
        grads.insert(0, (dW, db))
        if l > 0:
            delta = (W.T @ delta) * relu_grad(pre_acts[l-1])
    return grads

4.5 Il problema dei gradienti che svaniscono ed esplodono

Il segnale di errore δₗ coinvolge un prodotto di L-l matrici jacobiane. Se il raggio spettrale ρ(J) < 1, i gradienti svaniscono esponenzialmente; se ρ(J) > 1, esplodono. Tra le soluzioni ci sono le connessioni residue (h = F(x) + x), il gradient clipping (‖g‖ > γ → riscalatura), la layer normalization e un'inizializzazione accurata (inizializzazione di He: W ~ N(0, 2/n_in)).

5.1 Batch normalization

γ e β sono parametri appresi che permettono alla rete di annullare la normalizzazione, se è ottimale farlo. La BatchNorm è problematica per i modelli linguistici perché le sequenze hanno lunghezza variabile e le statistiche del batch sono instabili con batch piccoli.

5.2 Layer normalization

Le statistiche della layer norm si calcolano per singolo esempio, non per batch: sono indipendenti dalla dimensione del batch e funzionano allo stesso modo in addestramento e in inferenza. Per questo la LayerNorm è la normalizzazione standard nei transformer. Nei transformer Pre-LN (da GPT-2 in poi), la LayerNorm viene applicata prima dei sottolayer di attenzione e MLP, garantendo dinamiche di addestramento più stabili su larga scala.

5.3 RMSNorm

La RMSNorm è circa il 10% più veloce della LayerNorm e dà risultati comparabili. È usata nelle architetture LLaMA, Mistral e Gemma. L'intuizione: il ricentramento della LayerNorm ha un effetto minimo sulla qualità del modello; il beneficio principale deriva dal riscalamento che controlla l'ampiezza delle attivazioni.

6.1 Token embedding

Una matrice di token embedding E ∈ ℝ^|V|×d associa a ogni token discreto del vocabolario V un vettore denso a d dimensioni:

La dimensione dell'embedding d è in genere compresa tra 512 e 4096 nei modelli moderni. La matrice degli embedding viene appresa insieme al resto del modello: i token vicini nello spazio degli embedding hanno schemi d'uso contestuale simili. La scoperta di Word2Vec, secondo cui l'aritmetica nello spazio degli embedding cattura relazioni semantiche (king - man + woman ≈ queen), è una proprietà emergente dell'addestramento su grandi corpora.

Weight tying: in molti modelli la matrice di proiezione di output W_out è condivisa con E^ᵀ, riducendo i parametri di |V|×d senza alcun peggioramento empirico.

6.2 Codifica posizionale

I transformer non hanno un ordinamento intrinseco: l'attenzione è equivariante rispetto alle permutazioni. La codifica posizionale inietta l'informazione sulla posizione.

6.2.1 Codifica posizionale sinusoidale

6.2.2 Rotary Position Embeddings (RoPE)

RoPE (Su et al., 2021), usata in LLaMA, Mistral e GPT-NeoX, codifica la posizione ruotando i vettori query e key in sottospazi 2D:

Il prodotto scalare dipende solo dalla posizione relativa m-n, non dalle posizioni assolute. Questo rende RoPE nettamente superiore alla codifica sinusoidale in termini di sensibilità alla posizione relativa e permette di estrapolare la lunghezza del contesto.

7.1 Scaled dot-product attention

Il meccanismo di attenzione calcola somme pesate dei valori, dove i pesi sono determinati dalla similarità tra query e key:

dove Q ∈ ℝˢˣᵈᵏ (query), K ∈ ℝˢˣᵈᵏ (key), V ∈ ℝˢˣᵈᵥ (valori). Il fattore di scala 1/√d_k impedisce ai prodotti scalari di diventare troppo grandi — senza di esso la softmax satura in distribuzioni quasi one-hot, provocando gradienti che svaniscono.

La matrice dei pesi di attenzione A = softmax(QK^ᵀ/√d_k) ∈ ℝˢˣˢ ha l'elemento A_ij, che rappresenta quanta attenzione la posizione i presta alla posizione j. L'output è una somma pesata dei valori: output_i = Σ_j A_ij V_j. Ciò permette a ogni posizione di aggregare informazioni da qualsiasi altra posizione della sequenza — la capacità distintiva dei transformer.

7.2 Multi-head attention

La multi-head attention esegue h operazioni di attenzione in parallelo in sottospazi a dimensione ridotta:

Head diverse apprendono pattern di attenzione diversi: alcune si concentrano sulle posizioni recenti (contesto locale), altre sulla struttura sintattica, altre ancora sulle relazioni semantiche. Con h=12 head e d=768 (BERT-base), ogni head opera in un sottospazio a 64 dimensioni.

7.3 Attenzione causale (mascherata)

Aggiungere -∞ alle posizioni mascherate prima della softmax dà exp(-∞) = 0, azzerando quei pesi di attenzione. L'attenzione risultante è triangolare inferiore: la posizione i presta attenzione alle posizioni 1,...,i ma non a i+1,...,s.

7.4 Complessità computazionale

L'attenzione standard è O(s²d) in tempo e O(s²) in memoria a causa della matrice di attenzione s×s. Tra le varianti efficienti ci sono FlashAttention (tiling per un'accelerazione di 2-4×, esatta), la sparse attention (O(s·w) con finestra di dimensione w), l'attenzione lineare (O(s·d²)) e la Multi-Query Attention (condivide K e V tra le head, riducendo la dimensione della KV cache di un fattore h).

8.1 Il blocco transformer

Un layer transformer è formato da due sottolayer, la multi-head self-attention e un MLP applicato posizione per posizione, ciascuno con connessione residua e layer normalization:

Il sottolayer MLP:

dove W₁ ∈ ℝ^4d×d e W₂ ∈ ℝ^d×4d. Con d=4096, questo MLP ha circa 134 milioni di parametri per layer.

8.2 Numero di parametri

Per GPT-3 (L=96, d=12288): 12 × 96 × 12288² ≈ 175 miliardi di parametri.

8.3 Il residual stream

Lo schema delle connessioni residue crea il residual stream: un vettore a d dimensioni che scorre attraverso l'intera rete e che ogni layer modifica in modo additivo:

L'approccio dell'interpretabilità meccanicistica considera il residual stream come un canale di comunicazione: le head di attenzione e i layer MLP vi leggono e vi scrivono aggiornamenti additivi, il che consente di studiare il flusso di informazioni.

9.1 Il paesaggio della loss

La funzione di loss di una rete neurale L: ℝⁿ → ℝ (dove n ~ 10⁹–10¹²) è fortemente non convessa. In teoria è intrattabile, eppure le grandi reti sovraparametrizzate sono relativamente facili da addestrare grazie alla sovraparametrizzazione (la maggior parte dei minimi locali è vicina al minimo globale), al regime NTK (le reti di ampiezza infinita convergono come una regressione kernel) e alla regolarizzazione implicita (la SGD trova minimi piatti e generalizzabili).

9.2 Le leggi di scaling di Chinchilla

Hoffmann et al. (2022) hanno ricavato leggi di scaling empiriche che mettono in relazione il budget computazionale C, la dimensione del modello N e la dimensione del dataset D:

dove E ≈ 1,69 (entropia irriducibile), α ≈ β ≈ 0,34. Il risultato chiave: a parità di calcolo C = 6ND, il compromesso ottimale è N_opt ∝ C^0,5 e D_opt ∝ C^0,5 — dimensione del modello e dimensione del dataset dovrebbero crescere in egual misura. Ne consegue che GPT-3 (175 miliardi di parametri, 300 miliardi di token) era nettamente sottoaddestrato.

9.3 Addestramento a precisione mista

I modelli moderni si addestrano a precisione mista: passaggio in avanti in float16 per efficienza di memoria, aggiornamento dei pesi in float32 per stabilità numerica.

# Forward pass in fp16
with torch.autocast(device_type='cuda', dtype=torch.float16):
    logits = model(input_ids)
    loss = cross_entropy(logits, targets)

# Backward pass: gradients in fp16
scaler.scale(loss).backward()

# Gradient unscaling + clipping in fp32
scaler.unscale_(optimizer)
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

# Weight update in fp32 (master weights)
scaler.step(optimizer)
scaler.update()

Il BFloat16 è preferito al float16: ha lo stesso esponente a 8 bit del float32 (stesso intervallo dinamico) ma solo 7 bit di mantissa, ed evita overflow/underflow senza bisogno del loss scaling.

9.4 Addestramento distribuito

Addestrare un modello da 70B richiede circa 140 GB di memoria GPU solo per i pesi. Le strategie includono il parallelismo dei dati (replicare il modello e sincronizzare i gradienti), il parallelismo tensoriale (suddividere le matrici dei pesi tra le GPU), il parallelismo a pipeline (assegnare i layer a GPU diverse) e ZeRO (partizionare stati dell'ottimizzatore, gradienti e pesi tra i worker, consentendo modelli di dimensioni arbitrarie).

10.1 L'obiettivo autoregressivo

A ogni posizione t, il modello prevede una distribuzione sull'intero vocabolario V dati tutti i token precedenti. Questo semplice obiettivo di previsione del token successivo, applicato su scala enorme, basta per apprendere rappresentazioni ricche del linguaggio, conoscenze fattuali e capacità di ragionamento.

10.2 Strategie di decodifica

10.2.1 Scaling con la temperatura

T < 1 rende la distribuzione più appuntita (più deterministica), T > 1 la appiattisce (più casuale). T = 0 si riduce all'argmax (decodifica greedy).

10.2.2 Campionamento top-k

10.2.3 Campionamento nucleus (top-p)

Il top-p è adattivo: più token quando il modello è incerto, meno quando è sicuro. Impostazioni tipiche: temperatura 0,7–1,0, top-p 0,9–0,95.

10.2.4 Beam search

La beam search massimizza direttamente la probabilità. È preferita per la traduzione e gli output strutturati; per la generazione aperta si preferisce il campionamento.

10.3 La cache key-value

Durante l'inferenza autoregressiva, la KV cache conserva i tensori K e V già calcolati, rendendo ogni passo di generazione O(sd) anziché O(s²d), ma occupando O(2Lsd) di memoria: per un modello da 70B, circa 320 GB in float16. La compressione della KV cache è un'area di ricerca attiva e cruciale per l'inferenza su contesti lunghi.

kv_cache = {}

def generate_step(input_token, kv_cache, model):
    q, k, v = model.qkv_proj(embed(input_token))

    if layer_idx in kv_cache:
        K = torch.cat([kv_cache[layer_idx][0], k], dim=1)
        V = torch.cat([kv_cache[layer_idx][1], v], dim=1)
    else:
        K, V = k, v

    kv_cache[layer_idx] = (K, V)
    output = scaled_dot_product_attention(q, K, V)
    return output, kv_cache

11.1 La pipeline in tre fasi

L'RLHF allinea i modelli linguistici preaddestrati alle preferenze umane in tre fasi: fine-tuning supervisionato (SFT), addestramento del reward model e ottimizzazione tramite RL.

11.2 Il reward model

Un reward model R_φ: (prompt, completamento) → ℝ viene addestrato su dati di preferenza umana a coppie:

11.3 Ottimizzazione con PPO

Il modello linguistico π_θ viene ottimizzato per massimizzare la ricompensa attesa restando vicino alla policy di riferimento:

Il termine KL previene il reward hacking, cioè che il modello si allontani per sfruttare i punti deboli del reward model. L'obiettivo surrogato con clipping di PPO impedisce aggiornamenti della policy troppo ampi, che destabilizzerebbero l'addestramento.

11.4 Direct Preference Optimization (DPO)

La DPO (Rafailov et al., 2023) evita del tutto il reward model:

La DPO è matematicamente equivalente all'RLHF ma più semplice e stabile, e non richiede un reward model separato. La maggior parte delle pipeline di fine-tuning moderne usa la DPO o sue varianti (IPO, KTO) al posto di PPO.