├── .github
    ├── ISSUE_TEMPLATE
    │   └── bug_report.md
    └── workflows
    │   └── pythonpublish.yml
├── .gitignore
├── .readthedocs.yml
├── .travis.yml
├── CHANGELOG.rst
├── LICENSE.txt
├── README.rst
├── docs
    ├── Makefile
    ├── build
    │   ├── doctrees
    │   │   ├── environment.pickle
    │   │   ├── index.doctree
    │   │   ├── modules.doctree
    │   │   └── snntoolbox.io_utils.doctree
    │   └── html
    │   │   ├── .buildinfo
    │   │   ├── _images
    │   │       ├── gui_parameters.png
    │   │       ├── gui_plots.png
    │   │       └── workflow.png
    │   │   ├── _modules
    │   │       ├── index.html
    │   │       └── snntoolbox
    │   │       │   ├── config.html
    │   │       │   └── io_utils
    │   │       │       ├── common.html
    │   │       │       └── plotting.html
    │   │   ├── _sources
    │   │       ├── citation.rst.txt
    │   │       ├── intro.rst.txt
    │   │       ├── modules.rst.txt
    │   │       ├── running.rst.txt
    │   │       ├── snntoolbox.core.rst.txt
    │   │       ├── snntoolbox.gui.rst.txt
    │   │       ├── snntoolbox.io_utils.AedatTools.rst.txt
    │   │       ├── snntoolbox.io_utils.load_dataset.rst.txt
    │   │       ├── snntoolbox.io_utils.rst.txt
    │   │       ├── snntoolbox.model_libs.rst.txt
    │   │       ├── snntoolbox.rst.txt
    │   │       ├── snntoolbox.target_simulators.rst.txt
    │   │       └── support.rst.txt
    │   │   ├── _static
    │   │       ├── ajax-loader.gif
    │   │       ├── basic.css
    │   │       ├── comment-bright.png
    │   │       ├── comment-close.png
    │   │       ├── comment.png
    │   │       ├── css
    │   │       │   ├── badge_only.css
    │   │       │   └── theme.css
    │   │       ├── doctools.js
    │   │       ├── down-pressed.png
    │   │       ├── down.png
    │   │       ├── file.png
    │   │       ├── fonts
    │   │       │   ├── Inconsolata-Bold.ttf
    │   │       │   ├── Inconsolata-Regular.ttf
    │   │       │   ├── Lato-Bold.ttf
    │   │       │   ├── Lato-Regular.ttf
    │   │       │   ├── RobotoSlab-Bold.ttf
    │   │       │   ├── RobotoSlab-Regular.ttf
    │   │       │   ├── fontawesome-webfont.eot
    │   │       │   ├── fontawesome-webfont.svg
    │   │       │   ├── fontawesome-webfont.ttf
    │   │       │   └── fontawesome-webfont.woff
    │   │       ├── jquery.js
    │   │       ├── js
    │   │       │   ├── modernizr.min.js
    │   │       │   └── theme.js
    │   │       ├── minus.png
    │   │       ├── plus.png
    │   │       ├── pygments.css
    │   │       ├── searchtools.js
    │   │       ├── underscore-1.3.1.js
    │   │       ├── underscore.js
    │   │       ├── up-pressed.png
    │   │       ├── up.png
    │   │       └── websupport.js
    │   │   ├── genindex.html
    │   │   ├── index.html
    │   │   ├── modules.html
    │   │   ├── objects.inv
    │   │   ├── py-modindex.html
    │   │   ├── search.html
    │   │   ├── searchindex.js
    │   │   └── snntoolbox.io_utils.html
    ├── make.bat
    └── source
    │   ├── api
    │       ├── bin.rst
    │       ├── conversion.rst
    │       ├── datasets.rst
    │       ├── parsing.rst
    │       ├── simulation.rst
    │       └── utils.rst
    │   ├── conf.py
    │   ├── guide
    │       ├── citation.rst
    │       ├── configuration.rst
    │       ├── examples.rst
    │       ├── extending.rst
    │       ├── installation.rst
    │       ├── intro.rst
    │       ├── running.rst
    │       └── support.rst
    │   ├── images
    │       ├── features.png
    │       ├── gui_all.png
    │       ├── gui_cellparams.png
    │       ├── gui_globalparams.png
    │       ├── gui_parameters.png
    │       ├── gui_params.png
    │       ├── gui_plotparams.png
    │       ├── gui_plots.png
    │       ├── gui_plots2.png
    │       ├── gui_simparams.png
    │       ├── gui_tools.png
    │       ├── input_specs.png
    │       ├── snntoolbox_gui.png
    │       ├── workflow.odt
    │       └── workflow.png
    │   └── index.rst
├── examples
    ├── .gitignore
    ├── __init__.py
    ├── mnist_keras_INI.py
    ├── mnist_keras_brian2.py
    ├── mnist_keras_loihi.py
    ├── mnist_keras_nest.py
    ├── mnist_keras_spiNNaker.py
    ├── mnist_keras_spiNNaker_sparse.py
    ├── mnist_pytorch_INI.py
    └── resnet_keras_INI.py
├── requirements.rtd.txt
├── requirements.txt
├── setup.cfg
├── setup.py
├── snntoolbox
    ├── __init__.py
    ├── bin
    │   ├── __init__.py
    │   ├── gui
    │   │   ├── __init__.py
    │   │   ├── gui.py
    │   │   └── tooltip.py
    │   ├── run.py
    │   └── utils.py
    ├── config_defaults
    ├── conversion
    │   ├── __init__.py
    │   └── utils.py
    ├── datasets
    │   ├── __init__.py
    │   ├── aedat
    │   │   ├── DVSIterator.py
    │   │   ├── ImportAedat.py
    │   │   ├── ImportAedatBasicSourceName.py
    │   │   ├── ImportAedatDataVersion1or2.py
    │   │   ├── ImportAedatHeaders.py
    │   │   ├── __init__.py
    │   │   └── avi_to_lmdb.py
    │   └── utils.py
    ├── parsing
    │   ├── __init__.py
    │   ├── model_libs
    │   │   ├── __init__.py
    │   │   ├── caffe_input_lib.py
    │   │   ├── keras_input_lib.py
    │   │   ├── lasagne_input_lib.py
    │   │   └── pytorch_input_lib.py
    │   └── utils.py
    ├── simulation
    │   ├── __init__.py
    │   ├── backends
    │   │   ├── __init__.py
    │   │   ├── inisim
    │   │   │   ├── __init__.py
    │   │   │   ├── temporal_mean_rate_tensorflow.py
    │   │   │   ├── temporal_mean_rate_theano.py
    │   │   │   ├── temporal_pattern.py
    │   │   │   ├── ttfs.py
    │   │   │   ├── ttfs_corrective.py
    │   │   │   └── ttfs_dyn_thresh.py
    │   │   └── megasim
    │   │   │   ├── __init__.py
    │   │   │   └── megasim.py
    │   ├── plotting.py
    │   ├── target_simulators
    │   │   ├── INI_temporal_mean_rate_target_sim.py
    │   │   ├── INI_temporal_pattern_target_sim.py
    │   │   ├── INI_ttfs_corrective_target_sim.py
    │   │   ├── INI_ttfs_dyn_thresh_target_sim.py
    │   │   ├── INI_ttfs_target_sim.py
    │   │   ├── MegaSim_target_sim.py
    │   │   ├── __init__.py
    │   │   ├── brian2_target_sim.py
    │   │   ├── brian_target_sim.py
    │   │   ├── loihi_target_sim.py
    │   │   ├── nest_target_sim.py
    │   │   ├── neuron_target_sim.py
    │   │   ├── pyNN_target_sim.py
    │   │   └── spiNNaker_target_sim.py
    │   └── utils.py
    └── utils
    │   ├── __init__.py
    │   └── utils.py
├── tests
    ├── README.md
    ├── __init__.py
    ├── conftest.py
    ├── conversion
    │   └── __init__.py
    ├── core
    │   ├── test_config.py
    │   ├── test_gui.py
    │   ├── test_io.py
    │   └── test_models.py
    ├── datasets
    │   └── __init__.py
    ├── parsing
    │   ├── __init__.py
    │   ├── models
    │   │   ├── __init__.py
    │   │   └── pytorch.py
    │   └── test_pytorch.py
    └── simulation
    │   ├── __init__.py
    │   ├── test_conv.py
    │   └── test_pooling.py
└── tox.ini


/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a report to help us improve
 4 | title: ''
 5 | labels: ''
 6 | assignees: rbodo
 7 | 
 8 | ---
 9 | 
10 | **When filing a bug, please provide:**
11 | - A description of what you are trying to do
12 | - Are you using the development or pypi version of the toolbox?
13 | - The console output including the full stack trace
14 | - Your config file
15 | 


--------------------------------------------------------------------------------
/.github/workflows/pythonpublish.yml:
--------------------------------------------------------------------------------
 1 | # This workflows will upload a Python Package using Twine when a release is created
 2 | # For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries
 3 | 
 4 | name: Upload Python Package
 5 | 
 6 | on:
 7 |   release:
 8 |     types: [created]
 9 | 
10 | jobs:
11 |   deploy:
12 | 
13 |     runs-on: ubuntu-latest
14 | 
15 |     steps:
16 |     - uses: actions/checkout@v2
17 |     - name: Set up Python
18 |       uses: actions/setup-python@v1
19 |       with:
20 |         python-version: '3.x'
21 |     - name: Install dependencies
22 |       run: |
23 |         python -m pip install --upgrade pip
24 |         pip install setuptools wheel twine
25 |     - name: Build and publish
26 |       env:
27 |         TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
28 |         TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
29 |       run: |
30 |         python setup.py sdist bdist_wheel
31 |         twine upload dist/*
32 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | temp/*
 2 | dist/
 3 | build/
 4 | .eggs/
 5 | snntoolbox.egg-info/
 6 | *.pyc
 7 | __pycache__
 8 | .cache/
 9 | .idea/
10 | .tox/
11 | .pytest_cache
12 | .project
13 | .pydevproject
14 | .settings/
15 | **/log/
16 | **/application_generated_data_files/
17 | **/reports/
18 | *.h5
19 | *.npz
20 | *.json
21 | 


--------------------------------------------------------------------------------
/.readthedocs.yml:
--------------------------------------------------------------------------------
 1 | # Read the Docs configuration file
 2 | # See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
 3 | 
 4 | # Required
 5 | version: 2
 6 | 
 7 | # Build documentation in the docs/ directory with Sphinx
 8 | sphinx:
 9 |   configuration: docs/source/conf.py
10 | 
11 | # Optionally build your docs in additional formats such as PDF and ePub
12 | formats: []
13 | 
14 | # Optionally set the version of Python and requirements required to build your docs
15 | python:
16 |   install:
17 |     - requirements: requirements.txt
18 |     - requirements: requirements.rtd.txt
19 |   system_packages: true
20 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: python
2 | 
3 | install:
4 |   - pip install -r requirements.txt
5 |   - pip install -r requirements.rtd.txt
6 | 
7 | script: pytest
8 | 


--------------------------------------------------------------------------------
/CHANGELOG.rst:
--------------------------------------------------------------------------------
 1 | SNN Toolbox: Release Notes
 2 | ==========================
 3 | 
 4 | Version 0.6.0
 5 | -------------
 6 | 
 7 | Support for Tensorflow 2.4.
 8 | Added support for Conv1D layers.
 9 | Implemented spiking maxpool layer for tensorflow backend.
10 | More example scripts for ResNets and pytorch models.
11 | Minor bugfixes.
12 | 
13 | Version 0.5.0
14 | -------------
15 | 
16 | Added support for Tensorflow 2.2.
17 | The toolbox no longer imports stand-alone Keras, but instead uses Keras only
18 | from within Tensorflow (tf.keras).
19 | Enabled simulating SNNs in the tensorflow-based INIsim using graph mode rather
20 | than eager execution, which results in a speed-up of about 7X.
21 | Removed support for python 2.
22 | Updated various temporal coding backends.
23 | 
24 | Version 0.4.1
25 | -------------
26 | 
27 | The toolbox now supports input models from the PyTorch library.
28 | 
29 | Thanks to Pengfei Sun for contributing.
30 | 
31 | Version 0.4
32 | -----------
33 | 
34 | The toolbox now supports deploying converted networks on the SpiNNaker
35 | architecture!
36 | 
37 | Thanks to ej159, pabogdan, and rbodo for contributing.
38 | 
39 | Version 0.3.2
40 | -------------
41 | 
42 | Simulation with Brian2 backend now supports:
43 |     - Constant input currents (less noisy than Poisson input)
44 |     - Reset-by-subtraction (more accurate than reset-to-zero).
45 |     - Bias currents
46 | 
47 | Thanks to wilkieolin for this contribution.
48 | 
49 | Version 0.3.1
50 | -------------
51 | 
52 | Bugfixes:
53 |     - Setting biases in convolution layers for pyNN and Brian2 simulator
54 |       backends.
55 |     - Parsing axis parameter in BatchNorm layers.
56 |     - Counting of SNN operations.
57 |     - Minor issues due to updating to latest keras / tensorflow version.
58 |     - Syntax error in equation for membrane potential due to updating Brian2.
59 |     - Restoring a previously saved SNN to run with INIsim now works again.
60 |     - Fixed issue #25 (permutation of weights after flatten layer in models
61 |       trained with recent Keras version and simulated with Brian2 / pyNN).
62 | 
63 | Added support for:
64 |     - Intel's neuromorphic platform "Loihi".
65 |     - Tensorflow 2.0.
66 |     - Parsing depthwise-separable convolutions.
67 |     - Strides > 1 for pyNN and Brian2 simulator backends.
68 |     - Parsing a model can be skipped now by loading a previously saved parsed
69 |       model.
70 |     - Using SNN toolbox more easily from within a python script instead of via
71 |       terminal only.
72 |     - Save and load functions for Brian2 networks.
73 | 
74 | Miscellaneous:
75 |     - Added end-to-end examples for creating and training the model, saving
76 |       the dataset, and setting up the config file to run SNN toolbox.
77 |     - Moved large model files and datasets to separate repository
78 |       (snntoolbox_applications) to shrink size of core package.
79 |     - Minor refactoring, repo cleanup, and performance improvements.
80 | 
81 | Contributors:
82 |     - rbodo
83 |     - sflin
84 |     - nandantumu
85 |     - morth
86 |     - wilkieolin
87 |     - Al-pha
88 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Bodo Rueckauer
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/README.rst:
--------------------------------------------------------------------------------
 1 | |b1| |b2| |b3| |b4|
 2 | 
 3 | .. |b1| image:: https://travis-ci.org/NeuromorphicProcessorProject/snn_toolbox.svg?branch=master
 4 |     :target: https://travis-ci.org/NeuromorphicProcessorProject/snn_toolbox
 5 | 
 6 | .. |b2| image:: https://readthedocs.org/projects/snntoolbox/badge/?version=latest
 7 |     :target: https://snntoolbox.readthedocs.io/en/latest/?badge=latest
 8 |     :alt: Documentation Status
 9 | 
10 | .. |b3| image:: https://badge.fury.io/py/snntoolbox.svg
11 |     :target: https://badge.fury.io/py/snntoolbox
12 | 
13 | .. |b4| image:: https://pepy.tech/badge/snntoolbox
14 |     :target: https://pepy.tech/project/snntoolbox
15 |     
16 | 
17 | Spiking neural network conversion toolbox
18 | =========================================
19 | 
20 | The SNN conversion toolbox (SNN-TB) is a framework to transform rate-based
21 | artificial neural networks into spiking neural networks, and to run them using
22 | various spike encodings. A unique feature about SNN-TB is that it accepts input
23 | models from many different deep-learning libraries (Keras / TF, pytorch, ...)
24 | and provides an interface to several backends for simulation (pyNN, brian2,
25 | ...) or deployment (SpiNNaker, Loihi).
26 | 
27 | Please
28 | refer to the `Documentation <http://snntoolbox.readthedocs.io>`_ for a complete
29 | user guide and API reference. See also the accompanying articles
30 | `[Rueckauer et al., 2017] <https://www.frontiersin.org/articles/10.3389/fnins.2017.00682/abstract>`_, `[Rueckauer and Liu, 2018] <https://ieeexplore.ieee.org/abstract/document/8351295/>`_, and `[Rueckauer and Liu, 2021] <https://ieeexplore.ieee.org/abstract/document/9533837>`_.
31 | 


--------------------------------------------------------------------------------
/docs/build/doctrees/environment.pickle:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/doctrees/environment.pickle


--------------------------------------------------------------------------------
/docs/build/doctrees/index.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/doctrees/index.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/modules.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/doctrees/modules.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/snntoolbox.io_utils.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/doctrees/snntoolbox.io_utils.doctree


--------------------------------------------------------------------------------
/docs/build/html/.buildinfo:
--------------------------------------------------------------------------------
1 | # Sphinx build info version 1
2 | # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
3 | config: 5f4ba02e4f6aebe8580effbd0c2577d4
4 | tags: 645f666f9bcd5a90fca523b33c5a78b7
5 | 


--------------------------------------------------------------------------------
/docs/build/html/_images/gui_parameters.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_images/gui_parameters.png


--------------------------------------------------------------------------------
/docs/build/html/_images/gui_plots.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_images/gui_plots.png


--------------------------------------------------------------------------------
/docs/build/html/_images/workflow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_images/workflow.png


--------------------------------------------------------------------------------
/docs/build/html/_sources/citation.rst.txt:
--------------------------------------------------------------------------------
 1 | .. # coding=utf-8
 2 | 
 3 | Citation
 4 | ========
 5 | 
 6 | If you use this work in your research, please cite our corresponding Frontiers publication:
 7 | 
 8 | ::
 9 | 
10 |     Rueckauer, B. and Lungu, I.A. and Hu, Y. and Liu, S.C. and Pfeiffer, M.
11 |     Conversion of deep analog networks to efficient event-driven networks for image classification,
12 |     Frontiers in Neuroscience, 2017
13 | 
14 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/intro.rst.txt:
--------------------------------------------------------------------------------
  1 | .. # coding=utf-8
  2 | 
  3 | Spiking neural network conversion toolbox
  4 | =========================================
  5 | 
  6 | Introduction
  7 | ------------
  8 | 
  9 | Artificial neural networks have been studied and used extensively to solve tasks
 10 | from machine learning and artificial intelligence. *Deep Learning* has developed
 11 | increasingly large neural networks, spanning up to thousands of layers and
 12 | millions of neurons. These networks have proven to be very successful in solving
 13 | challenging tasks like object detection and recognition, scene segmentation and
 14 | parsing, video classification, etc. The downside is that running such large
 15 | networks requires massive amounts of computational resources.
 16 | 
 17 | Our research group at the University of Zurich and ETH Zurich develops
 18 | *Spiking Neural Networks* (SNNs) that perform the same task but with potentially
 19 | less computations and energy consumption. The fundamental idea is that in a
 20 | spiking network, all computation is *event-driven*, meaning that operations are
 21 | sparse and occur only when significant changes in the input make them necessary.
 22 | 
 23 | Training a deep spiking network (i.e. learning the synaptic weights) is
 24 | difficult. An alternative approach is to take a pre-trained neural network and
 25 | convert it into a spiking neural network. We call the original network
 26 | *Analog Neural Network* (ANN) because its activations are real-valued,
 27 | representing spike-rates. In this ANN-to-SNN conversion, we use the weights of
 28 | the ANN and replace the analog (rate) neurons of the ANN by simple
 29 | Integrate-and-Fire spiking neurons. This works because over the course of the
 30 | simulation, the average firing rate of the SNN neurons will approximate the
 31 | activation of the corresponding neurons in the original ANN. See :doc:`citation`
 32 | for details.
 33 | 
 34 | This toolbox automates the conversion of pre-trained analog to spiking neural
 35 | networks (ANN to SNN), and provides tools for testing the SNNs in a spiking
 36 | neuron simulator.
 37 | 
 38 | .. figure:: images/workflow.png
 39 |    :scale: 50 %
 40 |    :alt: Workflow diagram of the SNN toolbox.
 41 | 
 42 | Internal workflow
 43 | -----------------
 44 | 
 45 | Parsing and converting
 46 | **********************
 47 | 
 48 | Given a model written in some neural network library, the toolbox parses the
 49 | provided network files by extracting the relevant information and creating an
 50 | equivalent Keras model from it. This parsed model serves as common abstraction
 51 | stage from the input and is internally used by the toolbox to perform the actual
 52 | conversion to a spiking network.
 53 | 
 54 | The conversion toolbox currently supports input networks generated with
 55 | `Keras <https://keras.io/>`_,
 56 | `Lasagne <https://lasagne.readthedocs.io/en/latest/>`_, or
 57 | `Caffe <http://caffe.berkeleyvision.org/>`_. See :doc:`extending` on how to
 58 | extend the relevant methods to handle models from other common libraries like
 59 | Torch.
 60 | 
 61 | The following table lists the input files expected by the toolbox.
 62 | 
 63 | .. figure:: images/input_specs.png
 64 |    :scale: 50 %
 65 |    :alt: Input format specifications.
 66 | 
 67 | The second column in the following table summarized which features of the input
 68 | model the toolbox knows about and can handle.
 69 | 
 70 | .. _simulating:
 71 | 
 72 | Simulating
 73 | **********
 74 | 
 75 | After the input model has been converted, the resulting spiking network can be
 76 | exported for simulation in a spiking simulator or deployment on dedicated
 77 | spiking neuron chips. Currently, the following output formats are supported (see
 78 | :doc:`extending` on how to add a simulator to the toolbox):
 79 | 
 80 |     - `pyNN <http://neuralensemble.org/docs/PyNN/>`_ models. pyNN is a simulator
 81 |       -independent language for building neural network
 82 |       models. It allows running the converted net in a spiking simulator like
 83 |       `Brian <http://briansimulator.org/>`_,
 84 |       `Nest <http://www.nest-simulator.org/>`_,
 85 |       `Neuron <https://www.neuron.yale.edu/neuron/>`_, or by a custom simulator
 86 |       that allows pyNN models as inputs.
 87 |     - `Brian2 <http://brian2.readthedocs.io/en/latest/index.html#>`_.
 88 |     - The toolbox integrates MegaSim, an event-driven asynchronous spiking
 89 |       simulator developed at the University of Seville.
 90 |     - The toolbox provides a built-in simulator based on Keras, called INIsim.
 91 |       This simulator features a very simple integrate-and-fire neuron. By
 92 |       dispensing with redundant parameters and implementing a highly parallel
 93 |       simulation, the run time is reduced by several orders of magnitude,
 94 |       without compromising accuracy.
 95 | 
 96 | The second column in the table below compares these different simulators with
 97 | respect to the network features that can be implemented on them.
 98 | 
 99 | .. figure:: images/features.png
100 |    :scale: 100 %
101 |    :alt: Supported features in input and output model.
102 | 
103 | 
104 | Additionaly, a number of experimental features were implemented to improve and
105 | test the spiking network. They are currently only available in INIsim, and
106 | include:
107 | 
108 |    - Clamping of membrane potentials for a given time for each layer.
109 |    - Clipping membrane potentials to certain bounds.
110 |    - Activity-dependent adaptation of spike thresholds of each layer.
111 |    - Bias-relaxation.
112 |    - Spikes with payloads.
113 |    - Various reset mechanisms after spikes.
114 |    - Logging and visualization functions to monitor and debug simulation.
115 |    - Different input types: In all other simulators, only Poisson input is
116 |      supported at the moment. INIsim implements constant input currents as well
117 |      as input from DVS event sequences.
118 |    - Batch-wise testing.
119 | 
120 | 
121 | GUI (beta)
122 | ----------
123 | 
124 | .. figure:: images/gui_parameters.png
125 |    :scale: 50 %
126 |    :alt: Snapshot of the SNN toolbox GUI.
127 | 
128 |    **SNN toolbox GUI.** In the main window, the user can specify which tools to
129 |    use during the experiment. Also, parameters of the neuron cells used during
130 |    simulation can be set. The GUI saves and reloads last settings automatically,
131 |    and allows saving and loading preferences manually. Tooltips explain all
132 |    functionality.
133 | 
134 | .. figure:: images/gui_plots.png
135 |    :scale: 50 %
136 |    :alt: Snapshot of the SNN toolbox GUI plot window.
137 | 
138 |    **SNN toolbox GUI plot window.** The toolbox looks for plots in the specified
139 |    working directory. The user can select one or several layers, for which the
140 |    results of a test run will be displayed in a way that facilitates examining
141 |    and comparing results of each layer of the network. The example above
142 |    compares ANN activations to SNN spikerates for the first convolutional layer
143 |    on the MNIST dataset.
144 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/modules.rst.txt:
--------------------------------------------------------------------------------
1 | snntoolbox
2 | ==========
3 | 
4 | .. toctree::
5 |    :maxdepth: 4
6 | 
7 |    snntoolbox
8 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/running.rst.txt:
--------------------------------------------------------------------------------
 1 | .. # coding=utf-8
 2 | 
 3 | Getting started
 4 | ===============
 5 | 
 6 | In a terminal window, type ``snntoolbox -h`` to get all command-line options.
 7 | 
 8 | The basic use is::
 9 | 
10 |    snntoolbox settings.txt -t
11 | 
12 | The positional argument ``settings.txt`` specifies the path to a text file containing the settings to be used (in form of a python dictionary).
13 | 
14 | With ``-t``, we tell the program to stay in the terminal. Omitting this flag opens the GUI (beta).
15 | 
16 | See :doc:`examples` for typical usecases.
17 | 
18 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/snntoolbox.core.rst.txt:
--------------------------------------------------------------------------------
 1 | snntoolbox\.core package
 2 | ========================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | snntoolbox\.core\.ebsim module
 8 | ------------------------------
 9 | 
10 | .. automodule:: snntoolbox.core.ebsim
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | snntoolbox\.core\.inisim module
16 | -------------------------------
17 | 
18 | .. automodule:: snntoolbox.core.inisim
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | snntoolbox\.core\.pipeline module
24 | ---------------------------------
25 | 
26 | .. automodule:: snntoolbox.core.pipeline
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 
31 | snntoolbox\.core\.util module
32 | -----------------------------
33 | 
34 | .. automodule:: snntoolbox.core.util
35 |     :members:
36 |     :undoc-members:
37 |     :show-inheritance:
38 | 
39 | 
40 | Module contents
41 | ---------------
42 | 
43 | .. automodule:: snntoolbox.core
44 |     :members:
45 |     :undoc-members:
46 |     :show-inheritance:
47 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/snntoolbox.gui.rst.txt:
--------------------------------------------------------------------------------
 1 | snntoolbox\.gui package
 2 | =======================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | snntoolbox\.gui\.gui module
 8 | ---------------------------
 9 | 
10 | .. automodule:: snntoolbox.gui.gui
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | snntoolbox\.gui\.tooltip module
16 | -------------------------------
17 | 
18 | .. automodule:: snntoolbox.gui.tooltip
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | 
24 | Module contents
25 | ---------------
26 | 
27 | .. automodule:: snntoolbox.gui
28 |     :members:
29 |     :undoc-members:
30 |     :show-inheritance:
31 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/snntoolbox.io_utils.AedatTools.rst.txt:
--------------------------------------------------------------------------------
 1 | snntoolbox\.io\_utils\.AedatTools package
 2 | =========================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | snntoolbox\.io\_utils\.AedatTools\.DVSIterator module
 8 | -----------------------------------------------------
 9 | 
10 | .. automodule:: snntoolbox.io_utils.AedatTools.DVSIterator
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | snntoolbox\.io\_utils\.AedatTools\.ImportAedat module
16 | -----------------------------------------------------
17 | 
18 | .. automodule:: snntoolbox.io_utils.AedatTools.ImportAedat
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | snntoolbox\.io\_utils\.AedatTools\.ImportAedatBasicSourceName module
24 | --------------------------------------------------------------------
25 | 
26 | .. automodule:: snntoolbox.io_utils.AedatTools.ImportAedatBasicSourceName
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 
31 | snntoolbox\.io\_utils\.AedatTools\.ImportAedatDataVersion1or2 module
32 | --------------------------------------------------------------------
33 | 
34 | .. automodule:: snntoolbox.io_utils.AedatTools.ImportAedatDataVersion1or2
35 |     :members:
36 |     :undoc-members:
37 |     :show-inheritance:
38 | 
39 | snntoolbox\.io\_utils\.AedatTools\.ImportAedatHeaders module
40 | ------------------------------------------------------------
41 | 
42 | .. automodule:: snntoolbox.io_utils.AedatTools.ImportAedatHeaders
43 |     :members:
44 |     :undoc-members:
45 |     :show-inheritance:
46 | 
47 | snntoolbox\.io\_utils\.AedatTools\.avi\_to\_lmdb module
48 | -------------------------------------------------------
49 | 
50 | .. automodule:: snntoolbox.io_utils.AedatTools.avi_to_lmdb
51 |     :members:
52 |     :undoc-members:
53 |     :show-inheritance:
54 | 
55 | 
56 | Module contents
57 | ---------------
58 | 
59 | .. automodule:: snntoolbox.io_utils.AedatTools
60 |     :members:
61 |     :undoc-members:
62 |     :show-inheritance:
63 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/snntoolbox.io_utils.load_dataset.rst.txt:
--------------------------------------------------------------------------------
 1 | snntoolbox\.io\_utils\.load\_dataset package
 2 | ============================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | snntoolbox\.io\_utils\.load\_dataset\.caltech101\_load module
 8 | -------------------------------------------------------------
 9 | 
