NEURBOOK_HOME
INTRODUZIONE
CAPITOLO 1 * ESEMPIO DI MEMORIA ASSOCIATIVA
CAPITOLO 2 * RETI NEURALI ERROR BACK PROPAGATION
CAPITOLO 3 * APPLICAZIONI PRATICHE DI UNA RETE NEURALE EBP
CAPITOLO 4 * RETI NEURALI AUTOORGANIZZANTI
CAPITOLO 5 * FUZZY LOGIC LA TEORIA DEL RAGIONAMENTO SFUMATO
CAPITOLO 6 * NEURFUZZ 1.0
CAPITOLO 7 * GUIDA AL FLOPPY DISK
CAPITOLO 8 * GUIDA AL SOFTWARE
BIBLIOGRAFIA

FUZZY LOGIC
LA TEORIA DEL RAGIONAMENTO SFUMATO

DOVE SI APPLICA LA FUZZY LOGIC

Innanzitutto dobbiamo precisare che questa tecnica fa parte dei sistemi decisionali basati su regole del tipo "if ...then...else", o più semplicemente di quei sistemi basati sulla conoscenza(Knowledge Based Processing) come i cosiddetti Sistemi Esperti. La base di conscenza di un sistema esperto è come una specie di database che anzichè essere composto di dati è composto di relazioni tra i dati intese come associazioni di conseguenze determinate da particolari condizioni di ipotesi: tutto ciò viene chiaramente espresso nelle regole tipo "if then else". Non voglio in questo capitolo approfondire problematiche relative ai sistemi esperti ma concludo ancora dicendo che il programma che "aziona le regole" contenute nel "knowledge base" viene spesso chiamato motore inferenziale o reasoning engine e puo essere basato su diverse tecniche di supporto alla decisione. In fig.1 potete vedere un tipico protocollo di ragionamento per un sistema esperto ibrido con la estensione delle ultime tecnologie come reti neurali e algoritmi genetici.



Come potrete immaginare, un sistema esperto puo essere basato anche solamente su regole fuzzy e quìndi è il caso di capire cosa significa ragionamento fuzzy o sfumato. Se prendiamo in esame una regola del tipo if(acqua bolle) then (butto la pasta), non vi sono sicuramente incertezze a decidere quando buttare la pasta dato che (acqua bolle) è sicuramente vero o sicuramente falso. Se prendiamo in esame invece la regola if(acqua è calda) then (abbassa la fiamma) ci troviamo di fronte a dati incerti: che cosa significa calda? E quanto devo abbassare la fiamma? Supponendo di poter misurare la temperatura con un termometro, come faremo a decidere se quel valore rientrerà nella definizione "calda"? Dovremo iniziare a definire un range di valori in cui la temperatura puo variare e dei subranges che rappresentino definizioni come "calda" o "molto calda". Appare quindi evidente che non sono i dati input a essere imprecisi ma bensì le relazioni che esistono tra input e output: nei problemi trattati con fuzzy logic infatti non esiste un facile modello matematico che collega input e output . In pratica con un motore inferenziale fuzzy si puo empiricamente sintonizzare una funzione matematica che vincola input e output, tramite regole tipo " if ...then ...".

FUZZIFICAZIONE DELL INPUT

Il ragionamento cosiddetto sfumato dei sistemi fuzzy è dovuto al fatto che un ipotesi non è mai completamente vera nè completamente falsa ma ha un suo "grado di verita" che inciderà sulla forza con cui verra eseguita la regola e quindi applicata la conseguenza. Il grado di verità dell ipotesi è in realtà il grado di appartenenza del valore di input a quel determinato range(es:calda) e ciò è dovuto al fatto che questi ranges non sono nettamente separati ma si sovrappongono con funzioni di appartenenza normalmente di tipo triangolare/trapeziodale, per cui un valore di una variabile di input potrebbe appartenere a due ranges con due differenti gradi di credibilità(fig.2).



Il valore 25 gradi della tempertura appartiene alla classe tiepida con un degree of membership(grado di appartenenza) pari a 0.8 e alla classe fredda con un grado di appartenenza uguale 0.4. Come vedete, definendo delle classi triangolari o trapeziodali(le più usate) si hanno dei gradi di appartenenza che diminuiscono verso gli estremi delle classi costruendo così un inizio di quello che è un ragionamento sfumato. Quello che rappresenta la fig.2 è la operazione che viene comunemente definita "FUZZIFICAZIONE DELL INPUT" , cioè trasformazione del dato preciso in dato tipo fuzzy:

dato preciso temp=25 gradi centigradi

dato fuzzy temp =tiepida con credibilità 0.8

temp = fredda con credibilità 0.4

Per realizzare matematicamente il processo di fuzzificazione bisogna effettuare alcuni semplici calcoli sulle funzioni triangolari/trapeziodali . Il primo passo da fare nel processo di fuzzificazione è uno scanning dei valori estremi di ogni classe per cui quando si ha che

