App Unti

UNIVERSITA’ DEGLI STUDI DI TORINO
RETI NEURALI
a.a. 2020-2021
Capitolo 1
Introduzione alle reti neurali
1.1 Introduzione alle reti neurali

Il setting della computazione neurale è il seguente: data una serie di input, questi vengono
processati da una rete di neuroni che restituisce un output. Ci sono diverse motivazioni
dietro l’interesse verso questo processo:
• interesse di natura biologica: cercare di capire come funzionano i veri cervelli ani-
mali attraverso modelli di computazione neurale (legato alle neuroscienze, per
capire di più la biologia di questo sistema),
• costruzione di algoritmi di machine learning ispirati alla biologia del cervello (dalla
quale si possono discostare) e usati per risolvere problemi di diversa natura.
I modelli che studieremo sono reti di neuroni intese come unità computazionali legate
una all’altra in modo gerarchico (l’informazione è processata a strati). L’obiettivo è di
costruire modelli che riescono a processare un’informazione anche quando l’input è del
tutto nuovo (ad esempio rete neurale che processa immagini dopo che è stata addestrata
a risolvere task). Le reti neurali artificiali sono state richiamate come il deep learning
(imparare le caratteristiche implicite del dataset usando reti neurali), reti neurali che
hanno più livelli di neuroni. negli ultimi anni ci sono stati molti sviluppi dal punto
di vista sia applicativo che concettuale, anche se le basi c’erano da molto tempo. Le
reti neurali che studieremo sono un particolare tipo di algoritmi di machine learning
(abilità di imparare senza essere programmato appositamente), il quale a sua volta è
compreso nell’intelligenza artificiale (tecniche che permettono ai computer di imitare il
comportamento umano).
Machine learning
Il machine learning è un campo di studio che cerca di dare ai computer le abilità di
imparare dai dati senza essere esplicitamente programmati: sulla base di tanti esempi
(dataset possibilmente grandi), la macchina è in grado di estrarre informazioni senza il
bisogno di scrivere esplicitamente le regole per passare dall’input all’output. Operativa-
mente, il machine learning è definito da una certa misura di performance dell’algoritmo,
da un task e dall’esperienza. L’esempio classico è quello della classificazione delle mail,
ovvero dell’identificazione di mail di spam. Il task è di classificare le mail tra spam e
non spam; l’esperienza, ovvero il modo in cui si può allenare l’algoritmo, è data da una
classificazione manuale di mail. Si può quindi misurare la sua performance andando
ad analizzare la percentuale di mail che ha classificato in modo corretto. La differenza
sostanziale con la programmazione tradizionale è che il computer, dato un dataset e un
certo output che voglio, scriva le regole per assolvere questo task. Ad esempio, è difficile
scrivere un codice con regole dure sulle features che faccia la classificazione delle mail
sulla base di queste, ma da utente si riesce facilmente a dare una label ad ogni mail
2
1.1. INTRODUZIONE ALLE RETI NEURALI 3
anche se lo spazio dei dati è molto complicato: tocca quindi al computer capire quali
sono le features che gli servono per fare la classificazione vedendo come abbiamo dato
noi le label.
Il computer quindi è allenato attraverso tanti esempi e non tramite una definizione speci-
fica e rigorosa (esempio: riconoscimento dei volti un’immagine): abbiamo a disposizione
in questo periodo storico numerosi dataset, molti già labellati. Questi algoritmi non sono
applicati solo alle immagini: ad esempio, sono usati anche per il riconoscimento di parole
o nella sanità (informazioni delle cartelle cliniche digitalizzate per analizzare ad esempio
i raggi X o immagini di lesioni della pelle).
Esempi tipici di task per cui il machine learning può essere molto utile sono:
• riconoscimento pattern: volti o espressioni facciali, lettere o parole, immagini me-
diche,
• generazione pattern: generare immagini o sequenze una volta inferite statistiche
sui dati,
• riconoscimento anomalie: transazioni sospette, rilevamenti inusuali in un impianto
nucleare.
Sebbene per noi il riconoscimento delle immagini risulti essere una task semplice, è molto
complesso per il computer in quanto deve tenere conto della segmentazione (ci sono più
oggetti nella stessa immagine), della deformazione (gli oggetti di una stessa categoria
possono essere deformati anche in modi non affini) e della funzione (gli oggetti sono spesso
definiti in base al loro utilizzo). Inoltre, la posizione dell’oggetto non deve influenzare
la classe e le feature devono quindi esser invarianti rispetto a trasformazioni. Il machine
learning viene solitamente diviso in tre categorie:
• supervised learning: ho esempi di input in cui so qual è l’output giusto (labelled)(la
maggior parte delle applicazioni si basa su questo tipo di ML): si divide in fare
classificazione (separare le osservazioni in diverse variabili categoriche a partire
da caratteristiche definite) e regressione (il valore di output non è una variabile
categorica, ma uno scalare: attraverso un set di (xi , yi ), si cerca di capire la funzione
che associa a ciascun valore di x un valore di y),
• unsupervised learning: ho tanti dati senza label e l’obiettivo è cercare strutture nei
dati (clutersing, riduzione della dimensionalità senza perdere troppe informazioni,
estrazione di variabili nascoste che determinano alcune caratteristiche),
• reinforcement learning: ho un agente e un modello dell’ambiente in cui si può muo-
vere con delle strategie e in base ai rewards che ottiene adottando queste strategie
cambierà le sue scelte.
Specificità delle reti neurali

Nel machine learning è importante che ci sia qualcuno con una esperienza nel campo
che identifichi le feature utili per la classificazione. Nelle reti neurali profonde si cerca
di eliminare questa parte di ingegnerizzazione a mano: si cerca di avere un sistema che
estrae automaticamente le feature dalle informazioni grezze. Questo rende il sistema più
flessibile (non ho bisogno di esperienza nel campo) e più robusto (meno arbitrarietà nella
selezione delle feature), inoltre l’estrazione e la trasformazione delle feature permette di
avere una rappresentazione dei dati il più utile possibile per il task che abbiamo come
obiettivo. Le reti neurali sono una sottoclasse di rappresentation learning, ovvero modi
di estrarre le feature in un modo intelligente e gerarchico (si parte da feature semplici
che vengono combinate): questo tipo di computazione è particolarmente efficiente per
una serie di applicazioni. Tuttavia non c’è sempre bisogno di reti neurali o reti neurali
complesse: molto spesso basteranno algoritmi di machine learning più semplici. Diventa
però utile quando il dataset è complesso (ad esempio le immagini) e ha bisogno di una
rappresentazione gerarchica. Presi due diversi algoritmi di learning e una misura di
4 CAPITOLO 1. INTRODUZIONE ALLE RETI NEURALI
performance a scelta, quando si mediano le loro performance su tutti tipi di problemi, i

due algoritmi si equivalgono (No Free Lunch Theorem - Wolpert): gli algoritmi sono uno
superiore all’altro solo su specifici problemi, quindi un classificatore molto semplice non
è certamente peggio di uno complicato.
Sono stati scelti dei dataset con i quali si possono testare i proprio algoritmi. I più classici
sono già all’interno della libreria KERAS di Python. L’esempio per eccellenza è MNIST
dove ci sono immagini di numeri scritti a mano.
Nello standard setting, il dataset è diviso in dati usati per trainare il modello e settare
i parametri (training set) e dati mai visti per testare le sue performance (test set). Il
training set viene ulteriormente diviso in due parti, una parte di training e una parte di
validation per vedere come sta performando e settare altri parametri.
Rassegna storica sulle reti neurali

Tante delle basi che ci sono oggi sono state sviluppate già molto tempo fa: i primi
modelli di neurone sono stati sviluppati negli anni ’40. Nel 1956 c’è stato un workshop a
Dartmouth sull’intelligenza artificiale si è stilato un programma di ricerca per costruirne
una per risolvere i task più diversi. Sull’onda di questo entusiasmo, le 1958 Rosenblatt ha
sviluppato i primi algoritmi per Perceptrone, un semplice modello di neurone un grado
di risolvere modelli lineari. Il campo è stato un po’ abbandonato in quanto le attese
erano state disilluse, ma è stato ripreso negli anni 80 per poi esplodere negli ultimi anni.
C’è anche molta copertura mediatica e molti personaggi sostengono che il deep learning
guiderà una nuova rivoluzione industriale e avrà un potere trasformativo sul mercato
del lavoro. Questa esplosione di interesse e applicazioni è avvenuta adesso, anche se
le tecniche erano state sviluppate in passato, perché ci sono grandi dati a disposizione
che permettono di avere modelli molto espressivi e con molti parametri: l’era digitale
permette di lasciare una traccia enorme di dati che sono facilmente conservati. In più
ci sono stati avanzamenti dal punto di vista dell’hardware e si sono sviluppate librerie
specifiche per costruire reti neurali che hanno reso la scrittura di codice più leggera.
1.2 Modello del neurone

Il modello del neurone è ispirato ai modelli biologici, ma si discosta da una descrizione
realistica. Possiamo rappresentare un neurone della corteccia nel seguente modo:
I dendriti raccolgono i segnali che arrivano al neurone, solitamente da altri assoni tramite
sinapsi. Se questi segnali sono sufficienti ad accendere il neurone, questo fa firing e il
cono di integrazione manda uno spike, ovvero un impulso, che viaggia attraverso l’assone.
Le sinapsi non sono uguali tra di loro e possono cambiare nel tempo: può avvenire
l’adaptation, in quanto la densità dei recettori può cambiare, quindi gli input sono pesati
in modo diverso rispetto alla sinapsi permettendo di fare task diverse. Una volta che il
1.2. MODELLO DEL NEURONE 5
neurone ha mandato lo spike, c’è un periodo refrattario: il neurone deve aspettare una
certa quantità di tempo prima di poter fare firing di nuovo, a prescindere dai segnali in
ingresso.
Ora vediamo un modello di neurone sviluppato negli anni 40, in particolare il modello
di percettrone sviluppato da McCulloch e Pitts nel 1943. Questo modello è molto
semplificato ed è stato ripreso successivamente. Il nostro obiettivo è catturare gli input
x1 , . . . , xD che arrivano al neurone. I diversi input vengono pesati in modo diverso perché
c’è eterogeneità tra le sinapsi: definiamo quindi diversi pesi w1 , . . . , wD . Il neurone quindi
fa una somma di questi segnali pesati e sulla base di questa somma se fare firing oppure
no: il suo output dovrà essere una funzione a scala, dove se la somma è maggiore di una
certa soglia T l’output cambia. Nel modello originale gli input erano variabili binarie
(0, 1), così come l’output. Questo modello cattura strutture biologiche in grado di fare
task, ma ha fortissime analogie con i circuiti che permetteva un’implementazione anche
a livello di hardware.
Nel dettaglio, l’input è un vettore D-dimensionale x, come anche i pesi. La somma quindi
diventa wT x e l’output ŷ è 1 se wT x ≥ T oppure 0. Fino alla somma il sistema è lineare,
poi viene introdotta una non linearità chiamata funzione di attivazione che cattura il
concetto di azione binaria.
L’input viene immesso all’interno di tanti neuroni che formano un brain: questi analizzato
l’input e lo trasformano in un set di feature utili per lo specifico task per cui la rete è
stata addestrata e l’output viene restituito attraverso una regressione sotto forma di un
vettore Rn . Si parla di regressione in quanto la neural net costruisce ŷ = fˆ(x, w, T ).
Se assumiamo che esista una funzione vera data dalla natura y = f (x) che associa ad
ogni immagine il giusto vettore spostamento (ground truth), la rete neurale cerca di
approssimare al meglio questa funzione trovando il setting di parametri ottimale. Nel
caso in cui l’output sia binario (è un oggetto o non lo è), il tutto diventa un problema di
classificazione: tipo di task definisce come sarà l’output della rete, ma dietro c’è sempre
un certo wiring di neuroni che estraggono feature a partire da un input. Nel caso in cui
si hanno a disposizione tanti esempi di associazione tramite la funzione giusta f , si parla
di supervised learning. Come tutte le rappresentazioni modellistiche, anche questa del
percettrone cattura bene alcune cose e altre no:
Catturato Non catturato

Azione binaria Timing
Influenza cumulativa sulla scelta Periodo refrattario
Pesi nelle sinapsi Graded response
Biforcazione dell’assone
Per capire la bontà dell’approssimazione è necessaria una misura dell’efficienza della rete.
Un primo approccio è vedere la norma della differenza, ||y − ŷ||, che presenta un punto
angoloso. Questo problema è risolto considerando il quadrato e la condizione ideale sa-
rebbe essere nel minimo: la misura diventa quindi J(w, T ) = ||y − ŷ||2 .
6 CAPITOLO 1. INTRODUZIONE ALLE RETI NEURALI
Data una funzione di questo tipo, il nostro obiettivo è trovare w e T che minimizzano la
funzione J: questo lo si può fare utilizzando il gradient descent sfruttando la direzione
in cui il gradiente diminuisce. Si calcola infatti ∇w J, il gradiente di J, e lo si usa per
calcolare il successore di w tale che Deltaw = −η∇w J, dove η è il learning rate.
Ci sono tuttavia alcuni problemi:
I. Dato il modello di neurone, se definiamo z = wT x − T , la funzione a scala ha il gradino
in corrispondenza dello zero e dipende da z. Se aumentiamo la dimensionalità del vetto-
re input e del vettore dei pesi aggiungendo il valore x0 = 1 con il peso w0 = −T (bias),
abbiamo che z = wT x e quindi la treshold è stata riassordiba. In questo modo quindi
ŷ = θ(z), cioè l’output diventa la theta di Heavyside di wT x.
II. L’algoritmo di learning si basa su Deltaw = −η∇w J: vogliamo cambiare i pesi ba-
sandoci sulle derivate della funzione costo J(w) ∝ ||y − ŷ||2 . Tuttavia ŷ è una funzione a
gradino e la sua derivata è una delta di Dirac, quindi sempre zero e diverge nel punto di
soglia: usare questa come regola di learning diventa quindi un problema. Ci sono algo-
ritmi per addrestrare funzioni di soglia a gradino, ma se le reti diventano più complesse
diventa più difficile e sarebbe più comodo usare le derivate. L’idea è quindi quella di
passare ad una funzione smooth in (0, 1), ovvero una sigmoide ŷ = σ(z) = 1−e1−z . Que-
sta funzione ha le proprietà giuste in quanto di comporta come la theta di Heavyside:
quando gli input pesati sono molto grandi la funzione tende ad 1, se invece sono molto
grandi e negativi tende a zero, quando la somma pesata è 0 sta nel mezzo. Questa funzio-
ne può anche essere interpretata come una versione probabilistica del firing del neurone:
in questo caso, dato l’input, il neurone restituisce la probabilità di fare firing, ovvero
P(y = 1|x, w). Questa interpretazione probabilistica (probabilità che il neurone faccia
firing) suggerisce di stare facendo una regressione logistica (la variabile dipendente è di
tipo dicotomico: probabilità che l’input appartenga ad una classe oppure ad un’altra).
Come mai la sigmoide è la funzione giusta per fare smoothing della theta di Heavyside.
Interpretazione probabilistica della sigmoide

