Sistema esperto in Prolog con ragionamento incerto

Sistema esperto Prolog con ragionamentoincerto

Michele Filannino

16 Marzo 2010

Indice

1 Introduzione 31.1 Sistemi esperti . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2 Prolog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.3 Il ragionamento incerto . . . . . . . . . . . . . . . . . . . . . . . 5

2 Prolog Expert System with Uncertainty (PESU) 72.1 Premesse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.1.1 MYCIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.1.1.1 Determinare il livello di certezza delle premesse . 82.1.1.2 Combinare il livello di certezza delle premesse e

della conseguenza . . . . . . . . . . . . . . . . . 82.2 Capacità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.3 Primo avvio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.4 Funzionamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.4.1 Meccanismo di inferenza . . . . . . . . . . . . . . . . . . . 102.4.2 Interfaccia utente . . . . . . . . . . . . . . . . . . . . . . . 11

2.4.2.1 Comando ’dico’ . . . . . . . . . . . . . . . . . . 122.4.2.2 Comando ’fatti’ . . . . . . . . . . . . . . . . . . 132.4.2.3 Comando ’risolvi’ . . . . . . . . . . . . . . . . . 142.4.2.4 Comando ’dettagli’ . . . . . . . . . . . . . . . . 142.4.2.5 Comando ’aiuto’ . . . . . . . . . . . . . . . . . . 152.4.2.6 Comando ’chiudi’ . . . . . . . . . . . . . . . . . 16

2.4.3 Base di conoscenza . . . . . . . . . . . . . . . . . . . . . . 162.4.3.1 Conoscenza . . . . . . . . . . . . . . . . . . . . . 162.4.3.2 Localizzazioni . . . . . . . . . . . . . . . . . . . 172.4.3.3 Fatti . . . . . . . . . . . . . . . . . . . . . . . . 17

2.5 Uno sguardo al codice . . . . . . . . . . . . . . . . . . . . . . . . 172.5.1 Predicato ’say’ . . . . . . . . . . . . . . . . . . . . . . . . 182.5.2 Predicato ’show_facts’ . . . . . . . . . . . . . . . . . . . . 182.5.3 Predicato ’solve’ . . . . . . . . . . . . . . . . . . . . . . . 202.5.4 Predicato ’details’ . . . . . . . . . . . . . . . . . . . . . . 212.5.5 Predicato ’help’ . . . . . . . . . . . . . . . . . . . . . . . . 212.5.6 Predicato di chiusura . . . . . . . . . . . . . . . . . . . . . 22

1

INDICE 2

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

Bibliografia 33

Capitolo 1

Introduzione

Il seguente documento presenta una trattazione tecnica relativa alla realizzazio-ne di un sistema esperto in un ambiente di programmazione logica: Prolog.

Lo scopo di questa trattazione è illustrare le assunzioni adoperate a monteed i comportamenti che il sistema esperto esibisce in funzione delle scelte disviluppo intraprese durante la sua definizione.

Prima di far ciò sarà opportuno chiarire che cos’è un sistema esperto, di qualiparti si compone e quali caratteristiche deve esibire per essere definito tale.

1.1 Sistemi espertiPer sistema esperto s’intende un software che cerca di imitare un essere umanoesperto in un circoscritto dominio applicativo nell’attività di consulenza.

Una caratteristica importante del sistema esperto è la capacità di riferiretutti i passaggi logici che lo hanno indotto a prendere determinate decisioni.Si noti che quest’ultima caratteristica non è sempre riscontrabile in un essereumano: in altre parole non siamo sempre in grado di spiegare il perché dellenostre azioni.

Un sistema esperto è composto da tre parti fondamentali:

• Base di conoscenza – rappresentazione in forma dichiarativa dell’esperien-za del sistema;

• Motore inferenziale – componente che simula il processo di ragionamentomediante il quale è possibile trarre deduzioni logiche;

