Sistema esperto Prolog con ragionamento incerto

Michele Filannino 16 Marzo 2010

Indice
1 Introduzione 1.1 Sistemi esperti . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Prolog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3 Il ragionamento incerto . . . . . . . . . . . . . . . . . . . . . . . 2 Prolog Expert System with Uncertainty (PESU) 2.1 Premesse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.1 MYCIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.1.1 Determinare il livello di certezza delle premesse . 2.1.1.2 Combinare il livello di certezza delle premesse e della conseguenza . . . . . . . . . . . . . . . . . 2.2 Capacità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3 Primo avvio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4 Funzionamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4.1 Meccanismo di inferenza . . . . . . . . . . . . . . . . . . . 2.4.2 Interfaccia utente . . . . . . . . . . . . . . . . . . . . . . . 2.4.2.1 Comando ’dico’ . . . . . . . . . . . . . . . . . . 2.4.2.2 Comando ’fatti’ . . . . . . . . . . . . . . . . . . 2.4.2.3 Comando ’risolvi’ . . . . . . . . . . . . . . . . . 2.4.2.4 Comando ’dettagli’ . . . . . . . . . . . . . . . . 2.4.2.5 Comando ’aiuto’ . . . . . . . . . . . . . . . . . . 2.4.2.6 Comando ’chiudi’ . . . . . . . . . . . . . . . . . 2.4.3 Base di conoscenza . . . . . . . . . . . . . . . . . . . . . . 2.4.3.1 Conoscenza . . . . . . . . . . . . . . . . . . . . . 2.4.3.2 Localizzazioni . . . . . . . . . . . . . . . . . . . 2.4.3.3 Fatti . . . . . . . . . . . . . . . . . . . . . . . . 2.5 Uno sguardo al codice . . . . . . . . . . . . . . . . . . . . . . . . 2.5.1 Predicato ’say’ . . . . . . . . . . . . . . . . . . . . . . . . 2.5.2 Predicato ’show_facts’ . . . . . . . . . . . . . . . . . . . . 2.5.3 Predicato ’solve’ . . . . . . . . . . . . . . . . . . . . . . . 2.5.4 Predicato ’details’ . . . . . . . . . . . . . . . . . . . . . . 2.5.5 Predicato ’help’ . . . . . . . . . . . . . . . . . . . . . . . . 2.5.6 Predicato di chiusura . . . . . . . . . . . . . . . . . . . . . 3 3 4 5 7 7 8 8 8 8 9 9 10 11 12 13 14 14 15 16 16 16 17 17 17 18 18 20 21 21 22

1

INDICE A Uccelli A.1 Albatro di Laysan . . . . . . . A.2 Albatro piedineri . . . . . . . . A.3 Fulmaro . . . . . . . . . . . . . A.4 Cigno minore . . . . . . . . . . A.5 Cigno trombettiere . . . . . . . A.6 Oca del Canada . . . . . . . . . A.7 Oca delle nevi . . . . . . . . . . A.8 Germano reale . . . . . . . . . A.9 Codone comune . . . . . . . . . A.10 Avvoltoio collorosso . . . . . . . A.11 Condor della California . . . . A.12 Sparviero . . . . . . . . . . . . A.13 Falco pellegrino . . . . . . . . . A.14 Pigliamosche crestato maggiore A.15 Pigliamosche golacenerina . . . A.16 Rondine comune . . . . . . . . A.17 Rondine rupestre americana . . A.18 Rondine porporina . . . . . . . Bibliografia

2 23 23 24 24 25 25 26 26 27 27 28 29 29 30 30 31 31 32 32 33

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

Capitolo 1

Introduzione
Il seguente documento presenta una trattazione tecnica relativa alla realizzazione di un sistema esperto in un ambiente di programmazione logica: Prolog. Lo scopo di questa trattazione è illustrare le assunzioni adoperate a monte ed i comportamenti che il sistema esperto esibisce in funzione delle scelte di sviluppo intraprese durante la sua definizione. Prima di far ciò sarà opportuno chiarire che cos’è un sistema esperto, di quali parti si compone e quali caratteristiche deve esibire per essere definito tale.

1.1

Sistemi esperti

Per sistema esperto s’intende un software che cerca di imitare un essere umano esperto in un circoscritto dominio applicativo nell’attività di consulenza. Una caratteristica importante del sistema esperto è la capacità di riferire tutti i passaggi logici che lo hanno indotto a prendere determinate decisioni. Si noti che quest’ultima caratteristica non è sempre riscontrabile in un essere umano: in altre parole non siamo sempre in grado di spiegare il perché delle nostre azioni. Un sistema esperto è composto da tre parti fondamentali: • Base di conoscenza – rappresentazione in forma dichiarativa dell’esperienza del sistema; • Motore inferenziale – componente che simula il processo di ragionamento mediante il quale è possibile trarre deduzioni logiche; • Interfaccia utente – parte che si occupa di agevolare l’interazione tra l’utente utilizzatore ed il sistema. E’ opportuno chiarire anche i ruoli degli attori che interagiscono generalmente con un sistema esperto. Questi sono:

