sinabs 3.0.3.dev1__tar.gz → 3.0.4.dev1__tar.gz

{sinabs-3.0.3.dev1 → sinabs-3.0.4.dev1}/ChangeLog

@@ -1,6 +1,11 @@
 CHANGES
 =======
 
+v3.0.3
+
+* Add function in utils to help identify issues with memory constraints when mapping a network on Speck.
+(https://sinabs.readthedocs.io/v3.0.3/api/utils.html#sinabs.utils.validate_memory_mapping_speck)
+
 v3.0.2
 ------
 

{sinabs-3.0.3.dev1 → sinabs-3.0.4.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sinabs
-Version: 3.0.3.dev1
+Version: 3.0.4.dev1
 Summary: SynSense Spiking Neural Network simulator for deep neural networks (DNNs).
 Home-page: UNKNOWN
 Author: SynSense (formerly AiCTX)

{sinabs-3.0.3.dev1 → sinabs-3.0.4.dev1}/docs/api/utils.rst

@@ -9,3 +9,4 @@ utils
 .. autofunction:: sinabs.utils.get_network_activations
 .. autofunction:: sinabs.utils.normalize_weights
 .. autofunction:: sinabs.utils.set_batch_size
+.. autofunction:: sinabs.utils.validate_memory_mapping_speck

{sinabs-3.0.3.dev1 → sinabs-3.0.4.dev1}/docs/speck/overview.md

@@ -151,6 +151,9 @@ The actual Neuron memory entries is then:
 
 Where 128Ki neuron exceeds any available neuron memory contrains among 9 layers, thus this layer **CANNOT** be deployed on the chip
 
+If neuron and kernel memories exceeds the hardware resources, when trying to map the layer a "No valid mapping" error will be thrown.
+When working with Speck and Conv2D layers, we offer a tool to help you to validate if the layer can be mapped: `utils.validate_memory_mapping_speck()`.
+
 #### Leak operation
 
 Each layer includes a leak generation block, which will update all the configured neuron states with provided leak values with a clock reference signal. Checkout the [tutorial](notebooks/leak_neuron) on how to use leak feature.

{sinabs-3.0.3.dev1 → sinabs-3.0.4.dev1}/sinabs/__init__.py

@@ -2,9 +2,15 @@ from pbr.version import VersionInfo
 
 __version__ = VersionInfo("sinabs").release_string()
 
-from . import conversion, utils
+from . import conversion, utils, validate_memory_speck
 from .from_torch import from_model
 from .network import Network
 from .nir import from_nir, to_nir
 from .synopcounter import SNNAnalyzer, SynOpCounter
-from .utils import reset_states, set_batch_size, zero_grad
+from .utils import (
+    reset_states,
+    set_batch_size,
+    zero_grad,
+    validate_memory_mapping_speck,
+)
+from .validate_memory_speck import ValidateMapping

{sinabs-3.0.3.dev1 → sinabs-3.0.4.dev1}/sinabs/backend/dynapcnn/dynapcnn_network.py

@@ -361,8 +361,8 @@ class DynapcnnNetwork(nn.Module):
         try:
             _, is_compatible = self._make_config(device=device_type)
         except ValueError as e:
-            # Catch "No valid mapping found" error
-            if e.args[0] == ("No valid mapping found"):
+            # Catch "No valid mapping found" error, it is the first sentence in the string
+            if e.args[0].find("No valid mapping found.") == 0:
                 return False
             else:
                 raise e

{sinabs-3.0.3.dev1 → sinabs-3.0.4.dev1}/sinabs/backend/dynapcnn/mapping.py

@@ -188,5 +188,8 @@ def recover_mapping(graph, layer_mapping) -> List[Tuple[int, int]]:
             if edge.flow == 1:
                 mapping.append((i, edge.t - len(layer_mapping) - 1))
     if len(mapping) != len(layer_mapping):
-        raise ValueError("No valid mapping found")
+        raise ValueError(
+            "No valid mapping found. "
+            "For Speck family you can use `utils.validate_memory_mapping_speck()` to get more information."
+        )
     return mapping

{sinabs-3.0.3.dev1 → sinabs-3.0.4.dev1}/sinabs/utils.py

@@ -1,10 +1,11 @@
-from typing import List
+from typing import List, Tuple
 
 import numpy as np
 import torch
 import torch.nn as nn
 
 import sinabs
+from .validate_memory_speck import ValidateMapping
 
 
 def reset_states(model: nn.Module) -> None:
@@ -179,3 +180,62 @@ def set_batch_size(model: nn.Module, batch_size: int):
         if isinstance(mod, sinabs.layers.SqueezeMixin):
             mod.batch_size = batch_size
             # reset_states(mod)
+
+
+def validate_memory_mapping_speck(
+    input_feature_size: int,
+    output_feature_size: int,
+    kernel_size: Tuple[int, int],
+    stride: Tuple[int, int],
+    padding: Tuple[int, int],
+    input_dimension: Tuple[int, int] = [64, 64],
+    conv_2d: bool = True,
+):
+    """Helper function to verify if it is possible to map a specific layer on to speck.
+        This function validates kernel and neuron memories. It doesnt check for all the network layers together.
+        It considers the mapping of a Conv2D layer only.
+
+    Args:
+        input_feature_size (int): number of input channels
+        output_feature_size (int): number of output channels
+        kernel_size (Tuple[int, int]): 2D kernel size
+        stride (Tuple[int, int]): 2D stride size
+        padding (Tuple[int, int]): 2D padding size
+        input_dimension (Tuple[int, int]): 2D input dimension size. Defaults to [64,64]
+        conv_2d (bool): if it is mapping a Conv2D layers. Defaults to True. It won't validate other types of network.
+
+    Return:
+        msg (string): Message indicating layer can be mapped with total size of kernel and neuron memories.
+
+    Raises:
+        Exception: if neuron or kernel memories are higher than available on chip.
+    """
+
+    if not conv_2d:
+        raise ValueError("This function only validates Conv2D layers.")
+
+    validate = ValidateMapping(
+        input_feature_size,
+        output_feature_size,
+        kernel_size,
+        stride,
+        padding,
+        [input_dimension[0], input_dimension[1]],
+        conv_2d,
+    )
+    (
+        kernel,
+        neuron,
+        kernel_error_msg,
+        neuron_error_msg,
+    ) = validate.calculate_total_memory()
+
+    if kernel_error_msg != "" or neuron_error_msg != "":
+        raise Exception(kernel_error_msg + neuron_error_msg)
+    else:
+        msg = (
+            "Layer can be mapped successfully. "
+            f"Kernel memory is {kernel:g}Ki and neuron memory is {neuron:g}Ki."
+        )
+
+    return msg

sinabs-3.0.4.dev1/sinabs/validate_memory_speck.py

@@ -0,0 +1,144 @@
+from typing import Tuple
+from matplotlib import pyplot as plt
+from matplotlib import colors
+
+import numpy as np
+
+
+class ValidateMapping:
+    def __init__(
+        self,
+        input_feature_size: int,
+        output_feature_size: int,
+        kernel_size: Tuple[int, int],
+        stride: Tuple[int, int],
+        padding: Tuple[int, int],
+        input_dimension: Tuple[int, int] = [64, 64],
+        conv_2d: bool = True,
+    ):
+        self.input_feature_size = input_feature_size
+        self.output_feature_size = output_feature_size
+
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.padding = padding
+        self.input_dimension = input_dimension
+
+        # - If not Conv2D layer, assuming it is AvgPool2D layer
+        if not conv_2d:
+            if (
+                kernel_size[0] != kernel_size[1]
+                or kernel_size[0] == 3
+                or kernel_size[0] > 4
+            ):
+                raise Exception(
+                    "Kernel size is limited to 1x1, 2x2 or 4x4 for AvgPool2D layer."
+                )
+
+        if (
+            len(kernel_size) > 2
+            or len(stride) > 2
+            or len(padding) > 2
+            or len(input_dimension) > 2
+        ):
+            raise Exception(
+                "We expect input dimension kernel, stride and padding to be 2D elements, i.e.,"
+                "to have only two positions: x and y."
+            )
+
+        if kernel_size[0] > 16 or kernel_size[1] > 16:
+            raise Exception("Kernel size is limited to, at most, 16x16.")
+
+        if output_feature_size > 1024:
+            raise Exception("Output feature size is limited to, at most, 1024.")
+
+        if not self.check_stride():
+            raise Warning("Kernel stride can be 1, 2, 4 or 8 and, at most, 8x8.")
+
+    def calculate_total_memory(self):
+        kernel_memory = self.calculate_kernel_memory()
+        neuron_memory = self.calculate_neuron_memory()
+
+        kernel_error_msg = self.verify_combined_memories(
+            "kernel", kernel_memory, "neuron", neuron_memory
+        )
+        neuron_error_msg = self.verify_combined_memories(
+            "neuron", neuron_memory, "kernel", kernel_memory
+        )
+
+        print(kernel_error_msg)
+        print(neuron_error_msg)
+        return (
+            kernel_memory / 1024,
+            neuron_memory / 1024,
+            kernel_error_msg,
+            neuron_error_msg,
+        )
+
+    def calculate_kernel_memory(self):
+        return self.input_feature_size * pow(
+            2,
+            np.ceil(np.log2(self.kernel_size[0] * self.kernel_size[1]))
+            + np.ceil(np.log2(self.output_feature_size)),
+        )
+
+    def calculate_neuron_memory(self):
+        fx = (
+            (self.input_dimension[0] - self.kernel_size[0] + 2 * self.padding[0])
+            / self.stride[0]
+        ) + 1
+        fy = (
+            (self.input_dimension[1] - self.kernel_size[1] + 2 * self.padding[1])
+            / self.stride[1]
+        ) + 1
+        return self.output_feature_size * pow(
+            2, (np.ceil(np.log2(fx)) + np.ceil(np.log2(fy)))
+        )
+
+    def check_stride(self):
+        for i in range(len(self.stride)):
+            if (
+                self.stride[i] == 1
+                or self.stride[i] == 2
+                or self.stride[i] == 4
+                or self.stride[i] == 8
+            ):
+                return True
+        return False
+
+    def verify_combined_memories(
+        self, base_name: str, base_memory: int, compared_name: str, compared_memory: int
+    ):
+        # core ids --------- kernel memory -------- neuron memory
+        # [0, 1, 2] ------------- 16Ki ----------------- 64Ki
+        # [3, 4] ---------------- 32Ki ----------------- 32Ki
+        # [5, 6] ---------------- 64Ki ----------------- 16Ki
+        # [7, 8] ---------------- 16Ki ----------------- 16Ki
+
+        base_memory = base_memory / 1024
+        compared_memory = compared_memory / 1024
+
+        error_msg = ""
+        if base_memory > 64:
+            error_msg = (
+                f"{base_name.capitalize()} memory is {base_memory:g}Ki and can not be mapped on chip. "
+                f"{base_name.capitalize()} memory on chip needs to be at most 64Ki."
+            )
+
+        if base_memory > 16 and base_memory <= 32:
+            if compared_memory > 32:
+                error_msg = (
+                    "There is no core on chip to fit neuron and kernel memories. "
+                    f"When {base_name} memory is higher than 16Ki, {compared_name} memory needs to be at most 32Ki. "
+                    f"{base_name.capitalize()} is {base_memory:g}Ki and {compared_name} is {compared_memory:g}Ki."
+                )
+
+        if base_memory > 32:
+            if compared_memory > 16:
+                error_msg = (
+                    "There is no core on chip to fit neuron and kernel memories. "
+                    f"When {base_name} memory is higher than 32Ki, {compared_name} memory needs to be at most 16Ki. "
+                    f"{base_name.capitalize()} is {base_memory:g}Ki and {compared_name} is {compared_memory:g}Ki."
+                )
+
+        return error_msg

{sinabs-3.0.3.dev1 → sinabs-3.0.4.dev1}/sinabs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sinabs
-Version: 3.0.3.dev1
+Version: 3.0.4.dev1
 Summary: SynSense Spiking Neural Network simulator for deep neural networks (DNNs).
 Home-page: UNKNOWN
 Author: SynSense (formerly AiCTX)

{sinabs-3.0.3.dev1 → sinabs-3.0.4.dev1}/sinabs.egg-info/SOURCES.txt

@@ -164,6 +164,7 @@ sinabs/network.py
 sinabs/nir.py
 sinabs/synopcounter.py
 sinabs/utils.py
+sinabs/validate_memory_speck.py
 sinabs.egg-info/PKG-INFO
 sinabs.egg-info/SOURCES.txt
 sinabs.egg-info/dependency_links.txt

sinabs-3.0.4.dev1/sinabs.egg-info/pbr.json

@@ -0,0 +1 @@
+{"git_version": "5f6dcf9", "is_release": false}

{sinabs-3.0.3.dev1 → sinabs-3.0.4.dev1}/tests/test_dynapcnn/test_large_net.py

@@ -85,7 +85,6 @@ dynapcnn_out = dynapcnn_net(input_data)
 
 
 def test_same_result():
-    # print(dynapcnn_out)
     assert torch.equal(dynapcnn_out.squeeze(), snn_out.squeeze())
 
 
@@ -137,8 +136,6 @@ def test_to_device():
             device=device_name, chip_layers_ordering=[0, 1, 2, 7, 4, 5, 6, 3, 8]
         )
 
-        # TODO: this test fails when using speck2e but not speck 2f.
-        # This has been reported in Samna: https://www.wrike.com/workspace.htm?acc=6529583#/inbox/work_item/1674059530
         # Close device for safe exit
         from sinabs.backend.dynapcnn import io
 

{sinabs-3.0.3.dev1 → sinabs-3.0.4.dev1}/tests/test_utils.py

@@ -3,6 +3,7 @@ import torch.nn as nn
 
 import sinabs
 import sinabs.layers as sl
+import sinabs.utils as utils
 
 
 class SNN(nn.Module):
@@ -50,3 +51,51 @@ def test_zero_grad():
     sinabs.zero_grad(model)
     assert model.net[1].v_mem.grad_fn is None
     assert model.net[1].v_mem.sum() != 0
+
+
+def test_validate_memory_speck_raise_exception():
+    import pytest
+
+    kernel_size = [3, 3]
+    stride = [1, 1]
+    padding = [1, 1]
+    input_feature_size = 64
+    output_feature_size = 65
+    input_dimension = [8, 8]
+
+    with pytest.raises(Exception) as info:
+        utils.validate_memory_mapping_speck(
+            input_feature_size,
+            output_feature_size,
+            kernel_size,
+            stride,
+            padding,
+            input_dimension,
+        )
+    assert (
+        str(info.value)
+        == "Kernel memory is 128Ki and can not be mapped on chip. Kernel memory on chip needs to be at most 64Ki."
+    )
+
+
+def test_validate_memory_speck_no_exception():
+    kernel_size = [3, 3]
+    stride = [1, 1]
+    padding = [1, 1]
+    input_feature_size = 2
+    output_feature_size = 64
+    input_dimension = [8, 8]
+
+    msg = utils.validate_memory_mapping_speck(
+        input_feature_size,
+        output_feature_size,
+        kernel_size,
+        stride,
+        padding,
+        input_dimension,
+    )
+
+    assert (
+        msg
+        == "Layer can be mapped successfully. Kernel memory is 2Ki and neuron memory is 4Ki."
+    )

sinabs-3.0.3.dev1/sinabs.egg-info/pbr.json

@@ -1 +0,0 @@
-{"git_version": "b584589", "is_release": false}