CS 387: GAME AI BOARD GAMES. 5/24/2016 Instructor: Santiago Ontañón

Transcription

1 CS 387: GAME AI BOARD GAMES 5/24/2016 Instructor: Santiago Ontañón Class website:

2 Reminders Check BBVista site for the course regularly Also: Thursday, project 4 submission deadline

3 Outline Board Games Game Tree Search Portfolio Search Monte Carlo Search UCT

4 Outline Board Games Game Tree Search Portfolio Search Monte Carlo Search UCT

5 Game AI Architecture AI Strategy Decision Making World Interface (perception) Movement

6 So far, we have seen: Perception Movement (Steering behaviors): FPS, Car driving Pathfinding FPS, RTS, RPG, etc. Decision Making FPS, RPG, RTS, etc. Tactics and Strategy FPS, RTS PCG Many genres.

7 Board Games Main characteristic: turn-based The AI has a lot of time to decide the next move

8 Board Games Not just chess

9 Board Games Not just chess

10 Board Games Not just chess

11 Board Games Not just chess

12 Board Games Not just chess

13 Board Games Not just chess

14 Board Games From an AI point of view: Turn-based Discrete actions Complete information (mostly) Those features make these games amenable to game tree search!

15 Outline Board Games Game Tree Search Portfolio Search Monte Carlo Search UCT

16 Game Tree Current Situation Player 1 action U(s) U(s) U(s)

17 Game Tree Current Situation Player 1 action Pick the action that leads to the state with maximum expected utility U(s) U(s) U(s)

18 Game Tree Game trees capture the effects of successive action executions: Current Situation Player 1 action Player 2 action U(s) U(s) U(s) U(s) U(s) U(s)

19 Game Tree Game trees capture the effects of successive action executions: Current Situation Player 1 action Pick the action that leads to the state with maximum expected utility after taking into account what the other players might do Player 2 action U(s) U(s) U(s) U(s) U(s) U(s)

20 Game Tree Game trees capture the effects of successive action executions: In this example, we look ahead only one Current Situation player 1 action and one player 2 action. But we could grow the tree arbitrarily deep Player 1 action Player 2 action U(s) U(s) U(s) U(s) U(s) U(s)

21 Minimax Principle Positive utility is good for player 1, and negative for player 2 Player 1 chooses actions that maximize U, player 2 chooses actions that minimize U Current Situation Player 1 action Player 2 action U(s) = -1 U(s) = 0 U(s) = -1 U(s) = 0 U(s) = 0 U(s) = 0

22 Minimax Principle Positive utility is good for player 1, and negative for player 2 Player 1 chooses actions that maximize U, player 2 chooses actions that minimize U Current Situation Only looking at the utility values, which move should player 1 choose? Player 1 action Player 2 action U(s) = -1 U(s) = 0 U(s) = -1 U(s) = 0 U(s) = 0 U(s) = 0

23 Minimax Principle Positive utility is good for player 1, and negative for player 2 Player 1 chooses actions that maximize U, player 2 chooses actions that minimize U Current Situation Player 1 action Player 2 action (min) U(s) = -1 U(s) = 0 U(s) = -1 U(s) = 0 U(s) = 0 U(s) = 0

24 Minimax Principle Positive utility is good for player 1, and negative for player 2 Player 1 chooses actions that maximize U, player 2 chooses actions that minimize U Current Situation Player 1 action Player 2 action (min) U(s) = -1 U(s) = -1 U(s) = 0 U(s) = -1 U(s) = 0 U(s) = -1 U(s) = 0 U(s) = 0 U(s) = 0

25 Minimax Principle Positive utility is good for player 1, and negative for player 2 Player 1 chooses actions that maximize U, player 2 chooses actions that minimize U Current Situation Player 1 action (max) Player 2 action (min) U(s) = -1 U(s) = -1 U(s) = 0 U(s) = -1 U(s) = 0 U(s) = -1 U(s) = 0 U(s) = 0 U(s) = 0

26 Minimax Algorithm Minimax(state, player, MAX_DEPTH) IF MAX_DEPTH == 0 RETURN (U(state),-) BestAction = null BestScore = null FOR Action in actions(player, state) (Score,Action2) = Minimax(result(action, state), nextplayer(player), MAX_DEPTH-1) IF BestScore == null (player == 1 && Score>BestScore) (player == 2 && Score<BestScore) BestScore = Score BestAction = Action ENDFOR RETURN (BestScore, BestAction)

