Intelligence, IE, and SI - Part 2

Billy Brown (
Thu, 28 Jan 1999 17:41:00 -0600

<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