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

274
-1

Published on

My MSc Thesis (only in Italian) introduces Logic Programs with Annotated Disjunction (LPADs) a Prolog's probabilistic extension, and my work on CPLINT (https://sites.google.com/a/unife.it/ml/cplint) to reason on them. My goal was to implement and test several approximated algorithms to balance speed and accuracy when solving probabilistic problems. It was awarded by the Italian Association for Artificial Intelligence (AIxIA) as the best Italian thesis in Artificial Intelligence of 2009/2010.

Published in: Education
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
274
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
2
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

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

  1. 1. Universit` degli Studi di Bologna a ` FACOLTA DI INGEGNERIA Corso di Laurea in Ingegneria Informatica Intelligenza Artificiale 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
  2. 2. Universit` degli Studi di Bologna a ` FACOLTA DI INGEGNERIA Corso di Laurea in Ingegneria Informatica Intelligenza Artificiale 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
  3. 3. 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
  4. 4. 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
  5. 5. INDICE 3 Bibliografia 95 Elenco degli algoritmi 99 Elenco delle figure 101 Elenco delle tabelle 103
  6. 6. 4 INDICE
  7. 7. 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-
  8. 8. 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 efficace. 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 flessibilit` 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
  9. 9. 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.
  10. 10. 8 Introduzione
  11. 11. 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 definizioni 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
  12. 12. 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
  13. 13. 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. 1.2 Calcolo delle probabilit` di successo 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).
  14. 14. 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 definire 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-
  15. 15. 1.2 Calcolo delle probabilit` di successo 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 verifica 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 difficile 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-
  16. 16. 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’unificatore 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
  17. 17. 1.2 Calcolo delle probabilit` di successo 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).
  18. 18. 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
  19. 19. 1.2 Calcolo delle probabilit` di successo 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-
  20. 20. 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:
  21. 21. 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.
  22. 22. 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 ))
  23. 23. 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.
  24. 24. 22 ProbLog
  25. 25. 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
  26. 26. 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.
  27. 27. 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
  28. 28. 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  .
  29. 29. 2.2 Calcolo delle probabilit` di successo a 27 2.2 Calcolo delle probabilit` di successo 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 codifica 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 significativo. 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-
  30. 30. 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.
  31. 31. 2.3 Esempio 29 Algoritmo 2.1 Calcolo della probabilit` di un nodo multivalore a Input: BDD node n Output: equivalent probability 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 Output: equivalent probability 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
  32. 32. 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 ` verifica 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
  33. 33. 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 codifica binaria con cui si convertono in binarie. Il ` ` BDD che si ottiene e mostrato in Figura 2.2. A questo punto e sufficiente 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.
  34. 34. 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
  35. 35. 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 efficiente 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/
  36. 36. 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
  37. 37. 3.1 Cenni architetturali Figura 3.1: Architettura dell’interprete CPLINT. Figura 3.2: Architettura dell’interprete ProbLog. 35
  38. 38. 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
  39. 39. 3.2 Algoritmi ProbLog 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 )].
  40. 40. 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 fino 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-
  41. 41. 3.2 Algoritmi ProbLog 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.
  42. 42. 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
  43. 43. 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δ unifica 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 =←.
  44. 44. 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 specifico gli algoritmi che i due sistemi realizzano con i componenti che abbiamo descritto. Il
  45. 45. 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.
  46. 46. 44 Algoritmi esistenti
  47. 47. 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 efficiente. 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.
  48. 48. 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 finch` 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 finch` 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
  49. 49. 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 specificare 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 specificare 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
  50. 50. 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 specificato; 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 fino 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
  51. 51. 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 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 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 finch` 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
  52. 52. 50 Estensioni proposte Algoritmo 4.3 Pseudo-codice per l’algoritmo euristico K-Best Input: query goal Input: shrinking factor f actor Input: number of explanation per iteration k Output: lower bound for the given query 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
  53. 53. 4.6 Algoritmo stocastico Monte Carlo 51 Algoritmo 4.4 Pseudo-codice per l’algoritmo euristico K-First Input: query goal Input: shrinking factor f actor Input: number of desired explanation k Output: lower bound for the given query 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 ` finch´ 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 finora perch` non si appoggia ai BDD per valutare le probabilit` associate e a
  54. 54. 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
  55. 55. 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 Input: minimum error epsilon 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 ← confidence(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.
  56. 56. 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
  57. 57. 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.
  58. 58. 56 Estensioni proposte
  59. 59. 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
  60. 60. 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-
  61. 61. 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 grafi 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 significativi ottenuti.
  62. 62. 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 grafi 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 significativi ottenuti.
  63. 63. 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 ı
  64. 64. 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. ı
  65. 65. 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 grafi a percorsi paa ralleli con algoritmo Deep-It. Per motivi di spazio, la tabella riporta solamente una campionatura uniforme dei risultati significativi ottenuti.
  66. 66. 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 grafi a percorsi paa ralleli con algoritmo Best-First. Per motivi di spazio, la tabella riporta solamente una campionatura uniforme dei risultati significativi ottenuti.
  67. 67. 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 grafi a percorsi paralleli con algorita mi K-Best e K-First. Per motivi di spazio, la tabella riporta solamente una campionatura uniforme dei risultati significativi ottenuti.
  68. 68. 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 grafi a percorsi paralleli con algoa ritmi Monte Carlo e Memo Path. Per motivi di spazio, la tabella riporta solamente una campionatura uniforme dei risultati significativi ottenuti.
  69. 69. 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 print edge(current, 1) : 0.3. print edge(current, 1) : 0.3. 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
  70. 70. 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

×