NEST is a simulation software for spiking neural network models, including large-scale neuronal networks. NEST was initially developed by Markus Diesmann and Marc-Oliver Gewaltig and is now developed and maintained by the NEST Initiative.
Modeling philosophy
A NEST simulation tries to follow the logic of an electrophysiological experiment that takes place inside a computer with the difference, that the neural system to be investigated must be defined by the experimenter.
The neural system is defined by a possibly large number of neurons and their connections. In a NEST network, different neuron and synapse models can coexist. Any two neurons can have multiple connections with different properties. Thus, the connectivity can in general not be described by a weight or connectivity matrix but rather as an adjacency list.
To manipulate or observe the network dynamics, the experimenter can define so-called devices which represent the various instruments (for measuring and stimulation) found in an experiment. These devices write their data either to memory or to file.
NEST is extensible and new models for neurons, synapses, and devices can be added.
Example
The following example simulates spiking activity in a sparse random network with recurrent excitation and inhibition
The figure shows the spiking activity of 50 neurons as a raster plot. Time increases along the horizontal axis, neuron id increases along the vertical axis. Each dot corresponds to a spike of the respective neuron at a given time. The lower part of the figure shows a histogram with the mean firing-rate of the neurons.
import nest
import nest.raster_plot
J_ex = 0.1 # excitatory weight
J_in = -0.5 # inhibitory weight
p_rate = 20000.0 # external Poisson rate
neuron_params= { "C_m": 1.0, "tau_m": 20.0, "t_ref": 2.0, "E_L": 0.0, "V_reset": 0.0, "V_m": 0.0, "V_th": 20.0}
# Set parameters of neurons and devices
nest.SetDefaults("iaf_psc_delta", neuron_params) nest.SetDefaults("poisson_generator", { "rate": p_rate}) nest.SetDefaults("spike_detector", { "withtime": True, "withgid": True})
# Create neurons and devices
nodes_ex = nest.Create("iaf_psc_delta", 10000) nodes_in = nest.Create("iaf_psc_delta", 2500) noise = nest.Create("poisson_generator") espikes = nest.Create("spike_detector")
# Configure synapse models
nest.CopyModel("static_synapse", "excitatory", { "weight": J_ex, "delay": 1.5}) nest.CopyModel("static_synapse", "inhibitory", { "weight": J_in, "delay": 1.5})
# Connect the random net and instrument it with the devices
nest.Connect(nodes_ex, nodes_ex+nodes_in, { "rule": 'fixed_indegree', "indegree": 1000}, "excitatory") nest.Connect(nodes_in, nodes_ex+nodes_in, { "rule": 'fixed_indegree', "indegree": 250}, "inhibitory") nest.Connect(noise, nodes_ex + nodes_in, syn_spec="excitatory") nest.Connect(nodes_ex[1:51], espikes)
# Simulate for 100. ms
nest.Simulate(100.0)
# Plot results
nest.raster_plot.from_device(espikes, hist=True) nest.raster_plot.show()
Features
Neuron models
Integrate-and-fire models with different types of synaptic currents or potentials Integrate-and-fire models with conductance based synapses Single compartment Hodgkin–Huxley models Adaptive Exponential Integrate and Fire neuron (AdEx) MAT2 neuron model
Network models
Random neural network
Topological networks
Data-driven network models
Synapse models
Static synapses with homogeneous or heterogeneous weight and delay. Spike-timing-dependent plasticity Short-term plasticity (Tsodyks & Markram synapses) Neuromodulated synapses, using Dopamine.
Device models
Spike detector
Multimeter for potentials, currents, etc. AC, DC, and step current generators Noise generators (Poisson, Gauss, Gamma) Spike generators for replay of spikes
Accuracy
NEST aims at high accuracy and precision of its simulations
Each neuron model has its appropriate solver and many models have unit tests. If possible, exact integration is used. By default, spikes fall onto the grid, defined by the simulation time-step. Some models support spike-exchange in continuous time.
Parallel and distributed simulation
Support for multi-threaded simulation, using OpenMP or POSIX Threads. Support for hybrid multi-threaded and distributed simulation. Parallelization is handled semi-automatically by NEST's simulation kernel. Supra-linear to linear scaling for up to 10000 cores.