Sei sulla pagina 1di 50

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

Progetto di Sistemi Intelligenti

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

Progetto di Sistemi Intelligenti

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, allinterno 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 dingresso 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

Figura 1 - Struttura della strada.

Progetto di Sistemi Intelligenti

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

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 lauto come un punto allinterno del piano, caratterizzato da una tupla di valori del tipo , dove rappresenta la distanza dal centro del cerchio (e quindi della curva), mentre rappresenta langolo 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 dellangolo, visto che essa pu essere semplicemente ricavata. 8

Progetto di Sistemi Intelligenti Quindi ogni traiettoria sar formata da un vettore di 20 (il numero di sensori) elementi, che rappresentano le distanze dellauto dal centro della curva per ogni sensore; a ogni elemento del vettore associato un angolo pari a , dove rappresenta lindice 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

NEURAL NETWORK
Come strumento stato utilizzato il Neural Toolbox, incluso allinterno del sftware Matlab. Questo toolbox permette di creare una rete neurale in grado di approssimare il riconoscimento della bont della traiettoria dellauto allinterno 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 dingresso, 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 allinterno dellintervallo : questo necessario per far s che la rete non si adatti troppo a certe zone dellintervallo, e che riesca a riconoscere con buona approssimazione qualunque tipo dingresso. Ogni vettore che stato creato stato inserito allinterno di una matrice chiamata dataset, mentre i coefficienti sono stati salvati allinterno 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 lutilizzo 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 10

