BUILDING AN ARTIFICIAL BRAIN
Using an FPGA Based CAM-Brain Machine
Hugo de Garis (1), Michael Korkin (2), Felix Gers (3),
Eiji Nawa (1), Michael Hough (4)
time-shifted spiketrain : 1 0 0 1 0 1 1 ---> (moves left to right)
conv. filter : 1 4 9 5 -2
1 0 0 1 0 1 1
0 0 0 0 0 : 0 t = -1
1 0 0 1 0 1 1
1 0 0 0 0 : 1 t = 0
1 0 0 1 0 1 1
1 4 0 0 0 : 5 t = 1
1 0 0 1 0 1 1
0 4 9 0 0 : 13 t = 2
1 0 0 1 0 1 1
1 0 9 5 0 : 15 t = 3
1 0 0 1 0 1 1
0 4 0 5 -2 : 7 t = 4
1 0 0 1 0 1
0 0 9 0 -2 : 7 t = 5
1 0 0 1 0
1 0 0 5 0 : 6 t = 6
1 0 0 1
0 4 0 0 -2 : 2 t = 7
1 0 0
0 0 9 0 0 : 9 t = 8
1 0
0 0 0 5 0 : 5 t = 9
1
0 0 0 0 -2 : -2 t = 10
Hence, the time-dependent output of the convolution filter takes the values (0,1,5,13,15,7,7,6,2,9,5,-2). This is a time varying analog signal, which is the desired result.
t -> 0 1 2 3 4 5 6 7 8 9 10
out:
1 1 4 9 5 -2
1 1 4 9 5 -2
0 0 0 0 0 0
1 1 4 9 5 -2
0 0 0 0 0 0
0 0 0 0 0 0
1 1 4 9 5 -2
-------------------------------
1 5 13 15 7 7 6 2 9 5 -2
In the HSA deconvolution algorithm, we take advantage of this summation, and in effect do the reverse, i.e. a kind of progressive subtraction of the convolution function. If at a given clock tick, the values of the convolution function are less than the analog values at the corresponding positions, then subtract the convolution function values from the analog values. The justification for this is that for the analog values to be greater than the convolution values, implies that to generate the analog signal values at that clock tick, the CoDi module must have fired at that moment, and this firing contributed the set of convolution values to the analog output. Once one has determined that at that clock tick, there should be a spike, one subtracts the convolution function's values, so that a similar process can be undertaken at the next clock tick. For example, to deconvolve the convolved output (using the same vlaue of the convolution function as in the simple example of the previous section :
1 5 13 15 7 7 6 2 9 5 -2
compare: 1 4 9 5 -2 conv.vals
It is assumed that spiking will irreversibly raise the value of the convolved output. If the convolution filter value at a given clock tick is less than that of the target waveform, spiking will bring the two values closer together. If the waveform value is still too low after a spike has occurred, a near future spike will bring the two closer together.
Below is the C code for the algorithm. "DUR" is the duration of the spiketrain (the number of bits), "error" is the sum of the differences of the convolution value and waveform value at each clock tick, "N_CONV" is the number of elements (integers) in the convolution function, "wave" stores the value of the waveform at each clock tick, "bits" stores the spiking history (0 or 1) for each clocktick, thresh is the threshold value to decide when error is small enough for a spike, "conv_fn" contains the values of the convolution function.
void deconv(int wave[ ], char bits[ ], int thresh)
{
int i,j,ni;
int error;
for(i=0;i< DUR;i++) {
error=0;
for(j=0;j< N_CONV;j++) {
if(i+j>DUR) break;
if(wave[i+j]< conv_fn[j]) error+=conv_fn[j]-wave[i+j];
}
/* if error is okay, SPIKE! */
if(error< thresh) {
bits[i]=1;
for(j=0;j< N_CONV;j++) {
if(i+j>DUR) break;
wave[i+j]-=conv_fn[j];
}
}
else bits[i]=0;
}
}
Figs 5 and 6 show two examples of the HSA in action. The original input analog signals "Oi" are shown as stippled lines. The spiketrain resulting from each analog input is sent into the SIIC convolutor (shown in Fig. 1). The resulting analog output should be very close to the original "Oi" and is shown as a solid line. The third line near the bottom is the absolute difference (error) between the two analog signals. The HSA seems to work well when the values of the waveforms are large and do not take values close to zero, and do not change too quickly relative to the time width of the convolution filter window. An example of applying too stringent an analog wave form is shown in Fig 7. It may be possible to simply add a constant value to incoming analog signals before spiking them and to ensure that the analog signal does not change too rapidly.
Note however, that the HSA deconvolution algorithm was only discovered very recently, so the neural net module evolution that is discussed in section 7, does not use it. The inputs to these modules as specified by the EE (evolutionary engineer) were in binary, not analog.
6. "Robokoneko", the Kitten Robot
An artificial brain with nothing to control is rather useless, so we chose a controllable object that we thought would attract a lot of media attention, i.e. a cute life-size robot kitten that we call "Robokoneko" (which is Japanese for "robot-child-cat"). We did this partly for political and strategic reasons. Brain building is still very much in the "proof of concept" phase, so we want to show the world something that is controlled by an artificial brain, that would not require a PhD to understand what it is doing. If the kitten robot can perform lots of interesting actions, this will be obvious to anyone simply by observation. The more media attention the kitten robot gets, the more likely our brain building work will be funded beyond 2001 (the end of our current research project).
Fig. 4 shows the mechanical design our team has chosen for the kitten robot. Its total length is about 25 cms, hence roughly life size. Its torso has two components, joined with 2 degrees of freedom (DoF) articulation. The back legs have 1 DoF at the ankle and the knee, and 2 DoF at the hip. All 4 feet are spring loaded between the heel and toe pad. The front legs have 1 DoF at the knee, and 2 DoF at the hip. With one mechanical motor per DoF, that makes 14 motors for the legs. 2 motors are required for the connection between the back and front torso, 3 for the neck, 1 to open and close the mouth, 2 for the tail, 1 for camera zooming, giving a total of 23 motors.
In order to evolve modules which can control the motions of the robot kitten, we thought it would be a good idea to feed back the state of each motor (i.e. a spiketrain generated from the pulse width modulation PWM output value of the motor) into the controlling module. Since each module can have up to 188 inputs, feeding in these 23 motor state values will be no problem. We are thinking we may install acceleromotors and/or gyroscopes which may add another 6 or more inputs to each motion control module. It can thus be seen that the mechanical design of the kitten robot has implications on the design of the CBM modules. There need to be sufficient numbers of inputs for example.
The motion control modules will not be evolved directly using the mechanical robot kitten. This would be hopelessly slow. Mechanical fitness measurement is impractical for our purposes. Instead we will soon be simulating the kitten's motions using an elaborate commercial simulation software package called "Working Model - 3D". This software will allow input from an evolving module to control the simulated motors of the simulated kitten. This software simulation approach negates to some extent the philosophy of the CAM-Brain Machine and the CAM-Brain Project, i.e. the need for hardware evolution speeds. This compromise was felt to be a necessary evil. In practice, the proportion of modules concerned with motion control will be very small compared to the total. Potentially, we have 32K modules to play with. Probably most of them will be concerned with pattern recognition, vision, audition, etc. and decision making. Designing the kitten robot artificial brain remains the greatest research challenge of the CAM-Brain Project and will occupy us through 1998 and 1999, and possibly beyond.
7. A Sampler of CoDi-1Bit Evolved Neural Net Modules
Since the whole point of using the CBM is to attain a high evolution speed, it is useful if the representation chosen to interpret the 1 bit signals which enter and leave the CoDi modules can be unique, otherwise several representations would need to be implemented in the electronics. (For the CBM to be efficient, i.e. to evolve CoDi modules in about 1 second, fitness measurements need to be performed at electronic speeds, which implies that the representation chosen for the signals be implemented directly in the hardware). We chose the SIIC to be our unique representation. However, as mentioned at the bottom of section 5, most of the evolutionary experiments presented here were already undertaken before the SIIC representation was chosen. Since the results of these earlier experiments are interesting in their own right, we report on them here. They show to what extent that CoDi modules are evolvable and the power of their functionality. The evolution of SIIC-representation-based and HSA-based modules will be the subject of work in the very near future, given that both algorithms are now ready. So is the CBM multi-module simulation code, so progress should be rather rapid in the coming months prior to the delivery of the CBM itself. Once the CBM is delivered, multi-module systems should be built as fast as we can dream them up. The bottleneck in building large scale multi-module systems will become human creativity lag, not module evolution lag (as was the case with software evolution speeds in the "pre-CBM era".) We now provide a sample of evolved CoDi neural net modules, their specified functionalities, and their actual performances, to give a feel for what they can do.
XOR Module
If a CoDi module could not be evolved to perform something as simple as an exclusive OR, then the whole CAM-Brain approach would be cast in doubt, so one of the first things we tried was to evolve an XOR module. The module size was a cube of 24*24*24 3D CA cells (the standard CBM module size, as implemented in the hardware). Two binary signals, A and B (on the Z=0 face of the cube at (x,y,z) coordinates of (1,1,0) and (7,1,0) (axon cells)) were input over 64 clock ticks. There were 4 test cases (using a multi-test fitness measurement).
Case 1:
The A input was a steady stream of 1s for 64 clocks, and
the B input was a steady stream of 1s for 64 clocks.
Case 2:
The A input was a steady stream of 1s for 64 clocks, and
the B input was a steady stream of 0s for 64 clocks.
Case 3:
The A input was a steady stream of 0s for 64 clocks, and
the B input was a steady stream of 1s for 64 clocks.
Case 4:
The A input was a steady stream of 0s for 64 clocks, and
the B input was a steady stream of 0s for 64 clocks.
At the output point (4,4,0), the desired or target output values were a stream of 0s, 1s, 1s and 0s respectively (to implement the XOR function). The total fitness value was the sum of the partial fitness values of the 4 test cases, i.e. the total number of correct output values, giving a theoretical maximum fitness value of 4*64 = 256. However, since there are inevitable delays as the signals progress through the CA cells of the module, this perfect score is not possible.
The elite module, (population of 15, mutation rate of 0.005 per bit per generation, one point crossover rate of 0.6 per chromosome per generation), gave after about 20 generations, the following outputs for the 4 cases, with partial fitness scores of 63, 57, 56, 64 respectively. Hence total fitness was 240.
Case 1:
0000000100000000000000000000000000000000000000000000000000000000
Case 2:
0000000111111111111111111111111111111111111111111111111111111111
Case 3:
0000000011111111111111111111111111111111111111111111111111111111
Case 4:
0000000000000000000000000000000000000000000000000000000000000000
So the XOR module evolved fairly quickly and easily. Note that the XOR case is an example of "multi-test fitness measurement". For each test, a partial fitness score is obtained, which is later summed with other partial fitess scores, resulting in the overall fitness score of the CoDi module. Between each partial test, the signal states of the module are cleared, and a new test run is performed using the same circuit, but with different input. The same story occurs in the CBM hardware.
Timer Module
One of the first things we tested after the CoDi-1Bit model was invented, was to see if a CoDi module (consisting of 4K 3D CA cells, with about 150 artificial neurons in the 4K space, could evolve a "timer", i.e. where constantly firing binary inputs generate at a single cell output (placed elsewhere in the CA space) a string of 0s during the first 30 clock ticks, then a string of 1s during the next 20 clock ticks, and finally a string of 0s in the last 20 clocks, as shown below. This was quite a demanding evolutionary task, which was a useful test vehicle during our early evolutionary trials.
000000000000000000000000000000 11111111111111111111 00000000000000000000
The fitness definition was pretty simple. (Note, that the evolution of this module did not use the SIIC or HSA approaches. Inputs and outputs were specified directly in binary signals). If a 0 appeared in the first (0) block, score one point. If a 1 appeared in the second (1) block, score three points. If a 0 appeared in the third block (0), score two points. Hence a perfect score would be 30*1 + 20*3 + 20*2 = 130. Population size was 24, with no crossover.
The Codi-1Bit model software simulation evolved this with a fitness of 100% in about 150 generations. A few days later, by strongly increasing the neuron density in the CA space to about 90% of the maximum value, we got the same result in about 50 generations!
Multiple Timer Module
Since a 100% fitness score does not test the limits of evolvability of a module, a more demanding output function was tried. The target output (similar to the above pattern) and the actual evolved output (placed immediately under the target pattern for comparison) were as follows -
000000000000000000000000000000 11111111111111111111 -> (Target)
000000000000000000000000000000 00011111111111111111 -> (Evolved)
-> 000000000000000000000000 1111111111111111 00000000000000000000 (Target ctd.)
-> 100000000000000000000000 0111111111111111 10000000000000000000 (Evolved ctd.)
The fitness definition was similar to the above. If a 0 appeared in the first (0) block, score 12 points. If a 1 appeared in the second (1) block, score 7 points. If a 0 appeared in the third block (0), score 3 points. If a 1 appeared in the fourth block (1), score 2 points. If a 0 appeared in the fifth block (0), score 1 point. Hence a perfect score would be 30*12 + 20*7 + 24*3 + 16*2 + 20*1 = 624. These weightings were chosen so as to encourage the earlier outputs to be correct before the later outputs. Population size was 30. No crossover. This result converged after about 100 generations with a fitness value of 0.957
It is interesting to note that these good results are evolving in about 100 generations or so, and yet the chromosome length is very large. The standard CBM chromosome length is of the order of 90K bits. One might think that such a long chromosome would be very slow in evolving, but this was not the case. One possible explanation for this is that there may be so many possible solutions, that (any reasonable) one is quickly found.
Switchable Dual Function Module
Our thoughts then turned to the idea of trying to evolve a module whose behaviors could be placed under switchable control, i.e. a module with dual functionality, which could be switched from one behavior to the other, depending on whether a "control" input was activated or not.
More specifically, two fixed position input points "IN" and "SWITCH" were placed on an input surface (z = 0), at positions (8,8,0) and (16,16,0) for a rectanguloid of 24*24*18 3D CA cells, with a fixed output point at position (11,12,9). If the output point was not an axon, fitness was defined to be zero.
Two experiments were run on the same module (the same CoDi-1Bit circuit, with signal flushing between experiments). In both experiments, the IN input fired at every clock tick. In the first experiment, the SWITCH input was off for every clock tick. In the second experiment the SWITCH input fired for every clock tick. The module was evolved to give a very active output (lots of 1s) if the SWITCH was off, but a low output (few 1s) if the SWITCH was on. That is, the SWITCH acted as an inhibitor.
The bitstrings below show the outputs for the two cases, firstly with SWITCH off, then on. Over 90 clock ticks, the first output had 42 more 1s than the second output.
SWITCH off
000000000000000000000000000000000001100011101111111111111111
111111111111111111111111111111
SWITCH on
000000000000000000000000000000000000100000100000100000100000
100000100000100000100000100000
The number of 1s in the two outputs were labeled as Sum1 and Sum 2 respectively. The fitness definition finally settled upon, was :-
(if Sum1 > Sum2)
fitness = 10000*(Sum1 - Sum2) + 0.001*(Sum1 + Sum2)
(if Sum1 < Sum2)
fitness = 100*(Sum2 - Sum1) + 0.001*(Sum1 + Sum2)
The term 0.001*(Sum1 + Sum2) was used to encourage circuits to give nonzero output at the output point. The terms 100*(Sum2 - Sum1) and 10000*(Sum1 - Sum2) encouraged differences in the two outputs, with a strong preference for the first case to give more 1s in the output.
This result was very encouraging because it shows that controllable (switchable) multi-function modules are evolvable with the highly simplified (suitable for implementation in evolvable electronics) CoDi-1Bit model. Such modules will be very useful when the time comes to evolve them for placement in artificial brain architectures.
Pattern Detector Module
With a slight modification of the code used to evolve the above module, a pattern detector module was evolved which was capable of distinguishing between two square wave inputs, of 111000111000... and 11111000001111100000... In this case, no switch input was used. Two experiments were run. In the first, the input was the 6 clocktick cycle square wave input, applied at the fixed input point (8,8,0). In the second experiment, the circuit was regrown with the same chromosome and the 10 clocktick cycle square wave input was applied to the same fixed input point. The fitness definition was the same as above. Results are shown below. Over 90 clockticks, the first output had 48 more 1s than the second output.
Square wave input 111000111000...
Output
000000000000000000000000100110111011111111111111111111111111
111111111111111111111111111111
Square wave input 11111000001111100000...
Output
000000000000000000000000000010001000100010001000100010001000
100010000000000010001000100010
Since the CoDi modules seem capable of evolving such detectors, it may be possible to evolve modules which are capable of detecting a specific phoneme analog input (e.g. the spike train (bit string) which when convoluted with a particular convolution function gives the time dependent analog signal). In a manner similar to the above, one could input the signal in the first experiment, and a random signal in the second, in a multi-test experiment, and evolve the phoneme detector. Maybe one could evolve a set of detectors, one for each phoneme. By using the SIIC and HSA digital/analog conversions, this kind of thing may become quite practical.
Hubel-Wiesel Line Motion Detector Module
The results of the following experiment were significant for the CAM-Brain Project as a whole, we felt. It involved the evolution of a Hubel Wiesel type line motion detector. Hubel and Wiesel won a Nobel prize for discovering that certain neural cells in the visual region of the cat's brain fired strongly when lines of light at particular orientations and speeds were shone onto a screen that the cats were observing. These cells (neurons) were detecting the motion of lines at a particular orientation. The evolution of this "Hubel-Wiesel" module used the same fitness definition and a similar methodology as in the above case. In the first experiment, a square 12*12 neuron input grid was used. At the first clock tick, the top horizontal 12 neurons were made to fire - at the second clock tick, the second horizontal row of 12 neurons was made to fire, etc, for 12 clock ticks, then the cycle was repeated. This input firing pattern simulated the motion of a line of light moving horizontally down the visual field on the retina of a cat. In the second experiment, 12 randomly positioned input neurons were fired at each clock tick. These 12 positions were randomly generated for each clock tick. This second input firing pattern simulated input noise, to be contrasted with the line motion input. Output results are shown below.
Line Motion Input Case
Output
000000000000000000000000100110100110111111111111111111111111
111111111111111111111111111111
Random Input Case
Output
000000000000000000000000000010000000000000000100010101010101
010101010101010101010101010101
There were 35 more 1 bit outputs in the first case than the second. Since the inputs to the second case are positioned randomly, the same neural net module will generate a different fitness value depending on the input. Nevertheless the evolution still improved over time, developing a fairly robust net giving fitness values corresponding to over 30 1bit differences (between the two experiments) in most cases (e.g. the top 5 fitness chromosomes were saved for each generation and not crossed over or mutated. The fitness values (1bit difference count) of these top 5 were 31, 34, 35, 30, 29 after several hundred generations). Thus it was possible to evolve a Hubel Wiesel Line Motion Detector - quite an achievement. Of course, we have no idea how the circuit does what it does. This is the great strength of "evolutionary engineering".Evolved circuits can achieve performance levels beyond what human engineers can achieve with traditional top-down design techniques, i.e. attain superior engineering performance levels, but the price is that one loses scientific understanding, due to the overwhelming structural and dynamical complexity of these CoDi circuits. Thus "evolutionary engineering" can provide superior engineering, but inferior science. It is a trade-off. In practice, once EEs can generate tens of thousands, even millions of modules, only a few die-hard analysts will want to know how an individual module functions. For the most part, noone will care how a particular module amongst millions actually does its thing.
8. Ideas for Interesting Future CoDi Modules to be Evolved
The "Dagwood Approach" for a Multi-Test Module
The CBM hardware automatically performs a fitness measurement on the assumption that the 1Bit signals which leave the evolving module into the fitness measurement circuit are interpreted with the SIIC approach, i.e. the hardware actually implements the SIIC convolution algorithm. We have implemented the CBM having a single very general fitness measurement methodology, to simplify the electronics. Hence evolutionary engineers using the CBM will need to specify the functions of the modules they want to evolve using the SIIC methodology. However, there is a problem with this unified approach. How to give the same circuit several tests, i.e. several sets of different inputs in a single run. For example, imagine one aims to evolve a module which detects a time dependent input pattern P. One inputs the pattern P for Tp clocks. (Note that a CBM module has maximum 188 binary inputs, maximum 3 binary outputs). One wants the module to respond strongly when the pattern in detected, and weakly if any other pattern is presented. Hence the same circuit needs to be tested for several pattern inputs, i.e. P and others. The pattern P is called the positive case, the others are called the negative cases. (It is also possible that there may be several positive cases (Pi)). One does not want a module which responds well to any old pattern. It must discriminate.
How to test all these cases (positive and negative) in a single run? By concatenating them, i.e. sandwiching them ("Dagwooding" them) over time. (Dagwood was a popular US cartoon character in the 1960s who was famous for making multilayer sandwiches). For example, imagine there are 2 positive examples and 4 negative examples to be input to the same circuit. Hence there will be 6 time periods in which the patterns are presented sequentially at the input in one long run. Between each input signal presentation, the signal states in the circuit are cleared out, ready for the next signal input. This resetting of the signal states is part of the CBM fitness measuring approach that we call "multi-test" fitness measurement. The 6 input pattern periods can be represented as "P1, P2, N1, N2, N3, N4". The periods last Pi and Ni clock ticks each. So that the total number of clock ticks for the positive periods is more or less equal to the total of the negative periods, the durations of the Pi can be lengthened. This should increase the evolvability of the positive responses. Otherwise the evolution may favor the negative cases too heavily. The target output patterns one wants for these 6 periods can be represented as "high, high, low, low, low, low".
Clearing of the signal states between individual inputs in multi-test runs is needed because it is almost certain that reverberating loops will be set up in the circuit such that once an initial input is presented, self sustaining loops are generated which ensure non zero output, even when the input signal is switched off. Such self sustaining loops may in fact be very useful, since they can be looked upon as a form of memory, and hence may be used to make CoDi modules capable of learning, i.e. adapting to their experience. The next section will elaborate on this idea.
The CBM evaluates each partial fitness (one for each test in the multi-test case) and then sums the partial fitnesses to get the total fitness for the circuit (the module). The XOR case described in the previous section is a simple example of a multi-test case.
Modules Which Learn
Up until recently, we have always thought that the CAM-Brain Project would produce neural circuits that would be INcapable of learning, i.e. they would not modify themselves based on their run time experience. The rationale was that it would be complicated enough dealing with tens of thousands of non learning modules all interacting with each other, let alone having tens of thousands of learnable modules. Also, we saw no way of having CoDi modules which could learn. Lately however, we have begun to think that learnable CoDi modules might be evolvable. The essence of learning in a system is that some event in the past leaves some trace or memory in the system. In a CoDi module, that could take the form of reverberating internal signaling after an initiating input arrives. In some modules, once the input stops, the resulting 1Bit signals could die away, i.e. be transient. Alternatively, the reverberating signals could persist and hence constitute a form of memory. Thus CoDi modules may be evolvable which generate reverberating signals.
Once one begins to think along these lines, it may be possible to create modules capable of Pavlovian conditioning and similar phenomena, e.g. one could evolve a module which has two possible inputs M(eat) and B(ell). One evolves the circuit and gives it 3 tests (in a multi-test case), namely M alone (followed by a signal reset), then B alone (followed by a signal reset), then M and B together (with NO signal reset) followed by B alone. The respective output for each of the 3 cases should be high, low, high. If one employs the above zero input Z spacing technique, then the dagwooded input stream would be "[M], [B], [(M&B) then B]", and the desired outputs would be "high, low, high". Note that there would be no signal reset between the M&B input and the B input. This allows for a reverberating internal signaling to be set up by the M&B which allows the B input to give a high output. If this module can be made to function, it shows that classical conditioning is possible with CoDi modules. (Of course certain negative cases would need to be Dagwooded into the multi-test case as well). Thus artificial brains cpable of learning could be designed using learnable, conditionable modules.
From Multi Module Systems to Artificial Brains
Once our group and others have gained a lot of experience in evolving single modules, the next obvious step is to start to design multi-module systems, since the ultimate goal of the CAM-Brain Project is to put many many modules together (up to 32,000 of them in the current design of the CBM) to make artificial brains. Obviously, no CAM-Brain team will try to build a 32000 module brain (with maximum 40 million artificial neurons) all at once. Instead, as a first step, small multi-module systems will be built, with tens of modules. Once experience is gained in how to do this successfully, larger systems will be undertaken, e.g. with 100s of modules, then 1000s, and later 10,000s. What kinds of multi-module systems with about a dozen modules might be interesting to build? Answering such a question will depend on the creativity of individual (human) "evolutionary engineers". Here are some ideas for "10 to 1" systems (i.e. ten to power 1 = tens of modules) - handwritten "capital letter" recognizers (where each module is evolved to respond to a particular input stimulus e.g. 3 converging lines on the middle left hand side of the input region (which would make the letters A, E, F, H, P potential candidates). Similar feature extractor modules could be placed in appropriate input positions. Boolean modules (AND module, OR module) could combine the outputs of the feature extractor modules, to distinguish the letters. A "winner-take-all" macromodule (i.e. a module of modules considered as a functional unit) would be needed to detect the letter module with the largest output signal. How to design/evolve the macromodule? The usual way is to use a form of lateral inhibition. Using CoDi modules to build such a device might not be trivial.
Another "10 to 1" suggestion is a simple artificial nervous system with a small number of sensor modules, and a limited number of motion generating modules, which can be switched on or off by a control signal (i.e. the motion is active while the control signal is active, and becomes inactive when the control signal is inactive). The sensor modules (e.g. the environment is very bright, or dark, or noisy, or quiet, etc) can send their output signals to some decision modules (probably Boolean), whose outputs become the activating signals to the motion generating modules.
Over time, artificial nervous systems can grow in complexity, until they can be called artificial brains. The robot kitten ("Robokoneko" = Japanese for "robot, child, cat") that our team is currently designing will be controlled by an artificial brain with up to 32000 modules. Since this kitten robot contains a CCD TV camera, microphones for ears, touch sensors, 22 motors for the legs and body, etc, it should offer plenty of scope for brain building. Obviously, we will probably begin with "10 to 2" systems to control it, and work our way up to "10 to 4" systems. This is a huge amount of work, which will need to be distributed over many CAM-Brain teams across the planet. With modern (almost cost free) internet telephone technology, coordinating such a large management effort is less expensive. Our team already uses IPhone to talk with our international collaborators on a daily basis.
9. Conclusions
This paper has provided an overview of ATR's Artificial Brain ("CAM-Brain") Project, highlighting the capacities of the new CAM-Brain Machine (CBM) which should be delivered to ATR in January of 1999. This machine will update 150 Billion CA cells a second and evolve a CA based neural net module in about 1 second. This speed should make practical the assemblage of tens of thousands of evolved neural net modules into humanly defined artificial brain archtitectures, and hopefully create a new research field that we call simply "Brain Building". This paper has discussed the neural net model ("CoDi-1Bit") which is implemented by the CBM. Also presented were discussions on how to convert back and forth between analog time dependent signals and spiketrains (bit strings of 0s and 1s), thus enabling users to think entirely in terms of analog input and target output signals. A sample of evolved neural network modules using the CoDi-1Bit model was given. Once the CBM is delivered and sufficient experience with it enables the construction of large neural systems, with tens of thousands of modules, an artificial brain will be designed and built to control the behavior of a robot kitten called "Robokoneko" (Japanese for "robot, child, cat"). The challenges which remain in ATR's CAM-Brain Project are to fully test the limits of the evolvability of the CoDi-1Bit modules (using the CBM), so as to gain experience in what can be readily evolved and what cannot, and then to assemble large numbers of them to make Robokoneko's brain. The biggest challenge will probably be creating the brain's architecture.
The CBM should be fast enough for many multi-module tests to be undertaken. Multi-module systems can be evolved, assembled into the RAM, and then tested as a functional unit. Once a system has been built successfully it can be used as a component in a larger system, ad infinitum. The challenges of the CAM-Brain Project are not only conceptual in nature, but managerial as well. A back of the envelope calculation says that if an "evolutionary engineer (EE)" (i.e. someone who evolves a neural net module using a CBM) takes half an hour of human thinking time to dream up the fitness definition of a module, to specify the module's input signal(s), its target output signal, its input and output links with other modules, etc, then 4 EEs would be needed to complete the design of a 32000 module artificial brain within 2 years. Thus one needs to speak of brain builder teams. If one wants to be a lot more ambitious and build a million module artificial brain in 2 years, then 120 EEs are needed. Such a large team would need managers to control them. One can imagine higher level "brain architects" (BAs) handing out module specifications to lower level EEs who actually evolve them on their CBMs and report back to the BAs with the results. The BAs and EEs need not be located in one place. Modern internet telephone technologies make globally distributed "virtual teams" practical. Our ATR CAM-Brain team already uses the "IPhone" on a daily basis to collaborate with international colleagues.
If artificial brains can be made to work reasonably successfully, e.g. by making interesting robot pets, or simple household cleaner robots, etc, then a new artificial brain based computer industry will be created, which in twenty years may be worth a trillion euros a year world wide.
References
1 Hugo de Garis. "An artificial brain : ATR's cam-brain project aims to build/evolve an artificial brain with a million neural net modules inside a trillion cell cellular automata machine". New Generation Computing Journal, 12(2), pp 215-221, July 1994.
2 Felix Gers, Hugo de Garis, and Michael Korkin. "Codi-1 Bit: A simplified cellular automata based neuron model". In Proceedings of AE97, Artificial Evolution Conference, October 1997.
3 Michael Korkin, Hugo de Garis, Felix Gers, and Hitoshi Hemmi. "CBM (CAM-Brain Machine): A hardware tool which evolves a neural net module in a fraction of a second and runs a million neuron artificial brain in real time". In John R. Koza, Kalyanmoy Deb, Marco Dorigo, David B. Fogel, Max Garzon, Hitoshi Iba, and Rick L. Riolo, editors, Genetic Programming 1997: Proceedings of the Second Annual Conference, July 1997.
4 Michael Korkin, Norberto Eiji Nawa, and Hugo de Garis. "A 'spike interval information coding' representation for atr's CAM-brain machine (cbm)". In Proceedings of the Second International Conference on Evolvable Systems: From Biology to Hardware (ICES'98). Springer-Verlag, September 1998.
5 Fred Rieke, David Warland, Rob de Ruyter van Steveninck, and William Bialek. "Spikes: exploring the neural code". MIT Press/Bradford Books, Cambridge, MA, 1997.