CSCI445 Course Notes

Lecture #12: Subsumption Architecture

Last time we saw:

Representation
- types; duration and complexity
- state v. representation
- effects on time scale and looking ahead
Reactive Systems
- complete v. incomplete mappings
- lookup speed
Subsumption Architecture
- principles, AFSMs

System Decomposition

The traditional approach to control was:
- the Sense-Plan-Act (SPA) approach
- inherently sequential (horizontal)
This produces deliberative architectures
Subsumption Architecture was introduced as an alternative to SPA
Subsumption produces inherently parallel (vertical) systems

AFSMs

The structure of FSMs is convenient for incremental system design.
An AFSM can be in one state at a time, can receive one or more inputs, and send one or more outputs.
AFSMs are connected communication wires, which pass input and output messages between them.

Arbitration in Subsumption

Arbitration: deciding who has control
Inhibition: prevents output signals from reaching effectors
Suppression: replaces input signal with the suppressing message
The above two are the only mechanisms for coordination
=> Results in priority-based arbitration
- the rule or layer with higher priority takes over, i.e., has control of the AFSM

Designing in Subsumption

Networks of AFSMs

=> A Subsumption Architecture controller, using the AFSM-based programming language, is a network of AFSMs.
The network is divided into layers
Once a basic competence is achieved (e.g., moving around safely), it is labeled layer 0.
The next layer (1) is added, and communication is done through wires

Layering in AFSM Networks

Layer 1 (e.g., one that looks for objects and collects them), can then be added on top
The use of layers is meant to modularize the reactive system, so it is bad design to put a lot of behaviors within a single layer.
Also, it is bad design to put a large number of connections between the layers, so that they are strongly coupled.

Module Independence

Strong coupling implies dependence between modules, which violates the modularity of the system.
If modules are interdependent, they are not as robust to failure.
In Subsumption, if higher layers fail, the lower ones remain unaffected.
Thus Subsumption has one-way independence between layers.
Two-way independence is not practical, why?

Layering in AFSM Networks

With upward independence, a higher layer can always use a lower one
=> layer 1 certainly can and should be coupled with layer 0. How?
...by using suppression and inhibition
Do we always have to use these wires to communicate between parts of the system?

Using the World

Coupling between layers, and even between AFSMs, need not be through the system itself (i.e., not through explicit communication wires)
It could be through the world.
How?
E.g.: one Subsumption robot (Herbert) collected soda cans and took them home this way.

Herbert

First it searched for soda cans;
When it found one it grabbed it, picked it up, weighed it, ...
if it was heavy (full), put it down, if it was empty, picked it up,
...tucked its arm in, and headed home.
It did not keep internal state about what it had done and what it should do next! -- How?
It just sensed!
When it sensed the can, it reached out. When it had an empty can, it tucked the arm in. When the arm was tucked in, it went home...
There is no internal wire between the AFSMs that achieve can finding, grabbing, arm tucking, and going home.
Still, the events are all executed in proper sequence. Why?
Because the relevant parts of the control system interact and activate each other through sensing the world.
Herbert used vision and a laser striper to find soda cans, and sonars and IRs to wander around safely.
Herbert was implemented by Jon Connell, using individual processors for each AFSM and real wires for each connection in the architecture!

World Is Its Own Best Model

This is a key principle of reactive systems & Subsumption Architecture:
Use the world as its own best model!
If the world can provide the information directly (through sensing), it is best to get it that way, than to store it internally in a representation (which may be large, slow, expensive, and outdated).
Can we always do this?

Subsuption Evaluation