Sei sulla pagina 1di 4

Intelligenza Artificiale: 8-Puzzle with A*

Alberto Merciai–matricola:5421314

1 Descrizione del Problema

Il gioco si svolge su una tavola di 3x3 tessere (`e una versione ridotta del gioco originario, che ha dimensioni 4x4)contenente i numeri da 1 a 8 e una tessera vuota (modellato nel mio caso con la tessera 0).Partendo da una configu- razione iniziale casuale,spostando le tessere in orizzontale e verticale grazie alla tessera vuota,si deve giungere alla configurazione ’goal’:

1

3

2

1

2

4

5

6

3

4

5

7

8

6

7

8

l’algoritmo utilizzato per ottenere il nodo goal partendo da una qualsiasi configurazione iniziale delle 8 caselle `e l’algoritmo A*

2 Dettagli Implementazione

2.1 metodo di utilizzo

Per modellare il problema `e stato utilizzato il linguaggio di programmazione python. Una qualsiasi configurazione delle 9 caselle viene fornita attraverso una tupla di 9 valori interi cosi formata (0,2,3,4,5,7,8,1). Per eseguire la ricerca `e sufficente istanziare la classe Problem(statoIniziale,statoGoal) for- nendo come ingresso al costruttore la configurazione iniziale delle 9 caselle e la configurazione finale (es: Problem((0,2,3,4,5,7,8,1),(0,1,2,3,4,5,6,7,8))); una volta istanziata la classe Problem necessito di una coda con priorit`a, che verr`a utilizzata come frontiera durante la ricerca,per ottenere la coda con priorit`a basta istanziare la classe PQueue(). Una volta istanziata la classe Prob- lem e quella della coda con priorit`a PQueue non resta che istanziare la classe Search(problema,frontiera,euristica) la quale contiene il metodo astar che riceve come parametri di ingresso: un problema (Problem) , la coda con pri- orit`a (PQueue) , una euristica (PatternDatabase oppure Manhattam ) e ricerca la soluzione del problema utilizzando l’algoritmo A*. L’ euristica utilizzata pu`o essere scelta tra 2: l’euristica basata sulla distanza manhattam cio`e la somma delle distanze di tutti i tasselli dalla loro posizione corrente a quella goal, che `e ottenibile istanziando la classe Manhattam(problema) passando al costrut- tore di questa il problema (Problem);Oppure l’euristica basata su database di pattern , che calcola la soluzione di ogni istanza del sottoproblema ricercando dallo stato goal(cercando all’indietro)ed inserendo il costo in un database; in questo caso ho preso come database una lista di tuple nella quale ho inserito

1

la configurazione di ogni sottoproblema con associato il costo esatto. I tas- selli usati per costruire il sottoproblema possono essere specificati inserendo nella lista tilesOftheSubproblem i numeri corrispondenti ai tasselli, presente nel metodo simplyfyProblem della classe HdbHeuristic(problema). L’euristica basata su Database di pattern `e ottenuta istanziando la classe HdbHeuristic che riceve come parametro del suo costruttore il problema (Problem);fatto ci`o, il metodo makeDb che costruisce il Database deve essere chiamato.Per utiliz- zare questa euristica durante la ricerca sar`a sufficente passare l’istanza della classe HdbHeuristic al metodo astar della classe Search,quest’ultimo restitu- isce il nodo (una istanza della classe Node) della soluzione.Tramite il metodo printSolution del nodo `e possibile stampare la soluzione, mentre il costo della soluzione `e memorizzato nell’attributo pathCost del nodo (Node) fornito in out- put dal metodo astar. Infine `e possibile caratterizzare la qualit`a dell’euristica determinando l’ effective branching factor o calcolare la Penetrance istanziando la classe Info(problema,nodoSoluzione) chiamando poi i metodi getPene- trance oppure effectiveBF a seconda di quello che si desidera.

2.2 Descrizione Classi principali

2.2.1 classe Search

Contiene il metodo astar che implementa l’algoritmo A* applicando l’euristica da noi fornita. Usa come frontier una coda con priorit`a realizzata tramite un heap, ordinata in base al valore di f (n) = g(n) + h(n), dove g(n) costo del cammino dallo stato iniziale allo stato n e h(n) `e il vaore della funzione euristica sul nodo n. finch`e la frontier `e piena, si estrae il nodo con la minima f (n) e si confronta lo stato del nodo con lo statoGoal, se questo `e verificato restituisce il nodo, altrimenti prendo gli stati che sono successori di quello corrente tramite la funzione problem.successor(state) e per ognuno di questi stati controllo che non sia gia stato trovato il pathCost di un cammino fino a qui o che il costo gi`a trovato sia maggiore di quello del nodo corrente e se questo `e verificato memorizzo il pathCost pi`u recente; per velocizzare l’algoritmo salvo anche il valore dell’euristica corrispondente allo stato del nodo se non `e presente nella cache.Infine inserisco nella frontiera il nuovo nodo figlio child con il valore f (n) associato. il dizionario h memorizza il valore della funzione euristica rendendo l’algoritmo pi`u efficente. il dizionario g memorizza il pathCost di ogni nodo esplorato. il dizionario link memorizza i collegamenti tra i nodi.

2.2.2 classe Manhattam

implementa l’euristica manhattam. contiene il metodo h che prende in input uno stato(configurazione dei 8 tasselli) e rende il valore dell’euristica basata sulla distanza manhattam (|x 2 x 1 | + |y 2 y 1 |). il metodo h per ogni elemento(tassello) dello stato (una configurazione delle 9 caselle), si serve del metodo searchCoordinateOfElementIntoMatrix per cercare le coordinate del tassello nella matrice dello stato attuale e in quella dello stato goal;dopodich`e utilizza il metodo distanceByTwoPoint per calcolare la distanza tra 2 el- ementi incrementando passo passo distance della quantit`a resa dal metodo distanceByTwoPoint.

2

2.2.3 classe HdbHeuristic

implementa l’euristica basata su Pattern di Database, cio`e prima specifico il sottoproblema: riordinare i tasselli specificati nella variabile tilesOftheSub- problem del metodo simplifyProblem,poi una volta specificati i tasselli per ogni configurazione di questi, ricerca dallo stato goal e salva la soluzione in una lista. Per determinare il valore dell’euristica non si fa altro che matchare il valore dello stato(che passo al metodo h) con quello del corrispondente sot-

toproblema dopodich`e, il valore dell’euristica sar`a il costo del sottoproblema. Il metodo makeDb crea il database servendosi del metodo makeCombina- tionOfSubproblem per creare una lista con tutte le possibili configurazioni del sottoproblema e, per ognuna di queste ricerca il costo di una soluzione par- tendo dallo stato goal, salvando la configurazione finale delle 9 caselle e il costo associato a questa in una lista db. Il metodo h prende uno stato,lo converte nel sottoproblema e rende il costo della soluzione associata al sottoproblema

di questo stato. Per convertire uno stato nel sottoproblema associato uso il

metodo simplyfyProblem;se specifico che i tasselli del sottoproblema sono [0,1,2] e lo stato `e (0,1,2,3,4,5,6,7,8) allora esegue una conversione del tipo (0,1,2,*,*,*,*,*,*);Per come `e costruito il programma `e necessario che il tas- sello 0 sia presente nel sottoproblema e per sottoproblema intendo portare i

tasselli scelti in ordine senza considerare gli altri.

3

Analisi

Per valutare le performance dell’algoritmo utilizzo dei parametri specifici del problema:

3.1 Penetrance

la penetrance mette in relazione la lunghezza del cammino generato con il

numero T di nodi espansi ed `e calcolata come P = L/T ; un algoritmo `e tanto migliore quanto pi`u la penetranza si avvicina ad 1 e se P = 1 allora ogni nodo espanso dall’algoritmo apparterrebbe al cammino ottimo.

3.2 Effective branching Factor

Effective branching Factor caratterizza la qualit`a dell’euristica.Se il numero totale di nodi generati da A* per un particolare problema `e N e la profondit`a

`e d allora b`e il fattore di ramificazione che un albero uniforme a profondit`a d

dovrebbe avere per contenere N +1 nodi: N +1 = 1+b+(b) 2 +

Una euristica bene progettata dovrebbe avere questo valore vicino ad 1

+(b) d .

3.3 ottimalit`a

L’ottimalit`a `e garantita dal fatto che ogni volta che trovo 2 cammini che portano allo stesso nodo il pi`u costoso viene scartato ed inoltre entrambe le euristiche sono ammissibili, questo garantisce l’ottimalit`a dell’algoritmo poich`e ogni nodo espanso sar`a sicuramente quello meno costoso,dunque quando `e trovato uno stato goal questo avr`a sicuramente un costo ottimo.

3

4

Conclusioni

confrontando le 2 euristiche utilizzate da A* sul problema dell’8-Puzzle ottengo che: l’euristica basata su database di pattern fino a che i tasselli specificati nel sottoproblema sono minori di 5 non espande meno nodi della ricerca con l’euristica manhattam; quando per`o i tasselli specificati sono pi`u di cinque i nodi espansi dalla ricerca A* con l’euristica basata su database di pattern sono meno rispetto a ricercare con l’euristica manhattam. Poich`e ho implementato il database come una lista, il calcolo del database deve essere rifatto ogni volta per cui, costruire il database con tutte le possibili configurazioni del sottoproblema richiede molto tempo se i tasselli specificati sono tanti.

richiede molto tempo se i tasselli specificati sono tanti. Figure 1: esempio ricerca con distanza manhattam

Figure 1: esempio ricerca con distanza manhattam

sono tanti. Figure 1: esempio ricerca con distanza manhattam Figure 2: esempio ricerca con euristica basata

Figure 2: esempio ricerca con euristica basata su pattern di database con 5 tasselli specificati 0,1,2,3,4

4