Reti Neurali

Anthony Giorgio

1 Il percettrone
Nel campo dell’apprendimento automatico, una rete neurale (in inglese Neural Net-
work, siglato NN) è un modello computazionale composto di ”neuroni” artificiali,
ispirato dalla semplificazione di una rete neurale biologica.
Il neurone artificiale è un classificatore1 che mappa un vettore x = (x1 , ..., xn ) ∈
Rn in un valore di output g(x). Il modello matematico del neurone richiede 3
elementi di base:
ˆ Un insieme di sinapsi o connessioni, ciascuna delle quali è rappresentata da un
peso (efficacia sinaptica)

ˆ Un sommatore che somma i segnali in input pesati dalle rispettive sinapsi,

producendo in output una combinazione lineare degli input

ˆ una funzione di attivazione per limitare l’ampiezza dell’output di un neurone.

Tipicamente per comodità l’ampiezza degli output è l’intervallo [0,1] o [-1,1].
Il modello neuronale include anche un valore soglia o bias che ha l’effetto, a
seconda della sua positività o negatività, di aumentare o diminuire l’input dato.
Siano w = (w1 , ..., wn ) ∈ Rn il vettore dei pesi e w0 ∈ R il valore soglia. L’output
del neurone si può porre:
n
X 
y(x, w) = g wi x i − w0 = g(wT x − w0 )
i=1

dove la funzione g è una opportuna funzione differenziabile detta funzione di

attivazione.

1
una mappatura da uno spazio discreto o continuo di features X a un insieme di etichette Y

1
 Identifichiamo 5 tipi di funzioni di attivazione base:
1) Threshold function o Heaviside function: ossia la funzione a gradini

1 se x ≥ 0
g(x) =
0 se x < 0

2) Funzione segno: ossia la funzione a gradini:


1 se x ≥ 0
g(x) = sgn(x) =
−1 se x < 0

3) Piecewise-linear function:



1 se x ≥ 12

g(x) = x se − 21 < x < 1
2


0 se x ≤ − 1

2

4) Sigmoid function: la più usata nella costruzione di reti neurali. È una

funzione strettamente crescente a valori in [0, 1]:

1
g(x) =
1 + e−x

5) Tangente iperbolica: utilizzata ampiamente come la sigmoide, ma a valori

in [−1, 1]:
g(x) = tanh(x)

Consideriamo la funzione segno come funzione di attivazione. L’aspetto rilevante

di questo modello di calcolo consiste nel fatto che i valori dei pesi e della soglia
possono essere determinati attraverso un processo di apprendimento a partire da un
insieme di addestramento:

T = {(xp , y p ); xp ∈ Rn , y p ∈ {−1, 1}, p = 1, ...P }

Tale insieme di addestramento è costituito da coppie di ingresso-uscita in cui all’in-

gresso xp viene associata la classificazione corretta y p . Il neurone addestrato usando
i campioni dell’insieme T può essere utilizzato successivamente per classificare nuovi
ingressi x non appartenenti a T . Si definisce cosı̀ uno strumento per il riconoscimento
automatico di configurazioni, denominato percettrone.
I campioni dell’insieme di addestramento saranno classificati in modo corretto

2
se i pesi w e la soglia w0 sono determinati in modo tale che risulti:

wT xp − w ≥ 0 se y p = 1
0
(1)
wT xp − w < 0 se y p = −1
0

Dal punto di vista geometrico ciò si può interpretare come la ricerca di un iperpiano
di separazione H = {x ∈ Rn ; wT x = w0 } che separi gli insiemi:

A = {xp ; (xp , y p ) ∈ T, y p = 1} B = {xp ; (xp , y p ) ∈ T, y p = −1}

L’esistenza di w,w0 che risolva il sistema può quindi essere assicurata se gli
insiemi A e B sono linearmente separabili. Si verifica che le condizioni (1) ammettono
soluzione se e solo se ammette soluzione il sistema

