This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
can utilize the sort function requires a comparison function (evals to #t if input1 should come before input2)
climb-path takes the current path: if the current state (car of path) is the goal, then SUCCEED otherwise, get all possible moves and sort based on heuristic value (high to low) if no moves or "best" move is no better than current state, then FAIL otherwise, add "best" move to path and recurse
5
Hill-climbing in practice> (hill-climb 'Omaha 'LosAngeles)(losangeles denver omaha)
hill-climbing only works if the heuristic is accurate (i.e., distinguishes "closer" states) the path to the goal is direct (i.e., state improves on every move)
6
8-puzzle example
start state has 5 tiles in place1 2 3
8 6
7 5 4
hval = 5
457
368
21
457
68
321
57
468
321
hval = 4 hval = 6 hval = 6
457
628
31
457
68
321
47
658
321
hval = 4 hval = 4 hval = 5
of the 3 possible moves, 2 improve the situation
if assume left-to-right preference, move leads to a dead-end (no successor state improves the situation) so STOP!
heuristic(State) = # of tiles in place, including the space
7
Intuition behind hill-climbing
if you think of the state space as a topographical map (heuristic value = elevation), then hill-climbing selects the steepest gradient to move up towards the goal
potential dangers
plateau: successor states have same values, no way to choose
foothill: local maximum, can get stuck on minor peak
ridge: foothill where N-step lookahead might help
8
Hill-climbing variants
could generalize hill-climbing to continue even if the successor states look worse always choose best successor don't stop unless reach the goal or no successors
dead-ends are still possible (and likely if the heuristic is not perfect)
simulated annealing allow moves in the wrong direction on a probabilistic basis decrease the probability of a backward move as the search continues
idea: early in the search, when far from the goal, heuristic may not be good heuristic should improve as you get closer to the goal
approach is based on a metallurgical technique
9
Best first search
since bold, hill-climbing is dependent on a near-perfect heuristic
tentative & informed: best first search like breadth first search, keep track of all paths searched like hill-climbing, use heuristics to guide the search
always expand the "most promising" pathi.e., the path ending in a state with highest heuristic value
S1
S2 S3
hval = 0
hval = 20 hval =10
S4 S5hval = 5 hval = 8
S7hval = infinityGOAL
S6 hval = 3
10
Best first example 1 2 3
8 6
7 5 4hval = 5
457
628
31
457
68
321
47
658
321
hval = 4 hval = 4 hval = 5457
68
321
57
468
321
hval = 5 hval = 7
567
48
321
57
468
321
hval = 9 hval = 4
hval = 4 hval = 6 hval = 6457
368
21
457
68
321
57
468
321
NOTE:
breadth first = expand shortest path so farbest first = expand most promising path (according to heuristic)
only difference from BFS implementation: newly extended path list is sorted by heuristic value of end states (high-to-low) since new paths are added at end & sort is stable, ties will favor older/shorter paths
unlike hill-climbing, best first search can handle "dips" in the search not so dependent on a perfect heuristic
depth first search and breadth first search may be seen as special cases of best first searchDFS: heuristic value is distance (number of moves) from start state
BFS: heuristic value is inverse of distance (number of moves) from start state
or, procedurally:DFS: assign all states the same heuristic value
when adding new paths, add equal heuristic values at the front
BFS: assign all states the same heuristic value when adding new paths, add equal heuristic values at the end
15
Optimization problemsconsider a related search problem:
instead of finding the shortest path (i.e., fewest moves) to a solution, suppose we want to minimize some cost
EXAMPLE: airline travel problem• could associate costs with each flight, try to find the cheapest route• could associate distances with each flight, try to find the shortest route
we could use a strategy similar to breadth first search repeatedly extend the minimal cost path
search is guided by the cost of the path so far
but such a strategy ignores heuristic information would like to utilize a best first approach, but not directly applicable
search is guided by the remaining cost of the path
IDEAL: combine the intelligence of both strategies cost-so-far component of breadth first search (to optimize actual cost) cost-remaining component of best first search (to make use of heuristics)
16
Algorithm A
associate 2 costs with a pathg actual cost of the path so farh heuristic estimate of the remaining cost to the goal*f = g + h combined heuristic cost estimate
*note: the heuristic value is inverted relative to best first
Algorithm A: best first search using f as the heuristic
differences from best first search: put actual cost of path (sum of g's) at front of each path when path is extended, add cost of move to total path cost paths are sorted by (actual cost of path so far + H value for current state)
note: much more efficient to implement using graph, but more complex
20
Travel example
note: Algorithm A finds the path with least cost (here, distance)not necessarily the path with fewest steps
unlike best first search, takes total cost into account so guaranteed "cheapest" path
21
Algorithm A vs. hill-climbing
if the cost estimate function h is perfect, then f is a perfect heuristic Algorithm A is deterministic
S1
S2 S3
g = 0, h = 28f = 28
g = 10, h = 20f = 30
g = 20, h = 8f = 28
S4 S5g = 22, h = 6f = 28
g = 21, h = 12f = 33
X
10 20
2 1
10
G
6
g = 28, h = 0f = 28
X
20
X
2
if know actual costs for each state, Algorithm A reduces to hill-climbing
22
Admissibility
in general, actual costs are unknown at start – must rely on heuristics
if the heuristic is imperfect, NOT guaranteed to find an optimal solution
S1
S2 S3
g = 0, h = 2f = 2
g = 1, h = 4f = 5
g = 3, h = 1f = 4
1 3
X
1
G
1
g = 4, h = 0f = 4
if a control strategy is guaranteed to find an optimal solution (when a solution exists), we say it is admissibleif cost estimate h never overestimates actual cost, then Algorithm A is admissible(when admissible, Algorithm A is commonly referred to as Algorithm A*)
23
Heuristic examples
is our heuristic for the travel problem admissible?
h: crow-flies distance from Goal
8-puzzle heuristic?
h: number of tiles out of place, including the space
24
Cost of the search
the closer h is to the actual cost function, the fewer states considered however, the cost of computing h tends to go up as it improves
also, admissibility is not always needed or desired
Graceful Decay of Admissibility: If h rarely overestimates the actual cost by more than D, then Algorithm A will rarely find a solution whose cost exceeds optimal by more than D.
computationcost
closeness of h toactual cost
cost of solving problem
cost of computing h
cost of search using h
the best algorithm is one that minimizes the total cost of the solution
25
Flashlight example
consider the flashlight puzzle:Four people are on one side of a bridge. They wish to cross to the other side, but the bridge can only take the weight of two people at a time. It is dark and they only have one flashlight, so they must share it in order to cross the bridge. Assuming each person moves at a different speed (able to cross in 1, 2, 5 and 10 minutes, respectively), find a series of crossings that gets all four across in the minimal amount of time.
state representation?
cost of a move?
heuristic?
26
Flashlight implementation
state representation must identify the locations of each person and the flashlight
((1 2 5 10) left ())
note: must be careful of permutations e.g., (1 2 5 10) = (1 5 2 10) so must make sure there is only one representation per set
solution: maintain the lists in sorted order, so only one permutation is possible
only 3 possible moves:1. if the flashlight is on left and only 1 person on left, then
move that person to the right (cost is time it takes for that person)2. if flashlight is on left and at least 2 people on left, then
select 2 people from left and move them to right (cost is max time of the two)3. if the flashlight is on right, then
select a person from right and move them to left (cost is time for that person)
heuristic:h: number of people in wrong place
27
Flashlight code(define (GET-MOVES state) (define (generate-all-pairs lst) ;;; generates a list of all pairs of items from lst ) (define (make-each-move move-list) ;;; generates a list of all states obtainable from the current ;;; state by making a move from move-list )