Remark 1. Teorema di Bayes
P(B|A)P(A)
P(A|B) =
P(B)
Date due classi, C1 e C2 (nel caso del neurone fired o not fired), vogliamo definire la
probabilità di appartenere ad una delle due classi dato un certo input, ovvero P(Ck |x).
Applicando il teorema di Bayes otteniamo la sigmoide:
P(x|C1 )P(C1 )
P(C1 |x) = (dividendo per il numeratore)
P(x|C1 )P(C1 ) + P(x|C2 )P(C2 )

1 P(x|C1 )P(C1 )
= P(x|C2 )P(C2 )
ponendo z = ln
1 + P(x|C P(x|C2 )P(C2 )
1 )P(C1 )
1
=
1 + e−z
In questo caso z, ovvero la trasformazione dell’input, è il logaritmo di un rapporto di
probabilità: z = wT x viene quindi interpretato come log ratio di probabilità. Se infatti
z è grande, la probabilità di avere C1 è maggiore, analogamente se z è negativo.
z
La funzione σ(z) = 1+e1−z = eze+1 ha proprietà interessanti:
• 1 − σ(z) = σ(−z)
• σ 0 (z) = σ(z)σ(−z) (utile nel gradient descent)
Capitolo 2
Basi di Machine Learning
2.1 Stimatore di massima verosimiglianza - Distribu-

zioni gaussiane
Il principio di massima verosimiglianza è un principio che useremo spesso nella costru-
zione delle funzioni costo delle reti neurali. Supponiamo di essere nel caso della regres-
sione descritta nel capitolo precedente, una buona approssimazione della funzione costo
è J(w) ∝ ||y − ŷ||2 : cercheremo di capire da dove venga fuori, quali siano le assunzioni
dietro e quali siano i suoi limiti.
Distribuzione gaussiana
Data una variabile Gaussiana X ∼ N (x|µ, σ 2 ), la sua funzione di densità di probabilità
e i suoi momenti sono

1 1
p(x) = √ exp − 2 (x − µ)2 ,
2πσ 2 2σ
Z
E[X] = xp(x)dx = µ, E[X 2 ] = µ2 + σ 2 .
Una statistica sufficiente è data da (µ, σ 2 ): questa coppia di numeri caratterizza del
tutto le caratteristiche di un dataset estratto da una gaussiana. Questo suggerisce una
correlazione tra fare inferenza sui parametri e comprimere i dati. La gaussiana è molto
importante per il teorema centrale del limite e il principio di massima entropia.
Covarianza
La covarianza è un valore numerico che fornisce una misura di quanto le due varino
assieme, ovvero della loro dipendenza. Date X, Y variabili aleatorie, la covarianza è:
cov[X, Y ] = E[(X − E[X]))(Y − E[Y ]))] = E[XY ] − E[X]E[Y ].
Più questo valore è grande, più tendono a muoversi assieme, se invece tende a 0 vuol
dire che non sono dipendenti l’una dall’altra. Possiamo anche definire il coefficiente di
Pearson, che è la covarianza normalizzata sulle deviazioni standard:
cov[X, Y ]
ρXY = .
σX σY
Dato X un vettore d-dimensionale, possiamo definire la sua covarianza: questo oggetto
diventa una matrice di covarianza che è denotata con Σ, dove sulla diagonale ci sono
le varianze delle singole componenti, che è simmetrica (diagonale se le variabili sono
indipendenti).
7
8 CAPITOLO 2. BASI DI MACHINE LEARNING
Gaussiana multivariata
Le gaussiane esistono anche in più dimensioni. I parametri sono un vettore di valori medi
e da una matrice di covarianza.

1 1 T −1
p(x) = d 1 exp − (x − µ) Σ (x − µ) .
(2π) 2 |Σ| 2 2
I parametri sono dati dai d elementi del vettore µ e dai d(d−1)

2 elementi della matrice Σ:
il numero di parametri cresce in modo quadratico rispetto alla dimensionalità.
Sampling dalle distribuzioni

Fare sampling è importante in quanto capita spesso che si faccia inferenza per estrarre la
sufficient statistic dei dati. Una volta che abbiamo questo oggetto, in linea di principio è
possibile anche generare dati che abbiamo la stessa distribuzione: questo è importante per
costruire modelli generativi. Una volta aver inferito la pdf, definiamo la cumulativa. In
questo modo, estraendo col computer in modo uniforme valori tra 0 e 1, possiamo creare
un sample dalla stessa distribuzione usando la cumulativa per proiettare all’indietro: la
pendenza della cdf determina la quantità di punti in una zona. Questo metodo si chiama
inverse transform sampling.
Massima verosomiglianza per le distribuzioni gaussiane

Dato un dataset x = x(1) , . . . , x(m) con size m, dove i dati sono per ipotesi i.i.d. e
distribuiti come una gaussiana, abbiamo che la probabilità congiunta di ottenere x con
certi parametri è
m
Y
p(x|µ, σ 2 ) = N (x(i) |µ, σ 2 ).
i=1
L’idea quindi è quella di voler trovare i parametri (µ, σ 2 ) che massimizzano questa pro-
babilità. Usando il logaritmo (funzione monotona) per usare la log-likelihood function,
troviamo che essa è massimizzata dagli stimatori di massima verosimiglianza
1 X (i) 2 1 X (i)
µM L = (x ), σM L = (x − µM L )2 .
m m
Una valutazione della bontà di uno stimatore θ̂n è data dal bias
b(θ̂n ) = E[θ̂n ] − θ.
In questo caso abbiamo che
2 m−1 2
E[µM L ] = µ, E[σM L] = σ .
m
Per avere uno stimatore unbiased della varianza possiamo usare
2 1 X (i)
σ̂M L = (x − µM L )2 .
m−1
2.2. STIMATORE DI MASSIMA VEROSIMIGLIANZA - REGRESSIONE 9
2.2 Stimatore di massima verosimiglianza - Regres-

sione
Come possiamo applicare gli stimatori di massima verosimiglianza nel contesto della
regressione? Supponiamo di avere una rete neurale che come output dà uno scalare a
partire da un vettore di feature. Il dataset è formato da m osservazioni x(i) , y (i) ,
dove la label y (i) ∈ R ∀i. La rete produce dei guess ŷ (i) = fˆ(x(i) , w) a partire da una
configurazione di pesi e un input. La likelihood, come abbiamo visto, è la probabilità
di ottenere i dati osservati a partire dai parametri: fare maximum likelihood è trovare il
set di pesi wM L della rete che massimizzano questa probabilità P(dati|parametri). Le
assunzioni sul setting sono:
• i dati siano i.i.d.: questo permette di semplificare vedendo la likelihood come pro-
dotto di probabilità (spesso si passa a minimizzare − log P(D|w) da minimizzare):
n
Y
P(D|w) = P(y (i) |x(i) , w)
i=1
• y (i) è una funzione deterministica di x(i) quale è sommato un noise gaussiano.

Questo permette di scrivere (centrare la gaussiana nel guess dell’algoritmo)
P(y (i) |x(i) , w) = N (y (i) |µ = ŷ (i) (w), σ 2 ).
Con quest’ultimo punto abbiamo in particolare che, ponendo la precisione β = σ −2 :

m
Y 1 1 (i) (i) 2
− log P(D|w) = − log √ exp − 2 (y − ŷ )
i=1 2πσ 2 2σ
m
X β 1 1
=− − (y (i) − ŷ (i) )2 + log(2π)− 2 + log β − 2
i=1
2
m
β X (i) m m
= (y − ŷ (i) )2 + log 2π + log β.
2 i=1 2 2
Conseguentemente, vogliamo minimizzare la seguente funzione costo, che può anche

essere vista come energia
m
1 X (i)
J(w) = E(w) = (y − ŷ (i) )2 .
2m i=1
Quindi voler minimizzare l’errore quadratico corrisponde ad assumere di volere mas-

1
simizzare la likelihood. Inoltre, la scelta della costante m permette di considerare
J come l’energia/errore medio a partire dai dati di training.
• notiamo inoltre che
m
Y 1 β (i) (i) 2
P(D|w) = exp − (y − ŷ )
i=1
c 2
( )
1 β X (i) (i) 2
= exp − (y − ŷ )
z 2 i
1
= exp {−βE(w)}.
z
Dunque la probabilità di osservare i miei dati dati i parametri può essere scritta
come l’esponenziale negativo di una energia, che corrisponde a come scriviamo la
probabilità dei microstati in meccanica statistica (Janes).
• è possibile anche trovare il parametro β, ovvero la precision, che massimizza la

likelihood: " m #
δ β X (i) (i) 2 m m
(y − ŷ ) + log 2π + log β = 0,
δβ 2 i=1 2 2
m
1 2 1 X (i)
= σM L = (y − ŷ (i) )2 .
βM L m i=1
Con il principio di massima verosimiglianza quindi, prima otteniamo una stima dei
parametri wM L e poi della precision βM L .
• una volta stimati i parametri w, β, è possibile dato un nuovo vettore x∗ predire

il valore della ŷ(x∗) tramite il modello di massima verosimiglianza. Questo è un
modello probabilistico che predice la risposta e β misura la barra di errore costante,
anche se è lontano dai dati con cui ha fittato i parametri. Il problema è che questo
modello è over-confident sulle sue predizioni (il modello bayesiano invece tiene conto
se siamo lontani dai dati del training set).
• la massima verosimiglianza ha anche delle proprietà interessanti che permettono di

costruire la funzione costo facilmente e inoltre se la vera distribuzione dei dati P(D)
è nella famiglia di funzioni che il modello sta cercando, allora per m che tende a
∞ lo stimatore wM L converge al vero valore w da cui i dati sono estratti. Se i dati
non sono abbastanza, si rischia di ricadere nell’overfitting.
2.3 Regressione lineare

2.3.1 Neurone lineare
Possiamo vedere la linear regression come un esempio di neurone lineare. Come model-
lo di neurone prenderemo il percettrone con input il vettore D-dimensionale x, dove la
prima componente x0 è 1, e i pesi. In questo caso, il neurone prende il vettore delle
features D-dimensionale e restituisce come output un valore scalare ŷ (i) = wT x(i) = z (i)
attraverso
una regressione lineare. Il dataset di training è quindi formato da m osserva-
zioni x(i) , y (i) . Con la massima verosimiglianza, vogliamo massimizzare la probabilità
di osservare i dati con certi parametri: questo problema è esattamente equivalente a
minimizzare la funzione loss J(w), scritta come errore tipico:
m m
1 X (i) 1 X t (i)
J(w) = (y − ŷ (i) )2 ) = (w x − y (i) )2 .
2m i=1 2m i=1
Possiamo scrivere il tutto in maniera più compatta attraverso la design matrix, dove
le righe sono formate da 1 seguito dalle D feature:
  
(1) (1) (1)
−x(1)t −

1 x1 x2 · · · xD
 . .. .. .. ..  ..
X=  .. . = .
  
. . . .
(m) (m) (m)
1 x1 x2 ··· xD −x(m)t −
Segue che la loss function è la norma L2 :

1
J(w) = ||Xw − y||22 .
2m
Il fatto di usare vettori e matrici ha un’importanza dal punto di vista computazionale
perché le librerie sono spesso ottimizzate per il calcolo matriciale. Questo aspetto si
chiama vettorizzazione.
2.3. REGRESSIONE LINEARE 11
Osservazione 1. Stiamo assumendo che y (i) = f (x(i) ) + = f (x(i) , wT RU E ) + , dove

è del noise gaussiano e wT RU E sono i parametri veri, quelli che vorremmo approssimare
il meglio possibile. Nel caso della regressione lineare, l’ipotesi è che f (x(i) , wT RU E ) =
x(i)t wT RU E , cioè che i dati siano lineari.
Osservazione 2. Si chiama regressione lineare perché è lineare nei parametri w: se con-
2 3
sideriamo x(i) ∈ R e ŷ (i) = w0 + w1 x(i) + w2 x(i) + w3 x(i) , anche se è un polinomio di
terzo grado è ancora una regressione lineare perché la linearità sta nelle componenti di
w che sono lineari.
La funzione costo è quindi della forma

1 1
J(w) = ||Xw − y||22 = (Xw − y)t (Xw − y)
2m 2m
δJ
Ora vogliamo trovare il vettore w che massimizzi lo scalare J, quindi poniamo δw = 0:
δJ(w)
=
δw
1
δw wt X t Xw − wt X t y − y t Xw + y t Y =

2m
1
δw wt X t Xw − 2y t Xw + y t Y =

2m
1 t
2X Xw − 2y t X = 0.

2m
Da cui otteniamo l’equazione normale (soluzione analitica che dipende solo dai dati e dai
valori del training set):
wM L = (X t X)−1 Y t X = (X t X)−1 X t Y,
dove
..
 
(1) (m)  (1)

 x1 . x1  −x −
X X =  ...
t .. .. ..
  
 . . 
 . 
(1) .. (m)
(m)
−x −
xD . xD
(i) 2 (i) (i)
" Pn P #
i=1 (xi ) i x1 x2 ···
= .. .
.
Questo prodotto assomiglia alla matrice di covarianza. Spesso si fa feature scaling,

dove per ogni feature xj il valore usato è poi
xj − < xj >
σj
per poter avere le feature in un simile range di variabilità. In questo modo X t X diventa
proporzionale alla matrice di covarianza. Quando calcoliamo wM L , X t X deve essere
invertibile: in generale questo succede quando ci sono delle feature ridondanti, ovvero
quando rank(X) ≤ D + 1. Quindi, generalmente, se il numero dei dati m è maggiore del
numero delle feature, generalmente esiste l’inversa. Inoltre, una matrice di covarianza è
positiva semidefinita se gli autovalori λi ≥ 0 ∀i. Tuttavia, può succedere che invertire la
matrice X t X possa essere più costoso che usare algoritmi locali di ricerca (e.g. gradient
descent).
Ricapitolando, data una rete neurale, lo scopo è estrarre uno scalare ŷ: i neuroni cercano
di estrarre una nuova rappresentazione, quindi nuove feature utili per il task ovvero la
regressione lineare.
Output multipli e modello lineare generalizzato
La regressione lineare può essere estesa per ottenere come output un vettore d-dimensionale
a partire dai vettori di input D-dimensionali. Applicandolo alle reti neurali, otteniamo
che i parametri costituiscono una matrice di pesi W dove l’elemento wij è il peso tra xi e
ŷj . Anche in questo caso, le funzioni di applicazione sono lineari e abbiamo che ŷi = wit x:
infatti possiamo vedere Ŷ = W X, dove X è la design matrix trasposta (i vettori input
riga diventano colonna trasponendoli).
−w1t −
 
(1)
ŷ · · · ŷ (m) ..  x(1) · · · x(m)
=

