def test_dead_section(not_there, default_config): name, place = not_there default_config = default_config + "[Pets]\nsam=cat\n" with open(place, "w") as f: f.write(default_config) with LogCapture() as lc: conf_loader.load_config(name, [CFGPATH]) log_checker.assert_logs_warning_contains(lc.records, "Unexpected Section: [Pets]")
def test_new_option_home(not_there, default_config): name, place = not_there default_config = default_config + "sam=cat\n" with open(place, "w") as f: f.write(default_config) with LogCapture() as lc: conf_loader.load_config(name, [CFGPATH]) log_checker.assert_logs_warning_contains( lc.records, "Unexpected Option: [sect]sam")
def test_new_option_local(tmpdir, default_config, not_there): name, place = not_there with open(place, "w") as f: f.write(default_config) with tmpdir.as_cwd(): f = tmpdir.join(name) default_config = default_config + "sam=cat\n" f.write(default_config) with pytest.raises(UnexpectedConfigException): conf_loader.load_config(name, [CFGPATH])
def test_use_one_default(tmpdir, not_there): name, place = not_there with tmpdir.as_cwd(): with pytest.raises(NoConfigFoundException): conf_loader.load_config(name, [CFGPATH]) # Load the now created file config = configparser.ConfigParser() config.read(place) assert config is not None assert config.sections() == ["sect"] assert config.options("sect") == ["foobob"] assert config.get("sect", "foobob") == "bar"
def setUp(self): conf = conf_loader.load_config(spynnaker.pyNN, "spynnaker.cfg") self._previous_reportsEnabled = conf.get( "Reports", "reportsEnabled") self.previous_defaultReportFilePath = conf.get( "Reports", "defaultReportFilePath")
def assert_not_spin_three(self): config = conf_loader.load_config(filename="spynnaker.cfg", defaults=[]) if config.has_option("Machine", "version"): version = config.get("Machine", "version") if version in ["2", "3"]: raise SkipTest( "This test will not run on a spin {} board".format( version))
def test_retrieve_direct_block(self): default_config_paths = os.path.join( os.path.dirname(abstract_spinnaker_common.__file__), AbstractSpiNNakerCommon.CONFIG_FILE_NAME) config = conf_loader.load_config( AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths) key = 0 n_rows = 2 direct_matrix = bytearray(struct.pack("<IIII", 1, 2, 3, 4)) direct_matrix_1_expanded = bytearray( struct.pack("<IIIIIIII", 0, 1, 0, 1, 0, 1, 0, 2)) direct_matrix_2_expanded = bytearray( struct.pack("<IIIIIIII", 0, 1, 0, 3, 0, 1, 0, 4)) synaptic_manager = SynapticManager( synapse_type=None, ring_buffer_sigma=5.0, spikes_per_second=100.0, config=config, population_table_type=MockMasterPopulationTable( {key: [(1, 0, True), (1, n_rows * 4, True)]}), synapse_io=MockSynapseIO()) transceiver = MockTransceiverRawData(direct_matrix) placement = Placement(None, 0, 0, 1) data_1, row_len_1 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=0, indirect_synapses_address=0, direct_synapses_address=0, key=key, n_rows=n_rows, index=0, using_extra_monitor_cores=False) data_2, row_len_2 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=0, indirect_synapses_address=0, direct_synapses_address=0, key=key, n_rows=n_rows, index=1, using_extra_monitor_cores=False) # Row lengths should be 1 assert row_len_1 == 1 assert row_len_2 == 1 # Check the data retrieved assert data_1 == direct_matrix_1_expanded assert data_2 == direct_matrix_2_expanded
def test_different_value(not_there, default_config): name, place = not_there default_config = default_config.replace("bar", "cat") with open(place, "w") as f: f.write(default_config) config = conf_loader.load_config(name, [CFGPATH]) assert config is not None assert config.sections() == ["sect"] assert config.options("sect") == ["foobob"] assert config.get("sect", "foobob") == "cat"
def test_None_machine_spec_file(tmpdir, default_config, not_there): name, place = not_there default_config += "\n[Machine]\nmachine_spec_file=None\n" with open(place, "w") as f: f.write(default_config) with tmpdir.as_cwd(): with LogCapture() as lc: config = conf_loader.load_config(name, []) assert config is not None assert config.sections() == ["sect", "Machine"] assert config.options("sect") == ["foobob"] assert config.get("sect", "foobob") == "bar" log_checker.assert_logs_info_not_contains(lc.records, "None")
def load_config(): """ Reads in all the config files, resetting all values. """ global __config if not __default_config_files: raise Exception("No default configs set") if __config_file: __config = conf_loader.load_config(filename=__config_file, defaults=__default_config_files) else: __config = CamelCaseConfigParser() for default in __default_config_files: __config.read(default)
def test_advanced_use(tmpdir, default_config, not_there): def parseAbc(parser): f = parser.getfloat("Abc", "def") parser.set("Abc", "ghi", f * 3) parser.remove_option("Abc", "def") name, place = not_there default_config += "\n[Abc]\ndef=1.25\n" with open(place, "w") as f: f.write(default_config) with tmpdir.as_cwd(): config = conf_loader.load_config(name, [], config_parsers=[("Abc", parseAbc)]) assert config.options("Abc") == ["ghi"] assert config.getfloat("Abc", "ghi") == 3.75
def test_str_list(tmpdir, not_there): name, place = not_there with open(place, "w") as f: f.write("[abc]\n" "as_list=bacon, is,so ,cool \n" "as_none=None\n" "as_empty=\n" "fluff=more\n") with tmpdir.as_cwd(): config = conf_loader.load_config(name, []) assert config.get_str_list("abc", "as_list") == \ ["bacon", "is", "so", "cool"] assert config.get_str_list("abc", "as_none") == [] assert config.get_str_list("abc", "as_empty") == [] assert config.get_str_list("abc", "fluff") == ["more"]
def test_reports_creation_custom_location(self): conf = conf_loader.load_config(spynnaker.pyNN, "spynnaker.cfg") current_path = os.path.dirname(os.path.abspath(__file__)) conf.set("Reports", "defaultReportFilePath", current_path) conf.set("Reports", "reportsEnabled", "True") spinn = Spinnaker(timestep=1, min_delay=1, max_delay=10) if 'reports' in os.listdir(current_path): shutil.rmtree(os.path.join(current_path, 'reports')) spinn._set_up_report_specifics() self.assertEqual(spinn._report_default_directory, os.path.join(current_path, 'reports', 'latest')) # File reports should be in the new location self.assertIn('reports', os.listdir(current_path))
def test_intermediate_use(tmpdir, default_config, mach_spec, not_there): name, place = not_there default_config += "\n[Machine]\nmachine_spec_file=" + mach_spec + "\n" with open(place, "w") as f: f.write(default_config) with tmpdir.as_cwd(): with LogCapture() as lc: config = conf_loader.load_config(name, []) assert config is not None assert config.sections() == ["sect", "Machine"] assert config.options("sect") == ["foobob"] assert config.get("sect", "foobob") == "bar" assert config.options("Machine") == ["machinename", "version"] assert config.get("Machine", "MachineName") == "foo" assert config.getint("Machine", "VeRsIoN") == 5 log_checker.assert_logs_info_contains(lc.records, name)
def test_retrieve_synaptic_block(self): default_config_paths = os.path.join( os.path.dirname(abstract_spinnaker_common.__file__), AbstractSpiNNakerCommon.CONFIG_FILE_NAME) config = conf_loader.load_config( AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths) key = 0 synaptic_manager = SynapticManager( n_synapse_types=2, ring_buffer_sigma=5.0, spikes_per_second=100.0, config=config, population_table_type=MockMasterPopulationTable( {key: [(1, 0, False)]}), synapse_io=MockSynapseIO()) transceiver = MockTransceiverRawData(bytearray(16)) placement = Placement(None, 0, 0, 1) first_block, row_len_1 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=0, indirect_synapses_address=0, direct_synapses_address=0, key=key, n_rows=1, index=0, using_extra_monitor_cores=False) same_block, row_len_1_2 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=0, indirect_synapses_address=0, direct_synapses_address=0, key=key, n_rows=1, index=0, using_extra_monitor_cores=False) synaptic_manager.clear_connection_cache() different_block, row_len_2 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=0, indirect_synapses_address=0, direct_synapses_address=0, key=key, n_rows=1, index=0, using_extra_monitor_cores=False) # Check that the row lengths are all the same assert row_len_1 == row_len_1_2 assert row_len_1 == row_len_2 # Check that the block retrieved twice without reset is cached assert id(first_block) == id(same_block) # Check that the block after reset is not a copy assert id(first_block) != id(different_block)
def test_retrieve_synaptic_block(self): default_config_paths = os.path.join( os.path.dirname(abstract_spinnaker_common.__file__), AbstractSpiNNakerCommon.CONFIG_FILE_NAME) config = conf_loader.load_config( AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths) key = 0 synaptic_manager = SynapticManager( synapse_type=None, ring_buffer_sigma=5.0, spikes_per_second=100.0, config=config, population_table_type=MockMasterPopulationTable( {key: [(1, 0, False)]}), synapse_io=MockSynapseIO()) transceiver = MockTransceiverRawData(bytearray(16)) placement = Placement(None, 0, 0, 1) first_block, row_len_1 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=0, indirect_synapses_address=0, direct_synapses_address=0, key=key, n_rows=1, index=0, using_extra_monitor_cores=False) same_block, row_len_1_2 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=0, indirect_synapses_address=0, direct_synapses_address=0, key=key, n_rows=1, index=0, using_extra_monitor_cores=False) synaptic_manager.clear_connection_cache() different_block, row_len_2 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=0, indirect_synapses_address=0, direct_synapses_address=0, key=key, n_rows=1, index=0, using_extra_monitor_cores=False) # Check that the row lengths are all the same assert row_len_1 == row_len_1_2 assert row_len_1 == row_len_2 # Check that the block retrieved twice without reset is cached assert id(first_block) == id(same_block) # Check that the block after reset is not a copy assert id(first_block) != id(different_block)
def test_retrieve_direct_block(self): default_config_paths = os.path.join( os.path.dirname(abstract_spinnaker_common.__file__), AbstractSpiNNakerCommon.CONFIG_FILE_NAME) config = conf_loader.load_config( AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths) key = 0 n_rows = 2 direct_matrix = bytearray(struct.pack("<IIII", 1, 2, 3, 4)) direct_matrix_1_expanded = bytearray( struct.pack("<IIIIIIII", 0, 1, 0, 1, 0, 1, 0, 2)) direct_matrix_2_expanded = bytearray( struct.pack("<IIIIIIII", 0, 1, 0, 3, 0, 1, 0, 4)) synaptic_manager = SynapticManager( n_synapse_types=2, ring_buffer_sigma=5.0, spikes_per_second=100.0, config=config, population_table_type=MockMasterPopulationTable( {key: [(1, 0, True), (1, n_rows * 4, True)]}), synapse_io=MockSynapseIO()) transceiver = MockTransceiverRawData(direct_matrix) placement = Placement(None, 0, 0, 1) data_1, row_len_1 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=0, indirect_synapses_address=0, direct_synapses_address=0, key=key, n_rows=n_rows, index=0, using_extra_monitor_cores=False) data_2, row_len_2 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=0, indirect_synapses_address=0, direct_synapses_address=0, key=key, n_rows=n_rows, index=1, using_extra_monitor_cores=False) # Row lengths should be 1 assert row_len_1 == 1 assert row_len_2 == 1 # Check the data retrieved assert data_1 == direct_matrix_1_expanded assert data_2 == direct_matrix_2_expanded
def __init__(self, configfile, default_config_paths, validation_cfg): # global params if default_config_paths is None: default_config_paths = [] default_config_paths.insert( 0, os.path.join(os.path.dirname(__file__), CONFIG_FILE)) self._config = conf_loader.load_config(filename=configfile, defaults=default_config_paths, validation_cfg=validation_cfg) # set up machine targeted data self._use_virtual_board = self._config.getboolean( "Machine", "virtual_board") self._app_data_runtime_folder = None self._app_data_top_simulation_folder = None self._json_folder = None self._provenance_file_path = None self._report_default_directory = None self._report_simulation_top_directory = None self._this_run_time_string = None
def __init__(self, configfile, default_config_paths, validation_cfg): """ :param str configfile: The base name of the configuration file(s). Should not include any path components. :param list(str) default_config_paths: The list of files to get default configurations from. :type default_config_paths: list(str) or None :param validation_cfg: The list of files to read a validation configuration from. If None, no such validation is performed. :type validation_cfg: list(str) or None """ # global params if default_config_paths is None: default_config_paths = [] default_config_paths.insert(0, os.path.join( os.path.dirname(__file__), CONFIG_FILE)) self._config = conf_loader.load_config( filename=configfile, defaults=default_config_paths, validation_cfg=validation_cfg) # set up machine targeted data self._use_virtual_board = self._config.getboolean( "Machine", "virtual_board") # Pass max_machine_cores to Machine so if effects everything! max_machine_core = self._read_config_int("Machine", "max_machine_core") if max_machine_core is not None: Machine.set_max_cores_per_chip(max_machine_core) self._json_folder = None self._provenance_file_path = None self._report_default_directory = None self._report_simulation_top_directory = None self._this_run_time_string = None
def __init__( self, configfile, default_config_paths, validation_cfg): # global params if default_config_paths is None: default_config_paths = [] default_config_paths.insert(0, os.path.join( os.path.dirname(__file__), CONFIG_FILE)) self._config = conf_loader.load_config( filename=configfile, defaults=default_config_paths, validation_cfg=validation_cfg) # set up machine targeted data self._use_virtual_board = self._config.getboolean( "Machine", "virtual_board") self._app_data_runtime_folder = None self._app_data_top_simulation_folder = None self._json_folder = None self._provenance_file_path = None self._report_default_directory = None self._report_simulation_top_directory = None self._this_run_time_string = None
def test_write_synaptic_matrix_and_master_population_table(self): MockSimulator.setup() default_config_paths = os.path.join( os.path.dirname(abstract_spinnaker_common.__file__), AbstractSpiNNakerCommon.CONFIG_FILE_NAME) config = conf_loader.load_config( AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths) config.set("Simulation", "one_to_one_connection_dtcm_max_bytes", 40) machine_time_step = 1000.0 pre_app_vertex = SimpleApplicationVertex(10) pre_vertex = SimpleMachineVertex(resources=None) pre_vertex_slice = Slice(0, 9) post_app_vertex = SimpleApplicationVertex(10) post_vertex = SimpleMachineVertex(resources=None) post_vertex_slice = Slice(0, 9) post_slice_index = 0 one_to_one_connector_1 = OneToOneConnector(None) one_to_one_connector_1.set_projection_information( pre_app_vertex, post_app_vertex, None, machine_time_step) one_to_one_connector_1.set_weights_and_delays(1.5, 1.0) one_to_one_connector_2 = OneToOneConnector(None) one_to_one_connector_2.set_projection_information( pre_app_vertex, post_app_vertex, None, machine_time_step) one_to_one_connector_2.set_weights_and_delays(2.5, 2.0) all_to_all_connector = AllToAllConnector(None) all_to_all_connector.set_projection_information( pre_app_vertex, post_app_vertex, None, machine_time_step) all_to_all_connector.set_weights_and_delays(4.5, 4.0) direct_synapse_information_1 = SynapseInformation( one_to_one_connector_1, SynapseDynamicsStatic(), 0) direct_synapse_information_2 = SynapseInformation( one_to_one_connector_2, SynapseDynamicsStatic(), 1) all_to_all_synapse_information = SynapseInformation( all_to_all_connector, SynapseDynamicsStatic(), 0) app_edge = ProjectionApplicationEdge( pre_app_vertex, post_app_vertex, direct_synapse_information_1) app_edge.add_synapse_information(direct_synapse_information_2) app_edge.add_synapse_information(all_to_all_synapse_information) machine_edge = ProjectionMachineEdge( app_edge.synapse_information, pre_vertex, post_vertex) partition_name = "TestPartition" graph = MachineGraph("Test") graph.add_vertex(pre_vertex) graph.add_vertex(post_vertex) graph.add_edge(machine_edge, partition_name) graph_mapper = GraphMapper() graph_mapper.add_vertex_mapping( pre_vertex, pre_vertex_slice, pre_app_vertex) graph_mapper.add_vertex_mapping( post_vertex, post_vertex_slice, post_app_vertex) graph_mapper.add_edge_mapping(machine_edge, app_edge) weight_scales = [4096.0, 4096.0] key = 0 routing_info = RoutingInfo() routing_info.add_partition_info(PartitionRoutingInfo( [BaseKeyAndMask(key, 0xFFFFFFF0)], graph.get_outgoing_edge_partition_starting_at_vertex( pre_vertex, partition_name))) temp_spec = tempfile.mktemp() spec_writer = FileDataWriter(temp_spec) spec = DataSpecificationGenerator(spec_writer, None) master_pop_sz = 1000 master_pop_region = 0 all_syn_block_sz = 2000 synapse_region = 1 spec.reserve_memory_region(master_pop_region, master_pop_sz) spec.reserve_memory_region(synapse_region, all_syn_block_sz) synapse_type = MockSynapseType() synaptic_manager = SynapticManager( synapse_type=synapse_type, ring_buffer_sigma=5.0, spikes_per_second=100.0, config=config) synaptic_manager._write_synaptic_matrix_and_master_population_table( spec, [post_vertex_slice], post_slice_index, post_vertex, post_vertex_slice, all_syn_block_sz, weight_scales, master_pop_region, synapse_region, routing_info, graph_mapper, graph, machine_time_step) spec.end_specification() spec_writer.close() spec_reader = FileDataReader(temp_spec) executor = DataSpecificationExecutor( spec_reader, master_pop_sz + all_syn_block_sz) executor.execute() master_pop_table = executor.get_region(0) synaptic_matrix = executor.get_region(1) all_data = bytearray() all_data.extend(master_pop_table.region_data[ :master_pop_table.max_write_pointer]) all_data.extend(synaptic_matrix.region_data[ :synaptic_matrix.max_write_pointer]) master_pop_table_address = 0 synaptic_matrix_address = master_pop_table.max_write_pointer direct_synapses_address = struct.unpack_from( "<I", synaptic_matrix.region_data)[0] direct_synapses_address += synaptic_matrix_address + 8 indirect_synapses_address = synaptic_matrix_address + 4 placement = Placement(None, 0, 0, 1) transceiver = MockTransceiverRawData(all_data) # Get the master population table details items = synaptic_manager._poptable_type\ .extract_synaptic_matrix_data_location( key, master_pop_table_address, transceiver, placement.x, placement.y) # The first entry should be direct, but the rest should be indirect; # the second is potentially direct, but has been restricted by the # restriction on the size of the direct matrix assert len(items) == 3 # TODO: This has been changed because direct matrices are disabled! assert not items[0][2] assert not items[1][2] assert not items[2][2] data_1, row_len_1 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=master_pop_table_address, indirect_synapses_address=indirect_synapses_address, direct_synapses_address=direct_synapses_address, key=key, n_rows=pre_vertex_slice.n_atoms, index=0, using_extra_monitor_cores=False) connections_1 = synaptic_manager._synapse_io.read_synapses( direct_synapse_information_1, pre_vertex_slice, post_vertex_slice, row_len_1, 0, 2, weight_scales, data_1, None, app_edge.n_delay_stages, machine_time_step) # The first matrix is a 1-1 matrix, so row length is 1 assert row_len_1 == 1 # 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]) data_2, row_len_2 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=master_pop_table_address, indirect_synapses_address=indirect_synapses_address, direct_synapses_address=direct_synapses_address, key=key, n_rows=pre_vertex_slice.n_atoms, index=1, using_extra_monitor_cores=False) connections_2 = synaptic_manager._synapse_io.read_synapses( direct_synapse_information_2, pre_vertex_slice, post_vertex_slice, row_len_2, 0, 2, weight_scales, data_2, None, app_edge.n_delay_stages, machine_time_step) # The second matrix is a 1-1 matrix, so row length is 1 assert row_len_2 == 1 # 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]) data_3, row_len_3 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=master_pop_table_address, indirect_synapses_address=indirect_synapses_address, direct_synapses_address=direct_synapses_address, key=key, n_rows=pre_vertex_slice.n_atoms, index=2, using_extra_monitor_cores=False) connections_3 = synaptic_manager._synapse_io.read_synapses( all_to_all_synapse_information, pre_vertex_slice, post_vertex_slice, row_len_3, 0, 2, weight_scales, data_3, None, app_edge.n_delay_stages, machine_time_step) # The third matrix is an all-to-all matrix, so length is n_atoms assert row_len_3 == post_vertex_slice.n_atoms # Check that all the connections have the right weight and delay assert len(connections_3) == \ post_vertex_slice.n_atoms * pre_vertex_slice.n_atoms assert all([conn["weight"] == 4.5 for conn in connections_3]) assert all([conn["delay"] == 4.0 for conn in connections_3])
def DvsEmulatorDevice(n_neurons, machine_time_step, timescale_factor, label, port=12345, virtual_key=None, spikes_per_second=0, ring_buffer_sigma=None, device_id=0, fps=30, mode="128", scale_img=True, polarity="MERGED", inhibition = False, inh_area_width = 2, threshold=12, adaptive_threshold = False, min_threshold= 6, max_threshold=168, threshold_delta_down = 2, threshold_delta_up = 12, output_type="TIME", num_bits_per_spike=4, history_weight=0.99, save_spikes=None, run_time_ms=None, local_port=19999, database_notify_host=None, database_notify_port_num=None, database_ack_port_num=None): """ supports adding a spike injector to the applciation graph. :param n_neurons: the number of neurons the spike injector will emulate :type n_neurons: int :param machine_time_step: the time period in ms for each timer callback :type machine_time_step: int :param timescale_factor: the amount of scaling needed of the machine time step (basically a slow down function) :type timescale_factor: int :param spikes_per_second: the expected number of spikes per second :type spikes_per_second: int :param ring_buffer_sigma: the number of standard divations from a calcuation on how much safety in percision vs overflowing (this is deduced from the front end) :type ring_buffer_sigma: int :param label: the label given to the population :type label: str :param port: the port number used to listen for injections of spikes :type port: int :param virtual_key: the virtual key used in the routing system :type virtual_key: int :param database_notify_host: the hostnmae for the device which is listening to the database notifcation. :type database_notify_host: str :param database_ack_port_num: the port number to which a external device will ack that they have finished reading the database and are ready for it to start execution :type database_ack_port_num: int :param database_notify_port_num: The port number to which a external device will recieve the database is ready command :type database_notify_port_num: int :return: """ config = conf_loader.load_config(filename="spynnaker.cfg", defaults=[]) if database_notify_port_num is None: database_notify_port_num = config.getint("Database", "notify_port") if database_notify_host is None: database_notify_host = config.get("Database", "notify_hostname") if database_ack_port_num is None: database_ack_port_num = config.get("Database", "listen_port") if database_ack_port_num == "None": database_ack_port_num = None # build the database socket address used by the notifcation interface database_socket = SocketAddress( listen_port=database_ack_port_num, notify_host_name=database_notify_host, notify_port_no=database_notify_port_num) # update socket interface with new demands. spynnaker_external_devices.add_socket_address(database_socket) return ExternalDvsEmulatorDevice( n_neurons=n_neurons, machine_time_step=machine_time_step, timescale_factor=timescale_factor, database_socket=database_socket, spikes_per_second=spikes_per_second, ring_buffer_sigma=ring_buffer_sigma, label=label, port=port, virtual_key=virtual_key, device_id=device_id, fps=fps, mode=mode, scale_img=scale_img, polarity=polarity, inhibition=inhibition, inh_area_width = inh_area_width, threshold=threshold, adaptive_threshold=adaptive_threshold, min_threshold=min_threshold, max_threshold=max_threshold, threshold_delta_down=threshold_delta_down, threshold_delta_up=threshold_delta_up, output_type=output_type, num_bits_per_spike=num_bits_per_spike, history_weight=history_weight, save_spikes=save_spikes, run_time_ms=run_time_ms, local_port=local_port)
def test_set_synapse_dynamics(self): MockSimulator.setup() default_config_paths = os.path.join( os.path.dirname(abstract_spinnaker_common.__file__), AbstractSpiNNakerCommon.CONFIG_FILE_NAME) config = conf_loader.load_config( AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths) synaptic_manager = SynapticManager( n_synapse_types=2, ring_buffer_sigma=5.0, spikes_per_second=100.0, config=config) static = SynapseDynamicsStatic() stdp = SynapseDynamicsSTDP( timing_dependence=TimingDependenceSpikePair(), weight_dependence=WeightDependenceAdditive()) alt_stdp = SynapseDynamicsSTDP( timing_dependence=TimingDependenceSpikePair(), weight_dependence=WeightDependenceMultiplicative()) static_struct = SynapseDynamicsStructuralStatic( partner_selection=LastNeuronSelection(), formation=DistanceDependentFormation(), elimination=RandomByWeightElimination(0.5)) alt_static_struct = SynapseDynamicsStructuralStatic( partner_selection=RandomSelection(), formation=DistanceDependentFormation(), elimination=RandomByWeightElimination(0.5)) stdp_struct = SynapseDynamicsStructuralSTDP( partner_selection=LastNeuronSelection(), formation=DistanceDependentFormation(), elimination=RandomByWeightElimination(0.5), timing_dependence=TimingDependenceSpikePair(), weight_dependence=WeightDependenceAdditive()) alt_stdp_struct = SynapseDynamicsStructuralSTDP( partner_selection=RandomSelection(), formation=DistanceDependentFormation(), elimination=RandomByWeightElimination(0.5), timing_dependence=TimingDependenceSpikePair(), weight_dependence=WeightDependenceAdditive()) alt_stdp_struct_2 = SynapseDynamicsStructuralSTDP( partner_selection=LastNeuronSelection(), formation=DistanceDependentFormation(), elimination=RandomByWeightElimination(0.5), timing_dependence=TimingDependenceSpikePair(), weight_dependence=WeightDependenceMultiplicative()) # This should be fine as it is the first call synaptic_manager.synapse_dynamics = static # This should be fine as STDP overrides static synaptic_manager.synapse_dynamics = stdp # This should fail because STDP dependences are difference with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_stdp # This should work because STDP dependences are the same synaptic_manager.synapse_dynamics = stdp # This should work because static always works, but the type should # still be STDP synaptic_manager.synapse_dynamics = static self.assertIsInstance( synaptic_manager.synapse_dynamics, SynapseDynamicsSTDP) # This should work but should merge with the STDP rule synaptic_manager.synapse_dynamics = static_struct self.assertIsInstance( synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralSTDP) # These should work as static / the STDP is the same but neither should # change anything synaptic_manager.synapse_dynamics = static self.assertIsInstance( synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralSTDP) synaptic_manager.synapse_dynamics = stdp self.assertIsInstance( synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralSTDP) synaptic_manager.synapse_dynamics = static_struct self.assertIsInstance( synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralSTDP) # These should fail as things are different with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_static_struct with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_stdp # This should pass as same structural STDP synaptic_manager.synapse_dynamics = stdp_struct self.assertIsInstance( synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralSTDP) # These should fail as both different with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_stdp_struct with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_stdp_struct_2 # Try starting again to get a couple more combinations synaptic_manager = SynapticManager( n_synapse_types=2, ring_buffer_sigma=5.0, spikes_per_second=100.0, config=config) # STDP followed by structural STDP should result in Structural STDP synaptic_manager.synapse_dynamics = stdp synaptic_manager.synapse_dynamics = stdp_struct self.assertIsInstance( synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralSTDP) # ... and should fail here because of differences with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_stdp with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_static_struct with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_stdp_struct with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_stdp_struct_2 # One more time! synaptic_manager = SynapticManager( n_synapse_types=2, ring_buffer_sigma=5.0, spikes_per_second=100.0, config=config) # Static followed by static structural should result in static # structural synaptic_manager.synapse_dynamics = static synaptic_manager.synapse_dynamics = static_struct self.assertIsInstance( synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralStatic) # ... and should fail here because of differences with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_static_struct with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_stdp_struct # This should be fine synaptic_manager.synapse_dynamics = static # This should be OK, but should merge with STDP (opposite of above) synaptic_manager.synapse_dynamics = stdp self.assertIsInstance( synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralSTDP) # ... and now these should fail with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_stdp with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_static_struct with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_stdp_struct with self.assertRaises(SynapticConfigurationException): synaptic_manager.synapse_dynamics = alt_stdp_struct_2 # OK, just one more, honest synaptic_manager = SynapticManager( n_synapse_types=2, ring_buffer_sigma=5.0, spikes_per_second=100.0, config=config) synaptic_manager.synapse_dynamics = static_struct synaptic_manager.synapse_dynamics = stdp_struct
def test_write_synaptic_matrix_and_master_population_table(self): MockSimulator.setup() # Add an sdram so maxsdram is high enough SDRAM(10000) default_config_paths = os.path.join( os.path.dirname(abstract_spinnaker_common.__file__), AbstractSpiNNakerCommon.CONFIG_FILE_NAME) config = conf_loader.load_config( AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths) config.set("Simulation", "one_to_one_connection_dtcm_max_bytes", 40) machine_time_step = 1000.0 pre_app_vertex = SimpleApplicationVertex(10) pre_vertex = SimpleMachineVertex(resources=None) pre_vertex_slice = Slice(0, 9) post_app_vertex = SimpleApplicationVertex(10) post_vertex = SimpleMachineVertex(resources=None) post_vertex_slice = Slice(0, 9) post_slice_index = 0 one_to_one_connector_1 = OneToOneConnector(None) one_to_one_connector_1.set_projection_information( pre_app_vertex, post_app_vertex, None, machine_time_step) one_to_one_connector_2 = OneToOneConnector(None) one_to_one_connector_2.set_projection_information( pre_app_vertex, post_app_vertex, None, machine_time_step) all_to_all_connector = AllToAllConnector(None) all_to_all_connector.set_projection_information( pre_app_vertex, post_app_vertex, None, machine_time_step) direct_synapse_information_1 = SynapseInformation( one_to_one_connector_1, SynapseDynamicsStatic(), 0, 1.5, 1.0) direct_synapse_information_2 = SynapseInformation( one_to_one_connector_2, SynapseDynamicsStatic(), 1, 2.5, 2.0) all_to_all_synapse_information = SynapseInformation( all_to_all_connector, SynapseDynamicsStatic(), 0, 4.5, 4.0) app_edge = ProjectionApplicationEdge( pre_app_vertex, post_app_vertex, direct_synapse_information_1) app_edge.add_synapse_information(direct_synapse_information_2) app_edge.add_synapse_information(all_to_all_synapse_information) machine_edge = ProjectionMachineEdge( app_edge.synapse_information, pre_vertex, post_vertex) partition_name = "TestPartition" graph = MachineGraph("Test") graph.add_vertex(pre_vertex) graph.add_vertex(post_vertex) graph.add_edge(machine_edge, partition_name) graph_mapper = GraphMapper() graph_mapper.add_vertex_mapping( pre_vertex, pre_vertex_slice, pre_app_vertex) graph_mapper.add_vertex_mapping( post_vertex, post_vertex_slice, post_app_vertex) graph_mapper.add_edge_mapping(machine_edge, app_edge) weight_scales = [4096.0, 4096.0] key = 0 routing_info = RoutingInfo() routing_info.add_partition_info(PartitionRoutingInfo( [BaseKeyAndMask(key, 0xFFFFFFF0)], graph.get_outgoing_edge_partition_starting_at_vertex( pre_vertex, partition_name))) temp_spec = tempfile.mktemp() spec_writer = FileDataWriter(temp_spec) spec = DataSpecificationGenerator(spec_writer, None) master_pop_sz = 1000 master_pop_region = 0 all_syn_block_sz = 2000 synapse_region = 1 direct_region = 2 spec.reserve_memory_region(master_pop_region, master_pop_sz) spec.reserve_memory_region(synapse_region, all_syn_block_sz) synaptic_manager = SynapticManager( n_synapse_types=2, ring_buffer_sigma=5.0, spikes_per_second=100.0, config=config) # UGLY but the mock transceiver NEED generate_on_machine be False abstract_generate_connector_on_machine.IS_PYNN_8 = False synaptic_manager._write_synaptic_matrix_and_master_population_table( spec, [post_vertex_slice], post_slice_index, post_vertex, post_vertex_slice, all_syn_block_sz, weight_scales, master_pop_region, synapse_region, direct_region, routing_info, graph_mapper, graph, machine_time_step) spec.end_specification() spec_writer.close() spec_reader = FileDataReader(temp_spec) executor = DataSpecificationExecutor( spec_reader, master_pop_sz + all_syn_block_sz) executor.execute() master_pop_table = executor.get_region(0) synaptic_matrix = executor.get_region(1) direct_matrix = executor.get_region(2) all_data = bytearray() all_data.extend(master_pop_table.region_data[ :master_pop_table.max_write_pointer]) all_data.extend(synaptic_matrix.region_data[ :synaptic_matrix.max_write_pointer]) all_data.extend(direct_matrix.region_data[ :direct_matrix.max_write_pointer]) master_pop_table_address = 0 synaptic_matrix_address = master_pop_table.max_write_pointer direct_synapses_address = ( synaptic_matrix_address + synaptic_matrix.max_write_pointer) direct_synapses_address += 4 indirect_synapses_address = synaptic_matrix_address placement = Placement(None, 0, 0, 1) transceiver = MockTransceiverRawData(all_data) # Get the master population table details items = synaptic_manager._poptable_type\ .extract_synaptic_matrix_data_location( key, master_pop_table_address, transceiver, placement.x, placement.y) # The first entry should be direct, but the rest should be indirect; # the second is potentially direct, but has been restricted by the # restriction on the size of the direct matrix assert len(items) == 3 assert items[0][2] assert not items[1][2] assert not items[2][2] data_1, row_len_1 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=master_pop_table_address, indirect_synapses_address=indirect_synapses_address, direct_synapses_address=direct_synapses_address, key=key, n_rows=pre_vertex_slice.n_atoms, index=0, using_extra_monitor_cores=False) connections_1 = synaptic_manager._synapse_io.read_synapses( direct_synapse_information_1, pre_vertex_slice, post_vertex_slice, row_len_1, 0, 2, weight_scales, data_1, None, app_edge.n_delay_stages, machine_time_step) # The first matrix is a 1-1 matrix, so row length is 1 assert row_len_1 == 1 # 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]) data_2, row_len_2 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=master_pop_table_address, indirect_synapses_address=indirect_synapses_address, direct_synapses_address=direct_synapses_address, key=key, n_rows=pre_vertex_slice.n_atoms, index=1, using_extra_monitor_cores=False) connections_2 = synaptic_manager._synapse_io.read_synapses( direct_synapse_information_2, pre_vertex_slice, post_vertex_slice, row_len_2, 0, 2, weight_scales, data_2, None, app_edge.n_delay_stages, machine_time_step) # The second matrix is a 1-1 matrix, so row length is 1 assert row_len_2 == 1 # 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]) data_3, row_len_3 = synaptic_manager._retrieve_synaptic_block( transceiver=transceiver, placement=placement, master_pop_table_address=master_pop_table_address, indirect_synapses_address=indirect_synapses_address, direct_synapses_address=direct_synapses_address, key=key, n_rows=pre_vertex_slice.n_atoms, index=2, using_extra_monitor_cores=False) connections_3 = synaptic_manager._synapse_io.read_synapses( all_to_all_synapse_information, pre_vertex_slice, post_vertex_slice, row_len_3, 0, 2, weight_scales, data_3, None, app_edge.n_delay_stages, machine_time_step) # The third matrix is an all-to-all matrix, so length is n_atoms assert row_len_3 == post_vertex_slice.n_atoms # Check that all the connections have the right weight and delay assert len(connections_3) == \ post_vertex_slice.n_atoms * pre_vertex_slice.n_atoms assert all([conn["weight"] == 4.5 for conn in connections_3]) assert all([conn["delay"] == 4.0 for conn in connections_3])
def tearDown(self): conf = conf_loader.load_config(spynnaker.pyNN, "spynnaker.cfg") conf.set("Reports", "defaultReportFilePath", self.previous_defaultReportFilePath) conf.set("Reports", "reportsEnabled", self._previous_reportsEnabled)
def test_one_templates(tmpdir, default_config, not_there): # @UnusedVariable name, place = not_there with tmpdir.as_cwd(): with pytest.raises(NoConfigFoundException): conf_loader.load_config(name, [FOURPATH, ONEPATH, THREEPATH])
def test_two_templates(tmpdir, default_config, not_there): # @UnusedVariable name, place = not_there with tmpdir.as_cwd(): with pytest.raises(ConfigTemplateException): conf_loader.load_config(name, [ONEPATH, TWOPATH])
def test_write_synaptic_matrix_and_master_population_table(self): MockSimulator.setup() # Add an sdram so max SDRAM is high enough SDRAM(10000) # UGLY but the mock transceiver NEED generate_on_machine to be False AbstractGenerateConnectorOnMachine.generate_on_machine = self.say_false default_config_paths = os.path.join( os.path.dirname(abstract_spinnaker_common.__file__), AbstractSpiNNakerCommon.CONFIG_FILE_NAME) config = conf_loader.load_config( AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths) config.set("Simulation", "one_to_one_connection_dtcm_max_bytes", 40) machine_time_step = 1000.0 pre_app_vertex = SimpleApplicationVertex(10) pre_vertex_slice = Slice(0, 9) pre_vertex = pre_app_vertex.create_machine_vertex( pre_vertex_slice, None) post_app_vertex = SimpleApplicationVertex(10) post_vertex_slice = Slice(0, 9) post_vertex = post_app_vertex.create_machine_vertex( post_vertex_slice, None) post_slice_index = 0 one_to_one_connector_1 = OneToOneConnector(None) direct_synapse_information_1 = SynapseInformation( one_to_one_connector_1, pre_app_vertex, post_app_vertex, False, False, None, SynapseDynamicsStatic(), 0, 1.5, 1.0) one_to_one_connector_1.set_projection_information( machine_time_step, direct_synapse_information_1) one_to_one_connector_2 = OneToOneConnector(None) direct_synapse_information_2 = SynapseInformation( one_to_one_connector_2, pre_app_vertex, post_app_vertex, False, False, None, SynapseDynamicsStatic(), 1, 2.5, 2.0) one_to_one_connector_2.set_projection_information( machine_time_step, direct_synapse_information_2) all_to_all_connector = AllToAllConnector(None) all_to_all_synapse_information = SynapseInformation( all_to_all_connector, pre_app_vertex, post_app_vertex, False, False, None, SynapseDynamicsStatic(), 0, 4.5, 4.0) all_to_all_connector.set_projection_information( machine_time_step, all_to_all_synapse_information) app_edge = ProjectionApplicationEdge(pre_app_vertex, post_app_vertex, direct_synapse_information_1) app_edge.add_synapse_information(direct_synapse_information_2) app_edge.add_synapse_information(all_to_all_synapse_information) machine_edge = app_edge.create_machine_edge(pre_vertex, post_vertex, label=None) partition_name = "TestPartition" graph = MachineGraph("Test") graph.add_vertex(pre_vertex) graph.add_vertex(post_vertex) graph.add_edge(machine_edge, partition_name) weight_scales = [4096.0, 4096.0] key = 0 routing_info = RoutingInfo() routing_info.add_partition_info( PartitionRoutingInfo( [BaseKeyAndMask(key, 0xFFFFFFF0)], graph.get_outgoing_edge_partition_starting_at_vertex( pre_vertex, partition_name))) temp_spec = tempfile.mktemp() spec_writer = FileDataWriter(temp_spec) spec = DataSpecificationGenerator(spec_writer, None) master_pop_sz = 1000 all_syn_block_sz = 2000 master_pop_region = 0 synapse_region = 1 direct_region = 2 spec.reserve_memory_region(master_pop_region, master_pop_sz) spec.reserve_memory_region(synapse_region, all_syn_block_sz) synaptic_manager = SynapticManager(n_synapse_types=2, ring_buffer_sigma=5.0, spikes_per_second=100.0, config=config) # Poke in our testing region IDs synaptic_manager._pop_table_region = master_pop_region synaptic_manager._synaptic_matrix_region = synapse_region synaptic_manager._direct_matrix_region = direct_region synaptic_manager._write_synaptic_matrix_and_master_population_table( spec, [post_vertex_slice], post_slice_index, post_vertex, post_vertex_slice, all_syn_block_sz, weight_scales, routing_info, graph, machine_time_step) spec.end_specification() spec_writer.close() spec_reader = FileDataReader(temp_spec) executor = DataSpecificationExecutor(spec_reader, master_pop_sz + all_syn_block_sz) executor.execute() master_pop_table = executor.get_region(0) synaptic_matrix = executor.get_region(1) direct_matrix = executor.get_region(2) all_data = bytearray() all_data.extend( master_pop_table.region_data[:master_pop_table.max_write_pointer]) all_data.extend( synaptic_matrix.region_data[:synaptic_matrix.max_write_pointer]) all_data.extend( direct_matrix.region_data[:direct_matrix.max_write_pointer]) master_pop_table_address = 0 synaptic_matrix_address = master_pop_table.max_write_pointer direct_synapses_address = (synaptic_matrix_address + synaptic_matrix.max_write_pointer) direct_synapses_address += 4 indirect_synapses_address = synaptic_matrix_address placement = Placement(None, 0, 0, 1) transceiver = MockTransceiverRawData(all_data) # Get the master population table details items = synaptic_manager._extract_synaptic_matrix_data_location( key, master_pop_table_address, transceiver, placement) # The first entry should be direct, but the rest should be indirect; # the second is potentially direct, but has been restricted by the # restriction on the size of the direct matrix assert len(items) == 3 assert items[0][2] assert not items[1][2] assert not items[2][2] data_1, row_len_1 = synaptic_manager._retrieve_synaptic_block( txrx=transceiver, placement=placement, master_pop_table_address=master_pop_table_address, indirect_synapses_address=indirect_synapses_address, direct_synapses_address=direct_synapses_address, key=key, n_rows=pre_vertex_slice.n_atoms, index=0, using_monitors=False) connections_1 = synaptic_manager._read_synapses( direct_synapse_information_1, pre_vertex_slice, post_vertex_slice, row_len_1, 0, weight_scales, data_1, None, machine_time_step) # The first matrix is a 1-1 matrix, so row length is 1 assert row_len_1 == 1 # 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]) data_2, row_len_2 = synaptic_manager._retrieve_synaptic_block( txrx=transceiver, placement=placement, master_pop_table_address=master_pop_table_address, indirect_synapses_address=indirect_synapses_address, direct_synapses_address=direct_synapses_address, key=key, n_rows=pre_vertex_slice.n_atoms, index=1, using_monitors=False) connections_2 = synaptic_manager._read_synapses( direct_synapse_information_2, pre_vertex_slice, post_vertex_slice, row_len_2, 0, weight_scales, data_2, None, machine_time_step) # The second matrix is a 1-1 matrix, so row length is 1 assert row_len_2 == 1 # 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]) data_3, row_len_3 = synaptic_manager._retrieve_synaptic_block( txrx=transceiver, placement=placement, master_pop_table_address=master_pop_table_address, indirect_synapses_address=indirect_synapses_address, direct_synapses_address=direct_synapses_address, key=key, n_rows=pre_vertex_slice.n_atoms, index=2, using_monitors=False) connections_3 = synaptic_manager._read_synapses( all_to_all_synapse_information, pre_vertex_slice, post_vertex_slice, row_len_3, 0, weight_scales, data_3, None, machine_time_step) # The third matrix is an all-to-all matrix, so length is n_atoms assert row_len_3 == post_vertex_slice.n_atoms # Check that all the connections have the right weight and delay assert len(connections_3) == \ post_vertex_slice.n_atoms * pre_vertex_slice.n_atoms assert all([conn["weight"] == 4.5 for conn in connections_3]) assert all([conn["delay"] == 4.0 for conn in connections_3])