limite_inf_class < x < limite_sup_class

allora x appartiene alla classe e bisogna calcolare il grado di appartenenza. Bisogna definire uno "slope" cioe una pendenza , sui lati dei triangoli o dei trapezi che definiscono le classi, che sia fisso per ogni classe e che ci consenta di calcolare il grado di appartenenza di un input x alla classe y. A questo punto bisogna vedere se il valore x cade nella parte bassa della classe (pendenza positiva) o nella parte alta(pendenza negativa): per far questo è sufficente verificare se

x> oppure x < di (lim_sup-lim_inf)/2

che rappresenta il centro della classe. Nel primo caso si effettuerà il calcolo con lo slope positivo e nel secondo con lo slope negativo(fig.3):

1) gda = (x-lim_inf)*slope (se gda>max allora gda=max)

2) gda= (lim_sup-x)*slope (se gda >max allora gda=max)

(gda=grado di appartenenza o "degree of membership")



Bisogna precisare che questo è solamente un possibile approccio alla soluzione del problema di fuzzificazione, infatti è possibile implementare funzioni di qualunque tipo per definire il grado di appartenenza di un input ad una classe; si tratta solamente di calcolare il valore di una funzione in un particolare punto definito dal valore dell input. Personalmente ho sviluppato interfacce fuzzy per reti neurali error_back_propagation con funzioni circolari (seno ,coseno ecc) ma ciò che va tenuto presente è che, normalmente, il range dei valori di appartenenza o "degree of membership" deve essere normalizzato tra il valore 0 e il valore1. Ciò previene evidenti problemi tra variabili del sistema che hanno range di valori completamente differenti e sarebbe comunque auspicabile una soluzione che preveda la normalizzazione delle variabili di input su scala 0-1. Rimanendo comunque nelle classiche funzioni trapeziodali/triangolari si possono effettuare moltissime varianti. Ad esempio si puo fare in modo che la pendenza (slope) dei triangoli sia differenziabile per ogni classe e all interno di ogni classe quella di salita da quella di discesa. Si può anche effettuare il calcolo di fuzzificazione in modo differente senza calcolare il centro della classe (
fig.4). Risulta evidente che quanto più complesse sono le forme delle funzioni scelte per definire le classi, tanto maggiore è la quantità di informazione che deve essere memorizzata per definire una classe e la quantità di calcoli da effettuare per ottenere un valore di "membership degree". Ad esempio la semplice scelta di differenziare le pendenze dei lati dei triangoli o dei trapezi obbliga a memorizzare tale informazione per ogni classe presente.



LA VALUTAZIONE DELLE REGOLE

Un a volta che siamo in possesso di dati fuzzy provenienti dal processo di fuzzificazione dobbiamo inserire nel motore decisionale delle regole che ci diano degli output fuzzy particolari per particolari situazioni(fuzzy) degli input. Una di queste regole può avere la forma: if (input n appartiene a classe k) then output m appartiene a classe j con forza pari al grado di appartenenza di n a k. Spesso nella applicazione delle regole alcune di esse portano alla medesima conseguenza con livelli di forza differenti: in questi casi è pratica comune scegliere il valore maggiore(list.1). Avere dei dati fuzzy in uscita ci servirebbe a ben poco però, perciò si rende necessario trasformare i dati che derivano dalla valutazione delle regole in dati numerici reali: questo processo è il processo opposto alla fuzzificazione dell input e infatti si chiama defuzzificazione dell output.In fig.5 vedete rappresentato lo schema di un sistema fuzzy completo.



LISTATO 1

REGOLA 1: IF (A&&B) THEN X E Y

REGOLA 2: IF (C&&D) THEN X E Z

FORZA DELLA REGOLA 1= MIN(A,B)

FORZA DELLA REGOLA 2= MIN(C,D)

Y= FORZA DELLA REGOLA 1

Z= FORZA DELLA REGOLA 2

X=MAX(FORZA DELLA REGOLA 1,FORZA DELLA REGOLA 2) = MAX(MIN(A,B),MIN(C,D))

DOVE A,B,C,D SONO IPOTESI DEL TIPO "DEGREE OF MEMBERSHIP" OVVERO GRADO DI APPARTENENZA DI UN INPUT DEL SISTEMA AD UNA SPECIFICA CLASSE

E

X,Y,Z SONO CONSEGUENZE INTESE COME GRADO DI APPARTENENZA DI UN OUTPUT AD UNA PARTICOLARE CLASSE

DEFUZZIFICAZIONE DELL OUTPUT

Una volta che abbiamo fuzzificato gli inputs e abbiamo fornito le informazioni in formato fuzzy al motore decisionale del nostro sistema (il programma che fa girare le regole) e che questo ci ha fornito in risposta degli output in formato fuzzy del tipo output 3 appartiene a classe2 con grado 0.6 , dobbiamo ora trovare un sistema che ci consenta di estrarre dati numerici precisi da applicare alle uscite. Questa operazione detta defuzzificazione dell output deve risolvere il problema della conflittualità che nasce dal fatto che alcune regole possono avere generato conseguenze contrastanti tipo:

conseguenza1: out1 appartiene a classe2 con grado 0.6

conseguenza2: out1 appartiene a classe3 con grado 0.3

dove, cioè lo stesso output viene assegnato a classi differenti(normalmente adiacenti o vicine nel range della variabile). Viene comunemente utilizzato un metodo chiamato "center of gravity method" che consiste nel calcolare le aree "attive" dei trapezi o triangoli che definiscono le classi e, una volta posizionato il valore a metà tra i centri delle classi in conflitto farlo "attrarre" dai rispettivi centri_classe in modo proporzionale alle aree attive associate, come mostrato in fig.6. Una possibile semplificazione può essere quella di prendere i centri di tutte le classi in conflitto e far attrarre il valore numerico finale da tutti i centri in modo proporzionale alla forza delle regole che hanno determinato le conseguenze di appartenenza ad ogni classe:

valore finale = (f1*c1 + f2*c2 + f3*c3 ...+fn*cn)/(f1+f2+f3...+fn)

dove cn=centro numerico della classe n fn=grado di appartenenza (o forza della regola)



REALIZZAZIONE SOFTWARE

La realizzazione software di un sistema a regole basato su ragionamento sfumato non è particolarmente difficile inquanto non presenta particolari difficoltà tecniche. Naturalmente a seconda del tipo di applicazione che può avere esigenze di velocità esecutiva o meno, si potranno scegliere soluzioni differenti sia dal punto di vista strettamente teorico relativo alla scelta delle funzioni, sia dal punto di vista della programmazione. Quando si progetta un sistema fuzzy bisogna tenere presente alcuni passi fondamentali :

1) definizione delle classi per ogni variabile di ingresso

2) definizione delle classi per ogni variabile di uscita

3) definizione della forma che descrive il "degree of membership" e delle formule da usare per fuzzificazione e defuzzificazione (decidendo anche se utilizzare una normalizzazione dei dati)

4) definizione delle regole di base del motore decisionale

5) realizzazione del programma in modo che sia possibile aggiungere regole e modificare i limiti delle classi molto facilmente.

6) test del programma sul problema e sintonizzazione del sistema sul risultato desiderato tramite operazioni successive di affinamento tipo aggiunta/modifica di nuove regole e modifica dei limiti delle classi (talvolta anche ridefinizione del numero di classi presente sul range di una variabile)

Questo ultimo passo è senza dubbio il più difficile e il più lungo, tanto che ultimamente sono stati realizzati sistemi che permettono di sintonizzare un sistema fuzzy sulla soluzione del problema tramite reti neuronali e sono in fase di studio anche sistemi che cercano di pilotare la evoluzione di un fuzzy_system tramite algoritmi genetici, cioè algoritmi che seguono i principi della teoria di Darwin. Dal punto di vista strettamente inerente la tecnica di programmazione credo che le soluzioni stilistiche possano essere ben differenziate anche a seconda dell utilizzo o meno di un linguaggio object oriented come il c++: in ogni caso uno schema di base da seguire puo essere quello seguente.

dati definiti in partenza:

float inp_class_min[n][m]
(vettore con limiti minimi di m classi su n input)

float inp_class_max[n][m]
(vettore con limiti massimi di m classi su n input)

float out_class_min[n][m]
(vettore con limiti minimi di m classi su n output)

float out_class_max[n][m]
(vettore con limiti massimi di m classi su n output)

programma:

per ogni input { leggi il valore fuzzificazione: per ogni classe { if (min < valore < max) calcola grado appartenenza } }

per ogni regola { if(ipotesi input) imposta tesi output con grado di forza associato } defuzzificazione: per ogni output { calcola i conflitti con il "gravity center method" }

APPLICAZIONI

La maggior parte delle applicazioni di sistemi fuzzy riguada il controllo di processi o meccanismi in genere e nell industria americana e, giapponese soprattutto, se ne è fatto largo uso in questi ultimi tempi con risultati, a quanto pare, estremamente soddisfacenti: Minolta, Panasonic, Hitachi hanno fatto uso di fuzzy logic nella realizzazione di oggetti come macchine fotografiche o semplici aspirapolveri. In ogni caso la logica fuzzy può essere il nucleo di sistemi di supporto alla decisione o sistemi di controllo, in tasks dove l' estrema complessità non permette un approccio di tipo analitico: in questo senso la logica fuzzy è concorrente alla tecnologia delle reti neurali, ma sempre più spesso queste due tecnologie vengono utilizzate contemporaneamente in sistemi ibridi.


RETI NEURALI SU PERSONAL COMPUTER + FUZZY LOGIC marchese@mbox.ulisse.it