1
ARTIFICIAL
INTELLIGENCE
◤
CHAPTER 4
INFORMED
SEARCH
2
◤
OUTLINE
✔ Introduction
✔ Heuristic Search
✔ Greedy Search
✔ A* Search
✔ Memory Bounded Heuristic
Search
▪ Recursive Best First Search
▪ Simple Memory Bounded A*
✔ Dominance
✔ Relaxed Problems
3
◤
INTRODUCTION
Travel Salesperson Problem
Given a list of cities and their pair wise distances, the task is to find
a shortest possible tour that visits each city exactly once.
▪ Any idea how to improve this type of search?
▪ What type of information we may use to improve our search?
▪ Do you think this idea is useful: (At each stage visit the unvisited city
nearest to the current city)?
4
◤
HEURISTIC SEARCH ALGORITHM
5
◤
BEST-FIRST SEARCH
Idea: Use an evaluation function f(n) for each node
▪ family of search methods with various evaluation functions (estimate of "desirability“)
▪ usually gives an estimate of the distance to the goal
▪ often referred to as heuristics in this context
▪ Expand most desirable unexpanded node.
▪ A heuristic function ranks alternatives at each branching step based on the available
information (heuristically) in order to make a decision about which branch to follow during a
search.
Implementation:
▪ Order the nodes in fringe in decreasing order of desirability.
Special cases:
▪ greedy best-first search
▪ A* search
6
◤
BEST-FIRST SEARCH ALGORITHM
1. Initialize: Set OPEN= {Si}, CLOSED = { }, g(s) = 0, f(s) = h(s)
2. Fail: if OPEN = { } then return FAIL
3. Select: Select the minimum cost state (minimum evaluation function
f), n, from OPEN and insert in CLOSED
4. Terminate: if n belongs to G, terminate with Success, and return f(n)
5. Expand: Generate all direct successors of node n. For each
successor m, of n:
a) apply the evaluation function, f, to the node.
b) if the node has not been in either list, add it to OPEN.
else, if f(m) has decreased and m ∈ CLOSED, move m to OPEN
6. Loop: Go to Step 2
7
GREEDY BEST-FIRST SEARCH
◤
8
◤
ROMANIA WITH STEP COSTS IN KM
Suppose we can have this info (SLD)
▪ How can we use it to improve our search?
9
◤
GREEDY BEST-FIRST SEARCH
Greedy best-first search expands the node that appears to be
closest to goal.
▪ Estimate of cost from n to goal ,ex. hSLD(n)= straight-line
distance from n to Bucharest.
▪ Utilizes a heuristic function as evaluation function
▪ f(n) = h(n) = estimated cost from the current node to a
goal.
▪ Heuristic functions are problem-specific.
▪ Often straight-line distance for route-finding and similar problems.
10
◤
GREEDY BEST-FIRST SEARCH EXAMPLE
11
◤
GREEDY BEST-FIRST SEARCH EXAMPLE
12
◤
GREEDY BEST-FIRST SEARCH EXAMPLE
13
◤
GREEDY BEST-FIRST SEARCH EXAMPLE
14
◤
15
◤
GREEDY BEST-FIRST SEARCH
PROPERTIES
▪ Complete: No –can get stuck in loops (e.g., Iasi
□Neamt□Iasi □Neamt□….)
▪ Time: O(bm), but a good heuristic can give significant
improvement
▪ Space: O(bm) --keeps all nodes in memory
▪ Optimal: No
b: branching factor
m: maximum depth of the search tree
16
◤
DISCUSSION
▪ Do you think hSLD(n) is admissible?
▪ Did you find the Greedy idea useful?
▪ Ideas to improve it?
A*search
17
A* SEARCH
◤
18
◤
A* SEARCH
Idea: avoid expanding paths that are already expensive.
▪ Evaluation function = path cost + estimated cost to the goal
▪ f(n) = g(n) + h(n)
▪ -g(n) = cost so far to reach n
▪ -h(n)= estimated cost from n to goal
▪ -f(n) = estimated total cost of path to goal through n
▪ Combines greedy and uniform-cost search to find the (estimated)
cheapest path through the current node
▪ Heuristics must be admissible
▪ Never overestimate the cost to reach the goal
▪ Very good search method, but with complexity problems
19
◤
A* SEARCH EXAMPLE
20
◤
A* SEARCH EXAMPLE
21
◤
A* SEARCH EXAMPLE
22
◤
A* SEARCH EXAMPLE
23
◤
A* SEARCH EXAMPLE
24
◤
A* SEARCH EXAMPLE
25
◤
A* SEARCH ALGORITHM
1. Initialize: Set OPEN= {Si}, CLOSED = { }, g(s) = 0, f(s) = h(s)
2. Fail: if OPEN = { } then return FAIL
3. Select: Select the minimum cost state, n, from OPEN and insert in
CLOSED
4. Terminate: if n belongs to G, terminate with Success, and return f(n)
5. Expand: Generate all direct successors of node n.
For each successor m, of n
if m ✂ [OPEN ∪ CLOSED], Set g(m) = g(n) + C(n,m)
Set f(m) = g(m) + h(m) and insert m in OPEN
if m ∈ [OPEN ∪ CLOSED], Set g(m) = min (g(m), g(n) + C(n,m)), Set
f(m) = g(m) + h(m)
if f(m) has decreased and m ∈ CLOSED, move m to OPEN
6. Loop: Go to Step 2
7. End
26
◤
A* SEARCH EXERCISE
NODE SL DISTANCE
A 8.0
B 7.3
C 7.6
D 6
E 5.4
F 4.1
G 4.1
H 2.8
I 2.0
J 2.2
27
◤
A* SEARCH EXERCISE
28
◤
GREEDY BEST-FIRST SEARCH
EXERCISE
NODE SL DISTANCE
A 8.0
B 7.3
C 7.6
D 6
E 5.4
F 4.1
G 4.1
H 2.8
I 2.0
J 2.2
29
◤
GREEDY BEST-FIRST SEARCH
EXERCISE
30
◤
EXERCISE
NOD SL DISTANCE
E
A 8.0
B 6.3
C 6.3
D 5.0
E 4.0
F 5.1
G 5.0
H 4.5
I 2.8
J 2.2
K 3.6
31
◤
ADMISSIBLE HEURISTICS
▪ A heuristic h(n)is admissible if for every node n, h(n) ≤h*(n),
where h*(n) is the true cost to reach the goal state from n.
▪ An admissible heuristic never overestimates the cost to reach
the goal, i.e., it is optimistic.
▪ Example: hSLD(n) (never overestimates the actual road distance)
▪ Theorem-1: If h(n) is admissible, A* using tree-search is optimal.
32
◤
PROOF OF A* OPTIMALITY
▪ Recall that f(n) = g(n) + h(n)
▪ Now, suppose some suboptimal goal G2 has been generated and is in
the fringe. Let n be an unexpanded node in the fringe such that n is
on a shortest path to an optimal goal G.
▪ We want to prove:
f(n) < f(G2) i.e. A* will prefer n over G2
f(G2) = g(G2) since h(G2) = 0
g(G2) > g(G) since G2 is suboptimal f(G) = g(G) since h(G) = 0
f(G2) > f(G) from above
h(n) ≤ h*(n) since h is admissible g(n) + h(n) ≤ g(n) + h*(n)
f(n) ≤ f(G) Hence f(G2) > f(n), and n is expanded, thus, A* will never select G2 for
expansion
33
◤
PROOF OF A* OPTIMALITY (CONT’D)
In other words:
f(G2) = g(G2) + h(G2) = g(G2) > C*,
since G2 is a goal on a non-optimal path (C* is the
optimal cost)
f(n) = g(n) + h(n) <= C*, since h is admissible
f(n) <= C* < f(G2), so G2 will never be expanded
A* will not expand goals on sub-optimal paths
34
◤
CONSISTENT HEURISTICS
A heuristic is consistent if for every node n, every successor n’ of
n
generated by any action:
h(n) ≤ c(n,n') + h(n’)
If h is consistent, we have:
▪ f(n') = g(n') + h(n’)
= g(n) + c(n,n') + h(n') ≥ g(n) + h(n) = f(n)
▪ •i.e., f(n) is non-decreasing along any path.
▪ Theorem-2: If h(n)is consistent, A* using graph-search is
optimal.
▪ consistency is also called monotonicity
35
◤
OPTIMALITY OF A*
▪ A* expands nodes in order of increasing fvalue
▪ Gradually adds "f-contours" of nodes
▪ Contour i has all nodes with f = fi, where fi< fi+1
36
◤
COMPLEXITY OF A*
▪ The number of nodes within the goal contour search space
is still exponential
▪ with respect to the length of the solution
▪ better than other algorithms, but still problematic
▪ Frequently, space complexity is more important than time
complexity
▪ A* keeps all generated nodes in memory
37
◤
PROPERTIES OF A*
▪ Complete? Yes (unless there are infinitely many nodes with f ≤ f(G) )
▪ Time? Exponential
▪ Because all nodes such that f(n) <= C* are expanded!
▪ Space? Keeps all nodes in memory, (bd) Fringe is exponentially large
▪ Optimal? Yes (already proved to reach the optimal goal)
▪ A* prunes all nodes with f(n)>f((G)
Who can propose an idea to improve the time/space complexity?
38
◤
MEMORY BOUNDED HEURISTIC
SEARCH
▪ How can we solve the memory problem for A* search?
▪ Idea: Try something like iterative deeping search, but the cutoff
is f-cost (g+h) at each iteration, rather than depth first.
▪ Two types of memory bounded heuristic searches:
▪ Recursive BFS
▪ SMA*
39
◤
RECURSIVE BEST FIRST SEARCH (RBFS)
best alternative over
fringe nodes,
which are not children:
do I want to back up?
▪ RBFS changes its mind very
often in practice.
▪ This is because the f=g+h
become more accurate (less
optimistic) as we approach the
goal. Hence, higher level
nodes have smaller f-values
and will be explored first.
▪ Problem? If we have more
memory we cannot make use
of it.
▪ Any idea to improve this?
40
◤
PROPERTIES OF RECURSIVE BEST
FIRST SEARCH
▪ Complete? Yes, given enough
space
▪ Time? Hard to analyze
▪ Space? b*d
▪ Optimal? Yes, if admissible
41
◤
SIMPLE MEMORY BOUNDED A* (SMA*)
▪ This is like A*, but when memory is full we delete the
worst node (largest f-value).
▪ Like RBFS, we remember the best descendent in the
branch we delete.
▪ If there is a tie (equal f-values), we delete the oldest
nodes first.
▪ SMA* finds the optimal reachable solution given the
memory constraint.
▪ But time can still be exponential.
42
◤
SIMPLE MEMORY BOUNDED A* (SMA*)
▪ SMA* is a shortest path algorithm based on the A* algorithm.
▪ The advantage of SMA* is that it uses a bounded memory, while
the A* algorithm might need exponential memory.
▪ All other characteristics of SMA* are inherited from A*.
▪ How it works:
▪ Like A*, it expands the best leaf until memory is full.
▪ Drops the worst leaf node-the one with the highest f-value.
▪ Like RBFS, SMA* then backs up the value of the forgotten node to
its parent.
43
◤
SIMPLE MEMORY-BOUNDED A* (SMA*)
Example with 3-node memory
44
◤
SMA* ALGORITHM
45
◤
PROPERTIES OF SMA*
▪ It works with a heuristic, just as A*
▪ It is complete if the allowed memory is high enough to store the
shallowest solution.
▪ It is optimal if the allowed memory is high enough to store the shallowest
optimal solution, otherwise it will return the best solution that fits in the
allowed memory
▪ It avoids repeated states as long as the memory bound allows it
▪ It will use all memory available
▪ Enlarging the memory bound of the algorithm will only speed up the
calculation
▪ When enough memory is available to contain the entire search tree, then
calculation has an optimal speed
46
◤
ADMISSIBLE HEURISTICS
▪ Ex., for the 8-puzzle:
▪ h1(n) = number of misplaced tiles
▪ h2(n) = total Manhattan distance
▪ (i.e., no. of squares from desired location of each tile)
▪ h1(S) = 8
▪ h2(S) = 3+1+2+2+2+3+3+2 = 18
47
◤
DOMINANCE
▪ If h2(n) ≥ h1(n) for all n, and both are admissible.
▪ then h2 dominates h1 (h2 is more informed than h1)
▪ h2 is better for search: it is guaranteed to expand less
nodes.
▪ Typical search costs (average number of nodes expanded):
▪ d=1 IDS = 3,644,035 A*(h1) = 227 nodes A*(h2) = 73 nodes
2 nodes
▪ d=2 IDS = too many A*(h1) = 39,135 A*(h2) = 1,641
▪ What4to do If
nodes nodes
we have h1,…,hm; but none dominates the nodes
other?
▪ h(n) = max{h1(n), . . .hm(n)}
48
◤
RELAXED PROBLEMS
▪ A problem with fewer restrictions on the actions is called a
relaxed problem
▪ The cost of an optimal solution to a relaxed problem is an
admissible heuristic for the original problem
▪ If the rules of the 8-puzzle are relaxed so that a tile can move
anywhere, then h1(n) gives the shortest solution
▪ If the rules are relaxed so that a tile can move to any near
square, then h2(n) gives the shortest solution
