sinabs 3.0.4.dev25__tar.gz → 3.1.1__tar.gz

{sinabs-3.0.4.dev25 → sinabs-3.1.1}/AUTHORS

@@ -22,6 +22,7 @@ Vanessa Leite <vanessa.leite@synsense.ai>
 Vanessa Leite <vanessa@ini.uzh.ch>
 Vanessa Leite <vanessinhaleite.cp.ufma@gmail.com>
 Vanessa Leite <vrcleite@gmail.com>
+Willian Girao <williansoaresgirao@gmail.com>
 Willian-Girao <williansoaresgirao@gmail.com>
 Yalun Hu <yalun.hu@synsense.ai>
 Yalun_Hu <yalun.hu@synsense.ai>

{sinabs-3.0.4.dev25 → sinabs-3.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sinabs
-Version: 3.0.4.dev25
+Version: 3.1.1
 Summary: SynSense Spiking Neural Network simulator for deep neural networks (DNNs).
 Author: SynSense (formerly AiCTX)
 Author-email: support@synsense.ai
@@ -23,6 +23,7 @@ Requires-Dist: torch>=1.8
 Requires-Dist: nir<=1.0.4
 Requires-Dist: nirtorch
 Requires-Dist: samna>=0.33
+Requires-Dist: matplotlib
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -86,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.0.4.dev25 → sinabs-3.1.1}/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.0.4.dev25 → sinabs-3.1.1}/docs/about/differences.md

@@ -1,8 +1,8 @@
 How is Sinabs different?
 ========================
 
-There are many SNN simulators out there. What does Sinabs do differently? Sinabs is meant to extend PyTorch by adding stateful and spiking layers, which can then take full advantage of the optimised, gradient-based training mechanisms. You might find that the design of our sequential models differs slightly from that of recurrent layers in PyTorch, as we do not pass the state as an input or receive it as output. We do this so that we can be compatible with the nn.Sequential architecture, without having to manually define the flow of tensors between layers. 
+There are many SNN simulators out there. What does Sinabs do differently? Sinabs is meant to extend PyTorch by adding stateful and spiking layers, which can then take full advantage of the optimised, gradient-based training mechanisms. You might find that the design of our sequential models differs slightly from that of recurrent layers in PyTorch, as we do not pass the state as an input or receive it as output. We do this so that we can be compatible with the nn.Sequential architecture, without having to manually define the flow of tensors between layers.
 
 What is the difference between Rockpool and Sinabs?
 ---------------------------------------------------
-Rockpool provides multiple computational backends such as Jax, Nest or PyTorch and wraps its own api around it! That allows for powerful abstractions and many additional features such as graph tracing, support for continuous time systems and neuromorphic hardware. Sinabs on the other hand focuses on simplicity: Built exclusively on PyTorch, it's meant to be a thin layer that adds support for spiking layers that are not part of PyTorch. Traditionally, Sinabs added support for SynSense's convolutional neuromorphic hardware (Dynap-CNN), while Rockpool focuses on SynSense's hardware for lower-dimensional signals (Xylo). You can read about both hardware architectures [here](https://www.synsense-neuromorphic.com/technology). That means that Sinabs comes with built-in weight transfer functionality which converts a pre-trained ANN to an SNN, because vision models often have strong spatial dependencies. Rockpool on the other hand adds support for analog audio frontends and exact hardware simulation in software. 
+Rockpool provides multiple computational backends such as Jax, Nest or PyTorch and wraps its own api around it! That allows for powerful abstractions and many additional features such as graph tracing, support for continuous time systems and neuromorphic hardware. Sinabs on the other hand focuses on simplicity: Built exclusively on PyTorch, it's meant to be a thin layer that adds support for spiking layers that are not part of PyTorch. Traditionally, Sinabs added support for SynSense's convolutional neuromorphic hardware (Dynap-CNN), while Rockpool focuses on SynSense's hardware for lower-dimensional signals (Xylo). You can read about both hardware architectures [here](https://www.synsense.ai/products/speck-2/). That means that Sinabs comes with built-in weight transfer functionality which converts a pre-trained ANN to an SNN, because vision models often have strong spatial dependencies. Rockpool on the other hand adds support for analog audio frontends and exact hardware simulation in software.

