RE: Deep self-modification (was Re: How hard a Singularity?)

From: Ben Goertzel (
Date: Mon Jun 24 2002 - 17:19:04 MDT

Hi james,

I understand your perspective. I know one other venerable AI theorist who
agrees with you -- Pei Wang.

He reckons that the optimal near-AI architecture is fairly simple (his NARS
system), and that what a superintelligent AI would need to do would be to

a) learn within this architecture, including learning new high-level
cognitive schema to govern its thought-patterns, etc.

b) get itself more hardware, design more efficient hardware, etc.

I don't see things this way however ... because, I don't agree that an AGI
design is going to have to be near-optimal in order to be workable...

The best way to explain why I think you're dead wrong is to look at
supercompilation technology, e.g., which contains a
whitepaper I circulated a while back...

Human-written programs are almost NEVER anywhere near-optimal, automated
supercompilation can speed them up tremendously by introducing huge nasty
bits of code -- unrolling loops, specializing functions to particular
argument values, etc.

I think similar sorts of optimizations can be done to improve AGI
intelligence by orders of magnitude on fixed hardware.

Supercompilation is different than intelligence-oriented program
self-modification, because supercompilation *only* affects speed, leaving
program behavior identical. It's a special case of intelligence-oriented
program self-modification, which aims to improve both speed and the
intelligence of behaviors...

For instance, let's consider some examples of "subprogram specialization" --
one among very many things the supercompiler does -- as they may occur one
day in Novamente.

In Novamente, we have one core data structure for storing knowledge, and a
couple specialized knowledge representations for particular kinds of
knowledge. An advanced Novamente could create 100 different specialized
knowledge represntations for itself, and modify them dynamically. Human
programmers *could* do this, but it would overcomplicate things hugely.....

Similarly, in Novamente we have a few pre-specified "parameter vectors" for
the system as a whole, and some adaptive rules for altering them. An
advanced Novamente could create a shitload of complicated rules for
governing parameter adaptation, invoking its full inteligence to do so.
This is easy enough that we've previously experimented with it....

We have a few inference control strategies... and the system can learn its
own inference control strategies (called "cognitive schema"). Once it
learns enough of these, it may become WAY WAY smarter than it was before,
due to its ability to control its inferential processes in a cleverer
context-dependent way

We have a scheduling algorithm regulating the activity of the various mental
processes in the system... it's not a bad one. But maybe we need 373
different scheduling algorithms which may be selected between, on a
context-dependent basis...

These examples I'm reeling off (and I could give many more) are the port to
AGI of "program specialization", which is just *one* kind of optimization
that the supercompiler now does for Java programs. I'm not saying this is
the only kind of self-modification a Novamente will be able to do... no way.
But this kind of optimization alone could yield huge intelligence

Essentially any complex software system can be immensely optimized via
supercompilation. Similarly, I think essentially any complex AGI system can
be made immensely more intelligent by the application of
supercompilation-style optimizations.

How much of this optimization will involve the "basic architecture" versus
the "cognitive processes implemented on top of the architecture"? That I
don't know. But my guess is that the basic architecture will be strongly
affected by automated optimization, e.g. by things like scheduling and basic
knowledge structures being expanded into multiple specialized subcases via
subprogram specialization heuristics.

In any case, I hope this e-mail has served to indicate that
"intelligence-oriented self-modification" is not a completely abstract
pie-in-the-sky idea. I have a concrete idea of what kinds of optimizations
and improvements are going to be made to Novamente via self-modification....

However, we have a lot of engineering and testing and teaching to do, before
we have a system that is able to do the sorts of self-modifications I'm
describing here (which are only simple examples).

In fact, I'd like to approach Novamente self-mod by hybridizing Novamente
with the supercompiler, but the supercompiler is currently only written for
two languages: Refal and Java (and the java version is still incomplete).
When we get to that stage, either we'll need to make a C++ supercompiler
(very hard) or port Novamente to Java or some other pointerless language
(easier) ...

-- Ben g

> -----Original Message-----
> From: []On Behalf
> Of James Rogers
> Sent: Monday, June 24, 2002 3:43 PM
> To:
> Subject: Deep self-modification (was Re: How hard a Singularity?)
> I actually disagree that the ability to self-modify an AI architecture
> at some fundamental level is even important, at least in the sense that
> I get the strong impression people are using it.
> The value of deep self-modifying code is apparently premised on the
> first implementations of AGI being duct-taped architectures that barely
> function, due in no small part to their extreme complexity. My own take
> is that if AGI is actually as complicated as most believe, then the only
> likely and plausible human engineered implementations will almost have
> to be very close approximations of "optimal intelligence" (read: elegant
> and properly generalized models) as a consequence. Compounding this is
> the probable fragility of AGI architectures with respect to the various
> forms of computational complexity, meaning that most design vectors that
> stray away from optimal architectures may not be able to reach seed AI
> level due to tractability problems. From this perspective, I don't
> think it is unreasonable to assert that architectural self-modification
> is an unnecessary capability as all likely human implementations of an
> AI will almost have to be optimal (or close approximations) to even be
> practical.
> If this is the case and the first "real" AGI architecture is a close
> approximation of optimal, then the qualitative bootstrap process will
> essentially be hardware limited no matter how intelligent the AGI
> actually is. Obviously there has to be some self-modification at higher
> abstractions or a system couldn't learn, but that doesn't need to impact
> the underlying architecture (and is essentially orthogonal to the
> question in any case).
> -James Rogers

This archive was generated by hypermail 2.1.5 : Wed Jul 17 2013 - 04:00:39 MDT