spynnaker.pyNN.models.neuron package

Subpackages

Submodules

spynnaker.pyNN.models.neuron.generator_data module

class spynnaker.pyNN.models.neuron.generator_data.GeneratorData(synaptic_matrix_offset: int | None, delayed_synaptic_matrix_offset: int | None, app_edge: ProjectionApplicationEdge, synapse_information: SynapseInformation, max_row_info: MaxRowInfo, max_pre_atoms_per_core: int, max_post_atoms_per_core: int)[source]

Bases: object

Data for each connection of the synapse generator.

Parameters:

  • synaptic_matrix_offset

  • delayed_synaptic_matrix_offset

  • app_edge

  • synapse_information

  • max_row_info

  • max_pre_atoms_per_core

  • max_post_atoms_per_core

BASE_SIZE = 44
property gen_data: Sequence[ndarray[tuple[Any, ...], dtype[uint32]]]

The data to be written for this connection.

property size: int

The size of the generated data, in bytes.

spynnaker.pyNN.models.neuron.master_pop_table module

class spynnaker.pyNN.models.neuron.master_pop_table.MasterPopTableAsBinarySearch[source]

Bases: object

Master population table, implemented as binary search master.

add_application_entry(block_start_addr: int, row_length: int, key_and_mask: BaseKeyAndMask, core_mask: int, core_shift: int, n_neurons: int, n_colour_bits: int) → int[source]

Add an entry for an application-edge to the population table.

Parameters:

  • block_start_addr – where the synaptic matrix block starts

  • row_length – how long in words each row is

  • key_and_mask – the key and mask for this master pop entry

  • core_mask – Mask for the part of the key that identifies the core

  • core_shift – The shift of the mask to get to the core_mask

  • n_neurons – The number of neurons in each machine vertex (bar the last)

  • n_colour_bits – The number of bits to use for colour

Returns:

The index of the entry, to be used to retrieve it

Raises:

SynapticConfigurationException – If a bad address is used.

add_invalid_application_entry(key_and_mask: BaseKeyAndMask, core_mask: int, core_shift: int, n_neurons: int, n_colour_bits: int) → int[source]

Add an entry to the table from an application vertex that doesn’t point to anywhere. Used to keep indices in synchronisation between e.g. normal and delay entries and between entries on different cores.

Parameters:

  • key_and_mask – a key_and_mask object used as part of describing an edge that will require being received to be stored in the master pop table; the whole edge will become multiple calls to this function

  • core_mask – Mask for the part of the key that identifies the core

  • core_shift – The shift of the mask to get to the core_mask

  • n_neurons – The number of neurons in each machine vertex (bar the last)

  • n_colour_bits – The number of bits to use for colour

Returns:

The index of the added entry

static get_allowed_row_length(row_length: int) → int[source]

Get the next allowed row length.

Parameters:

row_length – the row length being considered

Returns:

the row length available

Raises:

SynapseRowTooBigException – If the row won’t fit

static get_master_population_table_size(incoming_projections: Iterable[Projection]) → int[source]

Get the size of the master population table in SDRAM.

Parameters:

incoming_projections – The projections arriving at the vertex that are to be handled by this table

Returns:

the size the master pop table will take in SDRAM (in bytes)

static get_next_allowed_address(next_address: int) → int[source]

Get the next allowed address.

Parameters:

next_address – The next address that would be used

Returns:

The next address that can be used following next_address

Raises:

SynapticConfigurationException – if the address is out of range

get_pop_table_data() → ndarray[tuple[Any, ...], dtype[uint32]][source]
Returns:

The master pop table data as a numpy array.

initialise_table() → None[source]

Initialise the master pop data structure.

property max_core_mask: int

The maximum core mask supported when n_neurons is > 0; this is the maximum number of cores that can be supported in a joined mask.

property max_index: int

The maximum index of a synaptic connection.

property max_n_neurons_per_core: int

The maximum number of neurons per core supported when a core-mask is > 0.

spynnaker.pyNN.models.neuron.neuron_data module

class spynnaker.pyNN.models.neuron.neuron_data.NeuronData(app_vertex: PopulationVertex)[source]

Bases: object

Holds and creates the data for a group of neurons.

Parameters:

app_vertex – Vertex to get data from.

property gen_on_machine: bool

Whether the neuron data can be generated on the machine or not.

generate_data() → None[source]

Do the data generation internally.

read_data(placement: Placement, neuron_regions: NeuronRegions) → None[source]

Read the current state of the data from the machine into the application vertex.

Parameters:

  • placement – The placement of the vertex to read

  • neuron_regions – The regions to read from

read_initial_data(placement: Placement, neuron_regions: NeuronRegions) → None[source]

Read the initial state of the data from the machine into the application vertex.

Parameters:

  • placement – The placement of the vertex to read

  • neuron_regions – The regions to read from

reset_generation() → None[source]

Reset generation so it is done again.

write_data(spec: DataSpecificationBase, vertex_slice: Slice, neuron_regions: NeuronRegions, gen_on_machine: bool = True) → None[source]

Write the generated data.

Parameters:

  • spec – The data specification to write to

  • vertex_slice – The vertex slice to generate for

  • neuron_regions – The regions to write to

  • gen_on_machine – Whether to allow generation on machine

spynnaker.pyNN.models.neuron.population_machine_common module

class spynnaker.pyNN.models.neuron.population_machine_common.CommonRegions(system: int, provenance: int, profile: int, recording: int)[source]

Bases: NamedTuple

Identifiers for common regions.

Create new instance of CommonRegions(system, provenance, profile, recording)

profile: int

Profiling data region

provenance: int

Provenance collection region

recording: int

Recording channels region

system: int

System control region

class spynnaker.pyNN.models.neuron.population_machine_common.PopulationMachineCommon(label: str, app_vertex: PopulationVertex, vertex_slice: Slice, sdram: AbstractSDRAM, regions: CommonRegions, n_provenance_items: int, profile_tags: Mapping[int, str], binary_file_name: str)[source]

Bases: MachineVertex, ProvidesProvenanceDataFromMachineImpl, AbstractReceiveBuffersToHost, AbstractHasProfileData, AbstractHasAssociatedBinary

A common machine vertex for all population binaries.

Parameters:

  • label – The label of the vertex

  • app_vertex – The associated application vertex

  • vertex_slice – The slice of the population that this implements

  • sdram – The SDRAM used by the vertex

  • regions – The regions to be assigned

  • n_provenance_items – The number of additional provenance items to be read

  • profile_tags – A mapping of profile identifiers to names

  • binary_file_name – The name of the binary file

get_binary_file_name() → str[source]
Returns:

The binary name to be run for this vertex.

get_binary_start_type() → ExecutableType[source]
Returns:

The start type of the binary to be run.

get_n_keys_for_partition(partition_id: str) → int[source]

Get the number of keys required by the given partition of edges.

Parameters:

partition_id – The identifier of the partition; the partition_id param is only used by some MachineVertex subclasses

Returns:

The number of keys required

get_profile_data(placement: Placement) → ProfileData[source]

Get the profile data recorded during simulation.

Parameters:

placement

Returns:

profile data read from the Machine

get_recording_region_base_address(placement: Placement) → int[source]

Get the recording region base address.

Parameters:

placement – the placement object of the core to find the address of

Returns:

the base address of the recording region

property sdram_required: AbstractSDRAM

The SDRAM space required by the vertex.

spynnaker.pyNN.models.neuron.population_machine_synapses module

class spynnaker.pyNN.models.neuron.population_machine_synapses.PopulationMachineSynapses[source]

Bases: PopulationMachineSynapsesProvenance, AbstractSupportsBitFieldRoutingCompression, AbstractSynapseExpandable, HasSynapses, AbstractReceiveRegionsToHost

Mix-in for machine vertices that contain synapses.

bit_field_base_address(placement: Placement) → int[source]

Returns the SDRAM address for the bit-field table data.

Parameters:

placement

Returns:

the SDRAM address for the bitfield address

property bit_field_size: int

The amount of bit field data to be generated. This is used to calculate the timeout of the execution.

property connection_generator_region: int

The region ID containing the parameters of synaptic expansion.

gen_on_machine() → bool[source]

True if the synapses of this vertex should be generated on the machine.

Note

The typical implementation for this method will be to ask the app_vertex’s synapse_manager

Returns:

True if this vertex can generate its data on machine

get_connections_from_machine(placement: Placement, app_edge: ProjectionApplicationEdge, synapse_info: SynapseInformation) → Sequence[NDArray][source]
Parameters:

  • placement – Where the connection data is on the machine

  • app_edge – The edge for which the data is being read

  • synapse_info – The specific projection within the edge

Returns:

The connections from the machine for this vertex.

get_download_regions(placement: Placement) → Sequence[Tuple[int, int, int]][source]

Get the region IDs that are to be downloaded

Returns:

The region number, address and size of the regions to be downloaded

property max_gen_data: int

The maximum amount of synaptic data to be generated. This is used to calculate the timeout of the execution.