wT xp − w > 0 xp ∈ A
0
(2)
wT xp − w < 0 xp ∈ B
0

Quindi, aggiungendo un ingresso fittizio x0 = −1 e ridefinendo x e w come vettori a

n + 1 componenti, ossia ponendo x = (x0 , x1 , ..., xn )T e w = (w0 , w1 , ..., wn )T , ci si
può ricondurre a risolvere rispetto a w ∈ Rn+1 il sistema

wT xp > 0 xp ∈ A
(3)
wT xp < 0 xp ∈ B

in cui, senza perdita di generalità, si può supporre

kxp k = 1, p = 1, ...P

3
1.1 Algoritmo di Rosenblatt
L’algoritmo di Rosenblatt fornisce un algoritmo di addestramento di tipo incre-
mentale che consente la determinazione di w a partire da T :

Algoritmo di addestramento del Percettrone

Dati in input: (xp , y p ) p = 1, ..., P
Inizializzazione: w(0) = 0, k = 0, nclass = 0
while nclass < P do
For p = 1, ..., P do
If sgn(w(k)T xp ) = y p then
nclass=nclass+1
else
w(k + 1) = w(k) + y p xp
k=k+1
end if
p=p+1
End For
If nclass < P then nclass = 0
End While

Teorema 1.1. Se gli insiemi A e B sono linearmente separabili, l’algoritmo di

Rosenblatt determina in un numero finito di iterazioni un vettore di pesi w tale che
tutti i campioni del training set risultano classificati correttamente, ossia soddisfano:

y p = sgn(wT xp ) p = 1, ..., P

Dimostrazione. Supponiamo che esista un vettore w che soddisfi la (3) e supponiamo,

senza perdita di generalità che si kwk = 1. Supponiamo che l’algoritmo non termini.
Ne segue che, per ogni k fissato, esisterà almeno un campione xp (dipendente da k)
non classificato correttamente, per cui, in base all’algoritmo:

w(k + 1) = w(k) + y p xp

Effettuando il prodotto scalare di w(k + 1) per w si ottiene:

wT w(k + 1) = wT w(k) + y p wT xp ≥ wT w(k) + δ (5)

dove
δ = min{y p wT xp } = min{sgn(wT xp )wT xp } > 0
p p

Poichè la (5) vale per ogni k e w(0) = 0, ragionando per induzione e usando la

4
disuguaglianza di Schwarz:

kw(k + 1)k = kwkkw(k + 1)k ≥ wT w(k + 1) ≥ (k + 1)δ (6)

D’altra parte, tenendo conto del fatto che y p w(k)T xp ≤ 0 (poichè xp non è classificato
correttamente) e che ky p xp k = 1, si ha:

kw(k + 1)k2 = kw(k)k2 + 2y p w(k)T xp + ky p xp k2 ≤ kw(k)k2 + 1

Il che implica, per induzione:

kw(k + 1)k2 ≤ k + 1 (7)

Da (6) e (7) segue

√
2
k + 1 ≥ (k + 1)δ
1
ossia k ≤ δ2
− 1, il che contraddice l’ipotesi che l’algoritmo non termini.

Un classificatore basato sul neurone formale ha limitate possibilità di applicazio-

ne, in quanto esistono problemi di classificazione in cui gli insiemi di campioni non
sono linearmente separabili.

2 Reti multistrato
Le limitazioni del percettrone, ossia di reti costituite da un solo strato adattivo di
neuroni formali vengono superate da architetture costituite da più strati di neuro-
ni connessi in cascata, denominate reti multistrato. L’architettura di una rete
neurale multistrato può essere descritta definendo:

ˆ Strato di ingresso: un insieme di n nodi di ingresso, sprovvisti di capacità

di elaborazione, associati agli n ingressi della rete: xi ∈ R, i = 1, ..., n

ˆ Strati nascosti: un insieme di neuroni formali organizzati in L − 1 diversi

