def load(userFileName, dataType):
"""
load(userFileName, dataType)
Convenient data loader for results saved as NeuroTools StandardPickleFile.
Return the corresponding NeuroTools object. Datatype argument may become
optionnal in the future, but for now it is necessary to specify the type
of the recorded data. To have a better control on the parameters of the
NeuroTools objects, see the load_*** functions.
Inputs:
userFileName - the user file name
datatype - A string to specify the type od the data in
's' : spikes
'g' : conductances
'v' : membrane traces
'c' : currents
"""
userFile = StandardPickleFile(userFileName)
if dataType in ('s', 'spikes'):
return signals.load_spikelist(userFile)
elif dataType == 'v':
# Need t_start to be None, othervice NeuroTools overwrite loaded
# t_start with default value 0
return signals.load_vmlist(userFile, t_start=None)
elif dataType == 'c':
return signals.load_currentlist(userFile, t_start=None)
elif dataType == 'g':
return signals.load_conductancelist(userFile, t_start=None)
else:
raise Exception(
"The datatype %s is not handled ! Should be 's','g','c' or 'v'" %
datatype)
def setUp(self):
#We could run the test from anywhere...
self.p = '/'.join(os.path.realpath(__file__).split('/')[:-1])
#The following are used for the make_kernel testcases
self.box = scipy.io.loadmat(self.p + '/analysis/make_kernel/box.mat')
self.tri = scipy.io.loadmat(self.p + '/analysis/make_kernel/tri.mat')
self.epa = scipy.io.loadmat(self.p + '/analysis/make_kernel/epa.mat')
self.gau = scipy.io.loadmat(self.p + '/analysis/make_kernel/gau.mat')
self.alp = scipy.io.loadmat(self.p + '/analysis/make_kernel/alp.mat')
self.exp = scipy.io.loadmat(self.p + '/analysis/make_kernel/exp.mat')
self.alp_reversed = scipy.io.loadmat(self.p + '/analysis/make_kernel/alp_reversed.mat')
self.exp_reversed = scipy.io.loadmat(self.p + '/analysis/make_kernel/exp_reversed.mat')
#Used for the testcases of the crosscorrelate function
spk = signals.load_spikelist(self.p + '/analysis/crosscorrelate/spike_data')
self.spk0 = spk[0]
self.spk1 = spk[1]
def setUp(self):
#We could run the test from anywhere...
self.p = '/'.join(os.path.realpath(__file__).split('/')[:-1])
#The following are used for the make_kernel testcases
self.box = scipy.io.loadmat(self.p + '/analysis/make_kernel/box.mat')
self.tri = scipy.io.loadmat(self.p + '/analysis/make_kernel/tri.mat')
self.epa = scipy.io.loadmat(self.p + '/analysis/make_kernel/epa.mat')
self.gau = scipy.io.loadmat(self.p + '/analysis/make_kernel/gau.mat')
self.alp = scipy.io.loadmat(self.p + '/analysis/make_kernel/alp.mat')
self.exp = scipy.io.loadmat(self.p + '/analysis/make_kernel/exp.mat')
self.alp_reversed = scipy.io.loadmat(
self.p + '/analysis/make_kernel/alp_reversed.mat')
self.exp_reversed = scipy.io.loadmat(
self.p + '/analysis/make_kernel/exp_reversed.mat')
#Used for the testcases of the crosscorrelate function
spk = signals.load_spikelist(self.p +
'/analysis/crosscorrelate/spike_data')
self.spk0 = spk[0]
self.spk1 = spk[1]
def run(self, params, verbose=True):
tmpdir = tempfile.mkdtemp()
timer = Timer()
timer.start() # start timer on construction
# === Build the network ========================================================
if verbose: print "Setting up simulation"
sim.setup(timestep=params.simulation.dt,
max_delay=params.simulation.syn_delay,
debug=False)
N = params.N
#dc_generator
current_source = sim.DCSource(amplitude=params.snr,
start=params.simulation.simtime / 4,
stop=params.simulation.simtime / 4 * 3)
# internal noise model (NEST specific)
noise = sim.Population(N, 'noise_generator', {
'mean': 0.,
'std': params.noise_std
})
# target population
output = sim.Population(N, sim.IF_cond_exp)
# initialize membrane potential
numpy.random.seed(params.simulation.kernelseed)
V_rest, V_spike = -70., -53.
output.tset('v_init',
V_rest + numpy.random.rand(N, ) * (V_spike - V_rest))
# Connecting the network
conn = sim.OneToOneConnector(weights=params.weight)
sim.Projection(noise, output, conn)
for cell in output:
cell.inject(current_source)
output.record()
# reads out time used for building
buildCPUTime = timer.elapsedTime()
# === Run simulation ===========================================================
if verbose: print "Running simulation"
timer.reset() # start timer on construction
sim.run(params.simulation.simtime)
simCPUTime = timer.elapsedTime()
timer.reset() # start timer on construction
output_filename = os.path.join(tmpdir, 'output.gdf')
#print output_filename
output.printSpikes(output_filename) #
output_DATA = load_spikelist(output_filename,
N,
t_start=0.0,
t_stop=params.simulation.simtime)
writeCPUTime = timer.elapsedTime()
if verbose:
print "\nFiber Network Simulation:"
print "Number of Neurons : ", N
print "Mean Output rate : ", output_DATA.mean_rate(
), "Hz during ", params.simulation.simtime, "ms"
print("Build time : %g s" % buildCPUTime)
print("Simulation time : %g s" % simCPUTime)
print("Writing time : %g s" % writeCPUTime)
os.remove(output_filename)
os.rmdir(tmpdir)
return output_DATA
pl.rcParams['legend.fontsize'] = 'small'
# load simulation parameters
network_params = simulation_parameters.parameter_storage() # network_params class containing the simulation parameters
params = network_params.load_params() # params stores cell numbers, etc as a dictionary
src = 0
tgt = 2
sim_cnt = 0
gid_list = [src, tgt]
gid_list.sort()
fn = params['exc_spiketimes_fn_merged'] + str(sim_cnt) + '.ras'
spklist = nts.load_spikelist(fn)#, range(params['n_exc_per_mc']), t_start=0, t_stop=params['t_sim'])
spiketrains = spklist.spiketrains
spiketimes_pre = spiketrains[src+1.].spike_times
spiketimes_post = spiketrains[tgt+1.].spike_times
# plot spikes
markersize = 10
fig = pl.figure()
ax = fig.add_subplot(611)
for gid in gid_list:
# fn = params['exc_spiketimes_fn_base'] + str(gid) + '.ras'
# d = np.loadtxt(fn)
# ax.plot(d[:, 0], np.ones(d[:,0].size)*gid, '|', markersize=markersize, color='k')
d = spiketrains[gid+1.].spike_times
def bcpnn_offline_noColumns(params, conn_list, sim_cnt=0, save_all=False, comm=None):
"""
This function computes the weight and bias values based on spiketimes during the simulation.
Arguments:
params: parameter dictionary
conn_list: two-dim numpy array storing cell-to-cell connections (only non-zero elements will be processed)
in the format (src, tgt, weight, delay)
or
file name in which the date is stored in this way
sim_cnt: int for recording to file
save_all: if True all traces will be saved
comm = MPI communicator
"""
if (type(conn_list) == type('')):
d = np.load(conn_list)
if (comm != None):
pc_id, n_proc = comm.rank, comm.size
else:
pc_id, n_proc = 0, 1
# extract the local list of elements 'my_conns' from the global conn_list
n_total = len(conn_list)
(min_id, max_id) = utils.distribute_n(n_total, n_proc, pc_id)
my_conns = [(conn_list[i, 0], conn_list[i, 1], conn_list[i, 2], conn_list[i, 3]) for i in xrange(min_id, max_id)]
fn = params['exc_spiketimes_fn_merged'] + str(sim_cnt) + '.ras'
spklist = nts.load_spikelist(fn)#, range(params['n_exc_per_mc']), t_start=0, t_stop=params['t_sim'])
spiketrains = spklist.spiketrains
new_conn_list = np.zeros((len(my_conns), 4)) # (src, tgt, weight, delay)
bias_dict = {}
for i in xrange(params['n_exc']):
bias_dict[i] = None
for i in xrange(len(my_conns)):
# for i in xrange(2):
pre_id = my_conns[i][0]
post_id = my_conns[i][1]
# create traces from spiketimes
# pre
spiketimes_pre = spiketrains[pre_id+1.].spike_times
pre_trace = utils.convert_spiketrain_to_trace(spiketimes_pre, params['t_sim'] + 1) # + 1 is to handle spikes in the last time step
# post
spiketimes_post = spiketrains[post_id+1.].spike_times
post_trace = utils.convert_spiketrain_to_trace(spiketimes_post, params['t_sim'] + 1) # + 1 is to handle spikes in the last time step
# compute
# print "%d Computing traces for %d -> %d; %.2f percent " % (pc_id, pre_id, post_id, i / float(len(my_conns)) * 100.)
get_traces = save_all
if (get_traces):
wij, bias, pi, pj, pij, ei, ej, eij, zi, zj = get_spiking_weight_and_bias(pre_trace, post_trace, get_traces)
dw = (wij.max() - wij.min()) * params['dw_scale']
# bias update
new_bias = bias.max()
else:
dw, new_bias = get_spiking_weight_and_bias(pre_trace, post_trace, get_traces)
dw *= params['dw_scale']
# bias update
if bias_dict[post_id] == None:
bias_dict[post_id] = new_bias
# weight update
new_conn_list[i, 0] = pre_id
new_conn_list[i, 1] = post_id
new_conn_list[i, 2] = dw + my_conns[i][2]
new_conn_list[i, 3] = my_conns[i][3]
# print "DEBUG Pc %d \t%d\t%d\t%.1e\t%.1e\tbias:%.4e\tconn:" % (pc_id, new_conn_list[i, 0], new_conn_list[i, 1], new_conn_list[i, 2], new_conn_list[i, 3], new_bias[i, 1]), my_conns[i]
if (save_all):
# save
output_fn = params['weights_fn_base'] + "%d_%d.npy" % (pre_id, post_id)
np.save(output_fn, wij)
output_fn = params['bias_fn_base'] + "%d.npy" % (post_id)
np.save(output_fn, bias)
output_fn = params['ztrace_fn_base'] + "%d.npy" % pre_id
np.save(output_fn, zi)
output_fn = params['ztrace_fn_base'] + "%d.npy" % post_id
np.save(output_fn, zj)
output_fn = params['etrace_fn_base'] + "%d.npy" % pre_id
np.save(output_fn, ei)
output_fn = params['etrace_fn_base'] + "%d.npy" % post_id
np.save(output_fn, ej)
output_fn = params['etrace_fn_base'] + "%d_%d.npy" % (pre_id, post_id)
np.save(output_fn, eij)
output_fn = params['ptrace_fn_base'] + "%d.npy" % pre_id
np.save(output_fn, pi)
output_fn = params['ptrace_fn_base'] + "%d.npy" % post_id
np.save(output_fn, pj)
output_fn = params['ptrace_fn_base'] + "%d_%d.npy" % (pre_id, post_id)
np.save(output_fn, pij)
if (n_proc > 1):
output_fn_conn_list = params['conn_list_ee_fn_base'] + str(sim_cnt+1) + '.dat'
utils.gather_conn_list(comm, new_conn_list, n_total, output_fn_conn_list)
output_fn_bias = params['bias_values_fn_base'] + str(sim_cnt+1) + '.dat'
utils.gather_bias(comm, bias_dict, n_total, output_fn_bias)
else:
print "Debug saving to", params['conn_list_ee_fn_base'] + str(sim_cnt+1) + '.dat'
np.savetxt(params['conn_list_ee_fn_base'] + str(sim_cnt+1) + '.dat', my_conns)#conn_list)
print "Debug saving to", params['bias_values_fn_base'] + str(sim_cnt+1) + '.dat'
np.savetxt(params['bias_values_fn_base'] + str(sim_cnt+1) + '.dat', bias)
def bcpnn_offline(params, connection_matrix, sim_cnt=0, pc_id=0, n_proc=1, save_all=False):
"""
Arguments:
params: parameter dictionary
connection_matrix: two-dim numpy array storing cell-to-cell connections (only non-zero elements will be processed)
or
file name
sim_cnt: int for recording to file
This function does basically the same thing as the script bcpnn_offline.py
"""
if (type(connection_matrix) == type('')):
connection_matrix = np.load(connection_matrix)
non_zeros = connection_matrix.nonzero()
conns = zip(non_zeros[0], non_zeros[1])
my_conns = utils.distribute_list(conns, n_proc, pc_id)
n, m = connection_matrix.shape
for i in xrange(len(my_conns)):
# for i in xrange(2):
pre_id = my_conns[i][0]
post_id = my_conns[i][1]
# extract the spike times from the file where all cells belonging to one minicolumn are stored
# pre
mc_index_pre = pre_id / params['n_exc_per_mc']
fn_pre = params['exc_spiketimes_fn_base'] + str(pre_id) + '.ras'
spklist_pre = nts.load_spikelist(fn_pre, range(params['n_exc_per_mc']), t_start=0, t_stop=params['t_sim'])
spiketimes_pre = spklist_pre[pre_id % params['n_exc_per_mc']].spike_times # TODO: check: + 1 for NeuroTools
pre_trace = utils.convert_spiketrain_to_trace(spiketimes_pre, params['t_sim'] + 1) # + 1 is to handle spikes in the last time step
# post
mc_index_post = post_id / params['n_exc_per_mc']
fn_post = params['exc_spiketimes_fn_base'] + str(post_id) + '.ras'
spklist_post = nts.load_spikelist(fn_post, range(params['n_exc_per_mc']), t_start=0, t_stop=params['t_sim'])
spiketimes_post = spklist_post[post_id % params['n_exc_per_mc']].spike_times# TODO: check: + 1 for NeuroTools
post_trace = utils.convert_spiketrain_to_trace(spiketimes_post, params['t_sim'] + 1)
# compute
wij, bias, pi, pj, pij, ei, ej, eij, zi, zj = get_spiking_weight_and_bias(pre_trace, post_trace)
# update
dw = (wij.max() - wij.min()) * params['dw_scale']
print "DEBUG, updating weight[%d, %d] by %.1e to %.1e" % (pre_id, post_id, dw, connection_matrix[pre_id, post_id] + dw)
connection_matrix[pre_id, post_id] += dw
bias[post_id] = bias.max()
ids_to_save = []
if (save_all):
ids_to_save = []
if (save_all):
# save
output_fn = params['weights_fn_base'] + "%d_%d.npy" % (pre_id, post_id)
np.save(output_fn, wij)
output_fn = params['bias_fn_base'] + "%d.npy" % (post_id)
np.save(output_fn, bias)
output_fn = params['ztrace_fn_base'] + "%d.npy" % pre_id
np.save(output_fn, zi)
output_fn = params['ztrace_fn_base'] + "%d.npy" % post_id
np.save(output_fn, zj)
output_fn = params['etrace_fn_base'] + "%d.npy" % pre_id
np.save(output_fn, ei)
output_fn = params['etrace_fn_base'] + "%d.npy" % post_id
np.save(output_fn, ej)
output_fn = params['etrace_fn_base'] + "%d_%d.npy" % (pre_id, post_id)
np.save(output_fn, eij)
output_fn = params['ptrace_fn_base'] + "%d.npy" % pre_id
np.save(output_fn, pi)
output_fn = params['ptrace_fn_base'] + "%d.npy" % post_id
np.save(output_fn, pj)
output_fn = params['ptrace_fn_base'] + "%d_%d.npy" % (pre_id, post_id)
np.save(output_fn, pij)
print "debug", params['conn_mat_ee_fn_base'] + str(sim_cnt+1) + '.npy'
np.savetxt(params['conn_mat_ee_fn_base'] + str(sim_cnt+1) + '.npy', connection_matrix)
print "debug", params['bias_values_fn_base'] + str(sim_cnt+1) + '.npy'
np.savetxt(params['bias_values_fn_base'] + str(sim_cnt+1) + '.npy', bias)
return connection_matrix, bias
sortmap = pylab.argsort(cell_ids, kind='mergesort')
cell_ids = pylab.take(cell_ids,sortmap)
allvdata = pylab.take(allvdata,sortmap)
for i in 0,1:
tdata = pylab.arange(0,(n+1)*dt,dt)
vdata = allvdata.compress(cell_ids==i)
vdata = pylab.where(vdata>=v_thresh-0.05,0.0,vdata) # add fake APs for plotting
if len(tdata) > len(vdata):
print "Warning. Shortening tdata from %d to %d elements (%s)" % (len(tdata),len(vdata),simulator)
tdata = tdata[0:len(vdata)]
assert len(tdata)==len(vdata), "%d != %d (%s)" % (len(tdata),len(vdata),simulator)
subplot.plot(tdata,vdata)
# Plot spike rasters
subplot = figure.add_axes([x,y0+2*dy,w,h])
exc_spikedata = signals.load_spikelist("Results/VAbenchmark_%s_exc_%s_np%d.ras" % (benchmark, simulator, num_nodes))
inh_spikedata = signals.load_spikelist("Results/VAbenchmark_%s_inh_%s_np%d.ras" % (benchmark, simulator, num_nodes))
exc_spikedata.raster_plot(display=subplot)
# Inter-spike-interval histograms
bins = pylab.exp(pylab.arange(0, 8, 0.2))
isihist, bins = exc_spikedata.isi_hist(bins)
subplot = figure.add_axes([x,y0+dy,0.4*w,h])
plot_hist(subplot, isihist, pylab.arange(0, 8, 0.2), 0.2,
xlabel="Inter-spike interval (ms)", xticks=pylab.log([3,10,30,100,1000]),
xticklabels=['3','10','30','100','1000'], xmin=pylab.log(2), ymax=0.006)
subplot.set_title('Exc')
isihist, bins = inh_spikedata.isi_hist(bins)
subplot = figure.add_axes([x+0.45*dx,y0+dy,0.4*w,h])
plot_hist(subplot, isihist, pylab.arange(0,8,0.2),0.2,
"""
Example to show off some capabilities of the signals module
and the SpikeList and AnalogSignalList class.
- loads spiking and voltage data simulated with pyNN
- calculates various measurements (mean firing rate, cv...)
- plot the signals
- plots the spike-triggered-averages
Performed at the NeuroTools demo session, INCF booth,
SfN annual meeting 2008, Washington. DC.
"""
import NeuroTools.signals as signals
# loading spiking data
s = signals.load_spikelist('spike_data')
# raster plot
s.raster_plot()
# mean rate
print 'mean rate: ', s.mean_rate()
print 'mean rates: ', s.mean_rates()
# fano factor of isi
print 'fano factor of isi: ', s.fano_factors_isi()
# cv of isi
print 'cv of isi:', s.cv_isi()
# isi distribution
hs = s.isi_hist(bins=20, display=True)
def run(self,params, verbose =True):
tmpdir = tempfile.mkdtemp()
timer = Timer()
timer.start() # start timer on construction
# === Build the network ========================================================
if verbose: print "Setting up simulation"
sim.setup(timestep=params.simulation.dt,max_delay=params.simulation.syn_delay, debug=False)
N = params.N
#dc_generator
current_source = sim.DCSource( amplitude= params.snr,
start=params.simulation.simtime/4,
stop=params.simulation.simtime/4*3)
# internal noise model (NEST specific)
noise = sim.Population(N,'noise_generator',{'mean':0.,'std':params.noise_std})
# target population
output = sim.Population(N , sim.IF_cond_exp)
# initialize membrane potential
numpy.random.seed(params.simulation.kernelseed)
V_rest, V_spike = -70., -53.
output.tset('v_init',V_rest + numpy.random.rand(N,)* (V_spike -V_rest))
# Connecting the network
conn = sim.OneToOneConnector(weights = params.weight)
sim.Projection(noise, output, conn)
for cell in output:
cell.inject(current_source)
output.record()
# reads out time used for building
buildCPUTime= timer.elapsedTime()
# === Run simulation ===========================================================
if verbose: print "Running simulation"
timer.reset() # start timer on construction
sim.run(params.simulation.simtime)
simCPUTime = timer.elapsedTime()
timer.reset() # start timer on construction
output_filename = os.path.join(tmpdir,'output.gdf')
#print output_filename
output.printSpikes(output_filename)#
output_DATA = load_spikelist(output_filename,N,
t_start=0.0, t_stop=params.simulation.simtime)
writeCPUTime = timer.elapsedTime()
if verbose:
print "\nFiber Network Simulation:"
print "Number of Neurons : ", N
print "Mean Output rate : ", output_DATA.mean_rate(), "Hz during ",params.simulation.simtime, "ms"
print("Build time : %g s" % buildCPUTime)
print("Simulation time : %g s" % simCPUTime)
print("Writing time : %g s" % writeCPUTime)
os.remove(output_filename)
os.rmdir(tmpdir)
return output_DATA
def run(self, params, verbose=True):
"""
params are the parameters to use
"""
tmpdir = tempfile.mkdtemp()
myTimer = Timer()
# === Build the network ========================================================
if verbose: print "Setting up simulation"
myTimer.start() # start timer on construction
sim.setup(timestep=params['dt'], max_delay=params['syn_delay'])
N = params['N']
#dc_generator
phr_ON = sim.Population((N, ), 'dc_generator')
phr_OFF = sim.Population((N, ), 'dc_generator')
for factor, phr in [(-params['snr'], phr_OFF),
(params['snr'], phr_ON)]:
phr.tset('amplitude', params['amplitude'] * factor)
phr.set({
'start': params['simtime'] / 4,
'stop': params['simtime'] / 4 * 3
})
# internal noise model (see benchmark_noise)
noise_ON = sim.Population((N, ), 'noise_generator', {
'mean': 0.,
'std': params['noise_std']
})
noise_OFF = sim.Population((N, ), 'noise_generator', {
'mean': 0.,
'std': params['noise_std']
})
# target ON and OFF populations (what about a tridimensional Population?)
out_ON = sim.Population(
(N, ), sim.IF_curr_alpha
) #'IF_cond_alpha) #iaf_sfa_neuron')# EIF_cond_alpha_isfa_ista, IF_cond_exp_gsfa_grr,sim.IF_cond_alpha)#'iaf_sfa_neuron',params['parameters_gc'])#'iaf_cond_neuron')# IF_cond_alpha) #
out_OFF = sim.Population(
(N, ), sim.IF_curr_alpha
) #'IF_cond_alpha) #IF_curr_alpha)#'iaf_sfa_neuron')#sim.IF_curr_alpha)#,params['parameters_gc'])
# initialize membrane potential TODO: and conductances?
from pyNN.random import RandomDistribution, NumpyRNG
rng = NumpyRNG(seed=params['kernelseed'])
vinit_distr = RandomDistribution(distribution='uniform',
parameters=[-70, -55],
rng=rng)
for out_ in [out_ON, out_OFF]:
out_.randomInit(vinit_distr)
retina_proj_ON = sim.Projection(phr_ON, out_ON,
sim.OneToOneConnector())
retina_proj_ON.setWeights(params['weight'])
# TODO fix setWeight, add setDelays to 10 ms (relative to stimulus onset)
retina_proj_OFF = sim.Projection(phr_OFF, out_OFF,
sim.OneToOneConnector())
retina_proj_OFF.setWeights(params['weight'])
noise_proj_ON = sim.Projection(noise_ON, out_ON,
sim.OneToOneConnector())
noise_proj_ON.setWeights(params['weight'])
noise_proj_OFF = sim.Projection(
noise_OFF, out_OFF, sim.OneToOneConnector(
)) # implication if ON and OFF have the same noise input?
noise_proj_OFF.setWeights(params['weight'])
out_ON.record()
out_OFF.record()
# reads out time used for building
buildCPUTime = myTimer.elapsedTime()
# === Run simulation ===========================================================
if verbose: print "Running simulation"
myTimer.reset() # start timer on construction
sim.run(params['simtime'])
simCPUTime = myTimer.elapsedTime()
myTimer.reset() # start timer on construction
# TODO LUP use something like "for pop in [phr, out]" ?
out_ON_filename = os.path.join(tmpdir, 'out_on.gdf')
out_OFF_filename = os.path.join(tmpdir, 'out_off.gdf')
out_ON.printSpikes(out_ON_filename) #
out_OFF.printSpikes(out_OFF_filename) #
# TODO LUP get out_ON_DATA on a 2D grid independantly of out_ON.cell.astype(int)
out_ON_DATA = load_spikelist(out_ON_filename,
range(N),
t_start=0.0,
t_stop=params['simtime'])
out_OFF_DATA = load_spikelist(out_OFF_filename,
range(N),
t_start=0.0,
t_stop=params['simtime'])
out = {
'out_ON_DATA': out_ON_DATA,
'out_OFF_DATA': out_OFF_DATA
} #,'out_ON_pos':out_ON}
# cleans up
os.remove(out_ON_filename)
os.remove(out_OFF_filename)
os.rmdir(tmpdir)
writeCPUTime = myTimer.elapsedTime()
if verbose:
print "\nRetina Network Simulation:"
print(params['description'])
print "Number of Neurons : ", N
print "Output rate (ON) : ", out_ON_DATA.mean_rate(
), "Hz/neuron in ", params['simtime'], "ms"
print "Output rate (OFF) : ", out_OFF_DATA.mean_rate(
), "Hz/neuron in ", params['simtime'], "ms"
print("Build time : %g s" % buildCPUTime)
print("Simulation time : %g s" % simCPUTime)
print("Writing time : %g s" % writeCPUTime)
return out
def run(self, params, verbose=True):
"""
params are the parameters to use
"""
tmpdir = tempfile.mkdtemp()
myTimer = Timer()
# === Build the network ========================================================
if verbose:
print "Setting up simulation"
myTimer.start() # start timer on construction
sim.setup(timestep=params["dt"], max_delay=params["syn_delay"])
N = params["N"]
# dc_generator
phr_ON = sim.Population((N,), "dc_generator")
phr_OFF = sim.Population((N,), "dc_generator")
for factor, phr in [(-params["snr"], phr_OFF), (params["snr"], phr_ON)]:
phr.tset("amplitude", params["amplitude"] * factor)
phr.set({"start": params["simtime"] / 4, "stop": params["simtime"] / 4 * 3})
# internal noise model (see benchmark_noise)
noise_ON = sim.Population((N,), "noise_generator", {"mean": 0.0, "std": params["noise_std"]})
noise_OFF = sim.Population((N,), "noise_generator", {"mean": 0.0, "std": params["noise_std"]})
# target ON and OFF populations (what about a tridimensional Population?)
out_ON = sim.Population(
(N,), sim.IF_curr_alpha
) #'IF_cond_alpha) #iaf_sfa_neuron')# EIF_cond_alpha_isfa_ista, IF_cond_exp_gsfa_grr,sim.IF_cond_alpha)#'iaf_sfa_neuron',params['parameters_gc'])#'iaf_cond_neuron')# IF_cond_alpha) #
out_OFF = sim.Population(
(N,), sim.IF_curr_alpha
) #'IF_cond_alpha) #IF_curr_alpha)#'iaf_sfa_neuron')#sim.IF_curr_alpha)#,params['parameters_gc'])
# initialize membrane potential TODO: and conductances?
from pyNN.random import RandomDistribution, NumpyRNG
rng = NumpyRNG(seed=params["kernelseed"])
vinit_distr = RandomDistribution(distribution="uniform", parameters=[-70, -55], rng=rng)
for out_ in [out_ON, out_OFF]:
out_.randomInit(vinit_distr)
retina_proj_ON = sim.Projection(phr_ON, out_ON, sim.OneToOneConnector())
retina_proj_ON.setWeights(params["weight"])
# TODO fix setWeight, add setDelays to 10 ms (relative to stimulus onset)
retina_proj_OFF = sim.Projection(phr_OFF, out_OFF, sim.OneToOneConnector())
retina_proj_OFF.setWeights(params["weight"])
noise_proj_ON = sim.Projection(noise_ON, out_ON, sim.OneToOneConnector())
noise_proj_ON.setWeights(params["weight"])
noise_proj_OFF = sim.Projection(
noise_OFF, out_OFF, sim.OneToOneConnector()
) # implication if ON and OFF have the same noise input?
noise_proj_OFF.setWeights(params["weight"])
out_ON.record()
out_OFF.record()
# reads out time used for building
buildCPUTime = myTimer.elapsedTime()
# === Run simulation ===========================================================
if verbose:
print "Running simulation"
myTimer.reset() # start timer on construction
sim.run(params["simtime"])
simCPUTime = myTimer.elapsedTime()
myTimer.reset() # start timer on construction
# TODO LUP use something like "for pop in [phr, out]" ?
out_ON_filename = os.path.join(tmpdir, "out_on.gdf")
out_OFF_filename = os.path.join(tmpdir, "out_off.gdf")
out_ON.printSpikes(out_ON_filename) #
out_OFF.printSpikes(out_OFF_filename) #
# TODO LUP get out_ON_DATA on a 2D grid independantly of out_ON.cell.astype(int)
out_ON_DATA = load_spikelist(out_ON_filename, range(N), t_start=0.0, t_stop=params["simtime"])
out_OFF_DATA = load_spikelist(out_OFF_filename, range(N), t_start=0.0, t_stop=params["simtime"])
out = {"out_ON_DATA": out_ON_DATA, "out_OFF_DATA": out_OFF_DATA} # ,'out_ON_pos':out_ON}
# cleans up
os.remove(out_ON_filename)
os.remove(out_OFF_filename)
os.rmdir(tmpdir)
writeCPUTime = myTimer.elapsedTime()
if verbose:
print "\nRetina Network Simulation:"
print (params["description"])
print "Number of Neurons : ", N
print "Output rate (ON) : ", out_ON_DATA.mean_rate(), "Hz/neuron in ", params["simtime"], "ms"
print "Output rate (OFF) : ", out_OFF_DATA.mean_rate(), "Hz/neuron in ", params["simtime"], "ms"
print ("Build time : %g s" % buildCPUTime)
print ("Simulation time : %g s" % simCPUTime)
print ("Writing time : %g s" % writeCPUTime)
return out
"""
Example to show off some capabilities of the signals module
and the SpikeList and AnalogSignalList class.
- loads spiking and voltage data simulated with pyNN
- calculates various measurements (mean firing rate, cv...)
- plot the signals
- plots the spike-triggered-averages
Performed at the NeuroTools demo session, INCF booth,
SfN annual meeting 2008, Washington. DC.
"""
import NeuroTools.signals as signals
# loading spiking data
s = signals.load_spikelist('spike_data')
# raster plot
s.raster_plot()
# mean rate
print 'mean rate: ',s.mean_rate()
print 'mean rates: ',s.mean_rates()
# fano factor of isi
print 'fano factor of isi: ',s.fano_factors_isi()
# cv of isi
print 'cv of isi:',s.cv_isi()
# isi distribution
hs = s.isi_hist(bins=20, display=True)
tdata = pylab.arange(0, (n + 1) * dt, dt)
vdata = allvdata.compress(cell_ids == i)
vdata = pylab.where(vdata >= v_thresh - 0.05, 0.0,
vdata) # add fake APs for plotting
if len(tdata) > len(vdata):
print "Warning. Shortening tdata from %d to %d elements (%s)" % (
len(tdata), len(vdata), simulator)
tdata = tdata[0:len(vdata)]
assert len(tdata) == len(
vdata), "%d != %d (%s)" % (len(tdata), len(vdata), simulator)
subplot.plot(tdata, vdata)
# Plot spike rasters
subplot = figure.add_axes([x, y0 + 2 * dy, w, h])
exc_spikedata = signals.load_spikelist(
"Results/VAbenchmark_%s_exc_%s_np%d.ras" %
(benchmark, simulator, num_nodes))
inh_spikedata = signals.load_spikelist(
"Results/VAbenchmark_%s_inh_%s_np%d.ras" %
(benchmark, simulator, num_nodes))
exc_spikedata.raster_plot(display=subplot)
# Inter-spike-interval histograms
bins = pylab.exp(pylab.arange(0, 8, 0.2))
isihist, bins = exc_spikedata.isi_hist(bins)
subplot = figure.add_axes([x, y0 + dy, 0.4 * w, h])
plot_hist(subplot,
isihist,
pylab.arange(0, 8, 0.2),
0.2,
xlabel="Inter-spike interval (ms)",
