Stefano Bragaglia MSc Thesis, awarded as Best Italian thesis in AI 2009/2010

Universit` degli Studi di Bologna
a
`
FACOLTA DI INGEGNERIA
Corso di Laurea in Ingegneria Informatica
Intelligenza Artiﬁciale

RAGIONAMENTO
CON PROGRAMMAZIONE LOGICA
A DISGIUNZIONE ANNOTATA

Tesi di laurea di:

Relatore:

Stefano Bragaglia

Chiar. mo Prof. Ing.

Paola Mello
Correlatori:

Dott. Ing.
Dott. Ing.

Fabrizio Riguzzi

Federico Chesani

Anno Accademico 2008-2009
Sessione I

Indice
Introduzione

5

1 ProbLog

9

1.1

Programmi ProbLog . . . . . . . . . . . . . . . . . . . . . . .

9

1.1.1

Cenni di Programmazione Logica . . . . . . . . . . .

9

1.1.2

Sintassi e semantica del linguaggio ProbLog . . . . .

10

Calcolo delle probabilit` di successo . . . . . . . . . . . . . .
a

11

1.2.1

Espressioni booleane e forme normali . . . . . . . . .

11

1.2.2

Interrogazioni ProbLog come formule DNF . . . . . .

13

1.2.3

Diagrammi decisionali binari . . . . . . . . . . . . . .

15

1.2.4

Calcolo della probabilit` delle formule DNF . . . . .
a

17

1.3

Esempio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

18

1.4

Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

21

1.2

2 LPAD

23

2.1

Programmi LPAD . . . . . . . . . . . . . . . . . . . . . . . . .

23

2.1.1

Cenni di Programmazione Logica . . . . . . . . . . .

23

2.1.2

Sintassi e semantica del linguaggio degli LPAD . . .

25

Calcolo delle probabilit` di successo . . . . . . . . . . . . . .
a

27

2.2.1

Interrogazioni sugli LPAD come formule DNF . . . .

27

2.2.2

Calcolo della probabilit` delle formule DNF . . . . .
a

27

2.3

Esempio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

28

2.4

Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

31

2.2

2

INDICE

3 Algoritmi esistenti

33

3.1

Cenni architetturali . . . . . . . . . . . . . . . . . . . . . . . .

33

3.2

Algoritmi ProbLog . . . . . . . . . . . . . . . . . . . . . . . .

36

3.2.1

Inferenza esatta . . . . . . . . . . . . . . . . . . . . . .

36

3.2.2

Inferenza approssimata con bound sulla probabilit` .
a

37

3.2.3

Inferenza approssimata ai risultati migliori . . . . . .

38

3.2.4

Inferenza approssimata con approccio statistico . . .

39

Algoritmi LPAD . . . . . . . . . . . . . . . . . . . . . . . . . .

40

3.3.1

Inferenza esatta con risoluzione SLDNF . . . . . . . .

40

Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

42

3.3
3.4

4 Estensioni proposte

45

4.1

Algoritmo esatto . . . . . . . . . . . . . . . . . . . . . . . . .

45

4.2

Algoritmo iterativo con vincolo sulla probabilit` . . . . . . .
a

46

4.3

Algoritmo approssimato Best-First . . . . . . . . . . . . . . .

47

4.4

Algoritmo approssimato K-Best . . . . . . . . . . . . . . . . .

48

4.5

Algoritmo approssimato K-First . . . . . . . . . . . . . . . . .

50

4.6

Algoritmo stocastico Monte Carlo . . . . . . . . . . . . . . .

51

4.7

Algoritmo stocastico Monte Carlo con memoria . . . . . . .

53

4.8

Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

55

5 Esperimenti
5.1

57

Grafi a percorsi paralleli . . . . . . . . . . . . . . . . .

58

5.1.2

Grafi a percorsi ramificati . . . . . . . . . . . . . . . .

62

5.1.3

Grafi a percorsi ridondanti . . . . . . . . . . . . . . .

68

Test su dataset reali . . . . . . . . . . . . . . . . . . . . . . . .

83

5.2.1

Dataset di dati biologici . . . . . . . . . . . . . . . . .

83

5.2.2
5.3

57

5.1.1

5.2

Test sintetici . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Dataset di reti sociali . . . . . . . . . . . . . . . . . . .

84

Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

88

Conclusioni

89

Ringraziamenti

93

INDICE

3

Bibliograﬁa

95

Elenco degli algoritmi

99

Elenco delle ﬁgure

101

Elenco delle tabelle

103

Introduzione
Fin dai primi anni ’50, la possibilit` di combinare logica e probabilit`
a
a
ha affascinato filosofi ed esperti di intelligenza artificiale [Car50, Gai64,
`
SK66, Hal90]. Negli ultimi vent’anni, questo campo di ricerca e stato oggetto di rinnovato interesse grazie al lavoro svolto da molte Universit`
a
e Centri di Ricerca nel campo dell’Apprendimento Relazionale Statistico
[GT07] e della Programmazione Logica Induttiva Probabilistica [RFKM08].
I numerosi formalismi che combinano aspetti statistici a quelli relazionali
proposti in questi anni, come ad esempio SLP [Mug00], PLP [Dan91], PHA
[Poo93], PRISM [SK97], pD [Fuh00] ed ICL [Poo97], ne sono un esempio.
Nei casi considerati, si consegue questo risultato semplicemente associando dei valori di probabilit` alle formule logiche dei programmi ed
a
imponendo opportuni vincoli su di loro. In SLP, ad esempio, le clausole
che definiscono lo stesso predicato devono essere mutuamente esclusive.
In PRISM e PHA, invece, le probabilit` possono essere associate solamente
a
ai fatti e si introducono nuovi vincoli per evitare che certe combinazioni
di fatti siano contemporaneamente vere. In pD, infine, non si impongono vincoli esterni ma il motore inferenziale su cui si basa ha limitazioni cos` forti che gli consente di risolvere solamente problemi di piccole
ı
dimensioni.
Questo lavoro si ispira a due importanti formalismi: ProbLog e i Programmi Logici a Disgiunzione Annotata, o LPAD. Il primo nasce dalla
necessit` di analizzare grafi biologici di grandi dimensioni in cui gli archi
a
sono etichettati con valori di probabilit` , mentre il secondo per modellare
a
generici sistemi causali.
`
ProbLog rappresenta l’estensione probabilistica di Prolog piu sempli-

6

Introduzione

ce che si possa realizzare. In pratica consente di etichettare le regole di
un programma logico con valori di probabilit` indipendenti tra di loro.
a
Il contributo innovativo dato da ProbLog consiste nell’introduzione di un
metodo in due fasi per il calcolo della probabilit` di successo di una intera
rogazione. Nella prima raccoglie tutte le spiegazioni dell’interrogazione
grazie al meccanismo di risoluzione SLD di Prolog, quindi converte questo risultato in una espressione booleana in Forma Normale Disgiuntiva,
o formula DNF; poi, nella seconda fase, calcola la probabilit` di questa
a
espressione mediante l’uso di Diagrammi Decisionali Binari, o BDD (dal`
l’inglese Binary Decision Diagrams). Questo metodo puo essere abbina`
to ad algoritmi di inferenza sia esatti che approssimati ed e in grado di
affrontare problemi di milioni di nodi e di archi.
Gli LPAD, invece, sono un formalismo particolarmente interessante
per la versatilit` della sintassi e per la semplicit` e la chiarezza della sea
a
mantica che rende i propri programmi molto leggibili ed equivalenti ad
altri famosi sistemi probabilistici. Diversamente da quelle dei programmi
`
ProbLog, le clausole degli LPAD possono essere disgiuntive ed e possibile
associare una probabilit` ad ogni singolo atomo presente nelle loro teste.
a
Come i programmi ProbLog, gli LPAD assegnano un valore di probabilit`
a
alle interrogazioni logiche e utilizzano un interprete top-down derivato
dal motore inferenziale di Prolog per determinare le spiegazioni dell’interrogazione ed un software di gestione dei BDD per calcolarne la probabilit`
a
equivalente. Gli LPAD implementano inoltre un metodo alternativo per il
calcolo della probabilit` con il quale la parte di programma esplorato dal
a
meccanismo di risoluzione SLDNF viene convertito in una rete bayesiana
`
ma sfortunatamente non e altrettanto efﬁcace.
Con questo lavoro vogliamo costruire un sistema che combini i vantaggi derivanti dall’adozione del linguaggio LPAD e della risoluzione SLDNF
introdotti in [Rig07] e i miglioramenti tecnologici in ambiente ProbLog
presentati in [KCR+ 08]. In particolare abbiamo presentato un algoritmo di
risoluzione esatto che coniuga la ﬂessibilit` degli LPAD con le innovazioa
ni dell’interprete ProbLog e diversi algoritmi euristici che implementano
molte soluzioni complementari. Tra questi citiamo un algoritmo basato su

7

approccio iterativo semplice (Depth-Iterative), tre algoritmi euristici (BestFirst, K-Best e K-First) e gli ultimi due basati su approccio probabilistico
(due varianti di Monte Carlo).
Inoltre abbiamo condotto diversi esperimenti sia su dataset artificiali
che su grafi biologici e reti sociali. Rispetto all’algoritmo esatto, gli algoritmi
statistici si sono dimostrati particolarmente efficaci in ogni contesto, mentre quelli approssimati sono stati condizionati dai limiti tecnologici dell’interprete Prolog adottato e sebbene abbiano mostrato importanti margini di
miglioramento, non hanno potuto esprimere tutto il loro potenziale.
`
La tesi e organizzata come segue. Nel capitolo 1 si introduce ProbLog,
un primo formalismo basato sulla conoscenza incerta. Dopo una breve
introduzione su alcune nozioni preliminari e sui concetti cardine su cui si
basa, si descrive la sintassi e la semantica dei suoi programmi ed il corrispondente metodo di risoluzione. Allo stesso modo, nel capitolo 2 si
presentano gli LPAD, un altro formalismo di conoscenza incerta. Anche in
questo caso, dopo averne descritto le caratteristiche principali, se ne analizza la sintassi, la semantica ed i metodi di risoluzione che utilizza. Nel
capitolo 3, invece, si descrivono ed analizzano tutti gli algoritmi utilizzati dai pacchetti software precedentemente introdotti evidenziandone, in
particolar modo, pregi e difetti. Nel capitolo 4 si espongono le estensioni
realizzate in ambiente YAP-Prolog come miglioramento degli algoritmi esistenti e le motivazioni che ne hanno suggerito l’adozione, mentre nel capitolo 5 si presentano i risultati degli esperimenti condotti con dati sintetici
e database reali su tali applicazioni. Infine si espongono le conclusioni a
`
cui si e pervenuti e si delineano i possibili sviluppi futuri.

Capitolo 1
ProbLog
In questo primo capitolo verranno dapprima richiamati i concetti preliminari e la terminologia propri della Programmazione Logica e successivamente si
introdurr` ProbLog ([DRKT07], [KCR+ 08]), un’importante estensione probabia
listica di Prolog.
Nel seguito tratteremo la sintassi e la semantica di questo linguaggio e, dopo aver introdotto le espressioni booleane in forma normale disgiunta ed
i diagrammi decisionali binari, mostreremo come sia possibile convertire in
una formula DNF qualsiasi interrogazione ProbLog e come sia possibile valutarne la probabilit` . I concetti appena introdotti verranno ulteriormente chiariti
a
nell’esempio che conclude il capitolo.

1.1 Programmi ProbLog
1.1.1 Cenni di Programmazione Logica
Di seguito sono riportate alcune deﬁnizioni preliminari di Programmazione Logica, con riferimento a [Llo87].
`
Un generico programma logico T e un insieme di formule, dette clausole,
espresse nella forma
h ← b1 , . . . , b m

10

ProbLog

`
in cui h e un atomo e b1 , . . . , bm sono i suoi letterali. h e b1 , . . . , bm sono
detti rispettivamente testa e corpo della clausola. Se il corpo non contiene
`
letterali negativi, la clausola si dice definita. Se il corpo e vuoto, la clau`
sola prende il nome di fatto. La sola formula ← b1 , . . . , bm e nota come
interrogazione o goal.
Un termine, un atomo, un letterale o una clausola si dicono ground se
`
non contengono alcuna variabile. Una sostituzione θ e un assegnamento di
termini a variabili: θ = {V1 /t1 , . . . , Vn /tn }. L’applicazione di una sostituzione ad un termine, un atomo, un letterale o una clausola C si indica con Cθ e
consiste nella sostituzione delle variabili che compaiono in C ed in θ con
`
i termini specificati in θ. Cθ rappresenta una istanza di C. Se C e ground,
`
Cθ e una istanza ground di C.

1.1.2 Sintassi e semantica del linguaggio ProbLog
`
`
ProbLog e stato pensato come l’estensione probabilistica di Prolog piu
semplice che si possa realizzare. Per questo motivo la sintassi dei pro`
grammi ProgLog e quasi del tutto identica a quella dei programmi Prolog.
`
In particolare, un generico programma ProbLog e composto da un insieme
di fatti etichettati con probabilit` pi :: ci e da un insieme di clausole definite.
a
`
Ogni fatto ci e vero con probabilit` pi . Inoltre si presume che tutti i fatti
a
siano mutualmente indipendenti. Si noti che le clausole definite permettono di aggiungere conoscenza di fondo arbitraria e ci si riferisce a loro come
BK (dall’inglese background knowledge).
Ad ogni programma ProbLog corrisponde un grafo probabilistico che
`
puo essere utilizzato per campionare i sottografi decidendo arbitrariamente se includere o escludere ogni arco del grafo. In pratica un programma
ProbLog T = {p1 :: c1 , · · · , pn :: cn } ∪ BK definisce una distribuzione di
probabilit` sui sottoprogrammi L ⊆ LT = {c1 , · · · , cn } tale che
a
P (L|T ) =

