The SpikeStream simulator is based on the SpikeNET architecture, which allows for the efficient simulation of large numbers of neurons as long as each neuron is relatively unlikely to fire within each time step. The efficiency of this approach comes from the fact that each neuron and synapse is only processed when it receives a spike, with their state being calculated retrospectively for the intervening time. This method does not operate completely asynchronously because it uses the exchange of spike messages to keep the layers running at the same rate, which makes this architecture behave much like a synchronous simulator, but with the performance gain of making the updates event driven.. Since the main overhead is processing the neurons and sending the spikes, the simulator's update speed depends heavily on the level of network activity and at high levels the difference between discrete event and synchronous simulators starts to break down.
The original implementation of SpikeNET was quite limited and lacked many important and useful features. For this reason it was decided to create a new simulator with the following key attributes:
Database storage. The SpikeStream simulator is based around a database that holds all the neurons, connections, parameters, archives and patterns. This makes it very easy to launch simulations across a variable number of machines and provides a great deal of flexibility in the creation of connection patterns.
Parallel Operation. All of the spike message passing and communication between processes is carried out using PVM so that the simulation can run in parallel across an arbitrary number of machines.
Sophisticated visualisation and editing tools. An intuitive graphical user interface has been created for the creation and editing of neuron and connection groups and the control of the simulation and archiving. There are also windows to enable the live monitoring of neural activity and the playback of neural activity from archived simulation runs. Some sample SpikeStream screenshots are given in figures 3-5.
Variable delays. SpikeStream creates variable delays by copying emitted spikes into 250 buffers corresponding to different delay values. At each time step only the spikes in the currently active buffer are sent.
Dynamic synapses. Each connection between neurons has a unique ID, which is used to route the spike to a particular synapse class. This makes it possible to model the dynamic response of synapses.
C++ / Qt. The simulator is written in C++ using Qt for the GUI.
Dynamic class loading. Neuron and synapse classes are implemented as dynamically loaded libraries, making it easy to try out different neural and synaptic models without recompiling the whole application. Each dynamically loadable class has a parameter table in the database, which makes it easy to change the parameters from the GUI during the simulation run.
Live operation. Unlike the majority of neural simulation tools, SpikeStream is designed to operate in live as well as simulation time so that it can control real and virtual robots in close to real time and process input from live data sources.
Modular architecture. The editing and simulating functions of SpikeStream are completely separate from each other and from the database, making it easy for other applications - for example, genetic algorithm software - to modify the neural model in the database without affecting the ability of SpikeStream to display the neural model and run a simulation of it.
SpikeStream will be available for download from this site towards the end of the year.
The SpikeStream simulator was tested using a variable number of pairs of recurrently connected layers. At the beginning of the simulation run 50% of the neurons were activated in one of the layers in each pair and then the simulation was left to run on its own activity for 60 seconds, after which the average update time and neuron fire rate was recorded. By ensuring constant activity in each of the layers, this approach enabled us to evaluate the performance of the simulator on networks of different sizes, thus giving a reasonable idea of how the simulator would perform in a real situation. Two different layer sizes of 5,000 and 10,000 neurons were used to evaluate the effect of layer size on update time. On average there were ten connections from each neuron, leading to around 50,000 and 100,000 connections in each direction for the 5,000 and 10,000 layer sizes. The neural model for these tests was a leaky integrate and fire neuron. No learning, live monitoring or archiving was used during these tests, which were run on one and two Pentium IV 3.2 GHz machines.
The performance of SpikeStream was measured in two different ways. The first was the amount of time taken to process each time step. As mentioned earlier, SpikeStream uses a combination of event-based and synchronous simulation and so the update time per time step indicates how close the simulator is running to real time (useful if it is to be used for live operation) and also measures how long it will take to simulate a given amount of neural time. The limitation of the update time per time step measurement is that when there are no events, the simulator runs very fast and it ceases to be a useful indicator of performance. To solve this problem, the average number of neurons firing per second was also recorded to give an idea about the amount of neural activity that SpikeStream is capable of simulating.
The results from the performance tests are shown in Figure 1 and Figure 2.
Figure 1. Update time per time step for networks with different numbers of neurons
Figure 2. Number of neurons firing per second for networks with different numbers of neurons
Figure 3. SpikeStream editor
Figure 4. SpikeStream simulator
Figure 5. SpikeStream archiver
The website is maintained by Richard Newcombe.