Deterministic Planning and State-space Search. Erez Karpas

Transcription

1 Planning and Search IE&M Technion to our

2 Problem-solving agents Restricted form of general agent def Simple-Problem-Solving-Agent (problem): state, some description of the current world state seq, an action sequence, initially empty state Update-State(state, percept) if seq is empty then seq SearchForSolution(problem) action SelectAction(seq, state) seq Remainder(seq, action) return action Note: offline problem solving; solution executed eyes closed. to our

3 Example: A trip in Romania Task On holiday in Romania; currently in Arad. Flight leaves tomorrow from Bucharest Arad Zerind Timisoara 111 Oradea Dobreta 151 Lugoj Mehadia 120 Sibiu 99 Craiova Fagaras 80 Rimnicu Vilcea 97 Pitesti Neamt Giurgiu 87 Bucharest Iasi Urziceni Vaslui Hirsova 86 Eforie to our

4 Example: A trip in Romania Task On holiday in Romania; currently in Arad. Flight leaves tomorrow from Bucharest Formulate goal: be in Bucharest Formulate problem: states: various cities actions: drive between cities Find solution: sequence of cities, e.g., Arad, Sibiu, Fagaras, Bucharest You probably know how to solve this one, but... to our

5 Example: A trip in Romania Task On holiday in Romania; currently in Arad. Flight leaves tomorrow from Bucharest Formulate goal: be in Bucharest Formulate problem: states: various cities actions: drive between cities Find solution: sequence of cities, e.g., Arad, Sibiu, Fagaras, Bucharest You probably know how to solve this one, but... to our

6 A sample of Route selection (from Arad to Bucharest) Solving 15-puzzle (or Rubik s cube, or...) Selecting and ordering movements of an elevator or a crane Production lines control Autonomous robots Crisis management... What is in common? to our

7 Planning Problems What is in common? All these deal with action selection or control Arad Some notion of problem state (Often) specification of initial state and/or goal state Legal moves or actions that allow transition from states to other states 71 Zerind Timisoara 111 Oradea Dobreta 151 Lugoj Mehadia 120 Sibiu 99 Craiova Fagaras 80 Rimnicu Vilcea 97 Pitesti Neamt Giurgiu 87 Bucharest Iasi Urziceni Vaslui Hirsova 86 Eforie to our

8 Planning Problems For now focus on: Plans (aka solutions) are sequences of moves that transform the initial state into the goal state Intuitively, not all solutions are equally desirable What is our task? 1 Find out whether there is a solution 2 Find any solution 3 Find an optimal solution 4 Find near-optimal solution 5 Fixed amount of time, find best solution possible 6 Find solution that satisfy property ℵ (what is ℵ? you choose!) to our

9 Planning Problems What is our task? 1 Find out whether there is a solution 2 Find any solution 3 Find an optimal solution 4 Find near-optimal solution 5 Fixed amount of time, find best solution possible 6 Find solution that satisfy property ℵ (what is ℵ? you choose!) While all these tasks sound related, they are very different. The best suited techniques are almost disjoint. to our

10 Planning vs. Scheduling Planning can be seen as extending scheduling Scheduling Deciding when to perform a given set of actions Time constraints Resource constraints Global constraints (e.g., regulatory issues) Objective functions Planning Deciding what actions to perform (and when) to achieve a given objective same issues The difference comes in play in solution techniques, and actually even in worst-case time/space complexity to our

11 Three Approaches to Problem Solving 1 programming: specify control by hand 2 model-oriented solving: specify problem by hand, derive control automatically 3 learning: learn control from experience Planning is a form of model-oriented problem solving to our

12 State Model for finite state space S an initial state s 0 S a set S G S of goal states applicable actions A(s) A for s S a transition function s = f(a, s) for a A(s) a cost function c : A [0, ) A solution is a sequence of applicable actions that maps s 0 into S G An optimal solution minimizes c to our

13 State Model for finite state space S an initial state s 0 S a set S G S of goal states applicable actions A(s) A for s S a transition function s = f(a, s) for a A(s) a cost function c : A [0, ) A solution is a sequence of applicable actions that maps s 0 into S G An optimal solution minimizes c to our

14 Small example C goal states B to D A E F initial state our

15 Why is difficult? Solutions to are paths from an initial state to a goal state in the transition graph Dijkstra s algorithm solves this problem in O( V log ( V ) + E ) Can we go home?? to our

16 Why is difficult? Solutions to are paths from an initial state to a goal state in the transition graph Dijkstra s algorithm solves this problem in O( V log ( V ) + E ) Can we go home?? Not exactly V of our interest is 10 10, 10 20, ,... But do we need such values of V?! to our

