Entropia, cross-entropy, KL divergence

Ogni training run di un language model moderno minimizza una sola quantità, e questa quantità ha un nome preciso: cross-entropy. Ogni perplexity riportata in un paper di NLP è l’esponenziale di quella stessa quantità. Capire entropia, cross-entropy e KL divergence non è un esercizio di teoria dell’informazione: è capire cosa sta cercando di fare il modello mentre si addestra.

Perché questo capitolo

Tre osservazioni motivano la trattazione.

La prima è che la loss function di praticamente ogni rete neurale supervisionata moderna — classificazione di immagini, traduzione automatica, autoregressive language modeling — è la cross-entropy. Quando si scrive loss = F.cross_entropy(logits, targets) in PyTorch, o quando un trainer di Hugging Face stampa loss: 2.34 durante il pre-training, quel numero è una stima della quantità H(p_data, p_θ) = -E_{x~p_data}[log p_θ(x)]. Sapere come si comporta, perché ha quella forma, e cosa significa minimizzarla è un prerequisito per leggere qualsiasi paper di deep learning con consapevolezza.

La seconda è che la perplessità — la metrica più diffusa per valutare language model — non è altro che l’esponenziale della cross-entropy media per token. Una perplexity di 10 significa “il modello è incerto come se dovesse scegliere uniformemente tra 10 token alternativi”. Senza la lente della teoria dell’informazione, perplexity è un numero magico. Con la lente, è una quantità interpretabile, confrontabile (con cautela), e collegata al limite teorico di Shannon sulla compressione.

La terza è che entropia e KL divergence appaiono in posti che apparentemente non hanno nulla a che vedere con la compressione: distillation di modelli (Hinton, Vinyals, Dean 2015), variational inference, regolarizzazione tramite label smoothing, contrastive learning, reinforcement learning con KL penalties (RLHF), reward modeling. Sono lo strumento universale per dire “quanto due distribuzioni si assomigliano” in un modo che ha proprietà matematiche utili. Non capirle vuol dire trattare ognuno di questi sistemi come una scatola nera con manopole arbitrarie.

L’obiettivo di questo capitolo è installare le tre quantità — entropia H(p), cross-entropy H(p, q), KL divergence KL(p||q) — con il minimo di formalismo e il massimo di intuizione, fino al punto in cui frasi come “minimizzare la cross-entropy equivale a massimizzare la likelihood” non richiedano più traduzione mentale.

Contesto

Il personaggio fondante è Claude Shannon (1916-2001, ingegnere e matematico americano dei Bell Telephone Laboratories), che nel 1948 pubblica A Mathematical Theory of Communication sul Bell System Technical Journal (vol. 27, pp. 379-423 e 623-656). Il problema che si pone è ingegneristico: dato un canale rumoroso e una sorgente che emette simboli secondo una distribuzione P, quanti bit servono in media per trasmettere ogni simbolo, e qual è il massimo throughput affidabile? La risposta a entrambe le domande passa per una quantità nuova:

$$H(P) = -Σ_i p_i log p_i$$

che Shannon chiama entropia, su suggerimento — racconta lui stesso — di John von Neumann (1903-1957, matematico ungherese-americano), il quale gli avrebbe detto: “chiamala entropia, perché nessuno sa cosa sia veramente, e in un dibattito avrai sempre un vantaggio”. L’aneddoto è citato da Tribus e McIrvine nel 1971; sia o non sia letterale, il legame con l’entropia termodinamica di Ludwig Boltzmann (1844-1906, fisico austriaco, S = k_B ln W) è formale, non solo verbale: nell’ensemble microcanonico le due formule coincidono modulo costanti.

Tre anni dopo, Solomon Kullback (1907-1994) e Richard Leibler (1914-2003), due matematici dell’NSA americana che lavoravano in crittanalisi, pubblicano On Information and Sufficiency (Annals of Mathematical Statistics, 1951, vol. 22(1), pp. 79-86). Il paper introduce la quantità

$$KL(P||Q) = Σ_i p_i log(p_i / q_i)$$

come misura della “discriminazione” tra due ipotesi P e Q nel contesto della statistica della sufficienza di Fisher. Il termine “divergenza di Kullback-Leibler” è posteriore agli autori; loro la chiamano semplicemente “directed divergence” e “information for discrimination”.

