Informed search
Download
1 / 56

Informed Search - PowerPoint PPT Presentation


  • 131 Views
  • Uploaded on

Informed Search. Russell and Norvig: Ch. 4.1 - 4.3 CSMSC 421 – Fall 2006. Outline. Informed = use problem-specific knowledge Which search strategies? Best-first search and its variants Heuristic functions? How to invent them Local search and optimization

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Informed Search' - libitha


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Informed search l.jpg

Informed Search

Russell and Norvig: Ch. 4.1 - 4.3

CSMSC 421 – Fall 2006


Outline l.jpg
Outline

  • Informed = use problem-specific knowledge

  • Which search strategies?

    • Best-first search and its variants

  • Heuristic functions?

    • How to invent them

  • Local search and optimization

    • Hill climbing, simulated annealing, local beam search,…


Previously graph search algorithm l.jpg
Previously: Graph search algorithm

function GRAPH-SEARCH(problem,fringe) return a solution or failure

closed an empty set

fringe INSERT(MAKE-NODE(INITIAL-STATE[problem]), fringe)

loop do

if EMPTY?(fringe) then return failure

node REMOVE-FIRST(fringe)

if GOAL-TEST[problem] applied to STATE[node] succeeds

then return SOLUTION(node)

if STATE[node] is not in closedthen

add STATE[node] to closed

fringe INSERT-ALL(EXPAND(node, problem), fringe)

A strategy is defined by picking the order of node expansion


Blind search l.jpg
Blind Search…

  • …[the ant] knew that a certain arrangement had to be made, but it could not figure out how to make it. It was like a man with a tea-cup in one hand and a sandwich in the other, who wants to light a cigarette with a match. But, where the man would invent the idea of putting down the cup and sandwich—before picking up the cigarette and the match—this ant would have put down the sandwich and picked up the match, then it would have been down with the match and up with the cigarette, then down with the cigarette and up with the sandwich, then down with the cup and up with the cigarette, until finally it had put down the sandwich and picked up the match. It was inclined to rely on a series of accidents to achieve its object. It was patient and did not think… Wart watched the arrangements with a surprise which turned into vexation and then into dislike. He felt like asking why it did not think things out in advance… T.H. White, The Once and Future King


Search algorithms l.jpg
Search Algorithms

  • Blind search – BFS, DFS, uniform cost

    • no notion concept of the “right direction”

    • can only recognize goal once it’s achieved

  • Heuristic search – we have rough idea of how good various states are, and use this knowledge to guide our search


Best first search l.jpg
Best-first search

  • General approach of informed search:

    • Best-first search: node is selected for expansion based on an evaluation function f(n)

  • Idea: evaluation function measures distance to the goal.

    • Choose node which appears best

  • Implementation:

    • fringe is queue sorted in decreasing order of desirability.

    • Special cases: Greedy search, A* search


Heuristic l.jpg
Heuristic

Webster's Revised Unabridged Dictionary (1913) (web1913)

Heuristic \Heu*ris"tic\, a. [Greek. to discover.] Serving to discover or find out.

The Free On-line Dictionary of Computing (15Feb98)

heuristic 1. <programming> A rule of thumb, simplification or educated guess that reduces or limits the search for solutions in domains that are difficult and poorly understood. Unlike algorithms, heuristics do not guarantee feasible solutions and are often used with no theoretical guarantee. 2. <algorithm> approximation algorithm.

From WordNet (r) 1.6

heuristic adj 1: (computer science) relating to or using a heuristic rule 2: of or relating to a general formulation that serves to guide investigation [ant: algorithmic] n : a commonsense rule (or set of rules) intended to increase the probability of solving some problem [syn: heuristic rule, heuristic program]


Informed search8 l.jpg
Informed Search

  • Add domain-specific information to select the best path along which to continue searching

  • Define a heuristic function, h(n), that estimates the “goodness” of a node n.

  • Specifically, h(n) = estimated cost (or distance) of minimal cost path from n to a goal state.

  • The heuristic function is an estimate, based on domain-specific information that is computable from the current state description, of how close we are to a goal


Greedy best first search l.jpg
Greedy Best-First Search

  • f(N) = h(N)  greedy best-first



Robot navigation11 l.jpg

8

7

6

5

4

3

2

3

4

5

6

7

5

4

3

5

6

3

2

1

0

1

2

4

7

6

5

8

7

6

5

4

3

2

3

4

5

6

Robot Navigation

f(N) = h(N), with h(N) = Manhattan distance to the goal


Robot navigation12 l.jpg
Robot Navigation

f(N) = h(N), with h(N) = Manhattan distance to the goal

8

7

6

5

4

3

2

3

4

5

6

7

5

4

3

5

0

6

3

2

1

0

1

2

4

What happened???

7

7

6

5

8

7

6

5

4

3

2

