SPIKER: Analog Waveform to Digital Spiketrain Conversion in ATR's Arti cial Brain (CAM-Brain) Project

(1) Computer Science Department, Stanford University, Stanford, USA, http://www.stanford.edu/ mhough (2) Dept. 6, ATR-HIP, Kyoto, Japan, http://www.hip.atr.co.jp/ fdegaris,xnawag (3) Genobyte Inc., Boulder, Colorado, USA, http://www.genobyte.com (4) Istituto Dalle Molle di Studi sull'Intelligenza Arti ciale, Lugano, Switzerland, http://www.idsia.ch/ felix
(1) (2) (3) (4) (2) Michael Hough , Hugo de Garis , Michael Korkin , Felix Gers , Norberto Eiji Nawa

This paper presents an algorithm which converts an arbitrary analog time-varying signal into a digital spiketrain (a bit string of 0's interspersed with 1's), where the information is contained in the spacing between the spikes. This conversion is an important ingredient in the CAM-Brain Project, as it allows the user of ATR's CAM-Brain Machine (CBM) to think entirely in terms of analog signals, and not the more abstract, visually rather meaningless, spiketrains. The SPIKER conversion completes a package of which makes the evolution of individual CBM based neural network modules easier to think about and to accomplish. Keywords: evolutionary neural networks, hardware implementation, CAM-Brain project, CoDi neural model, information representation schemes

Abstract

1 Introduction
ATR's CAM-Brain Project 1] aims to build a largescale brain-like neural network system in hardware. The essential ingredient in this project is a special piece of hardware, based on Xilinx XC6264 FPGAs which grow and evolve cellular automata based neural network circuits (modules) at electronic speeds. This machine, called CAM-Brain Machine (CBM) 3], can update the cellular automata (CA) cells which form the basis of the neural network at a rate of 150 billion a second, and can complete a full run of a genetic algorithm with tens of thousands of circuit grows and tness evaluations of those grown circuits in about one second. Tens of thousands (and higher magnitudes) of evolved neural net modules can be evolved and assembled into humanly de ned arti cial brain architectures. The cellular automata based neural net model used in the CBM had to be simple enough to be implementable in hardware. The constraints imposed

by the electronics were rather severe, thus, the neural model used, called "CoDi" (which stands for "Collect and Distribute, see 2] for details on the model) could not a ord to give many bits to the states of the neural signals which traverse the grown neural nets. In fact, the CoDi model has only single bit signaling. Thus, the inputs and outputs of each CoDi module are bitstrings (in this context, spiketrains). The problem that arises then is how to interpret the meaning of a spiketrain input or output, i.e. to choose a representation for the spiketrains. After some initial experimentation with various representation methods, we eventually settled on one we called Spike Interval Information Coding (SIIC) 4], which convolves the spiketrain output with a digitized analog convolution function, inspired by an hypothesis to explain the neural coding in biological neural networks presented in 6]. The result of this convolution is an analog waveform output (usually time varying) which can then be compared to some user supplied analog target waveform. The tness of the CoDi module grown and signaled by the CBM is then a function of the sum of the absolute di erences between the target and the actual analog waveform values at each clocktick. Experiments were performed using SIIC to generate sine curves and sum of sines and cosines. Constantly ring binary inputs were supplied to a CoDi module, which was evolved to output a spike train which was decoded using the SIIC. The nal product of the SIIC would then be compared to the target function. Fig. 1 shows one example of an evolved sinusoidal curve with the actual spikes that generated it. This paper shows how the opposite operation, i.e. transform an analog waveform into a spiketrain, can be done, with a fairly simple algorithm. The algorithm, named Hough Spiker Algorithm (HSA) will be very useful to evolutionary engineers (EEs), because they will be able to think entirely in terms of ana-

1 0.8 0.6 0.4 0.2 0 0.2 0.4 0.6 0.8 1 0 1 50 100 150 200 250

representation method delivers a real valued output at each clock tick, thus converting a binary pulse string into an analog time dependent signal. For more details on the method, refer to 4].