• Interfaccia utente – parte che si occupa di agevolare l’interazione tral’utente utilizzatore ed il sistema.

E’ opportuno chiarire anche i ruoli degli attori che interagiscono generalmentecon 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 sistemaesperto è imitare l’esperto di dominio umano.

• Ingegnere della conoscenza – l’individuo che codifica la conoscenza dell’e-sperto 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 PrologProlog (PROgrammation en LOGique) è un linguaggio di programmazione di-chiarativo. Ciò significa che in Prolog non si scrive che cosa dovrebbe fare ilcalcolatore 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 contienevariabili, con quali valori devono essere avvalorate.

Benché l’idea dichiarativa sia alla base del Prolog, è possibile vedere il codicedi Prolog come procedurale. Un programmatore di Prolog lavorerà secondo laparte del codice che sta leggendo o scrivendo.


Imparare il Prolog non è sempre fruttuoso quanto imparare C++, Java oPython. Il Prolog è più utile nelle zone relative alla ricerca in intelligenzaartificiale, quali soluzione dei problemi, la progettazione o l’interpretazione dilinguaggio naturale.

Alcuni campi che non sono rigorosamente IA (intelligenza artificiale), qualela costruzione di analizzatori o parser, possono anche trarre giovamento notevoledal Prolog.

Il Prolog può persino servire da strumento di abbozzo per provare le idee diprogrammazione di base prima di realizzarle con linguaggi procedurali. A causadel legame con la logica dei predicati, imparare il Prolog può condurre ad unacomprensione maggiore della logica di predicato.

Il Prolog è un linguaggio complesso, potente e elegante, che può ispiraresoddisfazione 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 fattorappresentato può essere vero oppure falso.

Sebbene le potenzialità di questo ambiente ci consentano un uso disinvolto indiverse 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 laverità 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 evidentea seconda dei contesti d’utilizzo del sistema.

Nel campo dei sistemi di diagnosi medica, per esempio, il suggerimento del-l’esperto di dominio non è mai definitivo circa la relazione tra sintomi e malat-tia. A testimonianza di ciò si noti che un buon medico propone sempre diversepossibili diagnosi al proprio paziente.

Lo scopo di questo caso di studio è quello di implementare un sistema espertoin Prolog affinché esso sia in grado di operare basandosi su fatti incerti. Si notiche 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 nonsi basasse sulla verità o falsità assoluta di una asserzione.

Nel corso degli anni si sono susseguiti diversi tentativi di formalizzazione daparte di illustri scienziati del calibro di Russel, Einstein ed Heisenberg.

Oggigiorno la formalizzazione più convincente e famosa si deve a Lotfi Za-deh ed è nota con il nome di logica fuzzy (sfocata). Si tratta di una logicapolivalente (estensione della logica booleana) e consente di attribuire a ciascuna


proposizione logica un grado di verità compreso tra 0 e 1. Il concetto di gradodi verità ha a che vedere con quanto si ritiene vera la proposizione.

Attualmente la logica fuzzy è molto studiata ed impiegata nei paesi orientaliche per motivi storico-filosofici sono più inclini ad accettarla, comprenderla edutilizzarla.

Il sistema in esame non ha la pretesa di ricorrere alla logica fuzzy, per diverseragione, prima tra tutte la sua intrinseca complessità, oltre che il suo grandepeso computazionale. E’ stato scelto di implementare un sistema che fornisseun indicatore di certezza relativamente intuitivo.

Capitolo 2

Prolog Expert System withUncertainty (PESU)

2.1 PremesseNel sistema esperto che ho realizzato, l’ingegnere della conoscenza è chiamatoad esprimere un valore di certezza sia sui fatti che sulle regole.

Tale valore di certezza (certainty value) è un numero che può assumere valoricompresi 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 soltantoche l’utente è completamente incerto sulla verità di un singolo asserto. Vicever-sa, un valore di verità pari ad uno sta ad indicare che l’utente è assolutamentecerto 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 dicertezza 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 valoreindicherà il livello di certezza attribuito, partendo da fatti completamente veri,al fatto dedotto utilizzando la regola stessa. In altri termini, data una regolacosì definita:

