1 / 16

Artificial Intelligence

Artificial Intelligence. Games 1: Game Tree Search. Ian Gent ipg@cs.st-and.ac.uk. Artificial Intelligence. Game Tree Search. Part I : Game Trees Part II: MiniMax Part III: A bit of Alpha-Beta . Perfect Information Games. Unlike Bridge, we consider 2 player perfect information games

natara
Download Presentation

Artificial Intelligence

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Artificial Intelligence Games 1: Game Tree Search Ian Gent ipg@cs.st-and.ac.uk

  2. Artificial Intelligence Game Tree Search Part I : Game Trees Part II: MiniMax Part III: A bit of Alpha-Beta

  3. Perfect Information Games • Unlike Bridge, we consider 2 player perfect information games • Perfect Information: both players know everything there is to know about the game position • no hidden information (e.g. opponents hands in bridge) • no random events (e.g. draws in poker) • two players need not have same set of moves available • examples are Chess, Go, Checkers, O’s and X’s • Ginsberg made Bridge 2 player perfect information • by assuming specific random locations of cards • two players were North-South and East-West

  4. Game Trees • A game tree is like a search tree • nodes are search states, with full details about a position • e.g. chessboard + castling/en passant information • edges between nodes correspond to moves • leaf nodes correspond to determined positions • e.g. Win/Lose/Draw • number of points for or against player • at each node it is one or other player’s turn to move

  5. Game Trees  Search Trees • Strong similarities with 8s puzzle search trees • there may be loops/infinite branches • typically no equivalent of variable ordering heuristic • “variable” is always what move to make next • One major difference with 8s puzzle • The key difference is that you have an opponent! • Call the two players Max and Min • Max wants leaf node with max possible score • e.g. Win = + • Min wants leaf node with min score, • e.g. Lose = -

  6. The problem with Game trees • Game trees are huge • O’s and X’s not bad, just 9! = 362,880 • Checkers/Draughts about 1040 • Chess about 10 120 • Go utterly ludicrous, e.g. 361! 10750 • Recall from Search1 Lecture, • It is not good enough to find a route to a win • Have to find a winning strategy • Unlike 8s/SAT/TSP, can’t just look for one leaf node • typically need lots of different winning leaf nodes • Much more of the tree needs to be explored

  7. Coping with impossibility • It is usually impossible to solve games completely • Connect 4 has been solved • Checkers has not been • we’ll see a brave attempt later • This means we cannot search entire game tree • we have to cut off search at a certain depth • like depth bounded depth first, lose completeness • Instead we have to estimate cost of internal nodes • Do so using a static evaluation function

  8. Static evaluation • A static evaluation function should estimate the true value of a node • true value = value of node if we performed exhaustive search • need not just be /0/- even if those are only final scores • can indicate degree of position • e.g. nodes might evaluate to +1, 0, -10 • Children learn a simple evaluation function for chess • P = 1, N = B = 3, R = 5, Q = 9, K = 1000 • Static evaluation is difference in sum of scores • chess programs have much more complicated functions

  9. O’s and X’s • A simple evaluation function for O’s and X’s is: • Count lines still open for maX, • Subtract number of lines still open for min • evaluation at start of game is 0 • after X moves in center, score is +4 • Evaluation functions are only heuristics • e.g. might have score -2 but maX can win at next move • O - X • - O X • - - - • Use combination of evaluation function and search

  10. MiniMax • Assume that both players play perfectly • Therefore we cannot optimistically assume player will miss winning response to our moves • E.g. consider Min’s strategy • wants lowest possible score, ideally -  • but must account for Max aiming for +  • Min’s best strategy is: • choose the move that minimises the score that will result when Max chooses the maximising move • hence the name MiniMax • Max does the opposite

  11. Minimax procedure • Statically evaluate positions at depth d • From then on work upwards • Score of max nodes is the max of child nodes • Score of min nodes is the min of child nodes • Doing this from the bottom up eventually gives score of possible moves from root node • hence best move to make • Can still do this depth first, so space efficient

  12. What’s wrong with MiniMax • Minimax is horrendously inefficient • If we go to depth d, branching rate b, • we must explore bd nodes • but many nodes are wasted • We needlessly calculate the exact score at every node • but at many nodes we don’t need to know exact score • e.g. outlined nodes are irrelevant

  13. Alpha-Beta search • Alpha-Beta =  • Uses same insight as branch and bound • When we cannot do better than the best so far • we can cut off search in this part of the tree • More complicated because of opposite score functions • To implement this we will manipulate alpha and beta values, and store them on internal nodes in the search tree

  14. Alpha and Beta values • At a Mx node we will store an alpha value • the alpha value is lower bound on the exact minimax score • the true value might be   • if we know Min can choose moves with score <  • then Min will never choose to let Max go to a node where the score will be  or more • At a Min node, we will store a beta value • the beta value is upper bound on the exact minimax score • the true value might be   • Alpha-Beta search uses these values to cut search

  15. Alpha Beta in Action • Why can we cut off search? • Beta = 1 < alpha = 2 where the alpha value is at an ancestor node • At the ancestor node, Max had a choice to get a score of at least 2 (maybe more) • Max is not going to move right to let Min guarantee a score of 1 (maybe less)

  16. Summary and Next Lecture • Game trees are similar to search trees • but have opposing players • Minimax characterises the value of nodes in the tree • but is horribly inefficient • Use static evaluation when tree too big • Alpha-beta can cut off nodes that need not be searched • Next Time: More details on Alpha-Beta

More Related