Informed Search Include specific knowledge to efficiently conduct the search and find the solution.
-
Upload
justina-hamilton -
Category
Documents
-
view
219 -
download
0
Transcript of Informed Search Include specific knowledge to efficiently conduct the search and find the solution.
Informed SearchInclude specific knowledge to efficiently conduct the search and find the solution.
Informed Search Methodsfunction BEST-FIRST-SEARCH (problem, EVAL-FN) returns a solution sequence
Queuing-Fn a function that orders nodes by EVAL-FN
return GENERAL-SEARCH(problem,Queuing-Fn)
end
Strategy: function of the order of node expansion
What evaluation functions can we choose?
Not really Best-first, can be close with proper EVAL-FN.
EVAL-FN can be incorrect, search goes off in wrong direction.
Informed Search Methods
Different evaluation functions lead to different Best-First-Search algorithms
• Uniform Cost Search: EVAL-FN = g(n) = cost from start
node to current node
Function BEST-FIRST-SEARCH (problem, EVAL-FN) returns a solution sequence
Queuing-Fn a function that orders nodes by EVAL-FN
return GENERAL-SEARCH(problem,Queuing-Fn)
end
• Greedy Search: EVAL-FN = h(n) = estimated cost from current node to
goal node• A* Search: EVAL-FN = g(n) + h(n)
Best First Search
70
Informed Search MethodsGreedy Search Expand the node closest to goal. Must be estimated, cannot be exactly
determined. if we could calculate then we could directly find
shortest path to the goal.
Heuristic Functions Estimate the cost to the goal from current node.h(n) = estimated cost of cheapest path from current state (node n) to goal node.
The EVAL-FN = h(n)
Greedy SearchHeuristic: Straight-Line Distance (HSLD)
Fararas
Sibiu
Greedy SearchApply the Straight Line Distance Heuristic to go from Oradea to Bucharest
Fararas
380
253374
Oradea
Zerind Sibiu
Bucharest
151
99
211
176
0
The actual path cost based upon distance is: 151+99+211 = 461
Is this the shortest distance?
Greedy Search
RimnicuVilcea Fararas
Sibiu
Greedy SearchIs this the shortest path between Oradea to Bucharest?
Pitesti
Fararas
380
253374
Oradea
Zerind Sibiu
193
Bucharest
151
80 99
97211
101
176
0
100No, Rimnicu Vilcea will lead to the shortest distance: 151+80+97+101 = 429
Greedy SearchSimilarities to Depth-First Search Both tend to follow a single path to the
goal. If Greedy Search encounters a dead end, it will
back-up. Is the expansion of dead end nodes a problem?
Both are susceptible to false starts, and can get caught in infinite loops.
Depending on the heuristic, a large number of extra nodes may be generated.
Properties of Greedy search
Is Greedy search Complete?
How long does this method take to find a solution?
How much memory does this method require?
Is this method optimal?
Heuristic FunctionsWhat are Heuristic functions?
Heuristic: to find or to discover. Cost estimate to the goal from current
node. Not an exact method.
Generally only improves average case performance. Does not improve worst case performance.
A* SearchAn improved Best-First Search is A* Search.Expanding nodes that have low cost. g(n): cost so far to reach n from start
node. Chose nodes for expansion based on proximity to goal. h(n): estimated cost to goal from n.The Evaluation function
f(n) = g(n) + h(n) Estimated total cost of path from start to goal going through node n.
A* Searchfunction A*-SEARCH (problem) returns a solution or failure
return BEST-FIRST-SEARCH(problem, g+h)
end
RimnicuVilcea
Oradea
Bucharest
A* Search - Oradea to Bucharest
A* search generates an optimal solution if the heuristic satisfies certain conditions.
nnn – g(n)nnn – h(n)nnn – f(n)
Fararas
Sibiu
Pitesti
RimnicuVilcea
380
253374
Oradea
Sibiu
193
Bucharest
151
151+80=231151+99=250
231+80=311 231+97=328
328+101=429
176
0
100
Zerind
Arad Oradea
71
151+151=302151+140=291
SibiuCraiova 160
231+146=377
Pitesti
Craiova
328+138=466
366 380
253
160
71+374=445
151+253=404
291+366=657 302+380=682 231+193=424 250+176=426
311+253=564 328+100=428 377+160=537
466+160=626 429+0=429
0+380=380
445
657 682
380
404
424 426
564 428 537Sibiu
250+99=349
250+211=461
Bucharest 0253
461+0=461 349+253=602
Fararas
602461
A* SearchUses an admissibleadmissible heuristic i.e., h(n) h*(n), for all nodes n in state space h*(n)
then h(n) is the true cost of going from n to goal state. Admissible heuristics never overestimate the distance
to the goal. Examples
Path finding: straight line distance: hSLD
Eight Tiles: # of misplaced tiles A better heuristic: (Manhattan distance for each tile from its
true location) -- this is also an underestimate
Can proveCan prove A* algorithm is optimalA* algorithm is optimal It always finds an optimal solution, if a solution exists.
A* SearchDesirable properties of the evaluation function. Along any path from start node (root) the path
cost f(n) does not decrease. If this property is satisfied, the heuristic function
satisfies the monotonicitymonotonicity property. Monotonicity is linked to the consistency property.
Consistency: A heuristic h(n) is consistent if, for every node n and every successor n’ of n generated by any action a, the estimated cost of reaching the goal from n is no greater than the step cost of getting to n’ plus the estimated cost of reaching the goal from n’.
If monotonicity is satisfied, then it is an easy intuitive proof to demonstrate the optimality of A*.
)'()',,()( nhnancnh
Some conceptual questions?
Is uniform cost search a form of A* search?
Given two heuristics, h1(n) < h2(n) h*(n)
what can we say about the performance of A1* versus A2*?
A* SearchTheorem: If h is admissible, and there is a path of finite cost from the start node, n0 to the goal node, A* is guaranteed to terminate with a minimal-cost path to the goal.
A* SearchLemma: At every step before A* terminates, there is always a node, say n*, yet to be expanded with the following properties:
1)n* is an optimal path to goal2)f(n*) f(n0)Proof of lemma can be developed by
mathematical induction.
A* SearchPart of the proof. Suppose some suboptimal goal G2 has
been generated, and is in the queue. Let n be an unexpanded node from shortest path to optimal goal G1
Start
G2
n
GnsionexpaforGselectneverwillAnfGfSince
dmissibleais hsincenf
suboptimalisGsince)g(G
)h(G sinceGgGf
22
21
222
*),()(
:)(
:
0 :)()(
Optimality of A*• A* expands nodes in order of increasing f value (f(n) < C*)• This gradually adds f-contours of nodes (like BFS adds layers)• Contour i has all nodes with f = fi, where fi < fi+1
If B is the goalthen when the contouris the goal contour,f(n) = C*.
A more accurate heuristic will createbands that stretch towards the goal state and become more narrowly focused around the optimal path.
Properties of A*Is A* an optimal search?
What is the time complexity?
What are the space requirements?
Does A* find the best (highest quality) solution when there is more than one solution?
What is the “informed” aspect of A* search?
Memory Bounded SearchIterative deepening A* (IDA*) search Depth first search with an f-cost limit
rather than a depth limit. Each iteration expands all nodes inside the
contour of the current f-cost (f-cost(g + h)) If solution found, stop. Else, look over current contour to determine
where the next contour lies.
IDA* vs. A*IDA* generates roughly the same number of nodes as A*. For example, the 8 puzzle problem.but not always! For example, the traveling salesperson
problem. It is a memory bounded search.
IDA*
Performs well when the heuristic has only a few possible values.
IDA*Is IDA* complete?
What is the time complexity of IDA*?
What is the space complexity of IDA*?
Does the method find the best (highest quality) solution when there is more than one solution?
More on Informed Heuristics
Some facts about the 8-puzzle Total # arrangements = 9! = 362,880 Typical solution may take 22 steps Exhaustive search to depth 22 would look at 322 nodes 3.1 * 1010 states.
8-Puzzle HeuristicsTwo heuristics: h1(n) = # of misplaced tiles = 7
h2(n) = (Manhattan distance for each tile from
its true location)
= 2+3+3+2+4+2+0+2 = 18
Heuristic QualityEffective Branching Factor: b* The branching factor that a uniform tree of depth d
would have to have to contain N + 1 nodes. An A* search of depth 5 using 52 nodes requires a b*
of 1.92. 52 + 1 = 1 + b* + (b*)2 + (b*)3 + (b*)4 + (b*)5
53 = 1 + 1.92 + 3.68 + 7.07 + 13.58 + 26.09 Useful for determining the overall usefulness of a
heuristic by applying b* to a small set of problems.
Well-designed heuristics will have a b* value close to 1.
8-Puzzle HeuristicsReturning to the two heuristics: h1(n) = # of misplaced tiles = 7
h2(n) = (Manhattan distance for each tile from its true location)
= 2+3+3+2+4+2+0+2 = 18
Typical Search Costs: d = 14: IDS = more than 3,644,035 nodes; A*(h1) = 227 nodes;
A*(h2) = 73 nodes
d = 24: IDS = too many nodes; A*(h1) = 39,135 nodes;
A*(h2) = 1,641 nodes
HeuristicsGiven h1(n) < h2(n) h*(n), h2(n) always expands fewer nodes than h1(n) because it dominates h1(n). h2(n) h1(n)
Recall that an admissible heuristic never overestimates the value to the goal.Therefore, it is always better to use a heuristic [h2(n)] that dominates another heuristic [h1(n)]if: h2(n) does not overestimate. The computation time for h2(n) is not too long.
HeuristicsDefining a heuristic depends upon the particular problem domain. If the problem is a game, then the rules.
Multiple heuristics can be combined into one heuristic:h(n) = max{h1(n) … hx(n)}
Inductive learning can also be employed to develop a heuristic.
Sudoku Heuristics
Define at least one heuristic to incorporate into an A* search solution for Sudoku.
Local SearchLocal search is applicable to problems in which the final solution is all that matters, rather than the entire path. For example the Eight-queens problem.
Only care about the final configuration, not how it came about.
Search only looks at the local state and only moves to neighbors of that state. Paths to the current state are not maintained. Not a systematic search method, the others we have
discussed are systematic.
Local SearchAdvantages Minimal memory usage
Typically a constant amount. Can typically find reasonable solutions for
problems with large or continuous state spaces. Systematic algorithms are not suited to these
problems. Very good for optimization problems
where want to find the best possible state given the objective function.
State Space LandscapeHave a state and an elevation
Current State
Elevation = heuristic cost, then global minimumElevation = objective function, then global maximum
Local Search
Complete local searches always find a goal if one exists.
Optimal algorithms always find a global minimum or maximum.
Hill Climbing SearchHill Climbing Search requires the local search to choose the direction of the increasing value. The search terminates when there is no
neighbor with a higher value. Remember, no look ahead. Only know
about the immediate neighbors. If there is a set of multiple successors,
algorithm randomly chooses from the set.
Also called a Greedy Local Search.
Hill Climbing SearchAdvantage: often can rapidly find a solution.
Disadvantages: Easily becomes stuck Local Maxima: A peak that is higher than all it’s
neighbors but is lower than the Global Maxima. Ridges: A series of local maxima. Plateaus: An area where the elevation function
is flat. Can resolve by always moving in one particular
sideways direction but usually limit the number of consecutive sideways movements.
Algorithm success is very dependent upon the shape of the state-space landscape.
Hill Climbing Searchfunction HILL-CLIMBING (problem) returns a state that is a local maximum
local variables: current, a node
neighbor, a node
current MAKE-NODE(INITIAL-STATE[problem])
loop do
neighbor A highest-valued successor of current
if VALUE[neighbor] VALUE[current]
then return STATE[current]
current neighbor
end
VariationsStochastic hill climbing (SHC) Randomly chooses from the uphill
moves. Probability of selection can vary with
steepness of move.
First-Choice hill climbing Like SHC but randomly generates
successors until one is generated that is better than the current state.
Variations
Hill climbing algorithms discussed thus far are incomplete.
Random-restart hill climbing Multiple hill climbing searches from randomly
generated initial states. Will eventually randomly generate the goal.
Additional local search algorithms exist Simulated annealing Local beam search