def simulate(self): """ Create the network and execute simulation. Record used memory and wallclock time. """ t0 = time.time() self.base_memory = self.memory() self.prepare() t1 = time.time() self.time_prepare = t1 - t0 print("Prepared simulation in {0:.2f} seconds.".format( self.time_prepare)) self.create_recording_devices() self.create_areas() t2 = time.time() self.time_network_local = t2 - t1 print("Created areas and internal connections in {0:.2f} seconds.". format(self.time_network_local)) self.cortico_cortical_input() t3 = time.time() self.network_memory = self.memory() self.time_network_global = t3 - t2 print( "Created cortico-cortical connections in {0:.2f} seconds.".format( self.time_network_global)) self.save_network_gids() print("Network size:", nest.GetKernelStatus('network_size')) print("Saved network in {0:2f} seconds.".format(time.time() - t3)) t4 = time.time() nest.Prepare() nest.Run(10.) self.time_init = time.time() - t4 self.init_memory = self.memory() print("Init time in {0:.2f} seconds.".format(self.time_init)) t5 = time.time() #nest.Simulate(self.T) nest.Run(self.T) nest.Cleanup() t6 = time.time() self.time_simulate = t6 - t5 self.total_memory = self.memory() print("Simulated network in {0:.2f} seconds.".format( self.time_simulate)) self.logging()
def RunSimulation(): nest.set_verbosity(M_INFO) logger = Logger() logger.log('{} # virt_mem_0'.format(memory_thisjob())) # ----------------------- Network Construction ----------------------------- BuildNetwork(logger) # ---------------- Initial simulation: rig and calibrate ------------------- tic = time.time() nest.Prepare() nest.Run(params['inisimtime']) InitializationTime = time.time() - tic logger.log('{} # init_time'.format(InitializationTime)) logger.log('{} # virt_mem_after_init'.format(memory_thisjob())) # ----------------------- Cleanup and output ------------------------------- nest.Cleanup() logger.log('{} # num_neurons'.format(logger_params['num_nodes'])) logger.log('{} # num_connections'.format( nest.GetKernelStatus('num_connections'))) logger.log('{} # min_delay'.format(nest.GetKernelStatus('min_delay'))) logger.log('{} # max_delay'.format(nest.GetKernelStatus('max_delay')))
def simulate(self, dvs_data, reward_conditional, reward_collision, area_left, area_right, test): for synapse in self.conn_l: weight = nest.GetStatus([synapse], keys="weight")[0] nest.SetStatus( [synapse], { "n": (reward_conditional - reward_collision) * weight * p.reward_factor * 0.0001 }) for synapse in self.conn_r: weight = nest.GetStatus([synapse], keys="weight")[0] nest.SetStatus( [synapse], { "n": -(reward_conditional + reward_collision) * weight * p.reward_factor * 0.0001 }) time = nest.GetKernelStatus("time") # # nest.SetStatus(self.spike_generators_left, {"origin": time}) # nest.SetStatus(self.spike_generators_left, {"stop": p.sim_time}) # nest.SetStatus(self.spike_generators_right, {"origin": time}) # nest.SetStatus(self.spike_generators_right, {"stop": p.sim_time}) nest.SetStatus(self.spike_generators, {"origin": time}) nest.SetStatus(self.spike_generators, {"stop": p.sim_time}) dvs_data = dvs_data.reshape(dvs_data.size) for i in range(dvs_data.size): rate = dvs_data[i] / p.max_spikes rate = np.clip(rate, 0, 1) * p.max_poisson_freq nest.SetStatus([self.spike_generators[i]], {"rate": rate}) # if i < 16: # nest.SetStatus([self.spike_generators_left[i]], {"rate": rate}) # else: # nest.SetStatus([self.spike_generators_right[i % 16]], {"rate": rate}) if test: nest.Prepare() nest.Run(p.sim_time) nest.Cleanup() else: nest.Simulate(p.sim_time) n_l = nest.GetStatus(self.spike_detector, keys="n_events")[0] n_r = nest.GetStatus(self.spike_detector, keys="n_events")[1] nest.SetStatus(self.spike_detector, {"n_events": 0}) weights_l = np.array(nest.GetStatus( self.conn_l, keys="weight")).reshape(p.resolution) weights_r = np.array(nest.GetStatus( self.conn_r, keys="weight")).reshape(p.resolution) # weights_l = np.array(nest.GetStatus(self.conn_l, keys="weight")).reshape(4,4) # weights_r = np.array(nest.GetStatus(self.conn_r, keys="weight")).reshape(4,4) return n_l, n_r, weights_l, weights_r
def simulate_mpi_co_simulation(time_synch, end, logger): """ simulation with co-simulation :param time_synch: time of synchronization between all the simulator :param end : time of end simulation :param logger : logger simulation """ # Simulation count = 0.0 logger.info("Nest Prepare") nest.Prepare() while count * time_synch < end: # FAT END POINT logger.info(" Nest run time " + str(nest.GetKernelStatus('time'))) nest.Run(time_synch) logger.info(" Nest end") count += 1 logger.info("cleanup") nest.Cleanup() logger.info("finish") return
def run(self, dvs_data): """Run the SNN (use this for testing as weights are not changed).""" # Set poisson neuron firing time span time = nest.GetKernelStatus("time") nest.SetStatus(self.spike_generators, {"origin": time}) nest.SetStatus(self.spike_generators, {"stop": params.sim_time}) # Set poisson neuron firing frequency dvs_data = dvs_data.reshape(dvs_data.size) for i in range(dvs_data.size): rate = dvs_data[i] / params.max_spikes rate = np.clip(rate, 0, 1) * params.max_poisson_freq nest.SetStatus([self.spike_generators[i]], {"rate": rate}) # Run network in NEST nest.Prepare() nest.Run(params.sim_time) nest.Cleanup() # Get left and right output spikes n_l = nest.GetStatus(self.spike_detector, keys="n_events")[0] n_r = nest.GetStatus(self.spike_detector, keys="n_events")[1] # Reset output spike detector nest.SetStatus(self.spike_detector, {"n_events": 0}) return n_l, n_r
def run(self, stim=0, stim_rate=0.5, stim_tim=5000, n_trials=1): """run the simulation Chunk - to prevent from running unnecessary stim - with extra Poiss inoput""" # print("Simulating") # Simulate in chunk and check a special condition in between # Thus we avoid unwanted condition if self.chunk and stim != 1: nest.Prepare() self.chunk_times = np.arange(0, self.simtime + 1, self.chunk_size)[1::] if len(self.chunk_times) != int(self.simtime / self.chunk_size): raise ChunkError('check the simulation length') for ch in self.chunk_times: nest.Run(self.chunk_size) self.events_ex = nest.GetStatus(self.espikes, "n_events")[0] self.rate_ex = self.events_ex / ch * 1000.0 / self.N_rec if self.rate_ex > 200.0: #if self.verbose: print('rate is ', self.rate_ex) print('Rate is too high. Finishing simulation at %s ms' % (self.chunk_size)) self.simtime = ch #self.chunk_size break nest.Cleanup() elif stim == 1: self.nu_th = self.theta / ( self.J * self.KE * self.tauMem ) ## (theta * CMem) / (J_ex * CE * exp(1) * tauMem * tauSyn) #self.new_nu_ex = stim_eta * self.nu_th self.new_p_rate = stim_rate self.add_noise = nest.Create("poisson_generator") nest.Simulate(self.simtime) nest.SetStatus(self.add_noise, {"rate": self.new_p_rate}) nest.Connect(self.add_noise, self.nodes_ex[:100], syn_spec=self.syn_dict) #nest.Connect(self.add_noise,self.nodes_in[:100], syn_spec=self.syn_dict) for trial in range(n_trials): nest.SetStatus(self.add_noise, {"rate": self.new_p_rate}) nest.Simulate(stim_tim) nest.SetStatus(self.add_noise, {"rate": 0.0}) nest.Simulate(10000) else: #nest.Simulate(self.simtime) nest.Prepare() nest.Run(self.simtime) nest.Cleanup() if self.verbose: self.events_ex = nest.GetStatus(self.espikes, "n_events")[0] #self.events_in = nest.GetStatus(self.ispikes,"n_events")[0] self.rate_ex = self.events_ex / self.simtime * 1000.0 / self.N_rec #self.rate_in = self.events_in/self.simtime*1000.0/self.N_rec self.num_synapses = ( nest.GetDefaults("excitatory")["num_connections"] + nest.GetDefaults("inhibitory")["num_connections"] + nest.GetDefaults("external")["num_connections"]) print("Brunel network simulation (Python)") print("Number of neurons : {0}".format(self.N)) print("Number of synapses: {0}".format(self.num_synapses)) print(" Exitatory : {0}".format( int(self.KE * self.N) + self.N)) print(" Inhibitory : {0}".format(int(self.KI * self.N))) print("Rate : %.2f Hz" % self.rate_ex) #print("Inhibitory rate : %.2f Hz" % self.rate_in) print("Simulation time : %.2f s" % self.simtime)
# Creation of current generator dc = nest.Create("dc_generator", params={"amplitude": 900.0}) dc_2 = nest.Create("dc_generator", params={"amplitude": 1000.0}) print("create nodes") # Creation of connections nest.Connect(s_ex, n, syn_spec={"weight": 1000.0}) nest.Connect(s_in, n_2, syn_spec={"weight": 1000.0}) nest.Connect(n, m) nest.Connect(n_2, m) nest.Connect(s_ex, m_2) nest.Connect(s_in, m_2) nest.Connect(n, m_3) nest.Connect(n_2, m_3) nest.Connect(s_ex, m_4) nest.Connect(s_in, m_4) print("create connect") ''' A network simulation with a duration of 5*100 ms is started. ''' print("Spike generator 1 {} and 2 {}".format(s_in, s_ex)) nest.Prepare() print("Start run") nest.Run(200.) nest.Run(200.) nest.Run(200.) nest.Run(200.) nest.Cleanup() # print result print(nest.GetStatus(m_3)[0]['events']) print(nest.GetStatus(m_4)[0]['events'])
if len(args) > 1: scale = int(args[1]) totVPs = int(args[2]) else: scale = 0.1 totVPs = 4 print("scale: ", scale) print("totVPs: ", totVPs) if __name__ == '__main__': nest.SetKernelStatus({'total_num_virtual_procs': totVPs}) pops = CreatePopulations(scale) ConnectAll(pops) # Init time and memory tic = time.time() nest.Prepare() nest.Run(10.) InitializationTime = time.time() - tic print('{} # init_time'.format(InitializationTime)) print('{} # virt_mem_after_init'.format( nest.ll_api.sli_func('memory_thisjob'))) print('{} # virt_mem_after_sim'.format( nest.ll_api.sli_func( 'memory_thisjob'))) # No simulation, just here for consistency
def runs(self): with nest.RunManager(): for _ in range(self.steps): nest.Run(self.time)
# This loop runs over the `n_trials` trials and performs a standard protocol # of a high-rate response, followed by a pause and then a recovery response. # # We actually run over ``n_trials + 1`` rounds, since the first trial is for # equilibration and is not recorded (see voltmeter parameters above). # # We use the NEST ``:class:.RunManager`` to improve performance and call ``:func:.Run`` # inside for each part of the simulation. # # We print a line of breadcrumbs to indicate progress. print(f"Simulating {n_trials} times ", end="", flush=True) with nest.RunManager(): for t in range(n_trials + 1): pre_neuron.I_e = I_stim nest.Run(T_on) pre_neuron.I_e = 0.0 nest.Run(T_off) if t % 10 == 0: print(".", end="", flush=True) print() ############################################################################### # Simulate one additional time step. This ensures that the # voltage traces for all trials, including the last, have the full length, so we # can easily transform them into a matrix below. nest.Simulate(nest.resolution) ###############################################################################
def create_network( path, nb_VP, nb_mpi, nb_run, time_sim, spike_generator=0, parrot=0, iaf=0, nb_mpi_recorder=0, separate=False, nb_mpi_generator_spike=0, nb_mpi_generator_current=0, shared_mpi_input=False, mix_mpi=0, ): """ configure Nest for the testing part :param path: path for saving sim :param nb_VP: number of virtual processing :param nb_mpi: number of MPI rank :param nb_run: number of run :param time_sim: time of 1 run :param spike_generator: number of devices :param parrot: number of parrot neurons :param iaf: number of model of neurons :param nb_mpi_recorder: number of MPI recording :param separate: boolean for the separation of not of the reference :param nb_mpi_generator_spike: number of mpi generator spike :param nb_mpi_generator_current: number of mpi current :param shared_mpi_input: shared of the mpi run ( need to valide the test ) :param mix_mpi: different case #TODO not yet implemented : creation of network where mpi input and output are connected :return: """ print(nb_VP, nb_run, time_sim, spike_generator, parrot, iaf, nb_mpi_recorder, separate, nb_mpi_generator_spike, nb_mpi_generator_current, shared_mpi_input, mix_mpi) sys.stdout.flush() # name of the test name = "nb_VP_"+str(nb_VP)+"nb_mpi"+str(nb_mpi)\ +'_D_'+str(int(spike_generator))+'_P_'+str(int(parrot))+'_N_'+str(int(iaf))\ +'_R_'+str(nb_mpi_recorder)+'_Separate_'+str(int(separate))\ +'_GS_'+str(nb_mpi_generator_spike) +'_GC_'+str(nb_mpi_generator_current)\ +'_SH_'+str(int(shared_mpi_input))+'_SM_'+str(mix_mpi) logger = create_logger( path + '/log/', name='nest_' + str(nest.Rank())) # TODO need to use it for the degging part nest.ResetKernel() nest.SetKernelStatus({ "overwrite_files": True, "data_path": path, "total_num_virtual_procs": nb_VP, }) # compute index and nb element for distinguish the different tests nb_element = int(parrot > 0) + int(spike_generator > 0) + int(iaf > 0) if nb_element == 0: raise Exception('Miss the configuration ' + str(nb_element)) if shared_mpi_input: if nb_mpi_recorder != 0 and nb_mpi_recorder % nb_element != 0: raise Exception('Miss nb recorder') if nb_mpi_generator_spike != 0 and nb_mpi_generator_spike % nb_element != 0: raise Exception('Miss nb spike generator') if nb_mpi_generator_current != 0 and nb_mpi_generator_current % nb_element != 0: raise Exception('Miss nb current generator') index_parrot = -2 index_device = -2 index_aif = -2 else: if parrot > 0: index_parrot = 0 if spike_generator > 0: index_device = 1 if iaf > 0: index_aif = 2 else: index_aif = -1 else: index_device = -1 if iaf > 0: index_aif = 1 else: index_aif = -1 else: index_parrot = -1 if spike_generator > 0: index_device = 0 if iaf > 0: index_aif = 1 else: index_aif = -1 else: index_device = -1 if iaf > 0: index_aif = 0 else: index_aif = -1 #create mpi device recorders = [] generator_spike = [] generator_current = [] for i in range(nb_mpi_recorder): recorders.append( nest.Create("spike_recorder", params={ "record_to": "mpi", "label": "file_record" })) for i in range(nb_mpi_generator_spike): generator_spike.append( nest.Create("spike_generator", params={ "spike_times": np.array([]), 'stimulus_source': 'mpi', "label": "file_gen_spike" })) for i in range(nb_mpi_generator_current): generator_current.append( nest.Create("step_current_generator", params={ 'amplitude_times': np.array([]), 'amplitude_values': np.array([]), 'stimulus_source': 'mpi', "label": "file_gen_current" })) # particular device poisson_generator = None if parrot > 0 and nb_mpi_recorder > 0: poisson_generator = nest.Create("poisson_generator") # recorder recorders_twins = [] recorder_parrot = [] recorder_device = [] recorder_neuron = [] for i in range(nb_mpi_recorder): recorders_twins.append( nest.Create("spike_recorder", params={"record_to": "memory"})) if parrot > 0: if (index_parrot != -1 and i % nb_element == index_parrot) or index_parrot == -2: recorder_parrot.append(nest.Create('parrot_neuron', parrot)) nest.Connect(poisson_generator, recorder_parrot[-1]) nest.Connect(recorder_parrot[-1], recorders[i]) nest.Connect(recorder_parrot[-1], recorders_twins[i]) if spike_generator > 0: if (index_device != -1 and i % nb_element == index_device) or index_device == -2: np.random.seed(recorders[i].tolist()[0]) recorder_device.append( nest.Create("spike_generator", spike_generator)) for j in range(spike_generator): recorder_device[-1][j].set({ "spike_times": np.around(np.sort( np.random.rand(100) * time_sim * nb_run), decimals=1).tolist() }) nest.Connect(recorder_device[-1], recorders[i]) if separate: np.random.seed(recorders[i].tolist()[0]) new_generator = nest.Create("spike_generator", spike_generator) for j in range(spike_generator): new_generator[j].set({ "spike_times": np.around(np.sort( np.random.rand(100) * time_sim * nb_run), decimals=1).tolist() }) nest.Connect(new_generator, recorders_twins[i]) else: nest.Connect(recorder_device[-1], recorders_twins[i]) if iaf > 0: if (index_aif != -1 and i % nb_element == index_aif) or index_aif == -2: recorder_neuron.append(nest.Create('iaf_psc_alpha', iaf)) nest.Connect(poisson_generator, recorder_neuron[-1]) nest.Connect(recorder_neuron[-1], recorders[i]) nest.Connect(recorder_neuron[-1], recorders_twins[i]) # generator spike generator_spike_twin = [] generator_spike_parrot = [] generator_spike_parrot_bis = None if separate: generator_spike_parrot_bis = [] generator_spike_device = [] generator_spike_device_bis = None if separate: generator_spike_device_bis = [] generator_spike_neuron = [] generator_spike_neuron_bis = None if separate: generator_spike_neuron_bis = [] for i in range(nb_mpi_generator_spike): data = generate_spike(generator_spike[i].tolist()[0], nb_run, time_sim)[1] data = np.concatenate(data).tolist() generator_spike_twin.append( nest.Create("spike_generator", params={"spike_times": data})) if parrot > 0: if (index_parrot != -1 and i % nb_element == index_parrot) or index_parrot == -2: new_parrot = nest.Create('parrot_neuron', parrot) generator_spike_parrot.append( nest.Create("spike_recorder", params={"record_to": "memory"})) nest.Connect(generator_spike[i], new_parrot) nest.Connect(new_parrot, generator_spike_parrot[-1]) if separate: new_parrot_2 = nest.Create('parrot_neuron', parrot) generator_spike_parrot_bis.append( nest.Create("spike_recorder", params={"record_to": "memory"})) nest.Connect(generator_spike_twin[i], new_parrot_2) nest.Connect(new_parrot_2, generator_spike_parrot_bis[-1]) else: nest.Connect(generator_spike_twin[i], new_parrot) if spike_generator > 0: if (index_device != -1 and i % nb_element == index_device) or index_device == -2: np.random.seed(generator_spike[-1].tolist()[0]) generator_spike_device.append( nest.Create("spike_recorder", spike_generator)) nest.Connect(generator_spike[i], generator_spike_device[-1]) if separate: generator_spike_device_bis.append( nest.Create("spike_recorder", spike_generator)) nest.Connect(generator_spike_twin[i], generator_spike_device_bis[-1]) else: nest.Connect(generator_spike_twin[i], generator_spike_device[-1]) if iaf > 0: if (index_aif != -1 and i % nb_element == index_aif) or index_aif == -2: neuron_test = nest.Create('iaf_psc_alpha', iaf) generator_spike_neuron.append(nest.Create("spike_recorder", 1)) nest.Connect(generator_spike[i], neuron_test) nest.Connect(neuron_test, generator_spike_neuron[-1]) if separate: generator_spike_neuron_bis.append( nest.Create("spike_recorder", 1)) nest.Connect(generator_spike_twin[i], generator_spike_neuron_bis[-1]) else: nest.Connect(generator_spike_twin[i], generator_spike_neuron[-1]) # generator generator_current_twin = [] generator_current_parrot = [] generator_current_parrot_bis = None if separate: generator_current_parrot_bis = [] generator_current_device = [] generator_current_device_bis = None if separate: generator_current_device_bis = [] generator_current_neuron = [] generator_current_neuron_bis = None if separate: generator_current_neuron_bis = [] for i in range(nb_mpi_generator_current): data = np.concatenate( generate_current(generator_current[i].tolist()[0], nb_run, time_sim)[1]) generator_current_twin.append( nest.Create("step_current_generator", params={ 'amplitude_times': data[:, 0], 'amplitude_values': data[:, 1], })) if parrot > 0: if (index_parrot != -1 and i % nb_element == index_parrot) or index_parrot == -2: new_neuron = nest.Create('iaf_cond_alpha', parrot) generator_current_parrot.append( nest.Create("multimeter", params={ 'record_from': ['V_m'], "record_to": "memory" })) nest.Connect(generator_current[i], new_neuron) nest.Connect(generator_current_parrot[-1], new_neuron) if separate: new_neuron_2 = nest.Create('iaf_cond_alpha', parrot) generator_current_parrot_bis.append( nest.Create("multimeter", params={ 'record_from': ['V_m'], "record_to": "memory" })) nest.Connect(generator_current_twin[i], new_neuron_2) nest.Connect(generator_current_parrot_bis[-1], new_neuron_2) else: nest.Connect(generator_current_twin[i], new_neuron) if spike_generator > 0: if (index_device != -1 and i % nb_element == index_device) or index_device == -2: neuron_test = nest.Create('iaf_cond_alpha', iaf) generator_current_device.append( nest.Create("multimeter", params={ 'record_from': ['V_m'], "record_to": "memory" })) nest.Connect(generator_current[i], neuron_test) nest.Connect(generator_current_device[-1], neuron_test) if separate: neuron_test_2 = nest.Create('iaf_cond_alpha', iaf) generator_current_device_bis.append( nest.Create("multimeter", params={ 'record_from': ['V_m'], "record_to": "memory" })) nest.Connect(generator_current_device_bis[-1], neuron_test) nest.Connect(generator_current_twin[i], neuron_test_2) else: nest.Connect(generator_current_twin[i], neuron_test) if iaf > 0: if (index_aif != -1 and i % nb_element == index_aif) or index_aif == -2: neuron_test = nest.Create('iaf_psc_alpha', iaf) generator_current_neuron.append( nest.Create("multimeter", params={ 'record_from': ['V_m'], "record_to": "memory" })) nest.Connect(generator_current[i], neuron_test) nest.Connect(generator_current_neuron[-1], neuron_test) if separate: neuron_test_2 = nest.Create('iaf_psc_alpha', iaf) generator_current_neuron_bis.append( nest.Create("multimeter", params={ 'record_from': ['V_m'], "record_to": "memory" })) nest.Connect(generator_current_neuron_bis[-1], neuron_test) nest.Connect(generator_current_twin[i], neuron_test_2) else: nest.Connect(generator_current_twin[i], neuron_test) # start simulation nest.Prepare() for i in range(nb_run): nest.Run(time_sim) nest.Cleanup() # write result in file for the validation devices_record_memory = [ ('recorders_memory', recorders_twins), ('GS_parrot', generator_spike_parrot), ('GS_parrot_bis', generator_spike_parrot_bis), ('GS_spike_device', generator_spike_device), ('GS_spike_device_bis', generator_spike_device_bis), ('GS_spike_neuron', generator_spike_neuron), ('GS_spike_neuron_bis', generator_spike_neuron_bis), ('GC_parrot', generator_current_parrot), ('GC_parrot_bis', generator_current_parrot_bis), ('GC_device', generator_current_device), ('GC_device_bis', generator_current_device_bis), ('GC_neuron', generator_current_neuron), ('GC_neuron_bis', generator_current_neuron_bis) ] for label, devices in devices_record_memory: if devices is not None: data_collect = [] for device in devices: for data in nest.GetStatus(device): data_collect.append(data['events']) name_save = path + '/' + label + '_rank_' + str( nest.Rank()) + '.npy' np.save(name_save, data_collect, allow_pickle=True)