def test_CSA_OneToOne_params(self): """One-to-one connectivity using CGConnect with paramters""" nest.ResetKernel() n_neurons = 4 weight = 10000.0 delay = 2.0 sources = nest.Create("iaf_psc_alpha", n_neurons) targets = nest.Create("iaf_psc_alpha", n_neurons) # Create a connection set with values for weight and delay cs = csa.cset(csa.oneToOne, weight, delay) # Connect sources and targets using the connection set cs and # a parameter map mapping weight to position 0 in the value # set and delay to position 1 nest.CGConnect(sources, targets, cs, {"weight": 0, "delay": 1}) for i in range(n_neurons): # We expect all connections from sources to have the # correct targets, weights and delays conns = nest.GetStatus(nest.GetConnections(sources[i])) self.assertEqual(len(conns), 1) self.assertEqual(conns[0]["target"], targets[i].get('global_id')) self.assertEqual(conns[0]["weight"], weight) self.assertEqual(conns[0]["delay"], delay) # We expect the targets to have no connections at all conns = nest.GetStatus(nest.GetConnections(targets[i])) self.assertEqual(len(conns), 0)
def connect(self, projection): """Connect-up a Projection.""" presynaptic_cells = projection.pre.all_cells.astype('int64') postsynaptic_cells = projection.post.all_cells.astype('int64') if csa.arity(self.cset) == 2: param_map = {'weight': 0, 'delay': 1} nest.CGConnect(presynaptic_cells, postsynaptic_cells, self.cset, param_map, projection.nest_synapse_model) else: nest.CGConnect(presynaptic_cells, postsynaptic_cells, self.cset, model=projection.nest_synapse_model) projection._connections = None # reset the caching of the connection list, since this will have to be recalculated projection._sources.extend(presynaptic_cells)
def test_CSA_OneToOne_params(self): """One-to-one connectivity""" nest.ResetKernel() n = 4 # number of neurons pop0 = nest.LayoutNetwork("iaf_neuron", [n]) pop1 = nest.LayoutNetwork("iaf_neuron", [n]) cs = csa.cset(csa.oneToOne, 10000.0, 1.0) nest.CGConnect(pop0, pop1, cs, {"weight": 0, "delay": 1}) sources = nest.GetLeaves(pop0)[0] targets = nest.GetLeaves(pop1)[0] for i in xrange(n): conns = nest.GetStatus(nest.FindConnections([sources[i]]), 'target') self.assertEqual(len(conns), 1) self.assertEqual(conns[0], targets[i]) conns = nest.GetStatus(nest.FindConnections([targets[i]]), 'target') self.assertEqual(len(conns), 0)
def test_CSA_OneToOne_intvectors(self): """One-to-one connectivity using CGConnect with id intvectors""" nest.ResetKernel() n_neurons = 4 sources = nest.Create("iaf_psc_alpha", n_neurons) targets = nest.Create("iaf_psc_alpha", n_neurons) # Create a plain connection set cg = csa.cset(csa.oneToOne) # Connect sources and targets (both converted to NumPy arrays) # using the connection set cs. This will internally call the # variant of CGConnect that takes intvector instead of lists nest.CGConnect(numpy.array(sources), numpy.array(targets), cg) for i in range(n_neurons): # We expect all connections from sources to have the # correct targets conns = nest.GetStatus(nest.GetConnections(sources[i])) self.assertEqual(len(conns), 1) self.assertEqual(conns[0]["target"], targets[i].get('global_id')) # We expect the targets to have no connections at all conns = nest.GetStatus(nest.GetConnections(targets[i])) self.assertEqual(len(conns), 0)
def test_CSA_OneToOne_synmodel(self): """One-to-one connectivity using CGConnect with synmodel""" nest.ResetKernel() n_neurons = 4 synmodel = "stdp_synapse" sources = nest.Create("iaf_psc_alpha", n_neurons) targets = nest.Create("iaf_psc_alpha", n_neurons) # Create a plain connection set cs = csa.cset(csa.oneToOne) # Connect with a non-standard synapse model nest.CGConnect(sources, targets, cs, model=synmodel) for i in range(n_neurons): # We expect all connections to have the correct targets # and the non-standard synapse model set conns = nest.GetStatus(nest.GetConnections(sources[i])) self.assertEqual(len(conns), 1) self.assertEqual(conns[0]["target"], targets[i].get('global_id')) self.assertEqual(conns[0]["synapse_model"], synmodel) # We expect the targets to have no connections at all conns = nest.GetStatus(nest.GetConnections(targets[i])) self.assertEqual(len(conns), 0)
def test_CSA_OneToOne_tuples(self): """One-to-one connectivity using CGConnect with id tuples""" nest.ResetKernel() n_neurons = 4 sources = nest.Create("iaf_psc_alpha", n_neurons) targets = nest.Create("iaf_psc_alpha", n_neurons) # Create a plain connection set cg = csa.cset(csa.oneToOne) # Connect sources and targets using the connection set # cs. This will internally call the variant of CGConnect that # takes lists nest.CGConnect(sources, targets, cg) for i in range(n_neurons): # We expect all connections from sources to have the # correct targets conns = nest.GetStatus(nest.GetConnections(sources[i])) self.assertEqual(len(conns), 1) self.assertEqual(conns[0]["target"], targets[i].get('global_id')) # We expect the targets to have no connections at all conns = nest.GetStatus(nest.GetConnections(targets[i])) self.assertEqual(len(conns), 0)
def csa_example(): cs = csa.cset(csa.random(0.1), 10000.0, 1.0) pop1 = nest.LayoutNetwork("iaf_neuron", [16]) pop2 = nest.LayoutNetwork("iaf_neuron", [16]) nest.PrintNetwork(10) nest.CGConnect(pop1, pop2, cs, {"weight": 0, "delay": 1}) pg = nest.Create("poisson_generator", params={"rate": 80000.0}) nest.DivergentConnect(pg, nest.GetLeaves(pop1)[0], 1.2, 1.0) vm_params = { "record_to": ["memory"], "withgid": True, "withtime": True, "interval": 0.1 } vm = nest.Create("voltmeter", params=vm_params) nest.DivergentConnect(vm, nest.GetLeaves(pop2)[0]) nest.Simulate(50.0) from nest import visualization allnodes = pg + nest.GetLeaves(pop1)[0] + nest.GetLeaves(pop2)[0] + vm visualization.plot_network(allnodes, "test_csa.png") if havePIL: im = Image.open("test_csa.png") im.show() from nest import voltage_trace voltage_trace.from_device(vm)
def test_CSA_OneToOne_subnet_1d(self): """One-to-one connectivity with 1-dim subnets""" nest.ResetKernel() n = 4 # number of neurons pop0 = nest.LayoutNetwork("iaf_neuron", [n]) pop1 = nest.LayoutNetwork("iaf_neuron", [n]) cg = csa.cset(csa.oneToOne) nest.CGConnect(pop0, pop1, cg) sources = nest.GetLeaves(pop0)[0] targets = nest.GetLeaves(pop1)[0] for i in range(n): conns = nest.GetStatus(nest.FindConnections([sources[i]]), 'target') self.assertEqual(len(conns), 1) self.assertEqual(conns[0], targets[i]) conns = nest.GetStatus(nest.FindConnections([targets[i]]), 'target') self.assertEqual(len(conns), 0)
def _connect(self): '''Connect populations.''' finite_set = csa.cross(xrange(self._N_s), xrange(self._N_t)) if self._fan == 'in': cs = csa.cset(csa.random(fanIn=self._C) * finite_set) else: cs = csa.cset(csa.random(fanOut=self._C) * finite_set) nest.CGConnect(self._source_pop, self._target_pop, csa.cset(cs))
def _connect(self): '''Connect populations.''' g1 = self._geometryFunction(self._ls) g2 = self._geometryFunction(self._lt) d = csa.euclidMetric2d(g1, g2) sigma = self._params['sigma'] cutoff = self._max_dist cs = csa.cset( csa.cross([0], xrange(self._N - 1)) * (csa.random * (csa.gaussian(sigma, cutoff) * d)), 1.0, 1.0) nest.CGConnect( nest.GetLeaves(self._ls)[0], nest.GetLeaves(self._lt)[0], cs, { 'weight': 0, 'delay': 1 })
def csa_example(): cs = csa.cset(csa.random(0.1), 10000.0, 1.0) # This does not work yet, as the implementation does not yet # support nested subnets. # #pop1 = nest.LayoutNetwork("iaf_neuron", [4,4]) #pop2 = nest.LayoutNetwork("iaf_neuron", [4,4]) pop1 = nest.LayoutNetwork("iaf_neuron", [16]) pop2 = nest.LayoutNetwork("iaf_neuron", [16]) nest.PrintNetwork(10) nest.CGConnect(pop1, pop2, cs, {"weight": 0, "delay": 1}) pg = nest.Create("poisson_generator", params={"rate": 80000.0}) nest.DivergentConnect(pg, nest.GetLeaves(pop1)[0], 1.2, 1.0) vm = nest.Create("voltmeter", params={ "record_to": ["memory"], "withgid": True, "withtime": True, "interval": 0.1 }) nest.DivergentConnect(vm, nest.GetLeaves(pop2)[0]) nest.Simulate(50.0) # Not yet supported in NEST #from nest import visualization #allnodes = [pg, nest.GetLeaves(pop1)[0], nest.GetLeaves(pop2)[0], vm] #visualization.plot_network(allnodes, "test_csa.png", "png", plot_modelnames=True #if havePIL: # im = Image.open("test_csa.png") # im.show() from nest import voltage_trace voltage_trace.from_device(vm)
def csa_topology_example(): # layers have 20x20 neurons and extent 1 x 1 pop1 = topo.CreateLayer({'elements': 'iaf_neuron', 'rows': 20, 'columns': 20}) pop2 = topo.CreateLayer({'elements': 'iaf_neuron', 'rows': 20, 'columns': 20}) # create CSA-style geometry functions and metric g1 = geometryFunction(pop1) g2 = geometryFunction(pop2) d = csa.euclidMetric2d(g1, g2) # Gaussian connectivity profile, sigma = 0.2, cutoff at 0.5 cs = csa.cset(csa.random * (csa.gaussian(0.2, 0.5) * d), 10000.0, 1.0) # create connections nest.CGConnect(pop1, pop2, cs, {"weight": 0, "delay": 1}) # show targets of center neuron topo.PlotTargets(topo.FindCenterElement(pop1), pop2)
def test_libcsa_OneToOne_idrange(self): """One-to-one connectivity with id ranges""" nest.ResetKernel() n = 4 # number of neurons sources = nest.Create("iaf_neuron", n) targets = nest.Create("iaf_neuron", n) cg = libcsa.oneToOne nest.CGConnect(sources, targets, cg) for i in range(n): conns = nest.GetStatus(nest.GetConnections([sources[i]]), 'target') self.assertEqual(len(conns), 1) self.assertEqual(conns[0], targets[i]) conns = nest.GetStatus(nest.GetConnections([targets[i]]), 'target') self.assertEqual(len(conns), 0)
g1 = geometryFunction(pop1) g2 = geometryFunction(pop2) d = csa.euclidMetric2d(g1, g2) """ The connection set ``cs`` describes a Gaussian connectivity profile with sigma = 0.2 and cutoff at 0.5, and two values (10000.0 and 1.0) used as weight and delay, respectively. """ cs = csa.cset(csa.random * (csa.gaussian(0.2, 0.5) * d), 10000.0, 1.0) """ We can now connect the populations using the `CGConnect` function. It takes the IDs of pre- and postsynaptic neurons (``pop1`` and ``pop2``), the connection set (``cs``) and a dictionary that maps the parameters weight and delay to positions in the value set associated with the connection set. """ # This is a work-around until NEST 3.0 is released. It will issue a deprecation # warning. pop1_gids = nest.GetLeaves(pop1)[0] pop2_gids = nest.GetLeaves(pop2)[0] nest.CGConnect(pop1_gids, pop2_gids, cs, {"weight": 0, "delay": 1}) """ Finally, we use the `PlotTargets` function to show all targets in ``pop2`` starting at the center neuron of ``pop1``. """ topo.PlotTargets(topo.FindCenterElement(pop1), pop2)
""" For each layer, we create a CSA-style geometry function and a CSA metric based on them. """ g1 = geometryFunction(pop1) g2 = geometryFunction(pop2) d = csa.euclidMetric2d(g1, g2) """ The connection set ``cs`` describes a Gaussian connectivity profile with sigma = 0.2 and cutoff at 0.5, and two values (10000.0 and 1.0) used as weight and delay, respectively. """ cs = csa.cset(csa.random * (csa.gaussian(0.2, 0.5) * d), 10000.0, 1.0) """ We can now connect the populations using the `CGConnect` function. It takes the IDs of pre- and postsynaptic neurons (``pop1`` and ``pop2``), the connection set (``cs``) and a dictionary that maps the parameters weight and delay to positions in the value set associated with the connection set. """ nest.CGConnect(pop1, pop2, cs, {"weight": 0, "delay": 1}) """ Finally, we use the `PlotTargets` function to show all targets in ``pop2`` starting at the center neuron of ``pop1``. """ topo.PlotTargets(topo.FindCenterElement(pop1), pop2)
Using the `Create` command from PyNEST, we create the neurons of the pre- and postsynaptic populations, each of which containing 16 neurons. """ pre = nest.Create("iaf_neuron", 16) post = nest.Create("iaf_neuron", 16) """ We can now connect the populations using the `CGConnect` function. It takes the IDs of pre- and postsynaptic neurons (``pre`` and ``post``), the connection set (``cs``) and a dictionary that maps the parameters weight and delay to positions in the value set associated with the connection set. """ nest.CGConnect(pre, post, cs, {"weight": 0, "delay": 1}) """ To stimulate the network, we create a `poisson_generator` and set it up to fire with a rate of 100000 spikes per second. It is connected to the neurons of the pre-synaptic population. """ pg = nest.Create("poisson_generator", params={"rate": 100000.0}) nest.Connect(pg, pre, "all_to_all") """ To measure and record the membrane potentials of the neurons, we create a `voltmeter` and connect it to all post-synaptic nodes. """ vm = nest.Create("voltmeter") nest.Connect(vm, post, "all_to_all")
def _connect(self): '''Connect populations.''' finite_set = csa.cross(xrange(self._N_s), xrange(self._N_t)) cs = csa.cset(csa.random(p=self._p) * finite_set) nest.CGConnect(self._source_pop, self._target_pop, csa.cset(cs))