# CS B551 : Elements of Artificial Intelligence - PowerPoint PPT Presentation

1 / 63

CS B551 : Elements of Artificial Intelligence. Instructor: Kris Hauser http://cs.indiana.edu/~hauserk. Agenda. Searching, data structures, and algorithms Breadth-first search Depth-first search Uniform-cost search. Defining a Search Problem. S. State space S

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

CS B551 : Elements of Artificial Intelligence

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

## CS B551: Elements of Artificial Intelligence

Instructor: Kris Hauser

http://cs.indiana.edu/~hauserk

### Agenda

• Searching, data structures, and algorithms

• Depth-first search

• Uniform-cost search

### Defining a Search Problem

S

• State space S

• Successor function: x  S  SUCC(x)  2S

• Initial state s0

• Goal test:

xS GOAL?(x) =T or F

• Arc cost

### State Graph

• Each state is represented by a distinct node

• An arc (or edge) connects a node s to a node s’ if s’ SUCC(s)

• The state graph may contain more than one connected component

I

### Solution to the Search Problem

• A solution is a path connecting the initial node to a goal node (any one)

• The cost of a path is the sum of the arc costs along this path

• An optimal solution is a solution path of minimum cost

• There might be no solution !

G

8

8

2

2

8

2

7

3

3

4

4

7

7

3

4

5

5

1

1

6

6

5

1

6

8

2

3

4

7

8

2

8

4

2

3

4

7

3

7

5

1

6

5

1

6

5

1

6

### Search Graph!= State Graph

If states are allowed to be revisited,the search tree may be infinite even

when the state space is finite

8

2

PARENT-NODE

3

4

7

BOOKKEEPING

5

1

6

STATE

CHILDREN

Action

Right

Depth

5

...

Path-Cost

5

yes

Expanded

### Search Graph Node != State

Depth of a node N = length of path from root to N

(depth of the root = 0)

8

2

8

2

7

3

4

7

3

4

5

1

6

5

1

6

### Fringe of Search Tree

• The fringe is the set of all search nodes that haven’t been expanded yet

8

2

3

4

7

5

1

6

8

2

7

3

4

5

1

6

8

2

8

2

3

4

7

3

4

7

5

1

6

5

1

6

### Search Strategy

• The fringe is the set of all search nodes that haven’t been expanded yet

• The fringe is implemented as a priority queue FRINGE

• INSERT(node,FRINGE)

• REMOVE(FRINGE)

• The ordering of the nodes in FRINGE defines the search strategy

### Search Algorithm #1

SEARCH#1

1. If GOAL?(initial-state) then return initial-state

2. INSERT(initial-node,FRINGE)

3.Repeat:

4.If empty(FRINGE) then return failure

5.N REMOVE(FRINGE)

6.s  STATE(N)

7.For every state s’ in SUCCESSORS(s)

8.Create a new node N’ as a child of N

9.If GOAL?(s’) then return path or goal state

10.INSERT(N’,FRINGE)

Expansion of N

## Blind Search Strategies

Arc cost = 1

Arc cost

= c(action) 0

### Blind Strategies

• Bidirectional

• Depth-first

• Depth-limited

• Iterative deepening

1

2

3

4

5

6

7

• New nodes are inserted at the end of FRINGE

FRINGE = (1)

1

2

3

4

5

6

7

• New nodes are inserted at the end of FRINGE

FRINGE = (2, 3)

1

2

3

4

5

6

7

• New nodes are inserted at the end of FRINGE

FRINGE = (3, 4, 5)

1

2

3

4

5

6

7

• New nodes are inserted at the end of FRINGE

FRINGE = (4, 5, 6, 7)

### Performance Measures

• CompletenessA search algorithm is complete if it finds a solution whenever one exists[What about the case when no solution exists?]

• OptimalityA search algorithm is optimal if it returns a minimum-cost path whenever a solution exists

• ComplexityIt measures the time and amount of memory required by the algorithm

### Important Parameters

• Maximum number of successors of any state branching factor b of the search tree

• Minimal length (≠ cost) of a path between the initial and a goal state depth d of the shallowest goal node in the search tree

### Evaluation

