Software tools for Classical Planning , Artificial ...gdicaro/15381/hw/hw2-files/software... ·...

Software tools for Classical PlanningArtificial Intelligence 15-381

Qatar Fall 2018

Sep 20, 2018

Contact: Eduardo Feo-Flushing <efeoflus at andrew.cmu.edu>

CONTENTS

1 Quick Start 11.1 Planning Problem Representation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 The Planning Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3 Implementing GraphPlan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.4 Using A* to find plans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.5 Validate a plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 API 52.1 Planning problem representation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.2 Planning Graph representation and solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.3 Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3 Indices and tables 13

Python Module Index 15

Index 17

i

CHAPTER

ONE

QUICK START

We introduce the most important features of the library. You can simply browse through it and take a look at theexamples provided.

1.1 Planning Problem Representation

A planning problem is encoded using PDDL in two separate files: the domain, and the problem instance. A planningproblem is represented using the class task.Task. This class and its dependencies are defined in the task module.

1.1.1 Parsing PDDL files

A task object can be created from the PDDL files using the function tools.parse_pddl() which is provided toyou

task = parse_pddl(domain, problem)logging.info('Parsed planning problem: {0}'.format(task.name))print(task)

1.1.2 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

Software tools for Classical PlanningArtificial Intelligence 15-381Qatar Fall 2018

Then we have a planning graph level, represented as planning_graph_level.PlanningGraphLevel whichaggregates 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 loggingfrom planning_graph import PlanningGraphfrom tools import parse_pddltask = 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.GraphPlanhas 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 thealgorithm, 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 inthe goal state, or some of these propositions are mutex in the

(continues on next page)

2 Chapter 1. Quick Start


Qatar Fall 2018

(continued from previous page)

layer and we have not reached the fixed point, continueexpanding the graph"""

logging.info("Initial expansion of planning graph ...")

"""Initial expansion of the planning graph until it has leveledoff 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. Ifa solution cannot be extracted, i.e., extract returns None, a new level is expanded. Expansions occur until the planninggraph has leveled off.

You should implement the graphplan.GraphPlan.extract() method, using the backward search approachintroduced in the lecture. The graphplan.GraphPlan.noGoods can be used to store the sets of actions thathave 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 classtask.Task and an heuristic (derived from heuristic_base.Heuristic).

1.4.1 Defining heuristics

You need to define a class that derives from heuristic_base.Heuristic and reimplements the methodheuristic_base.Heuristic.__call__(). Take a look at the example blind heuristic provided inheuristic_blind.BlindHeuristic.

1.4.2 Calling search

In order to use A* you should use the function a_star.astar_search(), passing a task instance and yourheuristic.

from a_star import astar_searchfrom heuristic_blind import BlindHeuristicfrom 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) solutionto 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


order, and we obtain a state that covers the goals.

The function validateplan.validate() provides this functionality.

4 Chapter 1. Quick Start

CHAPTER

TWO

API

The most relevant modules are documented below.

task Classes that are used to represent a planning problem.planning_graphplanning_graph_levelactionlayer Representation of an action layerfactlayer Representation of a fact layera_star Implements the A* (a-star) search algorithm.tools Utility functionsheuristic_base Base class for the implementation of heuristicsheuristic_blindvalidateplan

2.1 Planning problem representation

2.1.1 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_pddltask = 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).

preconditionsfrozenset – Represent the facts that have to be true before the operator can be applied.

add_effectsfrozenset – The facts that the operator makes true.

5


delete_effectsfrozenset – The facts that the operator makes false.

applicable(state: set)→ boolCheck 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)→ setApply operator to a given state

Applying an operator implies removing the facts that are made false the operator from the set of true factsin 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 thefact 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 thedomain initial_state (set): A set of fact names that are true at the beginning goals (set): A set of factnames that must be true to solve the problem operators(set): A set of task.Operator representingthe valid actions in the problem

copy()Get a deep copy of the task

Returns A copy of this task object

6 Chapter 2. API


Qatar Fall 2018

get_successor_states(state: set)→ listGet 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 oftask.Operator) and “new_state” the state that results when “op” is applied in state “state”.

goal_reached(state: set)→ boolCheck 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

2.2.1 actionlayer module

Representation of an action layer

class actionlayer.ActionLayerA class for an action layer in a level of the planning graph. It contains not only a list of actions, but also themutexes among them.

actionsset – The actions in this layer as a set of task.Operator

mutex_actionsset – The mutex actions, represented as a set of tuples (task.Operator, task.Operator)

actions_for_propdict – 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) –


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


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



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

2.2.2 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 mutexesamong them.

actionsset – The facts in this layer as a list of string

mutex_actionsset – 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) –


applicable(op)Check if a given action can be applied from this layer, i.e., if all facts that are preconditions of the actionexist in this layer

8 Chapter 2. API


Qatar Fall 2018

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



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

2.2.3 planning_graph_level module

class planning_graph_level.PlanningGraphLevel(action_layer=<actionlayer.ActionLayerobject>, fact_layer=<factlayer.FactLayerobject>)

A class for representing a level in the planning graph. Each level consists of one action layer and one fact layerat 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 actionlayer 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


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 planningproblem represented as a task (instance of Task). You can access each level directly using the graph.levelsmember variable, or using the provided getLevel() method. Note that there’s no need to use the private methodsprefixed 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 aremutex)

