Innate releasing mechanisms

Innate releasing mechanisms

Lorenz and Tinbergen attempted to clarify their work in how behaviors are
INNATE RELEASING coordinated and controlled by giving it a special name innate releasing mech-
MECHANISMS anisms (IRM). An IRM presupposes that there is a specific stimulus (either
internal or external) which releases, or triggers, the stereotypical pattern of
RELEASER action. The IRMactivates the behavior. A releaser is a latch or a Boolean variable
that has to be set. One way to think of IRMs is as a process of behaviors.
In a computational theory of intelligence using IRMs, the basic black boxes
of the process would be behaviors. Recall that behaviors take sensory input
and produce motor actions. But IRMs go further and specify when a behav

ior gets turned on and off. The releaser acts as a control signal to activate a
behavior. If a behavior is not released, it does not respond to sensory inputs
and does not produce motor outputs. For example, if a baby arctic tern isn’t
hungry, it doesn’t peck at red, even if there is a red beak nearby.
Another way to think of IRMs is as a simple computer program. Imagine
the agent running a C program with a continuous while loop. Each execution
through the loop would cause the agent to move for one second, then
the loop would repeat.
enum Releaser={PRESENT, NOT_PRESENT};
Releaser predator;
while (TRUE)
{
predator = sensePredators();
if (predator == PRESENT)
flee();
}
In this example, the agent does only two things: sense the world and then
flees if it senses a predator. Only one behavior is possible: flee. flee is
released by the presence of a predator. A predator is of type Releaser and
has only two possible values: it is either present or it is not. If the agent does
not sense the releaser for the behavior, the agent does nothing. There is no
“default” behavior.
This example also shows filtering of perception. In the above example, the
agent only looks for predators with a dedicated detection function, sense-
Predators(). The dedicated predator detection function could be a specialized
sense (e.g., retina is sensitive to the frequency of motions associated

with predator movement) or a group of neurons which do the equivalent of
a computer algorithm.
Another important point about IRMs is that the releaser can be a compound
of releasers. Furthermore, COMPOUND RELEASERS the releaser can be a combination of either external
(from the environment) or internal (motivation). If the releaser in the compound
isn’t satisfied, the behavior isn’t triggered. The pseudo-code below
shows a compound releaser.
enum Releaser={PRESENT, NOT_PRESENT};
Releaser food;
while (TRUE)
{
food = senseFood();
hungry = checkState();
if (food == PRESENT && hungry==PRESENT)
feed();
}
The next example below shows what happens in a sequence of behaviors,
where the agent eats, then nurses its young, then sleeps, and repeats the
IMPLICIT CHAINING sequence. The behaviors are implicitly chained together by their releasers.
Once the initial releaser is encountered, the first behavior occurs. It executes
for one second (one “movement” interval), then control passes to the next
statement. If the behavior isn’t finished, the releasers remain unchanged and
no other behavior is triggered. The program then loops to the top and the
original behavior executes again. When the original behavior has completed,
the internal state of the animal may have changed or the state of the environment
may have been changed as a result of the action. When the motivation
and environment match the stimulus for the releaser, the second behavior is
triggered, and so on.
enum Releaser={PRESENT, NOT_PRESENT};
Releaser food, hungry, nursed;
while (TRUE) {
food = sense();
hungry = checkStateHunger();
child = checkStateChild();
if (hungry==PRESENT)
searchForFood(); //sets food = PRESENT when done
if (hungry==PRESENT && food==PRESENT)
feed(); // sets hungry = NOT_PRESENT when done

if (hungry== NOT_PRESENT && parent==PRESENT)
nurse(); // set nursed = PRESENT when done
if (nursed ==PRESENT)
sleep();
}
The example also reinforces the nature of behaviors. If the agent sleeps
and wakes up, but isn’t hungry, what will it do? According to the releasers
created above, the agent will just sit there until it gets hungry.
In the previous example, the agent’s behaviors allowed it to feed and enable
the survival of its young, but the set of behaviors did not include fleeing
or fighting predators. Fleeing from predators could be added to the program
as follows:
enum Releaser={PRESENT, NOT_PRESENT};
Releaser food, hungry, nursed, predator;
while (TRUE) {
predator = sensePredator();
if (predator==PRESENT)
flee();
food = senseFood();
hungry = checkStateHunger();
parent = checkStateParent();
if (hungry==PRESENT)
searchForFood();
if (hungry==PRESENT && food==PRESENT)
feed();
if (hungry== NOT_PRESENT && parent==PRESENT)
nurse();
if (nursed ==PRESENT)
sleep();
}
Notice that this arrangement allowed the agent to flee the predator regardless
of where it was in the sequence of feeding, nursing, and sleeping
because predator is checked for first. But fleeing is temporary, because it did
not change the agent’s internal state (except possibly to make itmore hungry
which will show up on the next iteration). The code may cause the agent to
flee for one second, then feed for one second.
One way around this is to inhibit, or turn off, any other behavior until
fleeing is completed. This could be done with an if-else statement:

while (TRUE) {
predator = sensePredator();
if (predator==PRESENT)
flee();
else {
food = senseFood();
hungry = checkStateHunger();
...
}
}
The addition of the if-else prevents other, less important behaviors
from executing. It doesn’t solve the problem with the predator releaser disappearing
as the agents runs away. If the agent turns and the predator
is out of view (say, behind the agent), the value of predator will go to
NOT_PRESENT in the next update. The agent will go back to foraging, feeding,
nursing, or sleeping. Fleeing should be a fixed-pattern action behavior
which persists for some period of time, T. The fixed-pattern action effect can
be accomplished with:
#define T LONG_TIME
while (TRUE) {
predator = sensePredator();
if (predator==PRESENT)
for(time = T; time > 0; time--)
flee();
else {
food = senseFood();
...
}
}
The C code examples were implemented as an implicit sequence, where
the order of execution depended on the value of the releasers. An implementation
of the same behaviors with an explicit sequence would be:
Releaser food, hungry, nursed, predator;
while (TRUE) {
predator = sensePredator();
if (predator==PRESENT)

flee();
food = senseFood();
hungry = checkStateHunger();
parent = checkStateParent();
if (hungry==PRESENT)
searchForFood();
feed();
nurse();
sleep();
}
The explicit sequence at first may be more appealing. It is less cluttered
and the compound releasers are hidden. But this implementation is not
equivalent. It assumes that instead of the loop executing every second and
the behaviors acting incrementally, each behavior takes control and runs to
completion. Note that the agent cannot react to a predator until it has finished
the sequence of behaviors. Calls to the fleeing behavior could be inserted
between each behavior or fleeing could be processed on an interrupt
basis. But every “fix”makes the program less general purpose and harder to
add and maintain.
The main point here is: simple behaviors operating independently can lead to
what an outside observer would view as a complex sequence of actions.