def __init__(self, n_neurons, constraints=non_pynn_default_parameters['constraints'], label=non_pynn_default_parameters['label'], rate=default_parameters['rate'], start=default_parameters['start'], duration=default_parameters['duration'], seed=non_pynn_default_parameters['seed']): # pylint: disable=too-many-arguments super(SpikeSourcePoisson, self).__init__(label, constraints, self._model_based_max_atoms_per_core) config = globals_variables.get_simulator().config # atoms params self._n_atoms = n_neurons self._model_name = "SpikeSourcePoisson" self._seed = None # check for changes parameters self._change_requires_mapping = True self._change_requires_neuron_parameters_reload = False # Store the parameters self._rate = utility_calls.convert_param_to_numpy(rate, n_neurons) self._start = utility_calls.convert_param_to_numpy(start, n_neurons) self._duration = utility_calls.convert_param_to_numpy( duration, n_neurons) self._time_to_spike = utility_calls.convert_param_to_numpy( 0, n_neurons) self._rng = numpy.random.RandomState(seed) self._machine_time_step = None # Prepare for recording, and to get spikes self._spike_recorder = MultiSpikeRecorder() self._time_between_requests = config.getint("Buffers", "time_between_requests") self._receive_buffer_host = config.get("Buffers", "receive_buffer_host") self._receive_buffer_port = helpful_functions.read_config_int( config, "Buffers", "receive_buffer_port") self._minimum_buffer_sdram = config.getint("Buffers", "minimum_buffer_sdram") self._using_auto_pause_and_resume = config.getboolean( "Buffers", "use_auto_pause_and_resume") spike_buffer_max_size = 0 self._buffer_size_before_receive = None if config.getboolean("Buffers", "enable_buffered_recording"): spike_buffer_max_size = config.getint("Buffers", "spike_buffer_size") self._buffer_size_before_receive = config.getint( "Buffers", "buffer_size_before_receive") self._maximum_sdram_for_buffering = [spike_buffer_max_size]
def __init__(self, n_neurons, constraints, label, rate, start, duration, seed, max_atoms_per_core, model): # pylint: disable=too-many-arguments super(SpikeSourcePoissonVertex, self).__init__(label, constraints, max_atoms_per_core) config = globals_variables.get_simulator().config # atoms params self._n_atoms = n_neurons self._model_name = "SpikeSourcePoisson" self._model = model self._seed = seed self._kiss_seed = dict() self._rng = None self._n_subvertices = 0 self._n_data_specs = 0 # check for changes parameters self._change_requires_mapping = True self._change_requires_neuron_parameters_reload = False # Store the parameters self._rate = utility_calls.convert_param_to_numpy(rate, n_neurons) self._rate_change = numpy.zeros(self._rate.size) self._start = utility_calls.convert_param_to_numpy(start, n_neurons) self._duration = utility_calls.convert_param_to_numpy( duration, n_neurons) self._time_to_spike = utility_calls.convert_param_to_numpy( 0, n_neurons) self._machine_time_step = None # Prepare for recording, and to get spikes self._spike_recorder = MultiSpikeRecorder() self._time_between_requests = config.getint("Buffers", "time_between_requests") self._receive_buffer_host = config.get("Buffers", "receive_buffer_host") self._receive_buffer_port = helpful_functions.read_config_int( config, "Buffers", "receive_buffer_port") self._minimum_buffer_sdram = config.getint("Buffers", "minimum_buffer_sdram") self._using_auto_pause_and_resume = config.getboolean( "Buffers", "use_auto_pause_and_resume") spike_buffer_max_size = 0 self._buffer_size_before_receive = None if config.getboolean("Buffers", "enable_buffered_recording"): spike_buffer_max_size = config.getint("Buffers", "spike_buffer_size") self._buffer_size_before_receive = config.getint( "Buffers", "buffer_size_before_receive") self._maximum_sdram_for_buffering = [spike_buffer_max_size]
def __init__(self, n_neurons, constraints, label, rate, max_rate, start, duration, seed, max_atoms_per_core, model): # pylint: disable=too-many-arguments super(SpikeSourcePoissonVertex, self).__init__(label, constraints, max_atoms_per_core) # atoms params self.__n_atoms = n_neurons self.__model_name = "SpikeSourcePoisson" self.__model = model self.__seed = seed self.__kiss_seed = dict() self.__rng = None self.__n_subvertices = 0 self.__n_data_specs = 0 # check for changes parameters self.__change_requires_mapping = True self.__change_requires_neuron_parameters_reload = False self.__spike_recorder = MultiSpikeRecorder() # Store the parameters self.__max_rate = max_rate self.__rate = self.convert_rate(rate) self.__rate_change = numpy.zeros(self.__rate.size) self.__start = utility_calls.convert_param_to_numpy(start, n_neurons) self.__duration = utility_calls.convert_param_to_numpy( duration, n_neurons) self.__time_to_spike = utility_calls.convert_param_to_numpy( 0, n_neurons) self.__machine_time_step = None # get config from simulator config = globals_variables.get_simulator().config self.__n_profile_samples = helpful_functions.read_config_int( config, "Reports", "n_profile_samples") # Prepare for recording, and to get spikes self.__spike_recorder = MultiSpikeRecorder()
def __init__( self, n_neurons, constraints, label, rate, max_rate, start, duration, seed, max_atoms_per_core, model): # pylint: disable=too-many-arguments super(SpikeSourcePoissonVertex, self).__init__( label, constraints, max_atoms_per_core) # atoms params self._n_atoms = n_neurons self._model_name = "SpikeSourcePoisson" self._model = model self._seed = seed self._kiss_seed = dict() self._rng = None self._n_subvertices = 0 self._n_data_specs = 0 # check for changes parameters self._change_requires_mapping = True self._change_requires_neuron_parameters_reload = False # Prepare for recording, and to get spikes self._spike_recorder = MultiSpikeRecorder() # Store the parameters self._max_rate = max_rate self._rate = self.convert_rate(rate) self._rate_change = numpy.zeros(self._rate.size) self._start = utility_calls.convert_param_to_numpy(start, n_neurons) self._duration = utility_calls.convert_param_to_numpy( duration, n_neurons) self._time_to_spike = utility_calls.convert_param_to_numpy( 0, n_neurons) self._machine_time_step = None # Prepare for recording, and to get spikes self._spike_recorder = MultiSpikeRecorder()
def __init__(self, n_neurons, constraints, label, rate, max_rate, start, duration, seed, max_atoms_per_core, model): # pylint: disable=too-many-arguments super(SpikeSourcePoissonVertex, self).__init__(label, constraints, max_atoms_per_core) # atoms params self._n_atoms = n_neurons self._model_name = "SpikeSourcePoisson" self._model = model self._seed = seed self._kiss_seed = dict() self._rng = None self._n_subvertices = 0 self._n_data_specs = 0 # check for changes parameters self._change_requires_mapping = True self._change_requires_neuron_parameters_reload = False # Prepare for recording, and to get spikes self._spike_recorder = MultiSpikeRecorder() # Store the parameters self._max_rate = max_rate self._rate = self.convert_rate(rate) self._rate_change = numpy.zeros(self._rate.size) self._start = utility_calls.convert_param_to_numpy(start, n_neurons) self._duration = utility_calls.convert_param_to_numpy( duration, n_neurons) self._time_to_spike = utility_calls.convert_param_to_numpy( 0, n_neurons) self._machine_time_step = None # Prepare for recording, and to get spikes self._spike_recorder = MultiSpikeRecorder()
class SpikeSourcePoissonVertex( ApplicationVertex, AbstractGeneratesDataSpecification, AbstractHasAssociatedBinary, AbstractSpikeRecordable, AbstractProvidesOutgoingPartitionConstraints, AbstractChangableAfterRun, AbstractReadParametersBeforeSet, AbstractRewritesDataSpecification, SimplePopulationSettable, ProvidesKeyToAtomMappingImpl): """ A Poisson Spike source object """ SPIKE_RECORDING_REGION_ID = 0 def __init__( self, n_neurons, constraints, label, rate, max_rate, start, duration, seed, max_atoms_per_core, model): # pylint: disable=too-many-arguments super(SpikeSourcePoissonVertex, self).__init__( label, constraints, max_atoms_per_core) # atoms params self._n_atoms = n_neurons self._model_name = "SpikeSourcePoisson" self._model = model self._seed = seed self._kiss_seed = dict() self._rng = None self._n_subvertices = 0 self._n_data_specs = 0 # check for changes parameters self._change_requires_mapping = True self._change_requires_neuron_parameters_reload = False # Prepare for recording, and to get spikes self._spike_recorder = MultiSpikeRecorder() # Store the parameters self._max_rate = max_rate self._rate = self.convert_rate(rate) self._rate_change = numpy.zeros(self._rate.size) self._start = utility_calls.convert_param_to_numpy(start, n_neurons) self._duration = utility_calls.convert_param_to_numpy( duration, n_neurons) self._time_to_spike = utility_calls.convert_param_to_numpy( 0, n_neurons) self._machine_time_step = None # Prepare for recording, and to get spikes self._spike_recorder = MultiSpikeRecorder() @property @overrides(AbstractChangableAfterRun.requires_mapping) def requires_mapping(self): return self._change_requires_mapping @overrides(AbstractChangableAfterRun.mark_no_changes) def mark_no_changes(self): self._change_requires_mapping = False @overrides(SimplePopulationSettable.set_value) def set_value(self, key, value): SimplePopulationSettable.set_value(self, key, value) self._change_requires_neuron_parameters_reload = True def _max_spikes_per_ts(self, machine_time_step): ts_per_second = MICROSECONDS_PER_SECOND / float(machine_time_step) if float(self._max_rate) / ts_per_second <= \ SLOW_RATE_PER_TICK_CUTOFF: return 1 # experiement show at 1000 is result is typically higher than actual chance_ts = 1000 max_spikes_per_ts = scipy.stats.poisson.ppf( 1.0 - (1.0 / float(chance_ts)), float(self._max_rate) / ts_per_second) return int(math.ceil(max_spikes_per_ts)) + 1.0 def get_recording_sdram_usage(self, vertex_slice, machine_time_step): variable_sdram = self._spike_recorder.get_sdram_usage_in_bytes( vertex_slice.n_atoms, self._max_spikes_per_ts(machine_time_step)) constant_sdram = ConstantSDRAM( variable_sdram.per_timestep * OVERFLOW_TIMESTEPS_FOR_SDRAM) return variable_sdram + constant_sdram @inject_items({ "machine_time_step": "MachineTimeStep" }) @overrides( ApplicationVertex.get_resources_used_by_atoms, additional_arguments={"machine_time_step"} ) def get_resources_used_by_atoms(self, vertex_slice, machine_time_step): # pylint: disable=arguments-differ poisson_params_sz = self.get_params_bytes(vertex_slice) other = ConstantSDRAM( SYSTEM_BYTES_REQUIREMENT + SpikeSourcePoissonMachineVertex.get_provenance_data_size(0) + poisson_params_sz + recording_utilities.get_recording_header_size(1) + recording_utilities.get_recording_data_constant_size(1)) recording = self.get_recording_sdram_usage( vertex_slice, machine_time_step) # build resources as i currently know container = ResourceContainer( sdram=recording + other, dtcm=DTCMResource(self.get_dtcm_usage_for_atoms()), cpu_cycles=CPUCyclesPerTickResource( self.get_cpu_usage_for_atoms())) return container @property def n_atoms(self): return self._n_atoms def create_machine_vertex( self, vertex_slice, resources_required, label=None, constraints=None): # pylint: disable=too-many-arguments, arguments-differ self._n_subvertices += 1 return SpikeSourcePoissonMachineVertex( resources_required, self._spike_recorder.record, constraints, label) @property def rate(self): return self._rate def convert_rate(self, rate): new_rates = utility_calls.convert_param_to_numpy(rate, self._n_atoms) new_max = max(new_rates) if self._max_rate is None: self._max_rate = new_max # Setting record forces reset so ok to go over if not recording elif self._spike_recorder.record and new_max > self._max_rate: logger.info('Increasing spike rate while recording requires a ' '"reset unless additional_parameters "max_rate" is ' 'set') self._change_requires_mapping = True self._max_rate = new_max return new_rates @rate.setter def rate(self, rate): new_rate = self.convert_rate(rate) self._rate_change = new_rate - self._rate self._rate = new_rate @property def start(self): return self._start @start.setter def start(self, start): self._start = utility_calls.convert_param_to_numpy( start, self._n_atoms) @property def duration(self): return self._duration @duration.setter def duration(self, duration): self._duration = utility_calls.convert_param_to_numpy( duration, self._n_atoms) @property def seed(self): return self._seed @seed.setter def seed(self, seed): self._seed = seed self._kiss_seed = dict() self._rng = None @staticmethod def get_params_bytes(vertex_slice): """ Gets the size of the poisson parameters in bytes :param vertex_slice: """ return (PARAMS_BASE_WORDS + (vertex_slice.n_atoms * PARAMS_WORDS_PER_NEURON)) * 4 def reserve_memory_regions(self, spec, placement, graph_mapper): """ Reserve memory regions for poisson source parameters and output\ buffer. :param spec: the data specification writer :param placement: the location this vertex resides on in the machine :param graph_mapper: the mapping between app and machine graphs :return: None """ spec.comment("\nReserving memory space for data regions:\n\n") # Reserve memory: spec.reserve_memory_region( region=_REGIONS.SYSTEM_REGION.value, size=SIMULATION_N_BYTES, label='setup') # reserve poisson params dsg region self._reserve_poisson_params_region(placement, graph_mapper, spec) spec.reserve_memory_region( region=_REGIONS.SPIKE_HISTORY_REGION.value, size=recording_utilities.get_recording_header_size(1), label="Recording") placement.vertex.reserve_provenance_data_region(spec) def _reserve_poisson_params_region(self, placement, graph_mapper, spec): """ does the allocation for the poisson params region itself, as\ it can be reused for setters after an initial run :param placement: the location on machine for this vertex :param graph_mapper: the mapping between machine and application graphs :param spec: the dsg writer :return: None """ spec.reserve_memory_region( region=_REGIONS.POISSON_PARAMS_REGION.value, size=self.get_params_bytes(graph_mapper.get_slice( placement.vertex)), label='PoissonParams') def _write_poisson_parameters( self, spec, graph, placement, routing_info, vertex_slice, machine_time_step, time_scale_factor): """ Generate Neuron Parameter data for Poisson spike sources :param spec: the data specification writer :param key: the routing key for this vertex :param vertex_slice:\ the slice of atoms a machine vertex holds from its application\ vertex :param machine_time_step: the time between timer tick updates. :param time_scale_factor:\ the scaling between machine time step and real time :return: None """ # pylint: disable=too-many-arguments, too-many-locals spec.comment("\nWriting Neuron Parameters for {} poisson sources:\n" .format(vertex_slice.n_atoms)) # Set the focus to the memory region 2 (neuron parameters): spec.switch_write_focus(_REGIONS.POISSON_PARAMS_REGION.value) # Write Key info for this core: key = routing_info.get_first_key_from_pre_vertex( placement.vertex, constants.SPIKE_PARTITION_ID) spec.write_value(data=1 if key is not None else 0) spec.write_value(data=key if key is not None else 0) # Write the incoming mask if there is one in_edges = graph.get_edges_ending_at_vertex_with_partition_name( placement.vertex, constants.LIVE_POISSON_CONTROL_PARTITION_ID) if len(in_edges) > 1: raise ConfigurationException( "Only one control edge can end at a Poisson vertex") incoming_mask = 0 if len(in_edges) == 1: in_edge = in_edges[0] # Get the mask of the incoming keys incoming_mask = \ routing_info.get_routing_info_for_edge(in_edge).first_mask incoming_mask = ~incoming_mask & 0xFFFFFFFF spec.write_value(incoming_mask) # Write the offset value max_offset = ( machine_time_step * time_scale_factor) // _MAX_OFFSET_DENOMINATOR spec.write_value( int(math.ceil(max_offset / self._n_subvertices)) * self._n_data_specs) self._n_data_specs += 1 # Write the number of microseconds between sending spikes total_mean_rate = numpy.sum(self._rate) if total_mean_rate > 0: max_spikes = numpy.sum(scipy.stats.poisson.ppf( 1.0 - (1.0 / self._rate), self._rate)) spikes_per_timestep = ( max_spikes / (MICROSECONDS_PER_SECOND // machine_time_step)) # avoid a possible division by zero / small number (which may # result in a value that doesn't fit in a uint32) by only # setting time_between_spikes if spikes_per_timestep is > 1 time_between_spikes = 1.0 if spikes_per_timestep > 1: time_between_spikes = ( (machine_time_step * time_scale_factor) / (spikes_per_timestep * 2.0)) spec.write_value(data=int(time_between_spikes)) else: # If the rate is 0 or less, set a "time between spikes" of 1 # to ensure that some time is put between spikes in event # of a rate change later on spec.write_value(data=1) # Write the number of seconds per timestep (unsigned long fract) spec.write_value( data=float(machine_time_step) / MICROSECONDS_PER_SECOND, data_type=DataType.U032) # Write the number of timesteps per second (accum) spec.write_value( data=MICROSECONDS_PER_SECOND / float(machine_time_step), data_type=DataType.S1615) # Write the slow-rate-per-tick-cutoff (accum) spec.write_value( data=SLOW_RATE_PER_TICK_CUTOFF, data_type=DataType.S1615) # Write the lo_atom id spec.write_value(data=vertex_slice.lo_atom) # Write the number of sources spec.write_value(data=vertex_slice.n_atoms) # Write the random seed (4 words), generated randomly! kiss_key = (vertex_slice.lo_atom, vertex_slice.hi_atom) if kiss_key not in self._kiss_seed: if self._rng is None: self._rng = numpy.random.RandomState(self._seed) self._kiss_seed[kiss_key] = [ self._rng.randint(-0x80000000, 0x7FFFFFFF) + 0x80000000 for _ in range(4)] for value in self._kiss_seed[kiss_key]: spec.write_value(data=value) # Compute the start times in machine time steps start = self._start[vertex_slice.as_slice] start_scaled = self._convert_ms_to_n_timesteps( start, machine_time_step) # Compute the end times as start times + duration in machine time steps # (where duration is not None) duration = self._duration[vertex_slice.as_slice] end_scaled = numpy.zeros(len(duration), dtype="uint32") none_positions = numpy.isnan(duration) positions = numpy.invert(none_positions) end_scaled[none_positions] = 0xFFFFFFFF end_scaled[positions] = self._convert_ms_to_n_timesteps( start[positions] + duration[positions], machine_time_step) # Get the rates for the atoms rates = self._rate[vertex_slice.as_slice].astype("float") # Compute the spikes per tick for each atom spikes_per_tick = ( rates * (float(machine_time_step) / MICROSECONDS_PER_SECOND)) # Determine which sources are fast and which are slow is_fast_source = spikes_per_tick > SLOW_RATE_PER_TICK_CUTOFF # Compute the e^-(spikes_per_tick) for fast sources to allow fast # computation of the Poisson distribution to get the number of spikes # per timestep exp_minus_lambda = numpy.zeros(len(spikes_per_tick), dtype="float") exp_minus_lambda[is_fast_source] = numpy.exp( -1.0 * spikes_per_tick[is_fast_source]) # Compute the inter-spike-interval for slow sources to get the average # number of timesteps between spikes isi_val = numpy.zeros(len(spikes_per_tick), dtype="float") elements = numpy.logical_not(is_fast_source) & (spikes_per_tick > 0) isi_val[elements] = 1.0 / spikes_per_tick[elements] # Get the time to spike value time_to_spike = self._time_to_spike[vertex_slice.as_slice] changed_rates = ( self._rate_change[vertex_slice.as_slice].astype("bool") & elements) time_to_spike[changed_rates] = 0.0 # Merge the arrays as parameters per atom data = numpy.dstack(( start_scaled.astype("uint32"), end_scaled.astype("uint32"), is_fast_source.astype("uint32"), (exp_minus_lambda * (2 ** 32)).astype("uint32"), (isi_val * (2 ** 15)).astype("uint32"), (time_to_spike * (2 ** 15)).astype("uint32") ))[0] spec.write_array(data) @staticmethod def _convert_ms_to_n_timesteps(value, machine_time_step): return numpy.round( value * (MICROSECONDS_PER_MILLISECOND / float(machine_time_step))) @staticmethod def _convert_n_timesteps_to_ms(value, machine_time_step): return ( value / (MICROSECONDS_PER_MILLISECOND / float(machine_time_step))) @overrides(AbstractSpikeRecordable.is_recording_spikes) def is_recording_spikes(self): return self._spike_recorder.record @overrides(AbstractSpikeRecordable.set_recording_spikes) def set_recording_spikes( self, new_state=True, sampling_interval=None, indexes=None): if sampling_interval is not None: logger.warning("Sampling interval currently not supported for " "SpikeSourcePoisson so being ignored") if indexes is not None: logger.warning("indexes not supported for " "SpikeSourcePoisson so being ignored") if new_state and not self._spike_recorder.record: self._change_requires_mapping = True self._spike_recorder.record = new_state @overrides(AbstractSpikeRecordable.get_spikes_sampling_interval) def get_spikes_sampling_interval(self): return globals_variables.get_simulator().machine_time_step @staticmethod def get_dtcm_usage_for_atoms(): return 0 @staticmethod def get_cpu_usage_for_atoms(): return 0 @inject_items({ "machine_time_step": "MachineTimeStep", "time_scale_factor": "TimeScaleFactor", "graph_mapper": "MemoryGraphMapper", "routing_info": "MemoryRoutingInfos", "graph": "MemoryMachineGraph"}) @overrides( AbstractRewritesDataSpecification.regenerate_data_specification, additional_arguments={ "machine_time_step", "time_scale_factor", "graph_mapper", "routing_info", "graph"}) def regenerate_data_specification( self, spec, placement, machine_time_step, time_scale_factor, graph_mapper, routing_info, graph): # pylint: disable=too-many-arguments, arguments-differ # reserve the neuron parameters data region self._reserve_poisson_params_region(placement, graph_mapper, spec) # allocate parameters self._write_poisson_parameters( spec=spec, graph=graph, placement=placement, routing_info=routing_info, vertex_slice=graph_mapper.get_slice(placement.vertex), machine_time_step=machine_time_step, time_scale_factor=time_scale_factor) # end spec spec.end_specification() @overrides(AbstractRewritesDataSpecification .requires_memory_regions_to_be_reloaded) def requires_memory_regions_to_be_reloaded(self): return self._change_requires_neuron_parameters_reload @overrides(AbstractRewritesDataSpecification.mark_regions_reloaded) def mark_regions_reloaded(self): self._change_requires_neuron_parameters_reload = False @overrides(AbstractReadParametersBeforeSet.read_parameters_from_machine) def read_parameters_from_machine( self, transceiver, placement, vertex_slice): # locate sdram address to where the neuron parameters are stored poisson_parameter_region_sdram_address = \ helpful_functions.locate_memory_region_for_placement( placement, _REGIONS.POISSON_PARAMS_REGION.value, transceiver) # shift past the extra stuff before neuron parameters that we don't # need to read poisson_parameter_parameters_sdram_address = \ poisson_parameter_region_sdram_address + \ START_OF_POISSON_GENERATOR_PARAMETERS # get size of poisson params size_of_region = self.get_params_bytes(vertex_slice) size_of_region -= START_OF_POISSON_GENERATOR_PARAMETERS # get data from the machine byte_array = transceiver.read_memory( placement.x, placement.y, poisson_parameter_parameters_sdram_address, size_of_region) # Convert the data to parameter values (start, end, is_fast_source, exp_minus_lambda, isi, time_to_next_spike) = _PoissonStruct.read_data( byte_array, 0, vertex_slice.n_atoms) # Convert start values as timesteps into milliseconds self._start[vertex_slice.as_slice] = self._convert_n_timesteps_to_ms( start, self._machine_time_step) # Convert end values as timesteps to durations in milliseconds self._duration[vertex_slice.as_slice] = ( self._convert_n_timesteps_to_ms(end, self._machine_time_step) - self._start[vertex_slice.as_slice]) # Work out the spikes per tick depending on if the source is slow # or fast is_fast_source = is_fast_source == 1.0 spikes_per_tick = numpy.zeros(len(is_fast_source), dtype="float") spikes_per_tick[is_fast_source] = numpy.log( exp_minus_lambda[is_fast_source]) * -1.0 slow_elements = isi > 0 spikes_per_tick[slow_elements] = 1.0 / isi[slow_elements] # Convert spikes per tick to rates self._rate[vertex_slice.as_slice] = ( spikes_per_tick * (MICROSECONDS_PER_SECOND / float(self._machine_time_step))) # Store the updated time until next spike so that it can be # rewritten when the parameters are loaded self._time_to_spike[vertex_slice.as_slice] = time_to_next_spike @inject_items({ "machine_time_step": "MachineTimeStep", "time_scale_factor": "TimeScaleFactor", "graph_mapper": "MemoryGraphMapper", "routing_info": "MemoryRoutingInfos", "data_n_time_steps": "DataNTimeSteps", "graph": "MemoryMachineGraph" }) @overrides( AbstractGeneratesDataSpecification.generate_data_specification, additional_arguments={ "machine_time_step", "time_scale_factor", "graph_mapper", "routing_info", "data_n_time_steps", "graph" } ) def generate_data_specification( self, spec, placement, machine_time_step, time_scale_factor, graph_mapper, routing_info, data_n_time_steps, graph): # pylint: disable=too-many-arguments, arguments-differ self._machine_time_step = machine_time_step vertex = placement.vertex vertex_slice = graph_mapper.get_slice(vertex) spec.comment("\n*** Spec for SpikeSourcePoisson Instance ***\n\n") # Reserve SDRAM space for memory areas: self.reserve_memory_regions(spec, placement, graph_mapper) # write setup data spec.switch_write_focus(_REGIONS.SYSTEM_REGION.value) spec.write_array(simulation_utilities.get_simulation_header_array( self.get_binary_file_name(), machine_time_step, time_scale_factor)) # write recording data spec.switch_write_focus(_REGIONS.SPIKE_HISTORY_REGION.value) sdram = self.get_recording_sdram_usage( vertex_slice, machine_time_step) recorded_region_sizes = [sdram.get_total_sdram(data_n_time_steps)] spec.write_array(recording_utilities.get_recording_header_array( recorded_region_sizes)) # write parameters self._write_poisson_parameters( spec, graph, placement, routing_info, vertex_slice, machine_time_step, time_scale_factor) # End-of-Spec: spec.end_specification() @overrides(AbstractHasAssociatedBinary.get_binary_file_name) def get_binary_file_name(self): return "spike_source_poisson.aplx" @overrides(AbstractHasAssociatedBinary.get_binary_start_type) def get_binary_start_type(self): return ExecutableType.USES_SIMULATION_INTERFACE @overrides(AbstractSpikeRecordable.get_spikes) def get_spikes( self, placements, graph_mapper, buffer_manager, machine_time_step): return self._spike_recorder.get_spikes( self.label, buffer_manager, SpikeSourcePoissonVertex.SPIKE_RECORDING_REGION_ID, placements, graph_mapper, self, machine_time_step) @overrides(AbstractProvidesOutgoingPartitionConstraints. get_outgoing_partition_constraints) def get_outgoing_partition_constraints(self, partition): return [ContiguousKeyRangeContraint()] @overrides(AbstractSpikeRecordable.clear_spike_recording) def clear_spike_recording(self, buffer_manager, placements, graph_mapper): machine_vertices = graph_mapper.get_machine_vertices(self) for machine_vertex in machine_vertices: placement = placements.get_placement_of_vertex(machine_vertex) buffer_manager.clear_recorded_data( placement.x, placement.y, placement.p, SpikeSourcePoissonVertex.SPIKE_RECORDING_REGION_ID) def describe(self): """ Returns a human-readable description of the cell or synapse type. The output may be customised by specifying a different template together with an associated template engine (see ``pyNN.descriptions``). If template is None, then a dictionary containing the template context will be returned. """ parameters = dict() for parameter_name in self._model.default_parameters: parameters[parameter_name] = self.get_value(parameter_name) context = { "name": self._model_name, "default_parameters": self._model.default_parameters, "default_initial_values": self._model.default_parameters, "parameters": parameters, } return context @property def max_rate(self): return self._max_rate
class SpikeSourcePoissonVertex( ApplicationVertex, AbstractGeneratesDataSpecification, AbstractHasAssociatedBinary, AbstractSpikeRecordable, AbstractProvidesOutgoingPartitionConstraints, AbstractChangableAfterRun, AbstractReadParametersBeforeSet, AbstractRewritesDataSpecification, SimplePopulationSettable, ProvidesKeyToAtomMappingImpl): """ A Poisson Spike source object """ _N_POPULATION_RECORDING_REGIONS = 1 _DEFAULT_MALLOCS_USED = 2 SPIKE_RECORDING_REGION_ID = 0 # A count of the number of poisson vertices, to work out the random # back off range _n_poisson_machine_vertices = 0 def __init__(self, n_neurons, constraints, label, rate, start, duration, seed, max_atoms_per_core, model): # pylint: disable=too-many-arguments super(SpikeSourcePoissonVertex, self).__init__(label, constraints, max_atoms_per_core) config = globals_variables.get_simulator().config # atoms params self._n_atoms = n_neurons self._model_name = "SpikeSourcePoisson" self._model = model self._seed = seed self._kiss_seed = dict() self._rng = None # check for changes parameters self._change_requires_mapping = True self._change_requires_neuron_parameters_reload = False # Store the parameters self._rate = utility_calls.convert_param_to_numpy(rate, n_neurons) self._rate_change = numpy.zeros(self._rate.size) self._start = utility_calls.convert_param_to_numpy(start, n_neurons) self._duration = utility_calls.convert_param_to_numpy( duration, n_neurons) self._time_to_spike = utility_calls.convert_param_to_numpy( 0, n_neurons) self._machine_time_step = None # Prepare for recording, and to get spikes self._spike_recorder = MultiSpikeRecorder() self._time_between_requests = config.getint("Buffers", "time_between_requests") self._receive_buffer_host = config.get("Buffers", "receive_buffer_host") self._receive_buffer_port = helpful_functions.read_config_int( config, "Buffers", "receive_buffer_port") self._minimum_buffer_sdram = config.getint("Buffers", "minimum_buffer_sdram") self._using_auto_pause_and_resume = config.getboolean( "Buffers", "use_auto_pause_and_resume") spike_buffer_max_size = 0 self._buffer_size_before_receive = None if config.getboolean("Buffers", "enable_buffered_recording"): spike_buffer_max_size = config.getint("Buffers", "spike_buffer_size") self._buffer_size_before_receive = config.getint( "Buffers", "buffer_size_before_receive") self._maximum_sdram_for_buffering = [spike_buffer_max_size] @property @overrides(AbstractChangableAfterRun.requires_mapping) def requires_mapping(self): return self._change_requires_mapping @overrides(AbstractChangableAfterRun.mark_no_changes) def mark_no_changes(self): self._change_requires_mapping = False @overrides(SimplePopulationSettable.set_value) def set_value(self, key, value): SimplePopulationSettable.set_value(self, key, value) self._change_requires_neuron_parameters_reload = True def _max_spikes_per_ts(self, vertex_slice, n_machine_time_steps, machine_time_step): max_rate = numpy.amax(self._rate[vertex_slice.as_slice]) if max_rate == 0: return 0 ts_per_second = MICROSECONDS_PER_SECOND / float(machine_time_step) max_spikes_per_ts = scipy.stats.poisson.ppf( 1.0 - (1.0 / float(n_machine_time_steps)), float(max_rate) / ts_per_second) return int(math.ceil(max_spikes_per_ts)) + 1.0 @inject_items({ "n_machine_time_steps": "TotalMachineTimeSteps", "machine_time_step": "MachineTimeStep" }) @overrides( ApplicationVertex.get_resources_used_by_atoms, additional_arguments={"n_machine_time_steps", "machine_time_step"}) def get_resources_used_by_atoms(self, vertex_slice, n_machine_time_steps, machine_time_step): # pylint: disable=arguments-differ # build resources as i currently know container = ResourceContainer( sdram=SDRAMResource(self.get_sdram_usage_for_atoms(vertex_slice)), dtcm=DTCMResource(self.get_dtcm_usage_for_atoms()), cpu_cycles=CPUCyclesPerTickResource( self.get_cpu_usage_for_atoms())) recording_sizes = recording_utilities.get_recording_region_sizes( [ self._spike_recorder.get_sdram_usage_in_bytes( vertex_slice.n_atoms, self._max_spikes_per_ts(vertex_slice, n_machine_time_steps, machine_time_step), self._N_POPULATION_RECORDING_REGIONS) * n_machine_time_steps ], self._minimum_buffer_sdram, self._maximum_sdram_for_buffering, self._using_auto_pause_and_resume) container.extend( recording_utilities.get_recording_resources( recording_sizes, self._receive_buffer_host, self._receive_buffer_port)) return container @property def n_atoms(self): return self._n_atoms @inject_items({ "n_machine_time_steps": "TotalMachineTimeSteps", "machine_time_step": "MachineTimeStep" }) @overrides( ApplicationVertex.create_machine_vertex, additional_arguments={"n_machine_time_steps", "machine_time_step"}) def create_machine_vertex(self, vertex_slice, resources_required, n_machine_time_steps, machine_time_step, label=None, constraints=None): # pylint: disable=too-many-arguments, arguments-differ SpikeSourcePoissonVertex._n_poisson_machine_vertices += 1 buffered_sdram_per_timestep =\ self._spike_recorder.get_sdram_usage_in_bytes( vertex_slice.n_atoms, self._max_spikes_per_ts( vertex_slice, n_machine_time_steps, machine_time_step), 1) minimum_buffer_sdram = recording_utilities.get_minimum_buffer_sdram( [buffered_sdram_per_timestep * n_machine_time_steps], self._minimum_buffer_sdram) return SpikeSourcePoissonMachineVertex(resources_required, self._spike_recorder.record, minimum_buffer_sdram[0], buffered_sdram_per_timestep, constraints, label) @property def rate(self): return self._rate @rate.setter def rate(self, rate): new_rate = utility_calls.convert_param_to_numpy(rate, self._n_atoms) self._rate_change = new_rate - self._rate self._rate = new_rate @property def start(self): return self._start @start.setter def start(self, start): self._start = utility_calls.convert_param_to_numpy( start, self._n_atoms) @property def duration(self): return self._duration @duration.setter def duration(self, duration): self._duration = utility_calls.convert_param_to_numpy( duration, self._n_atoms) @property def seed(self): return self._seed @seed.setter def seed(self, seed): self._seed = seed self._kiss_seed = dict() self._rng = None @staticmethod def get_params_bytes(vertex_slice): """ Gets the size of the poisson parameters in bytes :param vertex_slice: """ return (PARAMS_BASE_WORDS + (vertex_slice.n_atoms * PARAMS_WORDS_PER_NEURON)) * 4 def reserve_memory_regions(self, spec, placement, graph_mapper): """ Reserve memory regions for poisson source parameters and output\ buffer. :param spec: the data specification writer :param placement: the location this vertex resides on in the machine :param graph_mapper: the mapping between app and machine graphs :return: None """ spec.comment("\nReserving memory space for data regions:\n\n") # Reserve memory: spec.reserve_memory_region(region=_REGIONS.SYSTEM_REGION.value, size=SYSTEM_BYTES_REQUIREMENT, label='setup') # reserve poisson params dsg region self._reserve_poisson_params_region(placement, graph_mapper, spec) spec.reserve_memory_region( region=_REGIONS.SPIKE_HISTORY_REGION.value, size=recording_utilities.get_recording_header_size(1), label="Recording") placement.vertex.reserve_provenance_data_region(spec) def _reserve_poisson_params_region(self, placement, graph_mapper, spec): """ does the allocation for the poisson params region itself, as\ it can be reused for setters after an initial run :param placement: the location on machine for this vertex :param graph_mapper: the mapping between machine and application graphs :param spec: the dsg writer :return: None """ spec.reserve_memory_region(region=_REGIONS.POISSON_PARAMS_REGION.value, size=self.get_params_bytes( graph_mapper.get_slice( placement.vertex)), label='PoissonParams') def _write_poisson_parameters(self, spec, graph, placement, routing_info, vertex_slice, machine_time_step, time_scale_factor): """ Generate Neuron Parameter data for Poisson spike sources :param spec: the data specification writer :param key: the routing key for this vertex :param vertex_slice:\ the slice of atoms a machine vertex holds from its application\ vertex :param machine_time_step: the time between timer tick updates. :param time_scale_factor:\ the scaling between machine time step and real time :return: None """ # pylint: disable=too-many-arguments, too-many-locals spec.comment( "\nWriting Neuron Parameters for {} poisson sources:\n".format( vertex_slice.n_atoms)) # Set the focus to the memory region 2 (neuron parameters): spec.switch_write_focus(_REGIONS.POISSON_PARAMS_REGION.value) # Write Key info for this core: key = routing_info.get_first_key_from_pre_vertex( placement.vertex, constants.SPIKE_PARTITION_ID) spec.write_value(data=1 if key is not None else 0) spec.write_value(data=key if key is not None else 0) # Write the incoming mask if there is one in_edges = graph.get_edges_ending_at_vertex_with_partition_name( placement.vertex, constants.LIVE_POISSON_CONTROL_PARTITION_ID) if len(in_edges) > 1: raise ConfigurationException( "Only one control edge can end at a Poisson vertex") incoming_mask = 0 if len(in_edges) == 1: in_edge = in_edges[0] # Get the mask of the incoming keys incoming_mask = \ routing_info.get_routing_info_for_edge(in_edge).first_mask incoming_mask = ~incoming_mask & 0xFFFFFFFF spec.write_value(incoming_mask) # Write the random back off value spec.write_value( random.randint( 0, min(self._n_poisson_machine_vertices, MICROSECONDS_PER_SECOND // machine_time_step))) # Write the number of microseconds between sending spikes total_mean_rate = numpy.sum(self._rate) if total_mean_rate > 0: max_spikes = numpy.sum( scipy.stats.poisson.ppf(1.0 - (1.0 / self._rate), self._rate)) spikes_per_timestep = ( max_spikes / (MICROSECONDS_PER_SECOND // machine_time_step)) # avoid a possible division by zero / small number (which may # result in a value that doesn't fit in a uint32) by only # setting time_between_spikes if spikes_per_timestep is > 1 time_between_spikes = 0.0 if spikes_per_timestep > 1: time_between_spikes = ( (machine_time_step * time_scale_factor) / (spikes_per_timestep * 2.0)) spec.write_value(data=int(time_between_spikes)) else: # If the rate is 0 or less, set a "time between spikes" of 1 # to ensure that some time is put between spikes in event # of a rate change later on spec.write_value(data=1) # Write the number of seconds per timestep (unsigned long fract) spec.write_value(data=float(machine_time_step) / MICROSECONDS_PER_SECOND, data_type=DataType.U032) # Write the number of timesteps per second (accum) spec.write_value(data=MICROSECONDS_PER_SECOND / float(machine_time_step), data_type=DataType.S1615) # Write the slow-rate-per-tick-cutoff (accum) spec.write_value(data=SLOW_RATE_PER_TICK_CUTOFF, data_type=DataType.S1615) # Write the lo_atom id spec.write_value(data=vertex_slice.lo_atom) # Write the number of sources spec.write_value(data=vertex_slice.n_atoms) # Write the random seed (4 words), generated randomly! kiss_key = (vertex_slice.lo_atom, vertex_slice.hi_atom) if kiss_key not in self._kiss_seed: if self._rng is None: self._rng = numpy.random.RandomState(self._seed) self._kiss_seed[kiss_key] = [ self._rng.randint(-0x80000000, 0x7FFFFFFF) + 0x80000000 for _ in range(4) ] for value in self._kiss_seed[kiss_key]: spec.write_value(data=value) # Compute the start times in machine time steps start = self._start[vertex_slice.as_slice] start_scaled = self._convert_ms_to_n_timesteps(start, machine_time_step) # Compute the end times as start times + duration in machine time steps # (where duration is not None) duration = self._duration[vertex_slice.as_slice] end_scaled = numpy.zeros(len(duration), dtype="uint32") none_positions = numpy.isnan(duration) positions = numpy.invert(none_positions) end_scaled[none_positions] = 0xFFFFFFFF end_scaled[positions] = self._convert_ms_to_n_timesteps( start[positions] + duration[positions], machine_time_step) # Get the rates for the atoms rates = self._rate[vertex_slice.as_slice].astype("float") # Compute the spikes per tick for each atom spikes_per_tick = ( rates * (float(machine_time_step) / MICROSECONDS_PER_SECOND)) # Determine which sources are fast and which are slow is_fast_source = spikes_per_tick > SLOW_RATE_PER_TICK_CUTOFF # Compute the e^-(spikes_per_tick) for fast sources to allow fast # computation of the Poisson distribution to get the number of spikes # per timestep exp_minus_lambda = numpy.zeros(len(spikes_per_tick), dtype="float") exp_minus_lambda[is_fast_source] = numpy.exp( -1.0 * spikes_per_tick[is_fast_source]) # Compute the inter-spike-interval for slow sources to get the average # number of timesteps between spikes isi_val = numpy.zeros(len(spikes_per_tick), dtype="float") elements = numpy.logical_not(is_fast_source) & (spikes_per_tick > 0) isi_val[elements] = 1.0 / spikes_per_tick[elements] # Get the time to spike value time_to_spike = self._time_to_spike[vertex_slice.as_slice] changed_rates = ( self._rate_change[vertex_slice.as_slice].astype("bool") & elements) time_to_spike[changed_rates] = 0.0 # Merge the arrays as parameters per atom data = numpy.dstack( (start_scaled.astype("uint32"), end_scaled.astype("uint32"), is_fast_source.astype("uint32"), (exp_minus_lambda * (2**32)).astype("uint32"), (isi_val * (2**15)).astype("uint32"), (time_to_spike * (2**15)).astype("uint32")))[0] spec.write_array(data) @staticmethod def _convert_ms_to_n_timesteps(value, machine_time_step): return numpy.round( value * (MICROSECONDS_PER_MILLISECOND / float(machine_time_step))) @staticmethod def _convert_n_timesteps_to_ms(value, machine_time_step): return (value / (MICROSECONDS_PER_MILLISECOND / float(machine_time_step))) @overrides(AbstractSpikeRecordable.is_recording_spikes) def is_recording_spikes(self): return self._spike_recorder.record @overrides(AbstractSpikeRecordable.set_recording_spikes) def set_recording_spikes(self, new_state=True, sampling_interval=None, indexes=None): if sampling_interval is not None: logger.warning("Sampling interval currently not supported for " "SpikeSourcePoisson so being ignored") if indexes is not None: logger.warning("indexes not supported for " "SpikeSourcePoisson so being ignored") self._spike_recorder.record = new_state @overrides(AbstractSpikeRecordable.get_spikes_sampling_interval) def get_spikes_sampling_interval(self): return globals_variables.get_simulator().machine_time_step def get_sdram_usage_for_atoms(self, vertex_slice): """ calculates total sdram usage for a set of atoms :param vertex_slice: the atoms to calculate sdram usage for :return: sdram usage as a number of bytes """ poisson_params_sz = self.get_params_bytes(vertex_slice) total_size = ( SYSTEM_BYTES_REQUIREMENT + SpikeSourcePoissonMachineVertex.get_provenance_data_size(0) + poisson_params_sz) total_size += self._get_number_of_mallocs_used_by_dsg() * \ SARK_PER_MALLOC_SDRAM_USAGE return total_size def _get_number_of_mallocs_used_by_dsg(self): """ Works out how many allocation requests are required by the tools :return: the number of allocation requests """ standard_mallocs = self._DEFAULT_MALLOCS_USED if self._spike_recorder.record: standard_mallocs += 1 return standard_mallocs @staticmethod def get_dtcm_usage_for_atoms(): return 0 @staticmethod def get_cpu_usage_for_atoms(): return 0 @inject_items({ "machine_time_step": "MachineTimeStep", "time_scale_factor": "TimeScaleFactor", "graph_mapper": "MemoryGraphMapper", "routing_info": "MemoryRoutingInfos", "graph": "MemoryMachineGraph" }) @overrides(AbstractRewritesDataSpecification.regenerate_data_specification, additional_arguments={ "machine_time_step", "time_scale_factor", "graph_mapper", "routing_info", "graph" }) def regenerate_data_specification(self, spec, placement, machine_time_step, time_scale_factor, graph_mapper, routing_info, graph): # pylint: disable=too-many-arguments, arguments-differ # reserve the neuron parameters data region self._reserve_poisson_params_region(placement, graph_mapper, spec) # allocate parameters self._write_poisson_parameters(spec=spec, graph=graph, placement=placement, routing_info=routing_info, vertex_slice=graph_mapper.get_slice( placement.vertex), machine_time_step=machine_time_step, time_scale_factor=time_scale_factor) # end spec spec.end_specification() @overrides(AbstractRewritesDataSpecification. requires_memory_regions_to_be_reloaded) def requires_memory_regions_to_be_reloaded(self): return self._change_requires_neuron_parameters_reload @overrides(AbstractRewritesDataSpecification.mark_regions_reloaded) def mark_regions_reloaded(self): self._change_requires_neuron_parameters_reload = False @overrides(AbstractReadParametersBeforeSet.read_parameters_from_machine) def read_parameters_from_machine(self, transceiver, placement, vertex_slice): # locate sdram address to where the neuron parameters are stored poisson_parameter_region_sdram_address = \ helpful_functions.locate_memory_region_for_placement( placement, _REGIONS.POISSON_PARAMS_REGION.value, transceiver) # shift past the extra stuff before neuron parameters that we don't # need to read poisson_parameter_parameters_sdram_address = \ poisson_parameter_region_sdram_address + \ START_OF_POISSON_GENERATOR_PARAMETERS # get size of poisson params size_of_region = self.get_params_bytes(vertex_slice) size_of_region -= START_OF_POISSON_GENERATOR_PARAMETERS # get data from the machine byte_array = transceiver.read_memory( placement.x, placement.y, poisson_parameter_parameters_sdram_address, size_of_region) # Convert the data to parameter values (start, end, is_fast_source, exp_minus_lambda, isi, time_to_next_spike) = _PoissonStruct.read_data( byte_array, 0, vertex_slice.n_atoms) # Convert start values as timesteps into milliseconds self._start[vertex_slice.as_slice] = self._convert_n_timesteps_to_ms( start, self._machine_time_step) # Convert end values as timesteps to durations in milliseconds self._duration[vertex_slice.as_slice] = ( self._convert_n_timesteps_to_ms(end, self._machine_time_step) - self._start[vertex_slice.as_slice]) # Work out the spikes per tick depending on if the source is slow # or fast is_fast_source = is_fast_source == 1.0 spikes_per_tick = numpy.zeros(len(is_fast_source), dtype="float") spikes_per_tick[is_fast_source] = numpy.log( exp_minus_lambda[is_fast_source]) * -1.0 slow_elements = isi > 0 spikes_per_tick[slow_elements] = 1.0 / isi[slow_elements] # Convert spikes per tick to rates self._rate[vertex_slice.as_slice] = ( spikes_per_tick * (MICROSECONDS_PER_SECOND / float(self._machine_time_step))) # Store the updated time until next spike so that it can be # rewritten when the parameters are loaded self._time_to_spike[vertex_slice.as_slice] = time_to_next_spike @inject_items({ "machine_time_step": "MachineTimeStep", "time_scale_factor": "TimeScaleFactor", "graph_mapper": "MemoryGraphMapper", "routing_info": "MemoryRoutingInfos", "tags": "MemoryTags", "n_machine_time_steps": "TotalMachineTimeSteps", "graph": "MemoryMachineGraph" }) @overrides(AbstractGeneratesDataSpecification.generate_data_specification, additional_arguments={ "machine_time_step", "time_scale_factor", "graph_mapper", "routing_info", "tags", "n_machine_time_steps", "graph" }) def generate_data_specification(self, spec, placement, machine_time_step, time_scale_factor, graph_mapper, routing_info, tags, n_machine_time_steps, graph): # pylint: disable=too-many-arguments, arguments-differ self._machine_time_step = machine_time_step vertex = placement.vertex vertex_slice = graph_mapper.get_slice(vertex) spec.comment("\n*** Spec for SpikeSourcePoisson Instance ***\n\n") # Reserve SDRAM space for memory areas: self.reserve_memory_regions(spec, placement, graph_mapper) # write setup data spec.switch_write_focus(_REGIONS.SYSTEM_REGION.value) spec.write_array( simulation_utilities.get_simulation_header_array( self.get_binary_file_name(), machine_time_step, time_scale_factor)) # write recording data ip_tags = tags.get_ip_tags_for_vertex(vertex) spec.switch_write_focus(_REGIONS.SPIKE_HISTORY_REGION.value) recorded_region_sizes = recording_utilities.get_recorded_region_sizes([ self._spike_recorder.get_sdram_usage_in_bytes( vertex_slice.n_atoms, self._max_spikes_per_ts(vertex_slice, n_machine_time_steps, machine_time_step), n_machine_time_steps) ], self._maximum_sdram_for_buffering) spec.write_array( recording_utilities.get_recording_header_array( recorded_region_sizes, self._time_between_requests, self._buffer_size_before_receive, ip_tags)) # write parameters self._write_poisson_parameters(spec, graph, placement, routing_info, vertex_slice, machine_time_step, time_scale_factor) # End-of-Spec: spec.end_specification() @overrides(AbstractHasAssociatedBinary.get_binary_file_name) def get_binary_file_name(self): return "spike_source_poisson.aplx" @overrides(AbstractHasAssociatedBinary.get_binary_start_type) def get_binary_start_type(self): return ExecutableType.USES_SIMULATION_INTERFACE @overrides(AbstractSpikeRecordable.get_spikes) def get_spikes(self, placements, graph_mapper, buffer_manager, machine_time_step): return self._spike_recorder.get_spikes( self.label, buffer_manager, SpikeSourcePoissonVertex.SPIKE_RECORDING_REGION_ID, placements, graph_mapper, self, machine_time_step) @overrides(AbstractProvidesOutgoingPartitionConstraints. get_outgoing_partition_constraints) def get_outgoing_partition_constraints(self, partition): return [ContiguousKeyRangeContraint()] @overrides(AbstractSpikeRecordable.clear_spike_recording) def clear_spike_recording(self, buffer_manager, placements, graph_mapper): machine_vertices = graph_mapper.get_machine_vertices(self) for machine_vertex in machine_vertices: placement = placements.get_placement_of_vertex(machine_vertex) buffer_manager.clear_recorded_data( placement.x, placement.y, placement.p, SpikeSourcePoissonVertex.SPIKE_RECORDING_REGION_ID) def describe(self): """ Returns a human-readable description of the cell or synapse type. The output may be customised by specifying a different template together with an associated template engine (see ``pyNN.descriptions``). If template is None, then a dictionary containing the template context will be returned. """ parameters = dict() for parameter_name in self._model.default_parameters: parameters[parameter_name] = self.get_value(parameter_name) context = { "name": self._model_name, "default_parameters": self._model.default_parameters, "default_initial_values": self._model.default_parameters, "parameters": parameters, } return context
def __init__(self, n_neurons, constraints, label, seed, max_atoms_per_core, model, rate=None, start=None, duration=None, rates=None, starts=None, durations=None, max_rate=None): # pylint: disable=too-many-arguments super(SpikeSourcePoissonVertex, self).__init__(label, constraints, max_atoms_per_core) # atoms params self.__n_atoms = n_neurons self.__model_name = "SpikeSourcePoisson" self.__model = model self.__seed = seed self.__kiss_seed = dict() self.__rng = None self.__n_subvertices = 0 self.__n_data_specs = 0 # check for changes parameters self.__change_requires_mapping = True self.__change_requires_neuron_parameters_reload = False self.__spike_recorder = MultiSpikeRecorder() # Check for disallowed pairs of parameters if (rates is not None) and (rate is not None): raise Exception("Exactly one of rate and rates can be specified") if (starts is not None) and (start is not None): raise Exception("Exactly one of start and starts can be specified") if (durations is not None) and (duration is not None): raise Exception( "Exactly one of duration and durations can be specified") if rate is None and rates is None: raise Exception("One of rate or rates must be specified") # Normalise the parameters self.__is_variable_rate = rates is not None if rates is None: if hasattr(rate, "__len__"): # Single rate per neuron for whole simulation rates = [numpy.array([r]) for r in rate] else: # Single rate for all neurons for whole simulation rates = numpy.array([rate]) elif hasattr(rates[0], "__len__"): # Convert each list to numpy array rates = [numpy.array(r) for r in rates] else: rates = numpy.array(rates) if starts is None and start is not None: if hasattr(start, "__len__"): starts = [numpy.array([s]) for s in start] elif start is None: starts = numpy.array([0]) else: starts = numpy.array([start]) elif starts is not None and hasattr(starts[0], "__len__"): starts = [numpy.array(s) for s in starts] elif starts is not None: starts = numpy.array(starts) if durations is None and duration is not None: if hasattr(duration, "__len__"): durations = [numpy.array([d]) for d in duration] else: durations = numpy.array([duration]) elif durations is not None and hasattr(durations[0], "__len__"): durations = [numpy.array(d) for d in durations] elif durations is not None: durations = numpy.array(durations) else: if hasattr(rates[0], "__len__"): durations = [ numpy.array([None for r in _rate]) for _rate in rates ] else: durations = numpy.array([None for _rate in rates]) # Check that there is either one list for all neurons, # or one per neuron if hasattr(rates[0], "__len__") and len(rates) != n_neurons: raise Exception( "Must specify one rate for all neurons or one per neuron") if (starts is not None and hasattr(starts[0], "__len__") and len(starts) != n_neurons): raise Exception( "Must specify one start for all neurons or one per neuron") if (durations is not None and hasattr(durations[0], "__len__") and len(durations) != n_neurons): raise Exception( "Must specify one duration for all neurons or one per neuron") # Check that for each rate there is a start and duration if needed # TODO: Could be more efficient for case where parameters are not one # per neuron for i in range(n_neurons): rate_set = rates if hasattr(rates[0], "__len__"): rate_set = rates[i] if not hasattr(rate_set, "__len__"): raise Exception("Multiple rates must be a list") if starts is None and len(rate_set) > 1: raise Exception("When multiple rates are specified," " each must have a start") elif starts is not None: start_set = starts if hasattr(starts[0], "__len__"): start_set = starts[i] if len(start_set) != len(rate_set): raise Exception("Each rate must have a start") if any(s is None for s in start_set): raise Exception("Start must not be None") if durations is not None: duration_set = durations if hasattr(durations[0], "__len__"): duration_set = durations[i] if len(duration_set) != len(rate_set): raise Exception("Each rate must have its own duration") if hasattr(rates[0], "__len__"): time_to_spike = [ numpy.array([0 for _ in range(len(rates[i]))]) for i in range(len(rates)) ] else: time_to_spike = numpy.array([0 for _ in range(len(rates))]) self.__data = SpynnakerRangeDictionary(n_neurons) self.__data["rates"] = SpynnakerRangedList( n_neurons, rates, use_list_as_value=not hasattr(rates[0], "__len__")) self.__data["starts"] = SpynnakerRangedList( n_neurons, starts, use_list_as_value=not hasattr(starts[0], "__len__")) self.__data["durations"] = SpynnakerRangedList( n_neurons, durations, use_list_as_value=not hasattr(durations[0], "__len__")) self.__data["time_to_spike"] = SpynnakerRangedList( n_neurons, time_to_spike, use_list_as_value=not hasattr(time_to_spike[0], "__len__")) self.__rng = numpy.random.RandomState(seed) self.__rate_change = numpy.zeros(n_neurons) self.__machine_time_step = None # get config from simulator config = globals_variables.get_simulator().config self.__n_profile_samples = helpful_functions.read_config_int( config, "Reports", "n_profile_samples") # Prepare for recording, and to get spikes self.__spike_recorder = MultiSpikeRecorder() all_rates = list(_flatten(self.__data["rates"])) self.__max_rate = max_rate if max_rate is None and len(all_rates): self.__max_rate = numpy.amax(all_rates) elif max_rate is None: self.__max_rate = 0 total_rate = numpy.sum(all_rates) self.__max_spikes = 0 if total_rate > 0: # Note we have to do this per rate, as the whole array is not numpy max_rates = numpy.array( [numpy.max(r) for r in self.__data["rates"]]) self.__max_spikes = numpy.sum( scipy.stats.poisson.ppf(1.0 - (1.0 / max_rates), max_rates))
class SpikeSourcePoissonVertex( ApplicationVertex, AbstractGeneratesDataSpecification, AbstractHasAssociatedBinary, AbstractSpikeRecordable, AbstractProvidesOutgoingPartitionConstraints, AbstractChangableAfterRun, AbstractReadParametersBeforeSet, AbstractRewritesDataSpecification, SimplePopulationSettable, ProvidesKeyToAtomMappingImpl): """ A Poisson Spike source object """ __slots__ = [ "__change_requires_mapping", "__change_requires_neuron_parameters_reload", "__duration", "__machine_time_step", "__model", "__model_name", "__n_atoms", "__rate", "__rng", "__seed", "__spike_recorder", "__start", "__time_to_spike", "__kiss_seed", "__n_subvertices", "__n_data_specs", "__max_rate", "__rate_change", "__n_profile_samples", "__data", "__is_variable_rate", "__max_spikes" ] SPIKE_RECORDING_REGION_ID = 0 def __init__(self, n_neurons, constraints, label, seed, max_atoms_per_core, model, rate=None, start=None, duration=None, rates=None, starts=None, durations=None, max_rate=None): # pylint: disable=too-many-arguments super(SpikeSourcePoissonVertex, self).__init__(label, constraints, max_atoms_per_core) # atoms params self.__n_atoms = n_neurons self.__model_name = "SpikeSourcePoisson" self.__model = model self.__seed = seed self.__kiss_seed = dict() self.__rng = None self.__n_subvertices = 0 self.__n_data_specs = 0 # check for changes parameters self.__change_requires_mapping = True self.__change_requires_neuron_parameters_reload = False self.__spike_recorder = MultiSpikeRecorder() # Check for disallowed pairs of parameters if (rates is not None) and (rate is not None): raise Exception("Exactly one of rate and rates can be specified") if (starts is not None) and (start is not None): raise Exception("Exactly one of start and starts can be specified") if (durations is not None) and (duration is not None): raise Exception( "Exactly one of duration and durations can be specified") if rate is None and rates is None: raise Exception("One of rate or rates must be specified") # Normalise the parameters self.__is_variable_rate = rates is not None if rates is None: if hasattr(rate, "__len__"): # Single rate per neuron for whole simulation rates = [numpy.array([r]) for r in rate] else: # Single rate for all neurons for whole simulation rates = numpy.array([rate]) elif hasattr(rates[0], "__len__"): # Convert each list to numpy array rates = [numpy.array(r) for r in rates] else: rates = numpy.array(rates) if starts is None and start is not None: if hasattr(start, "__len__"): starts = [numpy.array([s]) for s in start] elif start is None: starts = numpy.array([0]) else: starts = numpy.array([start]) elif starts is not None and hasattr(starts[0], "__len__"): starts = [numpy.array(s) for s in starts] elif starts is not None: starts = numpy.array(starts) if durations is None and duration is not None: if hasattr(duration, "__len__"): durations = [numpy.array([d]) for d in duration] else: durations = numpy.array([duration]) elif durations is not None and hasattr(durations[0], "__len__"): durations = [numpy.array(d) for d in durations] elif durations is not None: durations = numpy.array(durations) else: if hasattr(rates[0], "__len__"): durations = [ numpy.array([None for r in _rate]) for _rate in rates ] else: durations = numpy.array([None for _rate in rates]) # Check that there is either one list for all neurons, # or one per neuron if hasattr(rates[0], "__len__") and len(rates) != n_neurons: raise Exception( "Must specify one rate for all neurons or one per neuron") if (starts is not None and hasattr(starts[0], "__len__") and len(starts) != n_neurons): raise Exception( "Must specify one start for all neurons or one per neuron") if (durations is not None and hasattr(durations[0], "__len__") and len(durations) != n_neurons): raise Exception( "Must specify one duration for all neurons or one per neuron") # Check that for each rate there is a start and duration if needed # TODO: Could be more efficient for case where parameters are not one # per neuron for i in range(n_neurons): rate_set = rates if hasattr(rates[0], "__len__"): rate_set = rates[i] if not hasattr(rate_set, "__len__"): raise Exception("Multiple rates must be a list") if starts is None and len(rate_set) > 1: raise Exception("When multiple rates are specified," " each must have a start") elif starts is not None: start_set = starts if hasattr(starts[0], "__len__"): start_set = starts[i] if len(start_set) != len(rate_set): raise Exception("Each rate must have a start") if any(s is None for s in start_set): raise Exception("Start must not be None") if durations is not None: duration_set = durations if hasattr(durations[0], "__len__"): duration_set = durations[i] if len(duration_set) != len(rate_set): raise Exception("Each rate must have its own duration") if hasattr(rates[0], "__len__"): time_to_spike = [ numpy.array([0 for _ in range(len(rates[i]))]) for i in range(len(rates)) ] else: time_to_spike = numpy.array([0 for _ in range(len(rates))]) self.__data = SpynnakerRangeDictionary(n_neurons) self.__data["rates"] = SpynnakerRangedList( n_neurons, rates, use_list_as_value=not hasattr(rates[0], "__len__")) self.__data["starts"] = SpynnakerRangedList( n_neurons, starts, use_list_as_value=not hasattr(starts[0], "__len__")) self.__data["durations"] = SpynnakerRangedList( n_neurons, durations, use_list_as_value=not hasattr(durations[0], "__len__")) self.__data["time_to_spike"] = SpynnakerRangedList( n_neurons, time_to_spike, use_list_as_value=not hasattr(time_to_spike[0], "__len__")) self.__rng = numpy.random.RandomState(seed) self.__rate_change = numpy.zeros(n_neurons) self.__machine_time_step = None # get config from simulator config = globals_variables.get_simulator().config self.__n_profile_samples = helpful_functions.read_config_int( config, "Reports", "n_profile_samples") # Prepare for recording, and to get spikes self.__spike_recorder = MultiSpikeRecorder() all_rates = list(_flatten(self.__data["rates"])) self.__max_rate = max_rate if max_rate is None and len(all_rates): self.__max_rate = numpy.amax(all_rates) elif max_rate is None: self.__max_rate = 0 total_rate = numpy.sum(all_rates) self.__max_spikes = 0 if total_rate > 0: # Note we have to do this per rate, as the whole array is not numpy max_rates = numpy.array( [numpy.max(r) for r in self.__data["rates"]]) self.__max_spikes = numpy.sum( scipy.stats.poisson.ppf(1.0 - (1.0 / max_rates), max_rates)) @property def rate(self): if self.__is_variable_rate: raise Exception("Get variable rate poisson rates with .rates") return list(_flatten(self.__data["rates"])) @rate.setter def rate(self, rate): if self.__is_variable_rate: raise Exception("Cannot set rate of a variable rate poisson") self.__rate_change = rate - numpy.array( list(_flatten(self.__data["rates"]))) # Normalise parameter if hasattr(rate, "__len__"): # Single rate per neuron for whole simulation self.__data["rates"].set_value([numpy.array([r]) for r in rate]) else: # Single rate for all neurons for whole simulation self.__data["rates"].set_value(numpy.array([rate]), use_list_as_value=True) all_rates = list(_flatten(self.__data["rates"])) new_max = 0 if len(all_rates): new_max = numpy.amax(all_rates) if self.__max_rate is None: self.__max_rate = new_max # Setting record forces reset so OK to go over if not recording elif self.__spike_recorder.record and new_max > self.__max_rate: logger.info('Increasing spike rate while recording requires a ' '"reset unless additional_parameters "max_rate" is ' 'set') self.__change_requires_mapping = True self.__max_rate = new_max @property def start(self): if self.__is_variable_rate: raise Exception("Get variable rate poisson starts with .starts") return self.__data["starts"] @start.setter def start(self, start): if self.__is_variable_rate: raise Exception("Cannot set start of a variable rate poisson") # Normalise parameter if hasattr(start, "__len__"): # Single start per neuron for whole simulation self.__data["starts"].set_value([numpy.array([s]) for s in start]) else: # Single start for all neurons for whole simulation self.__data["starts"].set_value(numpy.array([start]), use_list_as_value=True) @property def duration(self): if self.__is_variable_rate: raise Exception( "Get variable rate poisson durations with .durations") return self.__data["durations"] @duration.setter def duration(self, duration): if self.__is_variable_rate: raise Exception("Cannot set duration of a variable rate poisson") # Normalise parameter if hasattr(duration, "__len__"): # Single duration per neuron for whole simulation self.__data["durations"].set_value( [numpy.array([d]) for d in duration]) else: # Single duration for all neurons for whole simulation self.__data["durations"].set_value(numpy.array([duration]), use_list_as_value=True) @property def rates(self): return self.__data["rates"] @rates.setter def rates(self, _rates): if self.__is_variable_rate: raise Exception("Cannot set rates of a variable rate poisson") raise Exception("Set the rate of a Poisson source using rate") @property def starts(self): return self.__data["starts"] @starts.setter def starts(self, _starts): if self.__is_variable_rate: raise Exception("Cannot set starts of a variable rate poisson") raise Exception("Set the start of a Poisson source using start") @property def durations(self): return self.__data["durations"] @durations.setter def durations(self, _durations): if self.__is_variable_rate: raise Exception("Cannot set durations of a variable rate poisson") raise Exception("Set the duration of a Poisson source using duration") @property @overrides(AbstractChangableAfterRun.requires_mapping) def requires_mapping(self): return self.__change_requires_mapping @overrides(AbstractChangableAfterRun.mark_no_changes) def mark_no_changes(self): self.__change_requires_mapping = False @overrides(SimplePopulationSettable.set_value) def set_value(self, key, value): SimplePopulationSettable.set_value(self, key, value) self.__change_requires_neuron_parameters_reload = True def _max_spikes_per_ts(self, machine_time_step): ts_per_second = MICROSECONDS_PER_SECOND / float(machine_time_step) if float(self.__max_rate) / ts_per_second < \ SLOW_RATE_PER_TICK_CUTOFF: return 1 # Experiments show at 1000 this result is typically higher than actual chance_ts = 1000 max_spikes_per_ts = scipy.stats.poisson.ppf( 1.0 - (1.0 / float(chance_ts)), float(self.__max_rate) / ts_per_second) return int(math.ceil(max_spikes_per_ts)) + 1.0 def get_recording_sdram_usage(self, vertex_slice, machine_time_step): variable_sdram = self.__spike_recorder.get_sdram_usage_in_bytes( vertex_slice.n_atoms, self._max_spikes_per_ts(machine_time_step)) constant_sdram = ConstantSDRAM(variable_sdram.per_timestep * OVERFLOW_TIMESTEPS_FOR_SDRAM) return variable_sdram + constant_sdram @inject_items({"machine_time_step": "MachineTimeStep"}) @overrides(ApplicationVertex.get_resources_used_by_atoms, additional_arguments={"machine_time_step"}) def get_resources_used_by_atoms(self, vertex_slice, machine_time_step): # pylint: disable=arguments-differ poisson_params_sz = self.get_rates_bytes(vertex_slice) other = ConstantSDRAM( SYSTEM_BYTES_REQUIREMENT + SpikeSourcePoissonMachineVertex.get_provenance_data_size(0) + poisson_params_sz + recording_utilities.get_recording_header_size(1) + recording_utilities.get_recording_data_constant_size(1) + profile_utils.get_profile_region_size(self.__n_profile_samples)) recording = self.get_recording_sdram_usage(vertex_slice, machine_time_step) # build resources as i currently know container = ResourceContainer(sdram=recording + other, dtcm=DTCMResource( self.get_dtcm_usage_for_atoms()), cpu_cycles=CPUCyclesPerTickResource( self.get_cpu_usage_for_atoms())) return container @property def n_atoms(self): return self.__n_atoms def create_machine_vertex(self, vertex_slice, resources_required, label=None, constraints=None): # pylint: disable=too-many-arguments, arguments-differ self.__n_subvertices += 1 return SpikeSourcePoissonMachineVertex(resources_required, self.__spike_recorder.record, constraints, label) @property def max_rate(self): return self.__max_rate @property def seed(self): return self.__seed @seed.setter def seed(self, seed): self.__seed = seed self.__kiss_seed = dict() self.__rng = None def get_rates_bytes(self, vertex_slice): """ Gets the size of the Poisson rates in bytes :param vertex_slice: """ n_rates = sum( len(self.__data["rates"][i]) for i in range(vertex_slice.lo_atom, vertex_slice.hi_atom + 1)) return ((vertex_slice.n_atoms * PARAMS_WORDS_PER_NEURON) + (n_rates * PARAMS_WORDS_PER_RATE)) * BYTES_PER_WORD def reserve_memory_regions(self, spec, placement, graph_mapper): """ Reserve memory regions for Poisson source parameters and output\ buffer. :param spec: the data specification writer :param placement: the location this vertex resides on in the machine :param graph_mapper: the mapping between app and machine graphs :return: None """ spec.comment("\nReserving memory space for data regions:\n\n") # Reserve memory: spec.reserve_memory_region(region=_REGIONS.SYSTEM_REGION.value, size=SIMULATION_N_BYTES, label='setup') # reserve poisson parameters and rates DSG region self._reserve_poisson_params_rates_region(placement, graph_mapper, spec) spec.reserve_memory_region( region=_REGIONS.SPIKE_HISTORY_REGION.value, size=recording_utilities.get_recording_header_size(1), label="Recording") profile_utils.reserve_profile_region(spec, _REGIONS.PROFILER_REGION.value, self.__n_profile_samples) placement.vertex.reserve_provenance_data_region(spec) def _reserve_poisson_params_rates_region(self, placement, graph_mapper, spec): """ Allocate space for the Poisson parameters and rates regions as\ they can be reused for setters after an initial run :param placement: the location on machine for this vertex :param graph_mapper: the mapping between machine and application graphs :param spec: the DSG writer :return: None """ spec.reserve_memory_region(region=_REGIONS.POISSON_PARAMS_REGION.value, size=PARAMS_BASE_WORDS * 4, label="PoissonParams") spec.reserve_memory_region(region=_REGIONS.RATES_REGION.value, size=self.get_rates_bytes( graph_mapper.get_slice( placement.vertex)), label='PoissonRates') def _write_poisson_parameters(self, spec, graph, placement, routing_info, vertex_slice, machine_time_step, time_scale_factor): """ Generate Parameter data for Poisson spike sources :param spec: the data specification writer :param key: the routing key for this vertex :param vertex_slice:\ the slice of atoms a machine vertex holds from its application\ vertex :param machine_time_step: the time between timer tick updates. :param time_scale_factor:\ the scaling between machine time step and real time """ # pylint: disable=too-many-arguments, too-many-locals spec.comment("\nWriting Parameters for {} poisson sources:\n".format( vertex_slice.n_atoms)) # Set the focus to the memory region 2 (neuron parameters): spec.switch_write_focus(_REGIONS.POISSON_PARAMS_REGION.value) # Write Key info for this core: key = routing_info.get_first_key_from_pre_vertex( placement.vertex, constants.SPIKE_PARTITION_ID) spec.write_value(data=1 if key is not None else 0) spec.write_value(data=key if key is not None else 0) # Write the incoming mask if there is one in_edges = graph.get_edges_ending_at_vertex_with_partition_name( placement.vertex, constants.LIVE_POISSON_CONTROL_PARTITION_ID) if len(in_edges) > 1: raise ConfigurationException( "Only one control edge can end at a Poisson vertex") incoming_mask = 0 if len(in_edges) == 1: in_edge = in_edges[0] # Get the mask of the incoming keys incoming_mask = \ routing_info.get_routing_info_for_edge(in_edge).first_mask incoming_mask = ~incoming_mask & 0xFFFFFFFF spec.write_value(incoming_mask) # Write the offset value max_offset = (machine_time_step * time_scale_factor) // _MAX_OFFSET_DENOMINATOR spec.write_value( int(math.ceil(max_offset / self.__n_subvertices)) * self.__n_data_specs) self.__n_data_specs += 1 if self.__max_spikes > 0: spikes_per_timestep = ( self.__max_spikes / (MICROSECONDS_PER_SECOND // machine_time_step)) # avoid a possible division by zero / small number (which may # result in a value that doesn't fit in a uint32) by only # setting time_between_spikes if spikes_per_timestep is > 1 time_between_spikes = 1.0 if spikes_per_timestep > 1: time_between_spikes = ( (machine_time_step * time_scale_factor) / (spikes_per_timestep * 2.0)) spec.write_value(data=int(time_between_spikes)) else: # If the rate is 0 or less, set a "time between spikes" of 1 # to ensure that some time is put between spikes in event # of a rate change later on spec.write_value(data=1) # Write the number of seconds per timestep (unsigned long fract) spec.write_value(data=float(machine_time_step) / MICROSECONDS_PER_SECOND, data_type=DataType.U032) # Write the number of timesteps per second (integer) spec.write_value(data=int(MICROSECONDS_PER_SECOND / float(machine_time_step))) # Write the slow-rate-per-tick-cutoff (accum) spec.write_value(data=SLOW_RATE_PER_TICK_CUTOFF, data_type=DataType.S1615) # Write the fast-rate-per-tick-cutoff (accum) spec.write_value(data=FAST_RATE_PER_TICK_CUTOFF, data_type=DataType.S1615) # Write the lo_atom ID spec.write_value(data=vertex_slice.lo_atom) # Write the number of sources spec.write_value(data=vertex_slice.n_atoms) # Write the random seed (4 words), generated randomly! kiss_key = (vertex_slice.lo_atom, vertex_slice.hi_atom) if kiss_key not in self.__kiss_seed: if self.__rng is None: self.__rng = numpy.random.RandomState(self.__seed) self.__kiss_seed[kiss_key] = validate_mars_kiss_64_seed([ self.__rng.randint(-0x80000000, 0x7FFFFFFF) + 0x80000000 for _ in range(4) ]) for value in self.__kiss_seed[kiss_key]: spec.write_value(data=value) def _write_poisson_rates(self, spec, vertex_slice, machine_time_step, first_machine_time_step): """ Generate Rate data for Poisson spike sources :param spec: the data specification writer :param vertex_slice:\ the slice of atoms a machine vertex holds from its application\ vertex :param machine_time_step: the time between timer tick updates. :param first_machine_time_step:\ First machine time step to start from the correct index """ spec.comment("\nWriting Rates for {} poisson sources:\n".format( vertex_slice.n_atoms)) # Set the focus to the memory region 2 (neuron parameters): spec.switch_write_focus(_REGIONS.RATES_REGION.value) # Extract the data on which to work and convert to appropriate form starts = numpy.array( list(_flatten( self.__data["starts"][vertex_slice.as_slice]))).astype("float") durations = numpy.array( list(_flatten(self.__data["durations"][ vertex_slice.as_slice]))).astype("float") local_rates = self.__data["rates"][vertex_slice.as_slice] n_rates = numpy.array([len(r) for r in local_rates]) splits = numpy.cumsum(n_rates) rates = numpy.array(list(_flatten(local_rates))) time_to_spike = numpy.array( list(_flatten(self.__data["time_to_spike"][ vertex_slice.as_slice]))).astype("u4") rate_change = self.__rate_change[vertex_slice.as_slice] # Convert start times to start time steps starts_scaled = self._convert_ms_to_n_timesteps( starts, machine_time_step) # Convert durations to end time steps, using the maximum for "None" # duration (which means "until the end") no_duration = numpy.isnan(durations) durations_filtered = numpy.where(no_duration, 0, durations) ends_scaled = self._convert_ms_to_n_timesteps( durations_filtered, machine_time_step) + starts_scaled ends_scaled = numpy.where(no_duration, _MAX_TIMESTEP, ends_scaled) # Work out the timestep at which the next rate activates, using # the maximum value at the end (meaning there is no "next") starts_split = numpy.array_split(starts_scaled, splits) next_scaled = numpy.concatenate( [numpy.append(s[1:], _MAX_TIMESTEP) for s in starts_split[:-1]]) # Compute the spikes per tick for each rate for each atom spikes_per_tick = rates * (float(machine_time_step) / MICROSECONDS_PER_SECOND) # Determine the properties of the sources is_fast_source = spikes_per_tick >= SLOW_RATE_PER_TICK_CUTOFF is_faster_source = spikes_per_tick >= FAST_RATE_PER_TICK_CUTOFF not_zero = spikes_per_tick > 0 # pylint: disable=assignment-from-no-return is_slow_source = numpy.logical_not(is_fast_source) # Compute the e^-(spikes_per_tick) for fast sources to allow fast # computation of the Poisson distribution to get the number of # spikes per timestep exp_minus_lambda = DataType.U032.encode_as_numpy_int_array( numpy.where(is_fast_source, numpy.exp(-1.0 * spikes_per_tick), 0)) # Compute sqrt(lambda) for "faster" sources to allow Gaussian # approximation of the Poisson distribution to get the number of # spikes per timestep sqrt_lambda = DataType.S1615.encode_as_numpy_int_array( numpy.where(is_faster_source, numpy.sqrt(spikes_per_tick), 0)) # Compute the inter-spike-interval for slow sources to get the # average number of timesteps between spikes isi_val = numpy.where(not_zero & is_slow_source, (1.0 / spikes_per_tick).astype(int), 0).astype("uint32") # Reuse the time-to-spike read from the machine (if has been run) # or don't if the rate has since been changed time_to_spike_split = numpy.array_split(time_to_spike, splits) time_to_spike = numpy.concatenate([ t if rate_change[i] else numpy.repeat(0, len(t)) for i, t in enumerate(time_to_spike_split[:-1]) ]) # Turn the fast source booleans into uint32 is_fast_source = is_fast_source.astype("uint32") # Group together the rate data for the core by rate core_data = numpy.dstack( (starts_scaled, ends_scaled, next_scaled, is_fast_source, exp_minus_lambda, sqrt_lambda, isi_val, time_to_spike))[0] # Group data by neuron id core_data_split = numpy.array_split(core_data, splits) # Work out the index where the core should start based on the given # first timestep ends_scaled_split = numpy.array_split(ends_scaled, splits) indices = [ numpy.argmax(e > first_machine_time_step) for e in ends_scaled_split[:-1] ] # Build the final data for this core, and write it final_data = numpy.concatenate([ numpy.concatenate(([len(d), indices[i]], numpy.concatenate(d))) for i, d in enumerate(core_data_split[:-1]) ]) spec.write_array(final_data) @staticmethod def _convert_ms_to_n_timesteps(value, machine_time_step): return numpy.round(value * (MICROSECONDS_PER_MILLISECOND / float(machine_time_step))).astype("uint32") @staticmethod def _convert_n_timesteps_to_ms(value, machine_time_step): return (value / (MICROSECONDS_PER_MILLISECOND / float(machine_time_step))) @overrides(AbstractSpikeRecordable.is_recording_spikes) def is_recording_spikes(self): return self.__spike_recorder.record @overrides(AbstractSpikeRecordable.set_recording_spikes) def set_recording_spikes(self, new_state=True, sampling_interval=None, indexes=None): if sampling_interval is not None: logger.warning("Sampling interval currently not supported for " "SpikeSourcePoisson so being ignored") if indexes is not None: logger.warning("indexes not supported for " "SpikeSourcePoisson so being ignored") if new_state and not self.__spike_recorder.record: self.__change_requires_mapping = True self.__spike_recorder.record = new_state @overrides(AbstractSpikeRecordable.get_spikes_sampling_interval) def get_spikes_sampling_interval(self): return globals_variables.get_simulator().machine_time_step @staticmethod def get_dtcm_usage_for_atoms(): return 0 @staticmethod def get_cpu_usage_for_atoms(): return 0 @inject_items({ "machine_time_step": "MachineTimeStep", "time_scale_factor": "TimeScaleFactor", "graph_mapper": "MemoryGraphMapper", "routing_info": "MemoryRoutingInfos", "graph": "MemoryMachineGraph", "first_machine_time_step": "FirstMachineTimeStep" }) @overrides(AbstractRewritesDataSpecification.regenerate_data_specification, additional_arguments={ "machine_time_step", "time_scale_factor", "graph_mapper", "routing_info", "graph", "first_machine_time_step" }) def regenerate_data_specification(self, spec, placement, machine_time_step, time_scale_factor, graph_mapper, routing_info, graph, first_machine_time_step): # pylint: disable=too-many-arguments, arguments-differ # reserve the neuron parameters data region self._reserve_poisson_params_rates_region(placement, graph_mapper, spec) # write parameters vertex_slice = graph_mapper.get_slice(placement.vertex) self._write_poisson_parameters(spec=spec, graph=graph, placement=placement, routing_info=routing_info, vertex_slice=vertex_slice, machine_time_step=machine_time_step, time_scale_factor=time_scale_factor) # write rates self._write_poisson_rates(spec, vertex_slice, machine_time_step, first_machine_time_step) # end spec spec.end_specification() @inject_items({"first_machine_time_step": "FirstMachineTimeStep"}) @overrides(AbstractRewritesDataSpecification. requires_memory_regions_to_be_reloaded, additional_arguments={"first_machine_time_step"}) def requires_memory_regions_to_be_reloaded(self, first_machine_time_step): # pylint: disable=arguments-differ return (self.__change_requires_neuron_parameters_reload or first_machine_time_step == 0) @overrides(AbstractRewritesDataSpecification.mark_regions_reloaded) def mark_regions_reloaded(self): self.__change_requires_neuron_parameters_reload = False @overrides(AbstractReadParametersBeforeSet.read_parameters_from_machine) def read_parameters_from_machine(self, transceiver, placement, vertex_slice): # locate SDRAM address where parameters are stored poisson_params = \ helpful_functions.locate_memory_region_for_placement( placement, _REGIONS.POISSON_PARAMS_REGION.value, transceiver) seed_array = transceiver.read_memory( placement.x, placement.y, poisson_params + SEED_OFFSET_BYTES, SEED_SIZE_BYTES) kiss_key = (vertex_slice.lo_atom, vertex_slice.hi_atom) self.__kiss_seed[kiss_key] = struct.unpack_from("<4I", seed_array) # locate SDRAM address where the rates are stored poisson_rate_region_sdram_address = \ helpful_functions.locate_memory_region_for_placement( placement, _REGIONS.RATES_REGION.value, transceiver) # get size of poisson params size_of_region = self.get_rates_bytes(vertex_slice) # get data from the machine byte_array = transceiver.read_memory( placement.x, placement.y, poisson_rate_region_sdram_address, size_of_region) # For each atom, read the number of rates and the rate parameters offset = 0 for i in range(vertex_slice.lo_atom, vertex_slice.hi_atom + 1): n_values = struct.unpack_from("<I", byte_array, offset)[0] offset += 4 # Skip reading the index, as it will be recalculated on data write offset += 4 (_start, _end, _next, is_fast_source, exp_minus_lambda, sqrt_lambda, isi, time_to_next_spike) = _PoissonStruct.read_data( byte_array, offset, n_values) offset += _PoissonStruct.get_size_in_whole_words(n_values) * 4 # Work out the spikes per tick depending on if the source is # slow (isi), fast (exp) or faster (sqrt) is_fast_source = is_fast_source == 1.0 spikes_per_tick = numpy.zeros(len(is_fast_source), dtype="float") spikes_per_tick[is_fast_source] = numpy.log( exp_minus_lambda[is_fast_source]) * -1.0 is_faster_source = sqrt_lambda > 0 # pylint: disable=assignment-from-no-return spikes_per_tick[is_faster_source] = numpy.square( sqrt_lambda[is_faster_source]) slow_elements = isi > 0 spikes_per_tick[slow_elements] = 1.0 / isi[slow_elements] # Convert spikes per tick to rates self.__data["rates"].set_value_by_id( i, spikes_per_tick * (MICROSECONDS_PER_SECOND / float(self.__machine_time_step))) # Store the updated time until next spike so that it can be # rewritten when the parameters are loaded self.__data["time_to_spike"].set_value_by_id(i, time_to_next_spike) @inject_items({ "machine_time_step": "MachineTimeStep", "time_scale_factor": "TimeScaleFactor", "graph_mapper": "MemoryGraphMapper", "routing_info": "MemoryRoutingInfos", "data_n_time_steps": "DataNTimeSteps", "graph": "MemoryMachineGraph", "first_machine_time_step": "FirstMachineTimeStep" }) @overrides(AbstractGeneratesDataSpecification.generate_data_specification, additional_arguments={ "machine_time_step", "time_scale_factor", "graph_mapper", "routing_info", "data_n_time_steps", "graph", "first_machine_time_step" }) def generate_data_specification(self, spec, placement, machine_time_step, time_scale_factor, graph_mapper, routing_info, data_n_time_steps, graph, first_machine_time_step): # pylint: disable=too-many-arguments, arguments-differ self.__machine_time_step = machine_time_step vertex = placement.vertex vertex_slice = graph_mapper.get_slice(vertex) spec.comment("\n*** Spec for SpikeSourcePoisson Instance ***\n\n") # Reserve SDRAM space for memory areas: self.reserve_memory_regions(spec, placement, graph_mapper) # write setup data spec.switch_write_focus(_REGIONS.SYSTEM_REGION.value) spec.write_array( simulation_utilities.get_simulation_header_array( self.get_binary_file_name(), machine_time_step, time_scale_factor)) # write recording data spec.switch_write_focus(_REGIONS.SPIKE_HISTORY_REGION.value) sdram = self.get_recording_sdram_usage(vertex_slice, machine_time_step) recorded_region_sizes = [sdram.get_total_sdram(data_n_time_steps)] spec.write_array( recording_utilities.get_recording_header_array( recorded_region_sizes)) # write parameters self._write_poisson_parameters(spec, graph, placement, routing_info, vertex_slice, machine_time_step, time_scale_factor) # write rates self._write_poisson_rates(spec, vertex_slice, machine_time_step, first_machine_time_step) # write profile data profile_utils.write_profile_region_data(spec, _REGIONS.PROFILER_REGION.value, self.__n_profile_samples) # End-of-Spec: spec.end_specification() @overrides(AbstractHasAssociatedBinary.get_binary_file_name) def get_binary_file_name(self): return "spike_source_poisson.aplx" @overrides(AbstractHasAssociatedBinary.get_binary_start_type) def get_binary_start_type(self): return ExecutableType.USES_SIMULATION_INTERFACE @overrides(AbstractSpikeRecordable.get_spikes) def get_spikes(self, placements, graph_mapper, buffer_manager, machine_time_step): return self.__spike_recorder.get_spikes( self.label, buffer_manager, SpikeSourcePoissonVertex.SPIKE_RECORDING_REGION_ID, placements, graph_mapper, self, machine_time_step) @overrides(AbstractProvidesOutgoingPartitionConstraints. get_outgoing_partition_constraints) def get_outgoing_partition_constraints(self, partition): return [ContiguousKeyRangeContraint()] @overrides(AbstractSpikeRecordable.clear_spike_recording) def clear_spike_recording(self, buffer_manager, placements, graph_mapper): machine_vertices = graph_mapper.get_machine_vertices(self) for machine_vertex in machine_vertices: placement = placements.get_placement_of_vertex(machine_vertex) buffer_manager.clear_recorded_data( placement.x, placement.y, placement.p, SpikeSourcePoissonVertex.SPIKE_RECORDING_REGION_ID) def describe(self): """ Return a human-readable description of the cell or synapse type. The output may be customised by specifying a different template\ together with an associated template engine\ (see ``pyNN.descriptions``). If template is None, then a dictionary containing the template context\ will be returned. """ parameters = dict() for parameter_name in self.__model.default_parameters: parameters[parameter_name] = self.get_value(parameter_name) context = { "name": self.__model_name, "default_parameters": self.__model.default_parameters, "default_initial_values": self.__model.default_parameters, "parameters": parameters, } return context
class SpikeSourcePoissonVertex( TDMAAwareApplicationVertex, AbstractSpikeRecordable, AbstractProvidesOutgoingPartitionConstraints, AbstractChangableAfterRun, SimplePopulationSettable, ProvidesKeyToAtomMappingImpl, LegacyPartitionerAPI): """ A Poisson Spike source object """ __slots__ = [ "__change_requires_mapping", "__duration", "__model", "__model_name", "__n_atoms", "__rate", "__rng", "__seed", "__spike_recorder", "__start", "__time_to_spike", "__kiss_seed", # dict indexed by vertex slice "__n_subvertices", "__n_data_specs", "__max_rate", "__rate_change", "__n_profile_samples", "__data", "__is_variable_rate", "__max_spikes", "__outgoing_projections" ] SPIKE_RECORDING_REGION_ID = 0 def __init__(self, n_neurons, constraints, label, seed, max_atoms_per_core, model, rate=None, start=None, duration=None, rates=None, starts=None, durations=None, max_rate=None, splitter=None): """ :param int n_neurons: :param constraints: :type constraints: iterable(~pacman.model.constraints.AbstractConstraint) :param str label: :param float seed: :param int max_atoms_per_core: :param ~spynnaker.pyNN.models.spike_source.SpikeSourcePoisson model: :param iterable(float) rate: :param iterable(int) start: :param iterable(int) duration: :param splitter: :type splitter: ~pacman.model.partitioner_splitters.abstract_splitters.AbstractSplitterCommon """ # pylint: disable=too-many-arguments super().__init__(label, constraints, max_atoms_per_core, splitter) # atoms params self.__n_atoms = self.round_n_atoms(n_neurons, "n_neurons") self.__model_name = "SpikeSourcePoisson" self.__model = model self.__seed = seed self.__kiss_seed = dict() self.__n_subvertices = 0 self.__n_data_specs = 0 # check for changes parameters self.__change_requires_mapping = True self.__spike_recorder = MultiSpikeRecorder() # Check for disallowed pairs of parameters if (rates is not None) and (rate is not None): raise Exception("Exactly one of rate and rates can be specified") if (starts is not None) and (start is not None): raise Exception("Exactly one of start and starts can be specified") if (durations is not None) and (duration is not None): raise Exception( "Exactly one of duration and durations can be specified") if rate is None and rates is None: raise Exception("One of rate or rates must be specified") # Normalise the parameters self.__is_variable_rate = rates is not None if rates is None: if hasattr(rate, "__len__"): # Single rate per neuron for whole simulation rates = [numpy.array([r]) for r in rate] else: # Single rate for all neurons for whole simulation rates = numpy.array([rate]) elif hasattr(rates[0], "__len__"): # Convert each list to numpy array rates = [numpy.array(r) for r in rates] else: rates = numpy.array(rates) if starts is None and start is not None: if hasattr(start, "__len__"): starts = [numpy.array([s]) for s in start] elif start is None: starts = numpy.array([0]) else: starts = numpy.array([start]) elif starts is not None and hasattr(starts[0], "__len__"): starts = [numpy.array(s) for s in starts] elif starts is not None: starts = numpy.array(starts) if durations is None and duration is not None: if hasattr(duration, "__len__"): durations = [numpy.array([d]) for d in duration] else: durations = numpy.array([duration]) elif durations is not None and hasattr(durations[0], "__len__"): durations = [numpy.array(d) for d in durations] elif durations is not None: durations = numpy.array(durations) else: if hasattr(rates[0], "__len__"): durations = [ numpy.array([None for r in _rate]) for _rate in rates ] else: durations = numpy.array([None for _rate in rates]) # Check that there is either one list for all neurons, # or one per neuron if hasattr(rates[0], "__len__") and len(rates) != n_neurons: raise Exception( "Must specify one rate for all neurons or one per neuron") if (starts is not None and hasattr(starts[0], "__len__") and len(starts) != n_neurons): raise Exception( "Must specify one start for all neurons or one per neuron") if (durations is not None and hasattr(durations[0], "__len__") and len(durations) != n_neurons): raise Exception( "Must specify one duration for all neurons or one per neuron") # Check that for each rate there is a start and duration if needed # TODO: Could be more efficient for case where parameters are not one # per neuron for i in range(n_neurons): rate_set = rates if hasattr(rates[0], "__len__"): rate_set = rates[i] if not hasattr(rate_set, "__len__"): raise Exception("Multiple rates must be a list") if starts is None and len(rate_set) > 1: raise Exception("When multiple rates are specified," " each must have a start") elif starts is not None: start_set = starts if hasattr(starts[0], "__len__"): start_set = starts[i] if len(start_set) != len(rate_set): raise Exception("Each rate must have a start") if any(s is None for s in start_set): raise Exception("Start must not be None") if durations is not None: duration_set = durations if hasattr(durations[0], "__len__"): duration_set = durations[i] if len(duration_set) != len(rate_set): raise Exception("Each rate must have its own duration") if hasattr(rates[0], "__len__"): time_to_spike = [ numpy.array([0 for _ in range(len(rates[i]))]) for i in range(len(rates)) ] else: time_to_spike = numpy.array([0 for _ in range(len(rates))]) self.__data = SpynnakerRangeDictionary(n_neurons) self.__data["rates"] = SpynnakerRangedList( n_neurons, rates, use_list_as_value=not hasattr(rates[0], "__len__")) self.__data["starts"] = SpynnakerRangedList( n_neurons, starts, use_list_as_value=not hasattr(starts[0], "__len__")) self.__data["durations"] = SpynnakerRangedList( n_neurons, durations, use_list_as_value=not hasattr(durations[0], "__len__")) self.__data["time_to_spike"] = SpynnakerRangedList( n_neurons, time_to_spike, use_list_as_value=not hasattr(time_to_spike[0], "__len__")) self.__rng = numpy.random.RandomState(seed) self.__rate_change = numpy.zeros(n_neurons) self.__n_profile_samples = get_config_int("Reports", "n_profile_samples") # Prepare for recording, and to get spikes self.__spike_recorder = MultiSpikeRecorder() all_rates = list(_flatten(self.__data["rates"])) self.__max_rate = max_rate if max_rate is None and len(all_rates): self.__max_rate = numpy.amax(all_rates) elif max_rate is None: self.__max_rate = 0 total_rate = numpy.sum(all_rates) self.__max_spikes = 0 if total_rate > 0: # Note we have to do this per rate, as the whole array is not numpy max_rates = numpy.array( [numpy.max(r) for r in self.__data["rates"]]) self.__max_spikes = numpy.sum( scipy.stats.poisson.ppf(1.0 - (1.0 / max_rates), max_rates)) # Keep track of how many outgoing projections exist self.__outgoing_projections = list() def add_outgoing_projection(self, projection): """ Add an outgoing projection from this vertex :param PyNNProjectionCommon projection: The projection to add """ self.__outgoing_projections.append(projection) @property def outgoing_projections(self): """ The projections outgoing from this vertex :rtype: list(PyNNProjectionCommon) """ return self.__outgoing_projections @property def n_profile_samples(self): return self.__n_profile_samples @property def rate(self): if self.__is_variable_rate: raise Exception("Get variable rate poisson rates with .rates") return list(_flatten(self.__data["rates"])) @rate.setter def rate(self, rate): if self.__is_variable_rate: raise Exception("Cannot set rate of a variable rate poisson") self.__rate_change = rate - numpy.array( list(_flatten(self.__data["rates"]))) # Normalise parameter if hasattr(rate, "__len__"): # Single rate per neuron for whole simulation self.__data["rates"].set_value([numpy.array([r]) for r in rate]) else: # Single rate for all neurons for whole simulation self.__data["rates"].set_value(numpy.array([rate]), use_list_as_value=True) all_rates = list(_flatten(self.__data["rates"])) new_max = 0 if len(all_rates): new_max = numpy.amax(all_rates) if self.__max_rate is None: self.__max_rate = new_max # Setting record forces reset so OK to go over if not recording elif self.__spike_recorder.record and new_max > self.__max_rate: logger.info('Increasing spike rate while recording requires a ' '"reset unless additional_parameters "max_rate" is ' 'set') self.__change_requires_mapping = True self.__max_rate = new_max @property def start(self): return self.__data["starts"] @start.setter def start(self, start): if self.__is_variable_rate: raise Exception("Cannot set start of a variable rate poisson") # Normalise parameter if hasattr(start, "__len__"): # Single start per neuron for whole simulation self.__data["starts"].set_value([numpy.array([s]) for s in start]) else: # Single start for all neurons for whole simulation self.__data["starts"].set_value(numpy.array([start]), use_list_as_value=True) @property def duration(self): return self.__data["durations"] @duration.setter def duration(self, duration): if self.__is_variable_rate: raise Exception("Cannot set duration of a variable rate poisson") # Normalise parameter if hasattr(duration, "__len__"): # Single duration per neuron for whole simulation self.__data["durations"].set_value( [numpy.array([d]) for d in duration]) else: # Single duration for all neurons for whole simulation self.__data["durations"].set_value(numpy.array([duration]), use_list_as_value=True) @property def rates(self): return self.__data["rates"] @rates.setter def rates(self, _rates): if self.__is_variable_rate: raise Exception("Cannot set rates of a variable rate poisson") raise Exception("Set the rate of a Poisson source using rate") @property def starts(self): return self.__data["starts"] @starts.setter def starts(self, _starts): if self.__is_variable_rate: raise Exception("Cannot set starts of a variable rate poisson") raise Exception("Set the start of a Poisson source using start") @property def durations(self): return self.__data["durations"] @durations.setter def durations(self, _durations): if self.__is_variable_rate: raise Exception("Cannot set durations of a variable rate poisson") raise Exception("Set the duration of a Poisson source using duration") @property def time_to_spike(self): return self.__data["time_to_spike"] @property def rate_change(self): return self.__rate_change @property @overrides(AbstractChangableAfterRun.requires_mapping) def requires_mapping(self): return self.__change_requires_mapping @overrides(AbstractChangableAfterRun.mark_no_changes) def mark_no_changes(self): self.__change_requires_mapping = False @overrides(SimplePopulationSettable.set_value) def set_value(self, key, value): super().set_value(key, value) for machine_vertex in self.machine_vertices: if isinstance(machine_vertex, AbstractRewritesDataSpecification): machine_vertex.set_reload_required(True) def max_spikes_per_ts(self): ts_per_second = (MICRO_TO_SECOND_CONVERSION / machine_time_step()) if float(self.__max_rate) / ts_per_second < \ SLOW_RATE_PER_TICK_CUTOFF: return 1 # Experiments show at 1000 this result is typically higher than actual chance_ts = 1000 max_spikes_per_ts = scipy.stats.poisson.ppf( 1.0 - (1.0 / float(chance_ts)), float(self.__max_rate) / ts_per_second) return int(math.ceil(max_spikes_per_ts)) + 1.0 def get_recording_sdram_usage(self, vertex_slice): """ :param ~pacman.model.graphs.common.Slice vertex_slice: """ variable_sdram = self.__spike_recorder.get_sdram_usage_in_bytes( vertex_slice.n_atoms, self.max_spikes_per_ts()) constant_sdram = ConstantSDRAM(variable_sdram.per_timestep * OVERFLOW_TIMESTEPS_FOR_SDRAM) return variable_sdram + constant_sdram @overrides(LegacyPartitionerAPI.get_resources_used_by_atoms) def get_resources_used_by_atoms(self, vertex_slice): """ :param ~pacman.model.graphs.common.Slice vertex_slice: """ # pylint: disable=arguments-differ poisson_params_sz = get_rates_bytes(vertex_slice, self.__data["rates"]) sdram_sz = get_sdram_edge_params_bytes(vertex_slice) other = ConstantSDRAM( SYSTEM_BYTES_REQUIREMENT + SpikeSourcePoissonMachineVertex.get_provenance_data_size(0) + poisson_params_sz + self.tdma_sdram_size_in_bytes + recording_utilities.get_recording_header_size(1) + recording_utilities.get_recording_data_constant_size(1) + profile_utils.get_profile_region_size(self.__n_profile_samples) + sdram_sz) recording = self.get_recording_sdram_usage(vertex_slice) # build resources as i currently know container = ResourceContainer(sdram=recording + other, dtcm=DTCMResource( self.get_dtcm_usage_for_atoms()), cpu_cycles=CPUCyclesPerTickResource( self.get_cpu_usage_for_atoms())) return container @property def n_atoms(self): return self.__n_atoms @overrides(LegacyPartitionerAPI.create_machine_vertex) def create_machine_vertex(self, vertex_slice, resources_required, label=None, constraints=None): # pylint: disable=too-many-arguments, arguments-differ index = self.__n_subvertices self.__n_subvertices += 1 return SpikeSourcePoissonMachineVertex(resources_required, self.__spike_recorder.record, constraints, label, self, vertex_slice, index) @property def max_rate(self): return self.__max_rate @property def seed(self): return self.__seed @seed.setter def seed(self, seed): self.__seed = seed self.__kiss_seed = dict() self.__rng = numpy.random.RandomState(seed) @overrides(AbstractSpikeRecordable.is_recording_spikes) def is_recording_spikes(self): return self.__spike_recorder.record @overrides(AbstractSpikeRecordable.set_recording_spikes) def set_recording_spikes(self, new_state=True, sampling_interval=None, indexes=None): if sampling_interval is not None: logger.warning("Sampling interval currently not supported for " "SpikeSourcePoisson so being ignored") if indexes is not None: logger.warning("indexes not supported for " "SpikeSourcePoisson so being ignored") if new_state and not self.__spike_recorder.record: self.__change_requires_mapping = True self.__spike_recorder.record = new_state @overrides(AbstractSpikeRecordable.get_spikes_sampling_interval) def get_spikes_sampling_interval(self): return machine_time_step() @staticmethod def get_dtcm_usage_for_atoms(): return 0 @staticmethod def get_cpu_usage_for_atoms(): return 0 def kiss_seed(self, vertex_slice): if vertex_slice not in self.__kiss_seed: self.__kiss_seed[vertex_slice] = create_mars_kiss_seeds(self.__rng) return self.__kiss_seed[vertex_slice] def update_kiss_seed(self, vertex_slice, seed): """ updates a kiss seed from the machine :param vertex_slice: the vertex slice to update seed of :param seed: the seed :rtype: None """ self.__kiss_seed[vertex_slice] = seed @overrides(AbstractSpikeRecordable.get_spikes) def get_spikes(self, placements, buffer_manager): return self.__spike_recorder.get_spikes( self.label, buffer_manager, SpikeSourcePoissonVertex.SPIKE_RECORDING_REGION_ID, placements, self) @overrides(AbstractProvidesOutgoingPartitionConstraints. get_outgoing_partition_constraints) def get_outgoing_partition_constraints(self, partition): return [ContiguousKeyRangeContraint()] @overrides(AbstractSpikeRecordable.clear_spike_recording) def clear_spike_recording(self, buffer_manager, placements): for machine_vertex in self.machine_vertices: placement = placements.get_placement_of_vertex(machine_vertex) buffer_manager.clear_recorded_data( placement.x, placement.y, placement.p, SpikeSourcePoissonVertex.SPIKE_RECORDING_REGION_ID) def describe(self): """ Return a human-readable description of the cell or synapse type. The output may be customised by specifying a different template\ together with an associated template engine\ (see :py:mod:`pyNN.descriptions`). If template is None, then a dictionary containing the template context\ will be returned. :rtype: dict(str, ...) """ parameters = dict() for parameter_name in self.__model.default_parameters: parameters[parameter_name] = self.get_value(parameter_name) context = { "name": self.__model_name, "default_parameters": self.__model.default_parameters, "default_initial_values": self.__model.default_parameters, "parameters": parameters, } return context @overrides(TDMAAwareApplicationVertex.get_n_cores) def get_n_cores(self): return len(self._splitter.get_out_going_slices()[0])