Nel 1957 Edwin Jaynes (1922-1998, fisico americano) collega entropia statistica e meccanica statistica nel paper Information Theory and Statistical Mechanics (Physical Review, vol. 106(4), pp. 620-630). Formula il principio di massima entropia (MaxEnt): tra tutte le distribuzioni compatibili con i vincoli noti (momenti misurati, conservazioni fisiche), scegli quella di entropia massima. È la distribuzione “meno informativa al di là di ciò che hai dichiarato di sapere”.

Decenni dopo, nel 2015, Geoffrey Hinton (1947-, informatico britannico-canadese, premio Turing 2018), Oriol Vinyals e Jeff Dean pubblicano Distilling the Knowledge in a Neural Network (arXiv:1503.02531), che usa la KL divergence come loss per trasferire conoscenza da un modello “teacher” grande a uno “student” piccolo via soft targets prodotti con temperatura. È uno dei modi in cui la KL divergence è entrata nella cassetta degli attrezzi del deep learning practitioner.

Sul lato della compressione, il filo parte da David Huffman (1925-1999, allora studente al MIT) che nel 1952 pubblica A Method for the Construction of Minimum-Redundancy Codes (Proceedings of the IRE, vol. 40(9), pp. 1098-1101). L’algoritmo greedy di Huffman costruisce, per una distribuzione data, il codice prefix-free a lunghezza media minima per simbolo. La lunghezza media che produce non scende sotto H(P): l’entropia è il limite inferiore, esattamente come Shannon aveva dimostrato.

I due testi di riferimento moderni sono Information Theory, Inference, and Learning Algorithms di David MacKay (1967-2016, fisico britannico, Cambridge University Press, 2003), gratuito online e con un taglio bayesiano-machine-learning, e Elements of Information Theory di Thomas Cover e Joy Thomas (Wiley, 2006, 2a ed.), il riferimento formale standard. Per il taglio deep learning, Deep Learning di Goodfellow, Bengio, Courville (MIT Press, 2016), capitolo 3.13.

Decoder rapido dei termini operativi:

• Entropia H(P): valore atteso della “sorpresa” -log p(X) sotto P. Misurata in bit (log base 2) o nat (log naturale).
• Self-information o surprisal: la quantità -log p(x), la sorpresa di un singolo evento.
• Cross-entropy H(P, Q): valore atteso di -log q(X) sotto P. Quanti bit servono in media se codifichiamo P credendo che la distribuzione sia Q.
• KL divergence KL(P||Q): differenza tra cross-entropy e entropia, ovvero il costo di usare Q al posto di P. Sempre ≥ 0.
• Negative log-likelihood (NLL): la quantità -log p_θ(y) per un singolo esempio, o la sua media su un dataset. Coincide con la cross-entropy quando il target è una delta sulla label vera.
• Perplexity: exp(cross-entropy media per token), usata come metrica di language modeling.

L’intuizione

Prima di scrivere altre formule, due immagini di cosa misura l’entropia. Compatibili, complementari.

Angolo 1: la sorpresa media

Immagina di osservare i campioni emessi da una sorgente. Ogni volta che vedi un simbolo x, provi una “sorpresa” che dipende solo da quanto era atteso: se la sorgente emette quasi sempre il simbolo “A”, quando finalmente esce “Z” la tua sorpresa è alta; se A e Z sono equiprobabili, le due sorprese sono uguali.

Vogliamo una funzione s(p) della probabilità che catturi questa intuizione. Tre richieste minime:

1. Eventi certi non sorprendono: s(1) = 0.
2. Eventi più rari sorprendono di più: s è decrescente in p.
3. Eventi indipendenti sommano sorprese: se x e y sono indipendenti con probabilità p e q, vedere entrambi ha probabilità pq, e la sorpresa congiunta dovrebbe essere s(p) + s(q).

Solo una famiglia di funzioni soddisfa tutte e tre: s(p) = -log(p), per qualche base del logaritmo. Cambiare base cambia solo l’unità di misura (bit con base 2, nat con base e, hartley con base 10).

Una volta accettato che -log p(x) è la sorpresa di un singolo evento, l’entropia è semplicemente la sua media sotto la distribuzione:

H(P) = E_{x~P}[-log p(x)] = -Σ_i p_i log p_i.

Una distribuzione concentrata su pochi valori ha sorpresa media bassa (entropia bassa). Una distribuzione uniforme su molti valori ha sorpresa media alta (entropia alta). L’entropia è una misura di incertezza o di diversità della sorgente.

Angolo 2: bit minimi di codifica