17 Why is difficult? Generalize the earlier example: Five locations, three robot carts, 100 containers, three piles V The number of atoms in the universe is only about The state space in our example is more than times as large (uppss...) Good news: Very much not hopeless! to our

18 Why is difficult? Generalize the earlier example: Five locations, three robot carts, 100 containers, three piles V The number of atoms in the universe is only about The state space in our example is more than times as large (uppss...) Good news: Very much not hopeless! to our

19 Different classes of Properties dynamics:, non or probabilistic observability: full, partial, or none horizon: finite or infinite... Side comment... It is not that are easy It is not even clear that they are too far from modeling real-world well! to Dynamics Observability Objectives our

20 Properties of the world: dynamics dynamics Action + current state uniquely determine successor state. Non dynamics For each action and current state there may be several possible successor states. Probabilistic dynamics For each action and current state there is a probability distribution over possible successor states. to Dynamics Observability Objectives our

21 Determistic dynamics example Moving objects with a robotic hand: move the green block onto the blue block. to Dynamics Observability Objectives our

22 Nondetermistic dynamics example Moving objects with an unreliable robotic hand: move the green block onto the blue block. to Dynamics Observability Objectives our

23 Probabilistic dynamics example Moving objects with an unreliable robotic hand: move the green block onto the blue block. to p = 0.1 p = 0.9 Dynamics Observability Objectives our

24 Properties of the world: observability Full observability Observations/sensing determine current world state uniquely. Partial observability Observations determine current world state only partially: we only know that current state is one of several possible ones. No observability There are no observations to narrow down possible current states. However, can use knowledge of action dynamics to deduce which states we might be in. Consequence: If observability is not full, must represent the knowledge an agent has. to Dynamics Observability Objectives our

25 What difference does observability make? Camera A Camera B to Goal Dynamics Observability Objectives our

26 Different objectives 1 Reach a goal state. Example: Earn 500 NIS. 2 Stay in goal states indefinitely (infinite horizon). Example: Never allow the bank account balance to be negative. 3 Maximize the probability of reaching a goal state. Example: To be able to finance buying a house by 2018 study hard and save money. 4 Collect the maximal expected rewards/minimal expected costs (infinite horizon). Example: Maximize your future income to Dynamics Observability Objectives our

27 Example: vacuum world state space graph L S R L S R L S R L L S S R states: 0/1 dirt and robot locations (ignore dirt amounts etc.) actions: Left, Right, Suck, NoOp goal test: no dirt path cost: 1 per action (0 for NoOp) R L L S S R R L S R to Dynamics Observability Objectives our

28 Vacuum world: different classes of Single-state, start in #5. Solution? to Dynamics Observability Objectives our

29 Vacuum world: different classes of Single-state, start in #5. Solution? [Right, Suck] Conformant, start in {1, 2, 3, 4, 5, 6, 7, 8} e.g., Right goes to {2, 4, 6, 8}. Solution? to Dynamics Observability Objectives our

30 Vacuum world: different classes of Single-state, start in #5. Solution? [Right, Suck] Conformant, start in {1, 2, 3, 4, 5, 6, 7, 8} e.g., Right goes to {2, 4, 6, 8}. Solution? [Right, Suck, Left, Suck] Conditional, start in {5, 7} Murphy s Law: Suck can dirty a clean carpet Local sensing: dirt, location only. Solution? [Right, if dirt then Suck] to Dynamics Observability Objectives our

31 transition A transition system is if there is only one initial state and all actions are. Hence all future states of the world are completely predictable. Definition ( transition system) A transition system is S, s 0, A, S G, c where finite state space S an initial state s 0 S a set S G S of goal states applicable actions A(s) A for s S a transition function s = f(a, s) for a A(s) a cost function c : A [0, ) to our

32 Blocks world The rules of the game Location on the table does not matter. Location on a block does not matter. to our

33 Blocks world The rules of the game At most one block may be below a block. to At most one block may be on top of a block. our

34 Blocks world The transition graph for three blocks to our

35 Blocks world Properties blocks states Finding a solution is polynomial time in the number of blocks (move everything onto the table and then construct the goal configuration). 2 Finding a shortest solution is NP-hard... to our

36 Planning Route selection (from Arad to Bucharest) Solving 15-puzzle (or Rubik s cube, or...) Selecting and ordering movements of an elevator or a crane Production lines control Autonomous robots Crisis management... to our

37 : one of the big success stories of AI Must carefully distinguish two different : satisficing : any solution is OK (although shorter solutions typically preferred) optimal : plans must have shortest possible length Both are often solved by, but: details are very different almost no overlap between good techniques for satisficing and good techniques for optimal many that are trivial for satisficing planners are impossibly hard for optimal planners to our

