Rockpool

https://rockpool.ai/
Admin
Rockpool is a Python package for designing, training, and deploying event-driven spiking neural...
Tokens:1,348,677
Snippets:12,954
Trust Score:6.6
Update:6 months ago
Show doc for...
Tokens:
Raw
### Build Network Example

Source: https://rockpool.ai/advanced/QuantTorch.html

A basic Python snippet demonstrating how to start building a network for use.

```python
# - Build a network to use
```

--------------------------------

### Initialize Rockpool environment

Source: https://rockpool.ai/basics/sharp_points.html

Setup imports and configuration for Rockpool, including suppressing warnings and installing matplotlib.

```python
# - Switch off warnings
import warnings

warnings.filterwarnings("ignore")

# - Rockpool imports
from rockpool import TSContinuous

# - General imports and configuration
import numpy as np

import sys
!{sys.executable} -m pip install --quiet matplotlib
import matplotlib.pyplot as plt

%matplotlib inline
plt.rcParams["figure.figsize"] = [12, 4]
plt.rcParams["figure.dpi"] = 300
```

--------------------------------

### Tutorials and Examples

Source: https://rockpool.ai/reference/api.html

A collection of tutorials and examples demonstrating various Rockpool functionalities, from basic introductions to advanced training techniques.

```APIDOC
## Tutorials and Examples

### Description
This section provides a curated list of tutorials and examples that showcase the capabilities of Rockpool AI, ranging from introductory concepts to advanced applications in neural network training and data processing.

### Introductory Tutorials
- **A simple introduction to spiking neurons**: Basic concepts of spiking neurons.
- **Introduction to Rockpool**: Getting started with the Rockpool library.
- **👋 Hello MNIST with Rockpool**: A beginner-friendly example using the MNIST dataset.
- **Working with time series data**: Techniques for handling temporal data.

### Advanced Training Tutorials
- **∇ Gradient descent training of a rate-based recurrent network**: Training rate-based networks.
- **⚡️ Training a spiking network with Jax**: Using Jax for spiking network training.
- **⚡️ Training a spiking network with Torch**: Using PyTorch for spiking network training.
- **👩🏽‍🔬 Advanced Jax training topics**: In-depth Jax training techniques.
- **👩🏼‍🚒 Training a Rockpool network with Torch**: Advanced PyTorch training.
- **🔊 Training an audio classification task using Torch 🔥**: Audio classification example.
- **WaveSense: Training a Spiking Neural Network with Temporal Convolutions**: Specific architecture training.
- **The SynNet architecture**: Tutorials on the SynNet architecture.

### Specific Applications and Techniques
- **👹 Adversarial training**: Techniques for adversarial attacks and defenses.
- **🐰 Easter with Rockpool 🥚**: Fun or specialized examples.
- **How To: Configure and perform constrained optimization in Rockpool**: Optimization techniques.

### Xylo™ Specific Tutorials
- **🐝🎵 Introduction to Xylo™Audio**: Getting started with Xylo™Audio.
- **🐝⚡️ Quick-start with Xylo™ SNN core**: Rapid deployment on Xylo™ SNN core.
- **🐝⚡️ Quick start with Xylo™Audio 3**: Getting started with Xylo™Audio 3.
```

--------------------------------

### Setup Training Loop Components

Source: https://rockpool.ai/tutorials/torch-training-spiking.html

Initializes the network, optimizer (Adam), and loss function (MSELoss) for training. Includes setup for recording loss values.

```python
# - Useful imports
from tqdm.autonotebook import tqdm
from torch.optim import Adam, SGD
from torch.nn import MSELoss

net = SimpleNet(Nin, Nhidden, Nout)

# - Get the optimiser functions
optimizer = Adam(net.parameters().astorch(), lr=1e-4)

# - Loss function
loss_fun = MSELoss()

# - Record the loss values over training iterations
loss_t = []

num_epochs = 10000
```

--------------------------------

### Setup Rockpool with Torch and Matplotlib

Source: https://rockpool.ai/in-depth/torch-training.html

Initializes the environment for training with Torch and Rockpool, including suppressing warnings and configuring plotting. Installs matplotlib if not already present.

```python
# - Switch off warnings
import warnings

warnings.filterwarnings("ignore")

# - Rich printing
try:
    from rich import print
except:
    pass

# - Import and configure matplotlib for plotting
import sys
!{sys.executable} -m pip install --quiet matplotlib
import matplotlib.pyplot as plt

%matplotlib inline
plt.rcParams["figure.figsize"] = [12, 4]
plt.rcParams["figure.dpi"] = 300

```

--------------------------------