3

CAPITOLO 1. INTRODUZIONE

4

• Esperto di dominio – l’attore che detiene la conoscenza di dominio e che è in grado di risolvere il problema in oggetto; L’obiettivo di un sistema esperto è imitare l’esperto di dominio umano. • Ingegnere della conoscenza – l’individuo che codifica la conoscenza dell’esperto di dominio in una forma comprensibile al sistema esperto; • Utente – l’individuo che consulta il sistema esperto per ottenere consigli (come se stesse interrogando direttamente l’esperto di dominio).

1.2

Prolog

Prolog (PROgrammation en LOGique) è un linguaggio di programmazione dichiarativo. Ciò significa che in Prolog non si scrive che cosa dovrebbe fare il calcolatore linea per linea, come nei linguaggi procedurali (C, Java, etc.). L’idea generale dietro i linguaggi dichiarativi è descrivere una situazione. Sulla base di questo codice, l’interprete o il compilatore calcolerà una soluzione. Nel caso del Prolog, ci dirà se una frase di Prolog sia vera o no, e, se contiene variabili, con quali valori devono essere avvalorate. Benché l’idea dichiarativa sia alla base del Prolog, è possibile vedere il codice di Prolog come procedurale. Un programmatore di Prolog lavorerà secondo la parte del codice che sta leggendo o scrivendo.

CAPITOLO 1. INTRODUZIONE

5

Imparare il Prolog non è sempre fruttuoso quanto imparare C++, Java o Python. Il Prolog è più utile nelle zone relative alla ricerca in intelligenza artificiale, quali soluzione dei problemi, la progettazione o l’interpretazione di linguaggio naturale. Alcuni campi che non sono rigorosamente IA (intelligenza artificiale), quale la costruzione di analizzatori o parser, possono anche trarre giovamento notevole dal Prolog. Il Prolog può persino servire da strumento di abbozzo per provare le idee di programmazione di base prima di realizzarle con linguaggi procedurali. A causa del legame con la logica dei predicati, imparare il Prolog può condurre ad una comprensione maggiore della logica di predicato. Il Prolog è un linguaggio complesso, potente e elegante, che può ispirare soddisfazione grande ai suoi programmatori (così come una rabbia immensa). L’apprendimento del Prolog richiede una certa attenzione.

1.3

Il ragionamento incerto
“La geometria, quando è certa, non dice nulla del mondo reale, e quando dice qualcosa a proposito della nostra esperienza, è incerta.” Albert Einstein

Uno dei limiti del Prolog è l’utilizzo di una logica a due valori {0,1}: ogni fatto rappresentato può essere vero oppure falso. Sebbene le potenzialità di questo ambiente ci consentano un uso disinvolto in diverse situazioni, anche complesse, nel mondo reale è palese la non applicabilità di una logica così rigida. In altri termini, non è affatto possibile dichiarare con assoluta certezza la verità di un fatto oppure la sua categorica falsità. Un fatto può essere vero, falso ma anche incerto. La necessità di gestire incertezza è più o meno evidente a seconda dei contesti d’utilizzo del sistema. Nel campo dei sistemi di diagnosi medica, per esempio, il suggerimento dell’esperto di dominio non è mai definitivo circa la relazione tra sintomi e malattia. A testimonianza di ciò si noti che un buon medico propone sempre diverse possibili diagnosi al proprio paziente. Lo scopo di questo caso di studio è quello di implementare un sistema esperto in Prolog affinché esso sia in grado di operare basandosi su fatti incerti. Si noti che il ragionamento incerto include, come caso limite, quello certo. L’esigenza di una logica meno rigida era palese sin dai tempi di Cartesio; egli infatti fu il primo ad intuire che potesse essere postulata una logica che non si basasse sulla verità o falsità assoluta di una asserzione. Nel corso degli anni si sono susseguiti diversi tentativi di formalizzazione da parte di illustri scienziati del calibro di Russel, Einstein ed Heisenberg. Oggigiorno la formalizzazione più convincente e famosa si deve a Lotfi Zadeh ed è nota con il nome di logica fuzzy (sfocata). Si tratta di una logica polivalente (estensione della logica booleana) e consente di attribuire a ciascuna

CAPITOLO 1. INTRODUZIONE

6

