Searching the search space graph

1
Searching the search space graph

• 171 Class 3

2
Recap State-Space Formulation

• Intelligent agents problem solving as search
• Search consists of
• state space
• operators
• start state
• goal states
• The search graph
• A Search Tree is an effective way to represent
  the search process
• There are a variety of search algorithms,
  including
• Depth-First Search
• Breadth-First Search
• Others which use heuristic knowledge (in future
  lectures)

3
Uninformed search strategies

• Uninformed While searching you have no clue
  whether one non-goal state is better than any
  other. Your search is blind. You dont know if
  your current exploration is likely to be
  fruitful.
• Various blind strategies
• Breadth-first search
• Uniform-cost search
• Depth-first search
• Iterative deepening search

4
Breadth-first search

• Expand shallowest unexpanded node
• Fringe nodes waiting in a queue to be explored,
  also called OPEN
• Implementation
• fringe is a first-in-first-out (FIFO) queue,
  i.e., new successors go at end of the queue.

Is A a goal state?
5
Breadth-first search

• Expand shallowest unexpanded node
• Implementation
• fringe is a FIFO queue, i.e., new successors go
  at end

Expand fringe B,C Is B a goal state?
6
Breadth-first search

• Expand shallowest unexpanded node
• Implementation
• fringe is a FIFO queue, i.e., new successors go
  at end

Expand fringeC,D,E Is C a goal state?
7
Breadth-first search

• Expand shallowest unexpanded node
• Implementation
• fringe is a FIFO queue, i.e., new successors go
  at end

Expand fringeD,E,F,G Is D a goal state?
8
Example BFS
9
Example Map Navigation
S start, G goal, other nodes
intermediate states, links legal transitions
10
Initial BFS Search Tree
S

D
A

B
D
E
E
C
Note this is the search tree at some particular
point in in the search.
11
Breadth First Search Tree (BFS)
S
D
A
B
A
E
D
E
S
E
C
F
B
B
S
(Use the simple heuristic of not generating a
child node if that node is a parent to avoid
obvious loops this clearly does not avoid all
loops and there are other ways to do this)
12
What is the Complexity of Breadth-First Search?

• Time Complexity
• assume (worst case) that there is 1 goal leaf at
  the RHS
• so BFS will expand all nodes 1 b b2
  ......... bd O (bd)
• Space Complexity
• how many nodes can be in the queue (worst-case)?
• at depth d there are bd unexpanded nodes in the
  Q O (bd)
• Time and space of number of generated nodes is O
  (b(d1))

d0
d1
d2
G
d0
d1
d2
G
13
Examples of Time and Memory Requirements for
Breadth-First Search
Depth of Nodes Solution Expanded Time Memory
0 1 1 millisecond 100 bytes 2 111 0.1
seconds 11 kbytes 4 11,111 11 seconds 1
megabyte 8 108 31 hours 11 giabytes 12 1012
35 years 111 terabytes
Assuming b10, 1000 nodes/sec, 100 bytes/node
14
Depth-First-Search ()

• 1. Put the start node s on OPEN
• 2. If OPEN is empty exit with failure.
• 3. Remove the first node n from OPEN and place
  it on CLOSED.
• 4. If n is a goal node, exit successfully with
  the solution obtained by tracing back pointers
  from n to s.
• 5. Otherwise, expand n, generating all its
  successors attach to them pointers back to n,
  and put them at the top of OPEN in some order.
• 6. Go to step 2.

15
Breadth-First Search (BFS) Properties

• Complete
• Solution Length optimal
• (Can) expand each node once (if checks for
  duplicates)
• Search Time O(bd)
• Memory Required O(bd)
• Drawback requires exponential space

16
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe Last In First Out (LIPO) queue, i.e.,
  put successors at front

Is A a goal state?
17
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at front

queueB,C Is B a goal state?
18
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at front

queueD,E,C Is D goal state?
19
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at front

queueH,I,E,C Is H goal state?
20
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at front

queueI,E,C Is I goal state?
21
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at front

queueE,C Is E goal state?
22
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at front

queueJ,K,C Is J goal state?
23
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at front

queueK,C Is K goal state?
24
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at front

queueC Is C goal state?
25
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at front

queueF,G Is F goal state?
26
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at front

queueL,M,G Is L goal state?
27
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at front

