Roberto Prevete » 11.Back-Propagation

Introduzione

Nella presente Lezione dimostreremo la formula (∂Eⁿ /∂w_ji)=δ_j z_i e quelle per il calcolo dei δ_j.

Backpropagation: dimostrazione

Nell’ambito dell’algoritmo di discesa del gradiente abbiamo visto come è fondamentale calcolare le derivate della funzione di errore rispetto ai pesi.

Per fare ciò abbiamo introdotto le seguenti formule:
(∂Eⁿ /∂w_ji)=δ_j z_i dove δ_j=(∂ Eⁿ /∂a_j)

L’equazione ci dice che la deriva richiesta è ottenuto semplicemente moltiplicando il valore di output del nodo allo start della connessione associata al peso w_ji per il valore di δ del nodo alla fine della connessione associata al peso w_ji (cioè abbiamo una formula locale).

Backpropagation: dimostrazione (segue)

Più precisamente per il calcolo dei delta, abbiamo:

• Per le unità di output si ha:

δ_k=(∂ Eⁿ /∂a_k)= g’(a_k) (∂ Eⁿ /∂y_k)

• Per le restanti unità

δj=(∂ Eⁿ /∂a_j)=g’(a_j) ∑_kw_kj* ∂_k

Backpropagation: dimostrazione (segue)

Dimostriamo le equazioni precedenti.

La funzione di errore Eⁿ dipende da un peso w_ji solo attraverso l’input al nodo j, cioè aj.

Allora possiamo scrivere:
(∂Eⁿ /∂w_ji)=(∂ Eⁿ /∂a_j) (∂ a_j /∂w_ji)

Backpropagation: dimostrazione (segue)

Dimostriamo le equazioni precedenti.

Dato che a_j =∑_hw_jhz_h risulta ∂ a_j /∂w_ji)= z_i

Quindi (∂Eⁿ /∂w_ji)=(∂ Eⁿ /∂a_j) z_i

Ponendo allora δ_j=(∂ Eⁿ /∂a_j), si ottiene:

(∂Eⁿ /∂w_ji)=δ_j z_i

Backpropagation: dimostrazione (segue)

Dimostriamo le equazioni precedenti.

Restano da dimostrare le formule per i δ_j.

Per un generico nodo della rete, Eⁿ dipende da aj tramite gli a_k dei nodi che ricevono connessioni dal nodo j, cioè

Eⁿ /∂a_j=∑k(∂ Eⁿ /∂a_k ) (∂a_k /∂aj )

dato che

a_k =∑_hw_khz_h=∑_hw_khg_h(a_h)

si ha

∂a_k /∂a_j = w_kjg’_j(a_j)

Backpropagation: dimostrazione (segue)

Dimostriamo le equazioni precedenti.

Quindi

∂Eⁿ /∂a_j=∑_k(∂ Eⁿ /∂a_k ) w_kjg’_j(a_j)

∂Eⁿ /∂a_j = g’_j(a_j)∑_k w_kj (∂ Eⁿ /∂a_k )

e dato che per definizione δ_j =(∂ Eⁿ /∂a_j ), si ottiene

δj= g’j(aj)∑k wkjδk

dove l’indice k corre su i nodi che ricevono connessione dal nodo j.

Osservo che questa formula vale solo per i nodi interni di una rete neurale feed-forward

Backpropagation: dimostrazione (segue)

Dimostriamo le equazioni precedenti.

Per quanto riguarda i nodi di output, se consideriamo un generico nodo di output k dato che En=E(y1,y2, …,ym) e y_k= g_k(a_k) si ha

δ_k=(∂ Eⁿ /∂a_k)= (∂ Eⁿ /∂y_k) g’_k(a_k)

Osservo che questa formula vale solo per i nodi di output di una rete neurale feed-forward.

Backpropagation: Riassumendo

Ancora una volta, allora, riassumiamo che la back-propagation si può suddividere in quattro fasi:

• Applicare un vettore di input xⁿ alla rete provocando una propagazione in avanti (forward propagation)

