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)