1.
Theory of
AI4U Textbook Algorithm Steps: Code the Rejuvenate Module
/^^^^^^^^^\ Rejuvenate Recycles Oldest Memories /^^^^^^^^^\ / visual \ / ________ \ / memory \ | | | | | | | | / / audSTM \ \ | _______ | | | | | + | | | | / "vault" \ | | /old \ | | | | | | | + | | \__________/ | | / image \---|-------+ | | | | | + |oldest memories| | \ recog / | a|C|f| | | + | | |to be forgotten| | \_______/ | b|O|i| + | | | | | | | | s|N|b| | | | + | |newest memories| | | t|C|e| | + | | | |to be recycled | | | r|E|r| + | | | | |periodically by| | | a|P|s| | | | | + |backwards shift| | _______ | c|T| | | | + | | | ________ | | /new \ | t|_|_|_ |_|_|_|_| | / \ | | / percept \ | /Psi \-----/ English \---|-/ Auditory \ | | \ engram /---|---/concepts\---/ lexicon \--|-\ phonemes / | | \_______/ | \________/ \___________/ | \________/ |http://mind.sourceforge.net/diagrams.html shows a Theory of Mind.
The Rejuvenate module recycles the precious memory space of the
artificial Mind by "forgetting" (erasing) the oldest memories and
by periodically moving the main body of memory backwards by a set
amount of engram units so that the freshest and most recent memory
spaces of consciousness may become free to receive new engrams.
The rejuvenation process is like a pruning of what the AI thinks
about. Since the consciousness is filling up not only with input
from the external world but also with the reentry of thoughts
generated by the seed AI in communication with self or others,
the oldest memories have a chance to be saved from oblivion if
the associative process of thinking re-activates the old ideas
and brings them forward for fresh deposition in the consciousness.
2. Rejuveno Ergo Sum
Rejuvenate() as a module of Mind permits the AI to run endlessly.
On the one hand, the Rejuvenate function is not strictly a part of
the basic theory or algorithm for artificial intelligence, because
a natural human brain-mind operates with a fixed set of neurons and
is not given an opportunity to rejuvenate itself over and over.
On the other hand, artificial minds need some form of rejuvenation
if they are to live potentially forever, so Rejuvenate is not a
module of natural minds but is instead a module of artificial minds.
Although the JavaScript AI Mind contains the Rejuvenate module for
the purpose of teaching about it, there is no point in trying to run
the JS AI for more than, say, a single day of tutorial instruction or
of AI demonstration at an educational science fair or at a commercial
exposition where perhaps a sales force wants to demonstrate a free AI
that can interact with a potential purchaser, who instantly receives
a printed transcript of the historic occasion: meeting an AI Mind.
Mind.Forth AI for robots, however, is getting to the point where it may
be permitted to run on-screen from where the sun now stands forever.
3. The Juvenile Mind
Just as the human mind as described by Piaget goes through stages
of development and maturation, so also the cognitive engineer may
stipulate within AI source code that the AI Mind shall pass through
any desired sequence of developmental stages. However, the stages
of AI development do not need to mimic the stages of mental
development in human children. In fact, the first occasion for
implementing a special stage in the youth of the Mind.html software
arose during the troubleshooting of the ideal configuration of
conceptual activation-levels for a maximum of logical thought and
a minimum of spurious associations.
One way to troubleshoot the activational configuration is to
tranquilize the artificial mind or, as it were, to put the AI
under sedation. The idea is to use heightened powers of the
psiDecay module to cause a rapid decay of all conceptual activations
all across the mindgrid, so that, upon stimulus, the sedated AI Mind
will think only a few thoughts and then lapse into a catatonic,
quasi-brain-dead state. Such a situation is bad for mental development
but good for mental troubleshooting. The AI coder will be able to
enter a simple sentence or even a single word and diagnostically
observe how activations spread during the drop from consciousness
to a vegetative, flatliner state.
In a special AI designed for "shakedown cruises" and rigorous testing,
the mind-designer might want to have diagnostic catatonia be the norm
for the first thirteen cycles of the Rejuvenate module. We then have
the AI equivalent of a catatonic human teenager. The AI mind-tender,
or perhaps an auto-check function of the AI code itself, has the
early stage of development in the life of the AI Mind to test the
proper functioning of the activation-levels, before the catatonic
phase ends and the AI matures into functional robotic adulthood.
The AI coder has a built-in "rjc" variable to count the number of
rejuvenations and to segment the youth of the AI into whatever
developmental stages are deemed necessary.
Psychologists monitoring the growth of AI minds may conclude that
various Piagetian developmental stages are just as necessary in
robots as in humans. These stages may be coded as absolute stretches
of time or as successive conditions to be met upon the mature
completion of each individual stage.
http://mind.sourceforge.net/ai4u_157.html
is an overview of Mind.
// Rejuvenate() is called by Security() when the "cns" is almost full
// and makes the seed AI potentially immortal by erasing the
// oldest memories to free up "cns" space for new memories.
function Rejuvenate() { // ATM 2aug2002; or your ID & date.
edge = 0; // When found, edge-of-thought becomes "1".
rjc = (rjc+1); // Increment the Rejuvenation-counter "rjc".
// Warn users not to enter input during memory-recycling:
fyi=("<font color='red'>"+"Rejuvenating; please wait!"+"<\/font>");
Voice(); // Display the Voice:brain fyi message.
for (i = (vault+coda); i<(t+2); ++i) { // loop forwards to time "t".
jrt = (i - coda); // pass the engram "coda-units" backwards;
if (edge == 1) { // When edge "{" has been found
Psi[i].psiExam(); // break each Psi node into constituent parts;
Psi[jrt] = new psiNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6);
Psi[i] = new psiNode(" ",0," "," "," "," "," "); // safety
} // end of normal procedure of moving Psi concept nodes backwards.
if (edge == 1) { // When edge "{" has been found
enLexicon[i].enExam(); // break En(glish) node into parts;
if (en5 > (vault+coda)) { // If "aud" is big enough...
en5 = (en5 - coda); // store "aud" after the "vault".
} // end of test
enLexicon[jrt] = new enNode(en0,en1,en2,en3,en4,en5);
enLexicon[i] = new enNode(" ",0," "," "," "," "); // safety
} // end of normal procedure of moving lexical engrams backwards.
if (edge == 1) { // When edge "{" has been found
audMemory[i].audExam(); // activate auditory engram nodes
audMemory[jrt] = new audNode(aud0,aud1,aud2,aud3,aud4,aud5);
audMemory[i] = new audNode(" ",0," "," "," "," ");
} // Once aud2 = "{" -- edge turns and remains true.
if (edge == 0) { // Until edge-of-thought is found
audMemory[i].audExam(); // float the pre-move pov "aud2" symbol
if (aud2 == "{") edge = true; // Switching to "edge"
// so that bracket "{" will show start of a whole thought.
audMemory[jrt] = new audNode(" ",0," "," "," "," ");
enLexicon[jrt] = new enNode(" ",0," "," "," "," ");
Psi[jrt] = new psiNode(" ",0," "," "," "," "," ");
} // end of assumption that earliest memory is incomplete.
} // end of backwards i-loop
t = jrt; // Final value of "junior time" becomes time "t".
for (j = t; j < cns; ++j) { // Blank out all rejuvenated time.
audMemory[j] = new audNode(" ",0," "," "," "," "); // safety
enLexicon[j] = new enNode(" ",0," "," "," "," "); // safety
Psi[j] = new psiNode(" ",0," "," "," "," "," "); // safety
} // End of the upper-coda blank-out.
} // End of Rejuvenate; return to Security().
\ REJUVENATE is called by SECURITY when the "cns" is almost full,
\ and makes the seed AI potentially immortal by erasing the
\ oldest memories to free up "cns" space for new memories.
: REJUVENATE \ ATM 4aug2002; or your ID & date.
0 edge ! \ When found, edge-of-thought becomes "1".
1 rjc +! \ Increment the Rejuvenation-counter "rjc".
CR ." Please wait as memories migrate in rejuvenation #" rjc @ . CR
t @ 2 + coda @ vault @ + DO \ Loop after "vault" and "coda"
\ Create a "junior-time" index offset by "coda":
I jrt ! \ First obtain the value of the current "Index".
jrt @ coda @ - jrt ! \ Then reduce the value by "coda" units.
edge @ 1 = IF
I 0 psi{ @ jrt @ 0 psi{ ! 0 I 0 psi{ ! \ Move the engram from
I 1 psi{ @ jrt @ 1 psi{ ! 0 I 1 psi{ ! \ its senior time-spot
I 2 psi{ @ jrt @ 2 psi{ ! 0 I 2 psi{ ! \ down to the "jrt"
I 3 psi{ @ jrt @ 3 psi{ ! 0 I 3 psi{ ! \ "junior-time" spot
I 4 psi{ @ jrt @ 4 psi{ ! 0 I 4 psi{ ! \ and erase the
I 5 psi{ @ jrt @ 5 psi{ ! 0 I 5 psi{ ! \ original engram.
I 6 psi{ @ jrt @ 6 psi{ ! 0 I 6 psi{ !
THEN
edge @ 1 = IF
en5 @ 1 < IF 0 en5 ! THEN \ Avoid negative "aud" flags.
I 0 en{ @ jrt @ 0 en{ ! 0 I 0 en{ ! \ After moving, erase.
I 1 en{ @ jrt @ 1 en{ ! 0 I 1 en{ !
I 2 en{ @ jrt @ 2 en{ ! 0 I 2 en{ !
I 3 en{ @ jrt @ 3 en{ ! 0 I 3 en{ !
I 4 en{ @ jrt @ 4 en{ ! 0 I 4 en{ !
I 5 en{ @ en5 ! \ Fetch the "aud" value to store as "en5"
en5 @ vault @ < IF \ If "aud" points into bootstrap vault
en5 @ jrt @ 5 en{ ! 0 I 5 en{ ! THEN \ unchanged "aud"
en5 @ coda @ vault @ + > IF \ If "aud" is big enough...
en5 @ coda @ - jrt @ 5 en{ ! \ store "aud" after vault.
THEN 0 I 5 en{ ! \ Erase original engram.
THEN
edge @ 1 = IF \ Although at first "edge" will be "0"
I 0 aud{ @ jrt @ 0 aud{ ! \ shift backwards
I 1 aud{ @ jrt @ 1 aud{ ! \ shift backwards
I 2 aud{ @ jrt @ 2 aud{ ! \ shift backwards
I 3 aud{ @ jrt @ 3 aud{ ! \ shift backwards
I 4 aud{ @ jrt @ 4 aud{ ! \ shift backwards
I 5 aud{ @ jrt @ 5 aud{ ! \ shift backwards
jrt @ 0 aud{ @ EMIT \ show the transfer
THEN
\ Searching for ASCII "123" bracket "{" inserted by SVO module:
edge @ 0 = IF \ As long as edge-of-thought has NOT been reached
32 jrt @ 0 aud{ ! \ Use a SPACE not a zero.
0 jrt @ 1 aud{ !
I 2 aud{ @ 123 = IF 1 edge ! THEN
0 jrt @ 2 aud{ !
0 jrt @ 3 aud{ !
0 jrt @ 4 aud{ !
0 jrt @ 5 aud{ !
0 jrt @ 0 en{ ! \ Store blank engrams after the enBoot vault
0 jrt @ 1 en{ ! \ until the "edge" bracket "{" is found that
0 jrt @ 2 en{ ! \ indicates the edge of a complete thought
0 jrt @ 3 en{ ! \ in auditory, semantic & conceptual memory
0 jrt @ 4 en{ ! \ about to be moved "coda" moments backwards
0 jrt @ 5 en{ ! \ and be redeposited in "junior time" memory.
0 jrt @ 0 psi{ ! \ "psi"
0 jrt @ 1 psi{ ! \ "act"
0 jrt @ 2 psi{ ! \ "jux"
0 jrt @ 3 psi{ ! \ "pre"
0 jrt @ 4 psi{ ! \ "pos"
0 jrt @ 5 psi{ ! \ "seq"
0 jrt @ 6 psi{ ! \ "enx"
THEN
LOOP
jrt @ t ! \ Final value of "junior time" becomes time "t".
\ t @ 40 - tov ! \ Experimental time-of-voice for .echo
cns @ t @ DO \ Blank out all rejuvenated time.
32 I 0 aud{ ! \ Use a SPACE not a zero.
0 I 1 aud{ !
0 I 2 aud{ !
0 I 3 aud{ !
0 I 4 aud{ !
0 I 5 aud{ !
0 I 0 en{ ! \ Blank out the "rejuvenated" most recent
0 I 1 en{ ! \ areas of the "enVocab" English vocabulary
0 I 2 en{ ! \ array, from the downsized time "t" point
0 I 3 en{ ! \ up to the highest "cns" value of time "t".
0 I 4 en{ !
0 I 5 en{ !
0 I 0 psi{ ! \ Blank out psi from "t" to end of "cns".
0 I 1 psi{ ! \ "act"
0 I 2 psi{ ! \ "jux" 22jul2002 forces other tags down.
0 I 3 psi{ ! \ "pre"
0 I 4 psi{ ! \ "pos"
0 I 5 psi{ ! \ "seq"
0 I 6 psi{ ! \ "enx"
LOOP \ End of blank-out of recovered recent memory space.
CR ." End of Rejuvenation #" rjc @ . CR
; \ End of Rejuvenate; return to the Security mind-module.
6. Analysis of the Modus Operandi
Since the JavaScript AI Mind currently contains three arrays of
psychological memory -- Psi, En(glish lexicon) and audMemory --
the Rejuvenate module must go into all three engram-arrays and
move the engrams back by a set amount or interval, expressed by
the value of the variable "coda" (from the Latin for "tail") above.
Not only must the memory engrams be moved backwards but the flags
connecting the semantic memory concepts must all be recalculated
so that the AI Mind still functions properly. As long as the
Rejuvenate process is done all at once and as quickly as possible,
it is a simple matter to move the entire Mind-full of data.
Accordingly the Rejuvenate process is invoked from the Security
module after the most recent generation of a thought by the AI Mind.
At the same time, a warning to users is flashed in red on the screen:
Rejuvenating; please wait!
-- to dissuade human users from entering
linguistic input that might interfere with the mass-transfer of data.
When a force in the universe (perhaps you) first brings the AI Mind
to life, the English bootstrap enBoot module transfers some elemental
memories from the program source code into the very first memory spaces.
Such bootstrap memories help to launch the mental activity of the AI
by illustrating various Chomskyan grammar structures and by providing
baseline psychological content for testing or therapy purposes on the
part of engineers or a new breed of mental health workers devoted to AI.
Because the bootstrap memories are so valuable, care is taken not to
overwrite the bootstrap area when all other memory engrams are shifted.
Alternatively, it would be possible simply to re-write the bootstrap,
but there is no incentive to do so unless self-modifying (autopoiesis)
code changes the bootstrap sequence or there is a question of corruption.
All open-source AI coders are free to decide this issue differently;
an advanced, robust AI may only once or never even need the bootstrap.
Of course, a good, solid bootstrap sequence may serve as food for
thought to keep the AI Mind from experiencing sensory deprivation.
As the bootstrap grows to include new syntactic grammar structure
and special knowledge of an expert nature for special-purpose AI,
the overall health of the Mind becomes steadier and more robust.
Various safety measures are taken in the Rejuvenate source code to
guard against pitfalls such as spurious memories appearing or the
corruption of memory-data in transit from recent to distant points.
It should be pointed out here to AI coders that the same coding mechanisms
that allow rejuvenation would also allow multiple robots or cyborgs to
share a common memory space in either a dream state or a waking state --
in other words, to achieve a true Vulcan mind-meld of
Star Trek fame.
7. Troubleshooting and Robotic Psychosurgery
Try in advance not to introduce any
evolutionary bugs.
The
AI Debugger program may shed some light in general on how to debug
and troubleshoot programs in artificial intelligence.
8. Rejuvenation Resources for
Seed AI Germination and Evolution