{sinabs-3.0.4.dev25 → sinabs-3.1.1}/docs/about/release_notes.md

@@ -1,5 +1,23 @@
 # Release notes
 
+## Unreleased
+
+* 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:
+    * Now, layers in Sinabs models can receive inputs from and send outputs to multiple layers.
+    * Deprecate `chip_layers_ordering` from DynapCNNNetwork. Use `layer2core_map` instead.
+    * Deprecate `DynapcnnCompatibleNetwork`. Use `DynapcnnNetwork` instead.
+    * Deprecate `merge_conv_bn` from `sinabs.utils`. Use `merge_bn` instead.
+* Fix tests crashing in case an unexpected board was found.
+* Fix tests that were not running for speck2fdevkit.
+* Fix error when initializing sinabs without matplotlib: matplotlib is not a sinabs dependency.
+
 ## v3.0.4 (08/09/2025)
 
 * Update sinabs code to be consistent with Python 3.12 and Numpy > 2.0.

{sinabs-3.0.4.dev25 → sinabs-3.1.1}/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.0.4.dev25 → sinabs-3.1.1}/docs/contact.md

@@ -1,5 +1,5 @@
 # **CONTACT US**
 
-Are you using Sinabs to train your networks? Do you have access to SynSense hardware and need help figuring something out? Found a bug? It's normally easiest to reach SynSense developers on the [SynSense Discord](https://discord.gg/V6FHBZURkg) server. There we have dedicated channels regarding Sinabs and our hardware. 
+Are you using Sinabs to train your networks? Do you have access to SynSense hardware and need help figuring something out? Found a bug? It's normally easiest to reach SynSense developers on the [SynSense Discord](https://discord.gg/9yY3uyJV) server. There we have dedicated channels regarding Sinabs and our hardware.
 
 If you don't have Discord, you can also start a discussion on [Github](https://github.com/synsense/sinabs/discussions)!

{sinabs-3.0.4.dev25 → sinabs-3.1.1}/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.0.4.dev25 → sinabs-3.1.1}/docs/getting_started/quickstart.ipynb

@@ -28,15 +28,9 @@
     "\n",
     "model = nn.Sequential(\n",
     "    nn.Linear(16, 64),\n",
-    "    sl.LIF(\n",
-    "        tau_mem=10.0,\n",
-    "        surrogate_grad_fn=sinabs.activation.SingleExponential()\n",
-    "    ),\n",
+    "    sl.LIF(tau_mem=10.0, surrogate_grad_fn=sinabs.activation.SingleExponential()),\n",
     "    nn.Linear(64, 4),\n",
-    "    sl.LIF(\n",
-    "        tau_mem=10.0,\n",
-    "        surrogate_grad_fn=sinabs.activation.SingleExponential()\n",
-    "    ),\n",
+    "    sl.LIF(tau_mem=10.0, surrogate_grad_fn=sinabs.activation.SingleExponential()),\n",
     ")"
    ]
   },

{sinabs-3.0.4.dev25 → sinabs-3.1.1}/docs/how_tos/activations.ipynb

@@ -258,7 +258,9 @@
     "x = torch.linspace(-0.5, 3.5, 500)\n",
     "plt.plot(x, sina.Heaviside(window=0.5)(v_mem=x, spike_threshold=1.0), label=\"Heaviside\")\n",
     "plt.plot(x, sina.MultiGaussian()(v_mem=x, spike_threshold=1.0), label=\"MultiGaussian\")\n",
-    "plt.plot(x, sina.SingleExponential()(v_mem=x, spike_threshold=1.0), label=\"SingleExponential\")\n",
+    "plt.plot(\n",
+    "    x, sina.SingleExponential()(v_mem=x, spike_threshold=1.0), label=\"SingleExponential\"\n",
+    ")\n",
     "\n",
     "plt.xlabel(\"Membrane potential v_mem\")\n",
     "plt.ylabel(\"derivative of output activation\")\n",

