CS 4100: Artificial Intelligence - PowerPoint Presentation

Slide1

CS 4100: Artificial Intelligence

Informed Search

Instructor: Jan-Willem van de Meent

[Adapted from slides by Dan Klein and Pieter Abbeel for CS188 Intro to AI at UC Berkeley (

ai.berkeley.edu

).]

Slide2

Announcements

Homework 1: Search (lead TA: Iris)

Due Mon 16 Sep at 11:59pm (deadline extended)Project 1: Search (lead TA: Iris)

Due Mon 23 Sep at 11:59pmLonger than most – start early! Homework 2: Constraint Satisfaction Problems (lead TA: Eli)Due Mon 23 Sep at 11:59pm

Office Hours

Iris:

Mon 10.00am-noon, RI 237

JW:

Tue 1.40pm-2.40pm, DG 111

Eli:

Wed 3.00pm-5pm, RY 143

Zhaoqing

:

Thu 9.00am-11.00am, HS 202

Slide3

Today

Informed SearchHeuristics

Greedy SearchA* SearchGraph Search

Slide4

Recap: Search

Slide5

Recap: Search

Search problem:States

(configurations of the world)Actions and costsSuccessor functio

n (world dynamics)Start state and goal test

Search tree:

Nodes

represent

plans

for reaching states

Plans

have

costs

(sum of action costs)

Search algorithm:Systematically builds a search treeChooses an ordering of the fringe (unexplored nodes)Complete: finds solution if it existsOptimal: finds least-cost plan

Slide6

Example: Pancake Problem

Cost: Number of pancakes flipped

Slide7

Example: Pancake Problem

Slide8

Example: Pancake Problem

Slide9

Example: Pancake Problem

3

2

4

3

3

2

2

2

4

State space graph with costs as weights

3

4

3

4

2

Slide10

General Tree Search

Action: flip top two

Cost: 2

Action: flip all four

Cost: 4

Path to reach goal:

Flip four, flip three

Total cost: 7

Slide11

The One Queue

All these search algorithms are the same except for fringe strategies

Conceptually, all fringes are priority queues (i.e. collections of nodes with attached priorities)

Practically, for DFS and BFS, you can avoid the log(n) overhead from an actual priority queue, by using stacks and queuesCan even code one implementation that takes a variable queuing object

Slide12

Uninformed Search

Slide13

Uniform Cost Search

Strategy:

expand lowest path cost

The good:

UCS is complete and optimal!

The bad:

Explores options in every “direction”

No information about goal location

Start

Goal

…

c

 3

c

 2

c

 1

Slide14

UCS in Empty Space

Slide15

UCS Contours for a Small Maze

Slide16

Informed Search

Slide17

Search Heuristics

A heuristic is:

A function that estimates how close a state is to a goal

Designed for a particular search problem

Examples:

Manhattan

distance,

Euclidean

distance

10

5

11.2

Slide18

Example: Heuristic for Travel in Romania

h(x)

Slide19

4

0

2

3

2

3

3

3

3

4

3

3

h(x)

Example: Heuristic for Pancake Flipping

Heuristic:

the

number

of pancakes that is still out of place

2

Slide20

Example: Heuristic for Pancake Flipping

New Heuristic:

the

index of the

largest

pancake that is still out of place

4

0

2

3

2

3

3

3

3

4

3

3

h

1

(x)

2

4

3

0

2

3

3

3

4

4

3

4

4

4

h

2

(x)

4

0

2

3

2

3

3

3

3

4

3

3

Slide21

Greedy Search

Slide22

Strategy: Pick node with smallest h(x)

h(x)

Slide23

Greedy Search

Expand the node that seems closest

What can go wrong?

Slide24

Greedy Search

Strategy:

expand the node that you think

is closest to a goal state

Heuristic:

estimate of distance to nearest goal for each state

A common case:

Best-first takes you straight to the goal

(but finds suboptimal path)

Worst-case:

like a badly-guided DFS

…

b

…

b

Slide25

Greedy Search in Empty Space

Slide26

Greedy Search in a Small Maze

Slide27

A* Search

Slide28

A* Search

UCS

(slow and steady)

Greedy Search

(fast but unreliable)

A* Search

(best of both worlds)

Slide29

Combining UCS and Greedy Search

Uniform-cost

orders by path cost, or

backward

cost

g(n)

Greedy

orders by goal proximity, or

forward

heuristic

h(n)

A* Search

orders by the sum:

f(n) = g(n) + h(n)

