Merge branch 'master' into categories

Author: Christian-B

pyproject.toml

@@ -17,5 +17,5 @@ requires = ["setuptools"]
 build-backend = "setuptools.build_meta"
 
 [[tool.mypy.overrides]]
-module = ["matplotlib", "matplotlib.*", "pyNN.*", "quantities", "neo", "neo.*", "scipy", "scipy.*", "lazyarray"]
+module = ["csa", "docstring_parser", "matplotlib", "matplotlib.*", "pyNN.*", "quantities", "neo", "neo.*", "scipy", "scipy.*", "lazyarray", "testfixtures"]
 ignore_missing_imports = true

spynnaker/pyNN/extra_algorithms/splitter_components/splitter_population_vertex_neurons_synapses.py

@@ -102,6 +102,8 @@ class SplitterPopulationVertexNeuronsSynapses(
         "__sdram_partitions",
         # The same chip groups
         "__same_chip_groups",
+        # The index used in get_source_specific_in_coming_vertices
+        "__synapse_index_used",
         # The application vertex sources that are neuromodulators
         "__neuromodulators")
 
@@ -117,6 +119,9 @@ def __init__(self) -> None:
             SourceSegmentedSDRAMMachinePartition] = []
         self.__same_chip_groups: List[Tuple[
             List[MachineVertex], AbstractSDRAM]] = []
+        self.__synapse_index_used: Dict[Tuple[ApplicationVertex, str], int]
+        self.__synapse_index_used = dict()
+
         self.__neuromodulators: Set[ApplicationVertex] = set()
         self.__incoming_vertices: List[List[MachineVertex]] = []
         self.__poisson_sources: Set[SpikeSourcePoissonVertex] = set()
@@ -539,10 +544,16 @@ def get_source_specific_in_coming_vertices(
         sources_per_vertex = max(1, int(2 ** math.ceil(math.log2(
             n_sources / n_synapse_cores))))
 
-        # Start on a different index each time to "even things out"
-        index = self.__next_synapse_index
-        self.__next_synapse_index = (
-            (self.__next_synapse_index + 1) % n_synapse_cores)
+        key = (source_vertex, partition_id)
+        if key in self.__synapse_index_used:
+            index = self.__synapse_index_used[key]
+        else:
+            # Start on a different index each time to "even things out"
+            index = self.__next_synapse_index
+            self.__next_synapse_index = (
+                (self.__next_synapse_index + 1) % n_synapse_cores)
+            self.__synapse_index_used[key] = index
+
         result: List[Tuple[MachineVertex, List[MachineVertex]]] = list()
         for start in range(0, n_sources, sources_per_vertex):
             end = min(start + sources_per_vertex, n_sources)

spynnaker/pyNN/models/neural_projections/connectors/abstract_connector.py

@@ -15,13 +15,14 @@
 import logging
 import math
 import re
-from typing import Dict, Optional, Sequence, Tuple, Union, TYPE_CHECKING
+from typing import Any, Dict, Optional, Sequence, Tuple, Union, TYPE_CHECKING
 from typing_extensions import Never
 
 import numpy
 from numpy import float64, uint32, uint16, uint8
 from numpy.typing import NDArray
 
+from pyNN import descriptions
 from pyNN.random import NumpyRNG, RandomDistribution
 from pyNN.space import Space
 
@@ -76,7 +77,8 @@ class AbstractConnector(object, metaclass=AbstractBase):
         "__safe",
         "__space",
         "__verbose",
-        "__param_seeds")
+        "__param_seeds",
+        "__used")
 
     def __init__(self, safe: bool = True, callback: None = None,
                  verbose: bool = False):