proposizione logica un grado di verità compreso tra 0 e 1. Il concetto di grado di verità ha a che vedere con quanto si ritiene vera la proposizione. Attualmente la logica fuzzy è molto studiata ed impiegata nei paesi orientali che per motivi storico-filosofici sono più inclini ad accettarla, comprenderla ed utilizzarla. Il sistema in esame non ha la pretesa di ricorrere alla logica fuzzy, per diverse ragione, prima tra tutte la sua intrinseca complessità, oltre che il suo grande peso computazionale. E’ stato scelto di implementare un sistema che fornisse un indicatore di certezza relativamente intuitivo.

Capitolo 2

Prolog Expert System with Uncertainty (PESU)
2.1 Premesse

Nel sistema esperto che ho realizzato, l’ingegnere della conoscenza è chiamato ad esprimere un valore di certezza sia sui fatti che sulle regole. Tale valore di certezza (certainty value) è un numero che può assumere valori compresi tra 0 e 1 nel dominio dei numeri reali. cv ∈ , 0 ≤ cv ≤ 1 Un valore di certezza pari a 0 non significa che il fatto sia falso, ma soltanto che l’utente è completamente incerto sulla verità di un singolo asserto. Viceversa, un valore di verità pari ad uno sta ad indicare che l’utente è assolutamente certo dell’asserzione e corrisponde al caso della logica classica: ogni asserzione, a prescindere dalla sua verità o falsità, è completamente certa. E’ possibile attribuire a ciascun fatto della base di conoscenza, un valore di certezza che esprime quanto l’utente sia certo del fatto asserito. Oltre ai fatti, anche le regole possono assumere un valore di certezza. In questo caso tale valore indicherà il livello di certezza attribuito, partendo da fatti completamente veri, al fatto dedotto utilizzando la regola stessa. In altri termini, data una regola così definita: (batteriaAutoGuasta ⇐ radioAutoSpenta)#0.5 significherà che quando sarà verificata la condizione radioAutoSpenta sarò certo che la condizione batteriaAutoGuasta sarà verificata con un valore di certezza pari a 0.5. Come si evince dall’esempio, i valori di certezza non esprimono probabilità, ma servono a dare un’idea numericamente intuitiva dell’attendibilità di un fatto e/o di una regola. 7

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)8

2.1.1

MYCIN

Il sistema esperto in esame è in grado di interrogare l’utente con delle domande calcolando il valore di certezza delle risposte. Tale calcolo, non è ispirato a quello delle probabilità ma ad un sistema appositamente creato per propagare i fattori di certezza in modo che i risultati appaiano tutto sommato corretti per un essere umano. Il nome di questo sistema è MYCIN. Nel sistema esperto in esame, l’utente può inserire i valori di certezza direttamente tramite l’interfaccia utente. L’altro metodo per introdurre valori di certezza è quello di inserirli direttamente all’interno delle regole presenti nella base di conoscenza. Quest’ultimo metodo, tuttavia, non è impiegabile dall’utente finale ma soltanto dall’ingegnere della conoscenza che la formalizza nel sistema. 2.1.1.1 Determinare il livello di certezza delle premesse

Solitamente le premesse di un regola possono non essere assolutamente certe. In tal caso è necessario stabilire quanto vale globalmente la certezza della premessa di una regola. Il criterio che ho utilizzato nel sistema esperto realizzato è quello della media aritmetica. Sia data la seguente regola: (batteriaAutoGuasta ⇐ radioAutoSpenta#0.8, luciAutoSpente#0.6)#0.5. batteriaAutoGuastapremessa = avg(0.8, 0.6) = 0.7 la premessa delle regola avrà un valore di certezza pari a 0.7. 2.1.1.2 Combinare il livello di certezza delle premesse e della conseguenza

Sempre con riferimento all’esempio precedente, si pone il problema di come calcolare il valore di certezza della parte conseguente della regola. In altre parole quanto varrà il valore di certezza del fatto batteriaAutoGuasta. Nel sistema esperto in esame è stato utilizzato un metodo molto semplice: moltiplicare tra loro i due valori di certezza. Si moltiplica il valore di certezza globale delle premesse con quello proprio della regola (indicato dall’ingegnere delle conoscenza). batteriaAutoGuastaconseguenza = 0.5 ∗ 0.7 = 0.35 In questo modo la parte conseguente della regola avrà un valore di certezza di 0.35.

2.2

Capacità

Il sistema esperto in esame è consegnato con una base di conoscenza relativa alla classificazione di uccelli ed imita il comportamento di un esperto che interroga l’utente chiedendogli informazioni sull’uccello da classificare.

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)9 L’utente risponde alle domande del sistema esperto indicando, oltre alla risposta, anche il valore di certezza. Il sistema esperto, dopo aver sottoposto le opportune domande all’utente, è in grado di comunicare il tipo di uccello posseduto dall’utente e con quale livello di certezza. Il sistema è in grado di memorizzare i fatti ed i relativi livelli di certezza, in maniera da recepirli e chiedere all’utente solo le informazioni delle quali necessita. In particolare, il numero e l’ordine delle domande dipendono fortemente dalle risposte che l’utente fornisce via via.