S

a

d

b

G

h=5

h=6

h=2

1

8

1

1

2

h=6

h=0

c

h=7

3

e

h=1

1

Example:

Teg

Grenager

S

a

b

c

e

d

d

G

G

g = 0 h=6

g = 1 h=5

g = 2 h=6

g = 3 h=7

g = 4 h=2

g = 6 h=0

g = 9 h=1

g = 10 h=2

g = 12 h=0

Slide30

When should A* terminate?

Should we stop when we

enqueue

a goal?

No:

only stop when we

dequeue

a goal

S

B

A

G

2

3

2

2

h = 1

h = 2

h = 0

h = 3

Slide31

Is A* Optimal?

What went wrong?

Actual cost < heuristic cost

We need estimates to be less than actual costs!

A

G

S

1

3

h = 6

h = 0

5

h = 7

Slide32

Admissible Heuristics

Slide33

Idea: Admissibility

Inadmissible (pessimistic) heuristics break optimality by trapping good plans on the fringe

Admissible (optimistic) heuristics slow down bad plans but never outweigh true costs

Slide34

Admissible Heuristics

A heuristic

h(n) is admissible (optimistic) if:

where h*(n) is the true cost to a nearest goal

Examples:

Coming up with admissible heuristics is

most of what’s involved in using A* in practice.

4

15

Slide35

Optimality of A* Tree Search

Slide36

Optimality of A* Tree Search

Assume:

A

is an optimal

goal node

B

is a

suboptimal

goal node

h

is admissible

Claim:

A

will exit the fringe before

B

…

Slide37

Optimality of A* Tree Search: Blocking

Proof:

Imagine

B

is on the fringe

Some ancestor

n

of

A

is on the fringe, too (maybe

A

itself!)

Claim:

n

will be expanded before

B

f(n)

is less or equal to

f(A)

Definition of f-cost

Admissibility of h

…

h = 0 at a goal

Slide38

Optimality of A* Tree Search: Blocking

Proof:

Imagine

B

is on the fringe

Some ancestor

n

of

A

is on the fringe, too (maybe

A

itself!)

Claim:

n

will be expanded before

B

f(n)

is less or equal to

f(A)

f(A)

is less than

f(B)

B

is suboptimal

h=0

at a goal

…

Slide39

Optimality of A* Tree Search: Blocking

Proof:

Imagine

B

is on the fringe

Some ancestor n of

A

is on the fringe, too (maybe

A

itself!)

Claim:

n

will be expanded before

B

f(n)

is less or equal to

f(A)

f(A)

is less than

f(B)

n

expands before

B

All ancestors of

A

expand before

B

A

expands before

B

A*

search is

optimal

…

Slide40

Properties of A*

Slide41

Properties of A*

…

b

…

b

Uniform-Cost

A*

Slide42

UCS

vs

A* Contours

Uniform-cost

expands equally

in all “directions”

A*

expands mainly toward the goal, but does hedge its bets

to ensure optimality

Start

Goal

Start

Goal

Slide43

A* Search in Empty Space

Slide44

UCS in Empty Space

Slide45

Greedy Search in Empty Space

Slide46

A* Search in Small Maze

Slide47

Comparison

Greedy

Uniform Cost

A*

Slide48

A* Applications

Slide49

A* Applications

Video gamesPathing / routing problemsResource planning problems

Robot motion planningLanguage analysisMachine translationSpeech recognition…

Slide50

Pacman (Tiny Maze) – UCS / A*

Slide51

Quiz: Shallow/Deep Water – Guess the Algorithm

Slide52

Creating Heuristics

Slide53

Creating Admissible Heuristics

Most of the work in solving hard search problems optimally is in coming up with admissible heuristics

Often, admissible heuristics are solutions to relaxed problems, where new actions are available

Inadmissible heuristics are often useful too

15

366

Slide54

Example: 8 Puzzle

What are the states?How many states?

What are the actions?How many successors from the start state?What should the costs be?

Start State

Goal State

Actions

Slide55

Average nodes expanded when the optimal path has…

…4 steps

…8 steps

…12 steps

UCS

112

6,300

3.6 x 10

6

TILES

13

39

227

Start State

Goal State

8 Puzzle I

Heuristic:

Number of tiles misplaced

Why is it admissible?

h(start) =

This is a

relaxed-problem

heuristic

8

Statistics from Andrew Moore

Slide56

8 Puzzle II

What if we had an easier 8-puzzle where

