1 / 135

Solving Problems by Searching

Solving Problems by Searching. Foundations for Uninformed Search Methods. Literature. S. Russell and P. Norvig. Artificial Intelligence: A Modern Approach , chapter 3. Prentice Hall, 2 nd edition, 2003.

Download Presentation

Solving Problems by Searching

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. Solving Problems by Searching Foundations for Uninformed Search Methods

  2. Literature • S. Russell and P. Norvig. Artificial Intelligence: A Modern Approach, chapter 3. Prentice Hall, 2nd edition, 2003. • S. Amarel. On Representations of Problems of Reasoning about Actions. In: D. Michie ,editor, Machine Intelligence 3, pages 131-171, Edinburgh University Press, 1968. Reprinted in: B. Webber and N. Nilsson ,editors, Readings in Artificial Intelligence, pages 2-22, Tioga, 1981. • N. Nilsson. Principles of Artificial Intelligence, chapters 1-2. Springer, 1982. Solving Problems by Searching

  3. Overview • Characterizing Search Problems • Searching for Solutions • Uninformed Search Strategies • Avoiding Repeated States • The Problem of Representation • Search in AND/OR-Graphs • Searching with Partial Information Solving Problems by Searching

  4. Problems of Reasoning about Actions • aim: find a course of actions that satisfies a number of specified conditions • examples: • planning an airplane trip • planning a dinner party Solving Problems by Searching

  5. Toy Problems concise and exact description used for illustration purposes (e.g. here) used for performance comparisons Real-World Problems no single, agreed-upon description people care about the solutions Toy Problems vs.Real-World Problems Solving Problems by Searching

  6. Toy Problem: Missionaries and Cannibals On one bank of a river are three missionaries (black triangles) and three cannibals (red circles). There is one boat available that can hold up to two people and that they would like to use to cross the river. If the cannibals ever outnumber the missionaries on either of the river’s banks, the missionaries will get eaten. How can the boat be used to safely carry all the missionaries and cannibals across the river? Solving Problems by Searching

  7. Search Problems • initial state • set of possible actions/applicability conditions • successor function: state set of <action, state> • successor function + initial state = state space • path (solution) • goal • goal test function or goal state • path cost function • assumption: path cost = sum of step costs • for optimality Solving Problems by Searching

  8. initial state: all missionaries, all cannibals, and the boat are on the left bank 5 possible actions: one missionary crossing one cannibal crossing two missionaries crossing two cannibals crossing one missionary and one cannibal crossing Missionaries and Cannibals: Initial State and Actions Solving Problems by Searching

  9. Missionaries and Cannibals: Successor Function Solving Problems by Searching

  10. Missionaries and Cannibals: State Space 1c 1c 2c 2c 1m1c 1m1c 1m 1m 2c 2c 1c 1c 1c 1c 2m 2m 1m1c Solving Problems by Searching

  11. goal state: all missionaries, all cannibals, and the boat are on the right bank. path cost step cost: 1 for each crossing path cost: number of crossings = length of path solution path: 4 optimal solutions cost: 11 Missionaries and Cannibals: Goal State and Path Cost Solving Problems by Searching

  12. Oradea 71 Neamt Zerind 87 151 75 Iasi Arad 140 Sibiu 92 Fagaras 99 118 Vaslui 80 Rimnicu Vilcea 211 Timisoara 97 142 Pitesti 111 98 Lugoj 101 85 Hirsova 146 Urziceni 70 Bucharest 86 Mehadia 138 90 75 Eforie Dobreta 120 Giurgiu Craiova Real-World Problem:Touring in Romania Solving Problems by Searching

  13. Goal Formulation • performance measure • assigns a “happiness value” to all possible world states • goal • a condition that either is or is not satisfied in a given world state; a set of world states • goal formulation • find a goal that must be true in all desirable world states, i.e. all situations in which the performance measure is high Solving Problems by Searching

  14. Problem Formulation • problem formulation • process of deciding what actions and states to consider • granularity/abstraction level • assumptions about the environment: • static • observable • discrete • deterministic Solving Problems by Searching

  15. Touring in Romania:Search Problem Definition • initial state: • In(Arad) • possible Actions: • DriveTo(Zerind), DriveTo(Sibiu), DriveTo(Timisoara), etc. • goal state: • In(Bucharest) • step cost: • distances between cities Solving Problems by Searching

  16. Overview • Characterizing Search Problems • Searching for Solutions • Uninformed Search Strategies • Avoiding Repeated States • The Problem of Representation • Search in AND/OR-Graphs • Searching with Partial Information Solving Problems by Searching

  17. Search • An agent with several immediate options of unknown value can decide what to do by first examining different possible sequences of actions that lead to states of known value, and then choosing the best sequence. • search(through the state space) for • a goal state • a sequence of actions that leads to a goal state • a sequence of actions with minimal path cost that leads to a goal state Solving Problems by Searching

  18. Search Trees • search tree: tree structure defined by initial state and successor function • Touring Romania (partial search tree): In(Arad) In(Zerind) In(Sibiu) In(Timisoara) In(Oradea) In(Fagaras) In(Rimnicu Vilcea) In(Arad) In(Sibiu) In(Bucharest) Solving Problems by Searching

  19. Search Nodes • search nodes: the nodes in the search tree • data structure: • state: a state in the state space • parent node: the immediate predecessor in the search tree • action: the action that, performed in the parent node’s state, leads to this node’s state • path cost: the total cost of the path leading to this node • depth: the depth of this node in the search tree Solving Problems by Searching

  20. Expanding a Search Node function expand(node, problem) successors { } for each <action, result> inproblem.successorFn(node.state) do s  new searchNode(result) s.parentNode  node s.action action s.pathCost node.pathCost + problem.stepCost(action, node.state) s.depth node.depth + 1 successors  successors + s returnsuccessors Solving Problems by Searching

  21. Expanded Search Nodesin Touring Romania Example In(Arad) In(Zerind) In(Sibiu) In(Timisoara) In(Oradea) In(Fagaras) In(Rimnicu Vilcea) In(Arad) In(Sibiu) In(Bucharest) Solving Problems by Searching

  22. Fringe Nodesin Touring Romania Example fringe nodes: nodes that have not been expanded In(Arad) In(Zerind) In(Sibiu) In(Timisoara) In(Oradea) In(Fagaras) In(Rimnicu Vilcea) In(Arad) In(Sibiu) In(Bucharest) Solving Problems by Searching

  23. Search (Control) Strategy • search or control strategy: an effective method for scheduling the application of the successor function to generate new states • selects the next node to be expanded from the fringe • determines the order in which nodes are expanded • aim: produce a goal state as quickly as possible • examples: • LIFO-queue for fringe nodes • alphabetical ordering Solving Problems by Searching

  24. General Tree Search Algorithm function treeSearch(problem, strategy) fringe { new searchNode(problem.initialState) } loop if empty(fringe) thenreturn failure node  selectFrom(fringe, strategy) ifproblem.goalTest(node.state) then return pathTo(node) fringe  fringe +expand(problem, node) Solving Problems by Searching

  25. Key Features of the General Search Algorithm • systematic • guaranteed to not generate the same state infinitely often • guaranteed to come across every state eventually • incremental • attempts to reach a goal state step by step (rather than guessing it all at once) Solving Problems by Searching

  26. Possible Outcomes • algorithm terminates with: • failure: no solution could be found • success: solution path was found • algorithm does not terminate Solving Problems by Searching

  27. In(Zerind) In(Timisoara) In(Oradea) In(Rimnicu Vilcea) In(Arad) In(Sibiu) General Search Algorithm:Touring Romania Example In(Arad) In(Sibiu) In(Fagaras) In(Bucharest) fringe selected Solving Problems by Searching

  28. Measuring Problem-Solving Performance • completeness • Is the algorithm guaranteed to find a solution when there is one? • optimality • Does the strategy find the optimal solution? • time complexity • How long does it take to find a solution? • space complexity • How much memory is need to perform the search? Solving Problems by Searching

  29. Search Problem Complexity Measures • in theoretical Computer Science: • size of the state space graph • in Artificial Intelligence: • branching factor: maximum number of successors per node • depth of the shallowest goal node • maximum length of any path in the state space Solving Problems by Searching

  30. Problem-Solving Performance: Examples Solving Problems by Searching

  31. Search Cost vs. Total Cost • search cost: • time (and memory) used to find a solution • total cost: • search cost + path cost of solution • optimal trade-off point: • further computation to find a shorter path becomes counterproductive Solving Problems by Searching

  32. Overview • Characterizing Search Problems • Searching for Solutions • Uninformed Search Strategies • Avoiding Repeated States • The Problem of Representation • Search in AND/OR-Graphs • Searching with Partial Information Solving Problems by Searching

  33. Uninformed vs. Informed Search • uninformed search (blind search) • no additional information about states beyond problem definition • only goal states and non-goal states can be distinguished • informed search (heuristic search) • additional information about how “promising” a state is available Solving Problems by Searching

  34. Breadth-First Search • strategy: • expand root node • expand successors of root node • expand successors of successors of root node • etc. • implementation: • use FIFO queue to store fringe nodes in general tree search algorithm Solving Problems by Searching

  35. Breadth-First Search: Missionaries and Cannibals depth = 0 depth = 1 depth = 2 depth = 3 Solving Problems by Searching

  36. Time and Space Complexity for Breadth-First Search • assumptions: • every search node has exactly b successors (b finite) • shallowest goal node is at finite depth d • analysis: • worst case: goal node last node at depth d • bn successors at depth n • time complexity: O(bd+1) • space complexity: O(bd+1) Solving Problems by Searching

  37. Breadth-First Search: Evaluation Solving Problems by Searching

  38. Exponential Complexity Solving Problems by Searching

  39. Exponential Complexity: Important Lessons • memory requirements are a bigger problem for breadth-first search than is the execution time • time requirements are still a major factor • exponential-complexity search problems cannot be solved by uninformed methods for any but the smallest instances Solving Problems by Searching

  40. Uniform-Cost Search • breadth-first search is optimal when all step costs are equal • uniform-cost search: • always expand the fringe node with lowest path cost first Solving Problems by Searching

  41. Uniform-Cost Search:Touring Romania fringe Arad(0) d = 0 selected Zerind(75) Sibiu(140) Timisoara(118) d = 1 Arad(280) Oradea(291) d = 2 Arad(150) Oradea(146) Arad(236) Lugoj(229) Fagaras(239) Rimnicu Vilcea(220) Sibiu(290) Timisoara(268) Sibiu(300) Craiova(346) Zerind(217) Sibiu(297) Timisoara(340) Mehadia(299) d = 3 Zerind(225) Pitesti(317) Arad(300) Oradea(296) Arad(292) Oradea(288) d = 4 Solving Problems by Searching

  42. Time and Space Complexity for Uniform-Cost Search • assumptions: • every search node has exactly b successors (b finite) • every step has cost ≥ ε for some positive constant ε • let C* be the cost of an optimal solution • analysis: • time complexity: O(b1+⌊C*/ε⌋) • space complexity: O(b1+⌊C*/ε⌋) Solving Problems by Searching

  43. Uniform-Cost Search: Evaluation Solving Problems by Searching

  44. Depth-First Search • strategy: • always expand the deepest node in the current fringe first • when a sub-tree has been completely explored, delete it from memory and “back up” • implementation: • use LIFO queue (stack) to store fringe nodes in general tree search algorithm • alternative: recursive function that calls itself on each of its children in turn Solving Problems by Searching

  45. Depth-First Search:Missionaries and Cannibals depth = 0 depth = 1 depth = 2 depth = 3 Solving Problems by Searching

  46. Recursive Implementation of Depth-First Search function depthFirstSearch(problem) return recursiveDFS( new searchNode(problem.initialState, problem) function recursiveDFS(node, problem) ifproblem.goalTest(node.state) thenreturn pathTo(node) foreachsuccessorin expand(node, problem) do result  recursiveDFS(successor, problem) ifresult≠ failure then returnresult returnfailure Solving Problems by Searching

  47. Time and Space Complexity for Depth-First Search • assumptions: • every search node has exactly b successors (b finite) • depth of the deepest node in the tree is m • analysis: • time complexity: O(bm) • space complexity: O(bm) Solving Problems by Searching

  48. Depth-First Search: Evaluation Solving Problems by Searching

  49. Depth-First Search: Finding the Optimal Path • first solution discovered may not be optimal  must keep searching • continued search: • assumption: non-decreasing path costs • remember path cost of cheapest path found so far • do not expand nodes for which path cost exceeds cheapest found so far Solving Problems by Searching

  50. Backtracking Search • a variant of depth-first search • generate only one successor at a time • each node remembers which successor to generate next • space complexity: O(m) • generate successors by modifying current state representation • must be able to undo modifications • may use even less memory (and time) Solving Problems by Searching

More Related