June 22, 2026 9 min read

PyTorch Spiking Neural Network Tutorial

You don't need a research lab or neuromorphic hardware to build a spiking neural network from PyTorch. Here is a complete, working example, start to finish.

This tutorial walks through converting a trained PyTorch convolutional network into a spiking neural network (SNN) using NeuroCUDA, an open-source, pip-installable compiler. By the end, you'll have a spiking model, a measured sparsity figure, and a validated accuracy comparison against the original network, all without touching specialized hardware.

Step 1: Install

pip install neurocuda
# or, with all optional backends:
pip install neurocuda[all]

Step 2: Start with a trained PyTorch model

NeuroCUDA converts models you've already trained conventionally - it does not require you to retrain from a spiking-native architecture. Any standard torch.nn.Module with ReLU activations is a valid starting point, including convolutional networks and residual architectures like ResNet.

Step 3: Convert to a spiking neural network

import neurocuda

snn_model = neurocuda.convert(your_pytorch_model, train_loader)

Under the hood, this applies QCFS (quantization-clip-floor-shift) calibration to align the model's activations with spiking integrate-and-fire (IF) neuron dynamics, then fine-tunes the result using backpropagation-through-time (BPTT) to recover accuracy that a naive conversion would lose. Without this kind of calibration, a straightforward ReLU-to-spiking swap commonly causes accuracy to collapse, since the two activation types have fundamentally different transfer functions.

Step 4: Measure sparsity

sparsity = neurocuda.measure_sparsity(snn_model, test_loader)
print(f"Sparsity: {sparsity:.1%}")

Sparsity measures the fraction of timesteps where a neuron doesn't fire. It matters because event-driven neuromorphic hardware only consumes meaningful energy when a spike actually occurs - higher sparsity translates more directly into energy savings on that kind of hardware. On a ResNet-18/CIFAR-10 conversion, NeuroCUDA measures roughly 93.7% sparsity; on a 3-layer CNN for N-MNIST, roughly 91.7% ± 0.5%.

Step 5: Validate accuracy against the original model

Notably, the N-MNIST conversion actually slightly outperforms its ANN baseline (99.88% vs. 99.70%), which is unusual for ANN-to-SNN conversion and reflects how well QCFS-calibrated spiking neurons can match event-based data specifically, since N-MNIST is itself spike-based.

Step 6: Run on different backends

neurocuda.compile(snn_model, target="gpu")
neurocuda.compile(snn_model, target="cpu")
neurocuda.compile(snn_model, target="loihi2_sim")

NeuroCUDA's GPU and CPU backends have been validated against each other to be bit-exact - zero deviations across 256,000 spike comparisons. The Loihi 2 backend is a simulator checked against Intel's own published neuron equations across 100,000+ comparisons with zero deviations - a spec-conformance check, not a run on the Lava SDK or physical Loihi 2 silicon.

Step 7: Export for portability

neurocuda.to_nir(snn_model, "model.nir")

Exporting to NIR means your model isn't locked into NeuroCUDA going forward - it can move to any tool that implements the NIR specification. For models with residual connections, NeuroCUDA's NIR executor is verified bit-exact, a case that commonly trips up reference NIR tooling.

What this tutorial doesn't cover

This walkthrough covers conversion, simulation, and software-level validation. It does not cover deploying to physical neuromorphic hardware, which requires separate hardware access (for Loihi 2, through Intel's INRC program) - see our Loihi 2 deployment guide for that next step.

Frequently asked questions