English | 中文(Chinese)
SpikingJelly is an open-source deep learning framework for Spiking Neural Network (SNN) based on PyTorch.
The documentation of SpikingJelly is written in both English and Chinese.
- Changelog
- Installation
- Build SNN In An Unprecedented Simple Way
- Fast And Handy ANN-SNN Conversion
- CUDA/Triton-Enhanced Neuron
- Device Supports
- Neuromorphic Datasets Supports
- Tutorials
- Publications and Citation
- Contribution
- About
We are actively maintaining and improving SpikingJelly. Below are our future plans and highlights of each release.
Highlights
Our new work Towards Lossless Memory-efficient Training of Spiking Neural Networks via Gradient Checkpointing and Spike Compression was recently accepted by ICLR 2026! The automatic training memory optimization tool is available in spikingjelly.activation_based.memopt. Read the tutorial for more information.
In the latest version (Github version),
IFNode,LIFNodeandParametricLIFNodeare now equipped with Triton backends;FlexSNis available for converting PyTorch spiking neuronal dynamics to Triton kernels;SpikingSelfAttentionandQKAttentionare available;memoptis available;nir_exchangeis available;op_counteris available;spikingjelly.activation_based.layer,spikingjelly.activation_based.functionalandspikingjelly.datasetsare refactored;- Dataset implementations are refactored;
- Docs and tutorials are updated;
- Conv-bn fusion functions in
spikingjelly.activation_based.functionalare deprecated; use PyTorch'sfuse_conv_bn_evalinstead.
Planned
We are going to release version 0.0.0.1.0 soon.
- Add Triton backend for further acceleration on GPU.
- Add a transpiler for converting PyTorch spiking neurons to Triton kernels, which will be more flexible than the existing
auto_cudasubpackage. - Add spiking self-attention implementations.
- Update docs and tutorials.
Other long-term plans include:
- Add NIR support.
- Optimize training memory cost.
- Accelerate on Huawei NPU.
For early-stage experimental features, see our companion project flashsnn. New ideas are prototyped in flashsnn before merging into SpikingJelly.
Version notes
-
The odd version number is the developing version, updated with the GitHub/OpenI repository. The even version number is the stable version and is available at PyPI.
-
The default doc is for the latest developing version. If you are using the stable version, do not forget to switch to the doc in the corresponding version.
-
From the version
0.0.0.0.14, modules includingclock_drivenandevent_drivenare renamed. Please refer to the tutorial Migrate From Old Versions. -
If you use an old version of SpikingJelly, you may encounter some fatal bugs. Refer to Bugs History with Releases for more details.
Docs for different versions:
Note that SpikingJelly is based on PyTorch. Please make sure that you have installed PyTorch, torchvision and torchaudio before you install SpikingJelly. Note that the latest version of SpikingJelly requires torch>=2.2.0 and is tested on torch==2.7.1 .
Install the last stable version from PyPI:
pip install spikingjellyInstall the latest developing version from the source code:
From GitHub:
git clone https://github.com/fangwei123456/spikingjelly.git
cd spikingjelly
pip install .From OpenI:
git clone https://openi.pcl.ac.cn/OpenI/spikingjelly.git
cd spikingjelly
pip install .Optional Dependencies
To enable cupy backend, install CuPy.
pip install cupy-cuda12x # for CUDA 12.x
pip install cupy-cuda11x # for CUDA 11.xTo enable triton backend, make sure that Triton is installed. Typically, triton is installed with PyTorch 2.X. We test triton backend on triton==3.3.1.
pip install triton==3.3.1To enable nir_exchange, install NIR and NIRTorch.
pip install nir nirtorchSpikingJelly is user-friendly. Building SNN with SpikingJelly is as simple as building ANN in PyTorch:
nn.Sequential(
layer.Flatten(),
layer.Linear(28 * 28, 10, bias=False),
neuron.LIFNode(tau=tau, surrogate_function=surrogate.ATan())
)This simple network with a Poisson encoder can achieve 92% accuracy on the MNIST test dataset. Read refer to the tutorial for more details. You can also run this code in a Python terminal for training on classifying MNIST:
python -m spikingjelly.activation_based.examples.lif_fc_mnist -tau 2.0 -T 100 -device cuda:0 -b 64 -epochs 100 -data-dir <PATH to MNIST> -amp -opt adam -lr 1e-3 -j 8SpikingJelly implements a relatively general ANN-SNN Conversion interface. Users can realize the conversion through PyTorch. What's more, users can customize the conversion mode.
class ANN(nn.Module):
def __init__(self):
super().__init__()
self.network = nn.Sequential(
nn.Conv2d(1, 32, 3, 1),
nn.BatchNorm2d(32, eps=1e-3),
nn.ReLU(),
nn.AvgPool2d(2, 2),
nn.Conv2d(32, 32, 3, 1),
nn.BatchNorm2d(32, eps=1e-3),
nn.ReLU(),
nn.AvgPool2d(2, 2),
nn.Conv2d(32, 32, 3, 1),
nn.BatchNorm2d(32, eps=1e-3),
nn.ReLU(),
nn.AvgPool2d(2, 2),
nn.Flatten(),
nn.Linear(32, 10)
)
def forward(self,x):
x = self.network(x)
return xThis simple network with analog encoding can achieve 98.44% accuracy after conversion on MNIST test dataset. Read the tutorial for more details. You can also run this code in a Python terminal for training on classifying MNIST using the converted model:
>>> import spikingjelly.activation_based.ann2snn.examples.cnn_mnist as cnn_mnist
>>> cnn_mnist.main()SpikingJelly provides multiple backends for multi-step neurons. You can use the user-friendly torch backend for easily coding and debugging and use cupy or triton backend for faster training speed.
The following figure compares the execution time of torch and cupy backends of Multi-Step LIF neurons (float32). Generally, triton backend is even more efficient than cupy backend.
float16 is also provided by the cupy and triton backend, and can be used in automatic mixed precision training.
To use the cupy backend, please install CuPy. To use the triton backend, please install Triton. Note that the cupy and triton backend only supports GPU, while the torch backend supports both CPU and GPU.
- Nvidia GPU
- CPU
- Huawei NPU
As simple as using PyTorch.
>>> net = nn.Sequential(layer.Flatten(), layer.Linear(28 * 28, 10, bias=False), neuron.LIFNode(tau=tau))
>>> net = net.to(device) # Can be CPU or CUDA devicesSpikingJelly includes the following neuromorphic datasets:
Users can use both the origin event data and frame data integrated by SpikingJelly:
import torch
from torch.utils.data import DataLoader
from spikingjelly.datasets.utils import pad_sequence_collate, padded_sequence_mask
from spikingjelly.datasets import DVS128Gesture
# Set the root directory for the dataset
root_dir = 'D:/datasets/DVS128Gesture'
# Load event dataset
event_set = DVS128Gesture(root_dir, train=True, data_type='event')
event, label = event_set[0]
# Print the keys and their corresponding values in the event data
for k in event.keys():
print(k, event[k])
# t [80048267 80048277 80048278 ... 85092406 85092538 85092700]
# x [49 55 55 ... 60 85 45]
# y [82 92 92 ... 96 86 90]
# p [1 0 0 ... 1 0 0]
# label 0
# Load a dataset with fixed frame numbers
fixed_frames_number_set = DVS128Gesture(root_dir, train=True, data_type='frame', frames_number=20, split_by='number')
# Randomly select two frames and print their shapes
rand_index = torch.randint(low=0, high=fixed_frames_number_set.__len__(), size=[2])
for i in rand_index:
frame, label = fixed_frames_number_set[i]
print(f'frame[{i}].shape=[T, C, H, W]={frame.shape}')
# frame[308].shape=[T, C, H, W]=(20, 2, 128, 128)
# frame[453].shape=[T, C, H, W]=(20, 2, 128, 128)
# Load a dataset with a fixed duration and print the shapes of the first 5 samples
fixed_duration_frame_set = DVS128Gesture(root_dir, data_type='frame', duration=1000000, train=True)
for i in range(5):
x, y = fixed_duration_frame_set[i]
print(f'x[{i}].shape=[T, C, H, W]={x.shape}')
# x[0].shape=[T, C, H, W]=(6, 2, 128, 128)
# x[1].shape=[T, C, H, W]=(6, 2, 128, 128)
# x[2].shape=[T, C, H, W]=(5, 2, 128, 128)
# x[3].shape=[T, C, H, W]=(5, 2, 128, 128)
# x[4].shape=[T, C, H, W]=(7, 2, 128, 128)
# Create a data loader for the fixed duration frame dataset and print the shapes and sequence lengths
train_data_loader = DataLoader(fixed_duration_frame_set, collate_fn=pad_sequence_collate, batch_size=5)
for x, y, x_len in train_data_loader:
print(f'x.shape=[N, T, C, H, W]={tuple(x.shape)}')
print(f'x_len={x_len}')
mask = padded_sequence_mask(x_len) # mask.shape = [T, N]
print(f'mask=\n{mask.t().int()}')
break
# x.shape=[N, T, C, H, W]=(5, 7, 2, 128, 128)
# x_len=tensor([6, 6, 5, 5, 7])
# mask=
# tensor([[1, 1, 1, 1, 1, 1, 0],
# [1, 1, 1, 1, 1, 1, 0],
# [1, 1, 1, 1, 1, 0, 0],
# [1, 1, 1, 1, 1, 0, 0],
# [1, 1, 1, 1, 1, 1, 1]], dtype=torch.int32)More datasets will be included in the future.
If some datasets' download links are not available for some users, the users can download from the OpenI mirror.
All datasets saved in the OpenI mirror are allowable by their license or author's agreement.
SpikingJelly provides elaborate tutorials. Here are some tutorials:
Other tutorials that are not listed here are also available at the document.
ZhenyuZhao provides jupyter tutorial notebooks in Chinese。
Publications using SpikingJelly are recorded in Publications. If you use SpikingJelly in your paper, you can also add it to this table by pull request.
If you use SpikingJelly in your work, please cite it as follows:
@article{
doi:10.1126/sciadv.adi1480,
author = {Wei Fang and Yanqi Chen and Jianhao Ding and Zhaofei Yu and Timothée Masquelier and Ding Chen and Liwei Huang and Huihui Zhou and Guoqi Li and Yonghong Tian },
title = {SpikingJelly: An open-source machine learning infrastructure platform for spike-based intelligence},
journal = {Science Advances},
volume = {9},
number = {40},
pages = {eadi1480},
year = {2023},
doi = {10.1126/sciadv.adi1480},
URL = {https://www.science.org/doi/abs/10.1126/sciadv.adi1480},
eprint = {https://www.science.org/doi/pdf/10.1126/sciadv.adi1480},
abstract = {Spiking neural networks (SNNs) aim to realize brain-inspired intelligence on neuromorphic chips with high energy efficiency by introducing neural dynamics and spike properties. As the emerging spiking deep learning paradigm attracts increasing interest, traditional programming frameworks cannot meet the demands of automatic differentiation, parallel computation acceleration, and high integration of processing neuromorphic datasets and deployment. In this work, we present the SpikingJelly framework to address the aforementioned dilemma. We contribute a full-stack toolkit for preprocessing neuromorphic datasets, building deep SNNs, optimizing their parameters, and deploying SNNs on neuromorphic chips. Compared to existing methods, the training of deep SNNs can be accelerated 11×, and the superior extensibility and flexibility of SpikingJelly enable users to accelerate custom models at low costs through multilevel inheritance and semiautomatic code generation. SpikingJelly paves the way for synthesizing truly energy-efficient SNN-based machine intelligence systems, which will enrich the ecology of neuromorphic computing. Motivation and introduction of the software framework SpikingJelly for spiking deep learning.}}You can read the issues and get the problems to be solved and the latest development plans. We welcome all users to join the discussion of development plans, solve issues, and send pull requests.
Not all API documents are written in both English and Chinese. We welcome users to complete translation (from English to Chinese or from Chinese to English).
Read the Contributing Guide for more information.
Multimedia Learning Group, Institute of Digital Media (NELVT), Peking University and Peng Cheng Laboratory are the main institutions behind the development of SpikingJelly.
SpikingJelly has been developed and maintained by multiple main developers over time.
2024.07~Now
2019.12~2024.06
Wei Fang, Yanqi Chen, Jianhao Ding, Ding Chen, Liwei Huang
The list of contributors can be found in the contributor page.