queueM,G Is M goal state?
28
Example DFS
29
(No Transcript)
30
Search Method 2 Depth First Search (DFS)
S
D
A
B
D
E
C
Here, to avoid repeated states assume we dont
expand any child node which appears already in
the path from the root S to the parent. (Again,
one could use other strategies)
F
D
G
31
Depth-First-Search ()

• 1. Put the start node s on OPEN
• 2. If OPEN is empty exit with failure.
• 3. Remove the first node n from OPEN and place
  it on CLOSED.
• 4. If n is a goal node, exit successfully with
  the solution obtained by tracing back pointers
  from n to s.
• 5. Otherwise, expand n, generating all its
  successors attach to them pointers back to n,
  and put them at the top of OPEN in some order.
• 6. Go to step 2.

32
What is the Complexity of Depth-First Search?
d0

• Time Complexity
• assume (worst case) that there is 1 goal leaf at
  the RHS
• so DFS will expand all nodes(m is cutoff) 1
  b b2 ......... bm O (bm)
  
• Space Complexity
• how many nodes can be in the queue (worst-case)?
• at depth l lt d we have b-1 nodes
• at depth d we have b nodes
• total (m-1)(b-1) b O(bm)

d1
d2
G
d0
d1
d2 d3 d4

33
Repeated states

• Failure to detect repeated states can turn a
  linear problem into an exponential one!

34
Solutions to repeated states
S
B
S
B
C
C
S
C
B
S
State Space
Example of a Search Tree

• Method 1
• do not create paths containing cycles (loops)
• Method 2
• never generate a state generated before
• must keep track of all possible states (uses a
  lot of memory)
• e.g., 8-puzzle problem, we have 9! 362,880
  states
• Method 1 is most practical, work well on most
  problems

35
Depth-First Search (DFS) Properties

• Non-optimal solution path
• Incomplete unless there is a depth bound
• Reexpansion of nodes,
• Exponential time
• Linear space

36
Properties of depth-first search
A

• Complete? No fails in infinite-depth spaces
• Can modify to avoid repeated states along path
• Time? O(bm) with mmaximum depth
• terrible if m is much larger than d
• but if solutions are dense, may be much faster
  than
• breadth-first
• Space? O(bm), i.e., linear space! (we only need
  to
• remember a single path expanded unexplored
  nodes)
• Optimal? No (It may find a non-optimal goal first)

B
C
37
Comparing DFS and BFS

• Same worst-case time Complexity, but
• In the worst-case BFS is always better than DFS
• Sometime, on the average DFS is better if
• many goals, no loops and no infinite paths
• BFS is much worse memory-wise
• DFS is linear space
• BFS may store the whole search space.
• In general
• BFS is better if goal is not deep, if infinite
  paths, if many loops, if small search space
• DFS is better if many goals, not many loops,
• DFS is much better in terms of memory

38
Iterative Deepening (DFS)

• Every iteration is a DFS with a depth cutoff.
• Iterative deepening (ID)
• i 1
• While no solution, do
• DFS from initial state S0 with cutoff i
• If found goal, stop and return solution, else,
  increment cutoff
• Comments
• ID implements BFS with DFS
• Only one path in memory
• BFS at step i may need to keep 2i nodes in OPEN

39
Iterative deepening search L0
40
Iterative deepening search L1
41
Iterative deepening search L2
42
Iterative Deepening Search L3
43
Iterative deepening search
44
Properties of iterative deepening search

• Complete? Yes
• Time? O(bd)
• Space? O(bd)
• Optimal? Yes, if step cost 1 or increasing
  function of depth.

45
Iterative Deepening Time (DFS)

• Time

• BFS time is O(bn)
• b is the branching degree
• ID is asymptotically like BFS
• For b10 d5 dcut-off
• DFS 110100,,111,111
• IDS 123,456
• Ratio is

46
Comments on Iterative Deepening Search

• Complexity
• Space complexity O(bd)
• (since its like depth first search run different
  times)
• Time Complexity
• 1 (1b) (1 bb2) .......(1 b....bd)
• O(bd) (i.e., asymptotically the same as BFS
  or DFS in the worst case)
• The overhead in repeated searching of the same
  subtrees is small relative to the overall time
• e.g., for b10, only takes about 11 more time
  than BFS