initialize()Initialization of the planning graph

2.2.5 graphplan module

class graphplan.GraphPlan(task)A class for initializing and running the graphplan algorithm

tasktask.Task – The planning problem

noGoodslist – 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 agraph 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 theinitial state. The code calls the extract function which you should complete below. noGoods[i] representthe states that have been explored so far from level i. You can use noGoods for memoization and reducethe computation time. Using noGoods is NOT mandatory.

2.3 Search

2.3.1 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* search.

@param task The task to be solved @param heuristic A heuristic callable which computes the estimated steps

10 Chapter 2. API


Qatar Fall 2018

from a search node to reach the goal.

@param 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, or-dered_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* search.

@param node The node itself. @param heuristic A heuristic function to be applied. @param node_tiebreakerAn increasing value to prefer the value first

inserted if the ordering is the same.

@returns A tuple to be inserted into priority queues.

2.3.2 heuristic_base module

Base class for the implementation of heuristics

class heuristic_base.HeuristicBase class for A* heuristics

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

2.3.4 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


12 Chapter 2. API

CHAPTER

THREE

INDICES AND TABLES

• genindex

• modindex

• search

13


14 Chapter 3. Indices and tables

PYTHON MODULE INDEX

aactionlayer, 7

ffactlayer, 8

ggraphplan, 10

hheuristic_base, 11

pplanning_graph_level, 9

vvalidateplan, 11

15


16 Python Module Index

INDEX

Aa_star (module), 10ActionLayer (class in actionlayer), 7actionlayer (module), 7actions (actionlayer.ActionLayer attribute), 7actions (factlayer.FactLayer attribute), 8actions_for_prop (actionlayer.ActionLayer attribute), 7actions_independent() (planning_graph.PlanningGraph

method), 10add_effects (task.Operator attribute), 5addAction() (actionlayer.ActionLayer method), 7addFact() (factlayer.FactLayer method), 8addMutexActions() (actionlayer.ActionLayer method), 7addMutexProp() (factlayer.FactLayer method), 8applicable() (factlayer.FactLayer method), 8applicable() (task.Operator method), 6apply() (task.Operator method), 6astar_search() (in module a_star), 10

BBlindHeuristic (class in heuristic_blind), 11

Cclear_add_effects() (task.Operator method), 6clear_del_effects() (task.Operator method), 6clear_precondition() (task.Operator method), 6copy() (task.Task method), 6

Ddelete_effects (task.Operator attribute), 5

EeffectExists() (actionlayer.ActionLayer method), 7expand_graph() (planning_graph.PlanningGraph

method), 10extract() (graphplan.GraphPlan method), 10

FFactLayer (class in factlayer), 8factlayer (module), 8

Gget_successor_states() (task.Task method), 6getActionLayer() (plan-

ning_graph_level.PlanningGraphLevelmethod), 9

getActions() (actionlayer.ActionLayer method), 7getActionsForCondition() (actionlayer.ActionLayer

method), 8getFactLayer() (planning_graph_level.PlanningGraphLevel

method), 9getFacts() (factlayer.FactLayer method), 9getMutexActions() (actionlayer.ActionLayer method), 8getMutexFacts() (factlayer.FactLayer method), 9goal_reached() (task.Task method), 7GraphPlan (class in graphplan), 10graphplan (module), 10

Hhas_leveled_off() (planning_graph.PlanningGraph

method), 10has_non_mutex_goals() (planning_graph.PlanningGraph

method), 10Heuristic (class in heuristic_base), 11heuristic_base (module), 11heuristic_blind (module), 11

Iinitialize() (planning_graph.PlanningGraph method), 10isMutex() (actionlayer.ActionLayer method), 8isMutex() (factlayer.FactLayer method), 9

Mmutex_actions (actionlayer.ActionLayer attribute), 7mutex_actions (factlayer.FactLayer attribute), 8

NnoGoods (graphplan.GraphPlan attribute), 10

OOperator (class in task), 5ordered_node_astar() (in module a_star), 11

17


Pplanning_graph (module), 10planning_graph_level (module), 9PlanningGraph (class in planning_graph), 10PlanningGraphLevel (class in planning_graph_level), 9preconditions (task.Operator attribute), 5

RremoveActions() (actionlayer.ActionLayer method), 8removeFact() (factlayer.FactLayer method), 9

Sset_add_effects() (task.Operator method), 6set_del_effects() (task.Operator method), 6set_precondition() (task.Operator method), 6setActionLayer() (plan-

ning_graph_level.PlanningGraphLevelmethod), 9

setFactLayer() (planning_graph_level.PlanningGraphLevelmethod), 9

solve() (graphplan.GraphPlan method), 10summary() (planning_graph_level.PlanningGraphLevel

method), 9

TTask (class in task), 6task (graphplan.GraphPlan attribute), 10task (module), 5

Vvalidate() (in module validateplan), 11validateplan (module), 11

18 Index

Software tools for Classical Planning , Artificial ...gdicaro/15381/hw/hw2-files/software... ·...

Documents

Transcript of Software tools for Classical Planning , Artificial ...gdicaro/15381/hw/hw2-files/software... ·...