cs 343h: artificial intelligence week 2b: informed search

CS 343H: Artificial Intelligence

Week 2b: Informed Search

Quiz : review

Which are true about DFS? (b is branching factor, m is depth of search tree.)1. At any given time during the search, the number of

nodes on the fringe can be no larger than bm.

2. At any given time in the search, the number of nodes on the fringe can be as large as b^m.

3. The number of nodes expanded throughout the entire search can be no larger than bm.

4. The number of nodes expanded throughout the entire search can be as large as b^m.

Quiz : review

Which are true about BFS? (b is the branching factor, s is the depth of the shallowest solution)1. At any given time during the search, the number of

nodes on the fringe can be no larger than bs.

2. At any given time during the search, the number of nodes on the fringe can be as large as b^s.

3. The number of nodes considered throughout the entire search can be no larger than bs.

4. The number of nodes considered throughout the entire search can be as large as b^s.

Quiz: search execution

Run DFS, BFS, and UCS:

Today

Informed search Heuristics Greedy search A* search

Graph search

Recap: Search

Search problem: States (configurations of the world) Actions and costs Successor function: a function from states to

lists of (state, action, cost) triples (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 tree Chooses an ordering of the fringe (unexplored nodes) Optimal: finds least-cost plans

Example: Pancake Problem

Cost: Number of pancakes flipped

Example: Pancake Problem

3

2

4

3

3

2

2

2

4

State space graph with costs as weights

34

3

4

2

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

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

[demo: countours UCS]

Example: Uniform cost search

Another example

Informed search: main idea

Search heuristic

A heuristic is: A function that estimates how close a state is to a goal Designed for a particular search problem

10

511.2

Example: Heuristic Function

h(x)

Example: Heuristic FunctionHeuristic: the largest pancake that is still out of place

4

3

0

2

3

3

3

4

4

3

4

4

4

h(x)

How to use the heuristic? What about following the “arrow” of the

heuristic?.... Greedy search

Example: Heuristic Function

h(x)

Best First / Greedy Search

Expand the node that seems closest…

What can go wrong?

Greedy search

Strategy: expand a 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 (wrong) goal

Worst-case: like a badly-guided DFS

…b

…b

Quiz: greedy search

Which solution would greedy search find if run on this graph?

Enter: A* search

Combining UCS and Greedy Uniform-cost orders by path cost, or backward cost g(n) Greedy orders by goal proximity, or forward cost h(n)

A* Search orders by the sum: f(n) = g(n) + h(n)

S a d

b

Gh=5

h=6

h=2

1

5

11

2

h=6h=0

c

h=7

3

e h=11

Example: Teg Grenager

Should we stop when we enqueue a goal?

No: only stop when we dequeue a goal

When should A* terminate?

S

B

A

G

2

3

2

2h = 1

h = 2

h = 0

h = 3

Quiz: A* Tree search

Quiz: A* Tree search

When running A*, the first node expanded is S (like all search algorithms). After expanding S, two nodes will be on the fringe: S->A and S->D. Fill in:

1. g((S->A)) =

2. h((S->A)) =

3. f((S->A)) =

4. g((S->D))=

5. h((S->D)) =

6. f((S->D)) =

7. Which node will be expanded next?

Is A* Optimal?

A

GS

1

3h = 6

h = 0

5

h = 7

What went wrong? Actual bad goal cost < estimated good goal cost We need estimates to be less than actual costs!

Idea: admissibility

Inadmissible (pessimistic): break optimality by trapping

good plans on the fringe

Admissible (optimistic): slows down bad plans but never outweigh true costs

Admissible Heuristics

A heuristic h is admissible (optimistic) if:

where 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

Optimality of A*

…Notation:

g(n) = cost to node n

h(n) = estimated cost from n

to the nearest goal (heuristic)

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

estimated total cost via n

A: a lowest cost goal node

B: another goal nodeClaim: A will exit the fringe before B.

A

B

Optimality of A*

… Imagine B is on the fringe. Some ancestor n of A must be on

the fringe too (maybe n is A) Claim: n will be expanded before B.

1. f(n) <= f(A) A

B

Claim: A will exit the fringe before B.

• f(n) = g(n) + h(n) // by definition

• f(n) <= g(A) // by admissibility of h

• g(A) = f(A) // because h=0 at goal

Optimality of A*



1. f(n) <= f(A)

2. f(A) < f(B)

A

B


• g(A) < g(B) // B is suboptimal

• f(A) < f(B) // h=0 at goals

Optimality of A*



1. f(n) <= f(A)

2. f(A) < f(B)

3. n will expand before B

A

B


• f(n) <= f(A) < f(B) // from above

• f(n) < f(B)

Optimality of A*



1. f(n) <= f(A)

2. f(A) < f(B)

3. n will expand before B All ancestors of A expand before B A expands before B

A

B


Properties of A*

…b

…b

Uniform-Cost A*

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

Recall: greedy

Uniform cost search

Quiz: A* tree search

A* applications

Pathing / routing problems Video games Resource planning problems Robot motion planning Language analysis Machine translation Speech recognition …

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 (why?)

15366

Example: 8 Puzzle

What are the states? How many states? What are the actions? What states can I reach from the start state? What should the costs be?

8 Puzzle I

Heuristic: Number of tiles misplaced

Why is it admissible?

h(start) =

This is a relaxed-problem heuristic

8 Average nodes expanded when optimal path has length…

…4 steps …8 steps …12 steps

UCS 112 6,300 3.6 x 106

TILES 13 39 227

8 Puzzle II

What if we had an easier 8-puzzle where any tile could slide any direction at any time, ignoring other tiles?

Total Manhattan distance

Why admissible?

h(start) =

3 + 1 + 2 + …

= 18

Average nodes expanded when optimal path has length…

…4 steps …8 steps …12 steps

TILES 13 39 227

MANHATTAN 12 25 73

Quiz 1

Consider the problem of Pacman eating all dots in a maze. Every movement action has a cost of 1. Select all heuristics that are admissible, if any.

the total number of dots left the distance to the closest dot the distance to the furthest dot the distance to the closest dot plus distance to the furthest dot none of the above

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 node!

Graph Search

In BFS, for example, we shouldn’t bother expanding the circled nodes (why?)

S

a

b

d p

a

c

e

p

h

f

r

q

q c G

a

qe

p

h

f

r

q

q c G

a

Graph Search

Idea: never expand a state twice

How 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 is new If not new, skip it

Important: store the closed set as a set, not a list

Can graph search wreck completeness? Why/why not?

How about optimality?

Warning: 3e book has a more complex, but also correct, variant

A* Graph Search Gone Wrong?

S

A

B

C

G

1

1

1

23

h=2

h=1

h=4h=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

Consistency of Heuristics

Admissibility: heuristic cost <=

actual cost to goal

h(A) <= actual cost from A to G

3

A

C

G

h=4 1

Consistency of Heuristics

Stronger than admissibility

Definition:

heuristic cost <= actual cost per arc

h(A) - h(C) <= cost(A to C)

Consequences:

The f value along a path never decreases

A* graph search is optimal

A

Ch=4

h=1

1

h=2

Optimality

Tree search: A* is optimal if heuristic is admissible (and non-negative) UCS is a special case (h = 0)

Graph search: A* optimal if heuristic is consistent UCS optimal (h = 0 is consistent)

Consistency implies admissibility

In general, most natural admissible heuristics tend to be consistent, especially if from relaxed problems

Trivial Heuristics, Dominance

Dominance: ha ≥ hc if

Heuristics 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

Summary: A*

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

A* is optimal with admissible / consistent heuristics

Heuristic design is key: often use relaxed problems

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.


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 suboptimal p would have been expanded before n’ Contradiction!

Graph Search

Very simple fix: never expand a state twice

Can this wreck completeness? Optimality?

Graph Search, Reconsidered

Idea: never expand a state twice

How to implement: Tree search + list of expanded states (closed list) Expand the search tree node-by-node, but… Before expanding a node, check to make sure its state is new

Python trick: store the closed list as a set, not a list

Can graph search wreck completeness? Why/why not?

How about optimality?


Consider what A* does: Expands nodes in increasing total f value (f-contours) Proof idea: optimal goals have lower f value, so get

expanded first

We’re making a stronger assumption than in the last proof… What?


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?

Course Scheduling

From the university’s perspective: Set of courses {c1, c2, … cn}

Set of room / times {r1, r2, … rn}

Each pairing (ck, rm) has a cost wkm

What’s the best assignment of courses to rooms? States: list of pairings Actions: add a legal pairing Costs: cost of the new pairing

Admissible heuristics?

Consistency Wait, how do we know parents have better f-vales than

their successors? Couldn’t we pop some node n, and find its child n’ to have

lower f value? YES:

What can we require to prevent these inversions?

Consistency: Real cost must always exceed reduction in heuristic Like admissibility, but better!

A

B

G

3h = 0

h = 10

g = 10

h = 8

cs 343h: artificial intelligence week 2b: informed search

Documents

search search problem

search graph search

informed search slide

entire search

uniform cost search

search algorithms

depth of search tree

particular search problem