Learning come estrazione di struttura

Imparare da dati e comprimere dati sono, sotto la giusta lente, la stessa operazione. Questo capitolo raccoglie i fili informazionali della Parte — entropia, compressione, complessità, informazione mutua, distorsione — e li lega all’apprendimento automatico: perché la loss è una lunghezza di codifica, da dove vengono softmax e regressione logistica, cosa c’entrano i bit con la generalizzazione, e quanto di tutto questo è teorema e quanto è teoria elegante ancora in cerca di conferme.

Perché questo capitolo

Nel 1957 un fisico di nome Edwin Jaynes (1922-1998, fisico statunitense noto per aver rifondato la meccanica statistica su basi inferenziali) pubblica un articolo che sposta un problema di fisica in un problema di logica. La domanda di partenza era termodinamica: data una scatola di gas di cui conosco solo l’energia media, quale distribuzione di velocità delle molecole devo assumere? La risposta di Jaynes non parla di molecole. Dice: tra tutte le distribuzioni compatibili con ciò che sai, scegli quella di entropia massima, perché è l’unica che non aggiunge ipotesi che non hai motivo di fare.

È un principio di onestà intellettuale travestito da formula. E, a settant’anni di distanza, è anche — vedremo — la giustificazione di perché un classificatore moderno produce le sue probabilità con un softmax e non con qualcos’altro.

C’è un secondo aneddoto, quasi contemporaneo, che mostra l’altra faccia della stessa idea. Nel 1951 Claude Shannon (1916-2001, matematico e ingegnere dei Bell Labs, fondatore della teoria dell’informazione) pubblica Prediction and Entropy of Printed English (Bell System Technical Journal, 30, pp. 50-64), dove fa un esperimento sorprendentemente semplice: mostra a delle persone le prime lettere di una frase e chiede di indovinare la successiva, lettera per lettera.

Dalla bravura dei partecipanti nell’indovinare, Shannon stima l’entropia dell’inglese scritto a circa 1 bit per carattere — molto meno dei circa 5 bit che servirebbero per un testo casuale. La conclusione è che chi predice bene la lettera dopo ha già, implicitamente, un modello della lingua, e quel modello è ciò che permette di comprimerla. Predire e comprimere, fin da subito, sono lo stesso gesto.

Questo capitolo è il punto in cui la Parte XIII smette di parlare di cavi, file e canali e comincia a parlare di apprendimento. Tutti gli strumenti costruiti finora — l’entropia come sorpresa media, la compressione come rimozione di ridondanza, la complessità di un oggetto come lunghezza del programma più corto che lo genera, l’informazione mutua come misura di dipendenza, la distorsione come perdita accettabile — convergono qui su una sola tesi.

La tesi è questa: imparare è estrarre struttura, e la struttura è esattamente ciò che permette di descrivere i dati con meno bit del loro costo grezzo.

Per chi costruisce sistemi AI questa non è filosofia d’archivio. La loss di ogni language model è una cross-entropy, e la cross-entropy è una lunghezza di codifica attesa: addestrare un modello a predire bene è, alla lettera, addestrarlo a comprimere. La perplexity con cui si valutano i modelli è quell’entropia esponenziata, e la regolarizzazione che impedisce l’overfitting si lascia leggere come un limite all’informazione che i pesi assorbono dai dati.

Pensare “in bit” trasforma metriche opache in oggetti interpretabili.

Conviene però sapere fin dall’inizio che alcune di queste connessioni sono teoremi solidi, altre sono framework utili, e altre ancora sono ipotesi affascinanti il cui supporto empirico è dibattuto. Distinguere le tre classi è metà del valore del capitolo, e il filo che lo attraversa dalla prima all’ultima riga.

Contesto

Questo capitolo siede in coda alla Parte XIII e ne fa la sintesi verso l’apprendimento. Prima di esso, la Parte ha costruito un vocabolario completo, e qui ogni pezzo trova un uso nell’apprendimento.

Informazione come riduzione di incertezza ha fissato l’entropia $H$ e il source coding theorem, il limite invalicabile della compressione. Minimum Description Length ha mostrato che comprimere e scoprire la struttura dei dati sono la stessa operazione, e ha aperto l’identità tra log-loss e tasso di compressione. Compressione e complessità algoritmica ha portato l’idea al suo estremo teorico — l’oggetto “più appreso” come quello descritto dal programma più corto.

Informazione mutua e dipendenza ha definito $I(X;Y)$ , la quantità con cui qui misureremo “quanto un modello memorizza”. Compressione lossy e perdita accettabile ha introdotto il trade-off rate-distortion che riapparirà come lente sui modelli generativi.

Cosa c’era prima che questi fili si intrecciassero con l’apprendimento? Due tradizioni distinte, nate quasi insieme e a lungo separate.

Da un lato la scuola dell’inferenza informazionale, che parte proprio da Jaynes nel 1957 e dal suo principio di massima entropia. Jaynes lavora sul ponte, già intravisto da Shannon, tra l’entropia della termodinamica e l’entropia dell’informazione: ne fa un metodo generale per costruire distribuzioni di probabilità a partire da conoscenza parziale. Questa tradizione vede l’apprendimento come scelta della distribuzione meno impegnativa compatibile con i dati.

Dall’altro la tradizione della descrizione minima. Ray Solomonoff (1926-2009, matematico statunitense) nel 1964 formula l’induzione come ricerca del programma più corto consistente con le osservazioni. Chris Wallace e David Boulton, informatici australiani, nel 1968 propongono il Minimum Message Length, di matrice bayesiana.

E Jorma Rissanen (1932-2020, teorico dell’informazione finlandese, ricercatore IBM) nel 1978 fonda il Minimum Description Length, la versione calcolabile dell’idea: invece del programma più corto in assoluto (impossibile da trovare), si fissa una classe di modelli e si misura quanto ciascuno comprime i dati. Questa tradizione vede l’apprendimento come compressione.

I due fili convergono — la distribuzione che comprime meglio rispettando dei vincoli è quella di massima entropia — ma il punto di incontro con il machine learning moderno arriva tardi e per tappe.

Negli anni ‘90 la regressione logistica viene riformulata come “maximum entropy classifier” nella linguistica computazionale (Berger, Della Pietra e Della Pietra, A Maximum Entropy Approach to Natural Language Processing, Computational Linguistics 1996). Nel 1999 Naftali Tishby (1952-2021, fisico e informatico israeliano), con Fernando Pereira e William Bialek, propone l’information bottleneck, che legge l’apprendimento di rappresentazioni come un trade-off tra compressione e predittività.

E intorno al 2016-2017 nasce la famiglia dei bound di generalizzazione informazionali — Russo e Zou, poi Xu e Raginsky — che legano quanto un modello generalizza all’informazione mutua tra i dati di training e ciò che ha appreso.