3 Hough Spiker Algorithm (HSA)

Although the SIIC showed to be e cient in translating the bitstrings output by the CoDi modules into analog waveforms, it only solves half the problem. In order to enable the other way around, i.e., to convert analog waveforms into spiketrains, the Hough Spiker Algorithm (HSA) was developed. This conversion is needed as an interface between the motors/sensors of the robot bodies (e.g. a kitten robot) that the arti cial brain controls, and the brain's CoDi modules. Moreover, it is also very useful in the design process of the modules, as it enables one to think entirely in terms of analog signals, in both the inputs and outputs, rather than in an abstract, visually unintelligible spiketrain format. An analog time varying waveform input, processed by the HSA, is converted into an equivalent spiketrain. This spiketrain, if processed by the SIIC, should give back the original analog signal. In order to give an intuitive feel of the HSA, consider a spiketrain consisting of a single pulse (i.e. all 0's with one 1). When this pulse passes through the convolution function window, it adds each value of the convolution function to the output in turn. At t = 0 its value will be the rst value of the convolution lter, at t = 1 its value will be the second value of the convolution lter, etc. Just as a particular spiketrain is a series of spikes with time delays between them, so too the convolved spiketrain will be the sum of the convolution lters, with (possibly) time delays between them. At each clock tick when there is a spike, add the convolution lter to the output. If there is no spike, just shift the time o set and repeat. In graphical form, with a generic spiketrain:
1101001 (spiketrain) 1 4 9 5 -2 (convolution filter) 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 -------------------------------

0.5

50

100

150

200

250

Figure 1: Three periods of a sinusoidal wave generated by the CoDi model and SIIC method. The lower gures show the actual spikes that generated the waveform. log waveform inputs and outputs when evolving CoDi modules. The remainder of this paper is structured as follows. Section 2 gives a brief description of the SIIC representation method, which converts a spiketrain into an analog signal. Section 3 presents the Hough Spiker Algorithm (HSA), which does the opposite, i.e. converts an analog signal into a spiketrain, and shows some preliminary results of simulation experiments. Section 4 summarizes and describes the future work.

2 Spike Interval Information Coding (SIIC)

The constraints imposed by programmable hardware devices are such that the neural model had to be very simple in order to be implementable within those constraints. Consequently, the signaling states in the CoDi model were made to contain only 1 bit of information (as happens in nature's "binary" spiketrains). The problem then arose as to interpretation. How were we to assign meaning to the binary pulse streams, i.e. the clocked sequences of 0's and 1's, which are neural net module's inputs and outputs? Ultimately, after several experiments were ran with di erent representation methods 5], a representation which convolves the binary pulse string with a convolution function was chosen. This representation, named Spike Interval Information Coding (SIIC), was inspired by a novel hypothesis of neural coding presented in 6]. The SIIC

5 13 15 7 7 6 2 9 5 -2 (analog waveform values)

In the HSA deconvolution algorithm, we take advantage of this summation, and in e ect 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 justi cation 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 red at that moment, and this ring 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:
(analog waveform values) 1 5 13 15 7 7 6 2 9 5 -2 1 4 9 5 -2 (convolution filter) conv.filter < analog wave vals., so spike: 1 0 1 4 10 9 7 6 2 9 5 -2 1 4 9 5 -2 less, so spike: 11 0 0 0 1 4 9 6 2 9 5 -2 1 4 9 5 -2 not less, so no spike: 110 0 0 0 1 4 9 6 2 9 5 -2 1 4 9 5 -2 less, so spike: 1101 0 0 0 0 0 0 1 4 9 5 -2 1 4 9 5 -2 not less: 11010 0 0 0 0 0 0 1 4 9 5 -2 1 4 9 5 -2 not less: 110100 0 0 0 0 0 0 1 4 9 5 -2 1 4 9 5 -2 less, so spike: 1101001 (original spikes) 0 0 0 0 0 0 0 0 0 0 0

as dashed lines. The spiketrain resulting from each analog input is sent into the SIIC convolution process. The resulting analog output should be very close to the original waveform and is shown as a solid line. The third line near the bottom is the absolute di erence (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 lter window. An example of applying too stringent an analog wave form is shown in Fig.3. 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.
450

400

350

300

?:

250

200

?:

150

100

?:

50

50

100

150

200

250

?:

?:

Figure 2: The original curve (dashed line) is converted into an spiketrain by the HSA. The resulting spiketrain is converted into an analog waveform, using the SIIC (solid line). The lower curve shows the absolute error between the two.

?:

?:

4 Summary and Conclusions

This paper introduced an algorithm, the Hough Spiker Algorithm (HSA), to transform analog wave forms into digital spiketrains (bitstrings) which will be very useful to designers of the component modules of the arti cial brains containing tens of thousands of such modules. Used in conjunction with the Spike Interval Information Coding (SIIC), it is possible to think entirely in terms of analog waveforms, which is considerably easier than dealing with abstract spiketrains. After an input waveform is spec-

It is assumed that spiking will irreversibly raise the value of the convolved output. If the convolution lter 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. Figures 2 and 3 show two examples of the HSA in action. The original input analog signals are shown

References
250 200

150

100

50

50

50

100

150

200

250

Figure 3: Another example of original waveform (dashed line) HSA spiketrain SIIC estimated waveform ! ! (solid line) i ed, it is then converted into spiketrains, using the HSA. These spiketrains are fed into the CoDi modules being evolved. Now, the spiketrains output by the CoDi modules can then be converted into an analog waveform using the reverse process of the HSA, the SIIC. The resulting waveform output can then be compared with a target analog waveform. The closer the match, the higher the tness of the evolving module. These two conversions, analog to spiketrain (HSA) and spiketrain to analog (SIIC) facilitate the evolution of CoDi neural net modules on the CAM-Brain Machine (CBM). With these two conversion algorithms on hand, it will be a lot more practical for designers to evolve CoDi modules, provided of course that the evolvability of the modules is adequate. The issue of evolvability is always an open question, because not all modules may evolve equally well. Criteria for good evolvability, or how to enhance it, are still not well understood issues. The next step in the CAM-Brain Project is to design multi-module systems, and to scale up the number of modules used. The CBM can update roughly 32000 modules at su cient speed (150 billion cellular automata cells a second) to enable real time control of a kitten robot. With 32000 modules allowed by the hardware, more sophisticated neural network modules, with more interesting behaviors, and multi-module architectures can be tried. The CBM will allow the systematic testing of module evolution procedures, which is rather di cult to be done on standard computers due to the long simulations times.

1] Hugo de Garis. An arti cial brain : ATR's cambrain project aims to build/evolve an arti cial brain with a million neural net modules inside a trillion cell cellular automata machine. New Generation Computing Journal, 12(2), July 1994. 2] Felix Gers and Hugo de Garis. CAM-Brain: A new model for ATR's cellular automata based arti cial brain project. In Proceedings of the First Internatioal Conference on Evolvable Systems: From Biology to Hardware (ICES'96), October 1996. 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 arti cial 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] Norberto Eiji Nawa, Hugo de Garis, Felix Gers, and Michael Korkin. ATR's CAM-brain machine (CBM) simulation results and representation issues. In John R. Koza, Wolfgang Banzhaf, Kumar Chellapilla, Kalyanmoym Deb, Marco Dorigo, David B. Fogel, Max H. Garzon, David E. Goldberg, Hitoshi Iba, and Rick L. Riolo, editors, Genetic Programming 1998: Proceedings of the Third Annual Conference. San Francisco, CA, Morgan Kaufmann, July 1998. 6] Fred Rieke, David Warland, Rob de Ruyter van Steveninck, and William Bialek. Spikes: exploring the neural code. MIT Press/Bradford Books, Cambridge, MA, 1997.