La perdita di classificazione misura quanto il modello è sorpreso
Quando addestri un classificatore con la cross-entropy, a ogni esempio il modello paga -\ln q_y, dove q_y è la probabilità che ha assegnato alla classe giusta: se gliene dà il 90% paga 0{,}105, se gliene dà il 10% paga 2{,}30. La perdita è il logaritmo della sorpresa, e capire perché è proprio il logaritmo, e che cosa lo lega a entropia, KL divergence e perplexity dei modelli di linguaggio, evita di usare queste quantità come formule da copiare. Il filo conduttore è uno solo: l'informazione che manca a un modello per descrivere i dati si misura in bit (o nat) di codice in più rispetto al minimo possibile.
Notazione, nel solco di quella dell'articolo su probabilità e statistica: p è la distribuzione vera, q quella del modello, H l'entropia. Il logaritmo è in base 2 per i bit e naturale per i nat; il libro di Goodfellow, Bengio e Courville usa sempre il naturale, ed è la convenzione di tutte le librerie di deep learning. Passare da un'unità all'altra è una moltiplicazione: 1 nat = 1/\ln 2 \approx 1{,}4427 bit.
Informazione di un evento: la sorpresa come logaritmo della probabilità
L'informazione di un evento di probabilità P(x) è I(x) = -\log_2 P(x): tanto più grande quanto più l'evento è raro. Un testa su una moneta equa vale 1 bit, un 4 su un dado equo \log_2 6 \approx 2{,}585 bit, un evento da uno su 1024 esattamente 10 bit, un evento al 99% solo 0{,}0145 bit. Il logaritmo non è una scelta arbitraria: due eventi indipendenti hanno probabilità P(x)P(y) e il logaritmo trasforma il prodotto in somma, -\log(P(x)P(y)) = I(x) + I(y), quindi due teste di fila portano 1 + 1 = 2 bit. Shannon (1948) definisce il bit con questa base: N dispositivi a due stati memorizzano N bit perché \log_2 2^N = N.
import numpy as np
def surprise_bits(p):
return -np.log2(p)
for name, p in [("moneta equa: testa", 1 / 2), ("dado equo: un 4", 1 / 6), ("evento 1 su 1024", 1 / 1024), ("evento quasi certo", 0.99)]:
print(f"{name:22s} P = {p:.4f} -> {surprise_bits(p):.4f} bit")
print("due lanci indipendenti (testa, testa):", surprise_bits(1 / 2 * 1 / 2), "bit = 1 + 1")
print("1 nat in bit:", round(1 / np.log(2), 4))
# Output:
# moneta equa: testa P = 0.5000 -> 1.0000 bit
# dado equo: un 4 P = 0.1667 -> 2.5850 bit
# evento 1 su 1024 P = 0.0010 -> 10.0000 bit
# evento quasi certo P = 0.9900 -> 0.0145 bit
# due lanci indipendenti (testa, testa): 2.0 bit = 1 + 1
# 1 nat in bit: 1.4427
Il listato è un calcolo diretto di -\log_2 p per quattro eventi, e fa vedere che la sorpresa cresce lentamente: passare da probabilità 1/2 a 1/1024 moltiplica la rarità per 512 ma l'informazione solo per dieci. L'ultima riga verifica la proprietà additiva e il fattore di conversione fra nat e bit, che servirà quando confronteremo i numeri di un'esecuzione in nat con quelli a mano in bit.
Entropia: la sorpresa media di una distribuzione
L'entropia è il valore atteso dell'informazione, cioè la sorpresa media prima di conoscere l'esito:
con la convenzione 0\log 0 = 0. Alcuni casi a mano. Una moneta equa: H = -2 \cdot \tfrac{1}{2}\log_2\tfrac{1}{2} = 1 bit. Una moneta con testa al 99%: -0{,}99\log_2 0{,}99 - 0{,}01\log_2 0{,}01 \approx 0{,}0144 + 0{,}0664 = 0{,}0808 bit: quasi nessuna incertezza. Un dado equo: \log_2 6 \approx 2{,}585 bit. Un dado dove il 3 esce metà delle volte e gli altri cinque numeri il 10% ciascuno: 0{,}5 \cdot 1 + 5 \cdot 0{,}1 \cdot 3{,}3219 \approx 2{,}161 bit, meno del dado equo.
L'entropia ha un significato operativo: è il numero minimo di bit per simbolo, in media, di un codice senza perdita. Sia p = (1/2, 1/4, 1/8, 1/8) sui simboli a,b,c,d. Il codice a prefisso 0, 10, 110, 111 ha lunghezze 1, 2, 3, 3 e lunghezza media \tfrac{1}{2} + \tfrac{2}{4} + \tfrac{3}{8} + \tfrac{3}{8} = 1{,}75 bit, che coincide con H(p). Un codice che ignora le frequenze e usa 2 bit per simbolo costa 2 bit per simbolo: 0,25 bit in più, che è esattamente la divergenza che definiremo fra poco.
import numpy as np
def entropy_bits(p):
p = np.asarray(p, dtype=float)
p = p[p > 0] # per convenzione 0 * log 0 = 0
return -np.sum(p * np.log2(p))
print(f"moneta equa H = {entropy_bits([0.5, 0.5]):.4f} bit")
print(f"moneta con P(T) = 0.99 H = {entropy_bits([0.99, 0.01]):.4f} bit")
print(f"dado equo H = {entropy_bits([1 / 6] * 6):.4f} bit (log2 6 = {np.log2(6):.4f})")
print(f"dado con un 3 al 50% H = {entropy_bits([0.1, 0.1, 0.5, 0.1, 0.1, 0.1]):.4f} bit")
# significato operativo: lunghezza media di un codice a prefisso
p = np.array([1 / 2, 1 / 4, 1 / 8, 1 / 8])
code_len = np.array([1, 2, 3, 3]) # codice 0, 10, 110, 111
print(f"\nH(p) = {entropy_bits(p):.4f} bit; lunghezza media del codice (0, 10, 110, 111) = {np.sum(p * code_len):.4f} bit")
print(f"codice uniforme a 2 bit per simbolo: lunghezza media = {np.sum(p * 2):.4f} bit = H(p) + {np.sum(p * 2) - entropy_bits(p):.4f}")
# Output:
# moneta equa H = 1.0000 bit
# moneta con P(T) = 0.99 H = 0.0808 bit
# dado equo H = 2.5850 bit (log2 6 = 2.5850)
# dado con un 3 al 50% H = 2.1610 bit
#
# H(p) = 1.7500 bit; lunghezza media del codice (0, 10, 110, 111) = 1.7500 bit
# codice uniforme a 2 bit per simbolo: lunghezza media = 2.0000 bit = H(p) + 0.2500
Il listato ripete i conti a mano e li confronta: l'entropia della moneta truccata è 0{,}0808 bit, quella del dado truccato 2{,}1610, e la lunghezza media del codice a prefisso è 1{,}7500, uguale all'entropia. La riga p = p[p > 0] implementa la convenzione 0\log 0 = 0, senza la quale np.log2(0) darebbe -\infty e il prodotto nan. Le proprietà da tenere sono tre:
- H(X) \geq 0 sempre, con H(X) = 0 solo quando un esito ha probabilità 1
- H(X) è massima, uguale a \log K, quando i K esiti sono equiprobabili
- per variabili continue la formula con l'integrale (entropia differenziale) perde alcune di queste proprietà, per esempio può essere negativa
L'ultima voce è un'avvertenza che si dimentica: tutto ciò che vale per l'entropia discreta, come essere sempre non negativa, non si trasferisce automaticamente al caso continuo (il libro di Goodfellow e colleghi lo nota per l'informazione di un evento con densità unitaria). Le prime due dicono che l'entropia misura quanta incertezza resta: nulla se l'esito è già deciso, massima quando nessun esito è favorito.
Cross-entropy: il costo di usare il codice sbagliato
La cross-entropy H(p, q) = -\sum_x p(x)\log q(x) è la lunghezza media del codice quando i dati vengono da p ma il codice è costruito per q. Nell'esempio sopra il codice uniforme corrisponde a q = (1/4, 1/4, 1/4, 1/4) e H(p, q) = 2 bit contro H(p) = 1{,}75. In classificazione p è l'etichetta one-hot (probabilità 1 sulla classe vera y) e q è l'uscita della softmax: la somma si riduce a un solo termine, L = -\log q_y. Per due classi diventa la cross-entropy binaria -[y\log \hat y + (1-y)\log(1-\hat y)], la stessa che nell'articolo sulla probabilità coincideva con la log-verosimiglianza negativa di una Bernoulli.
Conti a mano: se la classe vera riceve 0{,}9 la perdita è -\ln 0{,}9 = 0{,}1054 nat (0{,}152 bit); con 0{,}5 è 0{,}6931 nat, esattamente 1 bit; con 0{,}1 è 2{,}3026 nat (3{,}32 bit). Con tre logit z = (2, 1, 0{,}1) e classe vera 0, la softmax assegna q_0 \approx 0{,}659 e la perdita vale -\ln 0{,}659 = 0{,}417; si può calcolare senza passare dalle probabilità come \ln\sum_j e^{z_j} - z_0 = \ln 11{,}21 - 2 = 0{,}417. Il gradiente rispetto ai logit è sorprendentemente semplice: q - p = (0{,}659 - 1;\ 0{,}2424;\ 0{,}0986).
import numpy as np
z = np.array([2.0, 1.0, 0.1]) # logit; la classe vera e' la 0
y = 0
q = np.exp(z) / np.exp(z).sum() # softmax
print("softmax:", np.round(q, 4))
print(f"-log q[0] = {-np.log(q[y]):.4f} nat")
print(f"log(sum(exp(z))) - z[0] = {np.log(np.exp(z).sum()) - z[y]:.4f} nat")
for qy in (0.9, 0.5, 0.1):
print(f"probabilita' assegnata alla classe vera {qy}: perdita {-np.log(qy):.4f} nat = {-np.log2(qy):.4f} bit")
def ce(z, y): # cross-entropy con one-hot = log-sum-exp - z[y]
m = z.max()
return m + np.log(np.exp(z - m).sum()) - z[y]
onehot = np.eye(3)[y]
num = np.array([(ce(z + e, y) - ce(z - e, y)) / 2e-6 for e in 1e-6 * np.eye(3)])
print("gradiente numerico dL/dz :", np.round(num, 4))
print("softmax - one-hot :", np.round(q - onehot, 4))
big = np.array([1000.0, 0.0, 0.0])
print("logit grandi, forma stabile:", ce(big, 0), " forma ingenua:", -np.log(np.exp(big[0]) / np.exp(big).sum()))
# Output:
# softmax: [0.659 0.2424 0.0986]
# -log q[0] = 0.4170 nat
# log(sum(exp(z))) - z[0] = 0.4170 nat
# probabilita' assegnata alla classe vera 0.9: perdita 0.1054 nat = 0.1520 bit
# probabilita' assegnata alla classe vera 0.5: perdita 0.6931 nat = 1.0000 bit
# probabilita' assegnata alla classe vera 0.1: perdita 2.3026 nat = 3.3219 bit
# gradiente numerico dL/dz : [-0.341 0.2424 0.0986]
# softmax - one-hot : [-0.341 0.2424 0.0986]
# logit grandi, forma stabile: 0.0 forma ingenua: nan
Il listato fa quattro cose. Mostra che le due scritture della perdita coincidono; elenca il costo di una predizione sicura (0,9), incerta (0,5) e sbagliata (0,1) in nat e bit; confronta il gradiente calcolato con le differenze finite con la formula q - p e li trova uguali alla quarta cifra, un risultato che la discussione sulle funzioni di perdita sfrutta per spiegare perché la cross-entropy con softmax non soffre del gradiente che svanisce della perdita quadratica con sigmoide, descritto nell'articolo sul calcolo differenziale. Infine mostra perché le librerie calcolano la perdita direttamente dai logit: con un logit di 1000 la softmax ingenua va in overflow (nan), mentre sottrarre il massimo prima di esponenziare dà il valore corretto, 0. Il taglio np.clip(q, 1e-15, ...) che si vede spesso nei tutorial evita il log(0) ma è un cerotto: non risolve l'overflow e distorce i valori estremi.
KL divergence: quanti bit in più costa l'approssimazione
La divergenza di Kullback e Leibler misura lo scarto fra la cross-entropy e l'entropia:
Il codice con probabilità sbagliate costa D_{\mathrm{KL}} bit in più del codice ottimo. È sempre non negativa (disuguaglianza di Gibbs) e nulla solo se p = q. Non è simmetrica, quindi non è una distanza in senso stretto (Goodfellow e colleghi lo osservano esplicitamente), e se q assegna probabilità zero dove p ne assegna una positiva vale +\infty. Poiché H(p) non dipende dal modello, minimizzare la cross-entropy rispetto a q equivale a minimizzare la KL, ed equivale anche a massimizzare la log-verosimiglianza dei dati, perché con N campioni la cross-entropy contro la distribuzione empirica è la log-verosimiglianza negativa media.
Numeri: p uniforme su quattro classi e q = (0{,}3;\ 0{,}2;\ 0{,}3;\ 0{,}2) danno D_{\mathrm{KL}}(p\|q) = 0{,}25\,[2\ln(0{,}25/0{,}3) + 2\ln(0{,}25/0{,}2)] = 0{,}25\,[2(-0{,}1823) + 2(0{,}2231)] \approx 0{,}0204 nat. La cross-entropy è 1{,}4067 nat e H(p) = \ln 4 = 1{,}3863: la differenza è proprio 0{,}0204. Nei modelli generativi a variabili latenti (VAE) compare un termine in forma chiusa, la KL fra \mathcal{N}(\mu, \sigma^2) e \mathcal{N}(0, 1): \tfrac{1}{2}(\mu^2 + \sigma^2 - \ln\sigma^2 - 1). A mano: con \mu = 1 e \sigma^2 = 1 vale 0{,}5, con \mu = 0 e \sigma^2 = 1 vale zero, perché le due distribuzioni coincidono.
import numpy as np
from scipy import integrate
def kl(p, q):
p, q = np.asarray(p, float), np.asarray(q, float)
if np.any((q == 0) & (p > 0)):
return np.inf # p da' massa dove q ne da' zero
m = p > 0
return np.sum(p[m] * np.log(p[m] / q[m]))
p = np.full(4, 0.25)
q = np.array([0.3, 0.2, 0.3, 0.2])
print(f"KL(p||q) = {kl(p, q):.5f} nat")
print(f"KL(q||p) = {kl(q, p):.5f} nat (non simmetrica)")
H = lambda a: -np.sum(a * np.log(a))
CE = -np.sum(p * np.log(q))
print(f"H(p) + KL(p||q) = {H(p) + kl(p, q):.5f} H(p, q) = {CE:.5f}")
a, b = np.array([0.5, 0.5, 0.0]), np.full(3, 1 / 3)
print(f"supporti diversi: KL(a||b) = {kl(a, b):.4f} (ln 1.5 = {np.log(1.5):.4f}) KL(b||a) = {kl(b, a)}")
# KL fra N(mu, s2) e N(0, 1): formula chiusa contro integrazione numerica
mu, s2 = 0.5, 0.6
closed = 0.5 * (mu ** 2 + s2 - np.log(s2) - 1)
pdf = lambda x, m, v: np.exp(-(x - m) ** 2 / (2 * v)) / np.sqrt(2 * np.pi * v)
numeric = integrate.quad(lambda x: pdf(x, mu, s2) * np.log(pdf(x, mu, s2) / pdf(x, 0, 1)), -20, 20)[0]
print(f"KL(N({mu}, {s2}) || N(0, 1)): formula = {closed:.6f}, integrale = {numeric:.6f}")
print("caso mu = 1, s2 = 1:", 0.5 * (1 + 1 - 0 - 1), " caso mu = 0, s2 = 1:", 0.5 * (0 + 1 - 0 - 1))
# Output:
# KL(p||q) = 0.02041 nat
# KL(q||p) = 0.02014 nat (non simmetrica)
# H(p) + KL(p||q) = 1.40671 H(p, q) = 1.40671
# supporti diversi: KL(a||b) = 0.4055 (ln 1.5 = 0.4055) KL(b||a) = inf
# KL(N(0.5, 0.6) || N(0, 1)): formula = 0.180413, integrale = 0.180413
# caso mu = 1, s2 = 1: 0.5 caso mu = 0, s2 = 1: 0.0
Il listato implementa la KL con un controllo esplicito: se q = 0 dove p > 0 restituisce inf invece di nascondere il caso con una maschera, come fanno molte implementazioni, e il caso con supporti diversi mostra il comportamento: D_{\mathrm{KL}}(a\|b) = \ln 1{,}5 = 0{,}4055 mentre D_{\mathrm{KL}}(b\|a) = \infty. Per le gaussiane confronta la formula chiusa con l'integrale numerico di scipy.integrate.quad su un esempio (\mu = 0{,}5, \sigma^2 = 0{,}6): le due uscite coincidono fino alla sesta cifra. Questo articolo non entra nella costruzione dei VAE, che è un argomento a sé; la formula è qui perché è un buon caso in cui la KL si calcola a mano e si verifica.
Informazione mutua: quanto una variabile dice dell'altra
L'informazione mutua I(X;Y) = \sum_{x,y} P(x,y)\log\frac{P(x,y)}{P(x)P(y)} è la KL fra la distribuzione congiunta e il prodotto delle marginali, cioè quanto la congiunta si allontana dall'indipendenza. Equivale a H(X) - H(X \mid Y): la riduzione di incertezza su X ottenuta conoscendo Y. Vale zero se e solo se X e Y sono indipendenti. Esempio: due variabili binarie con congiunta \begin{pmatrix} 0{,}4 & 0{,}1 \\ 0{,}1 & 0{,}4 \end{pmatrix} hanno marginali (0{,}5; 0{,}5) e I = 2 \cdot 0{,}4\ln(0{,}4/0{,}25) + 2 \cdot 0{,}1\ln(0{,}1/0{,}25) = 0{,}376 - 0{,}1833 \approx 0{,}1927 nat, cioè 0{,}278 bit.
import numpy as np
from sklearn.metrics import mutual_info_score
P = np.array([[0.4, 0.1],
[0.1, 0.4]]) # distribuzione congiunta P(x, y)
Px, Py = P.sum(axis=1), P.sum(axis=0)
mi = np.sum(P * np.log(P / np.outer(Px, Py)))
Hx = -np.sum(Px * np.log(Px))
Hx_given_y = -np.sum(P * np.log(P / Py)) # H(X|Y) = -sum P(x,y) log P(x|y)
print(f"I(X;Y) = {mi:.5f} nat = {mi / np.log(2):.4f} bit")
print(f"H(X) - H(X|Y) = {Hx - Hx_given_y:.5f} nat (H(X) = {Hx:.4f}, H(X|Y) = {Hx_given_y:.4f})")
print("scikit-learn:", round(mutual_info_score(None, None, contingency=P * 100), 5))
# Output:
# I(X;Y) = 0.19274 nat = 0.2781 bit
# H(X) - H(X|Y) = 0.19274 nat (H(X) = 0.6931, H(X|Y) = 0.5004)
# scikit-learn: 0.19274
Il blocco calcola l'informazione mutua in due modi, come KL e come differenza di entropie (H(X) = \ln 2 = 0{,}6931 meno H(X \mid Y) = 0{,}5004), li confronta con mutual_info_score di scikit-learn e trova lo stesso numero. In pratica il calcolo diretto richiede una tabella di probabilità congiunte: con variabili continue o molte categorie occorre stimarla dai dati, e le stime sono distorte con pochi campioni. È lo strumento dietro la selezione di feature per informazione mutua e la valutazione di un clustering contro etichette di riferimento.
Perplexity: la cross-entropy letta come numero di scelte
La perplexity di un modello di linguaggio su N token è l'esponenziale della cross-entropy media per token, \mathrm{PPL} = \exp\left(-\frac{1}{N}\sum_i \ln q(w_i \mid w_{<i})\right). Si legge come il numero di scelte equiprobabili che darebbe la stessa incertezza: un modello uniforme su k opzioni ha perplexity k. Esempio: se il modello assegna ai tre token osservati le probabilità 0{,}5; 0{,}25; 0{,}25, la cross-entropy media è 1{,}1552 nat e la perplexity \exp(1{,}1552) = 3{,}175, che è anche (1/(0{,}5 \cdot 0{,}25 \cdot 0{,}25))^{1/3} = 32^{1/3}.
import numpy as np
probs = np.array([0.5, 0.25, 0.25]) # probabilita' assegnate dal modello ai 3 token osservati
ce = -np.mean(np.log(probs))
print(f"cross-entropy media = {ce:.4f} nat perplexity = exp(ce) = {np.exp(ce):.4f}")
print(f"controllo: (1 / prodotto)^(1/3) = {(1 / np.prod(probs)) ** (1 / 3):.4f} (32^(1/3))")
for k in (2, 10, 50_000):
print(f"modello uniforme su {k:6d} opzioni: perplexity = {np.exp(-np.log(1 / k)):.1f}")
# Output:
# cross-entropy media = 1.1552 nat perplexity = exp(ce) = 3.1748
# controllo: (1 / prodotto)^(1/3) = 3.1748 (32^(1/3))
# modello uniforme su 2 opzioni: perplexity = 2.0
# modello uniforme su 10 opzioni: perplexity = 10.0
# modello uniforme su 50000 opzioni: perplexity = 50000.0
Il listato verifica l'equivalenza fra le due scritture e che un modello uniforme su 50000 opzioni ha perplexity 50000, il punto di partenza di un modello che non ha ancora imparato nulla su un vocabolario di quella dimensione. Una perplexity più bassa è meglio, ma i valori sono confrontabili solo fra modelli valutati sugli stessi dati e con lo stesso modo di spezzare il testo in token: cambiando tokenizzatore cambia il significato di «per token», e il confronto perde di senso.
Che cosa sai fare adesso
Sai calcolare a mano la sorpresa di un evento, l'entropia di una distribuzione e la lunghezza di un codice che la raggiunge, e sai scrivere la cross-entropy di un classificatore come -\ln q_y e il suo gradiente come q - p. Sai perché minimizzare la cross-entropy, minimizzare la KL e massimizzare la verosimiglianza sono lo stesso problema, e sai evitare le due trappole dei tutorial: il log(0) nascosto da una maschera o da un clip, e il confronto di perplexity fra modelli con tokenizzatori diversi. L'articolo successivo, sulla PCA, torna all'algebra lineare: la stessa idea di «quanta informazione resta» diventa quanta varianza si conserva scartando delle dimensioni.
Come ho verificato i listati: li ho eseguiti il 2026-11-21, ciascuno da solo, con Python 3.14.4, NumPy 2.3.5, SciPy 1.16.3 e scikit-learn 1.8.0, e le cifre decimali riportate nel testo coincidono con quelle prodotte. Con versioni diverse delle librerie le ultime cifre possono cambiare.
Fonti
- Goodfellow, Bengio, Courville, Deep Learning, capitolo 3 (§3.13 Information Theory) - uso del logaritmo naturale e delle unità in nat, definizione di entropia, cross-entropy e KL, asimmetria della KL; capitolo letto, consultata il 2026-11-12
- Shannon, A Mathematical Theory of Communication, Bell System Technical Journal, 1948 (copia dell'articolo) - definizione del bit come unità con logaritmo in base 2; copia raggiunta, estratto letto, consultata il 2026-11-12
- Kullback, Leibler, On Information and Sufficiency, Annals of Mathematical Statistics 22, 1951 - articolo originale della divergenza che porta il loro nome; pagina raggiunta, testo non letto, consultata il 2026-11-12
- scikit-learn: sklearn.metrics.mutual_info_score - definizione dell'informazione mutua usata per il confronto numerico, consultata il 2026-11-12

Commenti
Caricamento commenti...
Accedi per commentare