Przeszukiwanie przestrzeni rozwiązań

Wprowadzenie Przeszukiwanie wgłab Przeszukiwanie wszerz Heurystyki Gry Postscriptum

Sztuczna Inteligencja i Systemy EkspertowePrzeszukiwanie przestrzeni rozwiazan

Aleksander Pohlhttp://apohllo.pl/dydaktyka/ai

Wyzsza Szkoła Zarzadzania i Bankowosci

26 maja 2009

Aleksander Pohl WSZiB

Przeszukiwanie przestrzeni rozwiazan


Plan prezentacji

Wprowadzenie

Przeszukiwanie wgłab

Przeszukiwanie wszerz

Heurystyki

Gry

Postscriptum




Przestrzen stanów

◮ Graf o wezłach opisujacych sytuacje dla danego problemu◮ Rozwiazanie sprowadza sie do znalezienia sciezki

w grafie◮ Wieze hanoi◮ Problem „wilka, kozy i kapusty”◮ Problem komiwojazera (TSP)

◮ Problem okreslony jest przez:◮ Przestrzen stanów◮ Wezeł poczatkowy◮ Wezeł/Wezły koncowy/e◮ ew. koszty przejsc

◮ s(X,Y)◮ s(X,Y,Cost)




Przykład – klocki




Metody poszukiwania rozwiazania

◮ przeszukiwanie wgłab◮ z limitem głebokosci◮ z powiekszanym limitem głebokosci (iterative deepening)

◮ przeszukiwanie wszerz◮ przeszukiwanie heurystyczne

◮ A*◮ IDA*◮ RBFS◮ BEAM




Plan prezentacji

Wprowadzenie



Heurystyki

Gry

Postscriptum




Przeszukiwanie wgłab – implementacja

◮ solve(N,[N]) :-goal(N).

◮ solve(N,[N|Sol1]):-s(N,N1),solve(N1,Sol1).

◮ [a] , [a,b], [a,b,d], [a,b,e], ..




Wykrywanie cykli

◮ solve( Node, Solution) :-depthfirst( [], Node, Solution).

◮ depthfirst( Path, Node, [Node | Path] ) :-goal( Node).

◮ depthfirst( Path, Node, Sol) :-s( Node, Node1),not member( Node1, Path),depthfirst( [Node | Path], Node1, Sol).




Ograniczenie głebokosci

◮ depthfirst2( Node, [Node], _) :-goal( Node).

◮ depthfirst2( Node, [Node | Sol],Maxdepth) :-Maxdepth > 0, s( Node, Node1),Max1 is Maxdepth - 1,depthfirst2( Node1, Sol, Max1).




Warianty

◮ iteratywne zwiekszanie głebokosci – iterative deepening◮ małe wymagania pamieciowe – pamietana jest tylko

aktualna sciezka od stanu wyjsciowego do stanuaktualnego




Plan prezentacji

Wprowadzenie



Heurystyki

Gry

Postscriptum





◮ Jesli głowa pierwszej sciezki jest celem, to ta sciezka jestrozwiazaniem

◮ Usun pierwsza sciezke z listy kandydatów, wytwórzwszystkie jej rozszerzenia o jeden krok, umiesc je nakoncu listy kandydatów, przeszukaj wgłab ta liste

◮ [a], [a,b], [a,c], [a,b,d] ....




Implementacja (1)

◮ solve(Start, Solution) :-breadthfirst([[Start]], Solution).

◮ breadthfirst([[Node|Path] | _],[Node|Path]) :-goal(Node).

◮ breadthfirst([Path | Paths], Solution) :-extend(Path, NewPaths),conc(Paths, NewPaths, Paths1),breadthfirst(Paths1, Solution).




Implementacja (2)

◮ extend( [Node | Path], NewPaths) :-bagof([NewNode, Node | Path],(s( Node, NewNode),not member( NewNode, [Node | Path] ) ),NewPaths),!.

◮ extend( Path, [] ).




Implementacja z wykorzystaniem list róznicowych

◮ solve( Start, Solution) :-breadthfirst( [ [Start] | Z] - Z,Solution).