read_generated_connection_holders(placement: Placement) → None[source]

Fill in the connection holders.

Parameters:

placement – Where the data is on the machine

regeneratable_sdram_blocks_and_sizes(placement: Placement) → List[Tuple[int, int]][source]

Returns the SDRAM addresses and sizes for the cores’ SDRAM that are available (borrowed) for generating bitfield tables.

Parameters:

placement

Returns:

list of tuples containing (the SDRAM address for the cores SDRAM address’s for the core’s SDRAM that can be used to generate bitfield tables loaded, and the size of memory chunks located there)

abstractmethod set_do_synapse_regeneration() → None[source]

Indicates that synaptic data regeneration is required.

abstract property vertex_slice: Slice

The slice of the application vertex that this machine vertex implements.

spynnaker.pyNN.models.neuron.synapse_io module

class spynnaker.pyNN.models.neuron.synapse_io.MaxRowInfo(undelayed_max_n_synapses: int, delayed_max_n_synapses: int, undelayed_max_bytes: int, delayed_max_bytes: int, undelayed_max_words: int, delayed_max_words: int)[source]

Bases: object

Information about the maximums for rows in a synaptic matrix.

delayed_max_bytes: int

Maximum number of bytes, including headers, in a row of the delayed matrix, or 0 if no synapses.

delayed_max_n_synapses: int

Maximum number of synapses in a row of the delayed matrix

delayed_max_words: int

Maximum number of words, excluding headers, in a row of the delayed matrix.

undelayed_max_bytes: int

Maximum number of bytes, including headers, in a row of the undelayed matrix, or 0 if no synapses.

undelayed_max_n_synapses: int

Maximum number of synapses in a row of the undelayed matrix.

undelayed_max_words: int

Maximum number of words, excluding headers, in a row of the undelayed matrix.

spynnaker.pyNN.models.neuron.synapse_io.convert_to_connections(synapse_info: SynapseInformation, post_vertex_slice: Slice, n_pre_atoms: int, max_row_length: int, n_synapse_types: int, weight_scales: WeightScales, data: bytes | NDArray | None, delayed: bool, post_vertex_max_delay_ticks: int, max_atoms_per_core: int) → ConnectionsArray[source]

Read the synapses for a given projection synapse information object out of the given data and convert to connection data

Parameters:

  • synapse_info – The synapse information of the synapses

  • n_pre_atoms – The number of atoms in the pre-vertex

  • post_vertex_slice – The slice of the target neurons of the synapses in the data

  • max_row_length – The length of each row in the data

  • n_synapse_types – The number of synapse types in total

  • weight_scales – The weight scaling of each synapse type

  • data – The raw data containing the synapses

  • delayed – True if the data should be considered delayed

  • post_vertex_max_delay_ticks – The maximum delayed ticks supported from post vertex

  • max_atoms_per_core – The maximum number of atoms on a core

Returns:

The connections read from the data; the dtype is NUMPY_CONNECTORS_DTYPE

spynnaker.pyNN.models.neuron.synapse_io.get_max_row_info(synapse_info: SynapseInformation, n_post_atoms: int, n_delay_stages: int, in_edge: ProjectionApplicationEdge) → MaxRowInfo[source]

Get the information about the maximum lengths of delayed and undelayed rows in bytes (including header), words (without header) and number of synapses.

Parameters:

  • synapse_info – The synapse information to get the row data for

  • n_post_atoms – The number of post atoms to get the maximum for

  • n_delay_stages – The number of delay stages on the edge

  • in_edge – The incoming edge on which the synapse information is held

Returns:

Information about the maximums for rows in a synaptic matrix.

Raises:

SynapseRowTooBigException – If the synapse information can’t be represented

spynnaker.pyNN.models.neuron.synapse_io.get_maximum_delay_supported_in_ms(post_vertex_max_delay_ticks: int) → float[source]

Get the maximum delay supported by the synapse representation before extensions are required.

Parameters:

post_vertex_max_delay_ticks – post vertex max delay

Returns:

Maximum delay, in milliseconds.

spynnaker.pyNN.models.neuron.synapse_io.get_synapses(connections: ConnectionsArray, synapse_info: SynapseInformation, n_delay_stages: int, n_synapse_types: int, weight_scales: WeightScales, app_edge: ProjectionApplicationEdge, max_row_info: MaxRowInfo, gen_undelayed: bool, gen_delayed: bool, max_atoms_per_core: int) → Tuple[_RowData, _RowData][source]

Get the synapses as an array of words for non-delayed synapses and an array of words for delayed synapses. This is used to prepare information for deployment to SpiNNaker.

Parameters:

  • connections – The connections to get the synapses from

  • synapse_info – The synapse information to convert to synapses

  • n_delay_stages – The number of delay stages in total to be represented

  • n_synapse_types – The number of synapse types in total to be represented

  • weight_scales – The scaling of the weights for each synapse type

  • app_edge – The incoming machine edge that the synapses are on

  • max_row_info – The maximum row information for the synapses

  • gen_undelayed – Whether to generate undelayed data

  • gen_delayed – Whether to generate delayed data

  • max_atoms_per_core – The maximum number of atoms on a core

Returns:

(row_data, delayed_row_data) where:

  • row_data is the undelayed connectivity data arranged into a

    row per source, each row the same length

  • delayed_row_data is the delayed connectivity data arranged

    into a row per source per delay stage, each row the same length

spynnaker.pyNN.models.neuron.synapse_io.read_all_synapses(data: NDArray[uint32], delayed_data: NDArray[uint32], synapse_info: SynapseInformation, n_synapse_types: int, weight_scales: WeightScales, post_vertex_slice: Slice, n_pre_atoms: int, post_vertex_max_delay_ticks: int, max_row_info: MaxRowInfo, max_atoms_per_core: int) → ConnectionsArray[source]

Read the synapses for a given projection synapse information object out of the given delayed and undelayed data.

Parameters:

  • data – The raw data containing the undelayed synapses

  • delayed_data – The raw data containing the delayed synapses

  • synapse_info – The synapse info that generated the synapses

  • n_synapse_types – The total number of synapse types available

  • weight_scales – A weight scale for each synapse type

  • n_pre_atoms – The number of atoms in the pre-vertex

  • post_vertex_slice – The slice of the post-vertex to read the synapses for

  • post_vertex_max_delay_ticks – max delayed ticks supported from post vertex

  • max_row_info – The maximum information for each of the rows

  • max_atoms_per_core – The maximum number of atoms on a core

Returns:

The connections read from the data; the dtype is NUMPY_CONNECTORS_DTYPE

spynnaker.pyNN.models.neuron.synaptic_matrices module

class spynnaker.pyNN.models.neuron.synaptic_matrices.AppKeyInfo(app_key: int, app_mask: int, core_mask: int, core_shift: int, n_neurons: int, n_colour_bits: int)[source]

Bases: object

An object which holds an application key and mask along with the other details.

app_key: int

The application-level key

app_mask: int

The application-level mask

core_mask: int

The mask to get the core from the key

core_shift: int

The shift to get the core from the key

property key_and_mask: BaseKeyAndMask

The key and mask as an object.

n_colour_bits: int

The number of colour bits sent

n_neurons: int

The neurons in each core (except possibly the last)

class spynnaker.pyNN.models.neuron.synaptic_matrices.SynapseRegionReferences(synapse_params: int | None = None, pop_table: int | None = None, synaptic_matrix: int | None = None, synapse_dynamics: int | None = None, structural_dynamics: int | None = None, bitfield_filter: int | None = None, connection_builder: int | None = None)[source]

Bases: NamedTuple

Indices of regions of synapse-implementing binaries.

Create new instance of SynapseRegionReferences(synapse_params, pop_table, synaptic_matrix, synapse_dynamics, structural_dynamics, bitfield_filter, connection_builder)

bitfield_filter: int | None

Alias for field number 5

connection_builder: int | None

Alias for field number 6

pop_table: int | None

Alias for field number 1

structural_dynamics: int | None

Alias for field number 4

synapse_dynamics: int | None

Alias for field number 3

synapse_params: int | None

Alias for field number 0

synaptic_matrix: int | None

Alias for field number 2

class spynnaker.pyNN.models.neuron.synaptic_matrices.SynapseRegions(synapse_params: int, pop_table: int, synaptic_matrix: int, synapse_dynamics: int, structural_dynamics: int, bitfield_filter: int, connection_builder: int)[source]

Bases: NamedTuple

Indices of regions of synapse-implementing binaries.

Create new instance of SynapseRegions(synapse_params, pop_table, synaptic_matrix, synapse_dynamics, structural_dynamics, bitfield_filter, connection_builder)

bitfield_filter: int

Alias for field number 5

connection_builder: int

Alias for field number 6

pop_table: int

Alias for field number 1

structural_dynamics: int

Alias for field number 4

synapse_dynamics: int

Alias for field number 3

synapse_params: int

Alias for field number 0

synaptic_matrix: int

Alias for field number 2