Vale la pena notare il filo che tiene insieme questa storia. Jaynes, Rissanen, Solomonoff, Tishby venivano da campi diversi — fisica statistica, teoria dei codici, teoria della computazione, neuroscienze computazionali — e nessuno partiva dal machine learning come lo intendiamo oggi. Eppure tutti arrivano alla stessa equazione di fondo: descrivere bene i dati, predire bene i dati e comprimere bene i dati sono lo stesso problema, e l’apprendimento è il processo che lo risolve. Questo capitolo non inventa quel filo: lo raccoglie e lo rende esplicito, mostrando dove regge come teorema e dove resta programma di ricerca.

L’intuizione

Prima di qualsiasi formula, due modi di guardare l’apprendimento dal punto di vista dell’informazione. Il primo lo vede come compressione: imparare è trovare la descrizione corta dei dati. Il secondo lo vede come scelta della distribuzione meno impegnativa: imparare è assumere il minimo compatibile con ciò che si è visto. Sono compatibili, anzi sono due facce dello stesso principio, e averli entrambi in testa rende leggibili cose che altrimenti sembrano scollegate.

Angolo 1: imparare è comprimere

Riprendi l’idea centrale del capitolo MDL. Un file si comprime nella misura in cui è prevedibile, e prevederlo bene significa averne capito la struttura. Applica questa idea a un modello che impara.

Hai un grande corpus di testo e un modello che, a ogni passo, assegna una probabilità al prossimo carattere. Se il modello è bravo, assegna probabilità alta ai caratteri che effettivamente arrivano: dopo “intelligen” si aspetta “za” e ci azzecca quasi sempre.

Un buon predittore di questo tipo è anche un buon compressore. Un codificatore aritmetico — la tecnica vista nel capitolo MDL che assegna a ogni simbolo un numero di bit pari alla sua sorpresa $-\log p$ — usa le probabilità del modello per scrivere il testo in pochi bit. Più il modello predice bene, meno bit servono.

Questo non è un paragone suggestivo, è un’identità. Il numero medio di bit per simbolo che il modello spende è esattamente la sua cross-entropy sul testo, la stessa quantità che durante l’addestramento chiamiamo “loss”. Imparare a predire e imparare a comprimere sono lo stesso processo guardato da due lati.

La tesi più radicale di questa tradizione — che comprimere bene sia capire, che l’intelligenza si misuri in tasso di compressione — risale a Solomonoff e alla complessità di Kolmogorov, e tornerà nella sezione sui limiti con tutte le sue cautele. Per ora basta l’intuizione operativa: il modello che impara è il modello che accorcia.

Angolo 2: imparare è assumere il minimo

Capovolgi la prospettiva. Invece di “comprimere ciò che vedo”, chiediti: “data la poca cosa che so, quale distribuzione di probabilità dovrei usare?”. Questo è il principio di massima entropia di Jaynes.

Immagina un dado di cui non sai nulla, se non che — per qualche misura ripetuta — la faccia media che esce vale $4{,}5$ invece del $3{,}5$ di un dado equo. Sai che è truccato verso i numeri alti, ma non come. Quale distribuzione assumi per le sei facce? Ce ne sono infinite compatibili con quella media.

Jaynes risponde: scegli quella di entropia massima, cioè la più “spalmata” possibile compatibile con il vincolo. Qualsiasi altra scelta nasconderebbe un’ipotesi in più che i tuoi dati non giustificano — per esempio che la faccia 6 sia molto più probabile della 5, cosa che la sola media non ti dice.

La distribuzione di massima entropia non è una congettura arbitraria: è “maximally noncommittal with regard to missing information”, massimamente prudente rispetto a ciò che non sai. È il principio di onestà di cui si parlava all’inizio.

E ha una conseguenza matematica che vale la pena anticipare: la distribuzione di massima entropia soggetta a vincoli sui valori medi di alcune feature ha sempre una forma esponenziale. È da questa forma esponenziale che, nella sezione successiva, salteranno fuori il softmax e la regressione logistica.

I due angoli si toccano. La distribuzione che minimizza la lunghezza di codifica attesa, rispettando i vincoli, è proprio quella di massima entropia: minima sorpresa media e minimo impegno ingiustificato sono lo stesso punto guardato da due direzioni. Comprimere senza inventare struttura che non c’è, e assumere il minimo compatibile coi dati, sono la stessa disciplina.

Un esempio concreto fa vedere i due angoli all’opera insieme. Quando un modello fa overfitting, sta facendo entrambe le cose in negativo: dal lato compressione, smette di accorciare i dati nuovi (la validation loss risale) perché ha cominciato a “imparare a memoria” dettagli irripetibili; dal lato del minimo impegno, ha adottato ipotesi che i dati non giustificano, inventando struttura dove c’era solo rumore. L’early stopping — fermarsi quando la validation loss smette di scendere — è il modo grezzo di dire “non assumere più di quanto i dati supportino, non cercare di comprimere il rumore”. È lo stesso principio, visto dal lato pratico dell’addestramento.

Angolo 3: l’orizzonte ideale, e perché è irraggiungibile

C’è un terzo modo di guardare la cosa, più astratto ma utile per fissare i confini. Immagina di poter usare, come “compressore”, non un modello fissato ma qualsiasi programma. La descrizione più corta dei dati diventa allora il programma più breve che li rigenera esattamente: è la complessità di Kolmogorov, l’oggetto del capitolo dedicato. Sotto questa lente, l’apprendimento perfetto sarebbe trovare quel programma minimo — la teoria più compatta che spiega tutto ciò che si è visto.

È un orizzonte, non una ricetta. La complessità di Kolmogorov è incalcolabile: nessun algoritmo può trovare in generale il programma più corto. Per questo l’apprendimento reale non insegue quell’ideale, ma la sua versione domestica: fissare una classe di modelli trattabili e cercare, dentro quella classe, la descrizione più corta. È esattamente il passo da Kolmogorov a MDL, e tenere a mente l’orizzonte ideale serve a ricordare che ogni modello reale è un’approssimazione povera di un compressore che non possiamo costruire. Questo angolo torna, con tutte le sue cautele, nella sezione “Dove si rompe”.

La meccanica

Adesso il formalismo, un filo alla volta. Ogni sezione raccoglie un legame tra informazione e apprendimento, lo enuncia con precisione, e ne dichiara la classe: teorema (provabile), risultato di ricerca con caveat, o analogia didattica. Non tutti i fili sono dello stesso colore, ed è importante non dipingerli come se lo fossero.

La cross-entropy è una lunghezza di codifica attesa

Sia $p$ la distribuzione vera che genera i dati e $q$ la distribuzione del modello. La cross-entropy è

$H(p, q) = -\sum_x p(x) \log q(x)$

In parole povere, questo dice: prendi la sorpresa $-\log q(x)$ che il modello prova davanti a ciascun esito $x$ , e mediala sugli esiti che la realtà produce davvero, pesati da $p(x)$ .