| | . 
| |
−wdt −
Possiamo far regressione lineare per rappresentare funzioni che non sono lineari tra
input e output (generalizzazione dell’esempio del polinomio). In questo caso possiamo
utilizzare una funzione di x invece che x stesso: resta una funzione lineare perché la linea-
rità resta nei pesi, ma rispetto all’input rappresentiamo funzioni non lineari. Abbiamo
quindi il linear basis function model
X
Ŷ (x, X) = wj φj (x) = wt φ(x),
j
dove φ0 (x) = 1, w0 = bias, φj bias function (ad esempio φj (x) = xj ). La differenza

concettuale nell’usare questo modello è che le bias function sono scelte da noi quindi
aumenta la flessibilità del modello.
2.4 Inferenza bayesiana e regolarizzazione

Abbiamo visto che wM L = argmaxw P(D|w), tuttavia questo modo di scrivere le cose è
strano in quanto stiamo massimizzando una probabilità come se i dati fossero una varia-
bile stocastica e i parametri sono fissati. Intuitivamente, dati i dati, so vorrebbe capire la
distribuzione di probabilità nello spazio dei parametri per cercare dove picca per capire
quali parametri scegliere e con che confidenza, ovvero stimare P(w|D). Questo ricade nei
metodi bayesiani, introduciamo quindi i concetti di statistica bayesiana.
Nella statistica bayesiana, la probabilità è interpretata come quantificazione di incertezza
(mentre nella statistica frequentista le probabilità sono scritte come frequenze di eventi
casuali ripetibili). Ci sono diversi motivi per cui usare la statistica bayesiana. Spesso è
difficile definire un evento casuale senza usare la parola probabilità e crea una circolarità
nelle definizioni. Inoltre, la statistica bayesiana permette di usare la probabilità anche
per eventi che non sono ripetibili.
Finora abbiamo usato la likelihood P(D|w) come metodo per stimare i parametri. Ora in-
troduciamo il concetto della prior P(w), la quale rappresenta il concetto di una qualsiasi
conoscenza sui valori dei parametri prima di guardare i parametri. In questo contesto,
il teorema di Bayes ci dice che la posterior P(w|D) (la distribuzione dei parametri sullo
2.4. INFERENZA BAYESIANA E REGOLARIZZAZIONE 13
spazio di probabilità dati i dati) è
P(D|w)P(w)
P(w|D) = ,
P(D)
dove il denominatore P(D) è una funzione di partizione, ovvero una normalizzazione

che rende la posterior una distribuzione di probabilità sui w (n.b. la likelihood non è
una distribuzione di probabilità sui w) ed è data da (integrazione su tutte le possibili
configurazioni del modello)
Z
P(D) = P(D|w)P(w)dw.
Analizziamo ora le differenze tra una stima basata sulla massima verosimiglianza e una
sull’inferenza bayesiana. In primo luogo, wM L è uno stimatore puntuale (si stima un set
di parametri che soddisfa la maximum likelihood), invece l’inferenza bayesiana ricostrui-
sce una distribuzione di probabilità quindi tutte le possibili configurazioni andranno a
contribuire alle predizioni. Ad esempio possiamo scrivere che (full bayesian: stima della
distribuzione in probabilità su tutti i parametri)
Z
P(x(m+1) |x(1) , . . . , x(m) ) = P(x(m+1) |w)P(w|x(1) , . . . , x(m) )dw
L’altra differenza fondamentale è la presenza della prior: generalmente in machine lear-

ning si scelgono delle prior generiche, ovvero funzioni ad alta entropia (come ad esempio
la gaussiana), oppure i pesi possono stare dentro un range con una probabilità uniforme.
Inoltre, la prior potrebbe spingere verso modelli semplici: dentro la prior posso dire che
mi aspetto che il modello finale sia il più semplice possibile. Supponiamo di avere tante
feature e il guess è che poche feature siano importanti. Una prior di questo tipo può
essere formalizzata dicendo che i wi siano distribuiti in modo gaussiano intorno a 0
r
Y λ 2
P(w|λ) = e−λwi Gaussian prior,
i
2
oppure che siano ancora di più spinti verso il valore 0

Y λ
P(w|λ) = e−λ|wi | Laplace prior.
i
2π
Abbiamo quindi che ciò che stiamo stimando P(w|D) ∝ P(D|w)P(w), man mano che il
dataset cresce, P(D|w) peserà sempre di più quindi i dati possono spostarmi molto dalla
prior: tuttavia, se non ho dati a sufficienza, il guess iniziale sui parametri è importante.
Questo approccio fornisce in automatico una error bar, ovvero una stima di incertezza. Se
stiamo utilizzando l’approccio frequentista e vogliamo comunque avere una stima dell’in-
certezza possiamo usare il bootstrap (metodo euristico per stimare quanto mi aspetto
che varino le stime dei parametri). Dato un dataset X = {X1 , · · · , XN }, creaimo dei da-
taset XB facendo sampling with replacement da X: questi altri dataset X̃1 , · · · , X˜N

sono pescati da X, quindi alcuni dati saranno ripetuti, e si stima w. Tutto questo è
ripetuto L volte: si avranno quindi L stime di w che permettono di vedere quanto sarà
variabile la stima di w sui dataset.
MAP: maximum a posterior estimation

Data una full bayesian P(w|D), noi siamo interessati ad avere una singola stima dei w.
Ci sono più scelte possibili:
R
• < w >= wP(w|D)dw (la media)
• ŵ = argmaxw P(w|D) (MAP).
MAP quindi è simile a maximum likelihood, ma allo stesso tempo è diverso perché c’è
anche l’informazione sulla prior. Mettere una prior sui w, ad esempio spingere affinché
alcuni w siano 0, vuol dire cercare di ridurre il numero di feature importanti nella predi-
zione. Prendendo ad esempio il caso ŷ = w0 + w1 x + w2 x2 + w3 x3 + · · · , dove abbiamo
pochi dati messi a parabola, siamo interessati a spingere verso zero i coefficienti di grado
maggiore di due, altrimenti di rischia overfitting. In questo quindi sta la differenza tra
ottimizzazione e machine learning: se vogliamo ridurre la distanza tra la predizione e i
dati reali ha senso aumentare il grado, ma se vogliamo utilizzare il modello su dati mai
visti dobbiamo settare la complessità il più bassa possibile (penalizzando maggiormente
i polinomi di grado alto).
Possiamo considerare ad esempio la regressione lineare bayesiana (MAP). Data la
full bayesian P(w|D) ∝ P(D|w)P(w), noi ci accontentiamo invece di ricostruirla di trovare
il set di parametri che la massimizza:
wM AP = argmaxw P(w|D)
= argmaxw log P(D|w) + log P(w)
= argminw − log P(D|w) − log P(w),
dove otteniamo lo stesso termine da minimizzare che ottenevamo nella maximum likeli-
hood al quale però aggiungiamo la prior (che non dipende dai dati, quindi diventa sempre
meno dominante all’aumentare dei dati). Per poter andare avanti, dobbiamo scegliere la
prior (dove α è la precision e z costante di normalizzazione):
Y 1
Y
1 − α wj2
p(w) = N wj |0, = e 2 ,
j
α j
z
la nostra assunzione è quindi quella di avere small weights. Quindi ora, dato D il numero
di feature da 1 (non includiamo il bias nella prior),
D
αX 2
− log P(w) = w + cost prior
2 j=1 j
m
β X (i)
− log P(w) = (y − ŷ (i) ) likelihood.
2 i=1
Il risultato è quindi
 
m D
β X α X
wM AD = argminw  (y (i) − ŷ (i) ) + w2 
2 i=1 2 j=1 j
= argminJ (w) minimizziamo la loss function

2
α σM
dove, definito λ = β = 2
L
σprior
(iper parametro: è un parametro che l’algoritmo di lear-
ning non cambia e setta l’importanza della prior rispetto all’importanza della prior: più
riduco la varianza della prior gaussiana e quindi spingo i parametri allo zero, più questo
parametro cresce e quindi la parte del regolarizzatore ha più importanza), alla funzione
costo aggiungiamo un regolarizzatore (l’abbiamo ricavato come conseguenza di una prior
gaussiana: ci aspettiamo che in assenza di dati che spingono in direzione diversa, i pesi
siano il pù piccoli possibili)
1
||ŷ − y||22 + λ||w||22 .

J(w) =
2m
Spesso i regolarizzatori sono spesso introdotti per cercare di aggiungere parti nella co-
st function per evitare l’overfitting, spingendo verso la semplicità per evitare polinomi
2.4. INFERENZA BAYESIANA E REGOLARIZZAZIONE 15
gi grado alto. Conuesto regolarizzatore specifico, la regressione si chiama L2 o Ridge

regression. Viene anche chiamata weight decay in quanto
λ t
J(w) = JM L (w) + ww
2m
e se supponiamo di fare gradient descent
∆w = −η∇w J(w)
λ
∇w J = ∇w JM L + w(priorlaplaciana)
m
λ
wnew = wold − η( wold + ∇w JM L )
m
λ
= wold (1 − η ) − η∇w JM L
m
e quindi ad ogni step i pesi si riducono.
Se usiamo la regressione lineare, si ha che ŷ = Xw con X design matrix, quindi
1
((Xw)t − y t )(Xw − y) + λwt w

J(w) =
2m
1 t
2X Xw − 2y t X + 2λw = 0

δw J(w) =
2m
→ (X t X − λ1)w = y t X → wM AP = (X t X − λ1)− 1X t y
Anche in questo caso abbiamo una soluzione analitica, dove però c’è un termine in più
dovuto alla regolarizzazione che rimuove tutti i problemi di invertibilità. La regolariz-
zazione diventa quindi un modo per ovviare al problema di feature ridondanti perché
spinge ad avere un basso grado di complessità. Inoltre, se X è ortogonale, otteniamo i
Xty w0
pesi che otterremmo con maximum likelihood riscalati w = λ+1 = λ+1 .
Se J è convessa (derivata seconda positiva oppure Hessiana semidefinita positiva cioè con
autovalori positivi) nella regressione lineare, wM L (e anche wM AX ) è un minimo globale.
Nel caso della regressione lineare, la convessità di J è assicurata da (proprietà persa nelle
reti neurali)
δ2 δ t
X Xw − y t X = X t X.

J=
δw2 δw
Ora introduciamo la regolarizzazione L1 oppure LASSO (Least Absolute Shrinkage and
Selection Operator) o Sparse Regularization. La regolarizzazione L2 implica λwt w
(dal prior gaussiano). Possiamo anche prendere la prior laplaciana (molto più piccata in
0, quindi spinge i pesi a zero e permette di selezionare le feature):
Y α
p(w) = e−α|wj | .
i
2
X
− log P(w) = α|wj | + · · · ,
i
wM AP = argminw log P(D|w) − log P(w),

la funzione energia diventa quindi
1
J(w) = (||ŷ − y||22 + λ||wj ||1 )
2m
Interpretiamo ora le regolarizzazioni L1 e L2 in modo geometrico. Il fatto di mettere
dei regolarizzatori lo possiamo vedere come un problema di ottimazzione (minimizzare
l’energia che deriva da makimum likelihood), ma con dei vincoli che corrispondono alla
prior. Abbiamo che J ∝ ||ŷ − y||2 + λ||w||2 . In questo caso quindi possiamo vincolare w
a stare in una sfera definita la λ attraverso t:
wRIDGE = argmin||ŷ(w, x) − y||22 , w/|w||22 ≤ t.
Possiamo definire la stessa cosa in L1 , dove si sta sotto t col modulo dei pesi:
wLASSO = argmin||ŷ − y||22 , w/|w||1 ≤ t.
Supponendo di avere soltanto due pesi, w1 e w2 , e un minimo di J in un punto del piano,

consideriamo le curve di livello e prendiamo il primo punto che interseca il vincolo.
Notiamo che la forma del vicolo L1 (politopo) fa si che la probabilità che il punto di
intersezione sia proprio uno spigolo (e quindi alcuni dei parametri sono nulli!) sia più
alta. Quindi L1 spinge verso la sparsity (alcuni pesi vicini a 0), mentre L2 verso small
weights. Quindi mettere delle prior coincide con cambiare la funzione costo e a seconda
delle prior (modelli con i quali spingo verso qualcosa) abbiamo regolarizzatori diversi e
quindi soluzioni diverse.
2.5 Decomposizione bias-variance

L’obiettivo dell’algoritmo è quello di generalizzare: dopo aver diviso un dataset in training
set e test set, il training è usato per fare ottimizzazione (o fit, cioè si settano i parametri
del modello in modo da spiegare al meglio i dati usati) e poi si generalizza con il test
set (si cerca di capire quanto si è stati bravi a predire i dati). Siamo quindi interessati
a misurare il test error (errore di generalizzazione), ovvero l’errore fatto sui dati di test
che non sono stati visti durante il training. Nello specifico, il test error è il valore atteso
su nuovi dati/input (in media, quanto mi aspetto che un algoritmo trainato su un certo
dataset si sbagli a fare predizioni su dati nuovi).
Vediamo un esempio. Sostanzialmente, stiamo assumendo che esista una distribuzione
sottostante vera da cui i dati vengono estratti i valori di x e y (p(x, y) o P(DATA)).
Supponiamo di avere un training set e un test set dove i parametri sono fissati senza
training. In questo caso, definita la misura dell’errore per la regressione |ŷ(x, w) − y|2 , il
valore atteso dell’errore è (va bene per entrambi i set perché i valori di w sono fissati)
Z
|ŷ(x, w) − y|2 p(x, y)dxdy,
tuttavia in machine learning i w arrivano dal training sul training set, quindi l’errore di
training sarà sempre minore di quello di generalizzazione perché ho ottimizzato il sistema
su training set. Quindi il machine learning è sostanzialmente definito da due problemi:
• I. rendere piccolo il training error (ottimizzazione) → se si fallisce si ha l’under
fitting,
• II. rendere la differenza tra il training e il test error piccolo → se si fallisce si ha
l’over fitting (segue il noise dei dati senza catturarne la struttura).
2.5. DECOMPOSIZIONE BIAS-VARIANCE 17
Introduciamo ora il concetto di capacity del modello, ovvero l’abilità del modello nel
fittare molte funzioni (questo è legato all’hypothesis space, ovvero lo spazio di tutte le
possibili associazioni (x,y) che sono in grado di fittare col modello). Ad esempio, con la
linear regression
Pk possiamo fittare tutte le funzioni lineari, mentre se prendiamo il modello
ŷ = b + i=1 wi xi possiamo fittare funzioni con polinomi di grado k-esimo (k setta la
capacità del modello). Tuttavia, bisogna tenere conto di una capacità effettiva: anche se
un modello in linea di principio potrebbe fittare un certo set di funzioni, non è detto che
l’algoritmo di learning sia in grado di esplorare tutto l’hypothesis space.
Una buona generalizzazione coincide dunque con il cercare una spiegazione semplice
dei dati che abbiamo (ridurre la complessità senza allontanarci troppo dai dati): ci
aspettiamo quindi di vedere il seguente plot dell’errore in funzione della capacità, dove
il generalizazion gap è dato dalla distanza tra il test error e il traning error.
Supponendo di avere un modello ideale, ovvero un modello che conosce P(DATA).

