sinabs 2.0.3.dev11__tar.gz → 2.0.4.dev32__tar.gz

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/.github/workflows/ci-pipeline.yml

@@ -16,7 +16,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest]
-        python-version: ["3.8",]
+        python-version: ["3.8","3.10"]
         torch-version: ["2.0.0",]
     steps:
       - uses: actions/checkout@v4
@@ -27,9 +27,9 @@ jobs:
       - name: Install requirements
         run: |
           sudo apt-get update && sudo apt-get -y install libglu1-mesa
-          pip install torch~=${{ matrix.torch-version }} torchvision --index-url https://download.pytorch.org/whl/cpu
           pip install .
           pip install -r tests/requirements.txt
+          pip install torch~=${{ matrix.torch-version }} torchvision --index-url https://download.pytorch.org/whl/cpu
       - name: Test with pytest
         run: |
           pytest tests
@@ -63,10 +63,10 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - name: Setup Python 3.8
+      - name: Setup Python 3.10
         uses: actions/setup-python@v5
         with:
-          python-version: 3.8
+          python-version: "3.10.18"
       - name: Install dependencies
         run: |
           sudo apt-get update && sudo apt-get -y install libglu1-mesa

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/ChangeLog

@@ -1,7 +1,19 @@
 CHANGES
 =======
 
+v2.0.4
+------
+
+* Remove support for older boards following update on Samna 0.46.0
+
+v2.0.3
+------
+
 * Update Sinabs license to Apache 2.0
+
+v2.0.2
+------
+
 * Spike count plot in 'DynapcnnVisualizer' is optional 
 * `DynapcnnVisualizer` allows custom JIT filters to make readout predictions
 

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/PKG-INFO

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

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/docs/speck/faqs/available_network_arch.md

@@ -8,18 +8,18 @@ Each core also have the following features:
 1. Each core has an unique index number, the first core's index starts from 0. So the index is in range [0, 8).
 
 2. Each core can **only** define **2 destination cores** as its output destination core(layer).