Il legame con la codifica è diretto: $-\log q(x)$ è il numero di bit (se il logaritmo è in base 2) che un codificatore ottimale, costruito credendo nel modello $q$ , spende per scrivere l’esito $x$ . La cross-entropy è quindi la lunghezza di codifica media che paghi usando il modello $q$ su dati che in realtà seguono $p$ .

Questa quantità si scompone in modo illuminante:

$H(p, q) = H(p) + D_{\mathrm{KL}}(p \,\|\, q)$

dove $H(p)$ è l’entropia della sorgente — il pavimento di Shannon, i bit irriducibili — e $D_{\mathrm{KL}}(p \| q)$ è la divergenza di Kullback-Leibler, i bit sprecati perché il modello è sbagliato. Questa decomposizione è già stata costruita in Entropia, cross-entropy, KL divergence; qui ne raccogliamo la conseguenza per l’apprendimento.

Minimizzare la cross-entropy significa azzerare i bit sprecati, cioè avvicinare $q$ a $p$ . E poiché $H(p)$ non dipende dal modello, minimizzare la cross-entropy equivale a minimizzare la KL divergence, cioè a rendere il modello il più fedele possibile alla sorgente. Questa è un’equivalenza, nel senso forte: è la stessa ottimizzazione scritta in due modi.

C’è di più. Sulla distribuzione empirica dei dati — quella che mette peso uguale su ciascun esempio del training set — minimizzare la cross-entropy è esattamente il metodo della massima verosimiglianza, l’MLE che la statistica usa da un secolo per fittare modelli (trattato in MLE: fittare modelli massimizzando probabilità). La loss per cross-entropy non è quindi un’invenzione del deep learning: è la massima verosimiglianza vestita da quantità informazionale. Classe dell’affermazione: teorema, dimostrabile in poche righe.

La perplexity è l’entropia esponenziata

Se la cross-entropy è in bit per simbolo, la perplexity è semplicemente la sua versione esponenziata:

$\mathrm{PP} = 2^{H(p,q)} \quad \text{(o } e^{H(p,q)} \text{ con logaritmi naturali)}$

L’esponenziazione la rende interpretabile come un numero concreto: il branching factor effettivo, ovvero quante scelte equiprobabili il modello sta in media considerando per il prossimo simbolo. Un modello con perplexity 8 è incerto come se a ogni passo dovesse scegliere tra 8 opzioni equiprobabili; uno con perplexity 40 è molto più disorientato. Perplexity bassa significa modello poco sorpreso, cioè modello che comprime bene quel testo. È la metrica con cui si valutano i language model su un corpus held-out — un testo tenuto da parte, mai visto in addestramento — e su cui torneremo nelle applicazioni.

Massima entropia, modelli esponenziali, softmax

Ora il legame anticipato nell’angolo 2. Il principio di Jaynes dice: tra tutte le distribuzioni $p(x)$ che rispettano dei vincoli sui valori medi di certe feature $f_i(x)$ — cioè $\sum_x p(x) f_i(x) = c_i$ , con $c_i$ i valori osservati — scegli quella che massimizza l’entropia $H(p)$ .

Risolvere questo problema di ottimizzazione vincolata (con i moltiplicatori di Lagrange, uno per ogni vincolo) dà sempre la stessa forma:

$p(x) = \frac{1}{Z} \exp\!\Big(\sum_i \lambda_i f_i(x)\Big)$

dove i $\lambda_i$ sono i moltiplicatori e $Z = \sum_x \exp(\sum_i \lambda_i f_i(x))$ è il normalizzatore (la funzione di partizione, nome ereditato dalla fisica). Questa è la famiglia esponenziale. In parole povere: la distribuzione meno impegnativa compatibile con vincoli lineari sui momenti è sempre un’esponenziale dei momenti stessi. Questo è un teorema.

Da qui il salto al machine learning, da fare con cura perché è il punto in cui si scivola facilmente.

Prendi un problema di classificazione con $K$ classi e una feature vettoriale $x$ . Cerca la distribuzione condizionata $p(y \mid x)$ di massima entropia, sotto il vincolo che certi valori medi (le feature combinate con le classi) corrispondano a quelli osservati. Il risultato ha forma

$p(y \mid x) = \frac{\exp(w_y \cdot x)}{\sum_{k} \exp(w_k \cdot x)}$

che è esattamente il softmax (trattato in Dalla somma alla probabilità). Con due sole classi, la stessa formula si riduce alla sigmoide della regressione logistica. Questa identità — il classificatore log-lineare è il modello di massima entropia su vincoli lineari — è il motivo per cui la regressione logistica veniva chiamata “maximum entropy classifier” nella linguistica computazionale degli anni ‘90.

Classe dell’affermazione: equivalenza, e per giunta argomentata da un teorema (la forma esponenziale della distribuzione MaxEnt). Non è un’analogia: il softmax è la forma funzionale che il principio di massima entropia impone. Va aggiunta una cautela: questa derivazione fissa la classe di vincoli (lineari sulle feature scelte); cambiare le feature cambia il modello. Il principio dice che forma avrà la distribuzione, non quali feature siano quelle giuste.

C’è una dualità ancora più stretta, che vale la pena enunciare senza dimostrarla: trovare i pesi $\lambda_i$ (o $w_k$ ) che massimizzano l’entropia rispettando i momenti empirici è lo stesso problema che trovare i pesi che massimizzano la verosimiglianza dei dati sotto il modello esponenziale. Massima entropia e massima verosimiglianza, su questa famiglia di modelli, danno la stessa soluzione.

L’intuizione del perché coincidono: la condizione che il modello esponenziale soddisfa quando massimizza la verosimiglianza è che i valori medi delle feature predetti dal modello eguaglino quelli osservati nei dati. Ma “eguagliare i momenti osservati” è esattamente il vincolo che MaxEnt impone.

Le due ottimizzazioni partono da problemi opposti — una massimizza l’entropia con i momenti come vincolo, l’altra massimizza la verosimiglianza con la forma esponenziale come vincolo — e si incontrano nello stesso punto. È un risultato classico; la prova passa per la convessità del problema e appartiene a un capitolo di ottimizzazione, ma l’intuizione “entrambe vogliono che i momenti del modello tornino con quelli dei dati” è già sufficiente per fidarsene. Una cautela da non dimenticare quando si usa questa equivalenza: vale dentro la famiglia esponenziale, non per modelli arbitrari.

MDL: selezione del modello e regolarizzazione

Il principio Minimum Description Length, costruito nel capitolo Minimum Description Length, descrive ogni descrizione completa dei dati come un two-part code: il costo di enunciare il modello più il costo di enunciare ciò che il modello non cattura.

$L(\text{dati}) = L(\text{modello}) + L(\text{dati} \mid \text{modello})$

