Software tools for Classical Planning Artificial Intelligence Qatar Fall 2018 Sep 20, 2018

Size: px

Start display at page:

Download "Software tools for Classical Planning Artificial Intelligence Qatar Fall 2018 Sep 20, 2018"

Brittany Dennis
5 years ago
Views:

1 Sep 20, 2018 Contact: Eduardo Feo-Flushing <efeoflus at andrew.cmu.edu>

3 CONTENTS 1 Quick Start Planning Problem Representation The Planning Graph Implementing GraphPlan Using A* to find plans Validate a plan API Planning problem representation Planning Graph representation and solution Search Indices and tables 13 Python Module Index 15 Index 17 i

4 ii

5 CHAPTER ONE QUICK START We introduce the most important features of the library. You can simply browse through it and take a look at the examples provided. 1.1 Planning Problem Representation A planning problem is encoded using PDDL in two separate files: the domain, and the problem instance. A planning problem is represented using the class task.task. This class and its dependencies are defined in the task module Parsing PDDL files A task object can be created from the PDDL files using the function tools.parse_pddl() which is provided to you task = parse_pddl(domain, problem) logging.info('parsed planning problem: {0}'.format(task.name)) print(task) Creating a Relaxed Version of the Problem In order to modify a task, you should first copy the task. In this way, the original problem description remains intact. task_relaxed = task.copy() For example, let s remove the preconditions of all the operators for op in task_relaxed.operators: op.clear_precondition() 1.2 The Planning Graph A planning graph is basically a sequence of levels. Each level contains an action layer and a fact layer, in this order! Note: The first level of the graph is a special one because it does not include any action. There are four classes that are used to represent the planning graph. They follow a hierarchy. First we have the layers, represented as actionlayer.actionlayer and factlayer.factlayer. 1

6 Then we have a planning graph level, represented as planning_graph_level.planninggraphlevel which aggregates an action layer and a fact layer. Lastly the planning graph, that is simply a sequence (list) of levels (planning_graph_level:planninggraphlevel). To create a planning graph you first need an instance of task.task, that represents a planning problem import logging from planning_graph import PlanningGraph from tools import parse_pddl task = parse_pddl('testbed/domain-blocks.pddl', 'testbed/blocks.pddl') logging.info('creating a planning graph for problem: {0}'.format(task.name)) pg = PlanningGraph(task) logging.info('graph has {0} levels'.format(pg.size())) Once we have created a planning graph, we can expand it one level using its planning_graph. PlanningGraph.expand_graph() method pg.expand_graph() logging.info('graph has {0} levels'.format(pg.size())) get the last level num_levels = pg.size() last_level = pg.getlevel(num_levels-1) get the fact layer of the last level last_fact_layer = last_level.getfactlayer() get the facts included in the last fact layer last_facts = last_fact_layer.getfacts() check if the goals of the planning problem are covered by the last fact layer print("are goals covered? ",task.goals <= last_facts) 1.3 Implementing GraphPlan The class graphplan.graphplan provides a skeleton for the GraphPlan algorithm. As with the planning graph, you need to supply an instance of the class task.task. The graphplan.graphplan has two methods, graphplan.graphplan.solve() and graphplan.graphplan.extract(). graphplan.graphplan.solve() is the entry point of the algorithm. It already implements some parts of the algorithm, such as the initial expansion of the graph # which consists of the initial state. self.graph = PlanningGraph(task) """ While the layer does not contain all of the propositions in the goal state, or some of these propositions are mutex in the (continues on next page) 2 Chapter 1. Quick Start

7 layer and we have not reached the fixed point, continue expanding the graph """ (continued from previous page) logging.info("initial expansion of planning graph...") """ Initial expansion of the planning graph until it has leveled off and the mutex are covered and non-mutex in the last level """ while not self.graph.has_non_mutex_goals(): if self.graph.has_leveled_off(): return None # this means we stopped the while loop # above because we reached a fixed point and the main loop. Note that the algorithm calls the graphplan.graphplan.extract() to extract a solution. If a solution cannot be extracted, i.e., extract returns None, a new level is expanded. Expansions occur until the planning graph has leveled off. You should implement the graphplan.graphplan.extract() method, using the backward search approach introduced in the lecture. The graphplan.graphplan.nogoods can be used to store the sets of actions that have been considered during the backward search at each level in the planning graph. 1.4 Using A* to find plans The module a_star provides an implementation of the A* algorithm. You need to supply an instance of the class task.task and an heuristic (derived from heuristic_base.heuristic) Defining heuristics You need to define a class that derives from heuristic_base.heuristic and reimplements the method heuristic_base.heuristic. call (). Take a look at the example blind heuristic provided in heuristic_blind.blindheuristic Calling search In order to use A* you should use the function a_star.astar_search(), passing a task instance and your heuristic. from a_star import astar_search from heuristic_blind import BlindHeuristic from tools import parse_pddl heuristic = BlindHeuristic(task) solution = astar_search(task, heuristic) 1.5 Validate a plan A plan is represented by a list of actions (task.operator). A plan is a valid (not necessarily optimal) solution to the planning problem if, starting from the initial state, we apply one by one the actions of the plan, in the appearance 1.4. Using A* to find plans 3

8 order, and we obtain a state that covers the goals. The function validateplan.validate() provides this functionality. 4 Chapter 1. Quick Start

9 CHAPTER TWO API The most relevant modules are documented below. task planning_graph planning_graph_level actionlayer factlayer a_star tools heuristic_base heuristic_blind validateplan Classes that are used to represent a planning problem. Representation of an action layer Representation of a fact layer Implements the A* (a-star) search algorithm. Utility functions Base class for the implementation of heuristics 2.1 Planning problem representation task module Classes that are used to represent a planning problem. A planning problem is basically an instance of the Task class. Note: A task object can be created from a PDDL file using the parser. Example: from tools import parse_pddl task = parse_pddl('testbed/domain-blocks.pddl', 'testbed/blocks.pddl') print("planning problem parsed ") print(task) class task.operator(name, preconditions, add_effects, del_effects) This class represents an operator (action). preconditions frozenset Represent the facts that have to be true before the operator can be applied. add_effects frozenset The facts that the operator makes true. 5

10 delete_effects frozenset The facts that the operator makes false. applicable(state: set) bool Check if the operator can be applied to a given state Operators are applicable when their set of preconditions is a subset of the facts that are true in state. Parameters state The state from which to check if the operator is applicable Returns True if the operator s preconditions is a subset of the state, False otherwise apply(state: set) set Apply operator to a given state Applying an operator implies removing the facts that are made false the operator from the set of true facts in state and adding the facts made true. Note that therefore it is possible to have operands that make a fact both false and true. This results in the fact being true at the end. Parameters state (set) The state from which the operator should be applied to Returns A new state (set of facts) after the application ofthe operator clear_add_effects(add_facts=set()) Clear the add effects Clear the facts that are added by this operator clear_del_effects(del_facts=set()) Clear the delete effects Clear the facts that are removed by this operator clear_precondition(precond=set()) Clear the preconditions set_add_effects(add_facts=set()) Set the add effects Set the facts that are added by this operator set_del_effects(del_facts=set()) Set the delete effects Set the facts that are removed by this operator set_precondition(precond=set()) Set the preconditions class task.task(name, facts, initial_state, goals, operators) A planning task Atrributes: name (string): The task s name facts (set): A set of all the fact names that are valid in the domain initial_state (set): A set of fact names that are true at the beginning goals (set): A set of fact names that must be true to solve the problem operators(set): A set of task.operator representing the valid actions in the problem copy() Get a deep copy of the task Returns A copy of this task object 6 Chapter 2. API

11 get_successor_states(state: set) list Get the successor states from a given state The successor states result from the application of all the applicable operators to a given state Parameters state The state from which to generate the successors Returns A list with (op, new_state) pairs where op is the applicable operator (instance of task.operator) and new_state the state that results when op is applied in state state. goal_reached(state: set) bool Check if the goal has been reached at a given state The goal has been reached if all facts that are true in goals are true in state. Parameters state The state that is being checked Returns True if all the goals are reached, False otherwise 2.2 Planning Graph representation and solution actionlayer module Representation of an action layer class actionlayer.actionlayer A class for an action layer in a level of the planning graph. It contains not only a list of actions, but also the mutexes among them. actions set The actions in this layer as a set of task.operator mutex_actions set The mutex actions, represented as a set of tuples (task.operator, task.operator) actions_for_prop dict A map between facts and the set of task.operator s that have them in the add_effects addaction(act) Add an action to the layer Parameters act (task.operator) The action to add addmutexactions(action1, action2) Add a mutex between action1 and action2 Parameters action1 (task.operator) action2 (task.operator) effectexists(fact) Check if there is an action in this layer that adds a given fact Parameters fact The fact to check inside the add_effects of the actions in this layer Returns True if at least one of the actions in this layer has the fact/proposition fact in its add list Return type bool getactions() Get the actions in this layer 2.2. Planning Graph representation and solution 7

12 Returns A set of task.operator getactionsforcondition(fact) Get all the actions in this layer that have the fact in its add list Parameters fact The fact to check Returns A set of task.operator that have fact in their task.operator. add_effects Return type set getmutexactions() Get the set of mutexes Returns The mutexes as a set of pairs (task.operator, task.operator) ismutex(action1, action2) Parameters action1 (task.operator) action2 (task.operator) Returns True if the actions action1 action2 are mutex in this action layer, False otherwise Return type bool removeactions(act) Remove an action from the layer Parameters act (task.operator) The action to remove factlayer module Representation of a fact layer class factlayer.factlayer(facts=set()) A class for a fact layer in a level of the planning graph. It contains not only a list of facts, but also the mutexes among them. actions set The facts in this layer as a list of string mutex_actions set The mutex between the facts, represented as a set of tuples (string, string) addfact(fact) Add a fact to the layer Parameters act (string) The fact to add addmutexprop(fact1, fact2) Add a mutex between fact1 and fact2 Parameters fact1 (task.operator) fact2 (task.operator) applicable(op) Check if a given action can be applied from this layer, i.e., if all facts that are preconditions of the action exist in this layer 8 Chapter 2. API

13 Parameters op (task.operator) The action to check Returns True if all facts that are preconditions of the action exist in this layer (i.e. the action can be applied) Return type bool getfacts() Get the facts in this layer Returns A set of task.operator getmutexfacts() Get the set of mutexes Returns The mutexes as a set of pairs (task.operator, task.operator) ismutex(fact1, fact2) Parameters fact1 (task.operator) fact2 (task.operator) Returns True if the facts fact1 and fact2 are mutex in this fact layer, False otherwise Return type bool removefact(fact) Remove a fact from the layer Parameters act (task.operator) The fact to remove planning_graph_level module class planning_graph_level.planninggraphlevel(action_layer=<actionlayer.actionlayer object>, fact_layer=<factlayer.factlayer object>) A class for representing a level in the planning graph. Each level consists of one action layer and one fact layer at this level in this order. Note: The first level of a planning graph is a special one because does not contain any action, i.e., the action layer is empty. getactionlayer() Returns the action layer getfactlayer() Returns the fact layer setactionlayer(alayer) Sets the action layer setfactlayer(flayer) Sets the fact layer summary() Prints out the number of actions, facts, and mutexes 2.2. Planning Graph representation and solution 9

14 2.2.4 planning_graph module class planning_graph.planninggraph(task) A planning graph is just a sequence of levels (instances of PlanningGraphLevel. It is created from a planning problem represented as a task (instance of Task). You can access each level directly using the graph.levels member variable, or using the provided getlevel() method. Note that there s no need to use the private methods prefixed with underscore (_). actions_independent(op1, op2) Returns True of actions op1 and op2 are independent expand_graph() Create a new level by expanding the current one has_leveled_off() Returns True if the graph has leveled off has_non_mutex_goals() Returns True if the goals are covered in the last level of the planning graph, conflict-free (no two goals are mutex) initialize() Initialization of the planning graph graphplan module class graphplan.graphplan(task) A class for initializing and running the graphplan algorithm task task.task The planning problem nogoods list sets of operators that have been considered during backward search, used for memoization. no- Goods[i] refers to level i of the planning graph. extract(subgoals, level) The backward search part of graphplan that tries to extract a plan when all goal propositions exist in a graph plan level. Must return a plan represented as a list of operators. TO BE COMPLETED solve(state=none) The graphplan algorithm applied to state. If state is None, it is asumed that the algorithm is applied to the initial state. The code calls the extract function which you should complete below. nogoods[i] represent the states that have been explored so far from level i. You can use nogoods for memoization and reduce the computation time. Using nogoods is NOT mandatory. 2.3 Search a_star module Implements the A* (a-star) search algorithm. a_star.astar_search(task, heuristic, make_open_entry=<function ordered_node_astar>) Searches for a plan in the given task using A* task The task to be heuristic A heuristic callable which computes the estimated steps 10 Chapter 2. API

15 from a search node to reach the make_open_entry An optional parameter to change the bahavior of the astar search. The callable should return a search node, possible values are ordered_node_astar, ordered_node_weighted_astar and ordered_node_greedy_best_first with obvious meanings. a_star.ordered_node_astar(node, h, node_tiebreaker) Creates an ordered search node (basically, a tuple containing the node itself and an ordering) for A* node The node heuristic A heuristic function to be node_tiebreaker An increasing value to prefer the value first inserted if the ordering is the A tuple to be inserted into priority queues heuristic_base module Base class for the implementation of heuristics class heuristic_base.heuristic Base class for A* heuristics heuristic_blind module class heuristic_blind.blindheuristic(task) Implements a simple blind heuristic for illustration purposes. It returns 0 if the goal was reached and 1 otherwise validateplan module validateplan.validate(task, plan) Validates a plan with respect to a problem instance Parameters task (task.task) The planning problem plan (list) The plan to validate Returns True if the plan is valid, False otherwise 2.3. Search 11

16 12 Chapter 2. API

17 CHAPTER THREE INDICES AND TABLES genindex modindex search 13

18 14 Chapter 3. Indices and tables

19 PYTHON MODULE INDEX a actionlayer, 7 f factlayer, 8 g graphplan, 10 h heuristic_base, 11 p planning_graph_level, 9 v validateplan, 11 15

20 16 Python Module Index

21 INDEX A a_star (module), 10 ActionLayer (class in actionlayer), 7 actionlayer (module), 7 actions (actionlayer.actionlayer attribute), 7 actions (factlayer.factlayer attribute), 8 actions_for_prop (actionlayer.actionlayer attribute), 7 actions_independent() (planning_graph.planninggraph method), 10 add_effects (task.operator attribute), 5 addaction() (actionlayer.actionlayer method), 7 addfact() (factlayer.factlayer method), 8 addmutexactions() (actionlayer.actionlayer method), 7 addmutexprop() (factlayer.factlayer method), 8 applicable() (factlayer.factlayer method), 8 applicable() (task.operator method), 6 apply() (task.operator method), 6 astar_search() (in module a_star), 10 B BlindHeuristic (class in heuristic_blind), 11 C clear_add_effects() (task.operator method), 6 clear_del_effects() (task.operator method), 6 clear_precondition() (task.operator method), 6 copy() (task.task method), 6 D delete_effects (task.operator attribute), 5 E effectexists() (actionlayer.actionlayer method), 7 expand_graph() (planning_graph.planninggraph method), 10 extract() (graphplan.graphplan method), 10 F FactLayer (class in factlayer), 8 factlayer (module), 8 G get_successor_states() (task.task method), 6 getactionlayer() (planning_graph_level.planninggraphlevel method), 9 getactions() (actionlayer.actionlayer method), 7 getactionsforcondition() (actionlayer.actionlayer method), 8 getfactlayer() (planning_graph_level.planninggraphlevel method), 9 getfacts() (factlayer.factlayer method), 9 getmutexactions() (actionlayer.actionlayer method), 8 getmutexfacts() (factlayer.factlayer method), 9 goal_reached() (task.task method), 7 GraphPlan (class in graphplan), 10 graphplan (module), 10 H has_leveled_off() (planning_graph.planninggraph method), 10 has_non_mutex_goals() (planning_graph.planninggraph method), 10 Heuristic (class in heuristic_base), 11 heuristic_base (module), 11 heuristic_blind (module), 11 I initialize() (planning_graph.planninggraph method), 10 ismutex() (actionlayer.actionlayer method), 8 ismutex() (factlayer.factlayer method), 9 M mutex_actions (actionlayer.actionlayer attribute), 7 mutex_actions (factlayer.factlayer attribute), 8 N nogoods (graphplan.graphplan attribute), 10 O Operator (class in task), 5 ordered_node_astar() (in module a_star), 11 17

22 P planning_graph (module), 10 planning_graph_level (module), 9 PlanningGraph (class in planning_graph), 10 PlanningGraphLevel (class in planning_graph_level), 9 preconditions (task.operator attribute), 5 R removeactions() (actionlayer.actionlayer method), 8 removefact() (factlayer.factlayer method), 9 S set_add_effects() (task.operator method), 6 set_del_effects() (task.operator method), 6 set_precondition() (task.operator method), 6 setactionlayer() (planning_graph_level.planninggraphlevel method), 9 setfactlayer() (planning_graph_level.planninggraphlevel method), 9 solve() (graphplan.graphplan method), 10 summary() (planning_graph_level.planninggraphlevel method), 9 T Task (class in task), 6 task (graphplan.graphplan attribute), 10 task (module), 5 V validate() (in module validateplan), 11 validateplan (module), Index

CMU-Q Lecture 6: Planning Graph GRAPHPLAN. Teacher: Gianni A. Di Caro

CMU-Q Lecture 6: Planning Graph GRAPHPLAN. Teacher: Gianni A. Di Caro CMU-Q 15-381 Lecture 6: Planning Graph GRAPHPLAN Teacher: Gianni A. Di Caro PLANNING GRAPHS Graph-based data structure representing a polynomial-size/time approximation of the exponential search tree Can