strati tra le unità neuronali di ingresso e quelle d’uscita

ˆ Strato di uscita: uno strato costituito da K ≥ 1 neuroni le cui uscite

costituiscono le uscite della rete yi ∈ R, i = 1, ..., K

ˆ Un insieme di archi orientati e pesati che rasppresentano le connessioni inter-

neuronali e le connessioni con i nodi di ingresso.

5
 Indicheremo con l = 1, ..., L gli indici associati ai vari strati. A ciascun arco
orientato entrante nel neurone j dello strato l e uscente dal neurone i dello strato
(l)
l − 1 oppure dal nodo di ingresso i, è associato un peso wji che rappresenta l’entità
della connessione sinaptica.
Ciascun neurone formale si suppone caratterizzato da una funzione di attivazione
(l)
gj : R → R che opera su una combinazione lineare pesata degli ingressi e di un
(l)
valore di soglia wj0 .
(l) (l)
Indicando con aj la somma pesata degli ingressi e della soglia e con zj l’uscita
del neurone, per il neurone j dello strato 1 si può scrivere:
n
(1) (1) (1) (1) (1) (1)
X
aj = wji xi − wj0 , zj = gj (aj ) (9)
i=1

e per il neurone j di uno strato l > 1:

(l−1)
NX
(l) (l) (l) (l) (l) (l)
aj = wji xi − wj0 , zj = gj (aj ) (10)
i=1

avendo indicato con N (l) il numero di neuroni dello strato l. In output si otterrà un
vettore y = (y1 , ..., yK )
Nello specifico, se consideriamo una rete a due strati con un solo strato nascosto
di N neuroni con funzione di attivazione g e uno strato d’uscita di K neuroni con
funzione di attivazione σ, si ottiene

N
X n
X  
(2) (1) (1) (2)
yk (x, W1 , W2 ) = σ wkj g wji xi + wj0 + wk0 (11)
j=1 i=1

dove tutti i pesi e i parametri soglia sono stati raggruppati in un opportune matrici
W1 (pesi e soglie tra lo strato di input e lo strato nascosto) e W2 (pesi e soglie tra
lo strato nascosto e lo strato di output). Come visto precedentemente, includendo

6
il parametro soglia nella sommatoria e definendo un input addizionale x0 = 1 si
ottiene:
N
X n
X 
(2) (1)
yk (x, W1 , W2 ) = σ wkj g wji xi (11)
j=0 i=0

3 Apprendimento della rete

Consideriamo il problema di determinare il vettore w ∈ Rm le cui componenti sono
pesi e soglie incogniti dei neuroni nei vari strati.
La scelta di tali parametri, per una architettura fissata, viene in genere effettuata
definendo un opportuno sottoinsieme dei dati disponibili

T = {(xp , y p ), xp ∈ Rn , y p ∈ RK , p = 1, ..., P }

che costituisce il training set e risolvendo successivamente un problema di ottimiz-

zazione del tipo:
P
X
minm E(w) = Ep (w)
w∈R
p=1

in cui Ep è il termine di errore relativo al p-esimo campione e misura la distanza

tra l’uscita desiderata y p e l’uscita y(xp , w) fornita dalla rete. La misura più usata
è l’errore quadratico:
1
Ep (w) = ky(xp , w) − y p k2
2
Nel seguito supponiamo che E sia una funzione continuamente differenziabile.
Tra gli algoritmi più noti per il calcolo dei pesi in una rete neurale vi è il metodo
iterativo noto come metodo di backpropagation, che è interpretabile come una
versione euristica del metodo del gradiente. Esistono due classi principali di metodi
iterativi per il calcolo dei pesi:

ˆ metodi batch in cui ad ogni passo i pesi vengono aggiornati utilizzando infor-
mazioni relative a tutti i campioni dell’insieme di addestramento T . Essi sono
riconducibili a metodi di ottimizzazione non vincolata per la minimizzazione
di E.

