Docstoc

willams-talk.ppt - MIT

Document Sample
willams-talk.ppt - MIT Powered By Docstoc
					Model-based Programming
of Cooperative Explorers

         Prof. Brian C. Williams
  Dept. of Aeronautics and Astronautics
       Artificial Intelligence Labs
           And Space Systems
                    MIT
Classical Robotics
Deep Space Explorers
and Aerial Robots


                                     Cassini Saturn
                                    Orbital Insertion
                                        Complements JPL

                                 Self Repairing

                                     Agile

                       Human-guided stunt helicopter
                              Complements Eric Feron, MIT
                                          and Draper Labs
                                            Cooperative




Exploring Mars: Hetrogenous robotics test bed
Model-based Autonomy and Programming

          How do we program explorers that reason
           quickly and extensively from commonsense
           models?
          How do we incorporate model-based autonomy
           into every day, ubiquitous computing devices
           through model-based programming?
          How do we coordinate heterogeneous teams of
           robots -- in space, air and land -- to perform
           complex exploration?
          How do we couple reasoning, adaptivity and
           learning to create robust agents?
Model-based Programming of
 Self Repairing Explorers
                                         Leading Diagnosis:
                                        •Legs deployed during descent.
                                        • Noise spike on leg sensors
                                        latched by software monitors.
                                        • Laser altimeter registers 50ft.
                                        • Begins polling leg monitors to
                                        determine touch down.
                                        • Latched noise spike read as
                                        touchdown.
  Mars 98:
  • Climate Orbiter                     • Engine shutdown at ~50ft.
  • Mars Polar Lander
                                   Would like to support programmers with
     Must diagnose symptoms             Embedded Languages that
 that are manifest through complex  Reason from Commonsense Models
Software and Hardware Interactions
                                      (Model-based Programming)
                        GS,SITURN,490UA,BOTH,96-355/03:42:00.000;
                        CMD,7GYON, 490UA412A4A,BOTH,      96-355/03:47:00:000,   ON;
                        CMD,7MODE, 490UA412A4B,BOTH,      96-355/03:47:02:000,   INT;
                        CMD,6SVPM, 490UA412A6A,BOTH,      96-355/03:48:30:000,   2;
                        CMD,7ALRT, 490UA412A4C,BOTH,      96-355/03:50:32:000,   6;
                        CMD,7SAFE, 490UA412A4D,BOTH,      96-355/03:52:00:000,   UNSTOW;
                        CMD,6ASSAN, 490UA412A6B,BOTH,     96-355/03:56:08:000,   GV,153,IMM,231,
                                                                                 GV,153;
                        CMD,7VECT, 490UA412A4E,BOTH,      96-355/03:56:10.000,   0,191.5,6.5,
                                                                                 0.0,0.0,0.0,
                                                                                 96-350/
                                                                                 00:00:00.000,MVR;
                        SEB,SCTEST, 490UA412A23A,BOTH,    96-355/03:56:12.000,   SYS1,NPERR;
                        CMD,7TURN, 490UA412A4F,BOTH,      96-355/03:56:14.000,   1,MVR;
                        MISC,NOTE, 490UA412A99A,,         96-355/04:00:00.000,   ,START OF TURN;,
                        CMD,7STAR, 490UA412A406A4A,BOTH   96-355/04:00:02.000,   7,1701,
                                                                                 278.813999,38.74;
                        CMD,7STAR, 490UA412A406A4B,BOTH, 96-355/04:00:04.000,    8,350,120.455999,
                                                                                 -39.8612;
                        CMD,7STAR, 490UA412A406A4C,BOTH, 96-355/04:00:06.000,    9,875,114.162,
                                                                                 5.341;
                        CMD,7STAR, 490UA412A406A4D,BOTH, 96-355/04:00:08.000,    10,159,27.239,
                                                                                 89.028999;
                        CMD,7STAR, 490UA412A406A4E,BOTH, 96-355/04:00:10.000,    11,0,0.0,0.0;
                        CMD,7STAR, 490UA412A406A4F,BOTH, 96-355/04:00:12.000,    21,0,0.0,0.0;




                                            Monitors

                                        Command dispatch
                                         Fault protection
             Command                     Attitude control
             Sequence


Mission Goal Scenario
Robustness involves controlling and
sensing a complex internal network
      Managing Interactions for Self-Repair
Programmers and operators must reason through
system-wide interactions to :
  •   monitor              • reconfigure hardware
  •   track goals          • coordinate control
  •   confirm commands       policies
  •   isolate faults       • repair
  •   diagnose faults      • avoiding failures
