Mesterséges intelligencia 3. laborgyakorlat Kétszemélyes játékok - Minimax A következő típusú játékok megoldásával foglalkozunk: (a) kétszemélyes, (b) determinisztikus, (c) zéróösszegű, (d) teljes információjú. A következő fogalmakat vezetjük be: 1. állapot, kiinduló állapot 2. játékfa 3. végteszt 4. hasznosságfüggvény vagy nyereségfüggvény 5. stratégia 6. lépés - féllépés (ang. ply) 7. MAX, MIN a két játékos. MAX kezd, és a nyereségét próbálja maximizálni; MIN a veszteségét próbálja minimizálni. 8. MAX illetve MIN csomópontok. A minimax algoritmus optimális stratégiát ad MAX kezébe: 1. generáljuk a teljes játékfát a le a végcsomópontokig 2. alkalmazzuk a terminális csúcsokra a hasznosságfüggvényt 3. alulról felfele haladva, annak függvényében, hogy MIN vagy MAX csomóponton vagyunk számítsuk ki a gyerek csúcsok minimumát, vagy maximumát, és ezt az értéket rendeljük hozzá az aktuális csúcshoz. Ez lesz a csúcs minimax értéke. A gyökér minimax értéke megadja, hogy mekkora MAX nyeresége abban az esetben, ha MIN a lehető legjobban játszik. (Ha MIN nem játszik optimálisan, akkor MAX nyeresége ennél nagyobb lesz.)
A minimax algoritmus 1 int minimax(state s) 3 if (end_of_game(s)) return utility(s); 4 state * children; 6 int best_value = is_max_node(s)? -INFINITY: +INFINITY; 7 if (is_max_node(s)){ 8 for (int i = 0; i < n; i++){ 9 best_value = max(best_value, minimax(children[i]); 12 else{ 13 for (int i = 0; i < n; i++){ 14 best_value = min(best_value, minimax(children[i]); 15 } 16 } 17 18 return best_value; Mélységkorlátozott minimax A keresési fa a nemtriviális játékok esetén túl nagy ahhoz, hogy teljes keresést végezzünk rajta. Ezért a keresés csak egy bizonyos előre meghatározott mélységig folyik. 1 int minimax(state s, int depth) 2 if (depth==0 end_of_game(s)) return heuristic_eval(s); 3 state * children; 4 int n = generate_children(s, &children); 5 int best_value = is_max_node(s)? -INFINITY: +INFINITY; 6 7 if (is_max_node(s)){ 8 for (int i = 0; i < n; i++){ 9 best_value = max(best_value, minimax(children[i],depth-1); 12 else{ 13 for (int i = 0; i < n; i++){ 14 best_value = min(best_value, minimax(children[i],depth-1); 15 } 16 } 17 18 return best_value; Kérdések: 1. Milyen mélységig elemezzük ki a fát? 2. Mit csináljon a heuristic_eval? Iteratívan mélyülő keresés Mivel nem tudjuk, hogy milyen mélységig keressünk és csak korlátozott idő áll a rendelkezésre, ezért keressünk rendre 0, 1, 2, 3, stb. mélységig. Mikor lejárt az idő, térjünk vissza azzal annak a mélységnek a minimax értékével, amelyet még sikerült teljesen kiértékelni.
NegaMax A klasszikus minimaxban az egyik játékos maximalizálni, a másik minimizálni akarja ugyanazt az függvényt. Kis módosítással egyszerűsíteni lehet a kódot, úgy, hogy mindkét játékos maximizálni akarjon. Vegyük észre, hogy az algoritmus komplexitása ezzel nem változik. 1 int negamax(state s, int depth) 3 if (depth==0) return heuristic_eval(s); 4 state children; 6 int best_value = -INFINITY; 7 for (int i = 0; i < n; i++){ 8 best_value = max(best_value, -negamax(children[i], depth-1); 9 } 10 return best_value; Feladatok. 1. Minimax algoritmust használva implementálja a Tic-tac-toe játékot. Használja a következő nyereségfüggvényt: +1, ha s nyerő pozíció MAX-nak f (s) = 1, ha s nyerő pozíció MIN-nek 0 ha s döntetlen pozíció Beküldési határidő: március 31, 23:59. Grafikus interfész nem szükséges. Alfa-béta nyesés Ugyanannyi idő alatt nagyobb mélységben járhatjuk be a játékfát, ha bizonyos részfákat nem értékelünk ki. A lenyesendő részfát úgy kell kiválasztani, hogy az ne befolyásolja a keresés minőségét. Az ötlet a következő. Ha egy lépésről már eleve tudjuk hogy rossz, akkor ne töltsünk időt azzal, hogy kiértékeljük, hogy valójában mennyire rossz az illető lépés. Vegyük a következő kifejezést: max(6, min(5, x)) Ennek a kifejezésnek az értéke 6 lesz, függetlenül x értékétől. Ezért az x csomópontot nem kell kifejteni, mert nem fogja befolyásolni az eredményt. x-et tehát lenyeshetjük. Hasonlóan a min(5, max(6, Y )) kifejezés értéke is az x értékétől függetlenül 5 lesz. Tehát az y-al kezdődő részfát is levághatjuk. Nézzünk egy komplexebb példát: A 1 a minimax értékét a hagyományos módon számoljuk ki. Rögtön következik, hogy MAX-nak legalább 3 a minimax értéke, tehát az A 1 alsó korlátot jelent a gyökér minimax értékére (a gyökér minimax értéke háromnál kisebb nem lesz). Lemegyünk A 2 felé, kiszámoljuk A 21 -t, ami 2. Mivel a gyökér minimax értéke legalább 3, és az A 2 legfönnebb 2-t fog felhozni, ezért A 22 -t, és A 23 -at nincs értelme kiértékelni.
A feladat tehát, hogy visszatérjünk a csúcs minimax értékével, miközben lenyessük a nem releváns ágakat. A megoldás folyamán két értéket fogunk tárolni, és frissíteni: α - az a legkisebb érték, amelyre MAX számíthat (kezdetben ), illetve β - az a legnagyobb érték, amelyre MIN számíthat (kezdetben + ) 1 int alpha_beta(state s, int depth, int alpha, int beta) 3 if (depth==0 end_of_game(s)) return heuristic_eval(s); 4 state * children; 6 if (max_node(s)){ 7 for (int i = 0; i < n; i++){ 8 alpha = max(alpha, alpha_beta(children[i], depth-1, alpha, beta)); 9 if (alpha >= beta) return alpha; 11 return alpha; 12 } 13 else{ 14 for (int i = 0; i < n; i++){ 15 beta = min(beta, alpha_beta(children[i], depth-1, alpha, beta)); 16 if (alpha >= beta) return beta; 17 } 18 return beta; 20 } Egy csúcs kibontásakor a gyerekek által visszatérített minimax érték alsó (felső) korlátot jelent az aktuális csúcs számára. Az algoritmus a legjobb alsó korlátot folyamatosan α-ban, a legjobb felső korlátot β-ban tárolja. Ha a keresés folyamán egy olyan X állapotba jutunk, ahol α β, akkor ez azt jelenti, hogy az illető pozíciót nem egy olyan játék eredményezte, ahol MIN és MAX is optimálisan játszik, tehát nincs értelme tovább értékelni. Az alfabéta nyesés hatékonysága nagyban függ attól, hogy egy X csúcs gyerek csomópontjai milyen sorrendben követik egymást. Ha például az A 3 ágon a gyerekek a 2-es értékű csomóponttal kezdődtek volna, akkor az A 32 és A 33 ágakat le lehetett volna nyesni. Ideális volna, ha a gyerek csúcsokat rendezni lehetne, s annak függvényében hogy mennyire ígéretesek, sorban kibontani őket. A gyerekeket nem bonthatjuk ki teljes mélységben - így értelmetlenné válna rendezés. A gyakran alkalmazott megoldás az, hogy iteratívan mélyülő kereséssel rendelünk a gyerekekhez értékeket, majd eszerint rendezzük őket.
Feladatok. 1. Tesztelje a http://www.ocf.berkeley.edu/~yosenl/extras/alphabeta/alphabeta.html címen levő appletet. 2. EC + 2 pont. Felhasználva az alfa-béta nyesést, implementálja a malom játékot. GUI nem szükséges. Javasolt könyvészet. 1. Russel & Norvig: Mesterséges intelligencia modern megközelítésben, Panem Kiadó 2000, Budapest