class spynnaker.pyNN.models.neuron.synaptic_matrices.SynapticMatrices(app_vertex: PopulationVertex, regions: SynapseRegions, max_atoms_per_core: int, weight_scales: WeightScales, all_syn_block_sz: int)[source]

Bases: object

Handler of synaptic matrices for a core of a population vertex.

Parameters:

  • app_vertex

  • regions – The synapse regions to use

  • max_atoms_per_core

  • all_syn_block_sz

property bit_field_size: int

The size of the bit field data.

property gen_on_machine: bool

Whether any matrices need to be generated on the machine.

generate_data() → None[source]

Generates the data if it has not already been done.

get_connections_from_machine(placement: Placement, app_edge: ProjectionApplicationEdge, synapse_info: SynapseInformation) → Sequence[NDArray][source]

Get the synaptic connections from the machine.

Parameters:

  • placement – Where the vertices are on the machine

  • app_edge – The application edge of the projection

  • synapse_info – The synapse information of the projection

Returns:

A list of arrays of connections, each with dtype NUMPY_CONNECTORS_DTYPE

get_download_regions(placement: Placement) → List[Tuple[int, int, int]][source]

Get the regions that need to be downloaded.

Parameters:

placement – The placement of the vertex

Returns:

The index, the start address and the size of the regions

get_index(app_edge: ProjectionApplicationEdge, synapse_info: SynapseInformation) → int[source]
Parameters:

  • app_edge – The application edge of the projection

  • synapse_info – The synapse information of the projection

Returns:

The index of an incoming projection in the population table.

property host_generated_block_addr: int

The address within the synaptic region after the last block written by the on-host synaptic generation, i.e. the start of the space that can be overwritten provided the synapse expander is run again.

property max_gen_data: int

The maximum amount of data to be generated for the synapses.

property on_chip_generated_matrix_size: int

The size of the space used by the generated matrix, i.e. the space that can be overwritten provided the synapse expander is run again.

read_generated_connection_holders(placement: Placement) → None[source]

Fill in any pre-run connection holders for data which is generated on the machine, after it has been generated.

Parameters:

placement – where the data is to be read from

write_synaptic_data(spec: DataSpecificationBase, post_vertex_slice: Slice, references: SynapseRegionReferences) → None[source]

Write the synaptic data for all incoming projections.

Parameters:

  • spec – The spec to write to

  • post_vertex_slice – The slice of the post-vertex the matrix is for

  • references – Regions which are referenced; each region which is not referenced can be None.

spynnaker.pyNN.models.neuron.synaptic_matrix_app module

class spynnaker.pyNN.models.neuron.synaptic_matrix_app.SynapticMatrixApp(synapse_info: SynapseInformation, app_edge: ProjectionApplicationEdge, n_synapse_types: int, synaptic_matrix_region: int, max_atoms_per_core: int, all_syn_block_sz: int, app_key_info: AppKeyInfo | None, delay_app_key_info: AppKeyInfo | None, weight_scales: WeightScales)[source]

Bases: object

The synaptic matrix (and delay matrix if applicable) for an incoming application edge.

Parameters:

  • synapse_info – The projection synapse information

  • app_edge – The projection application edge

  • n_synapse_types – The number of synapse types accepted

  • synaptic_matrix_region – The region where synaptic matrices are stored

  • all_syn_block_sz – The space available for all synaptic matrices on the core

  • app_key_info – Application-level routing key information for undelayed vertices

  • delay_app_key_info – Application-level routing key information for delayed vertices

  • weight_scales – Weight scale for each synapse edge

append_matrix(post_vertex_slice: Slice, data_to_write: List[ndarray[tuple[Any, ...], dtype[uint32]]], block_addr: int) → int[source]

Append a synaptic matrix from be written from host.

Parameters:

  • post_vertex_slice – The slice of the post-vertex the matrix is for

  • data_to_write – List to append the data to write to

  • block_addr – The amount of data written so far

Returns:

The amount of data written after this data has been written

property gen_size: int

Size of a block.

get_connections(placement: Placement) → List[ndarray[tuple[Any, ...], dtype[_ScalarT]]][source]

Read connections from an address on the machine.

Parameters:

placement – Where the matrix is on the machine

Returns:

A list of arrays of connections, each with dtype NUMPY_CONNECTORS_DTYPE

get_download_regions(placement: Placement, start_index: int) → List[Tuple[int, int, int]][source]

Get the data regions that should be downloaded when the simulation pauses.

Parameters:

  • placement – The placement of the vertex

  • start_index – The index to use for the first region to download

Returns:

A list of tuples of (index, address, size) to download

get_generator_data() → GeneratorData[source]

Prepare to write a matrix using an on-chip generator.

Returns:

The data to generate with

get_index() → int[source]
Returns:

The index in the master population table of the matrix.

read_generated_connection_holders(placement: Placement) → None[source]

Read any pre-run connection holders after data has been generated.

Parameters:

placement – Where the matrix is on the machine

reserve_matrices(block_addr: int, pop_table: MasterPopTableAsBinarySearch) → int[source]

Allocate the master pop table entries for the blocks.

Parameters:

  • block_addr – Where the allocation can start from

  • pop_table – The master population table

Returns:

Where the next allocation can start from

Module contents

class spynnaker.pyNN.models.neuron.AbstractPyNNNeuronModel(model: AbstractNeuronImpl)

Bases: AbstractPyNNModel

API for a PyNN Neuron Model

Parameters:

model – The model implementation

create_vertex(n_neurons: int, label: str, *, spikes_per_second: float | None = None, ring_buffer_sigma: float | None = None, max_expected_summed_weight: List[float] | None = None, incoming_spike_buffer_size: int | None = None, drop_late_spikes: bool | None = None, splitter: SplitterPopulationVertex | None = None, seed: int | None = None, n_colour_bits: int | None = None, neurons_per_core: int | Tuple[int, ...] | None = None, n_synapse_cores: int | None = None, allow_delay_extensions: bool | None = None) → PopulationVertex[source]

Create a vertex for a population of the model.

Parameters:

  • n_neurons – The number of neurons in the population

  • label – The label to give to the vertex

  • spikes_per_second

  • ring_buffer_sigma

  • incoming_spike_buffer_size

  • drop_late_spikes

  • splitter

  • seed

  • n_colour_bits

Returns:

An application vertex for the population

default_population_parameters: Dict[str, Any] = {'allow_delay_extensions': None, 'drop_late_spikes': None, 'incoming_spike_buffer_size': None, 'max_expected_summed_weight': None, 'n_colour_bits': None, 'n_synapse_cores': None, 'neurons_per_core': None, 'ring_buffer_sigma': None, 'seed': None, 'spikes_per_second': None, 'splitter': None}

The default values for the parameters at the population level. These are parameters that can be passed in to the Population constructor in addition to the standard PyNN options.

classmethod get_model_allow_delay_extensions() → bool[source]

Get whether to allow delay extensions for the model.

Returns:

True unless the model does not allow delay extensions

classmethod get_model_n_synapse_cores() → int | None[source]
Returns:

The number of synapse cores for the model.

property name: str

The name of this model.

classmethod reset_all() → None[source]

Reset the maximum values for all classes.

classmethod set_model_allow_delay_extensions(allow: bool) → None[source]

Set whether to allow delay extensions for a model.

Parameters:

allow – Whether to allow delay extensions

classmethod set_model_n_synapse_cores(n_synapse_cores: int | None) → None[source]

Set the number of synapse cores for a model.

Parameters:

n_synapse_cores – The number of synapse cores; 0 to force combined cores, and None to allow the system to choose

class spynnaker.pyNN.models.neuron.AbstractPyNNNeuronModelStandard(model_name: str, binary: str, neuron_model: NeuronModel, input_type: AbstractInputType, synapse_type: AbstractSynapseType, threshold_type: AbstractThresholdType, additional_input_type: AbstractAdditionalInput | None = None)

Bases: AbstractPyNNNeuronModel

A neuron model that follows the sPyNNaker standard composed model pattern for point neurons.

Parameters:

  • model_name – Name of the model.

  • binary – Name of the implementation executable.

  • neuron_model – The model of the neuron body

  • input_type – The model of synaptic input types

  • synapse_type – The model of the synapses’ dynamics

  • threshold_type – The model of the firing threshold

  • additional_input_type – The model (if any) of additional environmental inputs

create_vertex(n_neurons: int, label: str, *, spikes_per_second: float | None = None, ring_buffer_sigma: float | None = None, max_expected_summed_weight: List[float] | None = None, incoming_spike_buffer_size: int | None = None, drop_late_spikes: bool | None = None, splitter: SplitterPopulationVertex | None = None, seed: int | None = None, n_colour_bits: int | None = None, n_steps_per_timestep: int = 1, neurons_per_core: int | Tuple[int, ...] | None = None, n_synapse_cores: int | None = None, allow_delay_extensions: bool | None = None) → PopulationVertex[source]

Create a vertex for a population of the model.

