def _get_nest_synapse_model(self, suffix): synapse_defaults = {} for name, value in self.native_parameters.items(): if value.is_homogeneous: value.shape = (1,) synapse_defaults[name] = value.evaluate(simplify=True) synapse_defaults = make_sli_compatible(synapse_defaults) synapse_defaults.pop("tau_minus", None) label = "%s_%s" % (self.nest_name, suffix) nest.CopyModel(self.nest_name, label, synapse_defaults) return label
def connect(self): # print(nest.GetStatus([1],'C_m')) """Connect nodes""" if self.built == False: raise BuildError('Build the network first') nest.CopyModel("static_synapse", "excitatory", {"weight": self.J_ex}) nest.CopyModel("static_synapse", "inhibitory", {"weight": self.J_in}) nest.CopyModel("static_synapse", "external", {"weight": self.J_ext}) self.syn_dict = {'model': 'excitatory', 'delay': self.delay} self.syn_dict_in = {'model': 'inhibitory', 'delay': self.delay} self.syn_dict_ext = {'model': 'external', 'delay': self.delay} nest.Connect(self.noise, self.nodes_ex, syn_spec=self.syn_dict_ext) # if self.i_noise_off==False: # print('in noise connected') nest.Connect(self.noise, self.nodes_in, syn_spec=self.syn_dict_ext) nest.Connect(self.nodes_al[:self.N_rec], self.espikes, syn_spec=self.syn_dict) if self.record_vol: nest.Connect(self.voltmeter, self.nodes_al[:self.N_rec]) #self.N_rec # print("Connecting network") # print("Excitatory connections") self.conn_params_ex = {'rule': 'fixed_indegree', 'indegree': self.KE} nest.Connect(self.nodes_ex, self.nodes_ex + self.nodes_in, self.conn_params_ex, syn_spec=self.syn_dict) # print("Inhibitory connections") self.conn_params_in = {'rule': 'fixed_indegree', 'indegree': self.KI} nest.Connect(self.nodes_in, self.nodes_ex + self.nodes_in, self.conn_params_in, syn_spec=self.syn_dict_in)
def test_single_synapse_deletion_sp(self): for syn_model in nest.Models('synapses'): if syn_model not in self.exclude_synapse_model: nest.ResetKernel() nest.CopyModel('static_synapse', 'my_static_synapse') syn_dict = { 'model': syn_model, 'pre_synaptic_element': 'SE1', 'post_synaptic_element': 'SE2' } #nest.SetKernelStatus({'structural_plasticity_synapses': {'syn1': syn_dict}}) neurons = nest.Create( 'iaf_neuron', 2, { 'synaptic_elements': { 'SE1': { 'z': 0.0, 'growth_rate': 0.0 }, 'SE2': { 'z': 0.0, 'growth_rate': 0.0 } } }) nest.Connect(neurons, neurons, "all_to_all", syn_dict) nest.Connect(neurons, neurons, "all_to_all", {'model': 'my_static_synapse'}) # Test if the connected synaptic elements before the simulation are correct status = nest.GetStatus(neurons, 'synaptic_elements') for st_neuron in status: self.assertEqual(2, st_neuron['SE1']['z_connected']) self.assertEqual(2, st_neuron['SE2']['z_connected']) srcId = 0 targId = 1 conns = nest.GetConnections([neurons[srcId]], [neurons[targId]], syn_model) assert conns nest.DisconnectOneToOne(neurons[srcId], neurons[targId], syn_dict) status = nest.GetStatus(neurons, 'synaptic_elements') self.assertEqual(1, status[srcId]['SE1']['z_connected']) self.assertEqual(2, status[srcId]['SE2']['z_connected']) self.assertEqual(2, status[targId]['SE1']['z_connected']) self.assertEqual(1, status[targId]['SE2']['z_connected']) conns = nest.GetConnections([neurons[srcId]], [neurons[targId]], syn_model) assert not conns
def runSimulation(self,recorded_models,recorded_spikes,record_Vm): recorders = [] if record_Vm: nest.CopyModel('multimeter', 'RecordingNode', {'interval' : self.Params['resolution'], 'record_from': ['V_m'], 'record_to' : ['memory'], 'withgid' : True, 'withtime' : False}) for population, model in recorded_models: rec = nest.Create('RecordingNode') recorders.append([rec,population,model]) tgts = [nd for nd in nest.GetLeaves(population)[0] if nest.GetStatus([nd], 'model')[0]==model] nest.Connect(rec, tgts) nest.CopyModel('spike_detector', 'RecordingSpikes', {"withtime": True, "withgid": True, "to_file": False}) spike_detectors = [] for population, model in recorded_spikes: rec = nest.Create('RecordingSpikes') spike_detectors.append([rec,population,model]) tgts = [nd for nd in nest.GetLeaves(population)[0] if nest.GetStatus([nd], 'model')[0]==model] nest.Connect(tgts, rec) print ("\n--- Simulation ---\n") nest.SetStatus([0],{'print_time': True}) nest.Simulate(self.Params['simtime']) return recorders,spike_detectors
def test_prohibit_change_tic_base(self): """Getting error when changing tic-base in prohibited conditions""" nest.CopyModel('iaf_psc_alpha', 'alpha_copy') self._assert_ticbase_change_raises_and_reset('CopyModel') nest.SetDefaults("multimeter", {"record_to": "ascii"}) self._assert_ticbase_change_raises_and_reset('SetDefaults') nest.Create('multimeter') self._assert_ticbase_change_raises_and_reset('Create') nest.Simulate(10.) self._assert_ticbase_change_raises_and_reset('Simulate')
def __init__(self, presynaptic_population, postsynaptic_population, method, source=None, target=None, synapse_dynamics=None, label=None, rng=None): """ presynaptic_population and postsynaptic_population - Population objects. source - string specifying which attribute of the presynaptic cell signals action potentials target - string specifying which synapse on the postsynaptic cell to connect to If source and/or target are not given, default values are used. method - a Connector object, encapsulating the algorithm to use for connecting the neurons. synapse_dynamics - a `SynapseDynamics` object specifying which synaptic plasticity mechanisms to use. rng - specify an RNG object to be used by the Connector. """ common.Projection.__init__(self, presynaptic_population, postsynaptic_population, method, source, target, synapse_dynamics, label, rng) self.synapse_type = target or 'excitatory' if self.synapse_dynamics: synapse_dynamics = self.synapse_dynamics self.synapse_dynamics._set_tau_minus(self.post.local_cells) else: synapse_dynamics = NativeSynapseDynamics("static_synapse") synapse_model = synapse_dynamics._get_nest_synapse_model( "projection_%d" % Projection.nProj) if synapse_model is None: self.synapse_model = 'static_synapse_%s' % id(self) nest.CopyModel('static_synapse', self.synapse_model) else: self.synapse_model = synapse_model self._sources = [] self._connections = None Projection.nProj += 1 # Create connections method.connect(self)
def assert_parameter_limits_bigger(self, param_name, limit): nest.ResetKernel() nest.CopyModel("synaptic_sampling_rewardgradient_synapse", "test_synapse") try: nest.SetDefaults("test_synapse", {param_name: limit - 1}) self.fail("Expected exception of type NESTError, but got nothing") except Exception as e: self.assertEqual( type(e).__name__, "NESTError", "Expected exception of type NESTError, but got: '" + type(e).__name__ + "'") nest.ResetKernel() nest.CopyModel("synaptic_sampling_rewardgradient_synapse", "test_synapse") try: nest.SetDefaults("test_synapse", {param_name: limit}) self.fail("Expected exception of type NESTError, but got nothing") except Exception as e: self.assertEqual( type(e).__name__, "NESTError", "Expected exception of type NESTError, but got: '" + type(e).__name__ + "'") nest.ResetKernel() nest.CopyModel("synaptic_sampling_rewardgradient_synapse", "test_synapse") try: nest.SetDefaults("test_synapse", {param_name: limit + 1}) except Exception as e: self.fail("Expected no exception, but got: '" + type(e).__name__ + "'")
class TestGetStructuralPlasticityStatus(unittest.TestCase): neuron_model = 'iaf_psc_alpha' nest.CopyModel('static_synapse', 'synapse_ex') nest.SetDefaults('synapse_ex', {'weight': 1.0, 'delay': 1.0}) nest.SetStructuralPlasticityStatus({ 'structural_plasticity_synapses': { 'synapse_ex': { 'synapse_model': 'synapse_ex', 'post_synaptic_element': 'Den_ex', 'pre_synaptic_element': 'Axon_ex', }, } }) growth_curve = { 'growth_curve': "gaussian", 'growth_rate': 0.0001, # (elements/ms) 'continuous': False, 'eta': 0.0, # Ca2+ 'eps': 0.05 } ''' Now we assign the growth curves to the corresponding synaptic elements ''' synaptic_elements = { 'Den_ex': growth_curve, 'Den_in': growth_curve, 'Axon_ex': growth_curve, } nodes = nest.Create(neuron_model, 2, {'synaptic_elements': synaptic_elements}) all = nest.GetStructuralPlasticityStatus() assert ('structural_plasticity_synapses' in all) assert ('syn1' in all['structural_plasticity_synapses']) assert ('structural_plasticity_update_interval' in all) assert (all['structural_plasticity_update_interval'] == 10000.) sp_synapses = nest.GetStructuralPlasticityStatus( 'structural_plasticity_synapses') syn = sp_synapses['syn1'] assert ('pre_synaptic_element' in syn) assert ('post_synaptic_element' in syn) assert (syn['pre_synaptic_element'] == 'Axon_ex') assert (syn['post_synaptic_element'] == 'Den_ex') sp_interval = nest.GetStructuralPlasticityStatus( 'structural_plasticity_update_interval') assert (sp_interval == 10000.)
def do_the_nest_simulation(self): """ This function is where calls to NEST reside. Returns the generated pre- and post spike sequences and the resulting weight established by the tsodyks2 synapse. """ nest.set_verbosity("M_WARNING") nest.ResetKernel() nest.SetKernelStatus({"resolution": self.resolution}) neurons = nest.Create("parrot_neuron", 2, params={}) presynaptic_neuron = neurons[0] postsynaptic_neuron = neurons[1] presynaptic_generator = nest.Create("poisson_generator", params={ "rate": self.presynaptic_firing_rate, "stop": (self.simulation_duration - self.hardcoded_trains_length) }) spike_recorder = nest.Create("spike_recorder") nest.Connect(presynaptic_generator, presynaptic_neuron, syn_spec={"synapse_model": "static_synapse"}) nest.Connect(presynaptic_neuron + postsynaptic_neuron, spike_recorder, syn_spec={"synapse_model": "static_synapse"}) # The synapse of interest itself wr = nest.Create("weight_recorder") nest.CopyModel("tsodyks2_synapse", "tsodyks2_synapse_rec", {"weight_recorder": wr}) nest.Connect(presynaptic_neuron, postsynaptic_neuron, syn_spec=self.synapse_parameters) nest.Simulate(self.simulation_duration) all_spikes = spike_recorder.events pre_spikes = all_spikes["times"][all_spikes["senders"] == presynaptic_neuron.get("global_id")] weights = wr.get("events", "weights") return (pre_spikes, weights)
def testMultapses(self): """Weight Recorder Multapses""" nest.ResetKernel() nest.local_num_threads = 2 wr = nest.Create('weight_recorder') nest.CopyModel("stdp_synapse", "stdp_synapse_rec", { "weight_recorder": wr, "weight": 1. }) sg = nest.Create("spike_generator", params={"spike_times": [10., 15., 55., 70.]}) pre = nest.Create("parrot_neuron", 5) post = nest.Create("parrot_neuron", 5) nest.Connect(pre, post, 'one_to_one', syn_spec="stdp_synapse_rec") nest.Connect(pre, post, 'one_to_one', syn_spec="stdp_synapse_rec") nest.Connect(sg, pre) # simulate before GetConnections # as order of connections changes at beginning of simulation (sorting) nest.Simulate(1) conn = nest.GetConnections(pre, post) conn_dict = conn.get(['source', 'target', 'port']) connections = list( zip(conn_dict['source'], conn_dict['target'], conn_dict['port'])) nest.Simulate(100) wr_events = nest.GetStatus(wr, "events")[0] senders = wr_events["senders"] targets = wr_events["targets"] ports = wr_events["ports"] ids = list(zip(senders, targets, ports)) # create an array of object dtype to use np.unique to get # unique ids unique_ids = np.empty(len(ids), dtype=object) for i, v in enumerate(ids): unique_ids[i] = v unique_ids = np.unique(unique_ids) self.assertEqual(sorted(unique_ids), sorted(connections))
def test_getting_kernel_status(self): """ This tests the functionality of the structural plasticity status via GetKernelStatus. """ neuron_model = 'iaf_psc_alpha' nest.CopyModel('static_synapse', 'synapse_ex') nest.SetDefaults('synapse_ex', {'weight': 1.0, 'delay': 1.0}) nest.SetKernelStatus({ 'structural_plasticity_synapses': { 'synapse_ex': { 'synapse_model': 'synapse_ex', 'post_synaptic_element': 'Den_ex', 'pre_synaptic_element': 'Axon_ex', }, } }) growth_curve = { 'growth_curve': "gaussian", 'growth_rate': 0.0001, # (elements/ms) 'continuous': False, 'eta': 0.0, # Ca2+ 'eps': 0.05 } ''' Now we assign the growth curves to the corresponding synaptic elements ''' synaptic_elements = { 'Den_ex': growth_curve, 'Den_in': growth_curve, 'Axon_ex': growth_curve, } nodes = nest.Create(neuron_model, 2, {'synaptic_elements': synaptic_elements}) sp_synapses = nest.GetKernelStatus('structural_plasticity_synapses') syn = sp_synapses['syn1'] assert ('pre_synaptic_element' in syn) assert ('post_synaptic_element' in syn) assert (syn['pre_synaptic_element'] == 'Axon_ex') assert (syn['post_synaptic_element'] == 'Den_ex') sp_interval = nest.GetKernelStatus( 'structural_plasticity_update_interval') assert (sp_interval == 10000.)
def setUp_net(self, n_post, params={}): """Set up a net and parrots""" nest.set_verbosity("M_WARNING") nest.ResetKernel() nest.SetKernelStatus({"resolution": 1.}) # set pre and postsynaptic spike times delay = 1. # delay for connections # set the correct real spike times for generators (correcting for # delays) pre_times = [100. - delay, 200. - delay] post_times = [120. - delay, 140. - delay, 160. - delay] # create spike_generators with these times pre_spikes = nest.Create("spike_generator", 1, {"spike_times": pre_times}) post_spikes = nest.Create("spike_generator", 1, {"spike_times": post_times}) self.pre_spikes = pre_spikes self.post_spikes = post_spikes # create parrot neurons and connect spike_generators self.pre_parrot = nest.Create("parrot_neuron", 1) self.post_parrot = nest.Create("parrot_neuron", n_post) nest.Connect(pre_spikes, self.pre_parrot, syn_spec={"delay": delay}) nest.Connect(post_spikes, self.post_parrot, syn_spec={"delay": delay}, conn_spec={"rule": "all_to_all"}) # create spike detector self.spikes = nest.Create("spike_detector") nest.Connect(self.pre_parrot, self.spikes, conn_spec={"rule": "all_to_all"}) nest.Connect(self.post_parrot, self.spikes, conn_spec={"rule": "all_to_all"}) pars = {'tau': 0.02, 'tau_slow': 0.300, 'w0': .2, 'p_fail': .2} pars.update(params) nest.CopyModel('stdp_structpl_synapse_hom', 'testsyn', pars)
def _get_nest_synapse_model(self, suffix): # We create a particular synapse context for each projection, by copying # the one which is desired. if self.fast: if self.slow: raise Exception( "It is not currently possible to have both short-term and long-term plasticity at the same time with this simulator." ) else: base_model = self.fast.native_name elif self.slow: base_model = self.slow.possible_models if isinstance(base_model, set): logger.warning( "Several STDP models are available for these connections:") logger.warning(", ".join(model for model in base_model)) base_model = list(base_model)[0] logger.warning("By default, %s is used" % base_model) available_models = nest.Models(mtype='synapses') if base_model not in available_models: raise ValueError( "Synapse dynamics model '%s' not a valid NEST synapse model. " "Possible models in your NEST build are: %s" % (base_model, available_models)) synapse_defaults = nest.GetDefaults(base_model) for ignore in ('synapsemodel', 'num_connections', 'num_connectors', 'type', 'property_object'): synapse_defaults.pop(ignore, None) if self.fast: synapse_defaults.update(self.fast.parameters) elif self.slow: stdp_parameters = self.slow.all_parameters # NEST does not support w_min != 0 try: stdp_parameters.pop("w_min_always_zero_in_NEST") except Exception: pass # Tau_minus is a parameter of the post-synaptic cell, not of the connection stdp_parameters.pop("tau_minus") synapse_defaults.update(stdp_parameters) label = "%s_%s" % (base_model, suffix) nest.CopyModel(base_model, label, synapse_defaults) return label
def build_local_network(self): # Create neurons for pop in ['E', 'I']: self.neurons[pop] = nest.Create('default_neuron', self.N[pop]) # Sample subpopulations cut = 0 for pop in ['low', 'high', 'E_rec']: self.neurons[pop] = self.neurons['E'][cut:cut + self.N[pop]] cut += self.N[pop] self.neurons['I_rec'] = self.neurons['I'][:self.N['I_rec']] self.neurons['E_no_S'] = tuple( set(self.neurons['E']) - set(self.neurons['low']) - set(self.neurons['high'])) self.neurons['ALL'] = self.neurons['E'] + self.neurons['I'] # Connect subpopulations to spike detectors for pop in ['low', 'high', 'E_rec', 'I_rec']: self.spkdets[pop] = nest.Create('spike_detector') nest.Connect(self.neurons[pop], self.spkdets[pop]) # Connect neurons with each other for pop in ['E', 'I']: syn_model_name = f'cortex_{pop}_synapse' nest.CopyModel('default_synapse', syn_model_name, {"weight": self.J[pop]}) conn_params = {'rule': 'fixed_indegree', 'indegree': self.C[pop]} nest.Connect(self.neurons[pop], self.neurons['ALL'], conn_params, syn_model_name) # Create and connect background activity background_activity = nest.Create('poisson_generator', params={"rate": self.bg_rate}) nest.Connect(background_activity, self.neurons['ALL'], syn_spec='cortex_E_synapse') # initiate membrane potentials self.initiate_membrane_potentials_randomly() # Create and connect sensory stimulus self.stimulus = dict() for pop in ['low', 'high']: self.stimulus[pop] = nest.Create('step_current_generator') nest.Connect(self.stimulus[pop], self.neurons[pop])
def test_synapse_deletion_one_to_one_no_sp(self): for syn_model in nest.Models('synapses'): if syn_model not in self.exclude_synapse_model: nest.ResetKernel() nest.CopyModel('static_synapse', 'my_static_synapse') neurons = nest.Create('iaf_neuron', 2) syn_dict = {'model': syn_model} nest.Connect(neurons, neurons, "all_to_all", syn_dict) srcId = 0 targId = 1 conns = nest.GetConnections([neurons[srcId]],[neurons[targId]],syn_model) assert len(conns) == 1 nest.DisconnectOneToOne(neurons[srcId], neurons[targId], syn_dict) conns = nest.GetConnections([neurons[srcId]],[neurons[targId]],syn_model) assert len(conns) == 0
def connect_background(self): """ Connects background input to the microcircuit.""" # cell-type-specific membrance parameters ctsp = self.net_dict['ctsp'] # for weight recording copysynapse = 'static_synapse_wr_bg' if 'weight_recorder' in self.net_dict['rec_dev']: if copysynapse not in self.copysynapses: print('copysynapse = {}'.format(copysynapse)) nest.CopyModel('static_synapse', copysynapse, \ {'weight_recorder': self.weight_recorder['background'][0]}) self.copysynapses.append(copysynapse) if nest.Rank() == 0: print('Background input is connected') for i, target_pop in enumerate(self.pops): # population specific weights w = tools.calc_psc(self.net_dict['PSP_exc'], ctsp['C_m'][i], ctsp['tau_m'][i], self.net_dict['neuron_params']['tau_syn_ex']) syn_dict = { 'model': 'static_synapse', 'weight': w, 'delay': self.sim_resolution } # for weight recording if 'weight_recorder' in self.net_dict['rec_dev']: if i == 0: syn_dict['model'] = copysynapse if self.net_dict['test_mode']: return # Connect poisson->parrot parrots = nest.Create('parrot_neuron', self.net_dict['N_full'][i]) nest.Connect(self.poisson[i], parrots, conn_spec={'rule': 'all_to_all'}) # Connect parrot->population if 'multisynapse' in self.net_dict['neuron_model']: syn_dict['receptor_type'] = 1 nest.Connect(parrots, target_pop, conn_spec={'rule': 'one_to_one'}, syn_spec=syn_dict)
def test_neuron_synapse_multithreading(self): pre_spike_times = np.array([2., 4., 7., 8., 12., 13., 19., 23., 24., 28., 29., 30., 33., 34., 35., 36., 38., 40., 42., 46., 51., 53., 54., 55., 56., 59., 63., 64., 65., 66., 68., 72., 73., 76., 79., 80., 83., 84., 86., 87., 90., 95.]) post_spike_times = np.array([4., 5., 6., 7., 10., 11., 12., 16., 17., 18., 19., 20., 22., 23., 25., 27., 29., 30., 31., 32., 34., 36., 37., 38., 39., 42., 44., 46., 48., 49., 50., 54., 56., 57., 59., 60., 61., 62., 67., 74., 76., 79., 80., 81., 83., 88., 93., 94., 97., 99.]) nest.set_verbosity("M_ALL") nest.ResetKernel() nest.Install(self.neuron_synapse_module) nest.SetKernelStatus({'resolution': 0.1, 'local_num_threads': self.number_of_threads}) wr = nest.Create('weight_recorder') nest.CopyModel(self.neuron_synapse_synapse_model, "stdp_nestml_rec", {"weight_recorder": wr[0], "w": 1., "the_delay": 1., "receptor_type": 0}) # Spike generators pre_sg = nest.Create("spike_generator", 2, params={"spike_times": pre_spike_times}) post_sg = nest.Create("spike_generator", 2, params={"spike_times": post_spike_times, 'allow_offgrid_times': True}) pre_neuron = nest.Create(self.neuron_synapse_neuron_model, 2) post_neuron = nest.Create(self.neuron_synapse_neuron_model, 2) sr_pre = nest.Create("spike_recorder") sr_post = nest.Create("spike_recorder") mm = nest.Create("multimeter", params={"record_from": ["V_m"]}) 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, sr_pre) nest.Connect(post_neuron, sr_post) nest.Simulate(100.) V_m = nest.GetStatus(mm, "events")[0]["V_m"] print(V_m) np.testing.assert_almost_equal(V_m[-4], -59.17946541)
def get_synaptic_w(STimes): h = 0.1 nest.ResetKernel() nest.SetKernelStatus({"resolution": h}) spks = nest.Create('spike_generator', 1, {'spike_times': STimes}) pre = nest.Create('parrot_neuron', 1) post = nest.Create('iaf_psc_exp', 1) detector = nest.Create('weight_recorder') synapse_params = { 'weight': 1000., 'tau_fac': params['Tau_f'], 'weight_recorder': detector[0], 'tau_rec': params['Tau_r'], 'tau_1': params['Tau_FDR'], 'tau_2': params['Tau_r0'], 'tau_eta': params['Tau_i'], 'x': params['p0'], 'n': 1.0, 'y_0': params['a_FDR'], 'alpha_1': params['a_D'], 'alpha_2': params['a_i'], 'S': 1.0, 'alpha': params['p0bar'], 'z': params['Tau_D'], 'p': params['p0bar'] } nest.CopyModel("aibs_synapse", "syn", synapse_params) nest.Connect(spks, pre) nest.Connect(pre, post, syn_spec="syn") #nest.Connect(detector,pre) nest.Simulate(5000.0) weights = nest.GetStatus(detector, "events")[0]["weights"] weights = np.array(weights) weights = weights / weights[0] return weights
def build_local_network(self): # Create nodes self.drive = nest.Create( 'spike_generator') # Spike generator to drive VTA activity self.neurons['ALL'] = nest.Create( 'parrot_neuron', self.N['ALL']) #A middleman parrot neuron self.vt = nest.Create('volume_transmitter') # volume transmitter # Connect nodes in a chain # We can't connect the spike generator directly to the volume transmitter due to a NEST bug) nest.Connect(self.drive, self.neurons['ALL'], syn_spec={'delay': self.dt}) nest.Connect(self.neurons['ALL'], self.vt, syn_spec={'delay': self.dt}) self.DA_pars['vt'] = self.vt[0] # Create synapse that will be used by cortico-striatal neurons nest.CopyModel('stdp_dopamine_synapse', 'corticostriatal_synapse', self.DA_pars)
def _constructNetwork(self): '''Construct the E/I network''' self.i_model_name = "iaf_gridcells" self.e_neuron_params = gc_neurons.getENeuronParams(self.no) self.i_neuron_params = gc_neurons.getINeuronParams(self.no) self.i_receptors = nest.GetDefaults( self.i_model_name)['receptor_types'] nest.CopyModel('static_synapse', 'I_AMPA_NMDA', params={'receptor_type': self.i_receptors['AMPA_NMDA']}) self.e_model_name = "iaf_gridcells" self.i_model_name = "iaf_gridcells" self.E_pop = nest.Create(self.e_model_name, self.net_Ne, params=self.e_neuron_params) self.I_pop = nest.Create(self.i_model_name, self.net_Ni, params=self.i_neuron_params)
def build_topology(syn_specification): # create neurons neurons_pre = nest.Create("hh_cond_exp_traub", 101, nrn_params) neurons_post = nest.Create("hh_cond_exp_traub", 101, nrn_params) # create weight recorder wr = nest.Create('weight_recorder', n=1, params=wr_params) syn_specification['weight_recorder'] = wr[0] nest.CopyModel("stdp_synapse", "stdp_synapse_rec", params=syn_specification) # pair by pair for nrn_pre, nrn_post, pre_spike_time, post_spike_time in zip( neurons_pre, neurons_post, pre_spike_times, post_spike_times): # create generators # the spikes at the end of the simulation is need to re-calculate weights of synapses generator_pre = nest.Create('spike_generator', n=1, params={ 'spike_times': [pre_spike_time, 225.0], 'spike_weights': [350.0, 350.0] }) generator_post = nest.Create('spike_generator', n=1, params={ 'spike_times': [post_spike_time, 225.0], 'spike_weights': [350.0, 350.0] }) nest.Connect(generator_pre, [nrn_pre], syn_spec=static_synapse_spec) nest.Connect(generator_post, [nrn_post], syn_spec=static_synapse_spec) # create detector detector = nest.Create('spike_detector', n=1, params=detector_params) nest.Connect([nrn_pre, nrn_post], detector) spike_detectors[(nrn_pre, nrn_post)] = detector # create multimeter multimeter = nest.Create('multimeter', n=1, params=multimeter_params) nest.Connect(multimeter, [nrn_pre, nrn_post]) multimeters[(nrn_pre, nrn_post)] = multimeter # connect neurons nest.Connect([nrn_pre], [nrn_post], syn_spec="stdp_synapse_rec") return neurons_pre, neurons_post, wr
def connect(self): """Connect nodes""" if self.built == False: raise BuildError('Build the network first') nest.CopyModel("static_synapse", "excitatory", {"weight": self.J_ex}) if len(self.delay) < 2: self.delay = self.delay[0] print('sinlge delay') self.syn_dict = { 'model': 'excitatory', 'delay': self.delay, } else: self.d_min = self.delay[0] #3.5 self.d_max = self.delay[1] #5.5 self.syn_dict = { 'model': 'excitatory', 'delay': { 'distribution': 'uniform', 'low': self.d_min, 'high': self.d_max }, } print('uniform delay') nest.Connect(self.noise, self.nodes_ex, syn_spec=self.syn_dict) nest.Connect(self.nodes_al[:self.N_rec], self.espikes, syn_spec=self.syn_dict) #nest.Connect(self.nodes_in[:self.N_rec] ,self.ispikes, syn_spec=self.syn_dict) print("Connecting network") print("Excitatory connections") self.conn_params_ex = {'rule': 'fixed_indegree', 'indegree': self.CE} nest.Connect(self.nodes_ex, self.nodes_ex, self.conn_params_ex, syn_spec=self.syn_dict)
def __init__(self, synapse_type, synapse_model=None, parent=None): """ Create a new ConnectionManager. `synapse_type` -- the 'physiological type' of the synapse, e.g. 'excitatory' or 'inhibitory' `synapse_model` -- the NEST synapse model to be used for all connections created with this manager. `parent` -- the parent `Projection`, if any. """ self.sources = [] if synapse_model is None: self.synapse_model = 'static_synapse_%s' % id(self) nest.CopyModel('static_synapse', self.synapse_model) else: self.synapse_model = synapse_model self.synapse_type = synapse_type self.parent = parent if parent is not None: assert parent.plasticity_name == self.synapse_model self._connections = None
def testMultapses(self): """Weight Recorder Multapses""" nest.ResetKernel() nest.SetKernelStatus({"local_num_threads": 2}) wr = nest.Create('weight_recorder', params={"withport": True}) nest.CopyModel("stdp_synapse", "stdp_synapse_rec", { "weight_recorder": wr[0], "weight": 1. }) sg = nest.Create("spike_generator", params={"spike_times": [10., 15., 55., 70.]}) pre = nest.Create("parrot_neuron", 5) post = nest.Create("parrot_neuron", 5) nest.Connect(pre, post, 'one_to_one', syn_spec="stdp_synapse_rec") nest.Connect(pre, post, 'one_to_one', syn_spec="stdp_synapse_rec") nest.Connect(sg, pre) connections = [(c[0], c[1], c[4]) for c in nest.GetConnections(pre, post)] nest.Simulate(100) wr_events = nest.GetStatus(wr, "events")[0] senders = wr_events["senders"] targets = wr_events["targets"] ports = wr_events["ports"] ids = list(zip(senders, targets, ports)) # create an array of object dtype to use np.unique to get # unique ids unique_ids = np.empty(len(ids), dtype=object) for i, v in enumerate(ids): unique_ids[i] = v unique_ids = np.unique(unique_ids) self.assertEqual(sorted(unique_ids), sorted(connections))
def __init__(self, modelList): """ Create TCD computer for given modelList. The constructor instantiates NEST, including a call to ResetKernel() and instantiates all models in modelList. From all models derived from ht_model, synapse information is extracted and stored. Afterward, ResetKernel() is called once more. modelList: tuples of (parent, model, dict) Note: nest must have been imported before and all necessary modules loaded. """ import nest nest.ResetKernel() # keep "list" over all models derived from ht_neuron ht_kids = set(["ht_neuron"]) for parent, model, props in modelList: if parent in ht_kids and model not in ht_kids: nest.CopyModel(parent, model, props) ht_kids.add(model) # ht_kids now contains all models derived from ht_neuron # We collect in _tcd_info a mapping from (targetmodel, synapstype) # to an object containing all required information for TCD computation. self._tcd_info = {} for mod in ht_kids: props = nest.GetDefaults(mod) for syn in ['AMPA', 'GABA_A', 'GABA_B']: self._tcd_info[(mod, syn)] = self._TcdBeta(syn, props) self._tcd_info[(mod, 'NMDA')] = self._TcdNMDA(props) # delete models we created nest.ResetKernel()
def test_multiple_synapse_deletion_one_to_one_no_sp(self): for syn_model in nest.Models('synapses'): if syn_model not in self.exclude_synapse_model: nest.ResetKernel() nest.CopyModel('static_synapse', 'my_static_synapse') neurons = nest.Create('iaf_psc_alpha', 10) syn_dict = {'model': syn_model} nest.Connect(neurons, neurons, "all_to_all", syn_dict) srcId = range(0, 5) targId = range(5, 10) conns = nest.GetConnections(srcId, targId, syn_model) assert len(conns) == 20 conndictionary = {'rule': 'one_to_one'} syndictionary = {'model': syn_model} nest.Disconnect([neurons[i] for i in srcId], [neurons[i] for i in targId], conndictionary, syndictionary) conns = nest.GetConnections(srcId, targId, syn_model) assert len(conns) == 16
def _create_extra_models(self): c = self.config # models for plastic connections if c['synapse'] == 'stdp_synapse_sem': # SE: connections from other spaces to E-pool nest.CopyModel('stdp_synapse_sem', self.name+'_syn_SE', { 'Wmax': c['w_SE_max'], 'lambda': c['eta_SE'] / c['w_SE_max'], 'tau_plus': c['tau_plus_SE'], 'A_minus': c['A_minus_SE'], 'alpha': c['alpha_SE'], }) else: raise ValueError('Bad synapse type set.') # model dictionaries for connections model_dicts = {} # SE model_dicts['SE'] = { 'model': self.name+'_syn_SE', 'lambda': c['eta_SE'] / c['w_SE_max'], 'weight': { 'distribution': 'uniform', 'low': c['w_SE_low'], 'high': c['w_SE_high']}, 'delay': { 'distribution': 'uniform', 'low': c['synd_SE_low'], 'high': c['synd_SE_high']} } # rule dictionaries for connections # cannot create rule_dict for SE connections since it depends on N_S self.model_dicts.update(model_dicts)
def test_multiple_synapse_deletion_one_to_one_no_sp(self): for syn_model in nest.Models('synapses'): if syn_model not in self.exclude_synapse_model: nest.ResetKernel() nest.CopyModel('static_synapse', 'my_static_synapse') neurons = nest.Create('iaf_psc_alpha', 10) syn_dict = {'synapse_model': syn_model} nest.Connect(neurons, neurons, "all_to_all", syn_dict) src_neurons = neurons[:5] tgt_neurons = neurons[5:] conns = nest.GetConnections(src_neurons, tgt_neurons, syn_model) assert len(conns) == 25 conndictionary = {'rule': 'one_to_one'} syndictionary = {'synapse_model': syn_model} nest.Disconnect(src_neurons, tgt_neurons, conndictionary, syndictionary) conns = nest.GetConnections(src_neurons, tgt_neurons, syn_model) assert len(conns) == 20
def create_GR(subCB): """GR Example: :: create_GR() """ configuration = {} # Membrane potential in mV # configuration['V_m'] = 0.0 # Leak reversal Potential (aka resting potential) in mV configuration['E_L'] = -58.0 # Membrane Capacitance in pF configuration['C_m'] = 3.1 # Refractory period in ms configuration['t_ref'] = 5.0 # Threshold Potential in mV configuration['V_th'] = -35.0 # Reset Potential in mV configuration['V_reset'] = -82.0 # Excitatory reversal Potential in mV configuration['E_ex'] = 0.0 # Inhibitory reversal Potential in mV configuration['E_in'] = -82.0 # Leak Conductance in nS configuration['g_L'] = 0.43 # Time constant of the excitatory synaptic exponential function in ms configuration['tau_syn_ex'] = 52.0 # Time constant of the inhibitory synaptic exponential function in ms configuration['tau_syn_in'] = 59.0 # Constant Current in pA configuration['I_e'] = 0.0 print(subCB) nest.CopyModel('iaf_cond_exp', subCB + '_layer_gr', configuration)
def testDefinedTargetsAndSenders(self): """Weight Recorder Defined Subset Of Targets and Senders""" nest.ResetKernel() nest.local_num_threads = 1 wr = nest.Create('weight_recorder') nest.CopyModel("stdp_synapse", "stdp_synapse_rec", { "weight_recorder": wr, "weight": 1. }) sg = nest.Create("spike_generator", params={"spike_times": [10., 15., 55., 70.]}) pre = nest.Create("parrot_neuron", 5) post = nest.Create("parrot_neuron", 5) nest.Connect(pre, post, syn_spec="stdp_synapse_rec") nest.Connect(sg, pre) nest.SetStatus(wr, {"senders": pre[1:3], "targets": post[:3]}) # simulate before GetConnections # as order of connections changes at beginning of simulation (sorting) nest.Simulate(1) connections = nest.GetConnections(pre[1:3], post[:3]) targets = np.array([]) for i in range(1): nest.Simulate(1) targets = np.append(targets, connections.get("target")) wr_targets = nest.GetStatus(wr, "events")[0]["targets"] self.addTypeEqualityFunc(type(wr_targets), self.is_subset) self.assertEqual(wr_targets, targets)