# Introduction to Artificial Intelligence Class 1 Planning Search by StuartSpruce

VIEWS: 5 PAGES: 26

• pg 1
```									Introduction to Artificial Intelligence

Class 1
Planning & Search

Henry Kautz
Winter 2007
Outline of Course

Heuristic search
Constraint satisfaction
Automated planning
Propositional logic
First-order logic and logic programming
Knowledge engineering
Probabilistic reasoning: directed and undirected graphical
models
Learning graphical models
Decision trees and ensemble methods
Neural networks
Planning

Input
• Description of initial state of world
• Description of goal state(s)
• Description of available actions
– Optional: Cost for each action
Output
• Sequence of actions that converts the
initial state into a goal state
• May wish to minimize length or cost of
plan
3
Classical Planning

• Atomic time
• Deterministic actions
• Complete knowledge
• No numeric reward (just goals)
• Only planner changes world
Route Planning

State = intersection

Operators = block
between intersections

Operator cost = length
of block
Blocks World

Control a robot arm that can pick up and stack blocks.
• Arm can hold exactly one block
• Blocks can either be on the table, or on top of exactly
one other block

State = configuration of blocks
• { (on-table G), (on B G), (clear B), (holding R) }
Operator = pick up or put down a block
• (put-down R)              put on table
• (stack R B)               put on another block
State Space

Planning = Finding (shortest) paths in state graph

put-down(R)
stack(R,B)

pick-up(R)

pick-up(G)
stack(G,R)
STRIPS Representation

(define (domain prodigy-bw)
(:requirements :strips)
(:predicates
(on ?x ?y)
(on-table ?x)
(clear ?x)
(arm-empty)
(holding ?x))
Problem Instance

(define (problem bw-sussman)
(:domain prodigy-bw)
(:objects A B C)
(:init
(on-table a) (on-table b) (on c a)
(clear b) (clear c) (arm-empty))
(:goal
(and (on a b) (on b c))))
goal may be
a partial
description
Operator Schemas

(:action stack
:parameters (?obj ?under_obj)
:precondition
(and (holding ?obj) (clear ?under_obj))
:effect
(and (not (holding ?obj))
delete        (clear ?obj)                  effects –
effects –                                   make true
(arm-empty)
make false
(on ?obj ?under_obj)))
Blocks World
Blackbox Planner Demo
Search Algorithms

Today: Space-State Search
• Depth-First
• Best-First
• A*

Next Class:
• Local Search
• Constraint Satisfaction
A General Search Algorithm
Search( Start, Goal_test, Criteria )
Open = { Start }; Closed = { };
repeat
if (empty(Open)) return fail;
select Node from Open using Criteria;
if (Goal_test(Node)) return Node;
for each Child of node do
if (Child not in Closed)
Open = Open U { Child };
Closed = Closed U { Node };

Closed list
optional
Search( Start, Goal_test, Criteria )
Open: fifo_queue;
Closed: hash_table;
enqueue(Start, Open);
repeat
if (empty(Open)) return fail;
Node = dequeue(Open);
if (Goal_test(Node)) return Node;
for each Child of node do
if (not find(Child, Closed))
enqueue(Child, Open)
insert(Child, Closed)

Criteria = shortest distance from Start
Depth-First Search
Search( Start, Goal_test, Criteria )
Open: stack;
Closed: hash_table;
push(Start, Open);
repeat
if (empty(Open)) return fail;
Node = pop(Open);
if (Goal_test(Node)) return Node;
for each Child of node do
if (not find(Child, Closed))
push(Child, Open)
insert(Child, Closed)

Criteria = longest distance from Start
Best-First Search
Search( Start, Goal_test, Criteria )
Open: priority_queue;
Closed: hash_table;
enqueue(Start, Open, heuristic(Start));
repeat
if (empty(Open)) return fail;
Node = dequeue(Open);
if (Goal_test(Node)) return Node;
for each Child of node do
if (not find(Child, Closed))
enqueue(Child, Open, heuristic(Child))
insert(Child, Closed)

Criteria = shortest heuristic estimate of distance to goal
Properties

Depth First
• Simple implementation (stack)
• Might not terminate
• Might find non-optimal solution
• Always terminates if solution exists
• Finds optimal solutions
• Visits many nodes
Best First
• Always terminates if heuristic is “reasonable”
• Visits many fewer nodes
• May find non-optimal solution
Best-First with Manhattan Distance
(Δ x+ Δ y) Heuristic

53nd St

52nd St

51st St                                                                              G

50th St              S
10th Ave

9th Ave

8th Ave

2nd Ave
3rd Ave
7th Ave

6th Ave

5th Ave

4th Ave
2nd Ave
Non-Optimality of Best-First

3rd Ave
G

4th Ave
5th Ave
6th Ave
7th Ave
8th Ave
9th Ave

S
10th Ave

50th St
52nd St
53nd St

51st St
A*

Criteria: minimize (distance from start) +
(estimated distance to goal)

Implementation: priority queue

f(n) = g(n)   + h(n)

f(n) = priority of a node
g(n) = true distance from start
h(n) = heuristic distance to goal
Optimality of A*

Suppose the estimated distance is always less than
or equal to the true distance to the goal
• heuristic is a lower bound

Then: when the goal is removed from the priority
queue, we are guaranteed to have found a
shortest path!
Maze Runner Demo
Observations on A*
Perfect heuristic: If h(n) = h*(n) (true distance) for all n, then only the
nodes on the optimal solution path will be expanded.
Null heuristic: If h(n) = 0 for all n, then this is an admissible heuristic
and A* acts like breath-first search.
Comparing heuristics: If h1(n) ≤ h2(n) ≤ h*(n) for all non-goal nodes,
then h2 is as least as good a heuristic as h1
• Every node expanded by A* using h2 is also expanded by A*
using h1
• if h1(n)<h1(n) for some n, then h2 is stronger than h1
Combining heuristics: if h1(n) and h2(n) are admissible, then
• Why?
Search Heuristics

“Optimistic guess” at distance to a solution
Some heuristics are domain specific
• Manhattan distance for grid-like graphs
• Euclidean distance for general road maps
• Rubik’s Cube
– Admissible, but weak: # cubits out of place / 8
– Better:
MAX( Sum( Manhattan distance edge cubits )/4,
Sum( Manhattan distance corner cubits )/4 )
Planning Heuristics

A useful non-admissible heuristic for planning is the
number of goals that need to be achieved

Good admissible heuristics for planning can be created
by relaxing the operators, e.g.:
• Eliminate preconditions, or
• Eliminate negative preconditions & effects
Use the length of the solution to the relaxed problem as a
heuristic for the length of the solution to the original
problem
Homework

Shakey the robot has to
bring coffee to Prof. Kautz.
In order to make the coffee,
Shakey will need to gather
coffee filters, coffee, and
Prof. Kautz's mug and bring
them to the coffee maker in
the kitchen. The coffee and
filters are in the supply
room, but it is locked. To
unlock the supply room,
Represent this problem in STRIPS notation
Shakey will need to get the
key from Prof. Kautz's          What is the true value of the start state?
office.                         What is the heuristic value of the start start,
based on rhe relaxed problem with no
preconditions on actions?

```
To top