Teoria dell’informazione: misurare la sorpresa

Nel luglio del 1948, sulla rivista tecnica dei Bell Labs, un ingegnere trentaduenne di nome Claude Shannon pubblica un articolo dal titolo volutamente sobrio: A Mathematical Theory of Communication [Sha48]. Dentro c’è un’idea che cambierà il mondo più di quanto il titolo lasci intuire: l’informazione si può misurare, con la stessa oggettività con cui si misurano metri e chilogrammi. L’unità di misura è il bit: contrazione di binary digit, parola che Shannon attribuisce al collega John Tukey e che proprio in quell’articolo compare a stampa per la prima volta.

In quell’articolo la grandezza centrale della teoria prende il nome che ha ancora oggi, entropia, lo stesso della termodinamica: è il nome dell’aneddoto raccontato in apertura di capitolo, quello che von Neumann avrebbe suggerito a Shannon. Qui lo riempiamo di contenuto, perché ci riguarda da vicino: il punteggio d’errore con cui addestreremo quasi tutti i classificatori di questo libro (cioè i modelli che devono scegliere fra alternative: gatto o cane, spam o no) discende in linea diretta da quell’articolo del 1948, e si chiama cross-entropy.

La sorpresa di un evento

Il punto di partenza di Shannon è un’osservazione quasi banale: un messaggio porta tanta più informazione quanto più è improbabile.

Elementare

Il telegiornale non apre mai con «domani il sole sorgerà»: è certo, quindi non è una notizia. Apre con la nevicata a Palermo, proprio perché è rara. L’informazione, insomma, è sorpresa: un evento scontato ne porta poca, un evento raro ne porta molta.

Shannon trasformò l’intuizione in un numero. L’esito di una moneta equa (testa o croce, 50 e 50) vale esattamente 1 bit: è la sorpresa di una domanda secca con due risposte ugualmente possibili.

Se l’idea di «misurare in domande» sembra astratta, pensa al gioco delle venti domande: uno pensa a un oggetto, l’altro può chiedere solo cose con risposta sì o no. Giocando bene (ogni domanda dimezza le possibilità rimaste) venti domande bastano a distinguere fra più di un milione di oggetti, perché \(2^{20} \approx 1{,}05\) milioni. Giocando male («è un carciofo?», «è un trapano?») non bastano nemmeno per il contenuto di un cassetto. Un bit è esattamente una domanda ben posta, e l’entropia conterà quante ne servono in media.

Da qui esce il conto per tutti gli altri casi, e vale la pena farlo una volta perché altrimenti i numeri di questa sezione sembrano piovere dal cielo. Il bit è l’esponente del due. Due alternative fanno \(1\) bit perché \(2^1 = 2\); quattro ne fanno \(2\) perché \(2^2 = 4\); otto ne fanno \(3\). Con sei facce di un dado siamo in mezzo fra quattro e otto, quindi fra \(2\) e \(3\) bit: il numero esatto è quello che elevando \(2\) dà \(6\), cioè circa \(2{,}585\). Ecco i «2,6 bit» del dado: non è che servano due domande e mezzo, è che in media, su tante partite, una strategia ottima ne consuma poco più di due e mezzo.

Lo stesso conto vale per gli esiti singoli di una moneta sbilanciata, con una sola avvertenza: al posto del numero di alternative si mette uno diviso la probabilità. Una moneta truccata dà testa \(9\) volte su \(10\): la testa è «un’alternativa su \(1/0{,}9 = 1{,}11\)», quindi vale pochissimo, \(0{,}15\) bit. Ce lo aspettavamo già. La croce invece è «una su \(1/0{,}1 = 10\)», cioè quanto un dado a dieci facce, e vale \(3{,}32\) bit: rara, e perciò molto informativa. Sono i due numeri che torneranno fra poco.

Trovare quei due esponenti richiede una calcolatrice, e va benissimo prenderli come sono; verificarli invece si può a mano, andando nel verso facile, cioè elevando il due. Se \(0{,}15\) è giusto, allora \(2^{0{,}15}\) deve fare \(1{,}11\), e infatti fa \(1{,}11\). Se \(3{,}32\) è giusto, \(2^{3{,}32}\) deve fare \(10\): sta fra \(2^3 = 8\) e \(2^4 = 16\), e viene \(9{,}98\). (Che un due si possa elevare a un esponente con la virgola non è ovvio, ed è spiegato più avanti in questa stessa sezione, dov’è la prima volta che serve davvero.)

