Conference PaperPDF Available

The China-Brain Project: Building China's Artificial Brain Using an Evolved Neural Net Module Approach.

Authors:

Abstract and Figures

Prof. Hugo de Garis has recently received a 3 million RMB, 4 year grant to build China's first artificial brain, starting in 2008, that will consist of approximately 15,000 interconnected neural net modules, evolved one at a time in a special accelerator board (1) (which is 50 times faster than using an ordinary PC) to control the hundreds of behaviors of an autonomous robot. The approach taken in building this artificial brain is fast and cheap (e.g. $1500 for the FPGA board, $1000 for the robot, and $500 for the PC, a total of $3000), so we hope that other brain building groups around the world will copy this evolutionary engineering approach.
Content may be subject to copyright.
The China-Brain Project
Building China’s Artificial Brain Using an
Evolved Neural Net Module Approach
Hugo de GARIS1, 5, TANG Jian Yu1, 2, HUANG Zhiyong3, BAI Lu1, CHEN Cong1,
CHEN Shuo1, GUO Junfei1, TAN Xianjin1, TIAN Hao1, TIAN Xiaohan1,
WU Xianjian1, XIONG Ye1, YU Xiangqian1, HUANG Di4
1 Brain Builder Group, International School of Software, Wuhan University,
Wuhan, Hubei, China. Email: profhugodegaris@yahoo.com
2 Computer Science School, Hubei University of Economics, Wuhan, Hubei, China.
3 Computer Science School, Wuhan University, Wuhan, Hube, China.
4 Computer Science School, University of Geosciences, Wuhan, Hubei, China.
5 (from early 2008) Brain Builder Group, Institute of Artificial Intelligence,
Department of Computer Science, Xiamen University, Xiamen, Fujian, China.
Abstract. Prof. Hugo de Garis has recently received a 3 million RMB, 4 year grant
to build China’s first artificial brain, starting in 2008, that will consist of
approximately 15,000 interconnected neural net modules, evolved one at a time in
a special accelerator board [1] (which is 50 times faster than using an ordinary PC)
to control the hundreds of behaviors of an autonomous robot. The approach taken
in building this artificial brain is fast and cheap (e.g. $1500 for the FPGA board,
$1000 for the robot, and $500 for the PC, a total of $3000), so we hope that other
brain building groups around the world will copy this evolutionary engineering
approach.
Keywords. Artificial Brains, Evolved Neural Net Modules, Brain Architects,
Accelerator Board
1. Introduction
This paper shows how the first author and his research team build artificial brains
[2], and how we plan to build the first artificial brain in China, now that we have been
funded for it. We define an artificial brain (A-Brain) to be anetwork of neural
network modules” (10,000–50,000 of them), each of which is evolved quickly in
special electronic programmable (FPGA based) hardware, then downloaded into the
memory of a PC, and interconnected according to the designs of human “BAs” (“Brain
Architects”). The neural signaling of the artificial brain is performed by the PC in real
time (defined to be 25Hz per neuron). Such artificial brains can be used for many
purposes, e.g. controlling the behaviors of autonomous robots.
However, there is a major problem with the above approach (if one does not use
accelerator boards), namely the slowness, using PCs, of evolving individual neural
network modules. Typically, it can take many hours, or even a day to evolve a single
neural net module on a PC. Obviously, evolving several tens of thousands of such
modules using only a PC to build an artificial brain will not be practical. Before such
A-Brains can be built with this approach, it is necessary to find a way to accelerate the
evolution of such a large number of neural net (NN) modules. This we have done. It is
now possible for us to execute the evolution of neural net modules in hardware, and
achieve a speedup factor (relative to ordinary PC evolution speeds) of about 50 times.
We use a Celoxica company’s FPGA (Field Programmable Gate Array) electronic
accelerator board (containing a 3-megagate FPGA, i.e. Xilinx’s Virtex II
programmable chip) to accelerate the evolution of neural network modules. In this
paper we describe how we build artificial brains (using the accelerator board, which is
an essential component in our method). The remaining contents of this paper are as
follows. Section 2 provides an overview of how we evolve our neural network modules.
Section 3 describes the “Celoxica” electronic board that we use to accelerate the neural
net module evolution. Section 4 explains the so-called “IMSI” (Inter Module Signaling
Interface), i.e. the software used to allow modules to send and receive signals between
themselves. Section 5 describes the properties of the robot that our A-Brain is to
control. Section 6 talks about the brain-robot interface. Section 7 gives an example of a
multi-module architecture to illustrate how we build our A-Brains. Section 8 presents
some examples of single module evolution. Section 9 concludes.
2. Evolving Neural Net Modules
This section gives a brief description of the approach that we use to evolve our
neural network (NN) modules that become components for building artificial brains.
We use a particular neural net model called “GenNet” [3]. A GenNet neural network
consists of N (typically N = 12-20) fully connected artificial neurons. Each of the N2
connections has a “weight”, represented as a signed, binary fraction, real number, with
p (typically p = 6-10) bits per weight. The bit string chromosome used to evolve the N2
concatenated weights will have a length of N2 (p+1) bits. Each neuron “j” receives
input signals from the N neurons (i.e. including a signal from itself). Each input signal
Sij (a binary fraction) is multiplied by the corresponding connection weight Wij and
summed. To this sum is added an external signal value Ej. This final sum is called the
“activation signal” Aj to the neuron “j”.
=
+=
N
i
EjWijSijAj
1
This activation value is fed into a sigmoid function g that acts as a “squashing”
function, limiting the output value Sj to have a maximum absolute value of 1.0
0.1||
)( +
==
Aj
Aj
AjgSj
Each neuron of a neural network module has a weighted connection to (usually) a
single output neuron, whose output signal is considered to be the output signal for the
whole module. This output signal S(t) is compared to a target (desired) signal value
T(t) for some number (e.g. 100) “ticks” (where a “tick” is defined to be the time taken
for all neurons in the module to signal once). The “fitness function” used in the genetic
algorithm (GA) to perform the evolution of the neural net module is usually defined as
follows.
=
=100
1
2
))()((
1
t
tStT
f
3. The Celoxica Board
The aims of lowering the price of high-speed evolution, and of achieving higher
performance in evolving hardware led us to use FPGAs (Field Programmable Gate
Arrays). FPGAs are specially made digital semiconductor circuits that are often used
for prototyping. The several million logic gates in modern FPGAs (e.g. Xilinx’s Virtex
II chip) make it possible to have multiple copies of the same electronic sub circuit
running simultaneously on different areas of the FPGA. This parallelism is very useful
for a genetic algorithm. It allows the program to process the most time costly weight
calculations in parallel, and this can speed up the overall evolution by a factor of about
50 times, as we have determined experimentally in earlier work. We chose the Celoxica
FPGA board for our project. “Celoxica” is the name of a UK company [1]. Our
Celoxica board (an RC203) costs about $1500. With such a board, a design engineer is
able to program electrical connections on site for a specific application, without paying
thousands of dollars to have the chip manufactured in mass quantities. We currently
use an RC203 FPGA board for our experiments, which is a desktop platform for the
evaluation and development of high performance applications. The main FPGA chip is
a Xilinx Virtex II that can be configured without using an HDL (Hardware Description
Language). Instead, it uses a much easier high-level “C-like” language called “Handel-
C” (after Handel the composer) [4]. This language is very similar to ordinary C (i.e.
with approximately an 80% overlap between the two languages), with a few extra
features, particularly those involved with specifying which functions ought to be
executed in parallel.
A Celoxica board attaches to a PC, with two-way communication, so that
instructions can be sent to the board from the PC, and results coming from the board
can be displayed on the PC’s screen.
One of the aims of this paper is to emphasize that using the Celoxica board makes
brain-building practical, due to the considerable speedup factor in the evolution of the
individual neural network modules used to make artificial brains. The value of this
speedup factor is critical to this whole approach, which aims to make brain building
cheap. If a substantial speedup factor can be achieved, it then becomes practical to
evolve large numbers of neural net modules in a reasonable time, and to interconnect
them to build artificial brains inside a PC.
Fig. 1 The “Celoxica” Board ($1500) Fig. 2 Our Robot ($1000)
4. Inter Module Signaling Interface (IMSI)
In order that each neural net module can calculate the strength of its output signal,
it needs to know the strengths of all its input signals, including not only from “intra-
module” connections, but also from “inter-module” connections, i.e. either from the
“external world” (e.g. from sensors), or from the outputs of other modules. Each
module therefore needs a look up table (LUT) which lists the sources of its external
input signals (from sensors), and the integer I.D.s of the modules from which it
receives their output signals. A similar lookup table is needed to specify to which other
modules each module sends its output signal(s) to. One of the jobs of the BAs (Brain
Architects) is then to specify the interconnections between the modules, and to enter
them into these LUTs.
Special software was written for the PC, called “IMSI” (“Inter Module Signaling
Interface”) which is used to calculate the neural signaling of each neuron in each
module of the artificial brain. An ordinary PC is used to run the IMSI program, which
calculates sequentially the output signal value(s) of each module, for all modules in the
artificial brain. The IMSI code calculates the output neural signal value for each
module in the artificial brain. It loops through each module sequentially, using its input
LUT to find the signal values of its external inputs, as well as its internal signal values.
A slightly more complex “activation function” A is then calculated according to the
following formula
Ai = Σ(j=1,N) Wij*Sj + Σ(i=1,P) Ei
where a Wij is the weight value of the connection between neuron “i” and “j” in the
module, Sj is the value of the signal strength on that connection, Ei is the value of an
external neural signal, N is the number of neurons in the module, P is the number of
external input signals for that module. The convention used above is that a signal
travels from the “from’ neuron “j” to the “to” neuron “i”. Each module has a table of its
weight values Wij (i.e. N2 of them) and a list of its external input signals (i.e. P of them,
where P usually varies from module to module). The IMSI software calculates the Si
signal value for each module and stores it in its output signal register (“OSR”). This is
done sequentially for all modules in the artificial brain. The IMSI then places the
output signal value of each module into the input signal registers (“ISR”s) of those
modules that the outputting module signals to. For example, let us assume that module
M1432 sends its output signal value (0.328) to two other modules M3729 and M3606,
then the IMSI would use the “Output Modules LUT” of M1432 to place the value
0.328 into one of the input signal registers in each of the modules M3729 and M3606.
Thus the output signals of a given clock cycle (i.e. the time taken for all modules
to calculate their output signal values) become the input values at the next clock cycle.
Each module also has a table of its internal neural signal values Sj, where j ranges from
1 to N, the number of neurons in the module. These N values are calculated in each
clock cycle, to be used in the following clock cycle. In the IMSI code, two such “S
tables” are used, in a “ping-pong-ing” style, e.g. table St (calculated in clock cycle “t”)
is used to calculate table St+1 (in clock cycle t+1), which in turn is used to calculate
table St+2, which actually overwrites table St (hence the term “ping-pong-ing”).
Within each clock cycle “t”, the IMSI calculates for each module “m”, its output
signal value Sm, and updates its S table. The value Sm is transferred to “m’s” connecting
modules. Thus all the data is in place for calculating the Sm values in the next clock
cycle. Performing all these calculations is the job of the IMSI software. Some outputs
of modules are not sent to other modules but to external “effectors”, e.g. to the motors
of a robot, or to a transducer that generates a radio signal, etc. The IMSI deals with
these special external outputs (i.e. not to other modules).
Actually, the IMSI has two roles. Certainly its main role is as described above, i.e.
performing the neural signaling in the PC. Another important role is to allow the BAs
(Brain Architects) to specify the connections between the modules. Thus for example,
when BAs want to add a new module to the artificial brain, they will need to use IMSI
to specify the module’s :-
a) external inputs (from sensors)
b) inputs from other modules (i.e. their integer I.D.s)
c) outputs to other modules (i.e. their integer I.D.s)
d) external outputs (to effectors)
As the size of the artificial brain grows, special book-keeping software is used to
describe each module, e.g. its function, its fitness definition, its size (i.e. number of
neurons), its evolutionary strategy, its connections with other modules, its position in
the whole artificial brain design, etc.
5. The Robot
Fig. 2 shows a photo of our robot. It is controlled by a 2 way antenna at the back of
the robot, having 4 wheels, a gripper at the front, and a “CMU-CAM2” programmable
CCD camera. Visual (and other) data from the robot is transmitted via radio signals to
the A-Brain in the PC, and vice versa. This robot cost less than $1000 to build, so is not
expensive. Its length is about 20 cms. This robot will be controlled by an artificial brain
consisting of at least 15,000 evolved neural net modules that will allow the A-Brain to
have many hundreds of pattern recognition circuits, and a similar number of decision
circuits.
With any publicly funded research project, one needs to show results. An artificial
brain “hidden” inside a PC is not visible. Even a large wall chart, consisting of
thousands of interconnected neural net modules, may impress people with its
complexity, but would not have the visual impact of a moving robot that displays
hundreds of behaviors, switching from one to another depending on circumstances both
external and internal. If the average person can remain intrigued for half an hour by
such a robot and the A-Brain that controls it, then we state that the A-Brain has passed
the “China Test”.
6. The Brain-Robot Interface
Our research team has a robotics-mechatronics-electronic-engineering expert, who
is working on the interface problem between the robot and the artificial brain in the PC.
The CMU-CAM2 camera on the robot is programmable, using an assembler-like
language which can be used to process the mega-pixel image that the camera generates.
This language contains about 100 different statements. The “robot guy” of our team has
the task of becoming an expert in this “camera language”, and then to provide the rest
of the team, who are mostly BAs (Brain Architects) and EEs (Evolutionary Engineers)
who design and evolve the many neural net modules for the A-brain, with a summary
of what the camera outputs, as well as ideas on how these outputs can be translated
(interfaced) with possible inputs to neural net modules. This mapping from mega-pixel
camera images to single digit inputs to modules is what we call the robot-brain
interface. This mapping, which we have yet to specify in detail, will be executed using
normal computer code, in the PC (as will the IMSI), so our A-Brain is actually a
“hybrid” system, consisting of evolved neural network modules, and standard high-
level computer code. Having a clearer idea of the robot-brain interface will give the
research team a better idea of what “first layer” neural net modules to suggest, that take
as their inputs, the outputs from the interface mapping.
A type of reverse mapping, from the A-brain’s output modules to the motors of the
wheels, the camera motor, and the gripper motor, is also needed. Numerical output
signal values from neural net modules need to be translated into a form that is suitable
for the various motors. Signals between the robot and PC are sent via 2-way radio
antenna, so another level of interfacing is needed, i.e. between the antenna and to the
motors, and between the effectors (wheels, camera, and gripper) and the antenna that
sends signals to the PC. Once our robotist has finished his work, it will be easier for the
BAs defining the modules to design them to interface appropriately with the hardware
aspects of the project. Of course, the major part of the effort involved in the project
remains the specification and evolution of the 10,000s of modules used in the A-Brain.
7. Multi-Module Architecture
This section describes a simple artificial brain architecture of several dozen
modules, to illustrate the types of issues that arise when trying to design an artificial
brain using our approach. For this simple brain (for the illustrative purposes of this
paper) we do not use a real robot, but rather a conceptual “toy” robot, which can be
modeled as a horizontal rectangular body, with four wheels, and a “V” shaped antenna,
as shown in Fig. 3. When designing an artificial brain, certain common sense factors
come into play. For example, one needs to answer certain basic questions, such as –
a) What is the AB (Artificial Brain) to control, i.e. what is the “vehicle” that the AB
controls? (In our case the vehicle is the conceptual robot of Fig. 3)
b) What environment does the vehicle operate in?
c) What are the behaviors of the vehicle that the AB needs to control?
d) What are the inputs and outputs of the vehicle?
Once these basic questions are answered, the more detailed A-Brain design work
can begin. In our simple didactic case, the answers we give to the above questions are
the following. The environment in this simple conceptual model is a flat surface that
contains vertical triangles and squares, that project onto the camera eye (that looks like
a cone in Fig. 3). Sounds are also emitted from the environment of two different
frequencies (high and low). The behaviors of the robot are simple. It can turn left
slowly or quickly. It can turn right slowly or quickly. It can move straight ahead slowly
or quickly, and it can stop. So there are 7 initial behaviors, to be controlled by the A-
Brain. The inputs to the robot are a vertical triangle or square on the “retinal grid” of
the eye (i.e. 2 possibilities), and a high or low frequency sound.
Fig. 3 The Conceptual Robot “Vehicle” Fig. 4. Rules for Action Selection
The next set of questions asks how input stimuli map to output behaviors for the
vehicle. In our case we place the robot in the context of a “story”, i.e. a description of
the behaviors of the robot in a “coherent” context. This is rather vague, so it will be
illustrated with a concrete example to clarify the concept. The “story” we provide is
that the robot uses its detectors to see what the visual image is (i.e. is it a triangle or a
square) and whether the sound has a high or low frequency.
To the robot brain, these input signals are interpreted as follows. If the sound has a
low frequency, then that means that the source of the sound (assumed to be some object
in the environment) is far away , so the robot need not react quickly, i.e. its motions can
be slow. If the frequency of the sound is high, then the robot interprets this to mean the
object creating the sound is close, so it has to react quickly, so its motions are fast, not
Frequency Image Position Action
high triangle L > R LF
high triangle L < R RF
high triangle L = R AF
high square L > R RF
high square L < R LF
high square L = R LF
low triangle L > R LS
low triangle L < R RS
low triangle L = R AS
low square L > R RS
low square L < R LS
low square L = R LS
slow. Implicit in these interpretations is that a near object (high frequency sound) could
be a “threat” (e.g. a predator), so the robot needs to react quickly.
If the image is a triangle, then the robot interprets it as being something “positive”,
e.g. as prey, as food, as something to be approached. If the image is a square, then the
robot interprets it as being something “negative”, e.g. as a predator, as dangerous, as
something to be avoided. So the “story” in this case is “If the object detected in the
retinal grid of the eye is dangerous, then flee.” “If it is prey, then approach it.” This
mapping of sensor input to behavioral output makes sense in the context of the “story”,
i.e. “eat but don’t be eaten”, which also makes biological sense. The robot has two
other detectors (black circles in Fig. 3) on the tips of its “V” antenna. These are “Signal
Strength Detectors” (SSDs). If the sound strength drops off as an inverse function of
the distance between the robot and the source, then by having two such “SSDs” one
can use them to locate the position of the source of the sound. For example, if the
sound source lies to the “front-left” of the robot (i.e. as the robot faces the object, the
object lies closer to the left SSD on the left branch of the antenna than the SSD on the
right branch, then the signal strength detected will be stronger than that detected by the
SSD on the tip of the right branch of the antenna. One can use this “signal strength
difference” in the decision making as to which behavior the robot “chooses” to perform
(i.e. the 7 of them). To give a concrete example, take the case of the sound having a
high frequency, that the image is a triangle, and that the left SSD has a stronger signal
than the right SSD (abbreviated to “L > R”). Then this combination of inputs maps to a
given output in the form of a “rule”
IF (freq = high) & (image = triangle) & (L > R) THEN turn left fast (abbreviated to LF)
In light of the above story, this rule makes sense. The frequency is high, so the
sound source is close. Therefore the reaction of the robot should be fast, hence the F in
the behavioral selection (on the right hand side of the above rule). Since the image is a
triangle, that means the object is a prey, to be approached. Since L > R, the object lies
to the front-left of the robot, so to approach it, the robot should turn left, and quickly,
i.e. the behavior selected is LF.
Once one understands this simple rule, then the rest of the rules listed in Fig. 4 are
easily interpreted, e.g. in the Action column, an L means “left”, an R means “right”, an
A means “approach”, an F means “fast”, an S means “slow”. For example, AS means
“approach slowly”, LF means (turn) “left fast”. Most of the actions in Fig. 4 are turning
behaviors. Once the robot has turned enough, so that the signal strength difference
between the two SSDs on the V antenna is effectively zero, the robot then moves
straight ahead, i.e. it approaches the source of the sound, or flees from it. The stop
behavior creates complications, so we will ignore it in this simple didactic model. So
effectively there are 6 behaviors. Now that we understand the “story”, i.e. the general
behavior of the robot, we can now turn to a more detailed discussion of neural net
modules that can implement these behaviors. These modules are now listed. We need –
a) 2 detectors for the image, i.e. a “triangle detector”, and a “square detector”
b) 1 SSD (signal strength detector) (2 copies, for the two branches of the V antenna)
c) 2 frequency detectors (one for the high frequency, one for the low frequency)
d) 3 difference detectors (i.e. L > R, L < R, L = R).
e) 2 logic gates (“and”, “or”)
That's only 10 different modules, but it is enough for the didactic purposes of this
section. These modules can be combined (i.e. interconnected) to form networks of
modules (i.e. a form of networks of (neural) networks), called “circuits” (or “sub-
systems”), where the output(s) of some modules become the inputs of other modules,
e.g. for the above rule, the following circuit could be used, as shown in Fig. 5.
Similar circuits can be made for the other 11 cases of Fig. 4. But we need not make
12 separate circuits similar to that in Fig. 5. That would be wasted effort. Instead we
can use “or” gates to aggregate several cases. For example, Fig. 4 shows that there are
3 cases that give an LF output (or action). So make those 3 LF outputs become the
inputs to a 3 input “OR” gate – and similarly for LS (3 cases), RF (2 cases), RS (2
cases). AF and AS only have single cases, so they don't need an “OR” gate. One need
not replicate SSDs, nor difference detectors (L > R), (L < R), (L = R). One can simply
have the outputs of these detectors branch to become inputs to multiple other circuits.
Putting all these 12 (non redundant) circuits together would generate quite a complex
circuit, which is not given in this section.
Fig. 5 Circuit for LF Rule
Fig. 6 Control Signals to Wheels for Robot Turning
Similar circuits can be made for the other 11 cases of Fig. 4. But we need not make
12 separate circuits similar to that in Fig. 5. That would be wasted effort. Instead we
can use “or” gates to aggregate several cases. For example, Fig. 4 shows that there are
3 cases that give an LF output (or action). So make those 3 LF outputs become the
inputs to a 3 input “OR” gate – and similarly for LS (3 cases), RF (2 cases), RS (2
cases). AF and AS only have single cases, so they don't need an “OR” gate. One need
not replicate SSDs, nor difference detectors (L > R), (L < R), (L = R). One can simply
have the outputs of these detectors branch to become inputs to multiple other circuits.
Putting all these 12 (non redundant) circuits together would generate quite a complex
circuit, which is not given in this section.
How can we implement the LF, LS, AF, AS, RF, and RS? Common sense says that
to get a 4 wheeled vehicle to turn left, one needs to make the right side wheels turn
faster than the left side wheels. So use 3 more modules that output a constant signal of
a low value (e.g. 0.2) and a constant signal of a middling value (e.g. 0.4), and a
constant signal of a high value (e.g. 0.8). These different output signal values can be
used to turn the wheels at different speeds. A high signal (0.8) will turn the wheel it
controls quickly. A middling signal (0.4) will turn its wheel at a middling speed, etc.
Fig. 6 gives the combination of control signals to make the robot turn appropriately.
This brings the total of different modules now to 13. If the behavior LF is activated,
0.8 0.8AF
0.4 0.4AS
0.2 0.8RF
0.2 0.4RS
0.8 0.2LF
0.4 0.2LS
Right
Wheel
Left
Wheel
Freq =
high?
Triangle?
ou
SSD
(
L
)
SSD (R)
Sound (L)
Sound (R)
L > R
then it can send two output signals which become the inputs to modules that generate
the 2 control signals for the wheels (i.e. 0.2 and 0.8). This simple circuit is shown in
Fig. 7.
There are 6 different behaviors (LF, LS, AF, AS, RS, RS), with different
combinations of control signal strengths to the wheels, so how to solve the problem that
only one set of signals should be sent to the wheels at a time? With 6 circuits
functioning simultaneously, it is possible to have several of the six having non
negligible output values at the same time. This creates a conceptual problem. We want
to have only one of these 6 to be active (e.g. a strong output value of 0.8) and the rest to
be inactive (i.e. with weak output values of 0.2). Before proceeding further, it is
interesting to note that the problem we are now discussing is fairly typical of the role of
a brain builder or a “BA” (Brain Architect). It is analogous to the case of an electronic
engineer who designs digital electronic circuits. There is a lot of creativity involved,
and there may be “many ways to skin a cat” (i.e. many alternatives to solving a
problem, some of them being more intelligent, or more efficient than others). Returning
to the problem – how can only one of the 6 signals be strong and the other 5 weak?
This sounds like a “winner takes all (WTA)” problem. So we suggest creating a circuit
that has 6 inputs, and 6 outputs. If the ith input signal is the strongest of the 6 input
signals, then the ith output signal is strong (e.g. 0.8) and all the other output signals are
weak (e.g. 0.2), as shown in Fig. 8. How to design such a circuit using evolvable neural
net modules? (One sees the scope for creativity here!)
The very idea of using a WTA circuit may not be the best way to solve the “unique
signal problem” (i.e. ensuring that only one set of signals is sent to the wheel motors).
An alternative might be to add the output signals of the 6 behaviors (i.e. LF + LS + AS
+ AF + RF + RS). This will generate some inaccuracies for a time, but so long as the
behaviors don't change very fast from one to another, there will probably be time for
the contributions of the 5 non active behaviors to drop to low values, leaving only the
active behavior. (On the other hand a weak signal is about 0.2, so the sum of 5 weak
signals is roughly equal to one strong one, so we still have a problem). So let us pursue
the WTA approach. How to implement such a circuit? Trying to evolve a 6-input, 6-
output circuit is probably too difficult, so our instinct is to use a “divide and conquer”
approach, i.e. evolve simpler modules and then connect them to create the WTA circuit.
Consider a “dominator” circuit, which has 3 inputs A, B, C, and one output O as shown
in Fig. 9. If the input signal A (on the left) is the largest of the 3 input signals, then the
output O takes the input value A, else, O takes a very low value (e.g. 0.1 or 0.05). With
two such circuits we can combine them with a “greater than” circuit to create a WTA
circuit (component) provided that the left most of the 6 inputs is the largest, as shown
in Fig. 10. It should now not be too difficult to see that with 6 such components, we can
construct a winner take all (WTA) circuit. For example, if the input B has the largest
input signal strength, then if we swap the inputs A and B, then the using the circuit of
Fig. 10, we should get a strong output (e.g. 0.8) indicating that B was the strongest
input. Similarly, if we swap A and C, then if C is the strongest, again the output O will
be strong (else weak), and so on for the remaining 3 cases. With 6 such circuits, we can
construct a full WTA.
Fig. 7 Control Signals to Wheels for LF
Fig. 8 Winner Takes All (WTA) Circuit
The 6 outputs from the WTA circuit (one of which will be strong (0.8), and the
other five very weak (0.05) are fed into 6 circuits of the form shown in Fig. 7. The 6
“left wheel” output signals and the 6 “right wheel” output signals can be “paired”, i.e. 2
of the left wheel outputs have a value of 0.1, 2 have a value of 0.4, and 2 have a value
of 0.8 Similarly with the right wheel outputs. But instead of having 6 circuits as in
Fig. 7 we can simplify things a bit as in Fig. 11. Using the data of Fig. 4, an LS output
needs to send a 0.2 signal to the left motor and a 0.4 signal to the right motor. An LF
output sends signals 0.2 and 0.8 respectively to the left and right motors. Hence LS and
LF both send a 0.2 signal to the left motor. By connecting the two left motor signals to
an OR gate as shown in Fig. 11 if one of LS or LF is active from the WTA circuit, the
OR gate will output a strong signal. In the case of the LS/LF “OR” gate, if one of the
LS or LF is active, then the output of the OR gate is strong. This output connects to a
new module called “Multigen”, which generates a multiple of outputs depending on
which input has a strong signal. If the left input is strong (0.8) the output is a constant
signal of 0.2 - if the middle input is strong, the output is a constant signal of 0.4 - if the
right input is strong, the output is a constant of 0.8 Outputs go to the motors.
8. Single Module Evolution
This didactic section describes how a selection (a subset) of the modules discussed
in the previous section can be evolved. The first author is currently writing a book
entitled “Artificial Brains : An Evolved Neural Net Approach”, to be published by
World Scientific (Singapore) early 2010. In this book will be the descriptions of the
actual successful evolutions of many modules (probably many dozens) to give readers
and potential brain builders a fairly thorough introduction as to how to evolve
individual neural net modules, that is so critical to this approach of building artificial
brains. In this section we give only two, because describing each one takes quite a bit
of time. We start with a rather simple example, i.e. the Multigen module of Fig. 11.
Remember its specification. It has 3 inputs and one output. If the left most input is high,
and the others low, it outputs a constant signal of 0.2 If the middle input is high, it
outputs a constant signal of 0.4 If the right most input is high, it outputs a constant
signal of 0.8 How can one evolve such a module? We use a “multi-test” approach,
which is a technique commonly used in our work. In this case there are 3 tests, or
experiments, i.e. the 3 cases of input combinations (i.e. left high, middle high, right
.2
.8
LF
LF
0.2 to
left wheels
0.8 to
right wheels
Winner Takes All Circuit
0.3 0.4 0.2 0.6 0.5 0.4
0.8
0.2 02 0.2 0.2 0.2
high). Let us run each test (i.e. arrange to have the appropriate input signal values) for
a given number of “ticks”, e.g. 33 ticks for each experiment. So the total number of
ticks for the “multi-test” experiment will be 100 ticks. Fig. 12 shows the target output
signal values for the “multi-test evolution”. To evolve this module, three experiments
or tests are carried out on the same module, hence the word “multi-test”. For the first
33 ticks, 3 inputs (left to right) of value (0.8, 0.2, 0.2) are presented. For the second 33
ticks, the 3 inputs are (0.2, 0.8, 0.2), and for the third 33 ticks, the 3 inputs are (0.2, 0.2,
0.8). At the junctions of 33, 66 ticks, the internal neuronal signals are reset to zero, so
that a “fresh” experiment can begin. The fitness definition is
=
=100
1
2
))()((
1
t
tStT
f
Fig. 9 Dominator Circuit Fig. 10 Winner Takes All (WTA) Circuit Component
Fig . 12 Target Output Values for the
Multigen Module
.
Fig. 11 Motor Control Circuit
Dominator
O
A
B
C
Dominator
D
E
F
Dominator
A
B
C
>
R
R
R
R
R
R
MULTIGEN MULTIGEN
LS LF RS RF AS AF
to left motor to right motor
t (ticks)
Output
Signal
Strength
33 66 100
0.2
0.4
0.8
The T(t) is the target (desired) output signal value. It takes the value 0.2 for the
first 33 ticks, then 0.4 for the second 33 ticks, and 0.8 for the third 33 ticks. S(t) are the
actual output signal values from the evolving module. The closer the S(t) values are to
the target values T(t), the higher the fitness score f. The fitness is a simple inverse of
the sum of the squares of the differences between the T and S values for each tick t. For
a second example, take the case of the frequency detector in Fig. 5. We create a
training set of “positive” and “negative” examples. Let us assume that the
environmental model in which the robot is situated contains only 2 frequencies, i.e.
high and low, e.g. a high frequency with period of 20 ticks, and a low frequency with
period 40 ticks. Assume the strengths of the sound signals received by the robot take
the following form.
S(t) = Ai sin(2πt/T)
Let the amplitude of the signal, i.e. Ai have 3 different values, 0.2, 0.5, 0.8 Hence
there are 6 cases, i.e. 3 different possibilities for the amplitude, and 2 cases for the
period T. There will be thus 3 positive and 3 negative examples, corresponding to the
whether the period is small (high frequency) or large (low frequency). Use a 6 case
multi-test evolution, in which the 6 cases are presented each for 80 ticks. For the
positive cases, the target output is high i.e. 0.8, and for the negative cases the target
output is low i.e. 0.2
The above modules are fairly simple in their function and could be readily
programmed conventionally in a high level computer language, so why bother evolving
them? This next example, a pattern detector, can be evolved rather quickly, but it is not
at all obvious how one might program it, and especially in a comparable time. We
anticipate that there will be several thousand pattern detector modules in our 15000
module A-Brain, so we feel justified in our evolutionary engineering approach, when
people challenge us with comments such as “Why don't you just program everything?”
The CMU-CAM2 camera generates a mega-pixel image that can be data compressed to
a much smaller number of pixels, each with its own grey level or color code. For
didactic purposes, imagine this compressed grid has dimensions 10*10. Each pixel of
the grid has an output signal with magnitude less than 1.0 Each such pixel value is sent
to every neuron in a pattern detector module, so if the module has 16 neurons, there
would be 16*10*10 (external) connections, and hence weights, to the module i.e. 1600.
Imagine the module is to output a strong signal if the image contains a square (a
positive example), and a weak signal if it contains a triangle (a negative example), i.e.
it is a “square detector”.
A training set of images containing positive and negative examples is prepared, e.g.
squares and triangles of different sizes and positions in the image. Each image is
presented for 50 ticks, and the internal signals between the neurons in the module are
cleared between each test, i.e. between the presentation of each image. The fitness
function for this “multi-test evolution” is the inverse of the following formula
(T – P) Σ t Σ (+ ve tests) (0.8 – S(t))2 + P Σ t Σ (-ve tests) (0.1 – S(t))2
where T is the total number of images, P is the number of positive (square) images, so
T-P is the number of negative (triangle) images. S(t) is the strength at each tick of the
output signal of the module. The double sums are over the 50 ticks (t), and the positive
and negative test cases. The factors (T – P) and P before the summation signs are used
to “balance” the evolution, i.e. to steer the evolution equally between the negative and
the positive cases. Such pattern detector modules can often be evolved quickly using
the Celoxica board, and in much less time than they could be conventionally
programmed (assuming that one can even think of a way to program such cases quickly,
which is often not the case.)
For more examples of single neural net module evolution, readers will have to wait
until the first author’s book “Artificial Brains : An Evolved Neural Net Module
Approach” is published early 2010.
9. Conclusions
The Celoxica FPGA board is capable of speeding up the evolution of neural
network modules (relative to that on a PC) by a factor of about 50 times, depending on
the size of the neural net being evolved. We believe this to be an important advance
and an essential step when artificial brains, comprised of 10,000s of such modules are
to be evolved cheaply over a reasonable time period, and then run in real time in
interconnected form in an ordinary PC. Prior to the use of the Celoxica board, the
evolution of a single neural network could take many hours on an ordinary PC, a fact
that made brain building according to our PC-based approach quite impractical.
The underlying technology, i.e. the electronic evolution of large numbers of neural
net modules, will make the production of 10,000s of evolved modules needed to build
an artificial brain, practical. Then the real challenge of designing an artificial brain can
begin, and will result hopefully in the creation a new research field, namely “Brain
Building” or “Artificial Brains”.
This paper defined an artificial brain to be a network of evolved neural network
modules. Each module is evolved quickly using a (Celoxica) electronic accelerator
board (i.e. about 50 times faster than using a PC). The evolved weights of each neural
net module are downloaded into the RAM memory of the PC. This is done thousands
of times, one by one, up to a maximum of several 10,000s (which is the limit with
which the PC can perform the neural signaling of all the (interconnected) modules
sequentially in real time, where real time means the PC calculates the output signal
value of every neuron in the whole A-Brain 25 times per second (25 Hz).
Once all the modules are downloaded into the PC’s memory, they are
interconnected according to the designs of human “BAs” (Brain Architects). The
interconnected network of neural networks is the A-Brain (Artificial Brain). When the
PC is calculating each neuron’s output signal, it uses the IMSI’s LUTs to know where
its inputs come from, and to where it is to send its output signals. Today’s PCs allow
the real time neural signaling of A-Brains with up to a maximum of several 10,000s of
modules. To observe a 15,000 module A-Brain controlling the hundreds of behaviors
of a robot should give the impression to human observers that the robot “has a brain
behind it”. Longer term, the research field of “Artificial Brains” should grow in size
equivalent to those of NASA, ESA, etc.
References
[1] Celoxica 2006, www.celoxica.com
[2] Hugo de Garis, Michael Korkin, "The Cam-Brain Machine (CBM) : An FPGA Based Hardware
Tool which Evolves a 1000 Neuron Net Circuit Module in Seconds and Updates a 75 Million
Neuron Artificial Brain for Real Time Robot Control", Neurocomputing, Vol. 42, Issue 1-4,
February, 2002, Elsevier. Special issue on Evolutionary Neural Systems, guest editor Prof. Hugo de
Garis, http://www.iss.whu.edu.cn/degaris/papers
[3] PPt notes for a masters level Artificial Brains course
http://www.iss.whu.edu.cn/degaris/coursestaught.htm Click on the CS7910 course.
[4] The “Handel-C” High Level Language for Programming the Celoxica board, 2006,
www.celoxica.com
[5] Hugo de Garis, “Guest Editorial”, Neurocomputing, Vol. 42, Issue 1-4, February, 2002, Elsevier.
Special issue on Evolutionary Neural Systems, guest editor Prof. Hugo de Garis.
[6] Hugo de Garis, Michael Korkin, "The CAM-Brain Machine (CBM) : Real Time Evolution and Update
of a 75 Million Neuron FPGA-Based Artificial Brain", Journal of VLSI Signal Processing Systems,
Special Issue on VLSI on Custom Computing Technology, Vol. 24, Issue 2-3, (2000), pp 241-262.
[7] Hugo de Garis, Michael Korkin, Gary Fehr, "The CAM-Brain Machine (CBM) : An FPGA Based
Tool for Evolving a 75 Million Neuron Artificial Brain to Control a Lifesized Kitten Robot", Journal
of Autonomous Robots, Vol. 10, No. 3, May 2001.
[8] Hugo de Garis, Michael Korkin, Felix Gers, Eiji Nawa, Michael Hough, "Building an Artificial Brain
Using an FPGA Based CAM-Brain Machine", Applied Mathematics and Computation Journal,
Special Issue on "Artificial Life and Robotics, Artificial Brain, Brain Computing and Brainware", Vol.
111, 2000, pp163-192, North Holland.
[9] Hugo de Garis, Felix Gers, Michael Korkin, Arvin Agah, Norberto 'Eiji' Nawa , "CAM-Brain" :
ATR's Billion Neuron Artificial Brain Project : A Three Year Progress Report", Artificial Life and
Robotics Journal, Vol. 2, 1998, pp 56-61.
[10] Harik G.R., Lobo F.G., Goldberg D.E., “The Compact Genetic Algorithm”, IEEE Transactions on
Evolutionary Computation, Volume 3, Issue 4, Nov 1999, pp 287 – 297.
... 3 Repository url: https://github.com/numenta/nupic 4 Example projects attempting to simulate every aspect of the brain down to the molecular level are the China Brain Project [10] or the Blue Brain Project. See http://bluebrain. ...
... Vu la quantité de paramètres à choisir, évaluer et faire évoluer, rares sont les travaux de recherches qui reposent uniquement sur les réseaux de neurones pour modéliser directement la cognition. Néanmoins avec la dynamique actuelle du marché de l'électronique, on voit apparaître des projets d'émulation de cerveaux humains dans des cartes programmables tels que China Brain [de Garis et al., 2008]. ...
Article
Full-text available
This thesis promotes a cognitive infrastructure able to model sensorimotor behaviors in animals and humans. The theoretical developments upon which this infrastructure is drawn is inspired by the philosophical interactivist framework and the enaction paradigm: any system is represented by a set of active processes, in constant interaction with their subjective environment, which includes influences between these processes. Any living organism or cognitive system is therefore fractal, decomposed in different levels of emergence based on the same principles. These principles are now widely spread but appeared progressively during species evolution. Assimilation, regulation, anticipation or coordination made it possible for concurrent processes fighting for limited resources to cooperate, develop and maintain through ages. This joint evolution of environmental conditions and internal structures led to nowadays organisms, able to adapt to a genetically unpredictable environment of growing complexity. A mathematical model using the formalism of complex systems is detailed, as well as its computer implementation. The agent's dynamics is modeled by an activity field under the continuous influence of internal anticipations and external sensations. The global behavior of the agent then results from the implicit and stable coordination of localized interactive processes. On this aspect, the model extends artificial neural networks and classical probabilistic models. This essential characteristic enables applications in various domains and a unification of all levels of cognition. A set of applications validates the model, extending from physiological need satisfaction to mechanical systems handling, through auditory and visual perception. Finally and in order to extend the model to more complex behaviors in the future, technical contributions on algorithm optimization and parallel implementations are developed.
... 1. Neural-network-based systems, in which output or activity is triggered entirely by arbitrary connectionist processes (e.g., [13,14]). In such systems, input nodes correspond to raw sensory data, output nodes are motor commands corresponding to actions, and internal hidden nodes are trained without regard to the development of meaningful cognitive symbols (i.e., black-box intelligence): none of these nodes can be seen as capturing meaningful semantic interpretations. ...
Article
Full-text available
A great deal of contention can be found within the published literature on grounding and the symbol grounding problem, much of it motivated by appeals to intuition and unfalsifiable claims. We seek to define a formal framework of representa-tion grounding that is independent of any particular opinion, but that promotes classification and comparison. To this end, we identify a set of fundamental concepts and then formalize a hierarchy of six representational system classes that corre-spond to different perspectives on the representational require-ments for intelligence, describing a spectrum of systems built on representations that range from symbolic through iconic to distributed and unconstrained. This framework offers utility not only in enriching our understanding of symbol grounding and the literature, but also in exposing crucial assumptions to be explored by the research community.
... Fontana has extended this work in [15] to evolve complex 3D forms. The combination of neural networks and cellular automata which grow under evolutionary control is present in the China-Brain project [16], an effort to create an artificial brain of interacting small (typically 12-20 neurons) neural networks. This work, having several aspects in common, differs from the work presented in this paper in two aspects: China-Brain is intended as a controller (e.g., to a robot) while in our problem the structure and form of the cells themselves are the output and, second, the interconnections between the modules are designed explicitly by so-called brain architects, while they are an output of the evolutionary process for our model. ...
Conference Paper
Full-text available
This paper depicts and evaluates an evolutionary design process for gen- erating a complex self-organizing multicellular system based on Cellular Automata (CA). We extend the model of CA with a neural network that controls the cell be- havior according to its internal state. The model is used to evolve an Artificial Neu- ral Network controlling the cell behavior in a way a previously defined reference pattern emerges by interaction of the cells. Generating simple regular structures such as flags can be learned relatively easy, but for complex patterns such as for example paintings or photographs the output is only a rough approximation of the overall mean color scheme. The application of a genotypical template for all cells in the automaton greatly reduces the search space for the evolutionary algorithm, which makes the presented morphogenetic approach a promising and innovative method for overcoming the complexity limits of evolutionary design approaches.
Article
Full-text available
大数据时代下全球脑科学研究项目介绍
This book constitutes the refereed proceedings of the 5th International Workshop on Self-Organizing Systems, IWSOS 2011, held in Karlsruhe, Germany, in February 2011. The 9 revised full papers presented together with 1 invited paper were carefully selected from 25 initial submissions. It was the 5th workshop in a series of multidisciplinary events dedicated to self-organization in networked systems with main focus on communication and computer networks. The papers address theoretical aspects of self-organization as well as applications in communication and computer networks and robot networks.
Conference Paper
Full-text available
Cognitive functions such as a perception, thinking and acting are based on the working of the brain, one of the most complex systems we know. The traditional scientific methodology, however, has proved to be not sufficient to understand the relation between brain and cognition. The aim of this paper is to review an alternative methodology – nonlinear dynamical analysis – and to demonstrate its benefit for cognitive neuroscience in cases when the usual reductionist method fails.
Article
Full-text available
Cette thèse propose une infrastructure cognitive permettant de modéliser les comportements sensori-moteurs animaux et humains. La réflexion théorique ayant conduit à cette infrastructure s'inspire du cadre philosophique interactiviste et du paradigme de l'énaction : tout système est représenté par un ensemble de processus actifs, en interaction permanente avec leur environnement propre, ce qui inclut leur influence mutuelle. Tout organisme vivant ou système cognitif peut ainsi être décomposé de manière fractale, chaque niveau d'émergence reposant sur les mêmes principes. Ces principes aujourd'hui largement répandus sont apparus durant l'évolution des espèces vivantes. L'assimilation, la régulation, l'anticipation ou encore la coordination ont ainsi permis à des processus en concurrence pour des ressources limitées de coopérer, se développer et se maintenir à travers les âges. Cette évolution conjointe des conditions environnementales et des structures internes a conduit aux organismes modernes, capables de s'adapter à un environnement génétiquement imprévisible et d'une complexité croissante. Un modèle mathématique utilisant le formalisme des systèmes complexes est détaillé, ainsi que son implémentation informatique. La dynamique de l'agent y est modélisée par un champ d'activité sous l'influence permanente d'anticipations internes et de sensations externes. Le comportement global de l'agent résulte alors de la coordination implicite et stable de processus interactifs localisés. A ce niveau, le modèle étend et complète les réseaux de neurones artificiels et les modèles probabilistes classiques. Cette caractéristique essentielle permet d'appliquer le modèle à des domaines variés et d'unifier tous les niveaux de la cognition. Le modèle est validé par un ensemble d'applications s'étendant de la satisfaction de besoins physiologiques à la manipulation de systèmes mécaniques, en passant par la perception auditive et visuelle. Enfin, et afin de pouvoir étendre ce type de modèles à des problèmes plus complexes dans le futur, des contributions techniques touchant à l'optimisation et à la parallélisation des algorithmes sont développées.
Conference Paper
Full-text available
This work reports on progress made in the first 3 years of ATR's CAM-Brain Project, which aims to use evolutionary engineering techniques to build/grow/evolve a RAM-and-cellular-automata based artificial brain consisting of thousands of interconnected neural network modules inside special hardware such as MIT's Cellular Automata Machine CAM-8, or NTT's Content Addressable Memory System CAM-System. The states of a billion (later a trillion) 3D cellular automata cells, and millions of cellular automata rules which govern their state changes, can be stored relatively cheaply in giga(tera)bytes of RAM. After 3 years work, the CA rules are almost ready. MIT's CAM-8 (essentially a serial device) can update 200 million CA cells a second. It is likely that NTT's CAM-System (essentially a massively parallel device) will be able to update a hundred billion CA cells a second. Hence all the ingredients will soon be ready to create a revolutionary new technology which will allow thousands of evolved neural network modules to be assembled into artificial brains. This in turn will probably create not only a new research field, but hopefully a whole new industry, namely brain building. Building artificial brains with a billion neurons is the aim of ATR's 8 year CAM-Brain research project, ending in 2001.
Article
Full-text available
This article introduces ATR's CAM-Brain Machine (CBM), an FPGA based piece of hardware which implements a genetic algorithm (GA) to evolve a cellular automata (CA) based neural network circuit module, of approximately 1,000 neurons, in about a second, i.e. a complete run of a GA, with 10,000 s of circuit growths and performance evaluations. Up to 65,000 of these modules, each of which is evolved with a humanly specified function, can be downloaded into a large RAM space, and interconnected according to humanly specified artificial brain architectures. This RAM, containing an artificial brain with up to 75 million neurons, is then updated by the CBM at a rate of 130 billion CA cells per second. Such speeds should enable real time control of robots and hopefully the birth of a new research field that we call brain building. The first such artificial brain, to be built by ATR starting in 2000, will be used to control the behaviors of a life sized robot kitten called Robokoneko.
Article
Full-text available
This paper reports on recent progress made in ATR's attempt to build a 10 000-module evolved neural net artificial brain to control the behavior of a life-sized robot kitten.
Article
Full-text available
This article introduces the “CAM-Brain Machine” (CBM), an FPGA-based piece of hardware that implements a genetic algorithm (GA) to evolve a cellular automata (CA)-based neural network circuit module (of approximately 1000 neurons) in seconds (i.e., a complete run of a GA, with 10,000s of circuit growths and performance evaluations). Up to 65,000 of these modules (each of which is evolved with a specified function) can be downloaded into a gigabyte of RAM space, and interconnected according to specified artificial brain architectures. This RAM, containing an “artificial brain” with up to 75 million neurons, is then updated by the CBM at a rate of 130 billion CA cells per second. Such speeds should enable real-time control of robots and hopefully the birth of a new research field that we call “brain building”. The first such artificial brain (to be built by STARLAB starting in 2001) will be used to control the behaviors of a life-sized robot kitten called “Robokitty”.
Article
Full-text available
This paper provides an overview of ATR's Artificial Brain (CAM-Brain) Project, which aims to build an artificial brain containing some billion artificial neurons by the year 2001, and to use this brain to control the behaviors of a robot kitten “Robokoneko”.
Article
Full-text available
Introduces the compact genetic algorithm (cGA) which represents the population as a probability distribution over the set of solutions and is operationally equivalent to the order-one behavior of the simple GA with uniform crossover. It processes each gene independently and requires less memory than the simple GA. The development of the compact GA is guided by a proper understanding of the role of the GA's parameters and operators. The paper clearly illustrates the mapping of the simple GA's parameters into those of an equivalent compact GA. Computer simulations compare both algorithms in terms of solution quality and speed. Finally, this work raises important questions about the use of information in a genetic algorithm, and its ramifications show us a direction that can lead to the design of more efficient GAs
Article
Full-text available
. This article introduces the CAM-Brain Machine" (CBM), an FPGA based piece of hardware which implements a genetic algorithm (GA) to evolve a cellular automata (CA) based neural network circuit module, of approximately 1,000 neurons, in about a second, i.e. a complete run of a GA, with 10,000s of circuit growths and performance evaluations. Up to 65,000 of these modules, each of which is evolved with a humanly specied function, can be downloaded into a large RAM space, and interconnected according to humanly specied articial brain architectures. This RAM, containing an articial brain with up to 75 million neurons, is then updated by the CBM at a rate of 130 billion CA cells per second. Such speeds should enable real time control of robots and hopefully the birth of a new research eld that we call rain building". The rst such articial brain, to be built in 2000 and beyond, will be used to control the behaviors of a life sized robot kitten called Robokitty". 1 In...
Guest Editorial Issue 1-4
  • Hugo De
Hugo de Garis, "Guest Editorial", Neurocomputing, Vol. 42, Issue 1-4, February, 2002, Elsevier. Special issue on Evolutionary Neural Systems, guest editor Prof. Hugo de Garis.