Full Code of fzenke/spytorch for AI

main d363dbf93a04 cached
17 files
1.3 MB
871.5k tokens
5 symbols
1 requests
Download .txt
Showing preview only (1,364K chars total). Download the full file or copy to clipboard to get everything.
Repository: fzenke/spytorch
Branch: main
Commit: d363dbf93a04
Files: 17
Total size: 1.3 MB

Directory structure:
gitextract_9f1972op/

├── .gitignore
├── README.md
├── notebooks/
│   ├── .gitignore
│   ├── SpyTorchTutorial1.ipynb
│   ├── SpyTorchTutorial2.ipynb
│   ├── SpyTorchTutorial3.ipynb
│   ├── SpyTorchTutorial4.ipynb
│   ├── SpyTorchTutorial5.ipynb
│   ├── figures/
│   │   ├── .gitignore
│   │   ├── mlp_sketch/
│   │   │   ├── Makefile
│   │   │   └── mlp_sketch.tex
│   │   ├── snn_graph/
│   │   │   ├── Makefile
│   │   │   └── snn_graph.tex
│   │   └── surrgrad/
│   │       ├── Makefile
│   │       └── surrgrad.gnu
│   └── utils.py
└── requirements.txt

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitignore
================================================
# ---> Python
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class

# C extensions
*.so

# Distribution / packaging
.Python
env/
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
*.egg-info/
.installed.cfg
*.egg

# PyInstaller
#  Usually these files are written by a python script from a template
#  before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec

# Installer logs
pip-log.txt
pip-delete-this-directory.txt

# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*,cover

# Translations
*.mo
*.pot

# Django stuff:
*.log

# Sphinx documentation
docs/_build/

# PyBuilder
target/



================================================
FILE: README.md
================================================
# SpyTorch
A tutorial on surrogate gradient learning in spiking neural networks

Version: 0.4

