Intelligenza Artificiale: 8-Puzzle with A*

Alberto Merciaimatricola:5421314

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 configurazione iniziale casuale,spostando le tessere in orizzontale e verticale grazie alla
tessera vuota,si deve giungere alla configurazione goal:
1
4
7

3
5

2
6
8

3
6

1
4
7

2
5
8

lalgoritmo utilizzato per ottenere il nodo goal partendo da una qualsiasi

configurazione iniziale delle 8 caselle `e lalgoritmo A*

2
2.1

Dettagli Implementazione
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) fornendo 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 Problem 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 priorit`
a (PQueue) , una euristica (PatternDatabase oppure Manhattam ) e ricerca
la soluzione del problema utilizzando lalgoritmo A*. L euristica utilizzata pu`o
essere scelta tra 2: leuristica 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 costruttore di questa il problema (Problem);Oppure leuristica basata su database di
pattern , che calcola la soluzione di ogni istanza del sottoproblema ricercando
dallo stato goal(cercando allindietro)ed inserendo il costo in un database; in
questo caso ho preso come database una lista di tuple nella quale ho inserito

la configurazione di ogni sottoproblema con associato il costo esatto. I tasselli 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). Leuristica
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 utilizzare questa euristica durante la ricerca sar`a sufficente passare listanza della
classe HdbHeuristic al metodo astar della classe Search,questultimo restituisce 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 nellattributo pathCost del nodo (Node) fornito in output dal metodo astar. Infine `e possibile caratterizzare la qualit`a delleuristica
determinando l effective branching factor o calcolare la Penetrance istanziando
la classe Info(problema,nodoSoluzione) chiamando poi i metodi getPenetrance oppure effectiveBF a seconda di quello che si desidera.

2.2
2.2.1

Descrizione Classi principali

classe Search

Contiene il metodo astar che implementa lalgoritmo A* applicando leuristica

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 lalgoritmo salvo anche il
valore delleuristica 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
lalgoritmo 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 leuristica manhattam. contiene il metodo h che prende in input

uno stato(configurazione dei 8 tasselli) e rende il valore delleuristica basata
sulla distanza manhattam (|x2 x1 | + |y2 y1 |). 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 elementi incrementando passo passo distance della quantit`a resa dal metodo
distanceByTwoPoint.

2.2.3

classe HdbHeuristic

implementa leuristica basata su Pattern di Database, cio`e prima specifico il

sottoproblema: riordinare i tasselli specificati nella variabile tilesOftheSubproblem 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 delleuristica non si fa altro che matchare
il valore dello stato(che passo al metodo h) con quello del corrispondente sottoproblema dopodich`e, il valore delleuristica sar`a il costo del sottoproblema.
Il metodo makeDb crea il database servendosi del metodo makeCombinationOfSubproblem per creare una lista con tutte le possibili configurazioni
del sottoproblema e, per ognuna di queste ricerca il costo di una soluzione partendo 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 tassello 0 sia presente nel sottoproblema e per sottoproblema intendo portare i
tasselli scelti in ordine senza considerare gli altri.

Analisi

Per valutare le performance dellalgoritmo 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 dallalgoritmo apparterrebbe al cammino ottimo.

3.2

Effective branching Factor

Effective branching Factor caratterizza la qualit`a delleuristica.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 +.....+(b)d .
Una euristica bene progettata dovrebbe avere questo valore vicino ad 1

3.3

ottimalit`
a

Lottimalit`
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 lottimalit`a dellalgoritmo 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.

Conclusioni

confrontando le 2 euristiche utilizzate da A* sul problema dell8-Puzzle ottengo

che: leuristica basata su database di pattern fino a che i tasselli specificati
nel sottoproblema sono minori di 5 non espande meno nodi della ricerca con
leuristica manhattam; quando per`o i tasselli specificati sono pi`
u di cinque i
nodi espansi dalla ricerca A* con leuristica basata su database di pattern sono
meno rispetto a ricercare con leuristica 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.

Figure 1: esempio ricerca con distanza manhattam

Figure 2: esempio ricerca con euristica basata su pattern di database con 5

tasselli specificati 0,1,2,3,4