Il primo termine penalizza i modelli complessi: servono più bit per scriverli. Il secondo premia il fit: un modello che spiega bene i dati lascia residui piccoli, quindi pochi bit da codificare. Il minimo della somma è il punto di equilibrio, ed è esattamente il rasoio di Occam — la spiegazione più semplice che rende conto dei dati — che cade fuori dalla matematica della lunghezza di descrizione invece di essere aggiunto come euristica esterna.

Visto come teoria della selezione del modello, MDL dice: tra due modelli, scegli quello che dà la descrizione totale più corta. Questo lega MDL direttamente all’overfitting.

Un modello che memorizza i dati — un polinomio di grado altissimo che passa per ogni punto, rumore incluso — annulla i residui ma costa enormemente da descrivere: $L(\text{modello})$ esplode. Un modello troppo semplice — una retta dove i dati seguono una curva — costa poco a descrivere ma lascia residui enormi: $L(\text{dati} \mid \text{modello})$ esplode. Il modello che generalizza vive nel mezzo, e MDL lo trova senza bisogno di un set di validazione separato. È la stessa storia del trade-off in Il trade-off bias-varianza, raccontata in bit.

Questa lettura rende anche la regolarizzazione trasparente. Una penalità $L_2$ sui pesi (weight decay) corrisponde, sotto le giuste assunzioni, a un costo in bit per descrivere pesi grandi: pesi piccoli sono più economici da codificare, quindi la penalità è un termine $L(\text{modello})$ implicito. La regolarizzazione, in questa lente, non è un trucco numerico per evitare l’overfitting: è il termine di descrizione del modello del two-part code, reso esplicito nella loss.

Il legame con la versione bayesiana — la regolarizzazione $L_2$ come prior gaussiano sui pesi — è sviluppato in MAP, prior, posterior, regolarizzazione, ed è lo stesso conto visto dal lato della probabilità a posteriori invece che dal lato dei bit. Classe: il nucleo MDL è teorema; la mappa precisa tra una particolare penalità e un particolare costo in bit è una corrispondenza che vale sotto assunzioni dichiarate, non un’identità universale.

L’informazione di Fisher e la curvatura

La versione raffinata di MDL, dovuta a Rissanen (Fisher Information and Stochastic Complexity, IEEE Transactions on Information Theory 1996), rende preciso quanto costa “descrivere un modello” quando il modello ha parametri continui. Il costo non dipende solo dal numero di parametri, ma da quanto finemente vanno specificati — e questo lo dice l’informazione di Fisher.

L’informazione di Fisher $I(\theta)$ misura quanta informazione i dati portano sul parametro $\theta$ . Operativamente è la curvatura attesa della log-verosimiglianza attorno al suo massimo: è l’Hessiana media della log-likelihood, l’oggetto che descrive quanto velocemente la verosimiglianza cala allontanandosi dal punto ottimale (le Hessiane e la curvatura sono trattate in Hessiana, curvatura, condizionamento).

Curvatura alta significa picco stretto: piccoli spostamenti del parametro peggiorano molto il fit, quindi il parametro è determinato con precisione dai dati — e per codificarlo servono più bit, perché va specificato con molte cifre.

Nella forma raffinata di MDL, il termine di complessità di un modello con $k$ parametri e $n$ dati ha la forma

$\frac{k}{2}\log n + \log \int \sqrt{\det I(\theta)}\; d\theta$

Il primo addendo, $\frac{k}{2}\log n$ , è il celebre criterio BIC (Bayesian Information Criterion): più parametri e più dati, più bit per la complessità. Il secondo addendo è il “volume informativo” dello spazio dei parametri, misurato proprio dall’informazione di Fisher: cattura quanto la classe di modelli è “flessibile”, indipendentemente dal numero di parametri. Due modelli con lo stesso numero di parametri possono avere complessità diverse se uno è più capace di adattarsi a dati arbitrari.

Classe: teorema asintotico, valido sotto condizioni di regolarità. Il legame Fisher-curvatura-bit è uno dei punti dove la teoria dell’informazione, la statistica e l’ottimizzazione parlano letteralmente la stessa lingua.

Bound di generalizzazione informazionali

Qui si entra nel terreno più recente e più delicato. La domanda è: perché un modello addestrato su un campione finito funziona anche su dati nuovi? Una famiglia di risposte misura la generalizzazione in bit.

La prima formulazione, di tipo PAC-Bayes, è di David McAllester (informatico statunitense, PAC-Bayesian Model Averaging, COLT 1999). Il gap di generalizzazione — la differenza tra l’errore sul training e l’errore vero — è limitato da una quantità che contiene $D_{\mathrm{KL}}(Q \| P)$ , la divergenza KL tra la distribuzione $Q$ sui modelli che l’apprendimento produce e una distribuzione $P$ fissata prima di vedere i dati:

$\text{gap} \;\lesssim\; \sqrt{\frac{D_{\mathrm{KL}}(Q \,\|\, P) + \log(\dots)}{2m}}$

con $m$ la taglia del campione. La KL è leggibile come lunghezza di descrizione: quanti bit servono per specificare il modello appreso $Q$ partendo dal prior $P$ . Meno bit servono — più il modello è “comprimibile” rispetto a ciò che si sapeva già — meglio generalizza. È la stessa intuizione di MDL, sul terreno della teoria dell’apprendimento.

La seconda formulazione lega la generalizzazione all’informazione mutua. Daniel Russo e James Zou (How much does your data exploration overfit? Controlling bias via information usage, COLT 2016) mostrano che il bias da overfitting di una procedura adattiva è limitato dall’informazione mutua tra i dati e le scelte fatte guardandoli: $|\mathbb{E}[\phi - \mu]| \le \sigma\sqrt{2\, I(T;\phi)}$ , sotto l’ipotesi che le stime siano sub-gaussiane con parametro $\sigma$ .

Aolin Xu e Maxim Raginsky (Information-theoretic analysis of generalization capability of learning algorithms, NeurIPS 2017) estendono il risultato all’apprendimento vero e proprio: il gap di generalizzazione atteso è limitato dall’informazione mutua $I(S; W)$ tra il training set $S$ e i pesi appresi $W$ :

$|\mathbb{E}[\text{gap}]| \;\le\; \sqrt{\frac{2\sigma^2\, I(S; W)}{n}}$

In parole povere, questo dice che la differenza media tra l’errore sul training e l’errore vero non può superare una quantità che cresce con $I(S; W)$ e cala con la radice del numero di esempi $n$ : più dati hai, più stretto è il vincolo, e più i pesi dipendono dai dati specifici, più il vincolo si allarga.

L’interpretazione è limpida e bella: $I(S; W)$ misura quanta informazione i pesi finali “assorbono” dai dati specifici di training. Se i pesi dipendono pochissimo dal particolare campione visto — se l’algoritmo non memorizza i dati — allora $I(S; W)$ è piccola e la generalizzazione è garantita. Meno il modello memorizza i dati specifici, meglio generalizza. Xu e Raginsky usano questa lettura per giustificare la regolarizzazione: aggiungere rumore o una penalità di entropia relativa serve proprio a limitare $I(S; W)$ .

