Heurystyczne przeszukiwanie przestrzeni stanów

Heurystyczne przeszukiwanie przestrzeni stanów Wykład Informatyka Studia InŜynierskie Podstawowe pojęcia teorii grafów przeszukiwania Korzeń grafu Stan, od którego zaczynamy przeszukiwanie grafu (drzewa) początkowy stan problemu (instancja problemu) Wierzchołek końcowy (terminalny) Stan, który ma określoną wartość z punktu widzenia wyniku danego zadania (np. poraŝka, zwycięstwo, remis w grze) Liść Dowolny stan w grafie, w którym zatrzymujemy proces przeszukiwania i przypisujemy mu ocenę heurystyczną Wierzchołek wewnętrzny KaŜdy inny stan, którego wartość zaleŝy od jego poprzedników lub następników

Podstawowe pojęcia teorii grafów przeszukiwania c.d. Głębokość przeszukiwania (aktualna) Liczba przejść stanów (ruchów) od korzenia grafu do stanu aktualnego Branching factor Średnia liczba następników stanu (śr( śr.. liczba ruchów w stanie) Drzewa przeszukiwania/dag Większość grafów przeszukiwania to DAG (acykliczne grafy skierowane), część z nich to drzewa Generowanie następników Podstawowe pojęcia Korzeń Branching factor Wierzchołek wewnętrzny Stan Głębokość przeszukiwania Stan końcowy Ocena heurystyczna (liść)

Heurystyczne przeszukiwanie Połączenie wiedzy przedmiotowej dotyczącej danego zadania i metod przeszukiwania dla efektywnego poszukiwania rozwiązania Stosowane w celu ograniczenie kombinatorycznej eksplozji stanów w grafie przeszukiwania Nie gwarantuje znalezienia rozwiązania, pozwala jednak wybierać lub odrzucać pewne stany, określając tym samym dalsze kierunki przeszukiwania Heurystyka w przeszukiwaniu Jest praktyczną metodą poprawiającą efektywność rozwiązywania złoŝonych problemów Prowadzi do rozwiązania wzdłuŝ najbardziej prawdopodobnej drogi, omijając mniej obiecujące ścieŝki Podaje proste kryteria wyboru kierunków przeszukiwania jednak bez kategorycznego wskazywania stanów jednoznacznie dobrych i/lub złych Powinna pozwalać na unikanie przeszukiwania bezowocnych ścieŝek oraz wykorzystywanie informacji dotychczas zdobytych w trakcie analizy przestrzeni stanów do poprawy dalszego procesu poszukiwania rozwiązania

Rola heurystyki w przeszukiwaniu Zwiększa niepewność otrzymania wyniku w procesie konstrukcji rozwiązania ze względu na wykorzystywanie nieformalnej wiedzy przedmiotowej (zasady, reguły, intuicje itp.), której słuszność/uŝyteczność nie do końca jest znana Pozwala w naturalny sposób wykorzystywać informacje niepewne i nieprecyzyjne, które często towarzyszą przetwarzaniu danych pochodzących ze świata rzeczywistego Poprawia efektywność algorytmu poszukiwania rozwiązania danego problemu bezpośrednio (przez wskazywanie najlepszych kierunków przeszukiwania) lub pośrednio (przez eliminowanie najmniej obiecujących kierunków) Realizacja przeszukiwania heurystycznego Systemy eksperckie Gdy problem nie posiada dokładnego rozwiązania ze względu na swoją charakterystykę: * niejednoznaczność zadania (jaki jest cel, który mamy osiągnąć?) * nieprecyzyjne lub niepewne dane (błędy w danych) * brak wszystkich niezbędnych danych (niepełne dane) Algorytmy poszukiwania rozwiązania z numeryczną funkcją oceny stanu Gdy istnieją dokładne rozwiązania, ale wymagania zasobowe (pamięć, czas) są zbyt duŝe (kombinatoryczna eksplozja stanów w problemach rzeczywistych!)

Elementy składowe heurystycznych metod przeszukiwania Reprezentacja stanu przestrzeni (silnie zaleŝna od zastosowania) Stany startowe (początkowe, inicjujące) Stany końcowe (terminalne) Generator następników stanu (zbiór dopuszczalnych operatorów/akcji/ruchów) Procedura przeszukiwania Mechanizm wyboru następnego wierzchołka w grafie Mechanizm nawrotów Mechanizmy wykrywania cykli Funkcja heurystycznej oceny stanu Gdzie stosujemy przeszukiwanie heurystyczne? Problemy jednoosobowe (np.zagadki logiczne itp.) Problemy optymalizacji (np. nawigacja robota - znajdowanie najkrótszej ścieŝki, szeregowanie itd.) Gry dwuosobowe Systemy dowodzenia twierdzeń

Przykład zastosowania heurystyki Ruch heurystycznie najlepszy Rozmiary przestrzeni: Pełna - 9! Symetria i powtórzenia - 7! Heurystyka -. 9 Algorytmy przeszukiwania heurystycznego Problemy jednoosobowe Algorytm wspinaczkowy Algorytm Best-first first-searchsearch Algorytm A * Algorytm IDA * Gry dwuosobowe Algorytm min-max max Algorytm alfa-beta

Algorytm wspinaczkowy (ang. hill climbing) procedure hill_climbing(initial_state initial_state) begin current_node = initial_state; next = []; if current_node = goal then return(success); while true do begin generate all children of current_node; if any of children is a goal state then return(success); assign heuristic value to each child state; set next to a lowest-valued child of current_node; if value of next > value of current_node then return(success); % stop! - no improvements set current_node to next; end; % while end. Algorytm wspinaczkowy - przykład A- B- C- D- E F G H I J K L M N O P Q R S T U 7

Algorytm wspinaczkowy - przykład A- B- C- D- E- F- G H I J K L M N O P Q R S T U Algorytm wspinaczkowy - przykład A- B- C- D- E- F- G H I J K- L- M N O P Q R S T U 8

Algorytm wspinaczkowy - przykład A- B- C- D- E- F- G H I J K- L- M N O P Q R S T- U Algorytm wspinaczkowy - przykład A- B- C- D- E- F- G H I J K- L- M N O P Q R S T- U 9

Algorytm wspinaczkowy: charakterystyka Cechy szczególne Ocena heurystyczna stanu z reguły traktowana jako koszt Małe wymagania pamięciowe (brak historii!) Brak mechanizmu nawrotów Nieoptymalny Wady Lokalne ekstrema funkcji - zatrzymanie Plateaux - brak postępu w przeszukiwaniu Grzbiety funkcji powolny postęp w przeszukiwaniu? Algorytm wspinaczkowy: metody poprawy Nawroty do poprzednich stanów i próba wykorzystania innych, niemal równie dobrych, następników jak ten pierwotnie wybrany (trzeba zarezerwować dodatkową pamięć!) Wykonywanie "duŝych skoków" tzn. wybieranie operatorów, które wprowadzają ogromne zmiany stanu problemu lub, jeśli brak takowych, wykonywanie kilku drobnych kroków "pod rząd" w jednym wybranym kierunku przestrzeni stanów Wykonywanie kilku kroków w róŝnych kierunkach, ale bez sprawdzania wartości osiąganych stanów RóŜne punkty startowe (stany początkowe) algorytmu 0

Algorytm Best-first search () procedure best_first_search(initial_state) begin open = [initial_state]; closed = []; while open [] do begin remove the next state from open,, call it X; if X is a goal state then return(solution path that led to X); process X,, generating all its children; for each child of X do case the child is not already on open nor closed:... the child is already on open:... the child is already on closed:... end; %case put X on closed; re-order states on open according to heuristic merit (lower( values first); end; % while return(failure); % open is exhausted end....... Algorytm Best-first search () case the child is not already on open or closed: begin assign heuristic value to the child state; add the child state to open; end; the child is already on open: begin if the child was reached along shorter path than the state currently on open then give the state on open this shorter path value; end; the child is already on closed: begin if the child was reached along shorter path than the state currently on closed then begin give the state on closed this shorter path value; move the state from closed to open; end end; end; %case

Algorytm Best-first search - przykład A B C D E F G H I J Open Closed K L M N O P Q R S T U Algorytm Best-first search - przykład A B- C- D- E F G H I J Open Closed K L M N O P Q R S T U

Algorytm Best-first search - przykład A B- C- D- E- F- G H I J Open Closed K L M N O P Q R S T U Algorytm Best-first search - przykład A B- C- D- E- F- G H I J Open Closed K- L- M N O P Q R S T U

Algorytm Best-first search - przykład A B- C- D- E- F- G H I J Open Closed K- L- M N O P Q R S T- U Algorytm Best-first search - przykład A B- C- D- E- F- G H I J Open Closed K- L- M N O P Q R S T- U

Algorytm Best-first search - przykład A B- C- D- E- F- G H I J Open Closed K- L- M- N O P Q R S T- U Algorytm Best-first search - przykład A B- C- D- E- F- G H I J Open Closed K- L- M- N O P Q R S T- U

Algorytm Best-first search - przykład A B- C- D- E- F- G- H- I J Open Closed K- L- M- N O P Q R S T- U Algorytm Best-first search - przykład A B- C- D- E- F- G- H- I J Open Closed K- L- M- N O- P- Q R S T- U

Algorytm Best-first search - przykład A B- C- D- E- F- G- H- I J Open Closed K- L- M- N O- P- Q R S T- U Algorytm Best-first search - przykład A B- C- D- E- F- G- H- I J Open Closed K- L- M- N O- P- Q R S T- U- 7

Algorytm Best-first first-search: : charakterystyka Cechy szczególne Mechanizm nawrotów lista OPEN Historia ruchów wykrywanie cykli lista OPEN i CLOSED Wielokierunkowe przeszukiwanie przestrzeni Im lepsza ocena heurystyczna stanów, tym mniejszy obszar przeszukiwania Wady DuŜe wymagania pamięciowe (złoŝoność pamięciowa O(b d ), b branching factor, d głębokość przeszukiwania) Nieoptymalny (w ogólnym przypadku, ale...) Algorytm Best-fist fist-searchsearch - przykład 8 7 8 7 8 7 8 7 Ocena heurystyczna: liczba ruchów od startu do danego stanu (głębokość) plus liczba płytek (elementów) poza swoim połoŝeniem docelowym 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 7 8 8 7 8 7 8 7 8 7 7 8 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 8 7 7 8 8 cel 7 8

Ocena heurystyczna jaka? 8 7 7 8 7 8 7 Proponowana heurystyczna ocena 0 0 0 Próba : Liczba płytek poza pozycjami docelowymi Wada: Nie uwzględnia jak daleko jest kaŝda płytka od miejsca docelowego Próba : Suma odległości wszystkich płytek od miejsca docelowego Wada: Ignoruje fakt (podobnie jak poprzednia heurystyka), Ŝe prosta zamiana miejscami dwóch płytek to więcej niŝ dwa ruchy Próba : Liczba odwróconych par płytek pomnoŝona przez mały współczynnik (np. ) Wada: Nie uwzględnia sekwencji ruchów Funkcja oceny heurystycznej - definicja Funkcją oceny heurystycznej nazywamy funkcję rzeczywistą określoną na zbiorze wierzchołków grafu przestrzeni stanów postaci: f(n) ) = g(n) ) + h(n), gdzie: g(n) jest aktualną długość ścieŝki od stanu n do stanu początkowego, h(n) jest heurystycznym oszacowaniem odległości od stanu n do celu. 9

