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)