CSM6120
Introduction to Intelligent Systems
Informed search
rkj@aber.ac.uk
Quick review

Problem definition


Factors


Initial state, goal state, state space, actions, goal function, path
cost function
Branching factor, depth of shallowest solution, maximum depth
of any path in search state, complexity, etc.
Uninformed techniques

BFS, DFS, Depth-limited, UCS, IDS
Informed search

What we’ll look at:

Heuristics

Hill-climbing

Best-first search


Greedy search
A* search
Heuristics

A heuristic is a rule or principle used to guide a search



It provides a way of giving additional knowledge of the problem
to the search algorithm
Must provide a reasonably reliable estimate of how far a state
is from a goal, or the cost of reaching the goal via that state
A heuristic evaluation function is a way of calculating or
estimating such distances/cost
Heuristics and algorithms

A correct algorithm will find you the best solution given
good data and enough time


It is precisely specified
A heuristic gives you a workable solution in a reasonable
time

It gives a guided or directed solution
Evaluation function

There are an infinite number of possible heuristics

Criteria is that it returns an assessment of the point in the
search

If an evaluation function is accurate, it will lead directly to
the goal

More realistically, this usually ends up as “seemingly-bestsearch”

Traditionally, the lowest value after evaluation is chosen as
we usually want the lowest cost or nearest
Heuristic evaluation functions

Estimate of expected utility value from a current position



Humans have to do this as we do not evaluate all possible
alternatives


E.g. value for pieces left in chess
Way of judging the value of a position
These heuristics usually come from years of human experience
Performance of a game playing program is very dependent
on the quality of the function
Heuristics?
Heuristics?
Heuristic evaluation functions

Must agree with the ordering a utility function would give
at terminal states (leaf nodes)

Computation must not take long

For non-terminal states, the evaluation function must
strongly correlate with the actual chance of ‘winning’

The values can be learned using machine learning
techniques
Heuristics for the 8-puzzle

Number of tiles out of place (h1)

Manhattan distance (h2)


Sum of the distance of each tile from its goal position
Tiles can only move up or down  city blocks
0
1
2
3
4
5
6
7
The 8-puzzle

Using a heuristic evaluation function:

h2(n) = sum of the distance each tile is from its goal position
Goal state
0
1
2
3
4
5
6
7
Current state
Current state
0
1
2
0
2
5
3
4
5
3
1
7
7
6
6
h1=1
h2=1
4
h1=5
h2=1+1+1+2+2=7
Search algorithms

Hill climbing

Best-first search


Greedy best-first search
A*
Iterative improvement

Consider all states laid out on the surface of a landscape

The height at any point corresponds to the result of the
evaluation function
Iterative improvement

Paths typically not retained - very little memory needed

Move around the landscape trying to find the lowest
valleys - optimal solutions (or the highest peaks if trying
to maximise)


Useful for hard, practical problems where the state description
itself holds all the information needed for a solution
Find reasonable solutions in a large or infinite state space
Hill-climbing (greedy local)


Start with current-state = initial-state
Until current-state = goal-state OR there is no change
in current-state do:



a) Get the children of current-state and apply evaluation
function to each child
b) If one of the children has a better score, then set currentstate to the child with the best score
Loop that moves in the direction of decreasing
(increasing) value


Terminates when a “dip” (or “peak”) is reached
If more than one best direction, the algorithm can choose at
random
Hill-climbing (gradient ascent)
Hill-climbing drawbacks

Local minima (maxima)


Plateau



Local, rather than global minima (maxima)
Area of state space where the evaluation function is essentially
flat
The search will conduct a random walk
Ridges

Causes problems when states along the ridge are not directly
connected - the only choice at each point on the ridge
requires uphill (downhill) movement
Best-first search

Like hill climbing, but eventually tries all paths as it uses
list of nodes yet to be explored

Start with priority-queue = initial-state
While priority-queue not empty do:




a) Remove best node from the priority-queue
b) If it is the goal node, return success. Otherwise find its
successors
c) Apply evaluation function to successors and add to
priority-queue
Best-first example
Best-first search

Different best-first strategies have different evaluation
functions

Some use heuristics only, others also use cost functions:
f(n) = g(n) + h(n)

For Greedy and A*, our heuristic is:


Heuristic function h(n) = estimated cost of the cheapest path
from node n to a goal node
For now, we will introduce the constraint that if n is a goal
node, then h(n) = 0
Greedy best-first search

Greedy BFS tries to expand the node that is ‘closest’ to
the goal assuming it will lead to a solution quickly


f(n) = h(n)
aka “greedy search”

Differs from hill-climbing – allows backtracking

Implementation


Expand the “most desirable” node into the frontier queue
Sort the queue in decreasing order
Route planning: heuristic??
Route planning - GBFS
Greedy best-first search
Route planning
Greedy best-first search
Greedy best-first search
This happens to be the same search path
that hill-climbing would produce, as there’s
no backtracking involved (a solution is
found by expanding the first choice node
only, each time).
Greedy best-first search

Complete


Time complexity


O(bm) but a good heuristic can have dramatic improvement
Space complexity


No, GBFS can get stuck in loops (e.g. bouncing back and
forth between cities)
O(bm) – keeps all the nodes in memory
Optimal

No! (A – S – F – B = 450, shorter journey is possible)
Practical 2

Implement greedy best-first search for pathfinding