ˆ metodi on-line in cui ad ogni passo i pesi vengono aggiornati tenendo conto
soltanto di un singolo campione T .

3.1 Backpropagation error

La procedura di calcolo dei pesi mediante backpropagation (BP) viene utilizzata in
due versioni:

7
 ˆ BP batch, in cui i pesi vengono aggiornati dopo la presentazione di tutti i
campioni del training set T.

ˆ BP on-line, in cui i pesi vengono aggiornati in corrispondenza a ciascun cam-

pione di T.

La BP batch consiste nell’iterazione:

wk+1 = wk − η∇E(wk )

dove ∇E(wk ) è il gradiente di E nel vettore corrente wk e lo scalare η > 0 detto

learning rate definisce il passo lungo l’antigradiente.
La BP on-line consiste invece nel selezionare ad ogni passo un campione (xp(k) , y p(k) )
dell’insieme di addestramento e nell’aggiornare i pesi utilizzando soltanto il termine
∇Ep(k) del gradiente di E, ossia nel porre:

wk+1 = wk − η∇Ep(k) (wk )

Consideriamo una rete multistrato di tipo generico costituita da L strati, in cui

x ∈ Rn è il vettore di ingresso e y ∈ RK è il vettore di uscita e poniamo

(0) (L)
zi = xi , i = 1, ..., n zi = yi , i = 1, ..., K

Per semplificare le notazioni omettiamo gli indici relativi ai diversi strati. Sia wji
il peso di un arco entrante nel neurone j di uno strato. Utilizzando le regole di
derivazione di può porre:
∂Ep ∂Ep ∂aj
=
∂wji ∂aj ∂wji
Definendo
∂Ep
δj =
∂aj
X
e ricordando che aj = wjh zh , si ha:
h

∂Ep
= δ j zi
∂wji

Basta quindi calcolare zi , δj per ottenere la derivata rispetto a wji :

ˆ zi è l’uscita del neurone i o l’ingresso i-esimo del neurone dello strato successivo
e si determina, a partire allo strato di ingresso, applicando successivamente le
trasformazioni definite dalla rete (propagazione in avanti degli ingressi)

ˆ la quantità δj associata ad ogni neurone e denominata errore è calcolata in

modo diverso a seconda se:

8
 (a) il neurone appartiene allo strato d’uscita
(b) il neurone appartiene a uno strato nascosto

Nel caso (a), sia k l’indice di un neurone d’uscita. Si ha che yk = g(ak ) e quindi
si può scrivere
∂Ep ∂Ep
δk := = g 0 (ak )
∂ak ∂yk
∂Ep
essendo g 0 (ak ) la derivata della funzione di attivazione e ∂yk calcolabile analitica-
mente.
Nel caso (b), sia j l’indice di un neurone nascosto. Si ha:

∂Ep X ∂Ep ∂ak

δj = =
∂aj ∂ak ∂aj
k

dove la somma è estesa a tutti i neuroni (nascosti o d’uscita) che ricevono segnali
dal neurone j. (Ep dipende da aj solo attraverso la dipendenza da ak ).
Essendo ak = ... + wkj zj + ... = ... + wkj g(aj ) + ... si ha:

∂ak
= g 0 (aj )wkj
∂aj

e quindi si può scrivere

X
δj = g 0 (aj ) δk wkj
k

Ne segue che gli errori δj relativi ai neuroni di uno strato, si ottengono propagando
all’indietro lungo la rete gli errori relativi ai neuroni dello strato successivo, a partire
dallo strato d’uscita (retro-propagazione degli errori).
X
La tecnica di backpropagation consente di calcolare ∇E = ∇Ep con un costo
p
O(P × W ) dove W è il numero di parametri, P il numero di pattern.
La scelta del fattore di apprendimento η influenza molto il comportamento del-
l’algoritmo, infatti se scegliamo valori troppo piccoli, la convergenza sarà lenta,
mentre se scegliamo valori troppo grandi si rischia di avere una rete instabile con
comportamento oscillatorio. Un metodo semplice per incrementare il fattore di ap-
prendimento senza il rischio di rendere la rete instabile è quello di modificare la
regola di aggiornamento inserendo il momento:

wk+1 = wk − η∇E(wk ) + β(wk − wk−1 ) (caso batch)

wk+1 = wk − η∇Ep(k) (wk ) + β(wk − wk−1 ) (caso on − line)

dove β > 0 è uno scalare fissato.

9
3.2 Algoritmo di Backpropagation
(0) (0)
Dati input: (xp , y p ) ∈ Rn × RK . Poni zi = xpi , i = 1, ..., n e zn+1 = −1.

Propagazione in avanti dell’ingresso

For l = 1, ..., L

For j = 1, ..., N (l)

N (l−1)
X+1 (l) (l−1)
(l)
aj = wji zi
i=1
(l) (l)
zj = gj (aj )

End For
(l)
Poni zN (l) +1 = −1

End For

For i = 1, ..., K
(L)
poni ei = zi − yip

End For

Retro-propagazione dell’errore

For j = 1, ..., K
(L) (L)
δj = ej gj0 (aj )

For i = 1, ..., N (L−1) + 1

∂Ep (L) (L−1)
poni (L)
= δj zi
∂wji
End For

End For

For l = L − 1, ..., 1

For j = 1, ..., N (l)

(l+1)
NX
(l) (l) (l+1) (l+1)
δj = gj0 (aj ) δk wkj
k=1
For i = 1, ..., N (l−1) + 1
∂Ep (l) (l−1)
poni (l)
= δj zi
∂wji
End For

End For

End For

10
3.3 Criteri d’arresto
Non esistono criteri d’arresto ben definiti. Ne citiamo 3:

ˆ L’algoritmo di back-propagation può essere interrotto quando è nelle vicinanze

di un minimo locale, ovvero quando la norma euclidea del vettore gradiente è
inferiore di una soglia sufficientemente piccola.

ˆ L’algoritmo di back-propagation può essere interrotto quando la percentua-

le di variazione dell’errore quadratico medio tra due epoche consecutive è
sufficientemente piccola.

ˆ L’algoritmo di back-propagation può essere interrotto quando la capacità di

generalizzazione è adeguata.

4 Un esempio in Matlab: Rete neurale per il riconosci-

mento di cifre manoscritte
Si vuole creare in Matlab una rete neurale che riceve in input cifre manoscritte e
fornisce in output il numero rappresentato.
Si utilizza il MNIST database (Modified National Institute of Standards and
Technology database), una base di dati di cifre scritte a mano. Il MNIST database
contiene 60.000 immagini per il training della rete e 10.000 immagini per il test della
stessa. Tale database è fornito in formato .csv nel quale ogni immagine di 28x28
pixel è identificata mediante un vettore riga di 785 elementi:

ˆ L’etichetta, ossia il primo elemento della riga indica il numero rappresentato

nell’immagine.

ˆ L’immagine è definita dai 784 elementi successivi che indicano i valori dei
pixel che compongono l’immagine.

11
 Il seguente script effettua il train di una rete neurale con due strati nascosti dei
