populations = list() projections = list() weight_to_spike = 2.0 delay = 17 loopConnections = list() for i in range(0, nNeurons): singleConnection = ((i, (i + 1) % nNeurons, weight_to_spike, delay)) loopConnections.append(singleConnection) injectionConnection = [(0, 0)] spikeArray = {'spike_times': [[0]]} populations.append( p.Population(nNeurons, p.IF_curr_exp(**cell_params_lif), label='pop_1')) populations.append( p.Population(1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1')) projections.append(p.Projection( populations[0], populations[0], p.FromListConnector(loopConnections), p.StaticSynapse(weight=weight_to_spike, delay=delay))) projections.append(p.Projection( populations[1], populations[0], p.FromListConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=1))) populations[0].record(['v', 'gsyn_exc', 'gsyn_inh', 'spikes']) p.run(runtime) # get data (could be done as one, but can be done bit by bit as well)
def test_turn_off_spikes_indexes(self): sim.setup(timestep=1) if_curr = sim.Population(5, sim.IF_curr_exp()) if_curr.record("spikes") if_curr.record(None) self.assertListEq([], if_curr._get_all_recording_variables())
def structural_without_stdp(): p.setup(1.0) stim = p.Population(1, p.SpikeSourceArray(range(10)), label="stim") # These populations should experience formation pop = p.Population(1, p.IF_curr_exp(), label="pop") pop_2 = p.Population(1, p.IF_curr_exp(), label="pop_2") # These populations should experience elimination pop_3 = p.Population(1, p.IF_curr_exp(), label="pop_3") pop_4 = p.Population(1, p.IF_curr_exp(), label="pop_4") # Formation with last-neuron selection (0 probability elimination) proj = p.Projection( stim, pop, p.FromListConnector([]), p.StructuralMechanismStatic( partner_selection=p.LastNeuronSelection(), formation=p.DistanceDependentFormation([1, 1], 1.0), elimination=p.RandomByWeightElimination(2.0, 0, 0), f_rew=1000, initial_weight=2.0, initial_delay=5.0, s_max=1, seed=0, weight=0.0, delay=1.0)) # Formation with random selection (0 probability elimination) proj_2 = p.Projection( stim, pop_2, p.FromListConnector([]), p.StructuralMechanismStatic( partner_selection=p.RandomSelection(), formation=p.DistanceDependentFormation([1, 1], 1.0), elimination=p.RandomByWeightElimination(4.0, 0, 0), f_rew=1000, initial_weight=4.0, initial_delay=3.0, s_max=1, seed=0, weight=0.0, delay=1.0)) # Elimination with last neuron selection (0 probability formation) proj_3 = p.Projection( stim, pop_3, p.FromListConnector([(0, 0)]), p.StructuralMechanismStatic( partner_selection=p.LastNeuronSelection(), formation=p.DistanceDependentFormation([1, 1], 0.0), elimination=p.RandomByWeightElimination(4.0, 1.0, 1.0), f_rew=1000, initial_weight=2.0, initial_delay=5.0, s_max=1, seed=0, weight=0.0, delay=1.0)) # Elimination with random selection (0 probability formation) proj_4 = p.Projection( stim, pop_4, p.FromListConnector([(0, 0)]), p.StructuralMechanismStatic( partner_selection=p.RandomSelection(), formation=p.DistanceDependentFormation([1, 1], 0.0), elimination=p.RandomByWeightElimination(4.0, 1.0, 1.0), f_rew=1000, initial_weight=4.0, initial_delay=3.0, s_max=1, seed=0, weight=0.0, delay=1.0)) p.run(10) # Get the final connections conns = list(proj.get(["weight", "delay"], "list")) conns_2 = list(proj_2.get(["weight", "delay"], "list")) conns_3 = list(proj_3.get(["weight", "delay"], "list")) conns_4 = list(proj_4.get(["weight", "delay"], "list")) p.end() print(conns) print(conns_2) print(conns_3) print(conns_4) # These should be formed with specified parameters assert (len(conns) == 1) assert (tuple(conns[0]) == (0, 0, 2.0, 5.0)) assert (len(conns_2) == 1) assert (tuple(conns_2[0]) == (0, 0, 4.0, 3.0)) # These should have no connections since eliminated assert (len(conns_3) == 0) assert (len(conns_4) == 0)
# The port on which the spiNNaker machine should listen for packets. # Packets to be injected should be sent to this port on the spiNNaker # machine 'port': 12346, # This is the base key to be used for the injection, which is used to # allow the keys to be routed around the spiNNaker machine. This # assignment means that 32-bit keys must have the high-order 16-bit # set to 0x7; This will automatically be prepended to 16-bit keys. 'virtual_key': 0x70000, } # create synfire populations (if cur exp) pop_forward = Frontend.Population(n_neurons, Frontend.IF_curr_exp(**cell_params_lif), label='pop_forward') pop_backward = Frontend.Population(n_neurons, Frontend.IF_curr_exp(**cell_params_lif), label='pop_backward') # Create injection populations injector_forward = Frontend.Population( n_neurons, Frontend.external_devices.SpikeInjector( **cell_params_spike_injector_with_key), label='spike_injector_forward') injector_backward = Frontend.Population( n_neurons, Frontend.external_devices.SpikeInjector(**cell_params_spike_injector), label='spike_injector_backward')
def do_run(self, psh, psw, ksh, ksw, pre_start=(0, 0), post_start=(0, 0), pre_step=(1, 1), post_step=(1, 1)): sim.setup(timestep=1.0) # determine population size and runtime from the kernel sizes n_pop = psw * psh runtime = (n_pop * 5) + 1000 spiking = [[n * 5, (n_pop * 5) - 1 - (n * 5)] for n in range(n_pop)] input_pop = sim.Population(n_pop, sim.SpikeSourceArray(spiking), label="input") pop = sim.Population(n_pop // 4, sim.IF_curr_exp(), label="pop") weights = 5.0 delays = 17.0 shape_pre = [psh, psw] shape_post = [psh // 2, psw // 2] shape_kernel = [ksh, ksw] weight_list = [[ 7.0 if ((a + b) % 2 == 0) else 5.0 for a in range(ksw) ] for b in range(ksh)] delay_list = [[ 20.0 if ((a + b) % 2 == 1) else 10.0 for a in range(ksw) ] for b in range(ksh)] weight_kernel = np.asarray(weight_list) delay_kernel = np.asarray(delay_list) kernel_connector = sim.KernelConnector( shape_pre, shape_post, shape_kernel, weight_kernel=weight_kernel, delay_kernel=delay_kernel, pre_sample_steps_in_post=pre_step, post_sample_steps_in_pre=post_step, pre_start_coords_in_post=pre_start, post_start_coords_in_pre=post_start) c2 = sim.Projection(input_pop, pop, kernel_connector, sim.StaticSynapse(weight=weights, delay=delays)) pop.record(['v', 'spikes']) sim.run(runtime) weightsdelays = sorted(c2.get(['weight', 'delay'], 'list'), key=lambda x: x[1]) sim.end() return weightsdelays
def test_set_spikes_indexes3(self): sim.setup(timestep=1) if_curr = sim.Population(5, sim.IF_curr_exp()) if_curr.record("spikes") self.assertCountEqual(["spikes"], if_curr._recorder.get_all_recording_variables())
loopConnections.append(singleConnection) for i in range(160, 170): singleConnection = ((i, 3, 1, delay)) loopConnections.append(singleConnection) for i in range(170, 260): singleConnection = ((i, 4, 1, delay)) loopConnections.append(singleConnection) for i in range(260, 320): singleConnection = ((i, 5, 1, delay)) loopConnections.append(singleConnection) populations.append( p.Population(320, p.IF_curr_exp(**cell_params_lif), label='pop_1')) populations.append( p.Population(6, p.IF_curr_exp(**cell_params_lif1), label='pop_2')) populations.append( p.Population( 320, p.external_devices.SpikeInjector(label='inputSpikes_1', database_notify_port_num=19990))) projections.append( p.Projection( populations[0], populations[1], p.FromListConnector(loopConnections), )) projections.append(
def test_write_data_spec(): unittest_setup() # UGLY but the mock transceiver NEED generate_on_machine to be False AbstractGenerateConnectorOnMachine.generate_on_machine = say_false machine = virtual_machine(2, 2) p.setup(1.0) load_config() p.set_number_of_neurons_per_core(p.IF_curr_exp, 100) pre_pop = p.Population(10, p.IF_curr_exp(), label="Pre", additional_parameters={ "splitter": SplitterAbstractPopulationVertexSlice() }) post_pop = p.Population(10, p.IF_curr_exp(), label="Post", additional_parameters={ "splitter": SplitterAbstractPopulationVertexSlice() }) proj_one_to_one_1 = p.Projection(pre_pop, post_pop, p.OneToOneConnector(), p.StaticSynapse(weight=1.5, delay=1.0)) proj_one_to_one_2 = p.Projection(pre_pop, post_pop, p.OneToOneConnector(), p.StaticSynapse(weight=2.5, delay=2.0)) proj_all_to_all = p.Projection( pre_pop, post_pop, p.AllToAllConnector(allow_self_connections=False), p.StaticSynapse(weight=4.5, delay=4.0)) from_list_list = [(i, i, i, (i * 5) + 1) for i in range(10)] proj_from_list = p.Projection(pre_pop, post_pop, p.FromListConnector(from_list_list), p.StaticSynapse()) app_graph = globals_variables.get_simulator().original_application_graph context = {"ApplicationGraph": app_graph} with (injection_context(context)): delay_support_adder(app_graph) machine_graph, _ = spynnaker_splitter_partitioner( app_graph, machine, 100) allocator = ZonedRoutingInfoAllocator() n_keys_map = edge_to_n_keys_mapper(machine_graph) routing_info = allocator.__call__(machine_graph, n_keys_map, flexible=False) post_vertex = next(iter(post_pop._vertex.machine_vertices)) post_vertex_slice = post_vertex.vertex_slice post_vertex_placement = Placement(post_vertex, 0, 0, 3) temp_spec = tempfile.mktemp() spec = DataSpecificationGenerator(io.FileIO(temp_spec, "wb"), None) synaptic_matrices = SynapticMatrices(post_vertex_slice, n_synapse_types=2, all_single_syn_sz=10000, synaptic_matrix_region=1, direct_matrix_region=2, poptable_region=3, connection_builder_region=4) synaptic_matrices.write_synaptic_data( spec, post_pop._vertex.incoming_projections, all_syn_block_sz=10000, weight_scales=[32, 32], routing_info=routing_info) spec.end_specification() with io.FileIO(temp_spec, "rb") as spec_reader: executor = DataSpecificationExecutor(spec_reader, 20000) executor.execute() all_data = bytearray() all_data.extend(bytearray(executor.get_header())) all_data.extend(bytearray(executor.get_pointer_table(0))) for r in range(MAX_MEM_REGIONS): region = executor.get_region(r) if region is not None: all_data.extend(region.region_data) transceiver = MockTransceiverRawData(all_data) report_folder = mkdtemp() try: connections_1 = numpy.concatenate( synaptic_matrices.get_connections_from_machine( transceiver, post_vertex_placement, proj_one_to_one_1._projection_edge, proj_one_to_one_1._synapse_information)) # Check that all the connections have the right weight and delay assert len(connections_1) == post_vertex_slice.n_atoms assert all([conn["weight"] == 1.5 for conn in connections_1]) assert all([conn["delay"] == 1.0 for conn in connections_1]) connections_2 = numpy.concatenate( synaptic_matrices.get_connections_from_machine( transceiver, post_vertex_placement, proj_one_to_one_2._projection_edge, proj_one_to_one_2._synapse_information)) # Check that all the connections have the right weight and delay assert len(connections_2) == post_vertex_slice.n_atoms assert all([conn["weight"] == 2.5 for conn in connections_2]) assert all([conn["delay"] == 2.0 for conn in connections_2]) connections_3 = numpy.concatenate( synaptic_matrices.get_connections_from_machine( transceiver, post_vertex_placement, proj_all_to_all._projection_edge, proj_all_to_all._synapse_information)) # Check that all the connections have the right weight and delay assert len(connections_3) == 100 assert all([conn["weight"] == 4.5 for conn in connections_3]) assert all([conn["delay"] == 4.0 for conn in connections_3]) connections_4 = numpy.concatenate( synaptic_matrices.get_connections_from_machine( transceiver, post_vertex_placement, proj_from_list._projection_edge, proj_from_list._synapse_information)) # Check that all the connections have the right weight and delay assert len(connections_4) == len(from_list_list) list_weights = [values[2] for values in from_list_list] list_delays = [values[3] for values in from_list_list] assert all(list_weights == connections_4["weight"]) assert all(list_delays == connections_4["delay"]) finally: shutil.rmtree(report_folder, ignore_errors=True)
def test_simple(self): n_neurons = 5 label = "pop_1" sim.setup(timestep=1.0) pop_1 = sim.Population(n_neurons, sim.IF_curr_exp(), label=label) mask = [1, 3] view = PopulationView(pop_1, mask, label=label) self.assertEqual(2, view.size) self.assertEqual(2, view.local_size) random_view = pop_1.sample(3) self.assertEqual(3, random_view.size) self.assertEqual(label, view.label) self.assertEqual(pop_1.celltype, view.celltype) self.assertEqual(pop_1.celltype, random_view.celltype) view_initial_values = view.initial_values pop_initial_values = pop_1.initial_values self.assertEqual(len(view_initial_values), len(pop_initial_values)) for key in pop_initial_values: self.assertEqual(pop_initial_values[key][3], view_initial_values[key][1]) self.assertEqual(pop_1, view.parent) self.assertEqual(mask, view.mask) cells = view.all_cells self.assertEqual(2, len(cells)) self.assertEqual(1, cells[0].id) self.assertEqual(3, cells[1].id) self.assertEqual(cells, view.local_cells) self.assertEqual(cells[0], view[1]) iterator = iter(view) self.assertEqual(1, next(iterator).id) self.assertEqual(3, next(iterator).id) with pytest.raises(StopIteration): next(iterator) self.assertEqual(2, len(view)) iterator = view.all() self.assertEqual(1, next(iterator).id) self.assertEqual(3, next(iterator).id) with pytest.raises(StopIteration): next(iterator) self.assertEqual(view.can_record("v"), pop_1.can_record("v")) self.assertEqual(view.conductance_based, pop_1.conductance_based) describe = view.describe() self.assertIn('PopulationView "pop_1"', describe) self.assertIn('parent : "pop_1"', describe) self.assertIn('size : 2', describe) self.assertIn('mask : [1, 3]', describe) self.assertEqual(pop_1.find_units("v"), view.find_units("v")) sim.end()
def create_grid(n, label, dx=1.0, dy=1.0): grid_structure = p.Grid2D(dx=dx, dy=dy, x0=0.0, y0=0.0) return p.Population(n * n, p.IF_curr_exp(**cell_params_lif), structure=grid_structure, label=label)
def set_initialize_between_runs(self): runtime1 = 5 runtime2 = 5 runtime3 = 5 p.setup(timestep=1.0) pop = p.Population(3, p.IF_curr_exp()) pop.record(['v']) self.assertEquals([-65, -65, -65], pop.initial_values["v"]) pop.initialize(v=-64) self.assertEquals([-64, -64, -64], pop.initial_values["v"]) p.run(runtime1) self.assertEquals([-64, -64, -64], pop.initial_values["v"]) pop.initialize(v=-62) self.assertEquals([-62, -62, -62], pop.initial_values["v"]) p.run(runtime2) self.assertEquals([-62, -62, -62], pop.initial_values["v"]) id_mixin = pop[1] id_mixin.initialize(v=-60) # v on not changed is now the current state not initial value self.assertNotEqual(-60, pop.initial_values["v"][0]) self.assertNotEqual(-62, pop.initial_values["v"][0]) self.assertEquals(-60, pop.initial_values["v"][1]) self.assertNotEqual(-60, pop.initial_values["v"][2]) self.assertNotEqual(-62, pop.initial_values["v"][2]) p.run(runtime3) p.reset() self.assertEquals([-64, -64, -64], pop.initial_values["v"]) pop.initialize(isyn_exc=-0.1) self.assertEquals([-64, -64, -64], pop.initial_values["v"]) p.run(runtime1) self.assertEquals([-64, -64, -64], pop.initial_values["v"]) view = pop[0:2] view.initialize(v=-63) self.assertEquals(-63, pop.initial_values["v"][0]) self.assertEquals(-63, pop.initial_values["v"][1]) # v on not changed is now the current state not initial value self.assertNotEqual(-63, pop.initial_values["v"][2]) self.assertNotEqual(-64, pop.initial_values["v"][2]) p.run(runtime2) neo = pop.get_data('v') p.end() v0 = neo.segments[0].filter(name='v')[0] self.assertListEqual(list(v0[0]), [-64, -64, -64]) self.assertListEqual(list(v0[runtime1]), [-62.0, -62, -62]) assert v0[runtime1 + runtime2][0] != -62.0 assert v0[runtime1 + runtime2][0] != -60.0 assert v0[runtime1 + runtime2][1] == -60.0 assert v0[runtime1 + runtime2][2] != -62.0 assert v0[runtime1 + runtime2][2] != -60.0 v1 = neo.segments[1].filter(name='v')[0] self.assertListEqual(list(v1[0]), [-64.0, -64, -64]) assert v1[runtime1][0] == -63.0 assert v1[runtime1][1] == -63.0 assert v1[runtime1][2] != -63.0 assert v1[runtime1][2] != -64.0
import spynnaker8 as sim import pyNN.utility.plotting as plot import matplotlib.pyplot as plt simtime = 500 n_neurons = 100 # Set up the simulation to use a 1ms time step. sim.setup(timestep=1) # Create a population of 100 presynaptic neurons. pre_pop = sim.Population(n_neurons, sim.IF_curr_exp(), label="presynaptic") # Create a spike source array population of 100 sources connected to the # presynaptic population. # Set the spikes in the arrays so that each spikes twice 200ms apart, # and that the first spike for each is 1ms after the first spike of the last # e.g. [[0, 200], [1, 201], ...] # (hint: you can do this with a list comprehension). spike_times = [[x+y for x in [0, 200]] for y in range(n_neurons)] print spike_times pre_input = sim.Population( n_neurons, sim.SpikeSourceArray(spike_times=spike_times), label="pre input") sim.Projection(pre_input, pre_pop, sim.OneToOneConnector(), synapse_type=sim.StaticSynapse(weight=5.0)) # Create a population of 100 postsynaptic neurons. post_pop = sim.Population(n_neurons, sim.IF_curr_exp(), label="postsynaptic") # Create a spike source array connected to the postsynaptic neurons all # spiking at 50ms.
def test_write_data_spec(): unittest_setup() # UGLY but the mock transceiver NEED generate_on_machine to be False AbstractGenerateConnectorOnMachine.generate_on_machine = say_false machine = virtual_machine(2, 2) p.setup(1.0) load_config() p.set_number_of_neurons_per_core(p.IF_curr_exp, 100) pre_pop = p.Population( 10, p.IF_curr_exp(), label="Pre", additional_parameters={ "splitter": SplitterAbstractPopulationVertexSlice()}) post_pop = p.Population( 10, p.IF_curr_exp(), label="Post", additional_parameters={ "splitter": SplitterAbstractPopulationVertexSlice()}) proj_one_to_one_1 = p.Projection( pre_pop, post_pop, p.OneToOneConnector(), p.StaticSynapse(weight=1.5, delay=1.0)) proj_one_to_one_2 = p.Projection( pre_pop, post_pop, p.OneToOneConnector(), p.StaticSynapse(weight=2.5, delay=2.0)) proj_all_to_all = p.Projection( pre_pop, post_pop, p.AllToAllConnector(allow_self_connections=False), p.StaticSynapse(weight=4.5, delay=4.0)) # spynnaker8.setup(timestep=1) # # Add an sdram so max SDRAM is high enough # SDRAM(10000) # # set_config("Simulation", "one_to_one_connection_dtcm_max_bytes", 40) # # placements = Placements() # pre_app_population = MockPopulation(10, "mock pop pre") # pre_app_vertex = SimpleTestVertex(10, label="pre") # pre_app_vertex.splitter = MockSplitter() # pre_app_vertex.splitter._called = True # pre_vertex_slice = Slice(0, 9) # # post_app_population = MockPopulation(10, "mock pop post") # pre_vertex = pre_app_vertex.create_machine_vertex( # pre_vertex_slice, None) # placements.add_placement(Placement(pre_vertex, 0, 0, 1)) # post_app_vertex = SimpleTestVertex(10, label="post") # post_app_vertex.splitter = MockSplitter() # post_app_vertex.splitter._called = True # post_vertex_slice = Slice(0, 9) # post_vertex = post_app_vertex.create_machine_vertex( # post_vertex_slice, None) # post_vertex_placement = Placement(post_vertex, 0, 0, 2) # placements.add_placement(post_vertex_placement) # delay_app_vertex = DelayExtensionVertex( # 10, 16, 51, pre_app_vertex, label="delay") # delay_app_vertex.set_new_n_delay_stages_and_delay_per_stage( # 16, 51) # delay_app_vertex.splitter = SplitterDelayVertexSlice( # pre_app_vertex.splitter) # delay_vertex = DelayExtensionMachineVertex( # resources_required=None, label="", constraints=[], # app_vertex=delay_app_vertex, vertex_slice=post_vertex_slice) # placements.add_placement(Placement(delay_vertex, 0, 0, 3)) # one_to_one_connector_1 = OneToOneConnector(None) # direct_synapse_information_1 = SynapseInformation( # one_to_one_connector_1, pre_app_population, post_app_population, # False, False, None, SynapseDynamicsStatic(), 0, True, 1.5, 1.0) # one_to_one_connector_1.set_projection_information( # direct_synapse_information_1) # one_to_one_connector_2 = OneToOneConnector(None) # direct_synapse_information_2 = SynapseInformation( # one_to_one_connector_2, pre_app_population, post_app_population, # False, False, None, SynapseDynamicsStatic(), 1, True, 2.5, 2.0) # one_to_one_connector_2.set_projection_information( # direct_synapse_information_2) # all_to_all_connector = AllToAllConnector(False) # all_to_all_synapse_information = SynapseInformation( # all_to_all_connector, pre_app_population, post_app_population, # False, False, None, SynapseDynamicsStatic(), 0, True, 4.5, 4.0) # all_to_all_connector.set_projection_information( # all_to_all_synapse_information) from_list_list = [(i, i, i, (i * 5) + 1) for i in range(10)] proj_from_list = p.Projection( pre_pop, post_pop, p.FromListConnector(from_list_list), p.StaticSynapse()) app_graph = globals_variables.get_simulator().original_application_graph context = { "ApplicationGraph": app_graph } with (injection_context(context)): delay_adder = DelaySupportAdder() delay_adder.__call__(app_graph) partitioner = SpynnakerSplitterPartitioner() machine_graph, _ = partitioner.__call__(app_graph, machine, 100) allocator = ZonedRoutingInfoAllocator() n_keys_mapper = EdgeToNKeysMapper() n_keys_map = n_keys_mapper.__call__(machine_graph) routing_info = allocator.__call__( machine_graph, n_keys_map, flexible=False) post_vertex = next(iter(post_pop._vertex.machine_vertices)) post_vertex_slice = post_vertex.vertex_slice post_vertex_placement = Placement(post_vertex, 0, 0, 3) temp_spec = tempfile.mktemp() spec = DataSpecificationGenerator(io.FileIO(temp_spec, "wb"), None) synaptic_matrices = SynapticMatrices( post_vertex_slice, n_synapse_types=2, all_single_syn_sz=10000, synaptic_matrix_region=1, direct_matrix_region=2, poptable_region=3, connection_builder_region=4) synaptic_matrices.write_synaptic_data( spec, post_pop._vertex.incoming_projections, all_syn_block_sz=10000, weight_scales=[32, 32], routing_info=routing_info) spec.end_specification() with io.FileIO(temp_spec, "rb") as spec_reader: executor = DataSpecificationExecutor(spec_reader, 20000) executor.execute() all_data = bytearray() all_data.extend(bytearray(executor.get_header())) all_data.extend(bytearray(executor.get_pointer_table(0))) for r in range(MAX_MEM_REGIONS): region = executor.get_region(r) if region is not None: all_data.extend(region.region_data) transceiver = MockTransceiverRawData(all_data) report_folder = mkdtemp() try: connections_1 = numpy.concatenate( synaptic_matrices.get_connections_from_machine( transceiver, post_vertex_placement, proj_one_to_one_1._projection_edge, proj_one_to_one_1._synapse_information)) # Check that all the connections have the right weight and delay assert len(connections_1) == post_vertex_slice.n_atoms assert all([conn["weight"] == 1.5 for conn in connections_1]) assert all([conn["delay"] == 1.0 for conn in connections_1]) connections_2 = numpy.concatenate( synaptic_matrices.get_connections_from_machine( transceiver, post_vertex_placement, proj_one_to_one_2._projection_edge, proj_one_to_one_2._synapse_information)) # Check that all the connections have the right weight and delay assert len(connections_2) == post_vertex_slice.n_atoms assert all([conn["weight"] == 2.5 for conn in connections_2]) assert all([conn["delay"] == 2.0 for conn in connections_2]) connections_3 = numpy.concatenate( synaptic_matrices.get_connections_from_machine( transceiver, post_vertex_placement, proj_all_to_all._projection_edge, proj_all_to_all._synapse_information)) # Check that all the connections have the right weight and delay assert len(connections_3) == 100 assert all([conn["weight"] == 4.5 for conn in connections_3]) assert all([conn["delay"] == 4.0 for conn in connections_3]) connections_4 = numpy.concatenate( synaptic_matrices.get_connections_from_machine( transceiver, post_vertex_placement, proj_from_list._projection_edge, proj_from_list._synapse_information)) # Check that all the connections have the right weight and delay assert len(connections_4) == len(from_list_list) list_weights = [values[2] for values in from_list_list] list_delays = [values[3] for values in from_list_list] assert all(list_weights == connections_4["weight"]) assert all(list_delays == connections_4["delay"]) finally: shutil.rmtree(report_folder, ignore_errors=True)
def do_run(plot): p.setup(timestep=1.0) cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -40.0 } # Parameters n = 6 weight_to_spike = 3.0 delay = 2 runtime = 200 # Network population pop_1 = p.Population(n, p.IF_curr_exp(**cell_params_lif), label='pop_1') pop_2 = p.Population(n/2, p.IF_curr_exp(**cell_params_lif), label='pop_2') # SpikeInjector injectionConnection = [(0, n/2)] spikeArray = {'spike_times': [[0]]} inj_pop = p.Population(1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1') # Projection for injector p.Projection(inj_pop, pop_1, p.FromListConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=delay)) # Index-based connectors index_based_exc = "(i+j)/"+str(n*(n-n/2.0)) index_based_exc2 = "2.0*(i+j)/"+str(n*(n-n/2.0)) index_based_inh = "(i+j)/"+str(n*(n+n/2.0)) print('index_based_exc: ', index_based_exc) print('index_based_exc2: ', index_based_exc2) exc_connector = p.IndexBasedProbabilityConnector( index_based_exc, allow_self_connections=True) inh_connector = p.IndexBasedProbabilityConnector( index_based_inh, allow_self_connections=False) exc_connector2 = p.IndexBasedProbabilityConnector( index_based_exc2, allow_self_connections=True) # Projections within populations p.Projection(pop_1, pop_1, exc_connector, p.StaticSynapse(weight=2.0, delay=5)) p.Projection(pop_1, pop_1, inh_connector, p.StaticSynapse(weight=1.5, delay=5)) p.Projection(pop_1, pop_2, exc_connector2, p.StaticSynapse(weight=1.5, delay=2)) pop_1.record(['v', 'spikes']) pop_2.record(['v', 'spikes']) p.run(runtime) v = pop_1.get_data('v') spikes = pop_1.get_data('spikes') v2 = pop_2.get_data('v') spikes2 = pop_2.get_data('spikes') if plot: Figure( # raster plot of the presynaptic neurons' spike times Panel(spikes.segments[0].spiketrains, yticks=True, markersize=2.0, xlim=(0, runtime), xticks=True), # membrane potential of the postsynaptic neurons Panel(v.segments[0].filter(name='v')[0], ylabel="Membrane potential pop 1 (mV)", data_labels=[pop_1.label], yticks=True, xlim=(0, runtime), xticks=True), # raster plot of the presynaptic neurons' spike times Panel(spikes2.segments[0].spiketrains, yticks=True, markersize=2.0, xlim=(0, runtime), xticks=True), # membrane potential of the postsynaptic neurons Panel(v2.segments[0].filter(name='v')[0], ylabel="Membrane potential pop 2 (mV)", data_labels=[pop_2.label], yticks=True, xlim=(0, runtime), xticks=True), title="Simple index-based probability connector", annotations="Simulated with {}".format(p.name()) ) plt.show() p.end() return v, spikes, v2, spikes2
for j in range(len(spikes0)): newEntry.append(spikes0[j] + i * 40.0 / 100.0) arrayEntries.append(newEntry) spikeArray = {'spike_times': arrayEntries} teachlist = list() for i in range(nSourceNeurons): teachlist.append(teachingSpikes) teachingSpikeArray = {'spike_times': teachlist} populations.append( p.Population(nSourceNeurons, p.SpikeSourceArray(**spikeArray), label='excit_pop_ss_array')) # 0 populations.append( p.Population(nInhibNeurons, p.IF_curr_exp(**cell_params_lif), label='inhib_pop')) # 1 populations.append( p.Population(nExcitNeurons, p.IF_curr_exp(**cell_params_lif), label='excit_pop')) # 2 populations.append( p.Population(nTeachNeurons, p.SpikeSourceArray(**teachingSpikeArray), label='teaching_ss_array')) # 3 stdp_model = p.STDPMechanism( timing_dependence=p.extra_models.RecurrentRule(accumulator_depression=-6, accumulator_potentiation=3, mean_pre_window=10.0, mean_post_window=10.0,
def test_pop_based_master_pop_table_standard(undelayed_indices_connected, delayed_indices_connected, n_pre_neurons, neurons_per_core, expect_app_keys, max_delay): unittest_setup() machine = virtual_machine(12, 12) # Build a from list connector with the delays we want connections = [] connections.extend([(i * neurons_per_core + j, j, 0, 10) for i in undelayed_indices_connected for j in range(100)]) connections.extend([(i * neurons_per_core + j, j, 0, max_delay) for i in delayed_indices_connected for j in range(100)]) # Make simple source and target, where the source has 1000 atoms # split into 10 vertices (100 each) and the target has 100 atoms in # a single vertex p.setup(1.0) post_pop = p.Population(100, p.IF_curr_exp(), label="Post", additional_parameters={ "splitter": SplitterAbstractPopulationVertexSlice() }) p.IF_curr_exp.set_model_max_atoms_per_core(neurons_per_core) pre_pop = p.Population(n_pre_neurons, p.IF_curr_exp(), label="Pre", additional_parameters={ "splitter": SplitterAbstractPopulationVertexSlice() }) p.Projection(pre_pop, post_pop, p.FromListConnector(connections), p.StaticSynapse()) app_graph = globals_variables.get_simulator().original_application_graph context = {"ApplicationGraph": app_graph} with (injection_context(context)): delay_support_adder(app_graph) machine_graph, _ = spynnaker_splitter_partitioner( app_graph, machine, 100) allocator = ZonedRoutingInfoAllocator() n_keys_map = edge_to_n_keys_mapper(machine_graph) routing_info = allocator.__call__(machine_graph, n_keys_map, flexible=False) post_mac_vertex = next(iter(post_pop._vertex.machine_vertices)) post_vertex_slice = post_mac_vertex.vertex_slice # Generate the data temp_spec = tempfile.mktemp() spec = DataSpecificationGenerator(io.FileIO(temp_spec, "wb"), None) synaptic_matrices = SynapticMatrices(post_vertex_slice, n_synapse_types=2, all_single_syn_sz=10000, synaptic_matrix_region=1, direct_matrix_region=2, poptable_region=3, connection_builder_region=4) synaptic_matrices.write_synaptic_data( spec, post_pop._vertex.incoming_projections, all_syn_block_sz=1000000, weight_scales=[32, 32], routing_info=routing_info) with io.FileIO(temp_spec, "rb") as spec_reader: executor = DataSpecificationExecutor(spec_reader, SDRAM.max_sdram_found) executor.execute() # Read the population table and check entries region = executor.get_region(3) mpop_data = numpy.frombuffer(region.region_data, dtype="uint8").view("uint32") n_entries = mpop_data[0] n_addresses = mpop_data[1] # Compute how many entries and addresses there should be expected_n_entries = 0 expected_n_addresses = 0 if expect_app_keys: # Always one for undelayed, maybe one for delayed if present n_app_entries = 1 + int(bool(delayed_indices_connected)) expected_n_entries += n_app_entries # 2 address list entries for each entry, as there is also extra_info expected_n_addresses += 2 * n_app_entries # If both delayed and undelayed, there is an entry for each incoming # machine edge elif delayed_indices_connected and undelayed_indices_connected: all_connected = set(undelayed_indices_connected) all_connected.update(delayed_indices_connected) expected_n_entries += len(all_connected) expected_n_addresses += len(all_connected) # If there are only undelayed indices, there is an entry for each elif undelayed_indices_connected: expected_n_entries += len(undelayed_indices_connected) expected_n_addresses += len(undelayed_indices_connected) # If there are only delayed indices, there are two entries for each because # the undelayed ones are still connected else: expected_n_entries += 2 * len(delayed_indices_connected) expected_n_addresses += 2 * len(delayed_indices_connected) assert (n_entries == expected_n_entries) assert (n_addresses == expected_n_addresses)
def run_script(simtime, n_neurons, run_split=1, record_spikes=False, spike_rate=None, spike_rec_indexes=None, spike_get_indexes=None, record_v=False, v_rate=None, v_rec_indexes=None, v_get_indexes=None, record_exc=False, exc_rate=None, exc_rec_indexes=None, exc_get_indexes=None, record_inh=False, inh_rate=None, inh_rec_indexes=None, inh_get_indexes=None, file_prefix=""): sim.setup(timestep=1) pop_1 = sim.Population(n_neurons, sim.IF_curr_exp(), label="pop_1") input1 = sim.Population(1, sim.SpikeSourceArray(spike_times=[0]), label="input") sim.Projection(input1, pop_1, sim.AllToAllConnector(), synapse_type=sim.StaticSynapse(weight=5, delay=1)) input2 = sim.Population(n_neurons, sim.SpikeSourcePoisson(rate=100.0), label="Stim_Exc", additional_parameters={"seed": 1}) sim.Projection(input2, pop_1, sim.OneToOneConnector(), synapse_type=sim.StaticSynapse(weight=5, delay=1)) if record_spikes: if spike_rec_indexes is None: pop_1.record(['spikes'], sampling_interval=spike_rate) else: view = PopulationView(pop_1, spike_rec_indexes) view.record(['spikes'], sampling_interval=spike_rate) if record_v: if v_rec_indexes is None: pop_1.record(['v'], sampling_interval=v_rate) else: view = PopulationView(pop_1, v_rec_indexes) view.record(['v'], sampling_interval=v_rate) if record_exc: if exc_rec_indexes is None: pop_1.record(['gsyn_exc'], sampling_interval=exc_rate) else: view = PopulationView(pop_1, exc_rec_indexes) view.record(['gsyn_exc'], sampling_interval=exc_rate) if record_inh: if inh_rec_indexes is None: pop_1.record(['gsyn_inh'], sampling_interval=inh_rate) else: view = PopulationView(pop_1, inh_rec_indexes) view.record(['gsyn_inh'], sampling_interval=inh_rate) for i in range(run_split): sim.run(simtime / run_split) if record_spikes: if spike_get_indexes is None: neo = pop_1.get_data("spikes") else: view = PopulationView(pop_1, spike_get_indexes) neo = view.get_data("spikes") spikes = neo.segments[0].spiketrains spike_file = os.path.join(current_file_path, file_prefix + "spikes.csv") write_spikes(spikes, spike_file) else: spikes = None if record_v: if v_get_indexes is None: neo = pop_1.get_data("v") else: view = PopulationView(pop_1, v_get_indexes) neo = view.get_data("v") v = neo.segments[0].filter(name='v')[0] v_file = os.path.join(current_file_path, file_prefix + "v.csv") numpy.savetxt(v_file, v, delimiter=',') else: v = None if record_exc: if exc_get_indexes is None: neo = pop_1.get_data('gsyn_exc') else: view = PopulationView(pop_1, exc_get_indexes) neo = view.get_data('gsyn_exc') exc = neo.segments[0].filter(name='gsyn_exc')[0] exc_file = os.path.join(current_file_path, file_prefix + "exc.csv") numpy.savetxt(exc_file, exc, delimiter=',') else: exc = None if record_inh: if inh_get_indexes is None: neo = pop_1.get_data('gsyn_inh') else: view = PopulationView(pop_1, inh_get_indexes) neo = view.get_data('gsyn_inh') inh = neo.segments[0].filter(name='gsyn_inh')[0] inh_file = os.path.join(current_file_path, file_prefix + "inh.csv") numpy.savetxt(inh_file, inh, delimiter=',') else: inh = None sim.end() return spikes, v, exc, inh
def do_run(plot): p.setup(timestep=1.0) # n_pop = 2 # 60 nNeurons = 10 # 100 rng = p.NumpyRNG(seed=28374) # rng1 = p.NumpyRNG(seed=12345) # delay_distr = p.RandomDistribution('uniform', [5, 10], rng) # weight_distr = p.RandomDistribution('uniform', [0, 2], rng1) v_distr = p.RandomDistribution('uniform', [-55, -95], rng) v_inits = [] for i in range(nNeurons): v_inits.append(v_distr.next()) cell_params_lif_in = { 'tau_m': 32, 'v_init': -80, 'v_rest': -75, 'v_reset': -95, 'v_thresh': -55, 'tau_syn_E': 5, 'tau_syn_I': 10, 'tau_refrac': 20, 'i_offset': 1 } cell_params_lif = { 'tau_m': 32, 'v_init': -80, 'v_rest': -75, 'v_reset': -95, 'v_thresh': -55, 'tau_syn_E': 5, 'tau_syn_I': 10, 'tau_refrac': 5, 'i_offset': 0 } cell_params_ext_dev = {'port': 34567} populations = list() projections = list() weight_to_spike = 20 populations.append( p.Population(nNeurons, p.IF_curr_exp(**cell_params_lif_in), label='pop_%d' % 0)) populations[0].initialize(v=v_distr) p.external_devices.activate_live_output_for(populations[0]) pop_external = p.Population( nNeurons, p.external_devices.SpikeInjector(**cell_params_ext_dev), label='Babel_Dummy') populations.append( p.Population(nNeurons, p.IF_curr_exp(**cell_params_lif), label='pop_%d' % 1)) projections.append( p.Projection(pop_external, populations[1], p.OneToOneConnector(), p.StaticSynapse(weight=weight_to_spike, delay=10))) # populations[0].record_v() # at the moment is only possible to observe one population per core populations[1].record(['v']) for pop in populations: pop.record(['spikes'], to_file=False) # sends spike to the Monitoring application # populations[i].record_variable('rate', save_to='eth') # sends spike to the Monitoring application p.run(10000) # retrieving spike results and plotting... id_accumulator = 0 shapes = [] if plot: import matplotlib.pyplot as p_plot for pop_o in populations: data = numpy.asarray( neo_convertor.convert_spikes(pop_o.get_data('spikes'))) print(data.shape) shapes.append(data.shape) if plot: p_plot.scatter(data[:, 0], data[:, 1] + id_accumulator, color='green', s=1) id_accumulator = id_accumulator + pop_o.size if plot: p_plot.show() return shapes
import spynnaker8 as sim import pyNN.utility.plotting as plot import matplotlib.pyplot as plt sim.setup(timestep=1.0) sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 100) pop_1 = sim.Population(1, sim.IF_curr_exp(), label="pop_1") input = sim.Population(1, sim.SpikeSourceArray(spike_times=[0]), label="input") input_proj = sim.Projection(input, pop_1, sim.OneToOneConnector(), synapse_type=sim.StaticSynapse(weight=5, delay=1)) pop_1.record(["spikes", "v"]) simtime = 10 sim.run(simtime) neo = pop_1.get_data(variables=["spikes", "v"]) spikes = neo.segments[0].spiketrains print spikes v = neo.segments[0].filter(name='v')[0] print v sim.end() plot.Figure( # plot voltage for first ([0]) neuron plot.Panel(v, ylabel="Membrane potential (mV)", data_labels=[pop_1.label], yticks=True, xlim=(0, simtime)),
def do_run(): # boolean allowing users to use python or c vis using_c_vis = False # initial call to set up the front end (pynn requirement) Frontend.setup(timestep=1.0, min_delay=1.0, max_delay=144.0) # neurons per population and the length of runtime in ms for the # simulation, as well as the expected weight each spike will contain n_neurons = 100 run_time = 8000 weight_to_spike = 2.0 # neural parameters of the ifcur model used to respond to injected spikes. # (cell params for a synfire chain) cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0 } ################################## # Parameters for the injector population. This is the minimal set of # parameters required, which is for a set of spikes where the key is not # important. Note that a virtual key *will* be assigned to the population, # and that spikes sent which do not match this virtual key will be dropped; # however, if spikes are sent using 16-bit keys, they will automatically be # made to match the virtual key. The virtual key assigned can be obtained # from the database. ################################## cell_params_spike_injector = { # The port on which the spiNNaker machine should listen for packets. # Packets to be injected should be sent to this port on the spiNNaker # machine 'port': 12345, } ################################## # Parameters for the injector population. Note that each injector needs to # be given a different port. The virtual key is assigned here, rather than # being allocated later. As with the above, spikes injected need to match # this key, and this will be done automatically with 16-bit keys. ################################## cell_params_spike_injector_with_key = { # The port on which the spiNNaker machine should listen for packets. # Packets to be injected should be sent to this port on the spiNNaker # machine 'port': 12346, # This is the base key to be used for the injection, which is used to # allow the keys to be routed around the spiNNaker machine. This # assignment means that 32-bit keys must have the high-order 16-bit # set to 0x7; This will automatically be prepended to 16-bit keys. 'virtual_key': 0x70000, } # create synfire populations (if cur exp) pop_forward = Frontend.Population(n_neurons, Frontend.IF_curr_exp(**cell_params_lif), label='pop_forward') pop_backward = Frontend.Population(n_neurons, Frontend.IF_curr_exp(**cell_params_lif), label='pop_backward') # Create injection populations injector_forward = Frontend.Population( n_neurons, Frontend.external_devices.SpikeInjector(), additional_parameters=cell_params_spike_injector_with_key, label='spike_injector_forward') injector_backward = Frontend.Population( n_neurons, Frontend.external_devices.SpikeInjector(), additional_parameters=cell_params_spike_injector, label='spike_injector_backward') # Create a connection from the injector into the populations Frontend.Projection(injector_forward, pop_forward, Frontend.OneToOneConnector(), Frontend.StaticSynapse(weight=weight_to_spike)) Frontend.Projection(injector_backward, pop_backward, Frontend.OneToOneConnector(), Frontend.StaticSynapse(weight=weight_to_spike)) # Synfire chain connection where each neuron is connected to next neuron # NOTE: there is no recurrent connection so that each chain stops once it # reaches the end loop_forward = list() loop_backward = list() for i in range(0, n_neurons - 1): loop_forward.append((i, (i + 1) % n_neurons, weight_to_spike, 3)) loop_backward.append(((i + 1) % n_neurons, i, weight_to_spike, 3)) Frontend.Projection(pop_forward, pop_forward, Frontend.FromListConnector(loop_forward), Frontend.StaticSynapse(weight=weight_to_spike, delay=3)) Frontend.Projection(pop_backward, pop_backward, Frontend.FromListConnector(loop_backward), Frontend.StaticSynapse(weight=weight_to_spike, delay=3)) # record spikes from the synfire chains so that we can read off valid # results in a safe way afterwards, and verify the behaviour pop_forward.record(['spikes']) pop_backward.record(['spikes']) # Activate the sending of live spikes Frontend.external_devices.activate_live_output_for( pop_forward, database_notify_host="localhost", database_notify_port_num=19996) Frontend.external_devices.activate_live_output_for( pop_backward, database_notify_host="localhost", database_notify_port_num=19996) # Set up the live connection for sending spikes live_spikes_connection_send = \ Frontend.external_devices.SpynnakerLiveSpikesConnection( receive_labels=None, local_port=NOTIFY_PORT, send_labels=["spike_injector_forward", "spike_injector_backward"]) # Set up callbacks to occur at initialisation live_spikes_connection_send.add_init_callback( "spike_injector_forward", init_pop) live_spikes_connection_send.add_init_callback( "spike_injector_backward", init_pop) # Set up callbacks to occur at the start of simulation live_spikes_connection_send.add_start_resume_callback( "spike_injector_forward", send_input_forward) live_spikes_connection_send.add_start_resume_callback( "spike_injector_backward", send_input_backward) live_spikes_connection_receive = None if not using_c_vis: # if not using the c visualiser, then a new spynnaker live spikes # connection is created to define that there is a python function which # receives the spikes. live_spikes_connection_receive = \ Frontend.external_devices.SpynnakerLiveSpikesConnection( receive_labels=["pop_forward", "pop_backward"], local_port=19996, send_labels=None) # Set up callbacks to occur when spikes are received live_spikes_connection_receive.add_receive_callback( "pop_forward", receive_spikes) live_spikes_connection_receive.add_receive_callback( "pop_backward", receive_spikes) # Run the simulation on spiNNaker Frontend.run(run_time) Frontend.run(run_time) # Retrieve spikes from the synfire chain population spikes_forward = neo_convertor.convert_spikes( pop_forward.get_data('spikes')) spikes_backward = neo_convertor.convert_spikes( pop_backward.get_data('spikes')) # Clear data structures on spiNNaker to leave the machine in a clean state # for future executions Frontend.end() return (spikes_forward, spikes_backward)
import spynnaker8 as sim from pyNN.utility.plotting import Figure, Panel import matplotlib.pyplot as plt sim.setup(timestep=1.0, min_delay=1.0, max_delay=4.0) delta_cell = sim.Population(1, sim.extra_models.IFCurDelta(**{ 'i_offset': 0.1, 'tau_refrac': 3.0, 'v_thresh': -51.0, 'v_reset': -70.0})) exp_cell = sim.Population(1, sim.IF_curr_exp(**{ 'i_offset': 0.1, 'tau_refrac': 3.0, 'v_thresh': -51.0, 'v_reset': -70.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0})) spike_sourceE = sim.Population(1, sim.SpikeSourceArray(**{ 'spike_times': [float(i) for i in range(5, 105, 10)]})) spike_sourceI = sim.Population(1, sim.SpikeSourceArray(**{ 'spike_times': [float(i) for i in range(155, 255, 10)]})) sim.Projection(spike_sourceE, exp_cell, sim.OneToOneConnector(), synapse_type=sim.StaticSynapse(weight=1.5, delay=2.0), receptor_type='excitatory') sim.Projection(spike_sourceI, exp_cell,
def __init__(self): # initial call to set up the front end (pynn requirement) Frontend.setup(timestep=1.0, min_delay=1.0, max_delay=144.0) use_c_visualiser = True use_spike_injector = True # neurons per population and the length of runtime in ms for the # simulation, as well as the expected weight each spike will contain self.n_neurons = 100 # set up gui p = None if use_spike_injector: from multiprocessing import Process from multiprocessing import Event ready = Event() p = Process(target=GUI, args=[self.n_neurons, ready]) p.start() ready.wait() # different runtimes for demostration purposes run_time = None if not use_c_visualiser and not use_spike_injector: run_time = 1000 elif use_c_visualiser and not use_spike_injector: run_time = 10000 elif use_c_visualiser and use_spike_injector: run_time = 100000 elif not use_c_visualiser and use_spike_injector: run_time = 10000 weight_to_spike = 2.0 # neural parameters of the IF_curr model used to respond to injected # spikes. # (cell params for a synfire chain) cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0 } ################################## # Parameters for the injector population. This is the minimal set of # parameters required, which is for a set of spikes where the key is # not important. Note that a virtual key *will* be assigned to the # population, and that spikes sent which do not match this virtual key # will be dropped; however, if spikes are sent using 16-bit keys, they # will automatically be made to match the virtual key. The virtual # key assigned can be obtained from the database. ################################## cell_params_spike_injector = { # The port on which the spiNNaker machine should listen for # packets. Packets to be injected should be sent to this port on # the spiNNaker machine 'port': 12345 } ################################## # Parameters for the injector population. Note that each injector # needs to be given a different port. The virtual key is assigned # here, rather than being allocated later. As with the above, spikes # injected need to match this key, and this will be done automatically # with 16-bit keys. ################################## cell_params_spike_injector_with_key = { # The port on which the spiNNaker machine should listen for # packets. Packets to be injected should be sent to this port on # the spiNNaker machine 'port': 12346, # This is the base key to be used for the injection, which is used # to allow the keys to be routed around the spiNNaker machine. # This assignment means that 32-bit keys must have the high-order # 16-bit set to 0x7; This will automatically be prepended to # 16-bit keys. 'virtual_key': 0x70000 } # create synfire populations (if cur exp) pop_forward = Frontend.Population( self.n_neurons, Frontend.IF_curr_exp(**cell_params_lif), label='pop_forward') pop_backward = Frontend.Population( self.n_neurons, Frontend.IF_curr_exp(**cell_params_lif), label='pop_backward') # Create injection populations injector_forward = None injector_backward = None if use_spike_injector: injector_forward = Frontend.Population( self.n_neurons, Frontend.external_devices.SpikeInjector( **cell_params_spike_injector_with_key), label='spike_injector_forward') injector_backward = Frontend.Population( self.n_neurons, Frontend.external_devices.SpikeInjector( **cell_params_spike_injector), label='spike_injector_backward') else: spike_times = [] for _ in range(0, self.n_neurons): spike_times.append([]) spike_times[0] = [0] spike_times[20] = [(run_time / 100) * 20] spike_times[40] = [(run_time / 100) * 40] spike_times[60] = [(run_time / 100) * 60] spike_times[80] = [(run_time / 100) * 80] cell_params_forward = {'spike_times': spike_times} spike_times_backwards = [] for _ in range(0, self.n_neurons): spike_times_backwards.append([]) spike_times_backwards[0] = [(run_time / 100) * 80] spike_times_backwards[20] = [(run_time / 100) * 60] spike_times_backwards[40] = [(run_time / 100) * 40] spike_times_backwards[60] = [(run_time / 100) * 20] spike_times_backwards[80] = [0] cell_params_backward = {'spike_times': spike_times_backwards} injector_forward = Frontend.Population( self.n_neurons, Frontend.SpikeSourceArray( **cell_params_forward), label='spike_injector_forward') injector_backward = Frontend.Population( self.n_neurons, Frontend.SpikeSourceArray( **cell_params_backward), label='spike_injector_backward') # Create a connection from the injector into the populations Frontend.Projection( injector_forward, pop_forward, Frontend.OneToOneConnector(), Frontend.StaticSynapse(weight=weight_to_spike)) Frontend.Projection( injector_backward, pop_backward, Frontend.OneToOneConnector(), Frontend.StaticSynapse(weight=weight_to_spike)) # Synfire chain connections where each neuron is connected to its next # neuron # NOTE: there is no recurrent connection so that each chain stops once # it reaches the end loop_forward = list() loop_backward = list() for i in range(0, self.n_neurons - 1): loop_forward.append((i, (i + 1) % self.n_neurons, weight_to_spike, 3)) loop_backward.append(((i + 1) % self.n_neurons, i, weight_to_spike, 3)) Frontend.Projection(pop_forward, pop_forward, Frontend.FromListConnector(loop_forward)) Frontend.Projection(pop_backward, pop_backward, Frontend.FromListConnector(loop_backward)) # record spikes from the synfire chains so that we can read off valid # results in a safe way afterwards, and verify the behavior pop_forward.record('spikes') pop_backward.record('spikes') # Activate the sending of live spikes Frontend.external_devices.activate_live_output_for( pop_forward, database_notify_host="localhost", database_notify_port_num=19996) Frontend.external_devices.activate_live_output_for( pop_backward, database_notify_host="localhost", database_notify_port_num=19996) if not use_c_visualiser: # if not using the c visualiser, then a new spynnaker live spikes # connection is created to define that there are python code which # receives the outputted spikes. live_spikes_connection_receive = \ Frontend.external_devices.SpynnakerLiveSpikesConnection( receive_labels=["pop_forward", "pop_backward"], local_port=19999, send_labels=None) # Set up callbacks to occur when spikes are received live_spikes_connection_receive.add_receive_callback( "pop_forward", receive_spikes) live_spikes_connection_receive.add_receive_callback( "pop_backward", receive_spikes) # Run the simulation on spiNNaker Frontend.run(run_time) # Retrieve spikes from the synfire chain population spikes_forward = pop_forward.get_data('spikes') spikes_backward = pop_backward.get_data('spikes') # Clear data structures on spiNNaker to leave the machine in a clean # state for future executions Frontend.end() if use_spike_injector: p.join() Figure( # raster plot of the presynaptic neuron spike times Panel(spikes_forward.segments[0].spiketrains, yticks=True, markersize=0.2, xlim=(0, run_time)), Panel(spikes_backward.segments[0].spiketrains, yticks=True, markersize=0.2, xlim=(0, run_time)), title="Simple synfire chain example with injected spikes", annotations="Simulated with {}".format(Frontend.name()) ) plt.show()
def do_run(Neurons, sim_time, record, seed=None): """ :param Neurons: Number of Neurons :type Neurons: int :param sim_time: times for run :type sim_time: int :param record: If True will aks for spikes to be recorded :type record: bool """ g = 5.0 eta = 2.0 delay = 2.0 epsilon = 0.1 tau_m = 20.0 # ms (20ms will give a FR of 20hz) tau_ref = 2.0 v_reset = 10.0 v_th = 20.0 v_rest = 0.0 tau_syn = 1.0 n_e = int(round(Neurons * 0.8)) n_i = int(round(Neurons * 0.2)) c_e = n_e * 0.1 # Excitatory and inhibitory weights j_e = 0.1 j_i = -g * j_e # The firing rate of a neuron in the external pop # is the product of eta time the threshold rate # the steady state firing rate which is # needed to bring a neuron to threshold. nu_ex = eta * v_th / (j_e * c_e * tau_m) # population rate of the whole external population. # With CE neurons the pop rate is simply the product # nu_ex*c_e the factor 1000.0 changes the units from # spikes per ms to spikes per second. p_rate = 1000.0 * nu_ex * c_e print("Rate is: %f HZ" % (p_rate / 1000)) # Neural Parameters pynn.setup(timestep=1.0, min_delay=1.0, max_delay=16.0) # Makes it easy to scale up the number of cores pynn.set_number_of_neurons_per_core(pynn.IF_curr_exp, 100) pynn.set_number_of_neurons_per_core(pynn.SpikeSourcePoisson, 100) exc_cell_params = { 'cm': 1.0, # pf 'tau_m': tau_m, 'tau_refrac': tau_ref, 'v_rest': v_rest, 'v_reset': v_reset, 'v_thresh': v_th, 'tau_syn_E': tau_syn, 'tau_syn_I': tau_syn, 'i_offset': 0.9 } inh_cell_params = { 'cm': 1.0, # pf 'tau_m': tau_m, 'tau_refrac': tau_ref, 'v_rest': v_rest, 'v_reset': v_reset, 'v_thresh': v_th, 'tau_syn_E': tau_syn, 'tau_syn_I': tau_syn, 'i_offset': 0.9 } # Set-up pynn Populations e_pop = pynn.Population(n_e, pynn.IF_curr_exp(**exc_cell_params), label="e_pop") i_pop = pynn.Population(n_i, pynn.IF_curr_exp, inh_cell_params, label="i_pop") if seed is None: poisson_ext_e = pynn.Population(n_e, pynn.SpikeSourcePoisson(rate=10.0), label="Poisson_pop_E") poisson_ext_i = pynn.Population(n_i, pynn.SpikeSourcePoisson(rate=10.0), label="Poisson_pop_I") else: poisson_ext_e = pynn.Population(n_e, pynn.SpikeSourcePoisson(rate=10.0, seed=seed), label="Poisson_pop_E") poisson_ext_i = pynn.Population(n_i, pynn.SpikeSourcePoisson(rate=10.0, seed=seed + 1), label="Poisson_pop_I") # Connectors e_conn = pynn.FixedProbabilityConnector(epsilon) i_conn = pynn.FixedProbabilityConnector(epsilon) # Use random delays for the external noise and # set the initial membrane voltage below the resting potential # to avoid the overshoot of activity in the beginning of the simulation rng = NumpyRNG(seed=seed) delay_distr = RandomDistribution('uniform', [1.0, 16.0], rng=rng) ext_conn = pynn.OneToOneConnector() uniform_distr = RandomDistribution('uniform', [-10, 0], rng=rng) e_pop.initialize(v=uniform_distr) i_pop.initialize(v=uniform_distr) # Projections pynn.Projection(presynaptic_population=e_pop, postsynaptic_population=e_pop, connector=e_conn, receptor_type="excitatory", synapse_type=pynn.StaticSynapse(weight=j_e, delay=delay_distr)) pynn.Projection(presynaptic_population=i_pop, postsynaptic_population=e_pop, connector=i_conn, receptor_type="inhibitory", synapse_type=pynn.StaticSynapse(weight=j_i, delay=delay)) pynn.Projection(presynaptic_population=e_pop, postsynaptic_population=i_pop, connector=e_conn, receptor_type="excitatory", synapse_type=pynn.StaticSynapse(weight=j_e, delay=delay_distr)) pynn.Projection(presynaptic_population=i_pop, postsynaptic_population=i_pop, connector=i_conn, receptor_type="inhibitory", synapse_type=pynn.StaticSynapse(weight=j_i, delay=delay)) pynn.Projection(presynaptic_population=poisson_ext_e, postsynaptic_population=e_pop, connector=ext_conn, receptor_type="excitatory", synapse_type=pynn.StaticSynapse(weight=j_e * 10, delay=delay_distr)) pynn.Projection(presynaptic_population=poisson_ext_i, postsynaptic_population=i_pop, connector=ext_conn, receptor_type="excitatory", synapse_type=pynn.StaticSynapse(weight=j_e * 10, delay=delay_distr)) # Record stuff if record: e_pop.record('spikes') poisson_ext_e.record('spikes') pynn.run(sim_time) esp = None s = None if record: esp = e_pop.get_data('spikes') s = poisson_ext_e.get_data('spikes') pynn.end() return esp, s, n_e
def potentiation_and_depression(self): p.setup(1) runtime = 100 initial_run = 1000 # to negate any initial conditions # STDP parameters a_plus = 0.01 a_minus = 0.01 tau_plus = 20 tau_minus = 20 plastic_delay = 3 initial_weight = 2.5 max_weight = 5 min_weight = 0 pre_spikes = [10, 50] extra_spikes = [30] for i in range(len(pre_spikes)): pre_spikes[i] += initial_run for i in range(len(extra_spikes)): extra_spikes[i] += initial_run # Spike source to send spike via plastic synapse pre_pop = p.Population(1, p.SpikeSourceArray, {'spike_times': pre_spikes}, label="pre") # Spike source to send spike via static synapse to make # post-plastic-synapse neuron fire extra_pop = p.Population(1, p.SpikeSourceArray, {'spike_times': extra_spikes}, label="extra") # Post-plastic-synapse population post_pop = p.Population(1, p.IF_curr_exp(), label="post") # Create projections p.Projection(pre_pop, post_pop, p.OneToOneConnector(), p.StaticSynapse(weight=5.0, delay=1), receptor_type="excitatory") p.Projection(extra_pop, post_pop, p.OneToOneConnector(), p.StaticSynapse(weight=5.0, delay=1), receptor_type="excitatory") syn_plas = p.STDPMechanism( timing_dependence=p.SpikePairRule(tau_plus=tau_plus, tau_minus=tau_minus, A_plus=a_plus, A_minus=a_minus), weight_dependence=p.AdditiveWeightDependence(w_min=min_weight, w_max=max_weight), weight=initial_weight, delay=plastic_delay) plastic_synapse = p.Projection(pre_pop, post_pop, p.OneToOneConnector(), synapse_type=syn_plas, receptor_type='excitatory') # Record the spikes post_pop.record("spikes") # Run p.run(initial_run + runtime) # Get the weights weights = plastic_synapse.get('weight', 'list', with_address=False) # Get the spikes post_spikes = numpy.array( post_pop.get_data('spikes').segments[0].spiketrains[0].magnitude) # End the simulation as all information gathered p.end() # Get the spikes and time differences that will be considered by # the simulation (as the last pre-spike will be considered differently) last_pre_spike = pre_spikes[-1] considered_post_spikes = post_spikes[post_spikes < last_pre_spike] potentiation_time_diff = numpy.ravel( numpy.subtract.outer(considered_post_spikes + plastic_delay, pre_spikes[:-1])) potentiation_times = ( potentiation_time_diff[potentiation_time_diff > 0] * -1) depression_time_diff = numpy.ravel( numpy.subtract.outer(considered_post_spikes + plastic_delay, pre_spikes)) depression_times = depression_time_diff[depression_time_diff < 0] # Work out the weight according to the rules potentiations = max_weight * a_plus * numpy.exp( (potentiation_times / tau_plus)) depressions = max_weight * a_minus * numpy.exp( (depression_times / tau_minus)) new_weight_exact = \ initial_weight + numpy.sum(potentiations) - numpy.sum(depressions) # print("Pre neuron spikes at: {}".format(pre_spikes)) # print("Post-neuron spikes at: {}".format(post_spikes)) target_spikes = [1014, 1032, 1053] self.assertListEqual(list(post_spikes), target_spikes) # print("Potentiation time differences: {}".format(potentiation_times)) # print("Depression time differences: {}".format(depression_times)) # print("Potentiation: {}".format(potentiations)) # print("Depressions: {}".format(depressions)) # print("New weight exact: {}".format(new_weight_exact)) # print("New weight SpiNNaker: {}".format(weights)) self.assertTrue(numpy.allclose(weights, new_weight_exact, rtol=0.001))
def run_script(): p.setup(1.0) p.set_number_of_neurons_per_core(p.IF_curr_exp, 3) inp = p.Population(10, p.SpikeSourceArray(spike_times=[1.0]), label="SpikeSourceArray") out = p.Population(10, p.IF_curr_exp(), label="IF_curr_exp") out.record("spikes") param_projections = [ (1.0, 1.0), (RandomDistribution("uniform", low=1.0, high=10.0), 2.0), (3.0, 17.0), (4.0, RandomDistribution("normal", mu=22.0, sigma=10.0)), (5.0, RandomDistribution("normal_clipped", mu=22.0, sigma=10.0, low=5.0, high=32.0)), (6.0, RandomDistribution("normal_clipped_to_boundary", mu=14.0, sigma=5.0, low=6.0, high=16.0)), (7.0, RandomDistribution("exponential", beta=2.0)), ] connectors = [ p.OneToOneConnector, p.AllToAllConnector, functools.partial(p.AllToAllConnector, allow_self_connections=False), functools.partial(p.FixedProbabilityConnector, 0.5), functools.partial(p.FixedTotalNumberConnector, 50, with_replacement=True), functools.partial(p.FixedTotalNumberConnector, 20, with_replacement=False) ] projs = list() for weight, delay in param_projections: for connector in connectors: conn = connector() projs.append( (weight, delay, conn, False, p.Projection(inp, out, conn, p.StaticSynapse(weight=weight, delay=delay)))) projs.append((weight, delay, conn, True, p.Projection( inp, out, conn, p.STDPMechanism(p.SpikePairRule(), p.AdditiveWeightDependence(), weight=weight, delay=delay)))) p.run(10) for weight, delay, connector, is_stdp, proj in projs: weights = proj.get("weight", "list", with_address=False) delays = proj.get("delay", "list", with_address=False) if not is_stdp: check_params(weight, weights) check_params(delay, delays) p.end()
def do_run(nNeurons, n_pops, neurons_per_core, runtime=25000): """ Runs the script Does the run based on the parameters :param nNeurons: Number of Neurons in chain :type nNeurons: int :param n_pops: Number of populations :type n_pops: int :param neurons_per_core: Number of neurons per core :type neurons_per_core: int :param runtime: time to run the script for :type runtime: int """ p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0) p.set_number_of_neurons_per_core(p.IF_curr_exp, neurons_per_core) cell_params_lif = { 'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0 } populations = list() projections = list() weight_to_spike = 2.0 delay = 1 connections = list() for i in range(0, nNeurons - 1): singleConnection = (i, i + 1, weight_to_spike, delay) connections.append(singleConnection) pop_jump_connection = [(nNeurons - 1, 0, weight_to_spike, 1)] injectionConnection = [(0, 0, weight_to_spike, 1)] spikeArray = {'spike_times': [[0]]} for i in range(0, n_pops): populations.append( p.Population(nNeurons, p.IF_curr_exp(**cell_params_lif), label='pop_{}'.format(i))) populations.append( p.Population(1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1')) for i in range(0, n_pops): projections.append( p.Projection(presynaptic_population=populations[i], postsynaptic_population=populations[i], connector=p.FromListConnector(connections), synapse_type=p.StaticSynapse())) connector = p.FromListConnector(pop_jump_connection) projections.append( p.Projection(presynaptic_population=populations[i], postsynaptic_population=populations[((i + 1) % n_pops)], connector=connector, synapse_type=p.StaticSynapse())) projections.append( p.Projection(presynaptic_population=populations[n_pops], postsynaptic_population=populations[0], connector=p.FromListConnector(injectionConnection), synapse_type=p.StaticSynapse())) for pop_index in range(0, n_pops): populations[pop_index].record("spikes") p.run(runtime) total_spikes = populations[0].spinnaker_get_data("spikes") for pop_index in range(1, n_pops): spikes = populations[pop_index].spinnaker_get_data("spikes") if spikes is not None: for spike in spikes: spike[0] += (nNeurons * pop_index) total_spikes = numpy.concatenate((total_spikes, spikes), axis=0) p.end() return total_spikes
def test_receiver(): # Set up the live connection for sending spikes live_spikes_connection_send = \ Frontend.external_devices.SpynnakerLiveSpikesConnection( receive_labels=None, local_port=None, send_labels=["spike_injector_forward", "spike_injector_backward"]) # Set up callbacks to occur at initialisation live_spikes_connection_send.add_init_callback("spike_injector_forward", init_pop) live_spikes_connection_send.add_init_callback("spike_injector_backward", init_pop) # Set up callbacks to occur at the start of simulation live_spikes_connection_send.add_start_resume_callback( "spike_injector_forward", send_input_forward) live_spikes_connection_send.add_start_resume_callback( "spike_injector_backward", send_input_backward) ############################################################ # Start the external receiver # ############################################################ receiver = subprocess.Popen(binary_path("receiver"), stderr=subprocess.PIPE) firstline = str(receiver.stderr.readline(), "UTF-8") match = re.match("^Listening on (.*)$", firstline) if not match: receiver.kill() raise Exception(f"Receiver returned unknown output: {firstline}") receiver_port = int(match.group(1)) ############################################################ # Setup a Simulation to be injected into and received from # ############################################################ # initial call to set up the front end (pynn requirement) Frontend.setup(timestep=1.0, min_delay=1.0) # neurons per population and the length of runtime in ms for the simulation, # as well as the expected weight each spike will contain n_neurons = 100 run_time = 8000 weight_to_spike = 2.0 # neural parameters of the ifcur model used to respond to injected spikes. # (cell params for a synfire chain) cell_params_lif = { 'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0 } ################################## # Parameters for the injector population. # The virtual key is assigned here, rather than being allocated later. # Spikes injected need to match this key, and this will be done automatically # with 16-bit keys. ################################## cell_params_spike_injector_with_key = { # This is the base key to be used for the injection, which is used to # allow the keys to be routed around the spiNNaker machine. This # assignment means that 32-bit keys must have the high-order 16-bit # set to 0x7; This will automatically be prepended to 16-bit keys. 'virtual_key': 0x70000, } # create synfire populations (if cur exp) pop_forward = Frontend.Population(n_neurons, Frontend.IF_curr_exp(**cell_params_lif), label='pop_forward') pop_backward = Frontend.Population(n_neurons, Frontend.IF_curr_exp(**cell_params_lif), label='pop_backward') # Create injection populations injector_forward = Frontend.Population( n_neurons, Frontend.external_devices.SpikeInjector( database_notify_port_num=live_spikes_connection_send.local_port), label='spike_injector_forward', additional_parameters=cell_params_spike_injector_with_key) injector_backward = Frontend.Population( n_neurons, Frontend.external_devices.SpikeInjector( database_notify_port_num=live_spikes_connection_send.local_port), label='spike_injector_backward') # Create a connection from the injector into the populations Frontend.Projection(injector_forward, pop_forward, Frontend.OneToOneConnector(), Frontend.StaticSynapse(weight=weight_to_spike)) Frontend.Projection(injector_backward, pop_backward, Frontend.OneToOneConnector(), Frontend.StaticSynapse(weight=weight_to_spike)) # Synfire chain connections where each neuron is connected to its next neuron # NOTE: there is no recurrent connection so that each chain stops once it # reaches the end loop_forward = list() loop_backward = list() for i in range(0, n_neurons - 1): loop_forward.append((i, (i + 1) % n_neurons, weight_to_spike, 3)) loop_backward.append(((i + 1) % n_neurons, i, weight_to_spike, 3)) Frontend.Projection(pop_forward, pop_forward, Frontend.FromListConnector(loop_forward)) Frontend.Projection(pop_backward, pop_backward, Frontend.FromListConnector(loop_backward)) # record spikes from the synfire chains so that we can read off valid results # in a safe way afterwards, and verify the behavior pop_forward.record('spikes') pop_backward.record('spikes') # Activate the sending of live spikes Frontend.external_devices.activate_live_output_for( pop_forward, database_notify_port_num=receiver_port) Frontend.external_devices.activate_live_output_for( pop_backward, database_notify_port_num=receiver_port) # Run the simulation on spiNNaker Frontend.run(run_time) spikes_forward = pop_forward.get_data('spikes').segments[0].spiketrains spikes_backward = pop_backward.get_data('spikes').segments[0].spiketrains # Clear data structures on spiNNaker to leave the machine in a clean state # for future executions Frontend.end() last_line = str(receiver.stderr.readline(), "UTF-8") print(last_line) print("Waiting for receiver to stop...") receiver.wait() print("Done") n_spikes = sum(len(s) for s in spikes_forward) n_spikes += sum(len(s) for s in spikes_backward) # Check spike count, assuming some might get lost match = re.match("^Received (.*) spikes$", last_line) assert (match) assert (n_spikes // 2 <= int(match.group(1)) <= n_spikes)
def do_run(plot): p.setup(timestep=1.0) cell_params_lif = { 'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0 } # Parameters nNeurons = 200 weight_to_spike = 2.0 delay = 17 runtime = 5000 p.set_number_of_neurons_per_core(p.IF_curr_exp, nNeurons / 2) # Populations pop = p.Population(nNeurons, p.IF_curr_exp(**cell_params_lif), label='pop_1') pop2 = p.Population(nNeurons, p.IF_curr_exp(**cell_params_lif), label='pop_2') # create loopConnections array for first population using numpy linspaces loopConnections = numpy.array([ numpy.linspace(0, nNeurons - 1, nNeurons), numpy.linspace(1, nNeurons, nNeurons) ], numpy.uint32) # connect the final neuron to the first neuron loopConnections[1, nNeurons - 1] = 0 # do the same for the second population, but just for even numbered neurons loopConnections2 = numpy.array([ numpy.linspace(0, nNeurons - 2, nNeurons // 2), numpy.linspace(2, nNeurons + 1, nNeurons // 2) ], numpy.uint32) # connect the final neuron to the first neuron loopConnections2[1, (nNeurons // 2) - 1] = 0 # SpikeInjector injectionConnection = numpy.array([[0], [0]], numpy.uint32) spikeArray = {'spike_times': [[0]]} inj_pop = p.Population(1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1') # Projection for injector p.Projection(inj_pop, pop, p.ArrayConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=1)) p.Projection(inj_pop, pop2, p.ArrayConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=1)) # Projection within populations p.Projection(pop, pop, p.ArrayConnector(loopConnections), p.StaticSynapse(weight=weight_to_spike, delay=delay)) p.Projection(pop2, pop2, p.ArrayConnector(loopConnections2), p.StaticSynapse(weight=weight_to_spike, delay=delay)) pop.record(['v', 'spikes']) pop2.record(['v', 'spikes']) p.run(runtime) v = pop.get_data('v') spikes = pop.get_data('spikes') v2 = pop2.get_data('v') spikes2 = pop2.get_data('spikes') if plot: Figure( # raster plot of the presynaptic neurons' spike times Panel(spikes.segments[0].spiketrains, yticks=True, markersize=1.2, xlim=(0, runtime), xticks=True), # membrane potential of the postsynaptic neurons Panel(v.segments[0].filter(name='v')[0], ylabel="Membrane potential (mV)", data_labels=[pop.label], yticks=True, xlim=(0, runtime), xticks=True), Panel(spikes2.segments[0].spiketrains, yticks=True, markersize=1.2, xlim=(0, runtime), xticks=True), # membrane potential of the postsynaptic neurons Panel(v2.segments[0].filter(name='v')[0], ylabel="Membrane potential (mV)", data_labels=[pop2.label], yticks=True, xlim=(0, runtime), xticks=True), title="Testing ArrayConnector", annotations="Simulated with {}".format(p.name())) plt.show() p.end() return v, spikes, v2, spikes2
def split_structural_with_stdp(): p.setup(1.0) pre_spikes = numpy.array(range(0, 10, 2)) pre_spikes_last_neuron = pre_spikes[pre_spikes > 0] A_plus = 0.01 A_minus = 0.01 tau_plus = 20.0 tau_minus = 20.0 w_min = 0.0 w_max = 5.0 w_init_1 = 5.0 delay_1 = 2.0 w_init_2 = 4.0 delay_2 = 1.0 stim = p.Population(1, p.SpikeSourceArray(pre_spikes), label="stim") pop = p.Population(1, p.IF_curr_exp(), label="pop", additional_parameters={ "splitter": SplitterAbstractPopulationVertexNeuronsSynapses(1) }) pop_2 = p.Population(1, p.IF_curr_exp(), label="pop_2", additional_parameters={ "splitter": SplitterAbstractPopulationVertexNeuronsSynapses(1) }) pop_3 = p.Population(1, p.IF_curr_exp(), label="pop_3", additional_parameters={ "splitter": SplitterAbstractPopulationVertexNeuronsSynapses(1) }) pop_4 = p.Population(1, p.IF_curr_exp(), label="pop_4", additional_parameters={ "splitter": SplitterAbstractPopulationVertexNeuronsSynapses(1) }) pop.record("spikes") pop_2.record("spikes") proj = p.Projection( stim, pop, p.FromListConnector([]), p.StructuralMechanismSTDP( partner_selection=p.LastNeuronSelection(), formation=p.DistanceDependentFormation([1, 1], 1.0), elimination=p.RandomByWeightElimination(2.0, 0, 0), timing_dependence=p.SpikePairRule(tau_plus, tau_minus, A_plus, A_minus), weight_dependence=p.AdditiveWeightDependence(w_min, w_max), f_rew=1000, initial_weight=w_init_1, initial_delay=delay_1, s_max=1, seed=0, weight=0.0, delay=1.0)) proj_2 = p.Projection( stim, pop_2, p.FromListConnector([]), p.StructuralMechanismSTDP( partner_selection=p.RandomSelection(), formation=p.DistanceDependentFormation([1, 1], 1.0), elimination=p.RandomByWeightElimination(4.0, 0, 0), timing_dependence=p.SpikePairRule(tau_plus, tau_minus, A_plus, A_minus), weight_dependence=p.AdditiveWeightDependence(w_min, w_max), f_rew=1000, initial_weight=w_init_2, initial_delay=delay_2, s_max=1, seed=0, weight=0.0, delay=1.0)) proj_3 = p.Projection( stim, pop_3, p.FromListConnector([(0, 0)]), p.StructuralMechanismSTDP( partner_selection=p.LastNeuronSelection(), formation=p.DistanceDependentFormation([1, 1], 0.0), elimination=p.RandomByWeightElimination(4.0, 1.0, 1.0), timing_dependence=p.SpikePairRule(tau_plus, tau_minus, A_plus, A_minus), weight_dependence=p.AdditiveWeightDependence(w_min, w_max), f_rew=1000, initial_weight=2.0, initial_delay=5.0, s_max=1, seed=0, weight=0.0, delay=1.0)) proj_4 = p.Projection( stim, pop_4, p.FromListConnector([(0, 0)]), p.StructuralMechanismSTDP( partner_selection=p.RandomSelection(), formation=p.DistanceDependentFormation([1, 1], 0.0), elimination=p.RandomByWeightElimination(4.0, 1.0, 1.0), timing_dependence=p.SpikePairRule(tau_plus, tau_minus, A_plus, A_minus), weight_dependence=p.AdditiveWeightDependence(w_min, w_max), f_rew=1000, initial_weight=4.0, initial_delay=3.0, s_max=1, seed=0, weight=0.0, delay=1.0)) p.run(10) conns = list(proj.get(["weight", "delay"], "list")) conns_2 = list(proj_2.get(["weight", "delay"], "list")) conns_3 = list(proj_3.get(["weight", "delay"], "list")) conns_4 = list(proj_4.get(["weight", "delay"], "list")) spikes_1 = [ s.magnitude for s in pop.get_data("spikes").segments[0].spiketrains ] spikes_2 = [ s.magnitude for s in pop_2.get_data("spikes").segments[0].spiketrains ] p.end() print(conns) print(conns_2) print(conns_3) print(conns_4) w_final_1 = calculate_spike_pair_additive_stdp_weight( pre_spikes_last_neuron, spikes_1[0], w_init_1, delay_1, w_max, A_plus, A_minus, tau_plus, tau_minus) w_final_2 = calculate_spike_pair_additive_stdp_weight( pre_spikes, spikes_2[0], w_init_2, delay_2, w_max, A_plus, A_minus, tau_plus, tau_minus) print(w_final_1, spikes_1[0]) print(w_final_2, spikes_2[0]) assert (len(conns) == 1) assert (conns[0][3] == delay_1) assert (conns[0][2] >= w_final_1 - 0.01 and conns[0][2] <= w_final_1 + 0.01) assert (len(conns_2) == 1) assert (conns_2[0][3] == delay_2) assert (conns_2[0][2] >= w_final_2 - 0.01 and conns_2[0][2] <= w_final_2 + 0.01) assert (len(conns_3) == 0) assert (len(conns_4) == 0)