(batteriaAutoGuasta⇐ radioAutoSpenta)#0.5

significherà che quando sarà verificata la condizione radioAutoSpenta sarò certoche la condizione batteriaAutoGuasta sarà verificata con un valore di certezzapari 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 fattoe/o di una regola.

7

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

2.1.1 MYCINIl sistema esperto in esame è in grado di interrogare l’utente con delle domandecalcolando il valore di certezza delle risposte. Tale calcolo, non è ispirato aquello delle probabilità ma ad un sistema appositamente creato per propagare ifattori di certezza in modo che i risultati appaiano tutto sommato corretti perun essere umano.

Il nome di questo sistema è MYCIN. Nel sistema esperto in esame, l’utentepuò inserire i valori di certezza direttamente tramite l’interfaccia utente. L’al-tro metodo per introdurre valori di certezza è quello di inserirli direttamenteall’interno delle regole presenti nella base di conoscenza. Quest’ultimo metodo,tuttavia, non è impiegabile dall’utente finale ma soltanto dall’ingegnere dellaconoscenza 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. Intal caso è necessario stabilire quanto vale globalmente la certezza della premessadi una regola.

Il criterio che ho utilizzato nel sistema esperto realizzato è quello della mediaaritmetica. 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 conse-guenza

Sempre con riferimento all’esempio precedente, si pone il problema di comecalcolare il valore di certezza della parte conseguente della regola. In altreparole 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 certezzaglobale delle premesse con quello proprio della regola (indicato dall’ingegneredelle conoscenza).

batteriaAutoGuastaconseguenza = 0.5 ∗ 0.7 = 0.35

In questo modo la parte conseguente della regola avrà un valore di certezzadi 0.35.

2.2 CapacitàIl sistema esperto in esame è consegnato con una base di conoscenza relativa allaclassificazione di uccelli ed imita il comportamento di un esperto che interrogal’utente chiedendogli informazioni sull’uccello da classificare.


L’utente risponde alle domande del sistema esperto indicando, oltre allarisposta, 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 livellodi certezza.

Il sistema è in grado di memorizzare i fatti ed i relativi livelli di certezza, inmaniera da recepirli e chiedere all’utente solo le informazioni delle quali neces-sita. In particolare, il numero e l’ordine delle domande dipendono fortementedalle risposte che l’utente fornisce via via.

2.3 Primo avvioIl sistema esperto è stato realizzato in ambiente YAP Prolog v.5.1.3 installatosu Mac OS X 10.6.2. E’ stato tuttavia testato anche in ambiente Windows concompilatore YAP Prolog v.5.1.2.

Per avviare il sistema esperto è sufficiente copiare la cartella _PESU in unaqualsiasi directory di sistema. Dopo aver fatto ciò avviate il compilatore Prologe digitare la seguente stringa:

reconsult(’<path>/_PESU/init.prolog’).

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

2.4 FunzionamentoIl 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 trattadi caricare la libreria di predicati predefiniti per la gestione delle liste, abilitareil controllo attivo sulle clausole e rendere dinamici alcuni predicati.


2.4.1 Meccanismo di inferenzaLa componente relativa al meccanismo di inferenza contiene una serie di utilitytrasversali al sistema esperto (utilizzate da diversi predicati) e la definizione delpredicato di valutazione e propagazione del livello di certezza.

Il predicato di valutazione globale utilizza a sua volta due predicati rispetti-vamente preposti alla valutazione della parte conseguente ed antecedente di unaregola.

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 eventual-mente inseriti dall’ingegnere della conoscenza direttamente all’interno della basedi conoscenza. Il secondo serve a ripristinare i fatti precedentemente memoriz-zati al fine di preservare la possibilità di lanciare più volte il sistema espertosenza dover necessariamente riavviare il compilatore.