Anche questo modello ideale, che è irrealizzabile (abbiamo un sample finito), farebbe
comunque un errore nella generalizzazione, il Bayes error. Infatti se calcoliamo l’errore
di generalizzazione su uno specifico dataset D, l’associazione (x, y) è spesso stocastica
(c’è una distribuzione di possibili valori di y) e quindi il meglio che può fare il modello è
di predire l’y medio.
Cross-validation
Di solito, il dataset è diviso in training set e in test set, il quale ha tipicamente dimensioni
minori. Tuttavia, potrebbe capitare di avere pochi dati, il che porta a dei problemi.
Innanzitutto, sarebbe auspicabile usare tutti i dati per fare training, inoltre la misura
di performance è misurata su pochi dati del test set causando una misura sbagliata
della reale performance. Per risolvere questo problema, possiamo usare la K-fold cross
validation. Dividiamo il dataset in K parti che non overlappano. Durante il primo run,
prendiamo una parte per fare il test e tutto il resto per fare training. Ad ogni run,
seleziono un test set diverso e traino sul resto, ripetendo questa operazione per K volte
(tanti quanti i partizionamenti). Alla fine, facendo una media delle performance si ha un
valore molto più attendibile di quanto il modello sarà in grado di generalizzare, anche
se i test set sono piccoli (le fluttuazioni sono mitigate dalla media). Se K è uguale al
numero dei dati m, questa procedura prendi il nome di leave-one-out (piccoli dataset).
Decomposizione bias-variance

Supponiamo di avere un dataset D = (x(i) , y (i) ) , con y (i) ∈ R (caso di regressione),
dove assumiamo che i dati derivino dalla distribuzione p(x, y), dove (x(i) , y (i) ) sono i.i.d..
abbiamo che Y è una variabile aleatoria, ovvero p(x, y) = P(y|x)P(x). L’algoritmo, data
una x, ci deve fornire
R una ŷ dove il goal è che assomigli il più possibile all’y medio
ȳ(x) = Ey|x [y] = yp(x, y)dy.
Ora, supponiamo di chiamare il nostro algoritmo A (neuronal net): preso il dataset D,
costruiamo hD = A(D), ovvero un mapping tra x e ŷ che costruisce il guess e che dipende
da D. In questo caso di regressione, il valore atteso del test error per questa funzione è
Z Z
2
Ex,y∼p (hD (x) − y(x))2 =

[hD (x) − y(x)] p(x, y)dxdy.
x y
Inoltre, anche hD è stocastica, in quanto è una funzione che dipende dal dataset D scelto:
quindi facendo learning su diversi D saranno prodotte diverse hD e possiamo cercare la
funzione attesa (che dipende da A e da p(x, y), non più dal dataset)
Z
h̄ = ED∼pm [A(D))] = hD p(D)dD.
D
Tenendo conto di tutto ciò, possiamo calcolare il vero valore atteso dell’errore di genera-
lizzazione di A:
Z Z Z
2
Ex,y∼p,D∼pm (hD (x) − y)2 =

[hD (x) − y(x)] p(x, y)p(D)dxdydD.
D x y
Ponendo per semplicità di notazione Ex,y∼p,D∼pm = E, abbiamo che
E (hD (x) − y)2 = E ((hD − h̄(x)) + (h̄(x) − y))2

= E (hD − h̄)2 + E (h̄ − y)2 + 2E[(hd − h̄)(h̄ − y)].

Tuttavia notiamo che

Ex,y∼p,D∼pm [(hd −h̄)(h̄−y)] = Ex,y∼p [ED∼pm [hd −h̄](h̄−y)] = Ex,y∼p (h̄ − h̄)(h̄ − y) = 0.
Quindi h i
¯ 2 + E (h̄(x) − y)2 ,
E (hD (x) − y)2 = E (hD (x) − h(x))
dove il primo termine indica la varianza di hD , mentre per il secondo termine possiamo
notare che
E (h̄(x) − y)2 = E (h̄ − ȳ + ȳ − y)2 = E[h̄ − ȳ]2 + E[ȳ − y]2 .

Otteniamo quindi che il valore atteso dell’errore di generalizzazione con la bias-variance

decomposition è
h i
¯ 2 +Ex [h̄(x)− ȳ(x)]2 +Ex,y [ȳ(x)−y(x)]2 ,
Ex,y,D [(hd − h̄)(h̄−y)] = Ex,D E (hD (x) − h(x))
dove i termini sono rispettivamente
• Variance: rappresenta la variabilità delle predizioni quando il training è fatto su

diversi dataset D (è legata al concetto di overfitting, perché rappresenta se un
modello si adatta troppo ad un certo dataset)
• Bias2 : rappresenta l’errore intrinseco del modello ideale (è legato all’under fitting)
• Noise: è una proprietà intrinseca dei dati.

2.5. DECOMPOSIZIONE BIAS-VARIANCE 19
Questa decomposizione permette di capire tutte le possibili fonti di errore nella gene-
ralizzazione (variabilità del training su dataset del modello, capacità del modello, noise
intrinseco dei dati), il che è molto utile per raggiungere un certo livello di performance.
Spesso di parla di trade-off tra varianza e bias in quanto spesso la varianza è legato ad
una alta complessità del modello, mentre il bias ad un’alta semplicità del modello.
Di seguito, possiamo vedere come il nostro modello individua il target e con quanta
variabilità lo centra in termini di variance e bias.
Regolarizzazione nella decomposizione bias-variance

Finora abbiamo già visto un esempio di regolarizzazione, dove la composizione costo
è composta dalla funzione costo ottenuta facendo maximum likelihood e dalla prior su
come dovrebbero essere fatti i w (in questo caso spinge ad avere w piccoli e quindi a
pesare poco le feature)
J(w) = J(w)M L + λ||w||22 .
In questo contesto la generalizzazione può essere vista come una qualsiasi modifica alla
funzione costo che serva a ridurre l’errore di generalizzazione (e non il training error che
spinge a minimizzare il più possibile il termine di ML). Il peso della regolarizzazione
dipende da lambda, quindi si cerca un λ ottimale: infatti il suo valore è direttamente
proporzionale al bias e al training error (cerchiamo di fittare al meglio i dati) e inversa-
mente proporzionale alla variance, mentre quadratico con il test error (trade off).
Il parametro λ diventa quindi molto utile per mitigare il peso della Come possiamo sce-
gliere il λ ottimale (iperparametro, ovvero non viene toccato dal processo di learning)?
Nel caso delle reti neurali, all’input x è associato l’output ŷ(x, w) dove w è trovato trami-
te gradient descent ∆w = −η∇w J. Per settare l’iperparametro, nel dataset consideriamo
anche un validation set all’interno del training set: in questo modo facciamo il training
con un valore fissato di λ, misuriamo l’errore sul validation set e cambiamo valore di λ
per cercarne uno migliore (a seconda della misura dell’errore di approssimazione). A quel
punto poi le performance sono misurate sul test set.
Ci sono tanti modi per esplorare lo spazio dei λ, ad esempio possiamo fare una telesco-
pic search, dove lo proviamo per ordini di grandezza e, dopo aver selezionato il migliore,
restringiamo l’ordine. Tuttavia, questa procedura è molto time consuming ed è molto
inefficiente.
Early stopping
Early stopping è un tipo di regolarizzazione molto usata nelle reti neurali. Supponiamo
di stare facendo training con gradient descent, ovvero wt+1 = wt − η∇J: man mano
che l’algoritmo procede abbiamo la seguente situazione. Anche in questo caso possiamo
notare la presenza di uno sweet spot nel numero di iterazioni t∗ prima che il validation
error inizi a salire quando la capacità aumenta e c’è over fitting (se la capacità del modello
è alta, si adatta al training set). Questo suggerisce quindi di tenere traccia del vettore
dei pesi w e dell’errore di validazione durante il training dopo dopo un certo valore
temporale. Quando il validation error inizia ad aumentare, si interrompono le iterazioni
e si va a cercare il valore per cui il validation error era il minore per utilizzare poi la
rispettiva configurazione dei pesi. Il vantaggio rispetto alla regolarizzazione L1 o L2 in
quanto per fissare il parametro bisognava ogni volta rifare il training per diversi valori di
λ tra cui si sceglieva poi il migliore. Inoltre, concettualmente, l’early stopping assomiglia
alla regolarizzazione L2 . Avevamo detto che risolvere il problema di regressione con il
regolarizzatore coincideva con il cercare la versione di w che minimizza J vincolata a
stare in delle sfere. Early stopping ci assomiglia molto in quanto stiamo facendo una
traiettoria, che viene però interrotta dopo un certo tempo dopo un certo tempo, ma non
per dei vincoli. In entrambi i casi si guarda però l’errore di generalizzazione.
Vediamo ora l’algoritmo di early stopping:
Algorithm 1 EARLY STOPPING

1: ∆t = n° of steps between evaluations
2: p= "patience" (n° max iterations after increasing of validation error)
3: w0 = initialization
4: w ← w0
5: i ← 0 iterations
6: j ← 0 n° of steps of increasing error
7: v ← huge number (validation error)
8: w ∗ ← w best choice
9: i∗ ← i time for stopping
10: while j < p do:
11: run gradient descent for ∆t steps
12: w ← wnew
13: i ← i + ∆t
14: v 0 ← validation set error
15: if v 0 < v do: (decreasing error)
16: j ← 0 (reset count)
17: w∗ ← w (new guess for w∗ )
18: i∗ ← i (new guess stopping time)
19: else
20: j ← j + 1 (increasing error)
Rivisitazione moderna della decomposizione bias-variance

Nei modelli di reti neurali profonde sono utilizzati molti parametri: inizialmente l’impiego
di molti parametri era visto come un vantaggio, ma questo va contro l’idea di voler
limitare la complessità per limitare l’errore di generalizzazione. Diventa quindi necessario
rivedere il concetto di generalizzazione: si è visto che trainando reti su dataset standard
si riesce ad arrivare a training error uguali 0 in quanto la grande capacità del modello
permette di interpolare i dati (con label casuali cioè senza struttura). Questi modelli
vivono nel regime in cui il numero dei parametri è maggiore del numero di dati e quindi
riescono ad immagazzinare le informazioni di ogni singolo dato: nonostante ciò, queste
reti neurali profonde sono comunque riuscite a generalizzare. Si è quindi definito il
double descent: si è capito che la vera figura che mette in relazione l’errore con la
model capacity è la seguente (cambia perché la capacità è aumentata). Quando si supera
2.6. CLASSIFICAZIONE: IL PERCETTRONE 21
l’interpolazione infatti, il numero di modelli nell’hypothesis space che descrivono in modo

accurato aumenta e si può scegliere quello più semplice che minimizza il test error.
2.6 Classificazione: il percettrone

Ora lasciamo da parte i problemi di regressione e affronteremo problemi di classificazione,
ovvero dove il goal è di prendere un input (vettore di feature) e assegnarlo a una o k
classi (in genere discrete e disgiunte). due esempi classici di classificazione binaria sono
spam/not spam e benign/malign (per i tumori). In generale le classi possono essere più
di due, ad esempio immagini di cane/gatti/macchine etc. Fare classificazione vuole dire
definire i decision boundaries, ovvero dato lo spazio degli input decidere delle superfici
che separano i dati con label diverse (partizionamento dello spazio degli input). Nella
classificazione lineare, dato uno spazio D−dimensionale, si definiscono iperpiani di di-
mensione
D − 1. Ci sono due metodi principali per fare classification: dato il dataset
D = (x(i) , y (i) ) , con y (i) binarie (oppure -1,1), possiamo:
• definire le discriminant function: ad un x(i) associamo un ŷ (i) ∈ 0,1,

• definire un modello probabilistico: ad un x(i) associamo un ŷ (i) che è la proba-
bilità P(y (i) = 1|x(i) , w).
Abbiamo già visto due esempi specifici di questa classe di modelli che coincidono con i
due modelli di neurone: il primo è il percettrone (ŷ = θ(wt w) oppure = sign(wt x) se
includiamo il bias) e la regressione logistica (ŷ = σ(wt x), preferito per la differenziabilità).
In particolare, focalizziamoci sul percettrone, primo esempio di rete neurale molto fa-
cile da implementare. Useremo la notazione equivalente della funzione soglia come la
funzione segno di wt x, dove quindi le label sono -1,1. Vogliamo trovare un decision
boundary ortogonale a w: gli iperpiani sono della forma H = {x/wt x + bias = 0} che
diventano includendo il bias nei pesi (aggiungo una dimensione, ma gli iperpiani passano
per l’origine) H = {x/wt x = 0}. L’ipotesi di base del percettrone è che esiste un iper-
piano che separa le label (il problema è linearmente separabile). Ovviamente questo caso
è molto raro: anche solo pensando in due dimensioni, basta un po’ di noise per rendere
falsa questa assunzione. Tuttavia, mantenendo costante il numero di dati, più si sale di
dimensione più è probabile che il problema sia linearmente separabile.
Vediamo ora lo pseudocodice del learning algorithm, il quale trova un iperpiano che sepa-
ra le label se questo esiste: Notiamo quindi che l’update è tale che se la label era positiva,
Algorithm 2 PERCETTRONE
1: w = 0 (initialization)
2: while TRUE do:
3: m = 0 (where m = n° points misclassified)
4: for (x, y) ∈ D
5: if ywt x ≤ 0 (error test, as ŷ has the same sign as y)
6: w ← w + yx (update)
7: m←m+1
8: if m = 0 then BREAK (no misclassified point)
ma era stata classificata come negativa, aggiungiamo, altrimenti sottraiamo. Nel caso in
cui la notazione usata sia y =0,1, l’update diventa w ← w +η(y − ŷ)x, dove η è il learning
rate che possiamo settare ad 1. Inoltre, se non esiste l’iperpiano, il ciclo non termina: è
necessario quindi mettere uno stop al numero di cicli che si può fare.
Una domanda che ci si può porre è: quanti update posso fare continuando a sbagliare?
Supponendo di avere un dato sbagliato (x, +1), il fatto di avere sbagliato vuol dire che
ŷ = wt x ≤ 0: facciamo quindi l’update (w + x)t x ≤ 0. Supponendo di sbagliare k volte,
cioè alla kesima volta abbiamo (w + kx)t x ≤ 0, deduciamo che un upper bound per k su
un singolo input è:
wt x
wt x + kxt x ≤ 0 −→ k ≤ − t .
xx
Ora siamo interessati a dimostrare che l’algoritmo di apprendimento del percettrone con-
verge nel caso di label linearmente separabili.
La prima assunzione è che esista un iperpiano che separa lo spazio degli input in due
zone: questo equivale all’esistenza di una certa configurazione del pesi w∗ tali che qual-
siasi dato (x, y) ∈ D sia classificato nel modo giusto, ovvero che yw ∗t x > 0 (assenza di
errore). Osserviamo che se esiste w∗, allora anche αw∗ è una soluzione con α costante (la
risoluzione del problema è indipendente dalla scala di w∗): questo permette di assumere
che la norma di w∗ sia 1 senza perdere di generalità. Possiamo analogamente riscalare
l’input in quanto il problema di classificazione non cambia: per riscalare usiamo il mas-
simo delle norme dei vettori di input x(i) , quindi tutti i dati di input sono tutti inclusi in
una ipersfera (centrata nell’origine perché abbiamo incluso il bias) di raggio uno divisa da
un iperpiano identificato da w∗. Ora vogliamo dimostrare che un qualsiasi update di w
con w + yx lo avvicina sempre di più a w∗ nell’ipersfera, ovvero che wt w∗ diventa sempre
più grande (non però perché la norma di w cresce, ma perché si allineano). Quando cè
un update, poiché yw∗t > 0 per definizione di w∗
wt w∗ −→ (w + yx)t w∗ = wt w ∗ +yw∗t > wt w ∗ .
Possiamo provare a quantificare questa quantità: al minimo sarà grande come il valore
dell’input più vicino al bordo, ovvero il margine γ = min(x,y)∈D |xt w ∗ | ≥ 0. Quindi
dopo l’update abbiamo che wnew w∗ ≥ wt w ∗ +γ, ovvero questa quantità cresce con gli
update.
Ora dobbiamo controllare che stia crescendo perché w si sta avvicinando pian piano a
w∗ e non perché sta crescento wt w. Per definizione di update abbiamo che
wt w → (w + yx)t (w + yx) = wt w + 2ywt x + yxt x,