Robustness Requires Novel Solutions

                                 Quintuple fault occurs
                                  (three shorts, tank-line and
                                  pressure jacket burst, panel
                                  flies off).
                                 Mattingly works in ground
                                  simulator to identify new
                                  sequence handling severe
                                  power limitations.
                                 Mattingly identifies novel
                                  reconfiguration, exploiting
                                  LEM batteries for power.
           courtesy of NASA
  Example of a Model-based Agent:
                       Goals                           Scripts
• Goal-directed
                                     Remote Agent
• First time correct           Mission            Scripted
                               Manager           Executive
    • projective
    • reactive
• Commonsense models            Planner/
                               Scheduler         Diagnosis
                                                 & Repair
• Heavily deductive              Mission-level
                                  actions &        component models
                                  resources
Started: January 1996
Launch: Fall 1998       courtesy JPL
         Remote Agent Experiment
                       See rax.arc.nasa.gov
May 17-18th experiment
   Generate plan for course correction and thrust
   Diagnose camera as stuck on
     —   Power constraints violated, abort current plan and replan
   Perform optical navigation
   Perform ion propulsion thrust

May 21th experiment.
   Diagnose faulty device and
     —   Repair by issuing reset.
   Diagnose switch sensor failure.
     —   Determine harmless, and continue plan.
   Diagnose thruster stuck closed and
     —   Repair by switching to alternate method of thrusting.
   Back to back planning
Model-based Autonomy and Programming

          How do we program explorers that reason
           quickly and extensively from commonsense
           models?
          How do we incorporate model-based autonomy
           into every day, ubiquitous computing devices
           through model-based programming?
          How do we coordinate heterogeneous teams of
           robots -- in space, air and land -- to perform
           complex exploration?
          How do we couple reasoning, adaptivity and
           learning to create robust agents?
                      Model-based Programs
                    Interact Directly with State
Embedded programs interact with        Model-based programs
plant sensors/actuators:               interact with plant state:
• Read sensors                         • Read state
• Set actuators                        • Write state

                                           Model-based
      Embedded Program
                                         Embedded Program

Obs                      Cntrl


              S                                   S
            Plant                               Plant


Programmer must map between       Model-based executive maps
state and sensors/actuators.      between sensors, actuators to states.
             Orbital Insertion Example




EngineA   EngineB                EngineA   EngineB




  Science Camera                   Science Camera
Model-based Programs
 Evolve Hidden State

             Reactive Control
                Program


  State                               goals



          Model-based Executive


 Observations Flight System Control   Command
                 RT Control Layer
                  Model-based Programs                                                          Reactive Model-based
                                                                                                Programming Language:
                                                                                                 State assertion

                   Evolve Hidden State                                                           State query
                                                                                                 Conditional execution
Programmer specifies        Thrust
                            Goals                       Delta_V(direction=b, magnitude=200)      Preemption

abstract state evolutions                                                                        Iteration

                                                                                                 Concurrent execution
                            Power


Programs “read” and                        Temporal planner
“set” variables that        Attitude      Point(a)
                                                                             OrbitInsert()::
are typically hidden.
                            Engine        Off                                       Off
                                                                             (do-watching ((EngineA = Firing) OR
                                                                                            (EngineB = Firing))
                    Inferred State                                                Goal state
                                                                                (parallel
                                                                                      (EngineA = Standby)
                                                                                      (EngineB = Standby)
                                                                                      (Camera = Off)
                                       Model-based Executive
                                                           (do-watching (EngineA = Failed)
                                                                                              (when-donext ( (EngineA = Standby) AND
                                                                                                              (Camera = Off) )
                                                                                                 (EngineA = Firing)))
                                                                                      (when-donext ( (EngineA = Failed) AND
                        Observations Flight System Control                             Command (EngineB = Standby) AND
                                                                                                      (Camera = Off) )
                                                     RT Control Layer                    (EngineB = Firing))))
           RMPL Executive Reasons
             from Plant Model
                             Thrust
                             Goals                       Delta_V(direction=b, magnitude=200)




                             Power

                                            Temporal planner
                             Attitude      Point(a)
                                                                              OrbitInsert()::

                             Engine        Off                                       Off
                                                                              (do-watching ((EngineA = Firing) OR
                                                                                             (EngineB = Firing))
                           State                                                   goals
                                                                                 (parallel
                                                                                       (EngineA = Standby)
                                                                                       (EngineB = Standby)
            Valve                                                                      (Camera = Off)

 Open
                   0.01         Stuck   Model-based Executive
                                                            (do-watching (EngineA = Failed)
                                open                                                           (when-donext ( (EngineA = Standby) AND
Model
               0. 01
                                                                                                               (Camera = Off) )
    Open   Close
                                                                                                  (EngineA = Firing)))
              0. 01
                               Stuck                                                   (when-donext ( (EngineA = Failed) AND
Closed             0.01   Observations
                               closed            Flight System Control                  Command (EngineB = Standby) AND
                                                                                                       (Camera = Off) )
                   inflow = outflow = 0
                                                      RT Control Layer                    (EngineB = Firing))))
             RMPL Executive Reasons
               from Plant Model
                              Thrust
                              Goals                       Delta_V(direction=b, magnitude=200)




                              Power

                                             Temporal planner
                              Attitude      Point(a)
                                                                               OrbitInsert()::

                              Engine        Off                                       Off
                                                                               (do-watching ((EngineA = Firing) OR
                                                                                              (EngineB = Firing))
                        State                                                       goals
                                                                                  (parallel
                                                                                        (EngineA = Standby)
                                                                                        (EngineB = Standby)
                                                                                        (Camera = Off)
mode = open 
                                         Model-based Executive
                                                             (do-watching (EngineA = Failed)
 high pressure = high flow;                                                                     (when-donext ( (EngineA = Standby) AND
Model
nominal pressure = nominal flow;                                                                                (Camera = Off) )
 ...                                                                                               (EngineA = Firing)))
                                                                                        (when-donext ( (EngineA = Failed) AND
                      Observations Flight System Control                                 Command (EngineB = Standby) AND
mode = closed                                                                                          (Camera = Off) )
 Zero flow                                             RT Control Layer                    (EngineB = Firing))))
             RMPL Executive Reasons
               from Plant Model
                             Thrust
                             Goals                    Delta_V(direction=b, magnitude=200)


                                  Achieve Thrust
                             Power