any tile could slide in any direction at any time (ignoring other tiles)?

Total Manhattan distance of tiles

Why is it admissible?

h(start) =

3 + 1 + 2 + … = 18

Average nodes expanded when the optimal path has…

…4 steps

…8 steps

…12 steps

TILES

13

39

227

MANHATTAN

12

25

73

Start State

Goal State

Slide57

8 Puzzle III

How about using the actual cost as a heuristic?

Would it be admissible?Would we save on nodes expanded?What’s wrong with it?

With A*: a trade-off between quality of estimate and work per nodeAs heuristics get closer to the true cost, you will expand fewer nodes

but usually do more work per node to compute the heuristic

Slide58

Semi-Lattice of Heuristics

Slide59

Trivial Heuristics, Dominance

Dominance: ha

≥ hc ifHeuristics form a semi-lattice:

Max of admissible heuristics is admissible

Trivial heuristics

Bottom of lattice is the zero heuristic (what does this give us?)

Top of lattice is the exact heuristic

Slide60

Graph Search

Slide61

Tree Search: Extra Work!

Repeated states can cause exponentially more work.

Search Tree

State Graph

Slide62

Graph Search

In BFS, for example, we don’t need to expand the circled nodes (why?)

S

a

b

d

p

a

c

e

p

h

f

r

q

q

c

G

a

q

e

p

h

f

r

q

q

c

G

a

Slide63

Graph Search

Idea: never expand

a state twiceHow to implement: Tree search + set of expanded states (“closed set”)Expand the search tree node-by-node, but…

Before expanding a node, check to make sure its state has never been expanded beforeIf not new, skip it, if new add to closed set

Important:

store the closed set as a set

, not a list

Can graph search wreck completeness? Why/why not?

How about optimality?

Slide64

A* Graph Search Gone Wrong?

S

A

B

C

G

1

1

1

2

3

h=2

h=1

h=4

h=1

h=0

S (0+

2

)

A (1+

4

)

B (1+

1

)

C (2+

1

)

G (5+

0

)

C (3+

1

)

G (6+

0

)

State space graph

Search tree

Slide65

Consistency of Heuristics

Main idea:

heuristic costs ≤ actual costs

Admissibility: heuristic cost ≤ actual cost to goal

h(A)

≤

actual cost from A to G

Consistency:

heuristic ≤ actual cost for each “arc”

h(A) – h(C)

≤

cost(A to C)

Consequences of consistency:

The

f

value along a path never

decreases

h(A)

≤

cost(A to C)

+

h(C)

A* graph search is optimal

3

A

C

G

h=4

h=1

1

h=2

Slide66

Optimality of A* Graph Search

Slide67

Optimality of A* Graph Search

Sketch:

consider what A* does with a consistent heuristic:

Fact 1:

In tree search, A* expands nodes in increasing total f value (f-contours)

Fact 2:

For every state s, nodes that reach s optimally are expanded before nodes that reach s

suboptimally

Result:

A* graph search is optimal

…

f

 3

f

 2

f

 1

Slide68

Optimality

Tree search:A* is optimal if heuristic is

admissibleUCS is a special case (h = 0)Graph search:

A* optimal if heuristic is consistentUCS optimal (h = 0 is consistent)

Consistency implies admissibility

In general, most admissible heuristics

tend to be consistent, especially if

derived from relaxed problems

Slide69

A*: Summary

Slide70

A*: Summary

A* uses backward costs and (estimates of) forward costs

A* is optimal with admissible / consistent heuristics

Heuristic design is key: often use relaxed problems

Slide71

Tree Search Pseudo-Code

Slide72

Graph Search Pseudo-Code

Slide73

Optimality of A* Graph Search

Consider what A* does:

Expands nodes in increasing total f value (f-contours)

Reminder: f(n) = g(n) + h(n) = cost to n + heuristic

Proof idea:

the optimal goal(s) have the lowest

f

value, so it must get expanded first

…

f

 3

f

 2

f

 1

There’s a problem with this argument. What are we assuming is true?

Slide74

Optimality of A* Graph Search

Proof

:

New possible problem:

some

n

on path to

G*

isn’t in queue when we need it, because some worse

n’

for the same state

dequeued

and expanded first (disaster!)

Take the highest such

n

in tree

Let

p

be the ancestor of

n

that was on the queue when

n’

was popped

f(p) < f(n) because of consistency

f(n) < f(n’) because n’ is suboptimalp would have been expanded before

n’Contradiction!