• b: branching factor

• d: depth of shallowest goal node

• Complete? Not complete?

• Optimal? Not optimal?

### Evaluation

• b: branching factor

• d: depth of shallowest goal node

• Complete

• Optimal if step cost is 1

• Number of nodes generated:???

### Evaluation

• b: branching factor

• d: depth of shallowest goal node

• Complete

• Optimal if step cost is 1

• Number of nodes generated: 1 + b + b2 + … + bd= ???

### Evaluation

• b: branching factor

• d: depth of shallowest goal node

• Complete

• Optimal if step cost is 1

• Number of nodes generated: 1 + b + b2+ … + bd = (bd+1-1)/(b-1) = O(bd)

•  Time and space complexity is O(bd)

### Time and Memory Requirements

Assumptions: b = 10; 1,000,000 nodes/sec; 100bytes/node

### Time and Memory Requirements

Assumptions: b = 10; 1,000,000 nodes/sec; 100bytes/node

1

1

2

2

3

3

4

4

5

5

6

6

7

7

8

8

9

9

10

10

11

11

12

12

?

13

13

14

15

15

14

### Remark

• If a problem has no solution, breadth-first may run forever (if the state space is infinite or states can be revisited arbitrary many times)

s

### Bidirectional Strategy

2 fringe queues: FRINGE1 and FRINGE2

Time and space complexity isO(bd/2)  O(bd) if both trees have the same branching factor b

Question: What happens if the branching factor is different in each direction?

2

3

FRINGE = (1)

4

5

### Depth-First Strategy

• New nodes are inserted at the front of FRINGE

1

2

3

FRINGE = (2, 3)

4

5

### Depth-First Strategy

• New nodes are inserted at the front of FRINGE

1

2

3

FRINGE = (4, 5, 3)

4

5

### Depth-First Strategy

• New nodes are inserted at the front of FRINGE

1

2

3

4

5

### Depth-First Strategy

• New nodes are inserted at the front of FRINGE

1

2

3

4

5

### Depth-First Strategy

• New nodes are inserted at the front of FRINGE

1

2

3

4

5

### Depth-First Strategy

• New nodes are inserted at the front of FRINGE

1

2

3

4

5

### Depth-First Strategy

• New nodes are inserted at the front of FRINGE

1

2

3

4

5

### Depth-First Strategy

• New nodes are inserted at the front of FRINGE

1

2

3

4

5

### Depth-First Strategy

• New nodes are inserted at the front of FRINGE

1

2

3

4

5

### Depth-First Strategy

• New nodes are inserted at the front of FRINGE

1

2

3

4

5

### Depth-First Strategy

• New nodes are inserted at the front of FRINGE

1

### Evaluation

• b: branching factor

• d: depth of shallowest goal node

• m: maximal depth of a leaf node

• Depth-first search is:

• Complete?

• Optimal?

### Evaluation

• b: branching factor

• d: depth of shallowest goal node

• m: maximal depth of a leaf node

• Depth-first search is:

• Complete only for finite search tree

• Not optimal

• Number of nodes generated (worst case): 1 + b + b2+ … + bm = O(bm)

• Time complexity is O(bm)

• Space complexity is O(bm) [or O(m)]

• [Reminder: Breadth-first requires O(bd) time and space]

### Depth-Limited Search

• Depth-first with depth cutoff k (depth at which nodes are not expanded)

• Three possible outcomes:

• Solution

• Failure (no solution)

• Cutoff (no solution within cutoff)

### Iterative Deepening Search

• Provides the best of both breadth-first and depth-first search

• Main idea:

Totally horrifying !

IDS

For k = 0, 1, 2, … do:

Perform depth-first search with depth cutoff k

(i.e., only generate nodes with depth  k)

### Performance

• Iterative deepening search is:

• Complete

• Optimal if step cost =1

• Time complexity is: (d+1)(1) + db + (d-1)b2 + … + (1) bd= O(bd)

• Space complexity is: O(bd) or O(d)

### Calculation

db + (d-1)b2 + … + (1) bd

=bd+2bd-1 +3bd-2 +… +db

