Progetto Di Sistemi Intelligenti

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.


2


3

SOMMARIO Specifica del problema .......................................................................................................................................................................... 4

Specifica della traiettoria ..................................................................................................................................................................... 6

Definizione dello strumento ............................................................................................................................................................... 8

Neural Network ..................................................................................................................................................................................... 10

Creazione del dataset ..................................................................................................................................................................... 10

Creazione della rete neurale ...................................................................................................................................................... 11

Fase di testing della rete neurale ............................................................................................................................................. 22

Fuzzy Logic ............................................................................................................................................................................................... 24

Creazione della logica fuzzy ....................................................................................................................................................... 24

Fase di testing del sistema fuzzy .............................................................................................................................................. 32

Conclusioni ............................................................................................................................................................................................... 37

Script di Matlab ...................................................................................................................................................................................... 38

neural_network.m ........................................................................................................................................................................... 38

dataset_neural_2.m ......................................................................................................................................................................... 41

pre-testing.m ...................................................................................................................................................................................... 42

testing.m ............................................................................................................................................................................................... 43

result.m ................................................................................................................................................................................................. 44

fuzzy_script.m .................................................................................................................................................................................... 45

fuzzy_script_test.m .......................................................................................................................................................................... 46

fuzzy.fis ................................................................................................................................................................................................. 47

Indice delle figure ................................................................................................................................................................................. 50


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:


5

Figura 1 - Struttura della strada.


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.


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.


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.


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


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:

dataset = 30 * ones(n_sensori, n_elementi); dataset(1,:) = raggio_min_curva + ampiezza_strada * rand(1, n_elementi); risultato = 3 * ones(1, n_elementi); tot_blocchi = 40;

for n_blocco = 1:tot_blocchi for colonna = n_elementi * (n_blocco - 1) / tot_blocchi + 1:n_elementi *

n_blocco / tot_blocchi while(risultato(colonna) < (n_blocco - 1) / tot_blocchi ||

risultato(colonna) > n_blocco / tot_blocchi) dataset(2:n_sensori, colonna) = 30; for riga = 2:n_sensori while(dataset(riga, colonna) < raggio_min_curva || dataset(riga,

colonna) > (ampiezza_strada + raggio_min_curva)) if(n_blocco < tot_blocchi - 4) dataset(riga, colonna) = dataset(riga - 1, colonna) + (1 *

(tot_blocchi / n_blocco) * rand(1)) - (0.5 * (tot_blocchi / n_blocco)); else dataset(riga, colonna) = dataset(1, colonna) + (0.4 * (tot_blocchi /

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


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

script, riportato di seguito:

for colonna = 1:n_elementi2 while(risultato2_1(colonna) < 0.99 || risultato2_1(colonna) > 1 ||

dataset2_1(riga, colonna) < raggio_min_curva || dataset2_1(riga, colonna) >

(ampiezza_strada + raggio_min_curva)) for riga = 2:n_sensori dataset2_1(riga, colonna) = dataset2_1(1, colonna) + 0.06 *

rand(1) - 0.03; end risultato2_1(colonna) = result(dataset2_1(:,colonna)); end end

dataset2_2 = 30 * ones(n_sensori, n_elementi2); dataset2_2(1,:) = raggio_min_curva + ampiezza_strada * rand(1, n_elementi2); risultato2_2 = 3 * ones(1, n_elementi2);

for colonna = 1:n_elementi2 while(risultato2_2(colonna) < 0.96 || risultato2_2(colonna) > 0.99 ||


(ampiezza_strada + raggio_min_curva)) for riga = 2:n_sensori dataset2_2(riga, colonna) = dataset2_2(1, colonna) + 0.1 * rand(1)

- 0.05; end risultato2_2(colonna) = result(dataset2_2(:,colonna)); end end

dataset_ = [dataset2_1 dataset2_2] risultato_ = [risultato2_1 risultato2_2]

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:


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


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


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


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.


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.


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 .


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.


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:


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:


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.


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 è


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.


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).


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


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:


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:


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 bad not so good

2 excellent, 1 good ,1 bad good



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:


30

Figura 22 - Rule Editor - Visualizzazione Grafica [1/3].



31


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.


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:


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:


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 :


35

Figura 29 - Grafico di regressione del sistema fuzzy sul dataset di addestramento della rete neurale e range [0; 1].


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.


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.


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

dataset = 30 * ones(n_sensori, n_elementi); dataset(1,:) = raggio_min_curva + ampiezza_strada * rand(1, n_elementi); risultato = 3 * ones(1, n_elementi); tot_blocchi = 40;






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


39

for colonna = 1:n_elementi for riga = 1:n_sensori x(riga) = dataset(riga, colonna) * cos((riga - 1) * (phi / (n_sensori -

1))); y(riga) = dataset(riga, colonna) * sin((riga - 1) * (phi / (n_sensori -

1))); end plot(x, y, 'blue'); hold on end

for riga = 1:n_sensori a(riga) = 25 * cos((riga - 1)*(phi / (n_sensori - 1))); b(riga) = 25 * sin((riga - 1)*(phi / (n_sensori - 1))); end

for riga = 1:n_sensori c(riga) = 20 * cos((riga - 1) * (phi / (n_sensori - 1))); d(riga) = 20 * sin((riga - 1) *( phi / (n_sensori - 1))); end

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'};

net.inputs{1}.processFcns = {'removeconstantrows', 'mapminmax'}; net.outputs{2}.processFcns = {'removeconstantrows', 'mapminmax'};


40

% 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);