Classe dell’affermazione, da marcare con la massima cura: questi sono teoremi — i bound sono provabili — ma il loro valore esplicativo per il deep learning reale è un’area di ricerca aperta, non un fatto stabilito.

Stimare $I(S; W)$ per una rete neurale con miliardi di parametri è difficilissimo, e nei regimi reali i bound risultano spesso allentati o addirittura vacui (cioè più grandi di 1, quindi inutili come limite su una probabilità di errore). C’è di più: le reti profonde sovraparametrizzate memorizzano moltissimo — possono fittare etichette casuali — e generalizzano comunque, un fenomeno (la cosiddetta doppia discesa) che la storia semplice “meno memorizzi, meglio generalizzi” non cattura. I bound informazionali sono una lente vera e una direzione di ricerca viva, non la spiegazione chiusa di perché il deep learning funziona.

Vale la pena notare cosa hanno in comune le due famiglie di bound, perché il filo unificante è proprio il tema del capitolo. PAC-Bayes misura la complessità del modello come $D_{\mathrm{KL}}(Q \| P)$ — i bit per descrivere l’ipotesi appresa partendo da ciò che si sapeva prima. I bound alla Russo-Zou e Xu-Raginsky la misurano come $I(S; W)$ — i bit che i pesi assorbono dai dati.

Sono due quantità diverse, ma entrambe contano bit di informazione che lega il modello ai dati specifici. In entrambe la regola è la stessa: meno bit, meglio si generalizza. È la traduzione, in linguaggio di teoria dell’apprendimento, del principio MDL — la descrizione più corta del modello è quella che generalizza. La generalizzazione, in questa famiglia di risultati, è una proprietà della compressibilità del modello rispetto ai dati.

Information bottleneck: compressione contro predittività

L’information bottleneck, introdotto da Tishby, Pereira e Bialek nel 1999 (The information bottleneck method), guarda l’apprendimento di rappresentazioni come un trade-off. Una rappresentazione $T$ dell’input $X$ , usata per predire un target $Y$ , è buona se massimizza $I(T; Y)$ — quanto $T$ è predittiva di $Y$ — minimizzando al contempo $I(X; T)$ — quanto $T$ comprime l’input, buttando via tutto ciò che non serve a predire $Y$ .

Le soluzioni vivono lungo una curva, lo stesso tipo di frontiera vista in Compressione lossy e perdita accettabile: non è un caso, l’IB è formalmente imparentato con la teoria rate-distortion, con $Y$ al posto della ricostruzione.

Nel 2015-2017 Tishby e Ravid Shwartz-Ziv portano l’idea dentro il deep learning, sostenendo (in Opening the Black Box of Deep Neural Networks via Information, 2017) che il training di una rete attraversa due fasi visibili sul piano informazionale: prima una fase di fitting in cui $I(T; Y)$ cresce — la rete impara a predire — poi una fase di compression molto più lunga in cui $I(X; T)$ cala — la rete butta via informazione sull’input irrilevante per il target. La tesi è suggestiva: il grosso dell’addestramento sarebbe compressione.

È qui che il capitolo deve essere onesto. Andrew Saxe e collaboratori, in On the Information Bottleneck Theory of Deep Learning (ICLR 2018), contestano empiricamente: la fase di compressione che Tishby e Shwartz-Ziv osservano dipende dalla funzione di attivazione usata (compare con la tangente iperbolica, ma con le ReLU — oggi standard — spesso non si vede) e dal modo in cui l’informazione mutua viene stimata con il binning, una procedura notoriamente fragile in alta dimensione. Tishby ha replicato che le stime di Saxe erano troppo deboli per cogliere la compressione.

Classe dell’affermazione: dibattito aperto, non risolto. L’information bottleneck è un framework concettuale ricco e fecondo, ma la specifica tesi che “il deep learning generalizza perché comprime, in due fasi” non è consenso. È l’esempio modello di una teoria informazionale elegante con supporto empirico contestato — esattamente la categoria su cui questo capitolo invita alla cautela.

Rate-distortion come lente sui modelli generativi

L’ultimo filo. La teoria rate-distortion del capitolo precedente — il minimo di bit per ricostruire un segnale entro una distorsione accettabile — offre una lente naturale sui modelli generativi che comprimono i dati in un codice latente.

In un autoencoder variazionale (VAE), un tipo di modello generativo che impara a comprimere e ricostruire i dati passando per uno spazio latente più piccolo, l’obiettivo di addestramento ha due termini: uno di ricostruzione (quanto bene il dato viene rigenerato — la distorsione) e uno che misura quanti bit il codice latente porta (il rate).

Alexander Alemi e collaboratori (Fixing a Broken ELBO, ICML 2018) hanno mostrato che le diverse soluzioni di un VAE si dispongono lungo un piano rate-distortion, e che modelli con la stessa loss totale possono occupare punti molto diversi di quel piano — alcuni che comprimono molto e ricostruiscono male, altri il contrario.

Classe: framework formale solido, con riferimento; è una delle letture possibili dei generativi, non l’unica. La menziono perché chiude il cerchio: ogni capitolo della Parte XIII trova un uso nell’apprendimento, e rate-distortion non fa eccezione.

Una sola idea, classi diverse

Prima di passare agli esempi, conviene fissare la mappa dei fili appena percorsi, perché la cosa più facile da sbagliare non è la matematica ma la classe di ciascun legame. Tutti raccontano la stessa storia — apprendere è estrarre struttura, e la struttura si misura in bit — ma con gradi di solidità molto diversi.

Sono teoremi, provabili e non opinabili: l’identità cross-entropy uguale lunghezza di codifica attesa; minimizzare la cross-entropy equivale a minimizzare la KL e coincide con la massima verosimiglianza; la distribuzione MaxEnt su vincoli lineari ha forma esponenziale, da cui softmax e regressione logistica; i bound di generalizzazione di PAC-Bayes, Russo-Zou e Xu-Raginsky sono disuguaglianze dimostrate.

Sono framework solidi con assunzioni dichiarate: la forma raffinata di MDL con l’informazione di Fisher (asintotica, sotto regolarità); la corrispondenza tra una particolare regolarizzazione e un costo in bit (dipende dal prior); la lettura rate-distortion dei generativi (una lente, non l’unica).

Sono dibattiti aperti o programmi di ricerca: l’information bottleneck come spiegazione del training delle reti (contestato da Saxe et al.); la tesi forte “comprimere uguale intelligenza” (radicata in Kolmogorov, ma incalcolabile e non operativa); il valore esplicativo, non solo formale, dei bound informazionali per il deep learning sovraparametrizzato.

Tenere queste tre colonne separate è la disciplina che rende la teoria dell’informazione una lente onesta sull’apprendimento, invece di una collezione di slogan suggestivi. Quando in un paper o in un thread leggi “il modello impara perché comprime”, la prima domanda da farsi è: in quale delle tre colonne sta quella frase?

