Reti neurali artificiali

• Il modello del Neurone

• Il modello connessionista

• Unitá a gradino

• Discesa del Gradiente

• Reti a piu’ strati

• Algoritmo di Backpropagation

• Rappresentazione dei livelli nascosti

• Esempio: riconoscimento di volti

• Argomenti avanzati

Riferimento: Machine Learning, c©Tom M. Mitchell, McGraw Hill, 1997

1

Il modello del neurone

L’elemento costituente una rete neurale e’ il neurone. Da un punto di vista biologico il neurone esegue leseguenti 4 operazioni:

1. Riceve dei dati da altre sorgenti;

2. combina questi dati;

3. effettua una operazione non-lineare sul risultato della combinazione;

4. da in output il risultato ottenuto.

2

Il modello connessionista

Esperimenti recenti hanno mostrato che il neurone biologico ha una struttura molto complessa.

• Il tempo di attivazione di un neurone é ˜ .001 secondi

• Il numero di neuroni si aggira intorno alle ˜ 1010 unitá

• Connessioni per neurone ˜ 104−5

• Tempo di riconoscimento di una scena ˜ .1 secondi

• La sequenza di neuroni attivati in 10−1 sec. non puó essere maggiore di 100 passi, data la velocitá diattivazione di un neurone

→ ci deve essere una parte di calcolo parallelo

Proprietá di una rete neurale artificiale (ANN’s):

• Svariate unitá simili ai neuroni

• Svariate connessioni pesate tra le unitá

• Processi distribuiti e paralleli

• Enfasi sull’aggiustamento automatico

3

Il modello connessionista...

L’unita’ di base di una rete neurale, il neurone artificiale, simula i quattro passi analizzati nella precedenteslide. Come dalla figura:

Sum

Transfer

Xn

Xk

X2

X1

W1

W2

Wk

Wn

Output

Gli inputs alla rete sono rappresentati dagli xi, ciascuno e’ moltiplicato da un peso che rappresenta ilvalore di connessione. Nel caso piu’ semplice:

I =∑

wixi V = f(i) il transfer

nel caso piu’ semplice abbiamo una unita’ (il perceptron) che ha diversi inputs xi e ciascuno di tali inputse’ moltiplicato per un valore di connessione. Nel caso piu’ semplice tali prodotti sono semplicementesommati e, quindi, passano attraverso una funzione di trasferimento per generare un risultato.

4

Il modello connessionista...

In generale, l’elaborazione di una unita’ di una rete neurale, ha due componenti fondamentali. La primacomponente e’ lineare ed e’ la funzione somma o di input. La seconda componente e’ in genere non-lineareed e’ detta funzione di trasferimento o di attivazione. Questa trasforma la somma pesata nell’output.I differenti modelli sono ottenuti utilizzando differenti funzioni somma e differenti funzioni diattivazione/trasferimento.

W0

W1

Wn

Funzionedi Somma

S

Max

Min

Media

And

Or

Funzionedi Trasferimento

Tangente H

Lineare

Sigmoid

Seno

............

Ciclo diApprendimento

.....

5

In quali applicazioni sono utili le reti neurali

• L’input, pur essendo discreto ha una dimensione estremamente vasta oppure ha valori reali (e.g.input da sensori)

• L’ Output puó avere valori reali

• L’ Output é un vettore di valori

• I dati contengono rumore

• La struttura/forma della funzione obiettivo é sconosciuta

• Non é significativa la comprensione del risultato

Esempi:

• Riconoscimento di fonemi [Waibel]

• Classificazione di immagini [Kanade, Baluja, Rowley]

• Predizioni finanziarie

6

Una nota applicazione: ALVINN guida a70mph sull’autostrada

Sharp Left

SharpRight

4 Hidden Units

30 Output Units

30x32 Sensor Input Retina

Straight Ahead

7

Perceptron

w1

w2

wn

w0

x1

x2

xn

x0=1

.

.

.Σ � �

Σ wi xin

i=0 1 if > 0