I fatti inseriti tramite interfaccia grafica sono considerati soltanto duran-te l’esecuzione immediatamente successiva del sistema esperto. Al termine ditale esecuzione, tali fatti vengono rimossi. All’utente è comunque lasciata lapossibilità di reintrodurre fatti tramite interfaccia.

Quando si avvia il sistema esperto, esso esamina gli eventuali fatti dichia-rati (sia nella base di conoscenza che tramite interfaccia) e comincia a chiedereinformazioni solo di quegli attributi dei quali non sa nulla.

Se i fatti asseriti prima della risoluzione fossero sufficienti a classificare cor-rettamente l’uccello, non verrebbe posta alcuna domanda all’utente e verrebbecomunicato 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 attri-buto abbia un determinato valore e a prescindere dal carattere della risposta(positiva o negativa) chiede di inserire il livello di certezza.


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

2.4.2 Interfaccia utenteIl sistema esperto è corredato di una interfaccia utente a riga di comando checonsente una più facile interazione con l’utente finale.

Il sistema è in grado di esibire la propria interfaccia utente in diverse lin-gue. In particolare, il sistema esperto oggetto di questo documento offre unainterfaccia in italiano ed in inglese.

L’architettura per la gestione dell’interfaccia utente è tuttavia estremamentegenerale e consente, a chi lo desideri, di implementare un numero di lingue bensuperiori.


All’avvio dell’inizializzatore appare un messaggio di benvenuto seguito dal-l’elenco dei comandi che possono essere utilizzati: il sistema accetterà solo icomandi indicati nella legenda.

Nel caso venga inserito un comando non riconosciuto, viene mostrato unmessaggio di errore come in figura. Il sistema si rimetterà in attesa di uncomando 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: inquesto caso di tratta di un fatto affermativo.

Il secondo e terzo argomento indicano rispettivamente l’attributo oggettodell’asserzione ed il relativo valore assunto. Il quarto argomento indica il valoredi certezza espresso come numero in virgola mobile.


Nell’esempio di cui sopra si è asserito che l’attributo size ha valore large conun 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 impli-citamente asserire fatti affermativi. In tal senso all’utente verrà chiesto tramiteinterfaccia di introdurre solo gli ultimi 3 argomenti del predicato known.

Come già detto in 2.4.1, i fatti asseriti tramite interfaccia vengono conside-rati solo durante la prima esecuzione del sistema esperto (tramite 2.4.2.3). Altermine di tale esecuzione sarà necessario reinserire i fatti.

A tal proposito, all’interno della base di conoscenza vi è una sezione dedi-cata appositamente alla dichiarazione di fatti che si vuole siano validi per tuttal’esecuzione del sistema (anche dopo ripetuti processi di risoluzione).

Tutti i fatti dei quali il sistema esperto necessita e che non sono stati asseritivengono richiesti durante l’esecuzione dello stesso.

L’asserzione di fatti è un’operazione che dovrebbe essere eseguita dall’utenteche ha conoscenza delle modalità di formalizzazione dei dati. L’asserzione difatti su attributi non esistenti (non dichiarati nella base di conoscenza) va abuon 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. Ilcomando è in grado di mostrare a video sia i fatti temporanei inseriti tramiteinterfaccia (vedi 2.4.2.1) che quelli permanenti inseriti direttamente all’internodella base di conoscenza (vedi 2.4.3).


Nella lista sono presenti tutte le informazioni necessarie a descrivere un fat-to. 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 li-vello di certezza. Nel caso dei fatti temporanei è presente anche il caratteredell’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 ilcomando 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 temporaneamentetramite interfaccia (vedi 2.4.2.1).