Superiore

L’autoinformazione (o sorpresa) di un esito \(x\) con probabilità \(p(x)\) è

\[ I(x) = -\log_2 p(x), \]

dove il segno meno rende la quantità positiva (i logaritmi di numeri fra \(0\) e \(1\) sono negativi) e la base \(2\) fissa l’unità di misura in bit. La forma logaritmica non è un vezzo: è l’unica forma continua (a meno della base) che rende la sorpresa additiva per eventi indipendenti; se \(p(x,y)=p(x)\,p(y)\), allora \(I(x,y)=I(x)+I(y)\), perché il logaritmo trasforma i prodotti in somme. L’aggettivo serve: l’equazione funzionale \(f(pq)=f(p)+f(q)\) ha anche soluzioni patologiche, che però si costruiscono solo rinunciando a ogni regolarità (continuità, monotonia o misurabilità).

Esempi: moneta equa, \(I=-\log_2 0{,}5 = 1\) bit; una faccia del dado, \(I=-\log_2 \tfrac{1}{6} \approx 2{,}585\) bit; testa con la moneta truccata, \(I=-\log_2 0{,}9 \approx 0{,}152\) bit; croce con la stessa moneta, \(I=-\log_2 0{,}1 \approx 3{,}322\) bit. Con il logaritmo naturale al posto di \(\log_2\) l’unità si chiama nat: è la convenzione usata dalle loss di PyTorch.

L’entropia: la sorpresa media

Un singolo esito ha una sorpresa; una sorgente di esiti (una moneta, un dado, una lingua) ha una sorpresa media. È l’entropia: quanto ci aspettiamo di essere sorpresi, in media, a ogni estrazione (Fig. 3.20).

Fig. 3.20 Due monete identiche all’aspetto, entropie diverse: l’equa produce in media 1 bit di sorpresa per lancio, la truccata meno della metà. (La lettera \(H\) che compare nel disegno è il simbolo con cui si indica l’entropia, così come \(\pi\) indica il pi greco: «\(H = 1\) bit» si legge «l’entropia di questa moneta è di un bit».)

Elementare

Riprendiamo la moneta truccata: testa 9 volte su 10. Nove lanci su dieci la sorpresa è quasi nulla (0,15 bit), una volta su dieci è grande (3,32 bit). La media pesata fa \(0{,}9 \times 0{,}15 + 0{,}1 \times 3{,}32 \approx 0{,}47\) bit per lancio: meno della metà del bit pieno della moneta equa. Ha senso: una moneta prevedibile ci sorprende poco, e infatti «produce» poca informazione.

La regola generale: l’entropia è massima quando tutto è ugualmente possibile (massima incertezza: 1 bit per la moneta equa, circa 2,6 bit per il dado onesto) e scende verso zero man mano che un esito diventa dominante. Una moneta con due teste ha entropia zero: nessuna sorpresa, mai.

Superiore

Per una distribuzione discreta \(p=(p_1,\dots,p_n)\), l’entropia è il valore atteso dell’autoinformazione:

\[ H(p) = -\sum_{i=1}^{n} p_i \log_2 p_i , \]

dove i termini con \(p_i=0\) valgono \(0\) per convenzione (coerente col limite \(p\log p \to 0\)). Verifiche: moneta equa, \(H = -(0{,}5\log_2 0{,}5 + 0{,}5\log_2 0{,}5) = 1\) bit; moneta truccata con \(p=0{,}9\), \(H \approx 0{,}9\cdot 0{,}152 + 0{,}1\cdot 3{,}322 \approx 0{,}469\) bit; dado equo, \(H = \log_2 6 \approx 2{,}585\) bit.

Due proprietà strutturali: \(H(p)\ge 0\), con uguaglianza solo per distribuzioni degeneri (un esito certo); e \(H(p)\le \log_2 n\), con uguaglianza solo per la distribuzione uniforme. L’entropia è quindi una misura di incertezza: nulla quando l’esito è scritto, massima quando le \(n\) alternative sono equiprobabili.

Entrambe valgono nel discreto, ed è bene dirlo perché nel continuo la prima cade. L’analogo per una densità, l’entropia differenziale \(h(f) = -\int f\log_2 f\), può essere negativo appena la densità si concentra: \(h(\mathcal{N}(0,1)) = +2{,}05\) bit, ma \(h(\mathcal{N}(0,\,0{,}1^2)) = -1{,}27\). La divergenza KL, invece, resta \(\ge 0\) in entrambi i casi, ed è una delle ragioni per cui è lei l’oggetto su cui si costruisce.