### Install Rockpool in Development Mode with All Extras

Source: https://rockpool.ai/_sources/basics/installation.rst.txt

Install the Rockpool package in development mode with all optional dependencies included, for the current user.

```bash
$ pip install -e ".[all]" --user
```

--------------------------------

### Basic Rockpool Module Example

Source: https://rockpool.ai/_modules/nn/combinators/residual.html

Demonstrates the creation and usage of a simple Rockpool module. This serves as a fundamental example for understanding Rockpool's module system.

```python
import rockpool as rp
import jax.numpy as jnp

# Define a simple neuron model
class SimpleNeuron(rp.Module):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.add_input("input", jnp.float32)
        self.add_output("output", jnp.float32)

    def forward(self, input):
        return input * 2.0

# Instantiate the module
neuron = SimpleNeuron()

# Prepare input data
input_data = jnp.array([1.0, 2.0, 3.0])

# Run the module
output_data = neuron(input=input_data)

print(output_data)
```

--------------------------------

### Install Rockpool with All Optional Dependencies

Source: https://rockpool.ai/_sources/basics/installation.rst.txt

Use this command to automatically install all extra dependencies required by Rockpool.

```bash
$ pip install "rockpool[all]"
```

--------------------------------

### LinearTorch Example 2

Source: https://rockpool.ai/reference/_autosummary/nn.modules.LinearTorch.html

Example demonstrating LinearTorch initialization without bias and accessing parameters.

```APIDOC
### Example 2

```python
>>> m = LinearTorch((2, 3), has_bias = False)
>>> m.parameters()
{'weight': tensor([[ 0.6433, -0.7139, -0.2954],
 [ 0.9858,  0.3872,  0.6614]])}
```
```

--------------------------------

### Install optional dependencies

Source: https://rockpool.ai/basics/installation.html

Install specific backend dependencies or all available extras using pip extras syntax.

```bash
$ pip install "rockpool[numba, jax, torch, brian, sinabs, exodus, xylo, dynapse, tests, docs]"
```

```bash
$ pip install "rockpool[all]"
```

--------------------------------

### DYNAP-SE2 Quick Start

Source: https://rockpool.ai/reference/_autosummary/utilities.jax_tree_utils.html

A quick-start guide for using the DYNAP-SE2 mixed-signal processor, focusing on initial setup and basic functionality.

```APIDOC
## Quick Start with Dynap-SE2

### Description
This guide helps users quickly begin working with the DYNAP-SE2 mixed-signal processor. It covers the essential steps for setting up the hardware and running initial experiments.

### Method
GET

### Endpoint
`/dynap-se2/quickstart`

### Parameters
#### Query Parameters
- **`board_type`** (string) - Optional - Specifies the type of DYNAP-SE2 board being used.

### Response
#### Success Response (200)
- **`message`** (string) - A confirmation message indicating successful setup.
- **`status`** (string) - The status of the quick start process.
```

--------------------------------

### Initialize environment and imports

Source: https://rockpool.ai/tutorials/easter/easter-snn-images.html

Sets up the necessary libraries, JAX configuration, and plotting parameters for the tutorial.

```python
# - Switch off warnings
import warnings

warnings.filterwarnings("ignore")

# - Imports
from rockpool import TSEvent, TSContinuous

import numpy as np
from tqdm.autonotebook import trange

try:
    from rich import print
except:
    pass

import jax
from jax import config

config.update("jax_enable_x64", True)

import matplotlib.pyplot as plt

%matplotlib inline
plt.rcParams["figure.figsize"] = [12, 4]
plt.rcParams["figure.dpi"] = 300
```

--------------------------------

### Xylo™Audio 3 Quick Start

Source: https://rockpool.ai/reference/_autosummary/utilities.jax_tree_utils.html

A quick-start guide for using Xylo™Audio 3, focusing on rapid deployment and initial setup.

```APIDOC
## 🐝⚡️ Quick start with Xylo™Audio 3

### Description
This guide provides a streamlined approach to getting started with Xylo™Audio 3, enabling users to quickly set up and run audio processing tasks on the platform.

### Steps
1. **Setup**: Install necessary drivers and software.
2. **Configuration**: Configure the audio frontend and processing pipeline.
3. **Deployment**: Load and run a pre-trained or custom model.
4. **Testing**: Verify audio processing results.
```

--------------------------------

### Initialize environment and imports

Source: https://rockpool.ai/devices/torch-training-spiking-for-xylo.html

Setup necessary libraries including Rockpool, Numpy, Matplotlib, and Rich for the training environment.