Dopo la fase di caricamento dei fatti viene eseguito il processo di ragiona-mento tramite il quale il sistema esperto cerca di quale sia il tipo di uccelloposseduto dall’utente. Durante questa fase, il sistema ha bisogno di informazio-ni che possono essere chieste direttamente all’utente tramite interfaccia grafica.Se tra i fatti vi sono già le informazioni necessarie, il sistema esperto eviterà didomandarle all’utente.

Il numero di domande, il loro ordine e la notifica del risultato dipendonoesclusivamente dai fatti asseriti. In particolare, è interessante sottolineare chel’ordine delle domande cambia in funzione delle risposte via via ricevute.

Il sistema passo dopo passo esclude delle risposte ed interroga l’utente dina-micamente. 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 visua-lizza informazioni aggiuntive circa il risultato ottenuto.

Alla stessa stregua di quanto avviene nella fase di risoluzione classica, i fattinon asseriti direttamente all’interno della base di conoscenza (quindi quelli as-


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 riso-luzione si rimanda a 2.4.2.3.

Nella sua definizione esso dipende fortemente dalla base di conoscenza. Inparticolare, fornisce informazioni utili circa la famiglia di appertenenza dell’uc-cello ed il suo tipo.

2.4.2.5 Comando ’aiuto’

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

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


2.4.2.6 Comando ’chiudi’

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

2.4.3 Base di conoscenzaLa base di conoscenza sviluppata in questo caso di studio riguarda l’identifica-zione di alcuni tipi di uccelli a partire dalle loro caratteristiche fenotipiche.

Ogni specie di uccello appartiene ad una certa famiglia, ad una certa cate-goria e presenta delle proprietà fisiche che lo caratterizzano univocamente.

Da un punto di vista più profondo, anche un task di classificazione chesegue regole ben comprovate non può essere infallibile. Per questa ragione labase di conoscenza che utilizza il sistema esperto contiene alcune delle regole diclassificazione 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 formalizzazionedelle regole necessarie al sistema esperto per classificare correttamente un uc-cello. Tali regole sono esattamente quelle di competenza dell’ingegnere dellaconoscenza, il cui compito è quello di formalizzare la conoscenza dell’espertoumano.


Essa contiene la descrizione formale di ciascun uccello, in termini della suafamiglia di appartenenza, del suo tipo e dei suoi caratteri estetici. A sua volta,anche la famiglia (ed il tipo), sono informazioni desumibili da alcune precisecaratteristiche 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 essereprecise oppure generiche (vedi 2.4.1).

2.4.3.2 Localizzazioni

La parte di localizzazione è opzionale e serve per tradurre in quante lingue sivoglia 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 considerateper tutta la durata del sistema (anche dopo riavii multipli del risolutore). Talefunzionalità può essere utilizzata qualora un utente debba classificare un insie-me di uccelli che condividono alcune caratteristiche. In questo caso il sistemaesperto non seccherà l’utente con le stesse domande.

Oltre ad essere inseriti direttamente nella base di conoscenza, questi possonoanche essere asseriti utilizzando l’interfaccia grafica del sistema esperto (vedi2.4.2.1). In quest’ultimo caso, tuttavia, è necessario asserire i fatti desiderati adogni risoluzione.

2.5 Uno sguardo al codiceIn questa sezione analizziamo il codice Prolog del sistema esperto, spiegando indettaglio i predicati chiave. Di seguito il diagramma che sintetizza l’interfacciautente di PESU.


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 dal-l’utente. Per la lettura dell’input dell’utente sono stati utilizzati dei predicatispecifici che incapsulano il classico read, implementando anche un controllo suldominio. Ad esempio, nel caso dell’inserimento di un valore di certezza (predi-cato get_user_cert) è necessario inserire un numero con virgola; se ciò nonavvenisse, all’utente verrebbe richiesto di inserire nuovamente un valore corret-to. Il procedimento termina solo quando l’utente inserisce i dati nella formarichiesta.

Dopo aver letto i tre valori, il predicato say asserisce il fatto con connota-zione 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, chesono attivi nel sistema esperto (vedi 2.4.2.2).

Di seguito l’implementazione:


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 loroesaurimento, rimuovendoli dalla working memory, dopo ciò procede al ripristinocon il predicato restore_facts. Più che di una rimozione si tratta di unariformulazione dei fatti: si aggiunge un parametro supplementare (con valoreloaded).

Il predicato show_fact seleziona il primo fatto permanente asserito nellabase di conoscenza, stampa le informazioni a video, lo rimuove, asserisce la suariformulazione e fallisce (il fallimento è indispensabile per innescare l’iterazionedel repeat).

Il secondo predicato show_fact è identico al precedente a meno di unacaratteristica: seleziona, stampa, rimuove ed asserisce fatti temporanei presentinella working memory.

L’ultimo predicato viene invocato soltanto quando tutti i fatti, sia perma-nenti che temporanei, sono finiti. A quel punto il predicato show_fact risultavero ed il ciclo si interrompe. Dopo viene invocato il predicato restore_facts.

L’obiettivo del suddetto predicato è quello di ripristinare la formulazioneoriginale 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 predicatoshow_facts.


2.5.3 Predicato ’solve’Il comando risolvi serve a lanciare il sistema esperto (vedi 2.4.2.3). Di seguitoil diagramma dei predicati utilizzati:

Il predicato principale per l’esecuzione del sistema esperto, è il predicatosolve. 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 è discri-minante, poiché se fallisce viene utilizzata la seconda definizione del predicatosolve. Se il predicato top_goal ha successo allora viene ripulita la wor-king memory dai fatti temporanei (vengono definitivamente persi) e permanenti(vengono recuperati nuovamente con il predicato load_fact) e viene stampatoa video il risultato, in termini di uccello classificato e livello di certezza dellarisposta 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).


