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:2].record('v') print "%d Setting up recording in inhibitory population." % rank I_net.sample(Nrec).record('spikes') I_net[0:2].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,
def __init__(self, interval, t_stop): self.interval = interval self.t_stop = t_stop from pyNN.utility import ProgressBar self.pb = ProgressBar(width=int(t_stop / interval), char=".")
def __init__(self, interval, t_stop): self.interval = interval self.t_stop = t_stop self.pb = ProgressBar(width=int(t_stop / interval), char=".")
def build_connections(connector_type, connector_parameters): # === Setup ============================================================== node_id = sim.setup(**extra) np = sim.num_processes() 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'])) # === Type references ==================================================== celltype = sim.IF_cond_exp synapsetype = sim.StaticSynapse # === Definition of the types of neurons, synapses and connections ======= progress_bar = ProgressBar(width=20) cell_stim = sim.SpikeSourceArray(spike_times=[1.0]) cell_exc = celltype() cell_inh = celltype() syn_stim = synapsetype() syn_exc = synapsetype() syn_inh = synapsetype() conn_stim = connector_type(**connector_parameters) conn_exc = connector_type(**connector_parameters) conn_inh = connector_type(**connector_parameters) # === Populations ======================================================== print("%s Creating cell populations..." % node_id) pop_stim = sim.Population(n_ext, cell_stim, label="spikes") pop_exc = sim.Population(n_exc, cell_exc, label="Excitatory_Cells") pop_inh = sim.Population(n_inh, cell_inh, label="Inhibitory_Cells") print("%s Connecting populations..." % node_id) connections = {} connections['stim2e'] = sim.Projection( pop_stim, pop_exc, connector=conn_stim, synapse_type=syn_stim, receptor_type='excitatory') connections['stim2i'] = sim.Projection( pop_stim, pop_inh, connector=conn_stim, synapse_type=syn_stim, receptor_type='excitatory') connections['e2e'] = sim.Projection( pop_exc, pop_exc, conn_exc, syn_exc, receptor_type='excitatory') connections['e2i'] = sim.Projection( pop_exc, pop_inh, conn_exc, syn_exc, receptor_type='excitatory') connections['i2e'] = sim.Projection( pop_inh, pop_exc, conn_inh, syn_inh, receptor_type='inhibitory') connections['i2i'] = sim.Projection( pop_inh, pop_inh, conn_inh, syn_inh, receptor_type='inhibitory') # === Output connection results =========================================== # for prj in connections.keys(): # connections[prj].saveConnections('Results/VAconnections_%s_%s_np%d.conn' # % (prj, options.simulator, np)) str_connections = "%d e->e %d e->i %d i->e %d i->i" % (connections['e2e'].size(), connections[ 'e2i'].size(), connections[ 'i2e'].size(), connections['i2i'].size()) str_stim_connections = "%d stim->e %d stim->i" % ( connections['stim2e'].size(), connections['stim2i'].size()) if node_id == 0: print("\n\n--- Connector : %s ---" % connector_type.__name__) print("Nodes : %d" % np) print("Number of Stims : %d" % n_ext) print("Number of Exc Neurons : %d" % n_exc) print("Number of Inh Neurons : %d" % n_inh) print("Number of Synapses : %s" % str_connections) print("Number of inputs : %s" % str_stim_connections) print("\n") def normalize_array(arr): res = nan_to_num(arr) res = (res != 0) return res.astype(int) if options.plot_figure: filename = options.plot_figure + '_' + connector_type.__name__ from pyNN.utility.plotting import Figure, Panel array_stim_exc = normalize_array( connections['stim2e'].get('delay', format="array")[0:20, :]) array_stim_inh = normalize_array( connections['stim2i'].get('delay', format="array")[0:20, :]) array_exc_exc = normalize_array( connections['e2e'].get('delay', format="array")[0:20, :]) array_exc_inh = normalize_array( connections['e2i'].get('delay', format="array")[0:20, :]) array_inh_exc = normalize_array( connections['i2e'].get('delay', format="array")[0:20, :]) array_inh_inh = normalize_array( connections['i2i'].get('delay', format="array")[0:20, :]) Figure( Panel(array_stim_exc, data_labels=["stim->exc"], line_properties=[ {'xticks': True, 'yticks': True, 'cmap': 'Greys', 'vmin': 0.}]), Panel(array_stim_inh, data_labels=["stim->inh"], line_properties=[ {'xticks': True, 'yticks': True, 'cmap': 'Greys', 'vmin': 0.}]), Panel(array_exc_exc, data_labels=["exc->exc"], line_properties=[ {'xticks': True, 'yticks': True, 'cmap': 'Greys', 'vmin': 0.}]), Panel(array_exc_inh, data_labels=["exc->inh"], line_properties=[ {'xticks': True, 'yticks': True, 'cmap': 'Greys', 'vmin': 0.}]), Panel(array_inh_exc, data_labels=["inh->exc"], line_properties=[ {'xticks': True, 'yticks': True, 'cmap': 'Greys', 'vmin': 0.}]), Panel(array_inh_inh, data_labels=["inh->inh"], line_properties=[ {'xticks': True, 'yticks': True, 'cmap': 'Greys', 'vmin': 0.}]), ).save(filename) # === Finished with simulator ============================================ sim.end()
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) print "%s Connecting populations..." % node_id progress_bar = ProgressBar(60, '=') connector = FixedProbabilityConnector(pconn, rng=rng, callback=progress_bar) exc_syn = StaticSynapse(weight=w_exc, delay=delay) inh_syn = StaticSynapse(weight=w_inh, delay=delay) connections = {} connections['exc'] = Projection(exc_cells, all_cells, connector, exc_syn, receptor_type='excitatory') connections['inh'] = Projection(inh_cells, all_cells, connector, inh_syn, receptor_type='inhibitory')
from pylab import * from pyNN.utility import Timer, init_logging, ProgressBar import os simulator_name = sys.argv[1] exec("from pyNN.%s import *" % simulator_name) test_cases = [int(x) for x in sys.argv[2:]] from pyNN.recording import files from pyNN.space import * timer = Timer() progress_bar = ProgressBar(mode='fixed', width=20) init_logging("connectors_benchmark_%s.log" % simulator_name, debug=True) def draw_rf(cell, positions, connections, color='k'): idx = numpy.where(connections[:, 1] == cell)[0] sources = connections[idx, 0] for src in sources: plot([positions[cell, 1], positions[src, 1]], [positions[cell, 2], positions[src, 2]], c=color) def distances(pos_1, pos_2, N): dx = abs(pos_1[:, 0] - pos_2[:, 0]) dy = abs(pos_1[:, 1] - pos_2[:, 1]) dx = numpy.minimum(dx, N - dx) dy = numpy.minimum(dy, N - dy) return sqrt(dx * dx + dy * dy)
rate=rate, duration=stim_dur), label="expoisson") if options.protocol == "1": t_stim2 = 1000. ext_stim2 = sim.Population(stim_population, sim.SpikeSourcePoisson(start=t_stim2, rate=rate, duration=stim_dur), label="expoisson") rconn = 0.01 / stim_population #so that stim_population*rconn = 1 #used to be 0.01 ext_conn = sim.FixedProbabilityConnector(rconn) ext_syn = sim.StaticSynapse(weight=0.1) print("%s Connecting populations..." % node_id) progress_bar = ProgressBar(width=20) if options.use_csa: connector = sim.CSAConnector(csa.cset(csa.random(pconn))) else: connector = sim.FixedProbabilityConnector(pconn, rng=rng, callback=progress_bar) exc_syn = sim.StaticSynapse(weight=w_exc, delay=delay) inh_syn = sim.StaticSynapse(weight=w_inh, delay=delay) connections = {} if options.use_views or options.use_assembly: connections['exc'] = sim.Projection(exc_cells, all_cells, connector, exc_syn,
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 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
sim.setup() celltype = sim.IF_curr_alpha(tau_m=tau, v_thresh=theta, tau_refrac=2.0, v_reset=10.0, v_rest=0.0, cm=tau/1.5, tau_syn_E=tau_syn, tau_syn_I=tau_syn) ext_stim = sim.SpikeSourcePoisson(rate=input_rate) exc_cells = sim.Population(Ne, celltype, initial_values={'v': v_init}, label="Exc") inh_cells = sim.Population(Ni, celltype, initial_values={'v': v_init}, label="Inh") external = sim.Population(int(Cext), ext_stim, label="Ext") all_cells = exc_cells + inh_cells all_to_all = sim.AllToAllConnector(callback=ProgressBar()) random_uniform = sim.FixedProbabilityConnector(p_connect=epsilon, callback=ProgressBar()) static_ext = sim.StaticSynapse(delay=delay, weight=Jext) static_exc = sim.StaticSynapse(delay=delay, weight=Je) static_inh = sim.StaticSynapse(delay=delay, weight=Ji) input_prj = sim.Projection(external, all_cells, all_to_all, synapse_type=static_ext, receptor_type="excitatory", label="External") exc_prj = sim.Projection(exc_cells, all_cells, random_uniform, synapse_type=static_exc, receptor_type="excitatory", label="Excitation") inh_prj = sim.Projection(inh_cells, all_cells, random_uniform, synapse_type=static_inh, receptor_type="inhibitory", label="Inhibition")