Esempi

Esempio numerico: cross-entropy, KL e perplexity di due modelli

Una sorgente emette quattro simboli $\{A, B, C, D\}$ con probabilità vere $p = (0{,}5,\, 0{,}25,\, 0{,}125,\, 0{,}125)$ . La sua entropia è

$H(p) = -\big(0{,}5\log_2 0{,}5 + 0{,}25\log_2 0{,}25 + 2\cdot 0{,}125\log_2 0{,}125\big) = 1{,}75 \text{ bit/simbolo}$

Questo è il pavimento: nessun modello comprime sotto $1{,}75$ bit per simbolo senza perdere informazione.

Modello giusto: $q_1 = p$ . La cross-entropy $H(p, q_1) = 1{,}75$ , la KL è zero, la perplexity è $2^{1{,}75} \approx 3{,}36$ . Il modello è incerto come se scegliesse tra $3{,}36$ opzioni equiprobabili — meno di 4, perché la distribuzione è sbilanciata.

Modello sbagliato: $q_2 = (0{,}25,\, 0{,}25,\, 0{,}25,\, 0{,}25)$ , cioè crede che i simboli siano equiprobabili. Allora $H(p, q_2) = -\sum_x p(x)\log_2 0{,}25 = 2$ bit/simbolo. La KL vale $2 - 1{,}75 = 0{,}25$ bit: sono i bit sprecati a ogni simbolo perché il modello ignora che $A$ è più frequente. La perplexity sale a $2^2 = 4$ , il branching factor di chi non ha imparato nulla sulle frequenze.

La differenza tra i due modelli — $0{,}25$ bit per simbolo — è precisamente quanta compressione il modello giusto guadagna avendo imparato la struttura della sorgente. Su un milione di simboli sono $250\,000$ bit, oltre $30$ kilobyte di differenza solo per aver saputo che $A$ esce metà delle volte.

Lo stesso conto in poche righe di codice, per fissare che cross-entropy, KL e perplexity sono tre viste della stessa quantità:

import numpy as np

p  = np.array([0.5, 0.25, 0.125, 0.125])     # sorgente vera
q1 = p.copy()                                 # modello giusto
q2 = np.array([0.25, 0.25, 0.25, 0.25])       # modello sbagliato

def cross_entropy(p, q):
    return -np.sum(p * np.log2(q))            # bit/simbolo

H  = cross_entropy(p, p)                       # entropia = 1.75
H2 = cross_entropy(p, q2)                       # 2.0
print(H, H2, H2 - H)                            # 1.75 2.0 0.25 (la KL)
print(2**H, 2**H2)                              # perplexity: 3.36, 4.0

La riga H2 - H è la KL: i bit sprecati dal modello sbagliato.

Non c’è niente di magico nella loss di un classificatore — è esattamente questo conto, mediato su un dataset invece che su una distribuzione nota. Quando un framework di deep learning calcola cross_entropy_loss, sta facendo questa media; il resto è solo il gradiente che la spinge verso il basso.

Esempio in codice: massima entropia sul dado truccato

Riprendiamo il dado di cui sappiamo solo che la media è $4{,}5$ . Cercare la distribuzione di massima entropia con questo vincolo significa risolvere per il singolo moltiplicatore $\lambda$ tale che $p(k) \propto e^{\lambda k}$ e $\sum_k k\, p(k) = 4{,}5$ .

import numpy as np
from scipy.optimize import brentq

facce = np.array([1, 2, 3, 4, 5, 6])

def media_attesa(lmbda):
    pesi = np.exp(lmbda * facce)
    p = pesi / pesi.sum()          # forma esponenziale = MaxEnt
    return (facce * p).sum()

# trova il lambda che produce media 4,5
lmbda = brentq(lambda l: media_attesa(l) - 4.5, -2, 2)

pesi = np.exp(lmbda * facce)
p = pesi / pesi.sum()
print(np.round(p, 3))   # [0.054 0.079 0.114 0.165 0.240 0.347]

Il risultato non è “tutta la probabilità sul 6” né “metà sul 5 e metà sul 6”: è la distribuzione più spalmata possibile che comunque rispetta la media $4{,}5$ , con probabilità che crescono dolcemente verso le facce alte.

Nota la forma del codice: np.exp(lambda * facce) normalizzato. È un softmax con un solo parametro — lo stesso meccanismo che, su classi anziché su facce e con feature anziché un solo numero, è il softmax di un classificatore. L’esempio mostra in concreto perché il softmax non è una scelta arbitraria di funzione “che fa somma uno”: è la forma che il principio di massima entropia impone.

Scenario reale: la training loss letta come tasso di compressione

Stai addestrando un piccolo language model a livello di carattere e guardi la loss scendere. All’inizio, prima di qualsiasi apprendimento, il modello assegna probabilità uniforme ai 256 byte possibili: la sua cross-entropy è $\log_2 256 = 8$ bit per carattere, esattamente la dimensione grezza del testo. Non comprime nulla.

Dopo un po’ di addestramento la loss scende a, diciamo, $1{,}2$ bit per carattere. Quel numero ha un significato fisico immediato: il modello, usato come compressore con una codifica aritmetica, scriverebbe il testo a $1{,}2$ bit per carattere invece di 8 — un fattore di compressione di circa $6{,}7\times$ . La curva di loss è una curva di tasso di compressione.

Questa lettura cambia il modo di guardare le metriche. Quando un report dice che un modello ha “loss $0{,}9$ nat per token”, lo puoi tradurre in $0{,}9 / \ln 2 \approx 1{,}3$ bit per token, e da lì in perplexity $e^{0{,}9} \approx 2{,}46$ . Quando confronti due modelli, stai confrontando due compressori.

E quando vedi la validation loss smettere di scendere mentre la training loss continua, stai vedendo il modello che comincia a memorizzare rumore specifico del training — informazione che non comprime i dati nuovi — esattamente la situazione che il two-part code di MDL penalizza facendo esplodere il costo del modello. È il ponte verso il capitolo successivo della Parte, ponte-informazione-llm (in preparazione), che porta questa lettura fino in fondo sui modelli linguistici moderni.

Un quarto esempio: l’overfitting visto in bit

Per rendere tangibile il legame MDL-overfitting, considera dieci punti che seguono grosso modo una retta con un po’ di rumore. Un modello lineare (due parametri: pendenza e intercetta) li descrive con un costo del modello bassissimo e residui piccoli ma non nulli. Un polinomio di grado nove passa esattamente per tutti e dieci i punti — residui zero — ma per descriverlo servono dieci coefficienti, ciascuno specificato con molte cifre perché la curva oscilla violentemente tra i punti.

Nel conto del two-part code, $L(\text{dati} \mid \text{modello})$ va a zero per il polinomio, ma $L(\text{modello})$ esplode. La somma totale è minima per il modello lineare, ed è il motivo per cui generalizza meglio: la descrizione più corta dei dati è anche la più predittiva su dati nuovi. MDL trova questo equilibrio contando bit, senza aver mai visto un punto di test.

