def initialize(self, sim): self._spike_detector = nest.Create("spike_detector", 1, {'label': self._spike_labels, 'withtime': True, 'withgid': True, 'to_file': True}) nest.Connect(sim.net.gid_map.gids, self._spike_detector)
sd_syn_dict = {"weight": 1.0, "delay": 1.0} i_neuron_list = [] i_receptor_list = [] var_name_list = [] for i in range(n_test): ngpu.Connect([neuron[randrange(n_neurons)]], [sd[i]], sd_conn_dict, sd_syn_dict) i_neuron_list.append(sd[i]) i_receptor_list.append(0) var_name_list.append("spike_height") # create multimeter record of spikes record = ngpu.CreateRecord("", var_name_list, i_neuron_list, i_receptor_list) nest_sd = nest.Create('spike_detector', n_test) nest.Connect(nest_neuron, nest_sd, sd_conn_dict, sd_syn_dict) nest.Simulate(1000) data_list = ngpu.GetRecordData(record) t = [row[0] for row in data_list] spike_height = [row[1] for row in data_list] import matplotlib.pyplot as plt plt.figure(1) plt.plot(t, spike_height) row_sum = data_list[0] for row in data_list[1:len(data_list)]: for i in range(len(row_sum)):
def setupProperty(property): bad_syn_spec = self.syn_spec.copy() bad_syn_spec.update(property) nest.Connect(self.pre_neuron, self.post_neuron, syn_spec=bad_syn_spec)
"to_file": True, "label": "my_multimeter"}) s_ex = nest.Create("spike_generator", params={"spike_times": numpy.array([10.0, 20.0, 50.0])}) s_in = nest.Create("spike_generator", params={"spike_times": numpy.array([15.0, 25.0, 55.0])}) ############################################################################### # Next, We connect the spike generators to the neuron with ``Connect``. Synapse # specifications can be provided in a dictionary. In this example of a # conductance-based neuron, the synaptic weight ``weight`` is given in nS. # Note that the values are positive for excitatory stimulation and negative # for inhibitor connections. nest.Connect(s_ex, n, syn_spec={"weight": 40.0}) nest.Connect(s_in, n, syn_spec={"weight": -20.0}) nest.Connect(m, n) ############################################################################### # A network simulation with a duration of 100 ms is started with ``Simulate``. nest.Simulate(100.) ############################################################################### # After the simulation, the recordings are obtained from the multimeter via the # key ``events`` of the status dictionary accessed by ``GetStatus``. ``times`` # indicates the recording times stored for each data point. They are recorded # if the parameter ``withtime`` of the multimeter is set to True which is the # default case.
g = nest.Create('spike_generator', params={ 'spike_times': sorted( np.ravel([ np.linspace(10, 30, num=15), np.linspace(50, 70, num=15), np.linspace(15, 25, num=15), np.linspace(120, 140, num=15) ])) }) nest.Connect(g, n, params={ 'weight': 10.0, 'delay': 1.0, 'receptor_type': s['AMPA'] }, model='hill_synapse') nest.Connect(g, n, params={ 'weight': 10.0, 'delay': 1.5, 'receptor_type': s['GABA_A'] }) nest.Connect(m, n) nest.Simulate(1000) events = nest.GetStatus(m)[0]['events']
'multimeter', params={'record_from': ['rate'], 'interval': dt}) ############################################################################### # Connections between ``siegert neurons`` are realized with the synapse model # ``diffusion_connection``. These two parameters reflect the prefactors in # front of the rate variable in eq. 27-29 in [1]. ############################################################################### # Connections originating from the driving neuron syn_dict = {'drift_factor': drift_factor_ext, 'diffusion_factor': diffusion_factor_ext, 'synapse_model': 'diffusion_connection'} nest.Connect( siegert_drive, siegert_ex + siegert_in, 'all_to_all', syn_dict) nest.Connect(multimeter, siegert_ex + siegert_in) ############################################################################### # Connections originating from the excitatory neuron syn_dict = {'drift_factor': drift_factor_ex, 'diffusion_factor': diffusion_factor_ex, 'synapse_model': 'diffusion_connection'} nest.Connect(siegert_ex, siegert_ex + siegert_in, 'all_to_all', syn_dict) ############################################################################### # Connections originating from the inhibitory neuron syn_dict = {'drift_factor': drift_factor_in, 'diffusion_factor': diffusion_factor_in, 'synapse_model': 'diffusion_connection'}
"delta_tau": h }) nest.SetDefaults('ginzburg_neuron', { 'theta': 0.0, 'tau_m': tau_m, 'c_1': 0.0, 'c_2': 2. * m_x, 'c_3': 1.0 }) n1 = nest.Create("ginzburg_neuron") nest.SetDefaults("mcculloch_pitts_neuron", {'theta': 0.5, 'tau_m': tau_m}) n2 = nest.Create("mcculloch_pitts_neuron") nest.Connect(n1, n2, syn_spec={"weight": 1.0}) nest.Connect(n1, csd, syn_spec={"receptor_type": 0}) nest.Connect(n2, csd, syn_spec={"receptor_type": 1}) nest.Simulate(T) stat = nest.GetStatus(csd)[0] c = stat["count_covariance"] m = np.zeros(2, dtype=float) for i in xrange(2): m[i] = c[i][i][int(tau_max / h)] * (h / T) print 'mean activities =', m
"record_from": ['V_m'], "withgid": True, "to_file": True, "label": "multimeter_Golgi"}) m_Granular = nest.Create("multimeter", params = {"interval": 1.0, "record_from": ['V_m'], "withgid": True, "to_file": True, "label": "multimeter_Granular"}) # Connections nest.CopyModel('static_synapse_hom_w', 'excitatory', {'weight': J_E, 'delay': delay}) nest.CopyModel('static_synapse_hom_w', 'inhibitory', {'weight': J_I*3, 'delay': delay}) nest.Connect(mossy,neu_Glomeruli) nest.Connect(neu_Glomeruli,neu_Granular,{'rule':'fixed_indegree','indegree': C_Glo_Gra},'excitatory') nest.Connect(neu_Golgi,neu_Granular,{'rule':'fixed_indegree','indegree': C_Gol_Gra},'inhibitory') nest.Connect(neu_Golgi,neu_Golgi,{'rule':'fixed_indegree','indegree': C_Gol_Gol},'inhibitory') nest.Connect(neu_Glomeruli,neu_Golgi,{'rule':'fixed_indegree','indegree': C_Glo_Gol},'excitatory') nest.Connect(neu_Glomeruli,spk_Glomeruli) nest.Connect(neu_Golgi,spk_Golgi) nest.Connect(neu_Granular,spk_Granular) nest.Connect(m_Golgi,neu_Golgi) nest.Connect(m_Granular,neu_Granular) nest.Simulate(time_sim) try: nest.raster_plot.from_device(spk_Glomeruli, hist=True) except nest.NESTError as err: #print err try: nest.raster_plot.from_device(spk_Golgi, hist=True) except nest.NESTError as err:
def test_wb_cond_multisyn(self): if not os.path.exists("target"): os.makedirs("target") input_path = os.path.join( os.path.realpath( os.path.join(os.path.dirname(__file__), "../../models/neurons", "wb_cond_multisyn.nestml"))) target_path = "target" module_name = 'nestmlmodule' nest_path = nest.ll_api.sli_func("statusdict/prefix ::") suffix = '_nestml' to_nest(input_path=input_path, target_path=target_path, logging_level="INFO", suffix=suffix, module_name=module_name) install_nest(target_path, nest_path) nest.Install("nestmlmodule") model = "wb_cond_multisyn_nestml" dt = 0.01 t_simulation = 1000.0 nest.SetKernelStatus({"resolution": dt}) neuron = nest.Create(model) parameters = nest.GetDefaults(model) neuron.set({'I_e': 75.0}) multimeter = nest.Create("multimeter") multimeter.set({"record_from": ["V_m"], "interval": dt}) spike_recorder = nest.Create("spike_recorder") nest.Connect(multimeter, neuron) nest.Connect(neuron, spike_recorder) nest.Simulate(t_simulation) dmm = nest.GetStatus(multimeter)[0] Voltages = dmm["events"]["V_m"] tv = dmm["events"]["times"] dSD = nest.GetStatus(spike_recorder, keys='events')[0] spikes = dSD['senders'] ts = dSD["times"] firing_rate = len(spikes) / t_simulation * 1000 print("firing rate is ", firing_rate) expected_value = np.abs(firing_rate - 50) tolerance_value = 5 # Hz if TEST_PLOTS: fig, ax = plt.subplots(2, figsize=(8, 6), sharex=True) ax[0].plot(tv, Voltages, lw=2, color="k") ax[1].plot(ts, spikes, 'ko') ax[1].set_xlabel("Time [ms]") ax[1].set_xlim(0, t_simulation) ax[1].set_ylabel("Spikes") ax[0].set_ylabel("v [ms]") ax[0].set_ylim(-100, 50) for i in ts: ax[0].axvline(x=i, lw=1., ls="--", color="gray") plt.savefig("resources/wb_cond_multisyn.png") # plt.show() self.assertLessEqual(expected_value, tolerance_value)
# Create and configure the stimulus which is a step current. dc1 = nest.Create("dc_generator") # current DC generator dc2 = nest.Create("dc_generator", 2) nest.SetStatus(dc1, [{"amplitude": -800.0, "start": 0.0, "stop": 400.0}]) nest.SetStatus(dc2, [{ "amplitude": 500.0, "start": 0.0, "stop": 200.0 }, { "amplitude": 800.0, "start": 500.0, "stop": 1000.0 }]) # We connect the DC generator. nest.Connect(dc1, neuron1, 'all_to_all') nest.Connect(dc2, neuron2, 'all_to_all') # 'all_to_all' is not the necessary phrase here # And add a voltmeter to record the membrane potentials. voltmeter = nest.Create("voltmeter") # We set the voltmeter to record in small intervals of 0.1 ms and connect # the voltmeter to the neuron. nest.SetStatus(voltmeter, { "withgid": True, "withtime": True, 'interval': 0.1 }) # set lower recording resolution nest.Connect(voltmeter, neuron1) nest.Connect(voltmeter, neuron2)
'record_from': ['I'], 'interval': 0.1 }) # Create generators and connect ac = nest.Create('ac_generator', 1, params={ 'amplitude': 500.0, 'frequency': 50.0, 'phase': 45.0, 'origin': 5.0, 'start': 2.5, 'stop': 40.0 }) nest.Connect(ac, neuron_ac) nest.Connect(m_Vm_ac, neuron_ac) nest.Connect(m_Inj_ac, ac) dc = nest.Create('dc_generator', 1, params={ 'amplitude': 500.0, 'origin': 5.0, 'start': 2.5, 'stop': 40.0 }) nest.Connect(dc, neuron_dc) nest.Connect(m_Vm_dc, neuron_dc) nest.Connect(m_Inj_dc, dc)
# create a ``voltmeter`` for recording. nest.SetKernelStatus({'resolution': 0.05}) neuron = nest.Create('hh_psc_alpha_gap', 2) vm = nest.Create('voltmeter', params={'interval': 0.1}) ############################################################################### # Then we set the constant current input, modify the inital membrane # potential of one of the neurons and connect the neurons to the ``voltmeter``. neuron.I_e = 100. neuron[0].V_m = -10. 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', 'allow_autapses': False}, {'synapse_model': 'gap_junction', 'weight': 0.5}) ############################################################################### # Finally we start the simulation and plot the membrane potentials of both # neurons.
def _spikes(neurons, times): """Trigger spike to given neurons at specified times.""" delay = nest.GetKernelStatus('resolution') gen = nest.Create("spike_generator", 1, {"spike_times": [t - delay for t in times]}) nest.Connect(gen, neurons, syn_spec={"delay": delay})
# the Free Software Foundation, either version 2 of the License, or # (at your option) any later version. # # NEST is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with NEST. If not, see <http://www.gnu.org/licenses/>. import nest # Reset kernel nest.ResetKernel() # Create nodes pg = nest.Create("poisson_generator", params={"rate": 6500.}) neurons = nest.Create("iaf_psc_alpha", 100) sr = nest.Create("spike_recorder") # Connect nodes nest.Connect(pg, neurons, syn_spec={"weight": 10.}) nest.Connect(neurons[::10], sr) # Simulate nest.Simulate(1000.) # Get events n_events = sr.get("n_events")
'N': N[i], 't_ref': t_ref[i], 'tau_syn_ex': max([tau_ex, dt]), 'tau_syn_in': max([tau_in, dt]), 'E_L': 0. } for i in range(M)] nest_pops.set(params) # connect the populations g_syn = np.ones_like(J_syn) # synaptic conductance g_syn[:, 0] = C_m / tau_ex g_syn[:, 1] = C_m / tau_in for i in range(M): for j in range(M): nest.Connect(nest_pops[j], nest_pops[i], syn_spec={'weight': J_syn[i, j] * g_syn[i, j] * pconn[i, j], 'delay': delay[i, j]}) ############################################################################### # To record the instantaneous population rate `Abar(t)` we use a multimeter, # and to get the population activity `A_N(t)` we use spike recorder: # monitor the output using a multimeter, this only records with dt_rec! nest_mm = nest.Create('multimeter') nest_mm.set(record_from=['n_events', 'mean'], interval=dt_rec) nest.Connect(nest_mm, nest_pops) # monitor the output using a spike recorder nest_sr = [] for i in range(M): nest_sr.append(nest.Create('spike_recorder'))
neuron = nest.Create("iaf_psc_alpha", params={"V_th": float(10**10)}) meter = nest.Create("multimeter", params={ "withtime": True, "record_from": ["V_m"] }) detector = nest.Create("spike_detector", params={ "withgid": True, "withtime": True }) nest.Connect(generator, neuron, {"rule": "all_to_all"}, { "model": "static_synapse", "weight": weight }) nest.Connect(meter, neuron) nest.Connect(neuron, detector) nest.Simulate(1000.0) result_meter = nest.GetStatus(meter)[0] result_detector = nest.GetStatus(detector)[0] plt.figure() plt.plot(result_meter["events"]["times"], result_meter["events"]["V_m"]) plt.figure() plt.plot(result_detector["events"]["times"], result_detector["events"]["senders"], '.')
# a parameter dictionary or a list of parameter dictionaries. neurons.set(neuron_param) dc_gen.set(amplitude=I0, start=TIstart, stop=TIend) volts.set(label="voltmeter", interval=1.) ############################################################################### # Sixth, the ``dc_generator`` is connected to the first neuron # (`neurons[0]`) and the `voltmeter` is connected to the second neuron # (`neurons[1]`). The command `Connect` has different variants. Plain # ``Connect`` just takes the handles of pre- and postsynaptic nodes and # uses the default values for weight and delay. Note that the connection # direction for the ``voltmeter`` reflects the signal flow in the simulation # kernel, because it observes the neuron instead of receiving events from it. nest.Connect(dc_gen, neurons[0]) nest.Connect(volts, neurons[1]) ############################################################################### # Seventh, the first neuron (`neurons[0]`) is connected to the second # neuron (`neurons[1]`). The command ``CopyModel`` copies the # ``tsodyks_synapse`` model to the new name ``syn`` with parameters # ``syn_param``. The manually defined model ``syn`` is used in the # connection routine via the ``syn_spec`` parameter. nest.CopyModel("tsodyks_synapse", "syn", syn_param) nest.Connect(neurons[0], neurons[1], syn_spec="syn") ############################################################################### # Finally, we simulate the configuration using the command ``Simulate``, # where the simulation time `Tend` is passed as the argument. We plot the
def simulation(Params): #! ================= #! Import network #! ================= import importlib import time #network_names = ['network_full_keiko', 'network_full_leonardo'] network_names = ['network_full_keiko', 'network_full_keiko'] colors = [[0, 0, 1, .5], [0, 1, 0, .5]] fig, axs = plt.subplots(2, 2) for (inet, netname) in enumerate(network_names): # NEST Kernel and Network settings nest.ResetKernel() nest.ResetNetwork() nest.SetKernelStatus({ "local_num_threads": Params['threads'], 'resolution': Params['resolution'] }) nest.SetStatus([0], {'print_time': True}) # initialize random seed msd = int(round(time.time() * 1000)) nest.SetKernelStatus({'grng_seed': msd}) nest.SetKernelStatus({ 'rng_seeds': range(msd + Params['threads'] + 1, msd + 2 * Params['threads'] + 1) }) network = importlib.import_module(netname) reload(network) models, layers, conns = network.get_Network(Params) # import network_full_keiko # reload(network_full_keiko) # models, layers, conns = network_full_keiko.get_Network(Params) # Create models for m in models: nest.CopyModel(m[0], m[1], m[2]) # Create layers, store layer info in Python variable for l in layers: exec '%s = tp.CreateLayer(l[1])' % l[0] # Create connections, need to insert variable names for c in conns: eval('tp.ConnectLayers(%s,%s,c[2])' % (c[0], c[1])) if Params.has_key('show_V4_num_conn_figure' ) and Params['show_V4_num_conn_figure']: horizontal_nodes = nest.GetLeaves(Vp_horizontal, properties={'model': 'L4_exc'}, local_only=True)[0] vertical_nodes = nest.GetLeaves(Vp_vertical, properties={'model': 'L4_exc'}, local_only=True)[0] print('Ploting #1') n_conns_hor = [] for (idx, horizontal_node) in enumerate(horizontal_nodes): tgt_map = [] this_conns = nest.GetConnections([horizontal_node], horizontal_nodes, synapse_model='AMPA_syn') tgt_map.extend([conn[1] for conn in this_conns]) n_conns_hor.append(len(tgt_map)) plt.axes(axs[0, 0]) plt.hist(n_conns_hor, range(0, max(n_conns_hor + [30])), fc=colors[inet]) plt.title('# of connections Vp(h) L4pyr -> Vp(h) L4Pyr') print('Ploting #2') n_conns_hor = [] for (idx, horizontal_node) in enumerate(horizontal_nodes): tgt_map = [] this_conns = nest.GetConnections([horizontal_node], vertical_nodes, synapse_model='AMPA_syn') tgt_map.extend([conn[1] for conn in this_conns]) n_conns_hor.append(len(tgt_map)) # nest.DisconnectOneToOne(tp_node, tgt_map[0], {"synapse_model": "AMPA_syn"}) #nest.Disconnect([tp_node], tgt_map, 'one_to_one', {"synapse_model": "AMPA_syn"}) plt.axes(axs[0, 1]) plt.hist(n_conns_hor, range(0, max(n_conns_hor + [30])), fc=colors[inet]) plt.title('# of connections Vp(h) L4pyr -> Vp(v) L4Pyr') print('Ploting #3') n_conns_ver = [] for (idx, vertical_node) in enumerate(vertical_nodes): tgt_map = [] this_conns = nest.GetConnections([vertical_node], vertical_nodes, synapse_model='AMPA_syn') tgt_map.extend([conn[1] for conn in this_conns]) n_conns_ver.append(len(tgt_map)) plt.axes(axs[1, 1]) plt.hist(n_conns_ver, range(0, max(n_conns_ver + [30])), fc=colors[inet]) plt.title('# of connections Vp(v) L4pyr -> Vp(v) L4Pyr') print('Ploting #4') n_conns_ver = [] for (idx, vertical_node) in enumerate(vertical_nodes): tgt_map = [] this_conns = nest.GetConnections([vertical_node], horizontal_nodes, synapse_model='AMPA_syn') tgt_map.extend([conn[1] for conn in this_conns]) n_conns_ver.append(len(tgt_map)) plt.axes(axs[1, 0]) plt.hist(n_conns_ver, range(0, max(n_conns_ver + [30])), fc=colors[inet]) plt.title('# of connections Vp(v) L4pyr -> Vp(h) L4Pyr') plt.show() # Check connections # Connections from Retina to TpRelay # tp.PlotTargets(tp.FindCenterElement(Retina_layer), Tp_layer) if Params.has_key('show_V4_connectivity_figure' ) and Params['show_V4_connectivity_figure']: Vp_hor_gids = tp.GetElement(Vp_horizontal, [0, 0]) n_Vp_hor = len(Vp_hor_gids) f = [] for idx in range(n_Vp_hor): f.append(plt.figure()) positions = range(0, 41, 10) positions[-1] -= 1 for xi in range(len(positions)): for yi in range(len(positions)): print("Position [%d,%d] : %d" % (xi, yi, yi * (len(positions)) + xi + 1)) x = positions[xi] y = positions[yi] Vp_hor_gids = tp.GetElement(Vp_horizontal, [x, y]) Vp_hor_status = nest.GetStatus(Vp_hor_gids) for (idx, n) in enumerate(Vp_hor_status): if n['Tau_theta'] == 2.0: print idx try: f[idx].add_subplot(len(positions), len(positions), yi * (len(positions)) + xi + 1) tp.PlotTargets([Vp_hor_gids[idx]], Vp_horizontal, 'L4_exc', 'AMPA_syn', f[idx]) except: print('%i bad' % Vp_hor_gids[idx]) plt.show() # Connections from TpRelay to L4pyr in Vp (horizontally tuned) #topo.PlotTargets(topo.FindCenterElement(Tp), Vp_h, 'L4pyr', 'AMPA') #pylab.title('Connections TpRelay -> Vp(h) L4pyr') #pylab.show() # Connections from TpRelay to L4pyr in Vp (vertically tuned) #topo.PlotTargets(topo.FindCenterElement(Tp), Vp_v, 'L4pyr', 'AMPA') #pylab.title('Connections TpRelay -> Vp(v) L4pyr') #pylab.show() ''' # pablo # Create vertical grating for n in nest.GetLeaves(Retina_layer)[0]: retina_0 = (nest.GetLeaves(Retina_layer)[0])[0] col = (n-retina_0)/Params['Np'] cells_per_degree = Params['Np']/Params['visSize'] cells_per_cycle = cells_per_degree/Params['spatial_frequency'] nest.SetStatus([n], { "phase": col * 360/(cells_per_cycle-1) }) ''' ### keiko if Params['lambda_dg'] >= 0: [ nest.SetStatus( [n], { "phase": phaseInit( tp.GetPosition([n])[0], Params["lambda_dg"], Params["phi_dg"]) }) for n in nest.GetLeaves(Retina_layer)[0] ] else: # Leonardo: Random retina input [ nest.SetStatus( [n], { "phase": phaseInit( tp.GetPosition([n])[0], np.pi * np.random.rand(), np.pi * np.random.rand()) }) for n in nest.GetLeaves(Retina_layer)[0] ] # --------------------------------------------------------------------# # ---------- SET IB NEURONS ----------------------------------------- # # --------------------------------------------------------------------# # 30% of Cortex L56 excitatory neurons are intrinsically bursting(IB) neuron. # That is achieved by setting pacemaker current I_h. # So select 30% of L56_exc neuron, and change h_g_peak from 0.0 to 1.0. # (Other cortical neuron do not have I_h, thus h_g_peak=0.0) L56_vertical_idx = [ nd for nd in nest.GetLeaves(Vp_vertical)[0] if nest.GetStatus([nd], 'model')[0] == 'L56_exc' ] L56_horizontal_idx = [ nd for nd in nest.GetLeaves(Vp_horizontal)[0] if nest.GetStatus([nd], 'model')[0] == 'L56_exc' ] num_neuron = len(L56_vertical_idx) num_ib = int(num_neuron * 0.3) ridx_vertical = np.random.randint(num_neuron, size=(1, num_ib))[0] ridx_horizontal = np.random.randint(num_neuron, size=(1, num_ib))[0] for i in range(1, num_ib, 1): nest.SetStatus([L56_vertical_idx[ridx_vertical[i]]], {'h_g_peak': 1.0}) nest.SetStatus([L56_horizontal_idx[ridx_horizontal[i]]], {'h_g_peak': 1.0}) # initiate network activity #nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'rate': Params['ret_rate']}) nest.SetStatus( nest.GetLeaves(Retina_layer)[0], {'rate': Params['ret_rate']}) nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0}) nest.Simulate(500.0) #! ================= #! Recording devices #! ================= nest.CopyModel( 'multimeter', 'RecordingNode', params={ 'interval': Params['resolution'], #'record_from': ['V_m'], 'record_from': [ 'V_m', 'I_syn_AMPA', 'I_syn_NMDA', 'I_syn_GABA_A', 'I_syn_GABA_B', 'g_AMPA', 'g_NMDA', 'g_GABAA', 'g_GABAB', 'I_NaP', 'I_KNa', 'I_T', 'I_h' ], 'record_to': ['memory'], 'withgid': True, 'withtime': True }) recorders = [] ''' for population, model in [(Retina_layer, 'Retina'), (Tp_layer , 'Tp_exc'), (Tp_layer , 'Tp_inh'), (Rp_layer , 'Rp'), (Vp_vertical, 'L23_exc'), (Vp_horizontal, 'L23_exc'), (Vp_vertical, 'L23_inh'), (Vp_horizontal, 'L23_inh'), (Vp_vertical, 'L4_exc'), (Vp_horizontal, 'L4_exc'), (Vp_vertical, 'L4_inh'), (Vp_horizontal, 'L4_inh'), (Vp_vertical, 'L56_exc'), (Vp_horizontal, 'L56_exc'), (Vp_vertical, 'L56_inh'), (Vp_horizontal, 'L56_inh'), (Vs_vertical, 'L23_exc'), (Vs_horizontal, 'L23_exc'), (Vs_vertical, 'L23_inh'), (Vs_horizontal, 'L23_inh'), (Vs_vertical, 'L4_exc'), (Vs_horizontal, 'L4_exc'), (Vs_vertical, 'L4_inh'), (Vs_horizontal, 'L4_inh'), (Vs_vertical, 'L56_exc'), (Vs_horizontal, 'L56_exc'), (Vs_vertical, 'L56_inh'), (Vs_horizontal, 'L56_inh')]: ''' for population, model in [(Retina_layer, 'Retina'), (Tp_layer, 'Tp_exc'), (Tp_layer, 'Tp_inh'), (Vp_vertical, 'L4_exc'), (Vp_vertical, 'L4_inh'), (Vp_horizontal, 'L4_exc'), (Vp_vertical, 'L23_exc'), (Vp_horizontal, 'L23_exc'), (Vp_vertical, 'L56_exc'), (Rp_layer, 'Rp')]: rec = nest.Create('RecordingNode') recorders.append([rec, population, model]) if (model == 'Retina'): nest.SetStatus(rec, {'record_from': ['rate']}) tgts = [ nd for nd in nest.GetLeaves(population)[0] if nest.GetStatus([nd], 'model')[0] == model ] nest.Connect(rec, tgts) #! ================= #! Spike detector #! ================= detectors = [] ''' for population, model in [(Retina_layer, 'Retina'), (Tp_layer , 'Tp_exc'), (Tp_layer , 'Tp_inh'), (Rp_layer , 'Rp'), (Vp_vertical, 'L23_exc'), (Vp_horizontal, 'L23_exc'), (Vp_vertical, 'L23_inh'), (Vp_horizontal, 'L23_inh'), (Vp_vertical, 'L4_exc'), (Vp_horizontal, 'L4_exc'), (Vp_vertical, 'L4_inh'), (Vp_horizontal, 'L4_inh'), (Vp_vertical, 'L56_exc'), (Vp_horizontal, 'L56_exc'), (Vp_vertical, 'L56_inh'), (Vp_horizontal, 'L56_inh'), (Vs_vertical, 'L23_exc'), (Vs_horizontal, 'L23_exc'), (Vs_vertical, 'L23_inh'), (Vs_horizontal, 'L23_inh'), (Vs_vertical, 'L4_exc'), (Vs_horizontal, 'L4_exc'), (Vs_vertical, 'L4_inh'), (Vs_horizontal, 'L4_inh'), (Vs_vertical, 'L56_exc'), (Vs_horizontal, 'L56_exc'), (Vs_vertical, 'L56_inh'), (Vs_horizontal, 'L56_inh')]: ''' for population, model in [(Retina_layer, 'Retina'), (Tp_layer, 'Tp_exc'), (Tp_layer, 'Tp_inh'), (Vp_vertical, 'L4_exc'), (Vp_horizontal, 'L4_exc')]: rec = nest.Create('spike_detector', params={ "withgid": True, "withtime": True }) #rec = nest.Create('spike_detector') detectors.append([rec, population, model]) tgts = [ nd for nd in nest.GetLeaves(population)[0] if nest.GetStatus([nd], 'model')[0] == model ] if model == 'Retina': for t in tgts: try: nest.Connect([t], rec) print('connected %d' % t) except: print('%d did not work' % t) else: nest.Connect(tgts, rec) #! ==================== #! Simulation #! ==================== ''' # change gKL to 0.8 in all populations (necessary to get a little stronger evoked response) for l in layers: sim_elements = l[1]['elements'] for m in np.arange(0,np.size(sim_elements),1): if(np.size(sim_elements)==1): sim_model = sim_elements else: sim_model = sim_elements[m] exec("la = %s" % l[0]) pop = [nd for nd in nest.GetLeaves(la)[0] if nest.GetStatus([nd], 'model')[0]==sim_model] if (l[0]!='Retina_layer'): for cell in pop: nest.SetStatus([cell], {'g_KL':0.8}) ''' # Simulate for t in Params['intervals']: #if (t == 250.0): # Stimulus ON # # if (t == 1500.0): # Stimulus ON # nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 45.0}) #else: # Stimulus OFF # nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0}) if Params['input_flag'] == True: nest.SetStatus( nest.GetLeaves(Retina_layer)[0], {'amplitude': Params['ret_rate']}) else: nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0}) nest.Simulate(t) #! ==================== #! Plot Results #! ==================== if Params.has_key('show_main_figure') and Params['show_main_figure']: print "plotting..." rows = 9 cols = 2 fig = plt.figure() fig.subplots_adjust(hspace=0.4) # Plot A: membrane potential rasters recorded_models = [(Retina_layer, 'Retina'), (Vp_vertical, 'L23_exc'), (Vp_vertical, 'L4_exc'), (Vp_vertical, 'L56_exc'), (Rp_layer, 'Rp'), (Tp_layer, 'Tp_exc')] #plotting.potential_raster(fig,recorders,recorded_models,0,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,0) plotting.potential_raster(fig, recorders, recorded_models, 0, Params['Np'], np.sum(Params['intervals']), Params['resolution'], rows, cols, 0) #starting_neuron = 800+1 #plotting.potential_raster(fig,recorders,recorded_models,starting_neuron,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,0) plt.title('Evoked') # Plot B: individual intracellular traces recorded_models = [(Vp_vertical, 'L4_exc'), (Vp_vertical, 'L4_inh')] #plotting.intracellular_potentials(fig, recorders, recorded_models, 21, rows, cols, 6) #original # keiko total_time = 0.0 for t in Params['intervals']: total_time += t #draw_neuron = (Params['Np']*Params['Np']/2) #plotting.intracellular_potentials(fig, recorders, recorded_models, draw_neuron, rows, cols, 6, total_time) plotting.intracellular_potentials(fig, recorders, recorded_models, 21, rows, cols, 6, total_time) #plotting.intracellular_potentials(fig, recorders, recorded_models, 820, rows, cols, 6, total_time) # Plot C: topographical activity of the vertical and horizontal layers recorded_models = [(Vp_vertical, 'L23_exc')] labels = ["Vertical"] start = 130.0 stop = 140.0 #start = 650.0 #stop = 660.0 plotting.topographic_representation(fig, recorders, recorded_models, labels, Params['Np'], np.sum(Params['intervals']), Params['resolution'], rows, cols, start, stop, 8, 0) recorded_models = [(Vp_horizontal, 'L23_exc')] labels = ["Horizontal"] start = 130.0 stop = 140.0 #start = 650.0 #stop = 660.0 plotting.topographic_representation(fig, recorders, recorded_models, labels, Params['Np'], np.sum(Params['intervals']), Params['resolution'], rows, cols, start, stop, 8, 1) plt.show() # Plot D: movie #labels = ["Evoked_Vp_L23_Vertical","Evoked_Vp_L23_Horizontal"] #recorded_models = [(Vp_vertical,'L23_exc'),(Vp_horizontal,'L23_exc')] #plotting.makeMovie(fig,recorders,recorded_models,labels,Params['Np'],np.sum(Params['intervals']),Params['resolution']) #! ==================== #! Save Results #! ==================== print('save recorders data') # Set folder #rootdir = '/home/kfujii2/newNEST2/ht_model_pablo_based/data/' #expdir = 'random/' # expdir = 'random_full/' # expdir = 'structured_full/' # data_folder = rootdir + expdir data_folder = Params['data_folder'] if not os.path.isdir(data_folder): os.makedirs(data_folder) # To save spike data, set pairs of population id and its name population_name = [{ 'population': Retina_layer, 'name': 'Retina' }, { 'population': Vp_vertical, 'name': 'Vp_v' }, { 'population': Vp_horizontal, 'name': 'Vp_h' }, { 'population': Rp_layer, 'name': 'Rp' }, { 'population': Tp_layer, 'name': 'Tp' }, { 'population': Vs_vertical, 'name': 'Vs_v' }, { 'population': Vs_horizontal, 'name': 'Vs_h' }] for rec, population, model in recorders: # Get name of population for p in range(0, len(population_name), 1): if population_name[p]['population'] == population: p_name = population_name[p]['name'] data = nest.GetStatus(rec)[0]['events'] if model == 'Retina': scipy.io.savemat(data_folder + '/recorder_' + p_name + '_' + model + '.mat', mdict={ 'senders': data['senders'], 'rate': data['rate'] }) else: scipy.io.savemat(data_folder + '/recorder_' + p_name + '_' + model + '.mat', mdict={ 'senders': data['senders'], 'V_m': data['V_m'], 'I_syn_AMPA': data['I_syn_AMPA'], 'I_syn_NMDA': data['I_syn_NMDA'], 'I_syn_GABA_A': data['I_syn_GABA_A'], 'I_syn_GABA_B': data['I_syn_GABA_B'], 'g_AMPA': data['g_AMPA'], 'g_NMDA': data['g_NMDA'], 'g_GABAA': data['g_GABAA'], 'g_GABAB': data['g_GABAB'] }) print('save raster images') plt.close() for rec, population, model in detectors: spikes = nest.GetStatus(rec, 'events')[0] # Get name of population for p in range(0, len(population_name), 1): if population_name[p]['population'] == population: p_name = population_name[p]['name'] if len(nest.GetStatus(rec)[0]['events']['senders']) > 3: raster = raster_plot.from_device(rec, hist=True) pylab.title(p_name + '_' + model) f = raster[0].figure f.set_size_inches(15, 9) f.savefig(data_folder + 'spikes_' + p_name + '_' + model + '.png', dpi=100) plt.close() # Set filename and save spike data filename = data_folder + 'spike_' + p_name + '_' + model + '.pickle' pickle.dump(spikes, open(filename, 'w')) scipy.io.savemat(data_folder + '/spike_' + p_name + '_' + model + '.mat', mdict={ 'senders': spikes['senders'], 'times': spikes['times'] }) ''' filename_AMPA = data_folder + 'connection_' + p_name + '_AMPA_syn' + '.dat' filename_NMDA = data_folder + 'connection_' + p_name + '_NMDA_syn' + '.dat' filename_GABAA = data_folder + 'connection_' + p_name + '_GABA_A_syn' + '.dat' filename_GABAB = data_folder + 'connection_' + p_name + '_GABA_B_syn' + '.dat' tp.DumpLayerConnections(population, 'AMPA_syn', filename_AMPA) tp.DumpLayerConnections(population, 'NMDA_syn', filename_NMDA) tp.DumpLayerConnections(population, 'GABA_A_syn', filename_GABAA) tp.DumpLayerConnections(population, 'GABA_B_syn', filename_GABAB) ''' ''' for p in range(0, len(population_name), 1): population = population_name[p]['population'] p_name = population_name[p]['name'] filename_nodes = data_folder + '/gid_' + p_name + '.dat' tp.DumpLayerNodes(population, filename_nodes) ''' network_script = Params['network'] + '.py' shutil.copy2(network_script, Params['data_folder'] + network_script) print('end')
vol2 = nest.Create('volume_transmitter') pool1 = nest.Create('iaf_psc_exp', 100) pool2 = nest.Create('iaf_psc_exp', 100) if active_pool == 1: neuro_mod1 = nest.Create('poisson_generator', 1, {'rate': 950.0}) neuro_mod2 = nest.Create('poisson_generator', 1, {'rate': 0.0}) ap = '1' else: neuro_mod1 = nest.Create('poisson_generator', 1, {'rate': 0.0}) neuro_mod2 = nest.Create('poisson_generator', 1, {'rate': 950.0}) ap = '2' conn_dict = {'rule': 'all_to_all'} syn_dict = {'weight': 100., 'delay': 1.0} #50, nest.Connect(neuro_mod1, pool1, conn_spec=conn_dict, syn_spec=syn_dict) nest.Connect(neuro_mod2, pool2, conn_spec=conn_dict, syn_spec=syn_dict) nest.Connect(pool1, vol1) nest.Connect(pool2, vol2) print vol1, vol2 nest.CopyModel('stdp_dopamine_synapse', 'IC1', { "receptor_type": 1, "vt": vol1[0] }) nest.CopyModel('stdp_dopamine_synapse', 'IC2', { "receptor_type": 1, "vt": vol2[0] })
def synchrony_influence(weight=10., resolution=0.1, dt=20): nest.ResetKernel() print(resolution) nest.SetKernelStatus({'resolution': resolution, 'print_time': True}) print(nest.GetStatus([0])) neuron_model = 'izhikevich' nest.CopyModel( neuron_model, 'inh_Izhi', { 'consistent_integration': False, 'U_m': -0.2 * 65.0, 'b': 0.2, 'c': -65.0, 'a': 0.1, 'd': 2.0, 'tau_minus': 20. }) nest.CopyModel( neuron_model, 'ex_Izhi', { 'consistent_integration': False, 'U_m': -0.2 * 65.0, 'b': 0.2, 'c': -65.0, 'a': 0.02, 'd': 8.0, 'tau_minus': 20. }) nest.CopyModel("static_synapse", "EX", {'weight': weight, 'delay': 1.0}) ex_neuron = nest.Create('ex_Izhi', dt) spike_gen = nest.Create('spike_generator', dt) for i in range(dt): nest.SetStatus([spike_gen[i]], {'spike_times': [250., 250 + i * resolution]}) mm = nest.Create("multimeter", params={ 'record_from': ['V_m'], 'interval': resolution, 'withgid': True, 'withtime': True, 'to_memory': True, 'to_file': False, 'label': 'mem_pot' }) spk_det = nest.Create("spike_detector", params={ 'to_memory': True, 'to_file': False, 'label': 'spk_det' }) nest.SetStatus(ex_neuron, 'V_m', -70.) nest.SetStatus(ex_neuron, 'U_m', -70. * .2) nest.Connect(mm, ex_neuron, 'all_to_all') nest.Connect(spike_gen, ex_neuron, 'one_to_one', 'EX') nest.Connect(ex_neuron, spk_det, 'all_to_all', 'EX') nest.Simulate(500.) return nest.GetStatus(mm)[0]['events'], nest.GetStatus( spk_det)[0]['events']
for (s_t_pre, s_t_post) in zip(spike_times_pre, spike_times_post): nest.ResetKernel() nest.SetKernelStatus({"resolution": resolution}) # Create one neuron nrn = nest.Create("aeif_psc_delta_clopath", 1, nrn_params) # We need a parrot neuron since spike generators can only # be connected with static connections prrt_nrn = nest.Create("parrot_neuron", 1) # Create and connect spike generators spike_gen_pre = nest.Create("spike_generator", 1, {"spike_times": s_t_pre}) nest.Connect(spike_gen_pre, prrt_nrn, syn_spec={"delay": resolution}) spike_gen_post = nest.Create("spike_generator", 1, {"spike_times": s_t_post}) nest.Connect(spike_gen_post, nrn, syn_spec={ "delay": resolution, "weight": 80.0 }) # Create weight recorder wr = nest.Create('weight_recorder', 1) # Create Clopath connection with weight recorder
nest.ResetKernel() nest.SetKernelStatus({'resolution': 1.0}) neuron_low_res = nest.Create("izhikevich", 1, neuron_params_low_res) neuron_high_res = nest.Create("izhikevich", 1, neuron_params_high_res) nest.SetStatus(neuron_low_res, {"I_e": 4.}) nest.SetStatus(neuron_high_res, {"I_e": 4.}) mm = nest.Create('multimeter', 1, { 'record_from': ['V_m', 'U_m'], 'interval': 1.0 }) sd = nest.Create('spike_detector', 1) nest.Connect(neuron_low_res, sd) nest.Connect(neuron_high_res, sd) nest.Connect(mm, neuron_low_res + neuron_high_res) nest.Simulate(1000.) ev = nest.GetStatus(sd, 'events')[0] neuron0_mask = np.where(ev['senders'] == 1)[0] neuron1_mask = np.where(ev['senders'] == 2)[0] neuron0_times = ev['times'][neuron0_mask] neuron1_times = ev['times'][neuron1_mask] isi0 = np.diff(neuron0_times)
# current input to the neuron. We also want to record the global id of # the observed nodes and set the withgid flag of the voltmeter to # True. nest.SetStatus(neuron, "I_e", 376.0) nest.SetStatus(voltmeter, [{"withgid": True}]) # Fourth, the neuron is connected to the voltmeter. The command # `Connect()` has different variants. Plain `Connect()` just takes the # handles of pre- and post-synaptic nodes and uses the default values # for weight and delay. `ConvergentConnect()` takes four arguments: # lists of pre- and post-synaptic nodes and lists of weights and # delays. Note that the connection direction for the voltmeter is # reversed compared to the spike detector, because it observes the # neuron instead of receiving events from it. Thus, `Connect()` # reflects the direction of signal flow in the simulation kernel # rather than the physical process of inserting an electrode into the # neuron. The latter semantics is presently not available in NEST. nest.Connect(voltmeter, neuron) # Now we simulate the network using `Simulate()`, which takes the # desired simulation time in milliseconds. nest.Simulate(1000.0) # Finally, we plot the neuron's membrane potential as a function of # time. nest.voltage_trace.from_device(voltmeter)
def run_synapse_test( self, neuron_model_name, ref_neuron_model_name, synapse_model_name, ref_synapse_model_name, resolution=1., # [ms] delay=1., # [ms] sim_time=None, # if None, computed from pre and post spike times pre_spike_times=None, post_spike_times=None, fname_snip=""): if pre_spike_times is None: pre_spike_times = [] if post_spike_times is None: post_spike_times = [] if sim_time is None: sim_time = max(np.amax(pre_spike_times), np.amax(post_spike_times)) + 5 * delay nest.set_verbosity("M_ALL") nest.ResetKernel() nest.Install("nestml_jit_module") nest.Install("nestml_non_jit_module") print("Pre spike times: " + str(pre_spike_times)) print("Post spike times: " + str(post_spike_times)) nest.set_verbosity("M_WARNING") nest.ResetKernel() nest.SetKernelStatus({'resolution': resolution}) wr = nest.Create('weight_recorder') wr_ref = nest.Create('weight_recorder') nest.CopyModel( synapse_model_name, "stdp_nestml_rec", { "weight_recorder": wr[0], "w": 1., "the_delay": 1., "receptor_type": 0, "lambda": .001 }) if sim_ref: nest.CopyModel( ref_synapse_model_name, "stdp_ref_rec", { "weight_recorder": wr_ref[0], "weight": 1., "delay": 1., "receptor_type": 0, "lambda": .001 }) # create spike_generators with these times pre_sg = nest.Create("spike_generator", params={"spike_times": pre_spike_times}) post_sg = nest.Create("spike_generator", params={ "spike_times": post_spike_times, 'allow_offgrid_times': True }) # create parrot neurons and connect spike_generators if sim_mdl: pre_neuron = nest.Create("parrot_neuron") post_neuron = nest.Create(neuron_model_name) if sim_ref: pre_neuron_ref = nest.Create("parrot_neuron") post_neuron_ref = nest.Create(ref_neuron_model_name) if sim_mdl: spikedet_pre = nest.Create("spike_recorder") spikedet_post = nest.Create("spike_recorder") mm = nest.Create( "multimeter", params={"record_from": ["V_m", self.post_trace_var]}) if sim_ref: spikedet_pre_ref = nest.Create("spike_recorder") spikedet_post_ref = nest.Create("spike_recorder") mm_ref = nest.Create("multimeter", params={"record_from": ["V_m"]}) if sim_mdl: nest.Connect(pre_sg, pre_neuron, "one_to_one", syn_spec={"delay": 1.}) nest.Connect(post_sg, post_neuron, "one_to_one", syn_spec={ "delay": 1., "weight": 9999. }) nest.Connect(pre_neuron, post_neuron, "all_to_all", syn_spec={'synapse_model': 'stdp_nestml_rec'}) nest.Connect(mm, post_neuron) nest.Connect(pre_neuron, spikedet_pre) nest.Connect(post_neuron, spikedet_post) if sim_ref: nest.Connect(pre_sg, pre_neuron_ref, "one_to_one", syn_spec={"delay": 1.}) nest.Connect(post_sg, post_neuron_ref, "one_to_one", syn_spec={ "delay": 1., "weight": 9999. }) nest.Connect(pre_neuron_ref, post_neuron_ref, "all_to_all", syn_spec={'synapse_model': ref_synapse_model_name}) nest.Connect(mm_ref, post_neuron_ref) nest.Connect(pre_neuron_ref, spikedet_pre_ref) nest.Connect(post_neuron_ref, spikedet_post_ref) # get STDP synapse and weight before protocol if sim_mdl: syn = nest.GetConnections(source=pre_neuron, synapse_model="stdp_nestml_rec") if sim_ref: syn_ref = nest.GetConnections(source=pre_neuron_ref, synapse_model=ref_synapse_model_name) t = 0. t_hist = [] if sim_mdl: w_hist = [] if sim_ref: w_hist_ref = [] state = 0 while t <= sim_time: if t > sim_time / 6. and state == 0: post_neuron.set({"I_dend": 1.}) state = 1 if t > 2 * sim_time / 6 and state == 1: post_neuron.set({"I_dend": 1.}) if t > 2 * sim_time / 3. and state == 1: state = 2 nest.Simulate(resolution) t += resolution t_hist.append(t) if sim_ref: w_hist_ref.append(nest.GetStatus(syn_ref)[0]['weight']) if sim_mdl: w_hist.append(nest.GetStatus(syn)[0]['w']) third_factor_trace = nest.GetStatus(mm, "events")[0][self.post_trace_var] timevec = nest.GetStatus(mm, "events")[0]["times"] if TEST_PLOTS: fig, ax = plt.subplots(nrows=2) ax1, ax2 = ax if sim_mdl: V_m = nest.GetStatus(mm, "events")[0]["V_m"] ax2.plot(timevec, third_factor_trace, label="I_dend_post") ax1.plot(timevec, V_m, alpha=.7, linestyle=":") if sim_ref: pre_ref_spike_times_ = nest.GetStatus(spikedet_pre_ref, "events")[0]["times"] timevec_ = nest.GetStatus(mm_ref, "events")[0]["times"] V_m_ = nest.GetStatus(mm_ref, "events")[0]["V_m"] ax1.plot(timevec_, V_m_, label="nest ref", alpha=.7) ax1.set_ylabel("V_m") for _ax in ax: _ax.grid(which="major", axis="both") _ax.grid(which="minor", axis="x", linestyle=":", alpha=.4) # _ax.minorticks_on() _ax.set_xlim(0., sim_time) _ax.legend() fig.savefig("/tmp/stdp_triplet_synapse_test" + fname_snip + "_V_m.png", dpi=300) if TEST_PLOTS: fig, ax = plt.subplots(nrows=5) ax1, ax2, ax3, ax4, ax5 = ax if sim_mdl: pre_spike_times_ = nest.GetStatus(spikedet_pre, "events")[0]["times"] print("Actual pre spike times: " + str(pre_spike_times_)) if sim_ref: pre_ref_spike_times_ = nest.GetStatus(spikedet_pre_ref, "events")[0]["times"] print("Actual pre ref spike times: " + str(pre_ref_spike_times_)) if sim_mdl: n_spikes = len(pre_spike_times_) for i in range(n_spikes): ax1.plot(2 * [pre_spike_times_[i] + delay], [0, 1], linewidth=2, color="blue", alpha=.4) if sim_mdl: post_spike_times_ = nest.GetStatus(spikedet_post, "events")[0]["times"] print("Actual post spike times: " + str(post_spike_times_)) if sim_ref: post_ref_spike_times_ = nest.GetStatus(spikedet_post_ref, "events")[0]["times"] print("Actual post ref spike times: " + str(post_ref_spike_times_)) if sim_ref: n_spikes = len(pre_ref_spike_times_) for i in range(n_spikes): ax1.plot(2 * [pre_ref_spike_times_[i] + delay], [0, 1], linewidth=2, color="cyan", alpha=.4) ax1.set_ylabel("Pre spikes") if sim_mdl: n_spikes = len(post_spike_times_) for i in range(n_spikes): if i == 0: _lbl = "nestml" else: _lbl = None ax[-4].plot(2 * [post_spike_times_[i]], [0, 1], linewidth=2, color="black", alpha=.4, label=_lbl) if sim_ref: n_spikes = len(post_ref_spike_times_) for i in range(n_spikes): if i == 0: _lbl = "nest ref" else: _lbl = None ax[-4].plot(2 * [post_ref_spike_times_[i]], [0, 1], linewidth=2, color="red", alpha=.4, label=_lbl) ax[-4].set_ylabel("Post spikes") ax[-3].plot(timevec, third_factor_trace) ax[-3].set_ylabel("3rd factor") ax[-2].plot(t_hist[:-1], np.diff(w_hist), marker="o", label=u"Δw") ax[-2].set_ylabel(u"Δw") ax[-1].plot(t_hist, w_hist, marker="o") if sim_ref: ax[-1].plot(t_hist, w_hist_ref, linestyle="--", marker="x", label="ref") ax[-1].set_ylabel("w") ax[-1].set_xlabel("Time [ms]") for _ax in ax: if not _ax == ax[-1]: _ax.set_xticklabels([]) _ax.grid(which="major", axis="both") _ax.xaxis.set_major_locator( matplotlib.ticker.FixedLocator( np.arange(0, np.ceil(sim_time)))) _ax.set_xlim(0., sim_time) fig.savefig("/tmp/stdp_third_factor_synapse_test" + fname_snip + ".png", dpi=300) # verify MAX_ABS_ERROR = 1E-6 idx = np.where(np.abs(third_factor_trace) < 1E-3)[ 0] # find where third_factor_place is (almost) zero times_dw_should_be_zero = timevec[idx] for time_dw_should_be_zero in times_dw_should_be_zero: _idx = np.argmin((time_dw_should_be_zero - np.array(t_hist))**2) assert np.abs(np.diff(w_hist)[_idx]) < MAX_ABS_ERROR assert np.any(np.abs(np.array(w_hist) - 1) > MAX_ABS_ERROR), "No change in the weight!"
temp = nest.Create(zin, cell_n) All_cells[key1].append(temp) ext_key = xin[:2] + yin + zin temp_d = nest.Create('poisson_generator', 1, {'rate': Ext[ext_key]}) external_list[ext_key].append(temp_d) temp_sd = nest.Create('spike_detector', 1, { "label": key1, "withtime": True, "withgid": True, "to_file": False }) sd_list[key1].append(temp_sd) conn_dict = {'rule': 'all_to_all'} syn_dict = {'model': 'Frompyr', 'weight': 100, 'delay': 1.0} #50, nest.Connect(temp_d, temp, conn_spec=conn_dict, syn_spec=syn_dict) nest.Connect(temp, temp_sd) for yin in alltypes: sourcetypes = xin + yin source_list = list(All_cells[xin + yin][0]) for zin in alltypes: targettypes = xin + zin target_list = list(All_cells[xin + zin][0]) conn_keys = yin + '_' + zin if area == 'V1': exception = V1_exceptions weights = V1_weights elif area == 'LM': exception = LM_exceptions weights = LM_weights
"label": "voltmeter", "withtime": True, "withgid": True, "interval": 1. }) ############################################################################### # Sixth, the `dc_generator` is connected to the first neuron # (``neurons[0]``) and the `voltmeter` is connected to the second neuron # (``neurons[1]``). The command `Connect` has different variants. Plain # `Connect` just takes the handles of pre- and post-synaptic nodes and uses # the default values for weight and delay. Note that the connection # direction for the `voltmeter` reflects the signal flow in the simulation # kernel, because it observes the neuron instead of receiving events from it. nest.Connect(dc_gen, [neurons[0]]) nest.Connect(volts, [neurons[1]]) ############################################################################### # Seventh, the first neuron (``neurons[0]``) is connected to the second # neuron (``neurons[1]``). The command `CopyModel` copies the # `tsodyks_synapse` model to the new name ``syn`` with parameters # ``syn_param``. The manually defined model ``syn`` is used in the # connection routine via the ``syn_spec`` parameter. nest.CopyModel("tsodyks_synapse", "syn", syn_param) nest.Connect([neurons[0]], [neurons[1]], syn_spec="syn") ############################################################################### # Finally, we simulate the configuration using the command `Simulate`, # where the simulation time ``Tend`` is passed as the argument. We plot the
def _connect(self): """Connect populations.""" nest.Connect(self._ls, self._lt, self._conndict)
soma_inh_inp = g_inh(ampl_inh, t_start, t_end) ''' dendritic input create spike pattern by recording the spikes of a simulation of n_pg poisson generators. The recorded spike times are then given to spike generators. ''' n_pg = 200 # number of poisson generators p_rate = 10.0 # rate in Hz pgs = nest.Create('poisson_generator', n=n_pg, params={'rate': p_rate}) prrt_nrns_pg = nest.Create('parrot_neuron', n_pg) nest.Connect(pgs, prrt_nrns_pg, {'rule': 'one_to_one'}) sd = nest.Create('spike_detector', n_pg) nest.Connect(prrt_nrns_pg, sd, {'rule': 'one_to_one'}) nest.Simulate(pattern_duration) t_sds = [] for i, ssd in enumerate(nest.GetStatus(sd)): t_sd = ssd['events']['times'] t_sds.append(t_sd) nest.ResetKernel() nest.SetKernelStatus({'resolution': resolution}) ''' neuron and devices
def generateSpikes(self, neuron, times): """Trigger spike to given neuron at specified times.""" delay = 1. gen = nest.Create("spike_generator", 1, { "spike_times": [t - delay for t in times]}) nest.Connect(gen, neuron, syn_spec={"delay": delay})
} } ie_conn_dict = {'rule': 'pairwise_bernoulli', 'p': pI, 'autapses': False} ii_syn_dict = { "model": "ii", "weight": wII, "delay": { "distribution": "uniform", "low": 0.1, "high": 2.0 } } ii_conn_dict = {'rule': 'pairwise_bernoulli', 'p': pI, 'autapses': False} nest.Connect(exc, exc, ee_conn_dict, ee_syn_dict) nest.Connect(exc, inh, ei_conn_dict, ei_syn_dict) nest.Connect(inh, exc, ie_conn_dict, ie_syn_dict) nest.Connect(inh, inh, ii_conn_dict, ii_syn_dict) # create poisson noise noiseExc = nest.Create('poisson_generator', nExc) noiseInh = nest.Create('poisson_generator', nInh) # don't know rate, should be "to every neuron" ie one-to-one nest.SetStatus(noiseExc, [{ "rate": 90.0, "origin": 0.0, "start": 0.0, "stop": 100.0 }]) nest.SetStatus(noiseInh, [{