pi
ci ∈L

(1 − pi ).
ci ∈LT L

`
Ora ci si puo chiedere quale sia la probabilit` che esista un percorso tra
a

1.2 Calcolo delle probabilit` di successo
a

11

due nodi qualsiasi del grafo probabilistico che equivale a chiedersi quale
sia la probabilit` che un sottografo campionato a caso contenga un pera
`
corso diretto o uno o piu percorsi indiretti (o una combinazione qualsiasi
di questi) tra i due nodi in esame. Formalmente, la probabilit` di successo
a
`
Ps (q|T ) di una interrogazione q in un programma ProbLog T e definita
come
P (q|L) · P (L|T )

Ps (q|T ) =
L⊆LT

in cui P (q|L) = 1 se esiste una sostituzione θ tale che L ∪ BK |= qθ o
P (q|L) = 0 in caso contrario.
Di conseguenza, la probabilit` di una dimostrazione specifica, anche
a
`
detta spiegazione, e quella di campionare un programma logico L che contiene tutti i fatti richiesti da quella spiegazione o dimostrazione. La proba`
bilit` esplicativa Px (q|T ) e definita come la probabilit` della spiegazione o
a
a
`
della dimostrazione piu probabile dell’interrogazione q
Px (q|T ) = max P (e|T ) = max
e∈E(q)

e∈E(q)

pi
ci ∈e

`
in cui E(q) e l’insieme di tutte le spiegazioni per l’interrogazione q.

a
1.2.1 Espressioni booleane e forme normali
`
La logica proposizionale e quella branca della matematica che ha a che
fare con i valori di verit` . Date le costanti logiche vero 1 e falso 0, si dice vaa
riabile booleana o variabile proposizionale una qualsiasi variabile in grado di
assumere una costante logica qualsiasi come valore. Una generica espres`
sione booleana t e definita come composizione di variabili booleane median`
te gli operatori binari di congiunzione (il cui simbolo e ∧ o ·), e di disgiunzione (∨ o +) e l’operatore unario di negazione (¬ o un tratto orizzontale posto
sopra alla variabile negata).

12

ProbLog

Per ogni possibile assegnamento dei valori di verit` alle variabili che vi
a
compaiono, il valore di una espressione booleana t si calcola in base al contenuto delle tabelle di verit` standard. L’insieme dei valori di verit` si indica
a
a
generalmente con B = {0, 1}. Dato un qualsiasi criterio di ordinamento delle
`
variabili di una espressione booleana t, l’espressione booleana stessa puo
essere vista come una funzione suriettiva f : Bn → B in cui n esprime il
numero di variabili che compaiono in t. Si noti che il criterio di ordinamen`
to delle variabili di una espressione booleana e essenziale per deﬁnire le
funzioni. Inoltre, come si vedr` in seguito, tale criterio gioca un ruolo crua
ciale anche nella costruzione di rappresentazioni compatte per le espressioni
booleane.
Due espressioni booleane si dicono equivalenti se producono lo stesso
valore di verit` per ogni assegnamento delle variabili. Una espressione booa
`
leana e una tautologia se risulta sempre vera per ogni assegnamento delle
variabili. Una espressione booleana si dice soddisfacibile se risulta vera per
almeno un assegnamento di verit` .
a
Una espressione booleana si dice in forma normale disgiuntiva DNF (acronimo del termine inglese Disjunctive Normal Form) se consiste in una disgiunzione di congiunzioni di termini del tipo
(t1 ∧ · · · ∧ t11 ) ∨ · · · ∨ (tl ∧ · · · ∧ tl l )
1
k
1
k
in cui ogni termine tj e una variabile in forma vera xj o in forma negata
i `
i
¬xj . La ben nota funzione di disuguaglianza, per esempio, si esprime come
i
(x ∧ ¬y) ∨ (¬x ∧ y).
`
`
La formula per le espressioni DNF puo anche essere scritta in maniera piu
succinta utilizzando la versione indicizzata degli operatori di congiunzione e di disgiunzione:
l

j=1




kj

i=1



tj  .
i

Esiste una seconda forma normale per le espressioni booleane det-

a

13