Applicazioni pratiche

Pensare in bit. L’applicazione più trasversale è anche la più semplice: imparare a leggere ogni loss come un tasso di compressione e ogni perplexity come un branching factor. Una loss di $2$ nat per token non è un numero astratto: è un compressore che spende $\approx 2{,}9$ bit per token, una perplexity di $\approx 7{,}4$ scelte equiprobabili. Questa traduzione rende immediato capire se un modello ha davvero imparato qualcosa (perplexity vicina al numero di opzioni “ovvie” del dominio) o se sta brancolando.

Perplexity come metrica e come sensore di drift. La perplexity su un corpus held-out è la metrica standard per confrontare language model e per accorgersi che la distribuzione dei dati in produzione è cambiata: se la perplexity di un modello su nuovo traffico schizza in alto, il mondo si è spostato rispetto a ciò su cui è stato addestrato. È un allarme di concept drift letto in bit.

Regolarizzazione come limite di informazione. Weight decay, dropout, early stopping, label smoothing si lasciano tutti leggere come modi di limitare l’informazione che il modello assorbe dai dati specifici — abbassare quel $I(S; W)$ dei bound di Xu-Raginsky, o accorciare il termine $L(\text{modello})$ di MDL. Questa lente non cambia il codice, ma cambia l’intuizione: regolarizzare non è “rendere il modello più stupido”, è “impedirgli di memorizzare ciò che non generalizza”.

Selezione del modello senza validation set. Quando i dati sono pochi e tenerne da parte per la validazione fa male, criteri come BIC (la forma asintotica di MDL) permettono di scegliere il numero di componenti di un modello — quanti cluster, quale grado di polinomio, quanti stati in un modello di Markov nascosto — bilanciando fit e complessità in bit. È MDL applicato come strumento di tutti i giorni nella statistica e nella data science.

Leggere le eval in chiave informazionale. Per chi valuta modelli e agenti, il framing “in bit” offre una difesa contro un errore sottile: un modello può avere perplexity bassissima su un dominio e generalizzare male su un altro, perché ha compresso ottimamente quella distribuzione, non la struttura profonda del compito.

La perplexity misura quanta struttura il modello ha estratto dai dati su cui la calcoli, e quanto un modello ha “compresso” un dominio non garantisce che generalizzi a un dominio vicino ma diverso. Tenere distinte “quanta informazione il modello estrae da questi dati” e “quanto generalizza a dati nuovi” è la stessa distinzione $I(S;W)$ contro errore di test, riportata al banco di prova quotidiano della valutazione.

Label smoothing come massima entropia applicata. Una tecnica diffusa nell’addestramento dei classificatori è il label smoothing: invece di chiedere al modello di assegnare probabilità 1 alla classe corretta e 0 a tutte le altre, si chiede di assegnare, diciamo, $0{,}9$ alla corretta e di spalmare il resto sulle altre.

Letto in chiave informazionale, è un modo di iniettare un po’ di entropia nei target: si impedisce al modello di diventare arbitrariamente sicuro, mantenendolo più “spalmato”, più vicino allo spirito di MaxEnt. Il risultato pratico è un modello meglio calibrato, le cui probabilità sono più affidabili — un legame con la calibrazione che vale la pena tenere presente.

Comprimere = predire per capire i compressori general-purpose. Il framing di questo capitolo spiega perché un buon language model è anche un buon compressore di dati che non ha mai visto in quel formato — testo, immagini, audio — meglio dei programmi nati apposta per quei formati, come mostrato in lavori recenti sulla compressione via modelli linguistici. La chiave da tenere a mente, ripresa dalla sezione sui limiti, è che il confronto è onesto solo se si conta anche il peso del modello: il compressore include i suoi miliardi di parametri.

Dove si rompe

Questa sezione raccoglie i fraintendimenti e i confini, ed è ampia di proposito: in un capitolo che lega molte teorie eleganti, sapere dove ciascuna si ferma vale quanto saperla applicare.

“Cross-entropy bassa significa che il modello capisce.” No. La cross-entropy bassa significa buona predizione su quella distribuzione, ed è equivalente — formalmente — a buona compressione. Non dice nulla sulla comprensione semantica nel senso umano.

Un modello può comprimere ottimamente un testo sfruttando regolarità statistiche superficiali senza alcun modello del mondo. L’identità compressione-predizione è solida; il salto da lì a “comprensione” è una tesi filosofica separata, su cui la sezione finale del capitolo MDL e la complessità di Kolmogorov hanno già messo dei paletti.

“La distribuzione di massima entropia è la distribuzione vera.” No. MaxEnt è la distribuzione meno impegnativa compatibile con i vincoli che hai imposto. Se i vincoli sono giusti, è la scelta più prudente. Se i vincoli sono sbagliati o incompleti, MaxEnt è precisa nel modo sbagliato: produce con sicurezza una distribuzione che riflette le tue ipotesi, non la realtà. Il principio sceglie la forma data i vincoli; la responsabilità dei vincoli resta tua.

“I bound informazionali spiegano perché il deep learning generalizza.” Questo è il fraintendimento più importante da disinnescare. I bound di PAC-Bayes, Russo-Zou e Xu-Raginsky sono teoremi veri, ma per le reti profonde reali sono spesso vacui: il limite che producono sull’errore è più grande di uno, quindi non vincola nulla.

Inoltre la storia intuitiva “meno memorizzi, meglio generalizzi” è messa in crisi dal fatto sperimentale che le reti sovraparametrizzate memorizzano enormemente — fittano persino etichette completamente casuali — e generalizzano comunque bene su dati reali. Il fenomeno della doppia discesa, in cui l’errore di test prima peggiora e poi migliora aumentando la capacità del modello oltre il punto di interpolazione, non rientra nella narrazione semplice. I bound informazionali sono una direzione di ricerca viva e una lente legittima, non una spiegazione chiusa.

“L’information bottleneck spiega il training delle reti.” Dibattuto, come visto nella meccanica. La tesi delle due fasi (fitting poi compression) di Shwartz-Ziv e Tishby è contestata da Saxe et al.: la fase di compressione dipende dall’attivazione e dalle stime fragili dell’informazione mutua. Stimare $I(X; T)$ in alta dimensione è notoriamente difficile, e diverse “osservazioni” di compressione sono artefatti del metodo di stima. Non dare l’IB per assodato come meccanismo del deep learning.

“Comprimere è intelligenza.” La tesi forte — radicata in Solomonoff e nella complessità di Kolmogorov, e popolarizzata da iniziative come lo Hutter Prize — è affascinante ma non è un teorema sul machine learning pratico.