• Valutare δk= (∂ Eⁿ /∂y_k) g’_k(a_k) per i nodi di output

• Valutare tutti gli altri delta utilizzando δ_j= g’_j(a_j)∑_k w_kjδ_k, cioè propagando all’indietro il valore dei δ.

• Valutare le derivate richieste, cioè (∂Eⁿ/∂w_ji)=δ_jz_i

Backpropagation: Un esempio

Supponiamo di avere:

Una rete neurale a due strati di pesi con funzione di output g₂ dei neuroni di output lineare e funzione di output g₁ dei neuroni interni non lineare

g₁ (x)=1/(1+exp(-x))

Funzione di errore somma dei quadrati:

E=(∑_n[y(xⁿ;w) - tⁿ]2)/2= ∑_nEⁿ

Backpropagation: Un esempio (segue)

Facciamo un esempio di applicazione della backpropagation

Per ciascuna coppia (xⁿ,tⁿ) inviamo in input xⁿ alla rete e calcoliamo tramite propagazione feed-forward il vettore di uscita yⁿ.

Come prima cosa, allora, dobbiamo calcolare i δ_k dei nodi di output, cioè

δ_k= g₂‘(a_k) (∂Eⁿ /∂y_k)

dato che, nel nostro caso, è

• g₂(x)=x lineare e quindi g₂‘(a_k)=1
• Eⁿ =1/2∑_k (yⁿ_k – tⁿ_k)² o più semplicemente En =1/2∑_k (y_k – t_k)², e quindi
• ∂Eⁿ /∂y_k=(y_k – t_k)

Si ottiene

δ_k=(y_k – t_k)

Backpropagation: Un esempio (segue)

Facciamo un esempio di applicazione della backpropagation

Mentre per i nodi interni si ha:

δ_j=(∂ Eⁿ /∂a_j)= g₁‘(a_j)∑_kw_kj* δ_k

Dato che g₁‘(x)=( 1/(1+exp(-x)) )’=( exp(-x))/ (1+exp(-x))²=
= ( 1+exp(-x))/ (1+exp(-x))²-1/(1+exp(-x))²=
= 1/(1+exp(-x)) -1/(1+exp(-x))2= g₁(x) – (g1(x))²= g₁(x)(1- g₁ (x))

si ottiene

δ_j= g₁(a_j)(1- g₁ (a_j))∑_kw_kj* δ_k

ricordando che, per definizione, zj=g1(aj) si ha:

δ_j= z_j(1- z_j)∑_kw_kj* δ_k

Backpropagation: Un esempio (segue)

Facciamo un esempio di applicazione della backpropagation

Allora le derivate della funzione di errore rispetto al secondo (e in questo caso ultimo) e al primo layer di pesi sono date, rispettivamente, da:

(∂ Eⁿ /∂w”_kj)=δ_k z_j=(y_k – t_k) z_j

(∂ Eⁿ /∂w’_ji)=δ_j x_i, con δ_j= z_j(1- z_j)∑_kw_kj* δ_k

Backpropagation: Un esempio (segue)

Facciamo un esempio di applicazione della backpropagation

E i pesi sono aggiornati in una dei seguenti due modi:

(on-line learning) w”_kj= w”_kj-η(y_k – t_k)z_j e w’_ji= w’_ji-ηδ_j x_i

(batch learning) w”_kj= w”_kj-η∑_n(yⁿ_k – tⁿ_k)zⁿ_j e w’_ji= w’_ji-η∑_nδⁿ_j xⁿ_i

Dove abbiamo indicato con w” i pesi del secondo strato e w’ i pesi del primo strato

On-line learning: Alcune osservazioni finali

Due osservazioni sono importanti:

La prima riguarda il fatto che per ora non abbiamo ancora parlato di validation set, ma l’algoritmo precedentemente visto dovrà essere modificato per sfruttare anche il validation set.

Nell’algoritmo mostrato c’e’ un ciclo esterno pari a MAX.
Ma come si determina questo valore? Vedremo che tale valore può essere legato proprio al validation set.

Ma di tutto questo, ne parleremo nella prossima lezione !