ta forma normale congiuntiva CNF (dal termine inglese Conjunctive Normal
`
Form) che e il duale della precedente e che consiste in una congiunzione
di disgiunzioni di variabili booleane in forma vera o negata esprimibile
come:
l

j=1




kj

i=1



tj  .
i

`
`
Si puo dimostrare che qualsiasi espressione booleana e equivalente (e quindi riconducibile) ad una sola espressione DNF minima e ad una sola espressione CNF minima.
In termini generali, stabilire se una certa espressione booleana sia sod`
disfacibile e una operazione piuttosto complicata. In particolare, Cook ha
`
dimostrato in [Coo71] che questo tipo di problemi e NP completo. Grazie
a questo postulato, si sa che il problema della veriﬁca della soddisfacibilit` e NP completo anche per le espressioni CNF, mentre per le espressioni
a`
`
DNF e solamente polinomiale. Analogamente, il problema della tautolo`
`
gia e difﬁcile per le espressioni DNF (per la precisione e co-NP completo) e
viceversa per quelle CNF. Alla luce di queste considerazioni, si potrebbe
pensare di calcolare la soddisfacibilit` di una espressione booleana grazie
a
alla sua forma DNF e di effettuare il controllo di tautologia grazie alla sua
`
forma CNF, tuttavia la conversione da una forma all’altra e una operazione
di complessit` esponenziale nel numero delle variabili e quindi attuabile
a
solo per problemi di dimensioni contenute.

1.2.2 Interrogazioni ProbLog come formule DNF
Per studiare l’insieme dei programmi logici in cui una interrogazio`
ne puo essere provata, occorre considerare la sola parte logica LT della
teoria T su cui viene effettuata l’interrogazione. Di seguito si descrive
come questo insieme di programmi logici, o dimostrazioni, possa essere
rappresentato da una formula DNF.
Per pervenire a questo risultato si utilizza la risoluzione SLD da cui
deriva anche il meccanismo di inferenza di Prolog. I percorsi dalla radice
ad ogni singola foglia di un albero SLD rappresentano delle dimostrazio-

14

ProbLog

ni. Queste dimostrazioni possono avere successo (terminano in un goal
vuoto, generalmente indicato con

) o fallire (terminano in un goal non

`
vuoto e che non puo essere ulteriormente sviluppato). Per ogni dimostra`
zione con successo si puo costruire una risposta tramite una sostituzione
θ che rende vero il goal iniziale.
Il risolutore SLD genera l’albero grazie ad un procedimento top-down,
inizializzando il nodo radice con l’interrogazione q da dimostrare ← l1 ,
· · · , ln e successivamente generando ricorsivamente ogni meta−interrogazione ← b1 θ, · · · , bm θ, l2 θ, · · · , ln θ per ogni clausola h ← b1 , · · · , bm del pro`
gramma logico per cui l’uniﬁcatore piu generale di h ed l sia la sostituzione
θ.
Ogni dimostrazione con successo di un albero SLD, dunque, si appoggia ad un insieme di clausole {pi1 :: ci1 , · · · , pik :: cik } ⊆ T utilizzate per
ottenerla. Ovviamente queste clausole sono necessarie alla dimostrazione,
`
e la dimostrazione e completamente indipendente dalle restanti clausole.
Di conseguenza, la probabilit` che questa dimostrazione abbia successo
a
`
e data da

i

`
pi o, in altre parole, e uguale alla somma delle probabilit`
a

dei programmi che contengono le clausole necessarie alla dimostrazione
in esame.
Se a questo punto si introduce una variabile booleana casuale bi per
`
ogni clausola pi :: ci ∈ T per indicare se la clausola ci a cui e associata
faccia parte o no del programma logico, allora la probabilit` di una quala
siasi dimostrazione che coinvolge le clausole {pi1 :: ci1 , · · · , pik :: cik } ⊆ T
equivale alla probabilit` del congiunto bi1 ∧ · · · ∧ bik . Siccome ogni interroa
`
gazione puo avere molteplici dimostrazioni, la probabilit` di successo di una
a
`
interrogazione e uguale alla probabilit` che la disgiunzione dei congiunti
a
`
equivalenti alle dimostrazioni sia vera. In termini matematici cio equivale
a



Px (q|T ) = P 



e∈E (q) bi ∈cl(e)

bi 

in cui E (q) denota l’insieme delle dimostrazioni per l’interrogazione q
e cl (e) l’insieme delle variabili booleane che rappresentano fatti ground

a

15

utilizzati nella dimostrazione e.
In questo modo il calcolo della probabilit` di successo di una intera
rogazione ProbLog si riduce al calcolo della probabilit` di una formula
a
`
DNF che tra l’altro e monotona, dato che tutte le variabili booleane che vi
compaiono sono in forma vera.

1.2.3 Diagrammi decisionali binari
Un diagramma decisionale binario, o BDD (dal termine inglese Binary
`
`
Decision Diagram), e un particolare grafo diretto e aciclico che puo essere
utilizzato per rappresentare in forma compatta una espressione booleana.
`
Ogni BDD e composto da due nodi terminali e da un insieme di nodi
decisionali. I nodi terminali, detti terminale-0 e terminale-1, rappresentano
rispettivamente i valori 0 e 1 delle costanti logiche falso e vero. Ogni nodo
decisionale viene etichettato con il nome di una variabile booleana dell’espressione di partenza ed ha due nodi figlio corrispondenti ai valori
`
che questa puo assumere. Il nodo figlio a cui si perviene assegnando la
`
costante 0 alla variabile booleana associata al nodo decisionale attuale e
detto figlio inferiore. Analogamente il nodo figlio corrispondente all’assegnamento della costante 1 alla variabile booleana associata al nodo padre
`
e detto figlio superiore. Per convenzione, gli archi verso i figli inferiori sono rappresentati mediante una linea tratteggiata mentre quelli verso i figli
superiori con una linea continua. Ne deriva che tutti i nodi decisionali del
BDD hanno semigrado uscente Γ+ = 2 e semigrado entrante Γ− > 0, tranne
quello scelto come nodo radice per il quale Γ− = 0.
Un BDD si dice ordinato (OBDD) se le variabili booleane vengono visitate secondo lo stesso criterio di ordinamento lineare lungo ogni percorso che
`
congiugne il nodo radice con i nodi terminali. Un BDD e in forma ridotta o
semplicemente ridotto (RBDD) quando
• non contiene nodi isomorfi (principio di unicit` ),
a
• non contiene nodi i cui figli siano isomorfi (principio di non ridondanza).

16

ProbLog

(a)

(b)

(c)

Figura 1.1: Tabella di verit` (a), albero decisionale binario (b) e diagramma decia
sionale binario (c) dell’espressione booleana f = (x1 ∧ x2 ) ∨ (x1 ∧ x3 ) ∨
(x2 ∧ x3 ).

Due nodi sono isomorfi quando sono associati alla stessa variabile ed
hanno gli stessi figli inferiore e superiore. Analogamente due figli di uno
stesso nodo sono isomorfi quando il figlio inferiore coincide con quello superiore. Si noti che il contributo informativo offerto da nodi isomorfi di
`
qualsiasi tipo e il medesimo. In altre parole, poich` i nodi isomorfi sono
e
ridondanti, i principi di unicit` e di non ridondanza definiscono una proa
`
cedura di riduzione che e in grado di semplificare i BDD senza perdita di
informazione.
I ROBDD sono una rappresentazione canonica (unica) [And99] per le
`
espressioni booleane. Cio significa che, scelto un criterio di ordinamento
delle variabili a piacere, qualsiasi funzione f : Bn → B corrisponde ad un

a

(a)

17

(b)

(c)

Figura 1.2: Criterio di ordinamento lineare (a), principio di unicit` (b) e principio
a
di non ridondanza (c) dei BDD.

solo ROBDD.
Questa propriet` , insieme ai principi di unicit` e non ridondanza gi`
a
a
a
introdotti, consente di definire operazioni estremamente efficienti sulle epsressioni booleane. Si supponga, ad esempio, di voler verificare l’equivalenza tra due espressioni booleane. Generando e confrontando tra di loro
i ROBDD equivalenti alle funzioni di partenza, il problema risulta avere
complessit` polinomiale mentre per le espressioni booleane era NP-completo.
a
Si noti infine che generalmente quando si parla di BDD ci si riferisce ai
ROBDD. Il loro acronimo completo viene utilizzato solo quando si vogliono enfatizzare gli aspetti di ordinamento e riduzione tipici di questa classe
di BDD.

1.2.4 Calcolo della probabilit` delle formule DNF
a
`
Il calcolo della probabilit` di una formula DNF e un problema NP difa
`
ficile perch` non e detto che tutti i congiunti che vi compaiono siano tra
e
lodo indipendenti. Anche nell’ipotesi di variabili indipendenti prevista
dall’ambiente ProbLog, i singoli congiunti non risultano essere mutualmente esclusivi e possono sovrapporsi. Sono stati sviluppati molti algorit`
mi in grado di affrontare questo problema che in letteratura e noto come
problema della somma dei disgiunti.
`
L’approccio piu semplice, usato tra gli altri da pD, si basa sul principio
di inclusione ed esclusione della teoria degli insiemi ma raggiunge il proprio
limite tecnologico per programmi che generano una decina di dimostrazioni. Altri sistemi come PHA e ICL che consentono dimostrazioni non di-

18

ProbLog

Algoritmo 1.1 Calcolo della probabilit` di un generico nodo del BDD
a
Input: BDD node n
Output: equivalent probability
if n = terminal − 1 then
return 1
else if n = terminal − 0 then
return 0
else
h ← high(n)
prob(h) ← callProbability(h)
l ← low (n)
prob(l) ← callProbability(l)
return pn · prob(h) + (1 − pn ) · prob(l)
end if
sgiunte utilizzano un algoritmo che tuttavia consente di trattare problemi
di dimensioni di poco superiori al caso precedente.
ProbLog invece adotta un nuovo metodo che si avvantaggia dell’uso
dei BDD. Si noti che il criterio di ordinamento delle variabili scelto ha un
grande impatto sulla dimensione e sulla complessit` del BDD risultante.
a
`
Per calcolare la probabilit` dell’espressione booleana corrispondente e
a
sufficiente attraversare il BDD dal nodo radice fino ad uno dei nodi terminali. Per ogni nodo interno occorre calcolare ricorsivamente le probabilit`
a
`
di entrambi i nodi figlio e poi combinarle, come e descritto nell’Algoritmo 1.1. In pratica la memorizzazione dei risultati intermedi evita di dover
`
ricalcolare la probabilit` dei nodi condivisi da piu percorsi.
a
`
L’algoritmo risultante puo essere applicato a domini composti da centinaia di clausole (o variabili booleane) e da decine di migliaia di dimostrazioni (congiunti di variabili).

1.3 Esempio
La Figura 1.3(a) mostra un piccolo grafo probabilistico che funger` da
a
`
esempio. Questo grafo puo essere rappresentato in ProbLog mediante il
seguente programma:

1.3 Esempio

19

(a)

(b)

Figura 1.3: (a) Esempio di grafo probabilistico: le etichette sugli archi esprimono
la probabilit` che l’arco faccia parte del grafo finale. (b) Diagramma
a
decisionale binario che codifica la formula DNF cd ∨ (ce ∧ ed) che
corrisponde alla due spiegazioni per l’interrogazione path(c, d) del
grafo.

0.7 :: edge(a, b).
0.8 :: edge(a, c).
0.6 :: edge(b, c).
0.9 :: edge(c, d).
0.8 :: edge(c, e).
0.5 :: edge(e, d).
`
Si noti che il grafo in esame puo essere utilizzato per campionare i propri
sottografi semplicemente inserendo o escludendo ogni singolo arco in modo casuale. Il programma viene completato dalla seguente conoscenza di
fondo:
path(X, Y ) ← edge(X, Y ).
path(X, Y ) ← edge(X, Z), path(Z, Y ).
In pratica questo programma esprime la probabilit` che esista un pera
corso diretto o indiretto tra due nodi qualsiasi del grafo, ad esempio tra c
e d.

20

ProbLog

Figura 1.4: Albero SLD corrispondente all’interrogazione path(c, d).

In questo caso, l’insieme delle spiegazioni per l’interrogazione path(c, d)
`
e composta da due soli percorsi: l’arco con probabilit` 0.9 tra c e d e la copa
pia di archi da c ad e (con probabilit` 0.8) e da e a d (con probabilit` 0.5).
a
a
Risulta pertanto che
Px (path(c, d)|T ) = max{0.9, 0.8 · 0.5} = max{0.9, 0.4} = 0.9.

`
Grazie al metodo di risoluzione SLD tipico di Prolog, e possibile ottenere tutte le spiegazioni di una interrogazione. La Figura 1.4 mostra l’albero SLD generato per l’interrogazione ← path(c, d). Se si introduce una va`
riabile booleana bi per ogni clausola pi :: ci utilizzata, si puo ottenere la formula DNF corrispondente alla probabilit` di successo dell’interrogazione
a
di partenza che in questo caso risulta essere
Ps (path(c, d)|T ) = P (cd ∨ (ce ∧ ed ))

1.4 Riepilogo

21

in cui il tenerico termine xy rappresenta la variabile booleana corrispondente alla clausola edge(x, y).
Per calcolare la probabilit` della formula DNF appena trovata, occorre
a
`
attraversare il BDD ad essa equivalente. Il BDD per il problema in esame e
riportato in Figura 1.3(b). Poich` la procedura presentata in Algoritmo 1.1
e
`
e ricorsiva, conviene calcolare le probabilit` intermedie a partire dai nodi
a
terminali del BDD. Con pochi passaggi si ottiene:
P (ed) = ped · P (high(ed)) + (1 − ped ) · P (low (ed)) = 0.5
P (ed) = pce · P (high(ce)) + (1 − pce ) · P (low (ce)) = 0.4
P (cd) = pcd · P (high(cd)) + (1 − pcd ) · P (low (cd)) = 0.94
e dunque la probabilit` di successo dell’interrogazione path(c, d) vale:
a
Ps (path|T ) = 0.94.

1.4 Riepilogo
In questo capitolo abbiamo visto come estendere i concetti della programmazione logica per definire il formalismo probabilistico di ProbLog.
Abbiamo descritto la sintassi di questo linguaggio ed analizzato la semantica che questo definisce. Successivamente abbiamo mostrato quali strumenti utilizzi ProbLog per consentire il calcolo efficiente della probabilit`
a
di successo delle interrogazioni: inizialmente ProbLog utilizza la risoluzione SLD di Prolog per raccogliere tutte le spiegazioni possibili e le converte in una unica espressione booleana monotona in forma normale disgiuntiva, quindi sfrutta i diagrammi decisionali binari per calcolarne il
valore in modo efficiente.

Capitolo 2
LPAD
Il tema di questo secondo capitolo sono i Programmi Logici a Disgiunzione
Annotata [VDB06], anche noti come LPAD. Dopo aver richiamato alcuni concetti avanzati di programmazione logica, introdurremo la sintassi e la semantica
del linguaggio utilizzato da questo importante formalismo probabilistico.
Analogamente al caso di ProbLog, vedremo come ricondurre qualsiasi interrogazione sugli LPAD ad una espressione booleana in forma normale disgiunta gi` introdotta nel Capitolo 1.2.1. Inoltre mostreremo come sia possibia
le valutare in modo efficiente le espressioni booleane equivalenti alle interrogazioni per mezzo dei diagrammi decisionali binari anch’essi gi` introdotti nel
a
precedente Capitolo 1.2.3.
L’ultima parte del capitolo, infine, e dedicata ad un esempio che ha lo scopo
`
di chiarire i concetti appena introdotti.

2.1 Programmi LPAD
2.1.1 Cenni di Programmazione Logica
Le seguenti definizioni estendono quanto gi` visto nel Capitolo 1.
a
`
L’universo di Herbrand HU (T ) e l’insieme di tutti i termini che possono
essere costruiti con i simboli funtore che compaiono in T . La base di Her`
brand HB (T ) di un programma T e l’insieme di tutti gli atomi ground che
possono essere costruiti con i predicati ed i simboli funtore che compaiono in

24

LPAD

`
T . Se T contiene simboli funtore di arit` maggiore di 0, allora HB (T ) e infia
nita, finita altrimenti. Il grounding di una clausola C si ottiene sostituendo
le variabili di C con i termini presenti in HU (T ). Il grounding g(T ) di un
`
programma T e il programma che si ottiene sostituendo ogni clausola con
l’insieme di tutti i suoi grounding. Se il programma contiene variabili e
`
simboli funzione, g(T ) e infinito, finito altrimenti.
`
Una interpretazione di Herbrand e un insieme di atomi ground, ad esempio un sottoinsieme di HB (T ). Sia T l’insieme di tutte le possibili interpretazioni di Herbrand di T .
`
Una mappatura di livello di un progamma T e una funzione || : HB (T ) →
N degli atomi ground verso i numeri naturali. Per ogni a ∈ HB (T ), |a| rappresenta il livello di a. Si noti che se l = ¬a, allora |l| = |a| per definizione.
Un programma T si dice aciclico rispetto ad una mappatura di livello se per
`
ogni istanza ground a ← B di una clausola di T , il livello di a e maggiore
del livello di ogni letterale in B. Un programma T si dice aciclico se esiste
almeno un livello di mappatura rispetto al quale T risulta aciclico. Un
`
atomo a e vincolato rispetto ad un livello di mappatura se l’insieme dei
`
livelli di tutte le sue istanze e finito.
`
Un componente W di un programma T e il massimo sottoinsieme delle
regole di T tale che tutti i predicati che compaiono nella testa delle regole di W siano mutualmente ricorsivi, eventualmente tramite negazione.
Sia W la componente di un normale programma T e sia S l’insieme dei
predicati usati da W . Si supponga che S sia completamente definito da
un’interpretazione I su HB (T ). La riduzione di W modulo I si denota con
RI (W ) e si calcola nel modo seguente:
• rendendo ground tutte le regole di W , ottenendo cio` Wg = g(W );
e
• eliminando da Wg tutte le regole che hanno un letterale del proprio
`
`
corpo il cui predicato e in S ed e falso in I;
• eliminando dai corpi delle restanti regole tutti i letterali che hanno
predicati in S e che sono veri;
• ponendo RI (W ) uguale all’insieme delle regole ground rimanenti.

2.1 Programmi LPAD

25

Un normale programma T si dice modularmente aciclico se per ogni
componente W di T esiste un modello completo e ben fondato M per
l’unione di tutti i componenti W

`
W e la riduzione W modulo M e

aciclica.

2.1.2 Sintassi e semantica del linguaggio degli LPAD
`
`
La sintassi di questo nuovo formalismo e leggermente piu complessa di
quella che abbiamo visto nel precedente Capitolo 1, tuttavia la sua seman`
`
`
tica e molto piu espressiva. Questo linguaggio infatti puo essere utilizzato
per rappresentare in modo molto intuitivo problemi molto complessi ed
articolati.
`
Un qualsiasi programma logico a disgiunzioni annotate T (o LPAD) e composto da un insieme di formule, dette clausole, del tipo
h1 : p1 ∨ · · · ∨ hn : pn ← b1 , · · · , bm .
I termini hi e bj che compaiono in ogni clausola C sono detti rispettivamente atomi logici e letterali logici, mentre pi indica un numero reale nell’intervallo [0, 1] che esprime il valore di probabilit` associato all’atomo
a
logico.
Le probabilit` degli atomi logici di una stessa clausola sono tali per cui
a
n
i=1

pi = 1. Se la somma delle probabilit` risulta inferiore ad 1, significa
a

che la testa della clausola sottintende la presenza di un ulteriore atomo
logico che si pone come alternativa a tutti gli altri e a cui compete un valore
di probabilit` p = 1 −
a

n
i=1

pi . Inoltre se per una clausola risulta n = 1,

`
la probabilit` associata al suo unico atomo logico risulta essere p = 1 ed e
a
pertanto possibile omettere la notazione probabilistica dalla formula.
Si definiscono infine testa head (C) e corpo body(C) di una clausola C
l’insieme dei suoi atomi logici e corrispondenti probabilit` {(hi : pi ) : 1 ≤
a
i ≤ n} e l’insieme dei suoi letterali logici {bj : 1 ≤ j ≤ m} rispettivamente.
`
Come per i programmi ProbLog, la semantica degli LPAD e data in
funzione delle sue istanze. In questo caso, tuttavia, per istanza si intende
ogni normale programma ground che si ottiene scegliendo un atomo logico

26

LPAD

dalla testa di ogni clausola del programma e scartandone le relative pro`
babilit` . L’insieme di tutte le istanze I che e possibile ottenere da un LPAD
a
T si chiama grounding di T e lo si denota con TG . Il numero di istanze che
`
fanno parte di un grounding TG e dato dal prodotto del numero di atomi
logici presenti nella testa di ogni clausola del programma T di partenza,
ovvero da

n

|head (Ci )| .
i=1

`
La probabilit` di una istanza Ik ∈ TG e data dal prodotto dei fattori p
a
associati agli atomi logici scelti per quella istanza; in termini matematici
`
cio equivale a
P (Ik ) =

pik .
hik ∈Ik

`
A questo punto ci si puo chiedere quale sia la probabilit` che una qualsiasi
a
interrogazione q abbia successo su certo un programma T .

`
La probabilit` P (q|T ) di una interrogazione q e data dalla somma delle
a
`
probabilit` delle istanze del grounding di T per le quali l’interrogazione e
a
dimostrata, ovvero dall’espressione
(P (q|Ik ) · P (Ik ))

P (q|T ) =
Ik ∈TG

`
in cui P (q|Ik ) = 1 se l’interrogazione q e dimostrata in Ik e P (q|Ik ) = 0
altrimenti.

Dato un qualsiasi LPAD T quindi, la probabilit` di successo di una intera
`
rogazione q e data da


P (q|T ) =
Ik ∈TG

P (q|Ik ) ·



hik ∈Ik

pik  .

a

27

a
2.2.1 Interrogazioni sugli LPAD come formule DNF
Nonostante alcune sostanziali differenze, il concetto di derivazione per
`
i problemi ProbLog e gli LPAD e piuttosto simile.
Come abbiamo visto nel Capitolo 1.2.2 per i programmi ProbLog, una
`
particolare procedura puo ridurre il calcolo della probabilit` di successo
a
di una interrogazione al semplice calcolo della probabilit` di una formula
a
DNF.
Chiaramente i passi logici che descrivono questa procedura non sono
esattamente identici a quelli gi` descritti per i programmi ProbLog e si
a
`
rimanda il lettore al Capitolo 3.3.1 per una trattazione piu dettagliata.

2.2.2 Calcolo della probabilit` delle formule DNF
a
Il metodo per valutare le espressioni booleane in forma DNF intro`
dotto nel Capitolo 1 non puo essere applicato al caso degli LPAD perch`
e
utilizzano variabili multivalore.
Un possibile approccio consiste nella codiﬁca binaria: se una varia`
bile multivalore Xi puo assumere p diversi valori, si possono utilizzare
q = log2 p variabili binarie Xi,1 , · · · , Xi,q per rappresentarla, in cui Xi,1 si
`
riferisce al bit piu signiﬁcativo.
Pertanto per esprimere l’equazione Xi = j mediante variabili binarie
`
si puo operare in questo modo
Xi,1 = j1 ∧ · · · ∧ Xi,q = jq
`
in cui j1 · · · jq e la rappresentazione di j. Una volta convertite tutte le equa`
zioni multivalore in equazioni booleane semplici e possibile procedere alla
costruzione del BDD.
`
La probabilit` delle formule multivalore espresse come BDD puo essea
re valutata con un apposito algoritmo. Si avvale di due funzioni ricorsive
che si chiamano a vicenda: prob e probbool . La funzione prob(n) viene chia-

28

LPAD

mata per valutare una nuova variabile booleana multivalore e restituisce
la probabilit` del nodo n.
a
La funzione probbool , invece, viene chiamata per valutare le singole variabili booleane. Questa funzione costruisce un albero binario avente tanti
livelli quanti sono i bit della variabile multivalore equivalente, in modo
che le chiamate conclusive a probbool sui nodi foglia identifichino un singolo valore e vengano chiamate su un nodo la cui variabile binaria appartenga alla successiva variabile multivalore. Dopodich` probbool chiama
e
prob su quel nodo per valutare la probabilit` del sottografo e restiruisce il
a
prodotto del risultato e della probabilit` associata al valore. Le chiamate
a
intermedie a probbool sommano questi risultati parziali e restituiscono il
totale all’istanza di prob chiamante.
`
Anche questo metodo e ottimizzato come l’equivalente ProbLog. La
funzione prob, infatti, salva il valore della probabilit` che calcola per ogni
a
nodo in modo da recuperarlo immediatamente quando il nodo viene visitato nuovamente.

2.3 Esempio
Consideriamo come esempio un programma in grado di stabilire le
cause e gli effetti dello starnutire, sia esso dovuto ad influenza o ad allergia. Le clausole che descrivono il problema T sono le seguenti:
strong sneezing(X) : 0.3 ∨ moderate sneezing(X) : 0.5 ← flu(X).
strong sneezing(X) : 0.2 ∨ moderate sneezing(X) : 0.6 ← hay fever (X).
flu(david).
hay fever (david).
In pratica si modella il fatto che le cause dello starnutire possano essere l’influenza o l’allergia. L’influenza provoca forti starnuti, starnuti moderati o non provoca del tutto starnuti con probabilit` rispettivamente di
a
0.3, 0.5 e 1 − 0.3 − 0.5 = 0.2. Analogamente l’allergia provoca forti starnuti, starnuti moderati o non provoca del tutto starnuti con probabilit`
a
rispettivamente pari a 0.2, 0.6 e 1 − 0.2 − 0.6 = 0.2.

2.3 Esempio

29

Algoritmo 2.1 Calcolo della probabilit` di un nodo multivalore
a
Input: BDD node n
if n = terminal − 1 then
return 1
else if n = terminal − 0 then
return 0
else
mvar ← multivalue(n)
P ← probbool (n, 0, 1, mV ar)
return P
end if

Algoritmo 2.2 Calcolo della probabilit` di una formula
a
Input: BDD node n
Input: index of the multivalue variable’s value
Input: index of the boolean variable
Input: multivalue variable mvar
if index = mvar.nbit + 1 then
bv ← mvar[value]
return bv · prob(n)
else
bn ← boolean(n)
bi ← mvar[index]
if bn = bi then
h ← high(n)
l ← low (n)
valueshl 1
P ← probbool (h, value+1, index+1, mvar)+probbool (l, value, index+
1, mvar)
return P
else
valueshl 1
P
←
probbool (n, value + 1, index + 1, mvar) +
probbool (n, value, index + 1, mvar)
return P
end if
end if

30

LPAD

Poich` le teste delle ultime due clausole disgiuntive contengono ciae
`
scuna 3 atomi logici (di cui uno e ovviamente sottinteso), il numero di
`
istanze del grounding di T e pari a 3 · 3 = 9.
Si consideri ora l’istanza I6 del grounding TG che si ottiene scegliendo il
secondo atomo logico dalla testa della prima clausola moderate sneezing(X) :
0.5 e l’atomo logico sottointeso dalla testa della seconda clausola, il cui
valore di probabilit` abbiamo stabilito che vale 1 − 0.2 − 0.6 = 0.2.
a
La probabilit` P (I6 ) dell’istanza considerata vale dunque
a
P (I6 ) = 0.5 · 0.2 = 0.1.
Si supponga adesso di avere l’interrogazione strong sneezing(david).
Per calcolare la probabilit` di questa interrogazione, occorre stabilire in
a
quali istanze Ik di TG il goal sia derivabile.
`
Siccome q e dimostrabile in I1 ∈ TG , la sua probabilit` P (I1 ) contribuir`
a
a
al valore complessivo della probabilit` dell’interrogazione. Ripetendo la
a
`
veriﬁca per tutte le istanze di TG , si ricava che q e dimostrabile anche in I2 ,
I3 , I4 e I7 . Ora, poich` le probabilit` di queste istanze valgono
e
a
P (I1 ) = 0.3 · 0.2 = 0.06

P (I2 ) = 0.3 · 0.6 = 0.18

P (I3 ) = 0.3 · 0.2 = 0.06

P (I4 ) = 0.5 · 0.2 = 0.10

2.4 Riepilogo

31

P (I7 ) = 0.2 · 0.2 = 0.04
`
la probabilit` di successo dell’interrogazione q e data da:
a
P (q|T ) = P (I1 ) + P (I2 ) + P (I3 ) + P (I4 ) + P (I7 ) = 0.44.
Come vedremo meglio nel Capitolo 3.3.1, per calcolare questo valore
`
si puo anche utilizzare un metodo che sfrutta il meccanismo di risoluzione
SLDNF di Prolog e i Binary Decision Diagrams. In Figura 2.1, ad esempio,
`
e riportato l’albero di derivazione di q. Grazie alle spiegazioni ottenute
`
dall’albero di derivazione SLNF e possibile costruire un BDD. Poich` le
e
variabili in gioco sono multivalore, in questo caso occorre procedere ad
una ulteriore fase di codiﬁca binaria con cui si convertono in binarie. Il
`
`
BDD che si ottiene e mostrato in Figura 2.2. A questo punto e sufﬁciente
percorrere il diagramma appena ottenuto dal nodo radice al terminale-1 e
grazie all’Algoritmo 2.1 e all’Algoritmo 2.2 in pochi passaggi si ottiene:
P (q|T ) = 0.3 + (1 − 0.3) · 0.2 = 0.44.

2.4 Riepilogo
Questo capitolo ha trattato il formalismo degli LPAD in modo del tutto analogo a quello utilizzato per i programmi ProbLog nel Capitolo 1.
Abbiamo visto quali differenze intercorrano tra ProbLog ed LPAD sia a livello di sintassi che di semantica. Nonostante queste differenze, abbiamo
osservato che anche le interrogazioni sugli LPAD possono essere interpretate come formule DNF e quindi valutate tramite BDD. Inoltre abbiamo
presentato un diverso meccanismo inferenziale, la derivazione SLDNF, ed
un diverso algoritmo di valutazione dei BDD che si sono resi necessari per
via delle divergenze tra questo formalismo ed il precedente.

32

LPAD

Figura 2.1: Albero di derivazione per l’interrogazione strong sneezing(david).

Figura 2.2: Diagramma decisionale
strong sneezing(david).

binario

equivalente

all’interrogazione

Capitolo 3
Algoritmi esistenti
Questo capitolo e suddiviso in tre parti. Nella prima parte verranno introdotte
`
le architetture di sistema degli interpreti presi come esempio per i programmi
ProbLog e gli LPAD.
Nella seconda parte mostreremo gli algoritmi che implementa il sistema ProbLog. In particolare vedremo come e possibile valutare la probabilit` di una que`
a
ry utilizzando algoritmi di inferenza esatta e approssimata (con limite sulla
probabilit` , con approssimazione ai migliori risultati e con approccio statistico) e
a
naturalmente i BDD.
Nell’ultima parte del capitolo mostreremo l’algoritmo di inferenza esatta
per gli LPAD utilizzato dal sistema CPLINT. Questo algoritmo non e il solo
`
implementato dal sistema CPLINT, ma e l’unico pertinente al caso in esame.
`

3.1 Cenni architetturali
Il componente alla base sia dell’interprete ProbLog che dell’interprete
`
`
CPLINT che abbiamo studiato e il sistema Prolog YAP1 . YAP e un compilatore Prolog molto efﬁciente sviluppato in ambito universitario. Il suo
`
motore inferenziale e basato sulla Warren Abstract Machine alla quale sono
state apportate numerose ottimizzazioni per ottenere migliori prestazioni.
YAP segue la cosidetta tradizione di Edinburgo e risulta largamente compa1

http://www.ncc.up.pt/˜vsc/Yap/

34

Algoritmi esistenti

tibile con lo standard ISO-Prolog e con i programmi proprietari Quintus e
SICStus Prolog.
`
`
L’architettura del sistema CPLINT risulta essere piu semplice e piu
elegante di quella ProbLog perch` definisce i propri predicati specifici
e
mediante il meccanismo a plugin messo a disposizione da YAP Prolog.
`
Per contro, la soluzione ProbLog e meno flessibile ma, essendo stata ag`
giornata piu di recente, adotta una serie di miglioramenti che la rendono
piuttosto interessante.
In Figura 3.1 e 3.2 sono rappresentate le architetture a blocchi dei due
sistemi che abbiamo analizzato. Come possiamo vedere, entrambi i sistemi utilizzano la stessa libreria CUDD2 per elaborare i BDD. La differenza
`
tra i due interpreti e che CPLINT utilizza CUDD creando una istanza del
motore per i BDD in memoria e passandogli direttamente i valori che ha
ottenuto dal calcolo delle spiegazioni. ProbLog, al contrario, salva questi
valori in alcuni file di supporto e delega l’operazione di elaborazione ad
un opportuno programma esterno. Questo programma, oltre ad utilizzare la libreria CUDD gi` citata in precedenza, utilizza anche il componena
te SimpleCUDD3 in grado di trasferire i dati salvati su file in memoria in
modo molto efficiente.
Questo ulteriore livello di indirezione, pur introducendo necessariamente overhead, permette di specificare un tempo di timeout, scaduto il quale
il programma esterno termina autonomamente anche se non ha completato la propria elaborazione. Questi casi si verificano generalmente quando
`
l’algoritmo risolutore non e stato in grado di potare efficacemente l’albero di derivazione SLDNF. Con questo meccanismo le risorse di sistema
`
non piu impegnate nell’elaborazione del bdd possono essere utilizzate per
esplorare ulteriormente lo spazio di ricerca e, se tutto va bene, per potare
`
i rami piu infruttuosi dell’albero di derivazione.

2
3

http://vlsi.colorado.edu/˜vis/getting_VIS_2.1.html
http://www.cs.kuleuven.be/˜theo/tools/simplecudd.html

3.1 Cenni architetturali

Figura 3.1: Architettura dell’interprete CPLINT.

Figura 3.2: Architettura dell’interprete ProbLog.

35

36

Algoritmi esistenti

3.2 Algoritmi ProbLog
In questa sezione si descrivono gli algoritmi implementati dall’interprete ProbLog [KCR+ 08] che calcolano la probabilit` di successo delle ina
terrogazioni ProbLog mediante inferenza esatta, inferenza approssimata ed
inferenza statistica.

3.2.1 Inferenza esatta
Calcolare la probabilit` di successo di una interrogazione nel modo
a
`
`
visto nel Capitolo 1.2.2 e impossibile se non per i problemi piu piccoli.
L’interprete ProbLog utilizza un metodo in due passi. Col primo passo
ricava le dimostrazioni dell’interrogazione q dalla parte logica della teoria
`
`
T , che piu propriamente si indica con BK ∪ LT . Questo passaggio e simile all’analoga procedura svolta da pD descritta in [Fuh00]. Il risultato
`
di questa operazione e una formula DNF. Il secondo passo impiega i BDD
([Bry92]) per calcolare la probabilit` di questa formula.
a
Il meccanismo che permette all’interprete ProbLog di ottenere tutte le
`
varie dimostrazioni di una interrogazione e la risoluzione SLD di Prolog.
L’attuazione di questo meccanismo produce un albero di derivazione SLD
come quello visto in Figura 1.4. Ogni dimostrazione con successo presente
nell’albero SLD utilizza un insieme di fatti {pi1 :: xi1 , · · · , pik :: xik } ⊆
T . Questi fatti risultano essere necessari per la dimostrazione, e quella
`
dimostrazione e indipendente dagli altri fatti probabilistici di T .
Se a questo punto si introduce una variabile booleana casuale bi per
ogni clausola pi :: ci ∈ T che indica se ci fa parte del programma logico,
allora bi ha probabilit` pi di essere vera. La probabilit` di una certa dimoa
a
`
strazione che insiste sulla clausole {pi1 :: xi1 , · · · , pik :: xik } ⊆ T e quindi
`
pari al valore del congiunto bi1 ∧ · · · ∧ bik . Generalmente ogni goal puo
`
avere piu dimostrazioni, la probabilit` di successo di una interrogazione q
a
`
e data dalla probabilit` della disgiunzione delle congiunzioni di ogni sina
gola dimostrazione. Denotando l’insieme delle dimostrazioni del goal q
con E (q) e l’insieme delle variabili booleane corrispondenti ai fatti ground


37

utilizzati nella spiegazione e con cl (e), si ottiene


Ps (q|T ) = P 

e∈E (q) bi ∈cl(e)



bi  .

`
Il risultato di questa operazione e chiaramente una formula DNF che,
una volta valutata dal componente CUDD per la gestione dei BDD, restituisce il valore di probabilit` desiderato dell’interrogazione q.
a

3.2.2 Inferenza approssimata con bound sulla probabilit`
a
L’algoritmo di inferenza approssimata con bound sulla probabilit` proa
`
posto e simile a quello gi` introdotto nella precedente versione dell’ina
terprete ProbLog descritto in [DRKT07] ed utilizza le formula DNF per
ottenere sia un lower bound che un upper bound sulla probabilit` di una
a
interrogazione.
Inizialmente l’algoritmo esplora lo spazio di ricerca fino a raggiungere
il valore di soglia della probabilit` desiderato. Il vincolo sulla probabilit` e
a
a`
stato preferito al vincolo sulla profondit` della versione precedente pera
`
ch` genera upper bound piu stringenti fin dall’inizio e di conseguenza fa
e
`
convergere l’algoritmo piu velocemente.
Successivamente l’algoritmo percorre l’albero SLD parziale ed ottiene
le formule DNF per i due bound. La formula f1 per il lower bound considera tutte le dimostrazioni presenti nell’albero DNF parziale. La formula
f2 per l’upper bound comprende anche tutte le derivazioni che sono state
sospese per aver raggiunto il valore di soglia della probabilit` .
a
L’algoritmo quindi procede in modo iterativo, partendo da un altro
valore di soglia della probabilit` e riducendolo progressivamente (moltia
plicandolo ad ogni passo per un fattore di contrazione predefinito) finch` la
e
differenza tra i valori dei due bound non diventa sufficientemente piccola. Detta f la formula DNF corrispondente all’albero di derivazione SLD
`
completo, siccome f1 |= f |= f2 e garantito che la probabilit` di successo
a
della interrogazione q ricada nell’intervallo [P (f1 ), P (f2 )].

38

Algoritmi esistenti

Si supponga, per esempio, di avere un valore di soglia di probabilit`
a
di 0.9 per l’albero SLD di Figura 1.4. In queste ipotesi, f1 contiene solo
il percorso con successo di sinistra, mentre f2 contiene anche il percorso
di destra ﬁno a path(e, d). Risulta quindi f1 = cd, f2 = cd ∨ ce, mentre
f = cd ∨ (ce ∧ ed) per l’albero SLD completo.

3.2.3 Inferenza approssimata ai risultati migliori
Quando si deve valutare un grande numero di interrogazioni, come
nel contesto dell’apprendimento di parametri, diventa fondamentale avere pieno controllo sulla complessit` computazionale dell’algoritmo utiliza
zato. Un modo piuttosto semplice di conseguire questo risultato consiste
nell’utilizzare un numero m di dimostrazioni scelto a priori per approssimare il valore di probabilit` da calcolare.
a
A questo proposito si introduce il concetto di k-probabilit` Pk (q|T ) di
a
una interrogazione q sul programma T


Pk (q|T ) = P 

e∈Ek (q) bi ∈cl(e)



bi 

in cui Ek (q) = {e ∈ E(q)|Px (e) ≥ Px (ek )} con ek k-esimo elemento in
ordine di probabilit` decrescente di E(q) e grazie al quale si utilizzano le
a
`
k spiegazioni piu probabili per costruire la formula DNF da cui ricavare la
probabilit` di successo dell’interrogazione q.
a
`
`
Cio che si ottiene utilizzando solamente le migliori k spiegazioni e ovviamente una approssimazione per difetto, o lower bound, del valore di
probabilit` normalmente atteso Si noti che per k = ∞ e per k = 1 si
a
ottengono rispettivamente la probabilit` di successo Ps (q|T ) e la probabilit`
a
a
esplicativa Px (q|T ).
Il corpo principale dell’algoritmo con cui si ottengono le migliori k
`
spiegazioni e una tipica procedura branch-and-bound.
Per chiarire il concetto di k-probabilit` , si consideri nuovamente il graa
fo proposto in Figura 1.3(a) e si supponga che in questo caso l’interroga-


39

zione di cui calcolare la probabilit` sia path(a, d). Questa interrogazione
a
ha quattro spiegazioni equivalenti alle congiunzioni ac ∧ cd, ab ∧ bc ∧ cd,
ac ∧ ce ∧ ed e ab ∧ bc ∧ ce ∧ ed che hanno probabilit` 0.72, 0.378, 0.32 e 0.168
a
rispettivamente. Siccome P1 equivale alla probabilit` esplicativa Px , si ota
tiene P1 (path(a, d)) = 0.72. Per k = 2 bisogna prendere in considerazione
la sovrapposizione delle due migliori spiegazioni: la seconda dimostrazione contribuisce al valore di probabilit` solo quando non lo fa la prima.
a
Siccome hanno il termine cd in comune, significa che il rimanente termine
ac della prima dimostrazione deve contribuire negativamente alla seconda
dimostrazione, cio` P2 (path(a, d)) = P ((ac∧cd)∨(¬ac∧ab∧bc∧cd)) = 0.72+
e
(1 − 0.8) · 0.378 = 07956. Analogamente si ricava P3 (path(a, d)) = 0.8276 e
Pk (path(a, d)) = 0.83096 per k ≥ 4.

3.2.4 Inferenza approssimata con approccio statistico
L’ultima tecnica di approssimazione proposta dall’implementazione
ProbLog considerata implementa il metodo Monte Carlo. Questa tecni`
ca e degna di nota perch` non utilizza i BDD per la valutazione della
e
probabilit` delle interrogazioni.
a
L’algoritmo campiona ripetutamente il programma ProbLog ottenendo ogni volta una sua instanza e verifica se contiene una dimostrazione dell’interrogazione in esame. Il rapporto tra il numero di campioni
`
per i quali l’interrogazione e dimostrata ed il numero totale di campioni
considerati rappresenta una stima della probabilit` dell’interrogazione.
a
`
Il corpo principale dell’algoritmo e composto da un ciclo che ogni
m campioni analizzati, calcola l’intervallo di confidenza della popolazione
statistica considerata fino a quel momento. Questo ciclo termina quando l’ampiezza dell’intervallo di confidenza al 95% risulta essere inferiore
`
al valore del parametro δ. Si noti che e stato utilizzato lo stesso criterio
di uscita dal ciclo adottato dagli altri algoritmi di inferenza approssimata discussi finora bench` gli intervalli di confidenza non corrispondano
e
esattamente ai bound considerati in quei casi.

40

Algoritmi esistenti

Questo algoritmo, nonostante non facesse uso degli intervalli di confidenza, era gi` stato suggerito da Dantsin in [Dan91] senza riportarne una
a
implementazione. Inoltre era gi` stato trattato nel contesto delle reti da
a
[SEH+ 06].

3.3 Algoritmi LPAD
In questa sezione descriviamo l’algoritmo esatto utilizzato dall’inter`
prete CPLINT4 . Questo interprete e dotato di altri algoritmi di risoluzione
`
che pero esulano da questo contesto o sono noti per non essere molto efficienti e per questo motivo non sono stati presi in considerazione in questa
trattazione.

3.3.1 Inferenza esatta con risoluzione SLDNF
`
Il concetto di derivazione per problemi ProbLog ed LPAD e molto
simile, tuttavia ci sono tre differenze principali di cui tenere conto.
La prima consiste nel fatto che, a differenza di quelle ProbLog, le clau`
`
sole LPAD possono contenere piu atomi logici nella propria testa. Cio si` `
gnifica che per rappresentare ogni clausola non e piu sufficiente utilizzare
una variabile booleana ma occorre ricorrere ad una variabile multivalore. La
`
seconda differenza si riferisce ai concetti ai quali ogni variabile e associa`
ta. Le variabili non sono piu associate alle clausole del problema come in
`
ProbLog, ma ai loro grounding. Cio significa che occorrer` utilizzare una
a
nuova variabile per ogni grounding. La terza ed ultima discordanza consiste nel fatto che nel corpo delle clausole LPAD possono comparire dei letterali negati. In linea di massima questo significa che ogni interrogazione
negativa viene risolta trovando tutte le possibili derivazioni dell’interrogazione in forma vera: si sceglie una clausola ground per ogni derivazione e
la si aggiunge alla derivazione attuale ma con una testa diversa da quella
utilizzata per derivare il goal.
4

http://www.ing.unife.it/software/cplint/manual.html

3.3 Algoritmi LPAD

41

` `
Da queste considerazioni si evince il fatto che non e piu possibile utilizzare la semplice risoluzione SLD come meccanismo inferenziale per derivare le spiegazioni di ogni interrogazione ma che occorre perlomeno utilizzare la sua estensione alle interrogazioni negative, ovvero la risoluzione
SLDNF. L’adozione di questo metodo di derivazione impone alcuni vin`
coli che di fatto restringono la classe di problemi a cui puo essere applicato. Fortunatamente la classe dei programmi aciclici a cui appartiene una
moltitudine di interessanti applicazioni ricade in questa categoria.
`
Una derivazione da (G1 , C1 ) a (Gn , Cn ) in T di profondait` n e una
a
sequenza
(G1 , C1 ), · · · , (Gn , Cn )
`
`
tale che ogni Gi e una interrogazione del tipo ← l1 , · · · , ln e Ci e un insieme
di coppie in cui sono immagazzinate le clausole istanziate e le teste utilizzate. Per costruire il termine successivo (Gi+1 , Ci+1 ) della successione si
utilizzano la seguenti regole:
`
• se l1 e un predicato built-in, si esegue li e si pone Gi+1 = (← l2 , · · · , lk )θ
`
e Ci+1 = Ci θ, dove θ e la sostituzione ottenuta eseguendo li .
`
• se l1 e un letterale positivo, sia c = h1 : p1 ∨ · · · ∨ hn : pn ← B una
nuova copia della clausola che risolve con Gi su l1 , sia hj un atomo
della testa di c che risolve con l1 e sia θ la sostituzione mgu di l1 e
hj . Per ogni coppia (cδ, m) ∈ Ci tale che m = j e cδ uniﬁca con cθ, si
impone il vincolo dif (cδ, cθ) in modo che ulteriori istanziazioni di cδ
o di cθ non rendano uguali le due clausole. Quindi Gi+1 = r, dove r
`
e il risolvente di hj ← B con Gi sul letterale l1 e Ci+1 = Ci ∪ {(cθ, j)}.
`
• se l1 e un letterale negativo ¬a1 , sia C l’insieme di tutti gli insiemi C
per cui esiste una derivazione da (← a1 , ∅) a (←, C). Quindi Gi+1 =←
`
l1 , · · · , lk e Ci+1 = select(C, C), in cui select e la funzione mostrata
nell’Algoritmo 3.1.
Una derivazione ha successo se Gn =←.

42

Algoritmi esistenti

Algoritmo 3.1 Creazione della coppia (clausole istanziate, teste utilizzate)
Input: C sets for successfull derivations of the negative goal C
Input: current set of used clauses Ci
Output: new set of used clauses Ci+1
Ci+1 = Ci
for all C ∈ C do
select a (cθ, j) ∈ C
for all δ : (cδ, j) ∈ Ci+1 , unify(cδ, cθ) do
impose dif (cδ, cθ)
end for
{perform one of the following operations}
• select (cδ, m) ∈ Ci+1 : m = j, unify(cδ, cθ)
Ci+1 ← Ci+1 {(cδ, m)} ∪ {(cθ, m)}
• select (cδ, m) ∈ Ci+1 : m = j, unify(cδ, cθ)
impose dif (cδ, cθ)
Ci+1 ← Ci+1 ∪ {(cθ, m)}
• select m = j : ∃cδ/(cδ, m) ∈ Ci+1 , unify(cδ, cθ)
Ci+1 ← Ci+1 ∪ {(cθ, m)}
end for
return Ci+1
Dall’insieme C di tutte gli insiemi C per cui esiste una derivazione da
`
(← q, ∅) a (←, C) si puo costruire la formula
P (q|T ) =

(Xcθ = j)
C∈C (cθ,j)∈C

in cui Xcθ indica la variabile multivalore associata alla clausola cθ. Poi`
ch´ il membro a destra di questa ultima equazione e una congiunzione di
e
disgiunzioni di variabili booleane, risulta essere una formula DNF valida.

3.4 Riepilogo
In questo capitolo abbiamo visto quali componenti costituiscono i sistemi ProbLog e CPLINT. In particolare abbiamo visto che pur sfruttando
gli stessi componenti o quasi, i due interpreti li utilizzano in modo diverso.
Nel proseguo del capitolo abbiamo visto nello speciﬁco gli algoritmi
che i due sistemi realizzano con i componenti che abbiamo descritto. Il

3.4 Riepilogo

43

sistema ProbLog implementa un algoritmo di inferenza esatta e tre di inferenza approssimata che sono piuttosto performanti. Nella parte centrale
del capitolo abbiamo descritto ogni singolo algoritmo evidenziandone le
qualit` e gli svantaggi.
a
` `
L’interprete CPLINT e piu elegante della propria controparte, tuttavia
di tutti gli algoritmi che implementa il solo che abbiamo potuto conside`
rare e descrivere nel dettaglio e quello di inferenza esatta.

Capitolo 4
Estensioni proposte
In questo capitolo sono presentate tutte le estensioni che abbiamo proposto
per inferire la conoscenza descritta tramite gli LPAD in modo efﬁciente.
Dopo aver descritto i miglioramenti generali apportati all’algoritmo esatto
gi` presente nell’interprete CPLINT, tratteremo in dettaglio tutti gli algoritmi
a
che abbiamo sviluppato, ovvero: un algoritmo iterativo relativamente semplice,
tre algoritmi approssimati basati su euristiche avanzate, rispettivamente BestFirst, K-Best e K-First, e due algoritmi stocastici di tipo Monte Carlo.

4.1 Algoritmo esatto
` a
Ad onor del vero, l’algoritmo esatto per gli LPAD e gi` stato proposto in passato e pertanto non dovrebbe essere presentato come possibile
estensione in questa sezione. Tuttavia la versione utilizzata come termine di paragone per gli algoritmi che seguono negli esperimenti descritti al
Capitolo 5 contiene diversi contributi ispirati dall’interprete ProbLog che
lo rendono molto diverso dalla versione iniziale.
La differenza principale tra queste due versioni dello stesso algoritmo
` a
e gi` stata discussa nel Capitolo 3.1 e consiste nel processo esterno che
`
puo essere richiamato con un opportuno tempo di timeout per delegare la
valutazione tramite BDD delle spiegazioni. Si noti che per scelta progettuale l’algoritmo esatto non fa uso dei tempi di timeout ma attende che il
processo generato termini prima di proseguire oltre.

46

Estensioni proposte

4.2 Algoritmo iterativo con vincolo sulla probabilit`
a
Oltre al goal da risolvere, questo algoritmo necessita di quattro parametri per poter funzionare correttamente. I primi due parametri sono il
limite iniziale sul valore di probabilit` ed il fattore di contrazione con cui ria
`
durre tale limite ad ogni iterazione. Il terzo parametro e l’errore minimo
che l’algoritmo utilizza per stabilire quando uscire dal ciclo delle iterazio`
ni. L’ultimo parametro e il tempo di timeout per il calcolo dei BDD introdotto grazie ai miglioramenti all’algoritmo esatto. I valori che abbiamo
utilizzato durante gli esperimenti che vedremo nel Capitolo 5 per questi
parametri sono rispettivamente 0.01, 0.1, 0.01 e 300 secondi. L’algoritmo
restituisce l’intervallo di probabilit` in termini di lower bound e upper bound
a
a cui appartiene la probabilit` della query in esame.
a
Inizialmente la soglia di probabilit` equivale al valore del primo paraa
metro e l’albero di derivazione SLDNF contiene solamente la query. Ad
ogni iterazione, l’algoritmo espande i percorsi presenti nell’albero di derivazione parziale ﬁnch` le spiegazioni presenti lungo i suoi rami diventano
e
complete o superano il valore di soglia sulla probabilit` . Successivamente
a
da queste spiegazioni si generano tre insiemi. Il primo di questi corrisponde all’insieme delle spiegazioni complete e viene utilizzato per calcolare il
limite inferiore dell’intervallo di probabilit` grazie al processo esterno dea
scritto nel Capitolo. 4.1. Il secondo corrisponde all’insieme delle spiegazioni complete ed incomplete che in modo del tutto analogo viene usato
per determinare il limite superiore dell’intervallo di probabilit` . Il terzo
a
ed ultimo insieme coincide con l’insieme dei goal ancora da risolvere che
verr` utilizzato in seguito.
a
Il ciclo principale di questo algoritmo si ripete ﬁnch` l’insieme dei goal
e
da risolvere non risulta vuoto o l’ampiezza dell’intervallo di probabilit`
a
`
appena calcolato non diventa piu piccolo dell’errore minimo.
Queste operazioni sono state riassunte nell’Algoritmo 4.1. Si noti che si
`
e scelto di utilizzare la probabilit` come grandezza in base alla quale esploa
rare lo spazio di ricerca perch` garantisce la convergenza dell’algoritmo
e

4.3 Algoritmo approssimato Best-First

47

Algoritmo 4.1 Pseudo-codice per l’algoritmo iterativo sulla probabilit`
a
Input: query goal
Input: initial probability bound bound
Input: shrinking factor f actor
Input: minimum error epsilon
Output: lower bound for the given query
Output: upper bound for the given query
goals ← goal
threshold ← bound
repeat
answers ← solve(goals, threshold )
separate(answers, complete, all, pending)
lower ← bdd (complete)
upper ← bdd (all)
threshold ← threshold · f actor
goals ← pending
until (goals = ∅) ∨ (upper − lower ≤ epsilon)
return lower
return upper

nel minor tempo possibile.

4.3 Algoritmo approssimato Best-First
Per il corretto funzionamento di questo algoritmo occorre speciﬁcare
il numero di spiegazioni per iterazione desiderato, il fattore di contrazione per
il vincolo sulla probabilit` e l’errore minimo oltre che, naturalmente, al goal
a
da risolvere. I valori di questi parametri che abbiamo utilizzato per gli
esperimenti nel Capitolo 5 sono rispettivamente 64, 0.1 e 0.01. Inoltre, sic`
come sfrutta le migliorie introdotte per l’algoritmo esatto, e possibile speciﬁcare anche il tempo di timeout come ulteriore parametro. Si ricorda che
`
il tipico valore per questo parametro e di 300 secondi. I valori restituiti al
termine dell’esecuzione sono il lower bound e l’upper bound dell’intervallo
di probabilit` a cui appartiene la probabilit` della query.
a
a
L’Algoritmo 4.2 contiene lo pseudo-codice che descrive questo algoritmo. Durante la fase di inizializzazione, l’albero di derivazione parziale

48

Estensioni proposte

contiene solo la query del problema. Nella prima parte del proprio ciclo di iterazione principale, l’algoritmo esegue un ciclo innestato grazie al
quale individua k nuove spiegazioni. Per trovare ogni nuova spiegazione,
l’algoritmo sceglie come punto di espansione dell’albero di derivazione
SLDNF parziale la spiegazione incompleta a cui compete il valore di probabilit` piu promettente. Si noti che l’algoritmo calcola un limite sul valore
a `
di probabilit` moltiplicando la probabilit` associata al punto di espansioa
a
ne scelto per il fattore di contrazione speciﬁcato; questo valore serve ad
interrompere la ricerca delle spiegazioni entro un certo limite. Quando
ha individuato il numero desiderato di nuove spiegazioni o tutto l’albero
`
di derivazione e stato completamente esplorato, l’algoritmo procede alla
seconda parte del ciclo di iterazione principale. Durante questa fase, le
spiegazioni vengono utilizzate per comporre tre insiemi: l’insieme delle
spiegazioni complete, l’insieme delle spiegazioni complete e incomplete e
l’insieme dei goal ancora da risolvere. Il primo insieme viene utilizzato
per valutare il lower bound dell’intervallo di probabilit` da calcolare, il
a
secondo per calcolarne l’upper bound ed il terzo verr` utilizzato durante
a
la successiva eventuale iterazione come goal da risolvere.
Il ciclo appena descritto si sussegue nel tempo ﬁno a quando l’insieme dei goal da risolvere non diventa vuoto o l’ampiezza dell’intervallo di
probabilit` calcolato non scende al di sotto del valore dell’errore minimo.
a

4.4 Algoritmo approssimato K-Best
Questo algoritmo prevede che gli siano passati i seguenti parametri: il
fattore di contrazione per calcolare il valore limite sulla probabilit` (il cui vaa
`
lore tipico e 0.1), il numero di spiegazioni per iterazione desiderato (64) il tempo
di timeout (300 secondi) e, naturalmente, il goal da risolvere. Il valore resti`
tuito al termine dell’esecuzione e un lower bound sul valore di probabilit`
a
della query.
Il comportamento di questo algoritmo ricalca per larga parte quello
dell’algoritmo Best-First presentato al Capitolo 4.3. I primi passi consistono nell’inizializzare il nodo radice dell’albero di derivazione al goal da

4.4 Algoritmo approssimato K-Best

49

Algoritmo 4.2 Pseudo-codice per l’algoritmo euristico Best-First
Input: query goal
Input: number of explanation per iteration k
Output: upper bound for the given query
goals ← goal
repeat
for i = 1 to k do
if goals = ∅ then
break
end if
expanding ← best(goals)
goals ← goals − expanding
bound ← prob(expanding) · f actor
answers ← answers + solve(expanding, bound)
end for
separate(answers, complete, all, pending)
lower ← bdd (complete)
upper ← bdd (all)
goals ← pending
until (goals = ∅) ∨ (upper − lower ≤ epsilon)
return lower

risolvere e nell’impostare l’insieme delle migliori spiegazioni all’insieme
`
vuoto. Dopodich` inizia il ciclo principale della procedura, come si puo
e
vedere dal codice presentato con l’Algoritmo 4.3.
In questo ciclo, si calcola la soglia di probabilit` moltiplicando la proa
babilit` che compete all’insieme dei goal per il fattore di contrazione e
a
l’albero di derivazione SLDNF viene fatto crescere ﬁnch` non viene indie
viduato il numero di nuove spiegazioni desiderato nei limiti del valore
di soglia. Queste generano anche in questo caso l’insieme delle spiegazioni complete e dei goal ancora da risolvere. Diversamente da prima, le
spiegazioni complete non vengono direttamente utilizzate per calcolare il
limite inferiore sul valore di probabilit` della query in esame ma vengono
a
passate ad una procedura di branch and bound che si preoccupa di inserirle
in modo ordinato nella lista delle migliori spiegazioni. Le spiegazioni che

50

Estensioni proposte

Algoritmo 4.3 Pseudo-codice per l’algoritmo euristico K-Best
Input: query goal
Input: number of explanation per iteration k
goals ← goal
best ← ∅
repeat
bound ← prob(goals) · f actor
answers ← solve(goals, bound )
separate(answers, complete, , pending)
best ← branch and bound (k, best, complete)
goals ← pending
until (goals = ∅)
return bdd (best)

eccedono alle dimensione desiderate per la lista vengono scartate. Il lower
bound sulla probabilit` della query viene calcolato solo adesso passando
a
la lista aggiornata delle migliori spiegazioni al solito processo esterno per
la risoluzione dei BDD.
Il ciclo termina quando l’insieme dei goal ancora da risolvere diventa
vuoto; quindi si calcola e si restituisce il valore di probabilit` equivalente
a
alla migliori spiegazioni.

4.5 Algoritmo approssimato K-First
Questo algoritmo nasce dalla volont` di sperimentare un metodo che
a
riduca drasticamente la quantit` di risorse computazionali richieste dal
a
calcolo delle spiegazioni anche a scapito della qualit` del risultato. I soli
a
parametri oltre al goal da derivare di cui questo algoritmo necessita sono
il fattore di contrazione sulla probabilit` , il numero di spiegazioni desideraa
to ed il solito tempo di timeout da utilizzare per la risoluzione dei BDD.
`
`
`
Come e stato piu volte ricordato, i valori piu tipici per questi parametri
sono rispettivamente 0.1, 64 e 300 secondi. Anche in questo caso il valore
`
restituito e un lower bound sul valore di probabilit` della query in esame.
a

4.6 Algoritmo stocastico Monte Carlo

51

Algoritmo 4.4 Pseudo-codice per l’algoritmo euristico K-First
Input: query goal
Input: number of desired explanation k
counter ← 0
f irst ← ∅
repeat
bound ← prob(goals) · f actor
answers ← solve(goals, bound )
separate(answers, complete, , pending)
counter ← counter + count(answers)
f irst ← f irst + complete
goals ← pending
until (goals = ∅) ∨ (counter ≥ k)
return bdd (f irst)
`
Come si puo osservare dal codice dell’Algoritmo 4.4, questa procedura consiste in un ciclo molto semplice. L’albero di derivazione contiene
inizialmente solo il goal da derivare poi, dopo aver calcolato la soglia di
probabilit` moltiplicando la probabilit` che compete all’insieme dei goal
a
a
per il fattore di contrazione, viene fatto crescere nei limiti di tale valore
`
ﬁnch´ non si e ottenuto il numero desiderato di spiegazioni o non ci soe
`
no piu goal da derivare. L’insieme di spiegazioni ottenuto viene passato
alla consueta procedura che si occupa di separarli in modo da conservare
solamente le spiegazioni complete. Si noti che a seconda della natura del
problema affrontato, l’insieme delle spiegazioni complete rimasto potrebbe contenere un numero minore di elementi rispetto a quello desiderato.
Questo insieme di spiegazioni complete viene utilizzato dal processo a cui
viene delegata la valutazione dei BDD per calcolare il lower bound sulla
probabilit` della query in esame da restituire.
a

4.6 Algoritmo stocastico Monte Carlo
`
Questo algoritmo e completamente diverso da tutti quelli presentati
ﬁnora perch` non si appoggia ai BDD per valutare le probabilit` associate
e
a

52

Estensioni proposte

alle spiegazioni ma ad un approccio stocastico. Oltre al goal da derivare,
questo algoritmo deve conoscere i seguenti parametri: numero di campioni
per iterazione desiderato il cui tipico valore utilizzato durante gli esperi`
`
menti e 64 e l’errore minimo il cui consueto valore e 0.01. Il valore restituito
`
da questa procedura e la probabilit` equivalente alla query in esame.
a
Appena avviato l’algoritmo, l’insieme dei campioni viene inizializzato
all’insieme vuoto ed i contatori per il numero di successi ed il numero di
campioni totali viene azzerato.
Durante ogni iterazione, questo algoritmo si preoccupa di esplorare
daccapo lo spazio di ricerca del problema mediante una strategia depthfirst. Ogni volta che il percorso si trova ad un bivio, significa che occorre
effettuare una scelta per continuare la costruzione dell’albero di derivazio`
`
ne parziale. In altre parole, si puo dire che grazie a questo stratagemma e
possibile campionare le istanze del problema in modo incrementale ridu`
cendo drasticamente la durata dell’operazione. Il campionamento si puo
concludere con un successo o un fallimento a seconda che la query in esame sia derivabile o no nell’istanza campionata. Mentre il contatore dei
campioni generati viene sempre aggiornato, il contatore dei successi viene
ovviamente aggiornato solo in caso di successo. Le iterazioni terminano
`
solo quando e stato campionato un multiplo del numero di campioni de`
siderato e l’mpiezza dell’intervallo di confidenza sui campioni generati e
minore dell’errore minimo.
L’intervallo di confidenza viene calcolato mediate la seguente formula:
p ± z1−α/2
ˆ

p · (1 − p)
ˆ
ˆ
n

`
in cui p e la proporzione stimata per il campione statistico, z1−α/2 e 1 − α/2
ˆ`
percentile della distribuzione normale standard ed n il numero di cam`
pioni. Si noti che questa formula non e applicabile per valori di proba`
bilit` prossimi allo 0 o all’1. Per ovviare a questo problema si e utiliza
zato la regola empirica di Brown che consiglia di verificare che (n · p >
5) ∧ (n · (1 − p)).
Il valore di probabilit` da restituire viene infine calcolato come rappora

4.7 Algoritmo stocastico Monte Carlo con memoria

53

Algoritmo 4.5 Pseudo-codice per l’algoritmo stocastico Monte Carlo
Input: query goal
Input: number of samples per iteration k
Output: probability of the given query
success ← 0
number ← 0
samples ← ∅
repeat
current ← sample(goal, solution)
if solution = true then
success ← success + 1
end if
number ← number + 1
samples ← samples + current
interval ← conﬁdence(samples)
until (number mod k = 0) ∧ (interval < epsilon)
return success/number
to tra il numero di successi e il numero totale di campioni generati.
L’Algoritmo 4.5 contiene il codice della procedura che abbiamo appena
descritto.

4.7 Algoritmo stocastico Monte Carlo con memoria
Questa variante dell’algoritmo Monte Carlo necessita esattamente degli stessi parametri dell’algoritmo da cui trae origine, restituisce lo stesso
risultato e si comporta anche esattamente allo stesso modo. Per questo si
`
puo dire che l’Algoritmo 4.5 la descriva perfettamente.
`
L’unica differenza tra queste due varianti dello stesso algoritmo e la
struttura dati che viene utilizzata per memorizzare le scelte delle spiegazioni che descrivono ogni istanza campionata del problema. Nella versione originale di questa procedura, queste informazioni venivano salvate
nell’albero di derivazione SLDNF mentre in questa variante vengono memorizzate in un database ad accesso veloce interno all’interprete Prolog.

54

Estensioni proposte

`
In pratica e sufficiente sostituire i predicati che descrivono il meccanismo
di ricerca dei percorsi sui grafi dell’algoritmo Montecarlo
path(X, Y ) ← path(X, Y, [X], ).
path(X, X, A, A).
path(X, Y, A, R) ←
X = Y, arc(X, Z), ¬member (Z, A), path(Z, Y, [Z|A], R).
arc(X, Y ) ← edge(Y, X).
arc(X, Y ) ← edge(X, Y ).
con la seguente versione opportunamente modificata:
memopath(X, Y ) ←
eraseall (visited), recordz (visited , X, ), memopath(X, Y, [X], ).
memopath(X, X, A, A).
memopath(X, Y, A, R) ←
X = Y, arc(X, Z),
recordzifnot(visited, Z, ), memopath(Z, Y, [Z|A], R).
arc(X, Y ) ← edge(Y, X).
arc(X, Y ) ← edge(X, Y ).
Il vantaggio principale derivante da questa scelta consiste nella sostanziale riduzione dei tempi di accesso alle variabili, che si traduce in tempi
`
di esecuzione complessivi sensibilmente piu brevi.
Questa soluzione ha anche uno svantaggio non trascurabile che per
fortuna si manifesta solamente con gli LPAD che contengono incertezza
anche nelle regole di derivazione. Con la versione originale di questo algoritmo, il meccanismo di backtracking di Prolog lavorava in sinergia con
quello per la costruzione incrementale dei campioni in modo da esplorare
eventuali percorsi alternativi in caso di insuccesso lungo un ramo. Avendo
rimosso le spiegazioni dall’albero di derivazione parziale, quando si trova
` `
nelle stesse condizioni questa variante non e piu in grado di esplorare le
strade alternative in modo intelligente.
`
Questa interferenza e seria e potenzialemente pericolosa, pertanto necessit` sicuramente di futuri approfondimenti.
a

4.8 Riepilogo

55

4.8 Riepilogo
In questo capitolo abbiamo visto quali miglioramenti generali siano
stati applicati all’algoritmo esatto dell’interprete CPLINT e agli altri algoritmi che abbiamo sviluppato. Inoltre abbiamo analizzato ogni singolo
algoritmo (iterativo, euristico Best-First, euristico K-Best, euristico K-First,
stocastico Monte Carlo e variante) descrivendone le peculiarit` ed i tipici
a
parametri di utilizzo.

Capitolo 5
Esperimenti
Questo capitolo e diviso in due parti. Nella prima parte presentiamo alcu`
ni dataset sintetici appositamente creati per valutare l’efficacia degli algoritmi
sviluppati nel precedente Capitolo 4 e mostriamo i risultati delle simulazioni che
abbiamo condotto su di essi.
Nella seconda parte del capitolo, invece, introduciamo alcuni importanti dataset reali gi` utilizzati dagli interpreti ProbLog ed LPAD di esempio: dopo aver
a
ripetuto le simulazioni su questi nuovi dati, introduciamo i risultati conseguiti in
modo da poterli confrontare con quelli pubblicati in letteratura.

5.1 Test sintetici
Come gi` accennato nell’introduzione al capitolo, in questa sezione
a
vengono presentati alcuni dataset che sono stati appositamente inventati
per verificare l’efficienza degli algoritmi proposti e che non modellano alcuna applicazione reale. I problemi di verifica degli algoritmi consistono
nel calcolo della probabilit` dei percorsi dei grafi equivalenti ai programmi
a
descritti in ogni dataset.
Tutti gli algoritmi da sottoporre a verifica sono stati implementati con
YAP Prolog, una implementazione open source allo stato dell’arte del linguaggio Prolog, ed utilizzano i pacchetti CUDD e SimpleCUDD come
`
componente per la gestione dei BDD. Ogni esperimento e stato eseguito su macchine Linux dotate di processore Intel Core 2 Duo E6550 (2333

58

Esperimenti

Figura 5.1: Costruzione iterativa dei grafi sintetici a percorsi paralleli.

MHz) e 4 Gb di RAM limitando a 24 ore il tempo massimo di esecuzione
di ogni esperimento.

5.1.1 Grafi a percorsi paralleli
`
`
L’idea alla base di questi grafi artificiali e che esistano piu percorsi che
portano dal nodo di partenza a quello di destinazione. Questi grafi si costruiscono in modo iterativo aggiungendo un nuovo percorso ad ogni passaggio successivo. Ogni nuovo percorso, inoltre, deve essere formato da
`
un numero di archi pari al numero di archi del percorso precedente piu
uno.
La Figura 5.1 rappresenta i grafi prodotti dalle prime tre iterazioni
della procedura generatrice presentata nell’Algoritmo 5.1.
Da un punto di vista strutturale, questi grafi risultano essere piuttosto
semplici e non troppo pesanti in termini di dimensioni. Sono un ottimo
punto di partenza per valutare l’efficacia dei nuovi algoritmi proposti.
Gli algoritmi presentati nel Capitolo 4 sono stati testati su tutti i grafi
procedendo per numero di percorsi crescente. Gli esperimenti sono stati
interrotti dopo 24 ore di esecuzione o al termine dell’esecuzione del primo
grafo che ha provocato l’esaurimento della memoria a disposizione del
processo.
Le euristiche degli algoritmi Deep-It e Best-First introducono un overhead non trascurabile per problemi relativamente semplici come quelli
modellati da questo tipo di grafi. Come si vede in Tabella 5.1, questi algo-

5.1 Test sintetici

#

tres

Esatto
tbdd

12
24
36
48
60
72
84
96
108
120
132
144
156
168
180
192
204
216
228
240
252
264
276
288
300

0.000
0.008
0.080
0.081
0.100
0.184
0.273
0.388
0.604
0.785
1.032
1.453
1.825
−
−
−
−
−
−
−
−
−
−
−
−

0.004
0.068
0.404
0.872
1.729
3.345
5.885
9.553
15.316
23.153
33.382
47.571
66.116
−
−
−
−
−
−
−
−
−
−
−
−

59

ttot

tres

0.004
0.076
0.484
0.953
1.829
3.529
6.158
9.941
15.920
23.938
34.414
49.024
67.941
−
−
−
−
−
−
−
−
−
−
−
−

0.000
0.020
0.025
0.048
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−

Deep-It
tbdd
ttot
0.020
0.168
0.588
1.677
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−

0.020
0.188
0.613
1.725
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−

tres
0.000
0.000
0.000
0.004
0.028
0.028
0.020
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−

Best-First
tbdd
ttot
0.004
0.016
0.036
0.052
0.152
0.172
0.128
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−

0.004
0.016
0.036
0.056
0.180
0.200
0.148
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−

Tabella 5.1: Tempi di risoluzione tres , tempi di valutazione dei BDD tbdd e tempi totali ttot degli esperimenti sui graﬁ a percorsi paralleli con algoritmi Esatto, Deep-It e Best-First a confronto. Per motivi di spazio,
la tabella riporta solamente una campionatura uniforme dei risultati
signiﬁcativi ottenuti.

60

Esperimenti

#

tres

12
0.000
24
0.022
36
0.091
48
0.371
60
0.922
72
1.772
84
2.593
96
3.958
108 5.355
120 7.578
132 10.366
144 11.003
156 16.463
168 20.747
180 24.472
192 28.936
204 40.067
216 48.040
228 59.477
240 66.584
252 84.701
264 96.058
276 113.713
288 135.928
300 154.095

K-Best
tbdd

ttot

tres

K-First
tbdd

ttot

Monte
Carlo
ttot

1.425
3.446
34.630
31.617
81.549
80.966
79.659
78.134
79.605
78.698
81.255
78.542
80.446
78.271
80.693
78.824
79.867
77.737
79.784
79.975
81.679
79.200
80.934
78.948
79.229

1.425
3.468
34.721
31.988
82.471
82.738
82.252
82.092
84.960
86.276
91.621
89.545
96.909
99.018
105.165
107.760
119.934
125.777
139.261
146.559
166.380
175.258
194.647
214.876
233.324

0.000
0.000
0.000
0.016
0.004
0.024
0.064
0.032
0.032
0.052
0.060
0.052
0.028
0.068
0.088
0.036
0.068
0.048
0.072
0.096
0.056
0.072
0.096
0.128
0.152

0.000
0.000
0.004
0.000
0.000
0.000
0.000
0.000
0.000
0.000
0.000
0.000
0.000
0.004
0.000
0.000
0.000
0.000
0.000
0.000
0.000
0.000
0.000
0.000
0.000

0.000
0.000
0.004
0.016
0.004
0.024
0.064
0.032
0.032
0.052
0.060
0.052
0.028
0.072
0.088
0.036
0.068
0.048
0.072
0.096
0.056
0.072
0.096
0.128
0.152

0.188
0.348
0.573
0.837
1.152
1.565
1.893
2.381
2.925
3.473
4.244
4.529
5.528
6.505
6.949
76.521
82.397
80.009
77.809
86.225
117.415
118.299
120.147
125.103
124.391

Memo
Path
ttot
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−

Tabella 5.2: Tempi di risoluzione tres , tempi di valutazione dei BDD tbdd e tempi
totali ttot degli esperimenti sui graﬁ a percorsi paralleli con algoritmi
K-Best, K-First, Monte Carlo e Memo Path a confronto. Per motivi di
spazio, la tabella riporta solamente una campionatura uniforme dei
risultati signiﬁcativi ottenuti.

5.1 Test sintetici

61

Algoritmo 5.1 Algoritmo per grafi artificiali a percorsi paralleli
for step = 1 to 300 do
new ← 2
for lane = 1 to step do
for length = 1 to lane do
current ← 0
if length = lane then
print edge(current, 1) : 0.3.
else
print edge(current, new) : 0.3.
current ← new
new ← new + 1
end if
end for
end for
end for

ritmi riescono a risolvere un minor numero di step dell’algoritmo esatto.
`
`
Inoltre, a parit` di step, Deep-It risulta essere piu lento e Best-First piu vea
loce rispetto all’algoritmo esatto. Se si osservano la Tabella 5.3 e la Tabella 5.4, si evince che al lower ed upper bound calcolato da queste estensioni
compete un errore percentuale nullo o quasi nullo, almeno finch` e stato
e`
possibile fare un confronto con i risultati esatti.
`
La logica degli algoritmi K-Best e K-First e meno onerosa di quella de`
gli algoritmi considerati sopra ed infatti, come si puo vedere in Tabella 5.2,
questi sono stati in grado di risolvere tutti gli step che gli sono stati sottoposti in tempi sostanzialmente brevi. Tuttavia, se con K-Best abbiamo
ottenuto un buon lower bound ed un errore percentuale nullo, con K-First
abbiamo ottenuto risultati disastrosi. Questo risultato non ci stupisce perch` l’algoritmo K-First privilegia la velocit` di esecuzione all’accuratezza
e
a
dei risultati per ipotesi di progetto ed infatti i risultati che produce sono
ottenuti in modo quasi istantaneo. La Tabella 5.5 pone a confronto i valori
di probabilit` e gli errori percentuali prodotti da questi algoritmi.
a
La Tabella 5.2 raccoglie anche i tempi di esecuzione per gli algoritmi
Monte Carlo e Memo Path, la variante di Monte Carlo con memoria. L’ap`
proccio statistico di Monte Carlo e cos` leggero per il sistema da essere in
ı

62

Esperimenti

Figura 5.2: Costruzione iterativa dei grafi sintetici a percorsi ramificati.

grado di risolvere tutti gli step che gli sono stati sottoposti nella met` del
a
tempo impiegato da K-Best, il miglior algoritmo fino a questo punto. Da
un punto di vista del valore di probabilit` calcolato e del relativo erroa
`
re percentuale, Monte Carlo ha prodotto risultati piu che accettabili per la
velocit` di elaborazione seppur di poco inferiori rispetto a quelli di K-Best.
a
I valori di probabilit` e relativi errori percentuali di questi algoritmi sono
a
stati riportati in Tabella 5.6. Si noti che la variante Memo Path di Mon`
te Carlo non e stata in grado di produrre risultati perch` sia i fatti che le
e
regole dei problemi equivalenti ai grafi considerati contengono incertezza.

5.1.2 Grafi a percorsi ramificati
`
Il concetto che ha ispirato la creazione di questi grafi artificiali e che
`
ci fossero piu percorsi molto ramificati congiungenti il nodo di partenza
a quello di destinazione. Questo scenario dunque risulta essere l’ideale
per saggiare l’effettiva capacit` degli algoritmi implementati di ridurre lo
a
spazio di ricerca in modo intelligente grazie alla loro euristica.
Anche questi grafi sono stati generati in modo iterativo. Ogni iterazione della procedura generatrice aggiunge al grafo 2n percorsi di lunghezza
n+1 che si sviluppano tra il nodo radice e il nodo di destinazione. Il primo
`
arco e comune a tutti i percorsi, poi da ogni nodo intermedio scaturiscono
`
due nuovi archi finch` la lunghezza dei percorsi parziali non e pari a n. A
e
questo punto i percorsi si richiudono sul nodo di destinazione, diventando
cos` di lunghezza n + 1.
ı

5.1 Test sintetici

63

#

Esatto

Plow

2
4
6
8
10
12
14
16
18
20
22
24
26
28
30
32
34
36
38
40
42
44
46
48
50

0.095670
0.096211
0.096215
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
−
−
−
−

0.095670
0.096211
0.096215
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216

Deep-It
e(P )
Pup

e(P )

0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
−
−
−
−

0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
−
−
−
−

0.095670
0.096211
0.096215
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216

Tabella 5.3: Lower bound Plow , upper bound Pup e relativi errori percentuali e(P )
rispetto alla probabilit` dell’algoritmo Esatto sui graﬁ a percorsi paa
ralleli con algoritmo Deep-It. Per motivi di spazio, la tabella riporta solamente una campionatura uniforme dei risultati signiﬁcativi
ottenuti.

64

Esperimenti

#

Esatto

Plow

2
4
6
8
10
12
14
16
18
20
22
24
26
28
30
32
34
36
38
40
42
44
46
48
50

0.095670
0.096211
0.096215
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
−
−
−
−

0.095670
0.096211
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215
0.096215

Best-First
e(P )
Pup

e(P )

0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
−
−
−
−

0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.01%
0.01%
0.01%
0.01%
0.01%
0.01%
0.01%
0.01%
0.01%
0.01%
0.01%
0.01%
−
−
−
−

0.095670
0.096211
0.096215
0.096216
0.096217
0.096218
0.096218
0.096219
0.096220
0.096221
0.096221
0.096222
0.096223
0.096223
0.096224
0.096225
0.096226
0.096226
0.096227
0.096228
0.096228
0.096229
0.096230
0.096231
0.096231

Tabella 5.4: Lower bound Plow , upper bound Pup e relativi errori percentuali e(P )
rispetto alla probabilit` dell’algoritmo Esatto sui graﬁ a percorsi paa
ralleli con algoritmo Best-First. Per motivi di spazio, la tabella riporta solamente una campionatura uniforme dei risultati signiﬁcativi
ottenuti.

5.1 Test sintetici

#

Esatto

2
4
6
8
10
12
14
16
18
20
22
24
26
28
30
32
34
36
38
40
42
44
46
48
50

0.095670
0.096211
0.096215
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
−
−
−
−

65

K-Best
Plow
e(P )
0.095670
0.096211
0.096215
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216

0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
0.00%
−
−
−
−

K-First
Plow
e(P )
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000

100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
100.00%
−
−
−
−

Tabella 5.5: Lower bound Plow e relativo errore percentuale e(P ) rispetto alla probabilit` dell’algoritmo Esatto sui graﬁ a percorsi paralleli con algorita
mi K-Best e K-First. Per motivi di spazio, la tabella riporta solamente
una campionatura uniforme dei risultati signiﬁcativi ottenuti.

66

Esperimenti

#

Esatto

2
4
6
8
10
12
14
16
18
20
22
24
26
28
30
32
34
36
38
40
42
44
46
48
50

0.095670
0.096211
0.096215
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
0.096216
−
−
−
−

Monte Carlo
Pstat
e(P )
0.096461
0.098795
0.097017
0.097973
0.101324
0.101425
0.091657
0.097159
0.098655
0.090731
0.098325
0.094985
0.094985
0.096115
0.094913
0.098325
0.094042
0.096474
0.096474
0.097372
0.094334
0.100771
0.093381
0.094622
0.098395

0.83%
2.69%
0.83%
1.83%
5.31%
5.41%
4.74%
0.98%
2.53%
5.70%
2.19%
1.28%
1.28%
0.10%
1.35%
2.19%
2.26%
0.27%
0.27%
1.20%
1.96%
−
−
−
−

Memo Path
Pstat e(P )
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−

−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−

Tabella 5.6: Probabilit` Pstat e relativo errore percentuale e(P ) rispetto alla proa
babilit` dell’algoritmo Esatto sui graﬁ a percorsi paralleli con algoa
ritmi Monte Carlo e Memo Path. Per motivi di spazio, la tabella riporta solamente una campionatura uniforme dei risultati signiﬁcativi
ottenuti.

5.1 Test sintetici

67

Algoritmo 5.2 Algoritmo per grafi artificiali a percorsi ramificati
for step = 1 to 25 do
new ← 2
current ← 1
for length = 1 to step do
print edge(0, current) : 0.3.
if length > 1 then
lef t ← 2length−1 − 2
new ← new + 1
else
current ← new
end if
for node = 1 to (2length−1 − 1) do
if lef t = 0 then
else
print edge(current, new) : 0.3.
print edge(current, new + 1) : 0.3.
lef t ← lef t − 2
new ← new + 2
end if
current ← current + 1
end for
end for
end for

La Figura 5.2 mostra un esempio dei primi tre grafi prodotti dalla
procedura generatrice presentata nell’Algoritmo 5.2.
Rispetto a quelli introdotti al Capitolo 5.1.1, questi grafi risultano essere piuttosto complessi come testimonia la loro dimensione. La veloce
esplosione del numero di percorsi, infatti, produce grafi di notevoli dimensioni tanto che, pur limitandoci a 25 iterazioni, abbiamo ottenuto file
dell’ordine di grandezza dei 2 Gb.
I grafi generati sono stati sottoposti a test utilizzando tutti gli algoritmi
proposti, procedendo per complessit` crescente dei grafi. Come sempre,
a
gli esperimenti sono stati interrotti dopo 24 ore di esecuzione o al termine dell’esecuzione del primo grafo che ha provocato l’esaurimento della

68

Esperimenti

memoria a disposizione dell’applicazione di test.
`
Come si puo vedere in Tabella 5.7, le performance di Deep-It e BestFirst sono migliori rispetto al caso dei grafi a percorsi paralleli nonostante
`
questi grafi siano molto piu complessi. Sebbene abbiano risolto meno step
in valore assoluto rispetto alla casistica precedente, in questo caso DeepIt ha risolto quasi lo stesso numero di step risolti dall’algoritmo esatto e
`
Best-First addirittura qualche step in piu. Dal punto di vista della qualit` dei valori di probabilit` calcolati, anche in questo caso abbiamo errori
a
a
percentuali nulli, come si evince dalla Tabella 5.9 e Tabella 5.10.
`
Il comportamento degli algoritmi K-Best e K-First e risultato essere ancora migliore di quello appena citato: entrambi sono stati in grado di ela`
borare piu del doppio degli step risolti dall’algoritmo esatto. Per quanto
riguarda la qualit` dei valori di probabilit` calcolati, entrambi gli algorita
a
mi confermano il comportamento mostrato con i grafi a percorsi paralleli.
K-Best produce risultati attendibili con errore percentuale pressoch` nule
lo finch` e stato possibile confrontrali con quelli esatti, e K-First risultati
e`
terribili in tempi quasi nulli. La Tabella 5.8 documenta i tempi di esecuzione di K-Best e K-First mentre la Tabella 5.11 propone i relativi valori di
probabilit` ed errori percentuali calcolati.
a
`
L’algoritmo Monte Carlo citato nella Tabella 5.8 gi` introdotta e riuscia
`
to anch’esso a risolvere piu del doppio degli step elaborati dall’algoritmo
esatto. In merito alle performance, ha restituito i valori di probabilit` cala
colati in tempo quasi nullo, paragonabile a quello di K-First, e con errore
`
percentuale piu che accettabile. Anche in questo caso la variante Memo
Path non ha prodotto risultati per via dell’incertezza presente nelle regole
di questi problemi. La Tabella 5.12 presenta i risultati relativi agli utlimi
due algoritmi citati.

5.1.3 Grafi a percorsi ridondanti
Questa classe di grafi artificiali nasce dalla necessit` di coniugare una
a
complessit` paragonabile a quella dei grafi a percorsi ramificati del Capia

Stefano Bragaglia MSc Thesis, awarded as Best Italian thesis in AI 2009/2010

Stefano Bragaglia MSc Thesis, awarded as Best Italian thesis in AI 2009/2010

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Andere mochten auch

Andere mochten auch (17)

Ähnlich wie Stefano Bragaglia MSc Thesis, awarded as Best Italian thesis in AI 2009/2010

Ähnlich wie Stefano Bragaglia MSc Thesis, awarded as Best Italian thesis in AI 2009/2010 (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (8)

Stefano Bragaglia MSc Thesis, awarded as Best Italian thesis in AI 2009/2010