Game playing
1 / 22

Game Playing - PowerPoint PPT Presentation

  • Updated On :

Game Playing. Chapter 5. Game playing. Search applied to a problem against an adversary some actions are not under the control of the problem-solver there is an opponent (hostile agent) Since it is a search problem, we must specify states & operations/actions

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Game Playing' - Rita

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Game playing l.jpg

Game Playing

Chapter 5

Game playing2 l.jpg
Game playing

  • Search applied to a problem against an adversary

    • some actions are not under the control of the problem-solver

    • there is an opponent (hostile agent)

  • Since it is a search problem, we must specify states & operations/actions

    • initial state = current board; operators = legal moves; goal state = game over; utility function = value for the outcome of the game

    • usually, (board) games have well-defined rules & the entire state is accessible

Basic idea l.jpg
Basic idea

  • Consider all possible moves for yourself

  • Consider all possible moves for your opponent

  • Continue this process until a point is reached where we know the outcome of the game

  • From this point, propagate the best move back

    • choose best move for yourself at every turn

    • assume your opponent will make the optimal move on their turn

Examples l.jpg

  • Tic-tac-toe

  • Connect Four

  • Checkers

Problem l.jpg

  • For interesting games, it is simply not computationally possible to look at all possible moves

    • in chess, there are on average 35 choices per turn

    • on average, there are about 50 moves per player

    • thus, the number of possibilities to consider is 35100

Solution l.jpg

  • Given that we can only look ahead k number of moves and that we can’t see all the way to the end of the game, we need a heuristic function that substitutes for looking to the end of the game

    • this is usually called a static board evaluator (SBE)

    • aperfect static board evaluator would tell us for what moves we could win, lose or draw

    • possible for tic-tac-toe, but not for chess

Creating a sbe approximation l.jpg
Creating a SBE approximation

  • Typically, made up of rules of thumb

    • for example, in most chess books each piece is given a value

      • pawn = 1; rook = 5; queen = 9; etc.

    • further, there are other important characteristics of a position

      • e.g., center control

    • we put all of these factors into one function, weighting each aspect differently potentially, to determine the value of a position

      • board_value =  * material_balance +  * center_control + … [the coefficients might change as the game goes on]

Compromise l.jpg

  • If we could search to the end of the game, then choosing a move would be relatively easy

    • just use minimax

  • Or, if we had a perfect scoring function (SBE), we wouldn’t have to do any search (just choose best move from current state -- one step look ahead)

  • Since neither is feasible for interesting games, we combine the two ideas

Basic idea9 l.jpg
Basic idea

  • Build the game tree as deep as possible given the time constraints

  • apply an approximate SBE to the leaves

  • propagate scores back up to the root & use this information to choose a move

  • example

Score percolation minimax l.jpg
Score percolation: MINIMAX

  • When it is my turn, I will choose the move that maximizes the (approximate) SBE score

  • When it is my opponent’s turn, they will choose the move that minimizes the SBE

    • because we are dealing with competitive games, what is good for me is bad for my opponent & what is bad for me is good for my opponent

    • assume the opponent plays optimally [worst-case assumption]

Minimax algorithm l.jpg
MINIMAX algorithm

  • Start at the the leaves of the trees and apply the SBE

  • If it is my turn, choose the maximum SBE score for each sub-tree

  • If it is my opponent’s turn, choose the minimum score for each sub-tree

  • The scores on the leaves are how good the board appears from that point

  • Example

Alpha beta pruning l.jpg
Alpha-beta pruning

  • While minimax is an effective algorithm, it can be inefficient

    • one reason for this is that it does unnecessary work

    • it evaluates sub-trees where the value of the sub-tree is irrelevant

    • alpha-beta pruning gets the same answer as minimax but it eliminates some useless work

    • example

      • simply think: would the result matter if this node’s score were +infinity or -infinity?

Cases of alpha beta pruning l.jpg
Cases of alpha-beta pruning

  • Min level (alpha-cutoff)

    • can stop expanding a sub-tree when a value less than the best-so-far is found

      • this is because you’ll want to take the better scoring route [example]

  • Max level (beta-cutoff)

    • can stop expanding a sub-tree when a value greater than best-so-far is found

      • this is because the opponent will force you to take the lower-scoring route [example]

Alpha beta algorithm l.jpg
Alpha-beta algorithm

  • Maximizer’s moves have an alpha value

    • it is the current lower bound on the node’s score (i.e., max can do at least this well)

    • if alpha >= beta of parent, then stop since opponent won’t allow us to take this route

  • Minimizer’s moves have a beta value

    • it is the current upper bound on the node’s score (i.e., it will do no worse than this)

    • if beta <= alpha of parent, then stop since we (max) will won’t choose this

Slide17 l.jpg

  • We project ahead k moves, but we only do one (the best) move then

  • After our opponent moves, we project ahead k moves so we are possibly repeating some work

  • However, since most of the work is at the leaves anyway, the amount of work we redo isn’t significant (think of iterative deepening)

Alpha beta performance l.jpg
Alpha-beta performance

  • Best-case: can search to twice the depth during a fixed amount of time [O(bd/2) v. O(bd)]

  • Worst-case: no savings

    • alpha-beta pruning & minimax always return the same answer

    • the difference is the amount of work they do

    • effectiveness depends on the order in which successors are examined

      • want to examine the best first

  • Graph of savings

Refinements l.jpg

  • Waiting for quiescence

    • avoids the horizon effect

      • disaster is lurking just beyond our search depth

      • on the nth move (the maximum depth I can see) I take your rook, but on the (n+1)th move (a depth to which I don’t look) you checkmate me

    • solution

      • when predicted values are changing frequently, search deeper in that part of the tree (quiescence search)

Secondary search l.jpg
Secondary search

  • Find the best move by looking to depth d

  • Look k steps beyond this best move to see if it still looks good

  • No? Look further at second best move, etc.

    • in general, do a deeper search at parts of the tree that look “interesting”

  • Picture

Book moves l.jpg
Book moves

  • Build a database of opening moves, end games, tough examples, etc.

  • If the current state is in the database, use the knowledge in the database to determine the quality of a state

  • If it’s not in the database, just do alpha-beta pruning

Ai games l.jpg
AI & games

  • Initially felt to be great AI testbed

  • It turned out, however, that brute-force search is better than a lot of knowledge engineering

    • scaling up by dumbing down

      • perhaps then intelligence doesn’t have to be human-like

    • more high-speed hardware issues than AI issues

    • however, still good test-beds for learning