La complessità di Kolmogorov, il programma più corto che genera un oggetto, è incalcolabile: non esiste un algoritmo che la trovi. MDL è la versione calcolabile, ma solo relativa a una classe di modelli scelta. L’equazione “compressione = intelligenza” resta un programma di ricerca e una posizione filosofica, non un risultato consolidato.

Confondere i due tipi di informazione mutua. Nel capitolo compaiono due quantità che sono entrambe informazione mutua ma misurano cose diverse. $I(S; W)$ è l’informazione che i pesi assorbono dal training set — la lente dei bound di generalizzazione. $I(X; T)$ è l’informazione che una rappresentazione interna tiene dell’input — la lente dell’information bottleneck.

Sono concetti distinti, su oggetti distinti, e mescolarli porta a confusione. La prima riguarda quanto il modello dipende dai dati specifici; la seconda quanto una feature comprime l’input. Tenere separati i due usi della stessa lettera è una delle protezioni più semplici contro i fraintendimenti informazionali sull’apprendimento.

I limiti della corrispondenza regolarizzazione-bit. La lettura “weight decay = costo in bit del modello” è vera sotto assunzioni precise (in particolare, un certo prior gaussiano sui pesi). Non è un’identità universale: cambiare il prior cambia la corrispondenza, e non ogni tecnica di regolarizzazione ha una traduzione informazionale pulita. È una lente potente quando vale, non una legge che vale sempre.

I bound sono garanzie in attesa, non promesse su ogni caso. Come i risultati di universalità in compressione (Lempel-Ziv converge al tasso ottimale al limite), i bound informazionali sono affermazioni su un comportamento medio o asintotico sotto assunzioni (sub-gaussianità, regolarità). Su un singolo modello, un singolo dataset, possono essere allentati al punto da non dire nulla di utile. Conoscere l’assunzione che li regge è parte del saperli usare.

Confrontare perplexity tra modelli con tokenizzatori diversi. Questo è un errore pratico frequente. La perplexity è bit per simbolo, e il “simbolo” dipende da come il testo viene segmentato: un modello che usa token lunghi (parole intere) e uno che usa token corti (caratteri o sub-word piccole) producono perplexity non confrontabili, perché stanno contando su unità diverse.

Lo stesso testo, comprimibile con lo stesso numero di bit totali, dà perplexity per token molto diverse a seconda di quanti token servono a scriverlo. Per confrontare modelli con tokenizzatori diversi bisogna passare a una misura per-byte (bits-per-byte), che normalizza sul testo grezzo invece che sui token. Confrontare perplexity nude tra modelli con vocabolari diversi è uno degli errori più comuni nelle tabelle di benchmark.

Collegamenti

Entropia, cross-entropy, KL divergence: la decomposizione $H(p,q) = H(p) + D_{\mathrm{KL}}(p\|q)$ su cui poggia tutta l’identità loss-compressione raccolta in questo capitolo. La macchina formale arriva da lì.
Minimum Description Length: il two-part code, il rasoio di Occam che cade fuori dalla matematica, l’identità log-loss/compressione. Questo capitolo ne raccoglie le conseguenze per la selezione del modello e la regolarizzazione.
Compressione e complessità algoritmica: la tesi forte “comprimere = capire”, la sua radice in Solomonoff, e l’incalcolabilità che la tiene a livello di programma filosofico più che di teorema operativo.
Informazione mutua e dipendenza: la quantità $I(\cdot;\cdot)$ con cui si misura sia quanto un modello memorizza i dati ( $I(S;W)$ ) sia quanto una rappresentazione comprime l’input ( $I(X;T)$ ).
Compressione lossy e perdita accettabile: la frontiera rate-distortion che riappare come lente sui modelli generativi con bottleneck, e a cui l’information bottleneck è formalmente imparentato.
Informazione come riduzione di incertezza: l’entropia e il source coding theorem, il pavimento sotto cui nessun modello comprime senza perdere informazione vera.
MLE: fittare modelli massimizzando probabilità: minimizzare la cross-entropy sui dati empirici è esattamente la massima verosimiglianza. La loss del deep learning è l’MLE in abito informazionale.
MAP, prior, posterior, regolarizzazione: la regolarizzazione vista dal lato bayesiano (prior sui pesi) è lo stesso conto del termine $L(\text{modello})$ di MDL visto dal lato dei bit.
Dalla somma alla probabilità: il softmax non è una funzione arbitraria di normalizzazione, è la forma che il principio di massima entropia impone su vincoli lineari. La regressione logistica è il suo caso a due classi.
Il trade-off bias-varianza: MDL è la versione informazionale dello stesso trade-off. Modello troppo complesso uguale overfitting uguale descrizione lunga.
Hessiana, curvatura, condizionamento: l’informazione di Fisher come curvatura della log-verosimiglianza, l’oggetto che misura quanti bit servono per specificare un parametro nella forma raffinata di MDL.
Reliability diagram, Brier score, confidenza: il label smoothing letto come iniezione di entropia produce modelli meglio calibrati; il legame tra “spalmare” le probabilità e affidabilità delle confidenze.
ponte-informazione-llm (in preparazione): il capitolo successivo della Parte, che porta la lettura “comprimere = predire” fino in fondo sui language model — token prediction, compressione, rappresentazioni.

Per andare oltre

Jaynes, E. T. (1957). Information Theory and Statistical Mechanics, Physical Review, 106, 620-630. Il paper che fonda il principio di massima entropia come metodo di inferenza: scegliere la distribuzione meno impegnativa compatibile coi vincoli. Origine del legame con i modelli esponenziali.
Xu, A. & Raginsky, M. (2017). Information-theoretic analysis of generalization capability of learning algorithms, NeurIPS 2017 (arXiv:1705.07809). Il bound che lega la generalizzazione all’informazione mutua $I(S;W)$ tra dati e pesi. Da leggere insieme a Russo & Zou (2016, arXiv:1511.05219), che ne è il precursore.
Tishby, N., Pereira, F. C. & Bialek, W. (1999). The information bottleneck method (arXiv:physics/0004057). Il framework compressione-contro-predittività; da affiancare a Saxe et al., On the Information Bottleneck Theory of Deep Learning (ICLR 2018) per vedere il dibattito da entrambi i lati.
Grünwald, P. D. (2007). The Minimum Description Length Principle, MIT Press. La trattazione monografica moderna di MDL, dal two-part code alla forma raffinata con l’informazione di Fisher; il riferimento per la connessione MDL-Fisher-curvatura.
MacKay, D. J. C. (2003). Information Theory, Inference, and Learning Algorithms, Cambridge University Press (gratuito online). Il testo che intreccia teoria dell’informazione e apprendimento con esempi visivi: massima entropia, inferenza, codifica e modelli sotto un’unica copertina.
Shannon, C. E. (1951). Prediction and Entropy of Printed English, Bell System Technical Journal, 30, 50-64. L’esperimento del guessing game che lega, già nel 1951, la capacità di predire la lettera successiva alla comprimibilità della lingua. La radice intuitiva di tutto il capitolo.