{sinabs-3.0.4.dev25 → sinabs-3.1.1}/docs/how_tos/custom_hooks.ipynb

@@ -27,6 +27,7 @@
     "from sinabs import layers as sl\n",
     "import sinabs.hooks\n",
     "\n",
+    "\n",
     "# - Define SNN\n",
     "class SNN(nn.Sequential):\n",
     "    def __init__(self, batch_size):\n",
@@ -46,6 +47,7 @@
     "            sl.UnflattenTime(batch_size=batch_size),\n",
     "        )\n",
     "\n",
+    "\n",
     "batch_size = 5\n",
     "snn = SNN(batch_size=batch_size)"
    ]
@@ -162,7 +164,7 @@
    ],
    "source": [
     "# Forward pass\n",
-    "rand_input_spikes = (torch.ones((batch_size, 10, 1, 28, 28)) ).float()\n",
+    "rand_input_spikes = (torch.ones((batch_size, 10, 1, 28, 28))).float()\n",
     "snn(rand_input_spikes)\n",
     "\n",
     "# Access and print hook data\n",
@@ -170,7 +172,9 @@
     "    if hasattr(layer, \"hook_data\"):\n",
     "        print(f\"Layer {idx}:\")\n",
     "        print(f\"\\tBatch size: {layer.hook_data['batch_size']}\")\n",
-    "        print(f\"\\tShape: {layer.hook_data['neuron_shape']} - {layer.hook_data['num_neurons']} neurons in total\")"
+    "        print(\n",
+    "            f\"\\tShape: {layer.hook_data['neuron_shape']} - {layer.hook_data['num_neurons']} neurons in total\"\n",
+    "        )"
    ]
   },
   {

{sinabs-3.0.4.dev25 → sinabs-3.1.1}/docs/how_tos/synops_loss_ann.ipynb

@@ -49,7 +49,9 @@
     "from torchvision import datasets, transforms\n",
     "\n",
     "to_tensor = transforms.ToTensor()\n",
-    "mnist_train = datasets.MNIST(\"../tutorials/data\", train=True, transform=lambda x: to_tensor(x)*255)\n",
+    "mnist_train = datasets.MNIST(\n",
+    "    \"../tutorials/data\", train=True, transform=lambda x: to_tensor(x) * 255\n",
+    ")\n",
     "train_loader = DataLoader(mnist_train, batch_size=512, shuffle=True, num_workers=4)"
    ]
   },
@@ -162,8 +164,14 @@
     "        output = ann(data)\n",
     "        optim.zero_grad()\n",
     "\n",
-    "        model_loss = nn.functional.cross_entropy(output, target) \n",
-    "        synops_loss = synops_loss_weight * nn.functional.mse_loss(ann.hook_data[\"total_synops_per_timestep\"], target_synops) / 1e7\n",
+    "        model_loss = nn.functional.cross_entropy(output, target)\n",
+    "        synops_loss = (\n",
+    "            synops_loss_weight\n",
+    "            * nn.functional.mse_loss(\n",
+    "                ann.hook_data[\"total_synops_per_timestep\"], target_synops\n",
+    "            )\n",
+    "            / 1e7\n",
+    "        )\n",
     "        loss = model_loss + synops_loss\n",
     "        loss.backward()\n",
     "        optim.step()\n",