Przykład zastosowania funkcji oceny heurystycznej OPEN CLOSED 8 7 Stan b f(b) ) = 8 7 8 7 Stan a f(a) ) = Stan c f(c) ) = 8 7 Stan d f(d) ) = g(n) = 0 g(n) = 8 7 Stan e f(e) ) = 8 7 Stan f f(f) ) = 8 7 Stan g f(g) ) = g(n) = 8 7 Stan h f(h) ) = 8 7 Stan i f(i) ) =7 8 7 Stan j f(j) ) = 8 7 Stan k f(k) ) =7 g(n) = f(n) ) = g(n) ) + h(n), gdzie: g(n) ) rzeczywista odległość od startu do stanu n, h(n) ) liczba płytek (elementów) poza swoim połoŝeniem docelowym cel 8 7 Stan m f(m) ) = 8 7 Stan l f(l) ) = 7 8 Stan n f(n) ) =7 g(n) = g(n) = Funkcja oceny heurystycznej a algorytm Best-first first-searchsearch Niech dany będzie algorytm Best-first first-searchsearch z oceną heurystyczną postaci: f(n) ) = g(n) ) + h(n), jeŝeli dla kaŝdego stanu g(n) ) = 0 to otrzymujemy tzw. przeszukiwanie zachłanne (brak gwarancji znalezienia optymalnego rozwiązania) jeŝeli dla kaŝdego stanu h(n) ) = 0 i g(n) ) = depth(n) to mamy przeszukiwanie wszerz (moŝliwe znalezienie optymalnego rozwiązania) 0

