Recording¶
The activity of the network can be recorded by defining monitors.
Recording spikes¶
To record the spikes from a given group, define a SpikeMonitor
object:
M=SpikeMonitor(group)
At the end of the simulation, the spike times are stored in the variable spikes
as
a list of pairs (i,t) where neuron i fired at time t. For example, the following code extracts
the list of spike times for neuron 3:
spikes3=[t for i,t in M.spikes if i==3]
but this operation can be done directly as follows:
spikes3=M[3]
The total number of spikes is M.nspikes
.
Custom monitoring¶
To process the spikes in a specific way, one can pass a function at initialisation of the
SpikeMonitor
object:
def f(spikes):
print spikes
M=SpikeMonitor(group,function=f)
The function f
is called every time step with the argument spikes
being the list of
indexes of neurons that just spiked.
Recording state variables¶
State variables can be recorded continuously by defining a StateMonitor
object, as follows:
M=StateMonitor(group,'v')
Here the state variables v
of the defined group are monitored. By default, only the statistics
are recorded. The list of time averages for all neurons is M.mean
; the standard deviations are stored
in M.std
and the variances in M.var
. Note that these are averages over time, not over the neurons.
To record the values of the state variables over the whole simulation, use the keyword record
:
M1=StateMonitor(group,'v',record=True)
M2=StateMonitor(group,'v',record=[3,5,9])
The first monitor records the value of v
for all neurons while the second one records v
for
neurons 3, 5 and 9 only. The list of times is stored in M1.times
and the lists of values are stored in
M1[i]
, where i the index of the neuron. Means and variances are no longer recorded if you
record traces.
By default, the values of the state variables are recorded every timestep, but one may record every n timesteps
by setting the keyword timestep
:
M=StateMonitor(group,'v',record=True,timestep=n)
Recording spike triggered state values¶
You can record the value of a state variable at each spike using StateSpikeMonitor
:
M = StateSpikeMonitor(group, 'V')
The spikes
attribute of M
consists of a series of tuples (i,t,V)
where V
is the
value at the time of the spike.
Recording multiple state variables¶
You can either use multiple StateMonitor
objects or use the MultiStateMonitor
object:
M = MultiStateMonitor(group, record=True)
...
run(...)
...
plot(M['V'].times, M['V'][0])
figure()
for name, m in M.iteritems():
plot(m.times, m[0], label=name)
legend()
show()
Recording only recent values¶
You can use the RecentStateMonitor
object, e.g.:
G = NeuronGroup(1, 'dV/dt = xi/(10*ms)**0.5 : 1')
MR = RecentStateMonitor(G, 'V', duration=5*ms)
run(7*ms)
MR.plot()
show()
Counting spikes¶
To count the total number of spikes produced by a group, use a PopulationSpikeCounter
object:
M=PopulationSpikeCounter(group)
Then the number of spikes after the simulation is M.nspikes
. If you need to count the spikes
separately for each neuron, use a SpikeCounter
object:
M=SpikeCounter(group)
Then M[i]
is the number of spikes produced by neuron i.
Counting coincidences¶
To count the number of coincident spikes between the neurons of a group
and given target spike trains, use a CoincidenceCounter
object:
C=CoincidenceCounter(source=group, data=data, delta=delta)
data
is a list of pairs (neuron_index, spike time), and delta is the time window
in second. To get the number of coincidences for each neuron of the group, use
coincidences = C.coincidences
The gamma precision factor can be obtained with
gamma = C.gamma
Recording population rates¶
The population rate can be monitored with a PopulationRateMonitor
object:
M=PopulationRateMonitor(group)
After the simulation, M.times
contains the list of recording times and
M.rate
is the list of rate values (where the rate is meant in the spatial sense: average rate over
the whole group at some given time). The bin size is set with the bin
keyword (in seconds):
M=PopulationRateMonitor(group,bin=1*ms)
Here the averages are calculated over 1 ms time windows. Alternatively, one can use the
smooth_rate()
method to smooth the rates:
rates=M.smooth_rate(width=1*ms,filter='gaussian')
The rates are convolved with a linear filter, which is either a Gaussian function
(gaussian
, default) or a box function (‘flat’).
Van Rossum Metric¶
The Van Rossum metric can be computed by monitoring a group with a
VanRossumMetric
object:
M = VanRossumMetric(G, tau=4*ms)
...
imshow(M.distance)