38 Planning by forward : progression Progression: Computing the successor state f(s, a) of a state s with respect to an action a. Progression planners find solutions by forward : start from initial state iteratively pick a previously generated state and progress it through an action, generating a new state solution found when a goal state generated Arad to Sibiu Timisoara Zerind our Arad Fagaras Oradea Rimnicu Vilcea Arad Lugoj Arad Oradea

39 Planning by forward : progression Progression: Computing the successor state f(s, a) of a state s with respect to an action a. Progression planners find solutions by forward : start from initial state iteratively pick a previously generated state and progress it through an action, generating a new state solution found when a goal state generated Arad to Sibiu Timisoara Zerind our Arad Fagaras Oradea Rimnicu Vilcea Arad Lugoj Arad Oradea

40 Planning by forward : progression Progression: Computing the successor state f(s, a) of a state s with respect to an action a. Progression planners find solutions by forward : start from initial state iteratively pick a previously generated state and progress it through an action, generating a new state solution found when a goal state generated Arad to Sibiu Timisoara Zerind our Arad Fagaras Oradea Rimnicu Vilcea Arad Lugoj Arad Oradea

41 Implementation: states vs. nodes In, one distinguishes: states s states (vertices) of the transition system nodes σ states plus information on where/when/how they are encountered during What is in a node? Different algorithms store different information in a node σ, but typical information includes: state(σ): associated state parent(σ): pointer to node from which σ is reached action(σ): an action leading from state(parent(σ)) to state(σ) g(σ): cost of σ (length of path from the root node) For the root node, parent(σ) and action(σ) are undefined. to our

42 Implementation: states vs. nodes In, one distinguishes: states s states (vertices) of the transition system nodes σ states plus information on where/when/how they are encountered during What is in a node? Arad to Sibiu Timisoara Zerind Arad Fagaras Oradea Rimnicu Vilcea Arad Lugoj Arad Oradea our

43 Required ingredients for A general algorithm can be applied to any transition system for which we can define the following three operations: init(): generate the initial state is-goal(s): test if a given state is a goal state succ(s): generate the set of successor states of state s, along with the actions through which they are reached (represented as pairs o, s of actions and states) Together, these three functions form a space (a very similar notion to a transition system). to our

44 Classification of algorithms uninformed vs. heuristic : uninformed algorithms only use the basic ingredients for general algorithms heuristic algorithms additionally use heuristic functions which estimate how close a node is to the goal systematic vs. local : systematic algorithms consider a large number of nodes simultaneously local algorithms work with one (or a few) candidate solutions ( nodes) at a time not a black-and-white distinction; there are crossbreeds (e. g., enforced hill-climbing) to our

45 Common procedures for algorithms Before we describe the different algorithms, we introduce three procedures used by all of them: make-root-node: Create a node without parent. make-node: Create a node for a state generated as the successor of another state. extract-solution: Extract a solution from a node representing a goal state. to our

46 Procedure make-root-node make-root-node: Create a node without parent. Procedure make-root-node def make-root-node(s): σ := new node state(σ) := s parent(σ) := undefined action(σ) := undefined g(σ) := 0 return σ to our

47 Procedure make-node make-node: Create a node for a state generated as the successor of another state. Procedure make-node def make-node(σ, o, s): σ := new node state(σ ) := s parent(σ ) := σ action(σ ) := o g(σ ) := g(σ) + 1 return σ to our

48 Procedure extract-solution extract-solution: Extract a solution from a node representing a goal state. Procedure extract-solution def extract-solution(σ): solution := new list while parent(σ) is defined: solution.push-front(action(σ)) σ := parent(σ) return solution to our

49 algorithms Popular uninformed systematic algorithms: breadth-first depth-first iterated depth-first Popular uninformed local algorithms: random walk to our BFS DFS

50 Breadth-first Breadth-first queue := new fifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-back(σ ) return unsolvable A to our B C D E F G BFS DFS

51 Breadth-first Breadth-first queue := new fifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-back(σ ) return unsolvable A to our B C D E F G BFS DFS

52 Breadth-first Breadth-first queue := new fifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-back(σ ) return unsolvable A to our B C D E F G BFS DFS

53 Breadth-first Breadth-first queue := new fifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-back(σ ) return unsolvable A to our B C D E F G BFS DFS

54 Is it any good? Dimensions for evaluation completeness: always find a solution if one exists? time complexity: number of nodes generated/expanded space complexity: number of nodes in memory optimality: does it always find a least-cost solution? Time/space complexity measured in terms of b maximum branching factor of the tree d depth of the least-cost solution m maximum depth of the state space (may be ) Quiz: to our BFS DFS

