sinabs 3.1.1.dev1__tar.gz → 3.1.2__tar.gz

{sinabs-3.1.1.dev1 → sinabs-3.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sinabs
-Version: 3.1.1.dev1
+Version: 3.1.2
 Summary: SynSense Spiking Neural Network simulator for deep neural networks (DNNs).
 Author: SynSense (formerly AiCTX)
 Author-email: support@synsense.ai
@@ -87,7 +87,7 @@ Sinabs is published under Apache v2.0. See the LICENSE file for details.
 
 Contributing to Sinabs
 ------------------------
-Checkout the [contributing](https://sinabs.readthedocs.io/en/develop/about/contributing.html) page for more info.
+Checkout the [contributing](https://sinabs.readthedocs.io/develop/about/contributing.html) page for more info.
 
 
 Citation

{sinabs-3.1.1.dev1 → sinabs-3.1.2}/README.md

@@ -49,7 +49,7 @@ Sinabs is published under Apache v2.0. See the LICENSE file for details.
 
 Contributing to Sinabs
 ------------------------
-Checkout the [contributing](https://sinabs.readthedocs.io/en/develop/about/contributing.html) page for more info.
+Checkout the [contributing](https://sinabs.readthedocs.io/develop/about/contributing.html) page for more info.
 
 
 Citation

{sinabs-3.1.1.dev1 → sinabs-3.1.2}/docs/about/release_notes.md

@@ -1,5 +1,17 @@
 # Release notes
 
+## v3.1.2 (12/12/2025)
+
+* Update use of visualizer in Sinabs tutorials, previous tutorials were using a deprecated visualizer version.
+* Fix issue with `chip_layers_ordering` in the visualizer. `chip_layers_ordering` was deprecated in Sinabs 3.1.0 and `layer2core_map` needs to be used instead.
+
+## v3.1.1 (27/11/2025)
+
+* Fix NIR export of Conv1d layer which expected an input_shape parameter.
+* Fix broken link on documentation.
+* Fix missing plots on `Neuron Models` gallery.
+* Fix `open_device` function that would thrown an error if an unsupported SynSense device was connected to the computer.
+
 ## v3.1.0 (31/10/2025)
 
 * Add mapping of non-sequential networks:

{sinabs-3.1.1.dev1 → sinabs-3.1.2}/docs/conf.py

@@ -31,7 +31,6 @@ sphinx_gallery_conf = {
     # "backreferences_dir": "gen_modules/backreferences",
     "doc_module": ("sinabs",),
     "download_all_examples": False,
-    "ignore_pattern": r"utils\.py",
 }
 
 # Napoleon settings

{sinabs-3.1.1.dev1 → sinabs-3.1.2}/docs/gallery/layers/utils.py

@@ -1,8 +1,14 @@
+"""
+==============================
+Utility Function
+==============================
+Utility function for plots in the documentation.
+"""
+
 import matplotlib.pyplot as plt
 import torch
 
 import sinabs
-import sinabs.layers as sl
 
 
 def plot_evolution(neuron_model: sinabs.layers, input: torch.Tensor):

{sinabs-3.1.1.dev1 → sinabs-3.1.2}/docs/speck/notebooks/leak_neuron.ipynb

@@ -110,7 +110,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "id": "500e2d79",
    "metadata": {},
    "outputs": [
@@ -230,7 +230,7 @@
     ")\n",
     "# don't forget to set the slow clock frequency!\n",
     "# here we set the frequency to 1Hz, which mean the Vmem should decrease after every 1 second\n",
-    "dynapcnn.to(device=\"speck2fmodule\", slow_clk_frequency=1)\n",
+    "dynapcnn.to(device=\"speck2fdevkit\", slow_clk_frequency=1)\n",
     "\n",
     "# Check if neuron states decrease along with time pass by\n",
     "\n",
@@ -276,7 +276,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.0"
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,

{sinabs-3.1.1.dev1 → sinabs-3.1.2}/docs/speck/notebooks/nmnist_quick_start.ipynb

@@ -37,7 +37,7 @@
     "except ImportError:\n",
     "    ! pip install tonic\n",
     "    from tonic.datasets.nmnist import NMNIST\n",
-    "    \n",
+    "\n",
     "# download dataset\n",
     "root_dir = \"./NMNIST\"\n",
     "_ = NMNIST(save_to=root_dir, train=True)\n",
@@ -64,7 +64,9 @@
     "sample_data, label = NMNIST(save_to=root_dir, train=False)[0]\n",
     "\n",
     "print(f\"type of data is: {type(sample_data)}\")\n",
-    "print(f\"time length of sample data is: {sample_data['t'][-1] - sample_data['t'][0]} micro seconds\")\n",
+    "print(\n",
+    "    f\"time length of sample data is: {sample_data['t'][-1] - sample_data['t'][0]} micro seconds\"\n",
+    ")\n",
     "print(f\"there are {len(sample_data)} events in the sample data\")\n",
     "print(f\"the label of the sample data is: {label}\")"
    ]
@@ -99,15 +101,26 @@
     "# define a CNN model\n",
     "cnn = nn.Sequential(\n",
     "    # [2, 34, 34] -> [8, 17, 17]\n",
-    "    nn.Conv2d(in_channels=2, out_channels=8, kernel_size=(3, 3), padding=(1, 1), bias=False),\n",
+    "    nn.Conv2d(\n",
+    "        in_channels=2, out_channels=8, kernel_size=(3, 3), padding=(1, 1), bias=False\n",
+    "    ),\n",
     "    nn.ReLU(),\n",
     "    nn.AvgPool2d(2, 2),\n",
     "    # [8, 17, 17] -> [16, 8, 8]\n",
-    "    nn.Conv2d(in_channels=8, out_channels=16, kernel_size=(3, 3), padding=(1, 1), bias=False),\n",
+    "    nn.Conv2d(\n",
+    "        in_channels=8, out_channels=16, kernel_size=(3, 3), padding=(1, 1), bias=False\n",
+    "    ),\n",
     "    nn.ReLU(),\n",
     "    nn.AvgPool2d(2, 2),\n",
     "    # [16 * 8 * 8] -> [16, 4, 4]\n",
-    "    nn.Conv2d(in_channels=16, out_channels=16, kernel_size=(3, 3), padding=(1, 1), stride=(2, 2),  bias=False),\n",
+    "    nn.Conv2d(\n",
+    "        in_channels=16,\n",
+    "        out_channels=16,\n",
+    "        kernel_size=(3, 3),\n",
+    "        padding=(1, 1),\n",
+    "        stride=(2, 2),\n",
+    "        bias=False,\n",
+    "    ),\n",
     "    nn.ReLU(),\n",
     "    # [16 * 4 * 4] -> [10]\n",
     "    nn.Flatten(),\n",
@@ -160,7 +173,9 @@
     "\n",
     "# check the transformed data\n",
     "sample_data, label = cnn_train_dataset[0]\n",
-    "print(f\"The transformed array is in shape [Time-Step, Channel, Height, Width] --> {sample_data.shape}\")"
+    "print(\n",
+    "    f\"The transformed array is in shape [Time-Step, Channel, Height, Width] --> {sample_data.shape}\"\n",
+    ")"
    ]
   },
   {
@@ -306,8 +321,20 @@
     "\n",
     "cnn = cnn.to(device=device)\n",
     "\n",
-    "cnn_train_dataloader = DataLoader(cnn_train_dataset, batch_size=batch_size, num_workers=num_workers, drop_last=True, shuffle=shuffle)\n",
-    "cnn_test_dataloader = DataLoader(cnn_test_dataset, batch_size=batch_size, num_workers=num_workers, drop_last=True, shuffle=shuffle)\n",
+    "cnn_train_dataloader = DataLoader(\n",
+    "    cnn_train_dataset,\n",
+    "    batch_size=batch_size,\n",
+    "    num_workers=num_workers,\n",
+    "    drop_last=True,\n",
+    "    shuffle=shuffle,\n",
+    ")\n",
+    "cnn_test_dataloader = DataLoader(\n",
+    "    cnn_test_dataset,\n",
+    "    batch_size=batch_size,\n",
+    "    num_workers=num_workers,\n",
+    "    drop_last=True,\n",
+    "    shuffle=shuffle,\n",
+    ")\n",
     "\n",
     "optimizer = SGD(params=cnn.parameters(), lr=lr)\n",
     "criterion = CrossEntropyLoss()\n",
@@ -329,7 +356,9 @@
     "        loss.backward()\n",
     "        optimizer.step()\n",
     "        # set progressing bar\n",
-    "        train_p_bar.set_description(f\"Epoch {e} - Training Loss: {round(loss.item(), 4)}\")\n",
+    "        train_p_bar.set_description(\n",
+    "            f\"Epoch {e} - Training Loss: {round(loss.item(), 4)}\"\n",
+    "        )\n",
     "\n",
     "    # validate\n",
     "    correct_predictions = []\n",
@@ -348,9 +377,11 @@
     "            correct_predictions.append(pred.eq(label.view_as(pred)))\n",
     "            # set progressing bar\n",
     "            test_p_bar.set_description(f\"Epoch {e} - Testing Model...\")\n",
-    "    \n",
+    "\n",
     "        correct_predictions = torch.cat(correct_predictions)\n",
-    "        print(f\"Epoch {e} - accuracy: {correct_predictions.sum().item()/(len(correct_predictions))*100}%\")"
+    "        print(\n",
+    "            f\"Epoch {e} - accuracy: {correct_predictions.sum().item()/(len(correct_predictions))*100}%\"\n",
+    "        )"
    ]
   },
   {
@@ -391,7 +422,9 @@
    "source": [
     "from sinabs.from_torch import from_model\n",
     "\n",
-    "snn_convert = from_model(model=cnn, input_shape=(2, 34, 34), batch_size=batch_size).spiking_model\n",
+    "snn_convert = from_model(\n",
+    "    model=cnn, input_shape=(2, 34, 34), batch_size=batch_size\n",
+    ").spiking_model\n",
     "snn_convert"
    ]
   },
@@ -434,7 +467,13 @@
     "n_time_steps = 100\n",
     "to_raster = ToFrame(sensor_size=NMNIST.sensor_size, n_time_bins=n_time_steps)\n",
     "snn_test_dataset = NMNIST(save_to=root_dir, train=False, transform=to_raster)\n",
-    "snn_test_dataloader = DataLoader(snn_test_dataset, batch_size=batch_size, num_workers=num_workers, drop_last=True, shuffle=False)\n",
+    "snn_test_dataloader = DataLoader(\n",
+    "    snn_test_dataset,\n",
+    "    batch_size=batch_size,\n",
+    "    num_workers=num_workers,\n",
+    "    drop_last=True,\n",
+    "    shuffle=False,\n",
+    ")\n",
     "\n",
     "snn_convert = snn_convert.to(device)\n",
     "\n",
@@ -459,7 +498,9 @@
     "        test_p_bar.set_description(f\"Testing SNN Model...\")\n",
     "\n",
     "    correct_predictions = torch.cat(correct_predictions)\n",
-    "    print(f\"accuracy of converted SNN: {correct_predictions.sum().item()/(len(correct_predictions))*100}%\")"
+    "    print(\n",
+    "        f\"accuracy of converted SNN: {correct_predictions.sum().item()/(len(correct_predictions))*100}%\"\n",
+    "    )"
    ]
   },
   {
@@ -511,20 +552,39 @@
     "# just replace the ReLU layer with the sl.IAFSqueeze\n",
     "snn_bptt = nn.Sequential(\n",
     "    # [2, 34, 34] -> [8, 17, 17]\n",
-    "    nn.Conv2d(in_channels=2, out_channels=8, kernel_size=(3, 3), padding=(1, 1), bias=False),\n",
-    "    sl.IAFSqueeze(batch_size=batch_size, min_v_mem=-1.0, surrogate_grad_fn=PeriodicExponential()),\n",
+    "    nn.Conv2d(\n",
+    "        in_channels=2, out_channels=8, kernel_size=(3, 3), padding=(1, 1), bias=False\n",
+    "    ),\n",
+    "    sl.IAFSqueeze(\n",
+    "        batch_size=batch_size, min_v_mem=-1.0, surrogate_grad_fn=PeriodicExponential()\n",
+    "    ),\n",
     "    nn.AvgPool2d(2, 2),\n",
     "    # [8, 17, 17] -> [16, 8, 8]\n",
-    "    nn.Conv2d(in_channels=8, out_channels=16, kernel_size=(3, 3), padding=(1, 1), bias=False),\n",
-    "    sl.IAFSqueeze(batch_size=batch_size, min_v_mem=-1.0, surrogate_grad_fn=PeriodicExponential()),\n",
+    "    nn.Conv2d(\n",
+    "        in_channels=8, out_channels=16, kernel_size=(3, 3), padding=(1, 1), bias=False\n",
+    "    ),\n",
+    "    sl.IAFSqueeze(\n",
+    "        batch_size=batch_size, min_v_mem=-1.0, surrogate_grad_fn=PeriodicExponential()\n",
+    "    ),\n",
     "    nn.AvgPool2d(2, 2),\n",
     "    # [16 * 8 * 8] -> [16, 4, 4]\n",
-    "    nn.Conv2d(in_channels=16, out_channels=16, kernel_size=(3, 3), padding=(1, 1), stride=(2, 2),  bias=False),\n",
-    "    sl.IAFSqueeze(batch_size=batch_size, min_v_mem=-1.0, surrogate_grad_fn=PeriodicExponential()),\n",
+    "    nn.Conv2d(\n",
+    "        in_channels=16,\n",
+    "        out_channels=16,\n",
+    "        kernel_size=(3, 3),\n",
+    "        padding=(1, 1),\n",
+    "        stride=(2, 2),\n",
+    "        bias=False,\n",
+    "    ),\n",
+    "    sl.IAFSqueeze(\n",
+    "        batch_size=batch_size, min_v_mem=-1.0, surrogate_grad_fn=PeriodicExponential()\n",
+    "    ),\n",
     "    # [16 * 4 * 4] -> [10]\n",
     "    nn.Flatten(),\n",
     "    nn.Linear(16 * 4 * 4, 10, bias=False),\n",
-    "    sl.IAFSqueeze(batch_size=batch_size, min_v_mem=-1.0, surrogate_grad_fn=PeriodicExponential()),\n",
+    "    sl.IAFSqueeze(\n",
+    "        batch_size=batch_size, min_v_mem=-1.0, surrogate_grad_fn=PeriodicExponential()\n",
+    "    ),\n",
     ")\n",
     "\n",
     "# init the model weights\n",
@@ -585,6 +645,7 @@
    "source": [
     "try:\n",
     "    from sinabs.exodus import conversion\n",
+    "\n",
     "    snn_bptt = conversion.sinabs_to_exodus(snn_bptt)\n",
     "except ImportError:\n",
     "    print(\"Sinabs-exodus is not intalled.\")\n",
@@ -668,8 +729,20 @@
     "device = \"cuda:0\"\n",
     "shuffle = True\n",
     "\n",
-    "snn_train_dataloader = DataLoader(snn_train_dataset, batch_size=batch_size, num_workers=num_workers, drop_last=True, shuffle=True)\n",
-    "snn_test_dataloader = DataLoader(snn_test_dataset, batch_size=batch_size, num_workers=num_workers, drop_last=True, shuffle=False)\n",
+    "snn_train_dataloader = DataLoader(\n",
+    "    snn_train_dataset,\n",
+    "    batch_size=batch_size,\n",
+    "    num_workers=num_workers,\n",
+    "    drop_last=True,\n",
+    "    shuffle=True,\n",
+    ")\n",
+    "snn_test_dataloader = DataLoader(\n",
+    "    snn_test_dataset,\n",
+    "    batch_size=batch_size,\n",
+    "    num_workers=num_workers,\n",
+    "    drop_last=True,\n",
+    "    shuffle=False,\n",
+    ")\n",
     "\n",
     "snn_bptt = snn_bptt.to(device=device)\n",
     "\n",
@@ -695,15 +768,17 @@
     "        # backward\n",
     "        loss.backward()\n",
     "        optimizer.step()\n",
-    "        \n",
+    "\n",
     "        # detach the neuron states and activations from current computation graph(necessary)\n",
     "        for layer in snn_bptt.modules():\n",
     "            if isinstance(layer, sl.StatefulLayer):\n",
     "                for name, buffer in layer.named_buffers():\n",
     "                    buffer.detach_()\n",
-    "        \n",
+    "\n",
     "        # set progressing bar\n",
-    "        train_p_bar.set_description(f\"Epoch {e} - BPTT Training Loss: {round(loss.item(), 4)}\")\n",
+    "        train_p_bar.set_description(\n",
+    "            f\"Epoch {e} - BPTT Training Loss: {round(loss.item(), 4)}\"\n",
+    "        )\n",
     "\n",
     "    # validate\n",
     "    correct_predictions = []\n",
@@ -725,9 +800,11 @@
     "            correct_predictions.append(pred.eq(label.view_as(pred)))\n",
     "            # set progressing bar\n",
     "            test_p_bar.set_description(f\"Epoch {e} - BPTT Testing Model...\")\n",
-    "    \n",
+    "\n",
     "        correct_predictions = torch.cat(correct_predictions)\n",
-    "        print(f\"Epoch {e} - BPTT accuracy: {correct_predictions.sum().item()/(len(correct_predictions))*100}%\")"
+    "        print(\n",
+    "            f\"Epoch {e} - BPTT accuracy: {correct_predictions.sum().item()/(len(correct_predictions))*100}%\"\n",
+    "        )"
    ]
   },
   {
@@ -775,6 +852,7 @@
    "source": [
     "try:\n",
     "    from sinabs.exodus import conversion\n",
+    "\n",
     "    snn_bptt = conversion.exodus_to_sinabs(snn_bptt)\n",
     "except ImportError:\n",
     "    print(\"Sinabs-exodus is not intalled.\")\n",
@@ -812,7 +890,9 @@
     "\n",
     "# 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",
+    "dynapcnn = DynapcnnNetwork(\n",
+    "    snn=cpu_snn, input_shape=(2, 34, 34), discretize=True, dvs_input=False\n",
+    ")\n",
     "devkit_name = \"speck2fdevkit\"\n",
     "\n",
     "# use the `to` method of DynapcnnNetwork to deploy the SNN to the devkit\n",
@@ -886,10 +966,10 @@
     "    samna_event_stream = []\n",
     "    for ev in events:\n",
     "        spk = samna.speck2f.event.Spike()\n",
-    "        spk.x = ev['x']\n",
-    "        spk.y = ev['y']\n",
-    "        spk.timestamp = ev['t'] - events['t'][0]\n",
-    "        spk.feature = ev['p']\n",
+    "        spk.x = ev[\"x\"]\n",
+    "        spk.y = ev[\"y\"]\n",
+    "        spk.timestamp = ev[\"t\"] - events[\"t\"][0]\n",
+    "        spk.feature = ev[\"p\"]\n",
     "        # Spikes will be sent to layer/core #0, since the SNN is deployed on core: [0, 1, 2, 3]\n",
     "        spk.layer = 0\n",
     "        samna_event_stream.append(spk)\n",
@@ -897,7 +977,7 @@
     "    # inference on chip\n",
     "    # output_events is also a list of Spike, but each Spike.layer is 3, since layer#3 is the output layer\n",
     "    output_events = dynapcnn(samna_event_stream)\n",
-    "    \n",
+    "\n",
     "    # use the most frequent output neruon index as the final prediction\n",
     "    neuron_index = [each.feature for each in output_events]\n",
     "    if len(neuron_index) != 0:\n",
@@ -905,14 +985,16 @@
     "        prediction = frequent_counter.most_common(1)[0][0]\n",
     "    else:\n",
     "        prediction = -1\n",
-    "    inferece_p_bar.set_description(f\"label: {label}, prediction: {prediction}， output spikes num: {len(output_events)}\") \n",
+    "    inferece_p_bar.set_description(\n",
+    "        f\"label: {label}, prediction: {prediction}， output spikes num: {len(output_events)}\"\n",
+    "    )\n",
     "\n",
     "    if prediction == label:\n",
     "        correct_samples += 1\n",
     "\n",
     "    test_samples += 1\n",
-    "    \n",
-    "print(f\"On chip inference accuracy: {correct_samples / test_samples}\")        "
+    "\n",
+    "print(f\"On chip inference accuracy: {correct_samples / test_samples}\")"
    ]
   },
   {
@@ -1004,6 +1086,8 @@
    ],
    "source": [
     "import samnawe\n",
+    "\n",
+    "\n",
     "# first define a callback function to modify the devkit configuration\n",
     "# the callback function should only has 1 devkit config instance as its input argument\n",
     "def config_modify_callback(devkit_cfg):\n",
@@ -1014,24 +1098,32 @@
     "    devkit_cfg.dvs_layer.raw_monitor_enable = False\n",
     "    # prevent the events generated by the embedded dvs been feed to the DynapCNN Core.\n",
     "    devkit_cfg.dvs_layer.pass_sensor_events = False\n",
-    "    # point the dvs layer output destination to the core#0 \n",
+    "    # point the dvs layer output destination to the core#0\n",
     "    devkit_cfg.dvs_layer.destinations[0].enable = True\n",
     "    devkit_cfg.dvs_layer.destinations[0].layer = 0\n",
     "\n",
     "    # the callback must return the modified devkit config\n",
     "    return devkit_cfg\n",
     "\n",
+    "\n",
     "# close the devkit before reopen\n",
     "samna.device.close_device(dynapcnn.samna_device)\n",
     "\n",
     "# init DynapcnnNetwork instance\n",
-    "dynapcnn = DynapcnnNetwork(snn=cpu_snn, input_shape=(2, 34, 34), discretize=True, dvs_input=True)\n",
+    "dynapcnn = DynapcnnNetwork(\n",
+    "    snn=cpu_snn, input_shape=(2, 34, 34), discretize=True, dvs_input=True\n",
+    ")\n",
     "\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",
-    "dynapcnn.to(device=devkit_name, chip_layers_ordering=[0, 1, 2, 3], monitor_layers=layers_to_monitor, config_modifier=config_modify_callback)\n",
+    "dynapcnn.to(\n",
+    "    device=devkit_name,\n",
+    "    chip_layers_ordering=[0, 1, 2, 3],\n",
+    "    monitor_layers=layers_to_monitor,\n",
+    "    config_modifier=config_modify_callback,\n",
+    ")\n",
     "print(f\"The SNN is deployed on the core: {dynapcnn.chip_layers_ordering}\")"
    ]
   },
@@ -1160,16 +1252,16 @@
     "    samna_event_stream = []\n",
     "    for ev in events:\n",
     "        dvs_ev = samna.speck2f.event.DvsEvent()\n",
-    "        dvs_ev.x = ev['x']\n",
-    "        dvs_ev.y = ev['y']\n",
-    "        dvs_ev.timestamp = ev['t'] - events['t'][0]\n",
-    "        dvs_ev.p = ev['p']\n",
+    "        dvs_ev.x = ev[\"x\"]\n",
+    "        dvs_ev.y = ev[\"y\"]\n",
+    "        dvs_ev.timestamp = ev[\"t\"] - events[\"t\"][0]\n",
+    "        dvs_ev.p = ev[\"p\"]\n",
     "        samna_event_stream.append(dvs_ev)\n",
     "\n",
     "    # inference on chip\n",
     "    # output_events is also a list of Spike, but .layer will have 0, 1, 2, 3 since we choose to monitor all layers' output\n",
     "    output_events = dynapcnn(samna_event_stream)\n",
-    "    \n",
+    "\n",
     "    # get each layers output spikes\n",
     "    layer0_spks = [each.feature for each in output_events if each.layer == 0]\n",
     "    layer1_spks = [each.feature for each in output_events if each.layer == 1]\n",