quali si può scegliere il numero di neuroni e uno strato di output di 10 neuroni.
Viene utilizzato l’algoritmo di backpropagation e la discesa stocastica del gradiente
con mini-batch, per aggiornare i valori dei pesi e delle soglie. Si tratta di una
variante ampiamente utilizzata che rappresenta un approccio intermedio tra la SGD
on-line e SGD batch. Essa prevede di calcolare il gradiente su un sottoinsieme di
elementi del dataset ad ogni iterazione, invece che su un singolo elemento. Ciò rende
l’evoluzione della funzione costo nel corso delle iterazioni meno rumorosa, in quanto
il gradiente ad ogni iterazione diventa la media di ogni mini-batch, risultando in un
effetto di smoothing, e riducendo il costo computazionale, consentendo una migliore
vettorizzazione del codice. La dimensione del mini-batch è scelta dall’utente. Il train
è effettuato su un numero di epoche a scelta. La funzione di attivazione per ogni
neurone è la sigmoide.
1 data = load ( ' m n i s t t r a i n . csv ' ) ;
2 e t i c h e t t e = d a t a ( : , 1 ) ; %s e p a r o n e i d a t i e t i c h e t t e e i m m a g i n i
3 y = zeros (10 ,60000) ;
4 f o r i = 1:60000
5 y ( e t i c h e t t e ( i ) +1 , i ) = 1 ; %S c r i v e 1 n e l l a p o s i z i o n e i n d i c a n t e i l numero c o r r e t t o
6 end
7 immagini = data ( : , 2 : 7 8 5 ) ;
8 i m m a g i n i = i m m a g i n i / 2 5 5 ; %r e n d o i l v a l o r e d e l p i x e l un numero t r a 0 e 1
9 i m m a g i n i = immagini ' ; %v e t t o r i d i i n p u t
10 hn1 = i n p u t ( ' I n s e r i s c i i l numero d i n e u r o n i n e l primo s t r a t o n a s c o s t o : ' ) ;
11 hn2 = i n p u t ( ' I n s e r i s c i i l numero d i n e u r o n i d e l s e c o n d o s t r a t o n a s c o s t o : ' ) ;
12 %I n i z i a l i z z a z i o n e d i p e s i e s o g l i e
13 w12 = randn ( hn1 , 7 8 4 ) * s q r t ( 2 / 7 8 4 ) ;
14 w23 = randn ( hn2 , hn1 ) * s q r t ( 2 / hn1 ) ;
15 w34 = randn ( 1 0 , hn2 ) * s q r t ( 2 / hn2 ) ;
16 b12 = randn ( hn1 , 1 ) ;
17 b23 = randn ( hn2 , 1 ) ;
18 b34 = randn ( 1 0 , 1 ) ;
19 %l e a r n i n g r a t e
20 e t a = i n p u t ( ' I n s e r i s c i L e a r n i n g Rate : ' ) ; %p r o v a 0 . 0 0 5
21 %numero d i e p o c h e p e r l ' a d d e s t r a m e n t o
22 e p o c h s = i n p u t ( ' I n s e r i s c i i l numero d i e p o c h e d ' ' a d d e s t r a m e n t o : ' ) ;
23 m = i n p u t ( ' I n s e r i s c i i l v a l o r e d e l mini−b a t c h : ' ) ; %p r o v a 10
24 %i n i z i a l i z z a z i o n e v e t t o r e p e r g r a f i c o d e l l ' andamento d e l l ' e r r o r e
25 g r a f i c o 1 = z e r o s ( epochs , 1 ) ;
26 %g r a d i e n t e s t o c a s t i c o con mini−b a t c h
27 f o r k = 1 : epochs
28
29 prove = 1 ;
30 %i n i z i a l i z z o l ' e r r o r e dell ' epoca
31 erroretot1 = 0;
32
33 for j = 1 : 6 0 0 0 0 /m
34 %I n i z i a l i z z a z i o n i d i v e t t o r i errore e gradienti
35 errore4 = zeros (10 ,1) ;
36 e r r o r e 3 = z e r o s ( hn2 , 1 ) ;
37 e r r o r e 2 = z e r o s ( hn1 , 1 ) ;
38 erroretot4 = zeros (10 ,1) ;
39 e r r o r e t o t 3 = z e r o s ( hn2 , 1 ) ;
40 e r r o r e t o t 2 = z e r o s ( hn1 , 1 ) ;
41 grad4 = z e r o s ( 1 0 , 1 ) ;
42 g r a d 3 = z e r o s ( hn2 , 1 ) ;
43 g r a d 2 = z e r o s ( hn1 , 1 ) ;
44 f o r i = p r o v e : p r o v e+m−1
45
46 %P r o p a g a z i o n e i n a v a n t i dell ' ingresso
47 z1 = immagini ( : , i ) ;
48 a2 = w12 * z 1 + b12 ;
49 z 2 = s i g m o i d ( a2 ) ;
50 a3 = w23 * z 2 + b23 ;
51 z 3 = s i g m o i d ( a3 ) ;

