/GTPyhop

A task-planning system based on Pyhop, but generalized to plan for both goals and tasks.

Primary LanguagePythonBSD 3-Clause Clear LicenseBSD-3-Clause-Clear

GTPyhop

A Goal-Task-Network planning system written in Python

Dana S. Nau
University of Maryland
July 22, 2021

GTPyhop is an automated planning system written in Python, that uses hierarchical planning techniques to construct plans of action for tasks and goals. The way GTPyhop plans for tasks is very similar to the Pyhop planner, and GTPyhop is mostly backward-compatible with Pyhop. The way GTPyhop plans for goals is inspired by the GDP algorithm. However, GTPyhop may use both tasks and goals throughout its planning process.

Here is a brief summary of GTPyhop's features:

  • GTPyhop creates a plan (a sequence of actions) to accomplish a to-do list T consisting of actions, tasks, and goals. The objective is to construct a solution plan, i.e., a sequence of actions that accomplishes all of the items in T, in the order that they occur in T. To do this, GTPyhop does a backtracking search in a planning domain that includes definitions of what the actions do, task methods telling how to accomplish tasks, and goal methods telling how to achieve goals.

  • Unlike the task lists used in Pyhop and the goal lists used in GDP, GTPyhop's to-do list may contain both tasks and goals. The same is true for the to-do lists returned by GTPyhop's task methods and goal methods. Thus GTPyhop may switch back and forth between tasks and goals throughout its planning process.

  • GTPyhop is mostly backward-compatible with Pyhop. However, GTPyhop includes more documentation, more debugging features, and the ability to load multiple planning domains into memory and switch among them without having to restart Python each time.

For further information, see this overview of GTPyhop and this additional information.

Things in the GTPyhop distribution

  • The GTPyhop source file, the open-source license, and a simple test harness for debugging and demonstrating problem domains.

  • Several example problem domains and test problems. Go to the Examples directory, launch Python 3, and try one or more of the following:

    import simple_htn                   # some simple task-planning examples
import simple_hgn                   # some simple goal-planning examples
import backtracking_htn             # simple demonstration of backtracking
import logistics_hgn                # goal-planning version of the "logistics" domain
import blocks_gtn                   # goal-task-planning version of the blocks world
import blocks_htn                   # task-planning version of the blocks world
import blocks_hgn                   # goal-planning version of the blocks world
import blocks_goal_splitting        # separating goals and solving them sequentially
import pyhop_simple_travel_example  # example of near-backward-compatibility with Pyhop
import simple_htn_acting_error      # example of a problem at acting time

  • A version of the Run-Lazy-Lookahead algorithm described in Automated Planning and Acting. The above test problems include demonstrations of integrated planning and acting using Run-Lazy-Lookahead and GTPyhop.

  • The additional information document mentioned earlier. It includes some details about states, actions, and methods, a discussion of backward-compatibility with Pyhop, and comparisons to other planners.

Related work