2.6. CLASSIFICAZIONE: IL PERCETTRONE 23
dove 2ywt x ≤ 0 altrimenti non avrei fatto l’update e xt x ≤ 1 perché abbiamo riscalato i
t
dati all’inizio. Segue quindi che dopo l’update wnew w ≤ wt w + 1. Dopo M update:
wt w ≤ M,
√ √
M γ ≤ wt w∗ = ||w||||w ∗ || cos θ ≤ ||w||||w ∗ || = ||w|| = wt w ≤ M,
da cui concludiamo che M ≤ γ12 . Questo risultato mostra che il numero di update fatti è
limitato superiormente e dipende soltanto L’iperpiano che passa per l’origine con il mar-
gine più ampio sarà quello che meglio separa le label: se i dati sono molto ben separati,
è molto più facile trovare l’iperpiano e infatti il numero di iterazioni è minore.
L’unica pecca è questo sistema può funzionare solo con problemi linearmente separabili:
ad esempio lo XOR (A XOR B = A and !B OR !A and B) è un problema molto semplice
(4 quadranti dove i segni dei quadrati adiacenti sono opposti), ma non è linearmente
separabile. Inoltre, non è immediato generalizzare questa regola se abbiamo più neuroni
disposti in modo gerarchico.
Ora ci concentriamo sul concetto di capacity del percettrone. Abbiamo già affrontato il
tema di capacità con l’argomento della decomposizione bias-variance: avevamo definito la
capacità come il numero di relazioni input-output che il modello è in grado di realizzare.
In generale, è difficile definire la capacità: nel caso del percettrone però si può calcolare
esplicitamente. Vedremo quindi il teorema di Cover (1966).
Nel percettrone, le funzioni sono legate alla classificazione binaria e sono chiamate anche
dicotomie: ci chiediamo quante dicotomie il percettrone è in grado di realizzare. Sup-
poniamo di avere m input point x1 , . . . , xn , dove xi ∈ RD . Questi punti possono essere
abbinati ad un vettore binario b1 , . . . , bn tramite una dicotomia. Poiché sono m dati, ho
2m possibili configurazioni. Ci chiediamo quante di queste sono linearmente separabili
e quindi realizzabili da un percettrone. Vogliamo trovare una risposta generale, quindi
supponiamo i punti siano in general position: presi xii=1,...,m punti di D-dimensioni,
supponiamo che ogni sottoinsieme di dimendione minore o uguale di D sia linearmente
indipendente e non ci siano D + 1 punti sullo stesso iperspazio D − 1-dimensionale. Nel
caso in cui D = 3, in particolare, significa che non ci siano 3 punti collineari o 4 sul-
lo stesso piano. Ovviamente, non è detto che tutti i dataset reali, in particolare quelli
strutturati, soddisfino queste ipotesi: ad esempio le immagini non sonop distribuite a
caso nello spazio con dimensionalità pari al numero di pixel. Definiamo con C(m, D) il
numero di dicotomie che possono essere realizzate con un percettrone dati m punti in
posizioni casuali in RD . Iniziamo da alcuni casi facili, assumendo che l’iperpiano passi
per l’origine (includiamo il bias, quindi x0 = 1):
• D = 1, ∀m: C(m, 1) = 2
• ∀D, m = 1: C(1, D) = 2 (prendendo w = x1 )
• D = 2: C(m, 2) = 2m (rotazione della retta che passa tutti i punti 2 volte)
Troviamo ora il valore di C(m, D) per induzione: supponiamo di avere per m punti
C(m, D), cosa succede se aggiungiamo un punto? Se abbiamo (b1 , . . . , bm ), con b ∈ −1; 1,
esiste w tale che (output percettrone) (sign (wt x1 ) , . . . , sign(wt xm )) = (b1 , . . . , bm ). Ag-
giungendo un punto, abbiamo una nuova dicotomia definita dalla presenza di w, ovvero
(sign (wt x1 ) , . . . , sign(wt xm ), sign(wt xm+1 )): quindi la dicotomia precedente ne definisce
almeno un’altra quando aggiungo un punto. Segue che C(m + 1, D) ≥ C(m, D) e quindi
C(m + 1, D) = C(m, D) + A. Siamo quindi interessati a trovare il valore di A. Ragionia-
mo in due dimensioni: se riesco a realizzare una dicotomia che passa esattamente per il
nuovo punto, ottengo due dicotomie diverse (spostandolo un po’ più giù o un po’ più sù,
posso ottenere la stessa dicotomia di prima ma con +1 o -1 per quel punto). Questo tut-
tavia non è sempre possibile: le dicotomie che posso selezionare che passano per un punto
corrispondono a delle dicotomie con una dimensione in meno (vincolo che riduce la dimen-
sionalità) e quindi otteniamo la formula ricorsiva C(m + 1, D) = C(m, D) + C(m, D − 1).
Ricordando le boundary condition C(m, 1) = 2 and C(1, D) = 2, (Teorema di Cover):


m
D−1 2 m≤D
X m−1  !
C(m, D) = 2 = PD−1 m−1
k  k=0
 m<D
k=0 k
Finché il numero di punto è minore della dimensionalità del problema, tutte le possibili
dicotomie sono realizzabile, mentre questo non è vero quando il numero di punti eccede
la dimensionalità. Quindi più è alta la dimensionalità, più è probabile che il proble-
ma sia linearmente separabile. In particolare, se il numero di punti è il doppio della
dimensionalità, frazione di possibili dicotomie che il percettrone realizza è
C(2D, D) 1
C(2D, D) = 2m−1 = 22D−1 → m
=
2 2
Questo plot, oltre a sembrare una transizione di fase, suggerisce che, dal punto di vi-
sta della teoria dell’informazione, riusciamo ad immagazzinare i parametri wi con due
bit (fino a quando m < 2D riesco ad immagazzinare al massimo 2 volte il numero di
parametri, ovvero 2D label binarie).
2.7 Regressione logistica

Continuiamo a parlare del problema di classificazione, spostandoci però ad un modello
di tipo probabilistico, cioè dove aad ogni input si associa una certa probabilità di appar-
tenere ad una classe. Affrontiamo quindi il modello di regressione logistica. Abbiamo già
visto questa struttura come modello di neurone, dove però la somma pesata era trattata
da una sigmoide ŷ = σ(z) = 1+e1−z . Fare classificazione coincide con il trovare un decision
boundary, come nel caso del percettrone. Possiamo trovare la divisione lineare ponendo
σ(wt x) = 12 e quindi wt x = 0 (le curve di livello, quindi a pari probabilità in questo
caso, sono degli iperpiani). Il grafico è fatto in questo modo, dove sull’asse z abbiamo la
sigmoide valutata in wx , che corrisponde alla probabilità di assegnare al punto il valore
1. Nella transizione ho una probabilità che cresce o decresce, non è più una assegnazione
all or none come nel percettrone.
Come possiamo settare il vettore w che fa da discriminante? Utilizziamo, come nel ca-
so di regressione, la maximum likelihood estimation dove cerchiamo argmaxw P(D|w).
2.7. REGRESSIONE LOGISTICA 25
Non possiamo tuttavia usare direttamente P cosa avevamo trovato nel caso della regres-
(i)
sione in quanto avevamo che J(w) ∝ i (y − ŷ (i) )2 , formula ricavata a partire da
−1
P(y|x, w) = N (y|µ = ŷ, β ) (abbiamo settato il modello del noise gaussiano dell’at-
tribuzione x-y, dove però ŷ è deterministico). Ora questa assunzione non ha più senso
perché y è già una variabile aleatoria stocastica (assume solo i valori 0 o 1): ora ci serve
un noise model per variabile stocastiche binarie per poter applicare il principio di maxi-
mum likelihood.
Consideriamo ora X una variabile aleatoria distribuita come una bernoulliana di para-
metro θ(=probabilità che X = 1). Abbiamo allora che
P(X = x|θ) = θx (1 − θ)1−x , E[X] = E[X 2 ] = θ, V ar[X] = θ(1 − θ).
Dato un dataset binario x1 , . . . , xm (ad esempio il risultato di m lanci di moneta),

supponendo che tutti i punti del dataset siano i.i.d. abbiamo che
m
Y m
Y
P(D|θ) = P(xi |θ) = θix (1 − θ)1−xi .
i=1 i=1
Per trovare lo stimatore di massima verosimiglianza:

m
δ X X xi 1 − xi
log P(D|θ) = δθ xi log θ + (1 − xi ) log (1 − θ) = − =0
δθ i=1 i
θ 1−θ
1 X n
→ θM L = xi = , (n è il numero di volte che x = 1)
m i m
(Nel caso in cui ad esempio esca sempre un valore, abbiamo overfitting.)
Analizziamo ora la funzione costo per la regressione logistica. Dato un dataset x(i) , y (i) ,
dove y (i) è 1 se appartiene alla classe C1 , altrimenti 2 se appartiene alla classe C2 .
Utilizzando la sigmoide, abbiamo che
1 1
ŷ (i) (z (i) ) = = .
1+e −z (i)
1 + e t x(i)
−w
Dato quindi x(i) , abbiamo per la regressione logistica che
P(y (i) = 1|x(i) , w) = σ(z (i) ), P(y (i) = 0|x(i) , w) = σ(−z (i) ).
Possiamo notare un’analogia con un sistema con due stati (definiti da due energie 0 e
1 ) con particelle non interagenti. Possiamo identificare y (i) come lo stato della particella
i. Ci chiediamo quindi
e−β1 1
P(y (i) = 1|0 , 1 , t) = = ,
e−β0 + e−β1 1 + e−β∆
dove il neurone definise quindi la differenza di energia di appartenenza ad una classe o
1
ad un’altra, −β∆ = wt x, e quindi β = kT (parametro di freddezza/temperatura).
Tornando alla likelihood, il nostro obiettivo è quello di massimizzare argmaxw log P(D|w),
mentre la label è una variabile aleatoria binaria. Vogliamo che il modello descriva la
probabilità che y (i) = 1 attraverso la sigmoide.
m
Y m h
Y iy(i) h i1−y(i)
P(D|w) = P(y (i) |x(i),w ) = ŷ (i) 1 − ŷ (i)
i=1 i=1
"m #
X
log P(D|w) = − y (i) log ŷ (i) + (1 − y (i) ) log (1 − ŷ (i) ) .
i=1
In questo modo, possiamo definire la cost function/cross-entropy per la regressione

logistica: "m #
1 X (i) (i) (i) (i)
J(w) = − y log ŷ + (1 − y ) log (1 − ŷ ) .
m i=1
Possiamo anche aggiungere dei regolarizzatori, il che coincide con avere delle prior sui
valori dei parametri, per evitare l’overfitting (sia L1 che L2 ).
1
Per trovare i valori di w, possiamo posse a 0 la derivata? Ricordando che ŷ (i) = −z (i)
,
1+e
d (i)
dove z (i) = wt x(i) , e che dz ŷ = ŷ (i) (1 − ŷ (i) ):
" m
#
δ 1 X (i)
0= − y log ŷ (i) + (1 − y (i) ) log (1 − ŷ (i) )
δw m i=1
m
1 X y 1−y
=− ŷ(1 − ŷ)δw z + (−1)ŷ(1 − ŷ)δw z
m i=1 ŷ 1 − ŷ
1 X
=− (y − y ŷ − ŷ + y ŷ)δw z.
m i
δ t δ t
Ricordando che δw w x = δw x w = x, otteniamo che
1 X (i)
∇w J(w) = (ŷ − y (i) )x(i) = 0.
m i
Tuttavia non c’è nessuna risoluzione analitica per wM L in quanto ŷ (i) è la sigmoide:
bisogna ricorrere a metodi numerici. Oltre al gradient descent ∆w = −η∇wJ, un altro
modo per risolverlo è il metodo di Newton (molto più usato): utilizzando l’hessiana H,
abbiamo un metodo dei minimi quadrati pesato dove ∆w = −H −1 ∇wJ.
Abbiamo ottenuto una certa forma per il gradiente di J (con gradient descent), che è la
stessa forma ottenuta nel caso di linear regression dove:
1 X (i) 2
J(w) = y − ŷ (i)
2n i
∂ 1 X (i) ∂
J(w) = − y − ŷ (i) ŷ (i)
∂w m i ∂w
1 X (i)
= ŷ − y (i) x(i)t .
m i
Abbiamo visto che nel caso di regressione lineare J era convessa, quindi ogni spostamento
verso un valore J più basso portano verso il minimo globale. Questo vale anche per la
regressione logistica anche se non riusciamo a rivolvere l’equazione analiticamente?
2.8. SOFTMAX: REGRESSIONE LOGISTICA MULTICLASSE 27
Sì, infatti calcolando l’hessiana del vettore D + 1-dimensionale ∇w J

m m
1 X ∂ (i) (i) 1 X (i)
∇∇J = ŷ x = ŷ (1 − ŷ (i) )x(i) x(i)t
m i=1 ∂w m i=1
otteniamo che è proporzionale alla matrice di covarianza quindi semidefinita positiva.