Confrontare distribuzioni: cross-entropia e divergenza KL

Fin qui una sola sorgente e una sola tabella di probabilità. Ma nel machine learning ce ne sono sempre due, e vale la pena dire di quali si tratta. La prima descrive come vanno le cose davvero: quanto spesso, nel mondo, esce ciascuna risposta. Nessuno la conosce per intero (con la moneta truccata sì, perché l’abbiamo truccata noi; con le foto di gatti no), ma esiste, e la chiamiamo \(p\). La seconda è quello che il modello crede: le probabilità che assegna lui, e che sono sbagliate finché non impara. La chiamiamo \(q\). Serve un modo per misurare quanto la seconda sbaglia rispetto alla prima.

Fig. 3.21 Le due curve e il fatto che non combaciano. La cross-entropia misura il costo totale di descrivere \(p\) usando \(q\); la divergenza KL misura solo il sovrapprezzo, cioè quanto si paga in più rispetto a conoscere \(p\), ed è la sottrazione scritta in fondo al disegno. Due avvertenze sul resto. Lo spazio bianco fra le due curve è un promemoria visivo e non la misura: le due misure vere sono definite fra poche righe. E il punto segnato sulla coda di sinistra è il caso che costa di più, quello in cui la realtà ogni tanto produce una parola e il modello le aveva dato quasi zero: essere colti di sorpresa lì è la cosa più cara che possa capitare, ed è per questo che la scritta accanto dice che il conto «esplode».

La distinzione che Fig. 3.21 rende visiva spiega perché in pratica si minimizzi la cross-entropia e non la KL. Le due quantità differiscono per una sola cosa, la sorpresa media della realtà \(p\), che dipende dai dati e non da chi li prevede: è la stessa qualunque modello si usi. Spingere in basso l’una o l’altra porta quindi esattamente allo stesso modello, e la cross-entropia ha il vantaggio di potersi stimare dai soli esempi, senza mai scrivere \(p\).

A prima vista sembra impossibile, visto che nella definizione la \(p\) c’è. Il punto è che non serve la tabella completa delle probabilità vere: bastano gli esiti veri, uno alla volta. Ogni foto etichettata «gatto» è la realtà che si presenta e dice «stavolta è toccato a me», e facendo la media della sorpresa del modello su tutte le foto che si hanno, la \(p\) entra nel conto da sé, senza che nessuno l’abbia mai scritta.

La KL, invece, quella tabella la vorrebbe davvero, perché al suo interno c’è la sorpresa media della realtà, che dagli esempi non si ricava. Ed è la ragione per cui, dovendo sceglierne una, si minimizza la cross-entropia. È poi la situazione in cui ci si trova sempre: gli esempi si hanno, la legge che li ha prodotti no.

Elementare

Il codice Morse assegna il segnale più corto (un punto) alla E, che in inglese è la lettera più frequente: le scorciatoie migliori vanno alle cose più comuni, così i messaggi restano brevi. Ora immagina di telegrafare in italiano usando il Morse tarato sull’inglese: funziona, ogni lettera ha il suo codice, ma le frequenze delle lettere sono diverse e ogni tanto una lettera comune da noi si porta dietro un codice lungo. In media, sprechi.

La cross-entropia è la lunghezza media dei tuoi messaggi quando usi il codice pensato per la lingua sbagliata: le lettere arrivano secondo la realtà (\(p\)), le scorciatoie sono ottimizzate per la convinzione del modello (\(q\)). La divergenza di Kullback–Leibler è lo spreco puro: i bit pagati in più rispetto al codice giusto. È zero solo se \(q\) indovina esattamente \(p\), e non è simmetrica: sbagliare codice in un verso non costa quanto sbagliarlo nell’altro.

Superiore

La cross-entropia fra la distribuzione vera \(p\) e quella del modello \(q\) è

\[ H(p,q) = -\sum_i p_i \log_2 q_i , \]

cioè la sorpresa media che proviamo usando le probabilità sbagliate \(q\) mentre gli esiti escono secondo \(p\). La divergenza di Kullback–Leibler [KL51] è l’eccesso rispetto al minimo possibile:

\[ D_{KL}(p\,\|\,q) = H(p,q) - H(p) = \sum_i p_i \log_2 \frac{p_i}{q_i} \;\ge\; 0, \]

dove la disuguaglianza (di Gibbs) vale sempre, con uguaglianza se e solo se \(p=q\). Esempio con le nostre monete: se la realtà è la moneta truccata (\(p = (0{,}9;\, 0{,}1)\)) e il modello la crede equa, \(H(p,q)=1\) bit e \(D_{KL} = 1 - 0{,}469 \approx 0{,}531\) bit. Nel verso opposto (realtà equa, modello convinto del trucco) \(H(p,q) \approx 1{,}737\) bit e \(D_{KL} \approx 0{,}737\) bit. I due valori differiscono: la KL è asimmetrica, \(D_{KL}(p\,\|\,q) \ne D_{KL}(q\,\|\,p)\) in generale, e non soddisfa la disuguaglianza triangolare. Non è una distanza in senso matematico, per quanto la si usi come misura di dissimilarità.

Il ponte con l’apprendimento

Ed ecco il motivo per cui questa sezione sta in un libro di machine learning.

Elementare

Quando una rete neurale impara a classificare, a ogni esempio le si fa una sola domanda: quanto ti sorprende la risposta giusta? Se il modello dava al gatto il 90% di probabilità e l’immagine era davvero un gatto, la sorpresa è piccola e la correzione minima; se gli dava il 2%, la sorpresa è enorme e la correzione energica. Addestrare significa girare le manopole dei parametri per rendere la risposta giusta sempre meno sorprendente. La «punizione» media è esattamente la cross-entropia dell’analogia del Morse: il modello smette di sprecare quando il suo codice (le sue probabilità) combacia con la realtà.

Superiore

Minimizzare la cross-entropia rispetto ai parametri \(\theta\) del modello equivale a minimizzare la divergenza KL, perché

\[ H(p, q_\theta) = H(p) + D_{KL}(p\,\|\,q_\theta) \]

e \(H(p)\) non dipende da \(\theta\): il minimo teorico della loss non è zero ma l’entropia dei dati, la loro incertezza irriducibile.

Attenzione però a quale \(p\), perché il libro (come tutti) usa lo stesso simbolo per due cose. Se \(p\) è la distribuzione condizionata vera del processo che genera i dati, il pavimento è \(H(p) > 0\) e nessun modello scende sotto. Se invece \(p\) è il bersaglio empirico di un singolo esempio, cioè «questa immagine è un gatto» con probabilità \(1\) e tutto il resto a zero, allora \(H(p) = 0\) e il pavimento è zero. Le due affermazioni convivono e spiegano una cosa che si osserva addestrando: la loss di training può scendere quasi a zero, quella di validazione no, perché la prima misura la distanza da bersagli certi e la seconda da una distribuzione che certa non è.

Inoltre, sulla distribuzione empirica del training set la cross-entropia coincide con la log-verosimiglianza negativa media: minimizzarla è la stima di massima verosimiglianza vista nella sezione su probabilità e statistica. Le tre prospettive (minimizzare la cross-entropia, avvicinare \(q_\theta\) a \(p\) nel senso della KL, massimizzare la verosimiglianza) sono la stessa operazione. È ciò che fa nn.CrossEntropyLoss, la loss \(\mathcal{L}=-\log \hat{y}_c\) (dove \(\hat{y}_c\) è la probabilità che il modello assegna alla classe corretta \(c\)) che useremo nei capitoli sulle reti neurali e su PyTorch.

La perplessità: quante facce ha il dado

Dall’entropia si ricava una misura più parlante, cara a chi costruisce modelli di linguaggio.

Fig. 3.22 Un righello solo, con due scritte diverse sui due bordi. La perplessità non aggiunge niente all’entropia: la dice in facce invece che in bit, e le facce raddoppiano dove i bit crescono di uno.

Il salto alla perplessità è una riscrittura, non un concetto nuovo: si torna indietro dall’esponente al numero di alternative. Per la moneta equa \(2^1 = 2\) facce, per quella truccata \(2^{0{,}47} \approx 1{,}4\), e in Fig. 3.22 sono lo stesso punto letto sui due bordi.