3

4

5

6


Greedy search l.jpg
Greedy Search

  • f(N) = h(N) Greedy best-first

  • Is it complete?

  • Is it optimal?

  • Time complexity?

  • Space complexity?


More informed search l.jpg
More informed search

  • We kept looking at nodes closer and closer to the goal, but were accumulating costs as we got further from the initial state

  • Our goal is not to minimize the distance from the current head of our path to the goal, we want to minimize the overall length of the path to the goal!

  • Let g(N) be the cost of the best path found so far between the initial node and N

  • f(N) = g(N) + h(N)  A*


A search l.jpg
A* search

  • Best-known form of best-first search.

  • Idea: avoid expanding paths that are already expensive.

  • Evaluation function f(n)=g(n) + h(n) A*

    • g(n) the cost (so far) to reach the node.

    • h(n) estimated cost to get from the node to the goal.

    • f(n) estimated total cost of path through n to goal.


Robot navigation16 l.jpg

3+8

2+9

4+7

5+6

3+8

8

7

6

5

4

3

2

3

4

5

6

7+2

7

5

4

3

5

6+1

8+3

6+1

6

3

2

1

0

1

2

4

7+2

7+0

6+1

7

6

5

8+1

6+1

8

7

6

5

4

3

2

3

4

5

6

2+9

3+8

7+2

2+9

3+10

4+5

1+10

4+7

5+4

3+6

2+7

8+3

7+4

5+6

6+3

2+9

3+8

4+5

3+6

2+7

6+5

7+4

0+11

1+10

4+7

3+8

5+6

6+3

7+2

5+4

6+3

Robot Navigation

f(N) = g(N)+h(N), with h(N) = Manhattan distance to goal

7+0

8+1


Can we prove anything l.jpg
Can we Prove Anything?

  • If the state space is finite and we avoid repeated states, the search is complete, but in general is not optimal

  • If the state space is finite and we do not avoid repeated states, the search is in general not complete

  • If the state space is infinite, the search is in general not complete


Admissible heuristic l.jpg
Admissible heuristic

  • Let h*(N) be the true cost of the optimal path from N to a goal node

  • Heuristic h(N) is admissible if: 0 h(N)  h*(N)

  • An admissible heuristic is always optimistic


Optimality of a standard proof l.jpg
Optimality of A*(standard proof)

  • Suppose suboptimal goal G2 in the queue.

  • Let n be an unexpanded node on a shortest to optimal goal G.

    f(G2 ) = g(G2 ) since h(G2 )=0

    > g(G) since G2 is suboptimal

    >= f(n) since h is admissible

    Since f(G2) > f(n), A* will never select G2 for expansion


But graph search l.jpg
BUT … graph search

  • Discards new paths to repeated state.

    • Previous proof breaks down

  • Solution:

    • Add extra bookkeeping i.e. remove more expensive of two paths.

    • Ensure that optimal path to any repeated state is always first followed.

      • Extra requirement on h(n): consistency (monotonicity)


Consistency l.jpg
Consistency

  • A heuristic is consistent if

  • If h is consistent, we have

    i.e. f(n) is nondecreasing along any path.


Optimality of a more useful l.jpg
Optimality of A*(more useful)

  • A* expands nodes in order of increasing f value

  • Contours can be drawn in state space

    • Uniform-cost search adds circles.

    • F-contours are gradually

      Added:

      1) nodes with f(n)<C*

      2) Some nodes on the goal

      Contour (f(n)=C*).

      Contour I has all

      Nodes with f=fi, where

      fi < fi+1.


A search evaluation l.jpg
A* search, evaluation

  • Completeness: YES

    • Since bands of increasing f are added

    • Unless there are infinitely many nodes with f<f(G)


A search evaluation24 l.jpg
A* search, evaluation

  • Completeness: YES

  • Time complexity:

    • Number of nodes expanded is still exponential in the length of the solution.


A search evaluation25 l.jpg
A* search, evaluation

  • Completeness: YES

  • Time complexity: (exponential with path length)

  • Space complexity:

    • It keeps all generated nodes in memory

    • Hence space is the major problem not time


A search evaluation26 l.jpg
A* search, evaluation

  • Completeness: YES

  • Time complexity: (exponential with path length)

  • Space complexity:(all nodes are stored)

  • Optimality: YES

    • Cannot expand fi+1 until fi is finished.

    • A* expands all nodes with f(n)< C*

    • A* expands some nodes with f(n)=C*

    • A* expands no nodes with f(n)>C*

      Also optimally efficient (not including ties)


Memory bounded heuristic search l.jpg
Memory-bounded heuristic search

  • Some solutions to A* space problems (maintain completeness and optimality)

    • Iterative-deepening A* (IDA*)

      • Here cutoff information is the f-cost (g+h) instead of depth

    • Recursive best-first search(RBFS)

      • Recursive algorithm that attempts to mimic standard best-first search with linear space.

    • (simple) Memory-bounded A* ((S)MA*)

      • Drop the worst-leaf node when memory is full