Osserviamo ancora che abbiamo un problema di classificazione dove stiamo cercando
l’iperpiano di divisione delle classi: in questo caso, diversamente dal percettrone, non
c’è bisogno che le due classi siano linearmente separabili. Abbiamo infatti definito una
funzione costo che ha un minimo globale che porta ad un piano ottimale di separazioni tra
le due classi. Tuttavia, nel caso di regressione logistica, se le due classi sono linearmente
separabili, una volta che ho trovato un iperpiano (wt x = 0), la funzione costo continua a
diminuire se w aumenta (in norma, quindi la sigmoide è sempre più steep avvicinandosi
alla θ di Heavyside) in quanto
1
J ∝ − log .
1+ e−wt x(i)
Questo diventa quindi di nuovo un problema di overfitting, cioè il modello diventa iper-
confident, quando invece non vorremmo essere così sicuri nel caso il modello sia vicino al
boundary. Tuttavia, se aggiungiamo termini di regolarizzazione il problema è ridotto.
2.8 Softmax: regressione logistica multiclasse

Ora parleremo di problemi di classificazione a molte classi, cercando di estendere gli
argomenti delle lezioni precedenti. Ci sono due casi diversi: possiamo fare regressioni
logistiche di classificazione binaria del tutto indipendenti oppure avere C classi mutual-
mente esclusive. Ci occuperemo ora del secondo caso.
Utilizzeremo il one-hot encoding: supponiamo di avere un dataset x(i) , y (i) , dove la
label y (i) è un vettore in Z2c che ha 1 solo nella posizione della classa a cui appartiene e
c è il numero di classi. Siamo interessati nell’output probabilistico di ŷ (i) che è (Bayes)
P (x | ck ) P(Ck ) eak
P (Ck | x) = P = P aj ,
j P (x | Cj ) P(Cj ) je
dove ak = log P (x | ck ) P(Ck ). Questo si chiama softmax: nel caso specifico di regres-
sione logistica abbiamo che ak = wkt x, dove x è il vettore di input e wk il vettore dei
persi del k-esimo neurone di output. La softmax diventa quindi un’estensione naturale
della sigmoide, ma possiamo anche vederlo come uno smoothing della funzione di mas-
simo usata dalla classificazione binaria del percettrone (si prende la label k tale per cui
wkt x = zk > zj ).
Possiamo vedere anche le analogie con la distribuzione di Boltzmann: stiamo studiano

1
la probabilità del microstato k data la sua energia k e β = kT
e−βk 1
σ(k) = P −βj = e−βk , dove zk = −βk .
j e z
Vediamo ora la relazione di softmax con il caso con due classi. In quel caso, abbiamo
1
visto che il vettore di output è ŷ = σ(wt x) = 1+e−w t x = P(y = 1|x). Ora però abbiamo
un altro modo di rappresentarlo, ovvero tramite il softmax: usiamo due pesi w1 e w2 per
1
predire il vettore ŷ t = ez1 +e z2 (e
z1 z2
, e ).
Ci dedichiamo ora alla maximum likelihood estimation:

m Y
c
(i)
(i)
Y
P(D|w) = P(yk = 1|X (i) , w)yk ,
i=1 k=1
in questo modo ogni input è associato ad una sola classe anche se abbiamo una formula
generale perché
(i) (i)
∀x(i) → yk = 1 yj = 0∀j 6= k;

(i)
m X c P yk = 1|X (i) , w
(i)
X
− log P(D|w) = − yk log
i=1
,
k=1
(1) (i)

dove vogliamo che ŷk =σ z . La cross-entropy nel caso di C classi diventa
m c
1 X X (i) (i)
J(w) = − yk log ŷk
m i=1
k=1
2.9 Metriche di performance

Quando si scrive un algoritmo è importante misurare se sta facendo bene oppure no. Per
fare ciò, è importante quando si costruisce un modello predittivo identificare l’obietti-
vo/la questione: in questo modo possiamo adottare delle metriche di performance che
valutano in modo quantitavivo la vicinanza all’obiettivo (che spesso non coincidono con
le funzioni costo). Un altro aspetto importante è capire il target value della performance,
ovvero quando ci si può ritenere soddisfatti, tenendo in mente che è impossibile arrivare
all’errore zero (c’è sempre una soglia di errore che non si può abbassare data dal Bayes
error e in più abbiamo un training data finito).
Concentriamoci ora sul problema di classification. Finora abbiamo assunto di misurare
la performance dell’agoritmo sulla accuracy, ovvero la frazione di esempi per i quali il
modello restituisce l’output corretto. Analogamente, possiamo definire l’error rate (o
expected 0-1 loss) come 1-accuracy, cioè la frazione di esempi per cui il modello dà un
output sbagliato. Queste sono definizioni intuitive basate sul test set e la maggiorparte
delle volte queste misure vanno benissimo.
Introduciamo ora le confusion amatrix, cioè delle tabelle nel seguente contesto: sup-
poniamo di avere due classi, ovvero y (i) ∈ {0, 1}, dove 0 not cancer e 1 cancer, e
supponiamo anche di avere un modello probabilistico pere fare questa classificazione
ŷ (i) = P(y (i) = 1|x(i) ). Definiamo quindi, se è ad esempio una sigmoide, una treshold,
ovvero se ŷ (i) > t allora è uguale a uno, altrimenti è 0. Possiamo quindi costruire la
confusion matrix, dove y è la true label mentre ŷ sono le label del modello, TP sta per
true positive e così via, P è il totale di positivi nella realtà e P̂ il numero di positivi nel
modello e analogo per N e N̂ . Possiamo quindi definire
1
accuracy = (T P + T N ) , error rate = 1 − acc
T OT
2.9. METRICHE DI PERFORMANCE 29
y=1 y=0
ŷ = 1 TP FP P̂
ŷ = 0 FN TN N̂
P N
tot = P + N = T P + F P + F N + T N.
Ci possono tuttavia essere problemi se usiamo solo queste come misure di performance.
Ad esempio, supponiamo di aver fatto training di un classificatore di immagini per la
diagnosi (cancer/not cancer) e di aver poi calcolato con il test set che l’accuracy è del
99% (error= 1%). Siamo interessati a sapere quanto sia vera questa stima. Supponiamo
un test set con 104 analisi, tra cui 100 pazienti con label postiva. La confusion matrix
nel caso in cui il classificatore attribuisca a tutti la label ŷ = 0∀x(i) è In questo caso
y=1 y=0
ŷ = 1 0 0
ŷ = 0 100 9900
P=100 N=9900
9900
quindi l’accuracy è 10000 = 99%, ma il classificatore non predice bene. L’accuracy non
è quindi una buona misura della performance nel caso in cui gli esempi non sono ben
distribuiti nelle classi, ma questo non è sempre vero nei dataset reali. Ad esempio, ora
prendiamo il caso del classificatore spam/non spam. I due errori possibili, lasciar passare
la spam e bloccare mail non di spam, sono molto diversi tra loro e il secondo è molto più
grave. Tuttavia, dal punto di vista dell’accuracy questi due tipi di errore sono equivalenti,
quando invece può essere cruciale nelle applicazioni.
Ora vogliamo quindi passare a misure più precise a partire dalla confusion matrix, la quale
contiene tutte le informazioni riguardo agli errori che l’algoritmo sta facendo. (Nota: nel
caso di "classi rare", quindi che comprendono piccole % della popolazione, in genere si
usa y = 1).
La prima quantità che definiamo è la precision = TP̂P = T PT+F P
P , ovvero la frazione di
veri positivi in chi è pseudopositivo. Una high precision è implicata, in termini di soglia,
da una treshold alta (mi aspetto però di avere molti FN, in quanto siamo diventati
molto selettivi alzando la soglia). Per bilanciare la precision, definiamo ora la recall (o
sensitivity o true positive rate) come TPP = T PT+FP
N : indica la frazione di positivi che è
stata predetta tra tutti i positivi reali. Una high sensitivity è implicata da una treshold
bassa. Diventa quindi importante guardare il trade off tra la precision (se ti dico che
sei positivo è molto probabile che tu lo sia) e la recall(se sei postivo è molto probabile
che ti dica che sei positivo). L’idea quindi è che a fissata recall la precisione sia più alta
possibile.
Ora introduciamo il concetto di F1 score. Supponiamo di avere ad esempio diversi

algoritmi con relativa precision e recall. Vogliamo riassumere il plot di recall su precision
con uno scalare che indica la performance. Notiamo che non possiamo fare semplicemente
la media tra i due valori (non misura ad esempio la differenza se tutti i valori sono
classificati con la stessa label).che è sostanzialmente la media armonica tra le due quantità
(sarà alto solo se sia P che R sono grandi)
2 2P R
F1 = 1 1 = .
P + R
P +R
Un’altra misura molto usata insieme alaa sensitivity (la recall) è la specificity (quanti
tra quelli sani sono effetticamente sani): tramite queste si definiscono le ROC curves.
TP TN TN
Recall/sensitivity: Specificity: =
P N TN + FP
Anche in questo caso c’è un trade off tra le due misure, in base alla treshold abbiamo
infatti: Un elemento che può essere calcolato è l’AUC, ovvero l’area sotto la curva, che
distingue i modelli e descrive quanto il modello è performante su entrambi i fronti.
Tuttavia, per queste misure, è molto più popolare il plot delle ROC curves (Reveiver
Operating Characteristics), dove mettiamo sull’asse x 1-specificity (= FNP false positive
rate) e sull’asse y la recall (true positive rate):
Un random classifier fa una retta in quanto attribuisce probabilità ρ alla label ŷ = 1.

Infatti in questo caso ho che recall=1-specificy cioè la retta:
TP FP
T P = ρP → = ρ, F P = ρN → = ρ.
P N
Possiamo anche in questo caso utilizzare lo scalare AUC come misura della performance,
sapendo che questo sarà compreso tra 0 (random classifier) e 1 (perfect classifier).
Se abbiamo più classi, possiamo usare la multiclass confusion matrix:
0 1 2 ···
0 c00 c01 c02 ···
1 c10 c11 c12 ···
.. .. ..
. . .
Nella diagonale ci sono le classificazioni corrette, normalizzate per il numero di elementi

in ogni classe, mentre le cij sono le probabilità empiriche di predire la classe i data la
label j. Diventa quindi un plot di flusso, plot perché di solito si plottano con diversi
colori (o gradazioni di grigio) e se il colore non coincide con la diagonale allora significa
che alcuni elementi sono stati misclassificati.
2.9. METRICHE DI PERFORMANCE 31
Problema di regressione
La misura di performance più usata nei modelli di regressione è la root mean square
error r
1
RM SE = sumi=1 m(ŷ (i) − y (i) )2 ,
m
ovvero la l2 -norm, ed è la distanza tra la predizione il valore reale. Se ci sono outliers,
tuttavia, questi possono dominare il risultato. Per evitare ciò si può usare la mean
absolute error
1 X
M AE = m|ŷ (i) − y (i) |,
m i=1
ovvero la l1 -norm o Manhattan norm, che è meno sensibile agli outliers. In generale, si
possono usare le lk -norm: al crescere di k ci focalizziamo di più sui valori grandi.
Capitolo 3
Teoria dell’informazione
3.1 Entropia
La teoria dell’informazione nasce alla fine degli anni ’40/inizio anni ’50 soprattutto gra-
zie ai lavori di Shannon: questa teoria è nata per poter costruire codici ottimali per
trasmettere informazioni attraverso canali che potevano essere rumorosi (ad esempio per
la trasmissione radio). C’è un link profondo tra la teoria dell’informazione e il machine
learning: per fare data compression (rappresentare nel modo più efficiente possibile i da-
ti che ho ottenuto da variabili stocastiche), meglio conosciamo la distribuzione di questi
eventi, più saremo capaci di costruire un codice compatto per rappresentare questi dati.
Ad esempio, il linguaggio è il risultato di un processo di ottimizzazione: le parole che
sono molto corte tendenzialmente sono usate con una frequenza molto alta. Quindi se ho
un’idea della frequenza degli eventi, posso associare agli eventi più probabili codici più
corti, permettendo di comprimere il codice per trasmettere informazioni. Quindi tutto
ciò richiede un modello probabilistico dei dati, quindi bisogna costruire un modello di
inferenza per capire da dove sono generati i dati. Da questo punto di vista quindi diventa
un problema di machine learning: da dai dati, si cerca di capire riprodurre nel modo più
fedele possibile il modello generativo dei dati.
L’intuizione alla base della teoria dell’informazione è semplice, ma non banale: venire a
conoscenza di un evento molto improbabile porta tanto contenuto di informazione, men-
tre se un evento è fortemente probabile e capita di continuo venirne a conoscenza non
porta granché di informazione. Come si può tradurre questa intuizione in dei requisiti
formali per definire una qualche misura del contenuto di informazione?
• L’informazione deve decrescere con la probabilità di un evento: quindi gli eventi

certi portano zero informazione.
• Le informazioni che arrivano da eventi indipendenti si sommano.
Per soddisfare questi requisiti, utilizziamo la seguente forma funzionale: se x è l’outcome

di una variabile stocastica (es: lancio della moneta), possiamo definire l’informazione
data p(x) la probabilità che venga l’outcome x attraverso la self-information
1
h(x) = log = − log p(x).
p(x)
La self-information soddisfa i requisiti in quanto più l’evento è probabile, meno infor-

mazione ho. Inoltre h(x) ≥ 0, decresce con p(x) ed è zero solo quando x è un evento
certo (l’evento non porta nessuna informazione in quanto era certo che sarebbe arrivato).
Infine è additivo per eventi indipendenti in quanto le probabilità fattorizzano e si ha
h(x1 , x2 ) = − log p(x1 , x2 ) = − log p(x1 )p(x2 ) = h(x1 ) + h(x2 ).
32
3.1. ENTROPIA 33
Possiamo quindi definire il concetto di entropia, cioè il valore atteso dell’informazione

di un outcome x estratto dalla distribuzione p:
Hp (x) = Ex∼p [h(x)]

= Ex∼p [− log p(x)]
X
= p(x) log p(x).
x∈Ax
Anche in questo caso si mantiene l’idea di additività:
H(x, y) = H(x) + H(y) if p(x, y) = p(x)p(y)
Entropia per variabile aleatorie binarie (Bernoulli)

Dato un outcome x ∈ {0, 1}, dove P(x = 1) = θ, si ha che
1
X
Hp (x) = . θx (1 − θ)1−x log (θx (1 − θ)1−x )
x=0
= [(1 − θ) log (1 − θ) + θ log θ].
Quando |theta = 0 o θ = 1, l’informazione portata è nulla in quanto sono eventi certi.

