def test_multysinapse(): neuron1 = nest.Create("iaf_psc_alpha_multisynapse_neuron") neuron2 = nest.Create("iaf_psc_alpha_multisynapse_neuron") nest.SetDefaults("iaf_psc_alpha_multisynapse", {"tau_syn": [1.0, 2.0]}) spikegenerator = nest.Create('spike_generator', params={'spike_times': [100.0, 200.0]}) syn_dict = {"model": "static_synapse", "weight": 2.5, 'receptor_type': 1} nest.Connect(spikegenerator, neuron2, syn_spec=syn_dict) nest.Connect(spikegenerator, neuron1, syn_spec=syn_dict) # nest.SetStatus(neuron1, {"I_e": 376.0}) # nest.SetStatus(neuron2, {"I_e": 376.0}) multimeter1 = nest.Create('multimeter') multimeter2 = nest.Create('multimeter') V_m_specifier = 'V_m' # 'delta_V_m' nest.SetStatus(multimeter1, { "withtime": True, "record_from": [V_m_specifier] }) nest.SetStatus(multimeter2, { "withtime": True, "record_from": [V_m_specifier] }) nest.Connect(multimeter1, neuron1) nest.Connect(multimeter2, neuron2) nest.Simulate(400.0) dmm1 = nest.GetStatus(multimeter1)[0] Vms1 = dmm1["events"][V_m_specifier] ts1 = dmm1["events"]["times"] events1 = dmm1["events"] pylab.figure(1) dmm2 = nest.GetStatus(multimeter2)[0] Vms2 = dmm2["events"][V_m_specifier] ts2 = dmm2["events"]["times"] pylab.plot(ts1, Vms1) pylab.plot(ts2, Vms2) pylab.show() for index in range(0, len(Vms1)): if abs(Vms1[index] - Vms2[index]) > 0.000001: print('!!!!!!!!!!!!!!!!!!!!') print( str(Vms1[index]) + " divers from " + str(Vms2[index]) + " at iteration: " + str(index) + " of overall iterations: " + str(len(Vms1))) print('!!!!!!!!!!!!!!!!!!!!') raise Exception("TEST FAILED") elif abs(Vms1[index] - Vms2[index]) > 0: print("Greater than 0 difference" + str(abs(Vms1[index] - Vms2[index])) + " at iteration: " + str(index) + " of overall iterations: " + str(len(Vms1))) print("Test: PASSED")
def create(model, number): """Allow multiple model instance to be unpack as they are created.""" return map(lambda x: (x, ), nest.Create(model, number))
# # To directly simulate the mesoscopic population activities (i.e. generating # the activity of a finite-size population without simulating single # neurons), we can build the populations using the NEST model # ``gif_pop_psc_exp``: nest.set_verbosity("M_WARNING") nest.ResetKernel() nest.SetKernelStatus({ 'resolution': dt, 'print_time': True, 'local_num_threads': 1 }) t0 = nest.GetKernelStatus('time') nest_pops = nest.Create('gif_pop_psc_exp', M) C_m = 250. # irrelevant value for membrane capacity, cancels out in simulation g_L = C_m / tau_m params = [ { 'C_m': C_m, 'I_e': mu[i] * g_L[i], 'lambda_0': c[i], # in Hz! 'Delta_V': Delta_u[i], 'tau_m': tau_m[i], 'tau_sfa': tau_theta[i], 'q_sfa': J_theta[i] / tau_theta[i], # [J_theta]= mV*ms -> [q_sfa]=mV 'V_T_star': V_th[i], 'V_reset': V_reset[i],
'period_first': 500.0, 'period_second': 500.0, 'rate_first': 1000., 'rate_second': 800. } df = nest.GetDefaults("aeif_cond_exp") # pp(df) nest.CopyModel("aeif_cond_exp", "STN", getPramsSTN()) # rec=nest.GetDefaults("my_aeif_cond_exp")["receptor_types"] # pp(rec) n = nest.Create(**{ 'model': 'poisson_generator_periodic', 'n': 1000, 'params': par }) # n=nest.Create(**{ # 'model':'poisson_generator', # 'n':1000, # 'params':{'rate':900.}}) m = nest.Create('aeif_cond_exp', 1000) # m=nest.Create('my_aeif_cond_exp', 100) # m=nest.Create('izhik_cond_exp', 100) # nest.CopyModel( "static_synapse", "excitatory",
if (Dt >= 0): fact = Wplus * math.exp(-Dt / tau_plus) w1 = w + fact * math.pow(1.0 - w / Wmax, mu_plus) if w1 > Wmax: w1 = Wmax else: fact = -alpha * Wplus * math.exp(Dt / tau_minus) w1 = w + fact * math.pow(w / Wmax, mu_minus) if w1 < 0.0: w1 = 0.0 return w1 # presynaptic and postsynaptic neurons neuron_pre = nest.Create("parrot_neuron") neuron_post = nest.Create("parrot_neuron") #spike generators sg_pre = nest.Create("spike_generator") sg_post = nest.Create("spike_generator") # spike times spike_times_pre = [4.0] spike_times_post = [1.0, 5.0] nest.SetStatus(sg_pre, {"spike_times": spike_times_pre}) nest.SetStatus(sg_post, {"spike_times": spike_times_post}) # connect spike generators to neurons syn_dict = {"weight": 1.0, "delay": 1.0} nest.Connect(sg_pre, neuron_pre, "one_to_one", syn_dict)
def create_network(self): #! ============================= #! Configuration of the network #! ============================= # Load the LIF neuron model model = nest.Models(mtype='nodes',sel='iaf_bw_2003') if not model: nest.Install("mymodule") # Layers are configured as free layers (no spatial structure) pos_exc = [[np.random.uniform(-self.extent/2.0,self.extent/2.0), np.random.uniform(-self.extent/2.0,self.extent/2.0)] for j in range(self.N_exc)] layerProps_exc = { 'positions': pos_exc, 'extent' : [self.extent, self.extent], 'edge_wrap': False } pos_inh = [[np.random.uniform(-self.extent/2.0,self.extent/2.0), np.random.uniform(-self.extent/2.0,self.extent/2.0)] for j in range(self.N_inh)] layerProps_inh = { 'positions': pos_inh, 'extent' : [self.extent, self.extent], 'edge_wrap': False } # Layers of thalamocortical and cortical-cortical inputs have a single # poisson generator that sends independent spike trains to each cell, # instead of a layer with multiple poisson generators (to decrease # memory consumption) pos_th = [[np.random.uniform(-self.extent/2.0,self.extent/2.0), np.random.uniform(-self.extent/2.0,self.extent/2.0)] for j in range(1)] layerProps_th = { 'positions': pos_th, 'extent' : [self.extent, self.extent], 'edge_wrap': False } pos_cc = [[np.random.uniform(-self.extent/2.0,self.extent/2.0), np.random.uniform(-self.extent/2.0,self.extent/2.0)] for j in range(1)] layerProps_cc = { 'positions': pos_cc, 'extent' : [self.extent, self.extent], 'edge_wrap': False } # There is one parrot neuron for each excitatory/inhibitory cell of the network pos_parrot = [[np.random.uniform(-self.extent/2.0,self.extent/2.0), np.random.uniform(-self.extent/2.0,self.extent/2.0)] for j in range(self.N_exc + self.N_inh)] layerProps_parrot = { 'positions': pos_parrot, 'extent' : [self.extent, self.extent], 'edge_wrap': False } # NEST Kernel and Network settings np.random.seed(int(time.time())) seeds = np.arange(self.num_threads) + int((time.time()*100)%2**32) # Seeds # are different in each simulation nest.ResetKernel() nest.ResetNetwork() nest.SetKernelStatus({"local_num_threads": self.num_threads, "resolution": self.simstep, "data_path": os.path.abspath(os.path.join(__file__ ,"../results")), "rng_seeds": list(seeds)}) # Define properties of neuron models nest.CopyModel("iaf_bw_2003", "exc_cell", self.excitatory_cell_params) nest.CopyModel("iaf_bw_2003", "inh_cell", self.inhibitory_cell_params) # Thalamocortical and cortical-cortical inputs are defined as poisson generators nest.CopyModel("inhomogeneous_poisson_generator", "thalamocortical_input") nest.CopyModel("inhomogeneous_poisson_generator", "cortical_input") # Create layers self.exc = tp.CreateLayer(tools.updateDicts(layerProps_exc, {'elements': 'exc_cell'})) self.inh = tp.CreateLayer(tools.updateDicts(layerProps_inh, {'elements': 'inh_cell'})) self.thalamo = tp.CreateLayer(tools.updateDicts(layerProps_th, {'elements': 'thalamocortical_input'})) self.cort = tp.CreateLayer(tools.updateDicts(layerProps_cc, {'elements': 'cortical_input'})) # The layers of parrot neurons are used to compute the PSP (see below). # They also facilitate the computation of spike times from external inputs self.parrot_layer_th = tp.CreateLayer(tools.updateDicts(layerProps_parrot, {'elements': 'parrot_neuron'})) self.parrot_layer_cc = tp.CreateLayer(tools.updateDicts(layerProps_parrot, {'elements': 'parrot_neuron'})) # Ornstein-Uhlenbeck process (solved by Euler method) time_array = np.arange(self.simstep,self.simtime- self.simstep,self.simstep) OU_n = len(time_array) # Number of time steps. # Define renormalized variables (to avoid recomputing these constants # at every time step) OU_sigma_bis = self.OU_sigma * np.sqrt(2. / self.OU_tau) OU_sqrtdt = np.sqrt(self.simstep) OU_x = np.zeros(OU_n) # OU output for i in range(OU_n - 1): OU_x[i + 1] = OU_x[i] + self.simstep * (-OU_x[i] / self.OU_tau) + \ OU_sigma_bis * OU_sqrtdt * np.random.randn() # Sinusoidal rate v_signal = self.A_ext * np.sin(2.0 * np.pi * self.f_ext * time_array/1000.0) + self.v_0 # Final rate of the Poisson generators for n in nest.GetLeaves(self.thalamo)[0]: nest.SetStatus([n],{'rate_times' : time_array, 'rate_values':v_signal}) for n in nest.GetLeaves(self.cort)[0]: nest.SetStatus([n],{'rate_times' : time_array, 'rate_values':OU_x}) # Recurrent connections # (the size of the mask is big enough to ensure all cells are included within it) dict_exc_exc_recurrent = { "connection_type":"convergent", "mask": {'rectangular': {'lower_left':[-self.extent,-self.extent], 'upper_right':[self.extent,self.extent]}}, "kernel": self.P, "synapse_model": 'static_synapse', "weights": self.exc_exc_recurrent, "sources": {"model": 'exc_cell'}, "targets": {"model": 'exc_cell'}, "allow_autapses":False, "allow_multapses":False } dict_exc_inh_recurrent = { "connection_type":"convergent", "mask": {'rectangular': {'lower_left':[-self.extent,-self.extent], 'upper_right':[self.extent,self.extent]}}, "kernel": self.P, "synapse_model": 'static_synapse', "weights": self.exc_inh_recurrent, "sources": {"model": 'exc_cell'}, "targets": {"model": 'inh_cell'}, "allow_autapses":False, "allow_multapses":False } dict_inh_inh_recurrent = { "connection_type":"convergent", "mask": {'rectangular': {'lower_left':[-self.extent,-self.extent], 'upper_right':[self.extent,self.extent]}}, "kernel": self.P, "synapse_model": 'static_synapse', "weights": self.inh_inh_recurrent, "sources": {"model": 'inh_cell'}, "targets": {"model": 'inh_cell'}, "allow_autapses":False, "allow_multapses":False } dict_inh_exc_recurrent = { "connection_type":"convergent", "mask": {'rectangular': {'lower_left':[-self.extent,-self.extent], 'upper_right':[self.extent,self.extent]}}, "kernel": self.P, "synapse_model": 'static_synapse', "weights": self.inh_exc_recurrent, "sources": {"model": 'inh_cell'}, "targets": {"model": 'exc_cell'}, "allow_autapses":False, "allow_multapses":False } tp.ConnectLayers(self.exc,self.exc,dict_exc_exc_recurrent) tp.ConnectLayers(self.exc,self.inh,dict_exc_inh_recurrent) tp.ConnectLayers(self.inh,self.inh,dict_inh_inh_recurrent) tp.ConnectLayers(self.inh,self.exc,dict_inh_exc_recurrent) # Connections of the external inputs: each cell receives the same number of # external inputs as recurrent excitatory inputs (800 for the 5000-neuron network) dict_th_parrot = { "connection_type":"convergent", "mask": {'rectangular': {'lower_left':[-self.extent,-self.extent], 'upper_right':[self.extent,self.extent]}}, "kernel": 1., "synapse_model": 'static_synapse', "number_of_connections": 800, # constant fan in "weights": 1.0, "sources": {"model": 'thalamocortical_input'}, "targets": {"model": 'parrot_neuron'}, "allow_autapses":False, "allow_multapses":True } dict_cc_parrot = { "connection_type":"convergent", "mask": {'rectangular': {'lower_left':[-self.extent,-self.extent], 'upper_right':[self.extent,self.extent]}}, "kernel": 1., "synapse_model": 'static_synapse', "number_of_connections": 800, # constant fan in "weights": 1.0, "sources": {"model": 'cortical_input'}, "targets": {"model": 'parrot_neuron'}, "allow_autapses":False, "allow_multapses":True } # A parrot neuron is necessary to send the same spike train to both # original cells and cloned cells (used to compute the PSP). # Connection of Poisson generators with parrot neurons tp.ConnectLayers(self.thalamo,self.parrot_layer_th,dict_th_parrot) tp.ConnectLayers(self.cort,self.parrot_layer_cc,dict_cc_parrot) parrot_n_th = nest.GetLeaves(self.parrot_layer_th)[0] parrot_n_cc = nest.GetLeaves(self.parrot_layer_cc)[0] # Connection of parrot neurons with excitatory/inhibitory neurons i = 0 for n in nest.GetLeaves(self.exc)[0]: nest.Connect([parrot_n_th[i]],[n], 'one_to_one',syn_spec={"model":"static_synapse", "weight":self.th_exc_external}) nest.Connect([parrot_n_cc[i]],[n], 'one_to_one',syn_spec={"model":"static_synapse", "weight":self.cc_exc_external}) i+=1 for n in nest.GetLeaves(self.inh)[0]: nest.Connect([parrot_n_th[i]],[n], 'one_to_one',syn_spec={"model":"static_synapse", "weight":self.th_inh_external}) nest.Connect([parrot_n_cc[i]],[n], 'one_to_one',syn_spec={"model":"static_synapse", "weight":self.cc_inh_external}) i+=1 #! ================= #! Checkpoint #! ================= # # Plot mask and kernel of connections # fig = tp.PlotLayer(self.exc,nodesize =80) # ctr = tp.FindCenterElement(self.exc) # # tp.PlotTargets(ctr, self.exc, fig = fig, # mask=dict_exc_exc_recurrent['mask'], kernel=dict_exc_exc_recurrent['kernel'] , # src_size =250 , tgt_color = 'red' , tgt_size =20 , # kernel_color = 'green' ) # # plt.show() # # Print the avg. number of input connections # pop_ex = nest.GetLeaves(self.exc)[0] # pop_in = nest.GetLeaves(self.inh)[0] # pop_parrot_th = nest.GetLeaves(self.parrot_layer_th)[0] # pop_parrot_cc = nest.GetLeaves(self.parrot_layer_cc)[0] # pop_thalamo = nest.GetLeaves(self.thalamo)[0] # pop_cc = nest.GetLeaves(self.cort)[0] # # number_of_connections = [0,0,0,0] # for k in range(100): # conns_ex = nest.GetConnections(target = [pop_ex[k]]) # conns_th = nest.GetConnections(target = [pop_parrot_th[k]]) # conns_cc = nest.GetConnections(target = [pop_parrot_cc[k]]) # # st_ex = nest.GetStatus(conns_ex) # st_th = nest.GetStatus(conns_th) # st_cc = nest.GetStatus(conns_cc) # # for st_con in st_ex: # if st_con["source"] >= pop_ex[0] and st_con["source"] <= pop_ex[-1]: # number_of_connections[0]+=1 # if st_con["source"] >= pop_in[0] and st_con["source"] <= pop_in[-1]: # number_of_connections[1]+=1 # # for st_con in st_th: # if st_con["source"] >= pop_thalamo[0] and st_con["source"] <= pop_thalamo[-1]: # number_of_connections[2]+=1 # # for st_con in st_cc: # if st_con["source"] >= pop_cc[0] and st_con["source"] <= pop_cc[-1]: # number_of_connections[3]+=1 # # print("\nExc: %s, Inh: %s, Thalamo: %s, Cort: %s\n" % (number_of_connections[0]/\ # 100.,number_of_connections[1]/100.,number_of_connections[2]/100., # number_of_connections[3]/100.)) #! ================================================= #! Computation of the average postsynaptic potential #! ================================================= # Make a copy of a subset of neurons that receive same the synaptic input of # the original ones. The cloned neurons receive an extra spike, from the synapse under # investigation, each 100 ms if self.Compute_PSP: spike_gen_cloned = nest.Create("spike_generator") nest.SetStatus(spike_gen_cloned,{"spike_times":np.arange(500.0,self.simtime,100.0)}) cloned_n_AMPA = nest.Create("exc_cell",self.PSP_number_cells) cloned_n_GABA = nest.Create("exc_cell",self.PSP_number_cells) j=0 for n in nest.GetLeaves(self.exc)[0]: if j < self.PSP_number_cells: conns = nest.GetConnections(target = [n]) st = nest.GetStatus(conns) for st_con in st: conn_dict = {'rule': 'one_to_one'} syn_dict = {'weight': st_con["weight"]} nest.Connect([st_con["source"]],[cloned_n_AMPA[j]], conn_dict, syn_dict) nest.Connect([st_con["source"]],[cloned_n_GABA[j]], conn_dict, syn_dict) # extra spike nest.Connect(spike_gen_cloned,[cloned_n_AMPA[j]],conn_dict, {'weight': self.exc_exc_recurrent}) nest.Connect(spike_gen_cloned,[cloned_n_GABA[j]],conn_dict, {'weight': self.inh_exc_recurrent}) j+=1 #! ================= #! Recording devices #! ================= # Membrane potential and conductances if self.toMemory: record_to = 'memory' else: record_to = 'file' if len(self.To_be_measured)>0: nest.CopyModel('multimeter', 'RecordingNode', {'interval' : self.simstep, 'record_from': self.To_be_measured, 'record_to' : [record_to], 'withgid' : True, 'withtime' : True}) # Spikes nest.CopyModel('spike_detector', 'SpikesRecorder', {'record_to' : [record_to], 'withgid' : True, 'withtime' : True})
def myRun(rr1, rr2, Tstim=Tstim, Tblank=Tblank, Ntrials=Ntrials, bw = bw, \ rec_conn={'EtoE':1, 'EtoI':1, 'ItoE':1, 'ItoI':1}, nn_stim=0): # -- restart the simulator net_tools._nest_start_() init_seed = np.random.randint(1, 1234, n_cores) nest.SetStatus([0], [{'rng_seeds': init_seed.tolist()}]) # -- exc & inh neurons exc_neurons = net_tools._make_neurons_(NE, neuron_model=cell_type, \ myparams={'b':NE*[0.], 'a':NE*[0.]}) inh_neurons = net_tools._make_neurons_(NI, neuron_model=cell_type, \ myparams={'b':NE*[0.],'a':NE*[0.]}) all_neurons = exc_neurons + inh_neurons # -- recurrent connectivity if rec_conn['EtoE']: net_tools._connect_pops_(exc_neurons, exc_neurons, W_EtoE) if rec_conn['EtoI']: net_tools._connect_pops_(exc_neurons, inh_neurons, W_EtoI) if rec_conn['ItoE']: net_tools._connect_pops_(inh_neurons, exc_neurons, W_ItoE) if rec_conn['ItoI']: net_tools._connect_pops_(inh_neurons, inh_neurons, W_ItoI) # -- recording spike data spikes_all = net_tools._recording_spikes_(neurons=all_neurons) # -- background input pos_inp = nest.Create("poisson_generator", N) for ii in range(N): nest.Connect([pos_inp[ii]], [all_neurons[ii]], \ syn_spec = {'weight':Be_bkg, 'delay':delay_default}) # -- simulating network for N-trials for tri in range(Ntrials): print('') print('# -> trial # ', tri + 1) ## transient for ii in range(N): nest.SetStatus([pos_inp[ii]], {'rate': rr1[ii]}) net_tools._run_simulation_(Ttrans) ## baseline for ii in range(N): nest.SetStatus([pos_inp[ii]], {'rate': rr1[ii]}) net_tools._run_simulation_(Tblank) ## perturbing a subset of inh for ii in range(N): nest.SetStatus([pos_inp[ii]], {'rate': rr2[ii]}) net_tools._run_simulation_(Tstim) # -- reading out spiking activity spd = net_tools._reading_spikes_(spikes_all) # -- computes the rates out of spike data in a given time interval def _rate_interval_(spikedata, T1, T2, bw=bw): tids = (spikedata['times'] > T1) * (spikedata['times'] < T2) rr = np.histogram2d(spikedata['times'][tids], spikedata['senders'][tids], \ range=((T1,T2),(1,N)), bins=((T2-T1)/bw,N))[0] / (bw/1e3) return rr rout_blank = np.zeros((Ntrials, int(Tblank / bw), N)) rout_stim = np.zeros((Ntrials, int(Tstim / bw), N)) for tri in range(Ntrials): Tblock = Tstim + Tblank + Ttrans rblk = _rate_interval_(spd, Tblock * tri + Ttrans, Tblock * tri + Ttrans + Tblank) rstm = _rate_interval_(spd, Tblock * tri + Ttrans + Tblank, Tblock * (tri + 1)) rout_blank[tri, :, :] = rblk rout_stim[tri, :, :] = rstm print('##########') print('## Mean firing rates {Exc | Inh (pert.) | Inh (non-pert.)}') print('## Before pert.: ', \ np.round(rout_blank[:,:,0:NE].mean(),1), \ np.round(rout_blank[:,:,NE:NE+nn_stim].mean(),1), \ np.round(rout_blank[:,:,NE+nn_stim:].mean(),1) ) print('## After pert.: ', \ np.round(rout_stim[:,:,0:NE].mean(),1), \ np.round(rout_stim[:,:,NE:NE+nn_stim].mean(),1), \ np.round(rout_stim[:,:,NE+nn_stim:].mean(),1) ) print('##########') return rout_blank, rout_stim, spd
# synapse time constant is [2.0] ms, which is for neuron with one port. syn_tau = [2.0, 1.0] ############################################################################### # We create the five levels of GLIF model to be tested, i.e., # ``lif``, ``lif_r``, ``lif_asc``, ``lif_r_asc``, ``lif_r_asc_a``. # For each level of GLIF model, we create a ``glif_psc`` node. The node is # created by setting relative model mechanism parameters and the time constant # of the 2 synaptic ports as mentioned above. Other neuron parameters are set # as default. The five ``glif_psc`` node handles were combined as a list. n_lif = nest.Create("glif_psc", params={ "spike_dependent_threshold": False, "after_spike_currents": False, "adapting_threshold": False, "tau_syn": syn_tau }) n_lif_r = nest.Create("glif_psc", params={ "spike_dependent_threshold": True, "after_spike_currents": False, "adapting_threshold": False, "tau_syn": syn_tau }) n_lif_asc = nest.Create("glif_psc", params={ "spike_dependent_threshold": False, "after_spike_currents": True, "adapting_threshold": False,
def run_protocol(self, dt): """Set up a network with pre-post spike pairings with t_post - t_pre = dt""" nest.set_verbosity("M_WARNING") nest.ResetKernel() # set pre and postsynaptic spike times delay = 1. # delay for connections dspike = 100. # ISI # set the correct real spike times for generators (correcting for # delays) pre_times = [100., 100. + dspike] post_times = [k + dt for k in pre_times] # create spike_generators with these times pre_spikes = nest.Create("spike_generator", params={ "spike_times": pre_times, 'precise_times': True }) post_spikes = nest.Create("spike_generator", params={ "spike_times": post_times, 'precise_times': True }) # create parrot neurons and connect spike_generators pre_parrot = nest.Create("parrot_neuron_ps", 1) post_parrot = nest.Create("parrot_neuron_ps", 1) nest.Connect(pre_spikes, pre_parrot, syn_spec={"delay": delay}) nest.Connect(post_spikes, post_parrot, syn_spec={"delay": delay}) # create spike recorder spikes = nest.Create("spike_recorder") nest.Connect(pre_parrot, spikes) nest.Connect(post_parrot, spikes) # connect both parrot neurons with a stdp synapse onto port 1 # thereby spikes transmitted through the stdp connection are # not repeated postsynaptically. syn_spec = { "synapse_model": "stdp_synapse", # set receptor 1 postsynaptically, to not generate extra spikes "receptor_type": 1, } conn_spec = { "rule": "one_to_one", } nest.Connect(pre_parrot, post_parrot, syn_spec=syn_spec, conn_spec=conn_spec) # get STDP synapse and weight before protocol syn = nest.GetConnections(source=pre_parrot, synapse_model="stdp_synapse") w_pre = syn.get('weight') last_time = max(pre_times[-1], post_times[-1]) nest.Simulate(_round_up(last_time + 2 * delay)) # get weight post protocol w_post = syn.get('weight') return w_pre, w_post
# - The end of the time window to plot n_blocks = 5 t_block = 20. t_dep = [t_block] * n_blocks t_hyp = [t_block * 2**n for n in range(n_blocks)] I_dep = 10. I_hyp = -5. t_end = 500. ############################################################################### # We create the one neuron instance and the DC current generator and store # the returned handles. nrn = nest.Create('ht_neuron') dc = nest.Create('dc_generator') ############################################################################### # We create a multimeter to record # # - membrane potential ``V_m`` # - threshold value ``theta`` # - intrinsic currents ``I_NaP``, ``I_KNa``, ``I_T``, ``I_h`` # # by passing these names in the ``record_from`` list. # # To find out which quantities can be recorded from a given neuron, # run:: # # nest.GetDefaults('ht_neuron')['recordables']
'tau_m': tau_m, 'tau_syn_ex': tau_syn_ex, 'tau_syn_in': tau_syn_in, 'C_m': C_m, 'E_L': E_L, 't_ref': t_ref, 'V_m': E_L, 'V_reset': E_L } ############################################################################### # Neurons and devices are instantiated. We set a high threshold as we want # free membrane potential. In addition we choose a small resolution for # recording the membrane to collect good statistics. n = nest.Create('iaf_psc_alpha', n_neurons, params=neurondict) n_free = nest.Create('iaf_psc_alpha', params=dict(neurondict, V_th=1e12)) pg = nest.Create('poisson_generator', len(rates), {'rate': rates}) vm = nest.Create('voltmeter', params={'interval': .1}) sr = nest.Create('spike_recorder') ############################################################################### # We connect devices and neurons and start the simulation. pg_n_synspec = {'weight': np.tile(J, ((n_neurons), 1)), 'delay': 0.1} nest.Connect(pg, n, syn_spec=pg_n_synspec) nest.Connect(pg, n_free, syn_spec={'weight': [J]}) nest.Connect(vm, n_free) nest.Connect(n, sr) nest.Simulate(simtime)
"E_L": 0.0, "V_th": 15.0, "V_reset": 13.5, "V_m": 13.5, "I_e": Ie, "tau_syn_ex": 3.0, "tau_syn_in": 3.0 } nest.CopyModel('iaf_psc_exp', 'iaf_e', neuron_pars) nest.CopyModel('iaf_psc_exp', 'iaf_i', neuron_pars) nest.SetDefaults('iaf_i', { "t_ref": 2.0, "I_e": Ii }) #faster recovery for inhibitory neurons noise_e = nest.Create("noise_generator", Ne) if Ni > 0: noise_i = nest.Create("noise_generator", Ni) else: noise_i = 0 for n in range(0, Ne): nest.SetStatus([noise_e[n]], {"mean": 0.0, "std": noisestd}) for n in range(0, Ni): nest.SetStatus([noise_i[n]], {"mean": 0.0, "std": noisestd}) synapse_pars_e = { "tau_psc": 3.0, "tau_rec": 800.0, "tau_fac": 0.0, "U": 0.5,
exc_neuron = neuron[0:NE] # excitatory neurons inh_neuron = neuron[NE:n_neurons] # inhibitory neurons # receptor parameters E_rev = [0.0, -85.0] tau_decay = [1.0, 1.0] tau_rise = [1.0, 1.0] ngpu.SetStatus(neuron, { "E_rev": E_rev, "tau_decay": tau_decay, "tau_rise": tau_rise, "t_ref": 0.5 }) nest_neuron = nest.Create("aeif_cond_beta_multisynapse", n_test) nest.SetStatus(nest_neuron, { "E_rev": E_rev, "tau_decay": tau_decay, "tau_rise": tau_rise, "t_ref": 0.5 }) neuron_image = ngpu_nest.CreateNeuronImage(nest_neuron, 3) mean_delay = 0.5 std_delay = 0.25 min_delay = 0.1 # Excitatory connections # connect excitatory neurons to port 0 of all neurons # normally distributed delays, weight Wex and CE connections per neuron
def add_spike_trains(self, spike_trains, node_set, sg_params={'precise_times': True}): # Build the virtual nodes src_nodes = [ node_pop for node_pop in self.node_populations if node_pop.name in node_set.population_names() ] virt_gid_map = self._virtual_gids for node_pop in src_nodes: if node_pop.name in self._virtual_ids_map: continue virt_node_map = {} if node_pop.virtual_nodes_only: for node in node_pop.get_nodes(): nest_ids = nest.Create('spike_generator', node.n_nodes, sg_params) virt_gid_map.add_nestids(name=node_pop.name, nest_ids=nest_ids, node_ids=node.node_ids) for node_id, nest_id in zip(node.node_ids, nest_ids): virt_node_map[node_id] = nest_id st = np.array(spike_trains.get_times(node_id=node_id)) if len(st) == 0: continue st.sort() nest.SetStatus([nest_id], {'spike_times': st}) elif node_pop.mixed_nodes: for node in node_pop.get_nodes(): if node.model_type != 'virtual': continue nest_ids = nest.Create('spike_generator', node.n_nodes, sg_params) for node_id, nest_id in zip(node.node_ids, nest_ids): virt_node_map[node_id] = nest_id nest.SetStatus( [nest_id], { 'spike_times': np.array( spike_trains.get_times(node_id=node_id)) }) self._virtual_ids_map[node_pop.name] = virt_node_map # Create virtual synaptic connections for source_reader in src_nodes: for edge_pop in self.find_edges(source_nodes=source_reader.name): for edge in edge_pop.get_edges(): nest_trgs = self.gid_map.get_nestids( edge_pop.target_nodes, edge.target_node_ids) nest_srcs = virt_gid_map.get_nestids( edge_pop.source_nodes, edge.source_node_ids) nest.Connect(nest_srcs, nest_trgs, conn_spec='one_to_one', syn_spec=edge.nest_params)
import nest import numpy as np import pylab as pl # In this program 2 neuron connected by gap junction. they are synchronized based of same level of currnet input nest.ResetKernel() # First we set the resolution of the simulation, create two neurons and # create a `voltmeter` for recording. nest.SetKernelStatus({'resolution': 0.05}) neuron = nest.Create('hh_psc_alpha_gap', 2) vm = nest.Create('voltmeter', params={ 'to_file': False, 'withgid': True, 'withtime': True, 'interval': 0.1 }) # Then we set the constant current input, modify the initial membrane # potential of one of the neurons and connect the neurons to the `voltmeter`. nest.SetStatus(neuron, {'I_e': 100.0}) nest.SetStatus([neuron[0]], {'V_m': -10.0}) nest.Connect(vm, neuron, 'all_to_all') # In order to create the `gap_junction` connection we employ the `all_to_all` # connection rule: Gap junctions are bidirectional connections, therefore we # need to connect `neuron[0]` to `neuron[1]` and `neuron[1]` to `neuron[0]`: nest.Connect(neuron, neuron, { 'rule': 'all_to_all',
# repeat a stimulation protocol using the 'origin' property of devices # actually 'poisson generator' generates a spike train which is recorded by 'spike detector' # within each trial the poisson generator is active from 100ms to 500ms rate = 1000.0 # generator rate in spikes/s start = 100.0 # start of simulation relative to trial start, in ms stop = 500.0 # end of simulation relative to trial start, in ms trial_duration = 1000.0 # trial duration, in ms num_trials = 5 # number of trials to perform nest.ResetKernel() pg = nest.Create('poisson_generator', params={ 'rate': rate, 'start': start, 'stop': stop }) sd = nest.Create('spike_detector') nest.Connect(pg, sd) # 'origin' property of devices for n in range(num_trials): nest.SetStatus(pg, {'origin': nest.GetKernelStatus()['time']}) nest.Simulate(trial_duration) nest.raster_plot.from_device(sd, hist=True, hist_binwidth=50.0, title='Repeated stimulation by Poisson generator')
simtime = 10000. # needs to match the stoptime (here in ms) defined in the music config max_rate = 50. # needs to match the max rate defined for the encoder in the music config tau_m = 1. tau_syn = 20. J = 200. # setup and simulate nest.ResetKernel() nest.SetKernelStatus({'resolution': 1.}) C_m = nest.GetDefaults('iaf_psc_exp', 'C_m') music_in_proxy = nest.Create('music_event_in_proxy', 1, {'port_name': 'in'}) music_out_proxy = nest.Create('music_event_out_proxy', 1, {'port_name': 'out'}) neuron_left = nest.Create( 'iaf_psc_exp', 1, { 'E_L': -60.3 + get_current_offset( J, max_rate / 2., tau_m, tau_syn, C_m ), # add additional 0.3mV to make the left neuron a bit less excitable 'V_th': -60., 'tau_m': tau_m, 'tau_syn_ex': tau_syn, 'tau_syn_in': tau_syn, 'C_m': C_m })
) else: nest.Install('pt_module') initial_weight = np.log( nest.GetDefaults('bcpnn_synapse')['p_ij'] / (nest.GetDefaults('bcpnn_synapse')['p_i'] * nest.GetDefaults('bcpnn_synapse')['p_j'])) initial_bias = np.log(nest.GetDefaults('bcpnn_synapse')['p_j']) syn_param = { "weight": initial_weight, "bias": initial_bias, "K": 1.0, "delay": 1.0, "tau_i": 10.0, "tau_j": 10.0, "tau_e": 100.0, "tau_p": 1000.0 } neuron1_spike_gen = nest.Create('poisson_generator', params={'rate': f_in}) neuron2_spike_gen = nest.Create('poisson_generator', params={'rate': f_in}) neuron1 = nest.Create("iaf_neuron") neuron2 = nest.Create("iaf_neuron") nest.Connect(neuron1_spike_gen, neuron1, params={'weight': 1000.0}) nest.Connect(neuron2_spike_gen, neuron2, params={'weight': 1000.0}) nest.Connect(neuron1, neuron2, params=syn_param, model="bcpnn_synapse") nest.Simulate(t_sim)
def simulate_network(self,interval): #! ================= #! Recording devices #! ================= # Membrane potential and conductances if len(self.To_be_measured)>0: self.subthreshold_recorders = [] # Exc rec_exc = nest.Create('RecordingNode') tgts = [nd for nd in nest.GetLeaves(self.exc)[0]] nest.Connect(rec_exc,tgts) self.subthreshold_recorders.append(rec_exc) # Inh rec_inh = nest.Create('RecordingNode') tgts = [nd for nd in nest.GetLeaves(self.inh)[0]] nest.Connect(rec_inh,tgts) self.subthreshold_recorders.append(rec_inh) # Cloned neurons if self.Compute_PSP: rec_cloned_AMPA = nest.Create('RecordingNode') tgts = [nd for nd in cloned_n_AMPA] nest.Connect(rec_cloned_AMPA,tgts) self.subthreshold_recorders.append(rec_cloned_AMPA) rec_cloned_GABA = nest.Create('RecordingNode') tgts = [nd for nd in cloned_n_GABA] nest.Connect(rec_cloned_GABA,tgts) self.subthreshold_recorders.append(rec_cloned_GABA) # Spikes self.spikes = [] # For raster plots of spikes self.mult_exc = nest.Create('spike_detector',1) self.mult_inh = nest.Create('spike_detector',1) if self.Compute_PSP: mult_cloned_AMPA = nest.Create('spike_detector',1) mult_cloned_GABA = nest.Create('spike_detector',1) # Exc sp_exc = nest.Create('SpikesRecorder') tgts = [nd for nd in nest.GetLeaves(self.exc)[0]] nest.Connect(tgts,sp_exc) self.spikes.append(sp_exc) nest.Connect([tgts[i] for i in self.cells_to_analyze],self.mult_exc) # Inh sp_inh = nest.Create('SpikesRecorder') tgts = [nd for nd in nest.GetLeaves(self.inh)[0]] nest.Connect(tgts,sp_inh) self.spikes.append(sp_inh) nest.Connect([tgts[i] for i in self.cells_to_analyze],self.mult_inh) # Cloned neurons if self.Compute_PSP: sp_cloned_AMPA = nest.Create('SpikesRecorder') tgts = [nd for nd in cloned_n_AMPA] nest.Connect(tgts,sp_cloned_AMPA) self.spikes.append(sp_cloned_AMPA) nest.Connect([tgts[i] for i in range(self.PSP_number_cells)],mult_cloned_AMPA) sp_cloned_GABA = nest.Create('SpikesRecorder') tgts = [nd for nd in cloned_n_GABA] nest.Connect(tgts,sp_cloned_GABA) self.spikes.append(sp_cloned_GABA) nest.Connect([tgts[i] for i in range(self.PSP_number_cells)],mult_cloned_GABA) # Thalamocortical input sp_th = nest.Create('SpikesRecorder') tgts = [nd for nd in nest.GetLeaves(self.parrot_layer_th)[0]] nest.Connect(tgts,sp_th) self.spikes.append(sp_th) # Cortical-cortical_input sp_cc = nest.Create('SpikesRecorder') tgts = [nd for nd in nest.GetLeaves(self.parrot_layer_cc)[0]] nest.Connect(tgts,sp_cc) self.spikes.append(sp_cc) print ("\n--- Simulation ---\n") nest.SetStatus([0],{'print_time': True}) nest.Simulate(interval) #! ================= #! Gather results #! ================= if self.Compute_PSP: n_rec = 4 else: n_rec = 2 data_v=[] for i in range(n_rec): if len(self.To_be_measured)>0: data_v.append(nest.GetStatus(self.subthreshold_recorders[i],keys='events')) else: data_v.append([]) data_s=[] for i in range(n_rec+2): data_s.append(nest.GetStatus(self.spikes[i],keys='events')) senders_v = [] for i in range(n_rec): if len(self.To_be_measured)>0: senders_v.append(data_v[i][0]['senders']) else: senders_v.append([]) senders_s = [] for i in range(n_rec+2): senders_s.append(data_s[i][0]['senders']) pop_ex = nest.GetLeaves(self.exc)[0] pop_in = nest.GetLeaves(self.inh)[0] pop_parrot_th = nest.GetLeaves(self.parrot_layer_th)[0] pop_parrot_cc = nest.GetLeaves(self.parrot_layer_cc)[0] pop_thalamo = nest.GetLeaves(self.thalamo)[0] pop_cc = nest.GetLeaves(self.cort)[0] if self.Compute_PSP: pop_cloned_AMPA = [nd for nd in cloned_n_AMPA] pop_cloned_GABA = [nd for nd in cloned_n_GABA] return [self.simtime,data_v,data_s,senders_v,senders_s,pop_ex,pop_in, pop_thalamo,pop_cc,pop_parrot_th,pop_parrot_cc,pop_cloned_AMPA, pop_cloned_GABA,self.mult_exc,self.mult_inh,mult_cloned_AMPA,mult_cloned_GABA] else: return [self.simtime,data_v,data_s,senders_v,senders_s, pop_ex,pop_in,pop_thalamo,pop_cc,pop_parrot_th,pop_parrot_cc, self.mult_exc,self.mult_inh]
# Author: Abigail Morrison & Susanne Kunkel, 2011 # on the basis of Eilif Muller's comparison9ml_iaf_cond_exp.py # See: README for the build process for the "MyModule" required # by nest.Install below which contains stdp_guetig_9ml import nest nest.Install("mymodule") import numpy import time nest.ResetKernel() dt = 0.01 # [ms] tsim = 0.5 # [s] nest.SetStatus([0],{'resolution':dt}) pg = nest.Create('poisson_generator',1) nest.SetStatus(pg, {'rate': 10.0}) pre = nest.Create('parrot_neuron',1) post = nest.Create('iaf_neuron', 1) nest.SetStatus(post, {'I_e': 500.0}) nest.Connect(pg, pre, model='static_synapse') nest.Connect(pre, post, model='stdp_guetig_9ml') nest.Simulate(1000.0)
@property def len(self): return self._len @property def dlen(self): return self._dlen slg = SpindleLengthGenerator() # muscle spindle population # with primary and secondary afferents nest.Install("muscle_module") ms = nest.Create("muscle_spindle", 2 * pop_size) nest.SetStatus(ms[pop_size:2 * pop_size], {'primary': False}) # fusimotor activation dyn_gen = nest.Create('poisson_generator', 1, {'rate': 100.0}) nest.Connect(dyn_gen, ms, 'all_to_all', { 'weight': 1.0, 'delay': 1.0, 'receptor_type': 1 }) st_gen = nest.Create('poisson_generator', 1, {'rate': 30.0}) nest.Connect(st_gen, ms, 'all_to_all', { 'weight': 1.0, 'delay': 1.0, 'receptor_type': 2 })
def networkclassical(**kwargs): globals().update(kwargs) nest.ResetKernel() startbuild = tim() order = int(orderCE / (epsilon * 4)) #2500 NE = 4 * order # number of excitatory neurons NI = 1 * order # number of inhibitory neurons N_neurons = NE + NI # number of neurons in total # N_rec = 50 # record from 50 neurons CE = int(epsilon * NE) # number of excitatory synapses per neuron CI = int(epsilon * NI) # number of inhibitory synapses per neuron #C_tot = int(CI + CE) # total number of synapses per neuron neuron_params = { "C_m": 1.0, "tau_m": tauMem, "t_ref": 2.0, "E_L": 0.0, "V_reset": Vr, "V_m": 0.0, "V_th": theta } J_ex = J # amplitude of excitatory postsynaptic potential J_in = -g * J_ex # amplitude of inhibitory postsynaptic potential nu_th = theta / (J * CE * tauMem) nu_ex = eta * nu_th p_rate = 1000.0 * nu_ex * CE nest.SetKernelStatus({ "resolution": dt, "print_time": True, "overwrite_files": True, "local_num_threads": nthreads }) nest.SetDefaults("iaf_psc_delta", neuron_params) nest.SetDefaults("poisson_generator", {"rate": p_rate}) # `CE` gen's in 1 nodes_ex = nest.Create("iaf_psc_delta", NE) nodes_in = nest.Create("iaf_psc_delta", NI) noise = nest.Create("poisson_generator") #, CE) in the superdiffusive case espikes = nest.Create("spike_detector") ispikes = nest.Create("spike_detector") nest.SetStatus(espikes, [{ "label": "%s/alpha%.2fespikes" % (datafolder, alpha), "withtime": True, "withgid": True, "to_file": True }]) nest.SetStatus(ispikes, [{ "label": "%s/alpha%.2fispikes" % (datafolder, alpha), "withtime": True, "withgid": True, "to_file": True }]) nest.CopyModel("static_synapse", "excitatory", { "weight": J_ex, "delay": delay }) nest.CopyModel("static_synapse", "inhibitory", { "weight": J_in, "delay": delay }) multimeter = nest.Create("multimeter") nest.SetStatus( multimeter, { "to_memory": False, "withtime": True, "record_from": ["V_m"], "to_file": True, "label": "%s/alpha%.2fV_m" % (datafolder, alpha) }) #"interval": 100.0, nest.Connect(multimeter, nodes_ex + nodes_in) # nodes_ex[:N_rec]+... nest.Connect(noise, nodes_ex, syn_spec="excitatory") nest.Connect(noise, nodes_in, syn_spec="excitatory") nest.Connect(nodes_ex, espikes, syn_spec="excitatory") # nodes_ex[:N_rec] nest.Connect(nodes_in, ispikes, syn_spec="excitatory") # nodes_in[:N_rec] conn_params_ex = {'rule': 'fixed_indegree', 'indegree': CE} nest.Connect(nodes_ex, nodes_ex + nodes_in, conn_params_ex, "excitatory") conn_params_in = {'rule': 'fixed_indegree', 'indegree': CI} nest.Connect(nodes_in, nodes_ex + nodes_in, conn_params_in, "inhibitory") endbuild = tim() nest.Simulate(simtime) endsimulate = tim() events_ex = nest.GetStatus(espikes, "n_events")[0] events_in = nest.GetStatus(ispikes, "n_events")[0] rate_ex = events_ex / simtime * 1000.0 / NE rate_in = events_in / simtime * 1000.0 / NI num_synapses = (nest.GetDefaults("excitatory")["num_connections"] + nest.GetDefaults("inhibitory")["num_connections"]) build_time = endbuild - startbuild sim_time = endsimulate - endbuild print("alpha : {0}".format(alpha)) print("Number of neurons : {0}".format(N_neurons)) print("Number of synapses: {0}".format(num_synapses)) print(" Exitatory : {0}".format(int(CE * N_neurons) + N_neurons)) print(" Inhibitory : {0}".format(int(CI * N_neurons))) print("Excitatory rate : %.2f Hz" % rate_ex) print("Inhibitory rate : %.2f Hz" % rate_in) print("Building time : %.2f s" % build_time) print("Simulation time : %.2f s" % sim_time)
import nest import pylab as pl nest.Install("testModuleInstallmodule") model = "izhikevich_nestml" neuron = nest.Create(model) parameters = nest.GetDefaults(model) # for i in parameters: # print(i, parameters[i]) # exit(0) # nest.SetStatus(neuron, {'I_ext': 630.0}) multimeter = nest.Create("multimeter") nest.SetStatus(multimeter, {"withtime": True, "record_from": ["v"]}) spikedetector = nest.Create("spike_detector", params={ "withgid": True, "withtime": True }) nest.Connect(multimeter, neuron) nest.Connect(neuron, spikedetector) nest.Simulate(200.0) dmm = nest.GetStatus(multimeter)[0] Vms = dmm["events"]["v"] ts = dmm["events"]["times"] # dSD = nest.GetStatus(spikedetector, keys='events')[0] # evs = dSD['senders'] # ts = dSD["times"] pl.plot(ts, Vms)
def network(**kwargs): with nfailures_tightbalance.get_lock(): nfailures_tightbalance.value = 0 globals().update(kwargs) nest.ResetKernel() startbuild = tim() order = int(orderCE / (epsilon * 4)) #2500 NE = 4 * order # number of excitatory neurons NI = 1 * order # number of inhibitory neurons N_neurons = NE + NI # number of neurons in total # N_rec = 50 # record from 50 neurons CE = int(epsilon * NE) # number of excitatory synapses per neuron CI = int(epsilon * NI) # number of inhibitory synapses per neuron #C_tot = int(CI + CE) # total number of synapses per neuron neuron_params = { "C_m": 1.0, "tau_m": tauMem, "t_ref": 2.0, "E_L": 0.0, "V_reset": Vr, "V_m": 0.0, "V_th": theta } J_ex = J # amplitude of excitatory postsynaptic potential J_in = -g * J_ex # amplitude of inhibitory postsynaptic potential nu_th = theta / (J * CE * tauMem) nu_ex = eta * nu_th p_rate = 1000.0 * nu_ex * CE nest.SetKernelStatus({ "resolution": dt, "print_time": True, "overwrite_files": True, "local_num_threads": nthreads }) nest.SetDefaults("iaf_psc_delta", neuron_params) nest.SetDefaults("poisson_generator", {"rate": p_rate / CE}) nodes_ex = nest.Create("iaf_psc_delta", NE) nodes_in = nest.Create("iaf_psc_delta", NI) noise = nest.Create("poisson_generator", CE) espikes = nest.Create("spike_detector") ispikes = nest.Create("spike_detector") nest.SetStatus(espikes, [{ "label": "%s/alpha%.2fespikes" % (datafolder, alpha), "withtime": True, "withgid": True, "to_file": True }]) nest.SetStatus(ispikes, [{ "label": "%s/alpha%.2fispikes" % (datafolder, alpha), "withtime": True, "withgid": True, "to_file": True }]) nest.CopyModel("static_synapse", "excitatory", { "weight": J_ex, "delay": delay }) nest.CopyModel("static_synapse", "inhibitory", { "weight": J_in, "delay": delay }) A_alpha = gamma(1 + alpha) * numpy.sin(numpy.pi * alpha / 2) / numpy.pi D = 0.5 # pareto pdf = alpha*x1**alpha/(x-x0)**(alpha+1), defined for x > x0+x1 x1fac = (2 * A_alpha * D / alpha)**(1 / alpha) x0fac = 1 - x1fac * alpha / (alpha - 1) J_noise_ex = J_ex * (x1fac * (pareto(alpha, (NE, CE)) + 1) + x0fac) J_noise_in = J_ex * (x1fac * (pareto(alpha, (NI, CE)) + 1) + x0fac) # correlated amplitude populations: samples_ex = x1fac * (pareto(alpha, (NE + NI, CE)) + 1) + x0fac # print x0fac,x1fac with Pool_(nthreads) as p: samples_in = numpy.array( p.map(partial(f, alpha, x0fac, x1fac, CE, CI), numpy.sum(samples_ex, 1), 1)) J_ex_tot = J_ex * samples_ex J_in_tot = J_in * samples_in multimeter = nest.Create("multimeter") nest.SetStatus( multimeter, { "to_memory": False, "withtime": True, "record_from": ["V_m"], "to_file": True, "label": "%s/alpha%.2fV_m" % (datafolder, alpha) }) #"interval": 100.0, nest.Connect(multimeter, nodes_ex + nodes_in) # nodes_ex[:N_rec]+... nest.Connect(noise, nodes_ex, syn_spec={ "model": "excitatory", "weight": J_noise_ex }) nest.Connect(noise, nodes_in, syn_spec={ "model": "excitatory", "weight": J_noise_in }) nest.Connect(nodes_ex, espikes, syn_spec="excitatory") # nodes_ex[:N_rec] nest.Connect(nodes_in, ispikes, syn_spec="excitatory") # nodes_in[:N_rec] conn_params_ex = {'rule': 'fixed_indegree', 'indegree': CE} nest.Connect(nodes_ex, nodes_ex + nodes_in, conn_params_ex, syn_spec={ "model": "excitatory", "weight": J_ex_tot }) conn_params_in = {'rule': 'fixed_indegree', 'indegree': CI} nest.Connect(nodes_in, nodes_ex + nodes_in, conn_params_in, syn_spec={ "model": "inhibitory", "weight": J_in_tot }) endbuild = tim() nest.Simulate(simtime) endsimulate = tim() events_ex = nest.GetStatus(espikes, "n_events")[0] events_in = nest.GetStatus(ispikes, "n_events")[0] rate_ex = events_ex / simtime * 1000.0 / NE rate_in = events_in / simtime * 1000.0 / NI num_synapses = (nest.GetDefaults("excitatory")["num_connections"] + nest.GetDefaults("inhibitory")["num_connections"]) build_time = endbuild - startbuild sim_time = endsimulate - endbuild print("Number of tight balance failures: {0}".format( nfailures_tightbalance.value)) print("alpha : {0}".format(alpha)) print("Number of neurons : {0}".format(N_neurons)) print("Number of synapses: {0}".format(num_synapses)) print(" Exitatory : {0}".format(int(CE * N_neurons) + N_neurons)) print(" Inhibitory : {0}".format(int(CI * N_neurons))) print("Excitatory rate : %.2f Hz" % rate_ex) print("Inhibitory rate : %.2f Hz" % rate_in) print("Building time : %.2f s" % build_time) print("Simulation time : %.2f s" % sim_time)
def generateSpikes(neuron, times): """Trigger spike to given neuron at specified times.""" delay = 1.0 gen = nest.Create("spike_generator", 1, {"spike_times": [t - delay for t in times]}) nest.Connect(gen, neuron, syn_spec={"delay": delay})
"tau_m": Tau, "t_ref": TauR, "tau_syn_ex": Tau_psc, "tau_syn_in": Tau_psc, "C_m": C, "V_reset": U0, "E_L": U0, "V_m": U0, "V_th": Theta } # set defaults of desired neuron type with chosen parameters: nest.SetDefaults("iaf_psc_exp", neuron_param) # create two neurons of desired type: neurons = nest.Create("iaf_psc_exp", 2) # set properties of dc: nest.SetDefaults("dc_generator", { "amplitude": I0, "start": TIstart, "stop": TIend }) # create dc_generator: dc_gen = nest.Create("dc_generator") # set properties of voltmeter: volts = nest.Create("voltmeter") # create voltmeter:
def evaluate(rho, dt, nearest): """Evaluate connection change of weight and returns it.""" nest.ResetKernel() nest.SetKernelStatus({ "local_num_threads": 1, "resolution": 0.1, "print_time": False }) step = 1000.0 / rho simulation_duration = np.ceil(n * step) times_pre = np.arange(start_spikes, simulation_duration, step).round(1) times_post = [t + dt for t in times_pre] # Entities local_spec = syn_spec.copy() local_spec.update({"nearest_spike": nearest}) neuron_pre = nest.Create("parrot_neuron") neuron_post = nest.Create("parrot_neuron") triplet_synapse = nest.Create("stdp_longterm_node", params=local_spec) multi = nest.Create("multimeter") nest.SetStatus(multi, params={ "withtime": True, "interval": nest.GetKernelStatus()["resolution"], "record_from": [ "weight", "weight_ref", "B", "C", "Zplus", "Zslow", "Zminus", "Zht" ], }) nest.Connect(multi, triplet_synapse) # Connections generateSpikes(neuron_pre, times_pre) generateSpikes(neuron_post, times_post) nest.Connect(neuron_pre, triplet_synapse) nest.Connect(triplet_synapse, neuron_post, syn_spec={"receptor_type": 1}) # do not repeat spike nest.Connect(neuron_post, triplet_synapse, syn_spec={"receptor_type": 1}) # differentiate post-synaptic feedback # Simulation current_weight = nest.GetStatus(triplet_synapse, keys="weight")[0] nest.Simulate(start_spikes + simulation_duration) stats = nest.GetStatus(multi, keys="events")[0] # plt.figure() # # plt.subplot(211) # plt.title(str(rho)) # plt.plot(stats["times"], stats["weight"]) # plt.plot(stats["times"], stats["weight_ref"]) # plt.plot(stats["times"], stats["B"]) # plt.plot(stats["times"], stats["Zplus"]) # plt.plot(stats["times"], stats["Zslow"]) # plt.plot(stats["times"], stats["Zminus"]) # plt.legend(["weight", "weight_ref", "B", "Zplus", "Zslow", "Zminus"], loc = "upper left", frameon = False) # plt.ylim([-10, 10]) # plt.subplot(212) # plt.plot(stats["times"], stats["C"]) # plt.plot(stats["times"], stats["Zht"]) # plt.legend(["C", "Zht"], loc = "upper left", frameon = False) # Results end_weight = nest.GetStatus(triplet_synapse, keys="weight")[0] return end_weight - current_weight
# Configuration of the model `iaf_psc_alpha` and `poisson_generator` using # SetDefaults(). This function expects the model to be the inserted as a # string and the parameter to be specified in a dictionary. All instances of # theses models created after this point will have the properties specified # in the dictionary by default. nest.SetDefaults("iaf_psc_alpha", neuron_params) nest.SetDefaults("poisson_generator", {"rate": p_rate}) ############################################################################### # Creation of the nodes using `Create`. We store the returned handles in # variables for later reference. Here the excitatory and inhibitory, as well # as the poisson generator and two spike detectors. The spike detectors will # later be used to record excitatory and inhibitory spikes. nodes_ex = nest.Create("iaf_psc_alpha", NE) nodes_in = nest.Create("iaf_psc_alpha", NI) noise = nest.Create("poisson_generator") espikes = nest.Create("spike_detector") ispikes = nest.Create("spike_detector") ############################################################################### # Configuration of the spike detectors recording excitatory and inhibitory # spikes using `SetStatus`, which expects a list of node handles and a list # of parameter dictionaries. Setting the variable "to_file" to True ensures # that the spikes will be recorded in a .gdf file starting with the string # assigned to label. Setting "withtime" and "withgid" to True ensures that # each spike is saved to file by stating the gid of the spiking neuron and # the spike time in one line. nest.SetStatus(espikes, [{
def test_multisynapse(self): input_path = os.path.join( os.path.realpath( os.path.join(os.path.dirname(__file__), "resources", "iaf_psc_exp_multisynapse.nestml"))) nest_path = nest.ll_api.sli_func("statusdict/prefix ::") target_path = 'target' logging_level = 'INFO' module_name = 'nestmlmodule' store_log = False suffix = '_nestml' dev = True to_nest(input_path, target_path, logging_level, module_name, store_log, suffix, dev) install_nest(target_path, nest_path) nest.set_verbosity("M_ALL") nest.ResetKernel() nest.Install(module_name) # network construction neuron = nest.Create("iaf_psc_exp_multisynapse_neuron_nestml") sg = nest.Create("spike_generator", params={"spike_times": [20., 80.]}) nest.Connect(sg, neuron, syn_spec={ "receptor_type": 1, "weight": 1000., "delay": 0.1 }) sg2 = nest.Create("spike_generator", params={"spike_times": [40., 60.]}) nest.Connect(sg2, neuron, syn_spec={ "receptor_type": 2, "weight": 1000., "delay": 0.1 }) sg3 = nest.Create("spike_generator", params={"spike_times": [30., 70.]}) nest.Connect(sg3, neuron, syn_spec={ "receptor_type": 3, "weight": 500., "delay": 0.1 }) mm = nest.Create('multimeter', params={ 'record_from': [ 'I_kernel1__X__spikes1', 'I_kernel2__X__spikes2', 'I_kernel3__X__spikes3' ], 'interval': 0.1 }) nest.Connect(mm, neuron) vm_1 = nest.Create('voltmeter') nest.Connect(vm_1, neuron) # simulate nest.Simulate(125.) # analysis V_m_timevec = nest.GetStatus(vm_1)[0]["events"]["times"] V_m = nest.GetStatus(vm_1)[0]["events"]["V_m"] mm = nest.GetStatus(mm)[0]["events"] MAX_ABS_ERROR = 1E-6 print("Final V_m = " + str(V_m[-1])) assert abs(V_m[-1] - -72.89041451202348) < MAX_ABS_ERROR if TEST_PLOTS: fig, ax = plt.subplots(nrows=4) ax[0].plot(V_m_timevec, V_m, label="V_m") ax[0].set_ylabel("voltage") ax[1].plot(mm["times"], mm["I_kernel1__X__spikes1"], label="I_kernel1") ax[1].set_ylabel("current") ax[2].plot(mm["times"], mm["I_kernel2__X__spikes2"], label="I_kernel2") ax[2].set_ylabel("current") ax[3].plot(mm["times"], mm["I_kernel3__X__spikes3"], label="I_kernel3") ax[3].set_ylabel("current") for _ax in ax: _ax.legend(loc="upper right") _ax.set_xlim(0., 125.) _ax.grid(True) for _ax in ax[:-1]: _ax.set_xticklabels([]) ax[-1].set_xlabel("time") plt.show()
def test(referenceModel, testant, gsl_error_tol, tolerance=0.000001): nest.ResetKernel() neuron1 = nest.Create(referenceModel) neuron2 = nest.Create(testant) if not (gsl_error_tol is None): nest.SetStatus(neuron2, {"gsl_error_tol": gsl_error_tol}) spikegenerator = nest.Create('spike_generator', params={ 'spike_times': [100.0, 200.0], 'spike_weights': [1.0, -1.0] }) nest.Connect(spikegenerator, neuron1) nest.Connect(spikegenerator, neuron2) multimeter1 = nest.Create('multimeter') multimeter2 = nest.Create('multimeter') V_m_specifier = 'V_m' # 'delta_V_m' nest.SetStatus(multimeter1, { "withtime": True, "record_from": [V_m_specifier] }) nest.SetStatus(multimeter2, { "withtime": True, "record_from": [V_m_specifier] }) nest.Connect(multimeter1, neuron1) nest.Connect(multimeter2, neuron2) nest.Simulate(400.0) dmm1 = nest.GetStatus(multimeter1)[0] Vms1 = dmm1["events"][V_m_specifier] ts1 = dmm1["events"]["times"] events1 = dmm1["events"] pylab.figure(1) dmm2 = nest.GetStatus(multimeter2)[0] Vms2 = dmm2["events"][V_m_specifier] ts2 = dmm2["events"]["times"] # pylab.plot(ts1, Vms1, label = "Reference " + referenceModel) # pylab.plot(ts2, Vms2, label = "Testant " + testant) # pylab.legend(loc='upper right') for index in range(0, len(Vms1)): if abs(Vms1[index] - Vms2[index]) > tolerance: print('!!!!!!!!!!!!!!!!!!!!') print( str(Vms1[index]) + " divers from " + str(Vms2[index]) + " at iteration: " + str(index) + " of overall iterations: " + str(len(Vms1))) print('!!!!!!!!!!!!!!!!!!!!') raise Exception(testant + ": TEST FAILED") elif abs(Vms1[index] - Vms2[index]) > 0: None # print("Greater than 0 difference" + str(abs(Vms1[index]-Vms2[index])) + " at iteration: " + str(index) + " of overall iterations: " + str(len(Vms1))) print(testant + " PASSED")