1 / 63

CS B551 : Elements of Artificial Intelligence

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

huyen
Télécharger la présentation

CS B551 : Elements of Artificial Intelligence

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CS B551: Elements of Artificial Intelligence Instructor: Kris Hauser http://cs.indiana.edu/~hauserk

  2. Agenda • Searching, data structures, and algorithms • Breadth-first search • Depth-first search • Uniform-cost search

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

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

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

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

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

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

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

  11. Blind Search Strategies

  12. Arc cost = 1 Arc cost = c(action) 0 Blind Strategies • Breadth-first • Bidirectional • Depth-first • Depth-limited • Iterative deepening • Uniform-Cost(variant of breadth-first)

  13. 1 2 3 4 5 6 7 Breadth-First Strategy • New nodes are inserted at the end of FRINGE FRINGE = (1)

  14. 1 2 3 4 5 6 7 Breadth-First Strategy • New nodes are inserted at the end of FRINGE FRINGE = (2, 3)

  15. 1 2 3 4 5 6 7 Breadth-First Strategy • New nodes are inserted at the end of FRINGE FRINGE = (3, 4, 5)

  16. 1 2 3 4 5 6 7 Breadth-First Strategy • New nodes are inserted at the end of FRINGE FRINGE = (4, 5, 6, 7)

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

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

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

  20. Evaluation • b: branching factor • d: depth of shallowest goal node • Breadth-first search is: • Complete • Optimal if step cost is 1 • Number of nodes generated: ???

  21. Evaluation • 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= ???

  22. Evaluation • 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)

  23. Time and Memory Requirements Assumptions: b = 10; 1,000,000 nodes/sec; 100bytes/node

  24. Time and Memory Requirements Assumptions: b = 10; 1,000,000 nodes/sec; 100bytes/node

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

  26. 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?

  27. 2 3 FRINGE = (1) 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

  28. 2 3 FRINGE = (2, 3) 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

  29. 2 3 FRINGE = (4, 5, 3) 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

  30. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

  31. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

  32. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

  33. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

  34. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

  35. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

  36. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

  37. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

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

  39. 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]

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

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

  42. Iterative Deepening

  43. Iterative Deepening

  44. Iterative Deepening

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

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

  47. Number of Generated Nodes (Breadth-First & Iterative Deepening) • d = 5 and b = 2 120/63 ~ 2

  48. Number of Generated Nodes (Breadth-First & Iterative Deepening) • d = 5 and b = 10 123,456/111,111 ~ 1.111

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

  50. Related Topics • Non-unit costs • Revisited states • Heuristic search

More Related