Parameters:

  • n_neurons – The number of neurons in the population

  • label – The label to give to the vertex

  • spikes_per_second

  • ring_buffer_sigma

  • incoming_spike_buffer_size

  • drop_late_spikes

  • splitter

  • seed

  • n_colour_bits

  • n_steps_per_timestep

Returns:

An application vertex for the population

default_population_parameters: Dict[str, Any] = {'allow_delay_extensions': None, 'drop_late_spikes': None, 'incoming_spike_buffer_size': None, 'max_expected_summed_weight': None, 'n_colour_bits': None, 'n_steps_per_timestep': 1, 'n_synapse_cores': None, 'neurons_per_core': None, 'ring_buffer_sigma': None, 'seed': None, 'spikes_per_second': None, 'splitter': None}

The default values for the parameters at the population level. These are parameters that can be passed in to the Population constructor in addition to the standard PyNN options.

class spynnaker.pyNN.models.neuron.ConnectionHolder(data_items_to_return: Sequence[str] | None, as_list: bool, n_pre_atoms: int, n_post_atoms: int, connections: List[ndarray[tuple[Any, ...], dtype[void]]] | None = None, fixed_values: List[Tuple[str, int]] | None = None, notify: Callable[[ConnectionHolder], None] | None = None)

Bases: object

Holds a set of connections to be returned in a PyNN-specific format.

Parameters:

  • data_items_to_return – A list of data fields to be returned

  • as_list – True if the data will be returned as a list, False if it is to be returned as a matrix (or series of matrices)

  • n_pre_atoms – The number of atoms in the pre-vertex

  • n_post_atoms – The number of atoms in the post-vertex

  • connections – Any initial connections, as a numpy structured array of source, target, weight and delay

  • fixed_values –

    A list of tuples of field names and fixed values to be appended to the other fields per connection, formatted as [(field_name, value), …].

    Note

    If the field is to be returned, the name must also appear in data_items_to_return, which determines the order of items in the result.

  • notify – A callback to call when the connections have all been added. This should accept a single parameter, which will contain the data requested

add_connections(connections: ndarray[tuple[Any, ...], dtype[void]]) → None[source]

Add connections to the holder to be returned.

Parameters:

connections – The connection to add, as a numpy structured array of source, target, weight and delay

property connections: List[ndarray[tuple[Any, ...], dtype[void]]]

The connections stored.

finish() → None[source]

Finish adding connections.

class spynnaker.pyNN.models.neuron.LocalOnlyProvenance

Bases: Structure

Types of provenance and the DataType used to represent each.

N_ITEMS = 4
max_size_input_buffer

Structure/Union member

max_spikes_per_timestep

Structure/Union member

n_spikes_dropped

Structure/Union member

n_spikes_lost_from_input

Structure/Union member

class spynnaker.pyNN.models.neuron.NeuronProvenance

Bases: Structure

Provenance items from neuron processing.

N_ITEMS = 4
current_timer_tick

Structure/Union member

earliest_send

Structure/Union member

latest_send

Structure/Union member

n_tdma_misses

Structure/Union member

class spynnaker.pyNN.models.neuron.NeuronRegions(core_params: int, neuron_params: int, current_source_params: int, neuron_recording: int, neuron_builder: int, initial_values: int)

Bases: NamedTuple

Identifiers for neuron regions.

Create new instance of NeuronRegions(core_params, neuron_params, current_source_params, neuron_recording, neuron_builder, initial_values)

core_params: int

Alias for field number 0

current_source_params: int

Alias for field number 2

initial_values: int

Alias for field number 5

neuron_builder: int

Alias for field number 4

neuron_params: int

Alias for field number 1

neuron_recording: int

Alias for field number 3

class spynnaker.pyNN.models.neuron.PopulationMachineLocalOnlyCombinedVertex(sdram: AbstractSDRAM, label: str, app_vertex: PopulationVertex, vertex_slice: Slice, slice_index: int, ring_buffer_shifts: Sequence[int], weight_scales: ndarray[tuple[Any, ...], dtype[floating]], neuron_data: NeuronData, max_atoms_per_core: int)

Bases: PopulationMachineCommon, PopulationMachineNeurons, AbstractGeneratesDataSpecification, AbstractRewritesDataSpecification

A machine vertex for PyNN Populations.

Parameters:

  • sdram – The SDRAM used by the vertex

  • label – The label of the vertex

  • app_vertex – The associated application vertex

  • vertex_slice – The slice of the population that this implements

  • slice_index – The index of the slice in the ordered list of slices

  • ring_buffer_shifts – The shifts to apply to convert ring buffer values to S1615 values

  • weight_scales – The scaling to apply to weights to store them in the synapses

  • neuron_data – The handler of neuron data

  • max_atoms_per_core – The maximum number of atoms per core

BACKGROUND_MAX_QUEUED_NAME = 'Max_backgrounds_queued'
BACKGROUND_OVERLOADS_NAME = 'Times_the_background_queue_overloaded'
COMMON_REGIONS = (REGIONS.SYSTEM, REGIONS.PROVENANCE_DATA, REGIONS.PROFILING, REGIONS.RECORDING)
INPUT_BUFFER_FULL_NAME = 'Times_the_input_buffer_lost_packets'
LOCAL_ONLY_SIZE = 20
MAX_FILLED_SIZE_OF_INPUT_BUFFER_NAME = 'Max_filled_size_input_buffer'
MAX_SPIKES_PER_TIME_STEP_NAME = 'Max_spikes_per_time_step'
NEURON_REGIONS = (REGIONS.CORE_PARAMS, REGIONS.NEURON_PARAMS, REGIONS.CURRENT_SOURCE_PARAMS, REGIONS.NEURON_RECORDING, REGIONS.NEURON_BUILDER, REGIONS.INITIAL_VALUES)
N_LATE_SPIKES_NAME = 'Number_of_late_spikes'
class REGIONS(value)[source]

Bases: IntEnum

Regions for populations.

CORE_PARAMS = 4
CURRENT_SOURCE_PARAMS = 6
INITIAL_VALUES = 11
LOCAL_ONLY = 8
LOCAL_ONLY_PARAMS = 9
NEURON_BUILDER = 10
NEURON_PARAMS = 5
NEURON_RECORDING = 7
PROFILING = 2
PROVENANCE_DATA = 1
RECORDING = 3
SYSTEM = 0
generate_data_specification(spec: DataSpecificationGenerator, placement: Placement) → None[source]

Generate a data specification.

Parameters:

  • spec – The data specification to write to

  • placement – The placement the vertex is located at

get_recorded_region_ids() → List[int][source]

Get the recording region IDs that have been recorded using buffering.

Returns:

The region numbers that have active recording

parse_extra_provenance_items(label: str, x: int, y: int, p: int, provenance_data: Sequence[int]) → None[source]

Convert the remaining provenance words (those not in the standard set) into provenance items.

Called by get_provenance_data_from_machine()

Parameters:

  • label – A descriptive label for the vertex (derived from label and placed position) to be used for provenance error reporting to the user.

  • x – x coordinate of the chip where this core

  • y – y coordinate of the core where this core

  • p – virtual id of the core

  • provenance_data – The list of words of raw provenance data.

regenerate_data_specification(spec: DataSpecificationReloader, placement: Placement) → None[source]

Regenerate the data specification, only generating regions that have changed and need to be reloaded.

Parameters:

  • spec – Where to write the regenerated spec

  • placement – Where are we regenerating for?

reload_required() → bool[source]
Returns:

True if any data region needs to be reloaded.

set_do_neuron_regeneration() → None[source]

Indicate that data re-generation of neuron parameters is required.

set_reload_required(new_value: bool) → None[source]

Indicate that the regions have been reloaded.

Parameters:

new_value – the new value

class spynnaker.pyNN.models.neuron.PopulationMachineVertex(sdram: AbstractSDRAM, label: str, app_vertex: PopulationVertex, vertex_slice: Slice, slice_index: int, ring_buffer_shifts: Sequence[int], weight_scales: ndarray[tuple[Any, ...], dtype[floating]], structural_sz: int, max_atoms_per_core: int, synaptic_matrices: SynapticMatrices, neuron_data: NeuronData)

Bases: PopulationMachineCommon, PopulationMachineNeurons, PopulationMachineSynapses, AbstractGeneratesDataSpecification, AbstractRewritesDataSpecification

A machine vertex for PyNN Populations.

Parameters:

  • sdram – The SDRAM used by the vertex

  • label – The label of the vertex

  • app_vertex – The associated application vertex

  • vertex_slice – The slice of the population that this implements

  • slice_index – The index of the slice in the ordered list of slices

  • ring_buffer_shifts – The shifts to apply to convert ring buffer values to S1615 values

  • weight_scales – The scaling to apply to weights to store them in the synapses

  • structural_sz – The size of the structural data

  • synaptic_matrices – The synaptic matrices

  • neuron_data – The handler of neuron data

BACKGROUND_MAX_QUEUED_NAME = 'Max_backgrounds_queued'
BACKGROUND_OVERLOADS_NAME = 'Times_the_background_queue_overloaded'
COMMON_REGIONS = (REGIONS.SYSTEM, REGIONS.PROVENANCE_DATA, REGIONS.PROFILING, REGIONS.RECORDING)
DMA_COMPLETE = "DMA's that were completed"
INPUT_BUFFER_FULL_NAME = 'Times_the_input_buffer_lost_packets'
MAX_FILLED_SIZE_OF_INPUT_BUFFER_NAME = 'Max_filled_size_input_buffer'
NEURON_REGIONS = (REGIONS.CORE_PARAMS, REGIONS.NEURON_PARAMS, REGIONS.CURRENT_SOURCE_PARAMS, REGIONS.NEURON_RECORDING, REGIONS.NEURON_BUILDER, REGIONS.INITIAL_VALUES)
N_LATE_SPIKES_NAME = 'Number_of_late_spikes'
N_REWIRES_NAME = 'Number_of_rewires'
class REGIONS(value)[source]

Bases: IntEnum

Regions for populations.

BIT_FIELD_FILTER = 14
CONNECTOR_BUILDER = 12
CORE_PARAMS = 1
CURRENT_SOURCE_PARAMS = 3
INITIAL_VALUES = 16
NEURON_BUILDER = 13
NEURON_PARAMS = 2
NEURON_RECORDING = 9
POPULATION_TABLE = 5
PROFILING = 11
PROVENANCE_DATA = 10
RECORDING = 15
STRUCTURAL_DYNAMICS = 8
SYNAPSE_DYNAMICS = 7
SYNAPSE_PARAMS = 4
SYNAPTIC_MATRIX = 6
SYSTEM = 0
SPIKES_PROCESSED = 'How many spikes were processed'
SYNAPSE_REGIONS = (REGIONS.SYNAPSE_PARAMS, REGIONS.POPULATION_TABLE, REGIONS.SYNAPTIC_MATRIX, REGIONS.SYNAPSE_DYNAMICS, REGIONS.STRUCTURAL_DYNAMICS, REGIONS.BIT_FIELD_FILTER, REGIONS.CONNECTOR_BUILDER)
generate_data_specification(spec: DataSpecificationGenerator, placement: Placement) → None[source]

Generate a data specification.

Parameters:

  • spec – The data specification to write to

  • placement – The placement the vertex is located at

get_n_keys_for_partition(partition_id: str) → int[source]

Get the number of keys required by the given partition of edges.

Parameters:

partition_id – The identifier of the partition; the partition_id param is only used by some MachineVertex subclasses

Returns:

The number of keys required

get_recorded_region_ids() → List[int][source]

Get the recording region IDs that have been recorded using buffering.

Returns:

The region numbers that have active recording

parse_extra_provenance_items(label: str, x: int, y: int, p: int, provenance_data: Sequence[int]) → None[source]

Convert the remaining provenance words (those not in the standard set) into provenance items.

Called by get_provenance_data_from_machine()

Parameters:

  • label – A descriptive label for the vertex (derived from label and placed position) to be used for provenance error reporting to the user.

  • x – x coordinate of the chip where this core

  • y – y coordinate of the core where this core

  • p – virtual id of the core

  • provenance_data – The list of words of raw provenance data.

regenerate_data_specification(spec: DataSpecificationReloader, placement: Placement) → None[source]

Regenerate the data specification, only generating regions that have changed and need to be reloaded.

Parameters:

  • spec – Where to write the regenerated spec

  • placement – Where are we regenerating for?

reload_required() → bool[source]
Returns:

True if any data region needs to be reloaded.

set_do_neuron_regeneration() → None[source]

Indicate that data re-generation of neuron parameters is required.

set_do_synapse_regeneration() → None[source]

Indicates that synaptic data regeneration is required.

set_reload_required(new_value: bool) → None[source]

Indicate that the regions have been reloaded.

Parameters:

new_value – the new value

class spynnaker.pyNN.models.neuron.PopulationNeuronsMachineVertex(sdram: AbstractSDRAM, label: str, app_vertex: PopulationVertex, vertex_slice: Slice, slice_index: int, ring_buffer_shifts: Sequence[int], weight_scales: ndarray[tuple[Any, ...], dtype[floating]], neuron_data: NeuronData, max_atoms_per_core: int)

Bases: PopulationMachineCommon, PopulationMachineNeurons, AbstractGeneratesDataSpecification, AbstractRewritesDataSpecification, ReceivesSynapticInputsOverSDRAM

A machine vertex for the Neurons of PyNN Populations.

Parameters:

  • sdram – The SDRAM used by the vertex

  • label – The label of the vertex

  • app_vertex – The associated application vertex

  • vertex_slice – The slice of the population that this implements

  • slice_index – The index of the slice in the ordered list of slices

  • ring_buffer_shifts – The shifts to apply to convert ring buffer values to S1615 values

  • weight_scales – The scaling to apply to weights to store them in the synapses

  • neuron_data – The handler of neuron data

  • max_atoms_per_core – The maximum number of atoms per core

COMMON_REGIONS = (REGIONS.SYSTEM, REGIONS.PROVENANCE_DATA, REGIONS.PROFILING, REGIONS.RECORDING)
NEURON_REGIONS = (REGIONS.CORE_PARAMS, REGIONS.NEURON_PARAMS, REGIONS.CURRENT_SOURCE_PARAMS, REGIONS.NEURON_RECORDING, REGIONS.NEURON_BUILDER, REGIONS.INITIAL_VALUES)
class REGIONS(value)[source]

Bases: IntEnum

Regions for populations.

CORE_PARAMS = 1
CURRENT_SOURCE_PARAMS = 6
INITIAL_VALUES = 10
NEURON_BUILDER = 9
NEURON_PARAMS = 5
NEURON_RECORDING = 7
PROFILING = 3
PROVENANCE_DATA = 2
RECORDING = 4
SDRAM_EDGE_PARAMS = 8
SYSTEM = 0
generate_data_specification(spec: DataSpecificationGenerator, placement: Placement) → None[source]

Generate a data specification.

Parameters:

  • spec – The data specification to write to

  • placement – The placement the vertex is located at

static get_n_bytes_for_transfer(n_neurons: int, n_synapse_types: int) → int[source]
Parameters:

  • n_neurons – number of neurons

  • n_synapse_types – number of synapse types

Returns:

The number of bytes needed for a transfer.

get_n_keys_for_partition(partition_id: str) → int[source]

Get the number of keys required by the given partition of edges.

Parameters:

partition_id – The identifier of the partition; the partition_id param is only used by some MachineVertex subclasses

Returns:

The number of keys required

get_recorded_region_ids() → List[int][source]

Get the recording region IDs that have been recorded using buffering.

Returns:

The region numbers that have active recording

property n_bytes_for_transfer: int

The number of bytes to be sent over the channel. This will be calculated using the above numbers, but also rounded up to a number of words, and with the number of neurons rounded up to a power of 2.

parse_extra_provenance_items(label: str, x: int, y: int, p: int, provenance_data: Sequence[int]) → None[source]

Convert the remaining provenance words (those not in the standard set) into provenance items.

Called by get_provenance_data_from_machine()

Parameters:

  • label – A descriptive label for the vertex (derived from label and placed position) to be used for provenance error reporting to the user.

  • x – x coordinate of the chip where this core

  • y – y coordinate of the core where this core

  • p – virtual id of the core

  • provenance_data – The list of words of raw provenance data.

regenerate_data_specification(spec: DataSpecificationReloader, placement: Placement) → None[source]

Regenerate the data specification, only generating regions that have changed and need to be reloaded.

Parameters:

  • spec – Where to write the regenerated spec

  • placement – Where are we regenerating for?

reload_required() → bool[source]
Returns:

True if any data region needs to be reloaded.

sdram_requirement(sdram_machine_edge: SDRAMMachineEdge) → int[source]

Asks a machine vertex for the SDRAM requirement it needs.

Parameters:

sdram_machine_edge – The SDRAM edge in question ~pacman.model.graphs.machine.SDRAMMachineEdge

Returns:

The size in bytes this vertex needs for the SDRAM edge.

set_do_neuron_regeneration() → None[source]

Indicate that data re-generation of neuron parameters is required.

set_reload_required(new_value: bool) → None[source]

Indicate that the regions have been reloaded.

Parameters:

new_value – the new value

set_sdram_partition(sdram_partition: SourceSegmentedSDRAMMachinePartition) → None[source]

Sets the SDRAM Partition to receive data from.

Parameters:

sdram_partition – The partition to receive data from.

property weight_scales: ndarray[tuple[Any, ...], dtype[floating]]

A list of scale factors to be applied to weights that get passed over SDRAM, one for each synapse type.

class spynnaker.pyNN.models.neuron.PopulationSynapsesMachineVertexCommon(sdram: AbstractSDRAM, label: str, app_vertex: PopulationVertex, vertex_slice: Slice)

Bases: PopulationMachineCommon, SendsSynapticInputsOverSDRAM