Algorytm A - definicja RozwaŜmy funkcję oceny: f(n) ) = g(n) ) + h(n) gdzie: n jest dowolnym stanem odwiedzonym w czasie przeszukiwania, g(n) jest kosztem osiągnięcia stanu n od początku przeszukiwania, h(n) jest heurystycznym oszacowaniem kosztu przejścia od stanu n do celu. JeŜeli ta ocena (w pełnej postaci) jest realizowana łącznie z algorytmem best-first first-search,, to rezultat nazywa się algorytmem A. A Algorytm A - przykład A B- C- D- E- F- G- H- I- J- K- L- M- N- O- P- Q- R- S- T- U-0 7 Open Closed

Algorytm A - przykład A B- 0 C- 0 D- E- F- G- H- I- J- K- L- M- N- O- P- Q- R- S- T- U-0 7 0 Open Closed Algorytm A - przykład A B- C-0 D- E- F- G- H- I- J- K- L- M- N- O- P- Q- R- S- T- U-0 7 0 Open Closed

Algorytm A - przykład A B- C- D- E- F- G- H- I- J- K- L- M- N- O- P- Q- R- S- T- U-0 7 Open Closed Algorytm A - przykład A B- C- D- E- F- G- H- I- J- K- L- M- N- O- P- Q- R- S- T- U-0 7 Open Closed

Algorytm A - przykład A B- C- D- E- F- G- H- I-7 J- K- L- M- N- O- P- Q- R- S- T- U-0 7 7 Open Closed Algorytm A - przykład A B- C- D- E- F- G- H- I-7 J- K- L- M- N- O- P- Q- R- S- T- U-0 7 7 Open Closed

Algorytm A - przykład A B- C- D- E- F- G- H- I-7 J- K- 7 L- M- N- O- P- Q- R- S- T- U-0 7 7 Open Closed Algorytm A - przykład A B- C- D- E- F- G- H- I-7 J- K- 7 L- M- N- O- P- Q- R- S- T- U-0 7 7 Open Closed

Algorytm A - przykład S- A B- C- D- E- F- G- H- I-7 J- K- 7 L- M- T- 7 N- O- P- Q- R- U-0 7 Open Closed Algorytm A - przykład A B- C- D- E- F- G- H- I-7 J- K- 7 L- M- N- O- P- Q- R- S- T- U-0 7 7 Open Closed