◮ breadthfirst([[Node | Path] | _] - _ ,[Node | Path]) :-goal( Node).

◮ breadthfirst( [Path | Paths] - Z,Solution) :-extend( Path, NewPaths),conc( NewPaths, Z1, Z),Paths = Z1,breadthfirst( Paths - Z1, Solution).




Podsumowanie

Metoda Czas Pamiec Najkrótsza sciezkaWszerz bd bd TakWgłab bdmax dmax NieIteracyjne pogł. bd d TakDwukierunkowy b(d/2) b(d/2) Tak

◮ b – czynnik rozgałezienia,◮ d – długosc najkrótszego rozwiazania,◮ dmax – ograniczenie głebokosci przeszukania




Plan prezentacji

Wprowadzenie



Heurystyki

Gry

Postscriptum




Najpierw najlepszy (najtanszy) wezeł

◮ f (n) - „trudnosc” dla wezła n◮ najlepszy: f (T ) = mini f (Si)

◮ Sciezka od s do t :◮ g(n) – koszt s → n◮ h(n) – koszt n → t◮ f (n) = g(n) + h(n) – A*




A*

◮ Redukcja czynnika rozgałezienia b na b′ b′ << b◮ Zajetosc pamieci znaczna◮ Złozonosc obliczeniowa bardziej tolerowalna niz

pamieciowa◮ Jesli heurystyczny koszt jest nie mniejszy od

rzeczywistego – algorytm wykrywa rozwiazania optymalne




A* – implementacja, pseudokod

function A * (start,goal)var closed := the empty setvar q := make_queue(path(start))while q is not emptyvar p := remove_first(q)var x := the last node of pif x in closed : continueif x = goal : return padd x to closedforeach y in successors(p)# sortowane po f(x) = g(x)+h(x)enqueue(q, y)return failure




A* – implementacja (1)

◮ expand(P,Tree,Bound,Tree1, Solved,Solution)

◮ Tree – obecne poddrzewo◮ P – sciezka od poczatku do Tree◮ Bound – obecnie najlepsza wartosc◮ Tree1 – Tree poszerzone tak by zachowac Bound◮ Solved – „yes”, „no”, „never”◮ Solution – sciezka od startu




A* – implementacja (2)

◮ I(N, F/G) – Lisc grafu:◮ N – stan◮ G – koszt z dojscia z Start do N,◮ F – G + h(N) (h – heurystyka)

◮ t(N, F/G, Subs) – poddrzewo grafu◮ N – Korzen◮ Subs – lista pod-drzew◮ F/G - j.w. (F – najwyzsze sposród nastepników N)




Implementacja (3)◮ bestfirst( Start, Solution) :-

expand([], l(Start, 0/0), 9999, _, yes,Solution).

◮ expand(P, l(N, _), _, _, yes, [N|P]) :-goal(N).

◮ expand(P, l(N,F/G), Bound, Tree1, Solved,Sol) :-F =< Bound,(bagof(M/C, (s(N,M,C), not member(M,P) ),Succ),!, succlist(G, Succ, Ts), bestf(Ts, F1),expand(P, t(N,F1/G,Ts), Bound, Tree1,Solved, Sol); Solved = never).




Implementacja (4)

◮ expand(P, t(N,F/G,[T|Ts]), Bound, Tree1,Solved, Sol) :-F =< Bound,bestf(Ts, BF), min(Bound, BF, Bound1),expand([N|P], T, Bound1, T1, Solved1, Sol),continue(P, t(N,F/G,[T1|Ts]), Bound, Tree1,Solved1, Solved, Sol).

◮ expand(_, t(_,_,[]), _, _, never, _) :- !.




Implementacja (5)

◮ expand(_, Tree, Bound, Tree, no, _) :-f(Tree, F), F > Bound.

◮ continue(_, _, _, _, yes, yes, Sol).

◮ continue(P, t(N,F/G,[T1|Ts]), Bound, Tree1,no, Solved, Sol) :-insert(T1, Ts, NTs),bestf(NTs, F1),expand(P, t(N,F1/G,NTs), Bound, Tree1,Solved, Sol).




Implementacja (6)