@@ -197,14 +205,19 @@
    "source": [
     "import pandas as pd\n",
     "import seaborn as sns\n",
+    "\n",
     "sns.set(style=\"whitegrid\")\n",
     "\n",
-    "df = pd.DataFrame({\n",
-    "    'Loss type': ['Prediction'] * len(model_losses) + ['Synops'] * len(synops_losses),\n",
-    "    'Loss' : model_losses + synops_losses,\n",
-    "    'Training step' : list(range(len(model_losses))) + list(range(len(synops_losses)))\n",
-    "})\n",
-    "fig = sns.lineplot(data=df,  x='Training step', y='Loss', hue='Loss type')\n",
+    "df = pd.DataFrame(\n",
+    "    {\n",
+    "        \"Loss type\": [\"Prediction\"] * len(model_losses)\n",
+    "        + [\"Synops\"] * len(synops_losses),\n",
+    "        \"Loss\": model_losses + synops_losses,\n",
+    "        \"Training step\": list(range(len(model_losses)))\n",
+    "        + list(range(len(synops_losses))),\n",
+    "    }\n",
+    ")\n",
+    "fig = sns.lineplot(data=df, x=\"Training step\", y=\"Loss\", hue=\"Loss type\")\n",
     "fig.set_yscale(\"log\");"
    ]
   },
@@ -221,7 +234,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "mnist_test = datasets.MNIST(\"../tutorials/data\", train=False, transform=lambda x: to_tensor(x)*255)\n",
+    "mnist_test = datasets.MNIST(\n",
+    "    \"../tutorials/data\", train=False, transform=lambda x: to_tensor(x) * 255\n",
+    ")\n",
     "test_loader = DataLoader(mnist_test, batch_size=512, num_workers=4)"
    ]
   },
@@ -243,7 +258,8 @@
    ],
    "source": [
     "from torchmetrics.classification import MulticlassAccuracy\n",
-    "metric = MulticlassAccuracy(num_classes=10, average='micro').to(device)\n",
+    "\n",
+    "metric = MulticlassAccuracy(num_classes=10, average=\"micro\").to(device)\n",
     "\n",
     "accuracies = []\n",
     "for data, targets in iter(test_loader):\n",

{sinabs-3.0.4.dev25 → sinabs-3.1.1}/docs/how_tos/synops_loss_snn.ipynb

@@ -24,6 +24,7 @@
     "# Seed for reproducibility\n",
     "torch.manual_seed(1)\n",
     "\n",
+    "\n",
     "class SNN(nn.Sequential):\n",
     "    def __init__(self, batch_size):\n",
     "        super().__init__(\n",
@@ -42,6 +43,7 @@
     "            sl.UnflattenTime(batch_size=batch_size),\n",
     "        )\n",
     "\n",
+    "\n",
     "batch_size = 5\n",
     "snn = SNN(batch_size=batch_size)"
    ]
@@ -79,7 +81,7 @@
     "        layer.register_forward_hook(firing_rate_per_neuron_hook)\n",
     "\n",
     "# Forward pass to record the number of synaptic operations\n",
-    "rand_input_spikes = (torch.ones((batch_size, 10, 1, 28, 28)) ).float()\n",
+    "rand_input_spikes = (torch.ones((batch_size, 10, 1, 28, 28))).float()\n",
     "snn(rand_input_spikes)\n",
     "\n",
     "print(\"Synops after feeding input:\")\n",
@@ -112,7 +114,7 @@
    ],
    "source": [
     "print(\"Per layer:\")\n",
-    "for layer_idx, synops in snn.hook_data['synops_per_timestep'].items():\n",
+    "for layer_idx, synops in snn.hook_data[\"synops_per_timestep\"].items():\n",
     "    print(f\"- Layer {layer_idx}: {synops:.2e} SynOps per step\")"
    ]
   },
