Merge pull request #1575 from SpiNNakerManchester/numpy_cap

fixes as dtype param can not be integer or floating

Author: Christian-B

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

@@ -165,8 +165,9 @@ def __init__(self, kernel_weights: _Weights,
         self.__padding_shape = self.__decode_padding(padding)
         self.__filter_edges = filter_edges
 
+        self.__strides: NDArray[integer]
         if strides is None:
-            self.__strides = numpy.array((1, 1), dtype=integer)
+            self.__strides = numpy.array((1, 1), dtype=numpy.uint32)
         else:
             self.__strides = self.__to_2d_shape(strides, "strides")
         self.__pool_shape = self.__to_2d_shape(pool_shape, "pool_shape")
@@ -261,20 +262,20 @@ def __to_2d_shape(shape: _Shape, param_name: str) -> Optional[
         if shape is None:
             return None
         if numpy.isscalar(shape):
-            return numpy.array([shape, shape], dtype=integer)
+            return numpy.array([shape, shape], dtype=uint32)
         assert isinstance(shape, tuple)
         if len(shape) == 1:
-            return numpy.array([shape[0], 1], dtype=integer)
+            return numpy.array([shape[0], 1], dtype=uint32)
         elif len(shape) == 2:
-            return numpy.array(shape, dtype=integer)
+            return numpy.array(shape, dtype=uint32)
         raise SynapticConfigurationException(
             f"{param_name} must be an int or a tuple(int, int)")
 
     def __decode_padding(self, padding: _Padding) -> NDArray[integer]:
         if isinstance(padding, (int, Iterable)):
             return self.__to_2d_shape(padding, "padding")
         elif padding is None or padding is False:
-            return numpy.zeros(2, dtype=integer)
+            return numpy.zeros(2, dtype=uint32)
         elif padding:
             return self.__kernel_weights.shape // 2
         else:

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

@@ -133,7 +133,7 @@ def __build_post_neurons(
             self, synapse_info: SynapseInformation) -> List[NDArray[integer]]:
         rng = self.__rng or NumpyRNG()
         post_neurons: List[NDArray[integer]] = \
-            [numpy.empty([0], dtype=integer)] * synapse_info.n_pre_neurons
+            [numpy.empty([0], dtype=uint32)] * synapse_info.n_pre_neurons
         # Loop over all the pre neurons
         for m in range(synapse_info.n_pre_neurons):
             if post_neurons[m] is None:
@@ -226,9 +226,9 @@ def _n_post_neurons_in_slice(
         # this post-vertex slice
         this_post_neuron_array = post_neurons[n]
 
-        return numpy.count_nonzero(numpy.logical_and(
+        return int(numpy.count_nonzero(numpy.logical_and(
             post_vertex_slice.lo_atom <= this_post_neuron_array,
-            this_post_neuron_array <= post_vertex_slice.hi_atom))
+            this_post_neuron_array <= post_vertex_slice.hi_atom)))
 
     @overrides(AbstractConnector.get_n_connections_from_pre_vertex_maximum)
     def get_n_connections_from_pre_vertex_maximum(

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

@@ -133,8 +133,8 @@ def get_delay_minimum(self, synapse_info: SynapseInformation) -> float:
     def __build_pre_neurons(self, synapse_info: SynapseInformation) -> List[
             NDArray[integer]]:
         rng = self.__rng or NumpyRNG()
-        pre_neurons = [
-            numpy.zeros([0], dtype=integer)] * synapse_info.n_post_neurons
+        pre_neurons: List[NDArray[integer]] = [
+            numpy.zeros([0], dtype=uint32)] * synapse_info.n_post_neurons
         # Loop over all the post neurons
         for m in range(synapse_info.n_post_neurons):
             # If the pre and post populations are the same

spynnaker/pyNN/utilities/neo_buffer_database.py

@@ -24,7 +24,7 @@
     TYPE_CHECKING, Union)
 
 import numpy
-from numpy import floating, integer, uint8, uint32
+from numpy import float64, floating, integer, uint8, uint32
 from numpy.typing import NDArray
 import quantities
 import neo  # type: ignore[import]
@@ -892,7 +892,7 @@ def __get_matrix_data(
                 pop_neurons.extend(neurons)
             else:
                 indexes.append(index)
-                neurons = numpy.array([index], dtype=integer)
+                neurons = numpy.array([index], dtype=uint32)
             times, data = self.__get_matrix_data_by_region(
                 region_id, neurons, data_type)
             if signal_array is None or pop_times is None:
@@ -904,7 +904,7 @@ def __get_matrix_data(
             else:
                 raise NotImplementedError("times differ")
         if signal_array is None:
-            signal_array = numpy.zeros((0,), dtype=floating)
+            signal_array = numpy.zeros((0,), dtype=float64)
 
         if len(indexes) > 0:
             assert (len(pop_neurons) == 0)
@@ -993,7 +993,7 @@ def __get_rewires(self, rec_id: int,
                 rewire_preids, rewire_times, sampling_interval_ms)
 
             if len(rewire_values) == 0:
-                return numpy.zeros((0, 4), dtype=integer)
+                return numpy.zeros((0, 4), dtype=uint32)
 
         result = numpy.column_stack(
             (rewire_times, rewire_preids, rewire_postids, rewire_values))

spynnaker/pyNN/utilities/struct.py

@@ -16,7 +16,7 @@
 from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple, Union
 
 import numpy
-from numpy import uint8, uint32, integer
+from numpy import integer, uint8, uint32
 from numpy.typing import NDArray
 from pyNN.random import RandomDistribution
 from typing_extensions import TypeAlias
@@ -371,7 +371,7 @@ def read_data(
         :type array_size: int or None
         """
         n_items = 1
-        ids = numpy.zeros([0], dtype=integer)
+        ids: NDArray[integer] = numpy.zeros([0], dtype=uint32)
         if vertex_slice is None:
             if self.__repeat_type != StructRepeat.GLOBAL:
                 raise ValueError(

spynnaker/pyNN/utilities/utility_calls.py

@@ -25,7 +25,7 @@
 import neo
 from neo.io.baseio import BaseIO  # type: ignore[import]
 import numpy
-from numpy import uint32, floating
+from numpy import uint32, float64, floating
 from numpy.typing import NDArray
 from pyNN.random import AbstractRNG, RandomDistribution
 from scipy.stats import binom
@@ -104,12 +104,12 @@ def convert_param_to_numpy(
         # that it is an array
         param_value = param.next(n=no_atoms)
         if hasattr(param_value, '__iter__'):
-            return numpy.array(param_value, dtype=floating)
-        return numpy.array([param_value], dtype=floating)
+            return numpy.array(param_value, dtype=float64)
+        return numpy.array([param_value], dtype=float64)
 
     # Deal with a single value by exploding to multiple values
     if not hasattr(param, '__iter__'):
-        return numpy.array([param] * no_atoms, dtype=floating)
+        return numpy.array([param] * no_atoms, dtype=float64)
 
     # Deal with multiple values, but not the correct number of them
     if len(cast(Sized, param)) != no_atoms:
@@ -118,7 +118,7 @@ def convert_param_to_numpy(
             " the vertex")
 
     # Deal with the correct number of multiple values
-    return numpy.array(param, dtype=floating)
+    return numpy.array(param, dtype=float64)
 
 
 def convert_to(value: float, data_type: DataType) -> uint32: