def do_run(seed=None):
simulator_name = 'spiNNaker'
timer = Timer()
# === Define parameters =========================================
parallel_safe = True
n = 1500 # number of cells
# number of excitatory cells:number of inhibitory cells
r_ei = 4.0
pconn = 0.02 # connection probability
dt = 1 # (ms) simulation timestep
tstop = 200 # (ms) simulaton duration
delay = 1
# Cell parameters
area = 20000. # (µm²)
tau_m = 20. # (ms)
cm = 1. # (µF/cm²)
g_leak = 5e-5 # (S/cm²)
e_leak = -49. # (mV)
v_thresh = -50. # (mV)
v_reset = -60. # (mV)
t_refrac = 5. # (ms) (clamped at v_reset)
# (mV) 'mean' membrane potential, for calculating CUBA weights
v_mean = -60.
tau_exc = 5. # (ms)
tau_inh = 10. # (ms)
# (nS) #Those weights should be similar to the COBA weights
g_exc = 0.27
# (nS) # but the delpolarising drift should be taken into account
g_inh = 4.5
e_rev_exc = 0. # (mV)
e_rev_inh = -80. # (mV)
# === Calculate derived parameters ===============================
area *= 1e-8 # convert to cm²
cm *= area * 1000 # convert to nF
r_m = 1e-6 / (g_leak * area) # membrane resistance in MΩ
assert tau_m == cm * r_m # just to check
# number of excitatory cells
n_exc = int(round((n * r_ei / (1 + r_ei))))
n_inh = n - n_exc # number of inhibitory cells
celltype = p.IF_curr_exp
# (nA) weight of excitatory synapses
w_exc = 1e-3 * g_exc * (e_rev_exc - v_mean)
w_inh = 1e-3 * g_inh * (e_rev_inh - v_mean) # (nA)
assert w_exc > 0
assert w_inh < 0
# === Build the network ==========================================
p.setup(timestep=dt, min_delay=delay, max_delay=delay)
if simulator_name == 'spiNNaker':
# this will set 100 neurons per core
p.set_number_of_neurons_per_core(p.IF_curr_exp, 100)
# this will set 50 neurons per core
p.set_number_of_neurons_per_core(p.IF_cond_exp, 50)
# node_id = 1
# np = 1
# host_name = socket.gethostname()
cell_params = {'tau_m': tau_m, 'tau_syn_E': tau_exc, 'tau_syn_I': tau_inh,
'v_rest': e_leak, 'v_reset': v_reset, 'v_thresh': v_thresh,
'cm': cm, 'tau_refrac': t_refrac, 'i_offset': 0}
timer.start()
exc_cells = p.Population(n_exc, celltype, cell_params,
label="Excitatory_Cells")
inh_cells = p.Population(n_inh, celltype, cell_params,
label="Inhibitory_Cells")
rng = NumpyRNG(seed=seed, parallel_safe=parallel_safe)
uniform_distr = RandomDistribution('uniform', [v_reset, v_thresh], rng=rng)
exc_cells.initialize(v=uniform_distr)
inh_cells.initialize(v=uniform_distr)
exc_conn = p.FixedProbabilityConnector(pconn, rng=rng)
synapse_exc = p.StaticSynapse(weight=w_exc, delay=delay)
inh_conn = p.FixedProbabilityConnector(pconn, rng=rng)
synapse_inh = p.StaticSynapse(weight=w_inh, delay=delay)
connections = dict()
connections['e2e'] = p.Projection(exc_cells, exc_cells, exc_conn,
synapse_type=synapse_exc,
receptor_type='excitatory')
connections['e2i'] = p.Projection(exc_cells, inh_cells, exc_conn,
synapse_type=synapse_exc,
receptor_type='excitatory')
connections['i2e'] = p.Projection(inh_cells, exc_cells, inh_conn,
synapse_type=synapse_inh,
receptor_type='inhibitory')
connections['i2i'] = p.Projection(inh_cells, inh_cells, inh_conn,
synapse_type=synapse_inh,
receptor_type='inhibitory')
# === Setup recording ==============================
exc_cells.record("spikes")
# === Run simulation ================================
p.run(tstop)
exc_spikes = exc_cells.get_data("spikes")
exc_cells.write_data(neo_path, "spikes")
p.end()
return exc_spikes
def runBrunelNetwork(g=5.,
eta=2.,
dt=0.1,
simtime=1000.0,
delay=1.5,
epsilon=0.1,
order=2500,
N_rec=50,
N_rec_v=2,
save=False,
simulator_name='nest',
jnml_simulator=None,
extra={}):
exec("from pyNN.%s import *" % simulator_name) in globals()
timer = Timer()
# === Define parameters ========================================================
downscale = 1 # scale number of neurons down by this factor
# scale synaptic weights up by this factor to
# obtain similar dynamics independent of size
order = order # determines size of network:
# 4*order excitatory neurons
# 1*order inhibitory neurons
Nrec = N_rec # number of neurons to record from, per population
epsilon = epsilon # connectivity: proportion of neurons each neuron projects to
# Parameters determining model dynamics, cf Brunel (2000), Figs 7, 8 and Table 1
# here: Case C, asynchronous irregular firing, ~35 Hz
eta = eta # rel rate of external input
g = g # rel strength of inhibitory synapses
J = 0.1 # synaptic weight [mV]
delay = delay # synaptic delay, all connections [ms]
# single neuron parameters
tauMem = 20.0 # neuron membrane time constant [ms]
tauSyn = 0.1 # synaptic time constant [ms]
tauRef = 2.0 # refractory time [ms]
U0 = 0.0 # resting potential [mV]
theta = 20.0 # threshold
# simulation-related parameters
simtime = simtime # simulation time [ms]
dt = dt # simulation step length [ms]
# seed for random generator used when building connections
connectseed = 12345789
use_RandomArray = True # use Python rng rather than NEST rng
# seed for random generator(s) used during simulation
kernelseed = 43210987
# === Calculate derived parameters =============================================
# scaling: compute effective order and synaptic strength
order_eff = int(float(order) / downscale)
J_eff = J * downscale
# compute neuron numbers
NE = int(4 * order_eff) # number of excitatory neurons
NI = int(1 * order_eff) # number of inhibitory neurons
N = NI + NE # total number of neurons
# compute synapse numbers
CE = int(epsilon * NE) # number of excitatory synapses on neuron
CI = int(epsilon * NI) # number of inhibitory synapses on neuron
C = CE + CI # total number of internal synapses per n.
Cext = CE # number of external synapses on neuron
# synaptic weights, scaled for alpha functions, such that
# for constant membrane potential, charge J would be deposited
fudge = 0.00041363506632638 # ensures dV = J at V=0
# excitatory weight: JE = J_eff / tauSyn * fudge
JE = (J_eff / tauSyn) * fudge
# inhibitory weight: JI = - g * JE
JI = -g * JE
# threshold, external, and Poisson generator rates:
nu_thresh = theta / (J_eff * CE * tauMem)
nu_ext = eta * nu_thresh # external rate per synapse
p_rate = 1000 * nu_ext * Cext # external input rate per neuron (Hz)
# number of synapses---just so we know
Nsyn = (
C + 1
) * N + 2 * Nrec # number of neurons * (internal synapses + 1 synapse from PoissonGenerator) + 2synapses" to spike detectors
# put cell parameters into a dict
cell_params = {
'tau_m': tauMem,
'tau_syn_E': tauSyn,
'tau_syn_I': tauSyn,
'tau_refrac': tauRef,
'v_rest': U0,
'v_reset': U0,
'v_thresh': theta,
'cm': 0.001
} # (nF)
# === Build the network ========================================================
# clear all existing network elements and set resolution and limits on delays.
# For NEST, limits must be set BEFORE connecting any elements
#extra = {'threads' : 2}
rank = setup(timestep=dt, max_delay=delay, **extra)
print("rank =", rank)
np = num_processes()
print("np =", np)
import socket
host_name = socket.gethostname()
print("Host #%d is on %s" % (rank + 1, host_name))
if 'threads' in extra:
print("%d Initialising the simulator with %d threads..." %
(rank, extra['threads']))
else:
print("%d Initialising the simulator with single thread..." % rank)
# Small function to display information only on node 1
def nprint(s):
if rank == 0:
print(s)
timer.start() # start timer on construction
print("%d Setting up random number generator" % rank)
rng = NumpyRNG(kernelseed, parallel_safe=True)
print("%d Creating excitatory population with %d neurons." % (rank, NE))
celltype = IF_curr_alpha(**cell_params)
celltype.default_initial_values[
'v'] = U0 # Setting default init v, useful for NML2 export
E_net = Population(NE, celltype, label="E_net")
print("%d Creating inhibitory population with %d neurons." % (rank, NI))
I_net = Population(NI, celltype, label="I_net")
print(
"%d Initialising membrane potential to random values between %g mV and %g mV."
% (rank, U0, theta))
uniformDistr = RandomDistribution('uniform', low=U0, high=theta, rng=rng)
E_net.initialize(v=uniformDistr)
I_net.initialize(v=uniformDistr)
print("%d Creating excitatory Poisson generator with rate %g spikes/s." %
(rank, p_rate))
source_type = SpikeSourcePoisson(rate=p_rate)
expoisson = Population(NE, source_type, label="expoisson")
print("%d Creating inhibitory Poisson generator with the same rate." %
rank)
inpoisson = Population(NI, source_type, label="inpoisson")
# Record spikes
print("%d Setting up recording in excitatory population." % rank)
E_net.record('spikes')
if N_rec_v > 0:
E_net[0:min(NE, N_rec_v)].record('v')
print("%d Setting up recording in inhibitory population." % rank)
I_net.record('spikes')
if N_rec_v > 0:
I_net[0:min(NI, N_rec_v)].record('v')
progress_bar = ProgressBar(width=20)
connector = FixedProbabilityConnector(epsilon,
rng=rng,
callback=progress_bar)
E_syn = StaticSynapse(weight=JE, delay=delay)
I_syn = StaticSynapse(weight=JI, delay=delay)
ext_Connector = OneToOneConnector(callback=progress_bar)
ext_syn = StaticSynapse(weight=JE, delay=dt)
print(
"%d Connecting excitatory population with connection probability %g, weight %g nA and delay %g ms."
% (rank, epsilon, JE, delay))
E_to_E = Projection(E_net,
E_net,
connector,
E_syn,
receptor_type="excitatory")
print("E --> E\t\t", len(E_to_E), "connections")
I_to_E = Projection(I_net,
E_net,
connector,
I_syn,
receptor_type="inhibitory")
print("I --> E\t\t", len(I_to_E), "connections")
input_to_E = Projection(expoisson,
E_net,
ext_Connector,
ext_syn,
receptor_type="excitatory")
print("input --> E\t", len(input_to_E), "connections")
print(
"%d Connecting inhibitory population with connection probability %g, weight %g nA and delay %g ms."
% (rank, epsilon, JI, delay))
E_to_I = Projection(E_net,
I_net,
connector,
E_syn,
receptor_type="excitatory")
print("E --> I\t\t", len(E_to_I), "connections")
I_to_I = Projection(I_net,
I_net,
connector,
I_syn,
receptor_type="inhibitory")
print("I --> I\t\t", len(I_to_I), "connections")
input_to_I = Projection(inpoisson,
I_net,
ext_Connector,
ext_syn,
receptor_type="excitatory")
print("input --> I\t", len(input_to_I), "connections")
# read out time used for building
buildCPUTime = timer.elapsedTime()
# === Run simulation ===========================================================
# run, measure computer time
timer.start() # start timer on construction
print("%d Running simulation for %g ms (dt=%sms)." % (rank, simtime, dt))
run(simtime)
print("Done")
simCPUTime = timer.elapsedTime()
# write data to file
#print("%d Writing data to file." % rank)
#(E_net + I_net).write_data("Results/brunel_np%d_%s.pkl" % (np, simulator_name))
if save and not simulator_name == 'neuroml':
for pop in [E_net, I_net]:
io = PyNNTextIO(filename="brunel-PyNN-%s-%s-%i.gdf" %
(simulator_name, pop.label, rank))
spikes = pop.get_data('spikes', gather=False)
for segment in spikes.segments:
io.write_segment(segment)
io = PyNNTextIO(filename="brunel-PyNN-%s-%s-%i.dat" %
(simulator_name, pop.label, rank))
vs = pop.get_data('v', gather=False)
for segment in vs.segments:
io.write_segment(segment)
spike_data = {}
spike_data['senders'] = []
spike_data['times'] = []
index_offset = 1
for pop in [E_net, I_net]:
if rank == 0:
spikes = pop.get_data('spikes', gather=False)
#print(spikes.segments[0].all_data)
num_rec = len(spikes.segments[0].spiketrains)
print("Extracting spike info (%i) for %i cells in %s" %
(num_rec, pop.size, pop.label))
#assert(num_rec==len(spikes.segments[0].spiketrains))
for i in range(num_rec):
ss = spikes.segments[0].spiketrains[i]
for s in ss:
index = i + index_offset
#print("Adding spike at %s in %s[%i] (cell %i)"%(s,pop.label,i,index))
spike_data['senders'].append(index)
spike_data['times'].append(s)
index_offset += pop.size
#from IPython.core.debugger import Tracer
#Tracer()()
E_rate = E_net.mean_spike_count() * 1000.0 / simtime
I_rate = I_net.mean_spike_count() * 1000.0 / simtime
# write a short report
nprint("\n--- Brunel Network Simulation ---")
nprint("Nodes : %d" % np)
nprint("Number of Neurons : %d" % N)
nprint("Number of Synapses : %d" % Nsyn)
nprint("Input firing rate : %g" % p_rate)
nprint("Excitatory weight : %g" % JE)
nprint("Inhibitory weight : %g" % JI)
nprint("Excitatory rate : %g Hz" % E_rate)
nprint("Inhibitory rate : %g Hz" % I_rate)
nprint("Build time : %g s" % buildCPUTime)
nprint("Simulation time : %g s" % simCPUTime)
# === Clean up and quit ========================================================
end()
if simulator_name == 'neuroml' and jnml_simulator:
from pyneuroml import pynml
lems_file = 'LEMS_Sim_PyNN_NeuroML2_Export.xml'
print('Going to run generated LEMS file: %s on simulator: %s' %
(lems_file, jnml_simulator))
if jnml_simulator == 'jNeuroML':
results, events = pynml.run_lems_with_jneuroml(
lems_file,
nogui=True,
load_saved_data=True,
reload_events=True)
elif jnml_simulator == 'jNeuroML_NEURON':
results, events = pynml.run_lems_with_jneuroml_neuron(
lems_file,
nogui=True,
load_saved_data=True,
reload_events=True)
spike_data['senders'] = []
spike_data['times'] = []
for k in events.keys():
values = k.split('/')
index = int(
values[1]) if values[0] == 'E_net' else NE + int(values[1])
n = len(events[k])
print(
"Loading spikes for %s (index %i): [%s, ..., %s (n=%s)] sec" %
(k, index, events[k][0] if n > 0 else '-',
events[k][-1] if n > 0 else '-', n))
for t in events[k]:
spike_data['senders'].append(index)
spike_data['times'].append(t * 1000)
#print spike_data
return spike_data
def runBrunelNetwork(g=5.,
eta=2.,
dt = 0.1,
simtime = 1000.0,
delay = 1.5,
epsilon = 0.1,
order = 2500,
N_rec = 50,
N_rec_v = 2,
save=False,
simulator_name='nest',
jnml_simulator=None,
extra = {}):
exec("from pyNN.%s import *" % simulator_name) in globals()
timer = Timer()
# === Define parameters ========================================================
downscale = 1 # scale number of neurons down by this factor
# scale synaptic weights up by this factor to
# obtain similar dynamics independent of size
order = order # determines size of network:
# 4*order excitatory neurons
# 1*order inhibitory neurons
Nrec = N_rec # number of neurons to record from, per population
epsilon = epsilon # connectivity: proportion of neurons each neuron projects to
# Parameters determining model dynamics, cf Brunel (2000), Figs 7, 8 and Table 1
# here: Case C, asynchronous irregular firing, ~35 Hz
eta = eta # rel rate of external input
g = g # rel strength of inhibitory synapses
J = 0.1 # synaptic weight [mV]
delay = delay # synaptic delay, all connections [ms]
# single neuron parameters
tauMem = 20.0 # neuron membrane time constant [ms]
tauSyn = 0.1 # synaptic time constant [ms]
tauRef = 2.0 # refractory time [ms]
U0 = 0.0 # resting potential [mV]
theta = 20.0 # threshold
# simulation-related parameters
simtime = simtime # simulation time [ms]
dt = dt # simulation step length [ms]
# seed for random generator used when building connections
connectseed = 12345789
use_RandomArray = True # use Python rng rather than NEST rng
# seed for random generator(s) used during simulation
kernelseed = 43210987
# === Calculate derived parameters =============================================
# scaling: compute effective order and synaptic strength
order_eff = int(float(order)/downscale)
J_eff = J*downscale
# compute neuron numbers
NE = int(4*order_eff) # number of excitatory neurons
NI = int(1*order_eff) # number of inhibitory neurons
N = NI + NE # total number of neurons
# compute synapse numbers
CE = int(epsilon*NE) # number of excitatory synapses on neuron
CI = int(epsilon*NI) # number of inhibitory synapses on neuron
C = CE + CI # total number of internal synapses per n.
Cext = CE # number of external synapses on neuron
# synaptic weights, scaled for alpha functions, such that
# for constant membrane potential, charge J would be deposited
fudge = 0.00041363506632638 # ensures dV = J at V=0
# excitatory weight: JE = J_eff / tauSyn * fudge
JE = (J_eff/tauSyn)*fudge
# inhibitory weight: JI = - g * JE
JI = -g*JE
# threshold, external, and Poisson generator rates:
nu_thresh = theta/(J_eff*CE*tauMem)
nu_ext = eta*nu_thresh # external rate per synapse
p_rate = 1000*nu_ext*Cext # external input rate per neuron (Hz)
# number of synapses---just so we know
Nsyn = (C+1)*N + 2*Nrec # number of neurons * (internal synapses + 1 synapse from PoissonGenerator) + 2synapses" to spike detectors
print('Created Brunel network with parameters')
for p in ['NE','NI','downscale','order','N_rec','epsilon','eta','g','J','delay','tauMem','tauSyn','tauRef','U0','theta','simtime','dt', \
'order_eff','J_eff','N','CE','CI','C','Cext','fudge','JE','JI','nu_thresh','nu_ext','p_rate','Nsyn']:
print(' %s%s= %s'%(p, ' '*(12-len(p)), eval(p)))
# put cell parameters into a dict
cell_params = {'tau_m' : tauMem,
'tau_syn_E' : tauSyn,
'tau_syn_I' : tauSyn,
'tau_refrac' : tauRef,
'v_rest' : U0,
'v_reset' : U0,
'v_thresh' : theta,
'cm' : 0.001} # (nF)
# === Build the network ========================================================
# clear all existing network elements and set resolution and limits on delays.
# For NEST, limits must be set BEFORE connecting any elements
#extra = {'threads' : 2}
rank = setup(timestep=dt, max_delay=delay, **extra)
print("rank =", rank)
np = num_processes()
print("np =", np)
import socket
host_name = socket.gethostname()
print("Host #%d is on %s" % (rank+1, host_name))
if 'threads' in extra:
print("%d Initialising the simulator with %d threads..." % (rank, extra['threads']))
else:
print("%d Initialising the simulator with single thread..." % rank)
# Small function to display information only on node 1
def nprint(s):
if rank == 0:
print(s)
timer.start() # start timer on construction
print("%d Setting up random number generator" % rank)
rng = NumpyRNG(kernelseed, parallel_safe=True)
print("%d Creating excitatory population with %d neurons." % (rank, NE))
celltype = IF_curr_alpha(**cell_params)
celltype.default_initial_values['v'] = U0 # Setting default init v, useful for NML2 export
E_net = Population(NE, celltype, label="E_net")
print("%d Creating inhibitory population with %d neurons." % (rank, NI))
I_net = Population(NI, celltype, label="I_net")
print("%d Initialising membrane potential to random values between %g mV and %g mV." % (rank, U0, theta))
uniformDistr = RandomDistribution('uniform', low=U0, high=theta, rng=rng)
E_net.initialize(v=uniformDistr)
I_net.initialize(v=uniformDistr)
print("%d Creating excitatory Poisson generator with rate %g spikes/s." % (rank, p_rate))
source_type = SpikeSourcePoisson(rate=p_rate)
expoisson = Population(NE, source_type, label="expoisson")
print("%d Creating inhibitory Poisson generator with the same rate." % rank)
inpoisson = Population(NI, source_type, label="inpoisson")
# Record spikes
print("%d Setting up recording in excitatory population." % rank)
E_net.record('spikes')
if N_rec_v>0:
E_net[0:min(NE,N_rec_v)].record('v')
print("%d Setting up recording in inhibitory population." % rank)
I_net.record('spikes')
if N_rec_v>0:
I_net[0:min(NI,N_rec_v)].record('v')
progress_bar = ProgressBar(width=20)
connector = FixedProbabilityConnector(epsilon, rng=rng, callback=progress_bar)
E_syn = StaticSynapse(weight=JE, delay=delay)
I_syn = StaticSynapse(weight=JI, delay=delay)
ext_Connector = OneToOneConnector(callback=progress_bar)
ext_syn = StaticSynapse(weight=JE, delay=dt)
print("%d Connecting excitatory population with connection probability %g, weight %g nA and delay %g ms." % (rank, epsilon, JE, delay))
E_to_E = Projection(E_net, E_net, connector, E_syn, receptor_type="excitatory")
print("E --> E\t\t", len(E_to_E), "connections")
I_to_E = Projection(I_net, E_net, connector, I_syn, receptor_type="inhibitory")
print("I --> E\t\t", len(I_to_E), "connections")
input_to_E = Projection(expoisson, E_net, ext_Connector, ext_syn, receptor_type="excitatory")
print("input --> E\t", len(input_to_E), "connections")
print("%d Connecting inhibitory population with connection probability %g, weight %g nA and delay %g ms." % (rank, epsilon, JI, delay))
E_to_I = Projection(E_net, I_net, connector, E_syn, receptor_type="excitatory")
print("E --> I\t\t", len(E_to_I), "connections")
I_to_I = Projection(I_net, I_net, connector, I_syn, receptor_type="inhibitory")
print("I --> I\t\t", len(I_to_I), "connections")
input_to_I = Projection(inpoisson, I_net, ext_Connector, ext_syn, receptor_type="excitatory")
print("input --> I\t", len(input_to_I), "connections")
# read out time used for building
buildCPUTime = timer.elapsedTime()
# === Run simulation ===========================================================
# run, measure computer time
timer.start() # start timer on construction
print("%d Running simulation for %g ms (dt=%sms)." % (rank, simtime, dt))
run(simtime)
print("Done")
simCPUTime = timer.elapsedTime()
# write data to file
#print("%d Writing data to file." % rank)
#(E_net + I_net).write_data("Results/brunel_np%d_%s.pkl" % (np, simulator_name))
if save and not simulator_name=='neuroml':
for pop in [E_net , I_net]:
io = PyNNTextIO(filename="brunel-PyNN-%s-%s-%i.gdf"%(simulator_name, pop.label, rank))
spikes = pop.get_data('spikes', gather=False)
for segment in spikes.segments:
io.write_segment(segment)
io = PyNNTextIO(filename="brunel-PyNN-%s-%s-%i.dat"%(simulator_name, pop.label, rank))
vs = pop.get_data('v', gather=False)
for segment in vs.segments:
io.write_segment(segment)
spike_data = {}
spike_data['senders'] = []
spike_data['times'] = []
index_offset = 1
for pop in [E_net , I_net]:
if rank == 0:
spikes = pop.get_data('spikes', gather=False)
#print(spikes.segments[0].all_data)
num_rec = len(spikes.segments[0].spiketrains)
print("Extracting spike info (%i) for %i cells in %s"%(num_rec,pop.size,pop.label))
#assert(num_rec==len(spikes.segments[0].spiketrains))
for i in range(num_rec):
ss = spikes.segments[0].spiketrains[i]
for s in ss:
index = i+index_offset
#print("Adding spike at %s in %s[%i] (cell %i)"%(s,pop.label,i,index))
spike_data['senders'].append(index)
spike_data['times'].append(s)
index_offset+=pop.size
#from IPython.core.debugger import Tracer
#Tracer()()
E_rate = E_net.mean_spike_count()*1000.0/simtime
I_rate = I_net.mean_spike_count()*1000.0/simtime
# write a short report
nprint("\n--- Brunel Network Simulation ---")
nprint("Nodes : %d" % np)
nprint("Number of Neurons : %d" % N)
nprint("Number of Synapses : %d" % Nsyn)
nprint("Input firing rate : %g" % p_rate)
nprint("Excitatory weight : %g" % JE)
nprint("Inhibitory weight : %g" % JI)
nprint("Excitatory rate : %g Hz" % E_rate)
nprint("Inhibitory rate : %g Hz" % I_rate)
nprint("Build time : %g s" % buildCPUTime)
nprint("Simulation time : %g s" % simCPUTime)
# === Clean up and quit ========================================================
end()
if simulator_name=='neuroml' and jnml_simulator:
from pyneuroml import pynml
lems_file = 'LEMS_Sim_PyNN_NeuroML2_Export.xml'
print('Going to run generated LEMS file: %s on simulator: %s'%(lems_file,jnml_simulator))
if jnml_simulator=='jNeuroML':
results, events = pynml.run_lems_with_jneuroml(lems_file, nogui=True, load_saved_data=True, reload_events=True)
elif jnml_simulator=='jNeuroML_NEURON':
results, events = pynml.run_lems_with_jneuroml_neuron(lems_file, nogui=True, load_saved_data=True, reload_events=True)
spike_data['senders'] = []
spike_data['times'] = []
for k in events.keys():
values = k.split('/')
index = int(values[1]) if values[0]=='E_net' else NE+int(values[1])
n = len(events[k])
print("Loading spikes for %s (index %i): [%s, ..., %s (n=%s)] sec"%(k,index,events[k][0] if n>0 else '-',events[k][-1] if n>0 else '-',n))
for t in events[k]:
spike_data['senders'].append(index)
spike_data['times'].append(t*1000)
#print spike_data
return spike_data
def test(cases=[1]):
sp = Space(periodic_boundaries=((0, 1), (0, 1), None), axes="xy")
safe = False
callback = progress_bar.set_level
autapse = False
parallel_safe = True
render = True
to_file = True
for case in cases:
# w = RandomDistribution('uniform', (0,1))
w = "0.2 + d/0.2"
# w = 0.1
# w = lambda dist : 0.1 + numpy.random.rand(len(dist[0]))*sqrt(dist[0]**2 + dist[1]**2)
# delay = RandomDistribution('uniform', (0.1,5.))
# delay = "0.1 + d/0.2"
delay = 0.1
# delay = lambda distances : 0.1 + numpy.random.rand(len(distances))*distances
d_expression = "exp(-d**2/(2*0.1**2))"
# d_expression = "(d[0] < 0.05) & (d[1] < 0.05)"
# d_expression = "(d[0]/(0.05**2) + d[1]/(0.1**2)) < 100*numpy.random.rand()"
timer = Timer()
np = num_processes()
timer.start()
synapse = StaticSynapse(weight=w, delay=delay)
rng = NumpyRNG(23434, parallel_safe=parallel_safe)
if case is 1:
conn = DistanceDependentProbabilityConnector(
d_expression, safe=safe, callback=callback, allow_self_connections=autapse, rng=rng
)
fig_name = "DistanceDependent_%s_np_%d.png" % (simulator_name, np)
elif case is 2:
conn = FixedProbabilityConnector(
0.02, safe=safe, callback=callback, allow_self_connections=autapse, rng=rng
)
fig_name = "FixedProbability_%s_np_%d.png" % (simulator_name, np)
elif case is 3:
conn = AllToAllConnector(delays=delay, safe=safe, callback=callback, allow_self_connections=autapse)
fig_name = "AllToAll_%s_np_%d.png" % (simulator_name, np)
elif case is 4:
conn = FixedNumberPostConnector(50, safe=safe, callback=callback, allow_self_connections=autapse, rng=rng)
fig_name = "FixedNumberPost_%s_np_%d.png" % (simulator_name, np)
elif case is 5:
conn = FixedNumberPreConnector(50, safe=safe, callback=callback, allow_self_connections=autapse, rng=rng)
fig_name = "FixedNumberPre_%s_np_%d.png" % (simulator_name, np)
elif case is 6:
conn = OneToOneConnector(safe=safe, callback=callback)
fig_name = "OneToOne_%s_np_%d.png" % (simulator_name, np)
elif case is 7:
conn = FromFileConnector(
files.NumpyBinaryFile("Results/connections.dat", mode="r"),
safe=safe,
callback=callback,
distributed=True,
)
fig_name = "FromFile_%s_np_%d.png" % (simulator_name, np)
elif case is 8:
conn = SmallWorldConnector(
degree=0.1, rewiring=0.0, safe=safe, callback=callback, allow_self_connections=autapse
)
fig_name = "SmallWorld_%s_np_%d.png" % (simulator_name, np)
print "Generating data for %s" % fig_name
prj = Projection(x, x, conn, synapse, space=sp)
mytime = timer.diff()
print "Time to connect the cell population:", mytime, "s"
print "Nb synapses built", prj.size()
if to_file:
if not (os.path.isdir("Results")):
os.mkdir("Results")
print "Saving Connections...."
prj.save("all", files.NumpyBinaryFile("Results/connections.dat", mode="w"), gather=True)
mytime = timer.diff()
print "Time to save the projection:", mytime, "s"
if render and to_file:
print "Saving Positions...."
x.save_positions("Results/positions.dat")
end()
if node_id == 0 and render and to_file:
figure()
print "Generating and saving %s" % fig_name
positions = numpy.loadtxt("Results/positions.dat")
positions[:, 0] -= positions[:, 0].min()
connections = files.NumpyBinaryFile("Results/connections.dat", mode="r").read()
print positions.shape, connections.shape
connections[:, 0] -= connections[:, 0].min()
connections[:, 1] -= connections[:, 1].min()
idx_pre = connections[:, 0].astype(int)
idx_post = connections[:, 1].astype(int)
d = distances(positions[idx_pre, 1:3], positions[idx_post, 1:3], 1)
subplot(231)
title("Cells positions")
plot(positions[:, 1], positions[:, 2], ".")
subplot(232)
title("Weights distribution")
hist(connections[:, 2], 50)
subplot(233)
title("Delay distribution")
hist(connections[:, 3], 50)
subplot(234)
numpy.random.seed(74562)
ids = numpy.random.permutation(positions[:, 0])[0:6]
colors = ["k", "r", "b", "g", "c", "y"]
for count, cell in enumerate(ids):
draw_rf(cell, positions, connections, colors[count])
subplot(235)
plot(d, connections[:, 2], ".")
subplot(236)
plot(d, connections[:, 3], ".")
savefig("Results/" + fig_name)
# os.remove('Results/connections.dat')
# os.remove('Results/positions.dat')
show()
host_name = socket.gethostname()
print "Host #%d is on %s" % (node_id+1, host_name)
print "%s Initialising the simulator with %d thread(s)..." % (node_id, extra['threads'])
cell_params = {
'tau_m' : tau_m, 'tau_syn_E' : tau_exc, 'tau_syn_I' : tau_inh,
'v_rest' : E_leak, 'v_reset' : v_reset, 'v_thresh' : v_thresh,
'cm' : cm, 'tau_refrac' : t_refrac}
if (benchmark == "COBA"):
cell_params['e_rev_E'] = Erev_exc
cell_params['e_rev_I'] = Erev_inh
timer.start()
print "%s Creating cell populations..." % node_id
all_cells = Population(n_exc+n_inh, celltype(**cell_params), label="All Cells")
exc_cells = all_cells[:n_exc]; exc_cells.label = "Excitatory cells"
inh_cells = all_cells[n_exc:]; inh_cells.label = "Inhibitory cells"
if benchmark == "COBA":
ext_stim = Population(20, SpikeSourcePoisson(rate=rate, duration=stim_dur), label="expoisson")
rconn = 0.01
ext_conn = FixedProbabilityConnector(rconn)
ext_syn = StaticSynapse(weight=0.1)
print "%s Initialising membrane potential to random values..." % node_id
rng = NumpyRNG(seed=rngseed, parallel_safe=parallel_safe)
uniformDistr = RandomDistribution('uniform', [v_reset,v_thresh], rng=rng)
all_cells.initialize(v=uniformDistr)
class NetworkModel(object):
def __init__(self, params, comm):
self.params = params
self.debug_connectivity = True
self.comm = comm
if self.comm != None:
self.pc_id, self.n_proc = self.comm.rank, self.comm.size
print "USE_MPI: yes", "\tpc_id, n_proc:", self.pc_id, self.n_proc
else:
self.pc_id, self.n_proc = 0, 1
print "MPI not used"
np.random.seed(params["np_random_seed"] + self.pc_id)
if self.params["with_short_term_depression"]:
self.short_term_depression = SynapseDynamics(
fast=TsodyksMarkramMechanism(U=0.95, tau_rec=10.0, tau_facil=0.0)
)
def import_pynn(self):
"""
This function needs only be called when this class is used in another script as imported module
"""
import pyNN
exec ("from pyNN.%s import *" % self.params["simulator"])
print "import pyNN\npyNN.version: ", pyNN.__version__
def setup(self, load_tuning_prop=False, times={}):
self.projections = {}
self.projections["ee"] = []
self.projections["ei"] = []
self.projections["ie"] = []
self.projections["ii"] = []
if not load_tuning_prop:
self.tuning_prop_exc = utils.set_tuning_prop(
self.params, mode="hexgrid", cell_type="exc"
) # set the tuning properties of exc cells: space (x, y) and velocity (u, v)
self.tuning_prop_inh = utils.set_tuning_prop(
self.params, mode="hexgrid", cell_type="inh"
) # set the tuning properties of exc cells: space (x, y) and velocity (u, v)
else:
self.tuning_prop_exc = np.loadtxt(self.params["tuning_prop_means_fn"])
self.tuning_prop_inh = np.loadtxt(self.params["tuning_prop_inh_fn"])
indices, distances = utils.sort_gids_by_distance_to_stimulus(
self.tuning_prop_exc, self.params["motion_params"], self.params
) # cells in indices should have the highest response to the stimulus
if self.pc_id == 0:
print "Saving tuning_prop to file:", self.params["tuning_prop_means_fn"]
np.savetxt(self.params["tuning_prop_means_fn"], self.tuning_prop_exc)
print "Saving tuning_prop to file:", self.params["tuning_prop_inh_fn"]
np.savetxt(self.params["tuning_prop_inh_fn"], self.tuning_prop_inh)
print "Saving gids to record to: ", self.params["gids_to_record_fn"]
np.savetxt(self.params["gids_to_record_fn"], indices[: self.params["n_gids_to_record"]], fmt="%d")
# np.savetxt(params['gids_to_record_fn'], indices[:params['n_gids_to_record']], fmt='%d')
if self.comm != None:
self.comm.Barrier()
from pyNN.utility import Timer
self.timer = Timer()
self.timer.start()
self.times = times
self.times["t_all"] = 0
# # # # # # # # # # # #
# S E T U P #
# # # # # # # # # # # #
(delay_min, delay_max) = self.params["delay_range"]
setup(timestep=0.1, min_delay=delay_min, max_delay=delay_max, rng_seeds_seed=self.params["seed"])
rng_v = NumpyRNG(
seed=sim_cnt * 3147 + self.params["seed"], parallel_safe=True
) # if True, slower but does not depend on number of nodes
self.rng_conn = NumpyRNG(
seed=self.params["seed"], parallel_safe=True
) # if True, slower but does not depend on number of nodes
# # # # # # # # # # # # # # # # # # # # # # # # #
# R A N D O M D I S T R I B U T I O N S #
# # # # # # # # # # # # # # # # # # # # # # # # #
self.v_init_dist = RandomDistribution(
"normal",
(self.params["v_init"], self.params["v_init_sigma"]),
rng=rng_v,
constrain="redraw",
boundaries=(-80, -60),
)
self.times["t_setup"] = self.timer.diff()
self.times["t_calc_conns"] = 0
if self.comm != None:
self.comm.Barrier()
self.torus = space.Space(
axes="xy", periodic_boundaries=((0.0, self.params["torus_width"]), (0.0, self.params["torus_height"]))
)
def create_neurons_with_limited_tuning_properties(self):
n_exc = self.tuning_prop_exc[:, 0].size
n_inh = 0
if self.params["neuron_model"] == "IF_cond_exp":
self.exc_pop = Population(n_exc, IF_cond_exp, self.params["cell_params_exc"], label="exc_cells")
self.inh_pop = Population(
self.params["n_inh"], IF_cond_exp, self.params["cell_params_inh"], label="inh_pop"
)
elif self.params["neuron_model"] == "IF_cond_alpha":
self.exc_pop = Population(n_exc, IF_cond_alpha, self.params["cell_params_exc"], label="exc_cells")
self.inh_pop = Population(
self.params["n_inh"], IF_cond_alpha, self.params["cell_params_inh"], label="inh_pop"
)
elif self.params["neuron_model"] == "EIF_cond_exp_isfa_ista":
self.exc_pop = Population(n_exc, EIF_cond_exp_isfa_ista, self.params["cell_params_exc"], label="exc_cells")
self.inh_pop = Population(
self.params["n_inh"], EIF_cond_exp_isfa_ista, self.params["cell_params_inh"], label="inh_pop"
)
else:
print "\n\nUnknown neuron model:\n\t", self.params["neuron_model"]
# set cell positions, required for isotropic connections
cell_pos_exc = np.zeros((3, self.params["n_exc"]))
cell_pos_exc[0, :] = self.tuning_prop_exc[:, 0]
cell_pos_exc[1, :] = self.tuning_prop_exc[:, 1]
self.exc_pop.positions = cell_pos_exc
cell_pos_inh = np.zeros((3, self.params["n_inh"]))
cell_pos_inh[0, :] = self.tuning_prop_inh[:, 0]
cell_pos_inh[1, :] = self.tuning_prop_inh[:, 1]
self.inh_pop.positions = cell_pos_inh
self.local_idx_exc = get_local_indices(self.exc_pop, offset=0)
if not input_created:
self.spike_times_container = [[] for i in xrange(len(self.local_idx_exc))]
self.spike_times_container = [[] for i in xrange(len(self.local_idx_exc))]
print "Debug, pc_id %d has local %d exc indices:" % (self.pc_id, len(self.local_idx_exc)), self.local_idx_exc
self.exc_pop.initialize("v", self.v_init_dist)
self.local_idx_inh = get_local_indices(self.inh_pop, offset=self.params["n_exc"])
print "Debug, pc_id %d has local %d inh indices:" % (self.pc_id, len(self.local_idx_inh)), self.local_idx_inh
self.inh_pop.initialize("v", self.v_init_dist)
self.times["t_create"] = self.timer.diff()
def create(self, input_created=False):
"""
# # # # # # # # # # # #
# C R E A T E #
# # # # # # # # # # # #
"""
if self.params["neuron_model"] == "IF_cond_exp":
self.exc_pop = Population(
self.params["n_exc"], IF_cond_exp, self.params["cell_params_exc"], label="exc_cells"
)
self.inh_pop = Population(
self.params["n_inh"], IF_cond_exp, self.params["cell_params_inh"], label="inh_pop"
)
elif self.params["neuron_model"] == "IF_cond_alpha":
self.exc_pop = Population(
self.params["n_exc"], IF_cond_alpha, self.params["cell_params_exc"], label="exc_cells"
)
self.inh_pop = Population(
self.params["n_inh"], IF_cond_alpha, self.params["cell_params_inh"], label="inh_pop"
)
elif self.params["neuron_model"] == "EIF_cond_exp_isfa_ista":
self.exc_pop = Population(
self.params["n_exc"], EIF_cond_exp_isfa_ista, self.params["cell_params_exc"], label="exc_cells"
)
self.inh_pop = Population(
self.params["n_inh"], EIF_cond_exp_isfa_ista, self.params["cell_params_inh"], label="inh_pop"
)
else:
print "\n\nUnknown neuron model:\n\t", self.params["neuron_model"]
self.local_idx_exc = get_local_indices(self.exc_pop, offset=0)
print "Debug, pc_id %d has local %d exc indices:" % (self.pc_id, len(self.local_idx_exc)), self.local_idx_exc
cell_pos_exc = np.zeros((3, self.params["n_exc"]))
cell_pos_exc[0, :] = self.tuning_prop_exc[:, 0]
cell_pos_exc[1, :] = self.tuning_prop_exc[:, 1]
self.exc_pop.positions = cell_pos_exc
cell_pos_inh = np.zeros((3, self.params["n_inh"]))
cell_pos_inh[0, :] = self.tuning_prop_inh[:, 0]
cell_pos_inh[1, :] = self.tuning_prop_inh[:, 1]
self.inh_pop.positions = cell_pos_inh
if not input_created:
self.spike_times_container = [[] for i in xrange(len(self.local_idx_exc))]
self.exc_pop.initialize("v", self.v_init_dist)
self.local_idx_inh = get_local_indices(self.inh_pop, offset=self.params["n_exc"])
print "Debug, pc_id %d has local %d inh indices:" % (self.pc_id, len(self.local_idx_inh)), self.local_idx_inh
self.inh_pop.initialize("v", self.v_init_dist)
self.times["t_create"] = self.timer.diff()
def connect(self):
if self.params["n_exc"] > 5000:
save_output = False
else:
save_output = True
self.connect_input_to_exc()
self.connect_populations("ee")
self.connect_populations("ei")
self.connect_populations("ie")
self.connect_populations("ii")
self.connect_noise()
self.times["t_calc_conns"] = self.timer.diff()
if self.comm != None:
self.comm.Barrier()
def create_input(self, load_files=False, save_output=False):
if load_files:
if self.pc_id == 0:
print "Loading input spiketrains..."
for i_, tgt in enumerate(self.local_idx_exc):
try:
fn = self.params["input_st_fn_base"] + str(tgt) + ".npy"
spike_times = np.load(fn)
except: # this cell does not get any input
print "Missing file: ", fn
spike_times = []
self.spike_times_container[i_] = spike_times
else:
if self.pc_id == 0:
print "Computing input spiketrains..."
nprnd.seed(self.params["input_spikes_seed"])
dt = self.params["dt_rate"] # [ms] time step for the non-homogenous Poisson process
time = np.arange(0, self.params["t_sim"], dt)
blank_idx = np.arange(
1.0 / dt * self.params["t_before_blank"],
1.0 / dt * (self.params["t_before_blank"] + self.params["t_blank"]),
)
before_stim_idx = np.arange(0, self.params["t_start"] * 1.0 / dt)
blank_idx = np.concatenate((blank_idx, before_stim_idx))
my_units = self.local_idx_exc
n_cells = len(my_units)
L_input = np.zeros((n_cells, time.shape[0]))
# get the input signal
print "Calculating input signal"
for i_time, time_ in enumerate(time):
L_input[:, i_time] = utils.get_input(
self.tuning_prop_exc[my_units, :], self.params, time_ / self.params["t_stimulus"]
)
L_input[:, i_time] *= self.params["f_max_stim"]
if i_time % 500 == 0:
print "t:", time_
# print 'L_input[:, %d].max()', L_input[:, i_time].max()
# blanking
for i_time in blank_idx:
# L_input[:, i_time] = 0.
L_input[:, i_time] = np.random.permutation(L_input[:, i_time])
# create the spike trains
print "Creating input spiketrains for unit"
for i_, unit in enumerate(my_units):
print unit,
rate_of_t = np.array(L_input[i_, :])
# each cell will get its own spike train stored in the following file + cell gid
n_steps = rate_of_t.size
spike_times = []
for i in xrange(n_steps):
r = nprnd.rand()
if r <= ((rate_of_t[i] / 1000.0) * dt): # rate is given in Hz -> 1/1000.
spike_times.append(i * dt)
self.spike_times_container[i_] = spike_times
if save_output:
output_fn = self.params["input_rate_fn_base"] + str(unit) + ".npy"
np.save(output_fn, rate_of_t)
output_fn = self.params["input_st_fn_base"] + str(unit) + ".npy"
np.save(output_fn, np.array(spike_times))
self.times["create_input"] = self.timer.diff()
return self.spike_times_container
def connect_input_to_exc(self):
"""
# # # # # # # # # # # # # # # # # # # # # #
# C O N N E C T I N P U T - E X C #
# # # # # # # # # # # # # # # # # # # # # #
"""
if self.pc_id == 0:
print "Connecting input spiketrains..."
# self.stimulus = Population(len(self.local_idx_exc), SpikeSourceArray)
# self.exc_pop = Population(n_exc, IF_cond_exp, self.params['cell_params_exc'], label='exc_cells')
# prj = Projection(src_pop, tgt_pop, connector, target=syn_type)
# self.projections[conn_type].append(prj)
# self.projections['stim'] = []
# self.stimuli = []
# self.pop_views = []
# conn = OneToOneConnector(weights=self.params['w_input_exc'])
for i_, unit in enumerate(self.local_idx_exc):
spike_times = self.spike_times_container[i_]
# ssa = create(SpikeSourceArray, {'spike_times': spike_times})
ssa = Population(1, SpikeSourceArray, {"spike_times": spike_times})
# ssa.set({'spike_times' : spike_times})
# self.stimuli.append(ssa)
# if self.params['with_short_term_depression']:
# connect(ssa, self.exc_pop[unit], self.params['w_input_exc'], synapse_type='excitatory', synapse_dynamics=self.short_term_depression)
# selector = np.zeros(self.params['n_exc'], dtype=np.bool)
# selector[unit] = True
# print 'debug unit', unit, type(unit)
# w[i_] = 1.#self.params['w_input_exc']
# tgt = PopulationView(self.exc_pop, np.array([unit]))
# self.pop_views.append(tgt)
# prj = Projection(ssa, tgt, conn, target='excitatory', synapse_dynamics=self.short_term_depression)
# prj = Projection(self.stimuli[-1], self.pop_views[-1], conn, target='excitatory', synapse_dynamics=self.short_term_depression)
# self.projections['stim'].append(prj)
# else:
connect(ssa, self.exc_pop[unit], self.params["w_input_exc"], synapse_type="excitatory")
self.times["connect_input"] = self.timer.diff()
def resolve_src_tgt(self, conn_type):
"""
Deliver the correct source and target parameters based on conn_type
"""
if conn_type == "ee":
n_src, n_tgt = self.params["n_exc"], self.params["n_exc"]
src_pop, tgt_pop = self.exc_pop, self.exc_pop
tgt_cells = self.local_idx_exc
tp_src = self.tuning_prop_exc
tp_tgt = self.tuning_prop_exc
syn_type = "excitatory"
elif conn_type == "ei":
n_src, n_tgt = self.params["n_exc"], self.params["n_inh"]
src_pop, tgt_pop = self.exc_pop, self.inh_pop
tgt_cells = self.local_idx_inh
tp_src = self.tuning_prop_exc
tp_tgt = self.tuning_prop_inh
syn_type = "excitatory"
elif conn_type == "ie":
n_src, n_tgt = self.params["n_inh"], self.params["n_exc"]
src_pop, tgt_pop = self.inh_pop, self.exc_pop
tgt_cells = self.local_idx_exc
tp_src = self.tuning_prop_inh
tp_tgt = self.tuning_prop_exc
syn_type = "inhibitory"
elif conn_type == "ii":
n_src, n_tgt = self.params["n_inh"], self.params["n_inh"]
src_pop, tgt_pop = self.inh_pop, self.inh_pop
tgt_cells = self.local_idx_inh
tp_src = self.tuning_prop_inh
tp_tgt = self.tuning_prop_inh
syn_type = "inhibitory"
return (n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type)
def connect_anisotropic(self, conn_type):
"""
conn_type = ['ee', 'ei', 'ie', 'ii']
"""
if self.pc_id == 0:
print "Connect anisotropic %s - %s" % (conn_type[0].capitalize(), conn_type[1].capitalize())
(n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type) = self.resolve_src_tgt(conn_type)
if self.debug_connectivity:
conn_list_fn = self.params["conn_list_%s_fn_base" % conn_type] + "%d.dat" % (self.pc_id)
n_src_cells_per_neuron = int(round(self.params["p_%s" % conn_type] * n_src))
(delay_min, delay_max) = self.params["delay_range"]
local_connlist = np.zeros((n_src_cells_per_neuron * len(tgt_cells), 4))
for i_, tgt in enumerate(tgt_cells):
if self.params["direction_based_conn"]:
p, latency = CC.get_p_conn_vec_xpred(
tp_src,
tp_tgt[tgt, :],
self.params["w_sigma_x"],
self.params["w_sigma_v"],
self.params["connectivity_radius"],
)
else:
p, latency = CC.get_p_conn_vec(
tp_src,
tp_tgt[tgt, :],
self.params["w_sigma_x"],
self.params["w_sigma_v"],
self.params["connectivity_radius"],
self.params["maximal_latency"],
)
if conn_type[0] == conn_type[1]:
p[tgt], latency[tgt] = 0.0, 0.0
# random delays? --> np.permutate(latency) or latency[sources] * self.params['delay_scale'] * np.rand
sorted_indices = np.argsort(p)
if conn_type[0] == "e":
sources = sorted_indices[-n_src_cells_per_neuron:]
else: # source = inhibitory
if conn_type[0] == conn_type[1]:
sources = sorted_indices[
1 : n_src_cells_per_neuron + 1
] # shift indices to avoid self-connection, because p_ii = .0
else:
sources = sorted_indices[:n_src_cells_per_neuron]
# eta = 1e-9
eta = 0
w = (self.params["w_tgt_in_per_cell_%s" % conn_type] / (p[sources].sum() + eta)) * p[sources]
# print 'debug p', i_, tgt, p[sources]
# print 'debug sources', i_, tgt, sources
# print 'debug w', i_, tgt, w
delays = np.minimum(
np.maximum(latency[sources] * self.params["delay_scale"], delay_min), delay_max
) # map the delay into the valid range
conn_list = np.array((sources, tgt * np.ones(n_src_cells_per_neuron), w, delays))
local_connlist[i_ * n_src_cells_per_neuron : (i_ + 1) * n_src_cells_per_neuron, :] = conn_list.transpose()
connector = FromListConnector(conn_list.transpose())
if self.params["with_short_term_depression"]:
prj = Projection(
src_pop, tgt_pop, connector, target=syn_type, synapse_dynamics=self.short_term_depression
)
else:
prj = Projection(src_pop, tgt_pop, connector, target=syn_type)
self.projections[conn_type].append(prj)
if self.debug_connectivity:
if self.pc_id == 0:
print "DEBUG writing to file:", conn_list_fn
np.savetxt(conn_list_fn, local_connlist, fmt="%d\t%d\t%.4e\t%.4e")
def connect_ee_random(self):
"""
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
# C O N N E C T E X C - E X C R A N D O M #
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
"""
if self.pc_id == 0:
print "Drawing random connections"
sigma_x, sigma_v = self.params["w_sigma_x"], self.params["w_sigma_v"]
(delay_min, delay_max) = self.params["delay_range"]
if self.debug_connectivity:
conn_list_fn = self.params["conn_list_ee_fn_base"] + "%d.dat" % (self.pc_id)
conn_file = open(conn_list_fn, "w")
output = ""
for tgt in self.local_idx_exc:
p = np.zeros(self.params["n_exc"], dtype="float32")
latency = np.zeros(self.params["n_exc"], dtype="float32")
for src in xrange(self.params["n_exc"]):
if src != tgt:
p[src], latency[src] = CC.get_p_conn(
self.tuning_prop_exc[src, :],
self.tuning_prop_exc[tgt, :],
sigma_x,
sigma_v,
params["connectivity_radius"],
) # print 'debug pc_id src tgt ', self.pc_id, src, tgt#, int(ID) < self.params['n_exc']
sources = random.sample(xrange(self.params["n_exc"]), int(self.params["n_src_cells_per_neuron"]))
idx = p[sources] > 0
non_zero_idx = np.nonzero(idx)[0]
p_ = p[sources][non_zero_idx]
l_ = latency[sources][non_zero_idx] * self.params["delay_scale"]
w = utils.linear_transformation(p_, self.params["w_min"], self.params["w_max"])
for i in xrange(len(p_)):
# w[i] = max(self.params['w_min'], min(w[i], self.params['w_max']))
delay = min(max(l_[i], delay_min), delay_max) # map the delay into the valid range
connect(self.exc_pop[non_zero_idx[i]], self.exc_pop[tgt], w[i], delay=delay, synapse_type="excitatory")
if self.debug_connectivity:
output += "%d\t%d\t%.2e\t%.2e\n" % (
non_zero_idx[i],
tgt,
w[i],
delay,
) # output += '%d\t%d\t%.2e\t%.2e\t%.2e\n' % (sources[i], tgt, w[i], latency[sources[i]], p[sources[i]])
if self.debug_connectivity:
if self.pc_id == 0:
print "DEBUG writing to file:", conn_list_fn
conn_file.write(output)
conn_file.close()
def connect_isotropic(self, conn_type="ee"):
"""
conn_type must be 'ee', 'ei', 'ie' or 'ii'
Connect cells in a distant dependent manner:
p_ij = exp(- d_ij / (2 * w_sigma_x**2))
This will give a 'convergence constrained' connectivity, i.e. each cell will have the same sum of incoming weights
---> could be problematic for outlier cells
"""
if self.pc_id == 0:
print "Connect isotropic %s - %s" % (conn_type[0].capitalize(), conn_type[1].capitalize())
(n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type) = self.resolve_src_tgt(conn_type)
if conn_type == "ee":
w_ = self.params["w_max"]
w_tgt_in = params["w_tgt_in_per_cell_%s" % conn_type]
n_max_conn = n_src * n_tgt - n_tgt
elif conn_type == "ei":
w_ = self.params["w_ei_mean"]
w_tgt_in = params["w_tgt_in_per_cell_%s" % conn_type]
n_max_conn = n_src * n_tgt
elif conn_type == "ie":
w_ = self.params["w_ie_mean"]
w_tgt_in = params["w_tgt_in_per_cell_%s" % conn_type]
n_max_conn = n_src * n_tgt
elif conn_type == "ii":
w_ = self.params["w_ii_mean"]
w_tgt_in = params["w_tgt_in_per_cell_%s" % conn_type]
n_max_conn = n_src * n_tgt - n_tgt
if self.debug_connectivity:
conn_list_fn = self.params["conn_list_%s_fn_base" % conn_type] + "%d.dat" % (self.pc_id)
# conn_file = open(conn_list_fn, 'w')
# output = ''
# output_dist = ''
w_mean = w_tgt_in / (self.params["p_%s" % conn_type] * n_max_conn / n_tgt)
w_sigma = self.params["w_sigma_distribution"] * w_mean
w_dist = RandomDistribution(
"normal", (w_mean, w_sigma), rng=self.rng_conn, constrain="redraw", boundaries=(0, w_mean * 10.0)
)
delay_dist = RandomDistribution(
"normal",
(self.params["standard_delay"], self.params["standard_delay_sigma"]),
rng=self.rng_conn,
constrain="redraw",
boundaries=(self.params["delay_range"][0], self.params["delay_range"][1]),
)
p_max = utils.get_pmax(self.params["p_%s" % conn_type], self.params["w_sigma_isotropic"], conn_type)
connector = DistanceDependentProbabilityConnector(
"%f * exp(-d/(2*%f**2))" % (p_max, params["w_sigma_isotropic"]),
allow_self_connections=False,
weights=w_dist,
delays=delay_dist,
space=self.torus,
) # , n_connections=n_conn_ee)
print "p_max for %s" % conn_type, p_max
if self.params["with_short_term_depression"]:
prj = Projection(src_pop, tgt_pop, connector, target=syn_type, synapse_dynamics=self.short_term_depression)
else:
prj = Projection(src_pop, tgt_pop, connector, target=syn_type) # , synapse_dynamics=self.STD)
self.projections[conn_type].append(prj)
if self.debug_connectivity:
# if self.pc_id == 0:
# print 'DEBUG writing to file:', conn_list_fn
prj.saveConnections(self.params["conn_list_%s_fn_base" % conn_type] + ".dat", gather=True)
# prj.saveConnections(self.params['conn_list_%s_fn_base' % conn_type] + 'gid%d.dat' % tgt, gather=False)
# conn_file.close()
# w = np.zeros(n_src, dtype='float32')
# delays = np.zeros(n_src, dtype='float32')
# for src in xrange(n_src):
# if conn_type[0] == conn_type[1]:
# if (src != tgt): # no self-connections / autapses
# d_ij = utils.torus_distance2D(tp_src[src, 0], tp_tgt[tgt, 0], tp_src[src, 1], tp_tgt[tgt, 1])
# p_ij = p_max * np.exp(-d_ij**2 / (2 * params['w_sigma_isotropic']**2))
# if np.random.rand() <= p_ij:
# w[src] = w_
# delays[src] = d_ij * params['delay_scale']
# else:
# d_ij = utils.torus_distance2D(tp_src[src, 0], tp_tgt[tgt, 0], tp_src[src, 1], tp_tgt[tgt, 1])
# p_ij = p_max * np.exp(-d_ij**2 / (2 * params['w_sigma_isotropic']**2))
# if np.random.rand() <= p_ij:
# w[src] = w_
# delays[src] = d_ij * params['delay_scale']
# w *= w_tgt_in / w.sum()
# srcs = w.nonzero()[0]
# weights = w[srcs]
# for src in srcs:
# if w[src] > self.params['w_thresh_connection']:
# delay = min(max(delays[src], self.params['delay_range'][0]), self.params['delay_range'][1]) # map the delay into the valid range
# connect(src_pop[int(src)], tgt_pop[int(tgt)], w[src], delay=delay, synapse_type=syn_type)
# output += '%d\t%d\t%.2e\t%.2e\n' % (src, tgt, w[src], delay)
# if self.debug_connectivity:
# if self.pc_id == 0:
# print 'DEBUG writing to file:', conn_list_fn
# conn_file.write(output)
# conn_file.close()
def connect_random(self, conn_type):
"""
There exist different possibilities to draw random connections:
1) Calculate the weights as for the anisotropic case and sample sources randomly
2) Load a file which stores some random connectivity --> # connector = FromFileConnector(self.params['conn_list_.... ']
3) Create a random distribution with similar parameters as the non-random connectivition distribution
connector_ee = FastFixedProbabilityConnector(self.params['p_ee'], weights=w_ee_dist, delays=self.delay_dist)
prj_ee = Projection(self.exc_pop, self.exc_pop, connector_ee, target='excitatory')
conn_list_fn = self.params['random_weight_list_fn'] + str(sim_cnt) + '.dat'
print "Connecting exc - exc from file", conn_list_fn
connector_ee = FromFileConnector(conn_list_fn)
prj_ee = Projection(self.exc_pop, self.exc_pop, connector_ee, target='excitatory')
"""
if self.pc_id == 0:
print "Connect random connections %s - %s" % (conn_type[0].capitalize(), conn_type[1].capitalize())
(n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type) = self.resolve_src_tgt(conn_type)
w_mean = self.params["w_tgt_in_per_cell_%s" % conn_type] / (n_src * self.params["p_%s" % conn_type])
w_sigma = self.params["w_sigma_distribution"] * w_sigma
weight_distr = RandomDistribution(
"normal", (w_mean, w_sigma), rng=self.rng_conn, constrain="redraw", boundaries=(0, w_mean * 10.0)
)
delay_dist = RandomDistribution(
"normal",
(self.params["standard_delay"], self.params["standard_delay_sigma"]),
rng=self.rng_conn,
constrain="redraw",
boundaries=(self.params["delay_range"][0], self.params["delay_range"][1]),
)
connector = FastFixedProbabilityConnector(
self.params["p_%s" % conn_type], weights=weight_distr, delays=delay_dist
)
if self.params["with_short_term_depression"]:
prj = Projection(src_pop, tgt_pop, connector, target=syn_type, synapse_dynamics=self.short_term_depression)
else:
prj = Projection(src_pop, tgt_pop, connector, target=syn_type)
conn_list_fn = self.params["conn_list_%s_fn_base" % conn_type] + "%d.dat" % (self.pc_id)
print "Saving random %s connections to %s" % (conn_type, conn_list_fn)
prj.saveConnections(conn_list_fn, gather=False)
def connect_populations(self, conn_type):
"""
# # # # # # # # # # # #
# C O N N E C T #
# # # # # # # # # # # #
Calls the right according to the flag set in simultation_parameters.py
"""
if self.params["connectivity_%s" % conn_type] == "anisotropic":
self.connect_anisotropic(conn_type)
elif self.params["connectivity_%s" % conn_type] == "isotropic":
self.connect_isotropic(conn_type)
elif self.params["connectivity_%s" % conn_type] == "random":
self.connect_random(conn_type)
else: # populations do not get connected
pass
def connect_noise(self):
"""
# # # # # # # # # # # # # # # #
# N O I S E I N P U T #
# # # # # # # # # # # # # # # #
"""
if self.pc_id == 0:
print "Connecting noise - exc ... "
noise_pop_exc = []
noise_pop_inh = []
for tgt in self.local_idx_exc:
# new
if self.params["simulator"] == "nest": # for nest one can use the optimized Poisson generator
noise_exc = create(native_cell_type("poisson_generator"), {"rate": self.params["f_exc_noise"]})
noise_inh = create(native_cell_type("poisson_generator"), {"rate": self.params["f_inh_noise"]})
else:
noise_exc = create(SpikeSourcePoisson, {"rate": self.params["f_exc_noise"]})
noise_inh = create(SpikeSourcePoisson, {"rate": self.params["f_inh_noise"]})
connect(
noise_exc, self.exc_pop[tgt], weight=self.params["w_exc_noise"], synapse_type="excitatory", delay=1.0
)
connect(
noise_inh, self.exc_pop[tgt], weight=self.params["w_inh_noise"], synapse_type="inhibitory", delay=1.0
)
if self.pc_id == 0:
print "Connecting noise - inh ... "
for tgt in self.local_idx_inh:
if self.params["simulator"] == "nest": # for nest one can use the optimized Poisson generator
noise_exc = create(native_cell_type("poisson_generator"), {"rate": self.params["f_exc_noise"]})
noise_inh = create(native_cell_type("poisson_generator"), {"rate": self.params["f_inh_noise"]})
else:
noise_exc = create(SpikeSourcePoisson, {"rate": self.params["f_exc_noise"]})
noise_inh = create(SpikeSourcePoisson, {"rate": self.params["f_inh_noise"]})
connect(
noise_exc, self.inh_pop[tgt], weight=self.params["w_exc_noise"], synapse_type="excitatory", delay=1.0
)
connect(
noise_inh, self.inh_pop[tgt], weight=self.params["w_inh_noise"], synapse_type="inhibitory", delay=1.0
)
self.times["connect_noise"] = self.timer.diff()
def run_sim(self, sim_cnt, record_v=True):
# # # # # # # # # # # # # # # # # # # #
# P R I N T W E I G H T S #
# # # # # # # # # # # # # # # # # # # #
# print 'Printing weights to :\n %s\n %s\n %s' % (self.params['conn_list_ei_fn'], self.params['conn_list_ie_fn'], self.params['conn_list_ii_fn'])
# exc_inh_prj.saveConnections(self.params['conn_list_ei_fn'])
# inh_exc_prj.saveConnections(self.params['conn_list_ie_fn'])
# inh_inh_prj.saveConnections(self.params['conn_list_ii_fn'])
# self.times['t_save_conns'] = self.timer.diff()
# # # # # # # # # # # #
# R E C O R D #
# # # # # # # # # # # #
# print "Recording spikes to file: %s" % (self.params['exc_spiketimes_fn_merged'] + '%d.ras' % sim_cnt)
# for cell in xrange(self.params['n_exc']):
# record(self.exc_pop[cell], self.params['exc_spiketimes_fn_merged'] + '%d.ras' % sim_cnt)
record_exc = True
if os.path.exists(self.params["gids_to_record_fn"]):
gids_to_record = np.loadtxt(self.params["gids_to_record_fn"], dtype="int")[
: self.params["n_gids_to_record"]
]
record_exc = True
n_rnd_cells_to_record = 2
else:
n_cells_to_record = 5 # self.params['n_exc'] * 0.02
gids_to_record = np.random.randint(0, self.params["n_exc"], n_cells_to_record)
if record_v:
self.exc_pop_view = PopulationView(self.exc_pop, gids_to_record, label="good_exc_neurons")
self.exc_pop_view.record_v()
self.inh_pop_view = PopulationView(
self.inh_pop,
np.random.randint(0, self.params["n_inh"], self.params["n_gids_to_record"]),
label="random_inh_neurons",
)
self.inh_pop_view.record_v()
self.inh_pop.record()
self.exc_pop.record()
self.times["t_record"] = self.timer.diff()
# # # # # # # # # # # # # #
# R U N N N I N G #
# # # # # # # # # # # # # #
if self.pc_id == 0:
print "Running simulation ... "
run(self.params["t_sim"])
self.times["t_sim"] = self.timer.diff()
def print_results(self, print_v=True):
"""
# # # # # # # # # # # # # # # # #
# P R I N T R E S U L T S #
# # # # # # # # # # # # # # # # #
"""
if print_v:
if self.pc_id == 0:
print "print_v to file: %s.v" % (self.params["exc_volt_fn_base"])
self.exc_pop_view.print_v("%s.v" % (self.params["exc_volt_fn_base"]), compatible_output=False)
if self.pc_id == 0:
print "Printing inhibitory membrane potentials"
self.inh_pop_view.print_v("%s.v" % (self.params["inh_volt_fn_base"]), compatible_output=False)
if self.pc_id == 0:
print "Printing excitatory spikes"
self.exc_pop.printSpikes(self.params["exc_spiketimes_fn_merged"] + ".ras")
if self.pc_id == 0:
print "Printing inhibitory spikes"
self.inh_pop.printSpikes(self.params["inh_spiketimes_fn_merged"] + ".ras")
self.times["t_print"] = self.timer.diff()
if self.pc_id == 0:
print "calling pyNN.end() ...."
end()
self.times["t_end"] = self.timer.diff()
if self.pc_id == 0:
self.times["t_all"] = 0.0
for k in self.times.keys():
self.times["t_all"] += self.times[k]
self.n_cells = {}
self.n_cells["n_exc"] = self.params["n_exc"]
self.n_cells["n_inh"] = self.params["n_inh"]
self.n_cells["n_cells"] = self.params["n_cells"]
self.n_cells["n_proc"] = self.n_proc
output = {"times": self.times, "n_cells_proc": self.n_cells}
print "Proc %d Simulation time: %d sec or %.1f min for %d cells (%d exc %d inh)" % (
self.pc_id,
self.times["t_sim"],
(self.times["t_sim"]) / 60.0,
self.params["n_cells"],
self.params["n_exc"],
self.params["n_inh"],
)
print "Proc %d Full pyNN run time: %d sec or %.1f min for %d cells (%d exc %d inh)" % (
self.pc_id,
self.times["t_all"],
(self.times["t_all"]) / 60.0,
self.params["n_cells"],
self.params["n_exc"],
self.params["n_inh"],
)
fn = utils.convert_to_url(params["folder_name"] + "times_dict_np%d.py" % self.n_proc)
output = ntp.ParameterSet(output)
output.save(fn)
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_model(sim, **options):
"""
Run a simulation using the parameters read from the file "spike_train_statistics.json"
:param sim: the PyNN backend module to be used.
:param options: should contain a keyword "simulator" which is the name of the PyNN backend module used.
:return: a tuple (`data`, `times`) where `data` is a Neo Block containing the recorded spikes
and `times` is a dict containing the time taken for different phases of the simulation.
"""
import json
from pyNN.utility import Timer
print("Running")
timer = Timer()
g = open("spike_train_statistics.json", 'r')
d = json.load(g)
N = d['param']['N']
max_rate = d['param']['max_rate']
tstop = d['param']['tstop']
d['SpikeSourcePoisson'] = {
"duration": tstop
}
if options['simulator'] == "hardware.brainscales":
hardware_preset = d['setup'].pop('hardware_preset', None)
if hardware_preset:
d['setup']['hardware'] = sim.hardwareSetup[hardware_preset]
d['SpikeSourcePoisson']['random'] = True
place = mapper.place()
timer.start()
sim.setup(**d['setup'])
spike_sources = sim.Population(N, sim.SpikeSourcePoisson, d['SpikeSourcePoisson'])
delta_rate = max_rate/N
rates = numpy.linspace(delta_rate, max_rate, N)
print("Firing rates: %s" % rates)
if PYNN07:
spike_sources.tset("rate", rates)
else:
spike_sources.set(rate=rates)
if options['simulator'] == "hardware.brainscales":
for i, spike_source in enumerate(spike_sources):
place.to(spike_source, hicann=i//8, neuron=i%64)
place.commit()
if PYNN07:
spike_sources.record()
else:
spike_sources.record('spikes')
setup_time = timer.diff()
sim.run(tstop)
run_time = timer.diff()
if PYNN07:
spike_array = spike_sources.getSpikes()
data = spike_array_to_neo(spike_array, spike_sources, tstop)
else:
data = spike_sources.get_data()
sim.end()
closing_time = timer.diff()
times = {'setup_time': setup_time, 'run_time': run_time, 'closing_time': closing_time}
return data, times
class NetworkModel(object):
def __init__(self, params, comm):
self.params = params
self.debug_connectivity = True
self.comm = comm
if self.comm != None:
self.pc_id, self.n_proc = self.comm.rank, self.comm.size
print "USE_MPI: yes", '\tpc_id, n_proc:', self.pc_id, self.n_proc
else:
self.pc_id, self.n_proc = 0, 1
print "MPI not used"
np.random.seed(params['np_random_seed'] + self.pc_id)
if self.params['with_short_term_depression']:
self.short_term_depression = SynapseDynamics(fast=TsodyksMarkramMechanism(U=0.95, tau_rec=10.0, tau_facil=0.0))
def import_pynn(self):
"""
This function needs only be called when this class is used in another script as imported module
"""
import pyNN
exec("from pyNN.%s import *" % self.params['simulator'])
print 'import pyNN\npyNN.version: ', pyNN.__version__
def setup(self, load_tuning_prop=False, times={}):
self.projections = {}
self.projections['ee'] = []
self.projections['ei'] = []
self.projections['ie'] = []
self.projections['ii'] = []
if not load_tuning_prop:
self.tuning_prop_exc = utils.set_tuning_prop(self.params, mode='hexgrid', cell_type='exc') # set the tuning properties of exc cells: space (x, y) and velocity (u, v)
self.tuning_prop_inh = utils.set_tuning_prop(self.params, mode='hexgrid', cell_type='inh') # set the tuning properties of exc cells: space (x, y) and velocity (u, v)
else:
self.tuning_prop_exc = np.loadtxt(self.params['tuning_prop_means_fn'])
self.tuning_prop_inh = np.loadtxt(self.params['tuning_prop_inh_fn'])
indices, distances = utils.sort_gids_by_distance_to_stimulus(self.tuning_prop_exc, self.params) # cells in indices should have the highest response to the stimulus
if self.pc_id == 0:
print "Saving tuning_prop to file:", self.params['tuning_prop_means_fn']
np.savetxt(self.params['tuning_prop_means_fn'], self.tuning_prop_exc)
print "Saving tuning_prop to file:", self.params['tuning_prop_inh_fn']
np.savetxt(self.params['tuning_prop_inh_fn'], self.tuning_prop_inh)
print 'Saving gids to record to: ', self.params['gids_to_record_fn']
np.savetxt(self.params['gids_to_record_fn'], indices[:self.params['n_gids_to_record']], fmt='%d')
# np.savetxt(params['gids_to_record_fn'], indices[:params['n_gids_to_record']], fmt='%d')
if self.comm != None:
self.comm.Barrier()
from pyNN.utility import Timer
self.timer = Timer()
self.timer.start()
self.times = times
self.times['t_all'] = 0
# # # # # # # # # # # #
# S E T U P #
# # # # # # # # # # # #
(delay_min, delay_max) = self.params['delay_range']
setup(timestep=0.1, min_delay=delay_min, max_delay=delay_max, rng_seeds_seed=self.params['seed'])
rng_v = NumpyRNG(seed = sim_cnt*3147 + self.params['seed'], parallel_safe=True) #if True, slower but does not depend on number of nodes
self.rng_conn = NumpyRNG(seed = self.params['seed'], parallel_safe=True) #if True, slower but does not depend on number of nodes
# # # # # # # # # # # # # # # # # # # # # # # # #
# R A N D O M D I S T R I B U T I O N S #
# # # # # # # # # # # # # # # # # # # # # # # # #
self.v_init_dist = RandomDistribution('normal',
(self.params['v_init'], self.params['v_init_sigma']),
rng=rng_v,
constrain='redraw',
boundaries=(-80, -60))
self.times['t_setup'] = self.timer.diff()
self.times['t_calc_conns'] = 0
if self.comm != None:
self.comm.Barrier()
self.torus = space.Space(axes='xy', periodic_boundaries=((0., self.params['torus_width']), (0., self.params['torus_height'])))
def create_neurons_with_limited_tuning_properties(self):
n_exc = self.tuning_prop_exc[:, 0].size
n_inh = 0
if self.params['neuron_model'] == 'IF_cond_exp':
self.exc_pop = Population(n_exc, IF_cond_exp, self.params['cell_params_exc'], label='exc_cells')
self.inh_pop = Population(self.params['n_inh'], IF_cond_exp, self.params['cell_params_inh'], label="inh_pop")
elif self.params['neuron_model'] == 'IF_cond_alpha':
self.exc_pop = Population(n_exc, IF_cond_alpha, self.params['cell_params_exc'], label='exc_cells')
self.inh_pop = Population(self.params['n_inh'], IF_cond_alpha, self.params['cell_params_inh'], label="inh_pop")
elif self.params['neuron_model'] == 'EIF_cond_exp_isfa_ista':
self.exc_pop = Population(n_exc, EIF_cond_exp_isfa_ista, self.params['cell_params_exc'], label='exc_cells')
self.inh_pop = Population(self.params['n_inh'], EIF_cond_exp_isfa_ista, self.params['cell_params_inh'], label="inh_pop")
else:
print '\n\nUnknown neuron model:\n\t', self.params['neuron_model']
# set cell positions, required for isotropic connections
cell_pos_exc = np.zeros((3, self.params['n_exc']))
cell_pos_exc[0, :] = self.tuning_prop_exc[:, 0]
cell_pos_exc[1, :] = self.tuning_prop_exc[:, 1]
self.exc_pop.positions = cell_pos_exc
cell_pos_inh = np.zeros((3, self.params['n_inh']))
cell_pos_inh[0, :] = self.tuning_prop_inh[:, 0]
cell_pos_inh[1, :] = self.tuning_prop_inh[:, 1]
self.inh_pop.positions = cell_pos_inh
self.local_idx_exc = get_local_indices(self.exc_pop, offset=0)
if not input_created:
self.spike_times_container = [ [] for i in xrange(len(self.local_idx_exc))]
self.spike_times_container = [ [] for i in xrange(len(self.local_idx_exc))]
print 'Debug, pc_id %d has local %d exc indices:' % (self.pc_id, len(self.local_idx_exc)), self.local_idx_exc
self.exc_pop.initialize('v', self.v_init_dist)
self.local_idx_inh = get_local_indices(self.inh_pop, offset=self.params['n_exc'])
print 'Debug, pc_id %d has local %d inh indices:' % (self.pc_id, len(self.local_idx_inh)), self.local_idx_inh
self.inh_pop.initialize('v', self.v_init_dist)
self.times['t_create'] = self.timer.diff()
def create(self, input_created=False):
"""
# # # # # # # # # # # #
# C R E A T E #
# # # # # # # # # # # #
"""
if self.params['neuron_model'] == 'IF_cond_exp':
self.exc_pop = Population(self.params['n_exc'], IF_cond_exp, self.params['cell_params_exc'], label='exc_cells')
self.inh_pop = Population(self.params['n_inh'], IF_cond_exp, self.params['cell_params_inh'], label="inh_pop")
elif self.params['neuron_model'] == 'IF_cond_alpha':
self.exc_pop = Population(self.params['n_exc'], IF_cond_alpha, self.params['cell_params_exc'], label='exc_cells')
self.inh_pop = Population(self.params['n_inh'], IF_cond_alpha, self.params['cell_params_inh'], label="inh_pop")
elif self.params['neuron_model'] == 'EIF_cond_exp_isfa_ista':
self.exc_pop = Population(self.params['n_exc'], EIF_cond_exp_isfa_ista, self.params['cell_params_exc'], label='exc_cells')
self.inh_pop = Population(self.params['n_inh'], EIF_cond_exp_isfa_ista, self.params['cell_params_inh'], label="inh_pop")
else:
print '\n\nUnknown neuron model:\n\t', self.params['neuron_model']
self.local_idx_exc = get_local_indices(self.exc_pop, offset=0)
print 'Debug, pc_id %d has local %d exc indices:' % (self.pc_id, len(self.local_idx_exc)), self.local_idx_exc
cell_pos_exc = np.zeros((3, self.params['n_exc']))
cell_pos_exc[0, :] = self.tuning_prop_exc[:, 0]
cell_pos_exc[1, :] = self.tuning_prop_exc[:, 1]
self.exc_pop.positions = cell_pos_exc
cell_pos_inh = np.zeros((3, self.params['n_inh']))
cell_pos_inh[0, :] = self.tuning_prop_inh[:, 0]
cell_pos_inh[1, :] = self.tuning_prop_inh[:, 1]
self.inh_pop.positions = cell_pos_inh
if not input_created:
self.spike_times_container = [ [] for i in xrange(len(self.local_idx_exc))]
self.exc_pop.initialize('v', self.v_init_dist)
self.local_idx_inh = get_local_indices(self.inh_pop, offset=self.params['n_exc'])
print 'Debug, pc_id %d has local %d inh indices:' % (self.pc_id, len(self.local_idx_inh)), self.local_idx_inh
self.inh_pop.initialize('v', self.v_init_dist)
self.times['t_create'] = self.timer.diff()
def connect(self):
if self.params['n_exc'] > 5000:
save_output = False
else:
save_output = True
self.connect_input_to_exc()
self.connect_populations('ee')
self.connect_populations('ei')
self.connect_populations('ie')
self.connect_populations('ii')
self.connect_noise()
self.times['t_calc_conns'] = self.timer.diff()
if self.comm != None:
self.comm.Barrier()
def get_motion_params_from_protocol(self, time):
"""
"""
predictor_interval = int(time / self.params['predictor_interval_duration'])
# based on the motion_protocol calculate the stimulus position and direction etc --> predictor_params
if self.params['motion_protocol'] == 'congruent':
x0, y0, u0, v0, theta = self.params['motion_params'][0], self.params['motion_params'][1], self.params['motion_params'][2], self.params['motion_params'][3], self.params['motion_params'][4]
x, y = (x0 + u0 * time) % self.params['torus_width'], (y0 + v0 * time) % self.params['torus_height'] # current position of the blob at time t assuming a perfect translation
predictor_params = (x, y, u0, v0, theta)
elif self.params['motion_protocol'] == 'incongruent':
# incongruent protocol means having oriented bar as stimulus that its orientation is flipped inside the CRF
predictor_params = self.params['motion_params']
# if (t_check < time < t_stop_check):
# orientation = sp.params['motion_params'][:,4] + np.pi/2.0
# Missing CRF protocol includes a moving oriented bar which approches to CRF and disappears inside CRF
# --> we give noise as input
# --> we shuffle the stimulus among all cells to get an incoherent input (the output of the CRF will be very small)
elif protocol == 'Missing CRF':
predictor_params = self.params['motion_params']
# if (t_check < t < t_stop_check):
# L = np.random.permutation(stimulus)
# CRF only protocol includes an oriented bar which moves for a short period only inside CRF
elif protocol == 'CRF only':
predictor_params = self.params['motion_params']
# if (t_check < t < t_stop_check):
# L = stimulus
# else:
# L = np.random.permutation(stimulus)
# L = 0
elif self.params['motion_protocol'] == 'random predictor':
predictor_params = self.params['motion_params']
# we create a random sequence of orientations and segment the trajectory
# orientation = np.random.rand(self.params['n_random_predictor_orientations']) * np.pi
return predictor_params
def create_input(self, load_files=False, save_output=False):
if load_files:
if self.pc_id == 0:
print "Loading input spiketrains..."
for i_, tgt in enumerate(self.local_idx_exc):
try:
fn = self.params['input_st_fn_base'] + str(tgt) + '.npy'
spike_times = np.load(fn)
except: # this cell does not get any input
print "Missing file: ", fn
spike_times = []
self.spike_times_container[i_] = spike_times
else:
if self.pc_id == 0:
print "Computing input spiketrains..."
nprnd.seed(self.params['input_spikes_seed'])
dt = self.params['dt_rate'] # [ms] time step for the non-homogenous Poisson process
time = np.arange(0, self.params['t_sim'], dt)
blank_idx = np.arange(1./dt * self.params['t_before_blank'], 1. / dt * (self.params['t_before_blank'] + self.params['t_blank']))
before_stim_idx = np.arange(0, self.params['t_start'] * 1./dt)
blank_idx = np.concatenate((blank_idx, before_stim_idx))
my_units = self.local_idx_exc
n_cells = len(my_units)
L_input = np.zeros((n_cells, time.shape[0]))
# get the input signal
print 'Calculating input signal'
for i_time, time_ in enumerate(time):
predictor_params = self.get_motion_params_from_protocol(time_ / self.params['t_stimulus'])
L_input[:, i_time] = utils.get_input(self.tuning_prop_exc[my_units, :], self.params, predictor_params, motion = self.params['motion_type'])
L_input[:, i_time] *= self.params['f_max_stim']
if (i_time % 500 == 0):
print "t:", time_
# blanking
for i_time in blank_idx:
L_input[:, i_time] = np.random.permutation(L_input[:, i_time])
# L_input[:, i_time] = 0.
# create the spike trains
print 'Creating input spiketrains for unit'
for i_, unit in enumerate(my_units):
rate_of_t = np.array(L_input[i_, :])
# each cell will get its own spike train stored in the following file + cell gid
n_steps = rate_of_t.size
spike_times = []
for i in xrange(n_steps):
r = nprnd.rand()
if (r <= ((rate_of_t[i]/1000.) * dt)): # rate is given in Hz -> 1/1000.
spike_times.append(i * dt)
self.spike_times_container[i_] = spike_times
if save_output:
output_fn = self.params['input_rate_fn_base'] + str(unit) + '.npy'
np.save(output_fn, rate_of_t)
output_fn = self.params['input_st_fn_base'] + str(unit) + '.npy'
np.save(output_fn, np.array(spike_times))
self.times['create_input'] = self.timer.diff()
return self.spike_times_container
def connect_input_to_exc(self):
"""
# # # # # # # # # # # # # # # # # # # # # #
# C O N N E C T I N P U T - E X C #
# # # # # # # # # # # # # # # # # # # # # #
"""
if self.pc_id == 0:
print "Connecting input spiketrains..."
# self.stimulus = Population(len(self.local_idx_exc), SpikeSourceArray)
# self.exc_pop = Population(n_exc, IF_cond_exp, self.params['cell_params_exc'], label='exc_cells')
# prj = Projection(src_pop, tgt_pop, connector, target=syn_type)
# self.projections[conn_type].append(prj)
# self.projections['stim'] = []
# self.stimuli = []
# self.pop_views = []
# conn = OneToOneConnector(weights=self.params['w_input_exc'])
for i_, unit in enumerate(self.local_idx_exc):
spike_times = self.spike_times_container[i_]
# ssa = create(SpikeSourceArray, {'spike_times': spike_times})
ssa = Population(1, SpikeSourceArray, {'spike_times': spike_times})
# ssa.set({'spike_times' : spike_times})
# self.stimuli.append(ssa)
# if self.params['with_short_term_depression']:
# connect(ssa, self.exc_pop[unit], self.params['w_input_exc'], synapse_type='excitatory', synapse_dynamics=self.short_term_depression)
# selector = np.zeros(self.params['n_exc'], dtype=np.bool)
# selector[unit] = True
# print 'debug unit', unit, type(unit)
# w[i_] = 1.#self.params['w_input_exc']
# tgt = PopulationView(self.exc_pop, np.array([unit]))
# self.pop_views.append(tgt)
# prj = Projection(ssa, tgt, conn, target='excitatory', synapse_dynamics=self.short_term_depression)
# prj = Projection(self.stimuli[-1], self.pop_views[-1], conn, target='excitatory', synapse_dynamics=self.short_term_depression)
# self.projections['stim'].append(prj)
# else:
connect(ssa, self.exc_pop[unit], self.params['w_input_exc'], synapse_type='excitatory')
self.times['connect_input'] = self.timer.diff()
def resolve_src_tgt(self, conn_type):
"""
Deliver the correct source and target parameters based on conn_type
"""
if conn_type == 'ee':
n_src, n_tgt = self.params['n_exc'], self.params['n_exc']
src_pop, tgt_pop = self.exc_pop, self.exc_pop
tgt_cells = self.local_idx_exc
tp_src = self.tuning_prop_exc
tp_tgt = self.tuning_prop_exc
syn_type = 'excitatory'
elif conn_type == 'ei':
n_src, n_tgt = self.params['n_exc'], self.params['n_inh']
src_pop, tgt_pop = self.exc_pop, self.inh_pop
tgt_cells = self.local_idx_inh
tp_src = self.tuning_prop_exc
tp_tgt = self.tuning_prop_inh
syn_type = 'excitatory'
elif conn_type == 'ie':
n_src, n_tgt = self.params['n_inh'], self.params['n_exc']
src_pop, tgt_pop = self.inh_pop, self.exc_pop
tgt_cells = self.local_idx_exc
tp_src = self.tuning_prop_inh
tp_tgt = self.tuning_prop_exc
syn_type = 'inhibitory'
elif conn_type == 'ii':
n_src, n_tgt = self.params['n_inh'], self.params['n_inh']
src_pop, tgt_pop = self.inh_pop, self.inh_pop
tgt_cells = self.local_idx_inh
tp_src = self.tuning_prop_inh
tp_tgt = self.tuning_prop_inh
syn_type = 'inhibitory'
return (n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type)
def connect_anisotropic(self, conn_type):
"""
conn_type = ['ee', 'ei', 'ie', 'ii']
"""
if self.pc_id == 0:
print 'Connect anisotropic %s - %s' % (conn_type[0].capitalize(), conn_type[1].capitalize())
(n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type) = self.resolve_src_tgt(conn_type)
if self.debug_connectivity:
conn_list_fn = self.params['conn_list_%s_fn_base' % conn_type] + '%d.dat' % (self.pc_id)
n_src_cells_per_neuron = int(round(self.params['p_%s' % conn_type] * n_src))
(delay_min, delay_max) = self.params['delay_range']
local_connlist = np.zeros((n_src_cells_per_neuron * len(tgt_cells), 4))
for i_, tgt in enumerate(tgt_cells):
if self.params['conn_conf'] == 'direction-based':
p, latency = CC.get_p_conn_direction_based(tp_src, tp_tgt[tgt, :], self.params['w_sigma_x'], self.params['w_sigma_v'], self.params['connectivity_radius'])
elif self.params['conn_conf'] == 'motion-based':
p, latency = CC.get_p_conn_motion_based(tp_src, tp_tgt[tgt, :], self.params['w_sigma_x'], self.params['w_sigma_v'], self.params['connectivity_radius'])
elif self.params['conn_conf'] == 'orientation-direction':
p, latency = CC.get_p_conn_direction_and_orientation_based(tp_src, tp_tgt[tgt, :], self.params['w_sigma_x'], self.params['w_sigma_v'], self.params['w_sigma_theta'], self.params['connectivity_radius'])
else:
print '\n\nERROR! Wrong connection configutation conn_conf parameter provided\nShould be direction-based, motion-based or orientation-direction\n'
exit(1)
if conn_type[0] == conn_type[1]:
p[tgt], latency[tgt] = 0., 0.
# random delays? --> np.permutate(latency) or latency[sources] * self.params['delay_scale'] * np.rand
sorted_indices = np.argsort(p)
if conn_type[0] == 'e':
sources = sorted_indices[-n_src_cells_per_neuron:]
else: # source = inhibitory
if conn_type[0] == conn_type[1]:
sources = sorted_indices[1:n_src_cells_per_neuron+1] # shift indices to avoid self-connection, because p_ii = .0
else:
sources = sorted_indices[:n_src_cells_per_neuron]
eta = 1e-12
w = (self.params['w_tgt_in_per_cell_%s' % conn_type] / (p[sources].sum() + eta)) * p[sources]
w_ = np.minimum(np.maximum(w, self.params['w_thresh_min']), self.params['w_thresh_max'])
delays = np.minimum(np.maximum(latency[sources] * self.params['delay_scale'], delay_min), delay_max) # map the delay into the valid range
conn_list = np.array((sources, tgt * np.ones(n_src_cells_per_neuron), w_, delays))
local_connlist[i_ * n_src_cells_per_neuron : (i_ + 1) * n_src_cells_per_neuron, :] = conn_list.transpose()
connector = FromListConnector(conn_list.transpose())
if self.params['with_short_term_depression']:
prj = Projection(src_pop, tgt_pop, connector, target=syn_type, synapse_dynamics=self.short_term_depression)
else:
prj = Projection(src_pop, tgt_pop, connector, target=syn_type)
self.projections[conn_type].append(prj)
if self.debug_connectivity:
if self.pc_id == 0:
print 'DEBUG writing to file:', conn_list_fn
np.savetxt(conn_list_fn, local_connlist, fmt='%d\t%d\t%.4e\t%.4e')
def connect_ee_random(self):
"""
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
# C O N N E C T E X C - E X C R A N D O M #
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
"""
if self.pc_id == 0:
print 'Drawing random connections'
sigma_x, sigma_v = self.params['w_sigma_x'], self.params['w_sigma_v']
(delay_min, delay_max) = self.params['delay_range']
if self.debug_connectivity:
conn_list_fn = self.params['conn_list_ee_fn_base'] + '%d.dat' % (self.pc_id)
conn_file = open(conn_list_fn, 'w')
output = ''
for tgt in self.local_idx_exc:
p = np.zeros(self.params['n_exc'], dtype='float32')
latency = np.zeros(self.params['n_exc'], dtype='float32')
for src in xrange(self.params['n_exc']):
if (src != tgt):
p[src], latency[src] = CC.get_p_conn(self.tuning_prop_exc[src, :], self.tuning_prop_exc[tgt, :], sigma_x, sigma_v, params['connectivity_radius']) # print 'debug pc_id src tgt ', self.pc_id, src, tgt#, int(ID) < self.params['n_exc']
sources = random.sample(xrange(self.params['n_exc']), int(self.params['n_src_cells_per_neuron']))
idx = p[sources] > 0
non_zero_idx = np.nonzero(idx)[0]
p_ = p[sources][non_zero_idx]
l_ = latency[sources][non_zero_idx] * self.params['delay_scale']
w = utils.linear_transformation(p_, self.params['w_min'], self.params['w_max'])
for i in xrange(len(p_)):
# w[i] = max(self.params['w_min'], min(w[i], self.params['w_max']))
delay = min(max(l_[i], delay_min), delay_max) # map the delay into the valid range
connect(self.exc_pop[non_zero_idx[i]], self.exc_pop[tgt], w[i], delay=delay, synapse_type='excitatory')
if self.debug_connectivity:
output += '%d\t%d\t%.2e\t%.2e\n' % (non_zero_idx[i], tgt, w[i], delay) # output += '%d\t%d\t%.2e\t%.2e\t%.2e\n' % (sources[i], tgt, w[i], latency[sources[i]], p[sources[i]])
if self.debug_connectivity:
if self.pc_id == 0:
print 'DEBUG writing to file:', conn_list_fn
conn_file.write(output)
conn_file.close()
def connect_isotropic(self, conn_type='ee'):
"""
conn_type must be 'ee', 'ei', 'ie' or 'ii'
Connect cells in a distant dependent manner:
p_ij = exp(- d_ij / (2 * w_sigma_x**2))
This will give a 'convergence constrained' connectivity, i.e. each cell will have the same sum of incoming weights
---> could be problematic for outlier cells
"""
if self.pc_id == 0:
print 'Connect isotropic %s - %s' % (conn_type[0].capitalize(), conn_type[1].capitalize())
(n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type) = self.resolve_src_tgt(conn_type)
if conn_type == 'ee':
w_ = self.params['w_max']
w_tgt_in = params['w_tgt_in_per_cell_%s' % conn_type]
n_max_conn = n_src * n_tgt - n_tgt
elif conn_type == 'ei':
w_ = self.params['w_ei_mean']
w_tgt_in = params['w_tgt_in_per_cell_%s' % conn_type]
n_max_conn = n_src * n_tgt
elif conn_type == 'ie':
w_ = self.params['w_ie_mean']
w_tgt_in = params['w_tgt_in_per_cell_%s' % conn_type]
n_max_conn = n_src * n_tgt
elif conn_type == 'ii':
w_ = self.params['w_ii_mean']
w_tgt_in = params['w_tgt_in_per_cell_%s' % conn_type]
n_max_conn = n_src * n_tgt - n_tgt
if self.debug_connectivity:
conn_list_fn = self.params['conn_list_%s_fn_base' % conn_type] + '%d.dat' % (self.pc_id)
# conn_file = open(conn_list_fn, 'w')
# output = ''
# output_dist = ''
w_mean = w_tgt_in / (self.params['p_%s' % conn_type] * n_max_conn / n_tgt)
w_sigma = self.params['w_sigma_distribution'] * w_mean
w_dist = RandomDistribution('normal',
(w_mean, w_sigma),
rng=self.rng_conn,
constrain='redraw',
boundaries=(0, w_mean * 10.))
delay_dist = RandomDistribution('normal',
(self.params['standard_delay'], self.params['standard_delay_sigma']),
rng=self.rng_conn,
constrain='redraw',
boundaries=(self.params['delay_range'][0], self.params['delay_range'][1]))
p_max = utils.get_pmax(self.params['p_%s' % conn_type], self.params['w_sigma_isotropic'], conn_type)
connector = DistanceDependentProbabilityConnector('%f * exp(-d/(2*%f**2))' % (p_max, params['w_sigma_isotropic']), allow_self_connections=False, \
weights=w_dist, delays=delay_dist, space=self.torus)#, n_connections=n_conn_ee)
if self.params['with_short_term_depression']:
prj = Projection(src_pop, tgt_pop, connector, target=syn_type, synapse_dynamics=self.short_term_depression)
else:
prj = Projection(src_pop, tgt_pop, connector, target=syn_type)#, synapse_dynamics=self.STD)
self.projections[conn_type].append(prj)
if self.debug_connectivity:
# if self.pc_id == 0:
# print 'DEBUG writing to file:', conn_list_fn
prj.saveConnections(self.params['conn_list_%s_fn_base' % conn_type] + '.dat', gather=True)
# prj.saveConnections(self.params['conn_list_%s_fn_base' % conn_type] + 'gid%d.dat' % tgt, gather=False)
# conn_file.close()
# w = np.zeros(n_src, dtype='float32')
# delays = np.zeros(n_src, dtype='float32')
# for src in xrange(n_src):
# if conn_type[0] == conn_type[1]:
# if (src != tgt): # no self-connections / autapses
# d_ij = utils.torus_distance2D(tp_src[src, 0], tp_tgt[tgt, 0], tp_src[src, 1], tp_tgt[tgt, 1])
# p_ij = p_max * np.exp(-d_ij**2 / (2 * params['w_sigma_isotropic']**2))
# if np.random.rand() <= p_ij:
# w[src] = w_
# delays[src] = d_ij * params['delay_scale']
# else:
# d_ij = utils.torus_distance2D(tp_src[src, 0], tp_tgt[tgt, 0], tp_src[src, 1], tp_tgt[tgt, 1])
# p_ij = p_max * np.exp(-d_ij**2 / (2 * params['w_sigma_isotropic']**2))
# if np.random.rand() <= p_ij:
# w[src] = w_
# delays[src] = d_ij * params['delay_scale']
# w *= w_tgt_in / w.sum()
# srcs = w.nonzero()[0]
# weights = w[srcs]
# for src in srcs:
# if w[src] > self.params['w_thresh_connection']:
# delay = min(max(delays[src], self.params['delay_range'][0]), self.params['delay_range'][1]) # map the delay into the valid range
# connect(src_pop[int(src)], tgt_pop[int(tgt)], w[src], delay=delay, synapse_type=syn_type)
# output += '%d\t%d\t%.2e\t%.2e\n' % (src, tgt, w[src], delay)
# if self.debug_connectivity:
# if self.pc_id == 0:
# print 'DEBUG writing to file:', conn_list_fn
# conn_file.write(output)
# conn_file.close()
def connect_random(self, conn_type):
"""
There exist different possibilities to draw random connections:
1) Calculate the weights as for the anisotropic case and sample sources randomly
2) Load a file which stores some random connectivity --> # connector = FromFileConnector(self.params['conn_list_.... ']
3) Create a random distribution with similar parameters as the non-random connectivition distribution
connector_ee = FastFixedProbabilityConnector(self.params['p_ee'], weights=w_ee_dist, delays=self.delay_dist)
prj_ee = Projection(self.exc_pop, self.exc_pop, connector_ee, target='excitatory')
conn_list_fn = self.params['random_weight_list_fn'] + str(sim_cnt) + '.dat'
print "Connecting exc - exc from file", conn_list_fn
connector_ee = FromFileConnector(conn_list_fn)
prj_ee = Projection(self.exc_pop, self.exc_pop, connector_ee, target='excitatory')
"""
if self.pc_id == 0:
print 'Connect random connections %s - %s' % (conn_type[0].capitalize(), conn_type[1].capitalize())
(n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type) = self.resolve_src_tgt(conn_type)
if conn_type == 'ee':
w_ = self.params['w_max']
w_tgt_in = params['w_tgt_in_per_cell_%s' % conn_type]
n_max_conn = n_src * n_tgt - n_tgt
elif conn_type == 'ei':
w_ = self.params['w_ei_mean']
w_tgt_in = params['w_tgt_in_per_cell_%s' % conn_type]
n_max_conn = n_src * n_tgt
elif conn_type == 'ie':
w_ = self.params['w_ie_mean']
w_tgt_in = params['w_tgt_in_per_cell_%s' % conn_type]
n_max_conn = n_src * n_tgt
elif conn_type == 'ii':
w_ = self.params['w_ii_mean']
w_tgt_in = params['w_tgt_in_per_cell_%s' % conn_type]
n_max_conn = n_src * n_tgt - n_tgt
if self.debug_connectivity:
conn_list_fn = self.params['conn_list_%s_fn_base' % conn_type] + '%d.dat' % (self.pc_id)
# conn_file = open(conn_list_fn, 'w')
# output = ''
# output_dist = ''
w_mean = w_tgt_in / (self.params['p_%s' % conn_type] * n_max_conn / n_tgt)
w_sigma = self.params['w_sigma_distribution'] * w_mean
weight_distr = RandomDistribution('normal',
(w_mean, w_sigma),
rng=self.rng_conn,
constrain='redraw',
boundaries=(0, w_mean * 10.))
delay_dist = RandomDistribution('normal',
(self.params['standard_delay'], self.params['standard_delay_sigma']),
rng=self.rng_conn,
constrain='redraw',
boundaries=(self.params['delay_range'][0], self.params['delay_range'][1]))
connector= FastFixedProbabilityConnector(self.params['p_%s' % conn_type], weights=weight_distr, delays=delay_dist)
if self.params['with_short_term_depression']:
prj = Projection(src_pop, tgt_pop, connector, target=syn_type, synapse_dynamics=self.short_term_depression)
else:
prj = Projection(src_pop, tgt_pop, connector, target=syn_type)
conn_list_fn = self.params['conn_list_%s_fn_base' % conn_type] + '%d.dat' % (self.pc_id)
print 'Saving random %s connections to %s' % (conn_type, conn_list_fn)
prj.saveConnections(conn_list_fn, gather=False)
def connect_populations(self, conn_type):
"""
# # # # # # # # # # # #
# C O N N E C T #
# # # # # # # # # # # #
Calls the right according to the flag set in simultation_parameters.py
"""
if self.params['connectivity_%s' % conn_type] == 'anisotropic':
self.connect_anisotropic(conn_type)
elif self.params['connectivity_%s' % conn_type] == 'isotropic':
self.connect_isotropic(conn_type)
elif self.params['connectivity_%s' % conn_type] == 'random':
self.connect_random(conn_type)
else: # populations do not get connected
pass
def connect_noise(self):
"""
# # # # # # # # # # # # # # # #
# N O I S E I N P U T #
# # # # # # # # # # # # # # # #
"""
if self.pc_id == 0:
print "Connecting noise - exc ... "
noise_pop_exc = []
noise_pop_inh = []
for tgt in self.local_idx_exc:
#new
if (self.params['simulator'] == 'nest'): # for nest one can use the optimized Poisson generator
noise_exc = create(native_cell_type('poisson_generator'), {'rate' : self.params['f_exc_noise']})
noise_inh = create(native_cell_type('poisson_generator'), {'rate' : self.params['f_inh_noise']})
else:
noise_exc = create(SpikeSourcePoisson, {'rate' : self.params['f_exc_noise']})
noise_inh = create(SpikeSourcePoisson, {'rate' : self.params['f_inh_noise']})
connect(noise_exc, self.exc_pop[tgt], weight=self.params['w_exc_noise'], synapse_type='excitatory', delay=1.)
connect(noise_inh, self.exc_pop[tgt], weight=self.params['w_inh_noise'], synapse_type='inhibitory', delay=1.)
if self.pc_id == 0:
print "Connecting noise - inh ... "
for tgt in self.local_idx_inh:
if (self.params['simulator'] == 'nest'): # for nest one can use the optimized Poisson generator
noise_exc = create(native_cell_type('poisson_generator'), {'rate' : self.params['f_exc_noise']})
noise_inh = create(native_cell_type('poisson_generator'), {'rate' : self.params['f_inh_noise']})
else:
noise_exc = create(SpikeSourcePoisson, {'rate' : self.params['f_exc_noise']})
noise_inh = create(SpikeSourcePoisson, {'rate' : self.params['f_inh_noise']})
connect(noise_exc, self.inh_pop[tgt], weight=self.params['w_exc_noise'], synapse_type='excitatory', delay=1.)
connect(noise_inh, self.inh_pop[tgt], weight=self.params['w_inh_noise'], synapse_type='inhibitory', delay=1.)
self.times['connect_noise'] = self.timer.diff()
def run_sim(self, sim_cnt, record_v=False):
# # # # # # # # # # # # # # # # # # # #
# P R I N T W E I G H T S #
# # # # # # # # # # # # # # # # # # # #
# print 'Printing weights to :\n %s\n %s\n %s' % (self.params['conn_list_ei_fn'], self.params['conn_list_ie_fn'], self.params['conn_list_ii_fn'])
# exc_inh_prj.saveConnections(self.params['conn_list_ei_fn'])
# inh_exc_prj.saveConnections(self.params['conn_list_ie_fn'])
# inh_inh_prj.saveConnections(self.params['conn_list_ii_fn'])
# self.times['t_save_conns'] = self.timer.diff()
# # # # # # # # # # # #
# R E C O R D #
# # # # # # # # # # # #
# print "Recording spikes to file: %s" % (self.params['exc_spiketimes_fn_merged'] + '%d.ras' % sim_cnt)
# for cell in xrange(self.params['n_exc']):
# record(self.exc_pop[cell], self.params['exc_spiketimes_fn_merged'] + '%d.ras' % sim_cnt)
record_exc = True
if os.path.exists(self.params['gids_to_record_fn']):
gids_to_record = np.loadtxt(self.params['gids_to_record_fn'], dtype='int')[:self.params['n_gids_to_record']]
record_exc = True
n_rnd_cells_to_record = 2
else:
n_cells_to_record = 5# self.params['n_exc'] * 0.02
gids_to_record = np.random.randint(0, self.params['n_exc'], n_cells_to_record)
if ps.params['anticipatory_mode']:
record_gids, pops = utils.select_well_tuned_cells(self.tuning_prop_exc, self.params, self.params['n_gids_to_record'], 1)
np.savetxt(self.params['gids_to_record_fn'], record_gids)
self.exc_pop_view_anticipation = PopulationView(self.exc_pop, record_gids, label='anticipation')
self.exc_pop_view_anticipation.record_v()
self.exc_pop_view_anticipation.record_gsyn()
self.anticipatory_record = True
###################################
###################################
if record_v:
self.exc_pop_view = PopulationView(self.exc_pop, gids_to_record, label='good_exc_neurons')
self.exc_pop_view.record_v()
self.inh_pop_view = PopulationView(self.inh_pop, np.random.randint(0, self.params['n_inh'], self.params['n_gids_to_record']), label='random_inh_neurons')
self.inh_pop_view.record_v()
self.inh_pop.record()
self.exc_pop.record()
self.times['t_record'] = self.timer.diff()
# # # # # # # # # # # # # #
# R U N N N I N G #
# # # # # # # # # # # # # #
if self.pc_id == 0:
print "Running simulation ... "
run(self.params['t_sim'])
self.times['t_sim'] = self.timer.diff()
def print_results(self, print_v=True):
"""
# # # # # # # # # # # # # # # # #
# P R I N T R E S U L T S #
# # # # # # # # # # # # # # # # #
"""
if print_v:
if self.pc_id == 0:
print 'print_v to file: %s.v' % (self.params['exc_volt_fn_base'])
self.exc_pop_view.print_v("%s.v" % (self.params['exc_volt_fn_base']), compatible_output=False)
if self.pc_id == 0:
print "Printing inhibitory membrane potentials"
self.inh_pop_view.print_v("%s.v" % (self.params['inh_volt_fn_base']), compatible_output=False)
print 'DEBUG printing anticipatory cells', self.anticipatory_record
if self.anticipatory_record == True:
print 'print_v to file: %s' % (self.params['exc_volt_anticipation'])
self.exc_pop_view_anticipation.print_v("%s" % (self.params['exc_volt_anticipation']), compatible_output=False)
print 'print_gsyn to file: %s' % (self.params['exc_gsyn_anticipation'])
self.exc_pop_view_anticipation.print_gsyn("%s" % (self.params['exc_gsyn_anticipation']), compatible_output=False)
if self.pc_id == 0:
print "Printing excitatory spikes"
self.exc_pop.printSpikes(self.params['exc_spiketimes_fn_merged'] + '.ras')
if self.pc_id == 0:
print "Printing inhibitory spikes"
self.inh_pop.printSpikes(self.params['inh_spiketimes_fn_merged'] + '.ras')
self.times['t_print'] = self.timer.diff()
if self.pc_id == 0:
print "calling pyNN.end() ...."
end()
self.times['t_end'] = self.timer.diff()
if self.pc_id == 0:
self.times['t_all'] = 0.
for k in self.times.keys():
self.times['t_all'] += self.times[k]
self.n_cells = {}
self.n_cells['n_exc'] = self.params['n_exc']
self.n_cells['n_inh'] = self.params['n_inh']
self.n_cells['n_cells'] = self.params['n_cells']
self.n_cells['n_proc'] = self.n_proc
output = {'times' : self.times, 'n_cells_proc' : self.n_cells}
print "Proc %d Simulation time: %d sec or %.1f min for %d cells (%d exc %d inh)" % (self.pc_id, self.times['t_sim'], (self.times['t_sim'])/60., self.params['n_cells'], self.params['n_exc'], self.params['n_inh'])
print "Proc %d Full pyNN run time: %d sec or %.1f min for %d cells (%d exc %d inh)" % (self.pc_id, self.times['t_all'], (self.times['t_all'])/60., self.params['n_cells'], self.params['n_exc'], self.params['n_inh'])
fn = utils.convert_to_url(params['folder_name'] + 'times_dict_np%d.py' % self.n_proc)
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
class NetworkModel(object):
def __init__(self, params, comm):
self.params = params
self.debug_connectivity = True
self.comm = comm
if self.comm != None:
self.pc_id, self.n_proc = self.comm.rank, self.comm.size
print "USE_MPI: yes", '\tpc_id, n_proc:', self.pc_id, self.n_proc
else:
self.pc_id, self.n_proc = 0, 1
print "MPI not used"
def import_pynn(self):
"""
This function needs only be called when this class is used in another script as imported module
"""
import pyNN
exec("from pyNN.%s import *" % self.params['simulator'])
print 'import pyNN\npyNN.version: ', pyNN.__version__
def setup(self, load_tuning_prop=False):
if load_tuning_prop:
print 'Loading tuning properties from', self.params['tuning_prop_means_fn']
self.tuning_prop_exc = np.loadtxt(self.params['tuning_prop_means_fn'])
else:
print 'Preparing tuning properties with limited range....'
x_range = (0, 1.)
y_range = (0.2, .5)
u_range = (.05, 1.0)
v_range = (-.2, .2)
tp_exc_good, tp_exc_out_of_range = utils.set_limited_tuning_properties(params, y_range, x_range, u_range, v_range, cell_type='exc')
self.tuning_prop_exc = tp_exc_good
print 'n_exc within range: ', tp_exc_good[:, 0].size
print "Saving tuning_prop to file:", params['tuning_prop_means_fn']
np.savetxt(params['tuning_prop_means_fn'], tp_exc_good)
indices, distances = utils.sort_gids_by_distance_to_stimulus(self.tuning_prop_exc, self.params['motion_params'], self.params) # cells in indices should have the highest response to the stimulus
if self.pc_id == 0:
print "Saving tuning_prop to file:", self.params['tuning_prop_means_fn']
np.savetxt(self.params['tuning_prop_means_fn'], self.tuning_prop_exc)
print 'Saving gids to record to: ', self.params['gids_to_record_fn']
np.savetxt(self.params['gids_to_record_fn'], indices[:self.params['n_gids_to_record']], fmt='%d')
# np.savetxt(params['gids_to_record_fn'], indices[:params['n_gids_to_record']], fmt='%d')
if self.comm != None:
self.comm.Barrier()
from pyNN.utility import Timer
self.timer = Timer()
self.timer.start()
self.times = {}
# # # # # # # # # # # #
# S E T U P #
# # # # # # # # # # # #
(delay_min, delay_max) = self.params['delay_range']
setup(timestep=0.1, min_delay=delay_min, max_delay=delay_max, rng_seeds_seed=self.params['seed'])
rng_v = NumpyRNG(seed = sim_cnt*3147 + self.params['seed'], parallel_safe=True) #if True, slower but does not depend on number of nodes
self.rng_conn = NumpyRNG(seed = self.params['seed'], parallel_safe=True) #if True, slower but does not depend on number of nodes
# # # # # # # # # # # # # # # # # # # # # # # # #
# R A N D O M D I S T R I B U T I O N S #
# # # # # # # # # # # # # # # # # # # # # # # # #
self.v_init_dist = RandomDistribution('normal',
(self.params['v_init'], self.params['v_init_sigma']),
rng=rng_v,
constrain='redraw',
boundaries=(-80, -60))
self.times['t_setup'] = self.timer.diff()
self.times['t_calc_conns'] = 0
if self.comm != None:
self.comm.Barrier()
def create_neurons_with_limited_tuning_properties(self, input_created):
n_exc = self.tuning_prop_exc[:, 0].size
n_inh = 0
if self.params['neuron_model'] == 'IF_cond_exp':
self.exc_pop = Population(n_exc, IF_cond_exp, self.params['cell_params_exc'], label='exc_cells')
elif self.params['neuron_model'] == 'EIF_cond_exp_isfa_ista':
self.exc_pop = Population(n_exc, EIF_cond_exp_isfa_ista, self.params['cell_params_exc'], label='exc_cells')
else:
print '\n\nUnknown neuron model:\n\t', self.params['neuron_model']
self.local_idx_exc = get_local_indices(self.exc_pop, offset=0)
self.exc_pop.initialize('v', self.v_init_dist)
if not input_created:
self.spike_times_container = [ [] for i in xrange(len(self.local_idx_exc))]
# self.local_idx_inh = get_local_indices(self.inh_pop, offset=self.params['n_exc'])
# print 'Debug, pc_id %d has local %d inh indices:' % (self.pc_id, len(self.local_idx_inh)), self.local_idx_inh
# self.inh_pop.initialize('v', self.v_init_dist)
self.times['t_create'] = self.timer.diff()
def create(self):
"""
# # # # # # # # # # # #
# C R E A T E #
# # # # # # # # # # # #
"""
if self.params['neuron_model'] == 'IF_cond_exp':
self.exc_pop = Population(self.params['n_exc'], IF_cond_exp, self.params['cell_params_exc'], label='exc_cells')
self.inh_pop = Population(self.params['n_inh'], IF_cond_exp, self.params['cell_params_inh'], label="inh_pop")
# elif self.params['neuron_model'] == 'EIF_cond_exp_isfa_ista':
elif self.params['neuron_model'] == 'EIF_cond_alpha_isfa_ista':
self.exc_pop = Population(self.params['n_exc'], EIF_cond_exp_isfa_ista, self.params['cell_params_exc'], label='exc_cells')
self.inh_pop = Population(self.params['n_inh'], EIF_cond_exp_isfa_ista, self.params['cell_params_inh'], label="inh_pop")
else:
print '\n\nUnknown neuron model:\n\t', self.params['neuron_model']
self.local_idx_exc = get_local_indices(self.exc_pop, offset=0)
if not input_created:
self.spike_times_container = [ [] for i in xrange(len(self.local_idx_exc))]
self.exc_pop.initialize('v', self.v_init_dist)
self.local_idx_inh = get_local_indices(self.inh_pop, offset=self.params['n_exc'])
self.inh_pop.initialize('v', self.v_init_dist)
self.times['t_create'] = self.timer.diff()
def connect(self):
self.connect_input_to_exc()
self.connect_populations('ee')
# self.connect_populations('ei')
# self.connect_populations('ie')
# self.connect_populations('ii')
self.connect_noise()
self.times['t_connect'] = self.timer.diff()
if self.comm != None:
self.comm.Barrier()
def create_input(self, load_files=False, save_output=False):
if load_files:
if self.pc_id == 0:
print "Loading input spiketrains..."
for i_, tgt in enumerate(self.local_idx_exc):
try:
fn = self.params['input_st_fn_base'] + str(tgt) + '.npy'
spike_times = np.load(fn)
except: # this cell does not get any input
print "Missing file: ", fn
spike_times = []
self.spike_times_container[i_] = spike_times
else:
if self.pc_id == 0:
print "Computing input spiketrains..."
nprnd.seed(self.params['input_spikes_seed'])
dt = self.params['dt_rate'] # [ms] time step for the non-homogenous Poisson process
time = np.arange(0, self.params['t_sim'], dt)
blank_idx = np.arange(1./dt * self.params['t_before_blank'], 1. / dt * (self.params['t_before_blank'] + self.params['t_blank']))
my_units = self.local_idx_exc
n_cells = len(my_units)
L_input = np.zeros((n_cells, time.shape[0]))
# get the input signal
for i_time, time_ in enumerate(time):
if (i_time % 500 == 0):
print "t:", time_
L_input[:, i_time] = utils.get_input(self.tuning_prop_exc[my_units, :], self.params, time_/1000.)
# L_input[:, i_time] = utils.get_input(self.tuning_prop_exc[my_units, :], self.params, time_/self.params['t_stimulus'])
L_input[:, i_time] *= self.params['f_max_stim']
# blanking
for i_time in blank_idx:
L_input[:, i_time] = 0.
# create the spike trains
for i_, unit in enumerate(my_units):
rate_of_t = np.array(L_input[i_, :])
# each cell will get its own spike train stored in the following file + cell gid
n_steps = rate_of_t.size
spike_times = []
for i in xrange(n_steps):
r = nprnd.rand()
if (r <= ((rate_of_t[i]/1000.) * dt)): # rate is given in Hz -> 1/1000.
spike_times.append(i * dt)
self.spike_times_container[i_] = spike_times
if save_output:
output_fn = self.params['input_rate_fn_base'] + str(unit) + '.npy'
np.save(output_fn, rate_of_t)
output_fn = self.params['input_st_fn_base'] + str(unit) + '.npy'
np.save(output_fn, np.array(spike_times))
self.times['create_input'] = self.timer.diff()
return self.spike_times_container
def connect_input_to_exc(self):
"""
# # # # # # # # # # # # # # # # # # # # # #
# C O N N E C T I N P U T - E X C #
# # # # # # # # # # # # # # # # # # # # # #
"""
if self.pc_id == 0:
print "Connecting input spiketrains..."
for i_, unit in enumerate(self.local_idx_exc):
spike_times = self.spike_times_container[i_]
ssa = create(SpikeSourceArray, {'spike_times': spike_times})
connect(ssa, self.exc_pop[unit], self.params['w_input_exc'], synapse_type='excitatory')
self.times['connect_input'] = self.timer.diff()
def connect_anisotropic(self, conn_type):
"""
"""
if self.pc_id == 0:
print 'Connect anisotropic %s - %s' % (conn_type[0].capitalize(), conn_type[1].capitalize())
(n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type) = self.resolve_src_tgt(conn_type)
if self.debug_connectivity:
conn_list_fn = self.params['conn_list_%s_fn_base' % conn_type] + '%d.dat' % (self.pc_id)
conn_file = open(conn_list_fn, 'w')
output = ''
n_src_cells_per_neuron = int(round(self.params['p_%s' % conn_type] * n_src))
(delay_min, delay_max) = self.params['delay_range']
for tgt in tgt_cells:
p = np.zeros(n_src)
latency = np.zeros(n_src)
for src in xrange(n_src):
if conn_type[0] == conn_type[1]: # no self-connection
if (src != tgt):
p[src], latency[src] = CC.get_p_conn(tp_src[src, :], tp_tgt[tgt, :], params['w_sigma_x'], params['w_sigma_v']) # print 'debug pc_id src tgt ', self.pc_id, src, tgt#, int(ID) < self.params['n_exc']
else: # different populations --> same indices mean different cells, no check for src != tgt
p[src], latency[src] = CC.get_p_conn(tp_src[src, :], tp_tgt[tgt, :], params['w_sigma_x'], params['w_sigma_v']) # print 'debug pc_id src tgt ', self.pc_id, src, tgt#, int(ID) < self.params['n_exc']
sorted_indices = np.argsort(p)
if conn_type[0] == 'e':
sources = sorted_indices[-n_src_cells_per_neuron:]
else:
if conn_type == 'ii':
sources = sorted_indices[1:n_src_cells_per_neuron+1] # shift indices to avoid self-connection, because p_ii = .0
else:
sources = sorted_indices[:n_src_cells_per_neuron]
w = (self.params['w_tgt_in_per_cell_%s' % conn_type] / p[sources].sum()) * p[sources]
for i in xrange(len(sources)):
if w[i] > self.params['w_thresh_connection']:
# w[i] = max(self.params['w_min'], min(w[i], self.params['w_max']))
delay = min(max(latency[sources[i]] * self.params['t_stimulus'], delay_min), delay_max) # map the delay into the valid range
# print 'debug ', delay , ' latency', latency[sources[i]]
# delay = min(max(latency[sources[i]] * self.params['delay_scale'], delay_min), delay_max) # map the delay into the valid range
connect(src_pop[sources[i]], tgt_pop[tgt], w[i], delay=delay, synapse_type=syn_type)
if self.debug_connectivity:
output += '%d\t%d\t%.2e\t%.2e\n' % (sources[i], tgt, w[i], delay) # output += '%d\t%d\t%.2e\t%.2e\t%.2e\n' % (sources[i], tgt, w[i], latency[sources[i]], p[sources[i]])
if self.debug_connectivity:
if self.pc_id == 0:
print 'DEBUG writing to file:', conn_list_fn
conn_file.write(output)
conn_file.close()
def resolve_src_tgt(self, conn_type):
"""
Deliver the correct source and target parameters based on conn_type
"""
if conn_type == 'ee':
n_src, n_tgt = self.tuning_prop_exc[:, 0].size, self.tuning_prop_exc[:, 0].size
src_pop, tgt_pop = self.exc_pop, self.exc_pop
tgt_cells = self.local_idx_exc
tp_src = self.tuning_prop_exc
tp_tgt = self.tuning_prop_exc
syn_type = 'excitatory'
elif conn_type == 'ei':
n_src, n_tgt = self.tuning_prop_exc[:, 0].size, self.tuning_prop_inh[:, 0].size
src_pop, tgt_pop = self.exc_pop, self.inh_pop
tgt_cells = self.local_idx_inh
tp_src = self.tuning_prop_exc
tp_tgt = self.tuning_prop_inh
syn_type = 'excitatory'
elif conn_type == 'ie':
n_src, n_tgt = self.tuning_prop_inh[:, 0].size, self.tuning_prop_exc[:, 0].size
src_pop, tgt_pop = self.inh_pop, self.exc_pop
tgt_cells = self.local_idx_exc
tp_src = self.tuning_prop_inh
tp_tgt = self.tuning_prop_exc
syn_type = 'inhibitory'
elif conn_type == 'ii':
n_src, n_tgt = self.tuning_prop_inh[:, 0].size, self.tuning_prop_inh[:, 0].size
src_pop, tgt_pop = self.inh_pop, self.inh_pop
tgt_cells = self.local_idx_inh
tp_src = self.tuning_prop_inh
tp_tgt = self.tuning_prop_inh
syn_type = 'inhibitory'
return (n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type)
def connect_isotropic(self, conn_type='ee'):
"""
conn_type must be 'ee', 'ei', 'ie' or 'ii'
Connect cells in a distant dependent manner:
p_ij = exp(- d_ij / (2 * w_sigma_x**2))
This will give a 'convergence constrained' connectivity, i.e. each cell will have the same sum of incoming weights
---> could be problematic for outlier cells
"""
if self.pc_id == 0:
print 'Connect isotropic %s - %s' % (conn_type[0].capitalize(), conn_type[1].capitalize())
(n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type) = self.resolve_src_tgt(conn_type)
if conn_type == 'ee':
w_= self.params['w_max']
w_tgt_in = params['w_tgt_in_per_cell_%s' % conn_type]
elif conn_type == 'ei':
w_= self.params['w_ie_mean']
w_tgt_in = params['w_tgt_in_per_cell_%s' % conn_type]
elif conn_type == 'ie':
w_= self.params['w_ie_mean']
w_tgt_in = params['w_tgt_in_per_cell_%s' % conn_type]
elif conn_type == 'ii':
w_= self.params['w_ii_mean']
w_tgt_in = params['w_tgt_in_per_cell_%s' % conn_type]
if self.debug_connectivity:
conn_list_fn = self.params['conn_list_%s_fn_base' % conn_type] + '%d.dat' % (self.pc_id)
conn_file = open(conn_list_fn, 'w')
output = ''
p_max = utils.get_pmax(self.params['p_%s' % conn_type])
for tgt in tgt_cells:
w = np.zeros(n_src, dtype='float32')
delays = np.zeros(n_src, dtype='float32')
for src in xrange(n_src):
if (src != tgt):
# d_ij = np.sqrt((tp_src[src, 0] - tp_tgt[tgt, 0])**2 + (tp_src[src, 1] - tp_tgt[tgt, 1])**2)
d_ij = utils.torus_distance2D(tp_src[src, 0], tp_tgt[tgt, 0], tp_src[src, 1], tp_tgt[tgt, 1])
p_ij = p_max * np.exp(-d_ij / (2 * params['w_sigma_x']**2))
if np.random.rand() <= p_ij:
w[src] = w_
delays[src] = d_ij * self.params['delay_scale']
w *= w_tgt_in / w.sum()
srcs = w.nonzero()[0]
for src in srcs:
if w[src] > self.params['w_thresh_connection']:
delay = min(max(delays[src], self.params['delay_range'][0]), self.params['delay_range'][1]) # map the delay into the valid range
connect(src_pop[int(src)], tgt_pop[int(tgt)], w[src], delay=delay, synapse_type=syn_type)
output += '%d\t%d\t%.2e\t%.2e\n' % (src, tgt, w[src], delay)
# connect(src_pop[int(src)], tgt_pop[int(tgt)], w[src], delay=params['standard_delay'], synapse_type=syn_type)
# output += '%d\t%d\t%.2e\t%.2e\n' % (src, tgt, w[src], params['standard_delay'])
if self.debug_connectivity:
if self.pc_id == 0:
print 'DEBUG writing to file:', conn_list_fn
conn_file.write(output)
conn_file.close()
# isotropic nearest neighbour code:
# for tgt in tgt_cells:
# n_src_to_choose = int(round(p_max * n_src)) # guarantee that all cells have same number of connections
# dist = np.zeros(n_src, dtype='float32')
# for src in xrange(n_src):
# if (src != tgt):
# dist[src] = np.sqrt((tp_src[src, 0] - tp_tgt[tgt, 0])**2 + (tp_src[src, 1] - tp_tgt[tgt, 1])**2)
# src_idx = dist.argsort()[:n_src_to_choose] # choose cells closest to the target
# for src in src_idx:
# connect(src_pop[int(src)], tgt_pop[int(tgt)], w_, delay=params['standard_delay'], synapse_type='excitatory')
# output += '%d\t%d\t%.2e\t%.2e\n' % (src, tgt, w_, params['standard_delay'])
def connect_random(self, conn_type):
"""
There exist different possibilities to draw random connections:
1) Calculate the weights as for the anisotropic case and sample sources randomly
2) Load a file which stores some random connectivity --> # connector = FromFileConnector(self.params['conn_list_.... ']
3) Create a random distribution with similar parameters as the non-random connectivition distribution
connector_ee = FastFixedProbabilityConnector(self.params['p_ee'], weights=w_ee_dist, delays=self.delay_dist)
prj_ee = Projection(self.exc_pop, self.exc_pop, connector_ee, target='excitatory')
conn_list_fn = self.params['random_weight_list_fn'] + str(sim_cnt) + '.dat'
print "Connecting exc - exc from file", conn_list_fn
connector_ee = FromFileConnector(conn_list_fn)
prj_ee = Projection(self.exc_pop, self.exc_pop, connector_ee, target='excitatory')
"""
if self.pc_id == 0:
print 'Connect random connections %s - %s' % (conn_type[0].capitalize(), conn_type[1].capitalize())
(n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type) = self.resolve_src_tgt(conn_type)
w_mean = self.params['w_tgt_in_per_cell_%s' % conn_type] / (n_src * self.params['p_%s' % conn_type])
w_sigma = w_mean * .5 * (self.params['w_sigma_x'] + self.params['w_sigma_v'])
weight_distr = RandomDistribution('normal',
(w_mean, w_sigma),
rng=self.rng_conn,
constrain='redraw',
boundaries=(0, w_mean * 10.))
delay_dist = RandomDistribution('normal',
(self.params['standard_delay'], self.params['standard_delay_sigma']),
rng=self.rng_conn,
constrain='redraw',
boundaries=(self.params['delay_range'][0], self.params['delay_range'][1]))
connector= FastFixedProbabilityConnector(self.params['p_%s' % conn_type], weights=weight_distr, delays=delay_dist)
prj = Projection(src_pop, tgt_pop, connector, target=syn_type)
conn_list_fn = self.params['conn_list_%s_fn_base' % conn_type] + '%d.dat' % (self.pc_id)
print 'Saving random %s connections to %s' % (conn_type, conn_list_fn)
prj.saveConnections(conn_list_fn, gather=False)
def connect_populations(self, conn_type):
"""
# # # # # # # # # # # #
# C O N N E C T #
# # # # # # # # # # # #
Calls the right according to the flag set in simultation_parameters.py
"""
if self.params['connectivity_%s' % conn_type] == 'anisotropic':
self.connect_anisotropic(conn_type)
elif self.params['connectivity_%s' % conn_type] == 'isotropic':
self.connect_isotropic(conn_type)
elif self.params['connectivity_%s' % conn_type] == 'random':
self.connect_random(conn_type)
else: # populations do not get connected
pass
self.times['t_calc_conns'] += self.timer.diff()
def connect_noise(self):
"""
# # # # # # # # # # # # # # # #
# N O I S E I N P U T #
# # # # # # # # # # # # # # # #
"""
if self.pc_id == 0:
print "Connecting noise - exc ... "
noise_pop_exc = []
noise_pop_inh = []
for tgt in self.local_idx_exc:
#new
if (self.params['simulator'] == 'nest'): # for nest one can use the optimized Poisson generator
noise_exc = create(native_cell_type('poisson_generator'), {'rate' : self.params['f_exc_noise']})
noise_inh = create(native_cell_type('poisson_generator'), {'rate' : self.params['f_inh_noise']})
else:
noise_exc = create(SpikeSourcePoisson, {'rate' : self.params['f_exc_noise']})
noise_inh = create(SpikeSourcePoisson, {'rate' : self.params['f_inh_noise']})
connect(noise_exc, self.exc_pop[tgt], weight=self.params['w_exc_noise'], synapse_type='excitatory', delay=1.)
connect(noise_inh, self.exc_pop[tgt], weight=self.params['w_inh_noise'], synapse_type='inhibitory', delay=1.)
# if self.pc_id == 0:
# print "Connecting noise - inh ... "
# for tgt in self.local_idx_inh:
# if (self.params['simulator'] == 'nest'): # for nest one can use the optimized Poisson generator
# noise_exc = create(native_cell_type('poisson_generator'), {'rate' : self.params['f_exc_noise']})
# noise_inh = create(native_cell_type('poisson_generator'), {'rate' : self.params['f_inh_noise']})
# else:
# noise_exc = create(SpikeSourcePoisson, {'rate' : self.params['f_exc_noise']})
# noise_inh = create(SpikeSourcePoisson, {'rate' : self.params['f_inh_noise']})
# connect(noise_exc, self.inh_pop[tgt], weight=self.params['w_exc_noise'], synapse_type='excitatory', delay=1.)
# connect(noise_inh, self.inh_pop[tgt], weight=self.params['w_inh_noise'], synapse_type='inhibitory', delay=1.)
def run_sim(self, sim_cnt, record_v=True):
# # # # # # # # # # # # # # # # # # # #
# P R I N T W E I G H T S #
# # # # # # # # # # # # # # # # # # # #
record_exc = True
if os.path.exists(self.params['gids_to_record_fn']):
gids_to_record = np.loadtxt(self.params['gids_to_record_fn'], dtype='int')[:self.params['n_gids_to_record']]
record_exc = True
n_rnd_cells_to_record = 2
else:
n_cells_to_record = 5# self.params['n_exc'] * 0.02
gids_to_record = np.random.randint(0, self.params['n_exc'], n_cells_to_record)
if record_v:
self.exc_pop_view = PopulationView(self.exc_pop, gids_to_record, label='good_exc_neurons')
self.exc_pop_view.record_v()
self.exc_pop.record()
self.times['t_record'] = self.timer.diff()
if self.pc_id == 0:
print "Running simulation ... "
run(self.params['t_sim'])
self.times['t_sim'] = self.timer.diff()
def print_results(self, print_v=True):
"""
# # # # # # # # # # # # # # # # #
# P R I N T R E S U L T S
# # # # # # # # # # # # # # # # #
"""
if print_v:
if self.pc_id == 0:
print 'print_v to file: %s.v' % (self.params['exc_volt_fn_base'])
self.exc_pop_view.print_v("%s.v" % (self.params['exc_volt_fn_base']), compatible_output=False)
if self.pc_id == 0:
print "Printing excitatory spikes"
self.exc_pop.printSpikes(self.params['exc_spiketimes_fn_merged'] + '.ras')
# print a dummy file for inhibitory
np.savetxt(self.params['inh_spiketimes_fn_merged'] + '.ras', np.array([]))
self.times['t_print'] = self.timer.diff()
if self.pc_id == 0:
print "calling pyNN.end() ...."
end()
self.times['t_end'] = self.timer.diff()
if self.pc_id == 0:
self.times['t_all'] = 0.
for k in self.times.keys():
self.times['t_all'] += self.times[k]
self.n_cells = {}
self.n_cells['n_exc'] = self.params['n_exc']
self.n_cells['n_inh'] = self.params['n_inh']
self.n_cells['n_cells'] = self.params['n_cells']
self.n_cells['n_proc'] = self.n_proc
output = {'times' : self.times, 'n_cells_proc' : self.n_cells}
print "Proc %d Simulation time: %d sec or %.1f min for %d cells (%d exc %d inh)" % (self.pc_id, self.times['t_sim'], (self.times['t_sim'])/60., self.params['n_cells'], self.params['n_exc'], self.params['n_inh'])
print "Proc %d Full pyNN run time: %d sec or %.1f min for %d cells (%d exc %d inh)" % (self.pc_id, self.times['t_all'], (self.times['t_all'])/60., self.params['n_cells'], self.params['n_exc'], self.params['n_inh'])
fn = utils.convert_to_url(params['folder_name'] + 'times_dict_np%d.py' % self.n_proc)
output = ntp.ParameterSet(output)
output.save(fn)
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
def runNetwork(Be,
Bi,
nn_stim,
show_gui=True,
dt = defaultParams.dt,
N_rec_v = 5,
save=False,
simtime = defaultParams.Tpost+defaultParams.Tstim+defaultParams.Tblank+defaultParams.Ttrans,
extra = {},
kernelseed = 123):
exec("from pyNN.%s import *" % simulator_name) in globals()
timer = Timer()
rec_conn={'EtoE':1, 'EtoI':1, 'ItoE':1, 'ItoI':1}
print('####################')
print('### (Be, Bi, nn_stim): ', Be, Bi, nn_stim)
print('####################')
Bee, Bei = Be, Be
Bie, Bii = Bi, Bi
N = defaultParams.N
NE = defaultParams.NE
NI = defaultParams.NI
print('\n # -----> Num cells: %s, size of pert. inh: %s; base rate %s; pert rate %s'% (N, nn_stim, defaultParams.r_bkg, defaultParams.r_stim))
r_extra = np.zeros(N)
r_extra[NE:NE+nn_stim] = defaultParams.r_stim
rr1 = defaultParams.r_bkg*np.random.uniform(.75,1.25, N)
rr2 = rr1 + r_extra
rank = setup(timestep=dt, max_delay=defaultParams.delay_default, reference='ISN', save_format='hdf5', **extra)
print("rank =", rank)
nump = num_processes()
print("num_processes =", nump)
import socket
host_name = socket.gethostname()
print("Host #%d is on %s" % (rank+1, host_name))
if 'threads' in extra:
print("%d Initialising the simulator with %d threads..." % (rank, extra['threads']))
else:
print("%d Initialising the simulator with single thread..." % rank)
timer.start() # start timer on construction
print("%d Setting up random number generator using seed %s" % (rank, kernelseed))
ks = open('kernelseed','w')
ks.write('%i'%kernelseed)
ks.close()
rng = NumpyRNG(kernelseed, parallel_safe=True)
nesp = defaultParams.neuron_params_default
cell_parameters = {
'cm': nesp['C_m']/1000, # Capacitance of the membrane in nF
'tau_refrac': nesp['t_ref'], # Duration of refractory period in ms.
'v_spike': 0.0 , # Spike detection threshold in mV. https://github.com/nest/nest-simulator/blob/master/models/aeif_cond_alpha.cpp
'v_reset': nesp['V_reset'], # Reset value for V_m after a spike. In mV.
'v_rest': nesp['E_L'], # Resting membrane potential (Leak reversal potential) in mV.
'tau_m': nesp['C_m']/nesp['g_L'], # Membrane time constant in ms = cm/tau_m*1000.0, C_m/g_L
'i_offset': nesp['I_e']/1000, # Offset current in nA
'a': 0, # Subthreshold adaptation conductance in nS.
'b': 0, # Spike-triggered adaptation in nA
'delta_T': 2 , # Slope factor in mV. See https://github.com/nest/nest-simulator/blob/master/models/aeif_cond_alpha.cpp
'tau_w': 144.0, # Adaptation time constant in ms. See https://github.com/nest/nest-simulator/blob/master/models/aeif_cond_alpha.cpp
'v_thresh': nesp['V_th'], # Spike initiation threshold in mV
'e_rev_E': nesp['E_ex'], # Excitatory reversal potential in mV.
'tau_syn_E': nesp['tau_syn_ex'], # Rise time of excitatory synaptic conductance in ms (alpha function).
'e_rev_I': nesp['E_in'], # Inhibitory reversal potential in mV.
'tau_syn_I': nesp['tau_syn_in'], # Rise time of the inhibitory synaptic conductance in ms (alpha function).
}
print("%d Creating population with %d neurons." % (rank, N))
celltype = EIF_cond_alpha_isfa_ista(**cell_parameters)
celltype.default_initial_values['v'] = cell_parameters['v_rest'] # Setting default init v, useful for NML2 export
layer_volume = Cuboid(1000,100,1000)
layer_structure = RandomStructure(layer_volume, origin=(0,0,0))
layer_structure_input = RandomStructure(layer_volume, origin=(0,-150,0))
default_cell_radius = 15
stim_cell_radius = 10
#EI_pop = Population(N, celltype, structure=layer_structure, label="EI")
E_pop = Population(NE, celltype, structure=layer_structure, label='E_pop')
E_pop.annotate(color='1 0 0')
E_pop.annotate(radius=default_cell_radius)
E_pop.annotate(type='E') # temp indicator to use for connection arrowhead
#print("%d Creating pop %s." % (rank, E_pop))
I_pop = Population(NI, celltype, structure=layer_structure, label='I_pop')
I_pop.annotate(color='0 0 .9')
I_pop.annotate(radius=default_cell_radius)
I_pop.annotate(type='I') # temp indicator to use for connection arrowhead
#print("%d Creating pop %s." % (rank, I_pop))
I_pert_pop = PopulationView(I_pop, np.array(range(0,nn_stim)),label='I_pert_pop')
I_nonpert_pop = PopulationView(I_pop, np.array(range(nn_stim,NI)),label='I_nonpert_pop')
p_rate = defaultParams.r_bkg
print("%d Creating excitatory Poisson generator with rate %g spikes/s." % (rank, p_rate))
source_typeA_E = SpikeSourcePoisson(rate=p_rate, start=0,duration=defaultParams.Ttrans+defaultParams.Tblank+defaultParams.Tstim+defaultParams.Tpost)
expoissonA_E = Population(NE, source_typeA_E, structure=layer_structure_input, label="stim_E")
print("%d Creating excitatory Poisson generator with rate %g spikes/s." % (rank, p_rate))
source_typeA_I = SpikeSourcePoisson(rate=p_rate, start=0,duration=defaultParams.Ttrans+defaultParams.Tblank)
expoissonA_I = Population(NI, source_typeA_I, structure=layer_structure_input, label="pre_pert_stim_I")
print("%d Creating excitatory Poisson generator with rate %g spikes/s." % (rank, p_rate))
source_typeB = SpikeSourcePoisson(rate=p_rate, start=defaultParams.Ttrans+defaultParams.Tblank,duration=defaultParams.Tstim+defaultParams.Tpost)
#expoissonB_E = Population(NE, source_typeB, label="non_pert_stim_E")
expoissonB_I = Population(len(I_nonpert_pop), source_typeB, structure=layer_structure_input, label="non_pert_stim_I")
p_rate = defaultParams.r_bkg+defaultParams.r_stim
print("%d Creating excitatory Poisson generator with rate %g spikes/s." % (rank, p_rate))
source_typeC = SpikeSourcePoisson(rate=p_rate, start=defaultParams.Ttrans+defaultParams.Tblank, duration=defaultParams.Tstim)
expoissonC = Population(nn_stim, source_typeC, structure=layer_structure_input, label="pert_stim")
p_rate = defaultParams.r_bkg
print("%d Creating excitatory Poisson generator with rate %g spikes/s." % (rank, p_rate))
source_typeD = SpikeSourcePoisson(rate=p_rate, start=defaultParams.Ttrans+defaultParams.Tblank+defaultParams.Tstim, duration=defaultParams.Tpost)
expoissonD = Population(nn_stim, source_typeD, structure=layer_structure_input, label="pert_poststim")
for p in [expoissonA_E,expoissonA_I,expoissonB_I,expoissonC,expoissonD]:
p.annotate(color='0.8 0.8 0.8')
p.annotate(radius=stim_cell_radius)
progress_bar = ProgressBar(width=20)
connector_E = FixedProbabilityConnector(0.15, rng=rng, callback=progress_bar)
connector_I = FixedProbabilityConnector(1, rng=rng, callback=progress_bar)
EE_syn = StaticSynapse(weight=0.001*Bee, delay=defaultParams.delay_default)
EI_syn = StaticSynapse(weight=0.001*Bei, delay=defaultParams.delay_default)
II_syn = StaticSynapse(weight=0.001*Bii, delay=defaultParams.delay_default)
IE_syn = StaticSynapse(weight=0.001*Bie, delay=defaultParams.delay_default)
#I_syn = StaticSynapse(weight=JI, delay=delay)
ext_Connector = OneToOneConnector(callback=progress_bar)
ext_syn_bkg = StaticSynapse(weight=0.001*defaultParams.Be_bkg, delay=defaultParams.delay_default)
ext_syn_stim = StaticSynapse(weight=0.001*defaultParams.Be_stim, delay=defaultParams.delay_default)
E_to_E = Projection(E_pop, E_pop, connector_E, EE_syn, receptor_type="excitatory")
print("E --> E\t\t", len(E_to_E), "connections")
E_to_I = Projection(E_pop, I_pop, connector_E, EI_syn, receptor_type="excitatory")
print("E --> I\t\t", len(E_to_I), "connections")
I_to_I = Projection(I_pop, I_pop, connector_I, II_syn, receptor_type="inhibitory")
print("I --> I\t\t", len(I_to_I), "connections")
I_to_E = Projection(I_pop, E_pop, connector_I, IE_syn, receptor_type="inhibitory")
print("I --> E\t\t", len(I_to_E), "connections")
input_A_E = Projection(expoissonA_E, E_pop, ext_Connector, ext_syn_bkg, receptor_type="excitatory")
print("input --> %s cells pre pert\t"%len(E_pop), len(input_A_E), "connections")
input_A_I = Projection(expoissonA_I, I_pop, ext_Connector, ext_syn_bkg, receptor_type="excitatory")
print("input --> %s cells pre pert\t"%len(I_pop), len(input_A_I), "connections")
##input_B_E = Projection(expoissonB_E, E_pop, ext_Connector, ext_syn_bkg, receptor_type="excitatory")
##print("input --> %s cells post pert\t"%len(E_pop), len(input_B_E), "connections")
input_B_I = Projection(expoissonB_I, I_nonpert_pop, ext_Connector, ext_syn_bkg, receptor_type="excitatory")
print("input --> %s cells post pert\t"%len(I_nonpert_pop), len(input_B_I), "connections")
input_C = Projection(expoissonC, I_pert_pop, ext_Connector, ext_syn_stim, receptor_type="excitatory")
print("input --> %s cells pre pert\t"%len(I_pert_pop), len(input_C), "connections")
input_D = Projection(expoissonD, I_pert_pop, ext_Connector, ext_syn_stim, receptor_type="excitatory")
print("input --> %s cells pre pert\t"%len(I_pert_pop), len(input_D), "connections")
# Can't be used for connections etc. as NeuroML export not (yet) supported
EI_pop = Assembly(E_pop, I_pop, label='EI')
# Record spikes
print("%d Setting up recording in excitatory population." % rank)
EI_pop.record('spikes')
if N_rec_v>0:
EI_pop[0:min(N,N_rec_v)].record('v')
# read out time used for building
buildCPUTime = timer.elapsedTime()
# === Run simulation ===========================================================
# run, measure computer time
timer.start() # start timer on construction
print("%d Running simulation in %s for %g ms (dt=%sms)." % (rank, simulator_name, simtime, dt))
run(simtime)
print("Done")
simCPUTime = timer.elapsedTime()
# write data to file
if save and not simulator_name=='neuroml':
for pop in [EI_pop]:
filename="ISN-%s-%s-%i.gdf"%(simulator_name, pop.label, rank)
ff = open(filename, 'w')
spikes = pop.get_data('spikes', gather=False)
spiketrains = spikes.segments[0].spiketrains
print('Saving data recorded for %i spiketrains in pop %s, indices: %s, ids: %s to %s'% \
(len(spiketrains),
pop.label,
[s.annotations['source_index'] for s in spiketrains],
[s.annotations['source_id'] for s in spiketrains],
filename))
for spiketrain_i in range(len(spiketrains)):
spiketrain = spiketrains[spiketrain_i]
source_id = spiketrain.annotations['source_id']
source_index = spiketrain.annotations['source_index']
#print("Writing spike data for cell %s[%s] (gid: %i): %i spikes: [%s,...,%s] "%(pop.label,source_index, source_id, len(spiketrain),spiketrain[0],spiketrain[-1]))
for t in spiketrain:
ff.write('%s\t%i\n'%(t.magnitude,spiketrain_i))
ff.close()
vs = pop.get_data('v', gather=False)
for segment in vs.segments:
for i in range(len(segment.analogsignals[0].transpose())):
filename="ISN-%s-%s-cell%i.dat"%(simulator_name, pop.label, i)
print('Saving cell %i in %s to %s'%(i,pop.label,filename))
vm = segment.analogsignals[0].transpose()[i]
tt = np.array([t*dt/1000. for t in range(len(vm))])
times_vm = np.array([tt, vm/1000.]).transpose()
np.savetxt(filename, times_vm , delimiter = '\t', fmt='%s')
spike_data = {}
spike_data['senders'] = []
spike_data['times'] = []
index_offset = 1
for pop in [EI_pop]:
if rank == 0:
spikes = pop.get_data('spikes', gather=False)
#print(spikes.segments[0].all_data)
num_rec = len(spikes.segments[0].spiketrains)
print("Extracting spike info (%i) for %i cells in %s"%(num_rec,pop.size,pop.label))
#assert(num_rec==len(spikes.segments[0].spiketrains))
for i in range(num_rec):
ss = spikes.segments[0].spiketrains[i]
for s in ss:
index = i+index_offset
#print("Adding spike at %s in %s[%i] (cell %i)"%(s,pop.label,i,index))
spike_data['senders'].append(index)
spike_data['times'].append(s)
index_offset+=pop.size
print("Build time : %g s" % buildCPUTime)
print("Simulation time : %g s" % simCPUTime)
# === Clean up and quit ========================================================
end()
def test_va_benchmark(self):
simulator_name = 'spiNNaker'
timer = Timer()
# === Define parameters ========================================================
rngseed = 98766987
parallel_safe = True
n = 1500 # number of cells
r_ei = 4.0 # number of excitatory cells:number of inhibitory cells
pconn = 0.02 # connection probability
dt = 0.1 # (ms) simulation timestep
tstop = 200 # (ms) simulaton duration
delay = 1
# Cell parameters
area = 20000. # (µm²)
tau_m = 20. # (ms)
cm = 1. # (µF/cm²)
g_leak = 5e-5 # (S/cm²)
e_leak = -49. # (mV)
v_thresh = -50. # (mV)
v_reset = -60. # (mV)
t_refrac = 5. # (ms) (clamped at v_reset)
v_mean = -60. # (mV) 'mean' membrane potential, for calculating CUBA weights
tau_exc = 5. # (ms)
tau_inh = 10. # (ms)
g_exc = 0.27 # (nS) #Those weights should be similar to the COBA weights
g_inh = 4.5 # (nS) # but the delpolarising drift should be taken into account
e_rev_exc = 0. # (mV)
e_rev_inh = -80. # (mV)
# === Calculate derived parameters =============================================
area *= 1e-8 # convert to cm²
cm *= area * 1000 # convert to nF
r_m = 1e-6 / (g_leak * area) # membrane resistance in MΩ
assert tau_m == cm * r_m # just to check
n_exc = int(round((n * r_ei / (1 + r_ei)))) # number of excitatory cells
n_inh = n - n_exc # number of inhibitory cells
print n_exc, n_inh
celltype = IF_curr_exp
w_exc = 1e-3 * g_exc * (e_rev_exc - v_mean) # (nA) weight of excitatory synapses
w_inh = 1e-3 * g_inh * (e_rev_inh - v_mean) # (nA)
assert w_exc > 0
assert w_inh < 0
# === Build the network ========================================================
setup(timestep=dt, min_delay=delay, max_delay=delay)
if simulator_name == 'spiNNaker':
set_number_of_neurons_per_core('IF_curr_exp', 100) # this will set 100 neurons per core
set_number_of_neurons_per_core('IF_cond_exp', 50) # this will set 50 neurons per core
node_id = 1
np = 1
host_name = socket.gethostname()
print "Host #%d is on %s" % (np, host_name)
cell_params = {
'tau_m': tau_m, 'tau_syn_E': tau_exc, 'tau_syn_I': tau_inh,
'v_rest': e_leak, 'v_reset': v_reset, 'v_thresh': v_thresh,
'cm': cm, 'tau_refrac': t_refrac, 'i_offset': 0}
print cell_params
timer.start()
print "%s Creating cell populations..." % node_id
exc_cells = Population(n_exc, celltype, cell_params,
label="Excitatory_Cells")
inh_cells = Population(n_inh, celltype, cell_params,
label="Inhibitory_Cells")
NativeRNG(12345)
print "%s Initialising membrane potential to random values..." % node_id
rng = NumpyRNG(seed=rngseed, parallel_safe=parallel_safe)
uniform_distr = RandomDistribution('uniform', [v_reset, v_thresh],
rng=rng)
exc_cells.initialize('v', uniform_distr)
inh_cells.initialize('v', uniform_distr)
print "%s Connecting populations..." % node_id
exc_conn = FixedProbabilityConnector(pconn, weights=w_exc, delays=delay)
inh_conn = FixedProbabilityConnector(pconn, weights=w_inh, delays=delay)
connections = dict()
connections['e2e'] = Projection(exc_cells, exc_cells, exc_conn,
target='excitatory', rng=rng)
connections['e2i'] = Projection(exc_cells, inh_cells, exc_conn,
target='excitatory', rng=rng)
connections['i2e'] = Projection(inh_cells, exc_cells, inh_conn,
target='inhibitory', rng=rng)
connections['i2i'] = Projection(inh_cells, inh_cells, inh_conn,
target='inhibitory', rng=rng)
# === Setup recording ==============================
print "%s Setting up recording..." % node_id
exc_cells.record()
# === Run simulation ================================
print "%d Running simulation..." % node_id
print "timings: number of neurons:", n
print "timings: number of synapses:", n * n * pconn
run(tstop)
# === Print results to file ===============================
print "%d Writing data to file..." % node_id
if not(os.path.isdir('Results')):
os.mkdir('Results')
exc_spikes = exc_cells.getSpikes()
current_file_path = os.path.dirname(os.path.abspath(__file__))
current_file_path = os.path.join(current_file_path, "spikes.data")
# exc_cells.printSpikes(current_file_path)
pre_recorded_spikes = utility_calls.read_spikes_from_file(
current_file_path, 0, n_exc, 0, tstop)
end()
for spike_element, read_element in zip(exc_spikes, pre_recorded_spikes):
self.assertEqual(round(spike_element[0], 1),
round(read_element[0], 1))
self.assertEqual(round(spike_element[1], 1),
round(read_element[1], 1))
def test(cases=[1]):
sp = Space(periodic_boundaries=((0,1), (0,1), None))
safe = False
verbose = True
autapse = False
parallel_safe = True
render = True
for case in cases:
#w = RandomDistribution('uniform', (0,1))
w = "0.2 + d/0.2"
#w = 0.1
#w = lambda dist : 0.1 + numpy.random.rand(len(dist[0]))*sqrt(dist[0]**2 + dist[1]**2)
#delay = RandomDistribution('uniform', (0.1,5.))
delay = "0.1 + d/0.2"
#delay = 0.1
#delay = lambda distances : 0.1 + numpy.random.rand(len(distances))*distances
d_expression = "d < 0.1"
#d_expression = "(d[0] < 0.05) & (d[1] < 0.05)"
#d_expression = "(d[0]/(0.05**2) + d[1]/(0.1**2)) < 100*numpy.random.rand()"
timer = Timer()
np = num_processes()
timer.start()
if case is 1:
conn = DistanceDependentProbabilityConnector(d_expression, delays=delay, weights=w, space=sp, safe=safe, verbose=verbose, allow_self_connections=autapse)
fig_name = "DistanceDependent_%s_np_%d.png" %(simulator_name, np)
elif case is 2:
conn = FixedProbabilityConnector(0.05, weights=w, delays=delay, space=sp, safe=safe, verbose=verbose, allow_self_connections=autapse)
fig_name = "FixedProbability_%s_np_%d.png" %(simulator_name, np)
elif case is 3:
conn = AllToAllConnector(delays=delay, weights=w, space=sp, safe=safe, verbose=verbose, allow_self_connections=autapse)
fig_name = "AllToAll_%s_np_%d.png" %(simulator_name, np)
elif case is 4:
conn = FixedNumberPostConnector(50, weights=w, delays=delay, space=sp, safe=safe, verbose=verbose, allow_self_connections=autapse)
fig_name = "FixedNumberPost_%s_np_%d.png" %(simulator_name, np)
elif case is 5:
conn = FixedNumberPreConnector(50, weights=w, delays=delay, space=sp, safe=safe, verbose=verbose, allow_self_connections=autapse)
fig_name = "FixedNumberPre_%s_np_%d.png" %(simulator_name, np)
elif case is 6:
conn = OneToOneConnector(safe=safe, weights=w, delays=delay, verbose=verbose)
fig_name = "OneToOne_%s_np_%d.png" %(simulator_name, np)
elif case is 7:
conn = FromFileConnector('connections.dat', safe=safe, verbose=verbose)
fig_name = "FromFile_%s_np_%d.png" %(simulator_name, np)
elif case is 8:
conn = SmallWorldConnector(degree=0.1, rewiring=0., weights=w, delays=delay, safe=safe, verbose=verbose, allow_self_connections=autapse, space=sp)
fig_name = "SmallWorld_%s_np_%d.png" %(simulator_name, np)
print "Generating data for %s" %fig_name
rng = NumpyRNG(23434, num_processes=np, parallel_safe=parallel_safe)
prj = Projection(x, x, conn, rng=rng)
simulation_time = timer.elapsedTime()
print "Building time", simulation_time
print "Nb synapses built", len(prj)
if render :
if not(os.path.isdir('Results')):
os.mkdir('Results')
print "Saving Positions...."
x.savePositions('Results/positions.dat')
print "Saving Connections...."
prj.saveConnections('Results/connections.dat', compatible_output=False)
if node_id == 0 and render:
figure()
print "Generating and saving %s" %fig_name
positions = numpy.loadtxt('Results/positions.dat')
connections = numpy.loadtxt('Results/connections.dat')
positions = positions[numpy.argsort(positions[:,0])]
idx_pre = (connections[:,0] - x.first_id).astype(int)
idx_post = (connections[:,1] - x.first_id).astype(int)
d = distances(positions[idx_pre,1:3], positions[idx_post,1:3], 1)
subplot(231)
title('Cells positions')
plot(positions[:,1], positions[:,2], '.')
subplot(232)
title('Weights distribution')
hist(connections[:,2], 50)
subplot(233)
title('Delay distribution')
hist(connections[:,3], 50)
subplot(234)
ids = numpy.random.permutation(numpy.unique(positions[:,0]))[0:6]
colors = ['k', 'r', 'b', 'g', 'c', 'y']
for count, cell in enumerate(ids):
draw_rf(cell, positions, connections, colors[count])
subplot(235)
plot(d, connections[:,2], '.')
subplot(236)
plot(d, connections[:,3], '.')
savefig("Results/" + fig_name)
os.remove('Results/connections.dat')
os.remove('Results/positions.dat')
def run_retina(params):
"""Run the retina using the specified parameters."""
print "Setting up simulation"
timer = Timer()
timer.start() # start timer on construction
pyNN.setup(timestep=params['dt'],
max_delay=params['syn_delay'],
threads=params['threads'],
rng_seeds=params['kernelseeds'])
N = params['N']
phr_ON = pyNN.Population((N, N), pyNN.native_cell_type('dc_generator')())
phr_OFF = pyNN.Population((N, N), pyNN.native_cell_type('dc_generator')())
noise_ON = pyNN.Population(
(N, N),
pyNN.native_cell_type('noise_generator')(mean=0.0,
std=params['noise_std']))
noise_OFF = pyNN.Population(
(N, N),
pyNN.native_cell_type('noise_generator')(mean=0.0,
std=params['noise_std']))
phr_ON.set(start=params['simtime'] / 4,
stop=params['simtime'] / 4 * 3,
amplitude=params['amplitude'] * params['snr'])
phr_OFF.set(start=params['simtime'] / 4,
stop=params['simtime'] / 4 * 3,
amplitude=-params['amplitude'] * params['snr'])
# target ON and OFF populations
v_init = params['parameters_gc'].pop('Vinit')
out_ON = pyNN.Population((N, N),
pyNN.native_cell_type('iaf_cond_exp_sfa_rr')(
**params['parameters_gc']))
out_OFF = pyNN.Population((N, N),
pyNN.native_cell_type('iaf_cond_exp_sfa_rr')(
**params['parameters_gc']))
out_ON.initialize(v=v_init)
out_OFF.initialize(v=v_init)
#print "Connecting the network"
retina_proj_ON = pyNN.Projection(phr_ON, out_ON, pyNN.OneToOneConnector())
retina_proj_ON.set(weight=params['weight'])
retina_proj_OFF = pyNN.Projection(phr_OFF, out_OFF,
pyNN.OneToOneConnector())
retina_proj_OFF.set(weight=params['weight'])
noise_proj_ON = pyNN.Projection(noise_ON, out_ON, pyNN.OneToOneConnector())
noise_proj_ON.set(weight=params['weight'])
noise_proj_OFF = pyNN.Projection(noise_OFF, out_OFF,
pyNN.OneToOneConnector())
noise_proj_OFF.set(weight=params['weight'])
out_ON.record('spikes')
out_OFF.record('spikes')
# reads out time used for building
buildCPUTime = timer.elapsedTime()
print "Running simulation"
timer.start() # start timer on construction
pyNN.run(params['simtime'])
simCPUTime = timer.elapsedTime()
out_ON_DATA = out_ON.get_data().segments[0]
out_OFF_DATA = out_OFF.get_data().segments[0]
print "\nRetina Network Simulation:"
print(params['description'])
print "Number of Neurons : ", N**2
print "Output rate (ON) : ", out_ON.mean_spike_count(), \
"spikes/neuron in ", params['simtime'], "ms"
print "Output rate (OFF) : ", out_OFF.mean_spike_count(), \
"spikes/neuron in ", params['simtime'], "ms"
print "Build time : ", buildCPUTime, "s"
print "Simulation time : ", simCPUTime, "s"
return out_ON_DATA, out_OFF_DATA
def run_retina(params):
"""Run the retina using the specified parameters."""
print "Setting up simulation"
timer = Timer()
timer.start() # start timer on construction
pyNN.setup(timestep=params['dt'], max_delay=params['syn_delay'], threads=params['threads'], rng_seeds=params['kernelseeds'])
N = params['N']
phr_ON = pyNN.Population((N, N), pyNN.native_cell_type('dc_generator')())
phr_OFF = pyNN.Population((N, N), pyNN.native_cell_type('dc_generator')())
noise_ON = pyNN.Population((N, N), pyNN.native_cell_type('noise_generator')(mean=0.0, std=params['noise_std']))
noise_OFF = pyNN.Population((N, N), pyNN.native_cell_type('noise_generator')(mean=0.0, std=params['noise_std']))
phr_ON.set(start=params['simtime']/4, stop=params['simtime']/4*3,
amplitude=params['amplitude'] * params['snr'])
phr_OFF.set(start=params['simtime']/4, stop=params['simtime']/4*3,
amplitude=-params['amplitude'] * params['snr'])
# target ON and OFF populations
v_init = params['parameters_gc'].pop('Vinit')
out_ON = pyNN.Population((N, N), pyNN.native_cell_type('iaf_cond_exp_sfa_rr')(**params['parameters_gc']))
out_OFF = pyNN.Population((N, N), pyNN.native_cell_type('iaf_cond_exp_sfa_rr')(**params['parameters_gc']))
out_ON.initialize(v=v_init)
out_OFF.initialize(v=v_init)
#print "Connecting the network"
retina_proj_ON = pyNN.Projection(phr_ON, out_ON, pyNN.OneToOneConnector())
retina_proj_ON.set(weight=params['weight'])
retina_proj_OFF = pyNN.Projection(phr_OFF, out_OFF, pyNN.OneToOneConnector())
retina_proj_OFF.set(weight=params['weight'])
noise_proj_ON = pyNN.Projection(noise_ON, out_ON, pyNN.OneToOneConnector())
noise_proj_ON.set(weight=params['weight'])
noise_proj_OFF = pyNN.Projection(noise_OFF, out_OFF, pyNN.OneToOneConnector())
noise_proj_OFF.set(weight=params['weight'])
out_ON.record('spikes')
out_OFF.record('spikes')
# reads out time used for building
buildCPUTime = timer.elapsedTime()
print "Running simulation"
timer.start() # start timer on construction
pyNN.run(params['simtime'])
simCPUTime = timer.elapsedTime()
out_ON_DATA = out_ON.get_data().segments[0]
out_OFF_DATA = out_OFF.get_data().segments[0]
print "\nRetina Network Simulation:"
print(params['description'])
print "Number of Neurons : ", N**2
print "Output rate (ON) : ", out_ON.mean_spike_count(), \
"spikes/neuron in ", params['simtime'], "ms"
print "Output rate (OFF) : ", out_OFF.mean_spike_count(), \
"spikes/neuron in ", params['simtime'], "ms"
print "Build time : ", buildCPUTime, "s"
print "Simulation time : ", simCPUTime, "s"
return out_ON_DATA, out_OFF_DATA
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_model(sim, **options):
"""
Run a simulation using the parameters read from the file "I_f_curve.json"
:param sim: the PyNN backend module to be used.
:param options: should contain a keyword "simulator" which is the name of the PyNN backend module used.
:return: a tuple (`data`, `times`) where `data` is a Neo Block containing the recorded spikes
and `times` is a dict containing the time taken for different phases of the simulation.
"""
import json
from pyNN.utility import Timer
timer = Timer()
g = open("I_f_curve.json", 'r')
d = json.load(g)
N = d['param']['N']
max_current = d['param']['max_current']
tstop = d['param']['tstop']
if options['simulator'] == "hardware.brainscales":
hardware_preset = d['setup'].pop('hardware_preset', None)
if hardware_preset:
d['setup']['hardware'] = sim.hardwareSetup[hardware_preset]
timer.start()
sim.setup(**d['setup'])
popcell = sim.Population(N, sim.IF_cond_exp, d['IF_cond_exp'])
#current_source = []
#for i in xrange(N):
# current_source.append(sim.DCSource(amplitude=(max_current*(i+1)/N)))
# popcell[i:(i+1)].inject(current_source[i])
i_offset = max_current * (1 + np.arange(N))/N
popcell.tset("i_offset", i_offset)
if PYNN07:
popcell.record()
else:
popcell.record('spikes')
#popcell[0, 1, N-2, N-1].record('v') # debug
setup_time = timer.diff()
sim.run(tstop)
run_time = timer.diff()
if PYNN07:
spike_array = popcell.getSpikes()
data = spike_array_to_neo(spike_array, popcell, tstop)
else:
data = popcell.get_data()
sim.end()
closing_time = timer.diff()
times = {'setup_time': setup_time, 'run_time': run_time, 'closing_time': closing_time}
return data, times
def test(cases=[1]):
sp = Space(periodic_boundaries=((0, 1), (0, 1), None), axes='xy')
safe = False
callback = progress_bar.set_level
autapse = False
parallel_safe = True
render = True
to_file = True
for case in cases:
#w = RandomDistribution('uniform', (0,1))
w = "0.2 + d/0.2"
#w = 0.1
#w = lambda dist : 0.1 + numpy.random.rand(len(dist[0]))*sqrt(dist[0]**2 + dist[1]**2)
#delay = RandomDistribution('uniform', (0.1,5.))
#delay = "0.1 + d/0.2"
delay = 0.1
#delay = lambda distances : 0.1 + numpy.random.rand(len(distances))*distances
d_expression = "exp(-d**2/(2*0.1**2))"
#d_expression = "(d[0] < 0.05) & (d[1] < 0.05)"
#d_expression = "(d[0]/(0.05**2) + d[1]/(0.1**2)) < 100*numpy.random.rand()"
timer = Timer()
np = num_processes()
timer.start()
synapse = StaticSynapse(weight=w, delay=delay)
rng = NumpyRNG(23434, parallel_safe=parallel_safe)
if case is 1:
conn = DistanceDependentProbabilityConnector(
d_expression,
safe=safe,
callback=callback,
allow_self_connections=autapse,
rng=rng)
fig_name = "DistanceDependent_%s_np_%d.png" % (simulator_name, np)
elif case is 2:
conn = FixedProbabilityConnector(0.02,
safe=safe,
callback=callback,
allow_self_connections=autapse,
rng=rng)
fig_name = "FixedProbability_%s_np_%d.png" % (simulator_name, np)
elif case is 3:
conn = AllToAllConnector(delays=delay,
safe=safe,
callback=callback,
allow_self_connections=autapse)
fig_name = "AllToAll_%s_np_%d.png" % (simulator_name, np)
elif case is 4:
conn = FixedNumberPostConnector(50,
safe=safe,
callback=callback,
allow_self_connections=autapse,
rng=rng)
fig_name = "FixedNumberPost_%s_np_%d.png" % (simulator_name, np)
elif case is 5:
conn = FixedNumberPreConnector(50,
safe=safe,
callback=callback,
allow_self_connections=autapse,
rng=rng)
fig_name = "FixedNumberPre_%s_np_%d.png" % (simulator_name, np)
elif case is 6:
conn = OneToOneConnector(safe=safe, callback=callback)
fig_name = "OneToOne_%s_np_%d.png" % (simulator_name, np)
elif case is 7:
conn = FromFileConnector(files.NumpyBinaryFile(
'Results/connections.dat', mode='r'),
safe=safe,
callback=callback,
distributed=True)
fig_name = "FromFile_%s_np_%d.png" % (simulator_name, np)
elif case is 8:
conn = SmallWorldConnector(degree=0.1,
rewiring=0.,
safe=safe,
callback=callback,
allow_self_connections=autapse)
fig_name = "SmallWorld_%s_np_%d.png" % (simulator_name, np)
print "Generating data for %s" % fig_name
prj = Projection(x, x, conn, synapse, space=sp)
mytime = timer.diff()
print "Time to connect the cell population:", mytime, 's'
print "Nb synapses built", prj.size()
if to_file:
if not (os.path.isdir('Results')):
os.mkdir('Results')
print "Saving Connections...."
prj.save('all',
files.NumpyBinaryFile('Results/connections.dat',
mode='w'),
gather=True)
mytime = timer.diff()
print "Time to save the projection:", mytime, 's'
if render and to_file:
print "Saving Positions...."
x.save_positions('Results/positions.dat')
end()
if node_id == 0 and render and to_file:
figure()
print "Generating and saving %s" % fig_name
positions = numpy.loadtxt('Results/positions.dat')
positions[:, 0] -= positions[:, 0].min()
connections = files.NumpyBinaryFile('Results/connections.dat',
mode='r').read()
print positions.shape, connections.shape
connections[:, 0] -= connections[:, 0].min()
connections[:, 1] -= connections[:, 1].min()
idx_pre = connections[:, 0].astype(int)
idx_post = connections[:, 1].astype(int)
d = distances(positions[idx_pre, 1:3], positions[idx_post, 1:3], 1)
subplot(231)
title('Cells positions')
plot(positions[:, 1], positions[:, 2], '.')
subplot(232)
title('Weights distribution')
hist(connections[:, 2], 50)
subplot(233)
title('Delay distribution')
hist(connections[:, 3], 50)
subplot(234)
numpy.random.seed(74562)
ids = numpy.random.permutation(positions[:, 0])[0:6]
colors = ['k', 'r', 'b', 'g', 'c', 'y']
for count, cell in enumerate(ids):
draw_rf(cell, positions, connections, colors[count])
subplot(235)
plot(d, connections[:, 2], '.')
subplot(236)
plot(d, connections[:, 3], '.')
savefig("Results/" + fig_name)
#os.remove('Results/connections.dat')
#os.remove('Results/positions.dat')
show()
cortical_delay = 0.1
# ================= Simulation time ==================
dt = 1.0 # Simulation's time step
delay_min = 1.0 # Minimum delay
delay_max = 5.0 # Maximum delay
#############################
# Build the Network
#############################
# Has to be called at the beginning of the simulation
simulator.setup(timestep=dt, min_delay=delay_min, max_delay=delay_max)
timer.start() # start timer on construction
# ================== LGN ========================
# Load LGN positions
positions_on, positions_off = load_positions()
## Load the spikes
spikes_on, spikes_off = load_lgn_spikes(contrast, N_lgn_layers)
# Spike functions
def spike_times(simulator, layer, spikes_file):
return [simulator.Sequence(x) for x in spikes_file[layer]]
# Spatial structure of on LGN cells
# On cells
def test(cases=[1]):
sp = Space(periodic_boundaries=((0, 1), (0, 1), None))
safe = False
verbose = True
autapse = False
parallel_safe = True
render = True
for case in cases:
#w = RandomDistribution('uniform', (0,1))
w = "0.2 + d/0.2"
#w = 0.1
#w = lambda dist : 0.1 + numpy.random.rand(len(dist[0]))*sqrt(dist[0]**2 + dist[1]**2)
#delay = RandomDistribution('uniform', (0.1,5.))
delay = "0.1 + d/0.2"
#delay = 0.1
#delay = lambda distances : 0.1 + numpy.random.rand(len(distances))*distances
d_expression = "d < 0.1"
#d_expression = "(d[0] < 0.05) & (d[1] < 0.05)"
#d_expression = "(d[0]/(0.05**2) + d[1]/(0.1**2)) < 100*numpy.random.rand()"
timer = Timer()
np = num_processes()
timer.start()
if case is 1:
conn = DistanceDependentProbabilityConnector(
d_expression,
delays=delay,
weights=w,
space=sp,
safe=safe,
verbose=verbose,
allow_self_connections=autapse)
fig_name = "DistanceDependent_%s_np_%d.png" % (simulator_name, np)
elif case is 2:
conn = FixedProbabilityConnector(0.05,
weights=w,
delays=delay,
space=sp,
safe=safe,
verbose=verbose,
allow_self_connections=autapse)
fig_name = "FixedProbability_%s_np_%d.png" % (simulator_name, np)
elif case is 3:
conn = AllToAllConnector(delays=delay,
weights=w,
space=sp,
safe=safe,
verbose=verbose,
allow_self_connections=autapse)
fig_name = "AllToAll_%s_np_%d.png" % (simulator_name, np)
elif case is 4:
conn = FixedNumberPostConnector(50,
weights=w,
delays=delay,
space=sp,
safe=safe,
verbose=verbose,
allow_self_connections=autapse)
fig_name = "FixedNumberPost_%s_np_%d.png" % (simulator_name, np)
elif case is 5:
conn = FixedNumberPreConnector(50,
weights=w,
delays=delay,
space=sp,
safe=safe,
verbose=verbose,
allow_self_connections=autapse)
fig_name = "FixedNumberPre_%s_np_%d.png" % (simulator_name, np)
elif case is 6:
conn = OneToOneConnector(safe=safe,
weights=w,
delays=delay,
verbose=verbose)
fig_name = "OneToOne_%s_np_%d.png" % (simulator_name, np)
elif case is 7:
conn = FromFileConnector('connections.dat',
safe=safe,
verbose=verbose)
fig_name = "FromFile_%s_np_%d.png" % (simulator_name, np)
elif case is 8:
conn = SmallWorldConnector(degree=0.1,
rewiring=0.,
weights=w,
delays=delay,
safe=safe,
verbose=verbose,
allow_self_connections=autapse,
space=sp)
fig_name = "SmallWorld_%s_np_%d.png" % (simulator_name, np)
print "Generating data for %s" % fig_name
rng = NumpyRNG(23434, num_processes=np, parallel_safe=parallel_safe)
prj = Projection(x, x, conn, rng=rng)
simulation_time = timer.elapsedTime()
print "Building time", simulation_time
print "Nb synapses built", len(prj)
if render:
if not (os.path.isdir('Results')):
os.mkdir('Results')
print "Saving Positions...."
x.savePositions('Results/positions.dat')
print "Saving Connections...."
prj.saveConnections('Results/connections.dat',
compatible_output=False)
if node_id == 0 and render:
figure()
print "Generating and saving %s" % fig_name
positions = numpy.loadtxt('Results/positions.dat')
connections = numpy.loadtxt('Results/connections.dat')
positions = positions[numpy.argsort(positions[:, 0])]
idx_pre = (connections[:, 0] - x.first_id).astype(int)
idx_post = (connections[:, 1] - x.first_id).astype(int)
d = distances(positions[idx_pre, 1:3], positions[idx_post, 1:3], 1)
subplot(231)
title('Cells positions')
plot(positions[:, 1], positions[:, 2], '.')
subplot(232)
title('Weights distribution')
hist(connections[:, 2], 50)
subplot(233)
title('Delay distribution')
hist(connections[:, 3], 50)
subplot(234)
ids = numpy.random.permutation(numpy.unique(positions[:, 0]))[0:6]
colors = ['k', 'r', 'b', 'g', 'c', 'y']
for count, cell in enumerate(ids):
draw_rf(cell, positions, connections, colors[count])
subplot(235)
plot(d, connections[:, 2], '.')
subplot(236)
plot(d, connections[:, 3], '.')
savefig("Results/" + fig_name)
os.remove('Results/connections.dat')
os.remove('Results/positions.dat')
rng = NumpyRNG(seed=seed, parallel_safe=True)
print("[%d] Creating populations" % node)
n_spikes = int(2 * tstop * input_rate / 1000.0)
spike_times = numpy.add.accumulate(rng.next(n_spikes, 'exponential',
{'beta': 1000.0 / input_rate}, mask_local=False))
input_population = Population(100, SpikeSourceArray(spike_times=spike_times), label="input")
output_population = Population(10, IF_curr_exp(**cell_params), label="output")
print("[%d] input_population cells: %s" % (node, input_population.local_cells))
print("[%d] output_population cells: %s" % (node, output_population.local_cells))
print("[%d] Connecting populations" % node)
timer.start()
connector = CSAConnector(csa.random(0.5))
syn = StaticSynapse(weight=0.1)
projection = Projection(input_population, output_population, connector, syn)
print(connector.describe(), timer.elapsedTime())
file_stem = "Results/simpleRandomNetwork_csa_np%d_%s" % (num_processes(), simulator_name)
projection.save('all', '%s.conn' % file_stem)
input_population.record('spikes')
output_population.record('spikes')
output_population.sample(n_record, rng).record('v')
print("[%d] Running simulation" % node)
run(tstop)
def test_va_benchmark(self):
try:
simulator_name = 'spiNNaker'
timer = Timer()
# === Define parameters =========================================
rngseed = 98766987
parallel_safe = True
n = 1500 # number of cells
# number of excitatory cells:number of inhibitory cells
r_ei = 4.0
pconn = 0.02 # connection probability
dt = 0.1 # (ms) simulation timestep
tstop = 200 # (ms) simulaton duration
delay = 1
# Cell parameters
area = 20000. # (µm²)
tau_m = 20. # (ms)
cm = 1. # (µF/cm²)
g_leak = 5e-5 # (S/cm²)
e_leak = -49. # (mV)
v_thresh = -50. # (mV)
v_reset = -60. # (mV)
t_refrac = 5. # (ms) (clamped at v_reset)
# (mV) 'mean' membrane potential, for calculating CUBA weights
v_mean = -60.
tau_exc = 5. # (ms)
tau_inh = 10. # (ms)
# (nS) #Those weights should be similar to the COBA weights
g_exc = 0.27
# (nS) # but the delpolarising drift should be taken into account
g_inh = 4.5
e_rev_exc = 0. # (mV)
e_rev_inh = -80. # (mV)
# === Calculate derived parameters ===============================
area *= 1e-8 # convert to cm²
cm *= area * 1000 # convert to nF
r_m = 1e-6 / (g_leak * area) # membrane resistance in MΩ
assert tau_m == cm * r_m # just to check
# number of excitatory cells
n_exc = int(round((n * r_ei / (1 + r_ei))))
n_inh = n - n_exc # number of inhibitory cells
print n_exc, n_inh
celltype = p.IF_curr_exp
# (nA) weight of excitatory synapses
w_exc = 1e-3 * g_exc * (e_rev_exc - v_mean)
w_inh = 1e-3 * g_inh * (e_rev_inh - v_mean) # (nA)
assert w_exc > 0
assert w_inh < 0
# === Build the network ==========================================
p.setup(timestep=dt, min_delay=delay, max_delay=delay)
if simulator_name == 'spiNNaker':
# this will set 100 neurons per core
p.set_number_of_neurons_per_core('IF_curr_exp', 100)
# this will set 50 neurons per core
p.set_number_of_neurons_per_core('IF_cond_exp', 50)
node_id = 1
np = 1
host_name = socket.gethostname()
print "Host #%d is on %s" % (np, host_name)
cell_params = {
'tau_m': tau_m,
'tau_syn_E': tau_exc,
'tau_syn_I': tau_inh,
'v_rest': e_leak,
'v_reset': v_reset,
'v_thresh': v_thresh,
'cm': cm,
'tau_refrac': t_refrac,
'i_offset': 0
}
print cell_params
timer.start()
print "%s Creating cell populations..." % node_id
exc_cells = p.Population(n_exc,
celltype,
cell_params,
label="Excitatory_Cells")
inh_cells = p.Population(n_inh,
celltype,
cell_params,
label="Inhibitory_Cells")
p.NativeRNG(12345)
print "%s Initialising membrane potential to random values..." \
% node_id
rng = NumpyRNG(seed=rngseed, parallel_safe=parallel_safe)
uniform_distr = RandomDistribution('uniform', [v_reset, v_thresh],
rng=rng)
exc_cells.initialize('v', uniform_distr)
inh_cells.initialize('v', uniform_distr)
print "%s Connecting populations..." % node_id
exc_conn = p.FixedProbabilityConnector(pconn,
weights=w_exc,
delays=delay)
inh_conn = p.FixedProbabilityConnector(pconn,
weights=w_inh,
delays=delay)
connections = dict()
connections['e2e'] = p.Projection(exc_cells,
exc_cells,
exc_conn,
target='excitatory',
rng=rng)
connections['e2i'] = p.Projection(exc_cells,
inh_cells,
exc_conn,
target='excitatory',
rng=rng)
connections['i2e'] = p.Projection(inh_cells,
exc_cells,
inh_conn,
target='inhibitory',
rng=rng)
connections['i2i'] = p.Projection(inh_cells,
inh_cells,
inh_conn,
target='inhibitory',
rng=rng)
# === Setup recording ==============================
print "%s Setting up recording..." % node_id
exc_cells.record()
# === Run simulation ================================
print "%d Running simulation..." % node_id
print "timings: number of neurons:", n
print "timings: number of synapses:", n * n * pconn
p.run(tstop)
exc_spikes = exc_cells.getSpikes()
print len(exc_spikes)
current_file_path = os.path.dirname(os.path.abspath(__file__))
current_file_path = os.path.join(current_file_path, "spikes.data")
exc_cells.printSpikes(current_file_path)
pre_recorded_spikes = p.utility_calls.read_spikes_from_file(
current_file_path, 0, n_exc, 0, tstop)
for spike_element, read_element in zip(exc_spikes,
pre_recorded_spikes):
self.assertEqual(round(spike_element[0], 1),
round(read_element[0], 1))
self.assertEqual(round(spike_element[1], 1),
round(read_element[1], 1))
p.end()
# System intentional overload so may error
except SpinnmanTimeoutException as ex:
raise SkipTest(ex)
print "Host #%d is on %s" % (rank + 1, host_name)
if extra.has_key('threads'):
print "%d Initialising the simulator with %d threads..." % (
rank, extra['threads'])
else:
print "%d Initialising the simulator with single thread..." % (rank)
# Small function to display information only on node 1
def nprint(s):
if (rank == 0):
print s
timer.start() # start timer on construction
print "%d Setting up random number generator" % rank
rng = NumpyRNG(kernelseed, parallel_safe=True)
print "%d Creating excitatory population with %d neurons." % (rank, NE)
celltype = IF_curr_alpha(**cell_params)
E_net = Population(NE, celltype, label="E_net")
print "%d Creating inhibitory population with %d neurons." % (rank, NI)
I_net = Population(NI, celltype, label="I_net")
print "%d Initialising membrane potential to random values between %g mV and %g mV." % (
rank, U0, theta)
uniformDistr = RandomDistribution('uniform', [U0, theta], rng)
E_net.initialize(v=uniformDistr)
def runBrunelNetwork(
g=5.0,
eta=2.0,
dt=0.1,
simtime=1000.0,
delay=1.5,
epsilon=0.1,
order=2500,
N_rec=50,
N_rec_v=2,
save=False,
simulator_name="nest",
extra={},
):
exec("from pyNN.%s import *" % simulator_name) in globals()
timer = Timer()
# === Define parameters ========================================================
downscale = 1 # scale number of neurons down by this factor
# scale synaptic weights up by this factor to
# obtain similar dynamics independent of size
order = order # determines size of network:
# 4*order excitatory neurons
# 1*order inhibitory neurons
Nrec = N_rec # number of neurons to record from, per population
epsilon = epsilon # connectivity: proportion of neurons each neuron projects to
# Parameters determining model dynamics, cf Brunel (2000), Figs 7, 8 and Table 1
# here: Case C, asynchronous irregular firing, ~35 Hz
eta = eta # rel rate of external input
g = g # rel strength of inhibitory synapses
J = 0.1 # synaptic weight [mV]
delay = delay # synaptic delay, all connections [ms]
# single neuron parameters
tauMem = 20.0 # neuron membrane time constant [ms]
tauSyn = 0.1 # synaptic time constant [ms]
tauRef = 2.0 # refractory time [ms]
U0 = 0.0 # resting potential [mV]
theta = 20.0 # threshold
# simulation-related parameters
simtime = simtime # simulation time [ms]
dt = dt # simulation step length [ms]
# seed for random generator used when building connections
connectseed = 12345789
use_RandomArray = True # use Python rng rather than NEST rng
# seed for random generator(s) used during simulation
kernelseed = 43210987
# === Calculate derived parameters =============================================
# scaling: compute effective order and synaptic strength
order_eff = int(float(order) / downscale)
J_eff = J * downscale
# compute neuron numbers
NE = int(4 * order_eff) # number of excitatory neurons
NI = int(1 * order_eff) # number of inhibitory neurons
N = NI + NE # total number of neurons
# compute synapse numbers
CE = int(epsilon * NE) # number of excitatory synapses on neuron
CI = int(epsilon * NI) # number of inhibitory synapses on neuron
C = CE + CI # total number of internal synapses per n.
Cext = CE # number of external synapses on neuron
# synaptic weights, scaled for alpha functions, such that
# for constant membrane potential, charge J would be deposited
fudge = 0.00041363506632638 # ensures dV = J at V=0
# excitatory weight: JE = J_eff / tauSyn * fudge
JE = (J_eff / tauSyn) * fudge
# inhibitory weight: JI = - g * JE
JI = -g * JE
# threshold, external, and Poisson generator rates:
nu_thresh = theta / (J_eff * CE * tauMem)
nu_ext = eta * nu_thresh # external rate per synapse
p_rate = 1000 * nu_ext * Cext # external input rate per neuron (Hz)
# number of synapses---just so we know
Nsyn = (
C + 1
) * N + 2 * Nrec # number of neurons * (internal synapses + 1 synapse from PoissonGenerator) + 2synapses" to spike detectors
# put cell parameters into a dict
cell_params = {
"tau_m": tauMem,
"tau_syn_E": tauSyn,
"tau_syn_I": tauSyn,
"tau_refrac": tauRef,
"v_rest": U0,
"v_reset": U0,
"v_thresh": theta,
"cm": 0.001,
} # (nF)
# === Build the network ========================================================
# clear all existing network elements and set resolution and limits on delays.
# For NEST, limits must be set BEFORE connecting any elements
# extra = {'threads' : 2}
rank = setup(timestep=dt, max_delay=delay, **extra)
print("rank =", rank)
np = num_processes()
print("np =", np)
import socket
host_name = socket.gethostname()
print("Host #%d is on %s" % (rank + 1, host_name))
if "threads" in extra:
print("%d Initialising the simulator with %d threads..." % (rank, extra["threads"]))
else:
print("%d Initialising the simulator with single thread..." % rank)
# Small function to display information only on node 1
def nprint(s):
if rank == 0:
print(s)
timer.start() # start timer on construction
print("%d Setting up random number generator" % rank)
rng = NumpyRNG(kernelseed, parallel_safe=True)
print("%d Creating excitatory population with %d neurons." % (rank, NE))
celltype = IF_curr_alpha(**cell_params)
E_net = Population(NE, celltype, label="E_net")
print("%d Creating inhibitory population with %d neurons." % (rank, NI))
I_net = Population(NI, celltype, label="I_net")
print("%d Initialising membrane potential to random values between %g mV and %g mV." % (rank, U0, theta))
uniformDistr = RandomDistribution("uniform", low=U0, high=theta, rng=rng)
E_net.initialize(v=uniformDistr)
I_net.initialize(v=uniformDistr)
print("%d Creating excitatory Poisson generator with rate %g spikes/s." % (rank, p_rate))
source_type = SpikeSourcePoisson(rate=p_rate)
expoisson = Population(NE, source_type, label="expoisson")
print("%d Creating inhibitory Poisson generator with the same rate." % rank)
inpoisson = Population(NI, source_type, label="inpoisson")
# Record spikes
print("%d Setting up recording in excitatory population." % rank)
E_net.sample(Nrec).record("spikes")
E_net[0 : min(NE, N_rec_v)].record("v")
print("%d Setting up recording in inhibitory population." % rank)
I_net.sample(Nrec).record("spikes")
I_net[0 : min(NI, N_rec_v)].record("v")
progress_bar = ProgressBar(width=20)
connector = FixedProbabilityConnector(epsilon, rng=rng, callback=progress_bar)
E_syn = StaticSynapse(weight=JE, delay=delay)
I_syn = StaticSynapse(weight=JI, delay=delay)
ext_Connector = OneToOneConnector(callback=progress_bar)
ext_syn = StaticSynapse(weight=JE, delay=dt)
print(
"%d Connecting excitatory population with connection probability %g, weight %g nA and delay %g ms."
% (rank, epsilon, JE, delay)
)
E_to_E = Projection(E_net, E_net, connector, E_syn, receptor_type="excitatory")
print("E --> E\t\t", len(E_to_E), "connections")
I_to_E = Projection(I_net, E_net, connector, I_syn, receptor_type="inhibitory")
print("I --> E\t\t", len(I_to_E), "connections")
input_to_E = Projection(expoisson, E_net, ext_Connector, ext_syn, receptor_type="excitatory")
print("input --> E\t", len(input_to_E), "connections")
print(
"%d Connecting inhibitory population with connection probability %g, weight %g nA and delay %g ms."
% (rank, epsilon, JI, delay)
)
E_to_I = Projection(E_net, I_net, connector, E_syn, receptor_type="excitatory")
print("E --> I\t\t", len(E_to_I), "connections")
I_to_I = Projection(I_net, I_net, connector, I_syn, receptor_type="inhibitory")
print("I --> I\t\t", len(I_to_I), "connections")
input_to_I = Projection(inpoisson, I_net, ext_Connector, ext_syn, receptor_type="excitatory")
print("input --> I\t", len(input_to_I), "connections")
# read out time used for building
buildCPUTime = timer.elapsedTime()
# === Run simulation ===========================================================
# run, measure computer time
timer.start() # start timer on construction
print("%d Running simulation for %g ms." % (rank, simtime))
run(simtime)
simCPUTime = timer.elapsedTime()
# write data to file
# print("%d Writing data to file." % rank)
# (E_net + I_net).write_data("Results/brunel_np%d_%s.pkl" % (np, simulator_name))
if save:
for pop in [E_net, I_net]:
io = PyNNTextIO(filename="brunel-PyNN-%s-%s-%i.gdf" % (simulator_name, pop.label, rank))
spikes = pop.get_data("spikes", gather=False)
for segment in spikes.segments:
io.write_segment(segment)
io = PyNNTextIO(filename="brunel-PyNN-%s-%s-%i.dat" % (simulator_name, pop.label, rank))
vs = pop.get_data("v", gather=False)
for segment in vs.segments:
io.write_segment(segment)
spike_data = {}
spike_data["senders"] = []
spike_data["times"] = []
index_offset = 0
for pop in [E_net, I_net]:
spikes = pop.get_data("spikes", gather=False)
# print(spikes.segments[0].all_data)
num_rec = min(pop.size, N_rec)
print("Extracting spike info (%i) for %i cells in %s" % (num_rec, pop.size, pop.label))
assert num_rec == len(spikes.segments[0].spiketrains)
for i in range(num_rec):
ss = spikes.segments[0].spiketrains[i]
for s in ss:
index = i + index_offset
# print("Adding spike at %s in %s[%i] (cell %i)"%(s,pop.label,i,index))
spike_data["senders"].append(index)
spike_data["times"].append(s)
index_offset += pop.size
# from IPython.core.debugger import Tracer
# Tracer()()
E_rate = E_net.mean_spike_count() * 1000.0 / simtime
I_rate = I_net.mean_spike_count() * 1000.0 / simtime
# write a short report
nprint("\n--- Brunel Network Simulation ---")
nprint("Nodes : %d" % np)
nprint("Number of Neurons : %d" % N)
nprint("Number of Synapses : %d" % Nsyn)
nprint("Input firing rate : %g" % p_rate)
nprint("Excitatory weight : %g" % JE)
nprint("Inhibitory weight : %g" % JI)
nprint("Excitatory rate : %g Hz" % E_rate)
nprint("Inhibitory rate : %g Hz" % I_rate)
nprint("Build time : %g s" % buildCPUTime)
nprint("Simulation time : %g s" % simCPUTime)
# === Clean up and quit ========================================================
end()
return spike_data