@@ -210,25 +212,28 @@
    "source": [
     "# Helper functions to calculate the SynOp loss for each layer\n",
     "\n",
+    "\n",
     "def get_synops_squared_error(synops, target_synops):\n",
-    "    \"\"\" SynOps loss term for individual layer:\n",
+    "    \"\"\"SynOps loss term for individual layer:\n",
     "    Squared error on anything above the target\n",
     "    \"\"\"\n",
     "    # Use ReLU so that only values above taret are punished\n",
     "    above_target = nn.functional.relu(synops - target_synops)\n",
     "    # Return squared error\n",
     "    return above_target**2\n",
-    "    \n",
+    "\n",
+    "\n",
     "def get_synops_loss(snn, target_synops):\n",
-    "    \"\"\" Sum of synop losses of individual layers\"\"\"\n",
+    "    \"\"\"Sum of synop losses of individual layers\"\"\"\n",
     "    loss = sum(\n",
     "        get_synops_squared_error(synops, target_synops)\n",
     "        for synops in snn.hook_data[\"synops_per_timestep\"].values()\n",
     "    )\n",
     "    return loss\n",
     "\n",
+    "\n",
     "def get_firing_rate_squared_error(firing_rates, target_rate):\n",
-    "    \"\"\" Firing rate loss term for individual layer:\n",
+    "    \"\"\"Firing rate loss term for individual layer:\n",
     "    Squared error on anything below the target\n",
     "    \"\"\"\n",
     "    # Use ReLU so that only values below target are punished\n",
@@ -236,11 +241,14 @@
     "    # Return sum of squared errors\n",
     "    return (below_target**2).sum()\n",
     "\n",
+    "\n",
     "def get_firing_rate_loss(snn, target_rate):\n",
-    "    \"\"\" Sum of firing rate losses of individual layers\"\"\"\n",
+    "    \"\"\"Sum of firing rate losses of individual layers\"\"\"\n",
     "    loss = sum(\n",
-    "        get_firing_rate_squared_error(layer.hook_data[\"firing_rate_per_neuron\"], target_rate)\n",
-    "        for layer in snn \n",
+    "        get_firing_rate_squared_error(\n",
+    "            layer.hook_data[\"firing_rate_per_neuron\"], target_rate\n",
+    "        )\n",
+    "        for layer in snn\n",
     "        if hasattr(layer, \"hook_data\") and \"firing_rate_per_neuron\" in layer.hook_data\n",
     "    )\n",
     "    return loss"
@@ -256,7 +264,7 @@
     "target_synops = 1e5\n",
     "target_firing_rate = 0.5\n",
     "synops_loss_weight = 0.01\n",
-    "rate_loss_weight = 1.\n",
+    "rate_loss_weight = 1.0\n",
     "\n",
     "optim = torch.optim.Adam(snn.parameters(), lr=1e-3)\n",
     "\n",
@@ -265,9 +273,9 @@
     "    sinabs.reset_states(snn)\n",
     "    sinabs.zero_grad(snn)\n",
     "    optim.zero_grad()\n",
-    "    \n",
+    "\n",
     "    snn(rand_input_spikes)\n",
-    "    \n",
+    "\n",
     "    synop_loss = synops_loss_weight * get_synops_loss(snn, target_synops)\n",
     "    firing_rate_loss = rate_loss_weight * get_firing_rate_loss(snn, target_firing_rate)\n",
     "    loss = synop_loss + firing_rate_loss\n",
@@ -302,7 +310,7 @@
     "\n",
     "for idx, synops in synops_per_layer.items():\n",
     "    ax.plot(synops, label=f\"Layer {idx}\")\n",
-    "ax.axhline(y=target_synops, color='black', label=\"Target synops\")\n",
+    "ax.axhline(y=target_synops, color=\"black\", label=\"Target synops\")\n",
     "ax.set_ylabel(\"Mean synaptic operations per step\")\n",
     "ax.legend()\n",
     "plt.title(\"SynOps during training\");"

{sinabs-3.0.4.dev25 → sinabs-3.1.1}/docs/speck/faqs/available_network_arch.md

@@ -39,25 +39,154 @@ dynapcnn.to(devcie="your device", chip_layers_ordering=[2, 5, 7, 1])
 
 ## What network structure can I define?
 
-Currently, `sinabs-dynapcnn` can only parse a `torch.nn.Sequential` like architecture. So it is recommended to
-use a `Sequential` like network. We are developing a network graph extraction feature at the present, which will
-help the user to deploy their networks with more complex architecture to the devkit.
+`Sinabs` can parse a `torch.nn.Sequential` like architecture, so it is recommended to
+use a `Sequential` like network.
 
+As of `v3.1.0`, we released a network graph extraction feature that helps users deploy their networks with more complex architectures into the devkit.
+Our `Speck` chip, in fact, supports branched architectures. With the graph extraction feature, we support a range of network structures, as shown below:
 
-## 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.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.
+Two independent networks:
+
+![Two independent networks](imgs/two-independent-networks.png)
+
+Two networks with merging outputs:
+
+![Two networks with merging outputs](imgs/two-networks-merging-output.png)
+
+A network with a merge and a split:
 
+![A network with a merge and a split](imgs/network-with-merge-and-split.png)
 
-## What If I Really Want to Use "Residual Connection"!
+
+Note: with the graph extracture feature it is possible to implement recurrent neural networks. However, this is not recommended or supported as it can result in deadlock on the chip.
+
+## How to make use of the graph extraction feature?
+
+For general architectures, users need to define their classes, by defining at least the `__init__` method with all the layers, as well as an appropriate `forward` method.
+
+Here is an example to define a network with a merge and a split:
+
+```python
+import torch.nn as nn
+
+from sinabs.activation.surrogate_gradient_fn import PeriodicExponential
+from sinabs.layers import IAFSqueeze, Merge, SumPool2d
+
+class SNN(nn.Module):
+    def __init__(self, batch_size) -> None:
+        super().__init__()
+
+        self.conv1 = nn.Conv2d(2, 1, 2, 1, bias=False)
+        self.iaf1 = IAFSqueeze(
+            batch_size=batch_size,
+            min_v_mem=-1.0,
+            spike_threshold=1.0,
+            surrogate_grad_fn=PeriodicExponential(),
+        )
+
+        self.conv2 = nn.Conv2d(1, 1, 2, 1, bias=False)
+        self.iaf2 = IAFSqueeze(
+            batch_size=batch_size,
+            min_v_mem=-1.0,
+            spike_threshold=1.0,
+            surrogate_grad_fn=PeriodicExponential(),
+        )
+        self.pool2 = SumPool2d(2, 2)
+
+        self.conv3 = nn.Conv2d(1, 1, 2, 1, bias=False)
+        self.iaf3 = IAFSqueeze(
+            batch_size=batch_size,
+            min_v_mem=-1.0,
+            spike_threshold=1.0,
+            surrogate_grad_fn=PeriodicExponential(),
+        )
+        self.pool3 = SumPool2d(2, 2)
+        self.pool3a = SumPool2d(5, 5)
+
+        self.conv4 = nn.Conv2d(1, 1, 2, 1, bias=False)
+        self.iaf4 = IAFSqueeze(
+            batch_size=batch_size,
+            min_v_mem=-1.0,
+            spike_threshold=1.0,
+            surrogate_grad_fn=PeriodicExponential(),
+        )
+        self.pool4 = SumPool2d(3, 3)
+
+        self.flat1 = nn.Flatten()
+        self.flat2 = nn.Flatten()
+
+        self.conv5 = nn.Conv2d(1, 1, 2, 1, bias=False)
+        self.iaf5 = IAFSqueeze(
+            batch_size=batch_size,
+            min_v_mem=-1.0,
+            spike_threshold=1.0,
+            surrogate_grad_fn=PeriodicExponential(),
+        )
+
+        self.fc2 = nn.Linear(25, 10, bias=False)
+        self.iaf2_fc = IAFSqueeze(
+            batch_size=batch_size,
+            min_v_mem=-1.0,
+            spike_threshold=1.0,
+            surrogate_grad_fn=PeriodicExponential(),
+        )
+
+        # -- merges --
+        self.merge1 = Merge()
+        self.merge2 = Merge()
+
+    def forward(self, x):
+        # conv 1 - A/0
+        con1_out = self.conv1(x)
+        iaf1_out = self.iaf1(con1_out)
+
+        # conv 2 - B/1
+        conv2_out = self.conv2(iaf1_out)
+        iaf2_out = self.iaf2(conv2_out)
+        pool2_out = self.pool2(iaf2_out)
+
+        # conv 3 - C/2
+        conv3_out = self.conv3(iaf1_out)
+        iaf3_out = self.iaf3(conv3_out)
+        pool3_out = self.pool3(iaf3_out)
+        pool3a_out = self.pool3a(iaf3_out)
+
+        # conv 4 - D/3
+        merge1_out = self.merge1(pool2_out, pool3_out)
+        conv4_out = self.conv4(merge1_out)
+        iaf4_out = self.iaf4(conv4_out)
+        pool4_out = self.pool4(iaf4_out)
+        flat1_out = self.flat1(pool4_out)
+
+        # conv 5 - E/4
+        conv5_out = self.conv5(pool3a_out)
+        iaf5_out = self.iaf5(conv5_out)
+        flat2_out = self.flat2(iaf5_out)
+
+        # fc 2 - F/5
+        merge2_out = self.merge2(flat2_out, flat1_out)
+
+        fc2_out = self.fc2(merge2_out)
+        iaf2_fc_out = self.iaf2_fc(fc2_out)
+
+        return iaf2_fc_out
+```
+
+## Can I achieve a "Residual Connection" like ResNet does?
+
+Like mentioned above, "Yes, we can define a residual short-cut on the devkit". You can manually
+change the `samna.speck2f.configuration.CNNLayerDestination.layer` to achieve this, if you are very
+familiar with the `samna-configuration`.
+You can also make use of our network graph extraction feature, to implement residual networks.
+
+## How to use "Residual Connection" manually?
 
 Alright! Here I will give an example of achieving the "Residual Connection" by manually modify the `samna-configuration`.
 
 Let's say you want an architecture like below:
 
+
 ```python
 from torch import nn
 from sinabs.layers import IAFSqueeze
@@ -92,7 +221,7 @@ class ResidualBlock(nn.Module):
 
 ```
 
-Since currently sinabs-dynapcnn can only parse Sequential like network, we need to some tedious work like below:
+Since currently Sinabs can only parse Sequential like network, we need to do some tedious work like below:
 
 ```python
 # define a Sequential first
@@ -136,7 +265,7 @@ devkit.get_model().apply_configuration(samna_cfg)
 ```
 
 I have to say it is not an elegant solution though, it should help you to achieve an initial Residual Block. We will
-improve this part after sinabs-dynapcnn has the ability for extracting model's graph.
+improve this part after Sinabs has the ability for extracting model's graph.
 
 ## What execution order should I be aware of when I am implementing a sequential structure?
 You should be aware with the internal layer order.

{sinabs-3.0.4.dev25 → sinabs-3.1.1}/docs/speck/faqs/device_management.md

@@ -54,7 +54,7 @@ import samna
 speck = samna.device.open_device("Speck2fModuleDevKit")
 ```
 
-All devices that supported by samna can be found at [here.](https://synsense-sys-int.gitlab.io/samna/install.html#discover-supported-devices)
+All devices that supported by samna can be found at [here.](https://synsense-sys-int.gitlab.io/samna/0.48.0/install.html#supported-devices)
 
 ## How Do I Reset The Device
 

{sinabs-3.0.4.dev25 → sinabs-3.1.1}/docs/speck/faqs/tips_for_training.md

@@ -104,7 +104,7 @@ for synops_per_layer, limit in zip(synops_of_every_layer, synops_upper_limit):
     synops_loss += torch.nn.functional.relu(residual)
 ```
 4. Switch on the 
-   ["decimator"](https://synsense-sys-int.gitlab.io/samna/reference/speck2e/configuration/index.html?highlight=decimation#samna.speck2e.configuration.CnnLayerConfig.output_decimator_enable)
+   ["decimator"](https://synsense-sys-int.gitlab.io/samna/0.48.0/reference/speck2e/configuration/index.html#samna.speck2e.configuration.CnnLayerConfig.output_decimator_enable)
    on your DynapCNN Core. In the devkit, each DynapCNN Core is equipped with a decimator block at its data path output.
    The decimator block enables the user to reduce the spike rate at the output of a DynapCNN Core. By default,
    the decimator is disabled, and the code below shows an example of enabling the decimator of the chip by modifying
@@ -126,7 +126,7 @@ samna_cfg.cnn_layers[layer_idx].output_decimator_enable = True
 samna_cfg.cnn_layers[layer_idx].output_decimator_interval = 0b001
 ```
 
-more details about the "decimator" can be found [here.](https://synsense-sys-int.gitlab.io/samna/reference/speck2f/configuration/index.html?highlight=output_decimator#samna.speck2f.configuration.CnnLayerConfig.output_decimator_interval)
+more details about the "decimator" can be found [here.](https://synsense-sys-int.gitlab.io/samna/0.48.0/reference/speck2e/configuration/index.html#samna.speck2e.configuration.CnnLayerConfig.output_decimator_interval)
 
 ## The Reset Mechanism Of Neuron Membrane Potential
 Our devkit provides two types of reset mechanism for the spiking neuron's membrane potential.
@@ -141,7 +141,7 @@ If you use an ANN-to-SNN conversion, then you should choose the second one strat
 If you train an SNN with a "reset to 0" strategy, then you should choose the first one strategy.
 
 The `samna configuration` for each layer has a boolean attribute called 
-["return_to_zero"](https://synsense-sys-int.gitlab.io/samna/reference/speck2f/configuration/index.html?highlight=return_to_zero#samna.speck2f.configuration.CnnLayerConfig.return_to_zero).
+["return_to_zero"](https://synsense-sys-int.gitlab.io/samna/0.48.0/reference/speck2e/configuration/index.html#samna.speck2e.configuration.CnnLayerConfig.return_to_zero).
 - If it is set to be `True`, then the hardware execute the first resetting strategy. 
 - If it is set to be `False`, the hardware execute the second strategy.
 

{sinabs-3.0.4.dev25 → sinabs-3.1.1}/docs/speck/notebooks/leak_neuron.ipynb

@@ -100,9 +100,11 @@
     "        ev = samna.speck2f.event.ReadNeuronValue()\n",
     "        ev.layer = 0\n",
     "        # output feature map size is the same as the input shape\n",
-    "        ev.address = calculate_neuron_address(x=x, y=y, c=0, feature_map_size=input_shape)\n",
+    "        ev.address = calculate_neuron_address(\n",
+    "            x=x, y=y, c=0, feature_map_size=input_shape\n",
+    "        )\n",
     "        input_events.append(ev)\n",
-    "        \n",
+    "\n",
     "input_events"
    ]
   },
@@ -223,9 +225,11 @@
    "source": [
     "# Deploy the snn to speck devkit\n",
     "\n",
-    "dynapcnn = DynapcnnNetwork(snn=snn, discretize=True, dvs_input=False, input_shape=input_shape)\n",
+    "dynapcnn = DynapcnnNetwork(\n",
+    "    snn=snn, discretize=True, dvs_input=False, input_shape=input_shape\n",
+    ")\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",
+    "# 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",
     "\n",
     "# Check if neuron states decrease along with time pass by\n",
@@ -236,7 +240,7 @@
     "    # write input\n",
     "    dynapcnn.samna_input_buffer.write(input_events)\n",
     "    time.sleep(0.5)\n",
-    "    print(f'----After {0.5 * iter_times} seconds:----')\n",
+    "    print(f\"----After {0.5 * iter_times} seconds:----\")\n",
     "    # get outputs\n",
     "    output_events = dynapcnn.samna_output_buffer.get_events()\n",
     "\n",
@@ -244,8 +248,7 @@
     "        c, x, y = neuron_address_to_cxy(out_ev.address, feature_map_size=input_shape)\n",
     "        pre_neuron_state = neuron_states.get((c, x, y), 127)\n",
     "        neuron_states.update({(c, x, y): out_ev.neuron_state})\n",
-    "        print(f\"c:{c}, x:{x}, y:{y}, vmem:{out_ev.neuron_state}\")\n",
-    "    "
+    "        print(f\"c:{c}, x:{x}, y:{y}, vmem:{out_ev.neuron_state}\")"
    ]
   },
   {