12
 52 a4 = w34 * z 3 + b34 ;
53 z 4 = s i g m o i d ( a4 ) ; %v e t t o r e di output
54
55 %b a c k p r o p a g a t i o n ( R e t r o p r o p a g a z i o n e d e l l ' e r r o r e )
56 e r r o r e 1 = ( norm ( z4−y ( : , i ) ) ˆ 2 ) / 2 ; %c a l c o l o l ' e r r o r e
57
58 e r r o r e 4 = ( z4−y ( : , i ) ) . * s i g m o i d g r a d ( a4 ) ;
59 e r r o r e 3 = ( w34 ' * e r r o r e 4 ) . * s i g m o i d g r a d ( a3 ) ;
60 e r r o r e 2 = ( w23 ' * e r r o r e 3 ) . * s i g m o i d g r a d ( a2 ) ;
61
62 e r r o r e t o t 1 = e r r o r e t o t 1 + e r r o r e 1 ; %sommo g l i errori
63
64 erroretot4 = erroretot4 + errore4 ;
65 erroretot3 = erroretot3 + errore3 ;
66 erroretot2 = erroretot2 + errore2 ;
67 g r a d 4 = g r a d 4 + e r r o r e 4 * z3 ' ;
68 g r a d 3 = g r a d 3 + e r r o r e 3 * z2 ' ;
69 g r a d 2 = g r a d 2 + e r r o r e 2 * z1 ' ;
70
71 end
72
73 %G r a d i e n t descent
74 w34 = w34 − eta * grad4 ;
75 w23 = w23 − eta * grad3 ;
76 w12 = w12 − eta * grad2 ;
77 b34 = b34 − eta * e r ro r e t ot4 ;
78 b23 = b23 − eta * e r ro r e t ot3 ;
79 b12 = b12 − eta * e r ro r e t ot2 ;
80
81 p r o v e = p r o v e + m;
82
83 end
84 f p r i n t f ( ' Epoca : ' ) ;
85 d i s p ( k ) %m o s t r o i l numero d i e p o c a
86
87 %S a l v o l ' e r r o r e p e r l a v i s u a l i z z a z i o n e grafica
88 grafico1 (k ,1) = erroretot1 ;
89
90 [ immagini , y ] = r i m e s c o l o ( immagini , y ) ; %r i m e s c o l o l ' ordine per l ' epoca successiva
91 end
92 d i s p ( ' Apprendimento c o m p l e t a t o ! ' )
93 k0 = l i n s p a c e ( 1 , e p o c h s , e p o c h s ) ;
94 %V i s u a l i z z a z i o n e g r a f i c a d e l l ' e r r o r e
95 p l o t ( k0 , g r a f i c o 1 , '−b ' )
96 %S a l v a t a g g i o p a r a m e t r i i n f i l e
97 s a v e ( ' w f o u r . mat ' , ' w34 ' ) ;
98 s a v e ( ' w t h r e e . mat ' , ' w23 ' ) ;
99 s a v e ( ' wtwo . mat ' , ' w12 ' ) ;
100 s a v e ( ' b f o u r . mat ' , ' b34 ' ) ;
101 s a v e ( ' b t h r e e . mat ' , ' b23 ' ) ;
102 s a v e ( ' btwo . mat ' , ' b12 ' ) ;

1 function f r = sigmoid ( x )
2 f = zeros ( length (x) ,1) ;
3 for i = 1: length (x)
4 f ( i ) = 1/(1+ exp(−x ( i ) ) ) ;
5 end
6 fr = f ;
7 end

1 function f r = sigmoid grad (x)

2 f = zeros ( length (x) ,1) ;
3 for i = 1: length (x)
4 f ( i ) = s i g m o i d ( x ( i ) ) * (1− s i g m o i d ( x ( i ) ) ) ;
5 end
6 fr = f ;
7 end

1 f u n c t i o n [ B , v ] = r i m e s c o l o (A, y )
2 c o l o n n e = s i z e (A, 2 ) ;
3 P = randperm ( c o l o n n e ) ;
4 B = A ( : , P) ;
5 v = y ( : , P) ;
6 end

13
 Se si testa la rete con 30 e 20 neuroni per gli strati nascosti, per 50 epoche con
mini-batch 10 e learning rate 0.005 si ottiene il seguente andamento dell’errore:

Il seguente script effettua il test della rete neurale

1 t e s t = load ( ' m n i s t t e s t . csv ' ) ;

2 e t i c h e t t e = t e s t ( : , 1 ) ; %e t i c h e t t e
3 y = zeros (10 ,10000) ;
4 f o r i = 1:10000
5 y ( e t i c h e t t e ( i ) +1 , i ) = 1 ;
6 end
7 immagini = t e s t ( : , 2 : 7 8 5 ) ;
8 immagini = immagini / 2 5 5 ;
9 i m m a g i n i = immagini ' ;
10 %c a r i c o i p e s i e l e s o g l i e d e l l a r e t e a d d e s t r a t a
11 we34 = m a t f i l e ( ' w f o u r . mat ' ) ;
12 w4 = we34 . w34 ;
13 we23 = m a t f i l e ( ' w t h r e e . mat ' ) ;
14 w3 = we23 . w23 ;
15 we12 = m a t f i l e ( ' wtwo . mat ' ) ;
16 w2 = we12 . w12 ;
17 b i 3 4 = m a t f i l e ( ' b f o u r . mat ' ) ;
18 b4 = b i 3 4 . b34 ;
19 b i 2 3 = m a t f i l e ( ' b t h r e e . mat ' ) ;
20 b3 = b i 2 3 . b23 ;
21 b i 1 2 = m a t f i l e ( ' btwo . mat ' ) ;
22 b2 = b i 1 2 . b12 ;
23 successo = 0;
24 n = 10000;
25 %t e s t o l a r e t e
26 for i = 1:n
27 o u t 2 = s i g m o i d ( w2 * i m m a g i n i ( : , i )+b2 ) ;
28 o u t 3 = s i g m o i d ( w3 * o u t 2+b3 ) ;
29 o u t = s i g m o i d ( w4 * o u t 3+b4 ) ;
30 big = 0;
31 num = 0 ;
32 for k = 1:10
33 i f o u t ( k ) > b i g %c e r c o i l v a l o r e t r a 0 e 1 p i ù g r a n d e
34 num = k −1; %l a ” p o s i z i o n e −1” i n d i c a c h e numero è
35 b i g = out ( k ) ;
36 end
37 end
38 %c a l c o l o i s u c c e s s i
39 i f e t i c h e t t e ( i ) == num
40 successo = successo + 1;
41 end

14
42 end
43 f p r i n t f ( ' Accuratezza : ' ) ;
44 f p r i n t f ( '%f ' , s u c c e s s o /n * 1 0 0 ) ;
45 disp ( ' %' ) ;

Utilizzando i parametri sopra indicati si ottiene nel test un’accuratezza del 96%.

Riferimenti bibliografici
[1] Christopher M. Bishop. Patteren Recognition and Machine Learning. Springer,
2006.

[2] L. Grippo, M. Sciandrone. Metodi di ottimizzazione per le reti neurali.

Università di Roma.

[3] Michael Nielsen. Neural Networks and Deep Learning.

[4] A. C. C. Coolen. A Beginner’s Guide to the Mathematics of Neural Networks.

Department of Mathematics, King’s College London

15