Quel secondo conto merita una riga, perché «due elevato a zero virgola quarantasette» non è più «due moltiplicato per sé stesso un certo numero di volte»: l’elevamento a potenza si estende agli esponenti con la virgola in modo che continui a valere la regola di sempre, cioè che sommando gli esponenti si moltiplichino i risultati. Con quella regola \(2^{0{,}5}\) deve essere il numero che moltiplicato per sé stesso dà \(2\), cioè \(\sqrt 2 \approx 1{,}41\); e \(2^{0{,}47}\), di pochissimo più piccolo, vale circa \(1{,}4\). Non esiste un dado con \(1{,}4\) facce, e non serve: il numero dice «meno di due alternative vere», cioè che quella moneta è poco più che decisa.

Elementare

Dire «entropia 2,585 bit» non è intuitivo; dire «è incerto come un dado a sei facce» sì. La perplessità fa proprio questa traduzione: riconverte l’entropia nel numero di alternative ugualmente probabili che darebbero la stessa incertezza. Moneta equa: perplessità 2. Dado onesto: 6. La moneta truccata: circa 1,4 (quasi nessun dubbio, poco più di un’alternativa secca). Quando leggerai che un modello di linguaggio «ha perplessità 20», ora sai cosa significa: a ogni parola è incerto come se tirasse un dado a 20 facce.

Superiore

La perplessità di una distribuzione è

\[ \mathrm{PP}(p) = 2^{H(p)}, \]

l’esponenziale dell’entropia nella stessa base del logaritmo. Per la distribuzione uniforme su \(n\) esiti, \(\mathrm{PP} = 2^{\log_2 n} = n\): il numero di alternative, appunto. Per le nostre sorgenti: \(2^{1}=2\) (moneta equa), \(2^{\log_2 6}=6\) (dado), \(2^{0{,}469}\approx 1{,}38\) (moneta truccata). Nei modelli di linguaggio si usa la perplessità per parola, calcolata sulla cross-entropia media del modello su un testo di test: la riprenderemo, numeri alla mano, nel capitolo sul Natural Language Processing.

Il limite della compressione

Chiudiamo con la conseguenza più concreta del lavoro di Shannon: l’entropia è un limite alla compressione. Comprimere un file, come fa un programma tipo zip o gzip, vuol dire riscriverlo più corto in modo da poterlo poi ricostruire identico. Shannon dimostrò che quel «più corto» ha un fondo: nessun programma, per quanto ingegnoso, può scendere sotto l’entropia per simbolo del messaggio, cioè sotto la sorpresa media che ogni carattere porta con sé. In media, sotto quella soglia non si scende.

L’aggettivo «per simbolo» non è un dettaglio, ed è il punto in cui la frase detta male diventa falsa. La sorpresa media \(H\) calcolata sulle sole frequenze delle lettere descrive una sorgente senza memoria, una che estrae ogni lettera indipendentemente dalle precedenti. Una lingua non è così: dopo una «q» arriva quasi sempre una «u», dopo «il gatto ne» le continuazioni plausibili sono poche. Per una sorgente con memoria il limite vero è più basso, ed è la sorpresa media di ogni lettera dato tutto ciò che la precede.

La differenza si tocca con mano, e si può rifare a casa: prendendo i file di testo con cui questo libro è scritto (sei megabyte abbondanti) e contando soltanto quanto è frequente ciascun carattere, la sorpresa media viene circa \(4{,}7\) bit a carattere. Poi si passa il tutto a gzip, che è il compressore più ordinario che ci sia, e il file esce a circa \(2{,}9\) bit a carattere, cioè a poco più del \(60\%\) di quel presunto limite invalicabile. Non ha violato nessun teorema: sta sfruttando proprio la ridondanza fra un carattere e il successivo, che quel conto ignorava.

È la stessa quantità che Shannon stimò nel 1951 per l’inglese scritto in circa un bit per lettera [Sha51], e va confrontata con i quasi \(5\) bit che darebbero ventisei lettere equiprobabili tenendo conto solo di quante sono. Uno zip morde bene un testo perché quella ridondanza c’è tutta; non morde più niente su un file già compresso, dove è già stata spremuta via.

Comprimere è l’arte del Morse portata al suo limite matematico: scorciatoie a ciò che è frequente. E qui si chiude il cerchio con il machine learning, in un passaggio che vale la pena fare per esteso. Un compressore ha bisogno di sapere che cosa è frequente, per dare a quello le scorciatoie. Un modello che predice bene sa esattamente questo, anzi qualcosa di più: sa che cosa è frequente proprio lì, dopo le parole appena lette. Chi ha un modello così può scrivere il messaggio in un modo diverso e più corto: invece del testo, le sorprese, e dove il modello indovina la sorpresa è quasi zero, quindi non c’è quasi niente da scrivere. Predire e comprimere, ci dice Shannon, sono in fondo la stessa cosa.