```python
# -- Some useful imports

# - Time-series data
from rockpool import TSContinuous, TSEvent

# - Rich printing
try:
    from rich import print
except:
    pass

# - Numpy
import numpy as np

# - Import and configure matplotlib for plotting
import sys
!{sys.executable} -m pip install --quiet matplotlib
import matplotlib.pyplot as plt

%matplotlib inline
plt.rcParams["figure.figsize"] = [12, 4]
plt.rcParams["figure.dpi"] = 300
```

--------------------------------

### Install Rockpool and Dependencies

Source: https://rockpool.ai/devices/xylo-imu/xylo-imu-intro.html

Installs Rockpool with Xylo and Torch support, along with matplotlib and rich for visualization and enhanced printing. This is a general setup for the environment.

```python
# - General installation and imports
import sys
!{sys.executable} -m pip install --quiet matplotlib rich "rockpool[xylo, torch]"
```

```python
# - Import numpy
import numpy as np
```

```python
# - Configure matplotlib
import matplotlib.pyplot as plt
%matplotlib inline
plt.rcParams['figure.figsize'] = [12, 4]
plt.rcParams['figure.dpi'] = 300
```

```python
# - Display images
from IPython.display import Image
```

```python
import warnings
warnings.filterwarnings('ignore')
```

```python
# - Nice printing
from rich import print
```

--------------------------------

### Initialize Linear Modules

Source: https://rockpool.ai/_modules/nn/modules/native/linear.html

Examples demonstrating how to instantiate Linear modules with different shapes, initialization functions, and bias configurations.

```python
>>> Linear((3, 4))
Linear  with shape (3, 4)
```

```python
>>> Linear((2, 5), weight_init_func = lambda s: np.zeros(s))
Linear  with shape (2, 5)
```

```python
>>> Linear((2, 2), weight = np.array([[1, 2], [3, 4]]))
Linear  with shape (2, 2)
```

```python
>>> mod = Linear((2, 2), has_bias = True)
>>> mod.parameters()
Out:
{'weight': array([[ 0.56655314,  0.64411151],
        [-1.43016068, -1.538719  ]]),
 'bias': array([-0.58513867, -0.32314069])}
```

--------------------------------

### Get Module Parameters by Family

Source: https://rockpool.ai/reference/_autosummary/devices.xylo.syns61201.XyloSamna.html

Use this method to inspect parameters from a specific family within this module and its submodules. For example, 'weights' to get all weights.

```python
mod.parameters("weights")
```

--------------------------------

### Prepare Activity Transformation Configuration

Source: https://rockpool.ai/advanced/QuantTorch.html

Prepare a configuration tree for patching a network with activity transformations. This example demonstrates setting up for 8-bit signed integer rounding using `deterministic_rounding`.

```python
# - Build a null configuration tree, which can be manipulated directly
tt.make_act_T_config(net)

# - Specify a transformation function as a lambda
T_fn = lambda p: tt.deterministic_rounding(
    p, output_range=[-128, 127], num_levels=2**8
)
```

--------------------------------

### Rockpool AI Core Concepts

Source: https://rockpool.ai/reference/_autosummary/devices.xylo.syns61201.XyloSamna.html

Overview of fundamental concepts and getting started with Rockpool AI.

```APIDOC
## Rockpool AI Core Concepts

### Description
This section covers the basics of Rockpool AI, including installation, contributing, and introductory concepts for spiking neurons and time series data.

### Topics
- Installing Rockpool and contributing
- A simple introduction to spiking neurons
- Introduction to Rockpool
- Working with time series data
- Standard modules
- The sharp points of Rockpool
```

--------------------------------

### GET /torch/version-check

Source: https://rockpool.ai/_modules/utilities/backend_management.html

Verifies if the installed PyTorch version meets the specified minimum version requirements.

```APIDOC
## GET /torch/version-check

### Description
Checks if the installed version of torch satisfies a minimum version requirement.

### Method
GET

### Endpoint
/torch/version-check

### Parameters
#### Query Parameters
- **req_major** (int) - Optional - The minimum major version required
- **req_minor** (int) - Optional - The minimum minor version required
- **req_patch** (int) - Optional - The minimum patch version required

### Response
#### Success Response (200)
- **result** (bool) - True if the installed version of torch satisfies the minimum version requirement, otherwise False
```

--------------------------------

### Initialize Training Loop Components

Source: https://rockpool.ai/devices/torch-training-spiking-for-xylo.html

Sets up the optimizer, loss function, and training progress tracker.