Algorytm A - przykład A B- C- D- E- F- G- H- I-7 J- K-7 L- M- N-7 O- P- Q- R- S- T- U-0 7 7 7 7 Open Closed Algorytm A - przykład S- A B- C- D- E- F- G- H- I-7 J- K-7 L- M- T- 7 7 7 N-7 O- P- Q- R- U-0 7 koniec! Open Closed 7

Teoretyczne własności heurystyk a problemy przeszukiwania Czy algorytm znajduje najkrótszą ścieŝkę do celu? Dopuszczalność heurystyki (ang. admissibility) Czy kaŝdy stan w przestrzeni jest osiągany przy najniŝszym koszcie? Monotoniczność heurystyki (ang. monotonicity) Czy moŝna szybciej znaleźć rozwiązanie przy pomocy innej (lepszej) heurystyki? Informatywność heurystyki (ang. informedness) Teoretyczne własności heurystyk: idealna funkcja oceny heurystycznej Przyjmijmy następujące oznaczenia: g * (n) koszt najkrótszej ścieŝki od stanu początkowego do stanu n, h * (n) jest rzeczywistym kosztem przejścia najkrótszą ścieŝką od stanu n do celu, f * (n) rzeczywisty koszt optymalnej ścieŝki prowadzącej od stanu początkowego przez stan n do celu (tj. f * (n)= g * (n)+ h * (n)), Funkcja f * (n) to idealna wyrocznia - jej istnienie eliminowałoby potrzebę przeszukiwania! W trakcie przeszukiwania z reguły g(n) g * (n),, dopóki nie odkryjemy najkrótszej ścieŝki do n,, wtedy g(n) ) = g * (n). Nie jesteśmy w stanie podać wartości h * (n) przed zakończeniem przeszukiwania, dlatego stosujemy jego oszacowanie, czyli h(n). 8

Dopuszczalność (ang. admissibility) Definicja Algorytm przeszukiwania jest dopuszczalny,, jeŝeli dla dowolnego grafu zawsze kończy się na optymalnej ścieŝce do rozwiązania, o ile taka ścieŝka istnieje. Przykład Algorytm przeszukiwania wszerz Algorytm A * Definicja JeŜeli algorytm A wykorzystuje funkcję oceny taką, Ŝe h(n) ) jest mniejsze lub równe kosztowi minimalnej ścieŝki od wierzchołka n do celu (tj. h(n) h * (n)), to otrzymany w ten sposób algorytm nazywa się algorytmem A *. Twierdzenie Wszystkie algorytmy A * są dopuszczalne. 9

Niedoszacowanie wartości oceny heurystycznej A f = (h ( + g) n g(n)= depth(n) B (+) (+) C D (+) E (+) G F (+) (+) ZaniŜenie wartości, tzn. h < h * H (+) X goal Przeszacowanie wartości oceny heurystycznej A f = (h ( + g) n g(n)= depth(n) B (+) (+) C D (+) E (+) F (+) G (0+) X goal ZawyŜenie wartości, tzn. h > h * 0

Monotoniczność (ang. monotonicity) Funkcja oceny heurystycznej f jest monotoniczna,, gdy: dla dowolnych stanów s i oraz s j, gdzie s j jest następnikiem s i zachodzi: h(s i ) - h(s j ) cost(s i, s j ) gdzie cost(s i, s j ) jest rzeczywistym kosztem (w liczbie ruchów) przejścia od stanu s i do s j, i oszacowanie heurystyczne stanu docelowego jest równe zero h(goal) ) = 0 Monotoniczność, czyli spójność heurystyki Monotoniczność to tzw. lokalna dopuszczalność,, która oznacza, iŝ kaŝdy stan (a nie tylko stany docelowe) osiągany jest po najkrótszej ścieŝce. Monotoniczność oznacza równieŝ, Ŝe heurystyka jest spójna w całej przeszukiwanej przestrzeni. s i h(s i ) s i cost(s i, s j ) s j h(s j ) h(s i ) - h(s j ) cost(s i, s j ) h(s i ) cost(s i, s j ) + h(s j ) goal goal

Monotoniczność, czyli spójność heurystyki Heurystyka jest monotoniczna (inaczej: lokalnie dopuszczalna) jeŝeli dla kaŝdego stanu s i, kaŝdy jego następnik s j generowany przez akcję a,, która spełnia warunek: h(s i ) cost(s i, a, s j ) + h(s j ) h(s i ) s i goal cost(s i,a,s j ) s j h(s j ) Nierówność trójkątów!!! Jeśli h jest monotoniczna, to: f (s j ) = g(s j ) + h(s j ) = g(s i ) + cost(s i,a,s j ) + h(s j ) g(s i ) + h(s i ) = f(s i ) f (s j ) f(s i ) tzn. f(s i ) nigdy nie maleje podczas przeszukiwania! Czy monotoniczny to równieŝ dopuszczalny? RozwaŜmy dowolną ścieŝkę w przestrzeni stanów s, s,..., s g, prowadzącą od stanu początkowego s do stanu końcowego s g. Dla dowolnego ciągu ruchów na tej ścieŝce zachodzi: od s do s h(s ) - h(s ) cost(s, s ) od s do s h(s ) - h(s ) cost(s, s ) od s do s h(s ) - h(s ) cost(s, s )...... od s g- do s g h(s g- ) - h(s g ) cost(s g-, s g ) dodając obustronnie stronami otrzymujemy: ścieŝka od s do s g h(s ) - h(s g ) cost(s, s g ). Na podstawie własności monotoniczności wiemy, Ŝe h(s g ) = 0,, więc: h(s ) cost(s, s g ). PoniewaŜ cost(s, s g ) = h * (s ), to h(s ) h * (s ), czyli heurystyka monotoniczna jest dopuszczalna.

Jak uzyskać monotoniczność? JeŜeli funkcja oceny heurystycznej f nie jest monotoniczna,, ale jest dopuszczalna, zawsze moŝliwe jest zapewnienie monotoniczności za pomocą tzw. reguły PATHMAX. Reguła PATHMAX Jeśli dla dowolnych stanów s i oraz s j, gdzie s j jest następnikiem s i zachodzi: f(s i ) > f(s j ), to nową wartość funkcji oceny dla s j naleŝy wyznaczyć według zaleŝności: f(s j ) = max( f(s i ), g(s j ) + h(s j ) ) Co nam daje monotoniczność? procedure MonotonicBFS(initial_state) begin open = [initial_state]; closed = []; while open [] do begin remove the next state from open,, not already on closed,c,call it X; if X is a goal state then return(solution path that led to X); process X,, generating all its children; for each child of X do begin assign heuristic value to the child state; add the child state to open;!!! end; put X on closed; re-order states on open according to monotonic heuristic merit (lower values first); end; % while return(failure); % open is exhausted end.

Informatywność (ang. informedness) Dla dwóch heurystyk h i h typu A *, jeŝeli h (n) h (n),, dla dowolnego stanu n w przeszukiwanej przestrzeni, to o h mówi się, Ŝe zawiera więcej informacji niŝ h (jest lepiej poinformowana). JeŜeli heurystyka h jest lepiej poinformowana niŝ h, to zbiór stanów odwiedzanych przez h jest podzbiorem stanów odwiedzanych przez h. h h h h h * NajwaŜniejsze twierdzenia dot. algorytmu A * JeŜeli oszacowanie h(n) ) jest dopuszczalne,, to algorytm A* jest optymalny dla drzew przeszukiwania JeŜeli oszacowanie h(n) ) jest monotoniczne,, to algorytm A* jest optymalny dla dowolnych grafów przeszukiwania JeŜeli heurystyka jest monotoniczna,, to jest równieŝ dopuszczalna JeŜeli oszacowanie h(n) ) jest monotoniczne,, to wartości f(n) ) w trakcie przeszukiwania nigdy nie maleją