• A useful practical method
• combines
• guarantee of finding an optimal solution if one
  exists (as in BFS)
• space efficiency, O(bd) of DFS
• But still has problems with loops like DFS

47
Bidirectional Search

• Idea
• Simultaneously search forward from S and
  backwards from G
• stop when both meet in the middle
• need to keep track of the intersection of 2 open
  sets of nodes
• What does searching backwards from G mean
• need a way to specify the predecessors of G
• this can be difficult,
• e.g., predecessors of checkmate in chess?
• what if there are multiple goal states?
• what if there is only a goal test, no explicit
  list?
• Complexity
• time complexity is best O(2 b(d/2)) O(b
  (d/2)), worst O(bd1)
• memory complexity is the same

48
Bi-Directional Search
49
Uniform Cost Search

• Expand lowest-cost OPEN node (g(n))
• In BFS g(n) depth(n)

• Requirement
• g(successor)(n)) ? g(n)

50
Find minimum cost path
The graph above shows the step-costs for
different paths going from the start (S) to the
goal (G). On the right you find the straight-line
distances. Use uniform cost search to find
the optimal path to the goal.
51
Uniform cost search

• 1. Put the start node s on OPEN
• 2. If OPEN is empty exit with failure.
• 3. Remove the first node n from OPEN and place
  it on CLOSED.
• 4. If n is a goal node, exit successfully with
  the solution obtained by tracing back pointers
  from n to s.
• 5. Otherwise, expand n, generating all its
  successors attach to them pointers back to n,
  and put them at the end of OPEN in order of
  shortest cost
• Go to step 2.

52
Uniform cost search

• 1. Put the start node s on OPEN
• 2. If OPEN is empty exit with failure.
• 3. Remove the first node n from OPEN and place
  it on CLOSED.
• 4. If n is a goal node, exit successfully with
  the solution obtained by tracing back pointers
  from n to s.
• 5. Otherwise, expand n, generating all its
  successors attach to them pointers back to n,
  and put them at the end of OPEN in order of
  shortest cost
• Go to step 2.

DFS Branch and Bound
At step 4 compute the cost of the solution
found and update the upper bound U. at step 5
expand n, generating all its successors attach to
them pointers back to n, and put last in OPEN.
Compute cost of partial path to node and prune
if larger than U. .
53
Uniform-cost search

• Breadth-first is only optimal if step costs is
  increasing with depth (e.g. constant). Can we
  guarantee optimality for any step cost?
• Uniform-cost Search Expand node with
• 
  smallest path cost g(n).

54
Uniform-cost search
Implementation fringe queue ordered by path
cost Equivalent to breadth-first if all step
costs all equal. Complete? Yes, if step cost e
(otherwise it can get stuck
in infinite loops) Time? of nodes with path
cost cost of optimal solution. Space? of
nodes on paths with path cost cost of optimal

solution. Optimal?
Yes, for any step cost.
55
Comparison of Algorithms
56
Summary

• Problem formulation usually requires abstracting
  away real-world details to define a state space
  that can feasibly be explored
• Variety of uninformed search strategies
• Iterative deepening search uses only linear space
  and not much more time than other uninformed
  algorithms

http//www.cs.rmit.edu.au/AI-Search/Product/ http
//aima.cs.berkeley.edu/demos.html (for more
demos)
57
Summary

• A review of search
• a search space consists of states and operators
  it is a graph
• a search tree represents a particular exploration
  of search space
• There are various strategies for uninformed
  search
• breadth-first
• depth-first
• iterative deepening
• bidirectional search
• Uniform cost search
• Depth-first branch and bound
• Repeated states can lead to infinitely large
  search trees
• we looked at methods for for detecting repeated
  states
• All of the search techniques so far are blind
  in that they do not look at how far away the goal
  may be next we will look at informed or
  heuristic search, which directly tries to
  minimize the distance to the goal. Example we
  saw greedy search

58
straight-line distances
6
1
A
D
F
1
3
h(S-G)10 h(A-G)7 h(D-G)1 h(F-G)1 h(B-G)10 h(E
-G)8 h(C-G)20
2
4
8
S
G
B
E
1
20
C
The graph above shows the step-costs for
different paths going from the start (S) to the
goal (G). On the right you find the straight-line
distances. Use uniform cost search to find
the optimal path to the goal.
Exercise for at home