Look at code for AStarPathFinder.java
A* search

A* (A star) is the most widely known form of Best-First
search

It evaluates nodes by combining g(n) and h(n)

f(n) = g(n) + h(n)

where



g(n) = cost so far to reach n
h(n) = estimated cost to goal from n
f(n) = estimated total cost of path through n
start
g(n)
n
h(n)
goal
A* search

When h(n) = h*(n) (h*(n) is actual cost to goal)



When h(n) < h*(n)



Only nodes in the correct path are expanded
Optimal solution is found
Additional nodes are expanded
Optimal solution is found
When h(n) > h*(n)

Optimal solution can be overlooked
Route planning - A*
A* search
A* search
A* search
A* search
A* search
A* search

Complete and optimal if h(n) does not overestimate the true
cost of a solution through n

Time complexity


Exponential in [relative error of h x length of solution]
The better the heuristic, the better the time



Best case h is perfect, O(d)
Worst case h = 0, O(bd) same as BFS, UCS
Space complexity



Keeps all nodes in memory and save in case of repetition
This is O(bd) or worse
A* usually runs out of space before it runs out of time
A* exercise
Node
A
B
C
D
E
F
G
H
I
J
K
Coordinates
(5,9)
(3,8)
(8,8)
(5,7)
(7,6)
(4,5)
(6,5)
(3,3)
(5,3)
(7,2)
(5,1)
SL Distance to K
8.0
7.3
7.6
6.0
5.4
4.1
4.1
2.8
2.0
2.2
0.0
Solution to A* exercise
GBFS exercise
Node
A
B
C
D
E
F
G
H
I
J
K
Coordinates
(5,9)
(3,8)
(8,8)
(5,7)
(7,6)
(4,5)
(6,5)
(3,3)
(5,3)
(7,2)
(5,1)
Distance
8.0
7.3
7.6
6.0
5.4
4.1
4.1
2.8
2.0
2.2
0.0
Solution
To think about...
f(n) = g(n) + h(n)

What algorithm does A* emulate if we set



h(n) = -g(n) - depth(n)
h(n) = 0
Can you make A* behave like Breadth-First Search?
A* search - Mario

http://aigamedev.com/open/interviews/mario-ai/




Control of Super Mario by an A* search
Source code available
Various videos and explanations
Written in Java
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
Example: hSLD(n) (never overestimates the actual road distance)
Theorem: If h(n) is admissible, A* is optimal (for tree-search)
Optimality of A* (proof)

Suppose some suboptimal goal G2 has been generated and is in the frontier.
Let n be an unexpanded node in the frontier such that n is on a shortest
path to an optimal goal G

f(G2) = g(G2)
g(G2) > g(G)
f(G) = g(G)
f(G2) > f(G)



since h(G2) = 0 (true for any goal state)
since G2 is suboptimal
since h(G) = 0
from above
Optimality of A* (proof)

f(G2) > f(G)
h(n) ≤ h*(n)
g(n) + h(n) ≤ g(n) + h*(n)
f(n) ≤ f(G)

Hence f(G2) > f(n), and A* will never select G2 for expansion



since h is admissible
(f(G) = g(G) = g(n) + h*(n))
Heuristic functions

Admissible heuristic example: 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) = ??
h2(S) = ??
Heuristic functions

Admissible heuristic example: 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) = 6
h2(S) = 4+0+3+3+1+0+2+1
= 14
Heuristic functions

Dominance/Informedness

if h2(n)  h1(n) for all n (both admissible)
then h2 dominates h1 and is better for search


Typical search costs: (8 puzzle, d = solution length)
d = 12 IDS = 3,644,035 nodes
A*(h1) = 227 nodes
A*(h2) = 73 nodes
d = 24 IDS  54,000,000,000 nodes
A*(h1) = 39,135 nodes
A*(h2) = 1,641 nodes
Heuristic functions

Admissible heuristic
example: for the 8-puzzle
But how do we come up with a
heuristic?
h1(n) = number of misplaced tiles
h2(n) = total Manhattan distance
i.e. no of squares from desired location of
each tile
h1(S) = 6
h2(S) = 4+0+3+3+1+0+2+1
= 14
Relaxed problems

Admissible heuristics can be derived from the exact
solution cost of a relaxed version of the problem



E.g. 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 adjacent
square, then h2(n) gives the shortest solution
Key point: the optimal solution cost of a relaxed problem is
no greater than the optimal solution cost of the real
problem
Choosing a strategy

What sort of search problem is this?

How big is the search space?

What is known about the search space?

What methods are available for this kind of search?

How well do each of the methods work for each kind of
problem?
Which method?

Exhaustive search for small finite spaces when it is
essential that the optimal solution is found

A* for medium-sized spaces if heuristic knowledge is
available

Random search for large evenly distributed homogeneous
spaces

Hill climbing for discrete spaces where a sub-optimal
solution is acceptable
Summary

What is search for?

How do we define/represent a problem?

How do we find a solution to a problem?

Are we doing this in the best way possible?

What if search space is too large?

Can use other approaches, e.g. GAs, ACO, PSO...
Finally

Try the A* exercise on the course website (solutions will be
made available later)

Next seminar on Monday at 9:30am

See the algorithms in action:

http://web.archive.org/web/20110719085935/http://www.stefanbaur.de/cs.web.mashup.pathfinding.html