Introduction to Artificial Intelligence Class 1 Planning Search by StuartSpruce

VIEWS: 5 PAGES: 26

									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))
                (not (clear ?under_obj))          add
  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
   • Breadth-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
           Breadth-First Search
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
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
                                                   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
    • 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
 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