Se poniamo θ = 21 , l’informazione è massima in quanto sono pù incerto sull’output:
otteniamo che H(x) = log 2 ∼ 0.7 nuts (usando il logaritmo in base 2, otteniamo che
H(x) = log2 2 = 1 bit, dove il bit è definito proprio come il contenuto di informazione
tipico di una variabile bernoulliana quando i due parametri sono equiprobabili).
Entropia e coding
Enunciamo ora il teorema del noiseless coding: l’entropia H(x) è il lower bound per
il numero di bit necessari (in media) per codificare l’outcome di p(x).
Ad esempio, se prendiamo una variabile stocastica x che ha 8 possibili outcome e1 , . . . , e8 .
Se prendiamo il caso in cui le probabilità sono eque (la probabilità di ogni evento è 81 ),
abbiamo che l’entropia legata alla p(x) è
8
X 1 1
H(x) = − log2 = log2 23 = 3 bit.
i=1
8 8
Risulta quindi che 3 bit è la lunghezza del codice che ci serve per codificare 8 eventi, infatti
permettono di codificare 23 stati: Nel caso in cui gli eventi non fossero equiprobabili, ma
e1 e2 e3 e4 e5 e6 e7 e8
000 100 010 001 011 110 101 111
qualcuno è molto più probabile degli altri, l’entropia diventa 2 bit (nel momento in qui
gli eventi non sono più equiprobabili, il limite inferiore del numero di bit che servono
34 CAPITOLO 3. TEORIA DELL’INFORMAZIONE
per trasmettere l’outcome della distribuzione è ridotto), quindi la lunghezza dei codici
varia in base alle probabilità (pochi bit per quelli più probabili): Quindi ora la lunghezza
x e1 e2 e3 e4 e5 e6 e7 e8
1 1 1 1 1 1 1 1
p(x) 2 9 8 16 64 64 64 64
code (0) (10) (110) (1110) (111100) (111101) (111110) (111111)
media del codice (che è ottimale in quanto tocca il lower bound) è

1 1
· 1 + · 2 + · · · = 2 bit.
2 4
Entropia differenziale
Finora ci siamo occupati di variabili con output discreti e finiti, nel caso di variabili
continue possiamo estendere il concetto di entropia con l’entropia differenziale
Z
Hp (x) = − p(x) log p(x)dx.
Non è una definizione banale in quanto non è solo il limite dal discreto al continuo. Infatti,
se prendiamo dei bin di ampiezza ∆, possiamo associare alla probabilita dell’i-esimo bin
una probabilità discrete
Z (i+1)∆
.
i∆
Quindi in generale diventa
X
H∆ = − p(xi )∆ log [p(xi )∆]
i
X X
=− p(xi )∆ log [p(xi ) − p(xi )∆ log ∆∆]
i i
X
=− p(xi )∆ log p(xi ) − log ∆,
i
dove è la divergenza.
P Passando al limite per Delta che tende a 0, log ∆ diverge mentre
l’altra parte − i p(xi )∆ log p(xi ) diventa l’entropia differenziale. Quindi bisogna prima
rimuovere la divergenza perché stiamo definendo p(xi ) in infinite posizioni.
3.2 Introduzione ai modelli di massima entropia

Ora giustificheremo perché abbiamo utilizzato la distribuzione di Bernoulli e quella gaus-
siana come naturali guess del noise nel caso della maximum likelihood estimation. Inoltre
questo principio è molto utilizzato per modelli generali che soddisfano i constraint dati
dai dati. Il principio di massima entropia è stato introdotto da Jaynes negli anni ’50
nel contesto della meccanica statistica: l’idea è che ci siano dei vincoli sul sistema, ovvero
una informazione a priori su qualche aspetto del sistema (ad esempio su una distribu-
zione che descrive i dati) e si cerca il modello più agnostico possibile che descriva questa
situazione soddisfando i vincoli con il minor numero di assunzioni possibile (massima
ignoranza). Quindi quello che si invoca è un principio di massima entropia, o maxent,
nello studio di un modello complesso di cui ho solo dei dati su larga scala. Prendiamo il
caso di una variabile stocastica con M possibili outcome xi . Cerchiamo la distribuzione
di probabilità che massimizza l’entropia dove l’unico vincolo che stiamo ponendo è sugli
outcome (sono discreti e sono M ). Intuitivamente, più la distribuzione è flat sugli stati,
più è grande l’entropia: cerchiamo di quantificare l’intuizione.
Per l’ottimizzazione con dei vincoli si usano i moltiplicatori di Lagrange. Nel nostro
3.2. INTRODUZIONE AI MODELLI DI MASSIMA ENTROPIA 35
caso definiamo la Lagrangiana con l’entropia meno i vincoli esplicitati (la somma sugli
stati somma ad 1): !
Xm
L=H −λ p(xi ) − 1
i=1
P
dove H = − i p(xi ) log p(xi ) e λ sono i moltiplicatori di Lagrange. I punti critici di
L coincidono con il problema di ottimizzazione soddisfatti vincoli. Quindi prendendo la
derivata funzionale di questo oggetto e ponendola uguale a zero
δL
= − log p − 1 − λ = 0,
δp
quindi otteniamo la forma funzionale p(x) = e−λ−1 e sostituendola nel vincolo otteniamo
i moltiplicatori di Lagrange
M
X
e−λ−1 = 1 ⇒ M e−λ−1 = 1 ⇒ λ = log M,
i
otteniamo la distribuzione uniforme come maxent P (x) = e− log M = 1

M.
Consideriamo ora una variabile stocastica x ∈ {0, 1}, quindi ha due possibili outcome e
l’outcome atteso è θ, e cerchiamo la distribuzione di massima entropia. La lagrangiana
è data dai due vincoli (somma probabilità e media), dove p = p(x),
X X X
L=− p log p − λ1 p − 1 − λ2 xp − θ ,
quindi
δL
= − log p − 1 − λ1 − λ2 x = 0,
δp
da cui la forma funzionale di p(x) = e−(λ1 +λ2 +1) e, sostituendola nei vincoli,
X
p = 1 → e−(λ1 +1) + e−(λ1 +λ2 +1) = 1,
X
xp = θ → e−(λ1 +λ2 +1) = θ
otteniamo x
θ
p(x) = (1 − θ) = θx (1 − θ)1−x .
1−θ
Possiamo conclurre quindi che la distribuzione con massima entropia di una variabile con
due output fissati e con una media fissate è una distribuzione di Bernoulli.
Nel caso continuo, la distribuzione che massimizza l’entropia è la distribuzione gaussiana.

Innanzitutto, per poter massimizzare l’entropia dobbiamo aver fissato la varianza (se au-
mento la varianza, aumenta il contenuto di informazione degli output e quindi l’entropia)
e la media (altrimenti è un problema sottodeteminato perché shiftando la distribuzione,
la soluzione è ancora valida). Ora cerchiamo la distribuzione che ha il minor numero di
altre assunzioni possibili (oltre alla normalizzazione, alla media e alla varianza), ovvero
quella che massimizza l’entropia. Scriviamo la Lagrangiana utilizzando la differenzial
entropy
Z Z Z Z
L = − p(x) log p(x)+λ0 [ p(x)dx−1]+λ1 [ xp(x)dx−µ]+λ2 [ (x−µ)2 p(x)dx−σ 2 ];
δL
= − log p − 1 + λ0 + λ1 x + λ2 (x − µ)2 .
δp
Si ottiene per sostituzione che p(x) ∼ N (x|µ, σ 2 ).
Ora vogliamo dimostrare che la distribuzione di Boltzmann o Gibbs sono il risultato di

una maximum entropy estimation quando sono stato osservati una serie di valori medi. I
vincoli quindi sono definiti nel seguente modo: abbiamo osservato < fi >obs valori medi,
quindi il modello deve soddisfare queste osservazioni < fi >model =< fi >obs . Definiamo
quindi la Lagrangiana coi vincolo ei valori osservati
Z Z X Z
L[p] = − p log pdx + λ0 p(x)dx − 1 + λi fi (x)p(x)dx− < f >obs
i
δL X
= − log p − 1 + λ0 + λi fi (x).
δp i
Otteniamo quindi la distribuzione di Boltzmann con z che è la funzione di partizione

P 1 P
p(x) = eλ0 −1 e i λi fi (x) = e i λi fi (x) .
z
P
= 1 fa si che z1 e λi fi (x)] dx = 1, da cui la funzione di
R
Infatti il vincolo intp(x)dx
P
partizione z = e λi fi (x)] dx. Anche in questo contesto si possono ottenere i momenti
R
dalla funzione di partizione

δ log z
< fi >model = =< fi >obs .
δλi
Ad esempio, supponiamo di avere solo un osservazione di valore medio (l’energia media)

< fi >obs =< E(x) >obs . Otteniamo che p(x) = z1 eβE(x) , dove il moltiplicatore di
Lagrange è λ = −β e il vincolo osservato definisce com’è fatta la distribuzione.
3.3 La divergenza di Kullback-Leibler
La divergenza di Kullback-Leibler (o entropia relativa) è una misura di dissimilarità tra

due distribuzioni p(x) (l distribuzione dei dati) e q(x) (la distribuzione approssimata dal
modello): la divergenza DKL (p||q) rappresenta la quantità di informazione (differenza
di entropia) in più necessaria per trasmettere x ∼ p(x) se usiamo q(x) per costruire il
codice (assumendo di stare utilizzando un coding efficiente).

1 1
DKL (p||q) = Ex∼p log − Ex∼p log
q(x) p(x)
Z Z
= − p(x) log q(x)dx + p(x) log p(x)dx
Z
p(x)
= p(x) log dx
q(x)
= Hpq (x) − Hp (x)
h i
1
dove Hpq (x) = Ex∼p log q(x) è la cross entropy, nel senso che ripesa il contenuto
di informazione su un’altra distribuzione. Si può inoltre dimostrare la disuguaglianza
dell’informazione
DKL (p||q) ≥ 0 and DKL (p||q) = 0 iff p = q.
Questa misura della divergenza tra distribuzioni non è una distanza in quanto DKL (p||q) 6=
DKL (q||p) (non è simmetrica): entrambe spingono verso la direzione giusta (DKL è nullo
quando le le distribuzioni coincidono), ma penalizzano in cose diverse. Infatti se con-
sideriamo p una mixture di due gaussiane la nostra approssimazione q come una sola
3.3. LA DIVERGENZA DI KULLBACK-LEIBLER 37
gaussiana, otteniamo una q diversa in base alla distanza che abbiamo

Z
q(x)
q∗ = argminq DKL (q||p) dove DKL (q||p) = q(x) log dx
p(x)
Z
p(x)
q∗ = argminq DKL (p||q) dove DKL (p||q) = p(x) log dx
q(x)
Nel primo caso, non è importante se q ha bassa densità dove ci sono dati, ma non può
avere alta densità dove non ce ne sono. Nel secondo caso, nei picchi di p voglio che ci sia
più densità possibile di q per minimizzare la DKL , ma avendo una gaussiana sola, siamo
obbligati a riempire il buco di p (che non conta nella minimizzazione in quanto il termine
p(x) annulla tutto).
Stimatore di massima verosimiglianza e DKL

Ora vediamo il legame tra la stima basata su maximum likelihood e la KL divergence.
Dato un dataset D = {X1 , . . . , Xm } e una vera distribuzione dei dati p(x) che cerchiamo
di approssimare con un modello parametrico q(x(w)) che si basa su un set di parametri
w. Per trovare i parametri, cerchiamo di massimizzare P(D|w):
wM L = argmaxw P(D|w)
Ym
= argmaxw q(xi |w)
i=1
X
= argmaxw log q(xi |w)
i
1 X
= argmaxw log q(xi |w)
m i
1 X 1 X
= argmaxw log q(xi |w) − log p(x)
m i m i
m
1 X p(x)
= argminw log
m i=1 q(xi |w)
Z
p(x)
−→ argminw p(x) log dx, per m → ∞,
q(x|w)
da cui otteniamo che la maximum likelihood estimation coincide con minimizzare la KL

divergence:
wM L = argminw DKL (p||q).
Ora alcune considerazioni: ad un certo punto della dimostrazione abbiamo ottenuto la

prima uguaglianza, ma sviluppandola otteniamo anche che
1 X
wM L = argmaxw log q(xi |w)
m i
Z
' argmaxw p(x) log q(x|w)dx
Z
= argminw − p(x) log q(x|w)dx
= argminw − Hpq (x),
quindi la maximum likelihood è una minimizzazione della cross entropy (per questo si
chiamano cross entropy le funzioni costo), ma anche della KL divergence in quanto
Hpq = DKL (p||q) + Hp .
Ora vediamo perché i modelli ottenuti con maximum likelihood hanno dei problemi ad
essere dei modelli generativi. Ad esempio, nel caso visto prima con p mixture di due
gaussiane e q la gaussiana che minimizza DKL (p||q) (quello che fa maximum likelihood),
può capitare che il modello metta alta probabilità in zone dove la vera distribuzione ha
densità vicino a 0. Abbiamo quindi alta probabilità di pescare oggetti che in realtà non
sono realistici. Dei miglioramenti sono stati ottenuti con le GAN (generative adversary
network), dove sono combinante entrambe DKL (p||q) e DKL (q||p).
Regressione logistica a due classi

Possiamo anche definire il problema al contrario, ovvero già partendo da un problema
di minimizzazione di divergenza di Kullback-Leibler. Nel caso della regressione logistica,
p ∈ {y, 1 − y}, dove all’input x associamo la probabilità y di avere la label 1 e 1 − y di
avere l’altra label. Quindi abbiamo (con la sigmoide) che
1
qy=1 = ŷ = , qy=0 = 1 − ŷ
1 + e−wt x
e q ∈ {ŷ; 1 − ŷ} . La cross entropy in questo caso è
X
Hpq = − pi log qi = −y log ŷ − (1 − y) log (1 − ŷ)
i

Dato quindi un taining set D = x(i) , y (i) i=1,...,m , vogliamo minimizzare la cross entropy
media (funzione costo):
m
1 X (i)
J(m) = H
m i=1 pq
"m #
1 X (i) (i) (i) (i)
= y log ŷ + (1 − y ) log (1 − ŷ ) .
m i=1
Si ottiene lo stesso risultato che si otterrebbe usando la maximum likelihood.
3.4 Mutual information

A partire dall’idea della divergenza di Kullback-Leibler possiamo definire una misura
molto generale di correlazione tra variabili stocastiche (più della correlazione di Pearson).
Date due variabili aleatorie X e Y definite da una certa p(x, y), vogliamo misurare quanto
conoscere l’output di X ci dice riguardo al valore di Y (variabili correlate, cioè oggetti
3.4. MUTUAL INFORMATION 39
che si muovono assieme). Nel caso in cui le variabili fossero completamente scorrelate
abbiamo infatti che la probabilità fattorizza p(x, y) = p(x)p(y). Vogliamo quindi misurare
quanto le variabili distino dal caso di fattorizzazione con la mutual information
I(X, Y ) = DKL (p(x, y)||p(x)p(y)),
I(X, Y ) ≥ 0 and I(x, y) = 0 iff p(x, y) = p(x)p(y).

Per esteso quindi la mutual information nel caso discreto diventa
XX p(x, y)
I(X, Y ) = p(x, y) log ,
x y
p(x)p(y)
mentre nel caso continuo

Z Z
p(x, y)
I(X, Y ) = dxdyp(x, y) log (p(x, y) = p(x|y)p(y))
p(x)(y)
Z Z Z Z
= dxdyp(x, y) log p(x|y) − dxdyp(x, y) log p(x)
Z Z
= dxdyp(x, y) log p(x|y) − Hp (x).
Possiamo quindi definire la conditional entropy (entropia di X condizionato ad Y)