Recursive best first search l.jpg
Recursive best-first search

function RECURSIVE-BEST-FIRST-SEARCH(problem) return a solution or failure

return RFBS(problem,MAKE-NODE(INITIAL-STATE[problem]),∞)

function RFBS( problem, node, f_limit) return a solution or failure and a new f-cost limit

if GOAL-TEST[problem](STATE[node]) then return node

successors  EXPAND(node, problem)

ifsuccessors is empty then return failure, ∞

for eachsinsuccessorsdo

f [s]  max(g(s) + h(s), f [node])

repeat

best the lowest f-value node in successors

iff [best] > f_limitthen return failure, f [best]

alternative the second lowest f-value among successors

result, f [best]  RBFS(problem, best, min(f_limit, alternative))

ifresult failure then returnresult


Recursive best first search29 l.jpg
Recursive best-first search

  • Keeps track of the f-value of the best-alternative path available.

    • If current f-values exceeds this alternative f-value than backtrack to alternative path.

    • Upon backtracking change f-value to best f-value of its children.

    • Re-expansion of this result is thus still possible.


Rbfs evaluation l.jpg
RBFS evaluation

  • RBFS is a bit more efficient than IDA*

    • Still excessive node generation (mind changes)

  • Like A*, optimal if h(n) is admissible

  • Space complexity is O(bd).

    • IDA* retains only one single number (the current f-cost limit)

  • Time complexity difficult to characterize

    • Depends on accuracy if h(n) and how often best path changes.

  • IDA* and RBFS suffer from too little memory.


Simplified memory bounded a l.jpg
(simplified) memory-bounded A*

  • Use all available memory.

    • I.e. expand best leafs until available memory is full

    • When full, SMA* drops worst leaf node (highest f-value)

    • Like RFBS backup forgotten node to its parent

  • What if all leafs have the same f-value?

    • Same node could be selected for expansion and deletion.

    • SMA* solves this by expanding newest best leaf and deleting oldest worst leaf.

  • SMA* is complete if solution is reachable, optimal if optimal solution is reachable.


Heuristic functions l.jpg
Heuristic functions

  • E.g for the 8-puzzle

    • Avg. solution cost is about 22 steps (branching factor +/- 3)

    • Exhaustive search to depth 22: 3.1 x 1010 states.

    • A good heuristic function can reduce the search process.


Heuristic function l.jpg

1

2

3

4

5

6

7

8

5

8

4

2

1

7

3

6

Heuristic Function

  • Function h(N) that estimates the cost of the cheapest path from node N to goal node.

  • Example: 8-puzzle

h1(N) = number of misplaced tiles = 6

goal

N


Heuristic function34 l.jpg

1

2

3

4

5

6

7

8

5

8

4

2

1

7

3

6

Heuristic Function

  • Function h(N) that estimate the cost of the cheapest path from node N to goal node.

  • Example: 8-puzzle

h2(N) = sum of the distances of

every tile to its goal position

= 2 + 3 + 0 + 1 + 3 + 0 + 3 + 1

= 13

goal

N


8 puzzle l.jpg

3

3

4

5

3

4

2

4

2

1

3

3

0

4

5

4

8-Puzzle

f(N) = h1(N) = number of misplaced tiles


8 puzzle36 l.jpg

3+3

1+5

2+3

3+4

5+2

0+4

3+2

4+1

2+3

1+3

5+0

3+4

1+5

2+4

8-Puzzle

f(N) = g(N) + h(N)

with h1(N) = number of misplaced tiles


8 puzzle37 l.jpg

6

5

2

5

2

1

3

4

0

4

6

5

8-Puzzle

f(N) = h2(N) =  distances of tiles to goal


8 puzzle38 l.jpg

0+4

8-Puzzle

EXERCISE: f(N) = g(N) + h2(N)

with h2(N) =  distances of tiles to goal


Heuristic quality l.jpg
Heuristic quality

  • Effective branching factor b*

    • Is the branching factor that a uniform tree of depth d would have in order to contain N+1 nodes.

    • Measure is fairly constant for sufficiently hard problems.

      • Can thus provide a good guide to the heuristic’s overall usefulness.

      • A good value of b* is 1.


Heuristic quality and dominance l.jpg
Heuristic quality and dominance

  • 1200 random problems with solution lengths from 2 to 24.

  • If h2(n) >= h1(n) for all n (both admissible)

    then h2 dominates h1 and is better for search