55 Properties of breadth-first Complete Yes (if b is finite) Time 1 + b + b 2 + b b d + b(b d 1) = O(b d+1 ), i.e., exp(d) Space O(b d+1 ) (why?) Optimal Yes (if cost = 1 per step); can be generalized (how?) Space is the big problem; can easily generate nodes at 100MB/sec so 24hrs = 8640GB. to our BFS DFS

56 Breadth-first Breadth-first queue := new fifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-back(σ ) return unsolvable Possible improvement: duplicate detection (see next slide). Another possible improvement: test if σ is a goal node; if so, terminate immediately. (We don t do this because it obscures the similarity to some of the later algorithms.) to our BFS DFS

57 Breadth-first with duplicate detection Breadth-first with duplicate detection queue := new fifo-queue queue.push-back(make-root-node(init())) closed := while not queue.empty(): σ = queue.pop-front() if state(σ) / closed: closed := closed {state(σ)} if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-back(σ ) return unsolvable to our BFS DFS

58 Duplicate detection: Worth the effort? Worst-case complexity Time 1 + b + b 2 + b b d + b(b d 1) = O(b d+1 ) Same! (why?) Space O(b d+1 ) Same! (why?) to our BFS DFS

59 Duplicate detection: Worth the effort? Worst-case complexity Time 1 + b + b 2 + b b d + b(b d 1) = O(b d+1 ) Same! (why?) Space O(b d+1 ) Same! (why?) Empirical reality Failure to detect repeated states can turn a linear problem into an exponential one! to A B C D C B C A C B C our BFS DFS

60 Depth-first Depth-first queue := new lifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-front(σ ) return unsolvable B A D E F G H I J K L M N O C to our BFS DFS

61 Depth-first Depth-first queue := new lifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-front(σ ) return unsolvable B A D E F G H I J K L M N O C to our BFS DFS

62 Depth-first Depth-first queue := new lifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-front(σ ) return unsolvable B A D E F G H I J K L M N O C to our BFS DFS

63 Depth-first Depth-first queue := new lifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-front(σ ) return unsolvable B A D E F G H I J K L M N O C to our BFS DFS

64 Depth-first Depth-first queue := new lifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-front(σ ) return unsolvable B A D E F G H I J K L M N O C to our BFS DFS

65 Depth-first Depth-first queue := new lifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-front(σ ) return unsolvable B A D E F G H I J K L M N O C to our BFS DFS

66 Depth-first Depth-first queue := new lifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-front(σ ) return unsolvable B A D E F G H I J K L M N O C to our BFS DFS

67 Depth-first Depth-first queue := new lifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-front(σ ) return unsolvable B A D E F G H I J K L M N O C to our BFS DFS

68 Depth-first Depth-first queue := new lifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-front(σ ) return unsolvable B A D E F G H I J K L M N O C to our BFS DFS

69 Depth-first Depth-first queue := new lifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-front(σ ) return unsolvable B A D E F G H I J K L M N O C to our BFS DFS

70 Depth-first Depth-first queue := new lifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-front(σ ) return unsolvable B A D E F G H I J K L M N O C to our BFS DFS

71 Depth-first Depth-first queue := new lifo-queue queue.push-back(make-root-node(init())) while not queue.empty(): σ = queue.pop-front() if is-goal(state(σ)): return extract-solution(σ) for each o, s succ(state(σ)): σ := make-node(σ, o, s) queue.push-front(σ ) return unsolvable B A D E F G H I J K L M N O C to our BFS DFS

72 Is it any good? Dimensions for evaluation completeness: always find a solution if one exists? time complexity: number of nodes generated/expanded space complexity: number of nodes in memory optimality: does it always find a least-cost solution? Time/space complexity measured in terms of b maximum branching factor of the tree d depth of the least-cost solution m maximum depth of the state space (may be ) Quiz: to our BFS DFS

73 Properties of depth-first Complete No: fails in spaces with b = or m =, spaces with loops Possible improvement: duplicate detection along path complete in finite spaces Time O(b m ) terrible if m is much larger than d, but if solutions are dense, may be much faster than BFS Space O(bm) linear space! Optimal No (right?) to our BFS DFS

74 Random walk Random walk σ := make-root-node(init()) forever: if is-goal(state(σ)): return extract-solution(σ) Choose a random element o, s from succ(state(σ)). σ := make-node(σ, o, s) The algorithm usually does not find any solutions, unless almost every sequence of actions is a plan. Often, it runs indefinitely without making progress. It can also fail by reaching a dead end, a state with no successors. This is a weakness of many local approaches. to our BFS DFS