2.3

Primo avvio

Il sistema esperto è stato realizzato in ambiente YAP Prolog v.5.1.3 installato su Mac OS X 10.6.2. E’ stato tuttavia testato anche in ambiente Windows con compilatore YAP Prolog v.5.1.2. Per avviare il sistema esperto è sufficiente copiare la cartella _PESU in una qualsiasi directory di sistema. Dopo aver fatto ciò avviate il compilatore Prolog e digitare la seguente stringa:
reconsult(’<path>/_PESU/init.prolog’).

Dopo aver premuto il tasto Invio partirà l’interfaccia del sistema esperto in italiano. Per utilizzare l’interfaccia in inglese è sufficiente commentare la relativa riga e decommentare quella per la lingua inglese.

2.4

Funzionamento

Il sistema esperto in esame è composto dalle seguenti parti: 1. inizializzatore (init.prolog); 2. meccanismo di inferenza (inference_mechanism.prolog); 3. interfaccia in italiano (interface_ita.prolog); 4. interfaccia in inglese (interface_eng.prolog); 5. base di conoscenza (bird.kb). La componente di inizializzazione oltre che caricare le rimanenti componenti, serve a far eseguire alcune direttive all’interprete Prolog. In particolare si tratta di caricare la libreria di predicati predefiniti per la gestione delle liste, abilitare il controllo attivo sulle clausole e rendere dinamici alcuni predicati.

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)10

2.4.1

Meccanismo di inferenza

La componente relativa al meccanismo di inferenza contiene una serie di utility trasversali al sistema esperto (utilizzate da diversi predicati) e la definizione del predicato di valutazione e propagazione del livello di certezza. Il predicato di valutazione globale utilizza a sua volta due predicati rispettivamente preposti alla valutazione della parte conseguente ed antecedente di una regola. All’interno di questa componente è stata inserita anche la gestione dei fatti. Vi sono due predicati: load_facts e restore_facts. Il primo serve a caricare all’interno della memoria di lavoro i fatti eventualmente inseriti dall’ingegnere della conoscenza direttamente all’interno della base di conoscenza. Il secondo serve a ripristinare i fatti precedentemente memorizzati al fine di preservare la possibilità di lanciare più volte il sistema esperto senza dover necessariamente riavviare il compilatore. I fatti inseriti tramite interfaccia grafica sono considerati soltanto durante l’esecuzione immediatamente successiva del sistema esperto. Al termine di tale esecuzione, tali fatti vengono rimossi. All’utente è comunque lasciata la possibilità di reintrodurre fatti tramite interfaccia. Quando si avvia il sistema esperto, esso esamina gli eventuali fatti dichiarati (sia nella base di conoscenza che tramite interfaccia) e comincia a chiedere informazioni solo di quegli attributi dei quali non sa nulla. Se i fatti asseriti prima della risoluzione fossero sufficienti a classificare correttamente l’uccello, non verrebbe posta alcuna domanda all’utente e verrebbe comunicato immediatamente il risultato con il relativo livello di certezza. Ogni domanda può essere precisa o generica. La scelta del tipo di domanda è demandata all’ingegnere della conoscenza.

La domanda precisa chiede all’utente la conferma che un determinato attributo abbia un determinato valore e a prescindere dal carattere della risposta (positiva o negativa) chiede di inserire il livello di certezza.

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)11

La domanda generica, invece, chiede all’utente di indicare il valore per un determinato attributo, scegliendo da un elenco. In questo caso la risposta non potrà che essere sempre affermativa, poiché in elenco sono presenti tutti e soli i valori che possono essere dati all’attributo.

2.4.2

Interfaccia utente

Il sistema esperto è corredato di una interfaccia utente a riga di comando che consente una più facile interazione con l’utente finale. Il sistema è in grado di esibire la propria interfaccia utente in diverse lingue. In particolare, il sistema esperto oggetto di questo documento offre una interfaccia in italiano ed in inglese. L’architettura per la gestione dell’interfaccia utente è tuttavia estremamente generale e consente, a chi lo desideri, di implementare un numero di lingue ben superiori.

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)12 All’avvio dell’inizializzatore appare un messaggio di benvenuto seguito dall’elenco dei comandi che possono essere utilizzati: il sistema accetterà solo i comandi indicati nella legenda.

Nel caso venga inserito un comando non riconosciuto, viene mostrato un messaggio di errore come in figura. Il sistema si rimetterà in attesa di un comando valido. 2.4.2.1 Comando ’dico’