Progetto di Sistemi Intelligenti valido per quel blocco, lo salva, altrimenti procede di nuovo con la generazione di un nuovo vettore casuale. Dopo lesecuzione di questo script, per, ci siamo accorti, tramite il comando max(risultato), che i coefficienti restituiti per lultimo blocco erano tutti inferiori a quindi abbiamo provveduto a inserire anche dei vettori che avessero un coefficiente tra e 1 tramite lutilizzo 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 || dataset2_2(riga, colonna) < raggio_min_curva || dataset2_2(riga, colonna) > (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:

11

Progetto di Sistemi Intelligenti

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

12

Progetto di Sistemi Intelligenti

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 laddestramento, e il suo valore di default pari al 15% degli elementi del dataset; il terzo linsieme 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 duso, come in Figura 8

13

Progetto di Sistemi Intelligenti

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

14

Progetto di Sistemi Intelligenti

Figura 9 - Schermata di nftool - Step 3

In seguito si apre la schermata dove possibile iniziare laddestramento della rete, premendo il pulsante Train; si apre quindi la finestra di Figura 10. Di default utilizzato come metodo di addestramento lalgoritmo di Levenberg-Marquardt e come indice di performance il Mean Squared Error (Scarto Quadratico Medio). Dopo un po di tempo, necessario alla rete per laddestramento, il tool si blocca, come in Figura 10, permettendoci valutare i risultati della rete.

15

Progetto di Sistemi Intelligenti

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 allincirca 0.97, che ci permette di affermare che la rete riconosce bene la quasi totalit dei casi.

16

Progetto di Sistemi Intelligenti

Figura 11 - Regression plot della rete neurale

Per valutare la bont abbiamo anche analizzato alcuni altri grafici: tra questi abbiamo il grafico che rappresenta listogramma 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 listogramma ha un andamento simile a una funzione gaussiana, e la maggior parte degli errori rientra nel range .

17

Progetto di Sistemi Intelligenti

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 lesecuzione della rete, chiudendo, in questo modo, il Toolbox stesso.

18

Progetto di Sistemi Intelligenti 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 (allincirca Per la creazione della rete neurale, oltre allutilizzo 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 duscita la funzione tansig:

19

Progetto di Sistemi Intelligenti

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 duscita abbiamo utilizzato la funzione logsig:

20

Progetto di Sistemi Intelligenti

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.

21

Progetto di Sistemi Intelligenti

FASE DI TESTING DELLA RETE NEURALE


A questo punto si verificato che la rete neurale si comportasse bene per altri tipi dingressi, in maniera tale da verificare lefficacia 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 lunica 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 lanalisi 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 nellintorno di ) mentre per valori minori restituisce risultati con un errore maggiore. Questo fatto probabilmente 22

Progetto di Sistemi Intelligenti dovuto allutilizzo, 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 allutilizzo della funzione di trasferimento purelin per il percettrone di uscita.

23

Progetto di Sistemi Intelligenti

FUZZY LOGIC
Terminata la creazione del tool per lanalisi delle traiettorie tramite una rete neurale, si iniziato lo sviluppo di un medesimo tool, questa volta per tramite lutilizzo 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 dinput, sia quelle di output, sia le regole dinferenza 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 lapplicazione fuzzy; la finestra visibile in Figura 17:

Figura 17 - Schermata iniziale del Fuzzy Logic Toolbox.

Come si pu notare possibile specificare le variabili dinput (nel riquadro giallo), le variabili di output (nel riquadro verde), le regole dinferenza (nel riquadro bianco) e i vari metodi del sistema (nella parte in basso a sinistra della schermata). 24

Progetto di Sistemi Intelligenti Per prima cosa stato deciso di pre-processare il dataset di testing: questo stato deciso perch, avendo per ogni traiettoria venti (20) variabili dinput, se le avessimo lasciate tutte, avremmo avuto, utilizzando tre (3) member function, regole dinferenza. 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 dingresso 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 allutilizzo 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

25

Progetto di Sistemi Intelligenti


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 dinput 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 dingresso al fuzzyficatore mostrata in Figura 19:

26

Progetto di Sistemi Intelligenti

Figura 19 - Membership Function Editor per le variabili dingresso.

Ovviamente questa regola di fuzzificazione vale per tutte le variabili dingresso. 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:

27

Progetto di Sistemi Intelligenti

Figura 20 - Membership Function Editor per la variabile duscita.

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 allestremit{ dellintervallo. A questo punto, scelte le membership function sia per le variabili dingresso 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. Lultima cosa da fare scrivere le regole. Basandoci su considerazioni personali, abbiamo stilato la seguente lista di regole, basata sulle membership function sia dingresso sia duscita: 4 excellent 3 excellent, 1 good 3 excellent, 1 bad 2 excellent, 2 good 2 excellent, 2 bad 2 excellent, 1 good ,1 bad 1 excellent, 3 good excellent very good good very good not so good good very good 28

Progetto di Sistemi Intelligenti 1 excellent, 2 good, 1 bad 1 excellent, 1 good, 2 bad 1 excellent, 3 bad 4 good 3 good, 1 bad 2 good, 2 bad 1 good, 3 bad 4 bad good not so good not so good good not so good bad bad bad

In totale abbiamo quindi come si pu vedere in Figura 21:

regole allinterno del nostro sistema, inserite tramite il Rule Editor,

Figura 21 - Rule Editor.

Matlab ci permette anche di visualizzare graficamente l varie regole cha abbiamo inserito allinterno del sistema; la visualizzazione delle stesse riportata in Figura 22, Figura 23 e Figura 24:

29

Progetto di Sistemi Intelligenti

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

Figura 23 - Rule Editor - Visualizzazione Grafica [2/3].

30

Progetto di Sistemi Intelligenti

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 dingresso e come loro plasmano la variabile di uscita finale. 31

Progetto di Sistemi Intelligenti

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 dallesecuzione 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 questultimo mostrato in Figura 27:

32

Progetto di Sistemi Intelligenti

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:

33

Progetto di Sistemi Intelligenti

Figura 28 - Istogramma delle regole lessicali del sistema fuzzy.

Si pu notare anche che i valori agli estremi dellintervallo vengono riconosciuti, data laccortezza 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 :

34

Progetto di Sistemi Intelligenti

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

35

Progetto di Sistemi Intelligenti

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 dellintervallo di esistenza della variabile di uscita. Nonostante i risultati migliori, questa mancanza non ci ha reso soddisfatti e quindi, confortati dallottimo risultato raggiunto usando un range allargato, abbiamo deciso di scartare questa variante di rete fuzzy.

36

Progetto di Sistemi Intelligenti

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 dellindice 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 luna o laltra rete neurale, in maniera tale da avere un risultato globale probabilmente migliore di quello ottenuto utilizzando una sola rete neurale. Limplementazione di tale sistema fuori dalla nostra portata e non di nostro interesse, per pu fornire uno incipit per futuri progetti simili.

37

Progetto di Sistemi Intelligenti

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

38

Progetto di Sistemi Intelligenti

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

39

Progetto di Sistemi Intelligenti


% 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

40

Progetto di Sistemi Intelligenti DATASET_NEURAL_2.M


n_elementi2 = 200; n_sensori = 20; raggio_min_curva = 20; ampiezza_strada = 5; dataset2_1 = 30 * ones(n_sensori, n_elementi2); dataset2_1(1,:) = raggio_min_curva + ampiezza_strada * rand(1, n_elementi2); risultato2_1 = 3 * ones(1, n_elementi2); 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 || dataset2_2(riga, colonna) < raggio_min_curva || dataset2_2(riga, colonna) > (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

41

Progetto di Sistemi Intelligenti 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;

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

42

Progetto di Sistemi Intelligenti 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

43

Progetto di Sistemi Intelligenti 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

44

Progetto di Sistemi Intelligenti 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

45

Progetto di Sistemi Intelligenti 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

46

Progetto di Sistemi Intelligenti 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, 1 1 1 2, 1 1 2 1, 1 2 1 1, 3 5 5 5 (1) (1) (1) (1) : : : : 1 1 1 1

47

Progetto di Sistemi Intelligenti


2 1 1 1 3 1 1 1 2 2 2 1 1 1 3 3 3 1 1 1 1 1 1 2 2 2 3 3 3 1 2 2 2 1 1 1 2 2 2 2 2 2 3 3 3 1 1 1 2 2 2 3 3 3 3 3 3 1 3 3 3 2 1 1 1 3 1 1 2 2 1 1 2 1 3 3 1 1 3 1 1 2 2 3 3 1 1 3 1 1 2 2 1 2 2 2 2 3 1 1 2 2 3 3 1 2 2 2 3 3 1 3 3 1 1 2 2 3 3 3 1 3 3 2 1 1 3 1 1 2 1 2 2 1 1 3 1 3 3 1 1 2 3 1 3 1 2 1 3 1 1 2 1 2 2 1 2 2 3 2 2 3 1 3 1 2 2 1 2 3 2 3 3 1 3 2 3 1 3 1 2 3 3 1 3 2 1, 3, 1, 1, 1, 2, 2, 1, 1, 2, 1, 3, 3, 1, 1, 3, 1, 3, 2, 3, 1, 2, 1, 3, 1, 1, 2, 1, 1, 2, 2, 2, 1, 3, 2, 2, 3, 2, 3, 1, 2, 1, 2, 2, 1, 3, 3, 2, 3, 3, 1, 3, 2, 3, 1, 2, 1, 3, 3, 3, 1, 2, 5 4 4 4 4 5 5 5 5 5 5 2 2 2 2 2 2 4 4 4 4 4 4 4 4 4 4 4 4 5 5 5 5 4 4 4 4 4 4 4 4 4 4 4 4 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 4 (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

48

Progetto di Sistemi Intelligenti


2 2 2 3 2 2 2 3 3 3 2 3 3 3 3 2 2 3 2 2 3 3 2 2 3 3 2 3 3 3 2 3 2 2 3 2 3 2 3 2 3 3 2 3 3 3, 2, 2, 2, 3, 3, 2, 3, 2, 2, 3, 3, 3, 2, 3, 2 2 2 2 1 1 1 1 1 1 1 1 1 1 1 (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) : : : : : : : : : : : : : : : 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

49

Progetto di Sistemi Intelligenti

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 dingresso......................................................................... 27 Figura 20 - Membership Function Editor per la variabile duscita. ............................................................................ 28 Figura 21 - Rule Editor. ...................................................................................................................................................................... 29 Figura 22 - Rule Editor - Visualizzazione Grafica [1/3]. ................................................................................................... 30 Figura 23 - Rule Editor - Visualizzazione Grafica [2/3]. ................................................................................................... 30 Figura 24 - Rule Editor - Visualizzazione Grafica [3/3]. ................................................................................................... 31 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

50

Potrebbero piacerti anche