spikingjelly
1.0.0
Inglês | 中文 (chinês)
O SpikingJelly é uma estrutura de aprendizado profundo de código aberto para a Rede Neural Spiking (SNN) baseada em Pytorch.
A documentação de Spikingjelly está escrita em inglês e chinês: https://spikingjelly.readthedocs.io.
Observe que o Spikingjelly é baseado em Pytorch. Certifique -se de instalar o Pytorch antes de instalar o SpikingJelly.
Notas da versão
O número da versão ímpar é a versão em desenvolvimento, atualizada com o repositório GitHub/Openi. O número da versão uniforme é a versão estável e está disponível no PYPI.
O documento padrão é para a versão mais recente em desenvolvimento. Se você estiver usando a versão estável, não se esqueça de mudar para o documento na versão correspondente.
A partir da versão 0.0.0.0.14 , os módulos incluindo clock_driven e event_driven são renomeados. Consulte o tutorial migrar de versões antigas.
Se você usar uma versão antiga do SpikingJelly, poderá encontrar alguns bugs fatais. Consulte o histórico de bugs com lançamentos para obter mais detalhes.
Documentos para diferentes versões:
Instale a última versão estável da Pypi :
pip install spikingjellyInstale a versão mais recente em desenvolvimento do código -fonte :
Do github:
git clone https://github.com/fangwei123456/spikingjelly.git
cd spikingjelly
python setup.py installDe Openi:
git clone https://openi.pcl.ac.cn/OpenI/spikingjelly.git
cd spikingjelly
python setup.py installSpikingjelly é fácil de usar. Construir SNN com Spikingjelly é tão simples quanto a construção de Ann em Pytorch:
nn . Sequential (
layer . Flatten (),
layer . Linear ( 28 * 28 , 10 , bias = False ),
neuron . LIFNode ( tau = tau , surrogate_function = surrogate . ATan ())
)Esta rede simples com um codificador Poisson pode obter uma precisão de 92% no conjunto de dados de teste MNIST. Leia Consulte o tutorial para obter mais detalhes. Você também pode executar este código em um terminal Python para treinamento sobre classificação do 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 8 A SpikingJelly implementa uma interface de conversão Relativamente Geral de Ann-SNN. Os usuários podem realizar a conversão através do Pytorch. Além disso, os usuários podem personalizar o modo de conversão.
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 xEssa rede simples com codificação analógica pode obter uma precisão de 98,44% após a conversão no conjunto de dados de teste MNIST. Leia o tutorial para obter mais detalhes. Você também pode executar esse código em um terminal Python para treinamento em classificar o MNIST usando o modelo convertido:
> >> import spikingjelly . activation_based . ann2snn . examples . cnn_mnist as cnn_mnist
> >> cnn_mnist . main () O SpikingJelly fornece dois back-end para os neurônios de várias etapas. Você pode usar o back-end torch amigável para codificar e depurar facilmente e usar o back-end cupy para uma velocidade de treinamento mais rápida.
A figura a seguir compara o tempo de execução de dois back-ends de neurônios LIF de várias etapas ( float32 ):
float16 também é fornecido pelo back -end cupy e pode ser usado em treinamento automático de precisão mista.
Para usar o back -end cupy , instale o Cupy. Observe que o back -end cupy suporta apenas a GPU, enquanto o back -end torch suporta a CPU e a GPU.
Tão simples quanto usar 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 devices SpikingJelly inclui os seguintes conjuntos de dados neuromórficos:
| Conjunto de dados | Fonte |
|---|---|
| ASL-DVS | Classificação de objetos baseada em gráfico para detecção de visão neuromórfica |
| CIFAR10-DVS | CIFAR10-DVS: um conjunto de dados de fluxo de eventos para classificação de objetos |
| DVS128 Gesto | Um sistema de reconhecimento de gestos de baixa potência e totalmente baseado em eventos |
| Es-Imagenet | ES-IMAGENET: um milhão de dados de classificação de fluxo de eventos para redes neurais Spiking |
| Hardvs | Hardvs: revisitando o reconhecimento de atividades humanas com sensores de visão dinâmica |
| N-Caltech101 | Convertendo conjuntos de dados de imagem estática em conjuntos de dados neuromórficos de spiking usando sacadas |
| N-mnist | Convertendo conjuntos de dados de imagem estática em conjuntos de dados neuromórficos de spiking usando sacadas |
| Gesto de navegação | Reconhecimento de gestos baseado em eventos com supressão dinâmica de fundo usando recursos computacionais de smartphone |
| Spiking Heidelberg Digits (SHD) | Os conjuntos de dados de Spiking de Heidelberg para a avaliação sistemática de redes neurais de spiking |
| DVS-LIP | Recursos espaço-temporais com múltiplos graus |
Os usuários podem usar os dados do evento de origem e os dados do quadro integrado pela SpikingJelly:
import torch
from torch . utils . data import DataLoader
from spikingjelly . datasets import pad_sequence_collate , padded_sequence_mask
from spikingjelly . datasets . dvs128_gesture 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)Mais conjuntos de dados serão incluídos no futuro.
Se os links de download de alguns conjuntos de dados não estiverem disponíveis para alguns usuários, os usuários poderão baixar no Openi Mirror:
https://openi.pcl.ac.cn/openi/spikingjelly/datasets?type=0
Todos os conjuntos de dados salvos no Openi Mirror são permitidos por sua licença ou contrato de autor.
A SpikingJelly fornece tutoriais elaborados. Aqui estão alguns tutoriais:
| Figura | Tutorial |
|---|---|
 | Concepção básica |
 | Neurônio |
 | Camada única totalmente conectada SNN para classificar o MNIST |
 | SNN convolucional para classificar o fmnist |
 | Ann2Snn |
 | Processamento de conjuntos de dados neuromórficos |
 | Classifique o gesto de DVS |
 | Conexão recorrente e sinapse com estado |
 | Aprendizagem do STDP |
 | Aprendizagem de reforço |
Outros tutoriais que não estão listados aqui também estão disponíveis no documento https://spikingjelly.readthedocs.io.
Publicações usando SpikingJelly são registradas em publicações. Se você usar o SpikingJelly em seu papel, também poderá adicioná -lo a esta tabela por solicitação de tração.
Se você usar o SpikingJelly em seu trabalho, cite -o da seguinte forma:
@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.}}
Você pode ler os problemas e resolver os problemas e os planos de desenvolvimento mais recentes. Congratulamo -nos com todos os usuários para participar da discussão sobre planos de desenvolvimento, resolver problemas e enviar solicitações de puxar.
Nem todos os documentos da API são escritos em inglês e chinês. Congratulamo -nos com os usuários para completar a tradução (do inglês para o chinês ou do chinês para o inglês).
O Grupo de Aprendizagem Multimídia, o Instituto de Mídia Digital (NELVT), a Universidade de Pequim e o Laboratório Peng Cheng são os principais desenvolvedores da SpikingJelly.
A lista de desenvolvedores pode ser encontrada aqui.
