Utilizzo delle reti neurali di tipo MLP e RBF per l`approssimazione di

Utilizzo delle reti neurali di tipo MLP e RBF per
l’approssimazione di funzioni reali di variabile reale note
mediante coppie di punti (x,y) in presenza di rumore
Davide Anastasia, Nicola Cogotti
27 dicembre 2005
Sommario
• x tr ed y tr sono i vettori con i punti da
approssimare appartenenti al training set,
x ts è il vettore contenente le osservazioni
del test set.
• y tr mlp e y ts mlp sono i valori approssimati ottenuti dalla rete MLP sul training
e sul test set, rispettivamente;
• y tr rbf e y ts rbf sono i valori approssimati ottenuti dalla rete RBF sul training
e sul test set, rispettivamente;
• k è il numero di neuroni (nascosti).
In molte applicazioni ingegneristiche capita frequentemente di disporre di una serie di osservazioni che caratterizzano un dato sistema fisico a
livello ingresso-uscita. Spesso si assume l’esistenza
di una relazione tempo-invariante R(x, y) che leghi la variabile di uscita y a quella di ingresso x.
In molti casi, poi, si assume che tale relazione sia
una funzione, ossia che esista una legge del tipo
y = f (x). Il problema da risolvere in questa esercitazione consiste nel progettare due tipi di approssimatori basati sue due tipologie diverse di reti neurali: Multi-Layer Perceptron (MLP) e Radiai
Basis Function (RBF), capaci di approssimare
le N coppie di valori reali (xi , yi ), i = 1..N .
Alla fine del testo è stata inclusa la parte relativa
alla esercitazione 3, la quale realizza una interfaccia grafica tale da poter utilizzare questo lavoro in
maniera intuitiva ed interattiva.
1
Inserire, oltre a quelli specificati, tutti i parametri che si ritengono necessari prevedendo
per ciascuno di essi un valore di default.
2. Realizzare una funzione che generi:
• N valori reali {xi }N
( i = 1), scelti in maniera casuale con distribuzione uniforme
all’interno dell’intervallo [a, b], con a, b ∈
R,
• i corrispondenti N valori reali {yi }( i =
1)N , con yi = f (xi )+L∗ei, dove la funzione f (·) è descritta da una stringa del tipo
’sin(x)/x’, ’x∗x+3∗x’, ecc., ed L∗ei rappresenta il rumore (in particolare, ei è un
valore reale generato a caso secondo una
distribuzione gaussiana con media zero e
varianza uno, ed L è l’ampiezza di tale
rumore).
Specifiche della soluzione
1. Realizzare due funzioni Matlab che provvedano, rispettivamente, a costruire, addestrare e
simulare la rete neurale MLP (con un solo strato nascosto) e la rete RBF. I prototipi delle due
funzioni sono i seguenti:
• [y tr mlp, y ts mlp] = fun appr mlp
(x tr, y tr, x ts, k, ...)
Il prototipo della funzione richiesta è il
seguente:
• [y tr rbf, y ts rbf] = fun appr rbf
(x tr, y ts, x ts, k, ...)
• [x,y] = datagenxy(function string,
N, a, b, L)
dove
1
3. Realizzare la seguente funzione di plot:
5. Confrontare la rete MLP realizzata con
un’equivalente rete MLP con due strati
nascosti.
• plotxy(x tr, y tr, x ts, y ts,
y tr mlp, y ts mlp, y tr rbf,
y ts rbf)
6. Confrontare le performance della rete MLP
(con un solo strato nascosto) e della rete RBF
sia al variare del numero di neuroni e del livello
di rumore, sia al variare di parametri specifici per le due reti, quali ad esempio il numero
di epoche, il goal, la funzione utilizzata per
l’addestramento, lo spread, ecc.
dove x tr, y tr, x ts, y ts, y tr mlp, y ts mlp,
y tr rbf, y ts rbf sono, rispettivamente, gli ingressi e le uscite desiderate contenute nel training set, gli ingressi e le uscite desiderate contenute nel test set, le uscite della rete MLP sul
training set, le uscite della rete MLP sul test
set, le uscite della rete RBF sul training set, le
uscite della rete RBF sul test set. La funzione
plotxy produce un grafico con 4 subplots:
7. (Opzionale) Dotare l’applicazione di una
interfaccia grafica.
(a) in alto a sinistra il grafico della coppia
(x tr, y tr) e quello della coppia (x tr,
y tr mlp)
2
2.1
(b) in alto a destra il grafico della coppia
(x ts, y ts) e quello della coppia (x ts,
y ts mlp)
Soluzione del problema
Generazione dei dati
Per prima cosa si è scelto di implementare la funzione datagenxy descritta al punto 2 delle specifiche
sopra riportate.
Di seguito viene riportato il codice Matlab usato:
(c) in basso a sinistra il grafico della coppia (x tr, y tr) e quello della coppia (x tr,
y tr rbf )
function [x,y] = datagenxy(function string, N, a, b, L)
(d) in alto a destra il grafico della coppia
(x ts,y ts) e quello della coppia (x ts,
y ts rbf )
Descrizione
funzione
dei
valori
di
ingresso
alla
4. Realizzare un funzione principale denominata
• N = il numero di valori random da generare;
main che provveda a chiamare tre volte la fun• a = l’estremo inferiore dei valori random;
zione datagenxy, per creare tre training set con
diversi livelli di rumore (da assente a ’medio’
• b = estremo superiore dei valori random;
ad ’alto’) ed una volta per creare un test set,
privo di rumore. Tale funzione deve provvede• L = ampiezza del rumore sui dati;
re anche ad addestrare entrambe le reti su tutti e tre i training set per tre volte, cambiando Descrizione dei valori di ritorno
ogni volta il numero di neuroni (passando da
• x = valori random;
’pochi’ a ’medi’ a ’molti’), ed a plottare i risultati. Discutere, a seconda del tipo di funzione
• y = valutazione di function string su x più il
da approssimare e del numero di punti dei trairumore;
ning set, quali possono essere valori sensati per
i termini ’pochi’, ’medi’, ecc...
Per generare i valori random x si è usata la funDiscutere la bontà delle approssimazioni zione di Matlab RANDOM. Essa genera numeri caottenute dalle due reti nei sei casi.
suali con la distribuzione che gli viene indicata (in
Suggerimento: Si può partire dall’approssima- questo caso, come richiesto dalle specifiche, si è usazione della funzione ’10 ∗ sin(x)’ nell’intervallo ta la distribuzione uniforme) su un intervallo [a, b].
[0,6.28], con livelli di rumore 0, 2 e 5, con un Il risultato della funzione è un vettore colonna di
training set di 20 coppie di punti ed utilizzando N elementi.
i seguenti numeri di neuroni: 5, 10 e 20.
x = random(’uniform’,a,b,N,1);
2
Viene valutata la funzione passata come parametro
su gli N valori casuali e si somma a questi ultimi
del rumore gaussiano con media zero, varianza 1 e
ampiezza L.
1. È in grado di offrire un addestramento molto
veloce (in termini temporali);
2. È particolarmente adatto nell’addestramento
di reti che hanno il compito di approssimare
funzioni;
y = (feval(function string, x)+L∗randn(N,1));
Realizzazione della rete neurale
MLP
3. È accurato quando la rete non è particolarmente grande;
Di seguito verrà illustrata la procedura con la quale
si è realizzata, addestrata e, infine, simulata la rete
di tipo MLP.
I difetti principali di questo algoritmo si posso riscontrare quando si è in presenza di reti particolarmente grandi (con un numero molto elevato di
pesi e neuroni), o quando si devono progettare reti
neurali impiegate nel riconoscimento di pattern.
Da quanto detto sopra, quindi, si è scelto di usare
trainlm come algoritmo di addestramento.
In fine si è simulata la rete usando la funzione
sim del Matlab
2.2
function [y tr mlp, y ts mlp] = fun appr mlp(x tr, y tr,
x ts, k)
Descrizione della funzione La funzione
fun appr mlp crea una rete di perceptron con k
neuroni nello stato nascosto e funzioni di learning
e training di default (Matlab da la possibilità di
specificare altri tipi di funzioni d’addestramento
e d’apprendimento passando alla newff i nuovi
valori come parametro). La rete è formata da
neuroni di tipo sigmoidi nello strato nascosto e da
neuroni di tipo lineari nello strato di uscita.
y ts mlp = sim(net, x ts);
2.3
Realizzazione della rete neurale
di tipo RBF
Illustriamo ora la realizzazione della funzione che
crea, addestra e simula la rete RBF.
Codice della funzione La rete è stata creata nel
seguente modo:
function [y tr rbf, y ts rbf] = fun appr rbf(x tr, y tr, x ts,
k)
net = newff(minmax(x tr), [k, 1], {’tansig’, ’purelin’});
Successivamente sono stati settati i parametri
riguardanti l’addestramento come di seguito:
Descrizione funzione La funzione deve creare
una rete neurale RBF con k neuroni nello strato
nascosto; per fare questo si usa la funzione newrb
di Matlab:
net.trainParam.epochs = 300;
Questa istruzione consente di determinare il numero di epoche per cui si desidera addestrare la rete.
Si è ritenuto che trecento epoche fossero sufficienti
alla rete per essere addestrata, considerando anche
il fatto che sui dati viene applicato del rumore.
net = newrb(x tr, y tr, 0.0, 1.0, k);
net = init(net);
Descrizione dei parametri della newrb
Questa istruzione consente di inizializzare la rete
con dei pesi iniziali che verranno adattati e cambiati
durante la fase di addestramento.
• x tr = matrice di ingresso alla rete;
• y tr = matrice delle sucite target della rete;
[net, tr, y tr mlp] = train(net, x tr, y tr);
In fine si è eseguita la funzione di addestramento train con l’algoritmo di addestramento di default che Matlab setta a trainlm. Questo algoritmo di addestramento risulta essere particolarmente
efficace per i seguenti motivi:
• goal = è la variabile che si usa per determinare
un criterio di stop all’addestramento;
• spread = questo parametro risulta essere cruciale per il buon funzionamento di una re3
• In basso a sinistra viene ripostato il grafico
relativo alla fase di addestramento della rete
RBF;
te RBF e merita dunque una attenzione
maggiore.1
• k = numero di neuroni nello strato nascosto.
• In basso a destra viene riportato il grafico
relativo alla fase di testing della rete RBF.
In fine si è usata la sim per la simulazione della
rete su due tipi di insieme di dati diversi, uno per
l’addestramento e uno per il test della funzione.
Quanto detto sopra è osservabile nell’immagine che
riportiamo di seguito per una maggiore chiarezza.
y tr rbf = sim(net, x tr);
y ts rbf = sim(net, x ts);
2.4
Realizzazione
plotxy
della
funzione
La seguente funzione ha lo scopo di realizzare un
grafico composto da quattro sottografici che mostrino i risultati delle reti RBF e MLP in base ai
dati.
La dichiarazione della funzione è:
function plotxy(x tr, y tr, x ts, y ts, y tr mlp, y ts mlp,
y tr rbf, y ts rbf)
Come si vede dal codice, la funzione prende in ingresso i dati di training e le uscite desiderate (rispettivamente x tr e y tr), i dati di test e le uscite
desiderate del test (rispettivamente x ts e y ts) e
infine le uscite fornite dalle reti MLP e RBF sia
dalla fase di addestramento sia dalla fase di test (rispettivamente y tr mp, y tr rbf, y ts mpl,
y ts rbf). Per ogni rete esegue il grafico dei risultati sia nella fase di testing sia in quella di
training.
I quattro grafici sono cosi organizzati:
Figura 1: Grafico generato dalla funzione plotxy
I + in blu si riferiscono agli ingressi e alle uscite desiderate nel training set (la parte sinistra del
grafico) più il disturbo dovuto al rumore introdotto, le o in rosso invece sono le risposte della rete.
La parte destra del grafico si riferisce alla fase di
test. È possibile vedere il codice della funzione nei
sorgenti allegati alla presente relazione.
2.5
• In alto a sinista si può vedere il grafico relativo
alla fase di training della rete MLP;
Realizzazione del main
La funzione main sostanzialmente non fa altro che
richiamare le funzioni precedentemete descritte va• In alto a destra viene riportato il grafico
riando il numero dei neuroni e l’intensità del rumorelativo alla fase di testing della rete MLP;
re applicato sui dati. Si sono dichiarati due vettori,
1 Più grande sarà lo spread (apertura in inglese) più ark ed L, che rispettivamente contengono il numemoniosa e precisa, in genere, sarà l’approsimazione della fun- ro di neuroni che si assegnano alla rete e il livello
zione da parte della rete. Tuttavia si ha che con uno spread
di rumore che si applica ai dati, come mostrato di
troppo grande sarà necessario un numero di neuroni molto
elevato perché la rete possa approssimare una funzione che seguito:
cambia velocemente. Un spread troppo piccolo significa che
saranno richiesti molti neuroni per aprossimare una funzione
regolare impedendo alla rete di generalizzare bene. La scelta
di questo parametro quindi è fondamentale per permettere
alla rete di funzionare bene e solitamente è richiesto un certo numero di prove per la determinazione dello spread che
è strettamente collegato alla complessità e alla varietà delle
situazioni che la rete dovrà affrontare;
k = [5, 10 ,20];
L = [0, 0.2 , 0.5];
Succesivamente girano due cicli for annidati: quello più esterno contiene l’indice i sull’array K (dei
neuroni), mentre quello più interno contiene l’indice
j sul rumore sulla array L (del rumore).
4
Viene quindi creata una rete inizialmente con 5
neuroni nello strato nascosto e viene addestrata e
testata per tutti i livelli di rumore presenti nell’array L; successivamente viene creata una nuova rete
con 10 neuroni nello strato nascosto e anche questa
viene addestrata e testata per tutti i livelli di rumore presenti nell’array L. In fine si crea un’ultima
rete con 20 neuroni nello strato nascosto che viene addestrata e testata su tutti i livelli di rumore
presenti nell’array L.
Per tutte le iterazioni viene chiamata la funzione
ploxy che produce il grafico relativo alla rete realizzata (si avranno quindi in totale 9 grafici che illustreranno le prestazioni delle reti nelle condizioni
di 5 neuroni per tutti i livelli di rumore, 10 neuroni
per tutti i livelli di rumore e, in fine, 20 neuroni per
tutti i livelli di rumore).
Di seguito viene riportato il codice illustrato
precedentemente.
i valori numerici dello scarto quadrativo medio per
entrambi le reti sia sul training che sul test set (poco significativo quest’ultimo per quanto riguarda la
rete RBF, ma comunque calcolato e visualizzato).
L’applicazione è stata realizzata servendosi dello strumento GUIDE per collocare i vari elementi
dell’interfaccia nella posizione desiderata della finestra. A questo punto è stato scritto un callback
associato all’evento di pressione del tasto presente nell’interfaccia: questo prende i parametri in ingresso, calcola il main dell’esercitazione 1 con questi
parametri e visualizza le uscite nella stessa finestra
sotto forma di grafici e campi di testo. In particolari, i grafici sono realizzati con due colori: in rosso
c’è l’andamento ideale, mentre in blu si può vedere
il risultato del training e della simulazione sul test
set. In basso nell’interfaccia appaiono anche i valori
di SSE.
Poiché la maggior parte del lavoro è stato realizzato attraverso uno strumento grafico semi automatico, mostriamo solo il codice relativo al callback,
che rappresenta di fatto l’unica parte realizzata da
noi.
%Codice della funzione main
k = [5, 10 ,20];
L = [0, 0.2 , 0.5];
for i = 1:3 % indice sui neuroni
for j = 1:3 % indice sul rumore
% Training set
[x tr, y tr] = datagenxy(’sin’, 500, 0, 6.28, L(j));
% Test set
[x ts, y ts] = datagenxy(’sin’, 50, 0, 6.28, 0);
% −−− Executes on button press in pb simulation plot.
function pb simulation plot Callback(hObject, eventdata,
handles)
% hObject handle to pb simulation plot (see GCBO)
% eventdata reserved − to be defined in a future version
of MATLAB
% handles structure with handles and user data (see
GUIDATA)
[y tr mlp, y ts mlp] = fun appr mlp(x tr’, y tr’,
x ts’, k(i));
[y tr rbf, y ts rbf] = fun appr rbf(x tr’, y tr’, x ts’,
k(i));
function string = get(handles.ed function string, ’String’);
sx = str2num(get(handles.ed estremo sx, ’String’));
dx = str2num(get(handles.ed estremo dx, ’String’));
N = str2num(get(handles.ed points, ’String’));
L = str2num(get(handles.ed noise, ’String’));
k = str2num(get(handles.ed neurons, ’String’));
plotxy(x tr, y tr, x ts, y ts, y tr mlp, y ts mlp,
y tr rbf, y ts rbf)
%figure;
end
end
%subplot(handles.axes1);
[mlp tr, mlp ts, rbf ts, rbf tr] = main(function string, sx,
dx,N, L, k);
3
Esercitazione 3: interfaccia
grafica
set(handles.sse
set(handles.sse
set(handles.sse
set(handles.sse
L’esercitazione 3 (di cui non riportiamo il testo) richiede di prendere familiarità con le interfacce grafiche e di realizzarne una per l’applicazione appena
descritta.
Si tratta di fatto di accettare una serie di parametri e di mostrare a video i grafici relativi all’andamento del training e del test set sia per la MLP
che per la RBF. Inoltre l’interfaccia mostra a video
5
mlp tr, ’String’, mlp tr);
mlp ts, ’String’, mlp ts);
rbf tr, ’String’, rbf tr);
rbf ts, ’String’, rbf ts);