 |
| |
 |
| |
|
| |
 |
Coauthored with Ted Goertzel
I remember heading home from college for spring break in
1983, toward the end of my freshman year. I’d just
recently turned 16, and I’d been thinking about AI
a hell of a lot – even more than about my new girlfriend,
Rachel Gordon, whom I was pretty darn crazy about at the
time. A few days before spring break I’d tried to
explain my theories on artificial intelligence to my friend
Ken Silverman. Ken couldn't understand what I was talking
about, so I promised him I'd work on it over spring break,
and that when I got back to school I’d explain how
it all worked, I’d give him a complete design for
a thinking computer program. I had the idea clear in my
head, but I was totally unable to articulate it in a way
that Ken or anyone else could understand. I spent the whole
break working on it, and during those few days I basically
worked out the ideas that I’d later put in my first
book, The Structure of ntelligence, six years later. I went
through every aspect of the mind - reason, memory, aesthetics,
intuition, emotion, etc. - and convinced myself that every
one could be expressed in terms of pattern recognition and
pattern formation. The mind, I concluded, was a pattern
recognition system that recognized patterns in the world
around it, and – very crucially -- also recognized
patterns in itself. Recognizing patterns in itself, it formed
patterns within itself, continually giving rise to new structures.
After the break, I still wasn’t able to explain my
realizations to Ken in a way that made sense to him, but
at least things made a little more sense to me. I knew I
had to find a mathematical language to make sense of my
intuitions, or I’d never be able to communicate them
to anyone, let alone program them on a computer. My grasp
of software design at this stage was extremely weak; it
was formed mainly by programming games in BASIC. I was nowhere
near having the skills to design a general pattern recognition
system that recognized patterns in itself and adjusted itself
accordingly.
Ken's dad was an extremely smart guy and a prolific and
successful inventor, mostly in the area of electrical engineering;
and in our college years, Ken often fantasized about becoming
a rich inventor and building a mansion, with a basement
laboratory in which we’d putter around day and night,
wiring together intelligent robots and time machines and
so forth. So it’s pretty funny that 14 years later
when I decided to start an AI company (Intelligenesis Corp.,
later renamed Webmind Inc.) I somehow happened to turn to
Ken when I needed someone to take over the job of programming
my AI system, the Webmind AI Engine.
I hadn't spoken to him for years – he’d stayed
in the New York area, where he had grown up, whereas I’d
moved all over the world, teaching in universities in Las
Vegas, New Zealand and Australia. After getting his degree
in electrical engineering, he’d done a lot of different
things, including real estate and computer programming.
He was really psyched to finally get the chance to collaborate
with me on my thinking machine project. Finally, after a
decade and a half, I had figured out how to express my plan
for artificial intelligence in a way Ken could understand!
Ken was the lead engineer at Webmind Inc. for its first
couple years, and VP of Technology for the entire lifetime
of the firm. Now I’m working with a different crew
of engineers, and Ken is working on his own advanced pattern
recognition software, but we’re still good friends,
and he definitely played an important role in the evolution
of my work.
To articulate my vision of the mind in a comprehensible
form was much much harder than I’d ever thought it
would be. It turned out that the vocabulary for expressing
what I wanted to say didn’t really exist in the field
of computer science. To find the language I needed to express
my ideas and to work out the details, I had to step a long
way back from the world of computers and get deeply into
the philosophy of mind. Although I was very young then,
and even more naïve than I am now, I realized intuitively
that it was necessary to get the philosophy right before
proceeding to the computational details. Now, I’m
jaded by a fair amount of practical experience – though
I don’t have a head full of gray hair yet –
and I see this far more clearly than I did then. In implementing
a general vision of how the mind works, it’s very
easy to be misled by the nature of contemporary computer
hardware and programming languages, and to wind up implementing
things that subtly deviate from the vision one started out
with. The way to avoid this is to have the conceptual, philosophical
vision very firmly fixed in one’s mind as one sets
about the detailed design work, which is huge and at times
confusing.
What I’m going to give you in this chapter is a fairly
sketchy, but hopefully evocative, overview of the process
of creating Webmind and then Novamente. The two AI systems
are very different on a technical level, but on the level
of a popular exposition like this one, the differences are
really pretty small. Novamente uses more sophisticated mathematics
and more efficient software structures to implement the
same basic concepts that Webmind did. To keep things from
getting confusing, I’ll write mostly about “Novamente”
here, except where I’m talking historically about
the creation of Webmind in particular; but most of what
I’ll say about Novamente also applies to Webmind.
The Novamente project is far from complete. Just like every
other AI researcher, I’m an abject failure so far
– I haven’t yet created a software program displaying
human-level general intelligence. Unlike most other AI researchers,
however, I and my colleagues honestly believe we are on
a path that will lead us to success at this ambitious goal.
I don’t expect to convince you one way or another
in these pages – my hope is merely that the story
of our quest may be an interesting one … and that
some of the lessons we’ve learned along the way may
be of general value.
I
knew from the start that I didn’t want to build an
artificial idiot savant – an overspecialized, brittle
system as was typical in the AI field. I wanted to build
a mind.
But what is a mind, anyway?
In that spring break, sophomore year, that I spent trying
to figure out how to explain my vision of the mind to Ken,
I arrived at a basic working definition of the mind: a mind
is the set of patterns in an intelligent system.
Your mind is not your brain, nor is it some disembodied
soul somehow exchanging messages in your brain. Your mind
is the set of patterns in your brain – the structures
and processes in your brain, so that knowing these structures
and processes allows you to explain the brain more simply
than just listing the parts of the brains and their positions
and states over time.
Novamente’s mind is not the C++ code that my engineering
team and I type in – that’s just a code for
creating the mind, a little like DNA is the code for creating
a human. Novamente’s mind is the set of patterns in
the billions of 0’s and 1’s existing in RAM
while Novamente runs, cycling through the machine’s
processors and passing through the network cables. These
0’s and 1’s themselves are not Novamente’s
mind – it’s the patterns in these 0’s
and 1’s, the static and dynamic patterns, that are
mind. Mind is a set of patterns in a system that achieves
highly patterned goals in a highly patterned environment.
Everything is pattern, pattern, pattern!
Mind recognizes and creates patterns in the world and itself,
achieving complex goals, goals whose definition involves
a great deal of pattern.
Although these ideas were clear to me intuitively in 1983,
it wasn’t till 1990 or so that I was able to write
them down in a clear and comprehensible way. This is what
I did in the first few chapters my first book The Structure
of Intelligence. At that point I had gotten my PhD in mathematics
and was supposed to be doing mathematical research, but
just as I’d always been more interested in my own
reading and thinking than in my schoolwork, now I was spending
my time thinking about pattern and mind and the nature of
the universe, instead of proving math theorems like a good
assistant professor. The next step was to ask the question:
What are the principles by which a set of patterns, a mind,
can actually be intelligent? For sure, the precise structures
and dynamics are going to vary from one mind to the next,
but are there any general principles, applicable to every
kind of intelligent system, be it a human, a dolphin, a
computer program, an intelligent gas cloud on Jupiter? It’s
not totally obvious that there are such principles, but
my belief starting out was that such general principles
had to exist. What are the principles by which mind’s
core algorithm - pattern recognition and formation in itself
and the world -- is self-regulated?
One general principle is what the 19’th-century American
philosopher Charles Peirce called the “One Law of
Mind”: that things in the mind tend to spread attention
to other related things in the mind. This is a basic principle
for attention allocation, that we can see in the brain in
the diffusion of electricity. Novamente incorporates this
via activation spreading similar to that in a neural network.
This is what I call a “heterarchical” principle
– where a heterarchy just means a sprawling network
in which each element connects to a few other elements,
without a hierarchical structure. A random network in which
each node connects to a set of other nodes at random is
a heterarchy.
Hierarchy is another important structure of the mind. We
see it in the human brain all over the place, most famously
in the visual system, where we have a hierarchy of progressively
more abstract processes, starting with rccognition of lines
and edges, then shapes, then 3-D forms, and so forth. Hierarchy
in the mind has to do with increasing abstraction, and with
control that’s aligned with abstraction, so that processes
dealing with more abstract things control related processes
dealing with more concrete things.
A general principle that I’ve thought a lot about
– and that I wrote about in my second book, The Evolving
Mind -- is what I call the “dual network” –
this refers to the interpenetration of hierarchy and heterarchy.
In the mind, hierarchy and heterarchy overlap each other,
and the dynamics of the mind is such that they have to work
well together or the mind will be all screwed up. The overlap
of hierarchy and heterarchy gives the mind a kind of “dynamic
library card catalog” structure, in which topics are
linked to other related topics heterarchically, and linked
to more general or specific topics hierarchically. The creation
of new subtopics or supertopics has to make sense heterarchically,
meaning that the things in each topic grouping should have
a lot of associative, heterarchical relations with each
other. In Novamente, this general “dual network”
principle is reflected in many ways, when one gets down
into the details of its various dynamical processes.
Another general principle is self: that minds contain parts
of themselves that mirror the whole. This gives a quasi-fractal
structure to the mind.
Another general principle, also discovered by Charles Peirce,
is that there are three kinds of reasoning: induction, abduction,
and deduction. These are all ways of manipulating hierarchical
relationships. Hierarchy is about logic, whereas heterarchy
is about the spread of attention and the formation of wholes.
Once heterarchy has lead to the formation of new wholes,
corresponding to clusters of things that all relate to each
other, then these new wholes can be dealt with hierarchically,
they can be reasoned about. I was very fortunate, a month
after Intelligenesis got our seed funding, to get a job
application from Pei Wang, who had worked out a neat computational
reasoning system (NARS) based on the three forms of reason
that I, following Peirce, had identified as essential to
the mind.
There are also two dynamics that I believe are generally
part of mind. These correspond to the basic philosophical
principles of Being and Becoming.
Becoming corresponds to evolution, considered most generally
as the survival of the fittest members of a population,
and the reproduction of the survivors to form new population
elements. Novamente contains explicitly evolutionary components
– variations on the computational technique called
“genetic programming.” It also contains other
components that aren’t traditionally viewed as evolutionary,
but really are. For instance, Novamente’s reasoning
module involves logical relations (we call them “links”)
that combine with each other to create new logical relations.
The facts “pigs are fat” and “fat creatures
are ugly” combine to create the new relation “pigs
are ugly.” And in the reasoning system, unimportant
relations are deleted to save memory. Thus, we have survival
of the fittest, where fitness means importance to the system,
and we have reproduction of the survivors, via the rules
of inference. Reasoning is seen to be a form of evolution,
in the general sense.
Being corresponds to what system theorists call “autopoiesis”
– an obscure word that has a very useful meaning.
It means self-production. Every cell in the body is produced
by other cells in the body – so the body is a self-producing
system. The mind is also a self-producing system. This is
basically the theme of my third book, Chaotic Logic. If
you remove part of the mind, the other parts of the mind
that relate to it will be able to reproduce it, approximately
if not exactly. If you take out the logical relation “pigs
are ugly” for example, the system may be able to regenerate
it by inference from the other relations “pigs are
fat” and “fat creatures are ugly.” It
may come out with a different strength than it had before,
but it will still be reproduced, perhaps lossily. If you
take out all memory of the text “War and Peace”
from the mind, but retain a lot of related knowledge, this
related knowledge will cause the system to want to read
War and Peace, which eventually will likely lead the information
about the text to be regenerated. In this case, interaction
with the environment is part of the mind’s autopoietic
dynamics.
Evolution changes the system in accordance with its goals
and its environment; autopoiesis keeps the system the same
as it was before. The mind needs both of these forces; they
need to be properly balanced. The balance of these leads
to productive creativity, and this was the main theme of
my fourth book, From Complexity to Creativity.
I arrived at my list of general principles of the mind by
a kind of unholy combination of introspection, mathematical
analysis, and survey of biology, psychology and computer
science. I spent a long time trying to prove mathematically
that all these general structures and dynamics, and a few
others, were necessary and sufficient for mind – any
system having them would have a mind, and any system not
having them couldn’t have a mind. But eventually I
gave up; I decided that the mathematics of today is not
adequate for proving this kind of thing. I gathered my various
insights and intuitions and conclusions about how the mind
worked, and gave the list a name: the psynet model of mind.
Psynet = “mind-network”, a theory of the mind
as a network of interacting, intertransforming agents. I
realized that the conceptual picture of the mind that I’d
developed was of significant value in itself, apart from
any mathematical formalization I might give it. No one else
working in the AI field seemed to me to have a similarly
comprehensive and powerful conceptual analysis of the mind.
I still think inventing the needed mathematics to usefully
and completely formalize the psynet model is an interesting
challenge – but it’s not as interesting to me
right now as using my intuitions about the general structures
of intelligence to build thinking software.
The general structures and dynamics of the “psynet
model” can be manifested in many many different ways,
in different systems. The process of building Webmind, and
then Novamente, has been in this sense a top-down process.
I started out with an idea about what general principles
had to emerge from the system to make it intelligent, and
this placed a constraint on what the system had to be like.
It had to be built so as to make the right general structures
and dynamics emerge. Aside from that, I didn’t care
very much exactly what the system was like. I had, and still
have, an attitude of being willing to learn via experimentation
in this regard.
My
first serious attempt to build a real AI system (earlier
chatbots and abortive experiments not counted) occurred
in 1994. I used a programming language called Gofer, which
I later benchmarked at 1/10,000 the speed of C (the standard
programming language in the commercial world). Gofer was
a beautiful language, which matched up nicely to my vision
of the mind. This program was called Antimagicians; it was
a population of actors called magicians, and antimagician
actors that annihilated the magicians in complex patterns.
Just about all it ever did was produce a type of error called
a “stack overflow.” This was a shame, because
my model of mind was very simple and compact in this programming
language. But it could only run on one machine, and it ran
incredibly slowly; the only thing it did fast was use up
all the machine’s memory.
Gofer was a “functional” programming language,
meaning not that that it performed useful functions (far
from it!), but rather that it was based on the mathematical
concept of a “function.” Gofer was basically
equivalent to mathematics. It appealed to my sense of formal
elegance; it was perfect in the sense of a Bach fugue. Unfortunately,
though, functional languages do not match well to the von
Neumann computer architecture, so it is very hard to make
them efficient without special hardware. After the debacle
of my stack-overflowing proto-AI system, I abandoned Gofer
and turned back to C++, and then to the new programming
language Java. But I restricted myself to more modest programming
experiments. I made a C-language version of Antimagicians,
which was much simpler and less interesting than the Gofer
version. In Java, I made a genetic algorithm that ran on
multiple machines (coded together with Rosalind Barr at
University of Western Australia), and a simple actors-based
search engine (coded together with Mark Messenger, also
at UWA). I could see from this experience that, while my
AI system in Gofer had small, because Gofer was made for
expressing systems that refer to and organize themselves,
a comparable system in C++ or Java or any other practical
programming language was going to be huge. It took a couple
years for me to summon the guts to attempt such a thing.
One thing that occurred to me as I started to think about
implementation issues, much more than it had in my days
as a pure theorist, was the crucial role of specialization.
My Gofer-based mind had been theoretically capable of intelligence;
it was a general system for recognizing and forming patterns
in itself and its environment. But its generality didn’t
allow it to solve any particularly useful problems within
practical time and space constraints. In that sense, it
had been a miserable failure as an intelligent system. In
practice, I concluded, to get reasonably efficient intelligence
one needs to code specialized cognition algorithms, aimed
at recognizing patterns in particular kinds of data, learning
how to carry out particular kinds of actions, and so forth.
The brain is very much like this: we have 30% of our brain
specialized for visual pattern recognition; regions specialized
for language; regions specialized for body sensations; regions
specialized for social interaction; etc. etc. And then we
have a little bit of general intelligence, which is what
makes us uniquely brilliant among the animal kingdom –
but this general intelligence relies on all the specialized
stuff to give it a meaningful context within which to operate.
Specialization needs to be mediated by rich interaction
between specialized parts. The different specialized parts
of a system need to learn from each other, and learn about
the world together whenever they can. The integration of
various specialized pattern recognition subsystems has played
a huge role in practical Webmind engineering.
Because of all this specialization, it seemed to me in 1994
and 95 that there was no way to build a thinking computer
program on contemporary computer hardware. It seemed to
me that some kind of humongous brainlike supercomputer would
be necessary. And then I discovered the Internet (unlike
Al Gore, I didn’t invent it!). It struck me that the
millions, soon billions, of machines around the world, all
hooked together on the Net, had enough memory and processor
power to create a real computational intelligence. The Java
programming language came out in 1995 and it seemed the
right tool to use to create a networked AI engine embodying
the general principles of mind: recognizing and creating
patterns in itself and the world, using a variety of specialized
methods integrating together into a whole, an evolving autopoietic
whole.
Not only did the Internet give you the computational power
to build a thinking machine; it also provided a really rich
perceptual environment. A mind can’t exist in isolation;
it has to achieve complex goals in a complex environment.
The physical world is obviously complex but building a robot
body is another huge project, comparable in scope to building
a mind. The Internet is arguably rich enough in diverse
details to support intelligence, and it’s a lot easier
to hook your AI system into the Internet than to build it
a robot body. I made up my own complex goal: To build an
AI system whose body was part of the Net, and whose perceptual
world was the Net itself, the Web. A mind for the Web; a
Webmind.
In terms of the conception of intelligence as “achieving
complex goals in complex environments,” the goals
I had in mind when designing the Webmind system were roughly:
* Conversing with humans in simple English, with the goal
not of simulating human conversation, but of expressing
its insights and inferences to humans, and gathering information
and ideas from them.
*
Learning the preferences of humans and AI systems, and providing
them with information in accordance with their preferences.
Clarifying their preferences by asking them questions about
them and responding to their answers.
·
* Communicating with other AI systems, in a manner similar
to its conversations with humans, but using a mixture of
human language and a more formalized and precise computerized
language we have created, called Sasha
*
Composing knowledge files containing its insights, inferences
and discoveries, expressed in Sasha or in simple English.
*
Reporting on its own state, and modifying its parameters
based on its self-analysis to optimize its achievement of
its other goals.
Of course, my ambitions didn’t end there – that
would be wimpy. Subsequent versions of the system were intended
to offer enhanced conversational fluency, and enhanced abilities
at knowledge creation, including theorem proving, scientific
discovery and the composition of knowledge files consisting
of complex discourses. And then of course the holy grail:
progressive self-modification, leading to exponentially
accelerating artificial superintelligence!
I remember a particular moment when my diverse ideas about
AI crystallized in my mind, with amazing clarity. I could
see in my mind exactly how an AI system could be built.
Now all that was left was to work out a few pesky details.
At this point, it had been 13 years since I’d first
set myself the goal of building a thinking machine. I now
had a PhD in math, and had spent countless thousands of
hours studying of cognitive science, physics, computer science,
neurobiology, philosophy of mind. I’d published four
books on the mind, which were idiosyncratic combinations
of mathematics, philosophy and science, all pushing in the
same direction, toward an understanding of the mind that
was both fundamental and precise. I felt I finally had the
answer. And it seemed that the hardware was finally getting
there too. We had cheap computers with gigabytes of RAM,
and we had high-bandwidth Ethernet and Internet, allowing
distributed computing among dozens or even millions of these
powerful, cheap machines, etc.
It all seemed incredibly clear to me. Mind was exquisitely
simple in essence. A mind was a web of patterns, a network
of independent mind actors, each one concerned with recognizing
patterns in other actors, and patterns emergent between
itself and other actors. New actors were created to embody
new patterns. The overall network of mind was continually
re-making itself via recognizing patterns in itself. The
character of a particular sort of mind was determined by
the assemblage of pattern recognition/creation actors inside
it. The art of mind design – an as yet nonexistent
art – would consist of choosing the right assemblage
of types of actors so that the emergent self-reconstructing
behavior of mind would get into a productive dynamical attractor.
From my 13 years of thinking about human and artificial
intelligence, I felt I had a good idea how to choose and
design the right mind actors, so that when these actors
were released to study and transform one another, the self-reconstructing,
self-recognizing dynamic characteristic of mind would emerge.
And so in the fall of 1996 I started creating the Webmind
AI Engine. As I’ve said, I’d been working on
similar things off and on for years; but the actual design
of the Webmind system as it is now was something I started
in the fall of 1996, when I was in Western Australia, working
at UWA as a Research Fellow. Soon enough this got more interesting
than anything else I was working on -- I realized that I
was on the verge of something really cool, and something
that I wasn’t going to be able to implement myself,
or with a couple research assistants. John Pritchard, my
New York e-mail pal, was convincing me that it was plausible
to get funding to start a company building software according
to my designs. The idea was appealing.
At the start of 97 I quit my job at UWA and moved to the
US to work on Webmind design and coding full time. I didn’t
have any clear business plan in mind, but I figured that
once I got some clearly intelligent behavior working, the
venture capitalists would beat a path to my door. Naively
enough, I figured I’d reach that point after a few
months hard work. I figured that after I got some basic
stuff working, I could raise a few hundred thousand dollars
to pay perhaps 5 programmers, and then we’d get the
whole thing implemented in 6 months time – presto!
a thinking machine. Fame and fortune, and truckloads of
beautiful girls, would be mine.
What I had at the end of summer 1997 was ten thousand lines
of Java, largely designed as I went along. This system was
never completed, and of the parts that were completed only
half of them worked. There were lots of details I didn't
understand. This first serious attempt at Webmind had too
much of my theory of mind in it, and not enough computational
practicality. It was beautiful as a mathematical and logical
statement, but still horrible as a computer program. I still
was too closer to Gofer, and hadn’t come to grips
with what I’d have to do to make a useful, efficient
implementation of my model of mind.
But still, the ideas, data structures and dynamics underlying
this first Webmind were conceptually about the same as the
ones underlying Novamente today. The mathematics and the
software design have both changed tremendously, but the
underlying vision is the same. Novamente, like Webmind before
it, is based on the idea that the mind is a collection of
patterns that forms and recognizes patterns in itself and
the world, and in this way achieves complex goals in the
world. It makes this vision concrete by defining some simple
software objects corresponding to patterns and goals.
In
the mid-90’s, starting out on Webmind design, I had
basically a comprehensive knowledge of what was happening
in the AI world. It was a mess. It’s basically the
same way today. There’s no well-understood, commonly
accepted body of scientific knowledge about AI. Instead,
there’s a vast diversity of approaches to various
aspects of the relationship between computation and mind.
Some of the approaches contradict each other and some of
them complement each other. Designing Webmind was a process
of assembling information from various different perspectives
and disciplinary areas into a coherent whole, guided by
a set of governing principles.
Many different subdisciplines within the AI umbrella contributed
to the structuring of Webmind, and then Novamente. Some
of them I was thinking about when I first started designing
Webmind, others emerged as being significant more recently,
further along in the design process, in some cases only
in the transition from Webmind to Novamente. Table 1 gives
an overview of the sorts of things that Novamente draws
from various disciplines. It may be a bit opaque to the
nontechnical reader, but it will mean something to the reader
with some computer science background, and perhaps to others
it will be at least generally evocative.
|
Cognitive
Psychology |
From
cog psych we have taken a number of high-level
structural principles, for instance the notions
of Long-Term Memory, Episodic Memory (memory
of your own history), and Short-Term Memory;
and the distinction between procedural (knowledge
of how to do thing) and declarative knowledge
(factual knowledge).
|
| Introspective
Psychology |
Modern
cognitive psychology is experimentally focused,
but past traditions in psychology have more
openly drawn their inspirations from introspection,
from what each mind intuitive knows about itself.
The overall structure of Novamente owes something
to ideas drawn from these traditions, from Gestaltism
to Buddhist psychology and Peircean philosophy.
|
| Neuroscience |
From
neuroscience we have taken the observation that
mind can be implemented by a parallel distributed
system with activation spreading around it
in complex patterns – i.e. a ‘neural net’, broadly
conceived. We’ve also taken our approach to
localization from what’s known about the brain:
in Novamente, knowledge is distributed, but
not across the whole system; each type of knowledge
is distributed across a part of the system,
just as is done in the brain.
|
| Complexity
Science |
The
emerging science of complex systems has contributed
crucial concepts such as self-organization,
evolution, autopoiesis and emergence. Novamente
is a modular system in which the real intelligence
emerges from interaction between the modules.
Like many complex systems, it displays behaviors
like phase transitions and sensitivity to initial
conditions, and evolution-ecology interactions.
|
| Nonlinear
Dynamics |
One
of the more rigorous subsets of complexity science,
nonlinear dynamics studies the attractors and
transient patterns that emerge as nonlinear
systems evolve over time. Novamente is a highly
nonlinear dynamical system whose attention is
allocated by complex attractor dynamics, and
that specifically studies transients in its
own dynamics so as to self-adaptively modify
its own structure.
|
| Statistical
Pattern Recognition. |
In
its analysis of numerical data (e.g. financial
forecasting) and its lower-level linguistic
processing, Novamente makes use of statistical
pattern recognition tools. What makes it unique
is its ability to integrate statistically recognized
patterns with other types of knowledge, and
to generalize from this knowledge via inference
and other mechanisms.
|
| Multi-Agent
Systems |
With
the advent of distributed and parallel computing,
there is a substantial body of knowledge about
how to make populations of computational agents
cooperate to carry out useful activities. Novamente
is a multi-agent system, albeit a very unusual
one, and its system architecture makes use of
principles from this area of computer science
in many ways.
|
| Computational
Linguistics |
The
last decade’s explosion of knowledge in computational
language processing has produced many techniques
of use within Novamente. The challenge has
been to get all these tools working together
in a common framework focused on extracting,
creating and producing meaning rather than on
syntax analysis
|
| Expert
Systems |
Novamente
allows humans to enter expert knowledge into
it via XML, Sasha or other special formal languages,
similar to standard AI expert systems. Unlike
expert systems, though, it doesn’t take this
knowledge as truth: it takes it as information
given to it by another mind, and feels free
to forget it or modify it as it sees fit.
|
| Machine
Learning and Optimization |
Machine
learning and optimization algorithms are not
real AI systems but they do solve problems that
are crucial to the mind. Novamente uses genetic
algorithms, genetic programming, and statistical
machine learning techniques for various purposes,
internally.
|
| Logic |
While
Novamente is not a logic system in the traditional
sense, it makes use of the reduction of general
relationships to a simple relational formalism,
which was pioneered by mathematical logicians
and logic-inspired AI engineers. It manipulates
relationships using uncertainty-robust, self-organizing
reasoning techniques different from those used
in the logic or AI literature
|
|
Table
1 - Novamente’s Diverse Inspirations
|
Obviously,
this laundry list of component technologies doesn’t
really tell you a damn thing about Novamente. That’s
because the crux of Novamente lies, not in the component
technologies, but in the way these technologies are structured
to form a coherent self-organizing system. But still, the
presence of all these tools made the process of building
Novamente very different than it would have been if none
of the tools existed, and you had to build every component
technology from scratch. Rather than just “how do
you program a mind on current hardware and software?”,
the question becomes more like “Given all these wonderful
tools, and amazingly powerful distributed hardware on which
to implement them, how can we tie them all together in a
harmonious and mutually adaptive way to produce a mind?”
Given
the general conceptual framework I’ve described, and
the practical and conceptual toolbox I’ve listed,
the first step toward actually designing Webmind was deciding
what the “atomic mental object” should be.
Bigger than a neuron, smaller than a machine, was the first
decision. I created a Java object called a Node. A node
is the most basic kind of pattern known to Webmind –
it’s something Webmind recognizes as a whole. A node
says, “This thing is worth distinguishing from its
environment as a whole entity. Here it is. It persists and
maintains its boundaries over time.” We have some
nodes referring to external sensed objects: TextNodes, DataNodes,
WordNodes, and so forth. We have some nodes representing
patterns recognized in the system itself rather than in
the outside world: CategoryNodes of various kinds, AutomatonNodes
representing evolved patterns, etc. There are nodes called
SubgraphImageNodes that represent parts of the mind, grouped
with a boundary drawn around them so as to be considered
as a kind of higher-order individual. And so on, and so
on, and so on.
But nodes are just the start. Webmind is also wired to recognize
certain kinds of patterns involving nodes. Similarity is
the most basic kind of pattern: it’s the recognition
that two different things, occurring at different points
in space or time, are actually a lot like each other, and
can be interchanged for many purposes. Inheritance is also
basic: it’s the recognition that you can substitute
A for -- (though maybe not -- for A) without substantial
loss of information.
How many link types to incorporate was a big question. In
the AI systems known as semantic networks, you have a different
type of link for every relation in the net – a link
type for kick, a link type for eat, and so forth. On the
other hand, in a typical neural net model you have only
one link type; whereas in the brain, there are many types
of neurons and synapses – hundreds of link types,
if you identify a link type with a synapse that’s
reactive to a certain neurostransmitter.
In designing Webmind, we didn’t want to introduce
too many types of links, because this just leads to a network
that represents data in ways it doesn’t understand.
We chose to use a few dozen link types, representing what
I think of as archetypal types of relationships.
What kinds of relationships are “archetypal”
for Novamente? Here I’ll just give a few important
examples. We have similarity links, representing the belief
that one actor is similar to another. There are inheritance
links, representing the belief that one actor is a special
case of another. There are spatiotemporal links, representing
the belief that one actor represents something occurring
near the other one in time or space. There are containment
links, representing the belief that the entity represented
by one actor is contained inside another one. There are
associative links, representing simply the fact that Webmind's
dynamics tend to associate one actor with another. This
chart shows the definitions of these links in a bit more
systematic way:
| Link
Type Pointing from A to B |
Meaning
of the Link |
| Similarity |
A
is similar to B |
| Inheritance: |
|
|
by Extension |
A
is a special case of B |
|
by Intension |
B
is a special case of A |
| SpatioTemporal |
A
occurs at the same time and place as B |
| Temporal |
A
occurs at the same time as B |
| Before |
A
occurs before B |
| After |
A
occurs after B |
| Containment: |
|
|
Part of |
A
is a part of B |
|
Contains |
B
is a part of A |
| Associative |
B
is associated with A |
|
HaloLink |
B
is associated with A by Webmind's Dynamics |
These
link types, and others refining and extending these, are
the elemental types of relationships that Webmind “understood.”
They are a bit, but not a lot, like the various neurotransmitter
receptors in the brain, which make different synapses different.
The brain's receptors do not correspond so neatly to logical
relations. But Webmind is not a brain; it is a mind that
emerges out of digital computer hardware. Digital computer
hardware is closer to logic than cells are.
These links are heterarchal in a sense; any node can link
to any other node. But they are also organized in hierarchies
of composite actors representing, not specific relationships
like links, but collections of relationships. Nodes contain
links; nodegroups contain nodes, lobes contain nodegroups,
and the mother of them all: the Psynet, the whole Webmind,
that contains a lobe for each machine in its network. The
basis of it all is the node: a node containing a bundle
of links expressing its relationship to other nodes, and
also some basic data objects and actors and roles. Nodes
sending out messages -- information gathering and information
carrying actors -- of various types to help them build new
links to other nodes. A gigantic network of interlinked
actors, constantly rebuilding itself, extending across multiple
CPU's and multiple machines.
The nitty-gritty engineering needed to make this all work
is considerable indeed. But the basic concepts are elementary.
It's nothing but Peirce's network of relations, each spreading
attention to the other relations that it stands to in a
peculiar relation of affectability. It's nothing but Nietzsche's
dynamic quanta, each one defined in terms of other dynamic
quanta, each one re-creating itself and each other. It's
beautiful and primal -- but it's not intelligent, without
more detail, more specialization. It’s like the brain
of an infant. All the core abilities are there, but intelligence
develops as it incorporates and processes specialized information.
It’s easy to see how both node and links are patterns
in the sense that they allow one to compress information.
If two parts of something one is describing are similar,
one can save effort by not describing the second one in
detail and just describing it approximately by reference
to the first one. For instance, to describe a picture consisting
of two similar heads, you can draw one head and then just
say “imagine two of these next to each other.”
If one of the parts of the picture inherits from the other,
one can save effort by replacing the more specific one with
the more general one. Of course, there is a loss of information
here. Suppose half of the picture is a general human shape,
and the other half is my shape. My shape inherits from the
general human shape, obviously. But if you describe the
picture by drawing the general human shape and saying “two
of these,” you’re losing a fair bit of information,
though certainly not all of it.
Similarity and inheritance are logical relations, logical
patterns. We also have purely observational patterns, like
temporal relatedness, spatial relatedness, and part-whole
relatedness. And we look for general association relations:
When the system thinks of X, what Y comes to mind? This
Y stands in an associative relation to X.
Nodes in Webmind contain links to other nodes, each link
embodying one of these basic inter-node relationships: similarity,
inheritance, part/whole, spatial, temporal, associative.
Nodes and links are the two levels of pattern that are automatically
and instinctively recognized by Webmind: nodes representing
perceived wholes carved out of the chaos of the world or
mind, and links representing patterns perceived among the
nodes.
We then have special methods of building links. The method
we used most in Webmind (but have basically abandoned in
Novamente) was one I came up with in 1996, inspired by Web
spidering, called Wandering: we have actors that move around
through the network of nodes, traveling from node to node
along links, looking for nodes that are strongly related
and should be joined by new links. This particular method
of link formation may or may not be the best. The key point
is that there is some dynamic by which new and relevant
links are continually formed.
Relevance is determined by how much “activation”
each node has, and activation is spread through the network
by Peirce’s Law of Mind, which is the same at to say,
by basic neural net activation spreading. The Java object
that carries activation through Webmind, we call a Stimulus.
Associative links are built by a process we call “halo
spreading,” in which a node gets active and then measure
how active other nodes become as a consequence, after a
certain period of time. It spreads Stimuli to other nodes
and then collects them after a while, observing how stimulated
they’d become.
Again, there are a lot of ways of doing these things, and
the current ways may or may not be the best. The exact method
of spreading activation or halos is not crucial to Webmind,
but rather just the overall character of the patterns being
recognized and formed.
Halo spreading and reasoning and wandering form new links,
but it’s also crucial to form new nodes, and this
is done by combining old nodes in various ways (fusing them,
splitting them) and also be explicitly evolving new nodes
to satisfy various goals using special nodes called EvolverNodes.
The achieving of goals, crucial to intelligence, is done
using nodes that we now call SchemaNodes, which contain
little programs that control aspects of perception, action
and thought. Perceptions from the outside world come into
Webmind and are translated into nodes right away. These
nodes link to other nodes representing contexts that the
system is operating in, and these contexts link to SchemaNodes,
representing things that might be desirable to do. The goals
as well as the contexts link to the schema, so that the
hottest schema will be the ones that are relevant to the
current goals in the current contexts. Schema look into
the long-term memory of the system and grab out the various
nodes and links contained therein.
There’s also a SelfNode, recording the history of
the system – what psychologists call “episodic
memory” – and predicting the future of the system,
and selecting the system’s goals according to the
metagoal of maximizing system happiness. Yes, we have a
Happiness FeelingNode, and nodes for other basic emotions,
complex emotions being considered combinations and mutations
of simple ones. What makes the system happy – we get
to decide at first, until it mutates and modifies its own
HappinessNode just like we do. Right now, it likes to answer
questions people ask it, it likes to save memory, and it
likes to build a lot of high-strength links – i.e.,
to discover a lot. Schema look into the SelfNode to get
their overall motivation.
Many goals involve making others happy, and for this, models
of other minds need to be maintained; this is done in UserNodes.
There is a loose mapping between these data structures and
things in the brain. Nodes are a bit like neuronal groups
– clusters of 10,000 to 100,000 neurons, that sort
of act as a unified whole. Links are sort of like bunches
of neural connections between one cluster and another. This
intuitive mapping onto the brain can be useful, and it’s
surely not a complete fluke that the structure of the brain
is a lot like the structure of the mind that emerges from
the brain. On the other hand, it’s important not to
overblow the very loose neural modeling aspect of Webmind.
Webmind was supposed to be a mind, not a model of the human
brain, and it’s a definite failure at being a model
of the human brain, not surprisingly.
There’s a lot of complexity here, just like in the
brain. But basically, Webmind's architecture was that of
a massively parallel network, a population of many, many
different information actors – nodes, links, wanderers,
Stimuli spreading activation and collecting halos. The nodes
continually recompute their relationships to other nodes.
Queries put to the system are transformed into nodes that
take advantage of WebMind's self-evolving structure to produce
the needed answers.
All
this – plus or minus a few critical details, and a
lot of non-critical ones -- was outlined roughly and erratically
in some documents I wrote during Spring and Summer 1997.
Some things were designed in detail, others just hinted
at. Because so many details were left out, it wasn’t
quite clear to me, at that point, what a humongous system
this was going to become.
This was still pre-Webmind Inc.; I was working in loose
collaboration with a friend and programmer named John Pritchard,
who liked my thinking in a general way, but never really
came to grips with my ideas, except on a philosophical level.
He wanted to approach things by first building a general
Java infrastructure for dealing with AI, and then implementing
my particular AI theories – an approach which makes
sense, but only if the infrastructure is deeply informed
by the AI theories, which wasn’t the case then.
During summer 1997, John and I parted ways, and my friend
Lisa Pazer and I started the company that was initially
called Intelligenesis Corp., and later changed its name
to Webmind Inc. (because American businesspeople seemed
to have too much trouble spelling the orignal name!). At
that point I gave up coding 10 hours a day, turning that
responsibility over to my newly recruited old friend Ken
Silverman, and spending most of my time on design issues.
I was still coding a few hours a day at that point, but
not like before.
Ken learned Java in a couple weeks, and set to work. We
talked on the phone several hours a day, and he coded for
the rest of his waking hours. He ended up creating a new
Webmind from scratch, based on reading and reinterpreting
print-outs of my eccentric, tangled Java code. My first
version had been useless, but had followed the concepts
of my theory of mind fairly directly. Ken's version followed
the structure of Java more so than my theoretical ideas.
It was a colossal step backward in conceptual elegance.
But it had one fantastic redeeming feature: as of February
1998, it finally worked!
OK, in retrospect, it didn’t really work, but it looked
like it worked at the time. It wasn’t made to exploit
multiprocessor machines, or networks of machines. It wasn't
ready to serve as the infrastructure for the global brain.
It was too small to demonstrate any really interesting emergences,
any of the structures of mind I’d identified in my
theoretical work. But it was our first working prototype,
and we rigged it up to do some simple things like read in
a bunch of Web pages or numerical data series, and decide
which ones were similar to each other. No tremendous intelligence
was apparent yet, but we hadn't expected any. We'd built
the infrastructure for intelligence, but hadn't put in the
specialization that would allow the system to display useful
intelligence in particular areas.
It was very simple in concept, but very complex to actually
implement. We had a network of mental entities, each one
related to other mental entities, and each one constantly
revising its collection of relationships. Each node, and
each actor, was an "object" in the Java programming
language, which proved very well suited to our needs. Writing
Webmind meant writing Java "classes" for all the
different kinds of nodes, wanderers and other objects we
needed. Practical problems kept coming up, problems I had
never thought of when I was writing theoretical books and
scribbling notes on the back of photocopied research papers.
For example, what do you do when the system has recognized
too many relationships in itself and has run out of memory?
How do you decide which relationships to cull? How does
the system manage its time, allocating certain amounts of
CPU time to each node to use in building new relationships?
How does the system determine how much time to spend loading
in new information into new nodes, versus building new relationships
among existing nodes? And so on, and so on, and so on.
We also wanted to build up Webmind's thinking power. This
meant we had to keep increasing our palette of specialized
classes of nodes and links representing particular kinds
of relationships and concepts. The real intelligence, I
was certain, would then emerge from the interactions of
all these specialized nodes and links in the self-organizing
network. But before we could get there, there were dozens
of mechanical issues to be worked out, debugged, tested,
tuned.
In the very early days of Intelligenesis, before we got
funding, the work proceeded in pairs, each pair consisting
of me and someone else. Lisa and I worked on the business
plan and tried to raise money. Ken and I worked on the first
Webmind prototype, which ran on a single computer with a
single processor; Ken doing nearly all the coding, me giving
him designs and suggestions through endless phone calls
and meetings. Jeff and I were taking his nonlinear prediction
algorithms and making them more intelligent and flexible,
integrating them with some of my own AI work. Onar and I
were sending back and forth endless e-mails diagramming
what would later become the language learning component
of Webmind’s natural language system. And Paul, in
looser communication with me than the others, was designing
and coding the Pods system, a very nice system for doing
self-organizing computing on multiple machines and multiprocessor
machines.
In the spring of 1998, Ken integrated Webmind with the Pods
system, producing the first Webmind that had a prayer of
actually running on a lot of machines at once. This was
a system which could serve as the foundation for a global
mind. It exploited the power of Java even more fully than
Ken's first version had -- it was more "object-oriented,"
and used Java's network-computing facilities more thoroughly.
And then things went completely crazy. In a mostly good
way. Lisa finally got us funding, and we started hiring
programmers and scientists. People were coding nodes and
links embodying specialized kinds of intelligence. The system
got smarter, and things got far messier.
The most crucial hire was Pei Wang, a Chinese computer scientist
a few years older than Ken and me, who when we hired him
had spent the last 12 years developing a system of probabilistic
logic called NARS, the Non-Axiomatic Reasoning System. Within
a few months, Pei had integrated many of the ideas of his
NARS reasoning system into Webmind, providing us with a
handy nodes-and-links version of probabilistic logic. He
also introduced a lot of ideas into Webmind as a whole,
apart from its reasoning component. For instance, it was
Pei’s inspiration that every link in Webmind should
have four numbers associated with it: a strength telling
how significant the pattern represented by the link is;
a confidence telling how sure we are of the assessed significance;
an importance telling how useful the node is to the system
as a whole; and a decay rate telling you how fast importance
decays for that particular node.
Toward the end of summer 1998, we also hired Cassio Pennachin,
who at that point was just one among a handful of Java hackers
around the world whom I’d recruited through job ads
on Usenet. Cassio lived in Belo Horizonte, Brasil, and first
took on the job of fixing up some code I’d written
for evolving new structures in the mind using a variant
of genetic programming. This was the beginning of what’s
become an Intelligenesis tradition: Brasilian programmers
receive American code by e-mail and respond very politely
with comments like “Excuse me, but would you be terribly
offended if I made a few changes to this code?” Of
course, you say yes, and a few days later you receive a
completely new version of the software, containing exactly
three lines from your original code, but much better designed
and also more efficient.
Cassio proved to be an excellent manager as well as an excellent
software engineer, and I let him accumulate assistants until,
as of now, we have more than half our engineering staff
in an office Belo Horizonte, with Cassio as our overall
Director of Webmind Development. The Brasilians, so far,
have not made any big AI innovations, but the disciplined
approach to object-oriented design that they’ve brought
us has been just as important as our AI innovations, in
terms of getting Webmind, this humongous piece of Java code,
to actually work. The real importance of this aspect of
their work didn’t become apparent until the end of
1999, with their psycore redesign – but I’m
getting ahead of myself.
The rapidly increasing size of the Webmind codebase was
inevitable because the core code Ken and Paul and I had
written wasn't enough for intelligence in any practical
context. It was just a generic intelligence mechanism, a
self-organizing, relationship-building network. As we introduced
more and more specialized nodes into the system, the system
as a whole changed. New problems emerged. We should have
anticipated that this would happen, but we hadn't really
thought about it. We'd been too busy dealing with the challenges
of formulating the psynet model in Java in a network-friendly
way.
To deal with this blossoming of the Webmind code, in the
summer of 1998, Ken and Paul split Webmind into parts. The
central part, the one they had been working on, they called
Psycore. This contained the generic mechanisms for dealing
with nodes, links and wanderers. In a sense, this was Webmind's
operating system, the code that enabled all the parts to
work together. Then there were the Psymodules, one for each
specialized area of intelligence: natural language, reasoning,
numerical data analysis, etc. If we were to decode the DNA
code that generates the human brain, we might find that
it works in a similar way. The "psycore" would
be the DNA code that describes the features that are common
to all neurons, synapses and neurotransmitters. The "modules"
would be the DNA code which describes the distinct features
of the specialized types of neurons (there are dozens) and
neurotransmitters (there are hundreds), and the particular
patterns of neurons, neurotransmitters and synapses that
make up different parts of the brain.
The brain has hundreds of specialized parts devoted to tasks
such as visual perception, smell, language, episodic memory,
and so forth. Each of these parts is composed of neurons
which share certain fundamental features, but each also
has its unique features and capabilities that scientists
are only beginning to understand. Similarly, when a Webmind
is running on a computer, different parts of the computer's
memory are assigned to different tasks. Each of these parts
of the computer's memory draws on the psycore for its basic
organizational framework, and on more specialized modules
for advanced capabilities.
Each of Webmind’s modules is specialized for recognizing
and forming a particular kind of pattern. And all the different
kinds of nodes and links can learn from each other -- the
real intelligence of Webmind lies here, in the dynamic knowledge
that emerges from the interactions of different species
of nodes and links. This is how Webmind builds its own self;
it’s the essence of Webmind’s mind, of how Webmind’s
patterns create and recognize patterns in themselves and
the world to achieve their complex goals.
I’ll give a quick laundry list of modules, without
going into great detail on any of them.
There was a numerics module, containing data processing
actors that recognize patterns in tables of numbers, using
a variety of algorithms, some standard, some innovative.
DataNode embodies nonlinear data analysis methods and it
recognizes subtle patterns that’ll always be missed
by ordinary data mining and financial analysis software.
There was a natlang module, which deals with language processing.
The natlang module represents texts as TextNodes, linking
down to WordNodes representing words in the text, and other
nodes representing facts, concepts and ideas in the text.
It has text processing actors that recognize key features
and concepts in text, drawing relationships between texts
and other texts, between texts and people, between texts
and numerical data sets. These actors process vast amounts
of text with a fair amount of understanding and a lot of
speed.
The natlang module also contained reading actors, which
are used to study important texts in detail. They proceed
through each text slowly, building a mental model of the
relationships in the text just like a human reader does.
These reading actors really draw Webmind's full set of semantic
relationships into play, every time they read a text.
There was a category module, containing actors that group
other actors together according to measures of association,
and form new nodes representing these groupings. This, remember,
is a manifestation of the basic principle of the dual network.
There were learning actors, that recognized subtle patterns
among other actors, and embody these as new actors. These
spanned various modules, including the reason module, containing
logical inference wanderers, that reasoned according to
a form of probabilistic logic based on Pei's Non-Axiomatic
Reasoning System; and the automata module, containing AutomatonNodes
that carried out evolutionary learning, according to genetic
programming, a simulation of the way species reproduce and
evolve.
In the user module there were actors that model users' minds,
observing what users do, and recording and learning from
this information – these are UserNodes and their associated
Wanderers. There are actors that moderate specific interactions
with users, such as conversations, or interactions on a
graphical user interface. And in the self module there are
self actors, wanderers and stimuli that help the SelfNode
study its own structure and dynamics, and set and pursue
its own goals.
Each of these actors involved in the modules had in itself
only a small amount of intelligence, sometimes no more than
that you might see in competing AI products. The Webmind
core – “psycore”, as we sometimes called
it -- was a platform in which they can all work together,
learning from each other and rebuilding each other, creating
an intelligence in the whole that is vastly greater than
the sum of the intelligences of the parts.
The version of Webmind we completed in the summer of 1998
– the first multi-module version -- worked fine for
about a year. We used it to build the modules essential
for Webmind's core intelligence and for several impressive
applications. It included a module for text-based market
prediction; a natural language module for mapping texts
into networks of meanings; several modules for the evolution
of concepts according to different methods; a module for
Webmind's self-understanding; and so forth. The development
of each module was driven by requirements particular to
certain application areas. The financial modules were driven
by the practical need to predict the markets. The natural
language module was driven by the need to parse financial
text, and understand human queries. The concept learning
modules were driven by the need to learn concepts relevant
to financial prediction and to the processing of human queries.
The self-understanding module was driven by the need to
have the system proactively think about things that humans
were likely to ask it about in the future.
At this point, Webmind benefited greatly from the fact that
we weren't just implementing a theory, we were hard at work
developing practical applications. One of the most profound
pieces of advice I’ve ever received about Artificial
Intelligence came from Danny Hillis, who I discussed above
-- inventor of the Connection Machine parallel processor,
founder of Thinking Machines Inc., and an informal advisor
for Webmind Inc. throughout its lifetime. As we sat in the
South Street Seaport in New York eating dinner one day,
he was discussing a major AI company that had worked for
10 years to design an AI system, without considering in
detail any particular application of the system. Lo and
behold, the system had never done anything useful. Danny’s
comment was: “They were brilliant people with good
ideas, but they made a serious methodological error. They
developed their system for years and years, without any
contact with practical applications.” Our software
was saved from this fate by the fact that we were committed
to producing actual products, simultaneously with working
toward the goal of real AI. We were freed up to commit other
major errors instead!
The Webmind AI Engine itself was never used inside any production-version
software products, but it was used to prototype a number
of AI processes that were later re-implemented inside products.
One of these products, the Webmind Market Predictor, will
be discussed in detail in the following chapter. The reason
the Webmind AI Engine wasn’t used directly in products
was basically that it was too slow-running, and plagued
by hard-to-excise bugs. The Novamente system, as I’ll
discuss a little later, is a more mature effort and doesn’t
have these problems, and it’s being directly used
inside some software products we’re developing for
the bioinformatics market.
Working
on practical problems in parallel with grandiose long-term
goals was valuable – but it had its disadvantages
as well. It pushed us to overspecialize the system, hyperdeveloping
those portions that were needed for products, rather than
developing the whole system in a more evenly-balanced way.
Most of our code was good for the specific tasks it specialized
in, but we had not gotten to the stage where all the modules,
all the different node and link types, were working together
in one big multi-machine Webmind. We were producing cool
research software, but not the global brain I had dreamed
of. We hadn't yet seen the emergence of the dual network,
of the self. And we weren’t able to push straight
toward it because the particular portions of the system
needed for the Webmind Market Predictor – our first
product – needed so much attention.
But overspecialization induced by business needs was far
from our only problem. The truth, as we sourly discovered,
was that our core Java code, implementing the essence of
the psynet model of mind, was just barely adequate for building
products, let alone building real AI – it had too
many bugs and was poorly documented. Ken had implemented
this code brilliantly and painstakingly over a year of 15
hour workdays, but, even so, the task had been too big for
any one human. We could have fixed up his code to make it
product-ready, but we doubted whether we’d ever get
it to the point where it could support the global brain.
So, toward the end of summer 1999, we decided to rewrite
the Webmind code again. Not the whole system, thankfully
-- we were too far along for that -- but this time only
psycore, the central core of the system. This time around,
Ken was helped out not only by me but by Cassio and several
of his colleagues in Belo Horizonte, most notably Andre
Senna and Thiago Maia, two masters of data structures and
algorithms. At this point, there was a lot of pressure,
from some members of staff on both the technical and business
sides of Intelligenesis, to give up on the unified AI architecture
altogether, and just focus on making individual products
as good as they could be, postponing real AI into the future.
But Ken and Cassio and I and others focused on building
real AI resisted this pressure and plowed ahead with building
a new, improved psycore. Among other beloved chunks of code,
Paul’s Pods system met its doom in this rewrite.
The reasons for this redesign are somewhat interesting;
they reveal a lot about the nasty realities of building
big software systems doing complicated, intelligent things.
The erratic bugs and lack of documentation in Ken’s
code were part of the problem, and made Ken the arch-enemy
of the engineering staff for a while. But this stuff was
fixable. There was also a more serious problem with the
system. It just wasn't flexible enough to enable a huge,
multi-module Webmind to be run in a really intelligent way.
When the system was only doing one thing – say, reading
text, or using text to predict markets – then it was
fine. But, it was very bad at regulating several activities
at once.
For example, when loading in a series of texts, one would
see it get slower and slower at reading. The reason was,
the more texts it had in it, the more it had to think about.
It had no time to read more text because it was so busy
thinking about the texts it had already read! I remember
once when Mark Watson, one of our Java AI gurus, noticed
this problem in a Webmind demonstration he had written.
Jim McLoughlin – one of our early hires who built
a lot of Webmind’s numerical and financial analysis
components --showed him a way around it. By hacking the
code, you could get it to do anything, in any particular
situation. But what was needed was intelligent self-control:
the system had to know what processes were important to
it, and regulate the amount of attention it spent on various
things accordingly. Of course, we had always realized this
would be necessary. But we hadn’t realized how deeply
we’d have to code self-control into the system. Ken’s
1998-99 psycore was built to follow its whims, not to control
its dynamics in accordance with goals; and imposing goals
on top of this structure was like trying to get a hyper
child to sit down and listen to a history lesson.
The system was so complicated that we couldn’t easily
make the simple changes we needed to make to turn it into
a real global brain platform. We needed to be able to turn
on and off the different capabilities of the nodes and links
at will -- and have the system do this automatically, adapting
to its circumstances. We needed to be able to take collections
of nodes and links that were stable, no longer evolving,
and "freeze" them into a state that took up very
little memory, providing easy access but no adaptability.
We needed to be able to observe what was going on in a particular
part of the system, and chart its dynamics, to see what
structures were emerging.
Over the period 1998-99, psycore had evolved incrementally,
getting new features whenever a module author needed them.
The natural language team needed psycore to do one thing,
the finance team needed it to do another, the categorization
team needed it to do another, the reasoning team needed
a reasoning module, and so on, and so on. None of these
requests fundamentally changed the architecture of nodes,
links and wanderers -- mental entities relating to each
other and dynamically altering their relationships -- but
they changed the details of how nodes, links and wanderers
worked, and how they could be accessed and changed. The
abundance of new features had made the core code more powerful,
but it had made it messier too, and harder to control. Many
of the new features had similar structures, and in hindsight
could be consolidated into simpler structures. Engineers,
charged with building specialized components of Webmind,
complained that the system offered so many features and
possibilities that it was difficult to figure out how to
use it. They wanted something simpler, with a few good features
rather than a large number of features of varying quality.
Was it really necessary to go through all these revisions?
Why not just figure out everything correctly the first time,
and avoid all the reworking and re-reworking? One answer
is: We should have, we were just inexperienced, so we kept
fucking up. But there’s also another answer, that
I prefer because it’s more flattering to me! This
answer is: evolution doesn't work that way. Webmind, as
a software system, is an engineered system, but it is also
an evolved system. It went through several incarnations,
each one with some fit aspects and some unfit aspects. The
fit aspects survived to the next incarnation; the less fit
aspects didn’t. All large software projects evolve
through multiple generations; Webmind was not unique in
this regard. But the evolution of Webmind had unique aspects
because what is evolving is mind itself. In this evolution
we had to retain both those features that were most useful
for practical applications and those that were in accordance
with the abstract structure of mind.
Evolution’s good at figuring out how to make a system
that can achieve its goals within a certain environment.
In this case, the system was Webmind, and the environment
includes the physical structure of modern computer hardware,
the universe of software that has evolved to adapt to it,
and the practical applications that Webmind was intended
for, like market prediction, news filtering, data analysis,
text analysis, and conversation. Java, wonderful as it is,
wasn’t designed for mind hacking. The von Neumann
architecture was designed for repetitive mathematical calculations,
not for intelligence. But, by the same token, the brain
was designed for sensing and acting, not for abstract thought.
Fiber cells were designed for musculature, not for use as
neurons. Mind can emerge from any sufficiently flexible
substrate, as the features of the substrate gradually adapt
themselves to the requirements imposed on them.
The new psycore had a multi-layered structure, which I invented
based on some conversations with Youlian Troianov, a Bulgarian
software engineer who believes Webmind can never be truly
intelligent because it doesn’t make use of the fundamental
quantum symmetries of the universe (but he kept working
for us anyway, and even now follows Novamente work very
closely). I still don’t completely understand what
Youlian meant when he suggested psycore should have many
layers, but the idea set off a spark in my mind, and the
current psycore does indeed have three layers.
The lowest layer was what we called “abstract actors.”
It was a general framework for computational actors that
group other actors and transform other actors and send messages
to other actors. We chose the word “actors”
here instead of “actors” because “actors”
seems to mean too many things to too many people. Lots of
other possibilities were tossed around, including more interesting
ones like “cells,” “psells”, “psions”,
“psychons” and so forth. Basically, Layer 1
provides a kind of “mind operating system,”
suitable to run on a single machine and a single processor,
or else on a massively parallel hardware system in which
each actor gets its own processing power, like in the brain.
The second layer was “distributed actors” –
this deals with all the horrible nastiness of implementing
a massively parallel system on a collection of multiprocessor
machines networked together by TCP-IP. Scheduling of processes,
sending of messages from one machine to another, and so
forth. Paul’s Pods system was considered as a structuring
principle for this layer, but based on extensive testing
by the Brasilians, we chose some other ideas instead, which
Paul wasn’t terribly happy about.
The third layer, finally, was nodes and links and wanderers
and all the good stuff – all the stuff I invented
in 1997 and Ken and I coded up in the beginning. This layer
comes out very small once you put all the general actor
interaction stuff in layer one and all the nasty multiprocessor
and multi-machine stuff in layer 2. But the fact that it’s
small is great, because it means it can be easily experimented
with.
That’s it – three layers of psycore. If you
want to you can extend the layering metaphor outside of
psycore into the rest of Webmind. The fourth layer, conceptually,
is the modules, all the specific node and link types for
carrying out specialized functions of mind. And the fifth
layer, if you want to stretch the metaphor, would be some
fragments of Java code called “interfaces” that
I wrote to systematize all the different learning methods
in the modules. For instance, a categorization interface
that groups together all the different categorization methods
in the different modules.
None of this layering really adds anything to the philosophy
of mind underlying Webmind – it’s just a matter
of making the huge morass of complexity needed to make a
practically useful mind into a workable software system.
The complexity comes from two places: first, the diverse
specialization needed to make pattern recognition and formation
practical in any real world; and second, the fact that we
don’t have a massively parallel hardware substrate
like the brain, so we have to get a massively parallel self-organizing
system of nodes and links to run on a hodge-podge of processors
and memory units. The object-oriented design skills of our
Brasilian engineering team were crucial in getting all this
to actually work correctly, which it now seems to, much
to my amazement and pleasure.
The
next big upheaval in our conception of Webmind – a
few months after the new psycore was done – had to
do, not with the structure of the core system, but rather
with the teaching of the system as a whole. The basic problem
here was: Once you have the dynamics and structures needed
for the mind implemented in an adaptable, workable, testable
way – you still need to turn this mind framework into
an actual particular mind, that understands the world around
it. How do we get the knowledge in? We had a lot of ideas
about learning and extending knowledge from grounded to
ungrounded domains – ideas I mentioned above. But
this didn’t seem to be quite enough. We started to
think the system was going to need a bit more of a helping
hand in learning how to cope with its world.
In January 2000 I read the engineering plan for the Natural
Language module, written by Karin Verspoor, our Director
of Natural Language -- another one of our very early hires
who took over the language processing aspect of Webmind
from Onar way back in 1998. Karin has a comprehensive knowledge
of linguistics and computer science, but when she started
working for us, she didn’t have much background in
computational linguistics. She inherited from Onar and me,
when she first started out, a lot of ideas about how computers
could learn language by statistically studying texts. The
basic framework was one that my wife Gwen and I had developed
in 1994, when Gwen was working on her PhD in computational
linguistics. Onar helped me extend the ideas beyond where
they’d been when Gwen had dropped out of her PhD.
Karin helped Onar to make practical Webmind implementations
of the stuff he was working on.
Some of these language learning schemes were great and some
were absolute rubbish. We’re still not sure about
some of them. Anyway, after about 8 months trying to get
the 1998 version of Webmind to learn language by recognizing
patterns in texts, Karin gave up in frustration, and started
taking the Webmind NL module in a new direction, in which
the structures of language are built in, and even a lot
of specific facts about English are built in, like parts
of speech, grammar rules, and so forth. I always had mixed
feelings about this. Webmind was really supposed to learn
everything on its own, not have stuff wired in – that
was the stuff of expert systems, rule-based AI, which I
knew on philosophical grounds was a total dead end. On the
other hand, I told myself, human language was a special
case among all the things Webmind had to deal with. My theory
of mind explained how Webminds could learn their own language,
to communicate amongst each other. But I’d never really
explicitly thought about how a mind could learn the language
of a completely alien race – which is what we are,
from the point of view of Webminds.
Webmind didn’t have a human body, and without one,
could we really expect it to learn human language? Although
Onar’s and my methods for having the system learn
language from recognizing patterns in texts seemed to make
perfect sense, mathematically and conceptually, this obviously
wasn’t the way people learned language. You learn
to talk and hear language before you learn to read it. You
learn what words mean from your embodiment in the world
with other people who talk to you and listen to you.
It seemed to me we were missing something – not in
the core Webmind design, but somewhere else. Finally, after
a few days of soul-searching, I figured out what it was:
Humans learn how to be intelligent by interaction with other
humans in a shared environment. It’s as simple as
that. Raise a baby human in a room by itself and it’ll
grow up to be a moron. Of course, I’d said as much
in my theoretical books, way back in the Dark Ages, but
with all the focus on getting the system to actually work,
getting all the modules to work on their own and to work
together, I’d let this aspect of intelligence slide.
How to work this aspect into our current work on Webmind,
I wasn’t quite sure, but I knew I had to figure it
out fast.
I needed someone to bounce these ideas off of as they developed.
I chose two of our best young AI engineers – Cate
Hartley and Mike Ross – together with my Deputy CTO,
Stephan Bugaj. It was important to me, in developing these
ideas from vagueness to concreteness, to work with people
who hadn’t played a big role in designing the current
system, because I was afraid that the conclusion might be
that the current system was lacking in some basic way, and
I thought our old established engineers might be afraid
to come to this conclusion even if it was the right one.
Our conclusion was that the current system was pretty much
fine. It contains all the parts needed for learning through
shared experience; the trick is just to deploy them in the
right way. We designed a simple user interface in which
Webmind can move objects around and watch us move objects
around, and chat with us about what it’s doing and
seeing. Using this “Baby Webmind” interface,
we need to lead the system step by step through goals, beginning
with simple goals and gradually moving to more complex ones.
We need to teach the system step by step almost like a baby.
Ken, Karin, Pei, Jeff and all the “old guard”
quickly became deeply involved in helping us work out the
details.
All this entailed some changes in emphasis from our pre-Baby-Webmind
work. Before, we’d focused mainly on the system perceiving
its environment, now, in the Baby Webmind context we started
thinking just as much about action, about what Webmind does
in its world and how its actions intersect with its perceptions.
Before Baby Webmind, the evolutionary learning aspect of
Webmind was focused on learning to recognize patterns in
text and numerical data; now, it was tweaked so it can easily
evolve schema, procedures for seeing, doing and acting,
and so forth. But fortunately, we discovered, nothing big
and new needed to be built for Baby Webmind; it was all
just a matter of adjusting the modules that were already
there, encouraging them to interact with each other in the
right way.
The
dissolution of Webmind Inc. in March 2001 was a class A
disaster for all of us involved with the firm. I can think
of sadder moments in my life, but none that dragged on for
weeks and weeks. The “endgame” of the company
was a torturous process of laying off one group of friends
one week and another group the next, and sitting in endless
argumentative meetings, occupying ceaseless consecutive
12-hour workdays, trying to find some way to salvage things.
In retrospect I wish I’d spent the last 5 months of
the company’s life playing Pac-man or writing poetry
in machine language… but of course, at the time it
wasn’t evident how things would come out, and if we’d
succeeded in salvaging the firm then all the torture would
have seemed worthwhile.
From one point of view, however, the tragic event could
be construed as a positive thing. In the weeks following
the dissolution, the legal status of the company’s
“intellectual property” was not at all clear
(in fact, it did not become clear for over a year). A group
of us resolved to stick together and continue pushing toward
a real AI, but, we didn’t feel at all legally comfortable
continuing to work with the Webmind AI Engine sourcecode.
We waited a few more weeks to see if the legal situation
would resolve itself, but it didn’t, and so we decided
to start anew.
This new start was a much bigger break from the past than
the “psycore redesign” I discussed above. In
that redesign, mistakenly in hindsight, we’d tried
to preserve backwards-compatibility with the previous codebase.
We wanted the pre-redesign natlang module to keep on working
with the redesigned core. In practice, this backwards-compatibility
turned out to be pretty worthless, because everyone wound
up redesigning their modules for optimal performance under
the new core, even though their old versions would have
kept working “in principle” with only minor
changes. We hadn’t wanted to admit the necessity to
throw all the code out and start over, retaining only the
ideas and lessons and the best of the mathematical high-level
design features from the old version. We were under too
much business pressure to get the Webmind AI Engine doing
amazing things fast, so it could contribute to product development
and moneymaking.
But as we took stock of our situation in late Spring 2001,
we also realized we’d made some big mistakes that
weren’t attributable to business pressures or the
mistaken desire to retain backwards-compatibility. There
were three big problems.
First, we had built the new core as a generalized software
agents system, and done a wonderfully good job of it. But
with this generality came a terrible cost in terms of computational
inefficiency. Ken’s psycore had been just plain incorrect,
and incomprehensible. The new Brazilian psycore was elegant
and clearly structured; when there were bugs in it, it was
possible to find them and remove them, because the code
was well-written and well-documented. But the combination
of the inefficiencies of the Java programming language and
the inefficiencies of the general-agents-system design,
combined, led to a system that could take several minutes
for a single “cycle” to occur (a “cycle”
meaning a period of time in which every node in the system
got to do a little processing, dynamically relating itself
to the other nodes around it via its links, building new
links or modifying its old ones).
The other problem was more conceptual and mathematical than
software-oriented. We had a system for representing procedural
knowledge, which used SchemaNodes and related link types.
And we had a system for representing declarative knowledge,
using InheritanceLinks, SimilarityLinks, AssociativeLinks
and related things. The relationship between procedural
and declarative knowledge, however, could be expressed in
the system only in an extremely complicated way. We were
spending a terrifying amount of time working out the mathematical
and conceptual details of this relationship. This aspect
of the system just seemed wrong, because it was so bloody
complex. And it seemed complex in the wrong kind of way.
The right kind of complexity, we felt, was the kind that
involved a very simple framework giving rise to complex
emergent structures and dynamics. The wrong kind was when
the foundational framework itself was too complex, and that’s
what seemed to be happening with our procedural/declarative
integration work.
Finally, our approach to natural language processing really
wasn’t working. We were trying to hybridize a rule-based
approach with a statistical-learning approach, and it was
getting to be a huge mess. Accomodating the linguistic rules
that human beings had made up and stored in linguistic databases,
was requiring us to do all sorts of perverted things with
node and link types. More and more, we were forced to conclude
that you just couldn’t perform the hybridization we
were attempting. Instead, we began to think, the only way
to do language processing was to take the bull by the horns
and go with a full experiential interactive learning approach.
This wasn’t what the businessman half of my brain
wanted to hear, because the pure EIL approach means that
language processing comes last, after all the various cognition
processes are working perfectly together – which is
a problem for a AI system being built within a company whose
products are based on language processing. We badly wanted
the Webmind AI Engine to help our market prediction and
document management products understand language better
– but what our research was telling us was that there
were two ways to approach language: the overspecialized,
standard-AI, rule-based way, or the real-AI, EIL-based way.
Our attempt to chart a middle course by fusing the two together
just wasn’t going to cut it.
A number of us had been thinking for a while about better
ways of doing things. All the experimentation with the new
core had taught us a lot about how an integrative AI system
should work. Except for the language processing and procedural/declarative
interfacing issues, we seemed to have solved all the thorny
conceptual problems of inter-mind-module integration –
and there had been a hell of a lot of them. We felt like
we knew what we were doing to a vastly greater degree than
had been the case in 1999 when we’d designed the now-old,
then-new psycore. Which of course meant that, in a sense,
the 1999 core rewrite had been a success – because
working with it had taught us a hell of a lot.
In April 2001, two Brazilian engineers, Thiago Maia and
Andre’ Senna, began creating the new new “psycore.”
The basic principles of this new system were outlined by
Thiago and myself in New York, before he went back to Brazil,
lacking a visa to remain in the US after the death of Webmind
Inc. (as well as lacking a US source of income). The ideas
we discussed were loosely based on many past conversations
with others, including Senna, Cassio, and a few wild AI
mavericks from the Webmind New York office: Anton Kolonin,
Shane Legg and Youlian Troyanov. The latter three guys all
had their own theories of how to build a real AI, though
none of them articulated their approaches nearly clearly
enough for my liking (I’m still in touch with all
of them, and still enjoying witnessing the development of
their ideas). Because they each had an intuitive sense for
the “whole enchilada” of the real AI problem,
through their own speculative work, they were extremely
good critics of the Webmind AI approach. The idea of the
new new core was not to make a better generalized agents
system, it was rather to make a more specialized software
framework, which was ideally suited for exactly the mind
modules we now knew we needed. Ken’s original psycore
had been specialized, but then we’d had to add onto
it endlessly, because its specialization was overly limiting,
and didn’t allow all the mind modules we found we
needed. On the other hand the Brazilian 1999 new core had
been general enough to allow us to experiment with all sorts
of different mind modules, but this generality had carried
too much of a price in terms of efficiency. Now we knew
what we needed in terms of modules and could build an appropriately
specialized system.
The procedural/declarative learning problem was a hard nut
to crack, and when we started the development of our new
system in late Spring 2001, I had only a general idea of
how to solve it. But many months of effort paid off, and
by late fall 2001 I had come up with an apparently workable
solution, which used an advanced and obscure branch of mathematics
called combinatory logic to bridge the procedural/declarative
divide. This solution was eminently unbrainlike –
it much more resembled what goes on inside the compilers
for functional programming languages like Gofer -- but at
this point, quasi-detailed brain emulation no longer seemed
so critical to me. I was simultaneously working on a paper
on what I called “Hebbian Logic,” an original
theory of how advanced logical inference emerges from brain
structures. As my thinking on brain dynamics and its relation
to thought got clearer and clearer, I could see that, in
some cases (such as the procedural/declarative interface)
what’s right for the brain just isn’t going
to be workable for any system running on a clustered-von-Neumann-machine
hardware substrate. And one nice thing that happened was
that, when I formalized the most difficult parts of natural
language processing in terms of my new combinatory-logic-based
framework, much of the complexity melted away. The continuity
between language processing and generic cognitive processing
became vastly clearer.
Thus we arrived at the AI design we call Novamente –
the new mind. Novamente is currently (February 2002) only
about 25-30% implemented, but I have little doubt that by
the time you read these words, substantially more progress
will have been made.
I’ve told you a lot about our various mistakes, oversights
and revisions – and you may well draw from this tale
the conclusion that I and my colleagues are a bunch of oafs
who can’t get anything right! I think that a fairer
conclusion, however, is that the real AI problem is really
goddamned hard. Building a market predictor or a better
text classification system – these were somewhat tricky
problems, but we solved them relatively rapidly and unproblematically.
Building a real AI is a different sort of animal. Most people
who have approached the problem seemed to have begun with
a certain technical approach and followed it where it led
– and then stayed where their initial technical approach
led, doing valuable work and making specialized applications,
but abandoning the original real AI goal. On the other hand,
we began with a very general, high-level conceptual picture
of the type of system we wanted to build, and have progressively
revised our technical approach in order to achieve a closer
and closer approximation to our high-level conceptual picture.
What does Novamente do, right now? It doesn’t hold
a conversation with you. It doesn’t rewrite its own
sourcecode. In fact it is not nearly as impressive in its
current behaviors as, say, Deep Blue, which is well known
to be cognitively shallow. One of the really terrible things
about the real AI problem, however, is that the approach
that gives the best interim results is probably not anywhere
near the best approach to the end goal. This is because
good interim results are usually obtained by overspecializing
one mind-module for independent performance, whereas real
AI will only be achieved by interadapting an appropriate
assemblage of mind-modules to one another.
We have not given up on the use of interim, incomplete versions
of our AI system to yield practical results – first,
because we can’t afford to; and second, because we
really do believe that, as Danny Hillis says, feedback from
real applications is a critical part of the AI creation
process. This time around, however, we have enough experience
to choose our interim practical applications more intelligently.
We are not going to attempt serious language processing
until a significantly more advanced phase in the system’s
development. Rather, we are using the system’s inference,
association-finding, and concept-formation abilities to
enable highly sophisticated data mining – recognition
of patterns in complex databases filled with heterogenous
data. In particular, we’re applying the current Novamente
version to some sticky datamining problems that arise in
the analysis of genetic data. And we’re having some
significant success! But this is a story that’s best
told after some more background on modern genetics has been
presented, and so it will be deferred until Chapter 8. There
are also fascinating potential applications to the analysis
of brain scan data, as will be discussed in Chapter 7, though
unlike genetics this is not a type of data analysis we have
actually attempted yet.
Recall
from Chapter 1 the notion that there are two metasystem
transitions involved in the emergence of mind from unintelligent
matter. This idea was related there in a Novamente context
– and now that so much detail on Novamente has been
given, it may be appreciated more fully.
Each of Novamente’s modules has a certain wholeness,
a certain synergetic transcendence of the whole over the
parts. But the metasystem transition we’re really
focused on is the next one up. The big trick is to get emergent
intelligence out of the whole mess – active and productive
emergent intelligence, wherein the whole mind is engaged
in achieving goals by recognizing patterns in itself and
the outside world. The specialized pattern recognition and
formation routines in the modules aren’t capable of
achieving really complex goals or of generalizing from one
domain to another. Putting a few modules together can give
you functions that normal AI software can’t do –
things like using text to predict the financial markets,
which we’ll discuss in the following chapter. But
putting all the modules together can get you actual intelligence,
because the modules are chosen specifically so as to allow
the system to understand itself, to recognize patterns in
itself. Self-understanding is not an easy thing after all.
The modules in the current Novamente system represent pretty
much the minimal set required to achieve it, in the particular
complex environment that is the Internet. Interaction with
other intelligences – us – in a shared environment
is a task that uses all the modules of Novamente, integrated
together tightly and generating emergent structures that
are constantly tested for usefulness.
To teach our baby Novamente, we won’t chat with it
about trees and flowers and teeth, because it doesn’t
have direct experience of these things. We’ll chat
with it about data files and shapes and MIDI music files,
because these are the things that we can both experience.
Intelligence has to be gained through interactive experience
in a shared environment. And it’s intriguing to see
how the basic task of learning to interact in the world
uses all of Novamente’s specialized modules. Reasoning
and genetic programming – evolution – are used
to find schema -- sets of basic procedures for seeing and
doing and thinking – that are useful at achieving
the system’s goals and hence make the system happy.
Categorization is needed to define contexts in the world
– a schema has to be judged by how it achieves important
goals in relevant contexts. Language processing is obviously
needed to chat with humans, and although in this context
most of the specific nature of human language must be learned,
nevertheless the basic structures needed for language understanding
need to be provided from the start; learning language as
a general set of patterns is a job for millions of years
of evolution rather than for months or even years of learning.
Data processing is needed to turn raw numerical data files,
sensed by the system, into comprehensible perceptual features.
And so on. All the link building and node building methods
of Novamente’s long term memory, its core, are needed
to provide the data that basic behavior schema need to act
intelligently.
All this complexity is not 100% obvious from the original
vision of mind as a collection of patterns that forms and
perceives patterns in itself and the world, in order to
achieve complex goals in a complex environment. But once
you dive into the details, it does fall out of this general
view fairly naturally. A complex environment, including
other intelligences, involves a lot of different kinds of
things, each one requiring its own specialized pattern recognition
and formation mechanisms. Achieving complex goals in such
an environment involves forming concepts that span various
kinds of things, internal and external things. This requires
intense interaction between the various modules of mind.
And so it goes. The best conclusion I can think of is this:
There’s no big trick to building a thinking machine,
actually. A mind is a collection of patterns that recognizes
and forms patterns in itself, in order to achieve complex
goals. There are some universal structures and dynamics
that it seems any mind has got to have. And it’s possible
to build a system possessing these universal structures
and dynamics in Java, running on a network of high-powered
PC’s. The main problems are these. First, getting
the needed memory and processing power. Then, the routine
but really annoying software engineering problems of getting
such a huge system to actually work in a reliable and efficient
way. There’s the problem of parameter tuning –
getting the system to regulate itself, all its modules together,
in a way that keeps the whole huge system functioning adequately,
without any part starving the other for resources. And then
there’s the problem of teaching – how do we
play mommy and daddy to a baby intelligence so unlike us
without driving it totally batty! Fortunately we seem to
have solutions to all these problems, and so the creation
of the world’s first really thinking machine would
seem to be only a year or two ahead of us. And as we walk
along the path, we’re building lots of cool components
that can – if we play our cards right -- make us money
along the way. There are worse ways to spend a few years!
And the possibility of our work triggering the Singularity
in the fully Vingean sense is also somewhat tantalizing….
Now,
after all this, where does the “Web” part of
the original Webmind scheme fit in?
Refreshingly, the original vision still fits pretty damn
well: the Internet, now even more so than in the mid-90’s,
has the potential to give a real AI system both processing
power and a rich perceivable/manipulable environment. To
make this potential real, however, requires the development
of specific Internet software aimed at making the Net useful
for AI. Implementing Heylighen’s proposals for adaptive
hyperlink weight modification would be a step in this direction.
But what’s needed to make the Net truly Novamente-friendly
is a good bit more than this. Toward this end, we have designed
a global distributed processing framework called WebWorld,
which will allow a Novamente (or any other roughly-similarly-structured
AI system) to split up its thought processing across literally
millions of machines. Some of these machines may not be
powerful enough to run Novementes, but may nonetheless be
strong enough to run smaller “Webmind auxiliary processing
units,” which we call WebWorld lobes. The WebWorld
framework was prototyped at Webmind Inc.; a fully functional
version was never built, but a fairly complete design exists
and if no one else creates something similar, in time a
WebWorld variant will be implemented as part of the Novamente
project.
Once WebWorld has been built, how exactly will it be used
in Novamente? In the beginning, at least, a big Novemente
will always have a cluster of dedicated machines as its
main mind. But it will farm out various learning problems
to thousands or millions of machines elsewhere. One thing
that this surplus of machines will allow it to do is to
read the huge amount of textual and numerical data that’s
out there on the Web, and eventually picture, sound and
movie data as well. So, although Novamente is starting out
as a program running on a small cluster of machines and
operating on a limited pool of data, its need for a rich
perceptual environment combined with its limitless thirst
for processing power is going to push it onto the Net, totally
consistently with the initial vision of a Web mind, an Internet
global brain, the Internet turned into a global brain.
Taking this vision one step closer to reality, let’s
look at what this might mean in terms of the Internet of
the next five or ten years. Of course, we realize that no
such “map of the future” is likely to be extremely
accurate. The Internet is a complex and rapidly evolving
system. No one person, company or computer program can control
it. But nonetheless, we can all take part in guiding it.
And in order to do this intelligently, an overarching vision
is required.
The figure below, drawn from my recent book Creating Internet
Intelligence, is an attempt at an “architecture diagram”
for the entire Net, in its Webmind-infused form. Naturally,
any diagram with such a broad scope is going to skip over
a lot of details. The point is to get across a broad global
vision:
| |
 |