Common parts of a machine vertex for the synapses of a Population.

Parameters:

  • sdram – The SDRAM used by the vertex

  • label – The label of the vertex

  • app_vertex – The associated application vertex

  • vertex_slice – The slice of the population that this implements

COMMON_REGIONS = (REGIONS.SYSTEM, REGIONS.PROVENANCE_DATA, REGIONS.PROFILING, REGIONS.RECORDING)
DMA_COMPLETE = "DMA's that were completed"
EARLIEST_RECEIVE = 'Earliest_receive_time'
INPUT_BUFFER_FULL_NAME = 'Times_the_input_buffer_lost_packets'
LATEST_RECEIVE = 'Latest_receive_time'
MAX_FILLED_SIZE_OF_INPUT_BUFFER_NAME = 'Max_filled_size_input_buffer'
MAX_SPIKES_PROCESSED = 'Max_spikes_processed_in_time_step'
MAX_SPIKES_RECEIVED = 'Max_spikes_received_in_time_step'
MAX_SPIKE_OVERFLOW = 'Max_spike_overflow_in_time_step'
MAX_TRANSFER_TIMER_OVERRUNS = 'Max_transfer_overrun'
N_LATE_SPIKES_NAME = 'Number_of_late_spikes'
N_REWIRES_NAME = 'Number_of_rewires'
N_SKIPPED_TIME_STEPS = 'Times_a_time_step_was_skipped'
N_TRANSFER_TIMER_OVERRUNS = 'Times_the_transfer_did_not_complete_in_time'
class REGIONS(value)[source]

Bases: IntEnum

Regions for populations.

BIT_FIELD_FILTER = 9
CONNECTOR_BUILDER = 12
KEY_REGION = 11
POPULATION_TABLE = 6
PROFILING = 2
PROVENANCE_DATA = 1
RECORDING = 3
SDRAM_EDGE_PARAMS = 10
STRUCTURAL_DYNAMICS = 8
SYNAPSE_DYNAMICS = 7
SYNAPSE_PARAMS = 4
SYNAPTIC_MATRIX = 5
SYSTEM = 0
SPIKES_PROCESSED = 'How many spikes were processed'
SYNAPSE_REGIONS = (REGIONS.SYNAPSE_PARAMS, REGIONS.POPULATION_TABLE, REGIONS.SYNAPTIC_MATRIX, REGIONS.SYNAPSE_DYNAMICS, REGIONS.STRUCTURAL_DYNAMICS, REGIONS.BIT_FIELD_FILTER, REGIONS.CONNECTOR_BUILDER)
get_recorded_region_ids() → Sequence[int][source]

Get the recording region IDs that have been recorded using buffering.

Returns:

The region numbers that have active recording

parse_extra_provenance_items(label: str, x: int, y: int, p: int, provenance_data: Sequence[int]) → None[source]

Convert the remaining provenance words (those not in the standard set) into provenance items.

Called by get_provenance_data_from_machine()

Parameters:

  • label – A descriptive label for the vertex (derived from label and placed position) to be used for provenance error reporting to the user.

  • x – x coordinate of the chip where this core

  • y – y coordinate of the core where this core

  • p – virtual id of the core

  • provenance_data – The list of words of raw provenance data.

sdram_requirement(sdram_machine_edge: SDRAMMachineEdge) → int[source]

Asks a machine vertex for the SDRAM requirement it needs.

Parameters:

sdram_machine_edge – The SDRAM edge in question ~pacman.model.graphs.machine.SDRAMMachineEdge

Returns:

The size in bytes this vertex needs for the SDRAM edge.

set_neuron_vertex_and_partition_id(neuron_vertex: PopulationNeuronsMachineVertex, partition_id: str) → None[source]

Set the neuron vertex and partition ID for the case with a self-connection.

set_sdram_partition(sdram_partition: SourceSegmentedSDRAMMachinePartition) → None[source]

Set the SDRAM partition. Must only be called once per instance.

Parameters:

sdram_partition – The SDRAM partition to receive synapses from

class spynnaker.pyNN.models.neuron.PopulationSynapsesMachineVertexLead(sdram: AbstractSDRAM, label: str, app_vertex: PopulationVertex, vertex_slice: Slice, ring_buffer_shifts: Sequence[int], weight_scales: NDArray[floating], structural_sz: int, synapse_references: SynapseRegionReferences, max_atoms_per_core: int, synaptic_matrices: SynapticMatrices)

Bases: PopulationSynapsesMachineVertexCommon, PopulationMachineSynapses, AbstractGeneratesDataSpecification, AbstractRewritesDataSpecification

A synaptic machine vertex that leads other synaptic machine vertices, writing shared areas.

Parameters:

  • sdram – The SDRAM used by the vertex

  • label – The label of the vertex

  • app_vertex – The associated application vertex

  • vertex_slice – The slice of the population that this implements

generate_data_specification(spec: DataSpecificationGenerator, placement: Placement) → None[source]

Generate a data specification.

Parameters:

  • spec – The data specification to write to

  • placement – The placement the vertex is located at

get_recorded_region_ids() → List[int][source]

Get the recording region IDs that have been recorded using buffering.

Returns:

The region numbers that have active recording

regenerate_data_specification(spec: DataSpecificationReloader, placement: Placement) → None[source]

Regenerate the data specification, only generating regions that have changed and need to be reloaded.

Parameters:

  • spec – Where to write the regenerated spec

  • placement – Where are we regenerating for?

reload_required() → bool[source]
Returns:

True if any data region needs to be reloaded.

set_do_synapse_regeneration() → None[source]

Indicates that synaptic data regeneration is required.

set_reload_required(new_value: bool) → None[source]

Indicate that the regions have been reloaded.

Parameters:

new_value – the new value

class spynnaker.pyNN.models.neuron.PopulationSynapsesMachineVertexShared(sdram: AbstractSDRAM, label: str, app_vertex: PopulationVertex, vertex_slice: Slice, synapse_references: SynapseRegionReferences)

Bases: PopulationSynapsesMachineVertexCommon, PopulationMachineSynapsesProvenance, AbstractGeneratesDataSpecification

A machine vertex for PyNN Populations.

Parameters:

  • sdram – The SDRAM used by the vertex

  • label – The label of the vertex

  • app_vertex – The associated application vertex

  • vertex_slice – The slice of the population that this implements

generate_data_specification(spec: DataSpecificationGenerator, placement: Placement) → None[source]

Generate a data specification.

Parameters:

  • spec – The data specification to write to

  • placement – The placement the vertex is located at

class spynnaker.pyNN.models.neuron.PopulationVertex(*, n_neurons: int, label: str, max_atoms_per_core: int | Tuple[int, ...], n_synapse_cores: int | None, allow_delay_extensions: bool, spikes_per_second: float | None, ring_buffer_sigma: float | None, max_expected_summed_weight: List[float] | None, incoming_spike_buffer_size: int | None, neuron_impl: AbstractNeuronImpl, pynn_model: AbstractPyNNNeuronModel, drop_late_spikes: bool, splitter: SplitterPopulationVertex | None, seed: int | None, n_colour_bits: int | None, extra_partitions: List[str] | None = None)

Bases: PopulationApplicationVertex, AbstractAcceptsIncomingSynapses, AbstractCanReset, SupportsStructure

Underlying vertex model for Neural Populations.

Parameters:

  • n_neurons – The number of neurons in the population

  • label – The label on the population

  • max_atoms_per_core – The maximum number of atoms (neurons) per SpiNNaker core.

  • n_synapse_cores – The number of synapse cores to use: 0 for combined core, or None for automatic determination

  • allow_delay_extensions – Whether delay extensions should be allowed or not

  • spikes_per_second – Expected spike rate

  • ring_buffer_sigma – How many SD above the mean to go for upper bound of ring buffer size; a good starting choice is 5.0. Given length of simulation we can set this for approximate number of saturation events.

  • max_expected_summed_weight – The maximum expected summed weights for each synapse type.

  • incoming_spike_buffer_size

  • drop_late_spikes – control flag for dropping late packets.

  • neuron_impl – The (Python side of the) implementation of the neurons themselves.

  • pynn_model – The PyNN neuron model that this vertex is working on behalf of.

  • splitter – splitter object

  • seed – The Population seed, used to ensure the same random generation on each run.

  • n_colour_bits – The number of colour bits to use

  • extra_partitions – Extra partitions that are to be sent by the vertex

CORE_PARAMS_BASE_SIZE = 20
add_incoming_projection(projection: Projection) → None[source]

Add a projection incoming to this vertex.

Parameters:

projection – The new projection to add

property allow_delay_extension: bool

Whether delay extension should be allowed or not.

property atoms_shape: Tuple[int, ...]

The “shape” of the atoms in the vertex i.e. how the atoms are split between the dimensions of the vertex. By default everything is 1-dimensional, so the value will be a 1-tuple but can be overridden by a vertex that supports multiple dimensions.

can_generate_on_machine() → bool[source]
Returns:

True if the parameters of this vertex can be generated on the machine

