Riassunto esame Fundamentals of machine learning, Prof. Seidenari Lorenzo, libro consigliato Recognition and Machine Learning, Bishop, Christopher M. Pattern

Regolarizzatore - Early stopping 2

() | | | | <

sotto il vincolo

Data Augmentation () () '() () '()

( ) ( )

= , ' = ,

Si ha un dataset e si ha che si può creare in cui è una

()

versione “aumentata” di , ad esempio su immagini di rappresentazioni di numeri scritti a

mano, ruotando leggermente di pochi gradi l’immagine riesco a creare da un singolo

() ()

esempio tanti altri esempi della stessa classe . E’ molto importante che la classe sia

invariante rispetto a quella specifica trasformazione applicata, e qui entra in gioco la

conoscenza specifica di dominio.

Dropout δ ∼

( θ )

Per ogni unità si ha un’unità aggiuntiva (anche sugli input ) che rende il

calcolo della rete: = ∑ δ +

()

Ciò che succede in pratica è che, ogni volta che presento un nuovo esempio alla rete

δ θ

campiono dei nuovi , che fanno si che con una certa probabilità la specifica unità

venga spenta o lasciata accesa.

Facendo in questo modo si crea un Ensemble di un numero esponenziale di reti. Attenzione:

non è esattamente un ensemble stile bagging o random forest, in quanto le reti diverse

create non votano in realtà, semplicemente creano varianti che eseguono il train con

qualche porzione delle unità che vengono spente.

Si può dimostrare che:

Ciò implica che la media aritmetica dei logits diventa la media geometrica delle probabilità.

δ

Vi è anche una versione estrema del dropout, in cui mettiamo a zero ogni tranne uno. A

quel punto la rete diventa un modello Naive Bayes, in quanto si ha una diretta relazione tra

la variabile accesa e la corrispondente classe. Il peso relativo a quell’input viene addestrato

singolarmente senza considerare tutti gli altri, quindi il modello diventa generativo. Limita

l’overfitting, ma non riesce ad addestrare bene, in quanto non rappresenta bene i dati. L’idea

da trarre da questo è che un giusto ammontare di dropout è buono per limitare l’overfitting

→ idealmente le variabili combinate con i pesi devono riuscire a classificare bene anche in

gruppi più piccoli e non necessariamente tutte insieme.

Batch Normalization:

idea: modificare la procedura di training e modificare leggermente l’architettura,

regolarizzazione ma leggermente diversa.

ricordare: standardizzazione o normalizzazione sono processi necessari da eseguire sugli

inputs, perché valori alti creano pesi che sono molto distanti dallo zero, che è dove

vorremmo stare specialmente all’inizio.

Idealmente vorremmo cercare che i valori interni alla rete siano sotto controllo anche

durante la computazione al crescere di per migliorare l’apprendimento dei pesi dei layer

più alti. Questo shift dei valori interni della rete viene chiamato Internal Covariate Shift.

L’idea potrebbe essere quella di standardizzare anche i valori interni alla fine dell’epoca su

minibatch di varie dimensioni (e.g. 32, 64 esempi).

Si introduce quindi un BatchNorm layer (anche il dropout in realtà viene visto come un layer,

(1) ()

...

è una lista di valori) che riceve degli inputs dove è la minibatch size e produce

(1) ()

... come suo output: (1) () (1) ()

{ } ( )

... = ...

γ,β

µ

In particolare si calcola che è la media sul batch:

()

1

µ = ∑

=1

e la deviazione standard sul batch: 2

( )

2 ()

1

σ = ∑ − µ

=1

e i vettori standardizzati: ()

() −µ

= 2

σ +ε

ε

dove è un termine che previene la divisione per zero.

()

A questo punto la quantità in output viene calcolata come:

()

()

= γ + β

γ β

dove e sono dei parametri aggiornati man mano dal GD. Idealmente, a seconda dei valori

che impara, il metodo può prevenire questa operazione o amplificarla, non è un’operazione

γ β

hard ma è resa soft dai parametri e introdotti. 2

µ σ

C’è un problema: in fase di predizione, non si ha a disposizione e , in quanto la

predizione sul test non deve dipendere da quale batch di destinazione è finito l’esempio

* *

µ σ

-esimo. Vengono quindi collezionati dei valori e ottenuti tramite accumulazione di

diverse medie e varianze durante la computazione, sull’intero dataset.

L’effetto finale è quello di “accelerazione”, ovvero consente di arrivare all’accuratezza finale

più velocemente, oltre a quello di normalizzazione.

Idealmente è più logico applicare la BatchNormalization prima dell’applicazione della ReLU,

in quanto si assume che durante la BN si abbia a che fare con valori distribuiti secondo

→

gaussiane, quindi lineari, e poi infine applicare l’operazione non-lineare ReLU.