10 | .. automodule:: snntoolbox.io_utils.load_dataset.caltech101_load
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | snntoolbox\.io\_utils\.load\_dataset\.cifar10\_load module
16 | ----------------------------------------------------------
17 | 
18 | .. automodule:: snntoolbox.io_utils.load_dataset.cifar10_load
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | snntoolbox\.io\_utils\.load\_dataset\.facedetection\_load module
24 | ----------------------------------------------------------------
25 | 
26 | .. automodule:: snntoolbox.io_utils.load_dataset.facedetection_load
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 
31 | snntoolbox\.io\_utils\.load\_dataset\.imagenet\_load module
32 | -----------------------------------------------------------
33 | 
34 | .. automodule:: snntoolbox.io_utils.load_dataset.imagenet_load
35 |     :members:
36 |     :undoc-members:
37 |     :show-inheritance:
38 | 
39 | snntoolbox\.io\_utils\.load\_dataset\.inception\_v3\_load module
40 | ----------------------------------------------------------------
41 | 
42 | .. automodule:: snntoolbox.io_utils.load_dataset.inception_v3_load
43 |     :members:
44 |     :undoc-members:
45 |     :show-inheritance:
46 | 
47 | snntoolbox\.io\_utils\.load\_dataset\.mnist\_load module
48 | --------------------------------------------------------
49 | 
50 | .. automodule:: snntoolbox.io_utils.load_dataset.mnist_load
51 |     :members:
52 |     :undoc-members:
53 |     :show-inheritance:
54 | 
55 | 
56 | Module contents
57 | ---------------
58 | 
59 | .. automodule:: snntoolbox.io_utils.load_dataset
60 |     :members:
61 |     :undoc-members:
62 |     :show-inheritance:
63 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/snntoolbox.io_utils.rst.txt:
--------------------------------------------------------------------------------
 1 | snntoolbox\.io\_utils package
 2 | =============================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     snntoolbox.io_utils.AedatTools
10 |     snntoolbox.io_utils.load_dataset
11 | 
12 | Submodules
13 | ----------
14 | 
15 | snntoolbox\.io\_utils\.common module
16 | ------------------------------------
17 | 
18 | .. automodule:: snntoolbox.io_utils.common
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | snntoolbox\.io\_utils\.draw\_convnet module
24 | -------------------------------------------
25 | 
26 | .. automodule:: snntoolbox.io_utils.draw_convnet
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 
31 | snntoolbox\.io\_utils\.plotting module
32 | --------------------------------------
33 | 
34 | .. automodule:: snntoolbox.io_utils.plotting
35 |     :members:
36 |     :undoc-members:
37 |     :show-inheritance:
38 | 
39 | 
40 | Module contents
41 | ---------------
42 | 
43 | .. automodule:: snntoolbox.io_utils
44 |     :members:
45 |     :undoc-members:
46 |     :show-inheritance:
47 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/snntoolbox.model_libs.rst.txt:
--------------------------------------------------------------------------------
 1 | snntoolbox\.model\_libs package
 2 | ===============================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | snntoolbox\.model\_libs\.caffe\_input\_lib module
 8 | -------------------------------------------------
 9 | 
10 | .. automodule:: snntoolbox.model_libs.caffe_input_lib
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | snntoolbox\.model\_libs\.common module
16 | --------------------------------------
17 | 
18 | .. automodule:: snntoolbox.model_libs.common
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | snntoolbox\.model\_libs\.keras\_input\_lib module
24 | -------------------------------------------------
25 | 
26 | .. automodule:: snntoolbox.model_libs.keras_input_lib
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 
31 | snntoolbox\.model\_libs\.lasagne\_input\_lib module
32 | ---------------------------------------------------
33 | 
34 | .. automodule:: snntoolbox.model_libs.lasagne_input_lib
35 |     :members:
36 |     :undoc-members:
37 |     :show-inheritance:
38 | 
39 | 
40 | Module contents
41 | ---------------
42 | 
43 | .. automodule:: snntoolbox.model_libs
44 |     :members:
45 |     :undoc-members:
46 |     :show-inheritance:
47 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/snntoolbox.rst.txt:
--------------------------------------------------------------------------------
 1 | snntoolbox package
 2 | ==================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     snntoolbox.core
10 |     snntoolbox.gui
11 |     snntoolbox.io_utils
12 |     snntoolbox.model_libs
13 |     snntoolbox.target_simulators
14 | 
15 | Submodules
16 | ----------
17 | 
18 | snntoolbox\.config module
19 | -------------------------
20 | 
21 | .. automodule:: snntoolbox.config
22 |     :members:
23 |     :undoc-members:
24 |     :show-inheritance:
25 | 
26 | snntoolbox\.run module
27 | ----------------------
28 | 
29 | .. automodule:: snntoolbox.run
30 |     :members:
31 |     :undoc-members:
32 |     :show-inheritance:
33 | 
34 | 
35 | Module contents
36 | ---------------
37 | 
38 | .. automodule:: snntoolbox
39 |     :members:
40 |     :undoc-members:
41 |     :show-inheritance:
42 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/snntoolbox.target_simulators.rst.txt:
--------------------------------------------------------------------------------
 1 | snntoolbox\.target\_simulators package
 2 | ======================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | snntoolbox\.target\_simulators\.INI\_target\_sim module
 8 | -------------------------------------------------------
 9 | 
10 | .. automodule:: snntoolbox.target_simulators.INI_target_sim
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | snntoolbox\.target\_simulators\.INIeb\_target\_sim module
16 | ---------------------------------------------------------
17 | 
18 | .. automodule:: snntoolbox.target_simulators.INIeb_target_sim
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | snntoolbox\.target\_simulators\.MegaSim\_target\_sim module
24 | -----------------------------------------------------------
25 | 
26 | .. automodule:: snntoolbox.target_simulators.MegaSim_target_sim
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 
31 | snntoolbox\.target\_simulators\.neuron\_target\_sim module
32 | ----------------------------------------------------------
33 | 
34 | .. automodule:: snntoolbox.target_simulators.Neuron_target_sim
35 |     :members:
36 |     :undoc-members:
37 |     :show-inheritance:
38 | 
39 | snntoolbox\.target\_simulators\.brian2\_target\_sim module
40 | ----------------------------------------------------------
41 | 
42 | .. automodule:: snntoolbox.target_simulators.brian2_target_sim
43 |     :members:
44 |     :undoc-members:
45 |     :show-inheritance:
46 | 
47 | snntoolbox\.target\_simulators\.brian\_target\_sim module
48 | ---------------------------------------------------------
49 | 
50 | .. automodule:: snntoolbox.target_simulators.brian_target_sim
51 |     :members:
52 |     :undoc-members:
53 |     :show-inheritance:
54 | 
55 | snntoolbox\.target\_simulators\.common module
56 | ---------------------------------------------
57 | 
58 | .. automodule:: snntoolbox.target_simulators.common
59 |     :members:
60 |     :undoc-members:
61 |     :show-inheritance:
62 | 
63 | snntoolbox\.target\_simulators\.megasim module
64 | ----------------------------------------------
65 | 
66 | .. automodule:: snntoolbox.target_simulators.megasim
67 |     :members:
68 |     :undoc-members:
69 |     :show-inheritance:
70 | 
71 | snntoolbox\.target\_simulators\.nest\_target\_sim module
72 | --------------------------------------------------------
73 | 
74 | .. automodule:: snntoolbox.target_simulators.nest_target_sim
75 |     :members:
76 |     :undoc-members:
77 |     :show-inheritance:
78 | 
79 | snntoolbox\.target\_simulators\.pyNN\_target\_sim module
80 | --------------------------------------------------------
81 | 
82 | .. automodule:: snntoolbox.target_simulators.pyNN_target_sim
83 |     :members:
84 |     :undoc-members:
85 |     :show-inheritance:
86 | 
87 | 
88 | Module contents
89 | ---------------
90 | 
91 | .. automodule:: snntoolbox.target_simulators
92 |     :members:
93 |     :undoc-members:
94 |     :show-inheritance:
95 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/support.rst.txt:
--------------------------------------------------------------------------------
 1 | .. # coding=utf-8
 2 | 
 3 | Support
 4 | =======
 5 | 
 6 | For questions and feedback, please write to
 7 | 
 8 | Bodo Rueckauer
 9 | 
10 | rbodo(at)ini(dot)uzh(dot)ch
11 | 
12 | We are happy to hear from you!
13 | 
14 | 


--------------------------------------------------------------------------------
/docs/build/html/_static/ajax-loader.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/ajax-loader.gif


--------------------------------------------------------------------------------
/docs/build/html/_static/comment-bright.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/comment-bright.png


--------------------------------------------------------------------------------
/docs/build/html/_static/comment-close.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/comment-close.png


--------------------------------------------------------------------------------
/docs/build/html/_static/comment.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/comment.png


