The Four Levels of
SCL “Intelligence”
By Eugene
Asahara
Created:
April 25, 2008
Last Updated:
January 4, 2008
SCL attempts
to mimic four levels of intelligence that evolved through an eternal struggle
between predator and prey. This may at first seem difficult to accept since
most think of predators out-muscling their prey and prey outrunning their
predators; images of cheetahs and gazelles growing faster and faster. But that
is not intelligence. Intelligence is the predator’s ability to hide from the prey
and the prey’s ability to glide under the radar of the predator. The four
levels, from most mundane to that of our human intelligence are as follows:
1.
Simple
recognition. This is pretty much Boolean logic. This is the “push-button”, “insect
and fish” recognition. At the simplest level it means IF X AND Y AND Z THEN
Execute”. However, simple recognition goes further as in IF (X AND Y AND Z) OR (A AND B) THEN Execute”. The OR
means that a particular action can be triggered by more than one rule.
Creatures
possessing simple recognition are stupid. Such creatures suffer from false
negatives. This means that they fail to recognize situations because
their rules are too rigid. For example, we can easily catch fish because we
only need to mimic the movement, smell, and shape of a fish’s prey with a hook,
line, and bait, and it will fall for it every time … well, maybe not. The
important things are that the rules are such that a certain percentage of the
members will survive to reproduce. This isn’t too different from a casino
winning a certain percentage as long as the rules are strictly adhered to.
This
is the general state of most software today. Rules are rather hard-coded (for
example, as IF-THEN, CASE-WHEN, or IIF statements). However, many inputs used by
the rules are soft-coded; for example, configuration files for an application
where values can be set independently of the software.
In
general the variables plugged into a rule are directly measured and factual values.
In fact, the key difference between Simple and Robust (#2) recognition is that
for the latter, variables plugged into a rule are the result of rules. Simple
recognition is like a function or Web Service call these days that accept a
fixed set of parameters (even though there may be multiple “signatures” for the
call) which are all solid values processed by the rules encapsulated by the
function.
Simple
recognition rules assume a direct hit. Direct
hits are possible either because the rules try to recognize something vague
(recognizing a shadow, which is simply a change of light) or the rules are cut
and dried (such as calculating tax). However, the problem with direct hits is
that in the dynamic world we live in, direct hits are usually not feasible.
Therefore a rule will be rather loose in a “better safe than sorry” manner. For
example, a fly will react to any movement since it would require too many rules
to determine if the movement of a nearby animal is meant to hurt the fly or
unrelated to the fly.
The
reason why insects and fish species thrive with simple recognition is that they
reproduce in prodigious numbers. The simple rules by which they live ensure
that a certain, albeit very tiny, fraction of the individuals survive to
reproduce (again, in prodigious numbers).
2.
Robust
recognition. This is lower reptile and bird intelligence. Variables plugged
into rules can themselves be queries (a simple recognition). Robust recognition
is a network of simple recognitions. This is soft-coded logic, the separation
of logic and procedure.
Robust
recognition is different from simple recognition in that the rules are not rigid
resulting in direct hits. The main requirement for robust recognition is to recognize
something complex or avoid having too many rules (the too many false positives
problem).
For
example, if a rabbit is to recognize a fox stalking it, it would need to do
this from an incredibly large number of angles. In order to learn that, it
would need to first see the fox from all angles.
It
would take forever to process all of those rules from each angle. If the
requirement for a direct hit is removed, the rabbit can successfully recognize
the fox quickly and fairly accurately through a less direct hit.
With
simple recognition, the fox would need to be an exact shade of red, an exact
size, have an exact smell, etc. With simple recognition, the shade of red is
determined through a rule that takes into account the level of light and other
things.
With
robust recognition, the “too many false positives” problem is resolved. This is
a little different from the fox and the rabbit problem. The rabbit and fox
problem is a rabbit needing to recognize something in many different ways. This
problem occurs when there are so many learned rules that too many rules fire.
This problem would be restated from “Is this a fox?” to “What has ears and a
nose?”
That
is different from the “fuzziness” of simple recognition where a creature
recognizes only simple things. A rabbit attempts to recognize a more complex
object in a fuzzy manner than to run away from all objects.
Software
today is beginning to apply such mechanisms resulting in smarter applications.
3.
Iterative
recognition. Part I of higher animal (higher reptiles and mammals) recognition.
The difference between robust and iterative recognition is that iterative
recognition will actually take steps to proactively improve the recognition
accuracy by iteratively proving it through experiments and feedback. Iterative
recognition adds a process that begins with a list of possibilities and culls
the list by gathering more data to prove which possibility is the most likely. Each iteration could add new possibilities as well as new
evidence is gathered.
Vision
makes a bigger impact as a sensory role. With vision, comes the ability to
camouflage. This camouflage is generally not perfect. If a reptile spots a
partial view of its prey, because the match isn’t perfect, the reptile’s
recognition rule doesn’t fire and it pass up an opportunity to eat. (How often will it find prey in full view?) Therefore,
it must recognize that partial view as a “hypothesis” rather than a direct
match and begin to prove the theory through iterations of query and experiment.
For example, we see something in the distance that looks like a shady tree to
sit under. But something isn’t quite right about it. We walk more closely and
it looks even less like a tree. Or we toss a rock at it to see anything moves. We
walk closer and see that it’s a bear holding tree branches.
So
a creature with iterative recognition may be smarter about recognizing something,
but it has to also needs to be smarter about knowing
what to do about it; which brings up #4.
4.
Decoupled
Recognition and Action. This is Part II of higher animal recognition; of which
humans are in a class of their own. It’s the human’s ability to think
symbolically that separates us from all other animals. That is, we’re able to
perform experiments in our head before actually committing to a physical action,
which is probably not retractable. Something may be recognized accurately
(using iterative recognition), but what do we do about it? For example, we do
recognize that it’s a bear (from item #3 above). What do we do? Do we run away?
Do we fight? Do we pray to our maker and wish the bear bon appétit? Is it
really a threat? Maybe the kind bear is offering us shade. The point is that
recognition is only half the problem. Deciding what to do is what keeps us from
being caught with a fishing hook and bait.
Humans,
with our self-awareness, are each a species
of one. Most creatures aren’t really aware of their mortality. All that
matters for most species is that enough individuals survive to produce the next
generation. Humans are aware of our mortality and do much to preserve our lives.
Like an entire species, each human fills a niche, each carries a unique
intelligence, each is capable of profoundly changing
the world.
Lastly,
humans and all mammals still do rely on simple recognition. We still encounter
dangers that require a very quick “better safe than sorry” response. These are
the knee-jerk reactions we may have to sudden loud noises or shadows appearing
around the corner of our eyes.
SCL/RDB
facilitates the “robust recognition” level of intelligence. Basically, robust
recognition means that something, an object or event, can be recognized from
many different angles, some angles of which are not explicitly defined. In
contrast, my full vision for SCL is to facilitate “decoupled action and
recognition” and most software implements “simple recognition”. The former is
essentially the recognition of something, but further analysis is required in
choosing the proper action. The latter is a “push-button” action; a button is
pushed and an action is executed.
Related Articles: