Sei sulla pagina 1di 34

Sistema esperto Prolog con ragionamento

incerto

Michele Filannino

16 Marzo 2010
Indice

1 Introduzione 3
1.1 Sistemi esperti . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Prolog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Il ragionamento incerto . . . . . . . . . . . . . . . . . . . . . . . 5

2 Prolog Expert System with Uncertainty (PESU) 7


2.1 Premesse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.1 MYCIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.1.1 Determinare il livello di certezza delle premesse . 8
2.1.1.2 Combinare il livello di certezza delle premesse e
della conseguenza . . . . . . . . . . . . . . . . . 8
2.2 Capacità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3 Primo avvio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.4 Funzionamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.4.1 Meccanismo di inferenza . . . . . . . . . . . . . . . . . . . 10
2.4.2 Interfaccia utente . . . . . . . . . . . . . . . . . . . . . . . 11
2.4.2.1 Comando ’dico’ . . . . . . . . . . . . . . . . . . 12
2.4.2.2 Comando ’fatti’ . . . . . . . . . . . . . . . . . . 13
2.4.2.3 Comando ’risolvi’ . . . . . . . . . . . . . . . . . 14
2.4.2.4 Comando ’dettagli’ . . . . . . . . . . . . . . . . 14
2.4.2.5 Comando ’aiuto’ . . . . . . . . . . . . . . . . . . 15
2.4.2.6 Comando ’chiudi’ . . . . . . . . . . . . . . . . . 16
2.4.3 Base di conoscenza . . . . . . . . . . . . . . . . . . . . . . 16
2.4.3.1 Conoscenza . . . . . . . . . . . . . . . . . . . . . 16
2.4.3.2 Localizzazioni . . . . . . . . . . . . . . . . . . . 17
2.4.3.3 Fatti . . . . . . . . . . . . . . . . . . . . . . . . 17
2.5 Uno sguardo al codice . . . . . . . . . . . . . . . . . . . . . . . . 17
2.5.1 Predicato ’say’ . . . . . . . . . . . . . . . . . . . . . . . . 18
2.5.2 Predicato ’show_facts’ . . . . . . . . . . . . . . . . . . . . 18
2.5.3 Predicato ’solve’ . . . . . . . . . . . . . . . . . . . . . . . 20
2.5.4 Predicato ’details’ . . . . . . . . . . . . . . . . . . . . . . 21
2.5.5 Predicato ’help’ . . . . . . . . . . . . . . . . . . . . . . . . 21
2.5.6 Predicato di chiusura . . . . . . . . . . . . . . . . . . . . . 22

1
INDICE 2

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


za 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’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 Prolog
Prolog (PROgrammation en LOGique) è un linguaggio di programmazione di-
chiarativo. 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 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 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 Za-
deh 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. Vicever-
sa, 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’al-
tro 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 conse-


guenza
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 neces-
sita. 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 rispetti-
vamente 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 eventual-
mente inseriti dall’ingegnere della conoscenza direttamente all’interno della base
di conoscenza. Il secondo serve a ripristinare i fatti precedentemente memoriz-
zati 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 duran-
te 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 dichia-
rati (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 cor-
rettamente 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 attri-


buto 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 lin-
gue. 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 dal-


l’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 impli-
citamente 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 conside-
rati 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 dedi-
cata 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 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 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 ragiona-
mento 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 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à 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 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 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 riso-
luzione 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’uc-
cello 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’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 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 uc-
cello. 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 insie-
me 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 dal-
l’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 (predi-
cato get_user_cert) è necessario inserire un numero con virgola; se ciò non
avvenisse, all’utente verrebbe richiesto di inserire nuovamente un valore corret-
to. 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 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, 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 perma-
nenti 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 è discri-
minante, poiché se fallisce viene utilizzata la seconda definizione del predicato
solve. 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 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 caratte-


ristiche 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, vie-
ne 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(’ 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.


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 possibi-
lità 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