◮ insert(T, Ts, [T | Ts]) :-f(T, F), bestf(Ts, F1), F =< F1, !.

◮ insert(T, [T1 | Ts], [T1 | Ts1]) :-insert(T, Ts, Ts1).

◮ f(l(_,F/_), F).

◮ f(t(_,F/_,_), F).

◮ bestf([T|_], F) :- f(T, F).

◮ bestf([], 9999).

◮ min(X, Y, X) :-X =< Y, !.

◮ min(X, Y, Y).




Implementacja (7)

◮ succlist(_, [], []).

◮ succlist(G0, [N/C | NCs], Ts) :-G is G0 + C,h(N, H),F is G + H,succlist(G0, NCs, Ts1),insert(l(N,F/G), Ts1, Ts).




IDA* – iterative deepening A*

◮ Bound=f(Start)◮ Repeat

◮ Dokonaj szukania wgłab uwzgledniajac takie wezły N zef(N)<=Bound

◮ „if” cel osiagniety – koniec◮ „else”:

◮ NewBound = min{ f(N) | N wygenerowany , f(N)>Bound}◮ Bound=NewBound

◮ Until znaleziono rozwiaznie




Inne rozwiazania

◮ RBFS – recursive best-first search◮ A* – zapamietuje wszystkie wezły◮ RBFS – odrzuca te gałezie które nie sa optymalne

◮ BEAM search◮ na kazdym poziomie rozwijamy tylko m najlepszych sciezek

(m – beam)◮ niekoniecznie znajduje rozwiazanie




Plan prezentacji

Wprowadzenie



Heurystyki

Gry

Postscriptum




Grafy i/lub – przykład (1)




Grafy i/lub – przykład (2)

Szukanie sciezki – rozłozenie na podproblemy◮ W grafie a-z istnieja dwa „mosty” - f,g◮ Dwa mozliwe rozwiazania – a-z przez f badz a-z przez g

◮ Znajdz sciezke a-f i f-z◮ lub◮ Znajdz sciezke a-g i g-z




Grafy i/lub – charakterystyka (1)

◮ Dzieli problem na podproblemy◮ Wezły w grafie sa problemami, krawedzie relacjami◮ Dla wezła „LUB” (ma tylko wychodzace krawedzie

połaczone relacja „lub”) jeden z nastepników musi dacrozwiazanie

◮ Dla wezła „I” (ma tylko wychodzace krawedzie połaczonerelacja „I”) kazdy z nastepników musi dac rozwiazanie




Grafy i/lub – charakterystyka (2)

◮ Okreslamy problem przez wezeł startowy, warunkiosiagniecia celu

◮ Wezły celu odpowiadaja „trywialnym” rozwiazaniom◮ Rozwiazanie reprezentowane jest przez drzewo◮ Cała przestrzen posiada tylko wezły LUB◮ Wezły I odpowiadaja podproblemom, połaczenie

rozwiazan podproblemów winno dac globalne rozwiazanie◮ W teorii gier – „moje ruchy” – wezły LUB,

„jego ruchy” - wezły I




Zasada mini-max

◮ Dla gier dwuosobowych:◮ Okreslamy heurystyczna funkcje celu

◮ Im wieksza tym wieksza szansa zwyciestwa

◮ W kolejnych krokach na zmiane bierzmy minimum imaximum tej funkcji

◮ Po okreslonej głebokosci wybieramy cel maksymalizujacyfunkcje docelowa

◮ Efekt „horyzontu zdarzen”




Mini-max – przykład




Mini-max – pseudokod

function minimax(node, depth)if node is a terminal node or depth = 0

return the heuristic value of nodeif the adversary is to play at node

let α := +∞

foreach child of nodeα := min( α, minimax(child, depth-1))

else we are to play at nodelet α := −∞

foreach child of nodeα := max( α, minimax(child, depth-1))

return α




Mini-max – implementacja (1)

◮ minimax(Pos, BestSucc, Val) :-moves(Pos, PosList), !, best(PosList,BestSucc, Val) ;staticval(Pos, Val).

◮ best([ Pos], Pos, Val) :-minimax(Pos, _, Val), !.