@@ -1181,14 +1273,16 @@
     "        prediction = frequent_counter.most_common(1)[0][0]\n",
     "    else:\n",
     "        prediction = -1\n",
-    "    inferece_p_bar.set_description(f\"label: {label} prediction: {prediction}，layer 0 output spks: {len(layer0_spks)},layer 1 output spikes num: {len(layer1_spks)}, layer 2 output spikes num: {len(layer2_spks)},layer 3 output spikes num: {len(layer3_spks)}\") \n",
+    "    inferece_p_bar.set_description(\n",
+    "        f\"label: {label} prediction: {prediction}，layer 0 output spks: {len(layer0_spks)},layer 1 output spikes num: {len(layer1_spks)}, layer 2 output spikes num: {len(layer2_spks)},layer 3 output spikes num: {len(layer3_spks)}\"\n",
+    "    )\n",
     "\n",
     "    if prediction == label:\n",
     "        correct_samples += 1\n",
     "\n",
     "    test_samples += 1\n",
-    "    \n",
-    "print(f\"On chip inference accuracy: {correct_samples / test_samples}\")    "
+    "\n",
+    "print(f\"On chip inference accuracy: {correct_samples / test_samples}\")"
    ]
   },
   {

{sinabs-3.1.1.dev1 → sinabs-3.1.2}/docs/speck/notebooks/play_with_speck_dvs.ipynb

@@ -3,6 +3,7 @@
   {
    "cell_type": "markdown",
    "metadata": {
+    "collapsed": true,
     "jupyter": {
      "outputs_hidden": true
     }
@@ -61,7 +62,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
@@ -83,13 +84,15 @@
        "    )\n",
        "    (1): DynapcnnLayer(\n",
        "      (conv_layer): Conv2d(1, 1, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
-       "      (spk_layer): IAFSqueeze(spike_threshold=398.0, min_v_mem=-398.0, batch_size=1, num_timesteps=-1)\n",
+       "      (spk_layer): IAFSqueeze(spike_threshold=Parameter containing:\n",
+       "      tensor(418.), min_v_mem=Parameter containing:\n",
+       "      tensor(-418.), batch_size=1, num_timesteps=-1)\n",
        "    )\n",
        "  )\n",
        ")"
       ]
      },
-     "execution_count": 33,
+     "execution_count": 1,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -112,7 +115,7 @@
     "dynapcnn = DynapcnnNetwork(snn=snn, input_shape=input_shape, dvs_input=True)\n",
     "\n",
     "# deploy to speck devkit, use a different name if you're using a different version of the devkit\n",
-    "devkit_name = \"speck2fmodule\"\n",
+    "devkit_name = \"speck2fdevkit\"\n",
     "dynapcnn.to(device=devkit_name, monitor_layers=[\"dvs\", -1])"
    ]
   },
@@ -130,7 +133,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -164,7 +167,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -215,7 +218,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -224,6 +227,14 @@
      "text": [
       "Network is valid\n"
      ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/vleite/.pyenv/versions/sinabs/lib/python3.12/site-packages/sinabs/backend/dynapcnn/chips/dynapcnn.py:252: UserWarning: DVS layer has pooling and is being monitored. Note that pooling will not be reflected in the monitored events.\n",
+      "  warn(\n"
+     ]
     }
    ],
    "source": [
@@ -267,7 +278,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -309,7 +320,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
@@ -360,7 +371,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -391,7 +402,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -433,7 +444,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -485,7 +496,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -547,7 +558,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -594,7 +605,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -625,7 +636,7 @@
     "devkit_cfg_filter.dvs_filter.threshold = 5\n",
     "\n",
     "# set up the Unifirm/IO module\n",
-    "devkit_io = devkit.get_io_module()\n",
+    "devkit_io = dynapcnn.samna_device.get_io_module()\n",
     "\n",
     "# update the configuration\n",
     "dynapcnn.samna_device.get_model().apply_configuration(devkit_cfg_filter)"
@@ -655,7 +666,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.10"
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,