Transcript + h(n)
CSM6120
Introduction to Intelligent Systems
Informed search
[email protected]
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