State estimates          State Goals Temporal                  planner
                             Attitude   Point(a)



                     ˆ
                     s
  Estimation                      Commanding
                             Engine    Off                                           Off

  & Diagnosis                       & Repair
                          State                                                    goals


                  Engine Off fails
                        Valve
                               Model-based Executive four
                       stuck closed
                                                 Open                                          Fire backup
                                                                                    valves        engine
    Model

                         Observations Flight System Control                          Command
                                                   RT Control Layer
      Model-based Programming
Automate programmers ability to reason from
commonsense models in light of mission goals.

• Model-based Reactive Programming
   • Programmer guides state evolution at strategic levels.
• Commonsense Modeling
   • Programmer specifies commonsense, compositional models of
     spacecraft behavior.
• Model-based Execution Kernel
   • Reason through system interactions on the fly,
     performing deduction within the reactive control loop.
•Model-based Compilation
   • Reduce knowledge to a vivid form, think through local contingencies.
OPSAT: Exploring the Improbable
  When you have eliminated the impossible,
  whatever remains, however improbable, must be
  the truth.     - Sherlock Holmes. The Sign of the Four.


Generate Best Options:
  • Generalize test results to leap over infeasible options
Test Against Model:
   • Incrementally deduce how truth changes

                                     Test         Best
                                                 Feasible
                               Checked           Options
                    Generate    option   Conflicting
                                          Elements
         Compare Most Likely Hypothesis to Observations



                                                          Helium tank




            Oxidizer tank             Fuel tank
   Flow1 = zero                             Pressure2= nominal
Pressure1 = nominal




                             Main
                            Engines
  Acceleration = zero

   It is most likely that all components are okay, and the valves are in
   the mode indicated.
               Isolate Conflicting Information


                                               Helium tank




      Oxidizer tank             Fuel tank

Flow 1= zero




                       Main
                      Engines

The component modes indicated in red conflict with the model and
observations.
       Leap to the Next Most Likely Hypothesis
              that Resolves the Conflict


                                                 Helium tank




      Oxidizer tank             Fuel tank

Flow 1= zero




                       Main
                      Engines

The next consistent hypothesis must differ from the conflict
by at least one component mode.
          New Hypothesis Exposes Additional Conflicts


                                                         Helium tank




          Oxidizer tank             Fuel tank
Pressure1 = nominal                       Pressure2= nominal




                           Main
                          Engines
 Acceleration = zero

  Next consistent hypothesis must differ from both conflicts
       Final Hypothesis Resolves all Conflicts


                                                         Helium tank




          Oxidizer tank             Fuel tank
Pressure1 = nominal                       Pressure2= nominal
   Flow1 = zero                            Flow2 = positive




                           Main
                          Engines
 Acceleration = zero

  Implementation: Hypotheses generated by minimal set covering,
                  guided by A* search.
Model-based Autonomy and Programming

          How do we program explorers that reason
           quickly and extensively from commonsense
           models?
          How do we incorporate model-based autonomy
           into every day, ubiquitous computing devices
           through model-based programming?
          How do we coordinate heterogeneous teams of
           robots -- in space, air and land -- to perform
           complex exploration?
          How do we couple reasoning, adaptivity and
           learning to create robust agents?
     Model-based Programming of Cooperative Systems




   How do we model behaviors of cooperative robotic networks?
   How do we command cooperative networks?
   How do we monitor cooperative networks?
    Managing Interactions for Cooperation