Il comando dico è utile per asserire dei fatti. I fatti hanno la seguente sintassi: known(si, Attributo, V alore, LivelloDiCertezza). Il primo argomento sta ad indicare il carattere della conoscenza elicitata: in questo caso di tratta di un fatto affermativo. Il secondo e terzo argomento indicano rispettivamente l’attributo oggetto dell’asserzione ed il relativo valore assunto. Il quarto argomento indica il valore di certezza espresso come numero in virgola mobile.

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)13

Nell’esempio di cui sopra si è asserito che l’attributo size ha valore large con un grado di certezza pari a 0.87. In altri termini: known(si, size, large, 0.87). Nella realizzazione del comando dico si è assunto che l’utente voglia implicitamente asserire fatti affermativi. In tal senso all’utente verrà chiesto tramite interfaccia di introdurre solo gli ultimi 3 argomenti del predicato known. Come già detto in 2.4.1, i fatti asseriti tramite interfaccia vengono considerati solo durante la prima esecuzione del sistema esperto (tramite 2.4.2.3). Al termine di tale esecuzione sarà necessario reinserire i fatti. A tal proposito, all’interno della base di conoscenza vi è una sezione dedicata appositamente alla dichiarazione di fatti che si vuole siano validi per tutta l’esecuzione del sistema (anche dopo ripetuti processi di risoluzione). Tutti i fatti dei quali il sistema esperto necessita e che non sono stati asseriti vengono richiesti durante l’esecuzione dello stesso. L’asserzione di fatti è un’operazione che dovrebbe essere eseguita dall’utente che ha conoscenza delle modalità di formalizzazione dei dati. L’asserzione di fatti su attributi non esistenti (non dichiarati nella base di conoscenza) va a buon fine ma non fornisce alcuna informazione al sistema esperto. 2.4.2.2 Comando ’fatti’

Il comando fatti serve per visualizzare quali sono i fatti presenti in memoria. Il comando è in grado di mostrare a video sia i fatti temporanei inseriti tramite interfaccia (vedi 2.4.2.1) che quelli permanenti inseriti direttamente all’interno della base di conoscenza (vedi 2.4.3).

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)14

Nella lista sono presenti tutte le informazioni necessarie a descrivere un fatto. La prima informazione è il suo tipo, che può essere definitivo o temporaneo. Per ciascuno di essi viene mostrato l’attributo, il valore dell’attributo ed il livello di certezza. Nel caso dei fatti temporanei è presente anche il carattere dell’informazione: positiva o negativa (vedi anche 2.4.3). 2.4.2.3 Comando ’risolvi’

Il comando risolvi serve ad avviare il risolutore del sistema esperto. Quando il comando viene eseguito vengono effettuate alcune operazioni chiave. La prima di queste è la valutazione dei fatti inseriti nella base di conoscenza. Essi vengono caricati in memoria unitamente a quelli asseriti temporaneamente tramite interfaccia (vedi 2.4.2.1). Dopo la fase di caricamento dei fatti viene eseguito il processo di ragionamento tramite il quale il sistema esperto cerca di quale sia il tipo di uccello posseduto dall’utente. Durante questa fase, il sistema ha bisogno di informazioni che possono essere chieste direttamente all’utente tramite interfaccia grafica. Se tra i fatti vi sono già le informazioni necessarie, il sistema esperto eviterà di domandarle all’utente. Il numero di domande, il loro ordine e la notifica del risultato dipendono esclusivamente dai fatti asseriti. In particolare, è interessante sottolineare che l’ordine delle domande cambia in funzione delle risposte via via ricevute. Il sistema passo dopo passo esclude delle risposte ed interroga l’utente dinamicamente. La dinamicità è indotta dalle risposte dell’utente. 2.4.2.4 Comando ’dettagli’

Il comando dettagli lancia il sistema esperto e alla fine dell’elaborazione visualizza informazioni aggiuntive circa il risultato ottenuto. Alla stessa stregua di quanto avviene nella fase di risoluzione classica, i fatti non asseriti direttamente all’interno della base di conoscenza (quindi quelli as-

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)15 seriti tramite interfaccia) vengono completamente rimossi alla fine del processo. E’ pertanto opportuno reinserirli qualora si rendesse necessario. Per una trattazione più approfondita di quanto accade nel processo di risoluzione si rimanda a 2.4.2.3.

Nella sua definizione esso dipende fortemente dalla base di conoscenza. In particolare, fornisce informazioni utili circa la famiglia di appertenenza dell’uccello ed il suo tipo. 2.4.2.5 Comando ’aiuto’

Il comando aiuto serve a visualizzare l’elenco dei comandi disponibili tramite interfaccia utente.

Dopo una serie di spazi bianchi, viene stampata la guida e rimostrato il cursore, in attesa che l’utente inserisca un comando valido.

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)16 2.4.2.6 Comando ’chiudi’