| |
|
| |
 |
First,
we have a vast variety of “client computers,”
some old, some new, some powerful, some weak. Some of these
access the intelligent Net through dumb client applications
– they don’t directly contribute to Internet
intelligence at all. Others have smart clients such as WebWorld
clients, which carry out two kinds of operations: personalization
operations intended to help the machines serve particular
clients better, and general AI operations handed to them
by sophisticated AI server systems or other smart clients.
Next there are “commercial servers,” computers
that carry out various tasks to support various types of
heavyweight processing – transaction processing for
e-commerce applications, inventory management for warehousing
of physical objects, and so forth. Some of these commercial
servers interact with client computers directly, others
do so only via AI servers. In nearly all cases, these commercial
servers can benefit from intelligence supplied by AI servers.
Finally, there is what I view as the crux of the intelligent
Internet: clusters of AI servers distributed across the
Net, each cluster representing an individual computational
mind. Some of these will be Novamentes, others may be other
types of AI systems. These will be able to communicate via
a common language, and will collectively “drive”
the whole Net, by dispensing problems to client machines
via WebWorld or related client-side distributed processing
frameworks, and by providing real-time AI feedback to commercial
servers of various types.
Some AI servers will be general-purpose and will serve intelligence
to commercial servers doing a variety fo particular things;
others will be more specialized, tied particularly to a
certain commercial server (e.g., Yahoo might have its own
AI cluster to back-end its portal services).
Is this the final configuration for the Global Brain? No
way. Is it the only way to do things? No. But this seems
the most workable architecture for moving things from where
they are now to a reasonably intelligent Net. After this,
the dynamics of societies of AI agents become the dominant
factor, with the commercial servers and client machines
as a context. And after that….
Recall
the notion of “the Singularity,” first proposed
in the 70’s by science fiction writer Vernor Vinge,
referring to the notion that the accelerating pace of technological
change would ultimate reach a point of discontinuity. At
this point, our predictions are pretty much useless –
our technology has outgrown us in the same sense that we’ve
outgrown ants, beavers, rhesus monkeys and striped cockroaches.
The Singularity is not just about AI, but AI may play a
special role in the advent of the Singularity, because once
it’s sufficiently advanced it can serve as a powerful
“metatechnology,” drastically accelerating the
pace of creation of new technologies of various kinds.
Eliezer Yudkowsky and Brian Atkins have founded a non-profit
organization called the Singularity Institute [http://www.singinst.org/intro.html]
devoted to helping to bring about the Singularity, and making
sure it’s a positive event for humanity rather than
the instantaneous end of humankind. Yudkowsky has put particular
effort into understanding the AI aspects of the singularity,
discoursing extensively on the notion of Friendly AI –
the creation of AI systems that, as they rewrite their own
source code, achieving progressively greater and greater
intelligence, leave invariant the portion of their code
requiring them to be friendly to human beings. We’ll
discuss some of these ideas in depth in Chapter 12 below.
The notion of the Singularity seems to me to be a valid
one, and the notion of an AI system approach it by progressively
rewriting its own source code also seems to be valid. But
as usual, there are a few pesky details that only become
clear once one has a sufficiently-well-fleshed-out framework
within which to analyze them. From a Novamente perspective,
the following is the sequence of events that seems most
likely to lead up to the Singularity:
1. Someone (most likely the Webmind AI Engine team!) creates
a fairly intelligent AI, one that can be taught, conversed
with, etc.
2. This AI is taught about programming languages, is taught
about algorithms and data structures, etc.
3. It begins by being able to write and optimize and rewrite
simple programs
4. After it achieves a significant level of practical software
engineering experience and mathematical and AI knowledge,
it is able to begin improving itself ... at which point
the hard takeoff begins.
My
intuition is that, even in this picture, the “hard
takeoff” to superhuman intelligence will take a few
years, not minutes. But – obviously -- that's still
pretty fast by the standards of human progress.
The Singularity emerges, in this vision, as a consequence
of emergence-producing, dynamic feedback between the AI
Engine and intelligent program analysis tools like the Java
supercompiler. The global brain then becomes not only intelligent
but superintelligent, and we, as part of the global brain,
are swept up into this emerging global superintelligence
in ways that we can barely begin to imagine.
To cast the self-modification problem in the language of
Novamente AI, it suffices to observe that self-modification
is a special case of the kind of problem we call "schema
learning." The AI Engine itself is just a big procedure,
a big program, a big schema. The ultimate application of
schema learning, therefore, is the application of the system
to learn how to make itself better. The complexity of the
schema learning problem, with which we have some practical
experience, suggests how hard the “self-modifying
AI” problem really is.
Sure, it’s easy enough to make a small, self-modifying
program. But, such a program is not intelligent. It’s
closer to being “artificial life” of a very
primitive nature. Intelligence within practical computational
resources requires a lot of highly specialized structures.
These lead to a complicated program – a big, intricate
mind-schema – which is difficult to understand, optimize
and improve.
Creating a simple self-modifying program and expecting it
to become intelligent through progressive environment-driven
self-modification is an interesting research program, but
it seems more like an attempt to emulate the evolution of
life on Earth than an attempt to create a single intelligence
within a reasonable time frame.
But just because the “learn my own schema” problem
is hard, doesn’t mean it’s unsolvable. A Java
or C program can be represented as a SchemaNode inside Novamente
, and hence it can be reasoned about, mutated and crossed
over, and so forth. This is what needs to be done, ultimately,
to create a system that can understand itself and make itself
smarter and smarter as time goes on – eliminating
the need for human beings to write AI code and write articles
like this one.
Reasoning about schema representing computer programs requires
a lot of specialized intuition, and specialized preprocessing
may well be useful here, such as for instance the automated
analysis and optimization of program execution flow being
done in Val Turchin and friends’ Java supercompilation
project [http://www.supercompilers.com]. There is a lot
of work here, but it’s a fascinating direction, and
a necessary one.
Call
us mad scientists if you will, but all of us involved in
the project believe that the Novamente, once fully implemented
and tested, will lead to a computer program that manifests
intelligence, according to the criterion of being able to
carry out conversations with humans that will be subjectively
perceived as intelligent. It will demonstrate an understanding
of the contexts in which it is operating, an understanding
of who it is and why it is doing what it is doing, an ability
to creatively solve problems in domains that are new to
it, and so forth.
And of course it will supersede human intelligence in some
respects, by combining an initially probably modest general
intelligence with capabilities unique to digital computers
like accurate arithmetic and financial forecasting.
We believe we’ve covered all the bases: every major
aspect of the mind studied in psychology and brain science.
They’re all accomplished together, in a unified framework.
It’s a big system, it’s going to demand a lot
of computational resources, but that’s really to be
expected; the human brain, our only incontrovertible example
of human-level intelligence, is a complex and powerful information-processing
device.
Not all aspects of the Novamente system are original in
conception, and indeed, this is much of the beauty of the
thing. The essence of the system is the provision of an
adaptable self-reconstructing platform for integration of
insights from a huge number of different disciplines and
subdisciplines. In Novamente, aspects of mind that have
previously seemed disparate are drawn together into a coherent
self-organizing whole.
The cliché Newton quote, “If I’ve seen
further than others, it’s because I’ve stood
on the shoulders of giants,” inevitably comes to mind
here. (As well as the modification I read somewhere: “If
others have seen further than me, it’s because giants
were standing on my shoulders.”….) The human
race has been pushing toward AI for a long time –
Novamente, if it lives up to our aspirations for it, will
merely put on the finishing touches.
While constructing an ambitious system like this naturally
takes a long time, we were making steady and rapid progress
until Webmind Inc.’s dissolution in early 2001. It
seems Arthur C. Clarke was off by a bit -- Webmind won’t
be talking like HAL in the film 2001 until a bit later in
the millennium. But we’re currently scraping by with
a small team, and making significant and steady progress.
Accurate timing estimates remain difficult to make, but
if we manage to keep well enough funded to keep the current
team full-time on the project, we believe Novamente’s
first moderately intelligent conversations will take place
sometime in the next few years … and that’s
going to be (to use the technical term) pretty bloody cool!
What are the complaints and counterarguments most often
heard when discussing the Novamente project with expert
outsiders? We’ve already discussed some of these above.
First, there are those who just don’t believe AI is
possible, or believe that AI is only possible on quantum
computers, or quantum gravity computers, etc. Forget about
them. They’ll see. You can’t argue anyone out
of their religion. Science is on the side of digital AI
at this point, as has been exhaustively argued by many people.
Then there are those who feel the system doesn’t go
far enough in some particular aspect of the mind: temporal
or causal reasoning, or grammar parsing, or perceptual pattern
recognition, or whatever. This complaint usually comes from
people who have a research expertise in one or another of
these specialty areas. The Novamente system’s general
learning algorithms, they say, will always be inferior to
the highly specialized techniques that they know so well.
My feeling is that the current Novamente design is about
specialized enough. I don’t think it is so overspecialized
as to become brittle and non-adaptable, but I worry that
if it becomes more overspecialized, this will be the case.
My intuition is that things like temporal and causal reasoning
should be learned by the system as groundings of the concepts
“time” and “cause” and related concepts,
rather than wired in.
On the other side, there are those who feel that the system
is “too symbolic.” They want something more
neural-netish, or more like a simple self-modifying system
as I described in Chaotic Logic and From Complexity to Creativity.
I can relate to this point of view quite well, philosophically.
But a careful analysis of the system’s design indicates
that there is nothing a more sub-symbolic system can do
that this one can’t. We have SchemaNodes embodying
Boolean networks, feeding input into each other, learning
interrelationships via neural-net-like mechanisms such as
Hebbian learning, and being evolved by a kind of evolutionary-ecological
programming. This is in fact a sub-symbolic network of procedures,
differing from an evolutionary neural net architecture only
in that the atomic elements are Boolean operators rather
than threshold operators – a fairly insubstantial
difference which could be eliminated if there were reason
to do so. The fact that this sub-symbolic evolving adaptive
procedure network is completely mappable into the symbolic,
inferential aspect of the system is not a bad thing, is
it? In fact, I would say that in the Novamente design we
have achieved a very smooth integration of the symbolic
and subsymbolic domains, even smoother than is likely to
exist in the human brain. This will serve the system well
in the future.
There’s the complaint that Baby Novamente won’t
have a rich enough perceptual environment with just the
Internet. Maybe. Maybe we’ll need to hook up eyes
and ears to it. But there’s a hell of a lot of data
out there, and the ability to correlate numerical and textual
data is a good correlate of the cross-modal sensory correlation
that is so critical to the human brain. I really believe
that this complaint is just plain old anthropomorphism.
There’s the complaint that there are too many parameters
and it will take forever to get it to actually work, as
opposed to theoretically working. This is indeed a bit of
a worry, I can’t deny it. But we’ve gone a long
way by testing and tuning the individual modules of the
system separately, and so far our experience indicates that
the parameter values giving optimal function for independent
activity of a mind module are generally at least acceptable
values for the activity of that mind module in an integrated
Novamente context. A methodology of tuning parameters for
subsystems in isolation, then using the values thus obtained
as initial points for further dynamic adaptation, seems
very likely to succeed in general just as it has in some
special cases already.
Finally, there are those who reckon the design is about
right, but we just don’t have the processing power
and memory to run it, yet. This complaint scares me a little
bit too. But not too much. Based on our experimentation
with the system so far, there are only two things that seem
to require vastly more computer power than is available
on a cluster of a few dozen powerful PC’s. The first
of these, the learning of new procedures for acting appropriately
in various situations (“schema learning,” in
our lingo) is something that can be done offline, running
in the background on millions of PC’s around the world.
WebWorld. And the second, real-time conversation processing,
can likely be carried out on a single supercomputer, serving
as the core of the AI Engine cluster. We have a very flexible
software agents system that is able to support a variety
of different hardware configurations, and we believe that
by utilizing available hardware optimally, we can make a
fairly smart computer program even without the massive advances
that Moore’s law will quickly bring. Of course, the
more hardware we have, the cleverer our system will become…
and soon enough it will be literally begging us for more,
more, more!
I’ll close this chapter with a quote
I found in the book “Conversations with a Mathematician”
by algorithmic information pioneer Gregory Chaitin. Chaitin
is not an AI researcher, although his mathematical work
was inspirational for some parts of the Novamente design,
and in his career at IBM he has kept apprised of their diverse
AI work. When an interviewer asked him about AI and its
relationship with some mathematical ideas, he said:
“[M]y personal opinion is that AI is not a
mathematical problem, it’s an engineering problem….
To me a human being is just a very complicated piece of
engineering that’s exquisitely well-suited for surviving
in this world….
“[I]t’s very often the case that theoreticians
can show that in theory there’s no way to solve
a problem, but software engineers can find a clever algorithm
that usually works, or that usually gives you a good approximation
in a reasonable amount of time. And I think that human
intelligence is also a little bit like that, and that
it’s a matter of creeping up on it little by little,
a step at a time, until we can usually do a good job imitating
it.
“In fact I think that we may be almost halfway there,
only we don’t realize it, and that fifty years from
now we’ll be close to a real AI, and then people
will wonder why anyone ever thought that it was difficult
to create an AI. This AI won’t be the result of
a theorem, it’ll be a mountain of work, a giant
engineering project that was built piece by piece, little
by little, just like what happens in Nature. As the biologists
say, God is a tinkerer, he cobbles things together, he
patches things up, he makes do with what he has to create
new forms of life by experimenting with sloppy little
changes one step at a time….
“We humans aren’t artistic masterpieces of
design, we’re patched together, bit by bit, and
retouched every time that there’s an emergency and
the design has to be changed! We’re strange, awkward
creatures, but it all sort of works! And I think that
an AI is also going to be like that….
“[A] working AI is going to be like some kind of
Frankenstein monster that’s patched together bit
by bit until one day we realize that the monster sort
of works, that it’s finally intelligent enough!
“
I think he overstates the case a little bit. There is a
kind of elegance and order to complex adaptive systems with
emergent behavior, which is different from the elegance
and order in modern mathematics. But still, I like his articulation
of a point that has always seemed to me a piece of “AI
common sense,” but that yet seems to elude most academic
AI theorists. Building a mind is hard. But so was building
the Apollo rocket, so was building a computer. The magic
that we subjectively feel – we minds, we emergent
patterns in our brains – is mind-level magic, not
brain-level magic. The presence of this subjective experiential
consciousness-magic doesn’t imply that it takes magic
to build digital brains. Building a brain is hard work,
requiring a lot of really smart people collaborating together,
and the integration of results from many different kinds
of science. But this kind of hard work is exactly what the
ongoing sci-tech revolution is all about.
When I forwarded this Chaitin quote to some friends, one
person replied, basically: “But that doesn’t
say anything! Of course, anyone who believes that the mind
is a machine, automatically believes building a digital
mind is an engineering problem.”
Of course, there is a little truth to this retort. Chaitin
actually made the quoted statement in response to a question
about Roger Penrose’s claim that the mind is not a
machine in the standard sense, but rather some kind of cosmically
nonlocal nondeterministic quantum gravity system. However,
I think there is a little more substance to Chaitin’s
view that just “mind is mechanical.”
Yes, of course everyone who believes that the mind is a
machine believes that there is an engineering problem involved
in building a mind. But the question is: is the problem
primarily one of engineering, or primarily one of mathematics,
or primarily one of neuroscience, or primarily one of cognitive
psychology, etc.
I know a few individuals who believe the mind is a machine,
but who believe there is some simple mathematical trick
underlying mind operations, and that if we just find this
trick, then creating an artificial mind will be easy. So
they believe that figuring out the math is the main thing
required. My former Webmind collaborators Shane Legg and
Youlian Troyanov (commonly known as the “Bulgarian
Madmind”) have at various times held this opinion
with varying levels of strength.
Ray Kurzweil and others believe that the main problem is
figuring out exactly how the human brain works. Once this
is known, they reckon, it's just a matter of emulating the
brain on a sufficiently powerful computer, using a simple
neural simulator program (feeding in the exact distribution
of neurons, neurotransmitters, synapses, etc. as inputs).
Gregory Chaitin, on the other hand, is making the statement
that mind is mechanical, but he's also making the statement
that the task of constructing a thinking machine requires
primarily engineering-type thinking.
Chaitin's view is a bit like that of Danny Hillis, who stated
that he thinks intelligence is just "a lot of little
things all working together." Marvin Minsky's Society
of Mind theory of AI is somewhat in this direction as well.
These guys don't place much stock in emergence, and in the
need for different structures and dynamics to be exquisitely
harmonized together.
Also, it should be made clear that when Chaitin contrasts
engineering with mathematics, he is taking a pure mathematicians
view of mathematics. In my own AI work, I have not yet had
the opportunity to apply "deep math." There have
been no profound theorems proved about Novamente or Webmind
components, critical to the AI work. On the other hand,
there have been plenty of applications of known math, e.g.
probability theory, combinatory logic, nonlinear dynamics,
and so forth. To a real mathematician like Chaitin, working
out fairly straightforward applications of known math is
not "doing math." I’m well aware of the
pure mathematician’s attitude, having started out
my career in this environment; and when I first started
I hoped that pure math could provide the solution to AI
– just prove the “Fundamental Theorem of Mind”
and you’re in like Flynn … real AI is yours.
But it doesn’t seem to work that way; mind isn’t
that sort of thing.
Of course, the “it’s all engineering,”
“it’s all neuroscience and fast hardware”
and “it’s all the right math formula”
type views are extremes. Most of us involved in Real AI
theory or practice probably hold views that are intermediate
between these extremes. It's the extreme views that get
remembered and propagated because they're so compact to
state. My own view is an intermediate one: I think it takes
a mixture of philosophy, neuroscience, math, engineering
and psychology. When I started out I underestimated the
importance of the "engineering" part, but recognizing
that importance doesn't mean denigrating the importance
of the other aspects. It is precisely the need for integrative
input from so many domains of inquiry that makes digital
mind design (as opposed to simple digital emulation of the
brain cell by cell or molecule by molecule) so hard –
and so delightful.
|
|
|