Cambia scenario. Devi inviare i simboli emessi dalla sorgente attraverso un canale binario, e vuoi il messaggio più corto possibile in media. Sai che simboli frequenti dovrebbero avere codifiche corte e simboli rari codifiche lunghe (l’idea del Morse: “E” è un punto solo, “Q” è quattro segnali). Quanto corto puoi andare?

Shannon dimostra (source coding theorem) che esiste un codice prefix-free — uno in cui nessuna codifica è prefisso di un’altra, condizione che permette decodifica univoca senza separatori — con lunghezza media

$$L_avg ≥ H(P) bits/simbolo$$

e che esiste un codice con lunghezza media arbitrariamente vicina a H(P). L’entropia è il limite teorico inferiore della compressione lossless. La codifica ottimale assegna a ogni simbolo una lunghezza ≈ -log_2 p(x): simboli con p=1/2 occupano 1 bit, simboli con p=1/8 occupano 3 bit, simboli con p=1/1000 occupano circa 10 bit.

Le due immagini sono lo stesso oggetto guardato da due lati. La sorpresa media di una sorgente è il numero medio di bit minimo per descriverne i simboli. “Quanto sono incerto su cosa uscirà” e “quanto deve essere lungo il mio messaggio” sono la stessa cosa.

![Bernoulli entropy curve: H(p) in bit su p ∈ 0, 1, massimo in p=0.5, zero ai bordi]

La meccanica

Con le due intuizioni in tasca, formalizziamo.

Entropia di una distribuzione discreta

Per P = (p_1, …, p_n) con p_i ≥ 0 e Σ p_i = 1:

$$H(P) = -Σ_i p_i log p_i$$

con la convenzione 0 log 0 = 0 (giustificata dal limite p log p → 0 per p → 0). Proprietà chiave:

• H(P) ≥ 0, con uguaglianza sse P è concentrata su un singolo valore.
• H(P) ≤ log n, con uguaglianza sse P è uniforme. Teorema (massima entropia su supporto finito): per ogni P su n elementi, H(P) ≤ log n. Prova: per concavità del logaritmo (Jensen), H(P) - log n = Σ p_i log(1/(n p_i)) ≤ log Σ p_i · 1/(n p_i) = log 1 = 0.
• Concava in P: una mistura di due distribuzioni ha entropia almeno pari alla mistura delle entropie.

Cross-entropy

Date due distribuzioni P, Q sullo stesso supporto:

H(P, Q) = -Σ_i p_i log q_i = E_{x~P}[-log q(x)]

Lettura: codifichiamo i simboli di P assumendo che la distribuzione sia Q. La lunghezza media risultante è H(P, Q). Nota che H(P, Q) ≠ H(Q, P) in generale: il “ruolo” di P (chi genera) e Q (chi codifica) non è simmetrico.

KL divergence e decomposizione

$$KL(P || Q) = Σ_i p_i log(p_i / q_i) = H(P, Q) - H(P).$$

Da cui la decomposizione fondamentale:

$$H(P, Q) = H(P) + KL(P || Q).$$

In parole: la cross-entropy è il costo “naturale” di P (l’entropia) più la “penalità” per usare la codifica sbagliata Q.

Teorema (Gibbs’ inequality): KL(P || Q) ≥ 0, con uguaglianza sse P = Q. Prova: per Jensen applicato al logaritmo concavo, -KL(P||Q) = E_{xP}[log(q(x)/p(x))] ≤ log E_{xP}[q(x)/p(x)] = log Σ_i q_i = log 1 = 0. Quindi KL ≥ 0. L’uguaglianza in Jensen vale sse l’argomento è costante, cioè q/p costante, cioè P = Q (essendo entrambe normalizzate).

KL non è una metrica:

• Asimmetrica: KL(P||Q) ≠ KL(Q||P) in generale.
• Non rispetta la disuguaglianza triangolare.
• Può divergere: se esiste i con p_i > 0 e q_i = 0, KL(P||Q) = +∞.

Nonostante questo, è la “distanza” canonica tra distribuzioni in teoria dell’informazione, perché è quella che emerge naturalmente da maximum likelihood, source coding, e variational inference.

Cross-entropy come loss

Sia p_data la distribuzione vera (sui dati o sui token) e p_θ la distribuzione del modello parametrizzata da θ. La cross-entropy è

L(θ) = H(p_data, p_θ) = -E_{x~p_data}[log p_θ(x)] = H(p_data) + KL(p_data || p_θ).