◮ best([Pos1 | PosList], BestPos, BestVal) :-minimax(Pos1, _, Val1),best(PosList, Pos2, Val2),betterof(Pos1, Val1, Pos2, Val2, BestPos,BestVal).




Mini-max – implementacja (2)

◮ betterof(Pos0, Val0, Pos1, Val1, Pos0,Val0) :-min_to_move(Pos0), %nastepny ruch jegoVal0 > Val1, ! ;max_to_move(Pos0), % nastepny ruch mojVal0 < Val1, !.

◮ betterof(Pos0, Val0, Pos1, Val1, Pos1,Val1).




Mini-max – szachy

◮ 80 półruchów, 40 ruchów ∼ 100040 pozycji◮ MinMax – szukamy Min w ruchu przeciwnika, Max w

naszym




Algorytm alfa-beta

◮ Nie rozpatrujemy wszystkich wezłów◮ Gwarantujemy ze wartosc MAX jest nie mniejsza niz Alfa◮ Gwarantujemy ze wartosc MIN jest nie wieksza niz Beta◮ Z kazdym krokiem zwezamy przedział o nowo znalezione

wartosci




Alfa-beta – pseudokod

function minimax(node, depth)return alphabeta(node, depth, - ∞, + ∞)

function alphabeta(node, depth, α, β)if node is a terminal node or depth = 0

return the heuristic value of nodeforeach child of node

α := max( α, -alphabeta(child, depth-1,- β, - α))

if α ≥ β

return β

return α




Alfa-beta – implementacja (1)

◮ alphabeta(Pos, Alpha, Beta, GoodPos, Val):-moves(Pos, PosList), !,boundedbest(PosList, Alpha, Beta, GoodPos,Val);staticval(Pos, Val).

◮ boundedbest([Pos | PosList], Alpha, Beta,GoodPos, GoodVal) :-alphabeta(Pos, Alpha, Beta, _, Val),goodenough(PosList, Alpha, Beta, Pos, Val,GoodPos, GoodVal).




Alfa-beta – implementacja (2)◮ goodenough([], _, _, Pos, Val, Pos, Val) :-

!.◮ goodenough(_, Alpha, Beta, Pos, Val, Pos,

Val) :-min_to_move(Pos), Val > Beta, ! ;max_to_move(Pos), Val < Alpha, !.

◮ goodenough(PosList, Alpha, Beta, Pos, Val,GoodPos, GoodVal) :-newbounds(Alpha, Beta, Pos, Val, NewAlpha,NewBeta),boundedbest(PosList, NewAlpha, NewBeta,Pos1, Val1),betterof(Pos, Val, Pos1, Val1, GoodPos,GoodVal).




Alfa-beta – implementacja (3)

◮ newbounds(Alpha, Beta, Pos, Val, Val, Beta):-min_to_move(Pos), Val > Alpha, !.

◮ newbounds(Alpha, Beta, Pos, Val, Alpha,Val) :-max_to_move(Pos), Val < Beta, !.

◮ newbounds(Alpha, Beta, _, _, Alpha, Beta).

◮ betterof(Pos, Val, Pos1, Val1, Pos, Val) :-min_to_move(Pos), Val > Val1, ! ;max_to_move(Pos), Val < Val1, !.

◮ betterof(_, _, Pos1, Val1, Pos1, Val1).




Alfa-beta – podsumowanie

◮ sqrt(b) – redukcja czynnika rozgałezienia przy best-first(szachy: 30 -> 6)

◮ Ulepszenia:◮ „heuristic pruning” - usuwanie mało obiecujacyh gałezi◮ „progressive deepening”◮ ograniczenia czasowe◮ zapamietywanie ruchów posrednich




Plan prezentacji

Wprowadzenie



Heurystyki

Gry

Postscriptum




Materiały zródłowe

◮ L.Sterling, E.Shapiro - „The Art Of Prolog”◮ Ivan Bratko - „Prolog – Programming For Artificial

Intelligence”◮ Slajdy zostały przygotowane za zgoda

dr. Michała Korzyckiego na podstawie jego wykładu.



Przeszukiwanie przestrzeni rozwiązań

Documents

Transcript of Przeszukiwanie przestrzeni rozwiązań