--------------------------------------------------------------------------------
/docs/build/html/_static/css/badge_only.css:
--------------------------------------------------------------------------------
1 | .fa:before{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:before,.clearfix:after{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-weight:normal;font-style:normal;src:url("../fonts/fontawesome-webfont.eot");src:url("../fonts/fontawesome-webfont.eot?#iefix") format("embedded-opentype"),url("../fonts/fontawesome-webfont.woff") format("woff"),url("../fonts/fontawesome-webfont.ttf") format("truetype"),url("../fonts/fontawesome-webfont.svg#FontAwesome") format("svg")}.fa:before{display:inline-block;font-family:FontAwesome;font-style:normal;font-weight:normal;line-height:1;text-decoration:inherit}a .fa{display:inline-block;text-decoration:inherit}li .fa{display:inline-block}li .fa-large:before,li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-0.8em}ul.fas li .fa{width:.8em}ul.fas li .fa-large:before,ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before{content:""}.icon-book:before{content:""}.fa-caret-down:before{content:""}.icon-caret-down:before{content:""}.fa-caret-up:before{content:""}.icon-caret-up:before{content:""}.fa-caret-left:before{content:""}.icon-caret-left:before{content:""}.fa-caret-right:before{content:""}.icon-caret-right:before{content:""}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:"Lato","proxima-nova","Helvetica Neue",Arial,sans-serif;z-index:400}.rst-versions a{color:#2980B9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27AE60;*zoom:1}.rst-versions .rst-current-version:before,.rst-versions .rst-current-version:after{display:table;content:""}.rst-versions .rst-current-version:after{clear:both}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book{float:left}.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#E74C3C;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#F1C40F;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:gray;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:solid 1px #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .icon-book{float:none}.rst-versions.rst-badge .fa-book{float:none}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book{float:left}.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge .rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width: 768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}
2 | 


--------------------------------------------------------------------------------
/docs/build/html/_static/down-pressed.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/down-pressed.png


--------------------------------------------------------------------------------
/docs/build/html/_static/down.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/down.png


--------------------------------------------------------------------------------
/docs/build/html/_static/file.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/file.png


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Inconsolata-Bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/fonts/Inconsolata-Bold.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Inconsolata-Regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/fonts/Inconsolata-Regular.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato-Bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/fonts/Lato-Bold.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato-Regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/fonts/Lato-Regular.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/RobotoSlab-Bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/fonts/RobotoSlab-Bold.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/RobotoSlab-Regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/fonts/RobotoSlab-Regular.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/fonts/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/fonts/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/fonts/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/js/theme.js:
--------------------------------------------------------------------------------
1 | /* sphinx_rtd_theme version 0.4.3 | MIT license */
2 | /* Built 20190212 16:02 */
3 | require=function r(s,a,l){function c(e,n){if(!a[e]){if(!s[e]){var i="function"==typeof require&&require;if(!n&&i)return i(e,!0);if(u)return u(e,!0);var t=new Error("Cannot find module '"+e+"'");throw t.code="MODULE_NOT_FOUND",t}var o=a[e]={exports:{}};s[e][0].call(o.exports,function(n){return c(s[e][1][n]||n)},o,o.exports,r,s,a,l)}return a[e].exports}for(var u="function"==typeof require&&require,n=0;n<l.length;n++)c(l[n]);return c}({"sphinx-rtd-theme":[function(n,e,i){var jQuery="undefined"!=typeof window?window.jQuery:n("jquery");e.exports.ThemeNav={navBar:null,win:null,winScroll:!1,winResize:!1,linkScroll:!1,winPosition:0,winHeight:null,docHeight:null,isRunning:!1,enable:function(e){var i=this;void 0===e&&(e=!0),i.isRunning||(i.isRunning=!0,jQuery(function(n){i.init(n),i.reset(),i.win.on("hashchange",i.reset),e&&i.win.on("scroll",function(){i.linkScroll||i.winScroll||(i.winScroll=!0,requestAnimationFrame(function(){i.onScroll()}))}),i.win.on("resize",function(){i.winResize||(i.winResize=!0,requestAnimationFrame(function(){i.onResize()}))}),i.onResize()}))},enableSticky:function(){this.enable(!0)},init:function(i){i(document);var t=this;this.navBar=i("div.wy-side-scroll:first"),this.win=i(window),i(document).on("click","[data-toggle='wy-nav-top']",function(){i("[data-toggle='wy-nav-shift']").toggleClass("shift"),i("[data-toggle='rst-versions']").toggleClass("shift")}).on("click",".wy-menu-vertical .current ul li a",function(){var n=i(this);i("[data-toggle='wy-nav-shift']").removeClass("shift"),i("[data-toggle='rst-versions']").toggleClass("shift"),t.toggleCurrent(n),t.hashChange()}).on("click","[data-toggle='rst-current-version']",function(){i("[data-toggle='rst-versions']").toggleClass("shift-up")}),i("table.docutils:not(.field-list,.footnote,.citation)").wrap("<div class='wy-table-responsive'></div>"),i("table.docutils.footnote").wrap("<div class='wy-table-responsive footnote'></div>"),i("table.docutils.citation").wrap("<div class='wy-table-responsive citation'></div>"),i(".wy-menu-vertical ul").not(".simple").siblings("a").each(function(){var e=i(this);expand=i('<span class="toctree-expand"></span>'),expand.on("click",function(n){return t.toggleCurrent(e),n.stopPropagation(),!1}),e.prepend(expand)})},reset:function(){var n=encodeURI(window.location.hash)||"#";try{var e=$(".wy-menu-vertical"),i=e.find('[href="'+n+'"]');if(0===i.length){var t=$('.document [id="'+n.substring(1)+'"]').closest("div.section");0===(i=e.find('[href="#'+t.attr("id")+'"]')).length&&(i=e.find('[href="#"]'))}0<i.length&&($(".wy-menu-vertical .current").removeClass("current"),i.addClass("current"),i.closest("li.toctree-l1").addClass("current"),i.closest("li.toctree-l1").parent().addClass("current"),i.closest("li.toctree-l1").addClass("current"),i.closest("li.toctree-l2").addClass("current"),i.closest("li.toctree-l3").addClass("current"),i.closest("li.toctree-l4").addClass("current"),i[0].scrollIntoView())}catch(o){console.log("Error expanding nav for anchor",o)}},onScroll:function(){this.winScroll=!1;var n=this.win.scrollTop(),e=n+this.winHeight,i=this.navBar.scrollTop()+(n-this.winPosition);n<0||e>this.docHeight||(this.navBar.scrollTop(i),this.winPosition=n)},onResize:function(){this.winResize=!1,this.winHeight=this.win.height(),this.docHeight=$(document).height()},hashChange:function(){this.linkScroll=!0,this.win.one("hashchange",function(){this.linkScroll=!1})},toggleCurrent:function(n){var e=n.closest("li");e.siblings("li.current").removeClass("current"),e.siblings().find("li.current").removeClass("current"),e.find("> ul li.current").removeClass("current"),e.toggleClass("current")}},"undefined"!=typeof window&&(window.SphinxRtdTheme={Navigation:e.exports.ThemeNav,StickyNav:e.exports.ThemeNav}),function(){for(var r=0,n=["ms","moz","webkit","o"],e=0;e<n.length&&!window.requestAnimationFrame;++e)window.requestAnimationFrame=window[n[e]+"RequestAnimationFrame"],window.cancelAnimationFrame=window[n[e]+"CancelAnimationFrame"]||window[n[e]+"CancelRequestAnimationFrame"];window.requestAnimationFrame||(window.requestAnimationFrame=function(n,e){var i=(new Date).getTime(),t=Math.max(0,16-(i-r)),o=window.setTimeout(function(){n(i+t)},t);return r=i+t,o}),window.cancelAnimationFrame||(window.cancelAnimationFrame=function(n){clearTimeout(n)})}()},{jquery:"jquery"}]},{},["sphinx-rtd-theme"]);


--------------------------------------------------------------------------------
/docs/build/html/_static/minus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/minus.png


--------------------------------------------------------------------------------
/docs/build/html/_static/plus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/plus.png


--------------------------------------------------------------------------------
/docs/build/html/_static/pygments.css:
--------------------------------------------------------------------------------
 1 | .highlight .hll { background-color: #ffffcc }
 2 | .highlight  { background: #eeffcc; }
 3 | .highlight .c { color: #408090; font-style: italic } /* Comment */
 4 | .highlight .err { border: 1px solid #FF0000 } /* Error */
 5 | .highlight .k { color: #007020; font-weight: bold } /* Keyword */
 6 | .highlight .o { color: #666666 } /* Operator */
 7 | .highlight .ch { color: #408090; font-style: italic } /* Comment.Hashbang */
 8 | .highlight .cm { color: #408090; font-style: italic } /* Comment.Multiline */
 9 | .highlight .cp { color: #007020 } /* Comment.Preproc */
10 | .highlight .cpf { color: #408090; font-style: italic } /* Comment.PreprocFile */
11 | .highlight .c1 { color: #408090; font-style: italic } /* Comment.Single */
12 | .highlight .cs { color: #408090; background-color: #fff0f0 } /* Comment.Special */
13 | .highlight .gd { color: #A00000 } /* Generic.Deleted */
14 | .highlight .ge { font-style: italic } /* Generic.Emph */
15 | .highlight .gr { color: #FF0000 } /* Generic.Error */
16 | .highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
17 | .highlight .gi { color: #00A000 } /* Generic.Inserted */
18 | .highlight .go { color: #333333 } /* Generic.Output */
19 | .highlight .gp { color: #c65d09; font-weight: bold } /* Generic.Prompt */
20 | .highlight .gs { font-weight: bold } /* Generic.Strong */
21 | .highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
22 | .highlight .gt { color: #0044DD } /* Generic.Traceback */
23 | .highlight .kc { color: #007020; font-weight: bold } /* Keyword.Constant */
24 | .highlight .kd { color: #007020; font-weight: bold } /* Keyword.Declaration */
25 | .highlight .kn { color: #007020; font-weight: bold } /* Keyword.Namespace */
26 | .highlight .kp { color: #007020 } /* Keyword.Pseudo */
27 | .highlight .kr { color: #007020; font-weight: bold } /* Keyword.Reserved */
28 | .highlight .kt { color: #902000 } /* Keyword.Type */
29 | .highlight .m { color: #208050 } /* Literal.Number */
30 | .highlight .s { color: #4070a0 } /* Literal.String */
31 | .highlight .na { color: #4070a0 } /* Name.Attribute */
32 | .highlight .nb { color: #007020 } /* Name.Builtin */
33 | .highlight .nc { color: #0e84b5; font-weight: bold } /* Name.Class */
34 | .highlight .no { color: #60add5 } /* Name.Constant */
35 | .highlight .nd { color: #555555; font-weight: bold } /* Name.Decorator */
36 | .highlight .ni { color: #d55537; font-weight: bold } /* Name.Entity */
37 | .highlight .ne { color: #007020 } /* Name.Exception */
38 | .highlight .nf { color: #06287e } /* Name.Function */
39 | .highlight .nl { color: #002070; font-weight: bold } /* Name.Label */
40 | .highlight .nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */
41 | .highlight .nt { color: #062873; font-weight: bold } /* Name.Tag */
42 | .highlight .nv { color: #bb60d5 } /* Name.Variable */
43 | .highlight .ow { color: #007020; font-weight: bold } /* Operator.Word */
44 | .highlight .w { color: #bbbbbb } /* Text.Whitespace */
45 | .highlight .mb { color: #208050 } /* Literal.Number.Bin */
46 | .highlight .mf { color: #208050 } /* Literal.Number.Float */
47 | .highlight .mh { color: #208050 } /* Literal.Number.Hex */
48 | .highlight .mi { color: #208050 } /* Literal.Number.Integer */
49 | .highlight .mo { color: #208050 } /* Literal.Number.Oct */
50 | .highlight .sa { color: #4070a0 } /* Literal.String.Affix */
51 | .highlight .sb { color: #4070a0 } /* Literal.String.Backtick */
52 | .highlight .sc { color: #4070a0 } /* Literal.String.Char */
53 | .highlight .dl { color: #4070a0 } /* Literal.String.Delimiter */
54 | .highlight .sd { color: #4070a0; font-style: italic } /* Literal.String.Doc */
55 | .highlight .s2 { color: #4070a0 } /* Literal.String.Double */
56 | .highlight .se { color: #4070a0; font-weight: bold } /* Literal.String.Escape */
57 | .highlight .sh { color: #4070a0 } /* Literal.String.Heredoc */
58 | .highlight .si { color: #70a0d0; font-style: italic } /* Literal.String.Interpol */
59 | .highlight .sx { color: #c65d09 } /* Literal.String.Other */
60 | .highlight .sr { color: #235388 } /* Literal.String.Regex */
61 | .highlight .s1 { color: #4070a0 } /* Literal.String.Single */
62 | .highlight .ss { color: #517918 } /* Literal.String.Symbol */
63 | .highlight .bp { color: #007020 } /* Name.Builtin.Pseudo */
64 | .highlight .fm { color: #06287e } /* Name.Function.Magic */
65 | .highlight .vc { color: #bb60d5 } /* Name.Variable.Class */
66 | .highlight .vg { color: #bb60d5 } /* Name.Variable.Global */
67 | .highlight .vi { color: #bb60d5 } /* Name.Variable.Instance */
68 | .highlight .vm { color: #bb60d5 } /* Name.Variable.Magic */
69 | .highlight .il { color: #208050 } /* Literal.Number.Integer.Long */


--------------------------------------------------------------------------------
/docs/build/html/_static/up-pressed.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/up-pressed.png


--------------------------------------------------------------------------------
/docs/build/html/_static/up.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/_static/up.png


--------------------------------------------------------------------------------
/docs/build/html/objects.inv:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/build/html/objects.inv


--------------------------------------------------------------------------------
/docs/build/html/search.html:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | <!DOCTYPE html>
  4 | <!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
  5 | <!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
  6 | <head>
  7 |   <meta charset="utf-8">
  8 |   
  9 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 10 |   
 11 |   <title>Search &mdash; SNN toolbox 0.5.0 documentation</title>
 12 |   
 13 | 
 14 |   
 15 |   
 16 |   
 17 |   
 18 | 
 19 |   
 20 |   <script type="text/javascript" src="_static/js/modernizr.min.js"></script>
 21 |   
 22 |     
 23 |       <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
 24 |         <script src="_static/jquery.js"></script>
 25 |         <script src="_static/underscore.js"></script>
 26 |         <script src="_static/doctools.js"></script>
 27 |         <script src="_static/language_data.js"></script>
 28 |         <script async="async" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
 29 |         <script src="_static/searchtools.js"></script>
 30 |     
 31 |     <script type="text/javascript" src="_static/js/theme.js"></script>
 32 | 
 33 |     
 34 | 
 35 |   
 36 |   <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
 37 |   <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
 38 |     <link rel="index" title="Index" href="genindex.html" />
 39 |     <link rel="search" title="Search" href="#" /> 
 40 | </head>
 41 | 
 42 | <body class="wy-body-for-nav">
 43 | 
 44 |    
 45 |   <div class="wy-grid-for-nav">
 46 |     
 47 |     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
 48 |       <div class="wy-side-scroll">
 49 |         <div class="wy-side-nav-search" >
 50 |           
 51 | 
 52 |           
 53 |             <a href="index.html" class="icon icon-home"> SNN toolbox
 54 |           
 55 | 
 56 |           
 57 |           </a>
 58 | 
 59 |           
 60 |             
 61 |             
 62 |               <div class="version">
 63 |                 0.5
 64 |               </div>
 65 |             
 66 |           
 67 | 
 68 |           
 69 | <div role="search">
 70 |   <form id="rtd-search-form" class="wy-form" action="#" method="get">
 71 |     <input type="text" name="q" placeholder="Search docs" />
 72 |     <input type="hidden" name="check_keywords" value="yes" />
 73 |     <input type="hidden" name="area" value="default" />
 74 |   </form>
 75 | </div>
 76 | 
 77 |           
 78 |         </div>
 79 | 
 80 |         <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
 81 |           
 82 |             
 83 |             
 84 |               
 85 |             
 86 |             
 87 |               <ul>
 88 | <li class="toctree-l1"><a class="reference internal" href="guide/intro.html">Spiking neural network conversion toolbox</a></li>
 89 | <li class="toctree-l1"><a class="reference internal" href="guide/installation.html">Installation</a></li>
 90 | <li class="toctree-l1"><a class="reference internal" href="guide/running.html">Getting started</a></li>
 91 | <li class="toctree-l1"><a class="reference internal" href="guide/configuration.html">Configuration</a></li>
 92 | <li class="toctree-l1"><a class="reference internal" href="guide/extending.html">Extending the toolbox</a></li>
 93 | <li class="toctree-l1"><a class="reference internal" href="guide/examples.html">Examples</a></li>
 94 | <li class="toctree-l1"><a class="reference internal" href="guide/citation.html">Citation</a></li>
 95 | <li class="toctree-l1"><a class="reference internal" href="guide/support.html">Support</a></li>
 96 | </ul>
 97 | <ul>
 98 | <li class="toctree-l1"><a class="reference internal" href="api/bin.html"><code class="docutils literal notranslate"><span class="pre">snntoolbox.bin</span></code></a></li>
 99 | <li class="toctree-l1"><a class="reference internal" href="api/parsing.html"><code class="docutils literal notranslate"><span class="pre">snntoolbox.parsing</span></code></a></li>
100 | <li class="toctree-l1"><a class="reference internal" href="api/conversion.html"><code class="docutils literal notranslate"><span class="pre">snntoolbox.conversion</span></code></a></li>
101 | <li class="toctree-l1"><a class="reference internal" href="api/simulation.html"><code class="docutils literal notranslate"><span class="pre">snntoolbox.simulation</span></code></a></li>
102 | <li class="toctree-l1"><a class="reference internal" href="api/datasets.html"><code class="docutils literal notranslate"><span class="pre">snntoolbox.datasets</span></code></a></li>
103 | <li class="toctree-l1"><a class="reference internal" href="api/utils.html"><code class="docutils literal notranslate"><span class="pre">snntoolbox.utils</span></code></a></li>
104 | </ul>
105 | 
106 |             
107 |           
108 |         </div>
109 |       </div>
110 |     </nav>
111 | 
112 |     <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
113 | 
114 |       
115 |       <nav class="wy-nav-top" aria-label="top navigation">
116 |         
117 |           <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
118 |           <a href="index.html">SNN toolbox</a>
119 |         
120 |       </nav>
121 | 
122 | 
123 |       <div class="wy-nav-content">
124 |         
125 |         <div class="rst-content">
126 |         
127 |           
128 | 
129 | 
130 | 
131 | 
132 | 
133 | 
134 | 
135 | 
136 | 
137 | 
138 | 
139 | 
140 | 
141 | 
142 | 
143 | <div role="navigation" aria-label="breadcrumbs navigation">
144 | 
145 |   <ul class="wy-breadcrumbs">
146 |     
147 |       <li><a href="index.html">Docs</a> &raquo;</li>
148 |         
149 |       <li>Search</li>
150 |     
151 |     
152 |       <li class="wy-breadcrumbs-aside">
153 |         
154 |             
155 |         
156 |       </li>
157 |     
158 |   </ul>
159 | 
160 |   
161 |   <hr/>
162 | </div>
163 |           <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
164 |            <div itemprop="articleBody">
165 |             
166 |   <noscript>
167 |   <div id="fallback" class="admonition warning">
168 |     <p class="last">
169 |       Please activate JavaScript to enable the search
170 |       functionality.
171 |     </p>
172 |   </div>
173 |   </noscript>
174 | 
175 |   
176 |   <div id="search-results">
177 |   
178 |   </div>
179 | 
180 |            </div>
181 |            
182 |           </div>
183 |           <footer>
184 |   
185 | 
186 |   <hr/>
187 | 
188 |   <div role="contentinfo">
189 |     <p>
190 |         &copy; Copyright 2020, Bodo Rueckauer
191 |       <span class="lastupdated">
192 |         Last updated on May 12, 2020.
193 |       </span>
194 | 
195 |     </p>
196 |   </div>
197 |   Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/rtfd/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>. 
198 | 
199 | </footer>
200 | 
201 |         </div>
202 |       </div>
203 | 
204 |     </section>
205 | 
206 |   </div>
207 |   
208 | 
209 | 
210 |   <script type="text/javascript">
211 |       jQuery(function () {
212 |           SphinxRtdTheme.Navigation.enable(true);
213 |       });
214 |   </script>
215 | 
216 |   
217 |   
218 |     
219 |   
220 |   <script type="text/javascript">
221 |     jQuery(function() { Search.loadIndex("searchindex.js"); });
222 |   </script>
223 |   
224 |   <script type="text/javascript" id="searchindexloader"></script>
225 |    
226 | 
227 | 
228 | </body>
229 | </html>


--------------------------------------------------------------------------------
/docs/source/api/bin.rst:
--------------------------------------------------------------------------------
 1 | ``snntoolbox.bin``
 2 | ==================
 3 | 
 4 | :mod:`snntoolbox.bin.run`
 5 | -------------------------
 6 | 
 7 | .. automodule:: snntoolbox.bin.run
 8 | 
 9 | :mod:`snntoolbox.bin.utils`
10 | ---------------------------
11 | 
12 | .. automodule:: snntoolbox.bin.utils
13 | 
14 | ``snntoolbox.bin.gui``
15 | ----------------------
16 | 
17 | :mod:`snntoolbox.bin.gui.gui`
18 | .............................
19 | 
20 | .. automodule:: snntoolbox.bin.gui.gui
21 | 


--------------------------------------------------------------------------------
/docs/source/api/conversion.rst:
--------------------------------------------------------------------------------
1 | ``snntoolbox.conversion``
2 | =========================
3 | 
4 | :mod:`snntoolbox.conversion.utils`
5 | ----------------------------------
6 | 
7 | .. automodule:: snntoolbox.conversion.utils
8 | 


--------------------------------------------------------------------------------
/docs/source/api/datasets.rst:
--------------------------------------------------------------------------------
 1 | ``snntoolbox.datasets``
 2 | =======================
 3 | 
 4 | The modules in this package provide functionality to load and process datasets
 5 | into the SNN conversion toolbox.
 6 | 
 7 | :mod:`snntoolbox.datasets.utils`
 8 | --------------------------------
 9 | 
10 | .. automodule:: snntoolbox.datasets.utils
11 | 


--------------------------------------------------------------------------------
/docs/source/api/parsing.rst:
--------------------------------------------------------------------------------
 1 | ``snntoolbox.parsing``
 2 | ======================
 3 | 
 4 | On the input side of the SNN conversion toolbox, models from the following
 5 | neural network libraries can be parsed:
 6 | 
 7 | .. autosummary::
 8 |     :nosignatures:
 9 | 
10 |     snntoolbox.parsing.model_libs.keras_input_lib
11 |     snntoolbox.parsing.model_libs.pytorch_input_lib
12 |     snntoolbox.parsing.model_libs.lasagne_input_lib
13 |     snntoolbox.parsing.model_libs.caffe_input_lib
14 | 
15 | These parsers inherit from `AbstractModelParser` in
16 | 
17 | .. autosummary::
18 |     :nosignatures:
19 | 
20 |     snntoolbox.parsing.utils
21 | 
22 | See :ref:`extending` on how to extend the toolbox by another input model
23 | library.
24 | 
25 | ``snntoolbox.parsing.model_libs``
26 | ---------------------------------
27 | 
28 | :mod:`~snntoolbox.parsing.model_libs.keras_input_lib`
29 | .....................................................
30 | 
31 | .. automodule:: snntoolbox.parsing.model_libs.keras_input_lib
32 | 
33 | :mod:`~snntoolbox.parsing.model_libs.pytorch_input_lib`
34 | .......................................................
35 | 
36 | .. automodule:: snntoolbox.parsing.model_libs.pytorch_input_lib
37 | 
38 | :mod:`~snntoolbox.parsing.model_libs.lasagne_input_lib`
39 | .......................................................
40 | 
41 | .. automodule:: snntoolbox.parsing.model_libs.lasagne_input_lib
42 | 
43 | :mod:`~snntoolbox.parsing.model_libs.caffe_input_lib`
44 | .....................................................
45 | 
46 | .. automodule:: snntoolbox.parsing.model_libs.caffe_input_lib
47 | 
48 | :mod:`snntoolbox.parsing.utils`
49 | -------------------------------
50 | 
51 | .. automodule:: snntoolbox.parsing.utils
52 | 


--------------------------------------------------------------------------------
/docs/source/api/simulation.rst:
--------------------------------------------------------------------------------
  1 | ``snntoolbox.simulation``
  2 | =========================
  3 | 
  4 | On the output side of the toolbox, the following simulators are currently
  5 | implemented:
  6 | 
  7 | .. autosummary::
  8 |     :nosignatures:
  9 | 
 10 |     ~snntoolbox.simulation.target_simulators.pyNN_target_sim
 11 |     ~snntoolbox.simulation.target_simulators.brian2_target_sim
 12 |     ~snntoolbox.simulation.target_simulators.MegaSim_target_sim
 13 |     ~snntoolbox.simulation.target_simulators.INI_temporal_mean_rate_target_sim
 14 |     ~snntoolbox.simulation.target_simulators.INI_temporal_pattern_target_sim
 15 |     ~snntoolbox.simulation.target_simulators.INI_ttfs_target_sim
 16 |     ~snntoolbox.simulation.target_simulators.INI_ttfs_dyn_thresh_target_sim
 17 |     ~snntoolbox.simulation.target_simulators.INI_ttfs_corrective_target_sim
 18 |     ~snntoolbox.simulation.target_simulators.loihi_target_sim
 19 |     ~snntoolbox.simulation.target_simulators.spiNNaker_target_sim
 20 | 
 21 | The abstract base class :py:class:`~snntoolbox.simulation.utils.AbstractSNN` for
 22 | the simulation tools above is contained here:
 23 | 
 24 | .. autosummary::
 25 |     :nosignatures:
 26 | 
 27 |     snntoolbox.simulation.utils
 28 | 
 29 | See :ref:`extending` on how to extend the toolbox by another simulator.
 30 | 
 31 | The backends for our built-in simulator ``INIsim`` and the custom simulator
 32 | ``MegaSim`` are included here:
 33 | 
 34 | .. autosummary::
 35 |     :nosignatures:
 36 | 
 37 |     ~snntoolbox.simulation.backends.inisim.temporal_mean_rate_tensorflow
 38 |     ~snntoolbox.simulation.backends.inisim.temporal_mean_rate_theano
 39 |     ~snntoolbox.simulation.backends.inisim.temporal_pattern
 40 |     ~snntoolbox.simulation.backends.inisim.ttfs
 41 |     ~snntoolbox.simulation.backends.inisim.ttfs_dyn_thresh
 42 |     ~snntoolbox.simulation.backends.inisim.ttfs_corrective
 43 |     ~snntoolbox.simulation.backends.megasim.megasim
 44 | 
 45 | Finally, utility functions for plotting are contained in
 46 | 
 47 | .. autosummary::
 48 |     :nosignatures:
 49 | 
 50 |     snntoolbox.simulation.plotting
 51 | 
 52 | :mod:`snntoolbox.simulation.utils`
 53 | ----------------------------------
 54 | 
 55 | .. automodule:: snntoolbox.simulation.utils
 56 | 
 57 | :mod:`snntoolbox.simulation.plotting`
 58 | -------------------------------------
 59 | 
 60 | .. automodule:: snntoolbox.simulation.plotting
 61 | 
 62 | ``snntoolbox.simulation.backends``
 63 | ----------------------------------
 64 | 
 65 | :mod:`~snntoolbox.simulation.backends.inisim`
 66 | .............................................
 67 | 
 68 | :mod:`~snntoolbox.simulation.backends.inisim.temporal_mean_rate_tensorflow`
 69 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 70 | .. automodule:: snntoolbox.simulation.backends.inisim.temporal_mean_rate_tensorflow
 71 | 
 72 | :mod:`~snntoolbox.simulation.backends.inisim.temporal_mean_rate_theano`
 73 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 74 | .. automodule:: snntoolbox.simulation.backends.inisim.temporal_mean_rate_theano
 75 | 
 76 | :mod:`~snntoolbox.simulation.backends.inisim.temporal_pattern`
 77 | ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 78 | .. automodule:: snntoolbox.simulation.backends.inisim.temporal_pattern
 79 | 
 80 | :mod:`~snntoolbox.simulation.backends.inisim.ttfs`
 81 | ++++++++++++++++++++++++++++++++++++++++++++++++++
 82 | .. automodule:: snntoolbox.simulation.backends.inisim.ttfs
 83 | 
 84 | :mod:`~snntoolbox.simulation.backends.inisim.ttfs_dyn_thresh`
 85 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 86 | .. automodule:: snntoolbox.simulation.backends.inisim.ttfs_dyn_thresh
 87 | 
 88 | :mod:`~snntoolbox.simulation.backends.inisim.ttfs_corrective`
 89 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 90 | .. automodule:: snntoolbox.simulation.backends.inisim.ttfs_corrective
 91 | 
 92 | 
 93 | :mod:`~snntoolbox.simulation.backends.megasim`
 94 | ..............................................
 95 | 
 96 | .. automodule:: snntoolbox.simulation.backends.megasim.megasim
 97 | 
 98 | ``snntoolbox.simulation.target_simulators``
 99 | -------------------------------------------
100 | 
101 | :mod:`~snntoolbox.simulation.target_simulators.INI_target_sim`
102 | ..............................................................
103 | 
104 | :mod:`~snntoolbox.simulation.target_simulators.INI_temporal_mean_rate_target_sim`
105 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
106 | .. automodule:: snntoolbox.simulation.target_simulators.INI_temporal_mean_rate_target_sim
107 | 
108 | :mod:`~snntoolbox.simulation.target_simulators.INI_temporal_pattern_target_sim`
109 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
110 | .. automodule:: snntoolbox.simulation.target_simulators.INI_temporal_pattern_target_sim
111 | 
112 | :mod:`~snntoolbox.simulation.target_simulators.INI_ttfs_target_sim`
113 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
114 | .. automodule:: snntoolbox.simulation.target_simulators.INI_ttfs_target_sim
115 | 
116 | :mod:`~snntoolbox.simulation.target_simulators.INI_ttfs_dyn_thresh_target_sim`
117 | ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
118 | .. automodule:: snntoolbox.simulation.target_simulators.INI_ttfs_dyn_thresh_target_sim
119 | 
120 | :mod:`~snntoolbox.simulation.target_simulators.INI_ttfs_corrective_target_sim`
121 | ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
122 | .. automodule:: snntoolbox.simulation.target_simulators.INI_ttfs_corrective_target_sim
123 | 
124 | 
125 | :mod:`~snntoolbox.simulation.target_simulators.pyNN_target_sim`
126 | ...............................................................
127 | 
128 | .. automodule:: snntoolbox.simulation.target_simulators.pyNN_target_sim
129 | 
130 | :mod:`~snntoolbox.simulation.target_simulators.brian2_target_sim`
131 | .................................................................
132 | 
133 | .. automodule:: snntoolbox.simulation.target_simulators.brian2_target_sim
134 | 
135 | :mod:`~snntoolbox.simulation.target_simulators.MegaSim_target_sim`
136 | ..................................................................
137 | 
138 | .. automodule:: snntoolbox.simulation.target_simulators.MegaSim_target_sim
139 | 
140 | :mod:`~snntoolbox.simulation.target_simulators.loihi_target_sim`
141 | ................................................................
142 | 
143 | .. automodule:: snntoolbox.simulation.target_simulators.loihi_target_sim
144 | 
145 | :mod:`~snntoolbox.simulation.target_simulators.spiNNaker_target_sim`
146 | ....................................................................
147 | 
148 | .. automodule:: snntoolbox.simulation.target_simulators.spiNNaker_target_sim
149 | 


--------------------------------------------------------------------------------
/docs/source/api/utils.rst:
--------------------------------------------------------------------------------
1 | ``snntoolbox.utils``
2 | ====================
3 | 
4 | :mod:`snntoolbox.utils.utils`
5 | -----------------------------
6 | 
7 | .. automodule:: snntoolbox.utils.utils
8 | 


--------------------------------------------------------------------------------
/docs/source/guide/citation.rst:
--------------------------------------------------------------------------------
 1 | .. # coding=utf-8
 2 | 
 3 | Citation
 4 | ========
 5 | 
 6 | If you use this work in your research, please cite our corresponding `publication <https://www.frontiersin.org/articles/10.3389/fnins.2017.00682/abstract>`_
 7 | :
 8 | 
 9 | ::
10 | 
11 |     Rueckauer, B. and Hu, Y. and Lungu, I.A. and Pfeiffer, M. and Liu, S.-C.
12 |     Conversion of continuous-valued deep networks to efficient event-driven networks for image classification,
13 |     Front. Neurosci., 2017, doi: 10.3389/fnins.2017.00682
14 | 


--------------------------------------------------------------------------------
/docs/source/guide/examples.rst:
--------------------------------------------------------------------------------
 1 | .. # coding=utf-8
 2 | 
 3 | Examples
 4 | ========
 5 | 
 6 | To set up an :doc:`experiment <running>` with the SNN toolbox, we need to
 7 | create a config file as described in :doc:`settings <configuration>`. The
 8 | ``examples`` subdirectory of the repository root provides a number of
 9 | end-to-end tutorials covering how to
10 | 
11 |    - set up a small CNN using Keras and tensorflow,
12 |    - train the model on MNIST,
13 |    - store model and dataset in a temporary folder on disk,
14 |    - create a configuration file for SNN toolbox,
15 |    - call the main function of SNN toolbox to convert the trained ANN to an SNN
16 |      and run it using some simulator backend or neuromorphic hardware.
17 | 
18 | More examples are included in a stand-alone `applications repository
19 | <https://github.com/NeuromorphicProcessorProject/snntoolbox_applications.git>`_.
20 | 


--------------------------------------------------------------------------------
/docs/source/guide/extending.rst:
--------------------------------------------------------------------------------
 1 | .. # coding=utf-8
 2 | 
 3 | .. _extending:
 4 | 
 5 | Extending the toolbox
 6 | =====================
 7 | 
 8 | Input side: Adding a new model library
 9 | --------------------------------------
10 | 
11 | The philosophy behind the toolbox architecture is to make all steps in the
12 | conversion/simulation pipeline independent of the original model format.
13 | Therefore, in order to add a new input model library (e.g. Torch) to the
14 | toolbox, put a module named ``torch_input_lib`` into the
15 | :py:mod:`snntoolbox.parsing.model_libs` package. Then create a child class
16 | ``torch_input_lib.ModelParser`` inheriting from
17 | `snntoolbox.parsing.utils.AbstractModelParser`, and implement the abstract
18 | methods tailored to the new input model library.
19 | 
20 | Output side: Adding a custom simulator
21 | --------------------------------------
22 | 
23 | Similarly, adding another simulator to run converted networks implies adding a
24 | file to the :py:mod:`snntoolbox.simulation.target_simulators` package. Each
25 | file in there allows building a spiking network and exporting it for use in a
26 | specific spiking simulator.
27 | 
28 | To add a simulator called 'custom', put a file named ``<custom>_target_sim.py``
29 | into :py:mod:`~snntoolbox.simulation.target_simulators`. Then create a child
30 | class ``SNN`` inheriting from `AbstractSNN`, and implement the abstract methods
31 | tailored to the 'custom' simulator.
32 | 
33 | Adding custom layers to an existing simulator
34 | ---------------------------------------------
35 | 
36 | Say you want to add support for a new layer class to the toolbox e.g. you want
37 | to be able to use locally connected layers in INIsim. You would have to do the
38 | following:
39 | 
40 |     - Register the new layer class in the ``[restrictions]`` section of
41 |       :py:mod:`snntoolbox.config_defaults`. Otherwise the parser will remove
42 |       the layer.
43 |     - Add a method to the parser so the layer gets ported correctly from your
44 |       input model library to the internal Keras model. See e.g.
45 |       :py:meth:`this example <snntoolbox.parsing.model_libs.keras_input_lib.ModelParser.parse_dense>`
46 |       for the Keras parser.
47 |     - Define a spiking version of your new layer in the simulation / deployment
48 |       backend of your choice, e.g. like :py:class:`here <snntoolbox.simulation.backends.inisim.temporal_mean_rate_tensorflow.SpikeDense>`.
49 |       Also, in case of INIsim, register the new class in the ``custom_layers``
50 |       dict :py:const:`snntoolbox/simulation/backends/inisim/temporal_mean_rate_tensorflow.py:748`.
51 |       If necessary, you can add special behavior when building this new layer:
52 |       :py:meth:`snntoolbox.simulation.target_simulators.INI_temporal_mean_rate_target_sim.SNN.build_dense`.
53 |     - If you are interested in the number of operations your SNN consumes, add
54 |       a corresponding clause in :py:func:`snntoolbox.parsing.utils.get_fanout`
55 |       that defines the synaptic connectivity.
56 | 


--------------------------------------------------------------------------------
/docs/source/guide/installation.rst:
--------------------------------------------------------------------------------
 1 | .. # coding=utf-8
 2 | 
 3 | .. _installation:
 4 | 
 5 | Installation
 6 | ============
 7 | 
 8 | Release version
 9 | ---------------
10 | 
11 | Run ``pip install snntoolbox``. This will install the minimum dependencies
12 | needed to get started. Optional dependencies like matplotlib and scipy enable
13 | generating output plots.
14 | 
15 | The toolbox relies on Keras internally, and by default installs
16 | `Tensorflow <https://www.tensorflow.org/>`_ as Keras backend. You may want to
17 | update this backend to optimally fit your system.
18 | 
19 | .. note:: The SNN toolbox provides a built-in simulator to run the converted
20 |    network. This simulator is Keras-based and will use either Tensorflow or
21 |    `Theano <http://www.deeplearning.net/software/theano/install_ubuntu.html>`_
22 |    as backend. Depending on the backend you choose, different features are
23 |    available in the toolbox simulator. You can install both backends and switch
24 |    between them simply by setting the corresponding parameter in the
25 |    :ref:`config file <configuration>`::
26 | 
27 |       [simulation]
28 |       keras_backend = tensorflow
29 | 
30 |    As the Theano is not actively developed any more, the tensorflow backend is
31 |    better maintained. The only reason to choose Theano at this point is that we
32 |    provide an implementation of MaxPooling in INIsim, which is not available
33 |    with the tensorflow backend.
34 | 
35 | Development version (recommended)
36 | ---------------------------------
37 | 
38 | To get the latest updates, checkout the `repository <https://github.com/NeuromorphicProcessorProject/snn_toolbox>`_.
39 | In the toolbox root directory ``snn_toolbox/``, run ``pip install .``.
40 | 
41 | .. note:: Using easy_install via ``python setup.py install`` has been reported
42 |    to fail on some platforms due to dependency issues.
43 | 
44 | Additional tools
45 | ----------------
46 | 
47 | For testing a converted network, the toolbox includes a ready-to-use spiking
48 | simulator. In addition, you may install and use one of the simulators described
49 | :ref:`here <simulating>`.
50 | 
51 | .. note:: Depending on the simulator you use, we recommend installing the
52 |    toolbox in a virtual environment, because simulators supported by pyNN may
53 |    require different versions of their dependencies (Brian for instance only
54 |    works with python2).
55 | 


--------------------------------------------------------------------------------
/docs/source/guide/intro.rst:
--------------------------------------------------------------------------------
  1 | .. # coding=utf-8
  2 | 
  3 | Spiking neural network conversion toolbox
  4 | =========================================
  5 | 
  6 | Introduction
  7 | ------------
  8 | 
  9 | Artificial neural networks have been studied and used extensively to solve
 10 | tasks from machine learning and artificial intelligence. *Deep Learning* has
 11 | developed increasingly large neural networks, spanning up to thousands of
 12 | layers and millions of neurons. These networks have proven to be very
 13 | successful in solving challenging tasks like object detection and recognition,
 14 | scene segmentation and parsing, video classification, etc. The downside is that
 15 | running such large networks requires massive amounts of computational
 16 | resources.
 17 | 
 18 | Our research group at the University of Zurich and ETH Zurich develops
 19 | *Spiking Neural Networks* (SNNs) that perform the same task but with
 20 | potentially less computations and energy consumption. The fundamental idea is
 21 | that in a spiking network, all computation is *event-driven*, meaning that
 22 | operations are sparse and occur only when significant changes in the input make
 23 | them necessary.
 24 | 
 25 | Training a deep spiking network (i.e. learning the synaptic weights) is
 26 | difficult. An alternative approach is to take a pre-trained neural network and
 27 | convert it into a spiking neural network. We call the original network
 28 | *Analog Neural Network* (ANN) because its activations are real-valued,
 29 | representing spike-rates. In this ANN-to-SNN conversion, we use the weights of
 30 | the ANN and replace the analog (rate) neurons of the ANN by simple
 31 | Integrate-and-Fire spiking neurons. This works because over the course of the
 32 | simulation, the average firing rate of the SNN neurons will approximate the
 33 | activation of the corresponding neurons in the original ANN. See
 34 | :doc:`citation` for details.
 35 | 
 36 | This toolbox automates the conversion of pre-trained analog to spiking neural
 37 | networks (ANN to SNN), and provides tools for testing the SNNs in spiking
 38 | neuron simulators or neuromorphic hardware.
 39 | 
 40 | .. figure:: ../images/workflow.png
 41 |    :scale: 50 %
 42 |    :alt: Workflow diagram of the SNN toolbox.
 43 | 
 44 | Internal workflow
 45 | -----------------
 46 | 
 47 | Parsing and converting
 48 | **********************
 49 | 
 50 | Given a model written in some neural network library, the toolbox parses the
 51 | provided network files by extracting the relevant information and creating an
 52 | equivalent Keras model from it. This parsed model serves as common abstraction
 53 | stage from the input and is internally used by the toolbox to perform the
 54 | actual conversion to a spiking network.
 55 | 
 56 | The conversion toolbox currently supports input networks generated with
 57 | `Keras <https://keras.io/>`_, `PyTorch <https://pytorch.org/>`_,
 58 | `Lasagne <https://lasagne.readthedocs.io/en/latest/>`_, or
 59 | `Caffe <http://caffe.berkeleyvision.org/>`_. See :doc:`extending` on how to
 60 | extend the relevant methods to handle models from other common libraries.
 61 | 
 62 | The following table lists the input files expected by the toolbox.
 63 | 
 64 | .. figure:: ../images/input_specs.png
 65 |    :scale: 100 %
 66 |    :alt: Input format specifications.
 67 | 
 68 | The first column in the following table summarized which features of the input
 69 | model the toolbox knows about and can handle.
 70 | 
 71 | .. _simulating:
 72 | 
 73 | Simulating
 74 | **********
 75 | 
 76 | After the input model has been converted, the resulting spiking network can be
 77 | exported for simulation in a spiking simulator or deployment on dedicated
 78 | spiking neuron chips. Currently, the following output formats are supported
 79 | (see :doc:`extending` on how to add a simulator to the toolbox):
 80 | 
 81 |     - `pyNN <http://neuralensemble.org/docs/PyNN/>`_ models. pyNN is a
 82 |       simulator-independent language for building neural network
 83 |       models. It allows running the converted net in a spiking simulator like
 84 |       `Brian <http://briansimulator.org/>`_,
 85 |       `Nest <http://www.nest-simulator.org/>`_,
 86 |       `Neuron <https://www.neuron.yale.edu/neuron/>`_, or by a custom simulator
 87 |       that allows pyNN models as inputs. If you choose a pyNN
 88 |       simulator backend, we recommend Nest with version 2.14.
 89 |     - `Brian2 <http://brian2.readthedocs.io/en/latest/index.html#>`_.
 90 |     - The toolbox integrates MegaSim, an event-driven asynchronous spiking
 91 |       simulator developed at the University of Seville.
 92 |     - The toolbox provides a built-in simulator based on Keras, called INIsim.
 93 |       This simulator features a simple integrate-and-fire neuron. By
 94 |       dispensing with redundant parameters and implementing a highly parallel
 95 |       simulation, the run time is reduced by several orders of magnitude,
 96 |       without compromising accuracy. This simulator backend is recommended
 97 |       as it supports the most features and its integration is maintained best.
 98 |     - If you have access to Intel's neuromorphic processor Loihi, or the
 99 |       SpiNNaker system from the University of Manchester, you may use the SNN
100 |       toolbox to deploy your converted model on this dedicated hardware. See
101 |       :doc:`examples` for end-to-end tutorials.
102 | 
103 | The second column in the table below compares these different simulators with
104 | respect to the network features that can be implemented on them.
105 | 
106 | .. figure:: ../images/features.png
107 |    :scale: 100 %
108 |    :alt: Supported features in input and output model.
109 | 
110 | 
111 | Additionaly, a number of experimental features were implemented to improve and
112 | test the spiking network. They are currently only available in INIsim, and
113 | include:
114 | 
115 |    - Clamping of membrane potentials for a given time for each layer.
116 |    - Clipping membrane potentials to certain bounds.
117 |    - Activity-dependent adaptation of spike thresholds of each layer.
118 |    - Bias-relaxation.
119 |    - Spikes with payloads.
120 |    - Various reset mechanisms after spikes.
121 |    - Logging and visualization functions to monitor and debug simulation.
122 |    - Different input types: In all other simulators, only Poisson input is
123 |      supported at the moment. INIsim implements constant input currents as well
124 |      as input from DVS event sequences.
125 |    - Batch-wise testing.
126 | 
127 | 
128 | GUI (beta)
129 | ----------
130 | 
131 | .. note::
132 |    The GUI has not been maintained since 2017 and is most likely broken.
133 | 
134 | .. figure:: ../images/gui_parameters.png
135 |    :scale: 50 %
136 |    :alt: Snapshot of the SNN toolbox GUI.
137 | 
138 |    **SNN toolbox GUI.** In the main window, the user can specify which tools to
139 |    use during the experiment. Also, parameters of the neuron cells used during
140 |    simulation can be set. The GUI saves and reloads last settings
141 |    automatically, and allows saving and loading preferences manually. Tooltips
142 |    explain all functionality.
143 | 
144 | .. figure:: ../images/gui_plots.png
145 |    :scale: 50 %
146 |    :alt: Snapshot of the SNN toolbox GUI plot window.
147 | 
148 |    **SNN toolbox GUI plot window.** The toolbox looks for plots in the
149 |    specified working directory. The user can select one or several layers, for
150 |    which the results of a test run will be displayed in a way that facilitates
151 |    examining and comparing results of each layer of the network. The example
152 |    above compares ANN activations to SNN spikerates for the first convolutional
153 |    layer on the MNIST dataset.
154 | 


--------------------------------------------------------------------------------
/docs/source/guide/running.rst:
--------------------------------------------------------------------------------
 1 | .. # coding=utf-8
 2 | 
 3 | .. _running:
 4 | 
 5 | Getting started
 6 | ===============
 7 | 
 8 | In a terminal window, type ``snntoolbox -h`` to get all command-line options.
 9 | 
10 | The basic use is::
11 | 
12 |    snntoolbox <config-file> -t
13 | 
14 | The positional argument ``<config-file>`` specifies the path (including file
15 | name) to a plain text file containing the settings to be used. Refer to
16 | :doc:`configuration` for details on what this file looks like.
17 | 
18 | With ``-t``, we tell the program to stay in the terminal. Omitting this flag
19 | opens the GUI (not actively developed).
20 | 
21 | Instead of using the terminal, you may also invoke the toolbox within a python
22 | script::
23 | 
24 |    snntoolbox.bin.run.main(path_to_config_file)
25 | 
26 | See :doc:`examples` for typical usecases and end-to-end examples.
27 | 


--------------------------------------------------------------------------------
/docs/source/guide/support.rst:
--------------------------------------------------------------------------------
1 | .. # coding=utf-8
2 | 
3 | Support
4 | =======
5 | 
6 | For usage questions and bug reports please submit a ticket on the associated github page.
7 | 
8 | If applicable, provide your config file as well as the full stack trace.
9 | 


--------------------------------------------------------------------------------
/docs/source/images/features.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/features.png


--------------------------------------------------------------------------------
/docs/source/images/gui_all.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/gui_all.png


--------------------------------------------------------------------------------
/docs/source/images/gui_cellparams.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/gui_cellparams.png


--------------------------------------------------------------------------------
/docs/source/images/gui_globalparams.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/gui_globalparams.png


--------------------------------------------------------------------------------
/docs/source/images/gui_parameters.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/gui_parameters.png


--------------------------------------------------------------------------------
/docs/source/images/gui_params.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/gui_params.png


--------------------------------------------------------------------------------
/docs/source/images/gui_plotparams.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/gui_plotparams.png


--------------------------------------------------------------------------------
/docs/source/images/gui_plots.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/gui_plots.png


--------------------------------------------------------------------------------
/docs/source/images/gui_plots2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/gui_plots2.png


--------------------------------------------------------------------------------
/docs/source/images/gui_simparams.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/gui_simparams.png


--------------------------------------------------------------------------------
/docs/source/images/gui_tools.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/gui_tools.png


--------------------------------------------------------------------------------
/docs/source/images/input_specs.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/input_specs.png


--------------------------------------------------------------------------------
/docs/source/images/snntoolbox_gui.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/snntoolbox_gui.png


--------------------------------------------------------------------------------
/docs/source/images/workflow.odt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/workflow.odt


--------------------------------------------------------------------------------
/docs/source/images/workflow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/docs/source/images/workflow.png


--------------------------------------------------------------------------------
/docs/source/index.rst:
--------------------------------------------------------------------------------
 1 | .. -*- coding=utf-8 -*-
 2 | 
 3 | Spiking neural network conversion toolbox
 4 | =========================================
 5 | 
 6 | The SNN conversion toolbox (SNN-TB) is a framework to transform rate-based
 7 | artificial neural networks into spiking neural networks, and to run them using
 8 | various spike encodings. A unique feature about SNN-TB is that it accepts input
 9 | models from many different deep-learning libraries (Keras / TF, pytorch, ...)
10 | and provides an interface to several backends for simulation (pyNN, brian2,
11 | ...) or deployment (SpiNNaker, Loihi). The source code can be found on
12 | `GitHub`_. See also the accompanying articles
13 | `[Rueckauer et al., 2017] <https://www.frontiersin.org/articles/10.3389/fnins.2017.00682/abstract>`_,
14 | `[Rueckauer and Liu, 2018] <https://ieeexplore.ieee.org/abstract/document/8351295/>`_, and `[Rueckauer and Liu, 2021] <https://ieeexplore.ieee.org/abstract/document/9533837>`_.
15 | 
16 | User Guide
17 | ----------
18 | 
19 | These sections guide you through the installation, configuration and running of
20 | the toolbox. Examples are included.
21 | 
22 | .. toctree::
23 |    :maxdepth: 1
24 | 
25 |    guide/intro
26 |    guide/installation
27 |    guide/running
28 |    guide/configuration
29 |    guide/extending
30 |    guide/examples
31 |    guide/citation
32 |    guide/support
33 | 
34 | API Reference
35 | -------------
36 | 
37 | Here you find detailed descriptions of specific functions and classes.
38 | 
39 | .. toctree::
40 |    :maxdepth: 2
41 | 
42 |    api/bin
43 |    api/parsing
44 |    api/conversion
45 |    api/simulation
46 |    api/datasets
47 |    api/utils
48 | 
49 | Indices and tables
50 | ------------------
51 | 
52 | * :ref:`genindex`
53 | * :ref:`modindex`
54 | * :ref:`search`
55 | 
56 | .. _GitHub: https://github.com/NeuromorphicProcessorProject/snn_toolbox
57 | 


--------------------------------------------------------------------------------
/examples/.gitignore:
--------------------------------------------------------------------------------
1 | /mnist_keras_spiNNaker_sparse_sandbox.py
2 | /mnist_keras_spiNNaker_Fashion_MNIST.py
3 | 


--------------------------------------------------------------------------------
/examples/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/examples/__init__.py


--------------------------------------------------------------------------------
/examples/mnist_keras_INI.py:
--------------------------------------------------------------------------------
  1 | """End-to-end example for SNN Toolbox.
  2 | 
  3 | This script sets up a small CNN using Keras and tensorflow, trains it for one
  4 | epoch on MNIST, stores model and dataset in a temporary folder on disk, creates
  5 | a configuration file for SNN toolbox, and finally calls the main function of
  6 | SNN toolbox to convert the trained ANN to an SNN and run it using INI
  7 | simulator.
  8 | """
  9 | 
 10 | import os
 11 | import time
 12 | import numpy as np
 13 | 
 14 | from tensorflow import keras
 15 | from tensorflow.keras import Input, Model
 16 | from tensorflow.keras.layers import Conv2D, AveragePooling2D, Flatten, Dense, \
 17 |     Dropout, Concatenate, BatchNormalization, Activation
 18 | from tensorflow.keras.datasets import mnist
 19 | from tensorflow.keras.utils import to_categorical
 20 | 
 21 | from snntoolbox.bin.run import main
 22 | from snntoolbox.utils.utils import import_configparser
 23 | 
 24 | 
 25 | # WORKING DIRECTORY #
 26 | #####################
 27 | 
 28 | # Define path where model and output files will be stored.
 29 | # The user is responsible for cleaning up this temporary directory.
 30 | path_wd = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(
 31 |     __file__)), '..', 'temp', str(time.time())))
 32 | os.makedirs(path_wd)
 33 | 
 34 | # GET DATASET #
 35 | ###############
 36 | 
 37 | (x_train, y_train), (x_test, y_test) = mnist.load_data()
 38 | 
 39 | # Normalize input so we can train ANN with it.
 40 | # Will be converted back to integers for SNN layer.
 41 | x_train = x_train / 255
 42 | x_test = x_test / 255
 43 | 
 44 | # Add a channel dimension.
 45 | axis = 1 if keras.backend.image_data_format() == 'channels_first' else -1
 46 | x_train = np.expand_dims(x_train, axis)
 47 | x_test = np.expand_dims(x_test, axis)
 48 | 
 49 | # One-hot encode target vectors.
 50 | y_train = to_categorical(y_train, 10)
 51 | y_test = to_categorical(y_test, 10)
 52 | 
 53 | # Save dataset so SNN toolbox can find it.
 54 | np.savez_compressed(os.path.join(path_wd, 'x_test'), x_test)
 55 | np.savez_compressed(os.path.join(path_wd, 'y_test'), y_test)
 56 | # SNN toolbox will not do any training, but we save a subset of the training
 57 | # set so the toolbox can use it when normalizing the network parameters.
 58 | np.savez_compressed(os.path.join(path_wd, 'x_norm'), x_train[::10])
 59 | 
 60 | # CREATE ANN #
 61 | ##############
 62 | 
 63 | # This section creates a CNN using Keras, and trains it with backpropagation.
 64 | # There are no spikes involved at this point. The model is far more complicated
 65 | # than necessary for MNIST, but serves the purpose to illustrate the kind of
 66 | # layers and topologies supported (in particular branches).
 67 | 
 68 | input_shape = x_train.shape[1:]
 69 | input_layer = Input(input_shape)
 70 | 
 71 | layer = Conv2D(filters=16,
 72 |                kernel_size=(5, 5),
 73 |                strides=(2, 2),
 74 |                activation='relu')(input_layer)
 75 | layer = BatchNormalization(axis=axis)(layer)
 76 | layer = Activation('relu')(layer)
 77 | layer = AveragePooling2D()(layer)
 78 | branch1 = Conv2D(filters=32,
 79 |                  kernel_size=(3, 3),
 80 |                  padding='same',
 81 |                  activation='relu')(layer)
 82 | branch2 = Conv2D(filters=8,
 83 |                  kernel_size=(1, 1),
 84 |                  activation='relu')(layer)
 85 | layer = Concatenate(axis=axis)([branch1, branch2])
 86 | layer = Conv2D(filters=10,
 87 |                kernel_size=(3, 3),
 88 |                activation='relu')(layer)
 89 | layer = Flatten()(layer)
 90 | layer = Dropout(0.01)(layer)
 91 | layer = Dense(units=10,
 92 |               activation='softmax')(layer)
 93 | 
 94 | model = Model(input_layer, layer)
 95 | 
 96 | model.summary()
 97 | 
 98 | model.compile('adam', 'categorical_crossentropy', ['accuracy'])
 99 | 
100 | # Train model with backprop.
101 | model.fit(x_train, y_train, batch_size=64, epochs=1, verbose=2,
102 |           validation_data=(x_test, y_test))
103 | 
104 | # Store model so SNN Toolbox can find it.
105 | model_name = 'mnist_cnn'
106 | keras.models.save_model(model, os.path.join(path_wd, model_name + '.h5'))
107 | 
108 | # SNN TOOLBOX CONFIGURATION #
109 | #############################
110 | 
111 | # Create a config file with experimental setup for SNN Toolbox.
112 | configparser = import_configparser()
113 | config = configparser.ConfigParser()
114 | 
115 | config['paths'] = {
116 |     'path_wd': path_wd,             # Path to model.
117 |     'dataset_path': path_wd,        # Path to dataset.
118 |     'filename_ann': model_name      # Name of input model.
119 | }
120 | 
121 | config['tools'] = {
122 |     'evaluate_ann': True,           # Test ANN on dataset before conversion.
123 |     'normalize': True               # Normalize weights for full dynamic range.
124 | }
125 | 
126 | config['simulation'] = {
127 |     'simulator': 'INI',             # Chooses execution backend of SNN toolbox.
128 |     'duration': 50,                 # Number of time steps to run each sample.
129 |     'num_to_test': 100,             # How many test samples to run.
130 |     'batch_size': 50,               # Batch size for simulation.
131 |     'keras_backend': 'tensorflow'   # Which keras backend to use.
132 | }
133 | 
134 | config['output'] = {
135 |     'plot_vars': {                  # Various plots (slows down simulation).
136 |         'spiketrains',              # Leave section empty to turn off plots.
137 |         'spikerates',
138 |         'activations',
139 |         'correlation',
140 |         'v_mem',
141 |         'error_t'}
142 | }
143 | 
144 | # Store config file.
145 | config_filepath = os.path.join(path_wd, 'config')
146 | with open(config_filepath, 'w') as configfile:
147 |     config.write(configfile)
148 | 
149 | # RUN SNN TOOLBOX #
150 | ###################
151 | 
152 | main(config_filepath)
153 | 


--------------------------------------------------------------------------------
/examples/mnist_keras_brian2.py:
--------------------------------------------------------------------------------
  1 | """End-to-end example for SNN Toolbox.
  2 | 
  3 | This script sets up a small CNN using Keras and tensorflow, trains it for one
  4 | epoch on MNIST, stores model and dataset in a temporary folder on disk, creates
  5 | a configuration file for SNN toolbox, and finally calls the main function of
  6 | SNN toolbox to convert the trained ANN to an SNN and run it using Brian2
  7 | simulator.
  8 | """
  9 | 
 10 | import os
 11 | import time
 12 | import numpy as np
 13 | 
 14 | from tensorflow import keras
 15 | from tensorflow.keras import Input, Model
 16 | from tensorflow.keras.layers import Conv2D, AveragePooling2D, Flatten, Dense, \
 17 |     Dropout, BatchNormalization, Activation
 18 | from tensorflow.keras.datasets import mnist
 19 | from tensorflow.keras.utils import to_categorical
 20 | 
 21 | from snntoolbox.bin.run import main
 22 | from snntoolbox.utils.utils import import_configparser
 23 | 
 24 | 
 25 | # WORKING DIRECTORY #
 26 | #####################
 27 | 
 28 | # Define path where model and output files will be stored.
 29 | # The user is responsible for cleaning up this temporary directory.
 30 | path_wd = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(
 31 |     __file__)), '..', 'temp', str(time.time())))
 32 | os.makedirs(path_wd)
 33 | 
 34 | # GET DATASET #
 35 | ###############
 36 | 
 37 | (x_train, y_train), (x_test, y_test) = mnist.load_data()
 38 | 
 39 | # Normalize input so we can train ANN with it.
 40 | # Will be converted back to integers for SNN layer.
 41 | x_train = x_train / 255
 42 | x_test = x_test / 255
 43 | 
 44 | # Add a channel dimension.
 45 | axis = 1 if keras.backend.image_data_format() == 'channels_first' else -1
 46 | x_train = np.expand_dims(x_train, axis)
 47 | x_test = np.expand_dims(x_test, axis)
 48 | 
 49 | # One-hot encode target vectors.
 50 | y_train = to_categorical(y_train, 10)
 51 | y_test = to_categorical(y_test, 10)
 52 | 
 53 | # Save dataset so SNN toolbox can find it.
 54 | np.savez_compressed(os.path.join(path_wd, 'x_test'), x_test)
 55 | np.savez_compressed(os.path.join(path_wd, 'y_test'), y_test)
 56 | # SNN toolbox will not do any training, but we save a subset of the training
 57 | # set so the toolbox can use it when normalizing the network parameters.
 58 | np.savez_compressed(os.path.join(path_wd, 'x_norm'), x_train[::10])
 59 | 
 60 | # CREATE ANN #
 61 | ##############
 62 | 
 63 | # This section creates a simple CNN using Keras, and trains it
 64 | # with backpropagation. There are no spikes involved at this point.
 65 | 
 66 | input_shape = x_train.shape[1:]
 67 | input_layer = Input(input_shape)
 68 | 
 69 | layer = Conv2D(filters=16,
 70 |                kernel_size=(5, 5),
 71 |                strides=(2, 2),
 72 |                activation='relu')(input_layer)
 73 | layer = BatchNormalization(axis=axis)(layer)
 74 | layer = Activation('relu')(layer)
 75 | layer = Conv2D(filters=32,
 76 |                kernel_size=(3, 3),
 77 |                activation='relu')(layer)
 78 | layer = AveragePooling2D()(layer)
 79 | layer = Conv2D(filters=8,
 80 |                kernel_size=(3, 3),
 81 |                padding='same',
 82 |                activation='relu')(layer)
 83 | layer = Flatten()(layer)
 84 | layer = Dropout(0.01)(layer)
 85 | layer = Dense(units=10,
 86 |               activation='softmax')(layer)
 87 | 
 88 | model = Model(input_layer, layer)
 89 | 
 90 | model.summary()
 91 | 
 92 | model.compile('adam', 'categorical_crossentropy', ['accuracy'])
 93 | 
 94 | # Train model with backprop.
 95 | model.fit(x_train, y_train, batch_size=64, epochs=1, verbose=2,
 96 |           validation_data=(x_test, y_test))
 97 | 
 98 | # Store model so SNN Toolbox can find it.
 99 | model_name = 'mnist_cnn'
100 | keras.models.save_model(model, os.path.join(path_wd, model_name + '.h5'))
101 | 
102 | # SNN TOOLBOX CONFIGURATION #
103 | #############################
104 | 
105 | # Create a config file with experimental setup for SNN Toolbox.
106 | configparser = import_configparser()
107 | config = configparser.ConfigParser()
108 | 
109 | config['paths'] = {
110 |     'path_wd': path_wd,             # Path to model.
111 |     'dataset_path': path_wd,        # Path to dataset.
112 |     'filename_ann': model_name      # Name of input model.
113 | }
114 | 
115 | config['tools'] = {
116 |     'evaluate_ann': True,           # Test ANN on dataset before conversion.
117 |     'normalize': True,              # Normalize weights for full dynamic range.
118 | }
119 | 
120 | config['simulation'] = {
121 |     'simulator': 'brian2',          # Chooses execution backend of SNN toolbox.
122 |     'duration': 50,                 # Number of time steps to run each sample.
123 |     'num_to_test': 5,               # How many test samples to run.
124 |     'batch_size': 1,                # Batch size for simulation.
125 |     'dt': 0.1                       # Time resolution for ODE solving.
126 | }
127 | 
128 | config['input'] = {
129 |     'poisson_input': False          # Images are encodes as spike trains.
130 | }
131 | 
132 | config['output'] = {
133 |     'plot_vars': {                  # Various plots (slows down simulation).
134 |         'spiketrains',              # Leave section empty to turn off plots.
135 |         'spikerates',
136 |         'activations',
137 |         'correlation',
138 |         'v_mem',
139 |         'error_t'}
140 | }
141 | 
142 | # Store config file.
143 | config_filepath = os.path.join(path_wd, 'config')
144 | with open(config_filepath, 'w') as configfile:
145 |     config.write(configfile)
146 | 
147 | # RUN SNN TOOLBOX #
148 | ###################
149 | 
150 | main(config_filepath)
151 | 


--------------------------------------------------------------------------------
/examples/mnist_keras_loihi.py:
--------------------------------------------------------------------------------
  1 | """End-to-end example for SNN Toolbox.
  2 | 
  3 | This script sets up a small CNN using Keras and tensorflow, trains it for one
  4 | epoch on MNIST, stores model and dataset in a temporary folder on disk, creates
  5 | a configuration file for SNN toolbox, and finally calls the main function of
  6 | SNN toolbox to convert the trained ANN to an SNN and run it using Intel's Loihi
  7 | processor.
  8 | """
  9 | 
 10 | import os
 11 | import sys
 12 | import time
 13 | import numpy as np
 14 | 
 15 | from tensorflow import keras
 16 | from tensorflow.keras import Input, Model
 17 | from tensorflow.keras.layers import Conv2D, AveragePooling2D, Flatten, Dense, \
 18 |     Dropout, BatchNormalization, Activation
 19 | from tensorflow.keras.datasets import mnist
 20 | from tensorflow.keras.utils import to_categorical
 21 | 
 22 | from snntoolbox.bin.run import main
 23 | from snntoolbox.utils.utils import import_configparser
 24 | 
 25 | # Enable SLURM to run network on Loihi.
 26 | os.environ['SLURM'] = '1'
 27 | os.environ['PYTHONUNBUFFERED'] = '1'
 28 | 
 29 | # Add path to the nxsdk_modules package.
 30 | sys.path.append('/homes/rbodo/Repositories/nxsdk_modules')
 31 | 
 32 | # WORKING DIRECTORY #
 33 | #####################
 34 | 
 35 | # Define path where model and output files will be stored.
 36 | # The user is responsible for cleaning up this temporary directory.
 37 | path_wd = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(
 38 |     __file__)), '..', 'temp', str(time.time())))
 39 | os.makedirs(path_wd)
 40 | 
 41 | # GET DATASET #
 42 | ###############
 43 | 
 44 | (x_train, y_train), (x_test, y_test) = mnist.load_data()
 45 | 
 46 | # Normalize input so we can train ANN with it.
 47 | # Will be converted back to integers for SNN layer.
 48 | x_train = x_train / 255
 49 | x_test = x_test / 255
 50 | 
 51 | # Add a channel dimension.
 52 | axis = 1 if keras.backend.image_data_format() == 'channels_first' else -1
 53 | x_train = np.expand_dims(x_train, axis)
 54 | x_test = np.expand_dims(x_test, axis)
 55 | 
 56 | # One-hot encode target vectors.
 57 | y_train = to_categorical(y_train, 10)
 58 | y_test = to_categorical(y_test, 10)
 59 | 
 60 | # Save dataset so SNN toolbox can find it.
 61 | np.savez_compressed(os.path.join(path_wd, 'x_test'), x_test)
 62 | np.savez_compressed(os.path.join(path_wd, 'y_test'), y_test)
 63 | # SNN toolbox will not do any training, but we save a subset of the training
 64 | # set so the toolbox can use it when normalizing the network parameters.
 65 | np.savez_compressed(os.path.join(path_wd, 'x_norm'), x_train[::10])
 66 | 
 67 | # CREATE ANN #
 68 | ##############
 69 | 
 70 | # This section creates a CNN using Keras, and trains it with backpropagation.
 71 | # There are no spikes involved at this point. The model is far more complicated
 72 | # than necessary for MNIST, but serves the purpose to illustrate the kind of
 73 | # layers and topologies supported (in particular branches).
 74 | 
 75 | input_shape = x_train.shape[1:]
 76 | input_layer = Input(input_shape)
 77 | 
 78 | layer = Conv2D(filters=16,
 79 |                kernel_size=(5, 5),
 80 |                strides=(2, 2),
 81 |                activation='relu')(input_layer)
 82 | layer = BatchNormalization(axis=axis)(layer)
 83 | layer = Activation('relu')(layer)
 84 | layer = Conv2D(filters=32,
 85 |                kernel_size=(3, 3),
 86 |                activation='relu')(layer)
 87 | layer = AveragePooling2D()(layer)
 88 | layer = Conv2D(filters=8,
 89 |                kernel_size=(3, 3),
 90 |                padding='same',
 91 |                activation='relu')(layer)
 92 | layer = Flatten()(layer)
 93 | layer = Dropout(0.01)(layer)
 94 | layer = Dense(units=10,
 95 |               activation='softmax')(layer)
 96 | 
 97 | model = Model(input_layer, layer)
 98 | 
 99 | model.summary()
100 | 
101 | model.compile('adam', 'categorical_crossentropy', ['accuracy'])
102 | 
103 | # Train model with backprop.
104 | model.fit(x_train, y_train, batch_size=64, epochs=1, verbose=2,
105 |           validation_data=(x_test, y_test))
106 | 
107 | # Store model so SNN Toolbox can find it.
108 | model_name = 'mnist_cnn'
109 | keras.models.save_model(model, os.path.join(path_wd, model_name + '.h5'))
110 | 
111 | # SNN TOOLBOX CONFIGURATION #
112 | #############################
113 | 
114 | reset_mode = 'soft'
115 | 
116 | # Create a config file with experimental setup for SNN Toolbox.
117 | configparser = import_configparser()
118 | config = configparser.ConfigParser()
119 | 
120 | config['paths'] = {
121 |     'path_wd': path_wd,             # Path to model.
122 |     'dataset_path': path_wd,        # Path to dataset.
123 |     'filename_ann': model_name      # Name of input model.
124 | }
125 | 
126 | config['tools'] = {
127 |     'evaluate_ann': True,           # Test ANN on dataset before conversion.
128 |     'normalize': False              # Not needed for Loihi backend.
129 | }
130 | 
131 | config['simulation'] = {
132 |     'simulator': 'loihi',           # Chooses execution backend of SNN toolbox.
133 |     'duration': 100,                # Number of time steps to run each sample.
134 |     'num_to_test': 100,             # How many test samples to run.
135 |     'batch_size': 20
136 | }
137 | 
138 | config['loihi'] = {
139 |     # Reset mode 'soft'/'hard' for reset-by-subtraction (more accurate)
140 |     # or reset-to-zero (less resources).
141 |     'reset_mode': reset_mode,
142 |     # Scaling factor between max input and threshold.
143 |     'desired_threshold_to_input_ratio': 2 ** 3 if reset_mode == 'hard' else 1,
144 |     # Arguments passed to NxTF layer.
145 |     'compartment_kwargs': {'biasExp': 6, 'vThMant': 512},
146 |     'connection_kwargs': {'numWeightBits': 8, 'weightExponent': 0,
147 |                           'numBiasBits': 12},
148 |     'validate_partitions': False,   # Validates correctness of compiled layers.
149 |     'save_output': False,           # Plots compiler information.
150 |     'do_overflow_estimate': True,   # Estimate overflow of dendritic accumul.
151 |     'normalize_thresholds': True,   # Tune thresholds to optimal dynamic range.
152 | }
153 | 
154 | # Store config file.
155 | config_filepath = os.path.join(path_wd, 'config')
156 | with open(config_filepath, 'w') as configfile:
157 |     config.write(configfile)
158 | 
159 | # RUN SNN TOOLBOX #
160 | ###################
161 | 
162 | main(config_filepath)
163 | 


--------------------------------------------------------------------------------
/examples/mnist_keras_nest.py:
--------------------------------------------------------------------------------
  1 | """End-to-end example for SNN Toolbox.
  2 | 
  3 | This script sets up a small CNN using Keras and tensorflow, trains it for one
  4 | epoch on MNIST, stores model and dataset in a temporary folder on disk, creates
  5 | a configuration file for SNN toolbox, and finally calls the main function of
  6 | SNN toolbox to convert the trained ANN to an SNN and run it using pyNN/nest
  7 | simulator.
  8 | """
  9 | 
 10 | import os
 11 | import time
 12 | import numpy as np
 13 | 
 14 | from tensorflow import keras
 15 | from tensorflow.keras import Input, Model
 16 | from tensorflow.keras.layers import Conv2D, AveragePooling2D, Flatten, Dense, \
 17 |     Dropout
 18 | from tensorflow.keras.datasets import mnist
 19 | from tensorflow.keras.utils import to_categorical
 20 | 
 21 | from snntoolbox.bin.run import main
 22 | from snntoolbox.utils.utils import import_configparser
 23 | 
 24 | 
 25 | # WORKING DIRECTORY #
 26 | #####################
 27 | 
 28 | # Define path where model and output files will be stored.
 29 | # The user is responsible for cleaning up this temporary directory.
 30 | path_wd = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(
 31 |     __file__)), '..', 'temp', str(time.time())))
 32 | os.makedirs(path_wd)
 33 | 
 34 | # GET DATASET #
 35 | ###############
 36 | 
 37 | (x_train, y_train), (x_test, y_test) = mnist.load_data()
 38 | 
 39 | # Normalize input so we can train ANN with it.
 40 | # Will be converted back to integers for SNN layer.
 41 | x_train = x_train / 255
 42 | x_test = x_test / 255
 43 | 
 44 | # Add a channel dimension.
 45 | axis = 1 if keras.backend.image_data_format() == 'channels_first' else -1
 46 | x_train = np.expand_dims(x_train, axis)
 47 | x_test = np.expand_dims(x_test, axis)
 48 | 
 49 | # One-hot encode target vectors.
 50 | y_train = to_categorical(y_train, 10)
 51 | y_test = to_categorical(y_test, 10)
 52 | 
 53 | # Save dataset so SNN toolbox can find it.
 54 | np.savez_compressed(os.path.join(path_wd, 'x_test'), x_test)
 55 | np.savez_compressed(os.path.join(path_wd, 'y_test'), y_test)
 56 | # SNN toolbox will not do any training, but we save a subset of the training
 57 | # set so the toolbox can use it when normalizing the network parameters.
 58 | np.savez_compressed(os.path.join(path_wd, 'x_norm'), x_train[::10])
 59 | 
 60 | # CREATE ANN #
 61 | ##############
 62 | 
 63 | # This section creates a simple CNN using Keras, and trains it
 64 | # with backpropagation. There are no spikes involved at this point.
 65 | 
 66 | input_shape = x_train.shape[1:]
 67 | input_layer = Input(input_shape)
 68 | 
 69 | layer = Conv2D(filters=16,
 70 |                kernel_size=(5, 5),
 71 |                strides=(2, 2),
 72 |                activation='relu')(input_layer)
 73 | layer = Conv2D(filters=32,
 74 |                kernel_size=(3, 3),
 75 |                activation='relu')(layer)
 76 | layer = AveragePooling2D()(layer)
 77 | layer = Conv2D(filters=8,
 78 |                kernel_size=(3, 3),
 79 |                padding='same',
 80 |                activation='relu')(layer)
 81 | layer = Flatten()(layer)
 82 | layer = Dropout(0.01)(layer)
 83 | layer = Dense(units=10,
 84 |               activation='softmax')(layer)
 85 | 
 86 | model = Model(input_layer, layer)
 87 | 
 88 | model.summary()
 89 | 
 90 | model.compile('adam', 'categorical_crossentropy', ['accuracy'])
 91 | 
 92 | # Train model with backprop.
 93 | model.fit(x_train, y_train, batch_size=64, epochs=1, verbose=2,
 94 |           validation_data=(x_test, y_test))
 95 | 
 96 | # Store model so SNN Toolbox can find it.
 97 | model_name = 'mnist_cnn'
 98 | keras.models.save_model(model, os.path.join(path_wd, model_name + '.h5'))
 99 | 
100 | # SNN TOOLBOX CONFIGURATION #
101 | #############################
102 | 
103 | dt = 0.1  # Time resolution of simulator.
104 | 
105 | # Create a config file with experimental setup for SNN Toolbox.
106 | configparser = import_configparser()
107 | config = configparser.ConfigParser()
108 | 
109 | config['paths'] = {
110 |     'path_wd': path_wd,             # Path to model.
111 |     'dataset_path': path_wd,        # Path to dataset.
112 |     'filename_ann': model_name      # Name of input model.
113 | }
114 | 
115 | config['tools'] = {
116 |     'evaluate_ann': True,           # Test ANN on dataset before conversion.
117 |     'normalize': True,              # Normalize weights for full dynamic range.
118 | }
119 | 
120 | config['simulation'] = {
121 |     'simulator': 'nest',            # Chooses execution backend of SNN toolbox.
122 |     'duration': 50,                 # Number of time steps to run each sample.
123 |     'num_to_test': 5,               # How many test samples to run.
124 |     'batch_size': 1,                # Batch size for simulation.
125 |     'dt': dt                        # Time resolution for ODE solving.
126 | }
127 | 
128 | config['cell'] = {
129 |     'tau_refrac': dt,               # Refractory period and delay must be at
130 |     'delay': dt,                    # least one time step.
131 |     'v_thresh': 0.01                # Reducing default value (1) for higher
132 |                                     # spikerates.
133 | }
134 | 
135 | config['output'] = {
136 |     'plot_vars': {                  # Various plots (slows down simulation).
137 |         'spiketrains',              # Leave section empty to turn off plots.
138 |         'spikerates',
139 |         'activations',
140 |         'correlation',
141 |         'v_mem',
142 |         'error_t'}
143 | }
144 | 
145 | # Store config file.
146 | config_filepath = os.path.join(path_wd, 'config')
147 | with open(config_filepath, 'w') as configfile:
148 |     config.write(configfile)
149 | 
150 | # RUN SNN TOOLBOX #
151 | ###################
152 | 
153 | main(config_filepath)
154 | 


--------------------------------------------------------------------------------
/examples/mnist_keras_spiNNaker.py:
--------------------------------------------------------------------------------
  1 | """End-to-end example for SNN Toolbox.
  2 | 
  3 | This script sets up a small CNN using Keras and tensorflow, trains it for one
  4 | epoch on MNIST, stores model and dataset in a temporary folder on disk, creates
  5 | a configuration file for SNN toolbox, and finally calls the main function of
  6 | SNN toolbox to convert the trained ANN to an SNN and run it using SpiNNaker.
  7 | """
  8 | 
  9 | import os
 10 | import time
 11 | import numpy as np
 12 | 
 13 | from tensorflow import keras
 14 | from tensorflow.keras import Input, Model
 15 | from tensorflow.keras.layers import Conv2D, AveragePooling2D, Flatten, Dense, \
 16 |     Dropout
 17 | from tensorflow.keras.datasets import mnist
 18 | from tensorflow.keras.utils import to_categorical
 19 | 
 20 | from snntoolbox.bin.run import main
 21 | from snntoolbox.utils.utils import import_configparser
 22 | 
 23 | 
 24 | # WORKING DIRECTORY #
 25 | #####################
 26 | 
 27 | # Define path where model and output files will be stored.
 28 | # The user is responsible for cleaning up this temporary directory.
 29 | path_wd = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(
 30 |     __file__)), '..', 'temp', str(time.time())))
 31 | os.makedirs(path_wd)
 32 | 
 33 | # GET DATASET #
 34 | ###############
 35 | 
 36 | (x_train, y_train), (x_test, y_test) = mnist.load_data()
 37 | 
 38 | # Normalize input so we can train ANN with it.
 39 | # Will be converted back to integers for SNN layer.
 40 | x_train = x_train / 255
 41 | x_test = x_test / 255
 42 | 
 43 | # Add a channel dimension.
 44 | axis = 1 if keras.backend.image_data_format() == 'channels_first' else -1
 45 | x_train = np.expand_dims(x_train, axis)
 46 | x_test = np.expand_dims(x_test, axis)
 47 | 
 48 | # One-hot encode target vectors.
 49 | y_train = to_categorical(y_train, 10)
 50 | y_test = to_categorical(y_test, 10)
 51 | 
 52 | # Save dataset so SNN toolbox can find it.
 53 | np.savez_compressed(os.path.join(path_wd, 'x_test'), x_test)
 54 | np.savez_compressed(os.path.join(path_wd, 'y_test'), y_test)
 55 | # SNN toolbox will not do any training, but we save a subset of the training
 56 | # set so the toolbox can use it when normalizing the network parameters.
 57 | np.savez_compressed(os.path.join(path_wd, 'x_norm'), x_train[::10])
 58 | 
 59 | # CREATE ANN #
 60 | ##############
 61 | 
 62 | # This section creates a simple CNN using Keras, and trains it
 63 | # with backpropagation. There are no spikes involved at this point.
 64 | 
 65 | input_shape = x_train.shape[1:]
 66 | input_layer = Input(input_shape)
 67 | 
 68 | layer = Conv2D(filters=16,
 69 |                kernel_size=(5, 5),
 70 |                strides=(2, 2),
 71 |                activation='relu',
 72 |                use_bias=False)(input_layer)
 73 | layer = Conv2D(filters=32,
 74 |                kernel_size=(3, 3),
 75 |                activation='relu',
 76 |                use_bias=False)(layer)
 77 | layer = AveragePooling2D()(layer)
 78 | layer = Conv2D(filters=8,
 79 |                kernel_size=(3, 3),
 80 |                padding='same',
 81 |                activation='relu',
 82 |                use_bias=False)(layer)
 83 | layer = Flatten()(layer)
 84 | layer = Dropout(0.01)(layer)
 85 | layer = Dense(units=10,
 86 |               activation='softmax',
 87 |               use_bias=False)(layer)
 88 | 
 89 | model = Model(input_layer, layer)
 90 | 
 91 | model.summary()
 92 | 
 93 | model.compile('adam', 'categorical_crossentropy', ['accuracy'])
 94 | 
 95 | # Train model with backprop.
 96 | model.fit(x_train, y_train, batch_size=64, epochs=1, verbose=2,
 97 |           validation_data=(x_test, y_test))
 98 | 
 99 | # Store model so SNN Toolbox can find it.
100 | model_name = 'mnist_cnn'
101 | keras.models.save_model(model, os.path.join(path_wd, model_name + '.h5'))
102 | 
103 | # SNN TOOLBOX CONFIGURATION #
104 | #############################
105 | 
106 | # Create a config file with experimental setup for SNN Toolbox.
107 | configparser = import_configparser()
108 | config = configparser.ConfigParser()
109 | 
110 | config['paths'] = {
111 |     'path_wd': path_wd,             # Path to model.
112 |     'dataset_path': path_wd,        # Path to dataset.
113 |     'filename_ann': model_name      # Name of input model.
114 | }
115 | 
116 | config['tools'] = {
117 |     'evaluate_ann': True,           # Test ANN on dataset before conversion.
118 |     # Normalize weights for full dynamic range.
119 |     'normalize': False,
120 |     'scale_weights_exp': True
121 | }
122 | 
123 | config['simulation'] = {
124 |     # Chooses execution backend of SNN toolbox.
125 |     'simulator': 'spiNNaker',
126 |     'duration': 50,                 # Number of time steps to run each sample.
127 |     'num_to_test': 5,               # How many test samples to run.
128 |     'batch_size': 1,                # Batch size for simulation.
129 |     # SpiNNaker seems to require 0.1 for comparable results.
130 |     'dt': 0.1
131 | }
132 | 
133 | config['input'] = {
134 |     'poisson_input': True,           # Images are encodes as spike trains.
135 |     'input_rate': 1000
136 | }
137 | 
138 | config['cell'] = {
139 |     'tau_syn_E': 0.01,
140 |     'tau_syn_I': 0.01
141 | }
142 | 
143 | config['output'] = {
144 |     'plot_vars': {                  # Various plots (slows down simulation).
145 |         'spiketrains',              # Leave section empty to turn off plots.
146 |         'spikerates',
147 |         'activations',
148 |         'correlation',
149 |         'v_mem',
150 |         'error_t'}
151 | }
152 | 
153 | # Store config file.
154 | config_filepath = os.path.join(path_wd, 'config')
155 | with open(config_filepath, 'w') as configfile:
156 |     config.write(configfile)
157 | 
158 | # RUN SNN TOOLBOX #
159 | ###################
160 | 
161 | main(config_filepath)
162 | 


--------------------------------------------------------------------------------
/examples/mnist_keras_spiNNaker_sparse.py:
--------------------------------------------------------------------------------
  1 | """End-to-end example for SNN Toolbox.
  2 | 
  3 | This script sets up a small CNN using Keras and tensorflow, trains it for one
  4 | epoch on MNIST, stores model and dataset in a temporary folder on disk, creates
  5 | a configuration file for SNN toolbox, and finally calls the main function of
  6 | SNN toolbox to convert the trained ANN to an SNN and run it using spiNNaker.
  7 | """
  8 | 
  9 | import os
 10 | import numpy as np
 11 | 
 12 | from tensorflow import keras
 13 | from tensorflow.keras import Input, Model
 14 | from tensorflow.keras.layers import AveragePooling2D, Flatten, Dropout
 15 | from tensorflow.keras.datasets import mnist
 16 | from tensorflow.keras.utils import to_categorical
 17 | from keras_rewiring import Sparse, SparseConv2D, SparseDepthwiseConv2D
 18 | from keras_rewiring.optimizers import NoisySGD
 19 | from keras_rewiring.rewiring_callback import RewiringCallback
 20 | 
 21 | from snntoolbox.bin.run import main
 22 | from snntoolbox.utils.utils import import_configparser
 23 | 
 24 | 
 25 | # WORKING DIRECTORY #
 26 | #####################
 27 | 
 28 | # Define path where model and output files will be stored.
 29 | # The user is responsible for cleaning up this temporary directory.
 30 | path_wd = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(
 31 |     __file__)), '..', 'temp'))
 32 | # os.makedirs(path_wd)
 33 | 
 34 | # GET DATASET #
 35 | ###############
 36 | 
 37 | (x_train, y_train), (x_test, y_test) = mnist.load_data()
 38 | 
 39 | # Normalize input so we can train ANN with it.
 40 | # Will be converted back to integers for SNN layer.
 41 | x_train = x_train / 255
 42 | x_test = x_test / 255
 43 | 
 44 | # Add a channel dimension.
 45 | axis = 1 if keras.backend.image_data_format() == 'channels_first' else -1
 46 | x_train = np.expand_dims(x_train, axis)
 47 | x_test = np.expand_dims(x_test, axis)
 48 | 
 49 | # One-hot encode target vectors.
 50 | y_train = to_categorical(y_train, 10)
 51 | y_test = to_categorical(y_test, 10)
 52 | 
 53 | # Save dataset so SNN toolbox can find it.
 54 | np.savez_compressed(os.path.join(path_wd, 'x_test'), x_test)
 55 | np.savez_compressed(os.path.join(path_wd, 'y_test'), y_test)
 56 | # SNN toolbox will not do any training, but we save a subset of the training
 57 | # set so the toolbox can use it when normalizing the network parameters.
 58 | np.savez_compressed(os.path.join(path_wd, 'x_norm'), x_train[::10])
 59 | 
 60 | # SETUP REWIRING #
 61 | ##################
 62 | 
 63 | deep_r = RewiringCallback(noise_coeff=10 ** -5)
 64 | 
 65 | callback_list = [deep_r]
 66 | 
 67 | # CREATE ANN #
 68 | ##############
 69 | 
 70 | # This section creates a simple CNN using Keras, and trains it
 71 | # with backpropagation. There are no spikes involved at this point.
 72 | 
 73 | input_shape = x_train.shape[1:]
 74 | input_layer = Input(input_shape)
 75 | 
 76 | built_in_sparsity = [0.5] * 4
 77 | 
 78 | layer = SparseConv2D(
 79 |     filters=16,
 80 |     kernel_size=(
 81 |         5,
 82 |         5),
 83 |     strides=(
 84 |         2,
 85 |         2),
 86 |     activation='relu',
 87 |     use_bias=False,
 88 |     connectivity_level=built_in_sparsity.pop(0) or None)(input_layer)
 89 | layer = SparseConv2D(
 90 |     filters=32,
 91 |     kernel_size=(
 92 |         3,
 93 |         3),
 94 |     activation='relu',
 95 |     use_bias=False,
 96 |     connectivity_level=built_in_sparsity.pop(0) or None)(layer)
 97 | layer = AveragePooling2D()(layer)
 98 | layer = SparseConv2D(
 99 |     filters=8,
100 |     kernel_size=(
101 |         3,
102 |         3),
103 |     padding='same',
104 |     activation='relu',
105 |     use_bias=False,
106 |     connectivity_level=built_in_sparsity.pop(0) or None)(layer)
107 | layer = Flatten()(layer)
108 | layer = Dropout(0.01)(layer)
109 | layer = Sparse(units=10,
110 |                activation='softmax',
111 |                use_bias=False,
112 |                connectivity_level=built_in_sparsity.pop(0) or None)(layer)
113 | 
114 | model = Model(input_layer, layer)
115 | 
116 | model.summary()
117 | 
118 | model.compile(
119 |     NoisySGD(
120 |         lr=0.01),
121 |     'categorical_crossentropy',
122 |     ['accuracy'])
123 | 
124 | # Train model with backprop.
125 | model.fit(x_train, y_train, batch_size=64, epochs=5, verbose=2,
126 |           validation_data=(x_test, y_test),
127 |           callbacks=callback_list)
128 | 
129 | # Store model so SNN Toolbox can find it.
130 | model_name = 'sparse_mnist_cnn'
131 | keras.models.save_model(model, os.path.join(path_wd, model_name + '.h5'))
132 | 
133 | # SNN TOOLBOX CONFIGURATION #
134 | #############################
135 | 
136 | # Create a config file with experimental setup for SNN Toolbox.
137 | configparser = import_configparser()
138 | config = configparser.ConfigParser()
139 | 
140 | config['paths'] = {
141 |     'path_wd': path_wd,             # Path to model.
142 |     'dataset_path': path_wd,        # Path to dataset.
143 |     'filename_ann': model_name      # Name of input model.
144 | }
145 | 
146 | config['tools'] = {
147 |     'evaluate_ann': True,           # Test ANN on dataset before conversion.
148 |     # Normalize weights for full dynamic range.
149 |     'normalize': False,
150 |     'scale_weights_exp': True
151 | }
152 | 
153 | config['simulation'] = {
154 |     # Chooses execution backend of SNN toolbox.
155 |     'simulator': 'spiNNaker',
156 |     'duration': 50,                 # Number of time steps to run each sample.
157 |     'num_to_test': 5,               # How many test samples to run.
158 |     'batch_size': 1,                # Batch size for simulation.
159 |     # SpiNNaker seems to require 0.1 for comparable results.
160 |     'dt': 0.1
161 | }
162 | 
163 | config['input'] = {
164 |     'poisson_input': True,           # Images are encodes as spike trains.
165 |     'input_rate': 1000
166 | }
167 | 
168 | config['cell'] = {
169 |     'tau_syn_E': 0.01,
170 |     'tau_syn_I': 0.01
171 | }
172 | 
173 | config['output'] = {
174 |     'plot_vars': {                  # Various plots (slows down simulation).
175 |         'spiketrains',              # Leave section empty to turn off plots.
176 |         'spikerates',
177 |         'activations',
178 |         'correlation',
179 |         'v_mem',
180 |         'error_t'}
181 | }
182 | 
183 | # Store config file.
184 | config_filepath = os.path.join(path_wd, 'config')
185 | with open(config_filepath, 'w') as configfile:
186 |     config.write(configfile)
187 | 
188 | # RUN SNN TOOLBOX #
189 | ###################
190 | 
191 | main(config_filepath)
192 | 


--------------------------------------------------------------------------------
/examples/mnist_pytorch_INI.py:
--------------------------------------------------------------------------------
  1 | """End-to-end example for SNN Toolbox.
  2 | 
  3 | This script sets up a small CNN using PyTorch, trains it for one epoch on
  4 | MNIST, stores model and dataset in a temporary folder on disk, creates a
  5 | configuration file for SNN toolbox, and finally calls the main function of SNN
  6 | toolbox to convert the trained ANN to an SNN and run it using INI simulator.
  7 | """
  8 | 
  9 | import os
 10 | import shutil
 11 | import inspect
 12 | import time
 13 | 
 14 | import numpy as np
 15 | import torch
 16 | import torch.nn as nn
 17 | from tensorflow.keras import backend
 18 | from tensorflow.keras.datasets import mnist
 19 | from tensorflow.keras.utils import to_categorical
 20 | 
 21 | from snntoolbox.bin.run import main
 22 | from snntoolbox.utils.utils import import_configparser
 23 | from tests.parsing.models.pytorch import Model
 24 | 
 25 | 
 26 | # Pytorch to Keras parser needs image_data_format == channel_first.
 27 | backend.set_image_data_format('channels_first')
 28 | 
 29 | # WORKING DIRECTORY #
 30 | #####################
 31 | 
 32 | # Define path where model and output files will be stored.
 33 | # The user is responsible for cleaning up this temporary directory.
 34 | path_wd = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(
 35 |     __file__)), '..', 'temp', str(time.time())))
 36 | os.makedirs(path_wd)
 37 | 
 38 | # GET DATASET #
 39 | ###############
 40 | 
 41 | (x_train, y_train), (x_test, y_test) = mnist.load_data()
 42 | 
 43 | # Normalize input so we can train ANN with it.
 44 | # Will be converted back to integers for SNN layer.
 45 | x_train = x_train / 255
 46 | x_test = x_test / 255
 47 | 
 48 | # Add a channel dimension.
 49 | axis = 1 if backend.image_data_format() == 'channels_first' else -1
 50 | x_train = np.expand_dims(x_train, axis)
 51 | x_test = np.expand_dims(x_test, axis)
 52 | 
 53 | # One-hot encode target vectors before saving for use in toolbox.
 54 | y_train = to_categorical(y_train, 10)
 55 | y_test = to_categorical(y_test, 10)
 56 | 
 57 | # Save dataset so SNN toolbox can find it.
 58 | np.savez_compressed(os.path.join(path_wd, 'x_test'), x_test)
 59 | np.savez_compressed(os.path.join(path_wd, 'y_test'), y_test)
 60 | # SNN toolbox will not do any training, but we save a subset of the training
 61 | # set so the toolbox can use it when normalizing the network parameters.
 62 | np.savez_compressed(os.path.join(path_wd, 'x_norm'), x_train[::10])
 63 | 
 64 | # Pytorch doesn't support one-hot labels, so we undo it for training the ANN.
 65 | y_train = np.argmax(y_train, 1)
 66 | y_test = np.argmax(y_test, 1)
 67 | 
 68 | 
 69 | class PytorchDataset(torch.utils.data.Dataset):
 70 |     def __init__(self, data, target, transform=None):
 71 |         self.data = torch.from_numpy(data).float()
 72 |         self.target = torch.from_numpy(target).long()
 73 |         self.transform = transform
 74 | 
 75 |     def __getitem__(self, index):
 76 |         x = self.data[index]
 77 | 
 78 |         if self.transform:
 79 |             x = self.transform(x)
 80 | 
 81 |         return x, self.target[index]
 82 | 
 83 |     def __len__(self):
 84 |         return len(self.data)
 85 | 
 86 | 
 87 | trainset = torch.utils.data.DataLoader(PytorchDataset(x_train, y_train),
 88 |                                        batch_size=64)
 89 | testset = torch.utils.data.DataLoader(PytorchDataset(x_test, y_test),
 90 |                                       batch_size=64)
 91 | 
 92 | # CREATE ANN #
 93 | ##############
 94 | 
 95 | # This section creates a CNN using pytorch, and trains it with backpropagation.
 96 | # There are no spikes involved at this point.
 97 | 
 98 | # Create pytorch model from definition in separate script.
 99 | model = Model()
100 | 
101 | criterion = nn.CrossEntropyLoss()
102 | optimizer = torch.optim.Adam(model.parameters())
103 | 
104 | # Train model with backprop.
105 | acc = 0
106 | for epoch in range(3):
107 |     for i, (xx, y) in enumerate(trainset):
108 |         optimizer.zero_grad()
109 |         outputs = model(xx)
110 |         loss = criterion(outputs, y)
111 |         loss.backward()
112 |         optimizer.step()
113 | 
114 |     total = 0
115 |     correct = 0
116 |     with torch.no_grad():
117 |         for xx, y in testset:
118 |             outputs = model(xx)
119 |             _, predicted = torch.max(outputs.data, 1)
120 |             total += y.size(0)
121 |             correct += (predicted == y).sum().item()
122 |     acc = correct / total
123 | 
124 | print("Test accuracy: {:.2%}".format(acc))
125 | 
126 | # Store weights so SNN Toolbox can find them.
127 | model_name = 'pytorch_cnn'
128 | torch.save(model.state_dict(), os.path.join(path_wd, model_name + '.pkl'))
129 | 
130 | # SNN TOOLBOX CONFIGURATION #
131 | #############################
132 | 
133 | # Create a config file with experimental setup for SNN Toolbox.
134 | configparser = import_configparser()
135 | config = configparser.ConfigParser()
136 | 
137 | config['paths'] = {
138 |     'path_wd': path_wd,             # Path to model.
139 |     'dataset_path': path_wd,        # Path to dataset.
140 |     'filename_ann': model_name      # Name of input model.
141 | }
142 | 
143 | config['tools'] = {
144 |     'evaluate_ann': True,           # Test ANN on dataset before conversion.
145 |     'normalize': True               # Normalize weights for full dynamic range.
146 | }
147 | 
148 | config['simulation'] = {
149 |     'simulator': 'INI',             # Chooses execution backend of SNN toolbox.
150 |     'duration': 50,                 # Number of time steps to run each sample.
151 |     'num_to_test': 100,             # How many test samples to run.
152 |     'batch_size': 50,               # Batch size for simulation.
153 |     'keras_backend': 'tensorflow'   # Which keras backend to use.
154 | }
155 | 
156 | config['input'] = {
157 |     'model_lib': 'pytorch'          # Input model is defined in pytorch.
158 | }
159 | 
160 | config['output'] = {
161 |     'plot_vars': {                  # Various plots (slows down simulation).
162 |         'spiketrains',              # Leave section empty to turn off plots.
163 |         'spikerates',
164 |         'activations',
165 |         'correlation',
166 |         'v_mem',
167 |         'error_t'}
168 | }
169 | 
170 | # Store config file.
171 | config_filepath = os.path.join(path_wd, 'config')
172 | with open(config_filepath, 'w') as configfile:
173 |     config.write(configfile)
174 | 
175 | # Need to copy model definition over to ``path_wd`` (needs to be in same dir as
176 | # the weights saved above).
177 | source_path = inspect.getfile(Model)
178 | shutil.copyfile(source_path, os.path.join(path_wd, model_name + '.py'))
179 | 
180 | # RUN SNN TOOLBOX #
181 | ###################
182 | 
183 | main(config_filepath)
184 | 


--------------------------------------------------------------------------------
/examples/resnet_keras_INI.py:
--------------------------------------------------------------------------------
  1 | """End-to-end example for SNN Toolbox.
  2 | 
  3 | This script sets up a small ResNet using Keras, trains it for one epoch on
  4 | MNIST, stores model and dataset in a temporary folder on disk, creates a
  5 | configuration file for SNN toolbox, and finally calls the main function of SNN
  6 | toolbox to convert the trained ANN to an SNN and run it using INI simulator.
  7 | """
  8 | 
  9 | import os
 10 | import time
 11 | import numpy as np
 12 | 
 13 | from tensorflow.keras import Input, Model, layers, backend, models
 14 | from tensorflow.keras.datasets import mnist
 15 | from tensorflow.keras.utils import to_categorical
 16 | from snntoolbox.bin.run import main
 17 | from snntoolbox.utils.utils import import_configparser
 18 | 
 19 | # WORKING DIRECTORY #
 20 | #####################
 21 | 
 22 | # Define path where model and output files will be stored.
 23 | # The user is responsible for cleaning up this temporary directory.
 24 | path_wd = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(
 25 |     __file__)), '..', 'temp', str(time.time())))
 26 | os.makedirs(path_wd)
 27 | 
 28 | # GET DATASET #
 29 | ###############
 30 | 
 31 | (x_train, y_train), (x_test, y_test) = mnist.load_data()
 32 | 
 33 | # Normalize input so we can train ANN with it.
 34 | # Will be converted back to integers for SNN layer.
 35 | x_train = x_train / 255
 36 | x_test = x_test / 255
 37 | 
 38 | # Add a channel dimension.
 39 | axis = 1 if backend.image_data_format() == 'channels_first' else -1
 40 | x_train = np.expand_dims(x_train, axis)
 41 | x_test = np.expand_dims(x_test, axis)
 42 | 
 43 | # One-hot encode target vectors.
 44 | y_train = to_categorical(y_train, 10)
 45 | y_test = to_categorical(y_test, 10)
 46 | 
 47 | # Save dataset so SNN toolbox can find it.
 48 | np.savez_compressed(os.path.join(path_wd, 'x_test'), x_test)
 49 | np.savez_compressed(os.path.join(path_wd, 'y_test'), y_test)
 50 | # SNN toolbox will not do any training, but we save a subset of the training
 51 | # set so the toolbox can use it when normalizing the network parameters.
 52 | np.savez_compressed(os.path.join(path_wd, 'x_norm'), x_train[::10])
 53 | 
 54 | 
 55 | # CREATE ANN #
 56 | ##############
 57 | 
 58 | # This section creates a small ResNet using Keras, and trains it with
 59 | # backpropagation. There are no spikes involved at this point.
 60 | 
 61 | # Here we copy a residual block as implemented in
 62 | # ``tensorflow.keras.applications.resnet`` but make one change: The final conv
 63 | # layer needs a ReLU activation as explained below.
 64 | def block1(x, filters, kernel_size=3, stride=1, conv_shortcut=True, name=None):
 65 |     """A residual block.
 66 | 
 67 |     Arguments:
 68 |     x: input tensor.
 69 |     filters: integer, filters of the bottleneck layer.
 70 |     kernel_size: default 3, kernel size of the bottleneck layer.
 71 |     stride: default 1, stride of the first layer.
 72 |     conv_shortcut: default True, use convolution shortcut if True,
 73 |         otherwise identity shortcut.
 74 |     name: string, block label.
 75 | 
 76 |     Returns:
 77 |     Output tensor for the residual block.
 78 |     """
 79 |     bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
 80 | 
 81 |     if conv_shortcut:
 82 |         shortcut = layers.Conv2D(
 83 |             4 * filters, 1, strides=stride, name=name + '_0_conv')(x)
 84 |         shortcut = layers.BatchNormalization(
 85 |             axis=bn_axis, epsilon=1.001e-5, name=name + '_0_bn')(shortcut)
 86 |     else:
 87 |         shortcut = x
 88 | 
 89 |     x = layers.Conv2D(filters, 1, strides=stride, name=name + '_1_conv')(x)
 90 |     x = layers.BatchNormalization(
 91 |         axis=bn_axis, epsilon=1.001e-5, name=name + '_1_bn')(x)
 92 |     x = layers.Activation('relu', name=name + '_1_relu')(x)
 93 | 
 94 |     x = layers.Conv2D(
 95 |         filters, kernel_size, padding='SAME', name=name + '_2_conv')(x)
 96 |     x = layers.BatchNormalization(
 97 |         axis=bn_axis, epsilon=1.001e-5, name=name + '_2_bn')(x)
 98 |     x = layers.Activation('relu', name=name + '_2_relu')(x)
 99 | 
100 |     x = layers.Conv2D(4 * filters, 1, name=name + '_3_conv')(x)
101 |     x = layers.BatchNormalization(
102 |         axis=bn_axis, epsilon=1.001e-5, name=name + '_3_bn')(x)
103 | 
104 |     # Swapped order of Activation and Add layers so that ReLU is applied to
105 |     # the previous conv layer. The sequence {Conv + ReLU} or {Conv + BN + ReLU}
106 |     # is necessary because the SNN spike generation implicitly applies ReLU on
107 |     # each spiking layer.
108 |     x = layers.Activation('relu', name=name + '_out')(x)
109 |     x = layers.Add(name=name + '_add')([shortcut, x])
110 |     return x
111 | 
112 | 
113 | input_shape = x_train.shape[1:]
114 | input_layer = Input(input_shape)
115 | layer = layers.Conv2D(32, 3, strides=2, activation='relu')(input_layer)
116 | layer = block1(layer, filters=8, conv_shortcut=False, name='block1')
117 | layer = layers.Flatten()(layer)
118 | layer = layers.Dense(units=10, activation='softmax')(layer)
119 | 
120 | model = Model(input_layer, layer)
121 | 
122 | model.summary()
123 | 
124 | model.compile('adam', 'categorical_crossentropy', ['accuracy'])
125 | 
126 | # Train model with backprop.
127 | model.fit(x_train, y_train, batch_size=64, epochs=1, verbose=2,
128 |           validation_data=(x_test, y_test))
129 | 
130 | # Store model so SNN Toolbox can find it.
131 | model_name = 'mnist_resnet'
132 | models.save_model(model, os.path.join(path_wd, model_name + '.h5'))
133 | 
134 | # SNN TOOLBOX CONFIGURATION #
135 | #############################
136 | 
137 | # Create a config file with experimental setup for SNN Toolbox.
138 | configparser = import_configparser()
139 | config = configparser.ConfigParser()
140 | 
141 | config['paths'] = {
142 |     'path_wd': path_wd,  # Path to model.
143 |     'dataset_path': path_wd,  # Path to dataset.
144 |     'filename_ann': model_name  # Name of input model.
145 | }
146 | 
147 | config['tools'] = {
148 |     'evaluate_ann': True,  # Test ANN on dataset before conversion.
149 |     'normalize': True  # Normalize weights for full dynamic range.
150 | }
151 | 
152 | config['simulation'] = {
153 |     'simulator': 'INI',  # Chooses execution backend of SNN toolbox.
154 |     'duration': 50,  # Number of time steps to run each sample.
155 |     'num_to_test': 100,  # How many test samples to run.
156 |     'batch_size': 50,  # Batch size for simulation.
157 |     'keras_backend': 'tensorflow'  # Which keras backend to use.
158 | }
159 | 
160 | config['output'] = {
161 |     'plot_vars': {  # Various plots (slows down simulation).
162 |         'spiketrains',  # Leave section empty to turn off plots.
163 |         'spikerates',
164 |         'activations',
165 |         'correlation',
166 |         'v_mem',
167 |         'error_t'}
168 | }
169 | 
170 | # Store config file.
171 | config_filepath = os.path.join(path_wd, 'config')
172 | with open(config_filepath, 'w') as configfile:
173 |     config.write(configfile)
174 | 
175 | # RUN SNN TOOLBOX #
176 | ###################
177 | 
178 | main(config_filepath)
179 | 


--------------------------------------------------------------------------------
/requirements.rtd.txt:
--------------------------------------------------------------------------------
 1 | h5py
 2 | matplotlib
 3 | Pillow
 4 | torch
 5 | onnx
 6 | onnxruntime
 7 | # onnx2keras  # Latest version breaks installation in readthedocs build.
 8 | lasagne
 9 | theano
10 | brian2
11 | pyNN
12 | NEURON
13 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | tensorflow
2 | 


--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
 1 | [bdist_wheel]
 2 | # This flag says that the code is written to work on both Python 2 and 3.
 3 | universal=1
 4 | 
 5 | [egg_info]
 6 | # This will tell setuptools to generate package version numbers like
 7 | # 1.0a1.dev-r1263, which will be considered to be an older release than 1.0a1.
 8 | # tag_build = .dev
 9 | 
10 | [aliases]
11 | # Testing package with pytest.
12 | test=pytest
13 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | """
 2 | Setup SNN toolbox
 3 | 
 4 | """
 5 | 
 6 | from setuptools import setup, find_packages
 7 | 
 8 | 
 9 | with open('README.rst') as f:
10 |     long_description = f.read()
11 | 
12 | with open('requirements.txt') as f:
13 |     requirements = f.read().splitlines()
14 | 
15 | setup(
16 |     name='snntoolbox',
17 |     version='0.6.0',  # see https://www.python.org/dev/peps/pep-0440/
18 |     description='Spiking neural network conversion toolbox',
19 |     long_description=long_description,
20 |     author='Bodo Rueckauer',
21 |     author_email='bodo.rueckauer@gmail.com',
22 |     url='https://github.com/NeuromorphicProcessorProject/snn_toolbox',
23 |     download_url='https://github.com/NeuromorphicProcessorProject/snn_toolbox'
24 |                  '.git',
25 |     license='MIT',
26 | 
27 |     classifiers=[
28 |         # How mature is this project? Common values are
29 |         #   3 - Alpha
30 |         #   4 - Beta
31 |         #   5 - Production/Stable
32 |         # 'Development Status :: 3 - Alpha',
33 | 
34 |         # Indicate who this project is intended for
35 |         # 'Intended Audience :: Researchers',
36 |         # 'Topic :: Software Development :: Build Tools',
37 | 
38 |         # License
39 |         'License :: OSI Approved :: MIT License',
40 | 
41 |         # Supported Python versions
42 |         'Programming Language :: Python :: 2.7',
43 |         'Programming Language :: Python :: 3',
44 |         'Programming Language :: Python :: 3.6',
45 |         'Programming Language :: Python :: 3.7',
46 |     ],
47 | 
48 |     keywords='neural networks, deep learning, spiking',
49 | 
50 |     install_requires=requirements,
51 | 
52 |     setup_requires=['pytest-runner'],
53 | 
54 |     tests_require=['pytest'],
55 | 
56 |     # cmdclass={'test': Tox, 'build_doc': BuildDoc},
57 | 
58 |     # Additional groups of dependencies (e.g. development dependencies).
59 |     # Install them with $ pip install -e .[dev,test]
60 |     # extras_require={
61 |     #     'dev': ['foo'],
62 |     #     'test': ['bar']
63 |     # },
64 | 
65 |     packages=find_packages(exclude=[]),
66 | 
67 |     package_data={
68 |         'snntoolbox': ['config_defaults']
69 |     },
70 | 
71 |     # Include documentation
72 |     data_files=[
73 |         ('', ['README.rst']),
74 |     ],
75 | 
76 |     # To provide executable scripts, use entry points in preference to the
77 |     # "scripts" keyword. Entry points provide cross-platform support and allow
78 |     # pip to create the appropriate form of executable for the target platform.
79 |     entry_points={
80 |         'console_scripts': ['snntoolbox=snntoolbox.bin.run:main']
81 |         # 'gui_scripts': ['snntoolbox_gui=snntoolbox.bin.gui.gui:main']
82 |     },
83 | )
84 | 


--------------------------------------------------------------------------------
/snntoolbox/__init__.py:
--------------------------------------------------------------------------------
1 | # coding=utf-8
2 | 


--------------------------------------------------------------------------------
/snntoolbox/bin/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/snntoolbox/bin/__init__.py


--------------------------------------------------------------------------------
/snntoolbox/bin/gui/__init__.py:
--------------------------------------------------------------------------------
1 | # coding=utf-8
2 | 
3 | """Init"""
4 | 


--------------------------------------------------------------------------------
/snntoolbox/bin/run.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | """
 4 | The purpose of this module is to provide an executable for running the SNN
 5 | conversion toolbox, either from terminal or using a GUI.
 6 | 
 7 | During installation of the toolbox, python creates an entry point to the `main`
 8 | function of this module. See :ref:`running` for how call this executable.
 9 | 
10 | @author: rbodo
11 | """
12 | 
13 | import argparse
14 | import os
15 | 
16 | 
17 | def main(filepath=None):
18 |     """Entry point for running the toolbox.
19 | 
20 |     Note
21 |     ----
22 | 
23 |     There is no need to call this function directly, because python sets up an
24 |     executable during :ref:`installation` that can be called from terminal.
25 | 
26 |     """
27 |     from snntoolbox.bin.utils import update_setup, run_pipeline
28 | 
29 |     if filepath is not None:
30 |         config = update_setup(filepath)
31 |         run_pipeline(config)
32 |         return
33 | 
34 |     parser = argparse.ArgumentParser(
35 |         description='Run SNN toolbox to convert an analog neural network into '
36 |                     'a spiking neural network, and optionally simulate it.')
37 |     parser.add_argument('config_filepath', nargs='?',
38 |                         help='Path to configuration file.')
39 |     parser.add_argument('-t', '--terminal', action='store_true',
40 |                         help='Set this flag to run the toolbox from terminal. '
41 |                              'Omit this flag to open GUI.')
42 |     args = parser.parse_args()
43 | 
44 |     _filepath = os.path.abspath(args.config_filepath)
45 |     if _filepath is not None:
46 |         config = update_setup(_filepath)
47 | 
48 |         if args.terminal:
49 |             run_pipeline(config)
50 |         else:
51 |             from snntoolbox.bin.gui import gui
52 |             gui.main()
53 |     else:
54 |         if args.terminal:
55 |             parser.error("When using the SNN toolbox from terminal, a "
56 |                          "config_filepath argument must be provided.")
57 |             return
58 |         else:
59 |             from snntoolbox.bin.gui import gui
60 |             gui.main()
61 | 
62 | 
63 | if __name__ == '__main__':
64 |     main()
65 | 


--------------------------------------------------------------------------------
/snntoolbox/config_defaults:
--------------------------------------------------------------------------------
  1 | [paths]
  2 | path_wd =
  3 | dataset_path =
  4 | log_dir_of_current_run =
  5 | runlabel = test
  6 | filename_ann =
  7 | filename_parsed_model =
  8 | filename_snn =
  9 | filename_clamp_indices =
 10 | filepath_custom_objects =
 11 | class_idx_path =
 12 | 
 13 | [input]
 14 | model_lib = keras
 15 | dataset_format = npz
 16 | datagen_kwargs = {}
 17 | dataflow_kwargs = {}
 18 | poisson_input = False
 19 | input_rate = 1000
 20 | num_poisson_events_per_sample = -1
 21 | num_dvs_events_per_sample = 2000
 22 | eventframe_width = 10
 23 | label_dict = {}
 24 | chip_size = None
 25 | frame_gen_method =
 26 | is_x_first =
 27 | is_x_flipped =
 28 | is_y_flipped =
 29 | maxpool_subsampling = True
 30 | do_clip_three_sigma = True
 31 | keras_dataset =
 32 | 
 33 | [tools]
 34 | evaluate_ann = True
 35 | parse = True
 36 | normalize = True
 37 | convert = True
 38 | simulate = True
 39 | serialise_only = False
 40 | 
 41 | [normalization]
 42 | percentile = 99.9
 43 | normalization_schedule = False
 44 | online_normalization = False
 45 | diff_to_max_rate = 200
 46 | diff_to_min_rate = 100
 47 | timestep_fraction = 10
 48 | 
 49 | [conversion]
 50 | softmax_to_relu = False
 51 | maxpool_type = fir_max
 52 | max2avg_pool = False
 53 | spike_code = temporal_mean_rate
 54 | num_bits = 32
 55 | 
 56 | [simulation]
 57 | simulator = INI
 58 | duration = 200
 59 | dt = 1
 60 | batch_size = 1
 61 | num_to_test = 1
 62 | sample_idxs_to_test = []
 63 | reset_between_nth_sample = 1
 64 | top_k = 1
 65 | keras_backend = tensorflow
 66 | early_stopping = False
 67 | 
 68 | [spinnaker]
 69 | number_of_neurons_per_core = 64
 70 | 
 71 | [cell]
 72 | v_thresh = 1
 73 | tau_refrac = 0
 74 | v_reset = 0
 75 | v_rest = 0
 76 | cm = 1
 77 | tau_m = 1000
 78 | tau_syn_E = 0.01
 79 | tau_syn_I = 0.01
 80 | delay = 0
 81 | binarize_weights = False
 82 | quantize_weights = False
 83 | scaling_factor = 10000000
 84 | payloads = False
 85 | reset = Reset by subtraction
 86 | leak = False
 87 | bias_relaxation = False
 88 | 
 89 | [parameter_sweep]
 90 | param_values = []
 91 | param_name = v_thresh
 92 | param_logscale = False
 93 | 
 94 | [output]
 95 | log_vars = {}
 96 | plot_vars = {}
 97 | verbose = 1
 98 | overwrite = True
 99 | use_simple_labels = True
100 | plotproperties = {
101 |     'font.size': 13,
102 |     'axes.titlesize': 'xx-large',
103 |     'axes.labelsize': 'xx-large',
104 |     'xtick.labelsize': 'xx-large',
105 |     'xtick.major.size': 7,
106 |     'xtick.minor.size': 5,
107 |     'ytick.labelsize': 'xx-large',
108 |     'ytick.major.size': 7,
109 |     'ytick.minor.size': 5,
110 |     'legend.fontsize': 'xx-large',
111 |     'figure.figsize': (7, 6),
112 |     'savefig.format': 'png'}
113 | 
114 | # Use the following section to specify sets of possible values that certain
115 | # config settings may accept. Will be used in `bin.utils.update_setup` to test
116 | # validity of config.
117 | 
118 | [restrictions]
119 | model_libs = {'keras', 'lasagne', 'caffe', 'pytorch'}
120 | dataset_formats = {'npz', 'jpg', 'aedat'}
121 | frame_gen_method = {'signed_sum', 'rectified_sum',
122 |                     'rectified_polarity_channels', 'signed_polarity_channels'}
123 | maxpool_types = {'fir_max', 'exp_max', 'avg_max'}
124 | simulators_pyNN = {'nest', 'brian', 'neuron', 'spiNNaker'}
125 | simulators_other = {'INI', 'brian2', 'MegaSim', 'loihi'}
126 | simulators = %(simulators_pyNN)s | %(simulators_other)s
127 | # Keras backends:
128 | keras_backends = {'theano', 'tensorflow'}
129 | # Spike coding mechanisms:
130 | spike_codes = {'temporal_mean_rate', 'temporal_pattern', 'ttfs',
131 |                'ttfs_dyn_thresh', 'ttfs_corrective'}
132 | # Layers that have neurons with membrane potentials, from which we can measure spikes:
133 | spiking_layers = {'Dense', 'Conv1D', 'Conv2D', 'DepthwiseConv2D', 'Conv2DTranspose', 'UpSampling2D', 'MaxPooling2D',
134 |                   'AveragePooling2D', 'Sparse', 'SparseConv2D',
135 |                   'SparseDepthwiseConv2D'}
136 | # Layers that can be implemented by our spiking neuron simulators:
137 | snn_layers = %(spiking_layers)s | {'Reshape', 'Flatten', 'Concatenate',
138 |                                    'ZeroPadding2D'}
139 | cellparams_pyNN = {'v_thresh', 'v_reset', 'v_rest', 'cm', 'tau_refrac',
140 |                    'tau_m', 'tau_syn_E', 'tau_syn_I'}
141 | 
142 | log_vars = {'activations_n_b_l', 'spiketrains_n_b_l_t', 'input_b_l_t',
143 |             'mem_n_b_l_t', 'synaptic_operations_b_t', 'neuron_operations_b_t',
144 |             'all'}
145 | plot_vars = {'activations', 'spiketrains', 'spikecounts', 'spikerates',
146 |              'input_image', 'error_t', 'confusion_matrix', 'correlation',
147 |              'hist_spikerates_activations', 'normalization_activations',
148 |              'operations', 'v_mem', 'all'}
149 | 


--------------------------------------------------------------------------------
/snntoolbox/conversion/__init__.py:
--------------------------------------------------------------------------------
1 | # coding=utf-8
2 | 
3 | """Init"""
4 | 


--------------------------------------------------------------------------------
/snntoolbox/datasets/__init__.py:
--------------------------------------------------------------------------------
1 | # coding=utf-8
2 | 
3 | """Init"""
4 | 


--------------------------------------------------------------------------------
/snntoolbox/datasets/aedat/ImportAedat.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | """
 4 | Import aedat file.
 5 | """
 6 | 
 7 | from snntoolbox.datasets.aedat.ImportAedatHeaders import \
 8 |     import_aedat_headers
 9 | from snntoolbox.datasets.aedat.ImportAedatDataVersion1or2 import \
10 |     import_aedat_dataversion1or2
11 | 
12 | 
13 | def import_aedat(args):
14 |     """
15 | 
16 |     Parameters
17 |     ----------
18 |     args :
19 | 
20 |     Returns
21 |     -------
22 | 
23 |     """
24 | 
25 |     output = {'info': args}
26 | 
27 |     with open(output['info']['filePathAndName'], 'rb') as \
28 |             output['info']['fileHandle']:
29 |         output['info'] = import_aedat_headers(output['info'])
30 |         return import_aedat_dataversion1or2(output['info'])
31 | 


--------------------------------------------------------------------------------
/snntoolbox/datasets/aedat/ImportAedatBasicSourceName.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | """Import basic source name"""
 4 | 
 5 | 
 6 | def import_aedat_basic_source_name(inp):
 7 |     """
 8 | 
 9 |     Parameters
10 |     ----------
11 |     inp:
12 |         A device name.
13 | 
14 |     Returns
15 |     -------
16 |     :
17 |         The key device name associated with ``input``.
18 | 
19 |     """
20 | 
21 |     devices = {
22 |         'file': 'File',
23 |         'network': 'Network',
24 |         'dvs128': 'Dvs128',
25 |         'tmpdiff128': 'Dvs128',
26 |         'davis240a': 'Davis240A',
27 |         'sbret10': 'Davis240A',
28 |         'davis240b': 'Davis240B',
29 |         'sbret20': 'Davis240B',
30 |         'davis240c': 'Davis240C',
31 |         'sbret21': 'Davis240C',
32 |         'davis128mono': 'Davis128Mono',
33 |         'davis128rgb': 'Davis128Rgb',
34 |         'davis128': 'Davis128Rgb',
35 |         'davis208mono': 'Davis208Mono',
36 |         'davis208rgbw': 'Davis208Mono',
37 |         'pixelparade': 'Davis208Rgbw',
38 |         'sensdavis192': 'Davis208Rgbw',
39 |         'davis208': 'Davis208Rgbw',
40 |         'davis346amono': 'Davis346AMono',
41 |         'davis346argb': 'Davis346ARgb',
42 |         'davis346': 'Davis346ARgb',
43 |         'davis346bmono': 'Davis346BMono',
44 |         'davis346brgb': 'Davis346BRgb',
45 |         'davis346b': 'Davis346BRgb',
46 |         'davis346cbsi': 'Davis346CBsi',
47 |         'davis346bsi': 'Davis346CBsi',
48 |         'davis640mono': 'Davis640Mono',
49 |         'davis640rgb': 'Davis640Rgb',
50 |         'davis640': 'Davis640Rgb',
51 |         'davishet640mono': 'DavisHet640Mono',
52 |         'davishet640rgbw': 'DavisHet640Rgbw',
53 |         'cdavis640': 'DavisHet640Rgbw',
54 |         'cdavis640rgbw': 'DavisHet640Rgbw',
55 |         'das1': 'Das1',
56 |         'cochleaams1c': 'CochleaAms1c'}
57 | 
58 |     return devices.get(inp.lower()[:-2], 'Dvs128')  # Cut off '\r'
59 | 


--------------------------------------------------------------------------------
/snntoolbox/datasets/aedat/ImportAedatDataVersion1or2.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | """
  4 | Import aedat version 1 or 2.
  5 | """
  6 | 
  7 | import numpy as np
  8 | 
  9 | 
 10 | def import_aedat_dataversion1or2(info):
 11 |     """
 12 | 
 13 |     Parameters
 14 |     ----------
 15 |     info :
 16 |     """
 17 | 
 18 |     # The formatVersion dictates whether there are 6 or 8 bytes per event.
 19 |     if info['formatVersion'] == 1:
 20 |         num_bytes_per_event = 6
 21 |         addr_precision = np.dtype([('addr', '>u2'), ('ts', '>u4')])
 22 |     else:
 23 |         num_bytes_per_event = 8
 24 |         addr_precision = np.dtype([('addr', '>u4'), ('ts', '>u4')])
 25 | 
 26 |     file_handle = info['fileHandle']
 27 | 
 28 |     # Find the number of events, assuming that the file position is just at the
 29 |     # end of the headers.
 30 |     file_handle.seek(0, 2)
 31 |     num_events_in_file = int(np.floor(
 32 |         (file_handle.tell() - info['beginningOfDataPointer']) /
 33 |         num_bytes_per_event))
 34 |     info['numEventsInFile'] = num_events_in_file
 35 | 
 36 |     # Check the startEvent and endEvent parameters
 37 |     if 'startEvent' not in info:
 38 |         info['startEvent'] = 0
 39 |     assert info['startEvent'] <= num_events_in_file
 40 |     if 'endEvent' not in info:
 41 |         info['endEvent'] = num_events_in_file
 42 |     if 'startPacket' in info:
 43 |         print("The startPacket parameter is set, but range by packets is not "
 44 |               "available for .aedat version < 3 files")
 45 |     if 'endPacket' in info:
 46 |         print("The endPacket parameter is set, but range by events is not "
 47 |               "available for .aedat version < 3 files")
 48 |     if info['endEvent'] > num_events_in_file:
 49 |         print("The file contains {}; the endEvent parameter is {}; reducing "
 50 |               "the endEvent parameter accordingly.".format(num_events_in_file,
 51 |                                                            info['endEvents']))
 52 |         info['endEvent'] = num_events_in_file
 53 |     assert info['startEvent'] < info['endEvent']
 54 | 
 55 |     num_events_to_read = int(info['endEvent'] - info['startEvent'])
 56 | 
 57 |     # Read events
 58 |     file_handle.seek(info['beginningOfDataPointer'] + num_bytes_per_event *
 59 |                      info['startEvent'])
 60 |     all_events = np.fromfile(file_handle, addr_precision, num_events_to_read)
 61 | 
 62 |     all_addr = np.array(all_events['addr'])
 63 |     all_ts = np.array(all_events['ts'])
 64 | 
 65 |     # Trim events outside time window.
 66 |     # This is an inefficent implementation, which allows for non-monotonic
 67 |     # timestamps.
 68 | 
 69 |     if 'startTime' in info:
 70 |         temp_index = np.nonzero(all_ts >= info['startTime'] * 1e6)
 71 |         all_addr = all_addr[temp_index]
 72 |         all_ts = all_ts[temp_index]
 73 | 
 74 |     if 'endTime' in info:
 75 |         temp_index = np.nonzero(all_ts <= info['endTime'] * 1e6)
 76 |         all_addr = all_addr[temp_index]
 77 |         all_ts = all_ts[temp_index]
 78 | 
 79 |     # DAVIS. In the 32-bit address:
 80 |     # bit 32 (1-based) being 1 indicates an APS sample
 81 |     # bit 11 (1-based) being 1 indicates a special event
 82 |     # bits 11 and 32 (1-based) both being zero signals a polarity event
 83 |     aps_or_imu_mask = int('80000000', 16)
 84 |     aps_or_imu_logical = np.bitwise_and(all_addr, aps_or_imu_mask)
 85 |     signal_or_special_mask = int('400', 16)
 86 |     signal_or_special_logical = np.bitwise_and(all_addr,
 87 |                                                signal_or_special_mask)
 88 |     polarity_logical = \
 89 |         np.logical_and(np.logical_not(aps_or_imu_logical),
 90 |                        np.logical_not(signal_or_special_logical))
 91 | 
 92 |     # These masks are used for both frames and polarity events, so are defined
 93 |     # outside of the following if statement
 94 |     y_mask = int('7FC00000', 16)
 95 |     y_shift_bits = 22
 96 |     x_mask = int('003FF000', 16)
 97 |     x_shift_bits = 12
 98 | 
 99 |     output = {'data': {}}
100 | 
101 |     # Polarity(DVS) events
102 |     if ('dataTypes' not in info or 'polarity' in info['dataTypes']) \
103 |             and any(polarity_logical):
104 |         output['data']['polarity'] = {}
105 |         output['data']['polarity']['timeStamp'] = all_ts[polarity_logical]
106 |         # Y addresses
107 |         output['data']['polarity']['y'] = np.array(np.right_shift(
108 |             np.bitwise_and(all_addr[polarity_logical], y_mask), y_shift_bits),
109 |             'int32')
110 |         # X addresses
111 |         output['data']['polarity']['x'] = np.array(np.right_shift(
112 |             np.bitwise_and(all_addr[polarity_logical], x_mask), x_shift_bits),
113 |             'int32')
114 |         # Polarity bit
115 |         output['data']['polarity']['polarity'] = np.array(np.equal(
116 |             np.right_shift(all_addr[polarity_logical], 11) % 2, 1), 'int32')
117 | 
118 |     output['info'] = info
119 | 
120 |     # calculate numEvents fields; also find first and last timeStamps
121 |     output['info']['firstTimeStamp'] = np.infty
122 |     output['info']['lastTimeStamp'] = 0
123 | 
124 |     if 'polarity' in output['data']:
125 |         output['data']['polarity']['numEvents'] = \
126 |             len(output['data']['polarity']['timeStamp'])
127 |         # noinspection PyTypeChecker
128 |         if output['data']['polarity']['timeStamp'][0] < \
129 |                 output['info']['firstTimeStamp']:
130 |             # noinspection PyTypeChecker
131 |             output['info']['firstTimeStamp'] = \
132 |                 output['data']['polarity']['timeStamp'][0]
133 |         # noinspection PyTypeChecker
134 |         if output['data']['polarity']['timeStamp'][-1] > \
135 |                 output['info']['lastTimeStamp']:
136 |             # noinspection PyTypeChecker
137 |             output['info']['lastTimeStamp'] = \
138 |                 output['data']['polarity']['timeStamp'][-1]
139 | 
140 |     return output
141 | 


--------------------------------------------------------------------------------
/snntoolbox/datasets/aedat/ImportAedatHeaders.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """
  3 | This is a sub-function of importAedat. 
  4 | This function processes the headers of an Aedat file. 
  5 | (as well as any attached prefs files). 
  6 | The .aedat file format is documented here:
  7 | http://inilabs.com/support/software/fileformat/
  8 |     
  9 | 2015_12_11 Work in progress: 
 10 |     - Reading from a separate prefs file is not implemented yet.  
 11 |     - It would be neater (more readable) to turn the xml cell array into a
 12 |       structure.
 13 | """
 14 | 
 15 | from snntoolbox.datasets.aedat.ImportAedatBasicSourceName import \
 16 |     import_aedat_basic_source_name
 17 | 
 18 | 
 19 | def import_aedat_headers(info):
 20 |     # Start from the beginning of the file (should not be necessary)
 21 |     """
 22 | 
 23 |     Parameters
 24 |     ----------
 25 |     info :
 26 | 
 27 |     Returns
 28 |     -------
 29 | 
 30 |     """
 31 |     info['fileHandle'].seek(0)
 32 | 
 33 |     # From version 3.1 there is an unambiguous division between header and
 34 |     # data: A line like this: '#!END-HEADER\r\n'
 35 |     # However, for all older files there's no guarantee that the first
 36 |     # character in the data would not be '#'. We ignore this - we look in the
 37 |     # next unread position and if it is not # we exit.
 38 | 
 39 |     info['xml'] = {}
 40 | 
 41 |     # Assume the format version is 1 unless a header of the version number is
 42 |     # found
 43 |     info['formatVersion'] = 1
 44 | 
 45 |     # Read the first character
 46 |     is_comment = '#' in str(info['fileHandle'].read(1))
 47 |     while is_comment:
 48 | 
 49 |         # Read the rest of the line
 50 |         line = info['fileHandle'].readline().decode('utf-8')
 51 |         # File format
 52 |         if line[: 8] == '!AER-DAT':
 53 |             info['formatVersion'] = int(line[8: -4])
 54 | 
 55 |         # Pick out the source
 56 |         # Version 2.0 encodes it like this:
 57 |         if line[: 9] == ' AEChip: ':
 58 |             # Ignore everything the class path and only use what follows the
 59 |             # final dot
 60 |             start_prefix = line.rfind('.')
 61 |             info['sourceFromFile'] = import_aedat_basic_source_name(
 62 |                 line[start_prefix + 1:])
 63 |         # Version 3.0 encodes it like this
 64 |         # The following ignores any trace of previous sources
 65 |         # (prefixed with a minus sign)
 66 |         if line[: 8] == ' Source ':
 67 |             start_prefix = line.find(':')  # There should be only one colon
 68 |             if 'sourceFromFile' in info:
 69 |                 pass
 70 |                 # One source has already been added; convert to a cell array if
 71 |                 # it has not already been done
 72 | 
 73 |                 # NOT HANDLED YET:            
 74 | 
 75 |                 # if ~iscell(info.sourceFromFile)
 76 |                 #    info.sourceFromFile = {info.sourceFromFile};
 77 |                 # info.sourceFromFile = [info.sourceFromFile line[start_prefix
 78 |                 #  + 2 : ];
 79 |             else:
 80 |                 info['sourceFromFile'] = line[start_prefix + 2:]
 81 | 
 82 |         # Pick out date and time of recording
 83 | 
 84 |         # Version 2.0 encodes it like this:
 85 |         # # created Thu Dec 03 14:47:00 CET 2015
 86 |         if line[: 9] == ' created ':
 87 |             info['dateTime'] = line[9:]
 88 | 
 89 |         # Version 3.0 encodes it like this:
 90 |         # # Start-Time: #Y-#m-#d #H:#M:#S (TZ#z)\r\n
 91 |         if line[: 13] == ' Start-Time: ':
 92 |             info['dateTime'] = line[13:]
 93 | 
 94 |         """# Parse xml, adding it to output as a cell array, in a field
 95 |         called 'xml'. # This is done by maintaining a cell array which is
 96 |         inside out as it is # constructed - as a level of the hierarchy is
 97 |         descended, everything is # pushed down into the first position of a
 98 |         cell array, and as the # hierarchy is ascended, the first node is
 99 |         popped back up and the nodes # that have been added to the right are
100 |         pushed down inside it.
101 |         
102 |         # If <node> then descend hierarchy - do this by taking the existing
103 |         # cell array and putting it into another cell array
104 |         if strncmp(line, '<node', 5)
105 |             nameOfNode = line(length('<node name="') + 1 : end - length('">'));
106 |             info.xml = {info.xml nameOfNode};
107 | 
108 |         # </node> - ascend hierarchy - take everything to the right of the
109 |         # initial cell array and put it inside the inital cell array
110 |         elseif strncmp(line, '</node>', 7)
111 |             parent = info.xml{1};
112 |             child = info.xml(2:end);
113 |             info.xml = [parent {child}];
114 | 
115 |           # <entry> - Add a field to the struct
116 |             elseif strncmp(line, '<entry ', 7)
117 |             # Find the division between key and value
118 |             endOfKey = strfind(line, '" value="');
119 |             key = line(length('<entry key="') + 1 : endOfKey - 1);
120 |             value = line(endOfKey + length('" value="') : end - length('"/>'));
121 |         info.xml{end + 1} = {key value};
122 |         end
123 |         # Gets the next line, including line ending chars
124 |          line = native2unicode(fgets(info.fileHandle)); 
125 |         """
126 |         # Read ahead the first character of the next line to complete the
127 |         # while loop
128 |         is_comment = '#' in str(info['fileHandle'].read(1))
129 | 
130 |     # We have read ahead one byte looking for '#', and not found it.
131 |     # Now wind back one to be in the right place to start reading
132 |     info['fileHandle'].seek(-1, 1)
133 |     info['beginningOfDataPointer'] = info['fileHandle'].tell()
134 | 
135 |     """
136 |     # If a device is specified in input, does it match the derived source?
137 |     if isfield(info, 'source')
138 |         info.source = importAedat_basicSourceName(info.source);
139 |         if isfield(info, 'sourceFromFile') && ~strcmp(info.source,
140 |          info.sourceFromFile)
141 |             fprintf('The source given as input, "#s", doesn''t match the source
142 |             declared in the file, "#s"; assuming the source given as input.\n',
143 |              inputSource, info.Source);
144 |         end
145 |     elseif ~isfield(info, 'sourceFromFile')
146 |     # If no source was detected, assume it was from a DVS128	
147 |     info.source = 'Dvs128';
148 |     else
149 |         info.source = info.sourceFromFile;
150 |     end
151 |     if isfield(info, 'sourceFromFile') 
152 |         # Clean up
153 |         rmfield(info, 'sourceFromFile');
154 |     end
155 |         
156 |     """
157 | 
158 |     return info
159 | 


--------------------------------------------------------------------------------
/snntoolbox/datasets/aedat/__init__.py:
--------------------------------------------------------------------------------
1 | """
2 | Init
3 | """
4 | 


--------------------------------------------------------------------------------
/snntoolbox/parsing/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/snntoolbox/parsing/__init__.py


--------------------------------------------------------------------------------
/snntoolbox/parsing/model_libs/__init__.py:
--------------------------------------------------------------------------------
1 | # coding=utf-8
2 | 
3 | """Init"""
4 | 


--------------------------------------------------------------------------------
/snntoolbox/parsing/model_libs/pytorch_input_lib.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """PyTorch model parser.
  3 | 
  4 | @author: rbodo
  5 | """
  6 | 
  7 | import os
  8 | import numpy as np
  9 | 
 10 | import torch
 11 | import onnx
 12 | import onnxruntime
 13 | from tensorflow.keras import backend, models, metrics
 14 | 
 15 | from snntoolbox.parsing.model_libs import keras_input_lib
 16 | from snntoolbox.utils.utils import import_script
 17 | 
 18 | 
 19 | def to_numpy(tensor):
 20 |     return tensor.detach().cpu().numpy() if tensor.requires_grad \
 21 |         else tensor.cpu().numpy()
 22 | 
 23 | 
 24 | class ModelParser(keras_input_lib.ModelParser):
 25 | 
 26 |     def try_insert_flatten(self, layer, idx, name_map):
 27 |         return False
 28 |         
 29 | 
 30 | def load(path, filename):
 31 |     """Load network from file.
 32 | 
 33 |     Parameters
 34 |     ----------
 35 | 
 36 |     path: str
 37 |         Path to directory where to load model from.
 38 | 
 39 |     filename: str
 40 |         Name of file to load model from.
 41 | 
 42 |     Returns
 43 |     -------
 44 | 
 45 |     : dict[str, Union[keras.models.Sequential, function]]
 46 |         A dictionary of objects that constitute the input model. It must
 47 |         contain the following two keys:
 48 | 
 49 |         - 'model': keras.models.Sequential
 50 |             Keras model instance of the network.
 51 |         - 'val_fn': function
 52 |             Function that allows evaluating the original model.
 53 |     """
 54 | 
 55 |     filepath = str(os.path.join(path, filename))
 56 | 
 57 |     # Load the Pytorch model.
 58 |     mod = import_script(path, filename)
 59 |     kwargs = mod.kwargs if hasattr(mod, 'kwargs') else {}
 60 |     model_pytorch = mod.Model(**kwargs)
 61 |     map_location = 'cpu' if not torch.cuda.is_available() else None
 62 |     for ext in ['.pth', '.pkl']:
 63 |         model_path = filepath + ext
 64 |         if os.path.exists(model_path):
 65 |             break
 66 |     assert model_path, "Pytorch state_dict not found at {}".format(model_path)
 67 |     try:
 68 |         model_pytorch.load_state_dict(
 69 |             torch.load(model_path, map_location=map_location))
 70 |     except RuntimeError as e:
 71 |         print("WARNING: Ignored mismatch when loading pytorch state_dict.")
 72 |         print(e)
 73 |         model_pytorch.load_state_dict(
 74 |             torch.load(model_path, map_location=map_location), strict=False)
 75 | 
 76 |     # Switch from train to eval mode to ensure Dropout / BatchNorm is handled
 77 |     # correctly.
 78 |     model_pytorch.eval()
 79 | 
 80 |     # Run on dummy input with correct shape to trace the Pytorch model.
 81 |     input_shape = [1] + list(model_pytorch.input_shape)
 82 |     input_numpy = np.random.random_sample(input_shape).astype(np.float32)
 83 |     input_torch = torch.from_numpy(input_numpy).float()
 84 |     output_torch = model_pytorch(input_torch)
 85 |     output_numpy = to_numpy(output_torch)
 86 | 
 87 |     # Export as onnx model, and then reload.
 88 |     input_names = ['input_0']
 89 |     output_names = ['output_{}'.format(i) for i in range(len(output_torch))]
 90 |     dynamic_axes = {'input_0': {0: 'batch_size'}}
 91 |     dynamic_axes.update({name: {0: 'batch_size'} for name in output_names})
 92 |     torch.onnx.export(model_pytorch, input_torch, filepath + '.onnx',
 93 |                       input_names=input_names,
 94 |                       output_names=output_names,
 95 |                       dynamic_axes=dynamic_axes)
 96 |     model_onnx = onnx.load(filepath + '.onnx')
 97 |     # onnx.checker.check_model(model_onnx)  # Crashes with segmentation fault.
 98 | 
 99 |     # Compute ONNX Runtime output prediction.
100 |     ort_session = onnxruntime.InferenceSession(filepath + '.onnx')
101 |     input_onnx = {ort_session.get_inputs()[0].name: input_numpy}
102 |     output_onnx = ort_session.run(None, input_onnx)
103 | 
104 |     # Compare ONNX Runtime and PyTorch results.
105 |     err_msg = "Pytorch model could not be ported to ONNX. Output difference: "
106 |     np.testing.assert_allclose(output_numpy, output_onnx[0],
107 |                                rtol=1e-03, atol=1e-05, err_msg=err_msg)
108 |     print("Pytorch model was successfully ported to ONNX.")
109 | 
110 |     change_ordering = backend.image_data_format() == 'channels_last'
111 |     if change_ordering:
112 |         input_numpy = np.moveaxis(input_numpy, 1, -1)
113 |         output_numpy = np.moveaxis(output_numpy, 1, -1)
114 | 
115 |     # Import this here; import changes image_data_format to channels_first.
116 |     from onnx2keras import onnx_to_keras
117 |     # Port ONNX model to Keras.
118 |     model_keras = onnx_to_keras(model_onnx, input_names, [input_shape[1:]],
119 |                                 change_ordering=change_ordering, verbose=False)
120 |     if change_ordering:
121 |         backend.set_image_data_format('channels_last')
122 | 
123 |     # Save the keras model.
124 |     model_keras.compile('sgd', 'categorical_crossentropy',
125 |                         ['accuracy', metrics.top_k_categorical_accuracy])
126 |     models.save_model(model_keras, filepath + '.h5')
127 | 
128 |     # Compute Keras output and compare against ONNX.
129 |     output_keras = model_keras.predict(input_numpy)
130 |     err_msg = "ONNX model could not be ported to Keras. Output difference: "
131 |     np.testing.assert_allclose(output_numpy, output_keras,
132 |                                rtol=1e-03, atol=1e-05, err_msg=err_msg)
133 |     print("ONNX model was successfully ported to Keras.")
134 | 
135 |     return {'model': model_keras, 'val_fn': model_keras.evaluate}
136 | 
137 | 
138 | def evaluate(*args, **kwargs):
139 |     return keras_input_lib.evaluate(*args, **kwargs)
140 | 


--------------------------------------------------------------------------------
/snntoolbox/simulation/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/snntoolbox/simulation/__init__.py


--------------------------------------------------------------------------------
/snntoolbox/simulation/backends/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/snntoolbox/simulation/backends/__init__.py


--------------------------------------------------------------------------------
/snntoolbox/simulation/backends/inisim/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/snntoolbox/simulation/backends/inisim/__init__.py


--------------------------------------------------------------------------------
/snntoolbox/simulation/backends/megasim/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/snntoolbox/simulation/backends/megasim/__init__.py


--------------------------------------------------------------------------------
/snntoolbox/simulation/backends/megasim/megasim.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | """ MegaSim spiking neuron simulator.
 3 | 
 4 | A collection of helper functions used to get MegaSim's path and executable.
 5 | 
 6 | the configuration file will be stored at
 7 | $HOME/.snntoolbox/preferences/megasim_config.json
 8 | 
 9 | Assumes that have write access to the home folder.
10 | 
11 | @author: evan
12 | """
13 | 
14 | import os
15 | import sys
16 | import json
17 | 
18 | 
19 | def megasim_path():
20 |     """
21 | 
22 |     Returns
23 |     -------
24 | 
25 |     """
26 | 
27 |     # first check if the .snntoolbox folder exists
28 |     home_path = os.environ["HOME"]
29 |     snntoobox_path_root = home_path+"/.snntoolbox/"
30 |     snntoobox_preferences_path = snntoobox_path_root+"preferences/"
31 |     megasim_config_json_fname = "megasim_config.json"
32 |     if os.path.isdir(snntoobox_path_root):
33 |         # config folder found, check if the preferences folder is there
34 |         if os.path.isdir(snntoobox_preferences_path):
35 |             try:
36 |                 megasim_file_config = open(snntoobox_preferences_path +
37 |                                            megasim_config_json_fname, "r")
38 |                 megaconfig = json.load(megasim_file_config)
39 |                 megasim_path_is = megaconfig["MegaSim_path"]
40 |                 print("MegaSim folder is "+megasim_path_is)
41 |             except FileNotFoundError:
42 |                 # megasim config json file not found, ask the user for megasims
43 |                 # path and check if the executable is there
44 |                 print("MegaSim's config file not found.")
45 |                 new_path_is = input("Please enter the full path to megasim"
46 |                                     " executable: ")
47 |                 if new_path_is[-1] != "/":
48 |                     new_path_is = new_path_is+"/"
49 | 
50 |                 print("Checking if MegaSim executable exists at "+new_path_is)
51 |                 if not os.path.isfile(new_path_is+"megasim"):
52 |                     print("MegaSim executable not found in "+new_path_is)
53 |                     sys.exit(1)
54 |                 print("Creating the MegaSim config file")
55 |                 f = open(snntoobox_preferences_path+megasim_config_json_fname,
56 |                          "w")
57 |                 build_line = '{"MegaSim_path": "'+new_path_is+'"}'
58 |                 f.write(build_line)
59 |                 f.write("\n")
60 |                 f.close()
61 | 
62 |                 megasim_path_is = new_path_is
63 |         else:
64 |             print("snntoolbox preferences directory not found")
65 |             megasim_path_is = " "
66 | 
67 |     else:
68 |         print("snntoolbox config directory not found")
69 |         cur_dir = os.getcwd()
70 |         os.chdir(home_path)
71 |         os.makedirs(snntoobox_preferences_path)
72 |         print("MegaSim's config file not found.")
73 |         new_path_is = input("Please enter the full path to megasim executable:"
74 |                             " ")
75 |         if new_path_is[-1] != "/":
76 |             new_path_is = new_path_is + "/"
77 | 
78 |         print("Checking if MegaSim executable exists at " + new_path_is)
79 |         if not os.path.isfile(new_path_is + "megasim"):
80 |             print("MegaSim executable not found in " + new_path_is)
81 |             sys.exit(1)
82 |         print("Creating the MegaSim config file")
83 |         f = open(snntoobox_preferences_path + megasim_config_json_fname, "w")
84 |         build_line = '{"MegaSim_path": "' + new_path_is + '"}'
85 |         f.write(build_line)
86 |         f.write("\n")
87 |         f.close()
88 | 
89 |         # megasim_path_is = new_path_is
90 |         os.chdir(cur_dir)
91 |         megasim_path_is = " "
92 | 
93 |     return megasim_path_is
94 | 


--------------------------------------------------------------------------------
/snntoolbox/simulation/target_simulators/INI_temporal_pattern_target_sim.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """INI simulator with temporal pattern code.
  3 | 
  4 | @author: rbodo
  5 | """
  6 | 
  7 | import tensorflow as tf
  8 | import numpy as np
  9 | 
 10 | from snntoolbox.simulation.target_simulators.\
 11 |     INI_temporal_mean_rate_target_sim import SNN as SNN_
 12 | from snntoolbox.simulation.utils import get_layer_synaptic_operations, \
 13 |     remove_name_counter
 14 | 
 15 | 
 16 | class SNN(SNN_):
 17 |     """
 18 |     The compiled spiking neural network, using layers derived from
 19 |     Keras base classes (see
 20 |     `snntoolbox.simulation.backends.inisim.temporal_pattern`).
 21 | 
 22 |     Aims at simulating the network on a self-implemented Integrate-and-Fire
 23 |     simulator using a timestepped approach.
 24 | 
 25 |     Attributes
 26 |     ----------
 27 | 
 28 |     snn: keras.models.Model
 29 |         Keras model. This is the output format of the compiled spiking model
 30 |         because INI simulator runs networks of layers that are derived from
 31 |         Keras layer base classes.
 32 |     """
 33 | 
 34 |     def __init__(self, config, queue=None):
 35 | 
 36 |         SNN_.__init__(self, config, queue)
 37 | 
 38 |         self.num_bits = self.config.getint('conversion', 'num_bits')
 39 | 
 40 |     def compile(self):
 41 | 
 42 |         self.snn = tf.keras.models.Model(
 43 |             self._input_images,
 44 |             self._spiking_layers[self.parsed_model.layers[-1].name])
 45 |         self.snn.compile('sgd', 'categorical_crossentropy', ['accuracy'])
 46 | 
 47 |         # Tensorflow 2 lists all variables as weights, including our state
 48 |         # variables (membrane potential etc). So a simple
 49 |         # snn.set_weights(parsed_model.get_weights()) does not work any more.
 50 |         # Need to extract the actual weights here:
 51 |         parameter_map = {remove_name_counter(p.name): p for p in
 52 |                          self.parsed_model.weights}
 53 |         count = 0
 54 |         for p in self.snn.weights:
 55 |             name = remove_name_counter(p.name)
 56 |             if name in parameter_map:
 57 |                 p.assign(parameter_map[name])
 58 |                 count += 1
 59 |         assert count == len(parameter_map), "Not all weights have been " \
 60 |                                             "transferred from ANN to SNN."
 61 | 
 62 |         for layer in self.snn.layers:
 63 |             if hasattr(layer, 'bias'):
 64 |                 # Adjust biases to time resolution of simulator.
 65 |                 layer.bias.assign(layer.bias / self._num_timesteps)
 66 | 
 67 |     # @tf.function
 68 |     def simulate(self, **kwargs):
 69 | 
 70 |         from snntoolbox.utils.utils import echo
 71 | 
 72 |         input_b_l = kwargs[str('x_b_l')] * self._dt
 73 | 
 74 |         output_b_l_t = np.zeros((self.batch_size, self.num_classes,
 75 |                                  self._num_timesteps))
 76 | 
 77 |         self._input_spikecount = 0
 78 |         self.set_time(self._dt)
 79 | 
 80 |         # Main step: Propagate input through network and record output spikes.
 81 |         out_spikes = self.snn.predict_on_batch(input_b_l)
 82 | 
 83 |         # Broadcast the raw output (softmax) across time axis.
 84 |         output_b_l_t[:, :, :] = np.expand_dims(out_spikes, -1)
 85 | 
 86 |         # Record neuron variables.
 87 |         i = 0
 88 |         for layer in self.snn.layers:
 89 |             # Excludes Input, Flatten, Concatenate, etc:
 90 |             if hasattr(layer, 'spikerates') and layer.spikerates is not None:
 91 |                 spikerates_b_l = layer.spikerates.numpy()
 92 |                 spiketrains_b_l_t = to_binary_numpy(spikerates_b_l,
 93 |                                                     self.num_bits)
 94 |                 self.set_spikerates(spikerates_b_l, i)
 95 |                 self.set_spiketrains(spiketrains_b_l_t, i)
 96 |                 if self.synaptic_operations_b_t is not None:
 97 |                     self.set_synaptic_operations(spiketrains_b_l_t, i)
 98 |                 if self.neuron_operations_b_t is not None:
 99 |                     self.set_neuron_operations(i)
100 |                 i += 1
101 |         if 'input_b_l_t' in self._log_keys:
102 |             self.input_b_l_t[Ellipsis, 0] = input_b_l
103 |         if self.neuron_operations_b_t is not None:
104 |             self.neuron_operations_b_t[:, 0] += self.fanin[1] * \
105 |                 self.num_neurons[1] * np.ones(self.batch_size) * 2
106 | 
107 |         print("Current accuracy of batch:")
108 |         if self.config.getint('output', 'verbose') > 0:
109 |             guesses_b = np.argmax(np.sum(output_b_l_t, 2), 1)
110 |             echo('{:.2%}_'.format(np.mean(kwargs[str('truth_b')] ==
111 |                                           guesses_b)))
112 | 
113 |         return np.cumsum(output_b_l_t, 2)
114 | 
115 |     def load(self, path, filename):
116 |         SNN_.load(self, path, filename)
117 | 
118 |     def set_spiketrains(self, spiketrains_b_l_t, i):
119 |         if self.spiketrains_n_b_l_t is not None:
120 |             self.spiketrains_n_b_l_t[i][0][:] = spiketrains_b_l_t
121 | 
122 |     def set_spikerates(self, spikerates_b_l, i):
123 |         if self.spikerates_n_b_l is not None:
124 |             self.spikerates_n_b_l[i][0][:] = spikerates_b_l
125 | 
126 |     def set_neuron_operations(self, i):
127 |         self.neuron_operations_b_t += self.num_neurons_with_bias[i + 1]
128 | 
129 |     def set_synaptic_operations(self, spiketrains_b_l_t, i):
130 |         for t in range(self.synaptic_operations_b_t.shape[-1]):
131 |             ops = get_layer_synaptic_operations(spiketrains_b_l_t[Ellipsis, t],
132 |                                                 self.fanout[i + 1])
133 |             self.synaptic_operations_b_t[:, t] += 2 * ops
134 | 
135 | 
136 | def to_binary_numpy(x, num_bits):
137 |     """Transform an array of floats into binary representation.
138 | 
139 |     Parameters
140 |     ----------
141 | 
142 |     x: ndarray
143 |         Input array containing float values. The first dimension has to be of
144 |         length 1.
145 |     num_bits: int
146 |         The fixed point precision to be used when converting to binary.
147 | 
148 |     Returns
149 |     -------
150 | 
151 |     y: ndarray
152 |         Output array with same shape as ``x`` except that an axis is added to
153 |         the last dimension with size ``num_bits``. The binary representation of
154 |         each value in ``x`` is distributed across the last dimension of ``y``.
155 |     """
156 | 
157 |     n = 2 ** num_bits - 1
158 |     a = np.round(x * n) / n
159 | 
160 |     y = np.zeros(list(x.shape) + [num_bits])
161 |     for i in range(num_bits):
162 |         p = 2 ** -(i + 1)
163 |         b = np.greater(a, p) * p
164 |         y[Ellipsis, i] = b
165 |         a -= b
166 | 
167 |     return y
168 | 


--------------------------------------------------------------------------------
/snntoolbox/simulation/target_simulators/INI_ttfs_corrective_target_sim.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | """INI simulator with time-to-first-spike code and corrective spikes.
 3 | 
 4 | @author: rbodo
 5 | """
 6 | 
 7 | # noinspection PyUnresolvedReferences
 8 | from snntoolbox.simulation.target_simulators.\
 9 |     INI_temporal_mean_rate_target_sim import SNN
10 | 


--------------------------------------------------------------------------------
/snntoolbox/simulation/target_simulators/INI_ttfs_dyn_thresh_target_sim.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """INI simulator with time-to-first-spike code and a dynamic threshold.
  3 | 
  4 | @author: rbodo
  5 | """
  6 | 
  7 | import sys
  8 | from tensorflow import keras
  9 | import numpy as np
 10 | 
 11 | from snntoolbox.simulation.target_simulators.\
 12 |     INI_temporal_mean_rate_target_sim import SNN as SNN_
 13 | 
 14 | remove_classifier = False
 15 | 
 16 | 
 17 | class SNN(SNN_):
 18 |     """
 19 |     The compiled spiking neural network, using layers derived from
 20 |     Keras base classes (see
 21 |     `snntoolbox.simulation.backends.inisim.ttfs_dyn_thresh`).
 22 | 
 23 |     Aims at simulating the network on a self-implemented Integrate-and-Fire
 24 |     simulator using a timestepped approach.
 25 |     """
 26 | 
 27 |     def __init__(self, config, queue=None):
 28 | 
 29 |         SNN_.__init__(self, config, queue)
 30 | 
 31 |     def simulate(self, **kwargs):
 32 | 
 33 |         from snntoolbox.utils.utils import echo
 34 |         from snntoolbox.simulation.utils import get_layer_synaptic_operations
 35 | 
 36 |         input_b_l = kwargs[str('x_b_l')] * self._dt
 37 | 
 38 |         output_b_l_t = np.zeros((self.batch_size, self.num_classes,
 39 |                                  self._num_timesteps))
 40 | 
 41 |         print("Current accuracy of batch:")
 42 | 
 43 |         # Loop through simulation time.
 44 |         self.avg_rate = 0
 45 |         self._input_spikecount = 0
 46 | 
 47 |         add_threshold_ops = False  # Todo: Add option in config file.
 48 |         spike_flags_b_l = None
 49 |         if add_threshold_ops:
 50 |             prospective_spikes = [
 51 |                 np.zeros(l.output_shape)[:self.batch_size] for l in
 52 |                 self.snn.layers if hasattr(l, 'spiketrain')
 53 |                 and l.spiketrain is not None]
 54 |         else:
 55 |             prospective_spikes = []
 56 |         for sim_step_int in range(self._num_timesteps):
 57 |             sim_step = (sim_step_int + 1) * self._dt
 58 |             self.set_time(sim_step)
 59 | 
 60 |             # Generate new input in case it changes with each simulation step.
 61 |             if self._poisson_input:
 62 |                 input_b_l = self.get_poisson_frame_batch(kwargs[str('x_b_l')])
 63 |             elif self._is_aedat_input:
 64 |                 input_b_l = kwargs[str('dvs_gen')].next_eventframe_batch()
 65 | 
 66 |             new_input = np.concatenate([input_b_l, np.zeros_like(input_b_l)])
 67 |             # Main step: Propagate input through network and record output
 68 |             # spikes.
 69 |             out_spikes = self.snn.predict_on_batch(new_input)[:self.batch_size]
 70 | 
 71 |             # Add current spikes to previous spikes.
 72 |             if remove_classifier:  # Need to flatten output.
 73 |                 output_b_l_t[:, :, sim_step_int] = np.argmax(np.reshape(
 74 |                     out_spikes > 0, (out_spikes.shape[0], -1)), 1)
 75 |             else:
 76 |                 output_b_l_t[:, :, sim_step_int] = out_spikes > 0
 77 | 
 78 |             # Record neuron variables.
 79 |             i = j = 0
 80 |             for layer in self.snn.layers:
 81 |                 # Excludes Input, Flatten, Concatenate, etc:
 82 |                 if hasattr(layer, 'spiketrain') \
 83 |                         and layer.spiketrain is not None:
 84 |                     tmp = keras.backend.get_value(layer.spiketrain)
 85 |                     spiketrains_b_l = tmp[:self.batch_size]
 86 |                     if add_threshold_ops:
 87 |                         spike_flags_b_l = np.abs(tmp[self.batch_size:] -
 88 |                                                  prospective_spikes[i])
 89 |                         prospective_spikes[i] = tmp[self.batch_size:]
 90 |                     self.avg_rate += np.count_nonzero(spiketrains_b_l)
 91 |                     if self.spiketrains_n_b_l_t is not None:
 92 |                         self.spiketrains_n_b_l_t[i][0][
 93 |                             Ellipsis, sim_step_int] = spiketrains_b_l
 94 |                     if self.synaptic_operations_b_t is not None:
 95 |                         self.synaptic_operations_b_t[:, sim_step_int] += \
 96 |                             get_layer_synaptic_operations(spiketrains_b_l,
 97 |                                                           self.fanout[i + 1])
 98 |                         if add_threshold_ops:
 99 |                             self.synaptic_operations_b_t[:, sim_step_int] += \
100 |                                 get_layer_synaptic_operations(
101 |                                     spike_flags_b_l, self.fanout[i + 1])
102 |                     if self.neuron_operations_b_t is not None:
103 |                         self.neuron_operations_b_t[:, sim_step_int] += \
104 |                             self.num_neurons_with_bias[i + 1]
105 |                     i += 1
106 |                 if hasattr(layer, 'mem') and self.mem_n_b_l_t is not None:
107 |                     self.mem_n_b_l_t[j][0][Ellipsis, sim_step_int] = \
108 |                         keras.backend.get_value(layer.mem)[self.batch_size:]
109 |                     j += 1
110 | 
111 |             if 'input_b_l_t' in self._log_keys:
112 |                 self.input_b_l_t[Ellipsis, sim_step_int] = input_b_l
113 |             if self._poisson_input or self._is_aedat_input:
114 |                 if self.synaptic_operations_b_t is not None:
115 |                     self.synaptic_operations_b_t[:, sim_step_int] += \
116 |                         get_layer_synaptic_operations(input_b_l,
117 |                                                       self.fanout[0])
118 |             else:
119 |                 if self.neuron_operations_b_t is not None:
120 |                     if sim_step_int == 0:
121 |                         self.neuron_operations_b_t[:, 0] += self.fanin[1] * \
122 |                             self.num_neurons[1] * np.ones(self.batch_size) * 2
123 | 
124 |             spike_sums_b_l = np.sum(output_b_l_t, 2)
125 |             undecided_b = np.sum(spike_sums_b_l, 1) == 0
126 |             guesses_b = np.argmax(spike_sums_b_l, 1)
127 |             none_class_b = -1 * np.ones(self.batch_size)
128 |             clean_guesses_b = np.where(undecided_b, none_class_b, guesses_b)
129 |             current_acc = np.mean(kwargs[str('truth_b')] == clean_guesses_b)
130 |             if self.config.getint('output', 'verbose') > 0:
131 |                 if sim_step % 1 == 0:
132 |                     echo('{:.2%}_'.format(current_acc))
133 |             else:
134 |                 sys.stdout.write('\r{:>7.2%}'.format(current_acc))
135 |                 sys.stdout.flush()
136 | 
137 |             if self.config.getboolean('conversion', 'softmax_to_relu') and \
138 |                     all(np.count_nonzero(output_b_l_t, (1, 2)) >= self.top_k):
139 |                 print("Finished early.")
140 |                 break
141 | 
142 |         self.avg_rate /= self.batch_size * np.sum(self.num_neurons) * \
143 |             self._num_timesteps
144 | 
145 |         if self.spiketrains_n_b_l_t is None:
146 |             print("Average spike rate: {} spikes per simulation time step."
147 |                   "".format(self.avg_rate))
148 | 
149 |         return np.cumsum(output_b_l_t, 2)
150 | 
151 |     def load(self, path, filename):
152 |         SNN_.load(self, path, filename)
153 | 


--------------------------------------------------------------------------------
/snntoolbox/simulation/target_simulators/INI_ttfs_target_sim.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """INI simulator with time-to-first-spike code.
  3 | 
  4 | @author: rbodo
  5 | """
  6 | 
  7 | import sys
  8 | from tensorflow import keras
  9 | import numpy as np
 10 | 
 11 | from snntoolbox.simulation.target_simulators.\
 12 |     INI_temporal_mean_rate_target_sim import SNN as SNN_
 13 | 
 14 | remove_classifier = False
 15 | 
 16 | 
 17 | class SNN(SNN_):
 18 |     """
 19 |     The compiled spiking neural network, using layers derived from
 20 |     Keras base classes (see `snntoolbox.simulation.backends.inisim.ttfs`).
 21 | 
 22 |     Aims at simulating the network on a self-implemented Integrate-and-Fire
 23 |     simulator using a timestepped approach.
 24 |     """
 25 | 
 26 |     def __init__(self, config, queue=None):
 27 | 
 28 |         SNN_.__init__(self, config, queue)
 29 | 
 30 |     def simulate(self, **kwargs):
 31 | 
 32 |         from snntoolbox.utils.utils import echo
 33 |         from snntoolbox.simulation.utils import get_layer_synaptic_operations
 34 | 
 35 |         input_b_l = kwargs[str('x_b_l')] * self._dt
 36 | 
 37 |         output_b_l_t = np.zeros((self.batch_size, self.num_classes,
 38 |                                  self._num_timesteps))
 39 | 
 40 |         print("Current accuracy of batch:")
 41 | 
 42 |         # Loop through simulation time.
 43 |         self.avg_rate = 0
 44 |         self._input_spikecount = 0
 45 |         for sim_step_int in range(self._num_timesteps):
 46 |             sim_step = (sim_step_int + 1) * self._dt
 47 |             self.set_time(sim_step)
 48 | 
 49 |             # Generate new input in case it changes with each simulation step.
 50 |             if self._poisson_input:
 51 |                 input_b_l = self.get_poisson_frame_batch(kwargs[str('x_b_l')])
 52 |             elif self._is_aedat_input:
 53 |                 input_b_l = kwargs[str('dvs_gen')].next_eventframe_batch()
 54 | 
 55 |             # Main step: Propagate input through network and record output
 56 |             # spikes.
 57 |             out_spikes = self.snn.predict_on_batch(input_b_l)
 58 | 
 59 |             # Add current spikes to previous spikes.
 60 |             if remove_classifier:  # Need to flatten output.
 61 |                 output_b_l_t[:, :, sim_step_int] = np.argmax(np.reshape(
 62 |                     out_spikes > 0, (out_spikes.shape[0], -1)), 1)
 63 |             else:
 64 |                 output_b_l_t[:, :, sim_step_int] = out_spikes > 0
 65 | 
 66 |             # Record neuron variables.
 67 |             i = j = 0
 68 |             for layer in self.snn.layers:
 69 |                 # Excludes Input, Flatten, Concatenate, etc:
 70 |                 if hasattr(layer, 'spiketrain') \
 71 |                         and layer.spiketrain is not None:
 72 |                     spiketrains_b_l = keras.backend.get_value(layer.spiketrain)
 73 |                     self.avg_rate += np.count_nonzero(spiketrains_b_l)
 74 |                     if self.spiketrains_n_b_l_t is not None:
 75 |                         self.spiketrains_n_b_l_t[i][0][
 76 |                             Ellipsis, sim_step_int] = spiketrains_b_l
 77 |                     if self.synaptic_operations_b_t is not None:
 78 |                         self.synaptic_operations_b_t[:, sim_step_int] += \
 79 |                             get_layer_synaptic_operations(spiketrains_b_l,
 80 |                                                           self.fanout[i + 1])
 81 |                     if self.neuron_operations_b_t is not None:
 82 |                         self.neuron_operations_b_t[:, sim_step_int] += \
 83 |                             self.num_neurons_with_bias[i + 1]
 84 |                     i += 1
 85 |                 if hasattr(layer, 'mem') and self.mem_n_b_l_t is not None:
 86 |                     self.mem_n_b_l_t[j][0][Ellipsis, sim_step_int] = \
 87 |                         keras.backend.get_value(layer.mem)
 88 |                     j += 1
 89 | 
 90 |             if 'input_b_l_t' in self._log_keys:
 91 |                 self.input_b_l_t[Ellipsis, sim_step_int] = input_b_l
 92 |             if self._poisson_input or self._is_aedat_input:
 93 |                 if self.synaptic_operations_b_t is not None:
 94 |                     self.synaptic_operations_b_t[:, sim_step_int] += \
 95 |                         get_layer_synaptic_operations(input_b_l,
 96 |                                                       self.fanout[0])
 97 |             else:
 98 |                 if self.neuron_operations_b_t is not None:
 99 |                     if sim_step_int == 0:
100 |                         self.neuron_operations_b_t[:, 0] += self.fanin[1] * \
101 |                             self.num_neurons[1] * np.ones(self.batch_size) * 2
102 | 
103 |             spike_sums_b_l = np.sum(output_b_l_t, 2)
104 |             undecided_b = np.sum(spike_sums_b_l, 1) == 0
105 |             guesses_b = np.argmax(spike_sums_b_l, 1)
106 |             none_class_b = -1 * np.ones(self.batch_size)
107 |             clean_guesses_b = np.where(undecided_b, none_class_b, guesses_b)
108 |             current_acc = np.mean(kwargs[str('truth_b')] == clean_guesses_b)
109 |             if self.config.getint('output', 'verbose') > 0:
110 |                 if sim_step % 1 == 0:
111 |                     echo('{:.2%}_'.format(current_acc))
112 |             else:
113 |                 sys.stdout.write('\r{:>7.2%}'.format(current_acc))
114 |                 sys.stdout.flush()
115 | 
116 |             if self.config.getboolean('conversion', 'softmax_to_relu') and \
117 |                     all(np.count_nonzero(output_b_l_t, (1, 2)) >= self.top_k):
118 |                 print("Finished early.")
119 |                 break
120 | 
121 |         self.avg_rate /= self.batch_size * np.sum(self.num_neurons) * \
122 |             self._num_timesteps
123 | 
124 |         if self.spiketrains_n_b_l_t is None:
125 |             print("Average spike rate: {} spikes per simulation time step."
126 |                   "".format(self.avg_rate))
127 | 
128 |         return np.cumsum(output_b_l_t, 2)
129 | 
130 |     def load(self, path, filename):
131 |         SNN_.load(self, path, filename)
132 | 


--------------------------------------------------------------------------------
/snntoolbox/simulation/target_simulators/__init__.py:
--------------------------------------------------------------------------------
1 | # coding=utf-8
2 | 
3 | """Init"""
4 | 


--------------------------------------------------------------------------------
/snntoolbox/simulation/target_simulators/brian_target_sim.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | """Building and simulating spiking neural networks using Brian.
 3 | 
 4 | All the work is done in pyNN, so we simply redirect :py:mod:`brian_target_sim`
 5 | to :py:mod:`pyNN_target_sim` here.
 6 | 
 7 | @author: rbodo
 8 | """
 9 | 
10 | # noinspection PyUnresolvedReferences
11 | from snntoolbox.simulation.target_simulators.pyNN_target_sim import SNN
12 | 


--------------------------------------------------------------------------------
/snntoolbox/simulation/target_simulators/loihi_target_sim.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | """
 3 | Building and running spiking neural networks using Intel's Loihi platform.
 4 | 
 5 | Currently, this code is part of the nxsdk, so we redirect there.
 6 | @author: rbodo
 7 | """
 8 | 
 9 | # noinspection PyUnresolvedReferences
10 | from nxsdk_modules_ncl.snntoolbox.nx_backend import SNN
11 | 


--------------------------------------------------------------------------------
/snntoolbox/simulation/target_simulators/nest_target_sim.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | """Building and simulating spiking neural networks using Nest.
 3 | 
 4 | All the work is done in pyNN, so we simply redirect :py:mod:`nest_target_sim`
 5 | to :py:mod:`pyNN_target_sim` here.
 6 | 
 7 | @author: rbodo
 8 | """
 9 | 
10 | # noinspection PyUnresolvedReferences
11 | from snntoolbox.simulation.target_simulators.pyNN_target_sim import SNN
12 | 


--------------------------------------------------------------------------------
/snntoolbox/simulation/target_simulators/neuron_target_sim.py:
--------------------------------------------------------------------------------
 1 | # coding=utf-8
 2 | """Building and simulating spiking neural networks using Neuron.
 3 | 
 4 | All the work is done in pyNN, so we simply redirect :py:mod:`neuron_target_sim`
 5 | to :py:mod:`pyNN_target_sim` here.
 6 | 
 7 | @author: rbodo
 8 | """
 9 | 
10 | # noinspection PyUnresolvedReferences
11 | from snntoolbox.simulation.target_simulators.pyNN_target_sim import SNN
12 | 


--------------------------------------------------------------------------------
/snntoolbox/utils/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/snntoolbox/utils/__init__.py


--------------------------------------------------------------------------------
/tests/README.md:
--------------------------------------------------------------------------------
1 | # SNN toolbox testsuit
2 | 
3 | Code to test conversion and simulation of neural networks.
4 | 


--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/tests/__init__.py


--------------------------------------------------------------------------------
/tests/conversion/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/tests/conversion/__init__.py


--------------------------------------------------------------------------------
/tests/core/test_config.py:
--------------------------------------------------------------------------------
 1 | # coding=utf-8
 2 | 
 3 | """Test configuration of toolbox."""
 4 | 
 5 | import importlib
 6 | 
 7 | import os
 8 | import pytest
 9 | 
10 | from snntoolbox.bin.utils import update_setup
11 | from snntoolbox.utils.utils import import_configparser
12 | 
13 | with open(os.path.abspath(os.path.join(os.path.dirname(__file__),
14 |                                        '..', '..', 'requirements.txt'))) as f:
15 |     requirements = []
16 |     for s in f.readlines():
17 |         requirements.append(s.rstrip('\n').split('==')[0])
18 | 
19 | 
20 | @pytest.mark.parametrize('required_module', requirements)
21 | def test_imports_from_requirements(required_module):
22 |     assert importlib.import_module(required_module)
23 | 
24 | 
25 | # Todo: Add configuration that is expected to pass.
26 | _in_and_out = [
27 |     ({}, False),
28 |     ({'paths': {'path_wd': os.path.dirname(__file__),
29 |                 'dataset_path': os.path.dirname(__file__),
30 |                 'filename_ann': '98.96'}}, False)
31 |     ]
32 | 
33 | 
34 | @pytest.mark.parametrize('params, expect_pass', _in_and_out)
35 | def test_updating_settings(params, expect_pass, _path_wd):
36 |     configparser = import_configparser()
37 |     config = configparser.ConfigParser()
38 |     config.read_dict(params)
39 |     configpath = os.path.join(str(_path_wd), 'config')
40 |     with open(configpath, 'w') as file:
41 |         config.write(file)
42 |     if expect_pass:
43 |         assert update_setup(configpath)
44 |     else:
45 |         pytest.raises(AssertionError, update_setup, configpath)
46 | 


--------------------------------------------------------------------------------
/tests/core/test_gui.py:
--------------------------------------------------------------------------------
 1 | # coding=utf-8
 2 | 
 3 | """Test snntoolbox GUI."""
 4 | 
 5 | import shutil
 6 | import time
 7 | import pytest
 8 | 
 9 | 
10 | @pytest.mark.skip("Passes when all dependencies are installed properly.")
11 | def test_gui(_config):
12 |     from snntoolbox.bin.gui.gui import tk, SNNToolboxGUI
13 | 
14 |     root = tk.Tk()
15 |     app = SNNToolboxGUI(root, _config)
16 |     root.update_idletasks()
17 |     root.update()
18 |     time.sleep(0.1)
19 |     app.quit_toolbox()
20 |     shutil.rmtree(app.default_path_to_pref)
21 | 
22 |     assert True
23 | 


--------------------------------------------------------------------------------
/tests/core/test_io.py:
--------------------------------------------------------------------------------
 1 | # coding=utf-8
 2 | import os
 3 | 
 4 | import numpy as np
 5 | from tensorflow import keras
 6 | 
 7 | from snntoolbox.bin.utils import run_pipeline
 8 | from snntoolbox.datasets.utils import get_dataset
 9 | 
10 | 
11 | class TestGetDataset:
12 |     """Test obtaining the dataset from disk in correct format."""
13 | 
14 |     def test_get_dataset_from_npz(self, _config):
15 |         normset, testset = get_dataset(_config)
16 |         assert all([normset, testset])
17 | 
18 |     def test_get_dataset_from_png(self, _config):
19 |         try:
20 |             import matplotlib.pyplot as plt
21 |         except ImportError:
22 |             return
23 | 
24 |         datapath = _config.get('paths', 'dataset_path')
25 |         classpath = os.path.join(datapath, 'class_0')
26 |         os.mkdir(classpath)
27 |         data = np.random.random_sample((10, 10, 3))
28 |         plt.imsave(os.path.join(classpath, 'image_0.png'), data)
29 | 
30 |         _config.read_dict({
31 |              'input': {'dataset_format': 'png',
32 |                        'dataflow_kwargs': "{'target_size': (11, 12)}",
33 |                        'datagen_kwargs': "{'rescale': 0.003922,"
34 |                                          " 'featurewise_center': True,"
35 |                                          " 'featurewise_std_normalization':"
36 |                                          " True}"}})
37 | 
38 |         normset, testset = get_dataset(_config)
39 |         assert all([normset, testset])
40 | 
41 | 
42 | class TestModelIO:
43 |     """Test saving and loading various model instances along the pipeline."""
44 | 
45 |     def test_loading_parsed_model(self, _model_1, _config):
46 | 
47 |         model = _model_1
48 |         path_wd = _config.get('paths', 'path_wd')
49 |         model_name = _config.get('paths', 'filename_ann')
50 |         keras.models.save_model(model, os.path.join(path_wd,
51 |                                                     model_name + '.h5'))
52 | 
53 |         # Only perform parsing step.
54 |         updates = {'tools': {'evaluate_ann': False, 'normalize': False,
55 |                              'convert': False, 'simulate': False}}
56 | 
57 |         _config.read_dict(updates)
58 | 
59 |         run_pipeline(_config)
60 | 
61 |         path_parsed = os.path.join(path_wd, _config.get(
62 |             'paths', 'filename_parsed_model') + '.h5')
63 |         model_parsed = keras.models.load_model(path_parsed)
64 | 
65 |         x = np.random.random_sample((5,) + model.input_shape[1:])
66 |         y = model.predict(x)
67 |         y_parsed = model_parsed.predict(x)
68 | 
69 |         assert np.allclose(y, y_parsed)
70 | 


--------------------------------------------------------------------------------
/tests/datasets/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/tests/datasets/__init__.py


--------------------------------------------------------------------------------
/tests/parsing/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/tests/parsing/__init__.py


--------------------------------------------------------------------------------
/tests/parsing/models/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/tests/parsing/models/__init__.py


--------------------------------------------------------------------------------
/tests/parsing/models/pytorch.py:
--------------------------------------------------------------------------------
 1 | import torch
 2 | import torch.nn as nn
 3 | 
 4 | 
 5 | class Model(nn.Module):
 6 |     def __init__(self):
 7 |         super(Model, self).__init__()
 8 | 
 9 |         # The input_shape field is required by SNN toolbox.
10 |         self.input_shape = (1, 28, 28)
11 | 
12 |         layers_trunk = [
13 |             nn.Conv2d(1, 16, kernel_size=5, stride=2),
14 |             # BatchNorm doesn't work with Keras==2.3.1 because for some reason
15 |             # they put the batch-norm axis in a list.
16 |             # nn.BatchNorm2d(16),
17 |             nn.ReLU(),
18 |             nn.AvgPool2d(kernel_size=2, stride=2)]
19 |         layers_branch1 = [
20 |             nn.Conv2d(16, 32, kernel_size=3, padding=1),
21 |             nn.ReLU()]
22 |         layers_branch2 = [
23 |             nn.Conv2d(16, 8, kernel_size=1),
24 |             nn.ReLU()]
25 |         layers_head = [
26 |             nn.Conv2d(40, 8, kernel_size=1),
27 |             nn.ReLU()]
28 |         layers_classifier = [
29 |             nn.Dropout(1e-5),
30 |             nn.Linear(288, 10),
31 |             nn.Softmax(1)]
32 |         self.trunk = nn.Sequential(*layers_trunk)
33 |         self.branch1 = nn.Sequential(*layers_branch1)
34 |         self.branch2 = nn.Sequential(*layers_branch2)
35 |         self.head = nn.Sequential(*layers_head)
36 |         self.classifier = nn.Sequential(*layers_classifier)
37 | 
38 |     def forward(self, x):
39 |         x = self.trunk(x)
40 |         x1 = self.branch1(x)
41 |         x2 = self.branch2(x)
42 |         x = torch.cat([x1, x2], 1)
43 |         x = self.head(x)
44 |         x = x.view(-1, 288)  # Flatten
45 |         x = self.classifier(x)
46 |         return x
47 | 


--------------------------------------------------------------------------------
/tests/parsing/test_pytorch.py:
--------------------------------------------------------------------------------
  1 | from importlib import import_module
  2 | 
  3 | import inspect
  4 | import numpy as np
  5 | import os
  6 | import shutil
  7 | 
  8 | import pytest
  9 | from tensorflow.keras import backend
 10 | 
 11 | from snntoolbox.bin.utils import initialize_simulator, run_pipeline
 12 | from snntoolbox.datasets.utils import get_dataset
 13 | from tests.conftest import pytorch_skip_if_dependency_missing
 14 | from tests.core.test_models import get_correlations
 15 | 
 16 | 
 17 | DATA_FORMAT = backend.image_data_format()
 18 | 
 19 | 
 20 | def setup_module():
 21 |     """Setup any state specific to the execution of pytorch tests."""
 22 | 
 23 |     # Pytorch to Keras parser needs image_data_format == channel_first.
 24 |     backend.set_image_data_format('channels_first')
 25 | 
 26 | 
 27 | def teardown_module():
 28 |     """Teardown any state that was previously setup with setup_module."""
 29 | 
 30 |     # Reset to previous value.
 31 |     backend.set_image_data_format(DATA_FORMAT)
 32 | 
 33 | 
 34 | @pytorch_skip_if_dependency_missing
 35 | class TestPytorchParser:
 36 |     """Test parsing pytorch models."""
 37 | 
 38 |     @pytest.fixture(scope='function', autouse=True)
 39 |     def _setup(self, _config_first):
 40 |         self.config = _config_first
 41 | 
 42 |     def prepare_model(self, model):
 43 |         import torch
 44 | 
 45 |         path_wd = self.config.get('paths', 'path_wd')
 46 |         model_name = self.config.get('paths', 'filename_ann')
 47 |         torch.save(model.state_dict(), os.path.join(path_wd,
 48 |                                                     model_name + '.pkl'))
 49 |         # Need to copy model definition over to temp dir because only weights
 50 |         # were saved.
 51 |         from tests.parsing.models import pytorch
 52 |         source_path = inspect.getfile(pytorch)
 53 |         shutil.copyfile(source_path, os.path.join(path_wd, model_name + '.py'))
 54 | 
 55 |     def test_loading(self, _model_4_first):
 56 | 
 57 |         assert backend.image_data_format() == 'channels_first', \
 58 |             "Pytorch to Keras parser needs image_data_format == channel_first."
 59 | 
 60 |         self.prepare_model(_model_4_first)
 61 | 
 62 |         updates = {
 63 |             'tools': {'evaluate_ann': True,
 64 |                       'parse': False,
 65 |                       'normalize': False,
 66 |                       'convert': False,
 67 |                       'simulate': False},
 68 |             'input': {'model_lib': 'pytorch'},
 69 |             'simulation': {'num_to_test': 100,
 70 |                            'batch_size': 50}}
 71 | 
 72 |         self.config.read_dict(updates)
 73 | 
 74 |         initialize_simulator(self.config)
 75 | 
 76 |         normset, testset = get_dataset(self.config)
 77 | 
 78 |         model_lib = import_module('snntoolbox.parsing.model_libs.' +
 79 |                                   self.config.get('input', 'model_lib') +
 80 |                                   '_input_lib')
 81 |         input_model = model_lib.load(self.config.get('paths', 'path_wd'),
 82 |                                      self.config.get('paths', 'filename_ann'))
 83 | 
 84 |         # Evaluate input model.
 85 |         acc = model_lib.evaluate(
 86 |             input_model['val_fn'],
 87 |             self.config.getint('simulation', 'batch_size'),
 88 |             self.config.getint('simulation', 'num_to_test'),
 89 |             **testset)
 90 | 
 91 |         assert acc >= 0.8
 92 | 
 93 |     def test_parsing(self, _model_4_first):
 94 | 
 95 |         self.prepare_model(_model_4_first)
 96 | 
 97 |         updates = {
 98 |             'tools': {'evaluate_ann': True,
 99 |                       'parse': True,
100 |                       'normalize': False,
101 |                       'convert': False,
102 |                       'simulate': False},
103 |             'input': {'model_lib': 'pytorch'},
104 |             'simulation': {'num_to_test': 100,
105 |                            'batch_size': 50}
106 |         }
107 | 
108 |         self.config.read_dict(updates)
109 | 
110 |         initialize_simulator(self.config)
111 | 
112 |         acc = run_pipeline(self.config)
113 | 
114 |         assert acc[0] >= 0.8
115 | 
116 |     def test_normalizing(self, _model_4_first):
117 | 
118 |         self.prepare_model(_model_4_first)
119 | 
120 |         updates = {
121 |             'tools': {'evaluate_ann': True,
122 |                       'parse': True,
123 |                       'normalize': True,
124 |                       'convert': False,
125 |                       'simulate': False},
126 |             'input': {'model_lib': 'pytorch'},
127 |             'simulation': {'num_to_test': 100,
128 |                            'batch_size': 50}
129 |         }
130 | 
131 |         self.config.read_dict(updates)
132 | 
133 |         initialize_simulator(self.config)
134 | 
135 |         acc = run_pipeline(self.config)
136 | 
137 |         assert acc[0] >= 0.8
138 | 
139 |     def test_pipeline(self, _model_4_first):
140 | 
141 |         self.prepare_model(_model_4_first)
142 | 
143 |         updates = {
144 |             'tools': {'evaluate_ann': False},
145 |             'input': {'model_lib': 'pytorch'},
146 |             'simulation': {
147 |                 'duration': 100,
148 |                 'num_to_test': 100,
149 |                 'batch_size': 50},
150 |             'output': {
151 |                 'log_vars': {'activations_n_b_l', 'spiketrains_n_b_l_t'}}}
152 | 
153 |         self.config.read_dict(updates)
154 | 
155 |         initialize_simulator(self.config)
156 | 
157 |         acc = run_pipeline(self.config)
158 | 
159 |         assert acc[0] >= 0.8
160 | 
161 |         corr = get_correlations(self.config)
162 |         assert np.all(corr[:-1] > 0.97)
163 |         assert corr[-1] > 0.5
164 | 


--------------------------------------------------------------------------------
/tests/simulation/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NeuromorphicProcessorProject/snn_toolbox/0255f753efa32f69593ac6bc25a95d5b09f8f1cb/tests/simulation/__init__.py


--------------------------------------------------------------------------------
/tests/simulation/test_conv.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import numpy as np
 3 | import pytest
 4 | from tensorflow.keras import Input, Model, models, backend
 5 | from tensorflow.keras.layers import Conv1D, Flatten, Dense, Reshape, \
 6 |     BatchNormalization, ReLU
 7 | 
 8 | from snntoolbox.bin.utils import run_pipeline
 9 | from tests.core.test_models import get_correlations, get_ann_acc
10 | 
11 | DATA_FORMAT = backend.image_data_format()
12 | 
13 | 
14 | @pytest.fixture(scope='session')
15 | def _model_conv1D_1(_dataset):
16 |     return get_model_conv1D_1(_dataset)
17 | 
18 | 
19 | @pytest.fixture(scope='session')
20 | def _model_conv1D_1_last(_dataset_last):
21 |     backend.set_image_data_format('channels_last')
22 |     model = get_model_conv1D_1(_dataset_last)
23 |     backend.set_image_data_format(DATA_FORMAT)
24 |     return model
25 | 
26 | 
27 | def get_model_conv1D_1(dataset):
28 |     x_train, y_train, x_test, y_test = dataset
29 | 
30 |     axis = 1 if backend.image_data_format() == 'channels_first' else 2
31 |     input_shape = x_train.shape[1:]
32 |     input_shape_1d = (input_shape[0] * input_shape[1], input_shape[2])
33 |     input_layer = Input(input_shape)
34 |     layer = Reshape(input_shape_1d)(input_layer)
35 |     layer = Conv1D(8, 1)(layer)
36 |     layer = BatchNormalization(axis)(layer)
37 |     layer = ReLU()(layer)
38 |     layer = Conv1D(16, 3, strides=4, padding='causal')(layer)
39 |     layer = BatchNormalization(axis)(layer)
40 |     layer = ReLU()(layer)
41 |     layer = Conv1D(32, 2, padding='causal', dilation_rate=2)(layer)
42 |     layer = BatchNormalization(axis)(layer)
43 |     layer = ReLU()(layer)
44 |     layer = Flatten()(layer)
45 |     layer = Dense(10, activation='softmax', use_bias=False)(layer)
46 | 
47 |     model = Model(input_layer, layer)
48 | 
49 |     model.compile('adam', 'categorical_crossentropy', ['accuracy'])
50 | 
51 |     history = model.fit(x_train, y_train, batch_size=64, epochs=1, verbose=2,
52 |                         validation_data=(x_test, y_test))
53 | 
54 |     assert history.history['val_accuracy'][-1] > 0.8
55 | 
56 |     return model
57 | 
58 | 
59 | class TestConv1dINI:
60 |     """Test spiking conv1d layers in INIsim, using tensorflow backend."""
61 | 
62 |     def test_conv1d(self, _model_conv1D_1_last, _config_last):
63 |         """Test conv1d."""
64 |         config = _config_last
65 |         path_wd = config.get('paths', 'path_wd')
66 |         model_name = config.get('paths', 'filename_ann')
67 |         models.save_model(_model_conv1D_1_last,
68 |                           os.path.join(path_wd, model_name + '.h5'))
69 | 
70 |         updates = {
71 |             'tools': {'evaluate_ann': False, 'normalize': True},
72 |             'simulation': {
73 |                 'duration': 200,
74 |                 'num_to_test': 100,
75 |                 'batch_size': 50},
76 |             'output': {
77 |                 'log_vars': {'activations_n_b_l', 'spiketrains_n_b_l_t'},
78 |             }}
79 | 
80 |         config.read_dict(updates)
81 | 
82 |         acc = run_pipeline(config)
83 | 
84 |         acc_ann = get_ann_acc(config)
85 |         assert acc[0] >= 0.98 * acc_ann
86 | 
87 |         corr = get_correlations(config)
88 |         assert np.all(corr[:-1] > 0.97)
89 |         assert corr[-1] > 0.90
90 | 


--------------------------------------------------------------------------------
/tests/simulation/test_pooling.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import numpy as np
  3 | import pytest
  4 | from tensorflow.keras import Input, Model, models, backend
  5 | from tensorflow.keras.layers import MaxPooling2D, Flatten, Dense
  6 | 
  7 | from snntoolbox.bin.utils import run_pipeline
  8 | from tests.core.test_models import get_correlations, get_ann_acc
  9 | 
 10 | DATA_FORMAT = backend.image_data_format()
 11 | 
 12 | 
 13 | @pytest.fixture(scope='session')
 14 | def _model_maxpool2D_1(_dataset):
 15 |     return get_model_maxpool2D_1(_dataset)
 16 | 
 17 | 
 18 | @pytest.fixture(scope='session')
 19 | def _model_maxpool2D_1_first(_dataset_first):
 20 |     backend.set_image_data_format('channels_first')
 21 |     model = get_model_maxpool2D_1(_dataset_first)
 22 |     backend.set_image_data_format(DATA_FORMAT)
 23 |     return model
 24 | 
 25 | 
 26 | @pytest.fixture(scope='session')
 27 | def _model_maxpool2D_1_last(_dataset_last):
 28 |     backend.set_image_data_format('channels_last')
 29 |     model = get_model_maxpool2D_1(_dataset_last)
 30 |     backend.set_image_data_format(DATA_FORMAT)
 31 |     return model
 32 | 
 33 | 
 34 | def get_model_maxpool2D_1(dataset):
 35 |     """Patch size 2, stride 2."""
 36 | 
 37 |     x_train, y_train, x_test, y_test = dataset
 38 | 
 39 |     input_shape = x_train.shape[1:]
 40 |     input_layer = Input(input_shape)
 41 | 
 42 |     layer = MaxPooling2D()(input_layer)
 43 |     layer = Flatten()(layer)
 44 |     layer = Dense(10, activation='softmax', use_bias=False)(layer)
 45 | 
 46 |     model = Model(input_layer, layer)
 47 | 
 48 |     model.compile('adam', 'categorical_crossentropy', ['accuracy'])
 49 | 
 50 |     history = model.fit(x_train, y_train, batch_size=64, epochs=1, verbose=2,
 51 |                         validation_data=(x_test, y_test))
 52 | 
 53 |     assert history.history['val_accuracy'][-1] > 0.8
 54 | 
 55 |     return model
 56 | 
 57 | 
 58 | class TestMaxPoolingINI:
 59 |     """Test spiking max-pooling layers in INIsim, using tensorflow backend."""
 60 | 
 61 |     def test_maxpool_fallback(self, _model_maxpool2D_1, _config):
 62 |         """Test that maxpooling falls back on average pooling."""
 63 |         path_wd = _config.get('paths', 'path_wd')
 64 |         model_name = _config.get('paths', 'filename_ann')
 65 |         models.save_model(_model_maxpool2D_1,
 66 |                           os.path.join(path_wd, model_name + '.h5'))
 67 | 
 68 |         updates = {
 69 |             'tools': {'evaluate_ann': False, 'normalize': False},
 70 |             'conversion': {'max2avg_pool': True},
 71 |             'simulation': {
 72 |                 'duration': 100,
 73 |                 'num_to_test': 100,
 74 |                 'batch_size': 50},
 75 |             'output': {
 76 |                 'log_vars': {'activations_n_b_l', 'spiketrains_n_b_l_t'}}}
 77 | 
 78 |         _config.read_dict(updates)
 79 | 
 80 |         acc = run_pipeline(_config)
 81 | 
 82 |         assert acc[0] >= 0.8
 83 | 
 84 |         corr = get_correlations(_config)
 85 |         assert np.all(corr[:-1] > 0.99)
 86 |         assert corr[-1] > 0.90
 87 | 
 88 |     reason = "tf.ops.max_pool only works with NHWC data format"
 89 | 
 90 |     @pytest.mark.skip(reason)
 91 |     @pytest.mark.xfail(raises=ValueError, reason=reason)
 92 |     def test_maxpool_first(self, _model_maxpool2D_1_first, _config_first):
 93 |         """Test that maxpooling fails with data format channels_first."""
 94 |         config = _config_first
 95 |         path_wd = config.get('paths', 'path_wd')
 96 |         model_name = config.get('paths', 'filename_ann')
 97 |         models.save_model(_model_maxpool2D_1_first,
 98 |                           os.path.join(path_wd, model_name + '.h5'))
 99 | 
100 |         updates = {
101 |             'tools': {'evaluate_ann': False, 'normalize': False},
102 |             'simulation': {
103 |                 'duration': 100,
104 |                 'num_to_test': 100,
105 |                 'batch_size': 50},
106 |             'output': {
107 |                 'log_vars': {'activations_n_b_l', 'spiketrains_n_b_l_t'}}}
108 | 
109 |         config.read_dict(updates)
110 | 
111 |         run_pipeline(config)
112 | 
113 |     def test_maxpool(self, _model_maxpool2D_1_last, _config_last):
114 |         """Test maxpooling."""
115 |         config = _config_last
116 |         path_wd = config.get('paths', 'path_wd')
117 |         model_name = config.get('paths', 'filename_ann')
118 |         models.save_model(_model_maxpool2D_1_last,
119 |                           os.path.join(path_wd, model_name + '.h5'))
120 | 
121 |         updates = {
122 |             'tools': {'evaluate_ann': False, 'normalize': False},
123 |             'simulation': {
124 |                 'duration': 100,
125 |                 'num_to_test': 100,
126 |                 'batch_size': 50},
127 |             'output': {
128 |                 'log_vars': {'activations_n_b_l', 'spiketrains_n_b_l_t'}}}
129 | 
130 |         config.read_dict(updates)
131 | 
132 |         acc = run_pipeline(config)
133 | 
134 |         acc_ann = get_ann_acc(config)
135 |         assert acc[0] >= 0.9 * acc_ann
136 | 
137 |         corr = get_correlations(config)
138 |         assert np.all(corr[:-1] > 0.99)
139 |         assert corr[-1] > 0.90
140 | 


--------------------------------------------------------------------------------
/tox.ini:
--------------------------------------------------------------------------------
 1 | # Tox (http://tox.testrun.org/) is a tool for running tests
 2 | # in multiple virtualenvs. This configuration file will run the
 3 | # test suite on all supported python versions. To use it, "pip install tox"
 4 | # and then run "tox" from this directory.
 5 | 
 6 | [tox]
 7 | envlist =
 8 |     py38
 9 | 
10 | [testenv]
11 | commands = py.test
12 | deps = -rrequirements.txt
13 | 
14 | [testenv:docs]
15 | basepython = python
16 | changedir = docs
17 | deps = sphinx
18 | commands = sphinx-build -W -b html -d {envtmpdir}/doctrees .  {envtmpdir}/html
19 | 


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