= (1 + 2b-1 + 3b-2 + … + db-d)bd

 (Si=1,…,ib(1-i))bd = bd(b/(b-1))2

### Number of Generated Nodes (Breadth-First & Iterative Deepening)

• d = 5 and b = 2

120/63 ~ 2

### Number of Generated Nodes (Breadth-First & Iterative Deepening)

• d = 5 and b = 10

123,456/111,111 ~ 1.111

### Recap

• BFS: Complete, optimal

• O(bd) time and space

• DFS: Not complete nor optimal

• O(bd) space, unbounded time

• ID: Complete, optimal

• O(bd) space, O(bd) time

### Related Topics

• Non-unit costs

• Revisited states

• Heuristic search

Why?

### Non-unit Costs

• Each arc has cost c  > 0

• The cost of the path to each node N is g(N) =  costs of arcs

• Breadth-first is no longer optimal

A

S

1

10

0

S

B

G

5

5

A

B

C

5

1

5

15

C

15

G

G

10

11

Suboptimal path!

### Uniform-Cost Search

• Expand node in FRINGE with the cheapest path

### Search Algorithm #2

The goal test is applied

to a node when this node is

expanded, not when it is

generated.

SEARCH#2

1. If GOAL?(initial-state) then return initial-state

2. INSERT(initial-node,FRINGE)

3.Repeat:

4.If empty(FRINGE) then return failure

5.N REMOVE(FRINGE)

6.s  STATE(N)

7.If GOAL?(s) then return path or goal state

8.For every state s’ in SUCCESSORS(s)

9.Create a new node N’ as a child of N

10.INSERT(N’,FRINGE)

No

Few

Many

search tree is infinite

search tree is finite

1

2

3

4

5

assembly planning

7

8

6

8-queens

### Avoiding Revisited States

• Requires comparing state descriptions

• Store all states associated with generated nodes in VISITED

• If the state of a new node is in VISITED, then discard the node

### Avoiding Revisited States

• Requires comparing state descriptions

• Store all states associated with generated nodes in VISITED

• If the state of a new node is in VISITED, then discard the node

Implemented as hash-table

or as explicit data structure with flags

### Explicit Data Structures

• VISITED: array initialized to 0, matching grid

• When grid position (x,y) is visited, mark corresponding position in VISITED as 1

• Size of the entire state space!

8

2

3

4

7

5

1

6

1

2

3

4

5

7

8

6

### Hash Tables

VISITED: Hash table of size N

0

1

2

N-1

Hash function: map from S to {0,…,N-1}

If hash function is chosen carefully to minimize chance of collision, then membership testing on M states averages O(M/N) time

### Avoiding Revisited States

• Depth-first search:

• Solution 1:

• Store all states associated with nodes in current path in VISITED

• If the state of a new node is in VISITED, then discard the node

• ??

### Avoiding Revisited States

• Depth-first search:

• Solution 1:

• Store all states associated with nodes in current path in VISITED

• If the state of a new node is in VISITED, then discard the node

• Only avoids loops

• Solution 2:

• Store all generated states in VISITED

• If the state of a new node is in VISITED, then discard the node

• Same space complexity as breadth-first !

### Avoiding Revisited States in Uniform-Cost Search

• For any state S, when the first node N such that STATE(N) = S is expanded, the path to N is the best path from the initial state to S

• So:

• When a node is expanded, store its state into VISITED

• When a new node N is generated:

• If STATE(N) is in VISITED, discard N

• If there exits a node N’ in the fringe such that STATE(N’) = STATE(N), discard the node -- N or N’ -- with the highest-cost path

### Search Algorithm #3

SEARCH#3

1. If GOAL?(initial-state) then return initial-state

2. INSERT(initial-node,FRINGE)

3.Repeat:

4.If empty(FRINGE) then return failure

5.N REMOVE(FRINGE)

6.s  STATE(N)

7.If GOAL?(s) then return path or goal state

8.For every state s’ in SUCCESSORS(s)

9.Create a new node N’ as a child of N

10.If s’ is in VISITED then discard N’

11.If there is N’’ in FRINGE with STATE(N’)=STATE(N’’)

12. If g(N’’) is lower than g(N’) then discard N’