From: Billy Brown (bbrown@conemsco.com)
Date: Thu Jan 28 1999 - 16:41:00 MST
<continued from part 1>
If general intelligence is simply the sum of many different abilities, then
it would seem that the nature of these individual abilities would be
critical to any discussion of intelligence enhancement. If it is
impractical to improve specific forms of intelligence to a significant
degree, then it will also be impractical to improve general intelligence.
Building Blocks of Intelligence
So, what does it take to have a high level of ability within a narrow
problem domain? The answer to this question can vary quite a bit from one
domain to another. Some problems, like the problem of memorizing and
playing back sensory data, are trivial for modern data processing systems.
Others, such as the problem of self-awareness, are so complex that there is
currently no known method of dealing with them.
If we were forced to consider all possible problem domains individually, we
would likely be unable to form any meaningful conclusions about them.
Fortunately, the same techniques that can yield competence in one field can
also be used to achieve good performance in others. Virtually all solutions
that have been achieved to date rely on a relatively small number of
problem-solving approaches, or on combinations of these approaches. We
shall therefore examine each of these methods in turn, and see what we can
learn from them.
Decision Tree Searches
Many problems are simply a matter of choosing between a large number of
possible actions. Game-playing programs are the classic example, but many
real-world problems can be expressed in the same terms. Investment
decisions, physical dexterity, and planning how to achieve a goal are all
tasks that can be represented by decision trees.
The thing that makes such problems hard is usually the sheer number of
possible choices. In all but the most trivial problems it is impossible to
actually consider every possible alternative in detail. AI programs that
deal with such problems use heuristics - rules that tell them which
alternatives are worth investigating, and which ones to ignore.
Systems based on decision trees tend to require large amounts of
computation, but the code required to implement them is often surprisingly
simple. They can be improved in two completely different ways - by
increasing the speed of the hardware the system runs on, or by devising
better heuristics. The second approach is far more powerful, but it is also
much more difficult - once the obvious possibilities are exhausted it
becomes a process of invention, not of engineering.
Data Transformation Systems
Many problems are essentially a matter of taking a large mass of data and
extracting significant information from it. Basic sensory processing falls
into this problem category, as do tasks such as recognizing faces and
reading. Solving such problems is very different from dealing with a
decision tree.
If the complexity of the data is not too large, it is often possible to
hand-code a complete solution to this sort of problem. When the problem
becomes too complex for such an approach, neural nets or genetic algorithms
are brought to bear. In either case, the amount of effort needed to build a
system that displays basic competence tends to be fairly large.
However, once that point is reached improving performance usually hinges on
improving the speed of the underlying hardware. If you get a much faster
computer, you can run the same software on it and process data that much
faster. Alternatively, you can spend more effort processing the same data
and pick out patterns that were previously invisible. As an interesting
note, taking advantage of an exponential growth in computational resources
appears to be possible with a modest (either linear or very slow
exponential) increase in effort.
Knowledge Bases
In the real world, similar problems often arise repeatedly in a given
domain. Knowledge bases (also known as expert systems) are a way of
recording how problems were recorded in the past, in order to make it easier
to solve the same problems again in the future. They are usually used to
store solutions to decision tree-type problems, but in principle they could
be used in other domains.
The usefulness of a knowledge base is primarily limited by the amount of
experience it contains, not the speed of the underlying hardware. A simple
speed increase will simply let it look up answers a little faster, which
rarely makes any practical difference. An intelligent entity will fill a
knowledge base with the solutions discovered by some other problem-solving
system, so it will tend to become more useful as the entity develops
experience with that domain.
<to be continued>
Whew! That's it for now. Does anyone see a problem-solving approach I've
missed? Most of the obvious ones are actually special cases of the decision
tree or data transformation cases, but there may be something out there that
isn't.
Billy Brown, MCSE+I
bbrown@conemsco.com
This archive was generated by hypermail 2.1.5 : Fri Nov 01 2002 - 15:02:57 MST