- See [detail.](https://synsense-sys-int.gitlab.io/samna/reference/dynapcnn/configuration/index.html#samna.dynapcnn.configuration.CNNLayerDestination)
+ See [detail.](https://synsense-sys-int.gitlab.io/samna/0.46.1/reference/speck2f/configuration/index.html#samna.speck2f.configuration.CnnLayerDestination)
 
 3. You can define multiple cores to have one **same destination core**.
 Technically,you can use this feature to achieve a `short-cut`(residual connection) like ResNet does.
-See [detail.](https://synsense-sys-int.gitlab.io/samna/reference/dynapcnn/configuration/index.html#samna.dynapcnn.configuration.CNNLayerDestination.layer)
+See [detail.](https://synsense-sys-int.gitlab.io/samna/0.46.1/reference/speck2f/configuration/index.html#samna.speck2f.configuration.CnnLayerDestination.layer)
 
 4. Each core can optionally apply a `sum-pooling` operation before feeding the output events into the destination core.
-See [detail.](https://synsense-sys-int.gitlab.io/samna/reference/dynapcnn/configuration/index.html#samna.dynapcnn.configuration.CNNLayerDestination.pooling)
+See [detail.](https://synsense-sys-int.gitlab.io/samna/0.46.1/reference/speck2f/configuration/index.html#samna.speck2f.configuration.CnnLayerDestination.pooling)
 
 5. Each core can optionally apply a `channel-shift` operation before feeding the output events into the destination core.
 Technically, you can use this feature to `concatenate` two cores' output events among the channel axis.
-See [detail.](https://synsense-sys-int.gitlab.io/samna/reference/dynapcnn/configuration/index.html#samna.dynapcnn.configuration.CNNLayerDestination.feature_shift)
+See [detail.](https://synsense-sys-int.gitlab.io/samna/0.46.1/reference/speck2f/configuration/index.html#samna.speck2f.configuration.CnnLayerDestination.feature_shift)
 
 6. You can define the order of cores/layers by defining the `destination` index of each core, i.e. the order of the 9 layers on the chip can be customized by yourself.
 We already have this feature in sinabs-dynapcnn. When you deploy an SNN to the devkit, you can do:
@@ -47,7 +47,7 @@ help the user to deploy their networks with more complex architecture to the dev
 ## Can I achieve a "Residual Connection" like ResNet does?
 
 Like mentioned above, "Yes, we can define a residual short-cut on the devkit". However, currently you can only manually
-change the `samna.dynapcnn.configuration.CNNLayerDestination.layer` to achieve this, you can do this if you are very
+change the `samna.speck2f.configuration.CNNLayerDestination.layer` to achieve this, you can do this if you are very
 familiar with the `samna-configuration`. Otherwise,let's wait for a while after the  "network graph extraction feature" is
 completed.
 
@@ -179,7 +179,7 @@ class Network:
 ```
 network = nn.sequential([
                         nn.conv2d(),
-                        nn.BatchNorm2d(), # unspport in speck/dynapcnn
+                        nn.BatchNorm2d(), # unsupport in speck
                         IAFsqueeze(),
                         ])
 ```

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/docs/speck/faqs/save_hardware_config_as_binary.md

@@ -25,5 +25,5 @@ with open("./my_config.bin", "wb") as f:
         f.write((e).to_bytes(1, byteorder='little'))
 ```
 
-More details can be found in [samna documetation.](https://synsense-sys-int.gitlab.io/samna/search.html?q=configuration_to_flash_binary)
+More details can be found in [samna documetation.](https://synsense-sys-int.gitlab.io/samna/0.46.1/reference/speck2f/index.html#samna.speck2f.configuration_to_flash_binary)
 

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/docs/speck/faqs/tips_for_training.md

@@ -26,7 +26,7 @@ consist of:
  "Logic" −> "Kernel Memory Read" −> "Logic" −> "Neuron Read" −> "Neuron Write" −> "Logic" 
 `
 
-Each core/layer on the DynapCNN/Speck has an upper limit on the number of synaptic-operations it can execute per second.
+Each core/layer on the Speck processor has an upper limit on the number of synaptic-operations it can execute per second.
 This upper limit is the "bandwidth of SynOps/s". 
 
 If the number of SynOps/s for a single core exceeds the limit, the entire chip stalls, and the

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/docs/speck/index.rst

@@ -1,4 +1,4 @@
-**Speck/DynapCNN**
+**Speck**
 ==================
 
 .. toctree::

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/docs/speck/notebooks/nmnist_quick_start.ipynb

@@ -790,12 +790,12 @@
     "\n",
     "To deploy the SNN to the devkit, we use an auxiliary class `DynapcnnNetwork` to convert the pretrained SNN to a configuration object of the devkit.\n",
     "\n",
-    "In the example beblow, we use the \"Speck2fModuleDevKit\" as the inference device. More devkit names can be found [here.](https://gitlab.com/synsense/sinabs-dynapcnn/-/blob/master/sinabs/backend/dynapcnn/chip_factory.py)"
+    "In the example beblow, we use the \"Speck2fDevKit\" as the inference device. More devkit names can be found [here.](https://gitlab.com/synsense/sinabs-dynapcnn/-/blob/master/sinabs/backend/dynapcnn/chip_factory.py)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -813,7 +813,7 @@
     "# cpu_snn = snn_convert.to(device=\"cpu\")\n",
     "cpu_snn = snn_bptt.to(device=\"cpu\")\n",
     "dynapcnn = DynapcnnNetwork(snn=cpu_snn, input_shape=(2, 34, 34), discretize=True, dvs_input=False)\n",
-    "devkit_name = \"speck2fmodule\"\n",
+    "devkit_name = \"speck2fdevkit\"\n",
     "\n",
     "# use the `to` method of DynapcnnNetwork to deploy the SNN to the devkit\n",
     "dynapcnn.to(device=devkit_name, chip_layers_ordering=\"auto\")\n",
@@ -833,9 +833,9 @@
    "source": [
     "### Inference On The Devkit\n",
     "\n",
-    "Our devkits takes [`samna events`](https://synsense-sys-int.gitlab.io/samna/reference/speck2f/event/index.html) stream as the input. So before sending the raw N-MNIST events into devkit, we need first convert the data to samna's [`samna.speck2f.event.Spike`](https://synsense-sys-int.gitlab.io/samna/reference/speck2f/event/index.html#samna.speck2f.event.Spike) events stream.\n",
+    "Our devkits takes [`samna events`](https://synsense-sys-int.gitlab.io/samna/0.46.1/reference/speck2f/event/index.html#samna.speck2f.event.Spike) stream as the input. So before sending the raw N-MNIST events into devkit, we need first convert the data to samna's [`samna.speck2f.event.Spike`](https://synsense-sys-int.gitlab.io/samna/reference/speck2f/event/index.html#samna.speck2f.event.Spike) events stream.\n",
     "\n",
-    "**Notice**: Different types of devkit need different types of event as its input. For example, if you're using a `DynapcnnDevKit`, you need to use the [`samna.dynapcnn.event.Spike`](https://synsense-sys-int.gitlab.io/samna/reference/dynapcnn/event/index.html#samna.dynapcnn.event.Spike) as input."
+    "**Notice**: Different types of devkit need different types of event as its input. For example, if you're using a `Speck2eDevKit`, you need to use the [`samna.speck2e.event.Spike`](https://synsense-sys-int.gitlab.io/samna/0.46.1/reference/speck2f/event/index.html#samna.speck2f.event.Spike) as input."
    ]
   },
   {
@@ -974,7 +974,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1027,7 +1027,7 @@
     "# init DynapcnnNetwork instance\n",
     "dynapcnn = DynapcnnNetwork(snn=cpu_snn, input_shape=(2, 34, 34), discretize=True, dvs_input=True)\n",
     "\n",
-    "devkit_name = \"speck2fmodule\"\n",
+    "devkit_name = \"speck2fdevkit\"\n",
     "# define which layers output you want to monitor\n",
     "layers_to_monitor = [0, 1, 2, 3]\n",
     "# pass the callback function into the `.to` method\n",
@@ -1109,7 +1109,7 @@
     "\n",
     "By running the code block below, the input events will be displayed on the GUI window.\n",
     "\n",
-    "We now start to write inputs to the devkit.In the example above, we use the `samna.speck2f.event.Spike` as the input event type. Since now we need to visualize the input events which we write into the devkit, we need to use the `samna.speck2f.event.DvsEvent`. It is because only by this the input events can be captured by the visualizer. More details about the \"DvsEvent\" can be found [here.](https://synsense-sys-int.gitlab.io/samna/reference/speck2f/event/index.html#samna.speck2f.event.DvsEvent) \n",
+    "We now start to write inputs to the devkit.In the example above, we use the `samna.speck2f.event.Spike` as the input event type. Since now we need to visualize the input events which we write into the devkit, we need to use the `samna.speck2f.event.DvsEvent`. It is because only by this the input events can be captured by the visualizer. More details about the \"DvsEvent\" can be found [here.](https://synsense-sys-int.gitlab.io/samna/0.46.1/reference/speck2f/event/index.html#samna.speck2f.event.DvsEvent) \n",
     "\n",
     "![dvs_event_input_flow](/_static/nmnist_quick_start/dvs_input_flow.png)"
    ]

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/docs/speck/overview.md

@@ -1,48 +1,51 @@
 # Overview
 
-## DYNAP-CNN and SPECK
+SPECK™ are a family of spiking neural network ASICs, which is designed to focusing on convolution spiking neural network (CSNN) based vision processing tasks.
+Speck™ is the world first neuromorphic device which integrates the DYNAP-CNN neuromorphic processor and a dynamic vision sensor (DVS) into a single SoC.
+Speck™ processor, DYNAP-CNN, is a fully scalable, event-driven neuromorphic processor with up to 0.32M configurable spiking neurons and direct interface with external DVS.
 
-DYNAP-CNN/SPECK are a family of spiking neural network ASICs family, which is designed to focusing on convolution spiking neural network(SCNN) based vision processing tasks. DYNAP-CNN is a fully scalable, event-driven neuromorphic processor with up to 0.32M configurable spiking neurons and direct interface with external DVS. Speck™ is the world first neuromorphic device which integrates the DYNAP-CNN neuromorphic processor and a dynamic vision sensor(DVS) into a single SoC.
+DYNAP-CNN processor can be used directly bypassing the DVS camera integrated on Speck.
 
 ![image.png](/_static/Overview/speck_dynapcnn.png)
 
-
-Currently, __sinabs-dynapcnn__ library provides the interface to serveral available versions of hardwares for DYNAPCNN/SPECK family:
+Currently, __sinabs-dynapcnn__ library provides the interface to serveral available versions of hardwares for SPECK™ family:
 
 | Device Name |Identifier |
 | :----| :----: | 
-| DYNAP-CNN Development Kit |*dynapcnndevkit | 
-| Speck Tiny Development Kit|*speck2btiny|
-| Speck Development Kit |*speck2edevkit|
+| Speck 2E Test Board |*Speck2eTestBoard|
+| Speck 2E Development Kit |*speck2edevkit|
+| Speck 2F Module |*speck2fmodule|
+| Speck 2F Development Kit |*speck2fdevkit|
+| DYNAP-SE2 DevBoard |*dynapse2|
+| DYNAP-SE2 Stack |*dynapse2_stack|
 
 __note__: * stands for the correspond software identifier we assigned to the different devkit
 
 <br />
 
-The general top level diagram of the DYNAP-CNN/SPECK chip is shown as follows:
+The general top level diagram of the SPECK™ chip is shown as follows:
 
 ![top_diagram](/_static/Overview/speck_top_level.png)
 
 
-For DYNAP-CNN dev-kits, it allows the user to interact with the chip using external DVS sensors or pre-defined event data. Speck seriers devkit based on above, it additionally allows the user to use its embeded internal DVS for development.
-
-Currently, Speck/Dynapcnn supports following External DVS sensor with the samna support:
+Sinabs allows you to interact with the DynapCNN processor using external DVS sensors or pre-defined event data, besides its embeded internal DVS for development.
+Currently, Speck supports the following external DVS sensor with the samna support:
 
 * Inivation Davis346
 * Inivation Davis240
 * Inivation DVXplorer
 * Prophesee EVK3-Gen 3.1VGA
 
-# Backend: dynapcnn
+# Backend: Dynapcnn
 
-To interact with these developmentkit, sinabs needs [samna](https://pypi.org/project/samna/) dependency to enables the chip configuration and network setting. As is shown in the figure below, dynapcnn backend provides a simple way to convert the network structure and parameters to the _SammnaConfiguration_ that can be used by samna to setup the chip. 
+To interact with the processor, sinabs needs [samna](https://pypi.org/project/samna/) dependency to enables the chip configuration and network setting. As is shown in the figure below, dynapcnn backend provides a simple way to convert the network structure and parameters to the _SamnaConfiguration_ that can be used by samna to setup the chip.
 
 
 ![sinab-dynapcnn](/_static/Overview/sinabs-dynapcnn-role.png)
 
 # Chip Resources
 
-For all DYNAP-CNN/SPECK family, they using the DYNAP asynchronous computing structure and have the similar computation resources. The detailed features are shown below
+All SPECK™ family chips use the DYNAP asynchronous computing structure and have the similar computation resources. The detailed features are shown below
 
 ## Key Features
 
@@ -73,9 +76,7 @@ An Event noise filter is also included in the pre-processing layer, the filter c
 
 ### DYNAP-CNN Layer
 
-The DYNAP-CNN Layer is the main hard ware representation of the designed spiking neural network structure. One of the main goal of the sinabs-dynapcnn is to provide an efficient, simply way to convert the `torch.Sequential` object to equivalent DYNAP-CNN layer configuration. Details of how to use the sinabs-dynapcnn interact with your designed SNNs, please visit tutorial
-
-
+The DYNAP-CNN Layer is the main hardware representation of the designed spiking neural network structure. One of the main goal of the sinabs-dynapcnn is to provide an efficient, simply way to convert the `torch.Sequential` object to equivalent DYNAP-CNN layer configuration. For more details on how to use the sinabs-dynapcnn to interact with your designed SNNs, please check our tutorials.
 
 #### Feature
 - Max input dimension for the layer: 128x128
@@ -90,15 +91,15 @@ The DYNAP-CNN Layer is the main hard ware representation of the designed spiking
 - Fanout:2
 
 #### Internal Execution Order
-A single chip consists of __9__ configurable computing cores(layers), each layer can be regarded as a combination of (Conv2d Operation --> Spiking Activation --> Sumpooling). These computation has to be configured in exact equivalent execution order. Each layer can be flexiblely configured to be communicate with other layers.
+A single chip consists of __9__ configurable computing cores (layers), each layer can be regarded as a combination of (Conv2d Operation --> Spiking Activation --> Sumpooling). These computation has to be configured in exact equivalent execution order. Each layer can be flexiblely configured to be communicate with other layers.
 
 
 #### Async event-driven feature
-information communication with layers are only in "Event based" format, the layer process the "incomming" event only at whenever a layer recieves it. Each layer can be configured to set 1-2 destination to the other layer. 
+information communication with layers are only in "event based" format, the layer process the "incomming" event only at whenever a layer recieves it. Each layer can be configured to set 1-2 destination to the other layer.
 
 
 #### Memory Constraints and Network Sizing
-Each layer has different memory constraints that split into kernel memory(for weight parameters) and neuron memory(spiking neuron states) as is shown below.  __Note:__ For the entire series of chips, dynapcnn/speck support precision of **8bit** int for kernel parameters and **16bit** int for neuron state precisions.
+Each layer has different memory constraints that split into kernel memory (for weight parameters) and neuron memory (spiking neuron states) as is shown below.  __Note:__ For the entire series of chips, speck support precision of **8bit** int for kernel parameters and **16bit** int for neuron state precisions.
 
 ![memoryconstrains](/_static/Overview/memory_constraints.png)
 

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/docs/speck/the_basics.md

@@ -6,7 +6,7 @@ This package automates this process for the end-user and enables quick deploymen
 
 TLDR;
 -----
-A short (and perhaps the quickest path) to deploying your model on one of our dev-kits is shown in the example below.
+A short (and perhaps the quickest path) to deploying your model on one of our chips is shown in the example below.
 
 ```python
 import torch
@@ -45,7 +45,7 @@ hw_model = DynapcnnNetwork(
 )
 
 # Deploy model to a dev-kit
-hw_model.to(device="dynapcnndevkit:0")
+hw_model.to(device="speck2fdevkit:0")
 
 # Send events to chip
 events_in: List["Spike"] =  ... # Load your events
@@ -59,7 +59,7 @@ events_out = hw_model(events_in)
 Model conversion to DYNAP-CNN core structure
 --------------------------------------------
 
-DYNAP-CNN based chips like `DYNAP-CNN DevKit` or `Speck` series comprise several `cores` or `layers`. 
+Speck family chips, based on DYNAP-CNN, comprise several `cores` or `layers`.
 Each of these `layers` comprises three functionalities:
 
     1. 2D Convolution
@@ -97,7 +97,7 @@ Device selection
 ----------------
 
 The device naming is inspired by `pytorch` device naming convention ie `DEVICE_TYPE:INDEX`.
-`dynapcnndevkit:0` refers to the _first_ `Dynapcnn DevKit` available. 
+`speck2fdevkit:0` refers to the _first_ `Speck 2F DevKit` available.
 If there are multiple devices of the same kind connected to the PC, then they are referred by higher incremental indices.
 
 To see all the recognized devices, please have a look at the `sinabs.backend.dynapcnn.io.device_types`
@@ -116,16 +116,15 @@ List of devices currently recognized by *samna*
 ```
 # A map of all device types and their corresponding samna `device_name`
 device_types = {
-    "speck": "speck",
+    "speck2e": "Speck2eTestBoard",
+    "speck2edevkit": "Speck2eDevKit",
+    "speck2fmodule": "Speck2fModuleDevKit",
+    "speck2fdevkit": "Speck2fDevKit",
     "dynapse2": "DYNAP-SE2 DevBoard",
     "dynapse2_stack": "DYNAP-SE2 Stack",
-    "speck2devkit": "Speck2DevKit",
-    "dynapse1devkit": "Dynapse1DevKit",
     "davis346": "Davis 346",
     "davis240": "Davis 240",
     "dvxplorer": "DVXplorer",
-    "pollendevkit": "PollenDevKit",
-    "dynapcnndevkit": "DynapcnnDevKit",
 }
 ```
 
@@ -166,13 +165,13 @@ Porting model to device
 -----------------------
 
 `DynapcnnNetwork` class has an API similar to that of native `pytorch` and its `.to` method.
-Similar to porting a model to cpu with `model.to("cpu")` and GPU with `model.to("cuda:0")` you can also port your `DynapcnnCompatibleModel` to a chip with `model.to("dynapcnndevkit:0")`.
+Similar to porting a model to cpu with `model.to("cpu")` and GPU with `model.to("cuda:0")` you can also port your `DynapcnnCompatibleModel` to a chip with `model.to("speck2fdevkit:0")`.
 
 You can also specify a few additional parameters as shown below.
 
 ```python
 hw_model.to(
-    device="dynapcnndevkit:0",
+    device="speck2fdevkit:0",
     chip_layers_ordering="auto",  # default value is "auto"
     monitor_layers=[-1],
     config_modifier=config_modifier,

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/docs/speck/visualizer.md

@@ -137,14 +137,13 @@ In order to visualize the class outputs as images, we need to get the images. Th
 - In order to show a prediction only if there are more than a `threshold` number of events from that output, set the `readout_prediction_threshold`=`threshold`.
 - In order to default to a certain class (in `DVSGesture` example, we use the last `other` class) set `readout_default_return_value`=`class_idx` (int).
 - In order to limit the prediction between some thresholds (i.e. it is meaningless to make a prediction with too low and too high values) set `readout_default_threshold_low` and `readout_default_threshold_high` parameters.
-- In all the chips except for `DynapcnnDevkit` you can monitor the power consumption in 5 different rows. These rows are `io`, `logic`, `ram`, `pixel-digital` and `pixel-analog`.
+- In all the chips you can monitor the power consumption in 5 different rows. These rows are `io`, `logic`, `ram`, `pixel-digital` and `pixel-analog`.
     - `io`: Power consumption of IO unit on the chip.
     - `logic`: Power consumption caused by operations in the chip and communication with spikes.
     - `ram`: Power consumption of `memory` used to store `states` and `weights`.
     - `pixel-digital`: Power consumption of the digital part (i.e. communication via AER) of pixels.
     - `pixel-analog`: Power consumtpion of the analog part. (i.e. pixels.
     ). 
-- `DynapcnnDevkit` does not come with an on-board Dvs sensor, thus does not support the last two. If you want only the first 3 columns, pass `power_monitor_number_of_items`=`3`. If you want columns pass `5`.
 - If you follow the naming conventions for readout images (i.e. `{labelidx}_{labelname}.png`) the feature names are going to be parsed from the image names. However, you can also pass labels manually using `feature_names`=`["class01", "class02", ...]`. That can be used also while labeling `SpikeCountPlot` legend, when `ReadoutLayer` is not preferred.
 - The last layer feature count is going to be automatically extracted from the model. However you can pass it manually `feature_count`=`count`. This can be useful for plotting purposes, when there are other classes that you did not take into account in the model you trained.
 - `extra_arguments`: You can pass the function names and variables for the individual plots for `spike_count`, `readout` and `power_measurement` plots. Available function names and argument types can be found in the following link: [here](https://synsense-sys-int.gitlab.io/samna/reference/viz/imgui/index.html#samna-viz-imgui)

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/examples/mnist/dynapcnn_network.py

@@ -77,11 +77,9 @@ hardware_compatible_model = DynapcnnNetwork(
 )
 
 # Chip name
-# Depending on the available hardware you have, you can choose to run the
-# network for example on 'dynapcnndevkit' or 'speck2b' among others. See
-# documentation for full list of supported devices
-# chip_name = "speck2fmodule"
-chip_name = "dynapcnndevkit"
+# Depending on the available hardware you have, you need to update the chip name.
+# See documentation for full list of supported devices
+chip_name = "speck2fmodule"
 
 hardware_compatible_model.to(
     device=chip_name, monitor_layers=[-1]  # Monitor the output layer
@@ -110,8 +108,8 @@ print("Sending events to device")
 evs_out = hardware_compatible_model(input_events)
 
 # Filter readout events
-if chip_name == "dynapcnndevkit":
-    evs_out = list(filter(lambda x: isinstance(x, samna.dynapcnn.event.Spike), evs_out))
+if chip_name == "speck2fdevkit":
+    evs_out = list(filter(lambda x: isinstance(x, samna.speck2f.event.Spike), evs_out))
 
 if len(evs_out) > 0:
     print(

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/requirements.txt

@@ -1,7 +1,7 @@
 pbr
 numpy
 torch>=1.8
-nir
+nir <=1.0.4
 nirtorch
 samna >= 0.33
 

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/sinabs/backend/dynapcnn/chip_factory.py

@@ -4,10 +4,6 @@ import numpy as np
 import torch
 
 from .chips import (
-    DynapcnnConfigBuilder,
-    Speck2BConfigBuilder,
-    Speck2CMiniConfigBuilder,
-    Speck2DMiniConfigBuilder,
     Speck2EConfigBuilder,
     Speck2FConfigBuilder,
 )
@@ -17,11 +13,6 @@ from .utils import parse_device_id
 
 class ChipFactory:
     supported_devices = {
-        "dynapcnndevkit": DynapcnnConfigBuilder,
-        "speck2b": Speck2BConfigBuilder,
-        "speck2btiny": Speck2BConfigBuilder,  # It is the same chip, so doesn't require a separate builder
-        "speck2cmini": Speck2CMiniConfigBuilder,
-        "speck2dmini": Speck2DMiniConfigBuilder,
         "speck2e": Speck2EConfigBuilder,
         "speck2edevkit": Speck2EConfigBuilder,
         "speck2fmodule": Speck2FConfigBuilder,  # Speck2fModuleDevKit

sinabs-2.0.4.dev32/sinabs/backend/dynapcnn/chips/__init__.py

@@ -0,0 +1,3 @@
+# from .dynapcnn import DynapcnnConfigBuilder
+from .speck2e import Speck2EConfigBuilder
+from .speck2f import Speck2FConfigBuilder

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/sinabs/backend/dynapcnn/chips/dynapcnn.py

@@ -1,12 +1,11 @@
-import copy
+from abc import abstractmethod
 from typing import List
 from warnings import warn
 
 import samna
 import torch
-from samna.dynapcnn.configuration import DynapcnnConfiguration
-
 import sinabs
+
 from sinabs.backend.dynapcnn.config_builder import ConfigBuilder
 from sinabs.backend.dynapcnn.dvs_layer import DVSLayer, expand_to_pair
 from sinabs.backend.dynapcnn.dynapcnn_layer import DynapcnnLayer
@@ -15,63 +14,28 @@ from sinabs.backend.dynapcnn.mapping import LayerConstraints
 
 class DynapcnnConfigBuilder(ConfigBuilder):
     @classmethod
+    @abstractmethod
     def get_samna_module(cls):
-        return samna.dynapcnn
+        """
+        Get the samna parent module that hosts all the appropriate sub-modules and classes.
 
-    @classmethod
-    def get_default_config(cls) -> "DynapcnnConfiguration":
-        return DynapcnnConfiguration()
+        Returns
+        -------
+        samna module
+        """
 
     @classmethod
-    def get_dvs_layer_config_dict(cls, layer: DVSLayer): ...
+    @abstractmethod
+    def get_default_config(cls):
+        """
+        Returns the default configuration for the device type
+        """
 
     @classmethod
     def write_dvs_layer_config(cls, layer: DVSLayer, config: "DvsLayerConfig"):
         for param, value in layer.get_config_dict().items():
             setattr(config, param, value)
 
-    @classmethod
-    def set_kill_bits(cls, layer: DynapcnnLayer, config_dict: dict) -> dict:
-        """This method updates all the kill_bit parameters.
-
-        Args:
-            layer (DynapcnnLayer): The layer of whome the configuration is to be generated
-            config_dict (dict): The dictionary where the parameters need to be added
-
-
-        Returns:
-            dict: returns the updated config_dict.
-        """
-        config_dict = copy.deepcopy(config_dict)
-
-        if layer.conv_layer.bias is not None:
-            (weights, biases) = layer.conv_layer.parameters()
-        else:
-            (weights,) = layer.conv_layer.parameters()
-            biases = torch.zeros(layer.conv_layer.out_channels)
-
-        config_dict["weights_kill_bit"] = (~weights.bool()).tolist()
-        config_dict["biases_kill_bit"] = (~biases.bool()).tolist()
-
-        # - Neuron states
-        if not layer.spk_layer.is_state_initialised():
-            # then we assign no initial neuron state to DYNAP-CNN.
-            f, h, w = layer.get_neuron_shape()
-            neurons_state = torch.zeros(f, w, h)
-        elif layer.spk_layer.v_mem.dim() == 4:
-            # 4-dimensional states should be the norm when there is a batch dim
-            neurons_state = layer.spk_layer.v_mem.transpose(2, 3)[0]
-        else:
-            raise ValueError(
-                f"Current v_mem (shape: {layer.spk_layer.v_mem.shape}) of spiking layer not understood."
-            )
-
-        config_dict["neurons_value_kill_bit"] = (
-            torch.zeros_like(neurons_state).bool().tolist()
-        )
-
-        return config_dict
-
     @classmethod
     def get_dynapcnn_layer_config_dict(cls, layer: DynapcnnLayer):
         config_dict = {}
@@ -112,11 +76,8 @@ class DynapcnnConfigBuilder(ConfigBuilder):
         config_dict["weights"] = weights.int().tolist()
         config_dict["biases"] = biases.int().tolist()
         config_dict["leak_enable"] = biases.bool().any()
-        # config_dict["weights_kill_bit"] = torch.zeros_like(weights).bool().tolist()
-        # config_dict["biases_kill_bit"] = torch.zeros_like(biases).bool().tolist()
 
         # Update parameters from the spiking layer
-
         # - Neuron states
         if not layer.spk_layer.is_state_initialised():
             # then we assign no initial neuron state to DYNAP-CNN.
@@ -155,7 +116,6 @@ class DynapcnnConfigBuilder(ConfigBuilder):
                 "threshold_low": min_v_mem,
                 "monitor_enable": False,
                 "neurons_initial_value": neurons_state.int().tolist(),
-                # "neurons_value_kill_bit" : torch.zeros_like(neurons_state).bool().tolist()
             }
         )
         # Update parameters from pooling
@@ -167,9 +127,6 @@ class DynapcnnConfigBuilder(ConfigBuilder):
         else:
             pass
 
-        # Set kill bits
-        config_dict = cls.set_kill_bits(layer=layer, config_dict=config_dict)
-
         return config_dict
 
     @classmethod
@@ -273,7 +230,7 @@ class DynapcnnConfigBuilder(ConfigBuilder):
         return constraints
 
     @classmethod
-    def monitor_layers(cls, config: "DynapcnnConfiguration", layers: List):
+    def monitor_layers(cls, config, layers: List):
         """Updates the config object in place.
 
         Parameters
@@ -309,15 +266,36 @@ class DynapcnnConfigBuilder(ConfigBuilder):
         return config
 
     @classmethod
+    @abstractmethod
     def get_input_buffer(cls):
-        return samna.BasicSourceNode_dynapcnn_event_input_event()
+        """
+        Initialize and return the appropriate output buffer object Note that this just the
+        buffer object.
+
+        This does not actually connect the buffer object to the graph. (It is needed as of samna
+        0.21.0)
+        """
 
     @classmethod
+    @abstractmethod
     def get_output_buffer(cls):
-        return samna.BasicSinkNode_dynapcnn_event_output_event()
+        """
+        Initialize and return the appropriate output buffer object Note that this just the
+        buffer object.
+
+        This does not actually connect the buffer object to the graph.
+        """
 
     @classmethod
-    def reset_states(cls, config: DynapcnnConfiguration, randomize=False):
+    def reset_states(cls, config, randomize=False):
+        """
+        Parameters
+        ----------
+        config:
+            samna config object
+        randomize (bool):
+            If true, the states will be set to random initial values. Else, they will be set to zero
+        """
         for idx, lyr in enumerate(config.cnn_layers):
             shape = torch.tensor(lyr.neurons_initial_value).shape
             # set the config's neuron initial state values into zeros

{sinabs-2.0.3.dev11 → sinabs-2.0.4.dev32}/sinabs/backend/dynapcnn/chips/speck2e.py

@@ -5,9 +5,8 @@ from sinabs.backend.dynapcnn.dynapcnn_layer import DynapcnnLayer
 
 from .dynapcnn import DynapcnnConfigBuilder
 
-# Since most of the configuration is identical to DYNAP-CNN, we can simply inherit this class
-
 
+# Inherit DynapCNNConfigBuilder to share implementation with other DynapCNN/Speck devices
 class Speck2EConfigBuilder(DynapcnnConfigBuilder):
     @classmethod
     def get_samna_module(cls):
@@ -25,10 +24,6 @@ class Speck2EConfigBuilder(DynapcnnConfigBuilder):
     def get_output_buffer(cls):
         return samna.BasicSinkNode_speck2e_event_output_event()
 
-    @classmethod
-    def set_kill_bits(cls, layer: DynapcnnLayer, config_dict: dict) -> dict:
-        return config_dict
-
     @classmethod
     def get_dynapcnn_layer_config_dict(cls, layer: DynapcnnLayer):
         config_dict = super().get_dynapcnn_layer_config_dict(layer=layer)