def run_simulation(sim,Params):
print "Running Network"
timer = Timer()
timer.reset()
sim.run(Params['run_time'])
simCPUtime = timer.elapsedTime()
print "Simulation Time: %s" % str(simCPUtime)
def run_simulation(sim, params):
print "Running Network ..."
timer = Timer()
timer.reset()
sim.run(params['run_time'])
simCPUtime = timer.elapsedTime()
print "... The simulation took %s ms to run." % str(simCPUtime)
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
print "Bas --> Bas\t\t", len(Bas_to_Bas), "connections" Ext_to_Bas = Projection(bas_poisson, Bas_net, BasExt_Connector, target="excitatory") print "Ext --> Bas\t", len(Ext_to_Bas), "connections" Pyr_to_Sli = [] print "%d Connecting slow inhibitory population." % (rank) for pre in range(NP): P2S_sub = Projection(Pyr_net[pre], Sli_net, SliExc_Connector, rng=rng, target="excitatory") print "Pyr --> SlowInh\t\t", len(P2S_sub), "connections" Pyr_to_Sli.append(P2S_sub) Ext_to_Sli = Projection(sli_poisson, Sli_net, SliExt_Connector, target="excitatory") print "Ext --> SlowInh\t", len(Ext_to_Sli), "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() print "%d Writing data to file." % rank filename_spike_pyr = [] filename_v_pyr = [] for sp in range(NP): filename_spike_sub = "Results/%s_pyr%d_np%d_%s.ras" % (run_name, sp, np, simulator_name) # output file for excit. population filename_spike_pyr.append(filename_spike_sub)
out_file_string += compute_sdram_entries(db, c, memory_pointer, process_id=process_id)
memory_pointer = BASE + len(out_file_string)
# If there's something write the file
if len(out_file_string) > 0:
f = open(filename,'w+')
f.write(out_file_string)
f.close()
if __name__ == '__main__':
if DEBUG: print "\n----- creating SDRAM files"
db = pacman.load_db(sys.argv[1]) # IMPORTS THE DB (it will also load the model libraray by default)
global n_synapses
n_synapses = 0
print("Loading DB: %g" %timer.elapsedTime())
image_map = db.get_image_map()
chip_map = [ (c['x'],c['y']) for c in image_map ]
chip_map = list(set(chip_map)) # removing duplicates http://love-python.blogspot.co.uk/2008/09/remove-duplicate-items-from-list-using.html
for c in chip_map:
x = c[0]
y = c[1]
filename = './binaries/SDRAM_%d_%d.dat' % (x, y)
# filename = '/tmp/SDRAM_%d_%d.dat' % (x, y)
used_cores = [ el for el in image_map if el['x']==x and el['y']==y ]
out_file_string = ""
memory_pointer = BASE
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)
print("[%d] Writing spikes and Vm to disk" % node)
output_population.write_data('%s_output.pkl' % file_stem)
#input_population.write_data('%s_input.pkl' % file_stem)
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
# cell_params will be passed to the constructor of the Population Object
cell_params = {
'tau_m' : tau_m, 'cm' : cm,
'v_rest' : -65, 'v_reset' : -65, 'v_thresh' : -45,
'tau_syn_E' : tau_syn_exc, 'tau_syn_I' : tau_syn_inh, 'tau_refrac' : t_refrac, 'i_offset' : 0
}
# population and projection containers
v4_pop = []
pfc = []
projections = []
print "%g - Creating v4 populations" % timer.elapsedTime()
for i in range(orientations): # Cycles orientations
# creates a population for each connection
v4_pop.append(Population(base_v4_num_neurons*base_v4_num_neurons, # size
IF_curr_exp, # Neuron Type
cell_params, # Neuron Parameters
label="v4_%d" % i)) # Label)
if layer_to_observe == 'v4' or layer_to_observe == 'all':
print "%g - observing v4" % timer.elapsedTime()
# if layer_to_observe == 'v4': v4_pop[i].set_mapping_constraint({'x':0, 'y':1})
v4_pop[i].record() # ('spikes', to_file=False)
print "%g - Creating PFC population" % timer.elapsedTime()
for i in range(orientations): # Cycles orientations
if len(cortical_exc_inh_connections) !=0:
cortical_exc_inh_projection = simulator.Projection(cortical_neurons_exc, cortical_neurons_inh,
cortical_exc_inh_connector, receptor_type='excitatory')
#############################n
# Recordings
#############################
cortical_neurons_exc.record(['gsyn_exc', 'gsyn_inh','v', 'spikes'])
cortical_neurons_inh.record(['gsyn_exc', 'gsyn_inh', 'v', 'spikes'])
#cortical_neurons_exc.record('spikes', 'v')
# read out time used for building
build_time = timer.elapsedTime()
#############################
# Run model and print information
#############################
simulator.run(t) # Run the simulations for t ms
simulation_time = timer.elapsedTime()
print 'Construction time', build_time
print 'Simulation time', simulation_time
simulator.end()
#############################
# Extract the 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))
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')
already_computed = 0
for pop in params['Populations'].keys():
if os.path.exists(opts.data_folder + str(run) +'/'+pop+str(comb)+'.pkl'):
already_computed = already_computed + 1
if already_computed > 0:
print "already computed"
else:
Populations = h.build_network(sim,params)
h.record_data(params, Populations)
h.perform_injections(params, Populations)
print "Running Network"
timer = Timer()
timer.reset()
interval = 10
sim.run(params['run_time'], callbacks = SetInput(Populations, interval, params['dt']))
simCPUtime = timer.elapsedTime()
print "Simulation Time: %s" % str(simCPUtime)
h.save_data(Populations, opts.data_folder + str(run), str(comb))
sim.end()
else :
if search:
already_computed = 0
for pop in params['Populations'].keys():
if os.path.exists(opts.data_folder + str(run) +'/'+pop+str(comb)+'.png'):
already_computed = already_computed + 1
if already_computed > len(params['Populations']) - 1:
print "already analysed"
else:
ratio,fqcy,psd,freq, fqcy_ratio = h.analyse(params, opts.data_folder + str(run), str(comb), opts.remove)
print "ratio",ratio,"fqcy",fqcy,"psd",psd,"freq",freq
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()
# If there's something write the file
if len(out_file_string) > 0:
f = open(filename, 'w+')
f.write(out_file_string)
f.close()
if __name__ == '__main__':
if DEBUG: print "\n----- creating SDRAM files"
db = pacman.load_db(
sys.argv[1]
) # IMPORTS THE DB (it will also load the model libraray by default)
global n_synapses
n_synapses = 0
print("Loading DB: %g" % timer.elapsedTime())
image_map = db.get_image_map()
chip_map = [(c['x'], c['y']) for c in image_map]
chip_map = list(
set(chip_map)
) # removing duplicates http://love-python.blogspot.co.uk/2008/09/remove-duplicate-items-from-list-using.html
for c in chip_map:
x = c[0]
y = c[1]
filename = './binaries/SDRAM_%d_%d.dat' % (x, y)
# filename = '/tmp/SDRAM_%d_%d.dat' % (x, y)
used_cores = [el for el in image_map if el['x'] == x and el['y'] == y]
out_file_string = ""
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
rng=rng)
# Recording
#pyB.record_v(10)
#inhB.record_v(10)
py.record()
inh.record()
pyB.record()
inhB.record()
#
print "Running Network"
timer = Timer()
timer.reset()
run(run_time)
simCPUtime = timer.elapsedTime()
print "Simulation Time: %s" % str(simCPUtime)
#os.chdir('Insert Data Directory Here')
#pyB.print_v('pyB_v.dat')
#inhB.print_v('inhB_v.dat')
py.printSpikes('py.dat')
inh.printSpikes('inh.dat')
pyB.printSpikes('pyB.dat')
inhB.printSpikes('inhB.dat')
#py_py.saveConnections('py_py.conn')
plot.ion()
# cell_params will be passed to the constructor of the Population Object
cell_params = {
'tau_m': tau_m,
'cm': cm,
'v_rest': v_rest,
'v_reset': v_reset,
'v_thresh': v_thresh,
'tau_syn_E': tau_syn_exc,
'tau_syn_I': tau_syn_inh,
'tau_refrac': t_refrac,
'i_offset': i_offset
}
print "%g - Creating input population: %d x %d" % (
timer.elapsedTime(), scale.input_size[0], scale.input_size[1])
if input_file_type:
input_file = open(InputFilePol1, 'r')
input_spike_list = eval(input_file.readline())
data_input_1 = convert_spike_list_to_timed_spikes(
spike_list=input_spike_list,
min_idx=0,
max_idx=scale.input_size[0] * scale.input_size[1],
tmin=0,
tmax=runtime,
tstep=int(time_step))
else:
data_input_1 = convert_file_to_spikes(input_file_name=InputFilePol1,
min_idx=0,
max_idx=scale.input_size[0] *
scale.input_size[1],
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)
print "[%d] Writing spikes and Vm to disk" % node
output_population.write_data('%s_output.pkl' % file_stem)
#input_population.write_data('%s_input.pkl' % file_stem)
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(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 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')
if len(cortical_exc_inh_connections) != 0:
cortical_exc_inh_projection = simulator.Projection(
cortical_neurons_exc,
cortical_neurons_inh,
cortical_exc_inh_connector,
receptor_type='excitatory')
#############################n
# Recordings
#############################
cortical_neurons_exc.record(['v', 'spikes'])
# read out time used for building
build_time = timer.elapsedTime()
#############################
# Run model and print information
#############################
simulator.run(t) # Run the simulations for t ms
simulation_time = timer.elapsedTime()
print 'Construction time', build_time
print 'Simulation time', simulation_time
simulator.end()
#############################
# Extract the data
#############################
timer = Timer()
timer.start()
# cell_params will be passed to the constructor of the Population Object
cell_params = {
'tau_m' : tau_m, 'cm' : cm,
'v_rest' : v_rest, 'v_reset' : v_reset, 'v_thresh' : v_thresh,
'tau_syn_E' : tau_syn_exc, 'tau_syn_I' : tau_syn_inh, 'tau_refrac' : t_refrac, 'i_offset' : i_offset
}
print "%g - Creating input population: %d x %d" % (timer.elapsedTime(), scale.input_size[0], scale.input_size[1])
if input_file_type:
input_file = open(InputFilePol1, 'r')
input_spike_list = eval(input_file.readline())
data_input_1 = convert_spike_list_to_timed_spikes(spike_list=input_spike_list, min_idx=0, max_idx=scale.input_size[0]*scale.input_size[1], tmin=0, tmax=runtime, tstep=int(time_step))
else:
data_input_1 = convert_file_to_spikes(input_file_name=InputFilePol1, min_idx=0, max_idx=scale.input_size[0]*scale.input_size[1], tmin=0, tmax=runtime)
data_input_1 = subsample_spikes_by_time(data_input_1, 0, 100, 6)
data_input_1 = random_skew_times(data_input_1, 3)
data_input_1 = [data_input_1[neuron] if neuron in data_input_1 else [] for neuron in range(scale.input_size[0]*scale.input_size[1])]
input_pol_1 = Population(scale.input_size[0]*scale.input_size[1], # size
SpikeSourceArray, # Neuron Type
{'spike_times': data_input_1}, # Neuron Parameters
label="input_pol_1") # Label
if layer_to_observe == 'input_pol_1' or layer_to_observe == 'all':
print "%g - observing input (positive polarity)" % timer.elapsedTime()
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))
E_rate = E_net.mean_spike_count() * 1000.0 / simtime
I_rate = I_net.mean_spike_count() * 1000.0 / simtime
def run_simulation(run):
info = {}
# run combinations
for i,comb in enumerate(combinations):
print "param combination",i, "trial",run
print "current set:",comb
# replacement
for ckey,val in comb.iteritems():
keys = ckey.split('.') # get list from dotted string
replace(params,keys,val)
# save parameters in the data_folder
if not os.path.exists(opts.data_folder+str(run)):
os.makedirs(opts.data_folder+str(run))
shutil.copy('./'+opts.param_file, opts.data_folder + str(run)+'/'+opts.param_file+'_'+str(comb)+'.py')
if not opts.analysis: #run simulation
# run simulation if it hasn't already been ran for these parameters
already_computed = 0
for pop in params['Populations'].keys():
if os.path.exists(opts.data_folder + str(run) +'/'+pop+str(comb)+'.pkl'):
already_computed = already_computed + 1
if already_computed > 0:
print "already computed"
else:
Populations = h.build_network(sim,params)
h.record_data(params, Populations)
h.perform_injections(params, Populations)
print "Running Network"
timer = Timer()
timer.reset()
inject_spikes = partial(inject_spikes_pop,Populations = Populations)
sim.run(params['run_time'], [inject_spikes])
simCPUtime = timer.elapsedTime()
print "Simulation Time: %s" % str(simCPUtime)
h.save_data(Populations, opts.data_folder + str(run), str(comb))
sim.end()
else : #do analysis
if search: #then compute the csv needed for the search maps
already_analysed = 0 #analyse only those that haven't already been analysed
for pop in params['Populations'].keys():
if os.path.exists(opts.data_folder + str(run) +'/'+pop+str(comb)+'.png'):
already_analysed = already_analysed + 1
if already_analysed >= len(params['Populations'])-1 :
print "already analysed"
else:
ratio,fqcy,psd,freq, fqcy_ratio = h.analyse(params, opts.data_folder + str(run), str(comb), opts.remove)
#save computed values in csv files
gen = (pop for pop in params['Populations'].keys() if pop != 'ext')
for pop in gen:
if i == 0:
with open(opts.data_folder+ str(run)+'/map-'+pop+'.csv', 'wb') as csvfile:
mywriter = csv.writer(csvfile)
mywriter.writerow( ['#'+str(testParams[1])+ ':' +str(search[testParams[1]]) ] )
mywriter.writerow( ['#'+str(testParams[0])+ ':' +str(search[testParams[0]]) ] )
with open(opts.data_folder+ str(run)+'/psdmap-'+pop+'.csv', 'wb') as csvfile:
mywriter = csv.writer(csvfile)
mywriter.writerow( ['#'+str(testParams[1])+ ':' +str(search[testParams[1]]) ] )
mywriter.writerow( ['#'+str(testParams[0])+ ':' +str(search[testParams[0]]) ] )
if pop in freq:
mywriter.writerow(freq[pop])
info[pop] = []
if pop in ratio and pop in fqcy:
info[pop].append([ratio[pop],fqcy[pop],fqcy_ratio[pop]])
if (i+1)%len(search[testParams[1]]) == 0:
with open(opts.data_folder+str(run)+'/map-'+pop+'.csv', 'a') as csvfile:
mywriter = csv.writer(csvfile)
mywriter.writerow(info[pop])
info[pop] = []
if pop in psd:
with open(opts.data_folder+str(run)+'/psdmap-'+pop+'.csv', 'a') as csvfile:
mywriter = csv.writer(csvfile)
mywriter.writerow(psd[pop])
else:
h.analyse(params, opts.data_folder+str(run), str(comb), opts.remove)