% Recalculate Training, Validation and Test Performance trainTargets = targets .* tr.trainMask{1}; valTargets = targets .* tr.valMask{1}; testTargets = targets .* tr.testMask{1}; trainPerformance = perform(net,trainTargets,outputs); valPerformance = perform(net,valTargets,outputs); testPerformance = perform(net,testTargets,outputs);

% View the Network view(net)

% Plots figure, plotperform(tr) figure, plottrainstate(tr) %figure, plotfit(net,inputs,targets) figure, plotregression(targets,outputs) figure, ploterrhist(errors)

% Pulizia dei dati del workspace clear colonna riga n_elementi n_sensori distanza raggio_min_curva

ampiezza_strada x y a b c d phi


41

DATASET_NEURAL_2.M n_elementi2 = 200; n_sensori = 20; raggio_min_curva = 20; ampiezza_strada = 5;


for colonna = 1:n_elementi2 while(risultato2_1(colonna) < 0.99 || risultato2_1(colonna) > 1 ||


(ampiezza_strada + raggio_min_curva)) for riga = 2:n_sensori dataset2_1(riga, colonna) = dataset2_1(1, colonna) + 0.06 *

rand(1) - 0.03; end risultato2_1(colonna) = result(dataset2_1(:,colonna)); end end


for colonna = 1:n_elementi2 while(risultato2_2(colonna) < 0.96 || risultato2_2(colonna) > 0.99 ||


(ampiezza_strada + raggio_min_curva)) for riga = 2:n_sensori dataset2_2(riga, colonna) = dataset2_2(1, colonna) + 0.1 * rand(1)

- 0.05; end risultato2_2(colonna) = result(dataset2_2(:,colonna)); end end

dataset_ = [dataset2_1 dataset2_2] risultato_ = [risultato2_1 risultato2_2]

clear dataset2_1 dataset2_2 risultato2_1 risultato2_2


42

PRE-TESTING.M n_elementi = 1000; n_sensori = 20; ampiezza_strada = 5; raggio_min_curva = 20; dataset = 30 * ones(n_sensori, n_elementi); dataset(1,:) = raggio_min_curva + ampiezza_strada * rand(1, n_elementi); risultato = 3 * ones(1, n_elementi); tot_blocchi = 20;






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


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


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


45

FUZZY_SCRIPT.M for colonna = 1:4400 for riga = 2:20 dataset_fuzzy(riga - 1, colonna) = abs(dataset(riga, colonna) - dataset(1,







46

FUZZY_SCRIPT_TEST.M for colonna = 1:4400 for riga = 2:20 dataset_fuzzy(riga - 1, colonna) = abs(dataset(riga, colonna) - dataset(1,







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


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


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


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


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


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


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 22 - Rule Editor - Visualizzazione Grafica [1/3]. ................................................................................................... 30



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;

1]. ................................................................................................................................................................................................................... 36

Progetto Di Sistemi Intelligenti

Documents

Transcript of Progetto Di Sistemi Intelligenti