No Slide TitleHerbert, the soda can collector (MIT, Connell and Brooks, 1987)
NOTE: Exam #1 is NEXT THURSDAY (Feb. 15)
What to expect for Exam #1:
–Will cover all lecture notes through Thursday Feb. 8
–Will cover all extra readings (2 to date, Chapters 1 and 3 of Arkin text))
–Will cover Murphy text, chapters 1 – 4
Today’s Objectives
• To understand two different reactive architectures: – Subsumption
– Motor schemas
Recall Last Time: Behavioral Encodings
• Expression of behaviors can be accomplished in several ways: – SR diagrams – Functional notation – FSA diagrams
• Behaviors can be represented as triples (S, R, β )
• A strength multiplier, or gain g, can be used to turn off behaviors or alter the response’s relative strength.
• Responses are encoded in two forms: – Discrete encoding – Continuous functional encoding
b(s) = r, where: b = behavior s = stimulus r = response
Recall: Navigational Example (we’ll continue with this today)
• Consider student going from one room to another. What is involved? – Getting to your destination from your current location – Not bumping into anything along the way – Skillfully negotiating your way around other students who may have the same
or different intentions – Observing cultural idiosyncrasies (e.g., deferring to someone of higher priority
– age, rank, etc.; or passing on the right (in the U.S.), …) – Coping with change and doing whatever else is necessary
Assembling Behaviors
• Issue: When have multiple behaviors, how do we combine them? • Think about in terms of: Navigation example from last week:
Move-to-class C O O R D I N A T O R
Avoid-object
Action
• Emergent behavior: sum is considerably greater than its parts
• True: Behavior-based outcome is often a surprise to the designer
• But: is the surprise due to shortcoming of the analysis of the constituent behaviors and their coordination, or something else?
Meaning of “Emergence”
• Emergence is: “the appearance of novel properties in whole systems” (Moravec 1988)
• “Global functionality emerges from the parallel interaction of local behaviors” (Steels 1990)
• “Intelligence emerges from the interaction of the components of the system” (Brooks 1991)
• “Emergent functionality arises by virtue of interaction between components not themselves designed with the particular function in mind” (McFarland and Bosser 1993)
Common thread: emergence is a property of a collection of interacting components (here, behaviors)
Question: If individual behaviors are defined functionally, why should coordinated collection produce unanticipated results?
• The coordination functions we will study are algorithms, and therefore possess no magical properties
• Can be straightforward: – E.g., choosing highest ranked or most dominant behavior
• Can be more complex: – E.g., fusion of multiple active behaviors
• Nevertheless: they are deterministic and computable
• So, why can’t we predict their behavior exactly?
Answer Lies in Relationship of Robot with Environment
• For most situations in which behavior-based paradigm is applied: – The world itself resists analytical modeling – Nondeterminism is rampant – Real world is filled with uncertainty and dynamic properties – Perception process is poorly characterized
• Precise sensor models for open worlds do not exist
• If a world model could be created that accurately captured all of its properties, then: – Emergence would not exist – Accurate predictions could be made
• But, since the world resists such characterization, we cannot predict a priori, with any degree of confidence, in all but the simplest worlds, how the world will present itself.
• Probabilistic models can provide guidance, but not certainty.
Summarizing Emergent Properties…
• But, nothing mystical about them
• Consequence of: – Complexity of the world in which the robot resides – Complexity of perceiving that world – Complexity of interactions of agents and the world
Notation for Combining Behaviors
• S denotes vector of all stimuli, si ,relevant for each behavior βi detectable at time t.
• B denotes a vector of all active behaviors βi at a given time t
• G denotes a vector encoding the relative strength or gain gi of each active behavior βi.
• R denotes a vector of all responses ri generated by the set of active behaviors.
Notation for Combining Behaviors (con’t.)
Behavioral coordination function C is defined such that: ρ = C(G * B(S))
or, alternatively:
R = , S = , G = , and B =
ρ= vector encoding the global response that the robot will undertake, represented in the same form as r (e.g., [x, y, z, θ, φ, ψ]).
[ ]r1 r2 … rn
[ ] [ ] [ ]g1 g2 … gn
β1 β2 … βn
s1 s2 … sn
* Denotes scaling operation for multiplication of each scalar component (gi) by the corresponding magnitude of the component vector ri.
( In other words, result is a response reaction in the same direction as ri, with its magnitude scaled by gi.)
Defining Coordination Function C
• Two main strategies: – Competitive
• E.g., Pure arbitration, where only one behavior’s output is selected
– Cooperative • Blend outputs of multiple behaviors in some way consistent with agent’s overall
goals • E.g., vector addition
Revisit Classroom Navigation Example
• Robot current perceptions at time t:
for each si = (p,λ), where λ is the stimulus p’s percentage of maximum strength
(class_location,1.0) (detected_object, 0.2)
S =
Then, behavioral response is:
βmove-to-class(s1) βavoid-object(s2)
βdodge-student(s3) βstay-right(s4)
Rmagnitude = 1.0 0
0.8 1.0 0
(where each ri encodes an [x,y,θ] for this particular robot expressing the desired directional response for each independent behavior)
Revisit Classroom Navigation Example (con.’t)
• Remember: ρ = C(G * R) • Before the coordination function C is applied, R’ = G * R
yielding:
G = =
R’magnitude = 0.8 0
g1 * r1 g2 * r2 g3 * r3 g4 * r4 g5 * r5
Competitive Methods for Defining C
• Provide a means of coordinating behavioral response for conflict resolution
• Can be viewed as “winner take all”
• Arbitration can be: – Fixed prioritization – Action selection – Vote generation
Competitive Method #1: Arbitration via Fixed Prioritization
Behavior 4P E R C E P T I O N
Behavior 3
Behavior 2
Priority-based coordination
Competitive Method #2: Arbitration via Action Selection
Behavior 4P E R C E P T I O N
Behavior 3
Behavior 2
Behavior 1
MAX(act(B1),act(B2),act(B3),act(B4)) R = R
Action-Selection coordination
• Behaviors compete through use of activation levels driven by agent’s goals
Prioritization varies during mission
Competitive Method #3: Arbitration via Voting
Behavior 4P E R C E P T I O N
Behavior 3
Behavior 2
Behavior 1
R = MAX(votes(R1),votes(R2), votes(R3),votes(R4) votes(R5))
Voting-based coordination
• Pre-defined set of motor responses; • Each behavior allocates votes (in some distribution) to each motor response • Motor response with most votes is executed
Prioritization varies during mission
Cooperative Methods for Defining C
• Behavioral fusion provides ability to concurrently use the output of more than one behavior at a time
• Central issue: finding representation amenable to fusion
• Common method: – Vector addition using potential fields – Example potential field:
– (Lots more on this next time)
Cooperative Method #1: Behavioral Fusion via Vector Summation
Behavior 4P E R C E P T I O N
Behavior 3
Behavior 2
Behavior 1
– Cooperative • Vector addition • Etc.
Representative Reactive/Behavior-Based Architectures
• Reminder: What is a robotic architecture? – “Robotic architecture is the discipline devoted to the design of highly specific and
individual robots from a collection of common software building blocks” – “Robotic architecture is the abstract design of a class of robots: the set of structural
components in which perception, reasoning, and action occur; the specific functionality and interface of each component, and the interconnection topology between components
– “Robotic architecture provides a principled way of organizing a control system. However, in addition to providing structure, it imposes constraints on the way the control problem can be solved”
– “Robotic architecture describes a set of architectural components and how they interact”
• To study today: – Subsumption – Motor Schemas
Comparing and Constrasting Alternative Architectures
• Commonalities: – Emphasis on the importance of coupling sensing and action tightly – Avoidance of representational symbolic knowledge – Decomposition into contextually meaningful units (e.g., behaviors or situation-action
pairs)
Robot Architectures and Computability
• From computational perspective, architectures are equivalent in their computational expressiveness.
• Similar to choice of programming language (C, C++, Java, LISP, Cobol, Fortran, Pascal, etc.)
• Recall results of Bohm and Jacopini (1966) concerning computability in programming languages: – Proved that if any language contains:
• Ability to perform tasks sequentially • Conditional branching • Iteration then it can compute entire class of computable functions (i.e., it is Turing
equivalent)
Example Reactive/Behavior-Based Robots
Evaluating Architectures
• How do we evaluate an architecture’s suitability for a particular problem?
– Support for parallelism – Hardware targetability – Niche targetability – Support for modularity – Robustness – Timeliness in development – Run time flexibility – Performance effectiveness
Foraging Example
• As an example to consider, let’s look at robotic foraging
• Foraging: – Robot moves away from home base looking for attractor objects – When detect attractor object, move toward it, pick it up, and return it to home
base – Repeat until all attractors in environment have been returned home
• High-level behaviors required to accomplish foraging: – Wander: move through world in search of an attractor – Acquire: move toward attractor when detected – Retrieve: return the attractor to the home base once required
Example of Cooperative Foraging
Start Wander
Modify the WorldSense
Create Maps Model
Plan Discover New Areas
Tenets of the Subsumption Architecture
• Complex behavior need not be the product of a complex control system • Intelligence is in the eye of the observer • The world is its own best model • Simplicity is a virtue • Robots should be cheap • Robustness in the presence of noisy or failing sensors is a design goal • Planning is just a way of avoiding figuring out what to do next • All onboard computation is important • Systems should be built incrementally • No representation. No calibration. No complex computers. No high-
bandwidth communication.
inhibition and suppression) Programming method Old method uses AFMs; newer method uses
Behavior Language Robots fielded Allen, Genghis, Squirt, Toto, Seymour, Polly,
etc. References Brooks 1986; Brooks 1990
Subsumption Robots
• Allen • Tom and Jerry • Genghis and Attila • Squirt • Toto • Seymour • Tito • Polly • Cog
Coordination in Subsumption
• “Subsumption” comes from coordination process used between layered behaviors of architecture
• Complex actions subsume simpler behaviors • Fixed priority hierarchy defines topology • Lower levels of architecture have no “awareness” of upper levels
• Coordination has two mechanisms: – Inhibition: used to prevent a signal being transmitted along an AFSM wire
from reaching the actuators – Suppression: prevents the current signal from being transmitted and replaces
that signal with the suppressing message
Subsumption Based on Augmented Finite State Machines (AFSM)
Reset Suppressor
• AFSM encapsulates a particular behavioral transformation function βi
• Stimulus or response signals can be suppressed or inhibited by other active behaviors • Each AFSM performs its own action and is responsible for its own world perception • No global memory, bus, or clock • No central world models • No global sensor representations • Each behavior can be (but is not required to be) mapped onto its own processor • Later versions of subsumption:
– Use Behavior Language, which provides higher abstraction independent of AFSM, using a single rule set to encode each behavior
– High-level language is then compiled to the intermediate AFSM, which can then be further compiled to run on a range of target processors
Example of 3-Layered Subsumption Implementation
Run Away
Avoid-Objects Layer
Foraging Example
• Behaviors Used:
– Wandering: move in a random direction for some time
– Avoiding: • Turn to the right if the obstacle is on the left, then go • Turn to the left if the obstacle is on the right, then go • After three attempts, back up and turn • If an obstacle is present on both sides, randomly turn and back up
– Pickup: Turn toward the sensed attractor and go forward. If at the attractor, close gripper.
– Homing: Turn toward the home base and go forward, otherwise if at home, stop.
Organization for Subsumption-Based Foraging Robot
Homing
Pickup
Avoiding
Wandering
S
S
S
• Behavioral layers implemented: – Standup – Simple walk – Force balancing – Leg lifting – Whiskers – Pitch stabilization – Prowling – Steered prowling
Two motors per leg:
α = advance, which swings leg back and forth β = balance, which lifts leg up and down
Genghis AFSM Network
“Core Subset” of Genghis AFSM Network
walk up leg trigger
alpha balance alpha pos
Enables robot to walk without any feedback: • Standup • Simple walk
Evaluation of Subsumption
logic circuitry – Support for parallelism: Each behavioral layer can run independently and asynchronously – Niche targetability: Custom behaviors can be created for specific task-environment pairs
• Null (not strength/not weakness): – Robustness: Can be successfully engineered into system but is often hard-wired and hard to
implement – Timeliness for development: Some support tools exist, but significant learning curve exists
• Weaknesses: – Run time flexibility: priority-based coordination mechanism, ad hoc aspect of behavior
generation, and hard-wired aspects limit adaptation of system – Support for modularity: behavioral reuse is not widely done in practice
Preview of Next Class
• More about Motor Schemas
Today’s Objectives
Recall: Navigational Example(we’ll continue with this today)
Assembling Behaviors
Meaning of “Emergence”
Answer Lies in Relationship of Robot with Environment
Summarizing Emergent Properties…
Defining Coordination Function C
Revisit Classroom Navigation Example
Competitive Methods for Defining C
Competitive Method #1: Arbitration via Fixed Prioritization
Competitive Method #2: Arbitration via Action Selection
Competitive Method #3: Arbitration via Voting
Cooperative Methods for Defining C
Cooperative Method #1:Behavioral Fusion via Vector Summation
Summarizing Behavior Coordination
Representative Reactive/Behavior-Based Architectures
Robot Architectures and Computability
Subsumption Architecture
Categorization of Subsumption Architecture
Characteristics of Subsumption
Foraging Example
Genghis Subsumption Design
Genghis AFSM Network
Evaluation of Subsumption