2. Behavior-Based Robotics: Introduction and Definitions

What is behavior-based robotics (BBR)?

Mataric' Definition:

Behavior-based robotics (BBR) bridges the fields of artificial intelligence, engineering, and cognitive science. The behavior-based approach is a methodology for designing autonomous agents and robots; it is a type of intelligent agent architecture. Architectures supply structure and impose constraints on the way robot control problems are solved. The behavior-based methodology imposes a general, biologically inspired, bottom-up philosophy, allowing for a certain freedom of interpretation. Its goal is to develop methods for controlling artificial systems (usually physical robots, but also simulated robots and other autonomous software agents) and to use robotics to model and better understand biological systems (usually animals, ranging from insects to humans).

Take a look at Mataric' article in the MIT Encyclopedia of Cognitive Science at COGNET (cognet.mit.edu/MITECS/).

What are behaviors?

Again from Mataric:

Behavior-based robotics controllers consist of a collection of behaviors that achieve and/or maintain goals. For example, "avoid-obstacles" maintains the goal of preventing collisions; "go-home" achieves the goal of reaching some home destination. Behaviors are implemented as control laws (sometimes similar to those used in control theory), either in software or hardware, as a processing element or a procedure. Each behavior can take inputs from the robot"s sensors (e.g., camera, ultrasound, infrared, tactile) and/or from other behaviors in the system, and send outputs to the robot"s effectors (e.g., wheels, grippers, arm, speech) and/or to other behaviors. Thus, a behavior-based controller is a structured network of interacting behaviors.

Motivation: compare to "finite-state machines (FSMs)" (e.g., the 2nd to last sentence in the above quote)

many architectures are actually direct variants of FSMs (e.g., subsumption,situated automata, and others)

Need to implement control components that achieve "behaviors" and arrange them in a control system so that the transitions between behaviors occur according to specification, i.e., need an "architecture"
Lots of different architectures out there, can be characterized by an "architecture schema"

Architectures

In general, architectures specify an arrangement of components (or functional units) and how they are connected
Consequently, architectures define what is commonly called "virtual machine" in CS (e.g., a non-physical, "software" machine with interacting "software" parts)

Will talk much more about what these components can be later (for now, think of a "planning mechanism", for example)

Main way to "carve up" architecture space: reactive vs. deliberative architectures

Or better: deliberative vs. non-deliberative as "reactive" has different meanings to different people:

reactive as "stateless"
reactive as "(tight) sensor-motor coupling" (no intermediary processing)
reactive as "simple"
reactive as "non-representational"
reactive as "fast, timely response"

Hence, be very careful when you read the term "reactive", it may not mean what you think it means!

One (strong) characterization of deliberative architectures:they have components to perform "what-if" reasoning

need to be able to entertain representations of non-existent states (among other things)

Also possible: hybrid architectures that combine reactive and deliberative "sub-architectures"

Other dimensions of architectural variation (Fig. 1.10 in the Arkin book is only partially useful):

Arrangement of components

e.g., components arranged in a "hierarchy" (e.g., where components on higher levels dominate components on lower levels)?

Flow of control

e.g., sequential activation of components (cp. the "Omega" model by Albus, 1981)

Self-modifying vs. non-selfmodifying architectures

e.g., architectures with learning mechanisms

Functional dependence on external factors vs. independent functioning

e.g., a chess program vs. controller of a machine (think of the "thermostat" controlling the blinker)

Functions of components vs. emergent functions

e.g., "wall-following" implemented in a special components vs. emergent from other the functioning of other components

Behavior arbitration

e.g., centralized arbiter that decides which "behavior to execute"

Will talk a lot about architecture in this course

Animal Behavior

Why should we care? - Because nature solved most of the problems we are interested in (and typically there are many different solutions...)
Animals exhibit "intelligent behavior" (i.e., behavior that makes it likely that they will survive)

"Survival" is the touchstone of intelligent behavior!

Look at nature's solution at different levels:

the cognitive/architecture level (psychology)
the behavior/environmental level (ethology)
the mechanism/implementation level (neuroscience)

These disciplines contribute in different ways:

from psychology we functional components (e.g., memory, emotions, etc.)

understanding the behavior of an organism in terms of stimulus-response diagrams (behaviorism)
understanding the information in the environment that the organism can use (ecological psychology)
understanding the internal (cognitive) processes that drive behavior (cognitive psychology)

from ethology we get behavioral networks (i.e., functional breakdowns of the behavioral repertoires of animals, e.g., into "reflexes", "taxes", and "fixed action patterns")

understanding the ecological niche of an organism in terms of its evolutionary trajectory (evolutionary biology)
understanding the animals behavior in terms of the animal's natural habitat (animal behaviorism)

from neuroscience: implementation paradigms (e.g., neural networks and schemas)

understanding the neural underpinnings of cognitive processes (cognitive neuroscience)
understanding the architectural organization and properties of neural systems (neurophysiology)

New field: "biorobotics"--model nature (remember: this is stronger than just being "inspired"!)

take a look at the Webb BBS article (reference on a previous handout) for an extensive bibliography to the state-of-the-art in biorobotics

Will take the "animal stance" in this course:

will design "controllers" for robots explicitly viewing them as "animals" that

inhabit a particular environment
have to cope with various environmental conditions
need to survive (long enough...)
have "reproductive goals"

need to specify all of the about for every controller/robot we design

How to Evaluate Behavior

What are robotic behaviors?

First, be clear on the level of description: behavior or implementation
Note: we are sloppy in that we use the term “behavior” for both the observational description and the implementation of components (which implement the functions as described by the behavioral description)

Example: reactive systems

Keep in mind the different readings of "reactive"!
Arkin's characterization:

Behaviors serve as the basic building blocks for robotic action
Use of explicit abstract representational knowledge is avoided in the generation of a response
Animal models of behavior often serve as a basis for these systems
These systems are inherently modular from a software design perspective (cp. to the credo of “evolutionary roboticists”)

Claim: planning is not necessary to achieve effective navigation (i.e., only need reactive system for navigation—this is in contrast to classical systems like Shakey that used planning all the time)
Careful: this is a strong claim if read "not necessary in any circumstance" (reactive systems have very clear limitations, e.g., how to get to the airport without planning?)
Important: understand what the domains are in which reactive control is advantageous

Issue: where do “behaviors” come from? More specifically, how do we design a BB robot?

Follow-up questions:

what is the overall architecture?
what are the primitives (i.e., the smallest building blocks or components) that we can use?
how do those building blocks correspond to functional descriptions?
keep in mind that there may not be a clear correspondence for every behavior (e.g., when behaviors emerge...)
how do we connect these components (within the architecture and to sensors/effectors)?

Different design methodologies:

ethologically guided

consult ethological literature
extract model
import model to robot
run robotic experiments
evaluate results
possibly do new biological experiments
enhance models
import model to robot
etc.

situated activity

assess agent-environment dynamics
partition into situation
create situational responses
import behaviors to robot
run robotic experiments
evaluate results
enhance, expand, correct behavioral responses
import model to robot
etc.

experimentally driven

build minimal system
exercise robot
evaluate results
add new behavioral competence