From: Ben Goertzel (email@example.com)
Date: Sun Jul 29 2001 - 20:11:16 MDT
As an aside to all this stuff about Flare, I thought I'd add a little bit
about the Webmind approach to early-stage self-modification.
The first phase of self-modification in Webmind won't involve rewriting of
the actual C++ source for Webmind.
Rather, we have something in Webmind called a "schema" -- a procedure that
the system can follow, which is expressed entirely as a pattern of nodes and
links in the system. Schema can be learned by a variety of methods,
reasoned on, forgotten, mutated, blah blah blah.
Right now, some of Webmind's thought processes are represented as C++
objects called AIProcesses, and others are represented as schema. Only the
ones represented as schema can be improved and adapted.
Once the system gets smart enough, we'll rewrite all the AIProcesses in
terms of schema (not hard, but there's a performance penalty; we need to
make a really fast schema module first and we haven't done that yet). Then,
the system will be able to observe and study and modify or replace all its
thought processes. I call this Phase One WM self-modification.
What the system *won't* be able to do, in this phase, is rewrite the
infrastructure underlying the AIProcesses: the definition of nodes and links
(though it will be able to add and delete variables from the node and link
objects, effectively), the fact that WM is a system with a bunch of
AIProcesses acting on a distributed table of nodes and links, the fact that
it caches memory to disk periodically, etc.
Still, in phase One self-modification, the system will learn what its
reasoning, associating, feeling, etc. processes are doing, and how to
improve these processes.
IN parallel with phase one self-modification, we'll have to do some basic
*teaching of programming*. The system will be given the syntax for the
programming language it's written in, and some knowledge about the semantics
of the language. It can then automatically represent (say) C++ programs as
schema and experiment with them given its knowledge about schema. It must
be led through a series of exercises in programming, involving simple "CS
101" programs, until it can improve and modify simple programs, etc.
Now, once phase one self-modification is working well, AND the system knows
the programming language it's written in, THEN,
*then* it's time for Phase Two self-modification, where the two pieces are
put together, and the system tries to understand itself as an AI program
written in a real programming language.
A language like Flare would make the "teaching of programming" phase a bit
easier. But my feeling is that phase one self-modification is significantly
harder than "teaching of programming", because understanding what makes a
reasoning rule better than another is harder than understanding what makes a
simple C++ program work. So I feel that having flare would really only help
with the easier part of the problem....
>From what I understand about Eli's approach, the problem of getting to phase
two modification isn't broken down into parts in the same way as I propose
to do. But I don't understand his approach very well, so I won't say more
-- Ben G
This archive was generated by hypermail 2.1.5 : Wed Jul 17 2013 - 04:00:37 MDT