Introduction to Artificial Intelligence Class 1 Planning Search by StuartSpruce


									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
Learning graphical models
Decision trees and ensemble methods
Neural networks

    • Description of initial state of world
    • Description of goal state(s)
    • Description of available actions
      – Optional: Cost for each action
   • Sequence of actions that converts the
     initial state into a goal state
   • May wish to minimize length or cost of
      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



      STRIPS Representation

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

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

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

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

Next Class:
   • Local Search
   • Constraint Satisfaction
     A General Search Algorithm
Search( Start, Goal_test, Criteria )
 Open = { Start }; Closed = { };
    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
           Breadth-First Search
Search( Start, Goal_test, Criteria )
 Open: fifo_queue;
 Closed: hash_table;
 enqueue(Start, Open);
     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);
     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));
     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

Depth First
     • Simple implementation (stack)
     • Might not terminate
     • Might find non-optimal solution
Breadth First
     • 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

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

                                                                       10th Ave

                                                             50th St
                                         52nd St
                               53nd St

                                                   51st St

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
    • heuristic is admissible

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
 h3(n) = MAX(h1(n),h2(n)) is admissible
  • 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
     • Why not admissible?

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

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