Anda di halaman 1dari 34

Game Playing

Chapter 8
Outline

• Overview
• Minimax search
• Adding alpha-beta cutoffs
• Iterative deepening
• Specific games

2
Overview

Old beliefs
Games provided a structured task in which it was very easy to
measure success or failure.

Games did not obviously require large amounts of knowledge,

thought to be solvable by straightforward search.

3
Overview
Chess
The average branching factor is around 35.

4
Overview

• Improve the generate procedure so that only good

moves are generated.

• Improve the test procedure so that the best moves

will be recognized and explored first.

5
Overview

• Improve the generate procedure so that only good

moves are generated.

• Improve the test procedure so that the best moves

will be recognized and explored first.
less moves to be evaluated

6
Overview

found.

• It has to evaluate individual board positions by

estimating how likely they are to lead to a win.
Static evaluation function

7
Overview

8
Minimax Search

• At the player choice, maximize the static evaluation

of the next position.
• At the opponent choice, minimize the static
evaluation of the next position.

9
Minimax Search

A -2 Maximizing ply
Player
B -6 C -2 D -4
Minimizing ply
E F G H I J K Opponent
9 -6 0 0 -2 -4 -3

Two-ply search

10
Minimax Search

Player(Position, Depth):
for each S ∈ SUCCESSORS(Position) do
RESULT = Opponent(S, Depth + 1)
NEW-VALUE = VALUE(RESULT)

if NEW-VALUE > MAX-SCORE, then

MAX-SCORE = NEW-VALUE
BEST-PATH = PATH(RESULT) + S
return
VALUE = MAX-SCORE
PATH = BEST-PATH
11
Minimax Search

Opponent(Position, Depth):
for each S ∈ SUCCESSORS(Position) do
RESULT = Player(S, Depth + 1)
NEW-VALUE = VALUE(RESULT)

if NEW-VALUE < MIN-SCORE, then

MIN-SCORE = NEW-VALUE
BEST-PATH = PATH(RESULT) + S
return
VALUE = MIN-SCORE
PATH = BEST-PATH
12
Minimax Search

Any-Player(Position, Depth):
for each S ∈ SUCCESSORS(Position) do
RESULT = Any-Player(S, Depth + 1)
NEW-VALUE = − VALUE(RESULT)

if NEW-VALUE > BEST-SCORE, then

BEST-SCORE = NEW-VALUE
BEST-PATH = PATH(RESULT) + S
return
VALUE = BEST-SCORE
PATH = BEST-PATH
13
Minimax Search

MINIMAX(Position, Depth, Player):

• MOVE-GEN(Position, Player).

• STATIC(Position, Player).

• DEEP-ENOUGH(Position, Depth)

14
Minimax Search
1. if DEEP-ENOUGH(Position, Depth), then return:

PATH = nil

2. SUCCESSORS = MOVE-GEN(Position, Player)

3. if SUCCESSORS is empty, then do as in Step 1

15
Minimax Search
4. if SUCCESSORS is not empty:
RESULT-SUCC = MINIMAX(SUCC, Depth+1, Opp(Player))
NEW-VALUE = - VALUE(RESULT-SUCC)
if NEW-VALUE > BEST-SCORE, then:
BEST-SCORE = NEW-VALUE
BEST-PATH = PATH(RESULT-SUCC) + SUCC

5. Return:
VALUE = BEST-SCORE
PATH = BEST-PATH

16

branch-and-bound

• At the player choice, maximize the static evaluation

of the next position.
> α threshold

• At the opponent choice, minimize the static

evaluation of the next position.
< β threshold

17

A
Maximizing ply
>3
Player
B 3 C
Minimizing ply
D E F G Opponent
3 5 -5

Alpha cutoffs

18
A
Maximizing ply
>3
Player
B C
<5 Minimizing ply
Opponent
D E F G H
3 5 Maximizing ply
Player
I J M N
5 7 Minimizing ply
Alpha and Beta Opponent
cutoffs K L
0

19

Opponent
β
Player
α≥β α

Opponent
α≥β

Player
Alpha and Beta
cutoffs

20
Player(Position, Depth, α, β):
for each S ∈ SUCCESSORS(Position) do
RESULT = Opponent(S, Depth + 1, α, β)

NEW-VALUE = VALUE(RESULT)

if NEW-VALUE > α, then

α = NEW-VALUE
BEST-PATH = PATH(RESULT) + S

if α ≥ β then return
VALUE = α
PATH = BEST-PATH
return
VALUE = α
PATH = BEST-PATH
21
Opponent(Position, Depth, α, β):
for each S ∈ SUCCESSORS(Position) do
RESULT = Player(S, Depth + 1, α, β)

NEW-VALUE = VALUE(RESULT)

if NEW-VALUE < β, then

β = NEW-VALUE
BEST-PATH = PATH(RESULT) + S

if β ≤ α then return
VALUE = β
PATH = BEST-PATH
return
VALUE = β
PATH = BEST-PATH
22
Any-Player(Position, Depth, α, β):
for each S ∈ SUCCESSORS(Position) do
RESULT = Any-Player(S, Depth + 1, −β, −α)

NEW-VALUE = − VALUE(RESULT)

if NEW-VALUE > α, then

α = NEW-VALUE
BEST-PATH = PATH(RESULT) + S

if α ≥ β then return
VALUE = α
PATH = BEST-PATH
return
VALUE = α
PATH = BEST-PATH
23

• PassTd: current best value

24
1. if DEEP-ENOUGH(Position, Depth), then return:

PATH = nil

2. SUCCESSORS = MOVE-GEN(Position, Player)

3. if SUCCESSORS is empty, then do as in Step 1

25
4. if SUCCESSORS is not empty:
RESULT-SUCC = MINIMAX-A-B(SUCC, Depth + 1,
Opp(Player), − PassTd, − UseTd)
NEW-VALUE = - VALUE(RESULT-SUCC)
if NEW-VALUE > PassTd, then:
PassTd = NEW-VALUE
BEST-PATH = PATH(RESULT-SUCC) + SUCC

if PassTd ≥ UseTd, then return:

VALUE = PassTd
PATH = BEST-PATH
5. Return:
VALUE = PassTd
PATH = BEST-PATH
26

• Futility cutoffs
• Waiting for quiescence
• Secondary search
• Using book moves
• Not assuming opponent’s optimal move

27
Iterative Deepening

Iteration 1

Iteration 2

Iteration 3
28
Iterative Deepening

• Search can be aborted at any time and the best

move of the previous iteration is chosen.
• Previous iterations can provide invaluable move-
ordering constraints.

29
Iterative Deepening

• Can be adapted for single-agent search.

• Can be used to combine the best aspects of depth-
first search and breadth-first search.

30
Iterative Deepening
Depth-First Iterative Deepening (DFID)

1. Set SEARCH-DEPTH = 1

2. Conduct depth-first search to a depth of SEARCH-

DEPTH. If a solution path is found, then return it.

3. Increment SEARCH-DEPTH by 1 and go to step 2.

31
Iterative Deepening
Iterative-Deepening-A* (IDA*)

state

2. Conduct depth-first search, pruning any branch when

its total cost exceeds THRESHOLD. If a solution path
is found, then return it.

3. Increment THRESHOLD by the minimum amount it

was exceeded and go to step 2.

32
Iterative Deepening

• Is the process wasteful?

33
Homework

Presentations
– Specific games: Chess – State of the Art

34