come
Z Z
Hp (X|Y ) = − dyp(y) dxp(x|y) log p(x|y)
Z Z
=− p(x, y) log p(x|y)
e otteniamo quindi che la mutial information rappresenta la riduzione dell’entropia di

una variabile se conosco l’altra (poiché H(X, Y ) = H(X|Y ) + I(X, Y ) + H(Y |X)):
I(X, Y ) = −H(X|Y ) + H(X) ≤ H(X)

= H(Y ) − H(Y |X) ≤ H(Y ).
Ricaviamo quindi che
0 ≤ I(X, Y ) ≤ min {H(X), H(Y )}, dove H(X) ≤ log |X|(n° stati possibili)
La mutual information è una misura molto più efficiente e sofisticata per misurare le
correlazioni perché comprende qualsiasi tipo di dipendenza. Ad esempio con Pearson:
Capitolo 4
Recap + Il problema della

dimensionalità
4.1 Recap
Finora ci siamo concentrati principalmente su problemi di supervised learning, dove
abbiamo un dataset D =(x(i) , y (i) ).
Regression (linear regression)
Nel problema della regressione lineare, abbiami vusto la rappresentazione grafica di neu-
rone dove le feature erano pesate da pesi wi e in uscita c’era una predizione ŷ (i) associata
al vettore x(i) che corrispondeva ad un’attivazione lineare. Il learning consiste nel trovare
i pesi che portano ad una risposta il più giusta possibile dato un set di associazioni giu-
ste. Il principio che abbiamo usato per trovarle è quello di maximum likelihood, dove
abbiamo cercato i pesi che massimizzassero
Pm P(D|w). Questo ci ha portati a definire la
1 (i)
seguente funzione costo J(w) = 2m i=1 (ŷ −y (i) )2 : la minimizzazione di questo ogget-
to porta ad una forma chiusa risolvibile analiticamente, l’equazione normale (si possono
usare, ma algoritmi iterativi di learning non sono necessari). Abbiamo poi generalizzato
questo modello nel caso in cui l’output non fosse uno scalare, ma un vettore.
(i)
Inoltre, abbiamo sempre cercato di includere il bias nel vettore di pesi aggiungendo x0
per poter scrivere in forma compatta le nostre espressioni.
A queste funzioni costo J(w) si possono aggiungere dei termini di regolarizzazione che
cercano di limitare la crescita dei pesi o cercano di metterne alcuni a 0. Questi termini
sono stati introdotti come l’effetto di una prior sui pesi w.
Classification
Anche nel caso della classificazione abbiamo dato una rappresentazione simile a quella
del caso della regressione con la somma pesata dell’input, la differenza è nell’output della
rete. Mentre il percettrone attribuisce direttamente la classe attraverso una funzione a
tratti, la logistic regression fa uso della sigmoide, ovvero ŷ = σ(wt x) = σ(z) = 1+e1−z . In
questo caso, abbiamo una interpretazione probabilistica dove ad un vettore x associamo
la probabilità che appartenga ad una classe piuttosto che ad un’altra.
Anche in questo caso abbiamo applicato il principio di maximum likelihood per ottenere
la seguente funzione costo (detta anche cross entropy)sotto l’assunzione che la variabile
stocastica y (i) fosse descritta da una distribuzione di Bernoulli:
"m #
1 X (i)
J(w) = − y log ŷ (i) + (1 − y (i) ) log (1 − ŷ (i) ) .
m i=1
40
4.2. IL PROBLEMA DELLA DIMENSIONALITÀ 41
Abbiamo visto che in questo caso la minimizzazione di J non ha una forma chiusa, quindi
bisogna applicare algoritmi che cercano il minimo.
R Si chiama cross entropy perché abbia-
mo visto che minimizzare la cross entropy p(x) log p̂(x)dx coincide con il minimizzare
la divergenza KL DKL (p||p̂).
Abbiamo poi anche in questo caso esteso al caso di multiple classes. L’output è dato
da un vettore binario dove compare solo un 1 in un posto in corrispondenza alla classe
a cui appartiene (one-hot encoding). Nel caso di classificazione in più classi, abbiamo
un vettore di uscita per ogni classe, dove ogni componente del vettore di dimensione c è
calcolato applicando la sigmoide alla somma pesata del singolo neurone (softmax).
In questo caso la funzione costo (cross entropy) è
m X
c
(i)
X
J(w) = − yk log ŷ (i) .
i=1 k=1
Questi modelli non sono abbastanza e bisogna passare alle reti neurali, sebbene facciano
quello quello a cui siamo interessati. La motivazione sta nel fatto che la maggior parte
dei problemi non sono lineari: ad esempio, nel caso di classificazione, molto spesso il
boundary che separa le classi è non lineare (non per il noise, è proprio intrinseco nel
dataset). Finora noi abbiamo visto modelli lineari nel parametro w: possiamo quindi de-
finire nuove feature complicandole con polinomi (a partire da conoscenze sul problema)
in quanto in spazi con dimensioni maggiori il problema può diventare linearmente sepa-
rabile e possiamo applicare la regressione logistica. Tuttavia questo approccio presenta
dei problemi: in primo luogo possiamo partire già da un dato con alta dimensionalità (n
feature) e se non sappiamo quali combinazioni fare, considerando tutti i quadrati passia-
mo ad una dimensione di n2 /2, rendendo questo approccio intrattabile. Questo quindi
diventa un problema nel caso di immagini in quanto queste hanno già una dimensionalità
alta già nel dato grezzo. Cerchiamo di formalizzare questo possibile approccio di classic
machine learning : dato il vettore di feature, costruiamo una nuova configurazione dei
dati tramite una trasformazione fissata (anche non lineare) dalla quale ricaviamo ŷ con
un modello lineare. Con questo tipo di approccio, il vantaggio è che il learning avviene
soltanto nell’ultimo passaggio e inoltre è un problema convesso (se mi muovo verso un
minimo, sono sicuro di stare andando verso un minimo globale). L’approccio delle reti
neurali invece anche la trasformazione delle feature è parametrizzata con dei pesi w che
sono all’interno dell’algoritmo di learning (l’algoritmo capisce la rappresentazione giusta
del vettore di input); si applica poi un modello lineare. La differenza in questo caso è che
il problema di minimizzazione di complica che rendono le funzioni costo non convesse.
4.2 Il problema della dimensionalità
La non linearità non è l’unico problema: dobbiamo infatti tenere conto anche del fatto
di lavorare in spazi altamente dimensionali. I problemi che lavorare in uno spazio alto
dimensionale possono causare vanno sotto il nome di curse of dimensionality. Tutto
si riconduce al fatto che il numero di possibili configurazioni cresce esponenzialmente con
le dimensioni dei dati. La prima osservazione è che tipicamente i dati sono sparsi/isolati
in spazi alto dimensionali. Infatti il numero di dati in 1D deve essere simile al numero di
regioni con cui voglio stimare la funzione (idealmente ne vorrei uno per zona). Tuttavia,
se la dimensionalità d aumenta, il numero di dati richiesto sarà k d se consideriamo k
regioni per avere un buon campionamento. Ora immaginiamo questo esperimento per
capire che i punti sono isolati in spazi alto-dimensionali. Prendiamo un ipercubo (cubo in
Rd di lato 1) e supponiamo di avere N data points pescati in modo uniforme all’interno
del cubo. Supponiamo di prendere uno di questi cubi e di costruirci attorno un altro cubo
di lato l: ci chiediamo quanto debba essere grande l per contenere almeno altri k punti
42 CAPITOLO 4. RECAP + IL PROBLEMA DELLA DIMENSIONALITÀ
tra gli N punti. Tenendo conto del fatto che la proporzionalità è uniforme, otteniamo:
ld k k 1
' → l = ( )d .
1 N N
Con questa formula notiamo che più d cresce, più cresce anche l: diventa quindi perico-
loso attribuire ad un valore la label del suo primo vicino in questo caso perché è molto
distante (paragonabile alla massima distanza possibile nell’input space).
Un altro aspetto è che i data points stanno tutti sul boundary dello spazio di input.
Supponiamo infatti di avere una sfera di raggio r = 1, dove i punti sono pescati a caso
all’interno di questa sfera. Il suo volume è Vd (r) = kd rr . Ora ci chiediamo quanti punti
stanno in una scorza identificata da una sfera di raggio i − : visto che i punti sono
distribuiti unifermemente, possiamo fare il rapporto fra la dimensione della scorza e il
volume totale otteniamo 1 − (1 − )d , il che dimostra la nostra affermazione, ovvero che
con l’aumentare di d la frazione di volume contenuta nella buccia diventa sempre più
grande.
Un terzo aspetto è che i data points sono relativamente vicini a iperpiani (che possiamo
suppore fare da boundary nella classificazione). Se saliamo di dimensionalità, la distanza
tra i punti aumenta perché per definizione di distanza stiamo aggiungendo delle quan-
tità (ha senso perché sono isolati). Tuttavia la distanza dall’iperpiano non cambia in
quanto la dimensione aggiunta è ortogonale al vettore norma che definisce l’iperpiano,
sebbene i punti si allontanino tra di loro. Questo quindi implica che piccole pertur-
bazioni dei punti in alte dimensioni possono cambiare la boundary rule (adverasarial
example:perturbazioni che fanno cambiare di categoria).
Questi aspetti sembrano rendere svantaggioso fare machine learning con spazi alto di-
mensionali, tuttavia un’assunzione che abbiamo fatto è stata avere i dati distribuiti in
modo uniforme. Questo in generale non è vero (manifold hypothesis): i dati reali sono
concentrati in una piccola porzione dello spazio. Ci sono prove empiriche infatti sul fat-
to che i dati vivano in superfici (continuità: possiamo fare trasformazioni) a più bassa
dimensionalità rispetto allo spazio di input (tenendo conto ovviamente del noise). Ad
esempio le immagini reali, ad esempio di volti, non occupano tutto lo spazio di input:
se scegliessimo infatti colori casuali per ogni pixel il risultato non sarebbe un’immagine
sensata. Un’altra assunzione che si fa è che queste superfici siano delle varietà, ovvero
localmente sono spazi euclidei e vivono in uno spaio di dimensione maggiore.

Lingua

App Unti

Caricato da

Informazioni sul documento

Copyright

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

App Unti

Caricato da

Copyright:

UNIVERSITA’ DEGLI STUDI DI TORINO

Introduzione alle reti neurali

1.1 Introduzione alle reti neurali

Specificità delle reti neurali

performance a scelta, quando si mediano le loro performance su tutti tipi di problemi, i

Rassegna storica sulle reti neurali

1.2 Modello del neurone

Catturato Non catturato

Interpretazione probabilistica della sigmoide

Basi di Machine Learning

2.1 Stimatore di massima verosimiglianza - Distribu-

cov[X, Y ] = E[(X − E[X]))(Y − E[Y ]))] = E[XY ] − E[X]E[Y ].

I parametri sono dati dai d elementi del vettore µ e dai d(d−1)

Sampling dalle distribuzioni

Massima verosomiglianza per le distribuzioni gaussiane

In questo caso abbiamo che

2.2 Stimatore di massima verosimiglianza - Regres-

• y (i) è una funzione deterministica di x(i) quale è sommato un noise gaussiano.

P(y (i) |x(i) , w) = N (y (i) |µ = ŷ (i) (w), σ 2 ).

Con quest’ultimo punto abbiamo in particolare che, ponendo la precisione β = σ −2 :

Conseguentemente, vogliamo minimizzare la seguente funzione costo, che può anche

Quindi voler minimizzare l’errore quadratico corrisponde ad assumere di volere mas-

• è possibile anche trovare il parametro β, ovvero la precision, che massimizza la

• una volta stimati i parametri w, β, è possibile dato un nuovo vettore x∗ predire

• la massima verosimiglianza ha anche delle proprietà interessanti che permettono di

2.3 Regressione lineare

Segue che la loss function è la norma L2 :

Osservazione 1. Stiamo assumendo che y (i) = f (x(i) ) +  = f (x(i) , wT RU E ) + , dove 

La funzione costo è quindi della forma

Questo prodotto assomiglia alla matrice di covarianza. Spesso si fa feature scaling,

Output multipli e modello lineare generalizzato

dove φ0 (x) = 1, w0 = bias, φj bias function (ad esempio φj (x) = xj ). La differenza

2.4 Inferenza bayesiana e regolarizzazione

spazio di probabilità dati i dati) è

dove il denominatore P(D) è una funzione di partizione, ovvero una normalizzazione

L’altra differenza fondamentale è la presenza della prior: generalmente in machine lear-

oppure che siano ancora di più spinti verso il valore 0

MAP: maximum a posterior estimation

= argminJ (w) minimizziamo la loss function

gi grado alto. Conuesto regolarizzatore specifico, la regressione si chiama L2 o Ridge

wM AP = argminw log P(D|w) − log P(w),

wRIDGE = argmin||ŷ(w, x) − y||22 , w/|w||22 ≤ t.

wLASSO = argmin||ŷ − y||22 , w/|w||1 ≤ t.

Supponendo di avere soltanto due pesi, w1 e w2 , e un minimo di J in un punto del piano,

2.5 Decomposizione bias-variance

Supponendo di avere un modello ideale, ovvero un modello che conosce P(DATA).

Ponendo per semplicità di notazione Ex,y∼p,D∼pm = E, abbiamo che

E (hD (x) − y)2 = E ((hD − h̄(x)) + (h̄(x) − y))2

= E (hD − h̄)2 + E (h̄ − y)2 + 2E[(hd − h̄)(h̄ − y)].

Tuttavia notiamo che

E (h̄(x) − y)2 = E (h̄ − ȳ + ȳ − y)2 = E[h̄ − ȳ]2 + E[ȳ − y]2 .

Otteniamo quindi che il valore atteso dell’errore di generalizzazione con la bias-variance

dove i termini sono rispettivamente

• Variance: rappresenta la variabilità delle predizioni quando il training è fatto su

• Noise: è una proprietà intrinseca dei dati.

Regolarizzazione nella decomposizione bias-variance

Vediamo ora l’algoritmo di early stopping:

Algorithm 1 EARLY STOPPING

Rivisitazione moderna della decomposizione bias-variance

l’interpolazione infatti, il numero di modelli nell’hypothesis space che descrivono in modo

2.6 Classificazione: il percettrone

• definire le discriminant function: ad un x(i) associamo un ŷ (i) ∈ 0,1,

wt w∗ −→ (w + yx)t w∗ = wt w ∗ +yw∗t > wt w ∗ .

wt w → (w + yx)t (w + yx) = wt w + 2ywt x + yxt x,

• ∀D, m = 1: C(1, D) = 2 (prendendo w = x1 )

• D = 2: C(m, 2) = 2m (rotazione della retta che passa tutti i punti 2 volte)

Osservazione 1. Stiamo assumendo che y (i) = f (x(i) ) + = f (x(i) , wT RU E ) + , dove