Loading in 5 sec....

CS B551 : Elements of Artificial IntelligencePowerPoint Presentation

CS B551 : Elements of Artificial Intelligence

- 94 Views
- Uploaded on
- Presentation posted in: General

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

- Searching, data structures, and algorithms
- Breadth-first search
- Depth-first search
- Uniform-cost search

S

- State space S
- Successor function: x S SUCC(x) 2S
- Initial state s0
- Goal test:
xS GOAL?(x) =T or F

- Arc cost

- 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

- 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

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

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

- 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

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

- Breadth-first
- Bidirectional

- Depth-first
- Depth-limited
- Iterative deepening

- Uniform-Cost(variant of breadth-first)

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)

- 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

- 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

- b: branching factor
- d: depth of shallowest goal node
- Breadth-first search is:
- Complete? Not complete?
- Optimal? Not optimal?

- b: branching factor
- d: depth of shallowest goal node
- Breadth-first search is:
- Complete
- Optimal if step cost is 1

- Number of nodes generated:???

- b: branching factor
- d: depth of shallowest goal node
- Breadth-first search is:
- Complete
- Optimal if step cost is 1

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

- b: branching factor
- d: depth of shallowest goal node
- Breadth-first search is:
- 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)

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

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

- 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

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

- New nodes are inserted at the front of FRINGE

1

2

3

FRINGE = (2, 3)

4

5

- New nodes are inserted at the front of FRINGE

1

2

3

FRINGE = (4, 5, 3)

4

5

- New nodes are inserted at the front of FRINGE

1

2

3

4

5

- New nodes are inserted at the front of FRINGE

1

2

3

4

5

- New nodes are inserted at the front of FRINGE

1

2

3

4

5

- New nodes are inserted at the front of FRINGE

1

2

3

4

5

- New nodes are inserted at the front of FRINGE

1

2

3

4

5

- New nodes are inserted at the front of FRINGE

1

2

3

4

5

- New nodes are inserted at the front of FRINGE

1

2

3

4

5

- New nodes are inserted at the front of FRINGE

1

2

3

4

5

- New nodes are inserted at the front of FRINGE

1

- b: branching factor
- d: depth of shallowest goal node
- m: maximal depth of a leaf node
- Depth-first search is:
- Complete?
- Optimal?

- 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-first with depth cutoff k (depth at which nodes are not expanded)
- Three possible outcomes:
- Solution
- Failure (no solution)
- Cutoff (no solution within cutoff)

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

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

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

- d = 5 and b = 2

120/63 ~ 2

- d = 5 and b = 10

123,456/111,111 ~ 1.111

- 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

- Non-unit costs
- Revisited states
- Heuristic search

Why?

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

- Expand node in FRINGE with the cheapest path

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

8-puzzle and robot navigation

- Requires comparing state descriptions
- Breadth-first search:
- Store all states associated with generated nodes in VISITED
- If the state of a new node is in VISITED, then discard the node

- Requires comparing state descriptions
- Breadth-first search:
- 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

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

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

- 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

- ??

- Solution 1:

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

- Solution 1:

- 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#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.Add s to VISITED

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’

13.Otherwise discard N’’

14.INSERT(N’,FRINGE)

- Readings: R&N Ch. 3.5