27 Minimax Algorithm Minimax(state, player, MAX_DEPTH) IF MAX_DEPTH == 0 RETURN (U(state),-) BestAction = null BestScore = null FOR Action in actions(player, state) (Score,Action2) = Minimax(result(action, state), nextplayer(player), MAX_DEPTH-1) IF BestScore == null (player == 1 && Score>BestScore) (player == 2 && Score<BestScore) BestScore = Score BestAction = Action ENDFOR RETURN (BestScore, BestAction)

28 Minimax Algorithm Needs: Utility function U Way to determine which actions can a player execute in a given state MAX_DEPTH controls how deep is the search tree going to be: Size of the tree is exponential in MAX_DEPTH Branching factor is the number of moves that can be executed per state The higher MAX_DEPTH, the better the AI will play There are ways to increase speed: alpha-beta pruning

29 Minimax Algorithm Needs: Utility function U Way to determine which actions can a player execute in a given state MAX_DEPTH controls how deep is the search tree going to be: Size of the tree is exponential in MAX_DEPTH Branching factor is the number of moves that can be executed per state - Given: - Branching factor: B - Maximum tree depth: D The higher MAX_DEPTH, the better the AI will play - What is the time complexity? - What is the memory complexity? There are ways to increase speed: alpha-beta pruning

30 Successes of Minimax Deep Blue defeated Kasparov in Chess (1997) Checkers was completely solved by Jonathan Shaeffert (2007): If no players make mistakes, the game is a draw (like tick-tack-toe) Go: Using a variant of minimax, based on Monte Carlo Tree Search In 2011 The program Zen19S reached 4 dan (professional humans are rated between 1 to 9 dan) In 2016 AlphaGO defeated Lee SeDol (one of the best players in the world)

31 Interesting Uses of Minimax bastet (Bastard Tetris):

32 Iterative Deepening As described before, minimax receives a MAX_DEPTH and it is impossible to predict how much time will it take to execute In a game, minimax will receive a certain amount of time (e.g. 20 seconds) that it can use to decide the next move Solution: iterative deepening

33 Iterative Deepening Idea: Open the tree at depth 1 If there is still time, open it at depth 2 If there is still time, open it at depth 3 Etc.

34 Iterative Deepening Idea: Open the tree at depth 1 If there is still time, open it at depth 2 If there is still time, open it at depth 3 Etc. If we end up searching up to depth, say 5, how much time is wasted?

35 Iterative Deepening Idea: Open the tree at depth 1 If there is still time, open it at depth 2 If there is still time, open it at depth 3 Etc. If we end up searching up to depth, say 5, how much time is wasted? Given the branching factor d, each subsequent iteration is d times larger in average than the previous. For typical values of d (larger than 10), the extra cost of iterative deepening is negligible

36 Alpha-Beta Pruning Not all the nodes in the search tree are relevant for deciding the next move

37 Alpha-Beta Pruning Not all the nodes in the search tree are relevant for deciding the next move

38 Alpha-Beta Pruning Not all the nodes in the search tree are relevant for deciding the next move What would happen is this value was higher? What would happen if this value was lower?

39 Alpha-Beta Pruning Not all the nodes in the search tree are relevant for deciding the next move What would happen is this value was higher? What would happen if this value was lower? NOTHING!

40 Alpha-Beta Pruning Not all the nodes in the search tree are relevant for deciding the next move These two nodes are irrelevant! They do not have to be explored! This is because the first node has a 1, which is lower than the lowest found in any other branch so far

41 Minimax Algorithm α = - infinity β = infinity alphabeta(state, MAX_DEPTH, α, β, player) if MAX_DEPTH = 0 or state is a terminal state return U(state) if player= 1 for action in actions(player, state) α := max(α, alphabeta(result(action,state), MAX_DEPTH-1, α, β, 2)) if β α break return α else for action in actions(player, state) β := min(β, alphabeta(result(action,state), MAX_DEPTH-1, α, β, 1)) if β α break return β