Il comando chiudi serve ad uscire dall’interfaccia utente e ritornare al prompt proprio dell’ambiente Prolog.

2.4.3

Base di conoscenza

La base di conoscenza sviluppata in questo caso di studio riguarda l’identificazione di alcuni tipi di uccelli a partire dalle loro caratteristiche fenotipiche. Ogni specie di uccello appartiene ad una certa famiglia, ad una certa categoria e presenta delle proprietà fisiche che lo caratterizzano univocamente. Da un punto di vista più profondo, anche un task di classificazione che segue regole ben comprovate non può essere infallibile. Per questa ragione la base di conoscenza che utilizza il sistema esperto contiene alcune delle regole di classificazione che hanno un valore di certezza non pari a 1. In altri termini, tali regole di classificazione non sono assolutamente certe (non garantiscono cioè l’assoluta certezza della classificazione). La base di conoscenza è divisa in tre parti: 1. conoscenza; 2. localizzazioni; 3. fatti permanenti. 2.4.3.1 Conoscenza

La parte relativa alla conoscenza in senso stretto contiene la formalizzazione delle regole necessarie al sistema esperto per classificare correttamente un uccello. Tali regole sono esattamente quelle di competenza dell’ingegnere della conoscenza, il cui compito è quello di formalizzare la conoscenza dell’esperto umano.

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)17 Essa contiene la descrizione formale di ciascun uccello, in termini della sua famiglia di appartenenza, del suo tipo e dei suoi caratteri estetici. A sua volta, anche la famiglia (ed il tipo), sono informazioni desumibili da alcune precise caratteristiche fisiche dell’esemplare in esame. Ogni caratteristica utile alla classificazione, a meno che non sia già nota (vedi 2.4.2.3), viene richiesta all’utente attraverso domande che possono essere precise oppure generiche (vedi 2.4.1). 2.4.3.2 Localizzazioni

La parte di localizzazione è opzionale e serve per tradurre in quante lingue si voglia gli elementi della base di conoscenza che vengono visualizzati a video. Nel caso in cui un elemento non trovi la rispettiva traduzione, questo verrà visualizzato con il nome utilizzato per identificarlo nel codice Prolog. 2.4.3.3 Fatti

I fatti permanenti sono asserzioni che una volta compilate, vengono considerate per tutta la durata del sistema (anche dopo riavii multipli del risolutore). Tale funzionalità può essere utilizzata qualora un utente debba classificare un insieme di uccelli che condividono alcune caratteristiche. In questo caso il sistema esperto non seccherà l’utente con le stesse domande. Oltre ad essere inseriti direttamente nella base di conoscenza, questi possono anche essere asseriti utilizzando l’interfaccia grafica del sistema esperto (vedi 2.4.2.1). In quest’ultimo caso, tuttavia, è necessario asserire i fatti desiderati ad ogni risoluzione.

2.5

Uno sguardo al codice

In questa sezione analizziamo il codice Prolog del sistema esperto, spiegando in dettaglio i predicati chiave. Di seguito il diagramma che sintetizza l’interfaccia utente di PESU.

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)18

2.5.1

Predicato ’say’

Il comando dico serve a recepire fatti tramite interfaccia utente (vedi 2.4.2.1). Di seguito l’implementazione:
say :- nl, write(’Scrivi il nome dell\’attributo : ’), get_user(Attribute), write(’Scrivi il valore dell\’attributo: ’), get_user(Value), write(’Scrivi il livello di certezza : ’), get_user_cert(CertaintyLevel), assert(known(yes,Attribute,Value,CertaintyLevel)), write(’Il fatto e\’ stato memorizzato. Grazie.’), nl.

Tale comando stampa le frasi d’interfaccia a video e legge i valori inseriti dall’utente. Per la lettura dell’input dell’utente sono stati utilizzati dei predicati specifici che incapsulano il classico read, implementando anche un controllo sul dominio. Ad esempio, nel caso dell’inserimento di un valore di certezza (predicato get_user_cert) è necessario inserire un numero con virgola; se ciò non avvenisse, all’utente verrebbe richiesto di inserire nuovamente un valore corretto. Il procedimento termina solo quando l’utente inserisce i dati nella forma richiesta. Dopo aver letto i tre valori, il predicato say asserisce il fatto con connotazione positiva e stampa un messaggio di conferma.

2.5.2

Predicato ’show_facts’

