thrindex.snn

Import

import thrindex.snn as snn

snn.Sequential

A temporally-unrolled SNN container. Applies layers in order across all T timesteps. Owns and threads LIF state across timesteps — callers do not manage membrane tensors directly.

model = snn.Sequential(*layers)

Parameters

Name	Type	Description
`*layers`	`nn.Module`	Ordered layers. Any THRINDEX layer or standard `torch.nn` module.

Input / Output shape

Input: [T, batch, in_features] — time-first
Output: [T, batch, out_features] — time-first, spike raster of the last layer

Notes

Sequential is a torch.nn.Module. .parameters(), .state_dict(), .to(device), and all standard PyTorch optimizer integrations work as expected.
LIF state is reset to zero at the start of every forward call. It is not persistent across batches.
Non-LIF layers (Dense, Conv2d, standard torch.nn modules) are called without state at each timestep.

Example

import thrindex.snn as snn
import torch

model = snn.Sequential(
    snn.Dense(784, 512),
    snn.LIF(tau_mem=10.0),
    snn.Dense(512, 10),
    snn.LIF(tau_mem=10.0),
)

# x: [T=20, batch=32, 784]
spikes = model(x)  # [T=20, batch=32, 10]

snn.Dense

A linear (fully-connected) layer.

layer = snn.Dense(
    in_features: int,
    out_features: int,
    bias: bool = True,
)

Parameters

Name	Type	Default	Description
`in_features`	`int`	—	Input feature dimension
`out_features`	`int`	—	Output feature dimension
`bias`	`bool`	`True`	Whether to include a bias vector

Weight initialization Kaiming uniform (fan-in mode), matching torch.nn.Linear. Notes

Equivalent to torch.nn.Linear. No temporal state.
Applied at every timestep independently.

snn.LIF

A layer of leaky integrate-and-fire neurons.

layer = snn.LIF(
    tau_mem: float = 10.0,
    threshold: float = 1.0,
    tau_syn: float | None = None,
    reset: str = "subtract",
    beta: float = 25.0,
)

Parameters

Name	Type	Default	Description
`tau_mem`	`float`	`10.0`	Membrane time constant in ms. Must be > 1.0 ms.
`threshold`	`float`	`1.0`	Firing threshold (dimensionless)
`tau_syn`	`float \| None`	`None`	Synaptic filter time constant in ms. `None` = single-state LIF.
`reset`	`str`	`"subtract"`	Reset mode after a spike: `"subtract"` or `"zero"`
`beta`	`float`	`25.0`	Slope of the fast-sigmoid surrogate gradient

Computed constants

Name	Formula	Stored in artifact
`alpha`	`exp(-1.0 / tau_mem)`	Yes
`alpha_syn`	`exp(-1.0 / tau_syn)`	Yes (if `tau_syn` set)

The simulation timestep is fixed at dt = 1.0 ms. It is a class constant (LIF.DT), not a constructor parameter. Per-timestep update

mem_t   = alpha × mem_prev + x_t      # leak + integrate
spk_t   = H(mem_t − threshold)         # fire (Heaviside forward, surrogate backward)
mem_out = mem_t − spk_t × threshold   # reset: subtract mode
       OR mem_t × (1 − spk_t.detach())  # reset: zero mode

Reset modes

"subtract" — membrane potential is reduced by threshold on each spike. Gradients flow through the subtraction path.
"zero" — membrane potential is reset to zero on each spike. The reset mask is detached from the gradient graph.

Notes

LIF has no weight parameters. Its size is inferred from the output of the preceding layer.
tau_mem must be strictly greater than 1.0 ms. A time constant at or below the timestep loses all membrane history within a single step.
Surrogate gradient: fast-sigmoid. See Surrogate Gradients and E0101.

snn.Conv2d

A 2D convolutional layer for spatial spike inputs (event-camera data, 2D feature maps).

layer = snn.Conv2d(
    in_channels: int,
    out_channels: int,
    kernel_size: int | tuple[int, int],
    stride: int = 1,
    padding: int = 0,
    bias: bool = True,
)

Parameters

Name	Type	Default	Description
`in_channels`	`int`	—	Number of input channels
`out_channels`	`int`	—	Number of output channels
`kernel_size`	`int \| tuple`	—	Kernel height and width
`stride`	`int`	`1`	Convolution stride
`padding`	`int`	`0`	Zero-padding on all sides
`bias`	`bool`	`True`	Whether to include per-channel bias

Input / Output shapes

Input per timestep: [batch, C_in, H, W]
Output per timestep: [batch, C_out, H_out, W_out]

When used inside Sequential, the container calls it at each of the T timesteps.

Training

All THRINDEX layers are torch.nn.Module subclasses. A standard PyTorch training loop works without modification:

optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

for x, labels in dataloader:
    # x: [T, batch, in_features]
    spikes = model(x)                          # [T, batch, n_classes]
    loss = thrindex.train.rate_loss(spikes, labels)
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()

The surrogate gradient (FastSigmoid) handles the non-differentiable spike function during loss.backward(). BPTT gradients flow through all T timesteps automatically via PyTorch autograd.

Compiling a trained model

import thrindex as thx

# target="sim" — for simulation (default)
thx.compile(model, "model.thx", target="sim")

# target="akida-akd1500" — for AKD1500 hardware (Dense/Conv2d only, no LIF)
thx.compile(model, "model.thx", target="akida-akd1500")

See Hardware Targets for the AKD1500 deployment guide.

Getting Started

Tutorials

Concepts

Systems

API Reference

Errors

Benchmarks

Conformance

Import

snn.Sequential

snn.Dense

snn.LIF

snn.Conv2d

Training

Compiling a trained model

​Import

​snn.Sequential

​snn.Dense

​snn.LIF

​snn.Conv2d

​Training

​Compiling a trained model

Import

snn.Sequential

snn.Dense

snn.LIF

snn.Conv2d

Training

Compiling a trained model