Inventing admissible heuristics l.jpg
Inventing admissible heuristics

  • Admissible heuristics can be derived from the exact solution cost of a relaxed version of the problem:

    • Relaxed 8-puzzle for h1 : a tile can move anywhere

      As a result, h1(n) gives the shortest solution

    • Relaxed 8-puzzle for h2 : a tile can move to any adjacent square.

      As a result, h2(n) gives the shortest solution.

      The optimal solution cost of a relaxed problem is no greater than the optimal solution cost of the real problem.


Another approach local search l.jpg
Another approach… Local Search

  • Previously: systematic exploration of search space.

    • Path to goal is solution to problem

  • YET, for some problems path is irrelevant.

    • E.g 8-queens

  • Different algorithms can be used:Local Search

    • Hill-climbing or Gradient descent

    • Simulated Annealing

    • Genetic Algorithms, others…

  • Also applicable to optimization problems

    • systematic search doesn’t work

    • however, can start with a suboptimal solution and improve it


  • Local search and optimization l.jpg
    Local search and optimization

    • Local search= use single current state and move to neighboring states.

    • Advantages:

      • Use very little memory

      • Find often reasonable solutions in large or infinite state spaces.

    • Are also useful for pure optimization problems.

      • Find best state according to some objective function.



    Hill climbing search l.jpg
    Hill-climbing search

    • “is a loop that continuously moves in the direction of increasing value”

      • It terminates when a peak is reached.

    • Hill climbing does not look ahead of the immediate neighbors of the current state.

    • Hill-climbing chooses randomly among the set of best successors, if there is more than one.

    • Hill-climbing a.k.a. greedy local search

    • Some problem spaces are great for hill climbing and others are terrible.


    Hill climbing search46 l.jpg
    Hill-climbing search

    function HILL-CLIMBING(problem) return a state that is a local maximum

    input:problem, a problem

    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


    Robot navigation47 l.jpg
    Robot Navigation

    Local-minimum problem

    f(N) = h(N) = straight distance to the goal



    Drawbacks of hill climbing l.jpg
    Drawbacks of hill climbing

    • Problems:

      • Local Maxima: peaks that aren’t the highest point in the space

      • Plateaus: the space has a broad flat region that gives the search algorithm no direction (random walk)

      • Ridges: flat like a plateau, but with dropoffs to the sides; steps to the North, East, South and West may go down, but a combination of two steps (e.g. N, W) may go up.

    • Remedy:

      • Introduce randomness


    Hill climbing variations l.jpg
    Hill-climbing variations

    • Stochastic hill-climbing

      • Random selection among the uphill moves.

      • The selection probability can vary with the steepness of the uphill move.

    • First-choice hill-climbing

      • Stochastic hill climbing by generating successors randomly until a better one is found.

    • Random-restart hill-climbing

      • Tries to avoid getting stuck in local maxima.

      • If at first you don’t succeed, try, try again…


    Simulated annealing l.jpg
    Simulated annealing

    • Escape local maxima by allowing “bad” moves.

      • Idea: but gradually decrease their size and frequency.

    • Origin; metallurgical annealing

    • Bouncing ball analogy:

      • Shaking hard (= high temperature).

      • Shaking less (= lower the temperature).

    • If T decreases slowly enough, best state is reached.

    • Applied for VLSI layout, airline scheduling, etc.


    Simulated annealing52 l.jpg
    Simulated annealing

    function SIMULATED-ANNEALING( problem, schedule) return a solution state

    input:problem, a problem

    schedule, a mapping from time to temperature

    local variables: current, a node.

    next, a node.

    T, a “temperature” controlling the probability of downward steps

    current  MAKE-NODE(INITIAL-STATE[problem])

    for t  1 to ∞ do

    T  schedule[t]

    ifT = 0then returncurrent

    next a randomly selected successor of current

    ∆E VALUE[next] - VALUE[current]

    if∆E > 0 then current next

    elsecurrent next only with probability e∆E /T


    Simulated annealing53 l.jpg
    Simulated Annealing

    • applet

    • Successful application: circuit routing, traveling sales person (TSP)


    Local beam search l.jpg
    Local beam search

    • Keep track of k states instead of one

      • Initially: k random states

      • Next: determine all successors of k states

      • If any of successors is goal  finished

      • Else select k best from successors and repeat.

    • Major difference with random-restart search

      • Information is shared among k search threads.

    • Can suffer from lack of diversity.

      • Stochastic variant: choose k successors at proportionally to state success.


    When to use search techniques l.jpg
    When to Use Search Techniques?

    • The search space is small, and

      • There is no other available techniques, or

      • It is not worth the effort to develop a more efficient technique

    • The search space is large, and

      • There is no other available techniques, and

      • There exist “good” heuristics


    Summary informed search l.jpg
    Summary: Informed Search

    • Heuristics

    • Best-first Search Algorithms

      • Greedy Search

      • A*

        • Admissible heuristics

    • Constructing Heuristic functions

    • Local Search Algorithms


    ad