CSCI 335 - Artificial Intelligence

Spring 2020

Programming Project #8: Planning

Overview

You will develop a series of search heuristics for solving planning problems. These heuristics will be demonstrated using the Blocks World domain, in addition to two domains of your own making.

Setup

The Java source files are provided in planner.zip. You will want to copy over your Project 1 implmenetation of BestFirstSearcher into the search.core package. The version that is there is the breadth-first search implementation from the Project 1 zip file.

Programming Assignment

The files are placed in six packages. You will modify the PlanGraph class, and create several classes in the planner.heuristics package that implement the BestFirstHeuristic interface. Classes you will modify are in boldface.

planner.heuristics
- BreadthFirst.java will implement breadth-first search.
- You will place additional heuristics here as you create them.
- Every heuristic in this package will be visible to PlanViewer.java.
planner.core
- PlanGraph.java: Represents a plan graph, a data structure that can be useful to assist in creating plans. You will complete the extractNoDeletePlan() method.
- PlanGraphTest.java: Unit test for PlanGraph. It will fail initially. It should pass once your solution to PlanGraph.java is complete.
- Action.java: Describes a plan operator.
- BasicPlanner.java: Wraps a BestFirstSearcher for generating a plan. It is abstract in order to enable variants to handle different BestFirstObject classes. Implements the Planner interface.
- BasicPlanStep.java: Useful basis for creating BestFirstObject classes.
- BestFirstPlanner.java: Extends BasicPlanner. When provided with a BestFirstHeuristic, the result is a functioning planner.
- BreadthFirstTest.java: Should pass all tests upon downloading.
- Conjunction.java: Represents the effects of an Action.
- Domain.java: Represents a planning domain.
- Plan.java: Represents a plan.
- PlanStep.java: Represents a plan step, for use in the search process.
- Planner.java: Interface for planners. Implemented by BasicPlanner.
- Predicate.java: Represents a parameterizable true/false statement.
- Problem.java: Represents a specific planning problem in a given Domain.
- State.java: Collection of Predicate objects representing the state of the world.
planner.gui
- PlanViewer.java: Runnable GUI for evaluating your planning heuristics.
planner.lisp: The files in this package you may safely ignore.

Implement the following heuristics. Each one will be a class that implements the BestFirstHeuristic interface. Each one should be placed in planner.heuristics.

A heuristic that counts the number of goals that have not yet been achieved.
Create a heuristic that creates a relaxed plan that solves the problem. This relaxed plan will ignore the delete effects of each Action. To find a relaxed plan, complete the extractNoDeletePlan() method in the PlanGraph class. Then use the length of the relaxed plan as the estimate.
Devise at least one additional heuristic.
- It may be domain-independent (as with the two above), or it may be specialized to one of the three domains you are employing.
- A specialized heuristic for the Blocks World, for example, could count the number of blocks stacked atop a block that needs to be moved as part of its calculation.

Domains

The Blocks World domain has been provided for you. You are to construct two additional domains, encoded in PDDL. Create three problem files for each domain. Place each domain in a subdirectory of domains:

The first domain should represent a robot delivering packages in an office building.
The second domain can represent any environment you would like to encode.
When creating your three problems, try to create at least one problem that you believe will be difficult for the planners to solve.

Experiments

For each heuristic, determine experimentally the "hardest" Blocks World problem that it can solve in one minute or less on your computer. Note that the planner may well crash from inadequate memory before it reaches the one-minute mark.

For the two other domains, determine how long it takes for each heuristic to solve each of the three problems you created.

Note: If your planner can solve all of the regular Blocks World problems, some extra-hard problems are available in the blocks2 directory.

For each experiment you run, record:

Nodes expanded
Maximum depth
Effective branching factor
Solution length
Time (milliseconds)
ms/node expansion

Paper

When you are finished with your experiments, you will write a short paper summarizing your findings. Include the following details in your paper:

A description of each heuristic
The data you collected from each of your experiments
An analysis of the data, including:
- A discussion of the relative merits of the heuristics relative to breadth-first search and each other
- An analysis of how the heuristics are affected in different ways by different domains
- The degree to which the results matched your expectations
Both planning and Q-learning are AI algorithms that select actions for an agent. In what scenarios do you think Q-learning is preferable to planning? When might planning be preferable to Q-learning?

Grading criteria

Achievement	Points
Passes all tests in `PlanGraphTest`	4
Goal-counting heuristic works	3
Plan graph heuristic works	6
Robot delivery domain created, with 3 problems	4
User-devised domain created, with 3 problems	4
Final user-chosen heuristic works	4
Ran experiments to determine for each heuristic the hardest Blocks World problem solvable in one minute or less	10
Ran experiments to assess performance for each heuristic for the robot delivery domain	5
Ran experiments to assess performance for each heuristic for the third domain	5
Paper describes each of the three heuristics implemented	5
Paper reports all experimental data	4
Paper discusses the merits of the heuristics relative to breadth-first search and each other	4
Paper analyzes how the heuristics are affected in different ways by different domains	4
Paper discusses the degree to which the results matched expectations	4
Paper discusses the scenarios in which planning is preferable to Q-learning for action selection, as well as when Q-learning would be preferable to planning	4