Progetto di Sistemi Intelligenti Progettazione creazione di un sistema di rilevazione di traiettorie in una curva Giacomo Migliorini, Mirko Nigi 20/06/2011 Questo documento contiene la relazione del progetto di Sistemi Intelligenti, nel quale è progettato e realizzato un sistema in grado di rilevare la bontà di una traiettoria di una macchina in una curva. Per lo scopo è stato utilizzato il noto strumento Matlab.
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Progetto di Sistemi Intelligenti
Progettazione creazione di un sistema di rilevazione di traiettorie in una curva
Giacomo Migliorini, Mirko Nigi
20/06/2011
Questo documento contiene la relazione del progetto di Sistemi Intelligenti, nel quale è progettato e realizzato un sistema in grado di rilevare la bontà di una traiettoria di una macchina in una curva. Per lo scopo è stato utilizzato il noto strumento Matlab.
Progetto di Sistemi Intelligenti
2
Progetto di Sistemi Intelligenti
3
SOMMARIO Specifica del problema .......................................................................................................................................................................... 4
Specifica della traiettoria ..................................................................................................................................................................... 6
Definizione dello strumento ............................................................................................................................................................... 8
Creazione del dataset ..................................................................................................................................................................... 10
Creazione della rete neurale ...................................................................................................................................................... 11
Fase di testing della rete neurale ............................................................................................................................................. 22
Creazione della logica fuzzy ....................................................................................................................................................... 24
Fase di testing del sistema fuzzy .............................................................................................................................................. 32
Script di Matlab ...................................................................................................................................................................................... 38
Indice delle figure ................................................................................................................................................................................. 50
Progetto di Sistemi Intelligenti
4
SPECIFICA DEL PROBLEMA
Il problema consiste nel realizzare uno strumento in grado di analizzare il comportamento di una
macchina che sta attraversando una curva.
Il problema specifica solamente che, all’interno della curva, è presente un certo numero di sensori, in
grado di poter rilevare la posizione della macchina, ma dà a noi il controllo sia sul tipo sia sulla
posizione degli stessi; inoltre non è stato specificato nessun attributo della curva, quindi, in prima
istanza, sono stati decisi i parametri della stessa, secondo considerazioni personali.
Per prima cosa è stato deciso che la macchina fosse rappresentata da un punto sul piano cartesiano, in
maniera tale da utilizzare nei nostri calcoli note formule; in seguito è stato deciso che il disegno della
curva fosse idealizzato in un arco di cerchio di angolo pari a .
A questo punto abbiamo deciso di piazzare i sensori della curva: come posizione è stato scelto il centro
della curva, con i sensori che “puntano” la curva, distanziati in intervalli regolari di angoli: questo
significa che, se abbiamo sensori che controllano la curva, essi saranno ruotati di un angolo pari a
;
ovviamente da aggiungere ai sensori interni ci sarà sia il sensore di entrata in curva (quindi con angolo
pari a ), sia il sensore di uscita di curva (quindi con angolo pari a ).
Infine sono stati decisi i parametri numerici secondo considerazioni personali:
Come angolo di curva è stato deciso un angolo di
radianti
Sono stati scelti venti (20) sensori (inclusi il sensore d’ingresso e il sensore di uscita).
È stato scelto come raggio interno della corsia una distanza dal centro pari a 20 metri.
È stata scelta come larghezza della corsia la dimensione di 5 metri.
Tutti i parametri sono riassumibili in Figura 1:
Progetto di Sistemi Intelligenti
5
Figura 1 - Struttura della strada.
Progetto di Sistemi Intelligenti
6
SPECIFICA DELLA TRAIETTORIA Definiamo ora il concetto di “traiettoria perfetta”. Dopo varie consultazioni è stato deciso che la
traiettoria perfetta fosse quella definita dal punto di entrata della macchina: ad ogni sensore la
macchina deve avere la stessa distanza dalla linea di mezzeria che aveva nel punto di entrata. Un
esempio, per capire meglio il significato di traiettoria perfetta, è dato in Figura 2:
Figura 2 - Definizione di curva perfetta.
Progetto di Sistemi Intelligenti
7
Ovviamente non potevamo solamente specificare una traiettoria perfetta o meno, quindi il modello è
stato perfezionato introducendo una fascia di tolleranza. Si suppone che a una traiettoria perfetta sia
assegnato un punteggio pari a uno (1), mentre a qualsiasi altra traiettoria è assegnata un valore
compreso tra zero (0) e uno (1); ogni qualvolta la macchina passa attraverso un sensore, al punteggio
massimo è tolta una quantità secondo il diagramma di Figura 3:
Figura 3 - Grafico per il calcolo del valore da togliere a ogni sensore.
Progetto di Sistemi Intelligenti
8
DEFINIZIONE DELLO STRUMENTO Per la creazione del sistema è stato utilizzato il software Matlab. Abbiamo per prima cosa definito la
struttura dei dati da passare al software. Al posto di utilizzare delle coordinate cardinali, definite da
una tupla di valori , abbiamo deciso invece di utilizzare un sistema a coordinate polari. Questa
semplificazione è stata possibile grazie alla scelta di utilizzare come modello di curva degli archi di
cerchio; quindi ogni punto rilevato dal sensore, idealizzando l’auto come un punto all’interno del
piano, è caratterizzato da una tupla di valori del tipo , dove rappresenta la distanza dal centro
del cerchio (e quindi della curva), mentre rappresenta l’angolo cui si trova il sensore, come si vede in
Figura 4:
Figura 4 - Rappresentazione polare della posizione.
Dato che ogni sensore è a una posizione prefissata, non è necessario, per ogni punto, specificare la
dimensione dell’angolo, visto che essa può essere semplicemente ricavata.
Progetto di Sistemi Intelligenti
9
Quindi ogni traiettoria sarà formata da un vettore di 20 (il numero di sensori) elementi, che
rappresentano le distanze dell’auto dal centro della curva per ogni sensore; a ogni elemento del
vettore è associato un angolo pari a
, dove rappresenta l’indice del vettore che rappresenta la
traiettoria. La rappresentazione del vettore è visibile in Figura 5:
Figura 5 - Vettore che rappresenta la traiettoria.
Per ogni traiettoria è stato calcolato il risultato finale tramite una funzione scritta in Matlab, la quale
prende in ingresso un vettore contenente i valori dei sensori e restituisce il coefficiente associato a
quella traiettoria. Il codice della funzione è riportato di seguito:
function risultato = result( a ) %Result Restituisce il coefficiente associato ad ogni traiettoria % Prende in ingresso un vettore contenente le distanze dal centro della % curva per ogni sensore e restituisce il coefficiente, che varia da 0 a % 1, associato ad ogni traiettoria risultato = 1; for i = 2:length(a) distanza = abs(a(1) - a(i)); if(distanza > 0.5) risultato = risultato - (1 / (length(a) - 1)); else risultato = risultato - ((1 / (length(a) - 1)) * distanza); end end end
Progetto di Sistemi Intelligenti
10
NEURAL NETWORK Come strumento è stato utilizzato il Neural Toolbox, incluso all’interno del sftware Matlab. Questo
toolbox permette di creare una rete neurale in grado di approssimare il riconoscimento della bontà
della traiettoria dell’auto all’interno della curva.
Per poter funzionare il toolbox ha bisogno di dati in ingresso, dei valori reali di uscita, e che siano
specificati alcuni parametri interni.
CREAZIONE DEL DATASET Per creare i dati d’ingresso, poiché la specifica del problema non li forniva, ci siamo affidati alla
creazione casuale effettuata da Matlab; abbiamo creato un semplice script in grado di fornire un
determinato numero di vettori casuali, i cui punti sono tutti interni alla curva, e il cui coefficiente di
uscita sia, circa, distribuito uniformemente all’interno dell’intervallo : questo è necessario per far
sì che la rete non si adatti troppo a certe zone dell’intervallo, e che riesca a riconoscere con buona
approssimazione qualunque tipo d’ingresso. Ogni vettore che è stato creato è stato inserito all’interno
di una matrice chiamata dataset, mentre i coefficienti sono stati salvati all’interno del vettore risultato.
Di seguito è riportato il codice utilizzato per la creazione della matrice e del vettore:
n_blocco) * rand(1)) - (0.2 * (tot_blocchi / n_blocco)); end if(dataset(riga, colonna) > 25) dataset(riga, colonna) = 25; end if(dataset(riga, colonna) < 20) dataset(riga, colonna) = 20; end end end risultato(colonna) = result(dataset(:,colonna)); end disp(colonna);, end end
Lo script prima divide la matrice finale in un determinato numero di blocchi, dopodiché crea
casualmente, con l’utilizzo della funzione rand, un vettore di valori in base al primo elemento (che è la
posizione di partenza della macchina in curva), e ne calcola il risultato; se il risultato è un coefficiente
Progetto di Sistemi Intelligenti
11
valido per quel blocco, lo salva, altrimenti procede di nuovo con la generazione di un nuovo vettore
casuale.
Dopo l’esecuzione di questo script, però, ci siamo accorti, tramite il comando max(risultato), che i
coefficienti restituiti per l’ultimo blocco erano tutti inferiori a quindi abbiamo provveduto a
inserire anche dei vettori che avessero un coefficiente tra e 1 tramite l’utilizzo di un secondo
CREAZIONE DELLA RETE NEURALE La creazione della rete è effettuata tramite il Neural Toolbox interno a Matlab, utilizzando il comando
nftool; utilizzando questo comando si apre la finestra come in Figura 6:
Progetto di Sistemi Intelligenti
12
Figura 6 - Schermata iniziale di nftool.
Cliccando su Next ci viene chiesto di dare in ingresso al tool il dataset dei dati da presentare alla rete e
il vettore contenente i risultati reali, così come in Figura 7
Progetto di Sistemi Intelligenti
13
Figura 7 - Schermata di nftool - Step 1
Al secondo step ci viene richiesto come dividere il dataset iniziale tra Training Set, Validation Set e
Testing Set: il primo serve ad addestrare la rete, e il suo valore di default, non modificabile, è pari al
70% degli elementi del dataset; il secondo serve a verificare la capacità di generalizzazione della rete
dopo l’addestramento, e il suo valore di default è pari al 15% degli elementi del dataset; il terzo è
l’insieme di elementi utilizzato per valutare le prestazioni della rete, e il suo valore di default è pari al
15% degli elementi del dataset. Noi abbiamo lasciato i valori di default che ci ha dato di Matlab, dato
che essi sono buoni nella quasi totalit{ dei casi d’uso, come in Figura 8
Progetto di Sistemi Intelligenti
14
Figura 8 –Schermata di nftool - Step 2
Al passaggio successivo ci viene richiesto il numero di neuroni presenti nello strato nascosto della rete
neurale: dopo diverse esecuzioni abbiamo trovato che il numero ideale di neuroni per lo stato
nascosto non è 10 (valore di default dato da Matlab), bensì 15; abbiamo quindi modificato il valore
della variabile come in Figura 9
Progetto di Sistemi Intelligenti
15
Figura 9 - Schermata di nftool - Step 3
In seguito si apre la schermata dove è possibile iniziare l’addestramento della rete, premendo il
pulsante Train; si apre quindi la finestra di Figura 10. Di default è utilizzato come metodo di
addestramento l’algoritmo di Levenberg-Marquardt e come indice di performance il Mean Squared
Error (Scarto Quadratico Medio). Dopo un po’ di tempo, necessario alla rete per l’addestramento, il
tool si blocca, come in Figura 10, permettendoci valutare i risultati della rete.
Progetto di Sistemi Intelligenti
16
Figura 10 - Schermati di nftool - Addestramento della rete
Cliccando sul pulsante Regression, possiamo valutare il grafico di regressione, utile a comprendere la
bontà della rete: solitamente, in letteratura, si prende come valore di riferimento, per decidere la
bontà di una rete neurale, 0.93. Come si vede da Figura 11, il valore restituito dal grafico di regressione
è all’incirca 0.97, che ci permette di affermare che la rete riconosce bene la quasi totalità dei casi.
Progetto di Sistemi Intelligenti
17
Figura 11 - Regression plot della rete neurale
Per valutare la bontà abbiamo anche analizzato alcuni altri grafici: tra questi abbiamo il grafico che
rappresenta l’istogramma degli errori, che si può vedere in Figura 12; in questo grafico possiamo
notare gli errori delle uscite della rete neurale rispetto ai risultati esatti. Come si può notare
l’istogramma ha un andamento simile a una funzione gaussiana, e la maggior parte degli errori rientra
nel range .
Progetto di Sistemi Intelligenti
18
Figura 12 - Error Instagram
Successivamente, andando avanti negli step del Neural Toolbox, ci viene chiesto se vogliamo salvare le
strutture dati create da Matlab e gli script per l’esecuzione della rete, chiudendo, in questo modo, il
Toolbox stesso.
Progetto di Sistemi Intelligenti
19
Un altro grafico che è stato creato è il plot degli errori: per crearlo è stato utilizzato il vettore error, che
viene creato dal Neural Toolbox, con il comando plot. Il risultato è visibile in Figura 13:
Figura 13 - Error plot
Come si nota, i maggiori errori sono localizzati nella parte inferiore del dataset, quindi, dato com’è
stato creato il dataset stesso, significa che gli errori maggiori tra risultato esatto e valore restituito
dalla rete neurale si trovano per quelle traiettorie che hanno risultato esatto piccolo (all’incirca .
Per la creazione della rete neurale, oltre all’utilizzo del toolbox integrato in Matlab, è possibile
specificare tutti i parametri della rete tramite linea di comando, in modo tale da avere un totale
controllo su di essi. Per completezza abbiamo provato a creare diverse reti, le quali si differenziavano
tra di loro per la tipologia di funzione di trasferimento dello strato di uscita.
In Figura 14 riportiamo il grafico del risultato della rete neurale usando come funzione di
trasferimento dello strato d’uscita la funzione tansig:
Progetto di Sistemi Intelligenti
20
Figura 14 - Grafico di regressione della rete neurale utilizzando come FdT di uscita tansig.
Per completezza riportiamo in Figura 15 anche il grafico di regressione della rete neurale, dove, in
questo caso, come funzione di trasferimento dello strato d’uscita abbiamo utilizzato la funzione logsig:
Progetto di Sistemi Intelligenti
21
Figura 15 - Grafico di regressione della rete neurale utilizzando come FdT di uscita logsig.
Ovviamente si evince dal grafico che il risultato è pessimo, e che quindi non è consigliabile utilizzare
come funzione di trasferimento la funzione logsig.
Progetto di Sistemi Intelligenti
22
FASE DI TESTING DELLA RETE NEURALE A questo punto si è verificato che la rete neurale si comportasse bene per altri tipi d’ingressi, in
maniera tale da verificare l’efficacia della rete stessa. Per il testing è stata utilizzata parte del codice
che abbiamo usato per la creazione del dataset: questa scelta è stata dettata dal fatto che, ovviamente,
per analizzare in maniera ottimale i risultati, i dati delle curve stesse devono essere “spalmati” su tutti
i possibili range di curve. Il codice, poiché simile al precedente, non è riportato, dato che l’unica cosa
che cambia è il numero di elementi, che in questo caso è pari a mille ( ).
Il dataset creato per il testing è stato quindi passato alla rete neurale tramite il comando
net(dataset_testing) per poi poterli confrontare con i dati reali. Questo confronto è stato eseguito
tramite l’analisi del diagramma di regressione, creato ad hoc tramite il comando
plotregression(risultato_reale, risultato_rete_neurale). Il grafico della retta di regressione è
visualizzabile in Figura 16:
Figura 16 - Retta di regressione del dataset di testing
Dal grafico della retta di regressione si possono analizzare varie cose:
Il risultato è accettabile, poiché il coefficiente di regressione è pari a
(come ricordato in precedenza, il valore di per il coefficiente di regressione è riconosciuto
come trade-off tra un buon risultato e un cattivo risultato)
La rete riconosce bene i valori sopra una certa soglia (stimabile nell’intorno di ) mentre
per valori minori restituisce risultati con un errore maggiore. Questo fatto probabilmente è
Progetto di Sistemi Intelligenti
23
dovuto all’utilizzo, per il percettrone di uscita della rete neurale, della funzione di
trasferimento purelin.
Per alcuni valori si può notare che è restituito, al posto di un valore compreso tra zero (0) e
uno (1), un valore negativo: anche questo comportamento è attribuibile all’utilizzo della
funzione di trasferimento purelin per il percettrone di uscita.
Progetto di Sistemi Intelligenti
24
FUZZY LOGIC Terminata la creazione del tool per l’analisi delle traiettorie tramite una rete neurale, si è iniziato lo
sviluppo di un medesimo tool, questa volta però tramite l’utilizzo di una logica fuzzy, la quale, in breve,
è una logica in cui si può attribuire a ciascuna proposizione un grado di verità compreso tra zero (0) e
uno (1).
Per la creazione del tool abbiamo utilizzato di nuovo lo strumento Matlab, specificatamente nel Fuzzy
Logic Toolbox. Esso ci permette di definire sia le variabili d’input, sia quelle di output, sia le regole
d’inferenza per la logica.
Ovviamente il nostro scopo è di creare uno strumento in grado di essere comparato con la rete
neurale, quindi sia la specifica del problema, sia il dataset utilizzato per il testing sono stati riutilizzati.
CREAZIONE DELLA LOGICA FUZZY Come detto, la creazione della logica fuzzy avviene tramite un tool grafico, richiamabile tramite la linea
di comando di Matlab con l’applicazione fuzzy; la finestra è visibile in Figura 17:
Figura 17 - Schermata iniziale del Fuzzy Logic Toolbox.
Come si può notare è possibile specificare le variabili d’input (nel riquadro giallo), le variabili di output
(nel riquadro verde), le regole d’inferenza (nel riquadro bianco) e i vari metodi del sistema (nella parte
in basso a sinistra della schermata).
Progetto di Sistemi Intelligenti
25
Per prima cosa è stato deciso di pre-processare il dataset di testing: questo è stato deciso perché,
avendo per ogni traiettoria venti (20) variabili d’input, se le avessimo lasciate tutte, avremmo avuto,
utilizzando tre (3) member function, regole d’inferenza.
Abbiamo quindi preso ogni vettore rappresentante una specifica traiettoria, e applicato alcuni semplici
passi:
1. Abbiamo trasformato ogni distanza dal centro in un offset (scostamento) dal punto d’ingresso
della macchina, in modo tale da avere un vettore risultante di lunghezza pari a diciannove (19)
elementi.
2. Ogni distanza, nel vettore appena generato, se maggiore di , è stata “tagliata” a 0.5; questa
scelta è dovuta all’utilizzo della funzione rappresentata in Figura 3: infatti, per noi, oltre il
valore di soglia di 0.5 metri, la traiettoria è considerata pessima.
3. Il vettore normalizzato è stato ulteriormente ridotto a quattro (4) elementi, secondo il
seguente criterio: si sono prese le medie aritmetiche dei gruppi di offset
e sono stati utilizzati come elementi del vettore finale.
A questo punto ogni traiettoria è stata trasformata da un vettore di venti (20) elementi a un vettore di
quattro (4) elementi. I passi precedenti sono esplicati in Figura 18:
Figura 18 - Passaggi per la creazione dei vettori per la logica fuzzy.
I passi sono stati quindi riportati in Matlab sotto forma di script, il cui codice è visibile qui sotto:
for colonna = 1:4400 for riga = 2:20 dataset_fuzzy(riga - 1, colonna) = abs(dataset(riga, colonna) - dataset(1,
colonna)); if(dataset_fuzzy(riga - 1, colonna) > 0.5) dataset_fuzzy(riga - 1, colonna) = 0.5; end end end
for colonna = 1:4400 somma = 0; for riga = 1:4 somma = somma + dataset_fuzzy(riga, colonna); end dataset_fuzzy2(1, colonna) = somma / 4;
somma = 0; for riga = 5:9
Progetto di Sistemi Intelligenti
26
somma = somma + dataset_fuzzy(riga, colonna); end dataset_fuzzy2(2, colonna) = somma / 5;
somma = 0; for riga = 10:14 somma = somma + dataset_fuzzy(riga, colonna); end dataset_fuzzy2(3, colonna) = somma / 5;
somma = 0; for riga = 15:19 somma = somma + dataset_fuzzy(riga, colonna); end dataset_fuzzy2(4, colonna) = somma / 5; end
Ovviamente si suppone che nel workspace sia presente il dataset di partenza, utilizzato nella fase dell
rete neurale.
Creato il dataset, il lavoro si è spostato sulla creazione della logica fuzzy.
Per prima cosa abbiamo specificato le variabili d’input del sistema fuzzy, definendo, per ognuna di
esse, tre (3) membership function: bad, good ed excellent. Abbiamo scelto queste tre membership
function perché questo tipo di divisione ci sembrava il più coerente e garantisce un adeguato livello di
accuratezza. Inoltre, come tipo di funzione, è stata scelta la funzione a triangolo trimf, poiché il criterio
scelto per la valutazione della perfezione della curva nella rete neurale era lineare, quindi abbiamo
deciso di mantenere la solita direzione.
La rappresentazione delle variabili d’ingresso al fuzzyficatore è mostrata in Figura 19:
Progetto di Sistemi Intelligenti
27
Figura 19 - Membership Function Editor per le variabili d’ingresso.
Ovviamente questa regola di fuzzificazione vale per tutte le variabili d’ingresso.
In uscita abbiamo invece una sola variabile, chiamata risultato, che, a differenza delle variabili di input,
ha delle diverse membership function: bad, notSoGood, good, veryGood ed excellent. Questo numero
maggiore di membership function è stato deciso per avere una maggior accuratezza del risultato del
sistema fuzzy. Anche qui è stata scelta come tipo di funzione la trimf per coerenza con quelle scelte per
le regole di fuzzificazione degli ingressi.
La rappresentazione della variabile di uscita dal defuzzificatore è mostrata in Figura 20:
Progetto di Sistemi Intelligenti
28
Figura 20 - Membership Function Editor per la variabile d’uscita.
Come si può notare il range di applicazione della variabile di uscita non è precisamente , ma
: questo perché, se non avessimo fatto questa scelta, sarebbe stato praticamente
impossibile avere come uscita valori prossimi agli estremi (0 e 1). Infatti, poiché abbiamo scelto come
metodo di defuzzyficazione il centroide (o centro di massa), se non allarghiamo leggermente gli
estremi della variabile di uscita, il centro di massa, fisiologicamente, si sposterà più verso il centro del
range, non permettendoci di avere una buona rilevazione dei punti all’estremit{ dell’intervallo.
A questo punto, scelte le membership function sia per le variabili d’ingresso che di uscita, abbiamo
lasciato tutte le altre impostazioni del sistema a valore di default, perché, secondo letteratura, sono
valide per la maggior parte dei sistemi fuzzy.
L’ultima cosa da fare è scrivere le regole. Basandoci su considerazioni personali, abbiamo stilato la
seguente lista di regole, basata sulle membership function sia d’ingresso sia d’uscita:
4 excellent excellent
3 excellent, 1 good very good
3 excellent, 1 bad good
2 excellent, 2 good very good
2 excellent, 2 bad not so good
2 excellent, 1 good ,1 bad good
1 excellent, 3 good very good
Progetto di Sistemi Intelligenti
29
1 excellent, 2 good, 1 bad good
1 excellent, 1 good, 2 bad not so good
1 excellent, 3 bad not so good
4 good good
3 good, 1 bad not so good
2 good, 2 bad bad
1 good, 3 bad bad
4 bad bad
In totale abbiamo quindi regole all’interno del nostro sistema, inserite tramite il Rule Editor,
come si può vedere in Figura 21:
Figura 21 - Rule Editor.
Matlab ci permette anche di visualizzare graficamente l varie regole cha abbiamo inserito all’interno
del sistema; la visualizzazione delle stesse è riportata in Figura 22, Figura 23 e Figura 24:
Progetto di Sistemi Intelligenti
30
Figura 22 - Rule Editor - Visualizzazione Grafica [1/3].
Figura 23 - Rule Editor - Visualizzazione Grafica [2/3].
Progetto di Sistemi Intelligenti
31
Figura 24 - Rule Editor - Visualizzazione Grafica [3/3].
E’ inoltre possibile utilizzare la Surface Viewer, mostrata in Figura 25, che ci permette di vedere
graficamente il comportamento del sistema:
Figura 25 - Surface Viewer.
Dato che il grafico è in 3D, possiamo vedere solamente la superficie generata da due variabili
d’ingresso e come loro plasmano la variabile di uscita finale.
Progetto di Sistemi Intelligenti
32
FASE DI TESTING DEL SISTEMA FUZZY Creato il sistema fuzzy, non ci resta che testare il tutto e di valutare i risultati sia rispetto ai risultati
reali, sia rispetto ai risultati restituiti dalla rete neurale.
Per testare il sistema fuzzy, supponendo di averlo gi caricato nel workspace di Matlab, basta eseguire il
comando evalfis(dataset_fuzzy, sistema_fuzzy), il quale ritorna una struttura dati contenente il risultato
ottenuto dall’esecuzione del sistema_fuzzy, con variabile di ingresso dataset_fuzzy.
Per testare la bontà del sistema fuzzy, così come nel caso della rete neurale ci siamo serviti del grafico
di regressione: per prima abbiamo valutato la bontà del sistema utilizzando come dataset di partenza
quello utilizzato in fase di addestramento della rete neurale; il grafico di regressione è visibile in
Figura 26:
Figura 26 - Grafico di regressione del sistema fuzzy sul dataset di addestramento della rete neurale.
Poi abbiamo anche testato il sistema sul dataset di testing, utilizzato per testare la bontà della rete
neurale; il grafico di regressione di quest’ultimo è mostrato in Figura 27:
Progetto di Sistemi Intelligenti
33
Figura 27 - Grafico di regressione del sistema fuzzy sul dataset di testing della rete neurale.
Come si può notare dai due (2) grafici di Figura 26 e Figura 27, il sistema fuzzy riconosce abbastanza
bene le traiettorie, poiché il valore dei due grafici di regressione è rispettivamente
e , ma applica a tutte un offset negativo pari a circa . Questo
probabilmente è causato da un a schiacciamento verso il basso (quindi verso il valore bad) delle regole
lessicali del sistema, come si evince da Figura 28:
Progetto di Sistemi Intelligenti
34
Figura 28 - Istogramma delle regole lessicali del sistema fuzzy.
Si può notare anche che i valori agli estremi dell’intervallo vengono riconosciuti, data l’accortezza di
allargare il range della variabile di uscita, di cui abbiamo parlato in precedenza. Per completezza
riportiamo in Figura 29 e Figura 30 i grafici di regressione ottenuti dal medesimo sistema, ma
utilizzando per la variabile di uscita il range :
Progetto di Sistemi Intelligenti
35
Figura 29 - Grafico di regressione del sistema fuzzy sul dataset di addestramento della rete neurale e range [0; 1].
Progetto di Sistemi Intelligenti
36
Figura 30 - Grafico di regressione del sistema fuzzy sul dataset di testing della rete neurale e range [0; 1].
Come si può notare da Figura 29 e Figura 30, il sistema, non utilizzando un range allargato, crea nel
grafico un “buco” relativamente ai valori agli estremi dell’intervallo di esistenza della variabile di
uscita. Nonostante i risultati migliori, questa mancanza non ci ha reso soddisfatti e quindi, confortati
dall’ottimo risultato raggiunto usando un range allargato, abbiamo deciso di scartare questa variante
di rete fuzzy.
Progetto di Sistemi Intelligenti
37
CONCLUSIONI Dopo aver creato il sistema di risoluzione della bontà delle curve, possiamo trarre le nostre
conclusioni.
Come si nota dai risultati sperimentali, il sistema che riproduce più fedelmente il comportamento da
noi aspettato è la rete neurale: questo si evince dai risultati numerici (un più alto valore dell’indice di
regressione sia per il dataset di addestramento che per il dataset di testing).
Ovviamente anche il sistema creato con l logica fuzzy fa il suo lavoro, ma, a causa dello spostamento
verso valori linguistici delle regole, i risultati sono leggermente inferiori rispetto a quelli ottenuti dalla
rete neurale, la quale, come sappiamo, si basa, per il proprio addestramento, su valori reali.
Probabilmente una miglior distribuzione delle regole nel sistema fuzzy avrebbe portato ad avere
risultati migliori di quelli ottenuti, ma, per motivi di tempo e di esperienza (quelle regole ci sono
sembrate le migliori) non lo abbiamo fatto.
Un altro discorso invece può essere fatto per la rete neurale: come abbiamo notato, la rete neurale
dava risultati migliori per coefficienti (quindi risultato della rete) compresi tra 0 e 0.5 utilizzando
come funzione di trasferimento dello strato di uscita la funzione tansig, mentre se si utilizza come
funzione di trasferimento dello strato di uscita la funzione purelin, si hanno risultati migliori per quei
coefficienti compresi tra 0.5 e 1. Questo è un risultato normale (ce ne sono vari esempi in letteratura),
quindi una soluzione ancora migliore della nostra (abbiamo utilizzato per la rete la funzione purelin)
sarebbe stata quella di utilizzare due (2) reti neurali, una con funzione di trasferimento per lo strato di
uscita tansig e una con funzione purelin, precedute entrambe da un decisore. Questo decisore avrebbe
avuto il seguente ruolo: dato un ingresso, avrebbe valutato, approssimativamente, in quale intervallo
( o ) il risultato sarebbe caduto, e, in base alla risposta, avrebbe utilizzato l’una o l’altra
rete neurale, in maniera tale da avere un risultato globale probabilmente migliore di quello ottenuto
utilizzando una sola rete neurale.
L’implementazione di tale sistema è fuori dalla nostra portata e non è di nostro interesse, però può
fornire uno incipit per futuri progetti simili.
Progetto di Sistemi Intelligenti
38
SCRIPT DI MATLAB
NEURAL_NETWORK.M %% Progetto di Sistemi Intelligenti % Questo è lo script Matlab utilizzato per la realizzazione del progetto di % Sistemi Intelligenti. % Questo sistema permette di verificare la "bontà" della traiettoria di una % macchina che esegue uno specificato tipo di curva. %% Inserimento dei valori di struttura della curva % Questa parte dello script permette di inserire i dati strutturali della % curva
n_elementi = input('Inserisci il numero di elementi: '); n_sensori = input('Inserisci il numero di sensori (inclusi i sensori di entrata
e di uscita: '); raggio_min_curva = input('Inserisci la distanza dal centro del raggio minore
della curva: '); ampiezza_strada = input('Inserisci la larghezza della corsia: '); phi = input('Inserisci l"angolo della curva: '); %% Creazione del dataset % Questa sezione di codice permette di creare il dataset che verrà dato in % ingresso alla rete neurale
n_blocco) * rand(1)) - (0.2 * (tot_blocchi / n_blocco)); end if(dataset(riga, colonna) > 25) dataset(riga, colonna) = 25; end if(dataset(riga, colonna) < 20) dataset(riga, colonna) = 20; end end end risultato(colonna) = result(dataset(:,colonna)); end disp(colonna); end end %% Disegno delle traiettorie % Questa parte di codice serve a disegnare le traiettorie e la curva per % verificare che ogni elemento del dataset sia un punto interno alla curva
plot(a, b, 'red'); hold on; plot(c, d, 'red'); %% Rete neurale % Questa parte di codice, generata automaticamente da Matlab, serve per % l'esecuzione della rete neurale, partendo dal dateset creato nella % sezione precedente. La rete è stata modificata per adattarsi meglio ai % nostri scopi, modificando il numero di neuroni dello strato nascosto dal % valore 10 di default a 15, e modificando la funzione di trasferimento % dello strato di uscita da <matlab:doc('purelin') purelin> a % <matlab:doc('tansig') tansig>.
% Solve an Input-Output Fitting problem with a Neural Network % Script generated by NFTOOL % Created Thu May 05 11:25:11 CEST 2011 % % This script assumes these variables are defined: % % dataset - input data. % risultato - target data.
inputs = dataset; targets = risultato;
% Create a Fitting Network hiddenLayerSize = 15; net = fitnet(hiddenLayerSize); net.layers{1}.transferFcn = 'tansig'; net.layers{2}.transferFcn = 'tansig';
% Choose Input and Output Pre/Post-Processing Functions % For a list of all processing functions type: help nnprocess % net.inputs{1}.processFcns = {'removeconstantrows','mapminmax'}; % net.outputs{2}.processFcns = {'removeconstantrows','mapminmax'};
% Setup Division of Data for Training, Validation, Testing % For a list of all data division functions type: help nndivide net.divideFcn = 'dividerand'; % Divide data randomly net.divideMode = 'sample'; % Divide up every sample net.divideParam.trainRatio = 70/100; net.divideParam.valRatio = 15/100; net.divideParam.testRatio = 15/100;
% For help on training function 'trainlm' type: help trainlm % For a list of all training functions type: help nntrain net.trainFcn = 'trainlm'; % Levenberg-Marquardt
% Choose a Performance Function % For a list of all performance functions type: help nnperformance net.performFcn = 'mse'; % Mean squared error
% Choose Derivative Function % net.derivFcn = 'fpderiv';
% Choose Plot Functions % For a list of all plot functions type: help nnplot net.plotFcns = {'plotperform','plottrainstate','ploterrhist', 'plotregression',
'plotfit'};
% Train the Network [net,tr] = train(net,inputs,targets);
% Test the Network outputs = net(inputs); errors = gsubtract(targets,outputs); performance = perform(net,targets,outputs);
n_blocco) * rand(1)) - (0.2 * (tot_blocchi / n_blocco)); end if(dataset(riga, colonna) > 25) dataset(riga, colonna) = 25; end if(dataset(riga, colonna) < 20) dataset(riga, colonna) = 20; end end end risultato(colonna) = result(dataset(:,colonna)); end disp(colonna); end end
Progetto di Sistemi Intelligenti
43
TESTING.M B = 0 for i = 1:1000 D(i) = results.net(dataset(:,i)); B = B + ((risultato(i) - D(i))^2); disp(i); end
B = B/1000; B = sqrt(B); plotregression(risultato, D); disp(B);
clear i
Progetto di Sistemi Intelligenti
44
RESULT.M function risultato = result( a ) %Result Restituisce il coefficiente associato ad ogni traiettoria % Prende in ingresso un vettore contenente le distanze dal centro della % curva per ogni sensore e restituisce il coefficiente, che varia da 0 a % 1, associato ad ogni traiettoria risultato = 1; for i = 2:length(a) distanza = abs(a(1) - a(i)); if(distanza > 0.5) risultato = risultato - (1 / (length(a) - 1)); else risultato = risultato - ((1 / (length(a) - 1)) * distanza); end end end
Progetto di Sistemi Intelligenti
45
FUZZY_SCRIPT.M for colonna = 1:4400 for riga = 2:20 dataset_fuzzy(riga - 1, colonna) = abs(dataset(riga, colonna) - dataset(1,
colonna)); if(dataset_fuzzy(riga - 1, colonna) > 0.5) dataset_fuzzy(riga - 1, colonna) = 0.5; end end end
for colonna = 1:4400 somma = 0; for riga = 1:4 somma = somma + dataset_fuzzy(riga, colonna); end dataset_fuzzy2(1, colonna) = somma / 4;
somma = 0; for riga = 5:9 somma = somma + dataset_fuzzy(riga, colonna); end dataset_fuzzy2(2, colonna) = somma / 5;
somma = 0; for riga = 10:14 somma = somma + dataset_fuzzy(riga, colonna); end dataset_fuzzy2(3, colonna) = somma / 5;
somma = 0; for riga = 15:19 somma = somma + dataset_fuzzy(riga, colonna); end dataset_fuzzy2(4, colonna) = somma / 5; end
Progetto di Sistemi Intelligenti
46
FUZZY_SCRIPT_TEST.M for colonna = 1:4400 for riga = 2:20 dataset_fuzzy(riga - 1, colonna) = abs(dataset(riga, colonna) - dataset(1,
colonna)); if(dataset_fuzzy(riga - 1, colonna) > 0.5) dataset_fuzzy(riga - 1, colonna) = 0.5; end end end
for colonna = 1:4400 somma = 0; for riga = 1:4 somma = somma + dataset_fuzzy(riga, colonna); end dataset_fuzzy2(1, colonna) = somma / 4;
somma = 0; for riga = 5:9 somma = somma + dataset_fuzzy(riga, colonna); end dataset_fuzzy2(2, colonna) = somma / 5;
somma = 0; for riga = 10:14 somma = somma + dataset_fuzzy(riga, colonna); end dataset_fuzzy2(3, colonna) = somma / 5;
somma = 0; for riga = 15:19 somma = somma + dataset_fuzzy(riga, colonna); end dataset_fuzzy2(4, colonna) = somma / 5; end
Progetto di Sistemi Intelligenti
47
FUZZY.FIS [System]
Name='fuzzy_2'
Type='mamdani'
Version=2.0
NumInputs=4
NumOutputs=1
NumRules=81
AndMethod='prod'
OrMethod='max'
ImpMethod='min'
AggMethod='max'
DefuzzMethod='centroid'
[Input1]
Name='sensore_1'
Range=[0 0.5]
NumMFs=3
MF1='excellent':'trimf',[0 0 0.25]
MF2='good':'trimf',[0 0.25 0.5]
MF3='bad':'trimf',[0.25 0.5 0.5]
[Input2]
Name='sensore_2'
Range=[0 0.5]
NumMFs=3
MF1='excellent':'trimf',[0 0 0.25]
MF2='good':'trimf',[0 0.25 0.5]
MF3='bad':'trimf',[0.25 0.5 0.5]
[Input3]
Name='sensore_3'
Range=[0 0.5]
NumMFs=3
MF1='excellent':'trimf',[0 0 0.25]
MF2='good':'trimf',[0 0.25 0.5]
MF3='bad':'trimf',[0.25 0.5 0.5]
[Input4]
Name='sensore_4'
Range=[0 0.5]
NumMFs=3
MF1='excellent':'trimf',[0 0 0.25]
MF2='good':'trimf',[0 0.25 0.5]
MF3='bad':'trimf',[0.25 0.5 0.5]
[Output1]
Name='risultato'
Range=[-0.25 1.25]
NumMFs=5
MF1='bad':'trimf',[-0.25 0 0.25]
MF2='notsogood':'trimf',[0 0.25 0.5]
MF3='excellent':'trimf',[0.75 1 1.25]
MF4='good':'trimf',[0.25 0.5 0.75]
MF5='verygood':'trimf',[0.5 0.75 1]
[Rules]
1 1 1 1, 3 (1) : 1
1 1 1 2, 5 (1) : 1
1 1 2 1, 5 (1) : 1
1 2 1 1, 5 (1) : 1
Progetto di Sistemi Intelligenti
48
2 1 1 1, 5 (1) : 1
1 1 1 3, 4 (1) : 1
1 1 3 1, 4 (1) : 1
1 3 1 1, 4 (1) : 1
3 1 1 1, 4 (1) : 1
1 1 2 2, 5 (1) : 1
1 2 1 2, 5 (1) : 1
1 2 2 1, 5 (1) : 1
2 1 2 1, 5 (1) : 1
2 1 1 2, 5 (1) : 1
2 2 1 1, 5 (1) : 1
1 1 3 3, 2 (1) : 1
1 3 1 3, 2 (1) : 1
1 3 3 1, 2 (1) : 1
3 1 3 1, 2 (1) : 1
3 1 1 3, 2 (1) : 1
3 3 1 1, 2 (1) : 1
1 1 2 3, 4 (1) : 1
1 1 3 2, 4 (1) : 1
1 2 1 3, 4 (1) : 1
1 2 3 1, 4 (1) : 1
1 3 1 2, 4 (1) : 1
1 3 2 1, 4 (1) : 1
2 1 1 3, 4 (1) : 1
2 1 3 1, 4 (1) : 1
2 3 1 1, 4 (1) : 1
3 1 1 2, 4 (1) : 1
3 1 2 1, 4 (1) : 1
3 2 1 1, 4 (1) : 1
1 2 2 2, 5 (1) : 1
2 1 2 2, 5 (1) : 1
2 2 1 2, 5 (1) : 1
2 2 2 1, 5 (1) : 1
1 2 2 3, 4 (1) : 1
1 2 3 2, 4 (1) : 1
1 3 2 2, 4 (1) : 1
2 1 2 3, 4 (1) : 1
2 1 3 2, 4 (1) : 1
2 2 1 3, 4 (1) : 1
2 2 3 1, 4 (1) : 1
2 3 1 2, 4 (1) : 1
2 3 2 1, 4 (1) : 1
3 1 2 2, 4 (1) : 1
3 2 1 2, 4 (1) : 1
3 2 2 1, 4 (1) : 1
1 2 3 3, 2 (1) : 1
1 3 2 3, 2 (1) : 1
1 3 3 2, 2 (1) : 1
2 1 3 3, 2 (1) : 1
2 3 1 3, 2 (1) : 1
2 3 3 1, 2 (1) : 1
3 1 2 3, 2 (1) : 1
3 1 3 2, 2 (1) : 1
3 2 1 3, 2 (1) : 1
3 2 3 1, 2 (1) : 1
3 3 1 2, 2 (1) : 1
3 3 2 1, 2 (1) : 1
1 3 3 3, 2 (1) : 1
3 1 3 3, 2 (1) : 1
3 3 1 3, 2 (1) : 1
3 3 3 1, 2 (1) : 1
2 2 2 2, 4 (1) : 1
Progetto di Sistemi Intelligenti
49
2 2 2 3, 2 (1) : 1
2 2 3 2, 2 (1) : 1
2 3 2 2, 2 (1) : 1
3 2 2 2, 2 (1) : 1
2 2 3 3, 1 (1) : 1
2 3 2 3, 1 (1) : 1
2 3 3 2, 1 (1) : 1
3 2 2 3, 1 (1) : 1
3 2 3 2, 1 (1) : 1
3 3 2 2, 1 (1) : 1
2 3 3 3, 1 (1) : 1
3 2 3 3, 1 (1) : 1
3 3 2 3, 1 (1) : 1
3 3 3 2, 1 (1) : 1
3 3 3 3, 1 (1) : 1
Progetto di Sistemi Intelligenti
50
INDICE DELLE FIGURE Figura 1 - Struttura della strada. ...................................................................................................................................................... 5
Figura 2 - Definizione di curva perfetta. ...................................................................................................................................... 6
Figura 3 - Grafico per il calcolo del valore da togliere a ogni sensore. ......................................................................... 7
Figura 4 - Rappresentazione polare della posizione. ............................................................................................................ 8
Figura 5 - Vettore che rappresenta la traiettoria. ................................................................................................................... 9
Figura 6 - Schermata iniziale di nftool. ...................................................................................................................................... 12
Figura 7 - Schermata di nftool - Step 1 ...................................................................................................................................... 13
Figura 8 –Schermata di nftool - Step 2 ....................................................................................................................................... 14
Figura 9 - Schermata di nftool - Step 3 ...................................................................................................................................... 15
Figura 10 - Schermati di nftool - Addestramento della rete ........................................................................................... 16
Figura 11 - Regression plot della rete neurale ...................................................................................................................... 17
Figura 12 - Error Instagram ............................................................................................................................................................ 18
Figura 13 - Error plot .......................................................................................................................................................................... 19
Figura 14 - Grafico di regressione della rete neurale utilizzando come FdT di uscita tansig. ...................... 20
Figura 15 - Grafico di regressione della rete neurale utilizzando come FdT di uscita logsig. ....................... 21
Figura 16 - Retta di regressione del dataset di testing ...................................................................................................... 22
Figura 17 - Schermata iniziale del Fuzzy Logic Toolbox. ................................................................................................. 24
Figura 18 - Passaggi per la creazione dei vettori per la logica fuzzy. ........................................................................ 25
Figura 19 - Membership Function Editor per le variabili d’ingresso......................................................................... 27
Figura 20 - Membership Function Editor per la variabile d’uscita. ............................................................................ 28
Figura 21 - Rule Editor. ...................................................................................................................................................................... 29
Figura 25 - Surface Viewer. .............................................................................................................................................................. 31
Figura 26 - Grafico di regressione del sistema fuzzy sul dataset di addestramento della rete neurale. . 32
Figura 27 - Grafico di regressione del sistema fuzzy sul dataset di testing della rete neurale. ................... 33
Figura 28 - Istogramma delle regole lessicali del sistema fuzzy. ................................................................................. 34
Figura 29 - Grafico di regressione del sistema fuzzy sul dataset di addestramento della rete neurale e
range [0; 1]. .............................................................................................................................................................................................. 35
Figura 30 - Grafico di regressione del sistema fuzzy sul dataset di testing della rete neurale e range [0;