Il comando fatti serve a visualizzare tutti i fatti, temporanei e permanenti, che sono attivi nel sistema esperto (vedi 2.4.2.2). Di seguito l’implementazione:

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)19
show_facts :- write(’** LISTA DEI FATTI *********’), nl, repeat, show_fact, !, restore_facts. show_fact :- fact(Attribute,Value,Ce), write(’ definitivo(’), translate(Attribute,AttTranslate,ita), write(AttTranslate), write(’,’), translate(Value,ValTranslate,ita), write(ValTranslate), write(’,’), write(Ce), write(’).\n’), retract(fact(Attribute,Value,Ce)), assert(fact(Attribute,Value,Ce,loaded)), fail. show_fact :- known(Response,Attribute,Value,Ce), write(’ temporaneo(’), write(Response), write(’,’), translate(Attribute,AttTranslate,ita), write(AttTranslate), write(’,’), translate(Value,ValTranslate,ita), write(ValTranslate), write(’,’), write(Ce), write(’).\n’), retract(known(Response,Attribute,Value,Ce)), assert(known(Response,Attribute,Value,Ce,loaded)), fail. show_fact.

Il predicato show_facts stampa a video iterativamente tutti i fatti fino al loro esaurimento, rimuovendoli dalla working memory, dopo ciò procede al ripristino con il predicato restore_facts. Più che di una rimozione si tratta di una riformulazione dei fatti: si aggiunge un parametro supplementare (con valore loaded ). Il predicato show_fact seleziona il primo fatto permanente asserito nella base di conoscenza, stampa le informazioni a video, lo rimuove, asserisce la sua riformulazione e fallisce (il fallimento è indispensabile per innescare l’iterazione del repeat). Il secondo predicato show_fact è identico al precedente a meno di una caratteristica: seleziona, stampa, rimuove ed asserisce fatti temporanei presenti nella working memory. L’ultimo predicato viene invocato soltanto quando tutti i fatti, sia permanenti che temporanei, sono finiti. A quel punto il predicato show_fact risulta vero ed il ciclo si interrompe. Dopo viene invocato il predicato restore_facts. L’obiettivo del suddetto predicato è quello di ripristinare la formulazione originale dei fatti. Di seguito la sua formulazione:
restore_facts :- repeat, restore_fact, !. restore_fact :- fact(Attribute,Value,Ce,loaded), assert(fact(Attribute,Value,Ce)), retract(fact(Attribute,Value,Ce,loaded)), fail. restore_fact :- known(Response,Attribute,Value,Ce,loaded), assert(known(Response,Attribute,Value,Ce)), retract(known(Response,Attribute,Value,Ce,loaded)), fail. restore_fact.

La sua struttura ed il suo funzionamento sono del tutto simili al predicato show_facts.

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)20

2.5.3

Predicato ’solve’

Il comando risolvi serve a lanciare il sistema esperto (vedi 2.4.2.3). Di seguito il diagramma dei predicati utilizzati:

Il predicato principale per l’esecuzione del sistema esperto, è il predicato solve. Di seguito, la sua formulazione:
solve :- load_facts, top_goal(X,Ce), abolish(known/4), abolish(known/5), white_spaces, write(’** RISULTATO **********************************************’), nl, write(’*’), nl, write(’* Si tratta di un ’), translate(X,XTranslated,ita), write(XTranslated), write(’, con certezza ’), Certainty is round(Ce*100), write(Certainty), write(’%.’), nl, write(’*’), nl, write(’***********************************************************’), nl. solve :- nl, write(’Non ho risposte. :\(’), nl.

Per prima cosa vengono caricati i fatti permanenti tramite il predicato load_facts, dopo viene lanciata la risoluzione del goal principale. Tale risoluzione è discriminante, poiché se fallisce viene utilizzata la seconda definizione del predicato solve. Se il predicato top_goal ha successo allora viene ripulita la working memory dai fatti temporanei (vengono definitivamente persi) e permanenti (vengono recuperati nuovamente con il predicato load_fact) e viene stampato a video il risultato, in termini di uccello classificato e livello di certezza della risposta data. Il predicato load_facts è implementato nel seguente modo:
load_facts :- repeat, load_fact, !, restore_facts. load_fact :- fact(Attribute,Value,Ce), assert(known(yes,Attribute,Value,Ce)), retract(fact(Attribute,Value,Ce)), assert(fact(Attribute,Value,Ce,loaded)), fail. load_fact.

Il suo obiettivo è quello di caricare nella working memory i fatti permanenti, utilizzando lo stesso sistema del predicato show_facts (vedi 2.5.2).

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)21 Il predicato top_goal comincia a verificare, in modo ordinato, le caratteristiche richieste all’interno della base di conoscenza. Ogni caratteristica viene verificata tramite il predicato ask o menuask. In entrambi i casi, che differiscono solo per la modalità di interfaccia, viene prima verificato che l’attributo richiesto non sia già presente nella working memory, nel qual caso è inutile chiedere all’utente. Se nella working memory non vi sono informazioni sull’attributo in esame dal sistema esperto, allora il sistema interroga l’utente finale tramite interfaccia utente (vedi 2.4.1).