Poiché H(p_data) non dipende da θ, minimizzare la cross-entropy equivale a minimizzare KL(p_data || p_θ): stesso ottimo, gradienti identici. Questa è un’equivalenza argomentata: i due problemi di ottimizzazione hanno la stessa soluzione e lo stesso paesaggio di gradiente, modulo una costante additiva.

In pratica p_data è osservata via campioni. Per classificazione, ogni esempio (x, y) fornisce un target one-hot t = e_y (vettore con 1 in posizione y, 0 altrove). Allora

$$H(t, p_θ(·|x)) = -Σ_i t_i log p_θ(i|x) = -log p_θ(y|x).$$

Questa è la negative log-likelihood. Equivalenza: cross-entropy con target one-hot è la NLL della categorica con label y. Massimizzare la likelihood (MLE) è quindi lo stesso che minimizzare la cross-entropy.

Softmax + cross-entropy: la coppia standard

Per un vettore di logit z ∈ R^K, la softmax produce probabilità

$$p_i = exp(z_i) / Σ_j exp(z_j).$$

Sostituendo nella NLL:

$$NLL(z, y) = -log p_y = -z_y + log Σ_j exp(z_j) = LSE(z) - z_y$$

dove LSE è log-sum-exp. Due cose buone:

1. Gradiente compatto: ∂NLL/∂z_i = p_i - 1[i = y]. La differenza tra distribuzione predetta e one-hot. Niente derivate di sigmoid saturate, niente catene di moltiplicazioni instabili.

2. Numerica: il calcolo combinato evita overflow. Tutti i framework offrono cross_entropy(logits, target) come operazione atomica che lavora sui logit raw, non sulle probabilità. Mai applicare softmax e poi log separatamente in produzione.

flowchart LR
    L[Logits z] --> S[Softmax]
    S --> P["Probabilità p = exp(z) / Σ exp(z)"]
    Y[Target one-hot y] --> CE
    P --> CE[Cross-entropy NLL]
    CE --> G["Gradiente ∂L/∂z = p − y"]

Figura 3 — softmax + cross-entropy pipeline: logits → softmax → probabilities → NLL with label, and gradient ∂L/∂z = p - y on the side

Log-sum-exp trick

Calcolare LSE(z) = log Σ_j exp(z_j) ingenuamente overflowa quando qualche z_j è grande (exp(1000) = inf). Il trucco standard:

LSE(z) = m + log Σ_j exp(z_j - m), con m = max_j z_j.

Dopo la sottrazione il massimo esponente è 0, gli altri sono ≤ 0, l’exp non overflowa mai. Underflow possibile per esponenti molto negativi, ma i loro contributi sono trascurabili.

Perplexity

Per un language model autoregressivo che assegna p(x_1, …, x_T), la cross-entropy media per token su un test set è

$$CE = -(1/T) Σ_t log p(x_t | x_<t)$$

e la perplexity è

$$PPL = exp(CE)$$

(con log naturale; se si usa log_2, PPL = 2^CE). Lettura: una PPL di k significa che il modello, in media, distribuisce massa probabilistica come se dovesse scegliere uniformemente tra k token. Un modello che fa “guessing puro” su un vocabolario di V token ha PPL = V; ogni informazione che il modello riesce a estrarre dal contesto fa scendere la PPL.

Pseudocodice numpy

import numpy as np

def entropy(p, eps=1e-12):
    p = np.asarray(p, dtype=float)
    return -np.sum(p * np.log(p + eps))

def cross_entropy(p, q, eps=1e-12):
    p = np.asarray(p, dtype=float); q = np.asarray(q, dtype=float)
    return -np.sum(p * np.log(q + eps))

def kl(p, q, eps=1e-12):
    return cross_entropy(p, q, eps) - entropy(p, eps)

def log_softmax(z):
    z = np.asarray(z, dtype=float)
    m = z.max()
    return z - m - np.log(np.exp(z - m).sum())

def nll_from_logits(z, y):
    return -log_softmax(z)[y]

In PyTorch, torch.nn.functional.cross_entropy(logits, targets) fa esattamente $nll_from_logits$ in batch, in modo numericamente stabile, con label smoothing opzionale.

Mutual information (cenno)

Per due variabili X, Y con joint p(x, y) e marginali p(x), p(y):

I(X; Y) = KL(p(x, y) || p(x) p(y)) = H(X) - H(X|Y) = H(Y) - H(Y|X).

È simmetrica, sempre ≥ 0, zero sse X e Y sono indipendenti. La mutual information misura “quanto X e Y non sono indipendenti”, o equivalentemente “quanto Y aiuta a predire X”. È centrale in representation learning (InfoNCE, contrastive learning) e nel principio di information bottleneck.

