Expressing/describing behaviors
-
Need to capture our behavioral descriptions (e.g., formalize them)
-
Different ways of capturing them:
-
stimulus-response diagrams
-
(mathematical) functional notation
-
finite state machines
-
formal methods (e.g., robotic schemas, situated automata, JAVA programs,
etc.)
-
Will talk in detail about different ways to express/describe behaviors
Implementing "Behaviors"
How can we enocde/implement "behaviors"?
-
Remember: stimulus-response diagrams denote functions, i.e., mappings f(S)->R
(where S is the domain of stimuli and R the domain of responses)
-
Hence, in general a behavior is such any mapping from possible
stimuli to possible responses
-
What are possible stimuli?
-
depends on sensors (e.g., pixel images in the case of cameras, a frequency
spectrum for microphones, etc.)
-
In general: a stimulus can be taken to be a tuple <p,lambda>,
where p denotes a particular perceptual class and lambda denotes
the intensity of the stimulus
-
What are the responses?
-
depends on effectors or actuators (e.g., motors, wireless transmitters,
etc.)
-
often expressed in terms of strength and orientation for
motors (think of vectors!)
-
In general: if a motor response involves physical movement, then it can
be characterized by a six-tuple <x,y,z,theta,phi,psi>
(three translational and three rotational degrees of freedom-an
unconstrained rigid object has six DOFs)
-
Distinguish: holonomic from non-holonomic (a
"non-holonomic constraint" is a limitation on the allowable velocities
of an object)
-
For both stimuli and response, a notion of "strength" has to be defined
-
Issue: what is the magnitude?
-
Interesting dichotomies:
-
discrete vs. continuous (in time and/or space)
-
analog vs. digital
-
simple vs. complex
-
structured vs. unstructured
-
First Mantra of reactive BBR: the presence
of a stimulus is necessary, but not sufficient to evoke a motor response
in a BB robot.
-
Hence, need a threshold tau
What is a behavioral mapping?
-
Formally for motors: f:(p,lambda)-><x,y,z,theta,phi,psi>
(where <x,y,z,theta,phi,psi>=<0,0,0,0,0,0>
if lambda<tau)
-
In addition: gains (to modify response strength, also used to "integrate
behaviors", will talk about this later)
-
e.g., <a,b,c,d,e,f><x,y,z,theta,phi,psi>
(g=<a,b,c,d,e,f> is
a vector of scalars that modify the respective components of the response
r,
put more succinctly: r'=gr)
-
Note: f can be any function
-
However: often used functions are
-
constant (e.g., "move at a constant speed)
-
"binary" threshold (e.g., "stop when wall is encountered")
-
linear (e.g., "move faster the farther you are away from a wall")
-
combinations of the above (e.g., "move at a constant speed while you cannot
sense a wall, once you sense it slow down proportional to the distance to
the wall, and stop once you reached a critical threshold")
-
Distinguish: discrete vs. continuous responses
-
discrete responses categorizes the sensory space into discrete categories
and map a particular response to each domain (as in the above examples)
-
continuous responses do not categorize the sensory space, rather
they establish "correlations" (or more to the point: functional dependencies)
between stimuli and responses--force metaphor
-
Problem: how to integrate two or more behavioral mappings? (no issue if
we only have one, e.g., as for toy problem one)
-
Need to think of ways how to achieve this integration, since most likely
we will have different behaviors that the robot should exhibit at different
times
-
Subsequent issues: action selection and behavior arbitration
Assembling and Implementing "Behaviors"
Discrete vs. continuous encoding of behaviors
-
What exactly is the difference?
-
First cut: finitely vs. potentially infinitely many responses
-
Note: infinitely many behavioral responses are only possible, if sensory
space is also infinite (not very likely!)
-
Second cut: granularity of response
-
Compare: "moving forward" (for some time) vs. "moving forward one yard"
or "moving forward for 10 seconds at speed 1/10 yard/sec"
-
Third cut: architectural representation of response
-
In the former case, there is component for "moving forward" that may or
may not give rise to the specific "moving forward one yard" (given other
components and their interactions), whereas in the latter there is a particular
component for "moving forward one yard"
-
Different ways of discrete encodings:
-
Condition-action rules: IF perception/condition THEN action
ENDIF
-
E.g., Nilsons teleo-reactive rules (e.g., "forward at speed s"--e.g.,
as opposed to "forward one yard")
-
Goal-reduction rules (Gapps, situated automata): ACHIEVE condition/action
DO action ACHIEVE action/condition ... ENDACHIEVE
-
Brook's Behavior Language: WHENEVER condition &rest body-forms)
-
Most so-called "agent architectures" specify a finite set of "possible
actions" (e.g., dynamic logic and various logics used to describe
the temporal behavior of systems)
-
An agent is usually construed as a function F:(Inputs,States)->(Actions,States)
(FSM!)
-
Advantages: <fill in>
-
Disadvantages: <fill in>
-
Continuous encodings:
-
Use continuous mapping from sensors to motors, i.e., express relationship
of what to do
-
Commonly used: vector fields
-
Environment is construed as a vector space where in each location a vector
indicates the direction and strength of the motor response (may have to
do this for different motors)
-
Vectors are used as "forces", where forces are usually related to distance
in space by the "inverse-square law": force = 1/(distance*distance)
-
Use: attractive and repulsive forces to "classify" sensory
stimuli (i.e., some stimuli will produce attractive forces, others will
produce repulsive forces)
-
Advantages: <fill in>
-
Disadvantages: <fill in>
Behavior coordination
-
Need to integrate different behaviors to get interesting system behavior
-
Design issues:
-
what is the overall behavior the system needs to achieve
-
how can it be broken down into components
-
General case: given S (stimuli vector), B (vector of all
behavior functions), G (vector of gains for each behavior),
we get the response vector R=G*B(S)
-
Need to select one component of R, hence need a "coordination" function
C
from vectors to scalars: ro=C(R)
-
C is also called "coordination function (strategy)" or "action-selection
function (mechanisms)"
-
Different coordination/action-selection methods:
-
competitive
-
priority-based arbitration (e.g., through dominance hierarchies, where
higher levels dominate or suppress lower levels)
-
winner-takes-it-all (e.g., the highest activation of all behaviors gets
exclusive control of the motors)
-
direct competition (through excitation and inhibition)
-
voting for actions
-
cooperative
-
"field fusion" (remember: vector fields are "additive")
-
"desirability vectors" (e.g., try to find action that maximizes the desirability
values of the behaviors)
-
Putting things together:
-
parallel execution vs. sequencing of actions
-
hierarchical vs. non-hierarchical organization
-
=> architectures!
-
Issue: emergence of behavior, very tricky notion (often poorly presented
and understood, for a good discussion, see Wimsatt http://www.ageofsig.org/3M/archive/wimsatt.pdf)
This page is maintained by:
Matthias Scheutz
Copyright © Matthias Scheutz 2003
University of Notre Dame
All rights reserved.
Last revised on January 27, 2003