Adversarial Learning

Idea: trovare una rete “nemica” che ha il compito di cercare di creare un dato “maligno” per

farlo classificare male alla rete che si vuole creare.

()

() ()

In e si ha che la prima immagine è , la seconda è una perturbazione applicata

dalla rete avversaria, la terza è l’immagine risultante dalla somma della prima e dalla

seconda immagine. Si ha che sulla terza immagine gli errori risultanti sono molto alti.

Il problema risulta trasformarsi in:

( ( ', ), )

()

( )

'∈ ,ε

ovvero prendiamo la perturbazione che massimizza la Loss e poi ci applichiamo la

minimizzazione, ottenendo la formula dell’adversarial learning:

∑ ( (

',

), )

()

( )

'∈ ,ε

| | − ' | | < ε

dove in particolare indica che la perturbazione deve avere un certo limite, in

() ()

quanto altrimenti l’esempio cambia anche classe . Devono essere piccole

trasformazioni che perturbano l’esempio, mirando alla robustezza della previsione da parte

della NN.

Convolutional Networks

Contesto: abbiamo ad esempio un’immagine di MNist, ovvero l’immagine di una digit 28x28

pixel (risultante 784 pixel totali), “spiattellati” in un array unico lungo 784 ottenuto tramite

l’operazione flatten, concatenando le righe.

E’ importante che le NN sono invarianti rispetto a trasformazioni tipo permutazioni dei nodi

()

di input (con corrispondenza sui pesi ) che alterano l’ordine dei valori di input .

Idea: ogni sistema di computer vision o reti che trattano immagini dovrebbero fare uso di

“campi recettivi”, che tentano in qualche modo di isolare il focus su una porzione di

immagine alla volta. Idealmente quindi anche la rete, permutando i pixel, non dovrebbe

riuscire a riconoscere nulla e classificare correttamente, perché dovrebbe essere in grado di

osservare porzioni di immagine allo stesso tempo per analizzare la correlazione dei pixel

→

limitrofi reti convoluzionali perché sfruttano i prodotti di convoluzione.

Prodotto di convoluzione:

si indica con il segnale = {

[ ], ∈ }

[ ] ∈ ℜ < 0 > [ ] = 0

con . Per e dove è la lunghezza dell’input, si ha che .

Il prodotto di convoluzione è dato quindi da

∞

[ ] = ∑ [ ' ] [ − ' ]

'=−∞

ν = ()

oppure secondo il reverse :

ν ∗ [ ] = ∑ ν [

' ] [ − ' ] = ∑

[

− ' + 1

] [

− ' ]

'=1 '=1

= − ' + 1

e ponendo :

ν ∗ [ ] = ∑ [ ] [ − − 1 +

]

=1

L’idea è quella di applicare sull’input un filtro a lunghezza finita

[ 1

]... [

] 0

diversi da

che sono anche i parametri (pesi) che le reti aggiustano.

Valid convolution:

⎡ ⎤

[ ] = ∑ [ ] + − − 1

⎣ ⎦

2

=1

⎡ ⎤

∈ − − 1,

valido solo per .

⎣ ⎦

2

“Same” = variante che considera anche un piccolo padding di zeri:

Altra idea di convoluzione:

Pooling:

ridurre la dimensionalità di una feature map (shape)

Vi sono diversi tipi: →

- avg. pooling fa la media delle feature vicine

→ →

- max pooling prende il valore massimo (comune nelle immagini) invarianza

traslazionale nelle immagini

Stride: alternativa al pooling per ridurre la dimensionalità.

Consiste nell’effettuare un’estrazione delle feature tramite maschera ma con un salto che

non è di 1, ma bensì per esempio saltando un numero di “pixel” pari allo stride scelto.

Recurrent Networks

Idea:

ogni stato si aggiorna secondo un’equazione ricorrente, che mi indica quanto

dell’informazione passata “mantengo” e quanto “prendo” di nuovo dall’input corrente:

ℎ[] = σ ( ℎ [ − 1 ] + [

] )

ℎ [ − 1 ] [ ]

dove rappresenta lo stato precedente e è l’input attuale.

σ

Per varie opzioni non vanno bene varie opzioni (identità e ReLU) ma preferibile usare

→

ℎ [ − 1, 1

]

sigmoidi ( perché i suoi valori sono limitati tra ).

Idea chiave di funzionamento:

↔

Backprop. through time Reverse Mode AD

Per calcolare la derivata della loss usiamo la chain rule:

∂ ∂ ∂ℎ[] ∂ℎ[]

= ∑

∂ ∂ℎ[] ∂ℎ[] ∂

≤

∂ℎ[] ∂ℎ[−1] ∂ℎ[−2] ∂ℎ[+1]

= ...

dove &pa