@@ -102,6 +104,7 @@ def __init__(self, safe: bool = True, callback: None = None,
         self.__n_clipped_delays = numpy.int64(0)
         self.__min_delay = 0.0
         self.__param_seeds: Dict[Tuple[int, int], int] = dict()
+        self.__used = False
 
     def set_space(self, space: Space) -> None:
         """
@@ -573,37 +576,20 @@ def safe(self) -> bool:
         """
         return self.__safe
 
-    @safe.setter
-    def safe(self, new_value: bool) -> None:
-        self.__safe = new_value
-
     @property
     def space(self) -> Optional[Space]:
         """
         The space object (may be updated after instantiation).
         """
         return self.__space
 
-    @space.setter
-    def space(self, new_value: Space) -> None:
-        """
-        Set the space object (allowed after instantiation).
-
-        :param new_value:
-        """
-        self.__space = new_value
-
     @property
     def verbose(self) -> bool:
         """
         verbose value supplied by user
         """
         return self.__verbose
 
-    @verbose.setter
-    def verbose(self, new_value: bool) -> None:
-        self.__verbose = new_value
-
     def get_connected_vertices(
             self, s_info: SynapseInformation, source_vertex: ApplicationVertex,
             target_vertex: ApplicationVertex) -> Sequence[
@@ -679,3 +665,82 @@ def validate_connection(
                 "Using a projection where the source or target is a "
                 "PopulationView on a multi-dimensional Population is not "
                 "supported")
+
+    def get_parameters(self) -> Dict[str, Any]:
+        """
+        A list of parameters that would recreate this connector.
+
+        May not be exactly the same as the ones used to construct this.
+
+        Will also not include any information or changes added by later calls.
+
+        :return: A map of the init parameters to the values passed in.
+        """
+        # The default is error
+        # This to avoid missing parameters in user Connectors
+        raise NotImplementedError(
+            f"{type(self)} does not implement "
+            f"Standard pyNN get_parameters method")
+
+    def _get_parameters(self) -> Dict[str, Any]:
+        """
+        :return: A map of the init parameters to the values passed in.
+        """
+        return {
+            "safe": self.safe,
+            "verbose": self.verbose,
+            "callback": None
+        }
+
+    def clone(self) -> "AbstractConnector":
+        """
+        Create a clone of the Connector at init point
+
+        This is a best effort attempt and its use is not recommended
+
+        :return: A clone of the Connector. Ignoring any SynapseInformation
+        """
+        theType = type(self)
+        params = self.get_parameters()
+        logger.warning(
+            f"Cloning type{self} which may lead to incorrect results.")
+        return theType(**params)
+
+    def get_unused(self) -> "AbstractConnector":
+        """
+        Checks the Connector is unused and clones if needed
+
+        This method should just check the connector is unused,
+        mark it as used and return it.
+
+        If the Connector is used will attempt to make a clone,
+        log warning that this is not recommended and may be incorrect,
+        and returns the clone.
+
+        :return: Ideally this Connector
+        """
+        if self.__used:
+            logger.warning(
+                "Reusing Connectors in sPyNNaker is not recommended")
+            clone = self.clone()
+            # call get_unused to mark used
+            return clone.get_unused()
+        self.__used = True
+        return self
+
+    def describe(self, template: Optional[str] = None,
+                 engine: str = 'default') -> str:
+        """
+        Returns a human-readable description of the connection method.
+
+        The output may be customized 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.
+
+        :return: A human-readable description of the connector.
+        """
+        context = {"Type": self.__class__.__name__}
+        context.update(self.get_parameters())
+        return descriptions.render(engine, template, context)

spynnaker/pyNN/models/neural_projections/connectors/all_but_me_connector.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from __future__ import annotations
-from typing import Sequence, Optional, TYPE_CHECKING
+from typing import Any, Dict, Sequence, Optional, TYPE_CHECKING
 
 import numpy
 from numpy import uint32
@@ -92,6 +92,13 @@ def __init__(self, n_neurons_per_group: Optional[int] = None,
         self.__weights = weights
         self.__check_weights(weights, n_neurons_per_group)
 
+    @overrides(AbstractGenerateConnectorOnMachine.get_parameters)
+    def get_parameters(self) -> Dict[str, Any]:
+        parameters = self._get_parameters()
+        parameters["n_neurons_per_group"] = self.__n_neurons_per_group
+        parameters["weights"] = self.__weights
+        return parameters
+
     def __check_weights(self, weights: Optional[NDArray[numpy.float64]],
                         n_neurons_per_group: Optional[int]) -> None:
         if weights is not None and n_neurons_per_group is not None:

spynnaker/pyNN/models/neural_projections/connectors/all_to_all_connector.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from __future__ import annotations
-from typing import Sequence, Optional, TYPE_CHECKING
+from typing import Any, Dict, Optional, Sequence, TYPE_CHECKING
 
 import numpy
 from numpy import uint32
@@ -65,6 +65,12 @@ def __init__(self, allow_self_connections: bool = True, safe: bool = True,
         super().__init__(safe, callback, verbose)
         self.__allow_self_connections = allow_self_connections
 
+    @overrides(AbstractGenerateConnectorOnMachine.get_parameters)
+    def get_parameters(self) -> Dict[str, Any]:
+        parameters = self._get_parameters()
+        parameters["allow_self_connections"] = self.allow_self_connections
+        return parameters
+
     @overrides(AbstractConnector.get_delay_maximum)
     def get_delay_maximum(self, synapse_info: SynapseInformation) -> float:
         return self._get_delay_maximum(
@@ -152,10 +158,6 @@ def allow_self_connections(self) -> bool:
         """
         return self.__allow_self_connections
 
-    @allow_self_connections.setter
-    def allow_self_connections(self, new_value: bool) -> None:
-        self.__allow_self_connections = new_value
-
     @property
     @overrides(AbstractGenerateConnectorOnMachine.gen_connector_id)
     def gen_connector_id(self) -> int:

spynnaker/pyNN/models/neural_projections/connectors/array_connector.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 from __future__ import annotations
-from typing import Sequence, Optional, TYPE_CHECKING
+from typing import Any, Dict, Optional, Sequence, TYPE_CHECKING
 
 import numpy
 from numpy import uint8
@@ -76,6 +76,12 @@ def __init__(self, array: NDArray[uint8], safe: bool = True,
         self.__n_total_connections = n_total_connections
         self.__array_dims = dims
 
+    @overrides(AbstractConnector.get_parameters)
+    def get_parameters(self) -> Dict[str, Any]:
+        parameters = self._get_parameters()
+        parameters["array"] = self.__array
+        return parameters
+
     @overrides(AbstractConnector.get_delay_maximum)
     def get_delay_maximum(self, synapse_info: SynapseInformation) -> float:
         return self._get_delay_maximum(

spynnaker/pyNN/models/neural_projections/connectors/convolution_connector.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 from collections.abc import (Iterable, Sequence)
 from typing import (
-    List, Optional, Sequence as TSequence, Tuple, Union,
+    Any, Dict, List, Optional, Sequence as TSequence, Tuple, Union,
     cast, overload, TYPE_CHECKING)
 
 import numpy
@@ -169,10 +169,34 @@ def __init__(self, kernel_weights: _Weights,
             self.__pool_stride = self.__pool_shape
         if self.__pool_shape is not None:
             self.__kernel_weights /= numpy.prod(self.__pool_shape)
-
         self.__positive_receptor_type = positive_receptor_type
         self.__negative_receptor_type = negative_receptor_type
 
+    @overrides(AbstractConnector.get_parameters)
+    def get_parameters(self) -> Dict[str, Any]:
+        parameters = self._get_parameters()
+        if self.__pool_shape is None:
+            parameters["kernel_weights"] = self.__kernel_weights
+        else:
+            parameters["kernel_weights"] = (
+                self.__kernel_weights * numpy.prod(self.__pool_shape))
+        # Now included in weights
+        parameters["kernel_shape"] = None
+        parameters["strides"] = tuple(self.__strides)
+        parameters["padding"] = tuple(self.__padding_shape)
+        if self.__pool_shape is None:
+            parameters["pool_shape"] = None
+        else:
+            parameters["pool_shape"] = tuple(self.__pool_shape)
+        if self.__pool_stride is None:
+            parameters["pool_stride"] = None
+        else:
+            parameters["pool_stride"] = tuple(self.__pool_stride)
+        parameters["positive_receptor_type"] = self.__positive_receptor_type
+        parameters["negative_receptor_type"] = self.__negative_receptor_type
+        parameters["filter_edges"] = self.__filter_edges
+        return parameters
+
     @property
     def positive_receptor_type(self) -> str:
         """

spynnaker/pyNN/models/neural_projections/connectors/csa_connector.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from __future__ import annotations
-from typing import List, Optional, Tuple, TYPE_CHECKING, Sequence
+from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING, Sequence
 
 import numpy
 from numpy.typing import NDArray
@@ -81,6 +81,12 @@ def __init__(self, cset: CSet, safe: bool = True, callback: None = None,
         self.__full_connection_set: Optional[List[CSet]] = None
         self.__full_cset: Optional[List[CSet]] = None
 
+    @overrides(AbstractConnector.get_parameters)
+    def get_parameters(self) -> Dict[str, Any]:
+        parameters = self._get_parameters()
+        parameters["cset"] = self.__cset
+        return parameters
+
     @overrides(AbstractConnector.get_delay_maximum)
     def get_delay_maximum(self, synapse_info: SynapseInformation) -> float:
         n_conns_max = synapse_info.n_pre_neurons * synapse_info.n_post_neurons