In pratica, con NumPy

import numpy as np

def entropia(p):
    p = np.asarray(p, dtype=float)
    p = p[p > 0]                        # convenzione: 0·log 0 = 0
    return -(p * np.log2(p)).sum()

equa     = [0.5, 0.5]
truccata = [0.9, 0.1]
dado     = np.full(6, 1/6)

print(entropia(equa))                   # 1.0
print(entropia(truccata))               # ~0.4690
print(entropia(dado))                   # ~2.5850

def cross_entropia(p, q):
    p, q = np.asarray(p, dtype=float), np.asarray(q, dtype=float)
    m = p > 0
    return -(p[m] * np.log2(q[m])).sum()

# la realta' e' truccata, il modello crede la moneta equa
H_pq = cross_entropia(truccata, equa)   # 1.0
kl   = H_pq - entropia(truccata)        # ~0.5310: lo "spreco" in bit
print(H_pq, kl)

# perplessita': 2^H, il numero di alternative equiprobabili
print(2**entropia(equa), 2**entropia(dado))   # 2.0  6.0

Elementare

Da ricordare

• L’informazione è sorpresa: una notizia scontata (domani sorge il sole) non informa, una rara sì. Si misura in bit, e un bit è una domanda ben posta, con risposta sì o no.

• L’entropia è la sorpresa media di una sorgente: 1 bit a lancio per la moneta equa, circa 0,47 per quella truccata che dà testa nove volte su dieci, circa 2,585 per il dado a sei facce. Massima quando tutti gli esiti sono ugualmente possibili, nulla quando l’esito è già deciso in partenza.

• La cross-entropia è quanto costa scrivere i messaggi con il codice sbagliato (il Morse tarato sull’inglese, usato per l’italiano); i bit pagati in più rispetto al codice giusto, cioè lo spreco puro, sono la divergenza di Kullback–Leibler: mai negativa, zero solo se il modello indovina la realtà, e diversa a seconda del verso in cui si sbaglia (perciò non è una distanza).

• Addestrare un classificatore rendendo la risposta giusta sempre meno sorprendente, avvicinare le credenze del modello alla realtà e scegliere i parametri che rendono i dati più plausibili sono tre nomi per la stessa operazione.

• La perplessità traduce l’entropia in facce del dado: quante alternative ugualmente probabili darebbero la stessa incertezza (2 per la moneta equa, 6 per il dado). La ritroveremo nei modelli di linguaggio.

• Comprimere senza perdere niente ha un limite, ed è l’entropia per simbolo della sorgente: quanta sorpresa porta in media ogni pezzo di messaggio, tenuto conto di tutto quello che lo precede. È molto meno di quanto direbbero le sole frequenze delle lettere, ed è la ragione per cui uno zip su un testo fa meglio di quel conto ingenuo, e non fa niente su un file già compresso.

Superiore

Da ricordare

• L’informazione è sorpresa: un esito di probabilità \(p\) vale \(-\log_2 p\) bit; tanto più, quanto più è raro.

• L’entropia \(H(p)=-\sum_i p_i \log_2 p_i\) è la sorpresa media: 1 bit per la moneta equa, 0,47 per quella truccata, 2,585 per il dado. Massima sull’uniforme, nulla sul certo.

• La cross-entropia \(H(p,q)\) è il costo di usare il «codice» sbagliato; la divergenza KL \(D_{KL}(p\,\|\,q)=H(p,q)-H(p)\ge 0\) è lo spreco puro. Asimmetrica: non è una distanza.

• Minimizzare la cross-entropy come loss = minimizzare la KL fra dati e modello = massima verosimiglianza: tre nomi per la stessa operazione.

• La perplessità \(2^{H}\) traduce l’entropia in «facce del dado»: la ritroveremo nei modelli di linguaggio.

• Il limite della compressione senza perdite è l’entropia per simbolo (entropy rate) \(\lim_n H(X_1,\dots,X_n)/n\), non la \(H\) di ordine zero calcolata sulle frequenze marginali: per una sorgente con memoria la seconda sovrastima largamente, e un compressore generico la scavalca senza contraddire Shannon.