Download presentation

Presentation is loading. Please wait.

1
Game Playing Chapter 8

2
**Outline Overview Minimax search Adding alpha-beta cutoffs**

Additional refinements Iterative deepening Specific games

3
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.

4
**Overview Chess The average branching factor is around 35.**

In an average game, each player might make 50 moves. One would have to examine positions.

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.

6
Overview Improve the generate procedure so that only good moves are generated. plausible-moves vs. legal-moves Improve the test procedure so that the best moves will be recognized and explored first. less moves to be evaluated

7
Overview It is not usually possible to search until a goal state is found. It has to evaluate individual board positions by estimating how likely they are to lead to a win. Static evaluation function Credit assignment problem (Minsky, 1963).

8
**Overview Good plausible-move generator.**

Good static evaluation function.

9
**Minimax Search Depth-first and depth-limited 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.

10
**Minimax Search -2 A Maximizing ply Player -6 -2 -4 B C D**

Minimizing ply Opponent E F G H I J K 9 -6 -2 -4 -3 Two-ply search

11
**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

12
**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

13
**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

14
**Minimax Search MINIMAX(Position, Depth, Player):**

MOVE-GEN(Position, Player). STATIC(Position, Player). DEEP-ENOUGH(Position, Depth)

15
**Minimax Search if DEEP-ENOUGH(Position, Depth), then return:**

VALUE = STATIC(Position, Player) PATH = nil SUCCESSORS = MOVE-GEN(Position, Player) if SUCCESSORS is empty, then do as in Step 1

16
**Minimax Search 4. if SUCCESSORS is not empty: Return:**

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 Return: VALUE = BEST-SCORE PATH = BEST-PATH

17
**Adding Alpha-Beta Cutoffs**

Depth-first and depth-limited search. branch-and-bound At the player choice, maximize the static evaluation of the next position. > a threshold At the opponent choice, minimize the static evaluation of the next position. < b threshold

18
**Adding Alpha-Beta Cutoffs**

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

19
**Adding Alpha-Beta Cutoffs**

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

20
**Adding Alpha-Beta Cutoffs**

Opponent b Player a ≥ b a Opponent a ≥ b Player Alpha and Beta cutoffs

21
**Player(Position, Depth, a, b): for each S SUCCESSORS(Position) do**

RESULT = Opponent(S, Depth + 1, a, b) NEW-VALUE = VALUE(RESULT) if NEW-VALUE a, then a = NEW-VALUE BEST-PATH = PATH(RESULT) + S if a b then return VALUE = a PATH = BEST-PATH return

22
**Opponent(Position, Depth, a, b): for each S SUCCESSORS(Position) do**

RESULT = Player(S, Depth + 1, a, b) NEW-VALUE = VALUE(RESULT) if NEW-VALUE b, then b = NEW-VALUE BEST-PATH = PATH(RESULT) + S if b ≤ a then return VALUE = b PATH = BEST-PATH return

23
**Any-Player(Position, Depth, a, b): **

for each S SUCCESSORS(Position) do RESULT = Any-Player(S, Depth + 1, -b, -a) NEW-VALUE = - VALUE(RESULT) if NEW-VALUE a, then a = NEW-VALUE BEST-PATH = PATH(RESULT) + S if a b then return VALUE = a PATH = BEST-PATH return

24
**Adding Alpha-Beta Cutoffs**

MINIMAX-A-B(Position, Depth, Player, UseTd, PassTd): UseTd: checked for cutoffs. PassTd: current best value

25
**Adding Alpha-Beta Cutoffs**

if DEEP-ENOUGH(Position, Depth), then return: VALUE = STATIC(Position, Player) PATH = nil SUCCESSORS = MOVE-GEN(Position, Player) if SUCCESSORS is empty, then do as in Step 1

26
**Adding Alpha-Beta Cutoffs**

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 Return:

27
**Additional Refinements**

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

28
Iterative Deepening Iteration 1 Iteration 2 Iteration 3

29
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.

30
**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.

31
**Iterative Deepening Depth-First Iterative Deepening (DFID)**

Set SEARCH-DEPTH = 1 Conduct depth-first search to a depth of SEARCH-DEPTH. If a solution path is found, then return it. Increment SEARCH-DEPTH by 1 and go to step 2.

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

Set THRESHOLD = heuristic evaluation of the start state Conduct depth-first search, pruning any branch when its total cost exceeds THRESHOLD. If a solution path is found, then return it. Increment THRESHOLD by the minimum amount it was exceeded and go to step 2.

33
Iterative Deepening Is the process wasteful?

34
**Homework Presentations Exercises 1-7, 9 (Chapter 12)**

Specific games: Chess – State of the Art Exercises 1-7, 9 (Chapter 12)

Similar presentations

Presentation is loading. Please wait....

OK

Search in AI.

Search in AI.

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google

Ppt on diffusion taking place in our daily life Ppt on duty rosters Ppt on object-oriented programming concepts in c++ Ppt on networking related topics on meteorology Ppt on non renewable resources Ppt on media research group Ppt on history of prime numbers Ppt on marie curie timeline Ppt on needle stick injury protocol Ppt on high level languages of computer