clear_connection_cache() → None[source]

Flush the cache of connection information; needed for a second run.

property combined_binary_exists: bool

Whether the combined binary file exists.

property combined_binary_file_name: str

The name of the combined binary file for the vertex.

property conductance_based: bool

Whether the vertex models post-synaptic inputs as currents or conductance.

By default this is False; override if the model accepts conductance based input.

copy_initial_state_variables(vertex_slice: Slice) → None[source]

Copies the state variables into the initial state variables.

Parameters:

vertex_slice – The slice to copy now

core_seed(vertex_slice: Slice) → Sequence[int][source]

The seed to use for a core.

Parameters:

vertex_slice – The machine vertex that the seed is for

Returns:

A list of 4 integers

property current_source_id_list: Dict[AbstractCurrentSource, Selector]

Current source ID list needed to be available to machine vertex.

property current_sources: List[AbstractCurrentSource]

Current sources needed to be available to machine vertex.

describe() → Dict[str, str | Dict[str, Any]][source]
Returns:

A human-readable description of vertex and its parameters

property drop_late_spikes: bool

Whether spikes should be dropped if not processed in a timestep.

property extra_partitions: List[str]

The extra partitions that are to be sent by the vertex.

get_buffer_data_type(name: str) → BufferDataType[source]

Get the type of data recorded by the buffer manager.

The buffer data type controls how data returned by the cores is handled in NeoBufferDatabase.

Parameters:

name – The name of the variable recorded

Raises:

KeyError – if the variable isn’t being recorded

Returns:

Data type in the Buffer Database

get_common_constant_sdram(n_record: int, n_provenance: int, common_regions: CommonRegions) → MultiRegionSDRAM[source]
Parameters:

  • n_record – The number of recording regions

  • n_provenance – The number of provenance items

  • common_regions – Region IDs

Returns:

The amount of SDRAM used by common parts.

get_connections_from_machine(app_edge: ProjectionApplicationEdge, synapse_info: SynapseInformation) → ConnectionsArray[source]
Parameters:

  • app_edge – The edge for which the data is being read

  • synapse_info – The specific projection within the edge

Returns:

The connections from the machine post-run.

get_current_state_values(names: str | List[str] | Tuple[str, ...], selector: None | int | integer | SupportsInt | slice | Sequence[bool | bool] | Sequence[int | integer | SupportsInt] = None) → ParameterHolder[source]
Parameters:

  • names – The name or names of the variable to get

  • selector – a description of the subrange to accept, or None for all. See: :py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids

Returns:

The current values of a state variable for the whole Population or a subset if the selector is used.

Raises:

KeyError – if the variable is not something that can be read

get_data_type(name: str) → DataType | None[source]

Get the type data returned by a recording of the variable.

This is the type of data the C code is returning. For instance data such as spikes this will be None.

Parameters:

name – The name of the variable to get the type of

Returns:

The data type used by the C code

Raises:

KeyError – If the variable isn’t recordable

get_incoming_projections_from(source_vertex: PopulationApplicationVertex) → Iterable[Projection][source]
Returns:

The projections that target this population vertex from the given source.

get_initial_state_values(names: str | List[str] | Tuple[str, ...], selector: None | int | integer | SupportsInt | slice | Sequence[bool | bool] | Sequence[int | integer | SupportsInt] = None) → ParameterHolder[source]
Parameters:

  • names – The name or names of the variable to get

  • selector – a description of the subrange to accept, or None for all. See: selector_to_ids()

Returns:

The initial values of a state variable for the whole Population or a subset if the selector is used.

Raises:

KeyError – if the variable is not something that can be read

get_max_atoms_per_core() → int[source]

Gets the maximum number of atoms per core.

Which is either the number of atoms required across the whole application vertex or a lower value set.

Returns:

The maximum number of atoms per core

get_max_atoms_per_dimension_per_core() → Tuple[int, ...][source]

Gets the maximum number of atoms per dimension per core.

This will return a tuple with a number for each dimension of the vertex, which might be one if this is a single-dimension vertex.

Returns:

The maximum number of atoms per dimension per core

get_max_neuron_variable_sdram(n_neurons: int) → AbstractSDRAM[source]
Returns:

The amount of SDRAM per timestep used by neuron parts.

get_max_row_info(synapse_info: SynapseInformation, n_post_atoms: int, app_edge: ProjectionApplicationEdge) → MaxRowInfo[source]
Parameters:

  • synapse_info – Information about synapses

  • n_post_atoms – The number of atoms projected to

  • app_edge – The edge of the projection

Returns:

The maximum row length data.

get_max_synapse_variable_sdram(n_neurons: int) → AbstractSDRAM[source]
Returns:

The amount of SDRAM per timestep used by synapse parts.

get_n_atom_bits() → int[source]
Returns:

How many bits are required for one core’s worth of atoms

get_neuron_constant_sdram(n_atoms: int, neuron_regions: NeuronRegions) → MultiRegionSDRAM[source]
Parameters:

  • n_atoms – The number of atoms

  • neuron_regions – Region IDs

Returns:

The amount of SDRAM for these atoms and regions.

get_neuron_variable_sdram(vertex_slice: Slice) → AbstractSDRAM[source]
Parameters:

vertex_slice – The slice of neurons to get the size of

Returns:

The amount of SDRAM per timestep used by neuron parts.

get_neurons_recording(name: str, vertex_slice: Slice) → Collection[int] | None[source]

Gets the neurons being recorded on the core with this slice.

Typically vertex_slice.get_raster_ids(atoms_shape) but may be a sublist if doing selective recording.

Parameters:

  • name – The name of the variable to get the region of

  • vertex_slice

Returns:

A list of the global raster IDs of the atoms in recording named variable within this slice

get_parameter_values(names: str | List[str] | Tuple[str, ...], selector: None | int | integer | SupportsInt | slice | Sequence[bool | bool] | Sequence[int | integer | SupportsInt] = None) → ParameterHolder[source]
Parameters:

  • names – The name or names of the parameter to get

  • selector – a description of the subrange to accept, or None for all. See: selector_to_ids()

Returns:

The values of a parameter or parameters for the whole Population or a subset if the selector is used.

Raises:

KeyError – if the parameter is not something that can be read

get_parameters() → List[str][source]
Returns:

The names of all the parameters that can be obtained

get_recordable_variables() → List[str][source]

Get a list of the names of things that can be recorded.

This methods list the variable recorded via the Population.

Includes both neuron and synapse recordable things

Returns:

List of variable names

get_recording_region(name: str) → int[source]
Parameters:

name – The name of the variable to get the region of

Returns:

The recording region for the named variable.

Raises:

KeyError – If the variable isn’t being recorded

get_recording_variables() → List[str][source]
Returns:

A list of variables that are currently being recorded.

get_ring_buffer_shifts() → List[int][source]
Returns:

The shift of the ring buffers for transfer of values into the input buffers for this model.

get_sampling_interval_ms(name: str) → float[source]

Get the sampling interval of the recording for the given variable.

The values is in ms and unless selective recording is used will be SpynnakerDataView.get_simulation_time_step_us()

Parameters:

name – The name of the variable

Returns:

Sampling rate in milliseconds for this variable

Raises:

KeyError – If the variable isn’t being recorded

get_sdram_usage_for_core_neuron_params(n_atoms: int) → int[source]
Parameters:

n_atoms – The number of atoms per core

Returns:

The SDRAM required for the core neuron parameters

get_sdram_usage_for_current_source_params(n_atoms: int) → int[source]

Calculate the SDRAM usage for the current source parameters region.

Parameters:

n_atoms – The number of atoms to account for

Returns:

The SDRAM required for the current source region

get_sdram_usage_for_neuron_generation(n_atoms: int) → int[source]

Calculate the SDRAM usage for the neuron generation region.

Parameters:

n_atoms – The number of atoms per core

Returns:

The SDRAM required for the neuron generator region

get_sdram_usage_for_neuron_params(n_atoms: int) → int[source]

Calculate the SDRAM usage for just the neuron parameters region.

Parameters:

n_atoms – The number of atoms per core

Returns:

The SDRAM required for the neuron region

get_state_variables() → List[str][source]
Returns:

A list of supported state variables.

get_structural_dynamics_size(n_atoms: int) → int[source]
Parameters:

n_atoms – The number of atoms in the slice

Returns:

The size of the structural dynamics region, in bytes.

get_synapse_dynamics_size(n_atoms: int) → int[source]
Returns:

The size of the synapse dynamics region, in bytes.

get_synapse_expander_size() → int[source]
Returns:

The size of the synapse expander region, in bytes.

get_synapse_id_by_target(target: str) → int | None[source]
Parameters:

target – The synapse to get the id of

Returns:

The id of synapse using its target name.

get_synapse_params_size() → int[source]
Returns:

The size of the synapse parameters, in bytes.

get_synapse_variable_sdram(vertex_slice: Slice) → AbstractSDRAM[source]
Parameters:

vertex_slice – The slice of neurons to get the size of