Funkcje heurystyczne - jak definiować? Uproszczenie oryginalnego zadania poprzez rozluźnienie ograniczeń nałoŝonych na definicję operatorów ruchu (generację następnika) Koszt optymalnego rozwiązania dla tak uproszczonego problemu jest dopuszczalną heurystyką zadania oryginalnego! Przykłady dla układanki 8-polowej8. JeŜeli załoŝymy, Ŝe moŝna dokonywać przesunięć płytkami na dowolne miejsce (a nie tylko puste), to znajdziemy najkrótsze rozwiązanie - tak heurystyka jest dopuszczalna.. JeŜeli załoŝymy, Ŝe moŝna dokonywać przesunięć płytkami na dowolne ortogonalnie sąsiednie pole (a nie tylko puste), to znajdziemy najkrótsze rozwiązanie - tak heurystyka jest równieŝ dopuszczalna. IDA * - algorytm A * z iteracyjnym pogłębianiem Przeszukiwanie z ograniczoną zajętością pamięci Schemat iteracyjnego pogłębiania Limit dopuszczalnej głębokości zastąpiony przez limit wartości funkcji oceny heurystycznej

Algorytm IDA * - cz. procedure IDA * -Search( Search(initial_state) begin f_limit f(initial_state initial_state); while true do begin (solution, f_limit ) DFS-Contour( Contour(initial_state, f_limit); if solution null then return(solution solution); if f_limit = then return(failure failure); f_limit f_limit ; end; end. Algorytm IDA * - cz. function DFS-Contour( Contour(current_state, f_limit) begin next_f ; if f(current_state) ) > f_limit then return(null, f(current_state)); if current_state is a goal then return(current_state current_state, f_limit); while current_state has unexamined children do begin child := next unexamined child of current_state; (solution, new_f) DFS-Contour( Contour(child, f_limit); if solution null then return(current_state current_state+solution, f_limit); next_f min(next_f next_f, new_f ); end return(null, next_f); end.

Algorytm IDA * - przykład A-0 f_limit=? Algorytm IDA * - przykład A-0 f_limit=0 B- 0 7

Algorytm IDA * - przykład A-0 f_limit=0 E- B- 0 Algorytm IDA * - przykład A-0 f_limit=0 B- 0 E- F- 8

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit=0 E- F- Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit=0 E- F- G- 9

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit=0 E- F- G- H- Algorytm IDA * - przykład A-0 B- 0 C- 0 D- f_limit=0 E- F- G- H- 0

Algorytm IDA * - przykład A-0 0 f_limit= Algorytm IDA * - przykład A-0 f_limit= B- 0

Algorytm IDA * - przykład A-0 f_limit= E- B- 0 Algorytm IDA * - przykład A-0 f_limit= B- 0 E- F-

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G-

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- O-

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- O- P- Algorytm IDA * - przykład A-0 B- 0 C- 0 D- f_limit= E- F- G- H- O- P-

Algorytm IDA * - przykład A-0 0 f_limit= Algorytm IDA * - przykład A-0 f_limit= B- 0

Algorytm IDA * - przykład A-0 f_limit= E- B- 0 Algorytm IDA * - przykład A-0 f_limit= B- 0 E- F- 7

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- 8

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- O- 9

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- O- P- Algorytm IDA * - przykład A-0 B- 0 C- 0 D- f_limit= E- F- G- H- O- P- 0

Algorytm IDA * - przykład A-0 B- 0 C- 0 D- f_limit= E- F- G- H- I- O- P- 7 Algorytm IDA * - przykład A-0 B- 0 C- 0 D- 7 f_limit= E- F- G- H- I-7 J- O- P- 7 7

Algorytm IDA * - przykład A-0 0 f_limit= Algorytm IDA * - przykład A-0 f_limit= B- 0

Algorytm IDA * - przykład A-0 f_limit= E- B- 0 Algorytm IDA * - przykład A-0 f_limit= K- 7 E- B- 0

Algorytm IDA * - przykład A-0 f_limit= E- K-7L- B- 7 0 Algorytm IDA * - przykład A-0 f_limit= K-7L- B- E- F- 7 0

Algorytm IDA * - przykład A-0 f_limit= K- 7 L- B- E- F- 0 Algorytm IDA * - przykład A-0 f_limit= K- 7 L- T- B- E- F- 0

Algorytm IDA * - przykład A-0 f_limit= B- E- F- 0 K-7L- M- 7 T- Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- K-7L- M- 7 T-

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- K-7L- M- 7 T- Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- K-7L- M- 7 T- N- 7 7

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- K-7L- M- 7 T- N- 7 Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- K-7L- M- 7 T- N- 7 O- 8

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- K-7L- M- 7 T- N- 7 O- P- Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- K-7L- M- 7 N- 7 O- P- T- U-0 9

Algorytm IDA * - przykład A-0 B- 0 C- 0 D- f_limit= E- F- G- H- K-7L- M- 7 N- 7 O- P- T- U-0 Algorytm IDA * - przykład A-0 B- 0 C- 0 D- f_limit= E- F- G- H- I- K-7L- M- 7 N- 7 O- P- 7 T- U-0 0

Algorytm IDA * - przykład A-0 B- 0 C- 0 D- 7 f_limit= E- F- G- H- I-7 J- K-7L- M- 7 N- 7 O- P- 7 7 T- U-0 Algorytm IDA * - przykład A-0 0 f_limit=

Algorytm IDA * - przykład A-0 f_limit= B- 0 Algorytm IDA * - przykład A-0 f_limit= E- B- 0

Algorytm IDA * - przykład A-0 f_limit= K- 7 E- B- 0 Algorytm IDA * - przykład A-0 f_limit= E- K-7L- B- 7 0

Algorytm IDA * - przykład A-0 f_limit= E- K-7L- B- 7 T- 0 Algorytm IDA * - przykład A-0 f_limit= K-7L- B- E- F- 7 T- 0

Algorytm IDA * - przykład A-0 f_limit= K- 7 L- T- B- E- F- 0 Algorytm IDA * - przykład A-0 f_limit= K- 7 L- T- B- E- F- 0

Algorytm IDA * - przykład A-0 f_limit= B- E- F- 0 K-7L- M- 7 T- Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- K-7L- M- 7 T-

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- K-7L- M- 7 T- Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- K-7L- M- 7 T- N- 7 7

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- K-7L- M- 7 T- N- 7 Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- K-7L- M- 7 T- N- 7 O- 8

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- K-7L- M- 7 T- N- 7 O- P- Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- K-7L- M- 7 N- 7 O- P- T- U-0 9

Algorytm IDA * - przykład A-0 B- 0 C- 0 f_limit= E- F- G- H- K-7L- M- 7 N- 7 O- P- T- U-0 koniec! Algorytm IDA * : charakterystyka Cechy szczególne Brak historii nie ma list OPEN i CLOSED NiŜsze wymagania pamięciowe niŝ A * - proporcjonalne do najdłuŝszej badanej ścieŝki - O(bd bd) Limit wartości f w następnej iteracji jest najmniejszą wartością spośród wszystkich tych ocen, które przekroczyły aktualny limit sukcesywnie powiększany obszar przeszukiwania śadna ścieŝka w trakcie przeszukiwania nie moŝe mieć kosztu o wartości, która byłaby między dwoma kolejnymi limitami na wartość f Optymalny i pełny dla tych samych warunków co algorytm A * Wady W grafach DAG wielokrotnie moŝe docierać do tego samego stanu róŝnymi ścieŝkami Słabe wykorzystanie pamięci: kiedy ocena heurystyczna dla kaŝdego o stanu jest inna, to liczba nowych stanów, którego zostaną objęte przeszukiwaniem w kolejnej iteracji wynosi dokładnie (dla N róŝnych stanów konieczne będzie wykonanie nie N iteracji!!!) 70

Heurystyczne przeszukiwanie grafów gier dwuosobowych Wykład Informatyka Studia InŜynierskie Gry dwuosobowe - przeszukiwanie heurystyczne Dwóch przeciwników posiadających pełną informację o stanie gry i wszystkich moŝliwych ruchach Jeden gracz nosi nazwę Max,, bo: maksymalizuje rezultat końcowy kaŝdy wzrost wartości oznacza zysk dla tego gracza i równowaŝną stratę dla przeciwnika Drugi gracz nosi nazwę Min,, bo: minimalizuje rezultat końcowy kaŝdy spadek wartości oznacza zysk dla tego gracza i równowaŝną stratę dla przeciwnika 7

Zasada min-max max 8 max 8 7 min 8 9 9 8 7 max 7 8 9 9 8 7 Algorytm min-max max function MinMax(s: state, depth: integer, type: integer): integer; begin if is_terminal_node(s) or depth=0 then return(eval(s)); if type = MAX then begin best := - ; for child:= to NumOfSucc(s) do begin val := MinMax(Succ(s,child), depth-, MIN); if val > best then best := value; end end else { type = MIN } begin best := ; for child:= to NumOfSucc(s) do begin val := MinMax(Succ(s,child), depth-, MAX); if val < best then best := value; end end return best; end; 7

Przykład min-max max - gra NIM - korzeń MAX 7- - - - - - - -- --- -- -- - MAX MIN MAX --- - --- --- Ocena: mniejsza wartość ---- ----- bo wygrał wygrana MIN MIN większa wartość bo wygrał wygrana MAX ----- MAX MIN MAX MIN Przykład min-max max - gra NIM - korzeń MIN 7 MIN - - - -- - -- - -- -- MAX MIN --- - - --- --- Ocena: mniejsza wartość ---- - ---- bo wygrał wygrana MIN MAX większa wartość bo wygrał wygrana MAX ------ MIN MAX MIN MAX 7

Zasada negamax 8 8 7-8 - -7-8 -9 - -9-8 -7 8 9 9 8 7 max(y) y = -min min = max(x) x = -max max(z) 7 8 9 9 8 7 z Algorytm nega-max function MinMax-NegaMax(s: state, depth: integer): integer; begin if is_terminal_node(s) or depth=0 then {terminal position} return(eval(s,depth depth)); {find maximum of child values} best := - ; for child:= to NumOfSucc(s) do best := max(best, -MinMax(Succ(s,child), depth-); return(best); end; Funkcja heurystycznej oceny stanu musi uwzględniać do kogo naleŝy oceniany ruch. JeŜeli do gracza MAX to ocena jest w postaci prostej, jeśli do gracza MIN - w postaci zanegowanej. 7

Przykład nega-max - gra NIM - ruch MIN 7 - -MIN - - - -- -- - -- - -- MAX -MIN Ocena: MIN wartość zanegowana MAX wartość prosta ---- --- ---- - ---- przegrał MIN ---- wartość zaneg. przegrał MAX ------ wartość prosta MAX -MIN MAX Przykład nega-max - gra NIM - ruch MAX 7 - MAX - - - -- -- - -- - -- -MIN MAX Ocena: MIN wartość zanegowana MAX wartość prosta ---- --- ---- - ---- przegrał MAX ---- wartość prosta przegrał MIN ------ wartość zanegowana -MIN MAX -MIN 7

Kółko i krzyŝyk - heurystyka Funkcja oceny heurystycznej stanu gry - róŝnica liczby moŝliwych wygranych gracza X i gracza O Gracz X ma moŝliwych wygranych Gracz O ma moŝliwych wygranych E(n) = - = Gracz X ma moŝliwych wygranych Gracz O ma moŝliwych wygranych E(n) = - = - Gracz X ma moŝliwych wygranych Gracz O ma moŝliwych wygranych E(n) = - = Kółko i krzyŝyk - przykład gry() - Ruch MAXa - -= -=0=0 -= -=0=0 -= =- -= -= -= =- -=0=0 -= =- -=0=0 -= =- 7

Kółko i krzyŝyk - przykład gry() -= -= -= -= -= -= 0 Ruch MAXa -= -=0=0 -= -=0=0 -= -= 0 -= -= -= -= -= -= -= -= -=0=0 Kółko i krzyŝyk - przykład gry() - Ruch MAXa -= -= -= -= - -= -= -= - - - - -= -=0=0 -= - -= -= -= - -=0=0 -=0=0 -= 77

Algorytm min-max max (lub negamax) Przyjmując określony branching factor (b)) oraz stałą głębokość przeszukiwania (d)( ZłoŜoność pamięciowa O(bd) ZłoŜoność czasowa O(b d ) Czy moŝna ten wynik poprawić? Tak! Branch&bound Odcięcie α - ograniczenie dolne odcięcie α 7 9 78

Odcięcie β - ograniczenie górneg 9 odcięcie β 9 Odcięcia α-β 8 8 = 8 max 7 = 8 8 8 = 8 8 α 8 9 = = 8 9 8 β 8 8 α min max 7 8 9 9 8 7 79

Odcięcia α-β C = max = = 0 A D 0 E 0 α = 0 = B 0 β α min max 9 0 7 A ma próg β = (A nie będzie większe niŝ ) B odcięcie dla β,, bo > C ma próg α = (C nie będzie mniejsze niŝ ) D odcięcie dla α,, bo 0 < E odcięcie dla α,, bo < C ma wartość Głębokie odcięcia α-β = = = = = 7 7 β 0 0 7 8 α max min max min 0 7 max 80

Algorytm AlfaBeta (zapis min-max) max) wywołanie:result = AlphaBeta(s, MAXDEPTH, -,, MAX) int AlphaBeta(state s,int depth,int alpha,int beta,int type) { if( is_terminal_node(s) depth == 0 ) return(eval(s)); if( type == MAX){ for(child=; child<=numofsucc(s); child++) { val = AlphaBeta(Succ(s,child),depth-,alpha,beta,,alpha,beta,MIN); alpha = max(val val,, alpha); if( alpha >= beta ) return beta; //cutoff } //endfor return alpha; } else { // type == MIN for(child=; child<=numofsucc(s); child++) { val = AlphaBeta(Succ(s,child),depth-,alpha,beta,,alpha,beta,MAX); beta = min(val val,, beta); if( alpha >= beta ) return alpha; //cutoff } //endfor return beta; } } Mechanizm odcięć alfa-beta Dwa ograniczenia: α dolne ograniczenie dla wierzchołków max (najwyŝsza wartość jaką dotychczas osiągnął gracz max) β górne ograniczenie dla wierzchołków min (najniŝsza wartość jaką dotychczas osiągnął gracz min) Wartość ograniczenia α ustalana jest w wierzchołku max Wartość ograniczenia β ustalana jest w wierzchołku min Odcięcie α wykonywane jest w wierzchołku min Odcięcie β wykonywane jest w wierzchołku max Kiedy tylko zachodzi warunek α β, nie ma potrzeby analizowania dalszych następnik pników w danego stanu 8

Algorytm AlfaBeta (zapis nega-max) function AlfaBeta(s:state, α,β:integer, depth: integer): integer; begin if is_terminal_node(s) or depth=0 then {terminal position} return(eval Eval(s,depth)); {find maximum of child values} for child:= to NumOfSucc(s) do begin α := max(α, -AlfaBeta( Succ(s,child), -β, -α, depth-); if α β then return(β); {cutoff!} end return(α); end; wywołanie: result := AlfaBeta(s, -,, MAXDEPTH) Sformułowanie negamax dla AlfaBeta Sformułowanie min-max max wymaga przemiennych wywołań rekurencyjnych dwóch graczy (raz dla gracza MAX, dwa dla gracza MIN, itd.) Sformułowanie negamax opiera się tylko na graczu MAX (jedna funkcja rekurencyjna) Przy wyjściu z rekurencji negujemy zwracaną wartość Przy zagnieŝdŝeniu rekurencyjnym negujemy ograniczenia i zamieniamy miejscami, aby zachować niezmienność warunku odcięcia 8

Analiza algorytmu AlfaBeta Wartości zwracane: w wersji minmax: : ze względu na gracza w korzeniu w wersji negamax: : ze względu na tego czyj jest ruch w liściu Bardzo zawikłany kod ewentualny błędy pozostają długo ukryte (problemy moŝna zauwaŝyć tylko wtedy, gdy niepoprawne wartości zostaną przepropagowane do korzenia grafu) Efektywność algorytmu zaleŝy w ogromnym stopniu od kolejności następników i występowania odcięć Analiza algorytmu AlfaBeta Sytuacja idealna jeśli odcięcie ma się pojawić, to powinno wystąpić jak najszybciej, czyli najlepiej zaraz po sprawdzeniu pierwszego następnika 7 9 odcięcie α 9 7 9? zmieniona kolejność 8

Odcięcia α-β (mniej odcięć! ęć!) 8 8 = 8 max 7 = 8 8 8 = 8 8 9 = 9 9 =? 8 = 9 = = 8 9 8 8 8 α min max? 7 8 9 9 8 7 zmieniona kolejność ZłoŜoność algorytmu AlfaBeta Dla danej głębokości (d)( ) i stałego braching factor (b) Najlepszy przypadek: O(b d/ ) Najgorszy przypadek: brak odcięć (czyli jak MinMax) Średni przypadek: O(( ((b/log b) b d ) 8

Słabości algorytmu AlfaBeta Efekt horyzontu (ang. horizont effect) Niewidoczny spadek wartości stanu tuŝ za wyznaczoną głębokością przeszukiwania Występuje we wszystkich odmianach algorytmu Wykrywanie stanów naraŝonych na wystąpienie efektu horyzontu i prowadzenia przeszukiwania za tym stanami - problem otwarty Rozszerzenia algorytmu AlfaBeta Doskonalenie funkcji oceny stanu (funkcji heurystycznej) Modyfikacje sposobu przeszukiwania grafu zastosowanie pamięci (np. tablica przejść) porządkowanie następników manipulowanie zakresem α-β zmienna głębokość g przeszukiwania przeszukiwanie eksploracyjne Rozwiązania sprzętowe (np. obliczenia równoległe) 8