```python
# - Useful imports
from tqdm.autonotebook import tqdm
from torch.optim import Adam, SGD
from torch.nn import MSELoss

# - Get the optimiser functions
optimizer = Adam(net.parameters().astorch(), lr=1e-2)

# - Loss function
loss_fun = MSELoss()

# - Record the loss values over training iterations
loss_t = []

num_epochs = 1000
iterator = tqdm(range(num_epochs))
```

--------------------------------

### Build Documentation Locally

Source: https://rockpool.ai/_sources/basics/installation.rst.txt

Navigate to the docs directory and run 'make clean html' to build a local, live-hosted HTML version of the documentation.

```bash
$ cd docs
$ make clean html
```

--------------------------------

### Get Current Timestamp

Source: https://rockpool.ai/_modules/devices/xylo/syns61201/xylo_samna.html

Retrieves the current timestamp from the HDK, used to establish the start and end times for simulation events.

```python
start_timestep = hdkutils.get_current_timestamp(
            self._read_buffer, self._write_buffer
        )
```

--------------------------------

### Initialize DynapSimCore from Hardware Configuration

Source: https://rockpool.ai/_modules/devices/dynapse/parameters/translation/core.html

Example of creating a simulation core instance from a specific chip core configuration.

```python
simcore = DynapSimCore.from_Dynapse2Core(config.chips[0].cores[0])
Itau_ampa = simcore.Itau_ampa
```

--------------------------------

### Xylo™Audio 3 Support

Source: https://rockpool.ai/reference/_autosummary/devices.xylo.syns61201.XyloSamna.html

Guides and information for using Xylo™Audio 3 with Rockpool AI, including quick starts and operational details.

```APIDOC
## Xylo™Audio 3 Support

### Description
This section covers the integration and usage of Xylo™Audio 3 with Rockpool AI, including quick start guides, operation types, and specific components like AFESim, XyloSamna, and XyloMonitor.

### Topics
- Quick start with Xylo™Audio 3
- Operation types of XyloAudio 3
- Using AFESim as an audio transform
- Using XyloSamna and XyloMonitor to deploy a model on XyloAudio 3 HDK
- Bandpass Filtering In Audio Front End (AFE) Of Xylo™Audio 3
```

--------------------------------

### Rockpool Core Concepts and Tutorials

Source: https://rockpool.ai/reference/_autosummary/nn.modules.Rate.html

Introduction to Rockpool, installation, basic concepts like spiking neurons and time series data, and various tutorials.

```APIDOC
## Installing Rockpool and contributing

### Description
Instructions for installing Rockpool and guidelines for contributing to the project.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## A simple introduction to spiking neurons

### Description
A basic explanation of spiking neurons and their role in Rockpool.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## Introduction to Rockpool

### Description
A general introduction to the Rockpool library and its purpose.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## 👋 Hello MNIST with Rockpool

### Description
A tutorial demonstrating how to use Rockpool with the MNIST dataset.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## Working with time series data

### Description
Guidance on how to handle and process time series data using Rockpool.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## Standard modules

### Description
An overview of the standard modules available within the Rockpool library.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## 🐡 The sharp points of Rockpool 🐚

### Description
Exploration of specific or advanced features within Rockpool.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## 🛠 Low-level `Module` API

### Description
Documentation for the low-level API related to `Module` objects in Rockpool.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## ⏱ High-level `TimedModule` API

### Description
Documentation for the high-level API related to `TimedModule` objects in Rockpool.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## [𝝺] Low-level functional API

### Description
Details on the low-level functional API available in Rockpool.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## 🏃🏽‍♀️ Training a Rockpool network with Jax

### Description
Tutorial on training a Rockpool network using the Jax library.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## 👩🏽‍🔬 Advanced Jax training topics

### Description
Advanced topics related to training Rockpool networks with Jax.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## 🔥 Building Rockpool modules with Torch

### Description
Tutorial on building Rockpool modules using the PyTorch library.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## 👩🏼‍🚒 Training a Rockpool network with Torch

### Description
Tutorial on training a Rockpool network using the PyTorch library.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## How To: Configure and perform constrained optimization in Rockpool

### Description
A guide on how to configure and perform constrained optimization within Rockpool.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## ∇ Gradient descent training of a rate-based recurrent network

### Description
Tutorial on using gradient descent to train a rate-based recurrent network in Rockpool.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## ⚡️ Training a spiking network with Jax

### Description
Tutorial on training a spiking neural network using Rockpool and Jax.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## ⚡️ Training a spiking network with Torch

### Description
Tutorial on training a spiking neural network using Rockpool and PyTorch.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## 🐰 Easter with Rockpool 🥚

### Description
A fun or thematic tutorial related to Rockpool.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## 👹 Adversarial training

### Description
Details on performing adversarial training with Rockpool.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## 🔊 Training an audio classification task using Torch 🔥

### Description
Tutorial on training an audio classification task using Rockpool and PyTorch.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## WaveSense: Training a Spiking Neural Network with Temporal Convolutions

### Description
Tutorial on training a Spiking Neural Network for the WaveSense task using Temporal Convolutions in Rockpool.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## The SynNet architecture

### Description
Explanation of the SynNet architecture within the context of Rockpool.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A
```