Returns:

The amount of SDRAM per timestep used by synapse parts.

get_synapses_size(n_post_atoms: int) → int[source]
Parameters:

n_post_atoms – The number of atoms projected to

Returns:

The maximum SDRAM usage for the synapses on a vertex slice.

get_units(name: str) → str[source]

Get the units of the given parameter or state variable.

Parameters:

name – the name of the parameter to get the units of

Returns:

The unit or this variable. For example ‘mV’ or ‘uS’. Will be an empty string for things like spikes and probability

Raises:

KeyError – if the name isn’t recognised or the units cannot be identified

get_weight_scales(ring_buffer_shifts: Iterable[int]) → ndarray[tuple[Any, ...], dtype[floating]][source]
Parameters:

ring_buffer_shifts – The shifts to convert to weight scales

Returns:

The weight scaling to apply to weights in synapses.

property incoming_poisson_projections: Sequence[Projection]

The projections that target this population vertex which originate from a Poisson source which has only one outgoing projection

property incoming_projections: Iterable[Projection]

The projections that target this population vertex.

property incoming_spike_buffer_size: int

The size of the incoming spike buffer to be used on the cores.

property initial_state_variables: RangeDictionary[float]

The initial values of the state variables of the neurons.

inject(current_source: AbstractCurrentSource, selector: Selector = None) → None[source]

Inject a current source into this population.

Parameters:

  • current_source – the current source to be injected

  • selector – a description of the subrange to accept, or None for all. See: selector_to_ids()

Raises:

ConfigurationException – if the population doesn’t support injection

property max_delay_steps: int

The maximum number of delay steps supported on a core.

property max_delay_steps_incoming: int

The maximum delay steps needed to handle incoming synapses, accounting for delay extensions.

property n_atoms: int

The number of atoms in the vertex.

property n_colour_bits: int

The number of colour bits sent by this vertex.

Assumed 0 unless overridden

property n_profile_samples: int

The maximum number of profile samples to report.

property n_synapse_cores_required: int

The estimated number of synapse cores required, when using a split synapse-neuron core model.

property neuron_core_binary_file_name: str

The name of the neuron core binary file for the vertex.

property neuron_impl: AbstractNeuronImpl

The neuron implementation.

property neuron_recordables: List[str]

The names of variables that can be recorded by the neuron.

property neuron_recorder: NeuronRecorder

The recorder for neurons.

property parameters: RangeDictionary[float]

The parameters of the neurons in the population.

property pop_seed: Sequence[int]

The seed to use for the population overall; a list of four integers.

property read_initial_values: bool

Whether initial values need to be stored.

reset_to_first_timestep() → None[source]

Reset the object to first time step.

property ring_buffer_sigma: float

How many SD above the mean to go for upper bound of ring buffer size

property self_projection: Projection | None

Any projection from this vertex to itself.

set_allow_delay_extensions(allow_delay_extensions: bool) → None[source]

Set whether delay extensions are allowed.

Parameters:

allow_delay_extensions – Whether to allow delay extensions

set_current_state_values(name: str, value: float | Sequence[float] | ndarray[tuple[Any, ...], dtype[floating]] | RandomDistribution, selector: None | int | integer | SupportsInt | slice | Sequence[bool | bool] | Sequence[int | integer | SupportsInt] = None) → None[source]

Set the current values of a state variable for the whole Population or a subset if the selector is used.

Parameters:

  • name – The name of the variable to set

  • value – The new value

  • selector – a description of the subrange to accept, or None for all. See: selector_to_ids()

Raises:

KeyError – if the variable is not something that can be changed

set_initial_state_values(name: str, value: float | Sequence[float] | ndarray[tuple[Any, ...], dtype[floating]] | RandomDistribution, selector: None | int | integer | SupportsInt | slice | Sequence[bool | bool] | Sequence[int | integer | SupportsInt] = None) → None[source]

Set the initial values of a state variable for the whole Population or a subset if the selector is used.

Parameters:

  • name – The name of the variable to set

  • value – The new value

  • selector – a description of the subrange to accept, or None for all. See: selector_to_ids()

Raises:

KeyError – if the variable is not something that can be changed

set_max_atoms_per_dimension_per_core(new_value: int | Tuple[int, ...]) → None[source]

Set the maximum number of atoms per dimension per core.

Can be used to raise or lower the maximum number of atoms per core or per dimension per core.

Parameters:

new_value – Value to set. If the vertex is n-dimensional where n > 1, a tuple of n values must be given. If the vertex is 1 dimensional, a 1-tuple or integer can be given.

set_n_synapse_cores(n_synapse_cores: int | None) → None[source]

Set the number of synapse cores.

Parameters:

n_synapse_cores – The number of synapse cores to use; 0 for a combined core, or None to allow the system to choose

set_not_recording(name: str, indices: Collection[int] | None = None) → None[source]

Set a variable not recording.

Parameters:

  • name – The name of the variable to not record

  • indices – The list of neuron indices to not record or None for all

Raises:

KeyError – if the variable cannot be stopped from recording

set_parameter_values(name: str, value: float | Sequence[float] | ndarray[tuple[Any, ...], dtype[floating]] | RandomDistribution, selector: None | int | integer | SupportsInt | slice | Sequence[bool | bool] | Sequence[int | integer | SupportsInt] = None) → None[source]

Set the values of a parameter for the whole Population or a subset if the selector is used.

Parameters:

  • name – The name of the parameter to set

  • value – The new value

  • selector – a description of the subrange to accept, or None for all. See: selector_to_ids()

Raises:

KeyError – if the parameter is not something that can be changed

set_recording(name: str, sampling_interval: float | None = None, indices: Collection[int] | None = None) → None[source]

Set a variable recording.

Parameters:

  • name – The name of the variable to set the status of

  • sampling_interval – How often the variable should be recorded or None for every time step, in milliseconds

  • indices – The list of neuron indices to record or None for all

Raises:

KeyError – if the variable cannot be recorded

set_structure(structure: BaseStructure) → None[source]

Set the structure of the object.

Parameters:

structure – The structure to set

set_synapse_dynamics(synapse_dynamics: AbstractSynapseDynamics) → None[source]

Set the synapse dynamics of this population.

Parameters:

synapse_dynamics – The synapse dynamics to set

property size: int

The number of neurons in the vertex.

property spikes_per_second: float

Expected spike rate.

Comes from value passed into init otherwise cfg file

property split_binaries_exist: bool

Whether the split binary files exist.

property splitter: SplitterPopulationVertex

The splitter assigned to this vertex.

property state_variables: RangeDictionary[float]

The state variables of the neuron in the population.

property synapse_core_binary_file_name: str

The name of the synapse core binary file for the vertex.

property synapse_dynamics: AbstractSynapseDynamics

The synapse dynamics used by the synapses e.g. plastic or static. Settable.

property synapse_executable_suffix: str

The suffix of the executable name due to the type of synapses in use.

property synapse_recordables: List[str]

The names of variables that can be recorded by the synapses.

property synapse_recorder: NeuronRecorder

The recorder for synapses.

property use_combined_core: bool

Whether the vertex should operate on a combined neuron-synapse core, or if a split synapse-core is more appropriate.

property weight_scale: float

Get the weight scaling required by the implementation.

class spynnaker.pyNN.models.neuron.SpikeProcessingFastProvenance

Bases: Structure

Types of provenance and the DataType used to represent each.

N_ITEMS = 14
earliest_receive

Structure/Union member

latest_receive

Structure/Union member

max_size_input_buffer

Structure/Union member

max_spikes_overflow

Structure/Union member

max_spikes_processed

Structure/Union member

max_spikes_received

Structure/Union member

max_transfer_timer_overrun

Structure/Union member

n_buffer_overflows

Structure/Union member

n_dmas_complete

Structure/Union member

n_late_packets

Structure/Union member

n_rewires

Structure/Union member

n_skipped_time_steps

Structure/Union member

n_spikes_processed

Structure/Union member

n_transfer_timer_overruns

Structure/Union member

class spynnaker.pyNN.models.neuron.SpikeProcessingProvenance

Bases: Structure

The provenance from spike processing.

N_ITEMS = 6
max_size_input_buffer

Structure/Union member

n_buffer_overflows

Structure/Union member

n_dmas_complete

Structure/Union member

n_late_packets

Structure/Union member

n_rewires

Structure/Union member

n_spikes_processed

Structure/Union member

class spynnaker.pyNN.models.neuron.SynapseProvenance

Bases: Structure

Provenance items from synapse processing.

N_ITEMS = 10
max_late_spike

Structure/Union member

n_failed_bitfield_reads

Structure/Union member

n_filtered_by_bitfield

Structure/Union member

n_ghost_searches

Structure/Union member

n_invalid_pop_table_hits

Structure/Union member

n_late_spikes

Structure/Union member

n_plastic_saturations

Structure/Union member

n_pre_synaptic_events

Structure/Union member

n_saturations

Structure/Union member

n_skipped_synapses

Structure/Union member