Lecture 3 uninformed search
This presentation is the property of its rightful owner.
Sponsored Links
1 / 32

Lecture 3: Uninformed Search PowerPoint PPT Presentation


  • 91 Views
  • Uploaded on
  • Presentation posted in: General

Lecture 3: Uninformed Search. ICS 270a Winter 2003. Summary. Uninformed Blind search Breadth-first uniform first depth-first Iterative deepening depth-first Bidirectional Branch and Bound Informed Heuristic search (next class) Greedy search, hill climbing, Heuristics

Download Presentation

Lecture 3: Uninformed Search

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


Lecture 3 uninformed search

Lecture 3: Uninformed Search

ICS 270a Winter 2003


Summary

Summary

  • Uninformed Blind search

    • Breadth-first

    • uniform first

    • depth-first

    • Iterative deepening depth-first

    • Bidirectional

    • Branch and Bound

  • Informed Heuristic search (next class)

    • Greedy search, hill climbing, Heuristics

  • Important concepts:

    • Completeness

    • Time complexity

    • Space complexity

    • Quality of solution


Graph and tree notations

Graph and Tree notations


Search tree notation

Search Tree Notation

  • Branching degree, b

    • b is the number of children of a node

  • Depth of a node, d

    • number of branches from root to a node

  • Arc weight, Cost of a path

  • n  n’ , n parent node of n’, a child node

  • Node generation

  • Node expansion

  • Search policy:

    • determines the order of nodes expansion

  • Two kinds of nodes in the tree

    • Open Nodes (Fringe)

      • nodes which are not expanded (i.e., the leaves of the tree)

    • Closed Nodes

      • nodes which have already been expanded (internal nodes)

d = Depth

0

1

2

S

b=2

G


Example map navigation

B

C

A

G

S

D

F

E

Example: Map Navigation

S = start, G = goal, other nodes = intermediate states, links = legal transitions


Example of a search tree

Example of a Search Tree

S

D

A

D

B

E

E

C

Note: this is the search tree at some particular point in

in the search.


Search method 1 breadth first search

Search Method 1: Breadth First Search

S

D

A

B

A

E

D

S

E

E

C

F

S

B

B

(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)


Breadth first search

Breadth-First Search


Breadth first search1

Breadth-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 end of OPEN in some order.

  • Go to step 2.

    For Shortest path or uniform cost:

    5’ Otherwise, expand n, generating all its successors attach to them pointers back to n, and put them in OPEN in order of shortest cost path.

    * This simplified version does not check for loops


Lecture 3 uninformed search

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-1 there are bd unexpanded nodes in the Q = O (bd)

d=0

d=1

d=2

G

d=0

d=1

d=2

G


Examples of time and memory requirements for breadth first search

Examples of Time and Memory Requirements for Breadth-First Search

Depth of Nodes

SolutionExpandedTimeMemory

011 millisecond100 bytes

21110.1 seconds11 kbytes

411,11111 seconds1 megabyte

810831 hours11 giabytes

12101235 years111 terabytes

Assuming b=10, 1000 nodes/sec, 100 bytes/node


Breadth first search bfs properties

Breadth-First Search (BFS) Properties

  • Solution Length: optimal

  • Generates every node just once

  • Search Time: O(Bd)

  • Memory Required: O(Bd)

  • Drawback: require exponential space

1

2

3

7

4

6

5

8

9

10

11

12

13

14

15


Search method 2 depth first search dfs

Search Method 2: Depth First Search (DFS)

S

D

A

B

D

E

C

Here, to avoid repeated states assume we don’t 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


Depth first search

Depth-First Search


Depth first search1

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.


What is the complexity of depth first search

What is the Complexity of Depth-First Search?

  • Time Complexity

    • assume (worst case) that there is 1 goal leaf at the RHS

    • so DFS will expand all nodes =1 + b + b2+ ......... + bd = O (bd)

  • Space Complexity

    • how many nodes can be in the queue (worst-case)?

    • at depth l < d we have b-1 nodes

    • at depth d we have b nodes

    • total = (d-1)*(b-1) + b = O(bd)

d=0

d=1

d=2

G

d=0

d=1

d=2

d=3

d=4


Techniques for avoiding repeated states

Techniques for Avoiding Repeated States

S

  • 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

B

S

B

C

C

C

S

B

S

State Space

Example of a Search Tree


Example diamond networks

Example, diamond networks


Depth first search dfs properties

Depth-First Search (DFS) Properties

  • Non-optimal solution path

  • Incomplete unless there is a depth bound

  • Reexpansion of nodes,

  • Exponential time

  • Linear space


Comparing dfs and bfs

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


  • Iterative deepening dfs

    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


    Iterative deepening search

    Iterative deepening search


    Comments on iterative deepening search

    Comments on Iterative Deepening Search

    • Complexity

      • Space complexity = O(bd)

        • (since its like depth first search run different times)

      • Time Complexity

        • 1 + (1+b) + (1 +b+b2) + .......(1 +b+....bd)

        • = O(bd) (i.e., asymptotically the same as BFS or DFS in the the worst case)

        • The overhead in repeated searching of the same subtrees is small relative to the overall time

          • e.g., for b=10, only takes about 11% more time than DFS

    • 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


    Iterative deepening dfs1

    Iterative Deepening (DFS)

    • Time:

    • BFS time is O(bn)

    • B is the branching degree

    • ID is asymptotically like BFS

    • For b=10 d=5 d=cut-off

    • DFS = 1+10+100,…,=111,111

    • IDS = 123,456

    • Ratio is


    Bidirectional search

    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(bd+1)

      • memory complexity is the same


    Bi directional search

    Bi-Directional Search


    Bi directional search continued

    Bi-Directional Search (continued)


    Uniform cost search

    Uniform Cost Search

    • Expand lowest-cost OPEN node (g(n))

    • In BFS g(n) = depth(n)

    • Requirement

      • g(successor)(n))  g(n)


    Uniform cost search1

    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 in OPEN in order of shortest cost.

    Compute cost of paretial path to node and prune if larger than U.

    .


    Comparison of algorithms

    Comparison of Algorithms


    Summary1

    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


  • Login