42 Minimax Algorithm α = - infinity β = infinity alphabeta(state, MAX_DEPTH, α, β, player) if MAX_DEPTH = 0 or state is a terminal state return U(state) if player= 1 for action in actions(player, state) α := max(α, alphabeta(result(action,state), MAX_DEPTH-1, α, β, 2)) if β α break return α else for action in actions(player, state) β := min(β, alphabeta(result(action,state), MAX_DEPTH-1, α, β, 1)) if β α break return β

43 Alpha-Beta Pruning

44 Alpha-Beta Pruning Does pruning occur independently of the order in which nodes are visited?

45 Alpha-Beta Pruning Notice that pruning depends on the order in which the children are explored If we expand the 1 first, then 2 and 6 do not have to be explored

46 Alpha-Beta Pruning How to decide a good order for children expansion?

47 Alpha-Beta Pruning How to decide a good order for children expansion? Idea: Iterative deepening Explore first the children that was selected as the best move in the previous iteration of iterative deepening With this modification, iterative deepening is actually faster in practice than just opening the tree at a given depth! Other domain specific heuristics exist for well known games such as Chess.

48 Outline Board Games Game Tree Search Portfolio Search Monte Carlo Search UCT

49 What is an Action? Consider a complex board game like Settlers or Scrabble, what is the set of actions a player can perform in her turn?

50 What is an Action? Consider a complex board game like Settlers or Scrabble, what is the set of actions a player can perform in her turn? Way too many actions to consider in minimax!!

51 Portfolio Search Consider the game of Monopoly The set of possible actions is too large (just imagine all possible deals we can offer any player!) However, we can do the following: We can devise 3 or 4 strategies to play the game: A. Never do any deal nor build any house, just roll dies and buy streets. B. Never do any deal, but build one house in the most expensive street we can. C. Never do any deal, but build as many houses as we can, in the cheapest street we can. D. Do not build houses, but offer a deal to get the cheapest full set we could get by trading a single card with one player (offering her some predefined amount of money, a factor of the price of what we are getting)

52 Portfolio Search Consider the game of Monopoly Certainly, these different strategies would do better in The set of possible actions different is too situations. large (just imagine all The key idea portfolio search is to consider these possible deals we can offer any player!) strategies as the actions. However, we can do the following: We can devise 3 or 4 strategies to play the game: A. Never do any deal nor build any house, just roll dies and buy streets. B. Never do any deal, but build one house in the most expensive street we can. C. Never do any deal, but build as many houses as we can, in the cheapest street we can. D. Do not build houses, but offer a deal to get the cheapest full set we could get by trading a single card with one player (offering her some predefined amount of money, a factor of the price of what we are getting)

53 Minimax Portfolio Search At each level of the tree, use each of the predefined strategies to generate the next action, and only consider those actions. Action proposed By strategy B Action proposed By strategy A Action proposed By strategy C

54 Minimax Portfolio Search At each level of the tree, use each of the predefined strategies to generate the next action, and only consider those actions. Action proposed By strategy B Action proposed By strategy A Action proposed By strategy C This simple idea can make minimax search feasible in games with a set of actions that is too large to consider the whole tree.

55 Simple Portfolio Search Forget about game trees, just do this: given a set of strategies S For each s1 in S: For each s2 in S: Simulate a game for D game cycles where player 1 uses s1, and player 2 uses s2 Compute the average reward obtained by each strategy s1, and select the one that achieved the highest average.

56 Portfolio Search Imagine this situation: Branching factor B Search up to a depth D We have a set of S strategies (S << B) What is the time / memory complexity of: Minimax? Minimax portfolio search? Simple portfolio search?

57 Portfolio Search Imagine this situation: Branching factor B Search up to a depth D We have a set of S strategies (S << B) What is the time / memory complexity of: Minimax? B^D, D Minimax portfolio search? S^D, D Simple portfolio search? D * S^2, 2

58 Portfolio Search Imagine this situation: In terms of play strength: Branching Minimax factor > B minimax portfolio search > simple portfolio search Search up to a depth In D terms of computational needs: We have Minimax a set of > S minimax strategies portfolio search > simple portfolio search What is the time / memory complexity of: Minimax? B^D, D Minimax portfolio search? S^D, D Simple portfolio search? D * S^2, 2 Thus, if you can use minimax, that s the simplest thing to do. But if you cannot (due to CPU constraints), portfolio search is a good option to consider.