2.5.4

Predicato ’details’

Il predicato details è identico a quello solve, tranne per la presenza di ulteriori dettagli stampati a video. Di seguito la sua implementazione:
details :- load_facts, top_goal(X,Ce), white_spaces, write(’** RISULTATO **********************************************’), nl, write(’*’), nl, write(’* Si tratta di un ’), translate(X,XTranslated,ita), write(XTranslated), write(’, con certezza ’), Certainty is round(Ce*100), write(Certainty), write(’% ’), nl, write(’*’), write(’ perche\’ ’), write(’ e\’ della famiglia \”), family(Family,_), translate(Family,FmlTranslated,ita), write(FmlTranslated), write(’\’,’), nl, write(’*’), write(’ ed e\’ di tipo \”), order(Order,_), translate(Order,OrdTranslated,ita), write(OrdTranslated), write(’\’.’), nl, write(’***********************************************************’), nl, abolish(known/4), abolish(known/5). details :- nl, write(’Non ho risposte. :\(’), nl.

La diversità di tale predicato da quello solve sta nella stampa a video del tipo di famiglia dell’uccello classificato e del tipo di specie. Per il resto tale predicato è identico al precedente e si rimanda a quello per ulteriori dettagli.

2.5.5

Predicato ’help’

Il predicato help implementa il comando aiuto ed è realizzato nel seguente modo:
help :- write(’Comandi disponibili: ’), nl, write(’ write(’ write(’ write(’ write(’ write(’ dico. fatti. - Asserire un fatto;’), nl, - Visualizza i fatti asseriti;’), nl,

risolvi. - Avvia il sistema esperto;’), nl, dettagli.- Avvia il sistema esperto e fornisce piu\’ informazioni;’), nl, aiuto. chiudi. - Consultare la guida;’), nl, - Chiudere l\’interfaccia grafica;’), nl.

Si tratta di una banale stampa di informazioni a video.

CAPITOLO 2. PROLOG EXPERT SYSTEM WITH UNCERTAINTY (PESU)22

2.5.6

Predicato di chiusura

La chiusura dell’interfaccia è implementata mediante un controllo direttamente all’interno del predicato main. Quest’ultimo predicato serve a lanciare il sistema esperto all’atto della compilazione. La sua definizione è la seguente:

main :- white_spaces, greeting, repeat, write(’> ’), read(X), do(X), X == chiudi.

Il compito di tale predicato è quello di stampare il messaggio di benvenuto (che contiene un richiamo interno alla guida) e predisporre il prompt dell’interfaccia. A differenza dei precedenti predicati, che avevano una loro implementazione, nel caso della chiusura tale implementazione autonoma non è necessaria poiché rendendo vero l’intero predicato, il compilatore provvede automaticamente a restituire il prompt principale. Per agevolare il debugging nel periodo di sviluppo, e conservare la possibilità di interagire con il sistema senza utilizzare l’interfaccia, si è scelto di non cancellare la working memory all’uscita dal prompt di interfaccia.

Appendice A

Uccelli
A.1 Albatro di Laysan

23

APPENDICE A. UCCELLI

24

A.2

Albatro piedineri

A.3

Fulmaro

APPENDICE A. UCCELLI

25

A.4

Cigno minore

A.5

Cigno trombettiere

APPENDICE A. UCCELLI

26

A.6

Oca del Canada

A.7

Oca delle nevi

APPENDICE A. UCCELLI

27

A.8

Germano reale

A.9

Codone comune

APPENDICE A. UCCELLI

28

A.10

Avvoltoio collorosso

APPENDICE A. UCCELLI

29

A.11

Condor della California

A.12

Sparviero

APPENDICE A. UCCELLI

30

A.13

Falco pellegrino

A.14

Pigliamosche crestato maggiore

APPENDICE A. UCCELLI

31

A.15

Pigliamosche golacenerina

A.16

Rondine comune

APPENDICE A. UCCELLI

32

A.17

Rondine rupestre americana

A.18

Rondine porporina

Bibliografia
[1] Vitor Santos Costa. Yap prolog user’s manual, 06 2008. [2] P. Mello L. Console, E. Lamma. Programmazione logica in Prolog. UTET Libreria, 1991. [3] E. Shapiro L. Sterling. The Art of Prolog: Advanced Programming Techniques Second Edition. The MIT Press, 1994. [4] D. Merritt. Building expert system in Prolog. Amzi! Inc., 2000. [5] T. Finin S. Schocken. Prolog meta-interpreters for rule-based inference under uncertainty. Working paper series of New York University, 1989. [6] L. A. Zadeh. Fuzzy sets. Information and Control, 8(3):338–353, June 1965.

33