Programmers and operators must reason through
system-wide interactions to :

• select among            • select deadlines
  redundant
  procedures              • select timing
                            constraints
• Evaluate outcomes
                          • allocate resources
• Plan contingencies
     Model-based Cooperative Programming
                                                                c
• Model-based Programs
                                                            
                                                               If c next A
                                                               Unless c next A
  • Specify team behaviors as concurrent programs.             A, B
                                                               Always A
  • Specify alternatives using decision theoretic choice.
                                                                Choose reward
  • Specify timing constraints between activities.          

                                                               A in time [t-,t+]


• Model-based Execution
  • Looks before it leaps
   Pre-plans threads of execution that are            Decision-theoretic
    optimal and temporally consistent.                 Temporal Planner

  • Responds at reactive timescales
   Perform planning as graph search

  Navigates globally
               Mission Scenario
                                        TWO        ONE


HOME


                                              Enroute
                           RENDEZVOUS                    RESCUE AREA
Station: ABC




                                                                       Diverge
Station: XYZ


                                                                                 RESCUE LOCATION




                      MEETING POINT
Enroute Activity:

                    Enroute


                       Corridor 2




Rendezvous             Corridor 1   Rescue Area



                       Corridor 3
                RMPL for Group-Enroute
Group-Enroute()[l,u] = {
                                                         Non-deterministic
   choose {
      do {                                               choice:
         Group-Traverse-Path(PATH1_1,PATH1_2,PATH1_3,RE_POS)[l*90%,u*90%];
      } maintaining PATH1_OK,
      do {
         Group-Traverse-Path(PATH2_1,PATH2_2,PATH2_3,RE_POS)[l*90%,u*90%];
      } maintaining PATH2_OK
   };
   {
      Group-Transmit(OPS,ARRIVED)[0,2],
      do {
         Group-Wait(HOLD1,HOLD2)[0,u*10%]
      } watching PROCEED
   }
}
                      RMPL Interpreter
   Dynamically selects among alternate executions, satisfies open
    conditions and checks schedulability,
   Selects execution times, monitors outcomes and plans
    contingencies.
                           RMPL Program


          • Kirk       Reactive Temporal Planner

          • Idea            Plan Executive
                                    (Hidden) States
          • Titan
Model of                                            • monitor activities
Networked         Mode Estimation Reactive Planning • diagnose plan
Embedded                                              failures
 Vehicles
                     Observables         Commands
                   Enroute Activity:

     • Least cost threads of execution generated by extended auction algorithm
price = 425                                                                                                        price = 0

     1                                                 [450,540]                                                         2


 0                                                                                                                       0
                                                                                                           Extend Path


                                    425                                                  30
                         4                    5                                 9                10
                                                      0                0                                      0
              0       price = 425         price = 0                         price = 30        price = 0

         3                                                     8                                                   13
                                                           price = 0
price = 425                                                                                                    0 price = 0
                                                       0                0
                  0                 440                                                   1
                         6                    7                                11                12
                      price = 440         price = 0                         price = 1          price = 0




                                                  9  10
     Path P = 1  3  4  5  8                                    13  2
                                                  11  12
     Start Node : 1
     End Node: 2
        Temporal planning is combined with randomized
        path planning to find a collision free corridor
                         Path 1




xinit                                                     xgoal
  4                                     Xobs               5
                     Robotic Vehicles




   ATRV Rovers
   Monster Trucks
   Blimps
   Spheres

   Simulated Air/Space Vehicles
                               Scenario
Cooperative Target Site Exploration:
Heterogeneous rover team and blimps explore science sites determined by remote
   sensing
                                              Tasks:
                                              • small scout rovers (ATRV Jr)
                                                 explore terrain as described in
                                                 earlier scenarios
                                              • blimps provide additional fine grain
                                                 air surveillance
                                              • scout rovers identify features for
                                                 further investigation by sample
                                                 rover (ATRV)
                                              • scout rovers provide refined terrain
                                                 mapping for path planning of the
                                                 larger sample rover

                                              Scenario Research Objective
   exploration feature   exploration region   • Extend coordination to
   path planned/taken    identified feature      heterogeneous team …
   way point             goal position
        Summary: Model-based Autonomy
   To survive decades autonomous systems must orchestrate
    complex networks of devices.
   In model-based autonomy, programming involves
    specifying strategies as abstract state evolutions, and
    specifying commonsense models.
   Runtime kernels are agile, deducing and planning from
    these models within the reactive loop.
   Model-based programming languages and kernels are
    broadening out to cooperative and hybrid systems.

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:1
posted:4/4/2013
language:English
pages:42