-1 otherwise{o = Σ wi xin

i=0

Il Perceptron e’ l’unita’ piu’ semplice, la sua funzione di trasferimento e’ una funzione a gradino - -treshold. La soglia ha una motivazione biologica: attivazione o inibizione del neurone. In genere persimulare la soglia si aggiunge un extra input x0 che ha valore 1 e, quindi, un extra peso w0. In questomodo l’apprendimento si limita all’aggiustamento dei pesi senza dovere considerare il valore di soglia e lafunzione diventa una funzione di segno.

o(x1, . . . , xn) =

{

1 se w0 + w1x1 + · · ·+ wnxn > 0−1 altrimenti

Qualche volta possiamo usare la piú semplice notazione:

o(~x) =

{

1 se ~w · ~x > 0−1 altrimenti

L’apprendimento del Perceptron consiste nello scegliere gli opportuni pesi w0, w1, . . . , wn,quindi lo spazio delle ipotesi H per il perceptron é l’insieme di tutti i valori reali wi ∈ R :

H = {~w | ~w ∈ Rn+1}

8

Superficie di decisione di un Perceptron

x1

x2+

+

--

+

-

x1

x2

(a) (b)

-

+ -

+

Si possono rappresentare delle funzioni abbastanza semplici:

• Che pesi rappresenta g(x1, x2) = AND(x1, x2)?

Per esempio, per l’AND a due ingressi si puo’ porre w0 = −0.8 e w1 = w2 = 0.5.Per l’OR a due ingressi, ponendo w1 = w2 = 0.5, si puó definire il peso che sostituisce la funzione sogliacome w0 = −0.3, osserviamo che abbiamo posto x0 = 1.

Ma le funzioni che non sono linearmente separabili non possono essere rappresentate con il Perceptron:

• e.g., lo XOR non é linearmente separabile.

• Per tali funzioni e’ necessario definire altri tipi di reti.

9

Regola di apprendimento del Perceptron

wi ← wi + ∆wi

dove∆wi = η(t− o)xi

Dove:

• t = c(~x) é il valore obiettivo

• o é l’output del perceptron

• η é una costante con valore minore di 1 (e.g., .1) chiamata learning rate

10

Regola di apprendimento del Perceptron

Si puó dimostrarre che converge

• Se i dati di addestramento 〈xi, f(xi)〉 definiscono funzioni linearmente separabili

• e η é sufficientemente piccola

Esempio Supponiamo che il Perceptron fornisca in output -1 mentre la funzione obiettivo e’ +1. E’necessario alterare i pesi di connessione per maggiorare il valore

~w~x

Se xi = 0.8, η = 0.1, t = 1, e o = −1 allora la regola di apprendimento sara’ aggiornata come segue:

∆wi = η(t− o)xi = 0.1(1− (−1))0.8 = 0.16

D’altro canto, se t = −1 e o = 1 allora i pesi associati con xi positivi dovranno essere decrementati.

11

Discesa del Gradiente

La regola di apprendimento del Perceptron converge solo in caso di funzioni linearmente separabili. Unaseconda regola che non soffre di tali limitazioni e’ la ∆-rule.La regola cerca nello spazio delle ipotesi utilizzando l’algoritmo gradient descent, un algoritmo che cerca iminimi locali.Consideriamo delle semplici unitá lineari, in cui fissiamo

o = w0 + w1x1 + · · ·+ wnxn

Vogliamo apprendere il wi che minimizza il quadrato dell’errore

E[~w] ≡1

2

∑

d∈D

(td − od)2

Dove D é l’insieme degli esempi di addestramento, td e’ la funzione obiettivo per gli esempi diaddestramento in D e od e’ l’output dell’unita’ lineare.

12

Discesa del Gradiente

Consideriamo lo spazio delle ipotesi, costituito dai pesi, e gli errori ad essi associati. Per esempio seabbiamo due pesi w0 e w1 lo spazio delle ipotesi e’ un piano e l’asse verticale indica l’errore associato. Lasuperficie dell’errore e’ quindi parabolica ed ha un unico minimo globale.

-1

0

1

2

-2-1

01

23

0

5

10

15

20

25

w0 w1

E[w

]

∇E[~w] ≡

[

∂E

∂w0,

∂E

∂w1, · · ·

∂E

∂wn

]

La ricerca basata sulla discesa del gradiente determina i vettori peso che minimizzano E. Come funziona:Ad ogni passo il vettore dei pesi e’ modificato nella direzione che produce la piu’ ripida

discesa del gradiente sulla superficie dell’errore.

Interpretato come un vettore il gradiente specifica la direzione che produce l’incremento piu’ ripido in E.Data la regola di apprendimento:

~w ← ~w + ∆~w

La modifica dei pesi e’ determinata da ∆~w:

∆~w = −η∇E[~w]

Scritta nella forma delle sue componenti, la ∆ diventa:

∆wi = −η∂E

∂wi

Quindi la discesa piu’ ripida e’ ottenuta alterando ciascuna componente wi di ~w in proporzione a∂E

∂wi.

13

Discesa del Gradiente

Per calcolare il gradiente abbiamo:

∂E

∂wi=

∂

∂wi

1

2

∑

d

(td − od)2

=1

2

∑

d

∂

∂wi(td − od)

2

=1

2

∑

d

2(td − od)∂

∂wi(td − od)

=∑

d

(td − od)∂

∂wi(td − ~w · ~xd)

∂E

∂wi=

∑

d

(td − od)(−xi,d)

Dove xid denota il singolo valore di input per l’esempio d ∈ D. Sostituendo nella precedente equazioneotteniamo:

∆wi = η∑

d∈D

(td − od) xid

14

Discesa del Gradiente per unitá lineari

L’algoritmo e’ il seguente:Considera un vettore di pesi iniziale

Applica l’unita’ lineare a tutti gli esempi di addestramento

Calcola ∆wi per ciascun peso wiAggiusta η se necessarioRipeti finche’ non convergi al minimo globale

Siccome la superficie dell’errore contiene un unico minimo globale, questo algoritmo e’ garantito diconvergere, indipendentemente dal fatto che la funzione sia linearmente separabile se un tasso diapprendimento sufficientemente piccolo e’ fornito.

15

Algoritmo completo di Discesa del Gradiente

Gradient-Descent(esempiDiAddestramento, η)

Ciascun esempio di addestramento e’ una coppia del tipo 〈~x, t〉, dove ~x é il vettore dei valori diinput e t e’ il valore atteso che dovrebbe avere l’output, una volta appresa la funzione. η é iltasso di apprendimento (e.g., .05).

• Inizializza ciascun wi con qualche valore casuale, minore di 1.

• Fintanto che non sono state raggiunte le condizioni di terminazionedo

– Inizializza ciascun ∆wi a zero.

– Per ciascun 〈~x, t〉 in esempiDiAddestramentodo

∗ Accetta in input l’istanza ~x all’unitá considerata e calcola l’output o

∗ Per ciascun peso wi, dell’unitá linearedo

∆wi ← ∆wi + η(t− o)xi

– Per ciascun peso wi, dell’unitá linearedo

wi ← wi + ∆wi

16

Discesa del gradiente incrementale (Stocas-tica)

Discesa del gradiente in Batch mode :Finché i valori di approssimazione non sono soddisfattido

1. Calcola il gradiente ∇ED [~w]

2. ~w ← ~w − η∇ED[~w]

Discesa del gradiente Incrementale puó approssimare il calcolo Batch se η é sufficientemente piccolo:Finché i valori di approssimazione non sono soddisfattido

• Per cisacun esempio di addestramento d in D

1. Calcola il gradiente ∇Ed[~w]

2. ~w ← ~w − η∇Ed[~w]

Dove:

ED [~w] ≡1

2

∑

d∈D

(td − od)2

Ed[~w] ≡1

2(td − od)

2

17

Osservazioni

Nel gradient descent standard (o in batch mode) l’errore e’ sommato su tutti gli esempi prima diaggiornare i pesi. Mentre nel gradiente stocastico i pesi sono aggiornati per ciascun esempio.

Vantaggi Nel batch mode il calcolo di ogni aggiornamento e’ piu’ complesso perche’ richiede tutti gli esempidi apprendimento. Tuttavia, in genere viene utilizzato con un passo di aggiornamento piu’ ampio (la η ).

In casi in cui ci sono diversi minimi locali rispetto a E(~w) il gradiente stocastico riesce ad evitare i minimilocali perche’ usa i vari ∇Ed(~w) per guidare la ricerca.

18

Sommario

Abbiamo considerato due regole

• La regola di apprendimento del Perceptron e la delta-regola.

• La regola di addestramento si applica quando c’e’ una funzione a gradino, la delta regola si basa sullacombinazione lineare degli input.

La differenza fra queste due regole si riflette sulle propriet´ di convergenza.La regola di apprendimento del Perceptron ha garanzia di successo, converge con certezza, se:

• Gli esempi di addestramento hanno funzioni linearmente separabili

• Il tasso di apprendimento η é sufficientemente piccolo

Quando una unitá lineare é in condizione di usare la discesa del gradiente, allora:

• Si ha la garanzia che l’aggiustamento dei pesi converge su ipotesi con un errore formulato con iminimi quadrati (convergenza asintotica, una dimostrazione e’ data in Hertz et al. 1991).

• Dato un valore per il tasso di apprendimento η sufficientemente piccolo

• Anche quando i dati di addestramento contengono del rumore

• Anche quando i dati di apprendimento non sono separabili da H

19

Reti a piu’ strati con unita’ sinusoidali

Esempio.

Il compito della rete consiste nel distinguere dei fonemi nel contesto di certi termini. Il segnale delle parolepronunciate e’ l’ input alla rete: due input ottenuti tramite l’analisi spettrale della parola pronunciata.

Ci sono 10 output che corrispondono ai dieci possibili suoni delle vocali. La rete predice l’output che havalore piu’alto. La funzione di trasferimento non e’ lineare.

F1 F2

head hid who’d hood... ...

20

Reti a piu’ strati con unita’ sinusoidali

A destra vediamo lo spazio di decisione rispetto ai due input F1 ed F2: quello che la rete ha appreso. Ipunti rappresentano la distribuzione secondo esempi di test.

(Haung e Lipmann 1988)

21

Unita’ sinusoidali

Una unita’ sinusoidale e’ come il perceptron, ma basata su una funzione di soglia differenziabile.

w1

w2

wn

w0

x1

x2

xn

x0 = 1

����

.

.

.Σ

net = Σ wi xii=0n

1

1 + e-neto = σ(net) =

σ(x) é la funzione sinusoidale1

1 + e−x

Una proprietá interessante e’ la seguente: dσ(x)dx

= σ(x)(1 − σ(x))

Possiamo derivare la regola di discesa del gradiente

• Una unitá sinusoidale

• reti Multistrati di unitá sinusoidali → Backpropagation

Osservazione L’output e’ tra 0 e 1 e cresce monotonicamente rispetto ai valori di input. Per questo e’ anchechiamata funzione di schiacciamento.

22

Calcolo del gradiente dell’errore per unaUnita’ sinusoidale

∂E

∂wi=

∂

∂wi

1

2

∑

d∈D

(td − od)2

=1

2

∑

d

∂

∂wi(td − od)

2

=1

2

∑

d

2(td − od)∂

∂wi(td − od)

=∑

d

(td − od)

(

−∂od∂wi

)

= −∑

d

(td − od)∂od

∂netd

∂netd∂wi

Siccome dσ(x)dx

= σ(x)(1− σ(x)), e od = σ(netd), otteniamo

∂od∂netd

=∂σ(netd)

∂netd= od(1− od)

E siccome netd = ~w · ~x

∂netd∂wi

=∂(~w · ~xd)

∂wi= xi,d

Quindi:

∂E

∂wi= −

∑

d∈D

(td − od)od(1− od)xi,d

23

Reti a piu’ strati

Considereremo sempre reti feed-forward acicliche.Tra queste tre casi:

• Reti con solo due strati di unita’ sinusoidali, dove le unita’ a ciascun livello sono connesse con tutte leunita’ del livello precedente.

• Reti uniformi come la precedente ma con profondita’ arbitraria.

• Reti non uniformi di profondita’ arbitraria.

24

Derivazione della regola di

Backpropagation

Vogliamo derivare la regola di discesa stocastica del gradiente: calcolo del gradiente per ciascun esempiodi addestramento d, il peso wji e’ aggiornato aggiungendogli ∆wji:

∆wji = −η∂Ed∂wji

Dove Ed e’ l’errore rispetto all’esempio d ottenuto da tutte le unita’ di output della rete:

Ed(~w) =1

2

∑

k∈outputs

(tk − ok)2

Dove outputs e’ l’insieme delle unita’ di output della rete, tk e’ l’output atteso dell’unita’ k per l’esempio diaddestramento d e ok e’ l’output effettivo dell’unita’ k.

Legenda

1. xji = l’i-esimo input dell’unita’ j

2. wji = il peso associato con l’i-esimo input dell’unita’ j

3. netj =∑

wjixji (la somma pesata degli inputs dell’unita’ j)

4. oj = l’output calcolato dall’unita’ j

5. tj = l’output atteso dell’unita’ j

6. σ la funzione di trasferimanto

7. outputs l’insieme delle unita’ di output o ultimo strato della rete

8. Downstream(j) l’insieme delle unita’ il cui input include l’output dell’unita’ j.

25

Ancora sulla derivazione della regola

Deriviamo ora∂Ed∂wji

Osserviamo che∂Ed∂wji

=∂Ed∂netj

∂netj∂wji

=∂Ed∂netj

xji

Siccome dobbiamo derivare ∂Ed∂netj

consideriamo due casi: j e’ una unita’ esterna, j e’ una unita’ nascosta.

26

Regola di addestramento per una

unita’ di output

∂Ed∂netj

=∂Ed∂oj

∂oj∂netj

(1)

Consideriamo il primo termine:∂Ed∂oj

=∂

∂oj

1

2

∑

k∈Outputs

(tk − ok)2

(2)

Ma ∂∂oj

(tk − ok)2 sara’ 0 per tutte le unita’ di output k eccetto quando k = j. Pertanto possiamo fare

cadere il segno di sommatoria sulle unita’ di output e mettere k = j. Quindi

∂Ed∂oj

=∂

∂oj

1

2(tj − oj)

2

=1

22(tj − oj)

∂(tj − oj)

∂oj(3)

= −(tj − oj) (4)

Se consideriamo il secondo termine , poiche’ oj = σ(netj) allora ∂oj/∂netj e’ la derivata della funzione ditrasferimento che e’ uguale a

σ(netj)(1− σ(netj))

Quindi:

∂oj∂netj

=∂σ(netj)

∂netj(5)

= oj(1− oj) (6)

Da cui per sostituzione otteniamo:

∂Ed∂netj

= −(tj − oj)oj(1− oj)

Da cui otteniamo la regola del gradiente per unita’ di output:

∆ wji = −η∂Ed∂wji

= η(tj − oj)oj(1− oj)xji

27

Derivazione della regola per le unita’

nascoste

Nel caso in cui j e’ una unita’ nascosta la regola deve tenere in conto il modo in cui l’unita’ j, e quindi ilpeso wji influenza l’output e, quindi Ed. Quindi considereremo tutte le unita’ a valle di j.

∂Ed∂netj

=∑

k∈Downstream(j)

∂Ed∂netk

∂netk∂netj

(7)

=∑

k∈Downstream(j)

−δk∂netk∂netj

(8)

=∑

k∈Downstream(j)

−δk∂netk∂oj

∂oj∂netj

(9)

=∑

k∈Downstream(j)

−δkwkj∂oj

∂netj(10)

=∑

k∈Downstream(j)

−δkwkjoj(1− oj) (11)

(12)

Quindi se poniamo − ∂Ed∂netj

= δj otteniamo:

δj = oj(1− oj)∑

k∈Downstream(j)

−δkwkj

e∆wji = ηδjxji

28

ALgoritmo Backpropagation

29

Backpropagation(training − examples, η, nin, nout, nhidden)

Ogni esempio di addestramento e’ una coppia 〈~x,~t〉 dove ~x e’ il vettore di valori di input della rete e ~t e’ ilvettore degli output attesi della rete.η e’ il tasso di apprendimento della rete.nin e’ il numero di input della rete, nhidden e’ il numero di unita’ nello strato nascosto, e nout e’ il numerodi unita’ di output.xji e’ l’input dall’unita’ i all’unita’ j e wji e’ il peso tra l’unita’ i e l’unita’ j.

• Crea una rete feed-forward a piu’ strati con nin ingressi, nhidden unita’ nascoste e nout unita’ dioutput.

• Inizializza tutti i pesi della rete con valori piccoli (e.g. tra -0.5 e 0.5).

• Finche’ le condizioni di terminazione non sono soddisfatte Do

– Per ogni esempio di addestramento 〈~x,~t〉 in training − examples, Do

Propaga l’input in avanti (forward) attraverso la rete

1. Input l’istanza ~x alla rete e calcola l’output ou per ciascuna unita’ u nella rete.

Propaga l’errore all’indietro attraverso la rete

2. Per ogni unita’ di output k calcola il suo errore δk:

δk ← ok(1− ok)(tk − ok)

3. Per ogni unita’ nascosta h, calcola il suo errore δh:

δh ← oh(1− oh)∑

k∈outputs

wh,kδk

4. Aggiorna tutti i pesi wi,j della rete

wi,j ← wi,j + ∆wi,j

dove

∆wi,j = ηδjxi,j

Questo algoritmo e’ per reti multistratificate, feed-forward, con due strati di unita’ di trasferimento. Doveciascuna unita’ in ciascun livello e’ connessa con tutte le altre unita’ che precedono.

30

Osservazioni sull’algoritmo

• Per ciascun esempio di addestramento, l’algoritmo calcola l’errore rispetto all’output della rete,calcola il gradiente rispetto all’errore relativo all’esempio corrente. Quindi aggiorna la rete. Questoprocesso puo’, per un singolo esempio, andare avanti anche migliaia di volte.

• Somiglianza con la delta-regola.

• Le unita’ nascoste non hanno un output, per cui il loro errore e’ calcolato rispetto alla somma deglioutput di quelle unita’ k – di output – che esse influenzano: moltiplicando il peso whk per ilrespettivo errore di k.

• L’algoritmo corrisponde alla approssimazione stocastica del gradiente visto prima. Per avere il verogradiente rispetto ad E bisognerebbe sommare i δj xji rispetto a tutti gli esempi.

• Il loop di aggiornamento dei pesi puo’ essere ripetuto migliaia di volte. Ci sono varie condizioni diterminazione. (Come abbiamo visto per arrivare alla completezza si rischial’overfitting/sovradattamento).

• Dopo l’apprendimento l’uso della rete e’ molto veloce.

31

More on Backpropagation

• Gradient descent over entire network weight vector

• Easily generalized to arbitrary directed graphs –prossima slide.

• Will find a local, not necessarily global error minimum

– In practice, often works well (can run multiple times)

• Often include weight momentum α

∆wi,j(n) = ηδjxi,j + α∆wi,j (n− 1)

L’aggiornamento dei pesi alla n-esima iterazione dipende parzialmente dall’aggiornamento fatto allan− 1-esima iterazione. Qui ∆w(i, j) e’ l’aggiornamento fatto all’n-esimo ciclo e α e’ un parametrocompreso fra 0 e 1 ed e’ chiamato il momento.

Esempio. Una palla che rotola sulla superficie dell’errore, la funzione del momento consiste nelmantenere la palla nella stessa direzione tra una iterazione e l’altra, ma anche continuare a farlarotolare sui minimi locali o zone piatte.

32

Generalizzazione a reti acicliche

Modifichiamo nell’algoritmo Backpropagation il calcolo dei δ come segue.Il valore δr per l’unita’ r al livello m e’ calcolato utilizzando i valori δ calcolati al livello m + 1 (stiamoprocedendo all’indietro):

δr = or(1− or)Σs∈layer(m+1)wsrδs

Nel caso, invece, in cui la rete e’ un garfo diretto aciclico ma gli strati non sono arrangiati in modouniforme, la regola per calcolare δ per ogni unita’ nascosta e’ la seguente:

δr = or (1− or) Σs∈Downstream(r)wsrδs

Dove Downstraem sono le unita’ nascoste che stanno a valle dell’unita’ r nella rete.

33

Learning Hidden Layer Representations

Inputs Outputs

A target function:

Input Output10000000 → 1000000001000000 → 0100000000100000 → 0010000000010000 → 0001000000001000 → 0000100000000100 → 0000010000000010 → 0000001000000001 → 00000001

Can this be learned??

34

Learning Hidden Layer Representations

A network:Inputs Outputs

Learned hidden layer representation:

Input Hidden OutputValues

10000000 → .89 .04 .08 → 1000000001000000 → .01 .11 .88 → 0100000000100000 → .01 .97 .27 → 0010000000010000 → .99 .97 .71 → 0001000000001000 → .03 .05 .02 → 0000100000000100 → .22 .99 .99 → 0000010000000010 → .80 .01 .98 → 0000001000000001 → .60 .94 .01 → 00000001

Possiamo vedere che la rete ha costruito approssimativamente una codifica di otto valori in forma binariatra 000 e 111.

1 0 00 1 10 1 01 1 10 0 00 0 11 0 11 1 0

35

Training

L’effetto della ricerca effettuata dal backpropagation. Sull’asse y abbiamo∑

(td − od)2 per una unita’ di

output. L’asse x indica il numero di iterazioni per il ciclo piu’ esterno dell’algoritmo.

0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

0 500 1000 1500 2000 2500

Sum of squared errors for each output unit

36

Training

Qui vediamo l’evoluzione delle unita’ nascoste. In particolare l’evoluzione delle unita’ per apprenderel’esempio 01000000.

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

0 500 1000 1500 2000 2500

Hidden unit encoding for input 01000000

37

Training

-5

-4

-3

-2

-1

0

1

2

3

4

0 500 1000 1500 2000 2500

Weights from inputs to one hidden unit

38

Convergence of Backpropagation

Gradient descent to some local minimum

• Perhaps not global minimum...

• Add momentum

• Stochastic gradient descent

• Train multiple nets with different inital weights

Nature of convergence

• Initialize weights near zero

• Therefore, initial networks near-linear

• Increasingly non-linear functions possible as training progresses

39

Expressive Capabilities of ANNs

Boolean functions:

• Every boolean function can be represented by network with single hidden layer

• but might require exponential (in number of inputs) hidden units

Continuous functions:

• Every bounded continuous function can be approximated with arbitrarily small error, by networkwith one hidden layer [Cybenko 1989; Hornik et al. 1989]

• Any function can be approximated to arbitrary accuracy by a network with two hidden layers[Cybenko 1988].

40

Overfitting in ANNs

Esempi di overfitting per due specifiche operazioni di percezione di un robot. In entrambi i casi l’erroredecresce monotonicamente quando la discesa del gradiente aggiorna i pesi. Come si vede decresce sull’insieme di validazione prima e poi tende ad aumentare di nuovo in virtu’ dell’overfitting sugli esempi diaddestramento. Non ci si deve arrestare troppo presto, quando l’insieme di validazione sta per aumentare.

0.002

0.003

0.004

0.005

0.006

0.007

0.008

0.009

0.01

0 5000 10000 15000 20000

Err

or

Number of weight updates

Error versus weight updates (example 1)

Training set errorValidation set error

41

Overfitting in ANNs

0

0.01

0.02

0.03

0.04

0.05

0.06

0.07

0.08

0 1000 2000 3000 4000 5000 6000

Err

or

Number of weight updates

Error versus weight updates (example 2)

Training set errorValidation set error

42

Neural Nets for Face Recognition

... ...

left strt rght up

30x32inputs

Typical input images

90% accurate learning head pose, and recognizing 1-of-20 faces

43

Learned Hidden Unit Weights

... ...

left strt rght up

30x32inputs

Learned Weights

Typical input images

http://www.cs.cmu.edu/∼tom/faces.html

44

Funzioni di errore alternative

L’algoritmo di backpropagation puo’ essere applicato, usando la discesa del gradiente, su qualunquefunzione di errore che sia differenziabile rispetto allo spazio delle ipotesi – parametrizzato. Cosi’ come variefunzioni sinusoidali possono essere usate nelle sigmoid units. Sono state fornite altre funzioni per E. Adesmpio penalizzare i pesi:

E(~w) ≡1

2

∑

d∈D

∑

k∈outputs

(tkd − okd)2 + γ

∑

i,j

w2ji

Questa funzione fa si che la discesa del gradiente preferisca vettori peso con grandezze inferiori, riducendoil rischio di overfitting. Ogni peso e’, infatti, moltiplicato per una costante (1− 2γη).

Mitchell e Thrun (1993) forniscono un metodo per calcolare certi valori durante l’addestramento, basatisulla conoscenza a priori dell’apprendista. In pratica viene aggiunto, al calcolo dell’errore, un termine chemisura la discrepanza fra la derivata calcolata durante l’apprendmento e quella che si ottiene assumendo lavariazione che si dovrebbe avere rispetto ad un determinato input.

E(~w) ≡1

2

∑

d∈D

∑

k∈outputs

(tkd − okd)2 + µ

∑

j∈inputs

(

∂tkd

∂xjd−

∂okd

∂xjd

)2

Ovvero ∂tkd∂x

j

d

e’ la cosidetta derivata di addestramento che describe come il valore di output tk,d dovrebbe

variare modificando l’input xjd.

45

Recurrent Networks

x(t) x(t) c(t)

x(t) c(t)

y(t)

b

y(t + 1)

Feedforward network Recurrent network

Recurrent network unfolded in time

y(t + 1)

y(t + 1)

y(t – 1)

x(t – 1) c(t – 1)

x(t – 2) c(t – 2)

(a) (b)

(c)

46