Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza...
-
Upload
eula-turco -
Category
Documents
-
view
214 -
download
1
Transcript of Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza...
![Page 1: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/1.jpg)
Dipartimento di Ingegneria dell’InformazioneUniversità degli Studi di Parma
Intelligenza Artificiale
Risoluzione dei Problemi(parte 3)
Agostino Poggi
Stefano Cagnoni
![Page 2: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/2.jpg)
Risoluzione dei Problemi 2
L’Algoritmo A*
L’algoritmo lungo il cammino più vicino al goal (Greedy Search) minimizza il costo, h(n), per raggiungere il goal e spesso permette di ridurre considerevolmente il costo della ricerca, ma non è completo e neppure ottimo.
L’algoritmo di ricerca a costo uniforme minimizza il costo, g(n), del percorso ed è completo e ottimo, ma può essere molto inefficiente.
Combinando i due metodi si ottiene un algoritmo, detto A*, che offre i vantaggi di entrambi.
Per fare ciò, l’algoritmo A* somma le due funzioni di valutazione: f(n) = g(n) + h(n).
![Page 3: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/3.jpg)
Risoluzione dei Problemi 3
L’algoritmo A*
Possiamo definire un l’algoritmo A* come:
function A*-Search(problem, Enqueue-by-g+h) {
return General-Search(problem, Enqueue-by-g+h);
}
Si può provare che l’algoritmo A* è ottimo e completo se h è una euristica ammissibile, cioè se non sovrastima mai il costo per raggiungere il goal.
L’algoritmo A* è ottimamente efficiente (optimally efficient) per ogni funzione euristica, cioè non esiste alcun altro algoritmo ottimo che espande un numero di nodi minore dell’algoritmo A*.
![Page 4: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/4.jpg)
Risoluzione dei Problemi 4
L’Algoritmo A*
Si può dimostrare che l’algoritmo A* è ottimo. Sia OG un goal a costo minimo f* e sia SG un goal con costo
fg* > f*.
Supponiamo che A* abbia scelto SG e dimostriamo che ciò non è possibile.
Sia n un nodo sul percorso ottimo verso OG. Poiché la funzione h è ammissibile, allora risulta: f* f(n)
Ma, se è stato scelto SG, f(n) fg* e quindi segue che: f* fg*
![Page 5: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/5.jpg)
Risoluzione dei Problemi 5
L’Algoritmo A*
L’algoritmo A* è completo: questo algoritmo espande nodi nell’ordine dato dai rispettivi valori di f. Quindi se un goal ha valore f*, l’algoritmo A* è completo se non ci sono infiniti nodi con f < f*.
Anche se l’algoritmo A* è l’algoritmo di ricerca ottimo che espande il minor numero di nodi, in molti casi la complessità è esponenziale in funzione della lunghezza della soluzione.
Si è provato che il numero di nodi espansi cresce esponenzialmente a meno che l’errore della stima h del vero costo h* non cresca più lentamente del logaritmo del costo reale del percorso. Cioè |h(n) - h*(n)| <= O(log h*(n))
![Page 6: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/6.jpg)
Risoluzione dei Problemi 6
Scelta dell’Euristica
Consideriamo un problema molto semplice come 8-puzzle. Una soluzione tipica ha 20 mosse.
Dato che il fattore di ramificazione è circa 3, allora una ricerca in profondità esaustiva visiterebbe 320 = 3.5 x 109 nodi.
Il numero di nodi visitati si può limitare eliminando i nodi già visitati, dato che gli stati possibili sono 9! = 362880.
Tuttavia, sono valori eccessivi per poter risolvere il problema in modo esaustivo. Occorre quindi cercare di limitare la lunghezza della ricerca con delle buone euristiche.
![Page 7: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/7.jpg)
Risoluzione dei Problemi 7
Scelta dell’Euristica
Due euristiche candidate per l’8-puzzle sono: h1 = numero di quadrati fuori posizione. h2 = Manhattan distance = somma delle distanze dei quadrati dalla
loro posizione finale.
Da risultati sperimentali si ricava che h2 è migliore. Questo è ovvio dato che:
Entrambe le euristiche non sovrastimano il costo per raggiungere il goal, cioè sono ammissibili.
Per ogni configurazione h2 h1
Quindi h2 è una stima migliore del costo per raggiungere il goal.
![Page 8: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/8.jpg)
Risoluzione dei Problemi 8
Scelta dell’Euristica
Ecco un confronto dei costi di IDS e A* con h1 e h2 (numero
medio di nodi espansi in 100 esperimenti):
d IDS A*(h1) A*(h2) 2 10 6 6 4 112 13 12 6 680 20 18 8 6384 39 2510 47127 93 3912 364404 227 7314 3473941 539 11316 1301 21118 3056 36320 7276 67622 18094 121924 39135 1641
![Page 9: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/9.jpg)
Risoluzione dei Problemi 9
Scelta dell’Euristica
Come si può scegliere una euristica? Può un programma compiere questa scelta in modo automatico ?
Le due euristiche esaminate per l’8-puzzle sono le funzioni di valutazione esatte della distanza dal goal per due versioni semplificate del problema.
Quindi si può dire che le soluzioni di un problema Pr, ottenuto rilassando le regole di un problema P, sono delle buone euristiche per P.
Un altro modo per generare delle buone euristiche è usare delle informazioni statistiche.
Ad esempio se so che se h2(n) = 14 allora al 90% la reale distanza è 18. allora uso 18.
![Page 10: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/10.jpg)
Risoluzione dei Problemi 10
A* Iterativo in Profondità (Iterative Deepening A* - IDA*)
L’algoritmo A* nei casi peggiori richiede molta memoria. Si può usare la tecnica della ricerca iterativa in profondità per limitare la memoria necessaria.
In questo caso il limite non è la profondità del nodo, ma il costo f: ad ogni ciclo vengono espansi solo i nodi con costo minore del limite e viene aggiornato il limite per il prossimo ciclo al minimo valore f dei nuovi nodi generati.
Come A* è completo ed ottimo e dato che si basa su una ricerca in profondità ha una complessità spaziale di bd.
![Page 11: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/11.jpg)
Risoluzione dei Problemi 11
A* Iterativo in Profondità - IDA*
La complessità temporale dipende dal numero di valori che la funzione euristica può assumere dato che questo numero determina il numero di iterazioni.
In alcuni casi, ad esempio la Manhattan distance per il problema dell’8-puzzle, la funzione euristica assume pochi valori.
In altri casi, ad esempio, la distanza euclidea per il problema del commesso viaggiatore, la funzione euristica assume molti valori con limite massimo il numero di nodi N: 1 + 2 + ... + N = O(N2)
![Page 12: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/12.jpg)
Risoluzione dei Problemi 12
A* Iterativo in Profondità - IDA*
Un modo per superare questo limite è incrementare il limite di costo di rendendo il numero di cicli proporzionale a 1/.
Questo algoritmo è detto -ammissibile. Che problemi può avere rispetto all’algoritmo IDA*? L’algoritmo non è ottimo perché può ritornare una soluzione
che può essere peggiore di quella ottima, ma al massimo di .
![Page 13: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/13.jpg)
Risoluzione dei Problemi 13
A* Iterativo in Profondità - IDA*
Possiamo definire l’algoritmo IDA* come segue:
function IDA*(problem) {
root = Make-Node(Initial-State(problem));
f-limit = f-Cost(root)
while true {
solution, f-limit = DFS-Contour(root, f-limit);
if solution return solution;
if (f-limit = = ) return failure;
}
![Page 14: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/14.jpg)
Risoluzione dei Problemi 14
A* Iterativo in Profondità - IDA*
Dove la funzione DFS-Contour è definita come segue:
function DFS-Contour(problem, node, f-limit) {
next-f = ;
if (f-Cost(node) > f-limit) return null, f-limit;
if Goal(State(node), problem) return node, f-limit;
for each son in Expand(node, problem) {
solution, new-f = DFS-Contour(son, f-limit);
if solution return solution, f-limit;
next-f = Min(next-f, new-f);
}
return null, next-f;
}
![Page 15: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/15.jpg)
Risoluzione dei Problemi 15
SMA*(Simplified Memory-Bounded A*)
L’algoritmo IDA* non ha memoria e quindi non può evitare il problema degli stati ripetuti.
E’ possibile modificare l’algoritmo per evitare ripetizioni all’interno dello stesso percorso, ma non in percorsi differenti.
L’algoritmo SMA* supera questo problema e può lavorare con una quantità di memoria limitata.
L’algoritmo opera in modo simile a A*, tuttavia quando non c’è più memoria a disposizione: Rilascia la memoria del nodo meno promettente. Memorizza nel nodo padre il costo del percorso migliore che partiva
dal nodo rimosso.
![Page 16: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/16.jpg)
Risoluzione dei Problemi 16
SMA*
I nodi rimossi sono rigenerati solo nel caso in cui tutti i percorsi attivi assumano un valore peggiore del valore di un percorso rimosso.
L’algoritmo SMA* ha le seguenti proprietà: Utilizza la memoria a disposizione. Evita di rigenerare nodi nei limiti della memoria a disposizione. È completo se la memoria è sufficiente a contenere il percorso che
comprende la soluzione. È ottimo se la memoria è sufficiente a contenere il percorso della
soluzione, altrimenti ritorna la migliore soluzione che può raggiungere con la memoria a disposizione.
È ottimamente efficiente se può memorizzare tutto l’albero di ricerca.
![Page 17: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/17.jpg)
Risoluzione dei Problemi 17
SMA*
Se la memoria è sufficiente l’algoritmo SMA* risolve dei problemi più difficili di quelli risolti da A*.
Tuttavia, con problemi molto difficili, risolvibili da A* se avesse a disposizione una memoria illimitata, la necessità di ripetere più volte la generazione di nodi rende il problema intrattabile dal punto di vista temporale.
![Page 18: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/18.jpg)
Risoluzione dei Problemi 18
SMA*
0+12=12
24+5=29
10+5=15
30+0=30
24+0=24
8+5=13
24+0=2420+5=25 20+0=20
30+5=35
A
K
BG
I
J
E F
DC
H10+8=18
![Page 19: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/19.jpg)
Risoluzione dei Problemi 19
SMA*
12A
13(15)
13
18
A
H
G
13
15 13
A
BG
15 (15)
24()
A
I
G
24
15
15
A
B
24()G
12
15
A
B
15(24)
15
A
B
C
25
15(24)
20 ()
A
B
D
20
1
7
6
5
2 3 4
8
![Page 20: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/20.jpg)
Risoluzione dei Problemi 20
SMA*
Possiamo definire l’algoritmo SMA* come segue:
function SMA*(problem) {
queue = Make-Queue(Make-Node(Initial-State(problem)));
while true {
if Empty(queue) return failure;
n = Remove-Front(queue);
if Goal(State(n), problem) return n
s = Next-Successor(n);
‘manage s’
Enqueue-by-f(s, queue);
}
}
![Page 21: Dipartimento di Ingegneria dellInformazione Università degli Studi di Parma Intelligenza Artificiale Risoluzione dei Problemi (parte 3) Agostino Poggi.](https://reader037.fdocuments.net/reader037/viewer/2022110305/5542eb59497959361e8c5513/html5/thumbnails/21.jpg)
Risoluzione dei Problemi 21
SMA*
Il codice che gestisce s ha la forma:if ‘s is not a goal and is at maximum depth’
f(s) = ;
else f(s) = Max(g(s) + h(s), f(n));
if ‘all n’s successors have been generated’ (n è il padre di s)
‘update n’s f and those of its ancestors if necessary’
if ‘all n’s successors are in memory’
Remove(n, queue);
if ‘memory is full’ {
‘delete the shallowest highest-f-cost node from queue’
‘remove it from its parent’s successor list
‘insert its parent on queue if necessary’
}