Esempi

Tre esempi eterogenei: uno numerico a mano, uno di codice in PyTorch, uno scenario realistico di training di un language model.

Esempio 1: moneta truccata, entropia e perplexity

Sia X una moneta con P(testa) = 0.9, P(croce) = 0.1. Calcoliamo H usando il logaritmo naturale (nat):

$$H(X) = -0.9 · ln 0.9 - 0.1 · ln 0.1$$ $$= -0.9 · (-0.1054) - 0.1 · (-2.3026)$$ $$= 0.0948 + 0.2303$$ $$= 0.3251 nat$$

In bit (log_2): H(X) ≈ 0.3251 / ln 2 ≈ 0.469 bit. Una moneta truccata al 90% richiede meno di mezzo bit per simbolo in media: la maggior parte del tempo il risultato è prevedibile, e un buon codificatore (per esempio aritmetico, su sequenze lunghe) si avvicina a questo limite.

La perplexity è exp(H) = exp(0.3251) ≈ 1.384. Lettura: il modello “incerto” è incerto come se dovesse scegliere uniformemente tra 1.38 alternative. Quasi 1, perché quasi sempre sa la risposta.

Confronto: la moneta equa P(testa) = 0.5 ha H = ln 2 ≈ 0.693 nat = 1 bit, PPL = 2.

La moneta sbilanciatissima P(testa) = 0.99 ha H ≈ 0.056 nat ≈ 0.081 bit, PPL ≈ 1.058. Quasi gratis da trasmettere.

Esempio 2: cross-entropy a mano e con torch

Siano P = [0.7, 0.2, 0.1] (vera) e Q = [0.5, 0.3, 0.2] (modello), su tre classi. Calcoliamo a mano (in nat):

$$H(P) = -0.7 · ln 0.7 - 0.2 · ln 0.2 - 0.1 · ln 0.1$$ $$= -0.7 · (-0.3567) - 0.2 · (-1.6094) - 0.1 · (-2.3026)$$ $$= 0.2497 + 0.3219 + 0.2303$$ $$= 0.8018 nat$$ $$H(P, Q) = -0.7 · ln 0.5 - 0.2 · ln 0.3 - 0.1 · ln 0.2$$ $$= -0.7 · (-0.6931) - 0.2 · (-1.2040) - 0.1 · (-1.6094)$$ $$= 0.4852 + 0.2408 + 0.1609$$ $$= 0.8869 nat$$ $$KL(P || Q) = H(P, Q) - H(P) = 0.8869 - 0.8018 = 0.0851 nat.$$ $$Verifica diretta: KL = Σ p_i ln(p_i / q_i) = 0.7 · ln(0.7/0.5) + 0.2 · ln(0.2/0.3) + 0.1 · ln(0.1/0.2) = 0.7 · 0.3365 + 0.2 · (-0.4055) + 0.1 · (-0.6931) = 0.2355 - 0.0811 - 0.0693 = 0.0851. Coincide.$$

In PyTorch su un mini-batch con quattro esempi, vocabolario di tre classi, label intere e logit raw:

import torch
import torch.nn.functional as F

logits = torch.tensor([
    [ 2.0,  1.0,  0.1],
    [ 0.5,  2.5,  0.0],
    [-1.0,  0.0,  2.0],
    [ 1.0,  1.0,  1.0],
])
targets = torch.tensor([0, 1, 2, 0])

loss = F.cross_entropy(logits, targets)
print(loss.item())  # esempio: 0.4174

# Equivalente esplicito:
log_probs = F.log_softmax(logits, dim=-1)
nll = -log_probs[torch.arange(4), targets].mean()
print(nll.item())  # stesso valore

F.cross_entropy accetta direttamente i logit (non passare softmax prima: il calcolo combinato è quello stabile). La quarta riga, con tutti logit uguali a 1.0, dà softmax uniforme [1/3, 1/3, 1/3] e contribuisce con -log(1/3) = ln 3 ≈ 1.0986 alla loss: massima perdita possibile per un classificatore che non ha imparato nulla su un vocabolario di tre classi.

Esempio 3: training step di un language model autoregressive

Consideriamo una sequenza di token (x_1, x_2, x_3, x_4, x_5) e un modello transformer decoder-only che predice il token successivo dato il prefisso. In un singolo forward pass su un batch di una sequenza:

1. Il modello produce logits ∈ R^{T × V}, dove T è la lunghezza della sequenza e V la dimensione del vocabolario.
2. Per il training next-token, il target alla posizione t è x_{t+1}: le predizioni sono shiftate di uno rispetto agli input.
3. La loss è la cross-entropy media token-per-token:

$$loss = (1/(T-1)) · Σ_{t=1}^{T-1} -log p_θ(x_{t+1} | x_1, ..., x_t)$$

4. Il gradiente per ogni logit z_{t,v} è p_{t,v} - 1[v = x_{t+1}], dove p_{t,v} è la probabilità predetta per il vocabolo v alla posizione t.
5. Backprop propaga questi gradienti attraverso il transformer; un ottimizzatore (AdamW) aggiorna θ.

Dopo migliaia di step su miliardi di token, la loss media converge a un certo valore — diciamo 2.1 nat per token. La perplexity corrispondente è exp(2.1) ≈ 8.17. Interpretazione: il modello, sui dati di validazione, si comporta come se dovesse scegliere ogni token uniformemente tra circa 8 alternative. Un anno prima sullo stesso dataset il valore era forse 12; quel miglioramento — da PPL 12 a PPL 8.17 — è il progresso del modello.

Lo stesso meccanismo, identico, vale per GPT-3, Claude, Gemini: l’oggetto matematico minimizzato durante il pre-training è la cross-entropy media per token. La differenza è la scala (token, parametri, compute), non la loss.

Applicazioni pratiche

Cinque applicazioni canoniche dove le tre quantità appaiono.

Cross-entropy loss per classificazione e LM training

Già discussa nella meccanica. Vale la pena enfatizzare un dettaglio operativo: quando un trainer di Hugging Face stampa loss: 2.34, quel numero è la cross-entropy media per token in nat. Per convertirla in bit basta dividere per ln 2 ≈ 0.693, ottenendo 3.38 bit per token. Per ottenere la perplexity, exp(2.34) ≈ 10.4. Le tre quantità sono interscambiabili.

Perplexity come metrica di valutazione

Perplexity è la metrica primaria per valutare un language model su un test set held-out. Vantaggi: continua, derivabile (può essere monitorata durante il training), correlata in modo decente con qualità downstream. Limiti seri:

• Non confrontabile tra tokenizer: due modelli con vocabolari BPE diversi producono PPL su scale diverse anche se le distribuzioni di probabilità sui caratteri sottostanti sono identiche. La pratica corretta per confronti cross-tokenizer è normalizzare in bits-per-byte (BPB): CE_total / total_bytes / ln 2.
• Saturata sui dati: due modelli entrambi molto buoni su Wikipedia possono avere PPL praticamente identiche e comportamenti molto diversi su task downstream.
• Insensibile a errori catastrofici locali: la media nasconde varianza.

Nonostante questo, è ancora la metrica più usata in pre-training perché facile da calcolare e perché in regime di scaling laws (Kaplan, Chinchilla) decresce in modo prevedibile con compute e dati.

Knowledge distillation

Hinton, Vinyals, Dean (2015) introducono la distillation moderna. Un modello teacher T grande produce logit z_T(x); applicando softmax con temperatura τ > 1 si ottiene una distribuzione “ammorbidita” p_T(x) = softmax(z_T / τ). Lo student S piccolo viene addestrato a minimizzare

$$KL(p_T || p_S) + λ · CE(y_true, p_S)$$

dove la prima loss usa la stessa temperatura su entrambi i lati e la seconda è la classica cross-entropy con la label vera. La temperatura amplifica le piccole differenze tra logit del teacher: la “dark knowledge” — informazioni sul fatto che, per un esempio di “5”, il teacher pensa che sia più simile a un “6” che a un “1” — emerge solo a temperatura alta. Lo student impara una struttura di confusione, non solo l’identità della classe vincente. Empiricamente: distillation produce student più piccoli e più accurati dello student addestrato direttamente sulle hard label.

Label smoothing

Una variante leggera ma diffusa. Invece di usare target one-hot t = e_y, si usa

$$t_smooth = (1 - ε) · e_y + (ε / K) · 1$$

con ε ∈ [0.05, 0.2] e K = numero di classi. Il target ha entropia non nulla: il modello non è incentivato a portare il logit della classe corretta a +∞. Effetto: migliora calibrazione (riduce overconfidence) e talvolta accuracy. Costo: peggiora distillation (Müller, Kornblith, Hinton 2019), perché il teacher con label smoothing perde la geometria fine tra classi.

LM come compressori (analogia con prove)

