1 / 64

Homework Policies: Individual Work, No Code Duplication, Serious Honor Code Violations

This document outlines the policies for completing homework assignments in CS B351: Intro to AI and Computer Simulation. It emphasizes the importance of individual work, prohibits code duplication, and warns students of the consequences of honor code violations.

charityc
Download Presentation

Homework Policies: Individual Work, No Code Duplication, Serious Honor Code Violations

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. Homework Policies • All work must be done individually • You may discuss the homework with others, but you may not duplicate their text or code, in whole or in part (e.g., changing variable names) • Honor code violations are taken very seriously!

  2. CS B351: Intro to AI and Computer Simulation Instructor: Kris Hauser http://cs.indiana.edu/~hauserk

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

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

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

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

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

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

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

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

  12. Blind Search Strategies

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  30. 2 3 FRINGE = (4, 5, 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. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

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

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

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

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

  43. Iterative Deepening

  44. Iterative Deepening

  45. Iterative Deepening

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

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

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

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

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

More Related