--------------------------------

### DYNAP-SE2 Mixed-Signal Processor

Source: https://rockpool.ai/_modules/devices/dynapse/dynapsim_net/from_config/getter.html

Documentation for the DYNAP-SE2 mixed-signal processor, including quick start guides, neuron models, and deployment information.

```APIDOC
## Overview of Dynap-SE2

### Description
A general overview of the Dynap-SE2 mixed-signal processor.

### Method
N/A

### Endpoint
N/A

## Quick Start with Dynap-SE2

### Description
A quick-start guide for using the Dynap-SE2 processor.

### Method
N/A

### Endpoint
N/A

## DynapSim Neuron Model

### Description
Details on the DynapSim neuron model used with the Dynap-SE2 processor.

### Method
N/A

### Endpoint
N/A

## Training a Spiking Network to Deploy to Dynap-SE2

### Description
Instructions for training a spiking network intended for deployment on the Dynap-SE2 processor.

### Method
N/A

### Endpoint
N/A
```

--------------------------------

### Iterate Over Module Buffers

Source: https://rockpool.ai/reference/_autosummary/nn.modules.LIFExodus.html

Use the `buffers` method to get an iterator over the module's buffers. This example prints the type and size of each buffer.

```python
>>> # xdoctest: +SKIP("undefined vars")
>>> for buf in model.buffers():
>>>     print(type(buf), buf.size())
<class 'torch.Tensor'> (20L,)
<class 'torch.Tensor'> (20L, 1L, 5L, 5L)

```

--------------------------------

### LinearTorch Example: Provide Concrete Initial Weights

Source: https://rockpool.ai/_modules/nn/modules/torch/linear_torch.html

Illustrates initializing a LinearTorch layer with a pre-defined weight matrix.

```python
Linear((2, 2), weight = np.array([[1, 2], [3, 4]]))
```

--------------------------------

### Setup Training Loop

Source: https://rockpool.ai/in-depth/torch-training.html

Sets up the optimizer (Adam), loss function (MSELoss), and initializes a list to record loss values over training iterations.

```python
# - Useful imports
from tqdm.autonotebook import tqdm
from torch.optim import Adam, SGD
from torch.nn import MSELoss

# - Get the optimiser functions
optimizer = Adam(net.parameters().astorch(), lr=1e-4)

# - Loss function
loss_fun = MSELoss()

# - Record the loss values over training iterations
loss_t = []

num_epochs = 3000
```

--------------------------------

### Xylo™Audio 3 Support

Source: https://rockpool.ai/reference/_autosummary/devices.xylo.syns61201.XyloMonitor.html

Documentation for Xylo™Audio 3, including quick start guides, operation types, and deployment using XyloSamna and XyloMonitor.

```APIDOC
## Xylo™Audio 3 Support

### Description
This section provides comprehensive documentation for Xylo™Audio 3, covering quick start guides, operational types, and deployment procedures using tools like XyloSamna and XyloMonitor.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

--------------------------------

### Example benchmark output

Source: https://rockpool.ai/reference/lif-benchmarks.html

Sample output showing system configuration and hardware availability during a benchmark run.

```text
Benchmarks run on rockpool version 2.6.dev, on date 2023-04-12 11:50:19.475143.
Python version 3.8.13 (default, Oct 21 2022, 23:50:54)
[GCC 11.2.0]
System descriptor: Linux 5.15.0-69-generic x86_64
Jax devices: [StreamExecutorGpuDevice(id=0, process_index=0, slice_index=0)]
Torch CUDA available: True
    Number of devices: 1
    CUDA devices: ['NVIDIA GeForce RTX 3090 Ti']
```

--------------------------------

### Simulate to Device Workflow

Source: https://rockpool.ai/devices/DynapSE/developer.html

Demonstrates the process of defining a network, mapping it to hardware specifications, and deploying it to a Dynap-SE2 chip.

```python
# Define
net = Sequential(LinearJax((Nin, Nrec)), DynapSim((Nrec, Nrec)))

# Map
spec = mapper(net.as_graph())
spec.update(autoencoder_quantization(**spec))
config = config_from_specification(**spec)