Dato un language model che assegna p(x_t | x_<t), si può usarlo come modello probabilistico in un codificatore aritmetico. La sequenza viene codificata con

$$L_avg ≈ -Σ log_2 p(x_t | x_<t) bit$$

che è esattamente la cross-entropy in bit. Un LM con bassa cross-entropy è quindi, letteralmente, un buon compressore.

L’analogia è argomentabile come filiazione operativa — non solo somiglianza didattica — grazie a Language Modeling Is Compression (Delétang et al., DeepMind, arXiv:2309.10668, 2023). Gli autori mostrano che Chinchilla 70B, addestrato solo su testo, comprime ImageNet a ≈ 43% del raw e LibriSpeech audio a ≈ 17%, battendo PNG e FLAC come compressori general-purpose, senza aver mai visto né immagini né audio durante il training. La conclusione è che gli LLM sono compressori cross-modal, e che l’oggetto che minimizzano (cross-entropy) è esattamente la metrica di compressione attesa.

Dove si rompe

Le tre quantità sono robuste, ma hanno punti dolenti operativi che è importante conoscere.

KL non simmetrica: forward vs reverse

Minimizzare KL(P || Q) rispetto a Q — forward KL o “M-projection” — produce una Q “mean-seeking”: cerca di coprire tutti i modi di P, anche a costo di mettere massa dove P non ne ha. È il caso del maximum likelihood: P è la distribuzione vera dei dati, Q è la famiglia parametrica del modello, e il modello impara una versione “smooth” che assegna probabilità non nulla ovunque.

Minimizzare KL(Q || P) — reverse KL o “I-projection” — produce una Q “mode-seeking”: si concentra su un singolo modo di P. È il caso classico della variational inference per posterior bayesiani: l’approssimazione gaussiana si “incolla” a un modo del posterior, ignorando gli altri.

Non è un bug, è una feature: ognuna delle due direzioni risolve un problema diverso. Ma confondere le due porta a comportamenti inattesi: in RLHF la KL penalty tipica è KL(π_θ || π_ref) — reverse KL del modello rispetto al policy di riferimento — e questa scelta ha conseguenze precise sul mode collapse di π_θ.

flowchart LR
    L[Logits z] --> S[Softmax]
    S --> P["Probabilità p = exp(z) / Σ exp(z)"]
    Y[Target one-hot y] --> CE
    P --> CE[Cross-entropy NLL]
    CE --> G["Gradiente ∂L/∂z = p − y"]

Figura 3 — forward vs reverse KL: bimodal P, two panels showing Q from forward KL (covers both modes, broad) vs reverse KL (snaps to one mode)

KL può divergere

Se p(x) > 0 ma q(x) = 0 per qualche x, allora KL(P || Q) = +∞. Q deve avere supporto almeno tanto largo quanto P. Conseguenze pratiche:

• I generative model usano spesso prior con supporto pieno (gaussiana invece di uniforme su intervallo, per evitare zeri).
• Le distribuzioni empiriche (delta sui campioni) hanno supporto puntuale: la KL contro una Q continua è sempre ill-defined senza smoothing.
• Per softmax, il supporto è sempre pieno (exp > 0 sempre), quindi questo problema non si manifesta in classificazione standard. Si manifesta in sparse mixture-of-experts con routing top-k, dove esperti non scelti hanno probabilità esattamente zero.

Cross-entropy non è una metrica di calibrazione

Un modello può avere cross-entropy bassa (cioè log-likelihood alta sui dati veri) ed essere mal calibrato — ovvero, quando dice “90% confidente”, la frequenza empirica di correttezza è 75%. Cross-entropy premia accuracy (dare alta probabilità alla classe vera) ma non calibration (le probabilità riflettono frequenze). Guo et al. (2017), On Calibration of Modern Neural Networks (ICML), mostra che le reti neurali profonde moderne sono sistematicamente overconfident, e che la cross-entropy non è sufficiente a calibrarle.

Metriche separate: Expected Calibration Error (ECE), reliability diagrams, Brier score. Tecniche correttive: temperature scaling post-hoc, isotonic regression, label smoothing in training. Discutere nella prossima trattazione di calibration-abstention (in preparazione).

Perplexity non confrontabile tra tokenizer diversi

Un modello con tokenizer BPE da 32k vocaboli e un altro con 100k producono perplexity su scale incomparabili anche se la qualità sottostante è la stessa. Più il tokenizer comprime (vocabolario grande, token lunghi), più alta la PPL nominale, perché ogni “token” porta più informazione. La normalizzazione corretta è bits-per-byte:

BPB = (CE_total in nat) / (total_bytes) / ln 2.

$$Tutti i benchmark seri di compression-equivalent quality riportano BPB, non PPL.$$

Numerica: log-sum-exp obbligatorio

Ogni implementazione che calcoli softmax e poi applichi log separatamente è instabile. Alcuni framework lo fanno automaticamente, altri no. Sintomi di una implementazione naïve: NaN dopo qualche step di training, gradienti che esplodono in mixed-precision, loss che diventa -inf. Soluzione: usare sempre la primitiva combinata cross_entropy(logits, targets) o equivalente. Se si sta scrivendo a mano, applicare log-sum-exp con sottrazione del massimo.

Saturation di softmax

Con logit molto grandi in valore assoluto, la softmax diventa praticamente one-hot. La componente “vincente” ha p ≈ 1, le altre p ≈ 0. Conseguenza: i gradienti sulle componenti non vincenti sono ≈ 0 (saturate), il modello non riceve segnale per correggersi. È una delle ragioni per cui gli ottimizzatori fanno fatica con label molto sicure e per cui in distillation si usa una temperatura > 1.

Assunzione i.i.d.

La cross-entropy media per token assume implicitamente che i token siano campioni i.i.d. dalla distribuzione vera. La chain rule fattorizza esattamente la log-likelihood — questa parte è rigorosa — ma il “test set” usato per stimare la PPL è raramente i.i.d. con il “training set”: ci sono near-duplicates, contaminazione, correlazioni temporali (paper recenti, news fresche). Da qui le pratiche di deduplication aggressiva e canary detection. Il numero di PPL stimato su un test contaminato è ottimistico in modo non quantificabile.

Cross-entropy ignora costi asimmetrici

Se in un classificatore medico un falso negativo costa 100 volte un falso positivo, la cross-entropy non lo riflette: tratta tutti gli errori in modo simmetrico. Si interviene con cost-sensitive loss (pesi sulle classi), focal loss, o calibrazione esplicita post-hoc. La cross-entropy è la loss di default, non l’ottima per ogni problema.

Collegamenti

• Distribuzioni, valore atteso, varianza: valore atteso, distribuzioni discrete, base concettuale di tutta la macchina entropica.
• Teorema di Bayes e ragionamento bayesiano: cross-entropy = NLL, MLE, MAP, regolarizzazione L2 come prior gaussiano. Equivalenze tra likelihood e cross-entropy.
• softmax-sigmoid: la coppia softmax + cross-entropy, il MaxEnt classifier, le derivate stabili.
• attention-intuizione (in preparazione): la softmax è anche dentro l’attention, e la stessa stabilità numerica si applica.
• calibration-abstention (in preparazione): cross-entropy non garantisce calibrazione, e la differenza ha conseguenze in produzione.
• distillation (in preparazione): KL come loss per trasferire conoscenza da teacher a student.
• rlhf-ppo (in preparazione): KL penalty tra policy e reference policy in RLHF.
• loss-perplexity (in preparazione): perplexity come metrica primaria di pre-training, scaling laws, bits-per-byte.
• emergent-abilities (in preparazione): il dibattito su abilità emergenti è in parte un dibattito sulla metrica scelta — log-likelihood vs accuracy hanno comportamenti diversi al variare di scala.

Per andare oltre

• Shannon, C. E. (1948). A Mathematical Theory of Communication, Bell System Technical Journal 27. Il paper fondante. Leggibile, sorprendentemente accessibile per essere del 1948.
• MacKay, D. J. C. (2003). Information Theory, Inference, and Learning Algorithms, Cambridge University Press. Disponibile gratuitamente online. Capitoli 2-5 per entropia e codifica, 22-24 per inferenza bayesiana e MaxEnt. Il riferimento didattico unico se ne dovesse esistere uno solo.
• Cover, T. M. & Thomas, J. A. (2006). Elements of Information Theory, 2a ed., Wiley. Trattazione formale completa: AEP, source coding, channel coding, rate-distortion. Per chi vuole il rigore.
• Delétang, G. et al. (2023). Language Modeling Is Compression, arXiv:2309.10668. Evidenza empirica che gli LLM sono compressori cross-modal e che la cross-entropy ne misura direttamente la capacità di compressione.
• Hinton, G., Vinyals, O., Dean, J. (2015). Distilling the Knowledge in a Neural Network, arXiv:1503.02531. Il paper di distillation moderno, leggibile in mezz’ora, applicabile in produzione.