[![DOI](https://zenodo.org/badge/170391179.svg)](https://zenodo.org/badge/latestdoi/170391179)

This repository contains tutorial files to get you started with the basic ideas
of surrogate gradient learning in spiking neural networks using PyTorch. 

You find a brief introductory video accompanying these notebooks here https://youtu.be/xPYiAjceAqU

Feedback and contributions are welcome.

For more information on surrogate gradient learning please refer to:
> Neftci, E.O., Mostafa, H., and Zenke, F. (2019). Surrogate Gradient Learning in Spiking Neural Networks: Bringing the Power of Gradient-based optimization to spiking neural networks. IEEE Signal Processing Magazine 36, 51–63.
> https://ieeexplore.ieee.org/document/8891809
> preprint: https://arxiv.org/abs/1901.09948


Also see https://github.com/surrogate-gradient-learning

## Copyright and license

Copyright 2019-2022 Friedemann Zenke, https://fzenke.net

This work is licensed under a Creative Commons Attribution 4.0 International License.
http://creativecommons.org/licenses/by/4.0/


================================================
FILE: notebooks/.gitignore
================================================
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class

# C extensions
*.so

# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST

# PyInstaller
#  Usually these files are written by a python script from a template
#  before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec

# Installer logs
pip-log.txt
pip-delete-this-directory.txt

# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
.pytest_cache/

# Translations
*.mo
*.pot

# Django stuff:
*.log
local_settings.py
db.sqlite3

# Flask stuff:
instance/
.webassets-cache

# Scrapy stuff:
.scrapy

# Sphinx documentation
docs/_build/

# PyBuilder
target/

# Jupyter Notebook
.ipynb_checkpoints

# IPython
profile_default/
ipython_config.py

# pyenv
.python-version

# celery beat schedule file
celerybeat-schedule

# SageMath parsed files
*.sage.py

# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/

# Spyder project settings
.spyderproject
.spyproject

# Rope project settings
.ropeproject

# mkdocs documentation
/site

# mypy
.mypy_cache/
.dmypy.json
dmypy.json

# Pyre type checker
.pyre/



================================================
FILE: notebooks/SpyTorchTutorial1.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial 1: Training a spiking neural network with surrogate gradients\n",
    "\n",
    "Friedemann Zenke (https://fzenke.net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> For more details on surrogate gradient learning, please see: \n",
    "> Neftci, E.O., Mostafa, H., and Zenke, F. (2019). Surrogate Gradient Learning in Spiking Neural Networks.\n",
    "> https://arxiv.org/abs/1901.09948"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction \n",
    "\n",
    "The last months have seen a surge of interest in training spiking neural networks to do meaningful computations. On the one hand, this surge was fueled by the limited accomplishment of more traditional, and often considered more biologically plausible, learning paradigms in creating functional neural networks that solve interesting computational problems. This limitation was met by the undeniable success of deep neural networks in acing a diversity of challenging computational problems. A success that has raised both the bar and the question of how well this progress would translate to spiking neural networks.\n",
    "\n",
    "The rise of deep learning over the last decade is in large part due to GPUs and their increased computational power, growing training data sets, and --- perhaps most importantly --- advances in understanding the quirks and needs of the error back-propagation algorithm. For instance, we now know that we have to avoid vanishing and exploding gradients, a feat that can be accomplished by choice of a sensible nonlinearity, proper weight initialization, and a suitable optimizer. Powerful software packages supporting auto-differentiation have since made mangling with deep neural networks a breeze in comparison to what it used to be. This development begs the question of how much of this knowledge gain from deep learning and its tools we can leverage to train spiking neural networks. Although a complete answer to these questions cannot be given at the moment, it seems that we can learn a lot.\n",
    "\n",
    "In this tutorial, we use insights and tools from machine learning to build, step-by-step, a spiking neural network. Explicitly, we set out with the goal of building networks that solve (simple) real-world problems. To that end, we focus on classification problems and use supervised learning in conjunction with the aforementioned back-propagation algorithm. To do this, we have to overcome a vanishing gradient problem caused by the binary nature of the spikes themselves.\n",
    "\n",
    "In this tutorial, we will first show how a simple feed-forward spiking neural network of leaky integrate-and-fire (LIF) neurons with current-based synapses can be formally mapped to a discrete-time recurrent neural network (RNN). We will use this formulation to explain why gradients vanish at spikes and show one way of how the problem can be alleviated. Specifically, we will introduce surrogate gradients and provide practical examples of how they can be implemented in PyTorch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mapping LIF neurons to RNN dynamics\n",
    "\n",
    "The de-facto standard neuron model for network simulations in computational neuroscience is the LIF neuron model which is often formally written as a time continuous dynamical system in differential form:\n",
    "$$\\tau_\\mathrm{mem} \\frac{\\mathrm{d}U_i^{(l)}}{\\mathrm{d}t} = -(U_i^{(l)}-U_\\mathrm{rest}) + RI_i^{(l)}$$\n",
    "where $U_i$ is the membrane potential of neuron $i$ in layer $l$, $U_\\mathrm{rest}$ is the resting potential, $\\tau_\\mathrm{mem}$ is the membrane time constant, $R$ is the input resistance, and $I_i$ is the input current. The membrane potential $U_i$ characterizes the hidden state of each neuron and, importantly, it is not directly communicated to downstream neurons. However, a neuron fires an action potential or spike at the time $t$ when its membrane voltage exceeds the firing threshold $\\vartheta$. After having fired a spike, a neurons membrane voltage is reset $U_i \\rightarrow U_\\mathrm{rest}$. We write\n",
    "$$S_i^{(l)}(t)=\\sum_{k \\in C_i^l} \\delta(t-t_j^k)$$ \n",
    "for the spike train (ie. the sum of all spikes $C_i^l$ emitted by neuron $i$ in layer $l$). Here $\\delta$ is the Dirac delta function and $t_i^k$ are the associated firing times of the neuron.\n",
    "\n",
    "Spikes travel down the axon and generate a postsynaptic currents in connected neurons. Using our above formalism we can thus write\n",
    "$$\\frac{\\mathrm{d}I_i}{\\mathrm{d}t}= -\\frac{I_i(t)}{\\tau_\\mathrm{syn}} + \\sum_j W_{ij} S_j^{(0)}(t) + \\sum_j V_{ij} S_j^{(1)}(t)$$\n",
    "where we have introduced the synaptic weight matrices $W_{ij}$ (feed-forward), $V_{ij}$ (recurrent), and the synaptic decay time constant $\\tau_\\mathrm{syn}$.\n",
    "\n",
    "To link to RNNs apparent, we will now express the above equations in discrete time. In the interest of brevity we switch to natural units $U_\\mathrm{rest}=0$, $R=1$, and $\\vartheta=1$. Our arguments remain unaffected by this choice, and all results can always be re-scaled back to physical units. To highlight the nonlinear character of a spike, we start by noting that we can set\n",
    "$$S_i^{(l)}(t)=\\Theta(U_i^{(l)}(t)-\\vartheta)$$\n",
    "where $\\Theta$ denotes the Heaviside step function.\n",
    "\n",
    "Assuming a small simulation time step of $\\Delta_t>0$ we can approximate the synaptic dynamics by\n",
    "$$I_i^{(l)}(t+1) = \\alpha I_i^{(l)}(t) + \\sum_j W_{ij} S_j^{(l-1)}(t) +\\sum_j V_{ij} S_j^{(l)}(t)$$\n",
    "with the constant $\\alpha=\\exp\\left(-\\frac{\\Delta_t}{\\tau_\\mathrm{syn}} \\right)$. Further, the membrane dynamics can be written as\n",
    "$$U_i^{(l)}(t+1) = \\underbrace{\\beta U_i^{(l)}(t)}_{\\mathrm{leak}} + \\underbrace{I_i^{(l)}(t)}_{\\mathrm{input}} -\\underbrace{S_i^{(l)}(t)}_{\\mathrm{reset}}$$\n",
    "with the output $S_i(t) = \\Theta(U_i(t)-1)$ and the constant $\\beta=\\exp\\left(-\\frac{\\Delta_t}{\\tau_\\mathrm{mem}}\\right)$. Note the distinct terms on the right-hand-side of the equation which are responsible individually for i) leak, ii) synaptic input, and iii) the spike reset.\n",
    "\n",
    "\n",
    "\n",
    "These equations can be summarized succinctly as the computational graph of an RNN with a specific connectivity structure. \n",
    "<img src=\"figures/snn_graph/snn_graph.png\" width=\"450\">\n",
    "Time flows from left to right. Inputs enter the network at each time step from the bottom of the graph ($S_i^{(0)}$). These inputs sequentially influence the synaptic currents $I_i^{(1)}$, membrane potentials the $U_i^{(1)}$, and finally the spiking output $S_i^{(1)}$.  Moreover, dynamic quantities have direct input on future time steps. We have suppressed the indices $i$ in the figure for clarity.\n",
    "\n",
    "The computational graph illustrates a concept which is known as unrolling in time, which emphasizes the duality between a deep neural network and a recurrent neural network, which is nothing more but a deep network in time (with tied weights). Due to this fact, we can train RNNs using the back-propagation of error through time (BPTT). We will discuss problems arising from the binary character of the spiking nonlinearity later. For now, let us start by implementing the above dynamics in a three-layer spiking neural network in PyTorch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with a simple multilayer network model with a single hidden layer, as shown below. For simplicity, we will not use recurrent connections $V$ for now, keeping in mind that they can be added later should the need arise.\n",
    "\n",
    "<img src=\"figures/mlp_sketch/mlp_sketch.png\">\n",
    "\n",
    "For the sake of argument, we set the numbers for the input, hidden and output neurons as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_inputs  = 100\n",
    "nb_hidden  = 4\n",
    "nb_outputs = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we have seen above, we are technically simulating an RNN. Thus we have to simulate our neurons for a certain number of timesteps. We will use 1ms timesteps, and we want to simulate our network for say 200 timesteps. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_step = 1e-3\n",
    "nb_steps  = 200"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To take advantage of parallelism, we will set up our code to work on batches of data like this is usually done for neural networks that are trained in a supervised manner.\n",
    "To that end, we specify a batch size here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 256"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With these basic design choices made, we can now start building the actual network. Here we will be using PyTorch, but you will be able to reproduce these results in most common machine learning libraries.\n",
    "\n",
    "We start by importing the libraries we need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.gridspec import GridSpec\n",
    "import seaborn as sns\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "dtype = torch.float\n",
    "device = torch.device(\"cpu\")\n",
    "\n",
    "# Uncomment the line below to run on GPU\n",
    "# device = torch.device(\"cuda:0\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A simple synthetic dataset \n",
    "\n",
    "We start by generating some random spiking data set, which we will use as input to our network. In the beginning, we will work with a single batch of data. It will be straight forward to expand later what we have learned to larger datasets.\n",
    "\n",
    "Suppose we want our network to classify a set of different sparse input spike trains into two categories. \n",
    "\n",
    "To generate some synthetic data, we fill a tensor of (batch_size x nb_steps x nb_inputs) with random uniform numbers between 0 and 1 and use this to generate our input dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "freq = 5 # Hz\n",
    "prob = freq*time_step\n",
    "mask = torch.rand((batch_size,nb_steps,nb_inputs), device=device, dtype=dtype)\n",
    "x_data = torch.zeros((batch_size,nb_steps,nb_inputs), device=device, dtype=dtype, requires_grad=False)\n",
    "x_data[mask<prob] = 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the plot the spike raster of the first input pattern, this synthetic dataset looks as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_id = 0\n",
    "plt.imshow(x_data[data_id].cpu().t(), cmap=plt.cm.gray_r, aspect=\"auto\")\n",
    "plt.xlabel(\"Time (ms)\")\n",
    "plt.ylabel(\"Unit\")\n",
    "sns.despine()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we assign a random label of 0 or 1 to each of our input patterns. Our network's task will be to differentiate these patterns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_data = torch.tensor(1*(np.random.rand(batch_size)<0.5), device=device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that there is no structure in the data (because it is entirely random). Thus we won't worry about generalization now and only care about our ability to overfit these data with the spiking neural network we are going to build in a jiffy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setup of the spiking network model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now is the time to implement our LIF neuron model in discrete time.\n",
    "We will first do this step by step before we wrap all the steps into a function later on.\n",
    "But first, we fix several model constants such as the membrane and the synaptic time constant. Moreover, we define some essential variables, including our $\\alpha$ and $\\beta$ as described above. We do this now because we will use some of these variables to scale our weights to meaningful ranges."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "tau_mem = 10e-3\n",
    "tau_syn = 5e-3\n",
    "\n",
    "alpha   = float(np.exp(-time_step/tau_syn))\n",
    "beta    = float(np.exp(-time_step/tau_mem))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we set up our weight matrices, which connect the input and the hidden layer, as well as the matrix connecting the hidden layer with the output layer. Moreover, we initialize these weights randomly from a normal distribution. Note that we scale the variance with the inverse square root of the number of input connections. Moreover, for the sake of simplicity, we ignore Dale's law in this tutorial. Thus weights can be either excitatory or inhibitory. This choice is prevalent in artificial neural networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "init done\n"
     ]
    }
   ],
   "source": [
    "weight_scale = 7*(1.0-beta) # this should give us some spikes to begin with\n",
    "\n",
    "w1 = torch.empty((nb_inputs, nb_hidden),  device=device, dtype=dtype, requires_grad=True)\n",
    "torch.nn.init.normal_(w1, mean=0.0, std=weight_scale/np.sqrt(nb_inputs))\n",
    "\n",
    "w2 = torch.empty((nb_hidden, nb_outputs), device=device, dtype=dtype, requires_grad=True)\n",
    "torch.nn.init.normal_(w2, mean=0.0, std=weight_scale/np.sqrt(nb_hidden))\n",
    "\n",
    "print(\"init done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A spiking neuron model in discrete time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first thing we need to do to implement our spiking neuron is to multiply all input spikes with the weight matrix. We have to do this for each time step in each input example in the batch. Because we have stored our input spikes in a rank three tensor we can express this operation in a single line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "h1 = torch.einsum(\"abc,cd->abd\", (x_data, w1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These \"weighted\" input spikes will now feed into our synaptic variable and, ultimately, the membrane potential. To trigger a spike, we need to define moreover a threshold or spike function, which we do in the following. We will later have to alter this definition to train the network, but more about that later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The spiking nonlinearity (the naive way)\n",
    "\n",
    "In discrete-time, as explained earlier, we can formulate our spiking nonlinearity as a Heaviside step function. So let's begin with defining a Heaviside function. One way of implementing it is the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def spike_fn(x):\n",
    "    out = torch.zeros_like(x)\n",
    "    out[x > 0] = 1.0\n",
    "    return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For each trial, we initialize the synaptic currents and membrane potentials at zero.\n",
    "Next, we need to implement a loop that simulates our neuron models over time. \n",
    "Moreover, we will record the membrane potentials and output spikes of all trials and all neurons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "syn = torch.zeros((batch_size,nb_hidden), device=device, dtype=dtype)\n",
    "mem = torch.zeros((batch_size,nb_hidden), device=device, dtype=dtype)\n",
    "\n",
    "# Here we define two lists which we use to record the membrane potentials and output spikes\n",
    "mem_rec = []\n",
    "spk_rec = []\n",
    "\n",
    "# Here we loop over time\n",
    "for t in range(nb_steps):\n",
    "    mthr = mem-1.0\n",
    "    out = spike_fn(mthr)\n",
    "    rst = out.detach() # We do not want to backprop through the reset\n",
    "\n",
    "    new_syn = alpha*syn +h1[:,t]\n",
    "    new_mem = (beta*mem +syn)*(1.0-rst)\n",
    "    \n",
    "    mem_rec.append(mem)\n",
    "    spk_rec.append(out)\n",
    "    \n",
    "    mem = new_mem\n",
    "    syn = new_syn\n",
    "\n",
    "# Now we merge the recorded membrane potentials into a single tensor\n",
    "mem_rec = torch.stack(mem_rec,dim=1)\n",
    "spk_rec = torch.stack(spk_rec,dim=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And that's it. The above loop has now simulated our neurons for '''nb_steps''' and stored their membrane traces and output spikes. Let us take a look at those membrane potentials in which we directly \"paste\" the spikes for visual inspection. We will directly plot multiple trials at once and define a little helper function for this purpose."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_voltage_traces(mem, spk=None, dim=(3,5), spike_height=5):\n",
    "    gs=GridSpec(*dim)\n",
    "    if spk is not None:\n",
    "        dat = 1.0*mem\n",
    "        dat[spk>0.0] = spike_height\n",
    "        dat = dat.detach().cpu().numpy()\n",
    "    else:\n",
    "        dat = mem.detach().cpu().numpy()\n",
    "    for i in range(np.prod(dim)):\n",
    "        if i==0: a0=ax=plt.subplot(gs[i])\n",
    "        else: ax=plt.subplot(gs[i],sharey=a0)\n",
    "        ax.plot(dat[i])\n",
    "        ax.axis(\"off\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 15 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig=plt.figure(dpi=100)\n",
    "plot_voltage_traces(mem_rec, spk_rec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, our random initialization gives us some sporadic spiking. Thus far, we have only an input layer and a spiking layer, which should become our hidden layer. Next, we will have to add a readout layer to our network."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding a readout layer\n",
    "\n",
    "To use our network as a classifier, we need to have a readout layer on whose output we can define a cost function. There are several possibilities for doing this. For instance, we could count output layer spikes, or we could directly define an objective function on the membrane potential of the output neurons. Here we will follow the latter approach, but keep in mind that there are many other possibilities of defining an output layer and respective cost functions on them.\n",
    "\n",
    "In the following, we will build the output layer as a population of leaky integrator neurons. The reason for this choice is that leaky integration is the natural way of how neurons receive the spiking output of their brethren. Moreover, because we will need this code again, we combine our code from above plus the added readout layer into a single function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_snn(inputs):\n",
    "    h1 = torch.einsum(\"abc,cd->abd\", (inputs, w1))\n",
    "    syn = torch.zeros((batch_size,nb_hidden), device=device, dtype=dtype)\n",
    "    mem = torch.zeros((batch_size,nb_hidden), device=device, dtype=dtype)\n",
    "\n",
    "    mem_rec = []\n",
    "    spk_rec = []\n",
    "\n",
    "    # Compute hidden layer activity\n",
    "    for t in range(nb_steps):\n",
    "        mthr = mem-1.0\n",
    "        out = spike_fn(mthr)\n",
    "        rst = out.detach() # We do not want to backprop through the reset\n",
    "\n",
    "        new_syn = alpha*syn +h1[:,t]\n",
    "        new_mem = (beta*mem +syn)*(1.0-rst)\n",
    "\n",
    "        mem_rec.append(mem)\n",
    "        spk_rec.append(out)\n",
    "        \n",
    "        mem = new_mem\n",
    "        syn = new_syn\n",
    "\n",
    "    mem_rec = torch.stack(mem_rec,dim=1)\n",
    "    spk_rec = torch.stack(spk_rec,dim=1)\n",
    "\n",
    "    # Readout layer\n",
    "    h2= torch.einsum(\"abc,cd->abd\", (spk_rec, w2))\n",
    "    flt = torch.zeros((batch_size,nb_outputs), device=device, dtype=dtype)\n",
    "    out = torch.zeros((batch_size,nb_outputs), device=device, dtype=dtype)\n",
    "    out_rec = [out]\n",
    "    for t in range(nb_steps):\n",
    "        new_flt = alpha*flt +h2[:,t]\n",
    "        new_out = beta*out +flt\n",
    "\n",
    "        flt = new_flt\n",
    "        out = new_out\n",
    "\n",
    "        out_rec.append(out)\n",
    "\n",
    "    out_rec = torch.stack(out_rec,dim=1)\n",
    "    other_recs = [mem_rec, spk_rec]\n",
    "    return out_rec, other_recs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now run this code and plot the output layer \"membrane potentials\" below. As desired, these potentials do not have spikes riding on them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "out_rec,other_recs = run_snn(x_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 15 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig=plt.figure(dpi=100)\n",
    "plot_voltage_traces(out_rec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By preventing the output neurons from spiking themselves, we can define a relatively smooth objective on their membrane voltages directly. Specifically, we use the maximum voltage over time of each output unit\n",
    "$$\\hat U^\\mathrm{out}_i=\\max_t U^\\mathrm{out}_i(t)$$\n",
    "and then use this vector as input for either an argmax to compute the classification accuracy or as we will see below as input for a standard softmax function in conjunction with a negative log-likelihood loss for optimizing the weights in the network. \n",
    "\n",
    "Let us first compute the classification accuracy of this random network. We will see that this accuracy is somewhere around 50% as it should be since that corresponds to the chance level of our synthetic task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy 0.516\n"
     ]
    }
   ],
   "source": [
    "def print_classification_accuracy():\n",
    "    \"\"\" Dirty little helper function to compute classification accuracy. \"\"\"\n",
    "    output,_ = run_snn(x_data)\n",
    "    m,_= torch.max(output,1) # max over time\n",
    "    _,am=torch.max(m,1) # argmax over output units\n",
    "    acc = np.mean((y_data==am).detach().cpu().numpy()) # compare to labels\n",
    "    print(\"Accuracy %.3f\"%acc)\n",
    "    \n",
    "print_classification_accuracy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Supervised learning\n",
    "\n",
    "So far, we have built the infrastructure to simulate our spiking neural network, but we have worked with purely random network weights thus far.\n",
    "The vanilla method to adjust network weights to decrease the specified objective is gradient descent. \n",
    "Machine learning libraries like Tensorflow and PyTorch make implementing gradient descent a breeze.\n",
    "We first perform gradient descent on the correct gradient and use this as a motivation for introducing surrogate gradients.\n",
    "Here we go."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Supervised learning with the true gradient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = [w1,w2] # The paramters we want to optimize\n",
    "optimizer = torch.optim.Adam(params, lr=2e-3, betas=(0.9,0.999)) # The optimizer we are going to use\n",
    "\n",
    "log_softmax_fn = nn.LogSoftmax(dim=1) # The log softmax function across output units\n",
    "loss_fn = nn.NLLLoss() # The negative log likelihood loss function\n",
    "\n",
    "# The optimization loop\n",
    "loss_hist = []\n",
    "for e in range(1000):\n",
    "    # run the network and get output\n",
    "    output,_ = run_snn(x_data) \n",
    "    # compute the loss\n",
    "    m,_=torch.max(output,1)\n",
    "    log_p_y = log_softmax_fn(m) \n",
    "    loss_val = loss_fn(log_p_y, y_data)\n",
    "\n",
    "    # update the weights\n",
    "    optimizer.zero_grad()\n",
    "    loss_val.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    # store loss value\n",
    "    loss_hist.append(loss_val.item())\n",
    "    \n",
    "loss_hist_true_grad = loss_hist # store for later use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(loss_hist)\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Loss\")\n",
    "sns.despine()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy 0.512\n"
     ]
    }
   ],
   "source": [
    "print_classification_accuracy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We appreciate that loss decreases over iterations and converges towards a steady state. The classification accuracy, however, does not seem to improve dramatically throughout the optimization. What a shame! \n",
    "\n",
    "The underlying reason is that the nonlinearity of the hidden units have zero derivatives everywhere except at threshold crossings, where they become infinite. In practice that means that weight updates in the hidden layer vanish and the weights remain unmodified. By plotting the hidden layer activations and comparing them with what we have plotted before, we will see that these activations have not changed at all. Thus no learning happens in the hidden layer. The reason why the loss decreased initially during optimization is that the output layer weights could still change and allow for some improvement (even if it was very little).\n",
    "\n",
    "To improve performance, we need to get the hidden layer units to take part in learning. To achieve this, we will introduce a surrogate gradient in the next section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "output,other_recordings = run_snn(x_data)\n",
    "mem_rec, spk_rec = other_recordings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
Download .txt
gitextract_9f1972op/

├── .gitignore
├── README.md
├── notebooks/
│   ├── .gitignore
│   ├── SpyTorchTutorial1.ipynb
│   ├── SpyTorchTutorial2.ipynb
│   ├── SpyTorchTutorial3.ipynb
│   ├── SpyTorchTutorial4.ipynb
│   ├── SpyTorchTutorial5.ipynb
│   ├── figures/
│   │   ├── .gitignore
│   │   ├── mlp_sketch/
│   │   │   ├── Makefile
│   │   │   └── mlp_sketch.tex
│   │   ├── snn_graph/
│   │   │   ├── Makefile
│   │   │   └── snn_graph.tex
│   │   └── surrgrad/
│   │       ├── Makefile
│   │       └── surrgrad.gnu
│   └── utils.py
└── requirements.txt
Download .txt
SYMBOL INDEX (5 symbols across 1 files)

FILE: notebooks/utils.py
  function get_shd_dataset (line 15) | def get_shd_dataset(cache_dir, cache_subdir):
  function get_and_gunzip (line 36) | def get_and_gunzip(origin, filename, md5hash=None, cache_dir=None, cache...
  function validate_file (line 45) | def validate_file(fpath, file_hash, algorithm='auto', chunk_size=65535):
  function _hash_file (line 56) | def _hash_file(fpath, algorithm='sha256', chunk_size=65535):
  function get_file (line 68) | def get_file(fname,
Condensed preview — 17 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (1,376K chars).
[
  {
    "path": ".gitignore",
    "chars": 728,
    "preview": "# ---> Python\n# Byte-compiled / optimized / DLL files\n__pycache__/\n*.py[cod]\n*$py.class\n\n# C extensions\n*.so\n\n# Distribu"
  },
  {
    "path": "README.md",
    "chars": 1149,
    "preview": "# SpyTorch\nA tutorial on surrogate gradient learning in spiking neural networks\n\nVersion: 0.4\n\n[![DOI](https://zenodo.or"
  },
  {
    "path": "notebooks/.gitignore",
    "chars": 1328,
    "preview": "# Byte-compiled / optimized / DLL files\n__pycache__/\n*.py[cod]\n*$py.class\n\n# C extensions\n*.so\n\n# Distribution / packagi"
  },
  {
    "path": "notebooks/SpyTorchTutorial1.ipynb",
    "chars": 422584,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Tutorial 1: Training a spiking ne"
  },
  {
    "path": "notebooks/SpyTorchTutorial2.ipynb",
    "chars": 221911,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Tutorial 2: Training a spiking ne"
  },
  {
    "path": "notebooks/SpyTorchTutorial3.ipynb",
    "chars": 111069,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Tutorial 3: Training a spiking ne"
  },
  {
    "path": "notebooks/SpyTorchTutorial4.ipynb",
    "chars": 145875,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Tutorial 4: Training a spiking ne"
  },
  {
    "path": "notebooks/SpyTorchTutorial5.ipynb",
    "chars": 443345,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Tutorial 5: Training a spiking ne"
  },
  {
    "path": "notebooks/figures/.gitignore",
    "chars": 2480,
    "preview": "## Core latex/pdflatex auxiliary files:\n*.aux\n*.lof\n*.log\n*.lot\n*.fls\n*.out\n*.toc\n*.fmt\n*.fot\n*.cb\n*.cb2\n.*.lb\n\n## Inter"
  },
  {
    "path": "notebooks/figures/mlp_sketch/Makefile",
    "chars": 91,
    "preview": "all: mlp_sketch.png\n\n%.png: %.pdf\n\tconvert -density 150 $< $@\n\n%.pdf: %.tex\n\tpdflatex $< \n\n"
  },
  {
    "path": "notebooks/figures/mlp_sketch/mlp_sketch.tex",
    "chars": 2231,
    "preview": "\\documentclass{standalone}\n\n\n\\usepackage{tikz}\n\\usepackage{verbatim}\n\\usepackage{tikz,graphicx}\n\\usepackage{sfmath}\n\\use"
  },
  {
    "path": "notebooks/figures/snn_graph/Makefile",
    "chars": 88,
    "preview": "all: snn_graph.png\n\n%.pdf: %.tex\n\tpdflatex $<\n\n%.png: %.pdf\n\tconvert -density 150 $< $@\n"
  },
  {
    "path": "notebooks/figures/snn_graph/snn_graph.tex",
    "chars": 2411,
    "preview": "\\documentclass{standalone}\n\n\\usepackage[latin1]{inputenc}\n\\usepackage{tikz}\n\\usepackage{tikz,graphicx}\n\\usepackage{sfmat"
  },
  {
    "path": "notebooks/figures/surrgrad/Makefile",
    "chars": 114,
    "preview": "all: surrgrad.png\n\n%.png: %.pdf\n\tconvert -density 150 $< $@\n\n%.pdf: %.tex\n\tpdflatex $< \n\n%.tex: %.gnu\n\tgnuplot $<\n"
  },
  {
    "path": "notebooks/figures/surrgrad/surrgrad.gnu",
    "chars": 481,
    "preview": "#!/usr/bin/gnuplot\n\nset border 3\nset xtics nomirror out\nset ytics nomirror out\n\n\ntheta(x) = x>0?1:0\n\nsigma(x) = 0.5*x/(a"
  },
  {
    "path": "notebooks/utils.py",
    "chars": 4562,
    "preview": "import os\nimport urllib.request\nimport gzip, shutil\nimport hashlib\n\nfrom six.moves.urllib.error import HTTPError \nfrom s"
  },
  {
    "path": "requirements.txt",
    "chars": 141,
    "preview": "jupyter==1.0.0\njupyter-client==6.1.6\njupyter-console==6.1.0\njupyter-core==4.6.3\ntorch==1.6.0\ntorchvision==0.7.0\nseaborn="
  }
]

About this extraction

This page contains the full source code of the fzenke/spytorch GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 17 files (1.3 MB), approximately 871.5k tokens, and a symbol index with 5 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.

Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.

Copied to clipboard!