# Connect
se2_devices = find_dynapse_boards()
se2 = DynapseSamna(se2_devices[0], **config)
out, state, rec = se2(raster, record=True)
```

--------------------------------

### Get Submodule Example

Source: https://rockpool.ai/reference/_autosummary/nn.modules.aLIFTorch.html

Use `get_submodule` to efficiently retrieve a specific submodule by its fully-qualified string name. This is faster than querying `named_modules` for simple existence checks.

```python
A(
    (net_b): Module(
        (net_c): Module(
            (conv): Conv2d(16, 33, kernel_size=(3, 3), stride=(2, 2))
        )
        (linear): Linear(in_features=100, out_features=200, bias=True)
    )
)


```

```python
get_submodule("net_b.linear")

```

```python
get_submodule("net_b.net_c.conv")

```

--------------------------------

### Constructing and Manipulating Sequential Modules

Source: https://rockpool.ai/reference/_autosummary/nn.combinators.Sequential.html

Examples demonstrating how to initialize a Sequential stack, access internal modules via indexing, use OrderedDict for naming, and append modules dynamically.

```python
>>> Sequential(mod0, mod1, mod2)
```

```python
>>> mod = Sequential(mod0, mod1, mod2)
>>> mod[0]
A module with shape (xx, xx)
```

```python
>>> od = OrderedDict([('mod0', mod0), ('mod1', mod1)])
>>> seq = Sequential(od)
```

```python
>>> seq = Sequential()
>>> seq.append(mod0)
>>> seq.append(mod1, 'mod1)
```

--------------------------------

### Import Libraries and Setup Plotting

Source: https://rockpool.ai/basics/introduction_to_snns.html

Imports necessary libraries like numpy and matplotlib, and configures plotting parameters for better visualization. Installs matplotlib if not already present.

```python
# - Import some useful packages
import numpy as np

import sys
!{sys.executable} -m pip install --quiet matplotlib
import matplotlib.pyplot as plt

%matplotlib inline
plt.rcParams["figure.figsize"] = [12, 4]
plt.rcParams["figure.dpi"] = 300

```

--------------------------------

### Get Layer Start Print String

Source: https://rockpool.ai/_modules/nn/layers/layer.html

Returns a formatted string containing the layer's subclass name and its specific name attribute. Useful for logging and debugging.

```python
return f"{self.class_name} '{self.name}': "
```

--------------------------------

### SynNet Training Loop Setup

Source: https://rockpool.ai/tutorials/synnet/synnet_architecture.html

This code snippet sets up basic parameters for a toy training loop for SynNet, including the number of epochs, batch size, time steps, input channels, and output classes.

```python
n_epochs = 10
n_batch = 1
n_time = 100
n_channels = 4
n_classes = 1


```

--------------------------------

### Instantiate Rate modules

Source: https://rockpool.ai/reference/_autosummary/nn.modules.Rate.html

Examples of initializing Rate modules with different configurations, including feed-forward, recurrent, and custom time constant settings.

```python
>>> mod = Rate(8,)
RateEulerJax 'None' with shape (8,)
```

```python
>>> mod_rec = Rate(12, has_rec = True)
RateEulerJax 'None' with shape (12,)
```

```python
>>> mod = Rate(7, tau = np.arange(7,) * 10e-3)
RateEulerJax 'None' with shape (7,)
```

--------------------------------

### Xylo™Audio 2 and 3

Source: https://rockpool.ai/reference/_autosummary/graph.GraphModule.html

Documentation for Xylo™Audio 2 and 3, covering usage of the analog frontend model, quick start guides, operation types, and deployment on hardware.

```APIDOC
## Xylo™Audio 2

### Description
Documentation for the Xylo™Audio 2 system.

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## Using the analog frontend model

### Description
Guide on utilizing the analog frontend model within Xylo™Audio 2.

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## Xylo™Audio 3

### Description
Documentation for the Xylo™Audio 3 system.

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## Quick start with Xylo™Audio 3

### Description
A quick-start guide for Xylo™Audio 3.

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## Operation types of XyloAudio 3

### Description
Details the different operation types supported by XyloAudio 3.

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## Using AFESim as an audio transform

### Description
Instructions on using AFESim for audio transformations within Xylo™Audio 3.

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## Using XyloSamna and XyloMonitor to deploy a model on XyloAudio 3 HDK

### Description
Guide for deploying models on the XyloAudio 3 HDK using XyloSamna and XyloMonitor.

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## Bandpass Filtering In Audio Front End (AFE) Of Xylo™Audio 3

### Description
Details on implementing bandpass filtering in the Audio Front End (AFE) of Xylo™Audio 3.

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A
```

--------------------------------

### Build a template configuration

Source: https://rockpool.ai/in-depth/howto-constrained-opt.html

Initializes parameter bounds for a network.

```python
lb, ub = make_bounds(net.parameters())
print(lb, ub)
```

--------------------------------

### Configure a Spiking Neural Network (SNN)

Source: https://rockpool.ai/devices/DynapSE/neuron-model.html

Configure an SNN using Rockpool's Sequential model with LinearJax and DynapSim layers. Refer to 'Getting Started with Rockpool' for network configuration details.

```python
model = Sequential(
    LinearJax(shape=(1, 1), weight=np.array([0.1]), has_bias=False),
    DynapSim((1, 1), has_rec=False),
)
model
```

--------------------------------

### Rockpool Tutorials

Source: https://rockpool.ai/_modules/devices/dynapse/dynapsim_net/from_config/getter.html

A collection of tutorials covering various aspects of Rockpool, from gradient descent to specific tasks like audio classification.

```APIDOC
## Gradient Descent Training of a Rate-Based Recurrent Network

### Description
Tutorial on using gradient descent to train rate-based recurrent neural networks in Rockpool.

### Method
N/A

### Endpoint
N/A

## Training a Spiking Network with Jax

### Description
Tutorial demonstrating how to train spiking neural networks using Jax with Rockpool.

### Method
N/A

### Endpoint
N/A

## Training a Spiking Network with Torch

### Description
Tutorial covering the process of training spiking neural networks using Torch with Rockpool.

### Method
N/A

### Endpoint
N/A

## Training an Audio Classification Task using Torch

### Description
Tutorial focused on training an audio classification model using Torch within the Rockpool framework.

### Method
N/A

### Endpoint
N/A

## WaveSense: Training a Spiking Neural Network with Temporal Convolutions

### Description
Tutorial on the WaveSense architecture, detailing the training of SNNs with temporal convolutions in Rockpool.

### Method
N/A

### Endpoint
N/A

## The SynNet Architecture

### Description
An explanation and tutorial on utilizing the SynNet architecture within Rockpool.

### Method
N/A

### Endpoint
N/A
```

--------------------------------

### Import SHD Dataset and Setup DataLoader with Tonic

Source: https://rockpool.ai/tutorials/rockpool-shd.html

Imports necessary libraries for data loading and transformation. Downloads and prepares the SHD dataset using Tonic, configuring a DataLoader for training. Ensure Tonic is installed before running.

```python
# - Imports for loading data
import tonic
from tonic import datasets, transforms
from torch.utils.data import DataLoader
import numpy as np
import torch

from rockpool.timeseries import TSEvent

try:
    from rich import print
except ModuleNotFoundError:
    pass

import sys
!{sys.executable} -m pip install --quiet matplotlib
import matplotlib.pyplot as plt
plt.rcParams['figure.figsize'] = [12, 6]

download_dir='./data'

# - Download and import the training data. The transform ensures the data has a floating type
train_data = datasets.SHD(download_dir, train=True, transform=transforms.NumpyAsType(float))

train_dl = iter(DataLoader(train_data, drop_last=True, shuffle=False))

```

--------------------------------

### LinearTorch Example: Build with Shape (2, 5) and Zero Initialization

Source: https://rockpool.ai/_modules/nn/modules/torch/linear_torch.html

Demonstrates building a linear weight matrix with a shape of (2, 5) and initializing weights to zeros using a custom `weight_init_func`.

```python
Linear((2, 5), weight_init_func = lambda s: np.zeros(s))
```

--------------------------------

### Install Rockpool and Dependencies

Source: https://rockpool.ai/devices/quick-xylo/deploy_to_xylo.html

Installs Rockpool and its dependencies, including Matplotlib for plotting. Ensure you have Python and pip installed.

```python
# - Numpy
import numpy as np

# - Matplotlib
import sys
!{sys.executable} -m pip install --quiet matplotlib
import matplotlib.pyplot as plt
%matplotlib inline
plt.rcParams['figure.figsize'] = [12, 4]
plt.rcParams['figure.dpi'] = 300

# - Rockpool time-series handling
from rockpool import TSEvent, TSContinuous

# - Pretty printing
try:
    from rich import print
except:
    pass

# - Display images
from IPython.display import Image

# - Disable warnings
import warnings
warnings.filterwarnings('ignore')

```

--------------------------------

### Build a simple network

Source: https://rockpool.ai/_sources/advanced/nir_export_import.ipynb.txt

Example of constructing a sequential network using Rockpool modules.

```python
# - Import modules to build a simple network
from rockpool.nn.modules import LIFTorch, LinearTorch
from rockpool.nn.combinators import Sequential

try:
    from rich import print
except:
    pass

net = Sequential(
    LinearTorch((1, 2)),
    LIFTorch(2),
    LinearTorch((2, 4)),
    LIFTorch(4),
)
print(net)
```

--------------------------------

### Install Matplotlib Quietly

Source: https://rockpool.ai/devices/DynapSE/jax-training.html

Installs the matplotlib library using pip. The --quiet flag suppresses output during installation.

```python
import sys
!{sys.executable} -m pip install --quiet matplotlib
```

--------------------------------

### Install Rockpool in Development Mode

Source: https://rockpool.ai/_sources/basics/installation.rst.txt

Install the Rockpool package in development mode using pip after cloning the repository. This command installs the package for the current user.

```bash
$ cd rockpool
$ pip install -e . --user
```

--------------------------------

### Device to Simulation Workflow

Source: https://rockpool.ai/devices/DynapSE/developer.html

Shows how to reconstruct a simulation network from an existing hardware configuration.

```python
net = dynapsim_net_from_config(**config)
out, state, rec = net(raster, record=True)
```

--------------------------------

### Instantiate and use LIFExodus module

Source: https://rockpool.ai/_modules/nn/modules/sinabs/lif_exodus.html

Examples showing how to initialize the LIFExodus module with different configurations and execute a forward pass on a CUDA device.

```python
>>> mod = LIFExodus((4, 2))
```

```python
>>> mod = LIFExodus((4, 2), tau_mem = 30e-3, tau_syn = 10e-3, dt = 10e-3)
```

```python
>>> data = torch.ones((1, 10, 4))
>>> device = 'cuda: 1'
>>> mod.to(device)
>>> data = data.to(device)
>>> output = mod(data)
```

--------------------------------

### Install Rockpool with Optional Dependencies

Source: https://rockpool.ai/_sources/basics/installation.rst.txt

Install Rockpool with specific optional dependencies for features like numba, jax, torch, etc. This command installs dependencies for running tests.

```bash
$ pip install "rockpool[numba, jax, torch, brian, sinabs, exodus, xylo, dynapse, tests, docs]"
```

--------------------------------

### Rockpool Tutorials

Source: https://rockpool.ai/reference/_autosummary/nn.modules.LIF.html

A collection of tutorials covering various aspects of Rockpool, from basic introductions to advanced training techniques with Jax and Torch.

```APIDOC
## Rockpool Tutorials

### Description
This section contains tutorials for learning and utilizing Rockpool, including gradient descent, spiking network training with Jax and Torch, and specific applications like audio classification.

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A
```

--------------------------------

### Install NIR dependencies

Source: https://rockpool.ai/_sources/advanced/nir_export_import.ipynb.txt

Command to install the necessary dependencies for NIR support in Rockpool.

```bash
pip install 'rockpool[nir]'
```

--------------------------------

### Install Rockpool using conda

Source: https://rockpool.ai/_sources/basics/installation.rst.txt

Install Rockpool from the conda-forge channel using this command.

```bash
conda install -c conda-forge rockpool
```

--------------------------------

### Constructor: __init__

Source: https://rockpool.ai/reference/_autosummary/nn.modules.Instant.html

Initializes an Instant module by wrapping a callable function.

```APIDOC
## __init__

### Description
Wrap a callable function as an instantaneous Rockpool module.

### Parameters
#### Request Body
- **shape** (tuple) - Optional - The shape of the module.
- **function** (Callable) - Optional - A scalar function of its arguments, with a single output. Default: identity function.
```

--------------------------------

### LinearTorch Example 1

Source: https://rockpool.ai/reference/_autosummary/nn.modules.LinearTorch.html

Example demonstrating the basic usage of LinearTorch for a linear transformation.

```APIDOC
### Example 1

```python
>>> m = LinearTorch((20, 30))
>>> input = torch.randn(128, 20)
>>> output, _, _ = m(input)
>>> print(output.size())
torch.Size([128, 30])
```
```

--------------------------------

### Install Rockpool using pip

Source: https://rockpool.ai/_sources/basics/installation.rst.txt

Use this command to install the latest version of Rockpool from PyPI.

```bash
pip install rockpool
```

--------------------------------

### Instantiate LIFExodus Module

Source: https://rockpool.ai/reference/_autosummary/nn.modules.LIFExodus.html

Examples for initializing the LIFExodus neuron module with different configurations.

```python
>>> mod = LIFExodus((4, 2))
```

```python
>>> mod = LIFExodus((4, 2), tau_mem = 30e-3, tau_syn = 10e-3, dt = 10e-3)
```
Tokens:
Raw