Il predicato top_goal comincia a verificare, in modo ordinato, le caratte-ristiche richieste all’interno della base di conoscenza. Ogni caratteristica vieneverificata tramite il predicato ask o menuask.

In entrambi i casi, che differiscono solo per la modalità di interfaccia, vie-ne prima verificato che l’attributo richiesto non sia già presente nella workingmemory, nel qual caso è inutile chiedere all’utente. Se nella working memorynon vi sono informazioni sull’attributo in esame dal sistema esperto, allora ilsistema 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 ulterioridettagli 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 tipodi 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(’ dico. - Asserire un fatto;’), nl,

write(’ fatti. - Visualizza i fatti asseriti;’), nl,

write(’ risolvi. - Avvia il sistema esperto;’), nl,

write(’ dettagli.- Avvia il sistema esperto e fornisce piu\’ informazioni;’), nl,

write(’ aiuto. - Consultare la guida;’), nl,

write(’ chiudi. - Chiudere l\’interfaccia grafica;’), nl.

Si tratta di una banale stampa di informazioni a video.


2.5.6 Predicato di chiusuraLa chiusura dell’interfaccia è implementata mediante un controllo direttamenteall’interno del predicato main. Quest’ultimo predicato serve a lanciare il sistemaesperto 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 (checontiene 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 arestituire il prompt principale.

Per agevolare il debugging nel periodo di sviluppo, e conservare la possibi-lità di interagire con il sistema senza utilizzare l’interfaccia, si è scelto di noncancellare 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


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

[1] Vitor Santos Costa. Yap prolog user’s manual, 06 2008.

[2] P. Mello L. Console, E. Lamma. Programmazione logica in Prolog. UTETLibreria, 1991.

[3] E. Shapiro L. Sterling. The Art of Prolog: Advanced ProgrammingTechniques 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 underuncertainty. Working paper series of New York University, 1989.

[6] L. A. Zadeh. Fuzzy sets. Information and Control, 8(3):338–353, June 1965.

33

Sistema esperto in Prolog con ragionamento incerto

Documents

Transcript of Sistema esperto in Prolog con ragionamento incerto