games and adversarial search ii alpha-beta pruning (aima 5.3)cis521/lectures/games ii-6up.pdf ·...
TRANSCRIPT
1
Games and Adversarial Search II
Alpha-Beta Pruning (AIMA 5.3)
Some slides adapted from Richard Lathrop, USC/ISI, CS 271
CIS 421/521 - Intro to AI 3
Review: The Minimax Rule
Idea: Make the best move for MAX assuming that MIN
always replies with the best move for MIN
1. Start with the current position as a MAX node.
2. Expand the game tree a fixed number of ply.
3. Apply the evaluation function to all leaf positions.
4. Calculate back-up values bottom-up:
• For a MAX node, return the maximum of the values of its
children (i.e. the best for MAX)
• For a MIN node, return the minimum of the values of its
children (i.e. the best for MIN
5. Pick the move assigned to MAX at the root
6. Wait for MIN to respond and REPEAT FROM 1
CIS 421/521 - Intro to AI 4
2-ply Example: Backing up values
2 7 1 8
MAX
MIN
2 7 1 8
2 1
2 7 1 8
2 1
2
This is the move
selected by minimax
Evaluation function value
2 7 1 8
2 1
2
New point:
Actually calculated by DFS!
CIS 421/521 - Intro to AI 5
Minimax Algorithm
function MINIMAX-DECISION(state) returns an action
inputs: state, current state in game
vMAX-VALUE(state)
return an action in SUCCESSORS(state) with value v
function MIN-VALUE(state) returns a utility value
if TERMINAL-TEST(state) then return UTILITY(state)
v ∞
for a,s in SUCCESSORS(state) do
v MIN(v, MAX-VALUE(s) )
return v
function MAX-VALUE(state) returns a utility value
if TERMINAL-TEST(state) then return UTILITY(state)
v -∞
for a,s in SUCCESSORS(state) do
v MAX(v, MIN-VALUE(s) )
return v
CIS 421/521 - Intro to AI 6
Alpha-Beta Pruning
• A way to improve the performance of the Minimax
Procedure
• Basic idea: “If you have an idea which is surely
bad, don’t take the time to see how truly awful it
is” ~ Pat Winston
2 7 1
=2
>=2
<=1
?
• Assuming left-to-right tree
traversal:
• We don’t need to compute the
value at this node!
• No matter what it is it can’t
effect the value of the root
node.
2
Alpha-Beta Pruning II
• During Minimax, keep track of two additional values:
• α: current lower bound on MAX’s outcome
• β: current upper bound on MIN’s outcome
• MAX will never choose a move that could lead to a worse score
(for MAX) than α
• MIN will never choose a move that could lead to a better score
(for MAX) than β
• Therefore, stop evaluating a branch whenever:
• When evaluating a MAX node: a value v ≥ β is backed-up
—MIN will never select that MAX node
• When evaluating a MIN node: a value v ≤ α is found
—MAX will never select that MIN node
CIS 421/521 - Intro to AI 7
Alpha-Beta Pruning IIIa
• Based on observation that for all viable paths utility
value f(n) will be α <= f(n) <= β
• Initially, α = -infinity, β=infinity
• As the search tree is traversed, the possible utility
value window shrinks as α increases, β decreases
CIS 421/521 - Intro to AI 8
Alpha-Beta Pruning IIIb
• Whenever the current ranges of alpha and beta no
longer overlap ( ≥ ), it is clear that the current node
is a dead end, so it can be pruned
CIS 421/521 - Intro to AI 9
Alpha-beta Algorithm: In detail
• Depth first search (usually bounded, with static evaluation)
• only considers nodes along a single path from root at any time
= current lower bound on MAX’s outcome
(initially, = −infinity)
= current upper bound on MIN’s outcome
(initially, = +infinity)
• Pass current values of and down to child nodes during
search.
• Update values of and during search:
• MAX updates at MAX nodes
• MIN updates at MIN nodes
• Prune remaining branches at a node whenever ≥
CIS 421/521 - Intro to AI 10
β
α
When to Prune
Prune whenever ≥ .
• Prune below a Max node when its value becomes ≥
the value of its ancestors.
— Max nodes update based on children’s returned values.
— Idea: Player MIN at node above won’t pick that value anyway, since
MIN can force a worse value.
• Prune below a Min node when its value becomes ≤
the value of its ancestors.
— Min nodes update based on children’s returned values.
— Idea: Player MAX at node above won’t pick that value
anyway; she can do better.
CIS 421/521 - Intro to AI 11
β
α
Pseudocode for Alpha-Beta Algorithm
function ALPHA-BETA-SEARCH(state) returns an action
inputs: state, current state in game
vMAX-VALUE(state, - ∞ , +∞)
return an action in ACTIONS(state) with value v
CIS 421/521 - Intro to AI 12
3
Pseudocode for Alpha-Beta Algorithm
function ALPHA-BETA-SEARCH(state) returns an action
inputs: state, current state in game
vMAX-VALUE(state, - ∞ , +∞)
return an action in ACTIONS(state) with value v
function MAX-VALUE(state, , ) returns a utility value
if TERMINAL-TEST(state) then return UTILITY(state)
v - ∞
for a in ACTIONS(state) do
v MAX(v,MIN-VALUE(Result(s,a), , ))
if v ≥ then return v
MAX( ,v)
return v
CIS 421/521 - Intro to AI 13 CIS 421/521 - Intro to AI 14
Alpha-Beta Algorithm II
function MIN-VALUE(state, , ) returns a utility value
if TERMINAL-TEST(state) then return UTILITY(state)
v + ∞
for a,s in SUCCESSORS(state) do
v MIN(v,MAX-VALUE(s, , ))
if v ≤ then return v
MIN( ,v)
return v
An Alpha-Beta Example
, , initial values
Do DF-search until first leaf
=−
=+
=−
=+
, , passed to kids
CIS 421/521 - Intro to AI 15
β
α
Alpha-Beta Example (continued)
MIN updates , based on kids
=−
=3
CIS 421/521 - Intro to AI 16
=−
=+
β
α
Alpha-Beta Example (continued)
=−
=3
MIN updates , based on kids.No change.
CIS 421/521 - Intro to AI 17
=−
=+
β
α
Alpha-Beta Example (continued)
MAX updates , based on kids.
=3
=+
3 is returnedas node value.
CIS 421/521 - Intro to AI 18
β
α
4
Alpha-Beta Example (continued)
=3
=+
=3
=+
, , passed to kids
CIS 421/521 - Intro to AI 19
β
α
Alpha-Beta Example (continued)
=3
=+
=3
=2
MIN updates ,based on kids.
CIS 421/521 - Intro to AI 20
β
α
Alpha-Beta Example (continued)
=3
=2
≥ ,so prune.
=3
=+
CIS 421/521 - Intro to AI 21
β
α
Alpha-Beta Example (continued)
2 is returnedas node value.
MAX updates , based on kids.No change. =3
=+
CIS 421/521 - Intro to AI 22
β
α
Alpha-Beta Example (continued)
,=3
=+
=3
=+
, , passed to kids
CIS 421/521 - Intro to AI 23
β
α
Alpha-Beta Example (continued)
,
=3
=14
=3
=+MIN updates ,based on kids.
CIS 421/521 - Intro to AI 24
β
α
5
Alpha-Beta Example (continued)
,
=3
=5
=3
=+MIN updates ,based on kids.
CIS 421/521 - Intro to AI 25
β
α
Alpha-Beta Example (continued)
=3
=+2 is returnedas node value.
2
CIS 421/521 - Intro to AI 26
β
α
Alpha-Beta Example (continued)
Max now makes it’s
best move, as computed
by Alpha-Beta
2
CIS 421/521 - Intro to AI 27
β
α
CIS 421/521 - Intro to AI 28
Effectiveness of Alpha-Beta Pruning
• Guaranteed to compute same root value as
Minimax
• Worst case: no pruning, same as Minimax (O(bd))
• Best case: when each player’s best move is the first
option examined, examines only O(bd/2) nodes,
allowing to search twice as deep!
CIS 421/521 - Intro to AI 29
When best move is the first examined,
examines only O(bd/2) nodes….
• So: run Iterative Deepening search, sort by value
returned on last iteration.
• So: expand captures first, then threats, then forward
moves, etc.
• O(b(d/2)) is the same as having a branching factor of sqrt(b),
• Since (sqrt(b))d = b(d/2)
• e.g., in chess go from b ~ 35 to b ~ 6
• For Deep Blue, alpha-beta pruning reduced the
average branching factor from 35-40 to 6, as
expected, doubling search depth
CIS 421/521 - Intro to AI 31
Chinook and Deep Blue
• Chinook
• the World Man-Made Checkers Champion, developed at the University of
Alberta.
• Competed in human tournaments, earning the right to play for the human
world championship, and defeated the best players in the world.
• Deep Blue
• Defeated world champion Gary Kasparov 3.5-2.5 in 1997 after losing 4-2
in 1996.
• Uses a parallel array of 256 special chess-specific processors
• Evaluates 200 billion moves every 3 minutes; 12-ply search depth
• Expert knowledge from an international grandmaster.
• 8000 factor evaluation function tuned from hundreds of thousands of
grandmaster games
• Tends to play for tiny positional advantages.
6
FOR STUDY….
Example
3 4 1 2 7 8 5 6
-which nodes can be pruned?
CIS 421/521 - Intro to AI 33
Answer to Example
-which nodes can be pruned?
Answer: NONE! Because the most favorable nodes for both are
explored last (i.e., in the diagram, are on the right-hand side).
3 4 1 2 7 8 5 6
Max
Min
Max
34CIS 421/521 - Intro to AI
Second Example
(the exact mirror image of the first
example)
6 5 8 7 2 1 3 4
-which nodes can be pruned?
35CIS 421/521 - Intro to AI
Answer to Second Example
(the exact mirror image of the first
example) -which nodes can be pruned?
6 5 8 7 2 1 3 4
Min
Max
Max
Answer: LOTS! Because the most favorable nodes for both are
explored first (i.e., in the diagram, are on the left-hand side).
36CIS 421/521 - Intro to AI CIS 421/521 - Intro to AI 37
Constraint Satisfaction Problems
AIMA: Chapter 6
7
Big idea
• Represent the constraints that solutions must
satisfy in a uniform declarative language
• Find solutions by GENERAL PURPOSE search
algorithms with no changes from problem to
problem
• No hand built transition functions
• No hand built heuristics
• Just specify the problem in a formal declarative
language, and a general purpose algorithm does
everything else!
CIS 421/521 - Intro to AI 38 CIS 421/521 - Intro to AI 39
Constraint Satisfaction Problems
A CSP consists of:
• Finite set of variables X1, X2, …, Xn
• Nonempty domain of possible values for each variable
D1, D2, … Dn where Di = {v1, …, vk}
• Finite set of constraints C1, C2, …, Cm
—Each constraint Ci limits the values that variables can take,
e.g., X1 ≠ X2 A state is defined as an assignment of values to
some or all variables.
• A consistent assignment does not violate the
constraints.
• Example problem: Sudoku
CIS 421/521 - Intro to AI 40
Constraint satisfaction problems
• An assignment is complete when every variable is assigned a value.
• A solution to a CSP is a complete, consistent assignment.
• Solutions to CSPs can be found by a completely general purpose algorithm, given only the formal specification of the CSP.
• Beyond our scope: CSPs that require a solution that maximizes an objective function.
CIS 421/521 - Intro to AI 41
Applications
• Map coloring
• Line Drawing Interpretation
• Scheduling problems• Job shop scheduling
• Scheduling the Hubble Space Telescope
• Floor planning for VLSI
CIS 421/521 - Intro to AI 42
Example: Map-coloring
• Variables: WA, NT, Q, NSW, V, SA, T
• Domains: Di = {red,green,blue}
• Constraints: adjacent regions must have different colors
• e.g., WA ≠ NT—So (WA,NT) must be in {(red,green),(red,blue),(green,red), …}
CIS 421/521 - Intro to AI 43
Example: Map-coloring
Solutions: complete and consistent assignments
• e.g., WA = red, NT = green,Q = red, NSW = green,
V = red, SA = blue, T = green
8
CIS 421/521 - Intro to AI 44
Example: Cryptarithmetic
• Variables: F T U W R O, X1 X2 X3
• Domain: {0,1,2,3,4,5,6,7,8,9}
• Constraints: • Alldiff (F,T,U,W,R,O)
• O + O = R + 10 · X1
• X1 + W + W = U + 10 · X2
• X2 + T + T = O + 10 · X3
• X3 = F, T ≠ 0, F ≠ 0
X1X2X3
Benefits of CSP
• Clean specification of many problems, generic goal,
successor function & heuristics
• Just represent problem as a CSP & solve with general package
• CSP “knows” which variables violate a constraint
• And hence where to focus the search
• CSPs: Automatically prune off all branches that
violate constraints
• (State space search could do this only by hand-building
constraints into the successor function)
CIS 421/521 - Intro to AI 45
CIS 421/521 - Intro to AI 46
CSP Representations
• Constraint graph: • nodes are variables
• arcs are (binary) constraints
• Standard representation pattern: • variables with values
• Constraint graph simplifies search.
• e.g. Tasmania is an independent subproblem.
• This problem: A binary CSP: • each constraint relates two variables
CIS 421/521 - Intro to AI 47
Varieties of CSPs
• Discrete variables• finite domains:
—n variables, domain size d O(dn) complete assignments
—e.g., Boolean CSPs, includes Boolean satisfiability (NP-complete)
• infinite domains:
—integers, strings, etc.
—e.g., job scheduling, variables are start/end days for each job
—need a constraint language, e.g., StartJob1 + 5 ≤ StartJob3
• Continuous variables• e.g., start/end times for Hubble Space Telescope observations
• linear constraints solvable in polynomial time by linear programming
CIS 421/521 - Intro to AI 48
Varieties of constraints
• Unary constraints involve a single variable, • e.g., SA ≠ green
• Binary constraints involve pairs of variables,• e.g., SA ≠ WA
• Higher-order constraints involve 3 or more variables• e.g., crypt-arithmetic column constraints
• Preference (soft constraints) e.g. red is better than green can be represented by a cost for each variable assignment • Constrained optimization problems.
CIS 421/521 - Intro to AI 49
Idea 1: CSP as a search problem
• A CSP can easily be expressed as a search
problem
• Initial State: the empty assignment {}.
• Successor function: Assign value to any unassigned
variable provided that there is not a constraint conflict.
• Goal test: the current assignment is complete.
• Path cost: a constant cost for every step.
• Solution is always found at depth n, for n variables
• Hence Depth First Search can be used
9
CIS 421/521 - Intro to AI 50
Backtracking search
• Note that variable assignments are commutative• Eg [ step 1: WA = red; step 2: NT = green ]
equivalent to [ step 1: NT = green; step 2: WA = red ]
• Therefore, a tree search, not a graph search
• Only need to consider assignments to a single variable at each node
• b = d and there are dn leaves (n variables, domain size d )
• Depth-first search for CSPs with single-variable assignments is called backtracking search
• Backtracking search is the basic uninformed algorithm for CSPs
• Can solve n-queens for n ≈ 25
CIS 421/521 - Intro to AI 51
Backtracking example
CIS 421/521 - Intro to AI 52
Backtracking example
And so on….
CIS 421/521 - Intro to AI 53
Idea 2: Improving backtracking efficiency
• General-purpose methods & general-purpose
heuristics can give huge gains in speed, on average
• Heuristics:
• Q: Which variable should be assigned next?
1. Most constrained variable
2. (if ties:) Most constraining variable
• Q: In what order should that variable’s values be tried?
3. Least constraining value
• Q: Can we detect inevitable failure early?
4. Forward checking
CIS 421/521 - Intro to AI 54
Heuristic 1: Most constrained variable
• Choose a variable with the fewest legal values
• a.k.a. minimum remaining values (MRV) heuristic
3
3
3
3
33
3
3
3
2
3
23
2
33
13
1
33
2
CIS 421/521 - Intro to AI 55
Heuristic 2: Most constraining variable
• Tie-breaker among most constrained variables
• Choose the variable with the most constraints
on remaining variables
These two heuristics together lead
to immediate solution of our
example problem
10
CIS 421/521 - Intro to AI 56
Heuristic 3: Least constraining value
• Given a variable, choose the least constraining
value:
• the one that rules out the fewest values in the remaining
variables
Note: demonstrated here independent of the
other heuristics
CIS 421/521 - Intro to AI 57
Heuristic 4: Forward checking
• Idea:
• Keep track of remaining legal values for unassigned
variables
• Terminate search when any unassigned variable has no
remaining legal values
(A first step towards Arc Consistency & AC-3)New data
structure
CIS 421/521 - Intro to AI 58
Forward checking
• Idea:
• Keep track of remaining legal values for unassigned
variables
• Terminate search when any unassigned variable has no
remaining legal values
CIS 421/521 - Intro to AI 59
Forward checking
• Idea:
• Keep track of remaining legal values for unassigned
variables
• Terminate search when any unassigned variable has no
remaining legal values
CIS 421/521 - Intro to AI 60
Forward checking
• Idea:
• Keep track of remaining legal values for unassigned
variables
• Terminate search when any unassigned variable has no
remaining legal values
Terminate! No possible value for SA
CIS 421/521 - Intro to AI 61
Example: 4-Queens Problem
1
3
2
4
X3X2 X4X1
X1{1,2,3,4}
X3{1,2,3,4}
X4{1,2,3,4}
X2{1,2,3,4}
(From Bonnie Dorr, U of Md, CMSC 421)
11
CIS 421/521 - Intro to AI 62
Example: 4-Queens Problem
1
3
2
4
32 41
X1{1,2,3,4}
X3
{1,2,3,4}
X4
{1,2,3,4}
X2{1,2,3,4}
Assign value to
unassigned variableCIS 421/521 - Intro to AI 63
Example: 4-Queens Problem
1
3
2
4
32 41
X1{1,2,3,4}
X3
{ ,2, ,4}
X4
{ ,2,3, }
X2{ , ,3,4}
Forward check!
CIS 421/521 - Intro to AI 64
Example: 4-Queens Problem
1
3
2
4
32 41
X1{1,2,3,4}
X3{ ,2, ,4}
X4{ ,2,3, }
X2{ , ,3,4}
Assign value to
unassigned variableCIS 421/521 - Intro to AI 65
Example: 4-Queens Problem
1
3
2
4
32 41
X1{1,2,3,4}
X3{ , , , }
X4{ ,2, , }
X2{ , ,3,4}
Backtrack!!!
Forward check!
CIS 421/521 - Intro to AI 66
Example: 4-Queens Problem
1
3
2
4
32 41
X1{ ,2,3,4}
X3{1,2,3,4}
X4{1,2,3,4}
X2{1,2,3,4}
Picking up a little later after two
steps of backtracking….
Assign value to
unassigned variableCIS 421/521 - Intro to AI 67
Example: 4-Queens Problem
1
3
2
4
32 41
X1{ ,2,3,4}
X3{1, ,3, }
X4{1, ,3,4}
X2{ , , ,4}
Forward check!
12
CIS 421/521 - Intro to AI 68
Example: 4-Queens Problem
1
3
2
4
32 41
X1{ ,2,3,4}
X3
{1, ,3, }
X4
{1, ,3,4}
X2{ , , ,4}
Assign value to
unassigned variableCIS 421/521 - Intro to AI 69
Example: 4-Queens Problem
1
3
2
4
32 41
X1{ ,2,3,4}
X3
{1, , , }
X4
{1, ,3, }
X2{ , , ,4}
Forward check!
CIS 421/521 - Intro to AI 70
Example: 4-Queens Problem
1
3
2
4
32 41
X1{ ,2,3,4}
X3{1, , , }
X4{1, ,3, }
X2{ , , ,4}
Assign value to
unassigned variableCIS 421/521 - Intro to AI 71
Example: 4-Queens Problem
1
3
2
4
32 41
X1{ ,2,3,4}
X3{1, , , }
X4{ , ,3, }
X2{ , , ,4}
Forward check!
CIS 421/521 - Intro to AI 72
Example: 4-Queens Problem
1
3
2
4
32 41
X1{ ,2,3,4}
X3{1, , , }
X4{ , ,3, }
X2{ , , ,4}
Assign value to
unassigned variableCIS 421/521 - Intro to AI 73
Towards Constraint propagation
• Forward checking propagates information from
assigned to unassigned variables, but doesn't
provide early detection for all failures:
• NT and SA cannot both be blue!
• Constraint propagation goes beyond forward
checking & repeatedly enforces constraints locally