S4NN: temporal backpropagation for spiking neural networks with one spike per neuron

10/21/2019 ∙ by Saeed Reza Kheradpisheh, et al. ∙ 0

We propose a new supervised learning rule for multilayer spiking neural networks (SNN) that use a form of temporal coding known as rank-order-coding. With this coding scheme, all neurons fire exactly one spike per stimulus, but the firing order carries information. In particular, in the readout layer, the first neuron to fire determines the class of the stimulus. We derive a new learning rule for this sort of network, termed S4NN, akin to traditional error backpropagation, yet based on latencies. We show how approximate error gradients can be computed backward in a feedforward network with an arbitrary number of layers. This approach reaches state-of-the-art performance with SNNs: test accuracy of 97.4 Face/Motorbike dataset. Yet the neuron model we use, non-leaky integrate-and-fire, are simpler and more hardware friendly than the one used in all previous similar proposals.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 5

page 8

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Biological neurons use spikes to compute and transmit information. The spike times, in addition to the spike rates, are known to play an important role in how neurons process information [1, 2]. SNNs are thus more biologically realistic than the artificial neural networks (ANNs), and are arguably the only viable option if one wants to understand how the brain computes at the neuronal description level. But SNNs are also appealing for technology, especially for edge computing, since they are far less energy hungry than ANNs [3, 4, 5].

Here we focus on one sub-class of SNNs which classify static inputs (e.g. images), and in which neurons fire at most once, but the most strongly activated neurons fire first 

[6, 7]. Thus the spike latencies, or order, carry information. In the readout layer there is one neuron per category. As soon as one of these neurons fires, the network assigns the corresponding category to the input, and the computations can stop, when only a few neurons have fired. This coding scheme is thus extremely economical in number of spikes (and thus in energy).

In this work, we adapted the well known backpropagation algorithm, originally designed for ANNs, to this sort of SNNs. Backpropagation has been shown to solve extremely difficult classification problem in ANNs with many layers, leading to the so called “deep learning” revolution 

[8]. The tour de force of backpropagation is to solve the multi-layer credit assignment problem. That is, it finds what the hidden layers should do to minimize the loss in the readout layer. This motivated us, and others [9, 10, 11]

, to adapt backpropagation to single-spike SNNs, by using the latencies instead of the firing rates. The main strength of our approach with respect to the above-mentioned ones is the use of a simpler and more hardware-friendly neuron model: a non-leaky integrate-and-fire neuron with instantaneous synapses. Yet it reaches a comparable accuracy on the MNIST dataset.

2 S4NN: single-spike supervised spiking neural network

The proposed network (S4NN) is comprised of an input layer converting input data into a spike train and feeding it into the network, followed by one ore more hidden layers of integrate-and-fire (IF) neurons processing the input spikes, and finally, an output layer of IF neurons with one neuron per category. Here, we use a rank-order coding called time-to-first-spike in the input layer which is very sparse and produces at most one spike for each input value. The subsequent neurons are also limited to fire exactly once.

To train the network, a temporal version of the backpropagation algorithm is used. First, the network’s decision on the category of the input image is made by considering the first output neuron to fire. Then, the error of each output neuron is computed by comparing its actual firing time with a target firing time. Finally, these errors are backpropagated through the layers and weights get updated through stochastic gradient descent. Meanwhile, the temporal backpropagation confronts two challenges: defining the target firing time and computing the derivative of the neuron’s firing time with respect to its membrane potential. To overcome these challenges, the proposed learning algorithm uses relative target firing times and approximated derivations.

2.1 Time-to-first-spike coding

The first step of a SNN is to convert the analog input signal into a spike train representing the same information. Obviously, the neural processing in the following neurons should be compatible to this coding scheme to be able to decipher the information encoded in the input spikes. Here, we use a time-to-first-spike coding for the entry layer (in which a larger input value corresponds to an earlier spike) and IF neurons in subsequent layers that fire once.

Consider an image with the pixel intensity values in range [0, ], each input neuron encodes its corresponding pixel value in a single spike time in range [0, ]. The firing time of the input neuron, , is computed based on the pixel intensity value, , as follows:

(1)

Therefore, the spike train of the neuron in the input layer (layer zero) is defined as

(2)

Notably, this simple intensity-to-latency code does not need any preprocessing steps like applying Gabor or DoG filters that are commonly used in SNNs, especially, in those with STDP learning rule which can not handle homogeneous surfaces. Also, it produces only one spike per pixel and hence the obtained spike train is way sparser than what is common in rate codes.

The time-to-first-spike coding is in place at the subsequent layers as well and earlier spikes correspond to greater values, hence, the output neuron that fires earlier than others will determine the category of the input stimuli.

2.2 Forward path

The proposed network consists of multiple layers of IF neurons where the membrane potential of the neuron in the layer at time point , , is computed as

(3)

where and are, respectively, the input spike train and the input synaptic weight from the presynaptic neuron in the previous layer. The IF neuron emits a spike the first time its membrane potential reaches the threshold, ,

(4)

As explained in the previous section, the input image is transformed into a spike train, , in which each input neuron will emit a spike with a delay, in range , negatively proportional to the corresponding pixel value. These spikes are propagated towards the first layer of the network, where each neuron receives incoming spikes and update its membrane potential until it reaches its threshold and sends a spike to the neurons in the next layer. For each input image, the simulation starts by resetting all membrane voltages to zero and continues for time steps. Note that during a simulation, each neuron at any layer is allowed to fire at most once. If a neuron was silent during the simulation, we assume that it fires a fake spike at the last time step, . Finally, regarding the time-to-first-spike coding deployed in our network, the output neuron which fires earlier than others determines the category of the input stimuli.

2.3 IF approximating ReLU

In traditional ANNs with ReLU activation function, the output of a neuron in layer

with index is computed as

(5)

where and are the input and connection weight, respectively. Thus, a ReLU neuron with larger has a larger output value. Generally, the main portion of this integration value is due to the large inputs with large connection weights. In our time-to-first-spike coding, larger values are corresponded to earlier spikes, and hence, if an IF neuron receives these early spikes through strong synaptic weights, it will also fire earlier than others which is considered to have a larger output than others. This way, the time-to-first-spike coding is yet preserved in the hidden and output layers. Therefore, for the same inputs and synaptic weights, we can assume a relation between the output of the ReLU neuron, , and the firing time of the corresponding IF neuron, ,

(6)

and we know that

(7)

where if . According to Eq. (6) we assume that if , thus we have

(8)

where if .

2.4 Backward path

Assume that in a categorization task with categories, each output neuron is assigned to a different category. After completing the forward path over the input pattern, each output neuron may fire at a different time point. As mentioned before, the category of an input image is predicted as the category assigned to the winner output neuron (the output neuron which has fired earlier than others).

Hence, to be able to train the network, we define a temporal error function as

(9)

where and are the target and actual firing times of the output neuron, respectively.

During the learning phase, we use the stochastic gradient descent (SGD) and backpropagation algorithms to minimize the “squared error” loss function. For each training sample the loss is defined as,

(10)

and, hence, we need to compute its gradient with respect to each synaptic weight. To update , the synaptic weight between the neuron of layer and the neuron of layer , we have

(11)

where is the learning rate parameter.

Let’s define

(12)

therefore, by considering Eq. (8) and Eq. (12), we have

(13)

where for the output layer (i. e., ) we have

(14)

and for the hidden layers (i. e., ), we have

(15)

where iterates over neurons in layer . Note that regarding Eq. 12 we have , and as explained in Section 2.3 we approximate . To compute we should note that the firing of neuron in layer at time increases by if and only if .

To avoid the exploding and vanishing gradient problems during backpropagation, we use a normalized gradients. Literally, at any layer

, we normalize the backpropagated gradients before updating the weights

(16)

To avoid over-fitting, we added an -norm regularization term (over all the synaptic weights in all the layers) to the ”squared error” loss function in Eq. (10). The parameter is the regularization parameter determining how much to penalize the weights.

2.5 Relative target firing time

As the proposed network works in temporal domain, for each input image, we need to define the target firing time of output neurons regarding to its category label.

One possible scenario is to define a fixed and pre-defined vector of target firing times for each category, in a way that the correct neuron has a shorter target firing time than others. For instance, if the input image belongs to the

category, then, one can define and for , where is the desired firing time for the winner neuron. This way, the correct output neuron is encouraged to fire early at time while others are enforced not to fire up to the end of the simulation.

Such strict approaches have several drawbacks. For instance, assume an input image belonging to the category with shorter than , this way the correct neuron has a negative error which means that it should have fired later and, as explained in the backward path, this will enforce the network to unlearn what helped the correct neuron to fire that early, which is obviously not desirable.

The other scenario is to employ a dynamic method to determine the target firing times for each input image, independently. Here, we propose a relative method which takes the actual firing times into account. Assume an input image of the category is fed to the network and the firing time of the output neurons is obtained. First we compute the minimum output firing time as and then we set the target firing time of the output neuron as

(17)

where is a positive constant term penalizing output neurons with firing times close to . Other neurons which has fired quite after are not penalized and the correct output neuron is encouraged to fire earlier than others at the minimum firing time, .

In a special case where all output neurons are silent during the simulation and their firing time is manually set to , we compute the target firing times as

(18)

to encourage the correct output neuron to fire during the simulation.

2.6 Learning procedure

As mentioned before, the proposed network employs a temporal version of SGD and backpropagation to train the network. During a training epoch, images are converted into input spike trains by the time-to-first-spike coding (see Section 

2.1) and fed to the network one by one. Through the forward path, each IF neuron at any layer receives incoming spikes and emits a spike when it reaches its threshold (see Section 2.2

). Then, after computing the relative target output firing times (encouraging correct output neuron to fire earlier, see Section 

2.5), we update the synaptic weights in all the layers using temporal error backpropagation (see Section 2.4). Note that we enforce neurons to fire a fake spike at the last time step if they could not reach the threshold during the simulation (it is necessary for computing the target firing times). After completing the forward and backward processes on the current input image, the membrane potentials of all the IF neurons are reset to zero and the network gets ready to process the next input image. Notably, each neuron is allowed to fire only once during the processing of each input image.

As stated before, except for the fake spikes, IF neurons fire if and only if they reach their threshold. Consider an IF neuron that has decreased its weights (during the weight update process) in a way that it can not reach its threshold for any of the training images. Now it is a dead neuron and only emits fake spikes. Hence, if a neuron dies and does not fire real spikes during a training epoch, we recycle it by reseting its weights to a new set of random values. Although it happens rarely, but it helps the network to use all of its learning capacity.

3 Results

We first use the Caltech 101 face/motorbike dataset to better demonstrate the learning process in S4NN and its capacity to work on large-scale and natural images. Afterwards, we evaluate S4NN on MNIST dataset which is one of the widely used benchmarks in the area of spiking neural networks to demonstrate its capability to handle large and multi-class problems.

3.1 Caltech face/motorbike dataset

Figure 1: Some sample images from Caltech face/motorbike dataset.

We evaluated our S4NN on the face and motorbike categories of the Caltech 101 dataset available at http://www.vision.caltech.edu (see Figure 1 for sample images). The training and validation set respectively contain 200 and 50 randomly selected images per category, and remaining images constitute the test set. The test images are not seen during the learning phase but used afterward to evaluate the performance on novel images. This standard cross-validation procedure allows measuring the system’s ability to generalize, as opposed to learning the specific training examples. All images were converted to grayscale values and rescaled to be 160250 pixels in height.

In the first experiment, we use a fully connected architecture with a hidden layer of four IF neurons. The input layer has the same size as the input images (i. e., 160250) and the firing time of each input neuron is calculated by the time-to-first-spike explained in Section 2.1. The output layer is comprised of two output IF neurons (the face and the motorbike neurons) corresponding to the image categories. We set the maximum simulation time as

and initialize the input-hidden and hidden-output synaptic weights with random values drawn from uniform distributions in range

and , respectively. We also set the learning rate as , the penalty term in the target firing time calculation as , and the regularization parameter as . For all the neurons in all the layers the membrane potential’s threshold is set to 100.

Figure 2: SSE on the training and validation sets through the epochs.

Figure 2 shows the trajectory of the sum of squared error (SSE) of the training and validation samples over the training epochs. The sudden jumps in the early part of SSE curves are mainly due to the enormous weight changes in the first training epochs that may keep any of the output neurons silent (emitting fake spikes only) for a while that is being resolved during the next epoch. Finally, after some epochs, the network overcomes this challenge and decreases and stabilizes the SSE in an acceptable range.

The proposed S4NN could reach 99.75% accuracy on training samples and 99.2% accuracy on testing samples which outperforms previously reported SNN results on this dataset. In [12]

, a two-layer convolutional SNN trained by unsupervised STDP followed by a supervised potential-based radial basis functions (RBFs) classifier reached 99.2% accuracy on this dataset. This network uses four Gabor filters and four scales in the first layer and extracts ten different filters for the second layer. Also, it does not make decisions by the spike times, rather it uses neurons’ membrane potential to do the classification. In 

[13], a STDP-based SNN with three convolutional layers (respectively consisting of 4, 20, and 10 filters) and a SVM classifier could reach to 99.1% accuracy on this dataset. This model has also used the membrane potentials of neurons in the last layer to do the classification. To do a spike-based classification, authors in [14]

proposed a two-layer convolutional network with four Gabor filters in the first layer and 20 filters learned by reward-modulated STDP in the second layer. Each of the 20 filter was assigned to a specific category and decision was made by the first neuron to fire. It reached to 98.2% accuracy on Caltech face/motorbike dataset. The important feature of this network was the spike-time-based decision-making achieved through reinforcement learning. The proposed S4NN also make decisions by the spike times and could reach 99.2% accuracy only by using four hidden and two output neurons.

Figure 3: The firing time of face and motorbike output neurons over the face and motorbike images at A) the beginning and B) the end of the training phase. Left (right) plots show the firing time of both neurons over the face (motorbike) images.
Figure 4: The histogram of the firing time of the winner neuron (regardless of its category) over the training images. The red dashed line shows the mean firing time of the winner neuron.
Figure 5: The pattern (input-hidden weight matrix) learned by each of the four hidden neurons. The first neuron responds to face images while the other three are selective to the motorbikes variants.
Figure 6: The histogram of the input-hidden synaptic weighs for each of the hidden neurons.

As explained in Section 2.2, each output neuron is assigned to a category and the network decision is made based on the first output neuron to fire. During the learning phase, regarding the relative target firing time (see Section 2.5), the network adjusts its weights to make the correct output neuron to fire first (see Section 2.4). Figure 3 provides the firing time of both face and motorbike output neurons (over the training and validation images) at the beginning and ending of the learning phase. As seen in Figure 3A, at the beginning of the learning, the distribution of the firing times of both output neurons (regardless of the image category) are interleaved that leads to a poor classification accuracy around the chance level. But as the learning phase proceeds and network learns to solve the task, the correct output neuron tends to fire earlier. As shown in Figure 3B, at the end of the learning phase, for each image category, its corresponding output neuron fires at the early time steps while the other neuron fires long after. Note that we enforce neurons to emit a fake spike at the last time step if they have not fired during the simulation. Hence, in test phase, we do not need to continue the simulation after the emission of the first spike in the output layer. Figure 4 shows the distribution of the firing times of the winner neurons. The mean firing time for winner neuron is 27.4 (shown by the red line) where in 78% of the images, the winner neuron has fired within the first 40 time steps. It means that the network makes its decision very quickly and accurately.

As the employed network has only one hidden layer of fully connected neurons, we can simply reconstruct the pattern learned by each hidden neuron by plotting its synaptic weights. Figure 5 demonstrates the synaptic weights of the four hidden neurons at the end of the learning phase. As seen, neurons #2 to #4 became selective to different shapes of motorbikes. Neuron #1 has learned a combination of faces appearing at different locations and consequently responds only to face images. Because of the competition held between the output neurons to fire first, hidden and output neurons should learn and rely on the early spikes received from the input layer (not all of them). And this is the reason of why the learned features in the hidden layer are not visually well detectable. The distribution of synaptic weights for each of the four hidden neurons are plotted in Figure 6

. as seen the initial uniform distribution of the weights, through the learning, are transformed into normal distributions with zero means. Here, positive weights encourages neuron to fire for its learned pattern and negative weights prevent it from firing for other patterns.

To assess the capacity of the proposed temporal backpropagation algorithm to be used in deeper architectures, we did another experiment on Caltech face/motorbike dataset with a three-layer network. The deep network is comprised of two hidden layers each of which consists of four IF neurons followed by an output layer with two IF neurons. We initialized the input-hidden1, hidden1-hidden2, and hidden2-output weights with random values drawn from uniform distributions in range , , and , respectively. Other parameters are exactly the same as the aforementioned network with one hidden layer. After 25 training epochs, the network reached 99.1% accuracy on testing images with the mean firing time of 32.1 for the winner neuron. It shows that the proposed S4NN can well backpropagate the temporal error through the layers and can be used in deeper networks.

3.2 MNIST Dataset

Model Coding Neuron model Learning method Hidden neurons Acc. (%)
Mostafa (2017) [10] Temporal IF (exponential synaptic current) Temporal backpropagation 800 97.2
Tavanaei et al (2019) [15] Rate IF (instantaneous synaptic current) STDP-based backpropagation 1000 96.6
Comsa et al (2019) [11] Temporal SRM (exponential synaptic current) Temporal backpropagation 340 97.9
S4NN (This paper) Temporal IF (instantaneous synaptic current) Temporal backpropagation 400 97.4
Table 1: Recogniton accuracy of recent supervised SNNs with time-based backpropagation on MNIST dataset. The details of each model including its input coding scheme, neuro model, learning method, and the number of hidden neurons are provided in the table.

MNIST [16] is a benchmark dataset which has been widely used in SNN literature [4]. We also evaluated the proposed S4NN on the MNIST dataset which contains 60,000 training and 10,000 test handwritten single-digit images. Each image is of size pixels and contains one of the digits 0–9. To this end, we used a S4NN with one hidden and one output layers containing 400 and 10 IF neurons, respectively. The input layer is of the same size as the input images where each the firing time of each input neuron is determined by the time-to-first-spike coding explained in Section 2.1 with the maximum simulation time of . The input-hidden and hidden-output layers synaptic weights are randomly drawn from uniform distributions in ranges and , respectively. The threshold for all the neurons in all the layers was set to . We set the learning rate as , the penalty term in the target firing time calculation as , and the regularization parameter as .

Digit ’0’ ’1’ ’2’ ’3’ ’4’ ’5’ ’6’ ’7’ ’8’ ’9’
Mean firing Time 97.2 44.1 75.3 98.1 118.5 81.2 90.9 100.1 115.6 75.6
Mean required spikes 221.0 172.6 226.4 220.5 233.2 220.7 224.0 224.6 233.6 213.4
Table 2: The mean firing time of the correct output neuron along with the mean required number of spikes (in all the layers) until the emission of the first spike at the output layer, for each digit category.

Table 1 provides the categorization accuracy of the proposed S4NN and recent SNNs with spike-time-based supervised learning rules on MNIST dataset. In Mostafa (2017) [10], the use of 800 IF neurons with alpha functions complicates the neural processing and the learning procedure of the network. In Tavanaei et al (2018) [15], the network’s computational cost is quite large due to the use of rate coding and 1000 hidden neurons. In Comsa et al (2019) [11], the use of complicated SRM neuron model with exponential synaptic current makes it difficult for event-based implementation. The advantages of S4NN is the use of simple neuron model (IF with instantaneous synaptic current), temporal coding with at most one spike per neuron, and simple supervised temporal learning rule. Also, we used only 400 neurons in the hidden layer which makes it lighter than other networks.

Figure 7: The mean firing time of each output neuron (rows) over the images of different digit categories (columns).

Figure 7 shows the mean firing time of each output neuron on images of different digit categories. As seen, for each digit category, there is a huge gap between the mean firing time of correct output neurons with respect to the others. Digits ’1’ and ’4’ with the time firing times of 44.1 and 118.5 have the minimum and maximum mean firing times, respectively. Hypothetically, recognition of digit ’1’ relies on much fewer spikes than other digits and would have much faster response. While digit ’4’ (or digit ’8’ with the mean firing time of 101.5) needs much more input spikes to be correctly recognized from other (and similar) digits. Interestingly, on average, the network needs 172.69 spikes to recognize digit ’1’ and 233.22 spikes for digit ’4’. Table 2 presents the mean firing time of the correct output neurons along with the mean required number of spikes. Note that the required spikes are obtained by counting the number of spikes in all the three layers (input, hidden, and output) until the emission of the first spike at the output layer.

On average, the proposed S4NN makes its decisions with 97.4% precision in 89.7 time step (35.17% of maximum simulation time) with only 218.3 spikes (18.22% of 784+400+10 possible spikes). Therefore, the proposed network works in a fast, accurate, and sparse manner.

4 Discussion

In this paper, we proposed a SNN (called S4NN) comprised of multiple layers of IF neurons with single-spike temporal coding and temporal error backpropagation. Regarding the employed time-to-first-spike coding, input neurons emit a spike with a latency negatively proportional to the corresponding pixel value and upstream neurons are allowed to fire only once. The proposed temporal error backpropagation, pushes the correct output neuron to fire earlier than others. It enforces the network to make quick and accurate decisions with a few number of spikes (high sparsity). Our experiments on Caltech face/motorbike (99.2% accuracy) and MNIST (97.4% accuracy) datasets show the merits of S4NN to accurately solve object recognition tasks with less computational cost compared to other recent supervised SNNs with temporal learning rules.

The use of simple IF neurons in S4NN makes it more computationally efficient and hardware friendly than other SNNs that use complicated neuron models such as SRM and LIF. Also, preventing neurons to fire more than once increases the energy efficiency of S4NN for hardware implementations compared to SNNs that use rate coding schemes. Moreover, spike-rate-based SNNs require a longer time to have enough output spikes to make a confident decision, while spike-time-based SNNs can make final decision based on the first output spike. Note that the role of the employed temporal backpropagation is critical here, as the network should learn spike times (not spike rates or membrane potentials) as well as enforcing the network to make quick (and off course accurate) decisions.

Due to the non-differentiablity of the thresholding activation function of spiking neurons at their firing times, applying gradient descent and backpropagation algorithms to SNNs has always been a big challenge. The first approach is to forget about single spike events and use the relation between the input and the output spike rates as a proxy to the neuron’s activation function [17, 18, 19]. The second approach is to use smoothed spike generating process to make it differentiable around the firing time [20]. The third approach is to use surrogate gradients at the firing times [5, 21, 22, 23, 24, 25].

All the aforementioned approaches do not deal with spike times. In the fourth approach, known as latency learning, neuron’s activity is defined based on its firing time (usually the first spike) and contrary to the three previous approaches, the derivation of the thresholding activation function is not needed. However, they need to define the firing time of the neuron as a function of its membrane potential or the firing time of presynaptic neurons and use its derivation in the backpropagation process. For instance, in Spikeprop [9], authors use a linear approximation function which relies on the changes of the membrane potential around the firing time (hence, they can not use IF neuron model). Also, in [10], by using exponentially decaying synapses, the author has defined the firing time of a neuron directly based on the firing times of its presynaptic neurons. Here, by assuming a monotonically increasing linear relation between the firing time and membrane potential, we could use IF neurons with instantaneous synapses in the proposed S4NN model.

SNNs with latency learning use single-spike-timing coding, and hence, there is a problem if neurons do not reach their threshold, because then the latency is not defined. There are different approaches to deal with this problem. In [10], the author uses non-leaky neurons and makes sure that the sum of the weights is more than the threshold or in [11], authors use fake input “synchronization pulses” to push neurons over threshold. In the proposed S4NN, we assume that if a neuron has not fired during the simulation it will fire sometime after the simulation, thus, we enforce it to emit a fake spike at the last time step.

As shown on the Caltech face/motorbike dataset, the proposed learning rule is scalable and can be used in deeper S4NN architectures. Also, it can be used in convolutional spiking neural networks (CSNN). Current CSNNs are mainly converted from traditional CNNs with rate [26, 27, 28, 29] and temporal coding [30]. Although these networks are well in terms of accuracy, they might not work efficiently in terms of computational cost or time. Recent efforts to develop CSNNs with spike-based backpropagation have led to impressive results on different datasets [31, 32], however, they use costly neuron models and rate coding schemes. Hence, extending the proposed S4NN to convolutional architectures can provide large computational benefits.

Moreover, although SNNs are more hardware friendly than traditional ANNs, the backpropagation process in supervised SNNs is not easy to be implemented in hardware. Recently, efforts are made to approximate backpropagation using spikes [33] that can be used in S4NN to be more suitable for hardware implementation.

References

  • [1] R. VanRullen, R. Guyonneau, S. J. Thorpe, Spike times make sense., Trends in Neuroscience 28 (1) (2005) 1–4.
  • [2] R. Brette, Philosophy of the spike: rate-based vs. spike-based theories of the brain, Frontiers in systems neuroscience 9 (2015) 151.
  • [3] M. Pfeiffer, T. Pfeil, Deep learning with spiking neurons: opportunities and challenges, Frontiers in neuroscience 12 (2018) 774.
  • [4] A. Tavanaei, M. Ghodrati, S. R. Kheradpisheh, T. Masquelier, A. Maida, Deep learning in spiking neural networks, Neural Networks 111 (2019) 47–63.
  • [5] E. O. Neftci, H. Mostafa, F. Zenke, Surrogate gradient learning in spiking neural networks, arXiv (2019) 1901.09948.
  • [6] S. J. Thorpe, J. Gautrais, Rank Order Coding, in: J. M. Bower (Ed.), Computational Neuroscience : Trends in Research, New York: Plenum Press, 1998, pp. 113–118.
  • [7] S. Thorpe, A. Delorme, R. V. Rullen, Spike-based strategies for rapid processing., Neural Netw 14 (6-7) (2001) 715–725.
  • [8] Y. LeCun, Y. Bengio, G. Hinton, Deep learning, Nature 521 (7553) (2015) 436–444.
  • [9] S. M. Bohte, H. La Poutré, J. N. Kok, Error-Backpropagation in Temporally Encoded Networks of Spiking Neurons, Neurocomputing 48 (2000) 17–37.
  • [10] H. Mostafa, Supervised learning based on temporal coding in spiking neural networks, IEEE transactions on neural networks and learning systems 29 (7) (2017) 3227–3235.
  • [11] I. M. Comsa, K. Potempa, L. Versari, T. Fischbacher, A. Gesmundo, J. Alakuijala, Temporal coding in spiking neural networks with alpha synaptic function, arXiv (2019) 1907.13223.
  • [12]

    T. Masquelier, S. J. Thorpe, Unsupervised learning of visual features through spike timing dependent plasticity, PLoS computational biology 3 (2) (2007) e31.

  • [13]

    S. R. Kheradpisheh, M. Ganjtabesh, S. J. Thorpe, T. Masquelier, Stdp-based spiking deep convolutional neural networks for object recognition, Neural Networks 99 (2018) 56–67.

  • [14] M. Mozafari, S. R. Kheradpisheh, T. Masquelier, A. Nowzari-Dalini, M. Ganjtabesh, First-spike-based visual categorization using reward-modulated stdp, IEEE transactions on neural networks and learning systems 29 (12) (2018) 6178–6190.
  • [15] A. Tavanaei, A. Maida, Bp-stdp: Approximating backpropagation using spike timing dependent plasticity, Neurocomputing 330 (2019) 39–47.
  • [16] Y. LeCun, L. Bottou, Y. Bengio, P. Haffner, et al., Gradient-based learning applied to document recognition, Proceedings of the IEEE 86 (11) (1998) 2278–2324.
  • [17] E. Hunsberger, C. Eliasmith, Spiking deep networks with lif neurons, arXiv (2015) 1510.08829.
  • [18] J. H. Lee, T. Delbruck, M. Pfeiffer, Training deep spiking neural networks using backpropagation, Frontiers in neuroscience 10 (2016) 508.
  • [19] E. O. Neftci, C. Augustine, S. Paul, G. Detorakis, Event-driven random back-propagation: Enabling neuromorphic deep learning machines, Frontiers in neuroscience 11 (2017) 324.
  • [20] D. Huh, T. J. Sejnowski, Gradient descent for spiking neural networks, in: Advances in Neural Information Processing Systems, 2018, pp. 1433–1443.
  • [21] S. M. Bohte, Error-backpropagation in networks of fractionally predictive spiking neurons, in: International Conference on Artificial Neural Networks, Springer, 2011, pp. 60–68.
  • [22] S. K. Esser, P. A. Merolla, J. V. Arthur, A. S. Cassidy, R. Appuswama, A. Andreopoulos, D. J. Berg, J. L. McKinstry, T. Melano, D. R. Barch, C. d. Nolfo, P. Datta, A. Amir, B. Taba, M. D. Flickner, D. S. Modha, Convolutional networks for fast energy-efficient neuromorphic computing, Proceedings of the National Academy of Sciences of USA 113 (41) (2016) 11441–11446.
  • [23] S. B. Shrestha, G. Orchard, Slayer: Spike layer error reassignment in time, in: Advances in Neural Information Processing Systems, 2018, pp. 1412–1421.
  • [24] F. Zenke, S. Ganguli, Superspike: Supervised learning in multilayer spiking neural networks, Neural computation 30 (6) (2018) 1514–1541.
  • [25]

    G. Bellec, D. Salaj, A. Subramoney, R. Legenstein, W. Maass, Long short-term memory and learning-to-learn in networks of spiking neurons, in: Advances in Neural Information Processing Systems, 2018, pp. 787–797.

  • [26]

    Y. Cao, Y. Chen, D. Khosla, Spiking deep convolutional neural networks for energy-efficient object recognition, International Journal of Computer Vision 113 (1) (2015) 54–66.

  • [27]

    P. U. Diehl, G. Zarrella, A. Cassidy, B. U. Pedroni, E. Neftci, Conversion of artificial recurrent neural networks to spiking neural networks for low-power neuromorphic hardware, in: 2016 IEEE International Conference on Rebooting Computing (ICRC), IEEE, 2016, pp. 1–8.

  • [28] A. Sengupta, Y. Ye, R. Wang, C. Liu, K. Roy, Going deeper in spiking neural networks: Vgg and residual architectures, Frontiers in neuroscience 13 (2019) 95.
  • [29] B. Rueckauer, I.-A. Lungu, Y. Hu, M. Pfeiffer, S.-C. Liu, Conversion of continuous-valued deep networks to efficient event-driven networks for image classification, Frontiers in neuroscience 11 (2017) 682.
  • [30] B. Rueckauer, S.-C. Liu, Conversion of analog to spiking neural networks using sparse temporal coding, in: 2018 IEEE International Symposium on Circuits and Systems (ISCAS), IEEE, 2018, pp. 1–5.
  • [31]

    Y. Wu, L. Deng, G. Li, J. Zhu, Y. Xie, L. Shi, Direct training for spiking neural networks: Faster, larger, better, in: Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 33, 2019, pp. 1311–1318.

  • [32] C. Lee, S. S. Sarwar, K. Roy, Enabling spike-based backpropagation in state-of-the-art deep neural network architectures, arXiv (2019) 1903.06379.
  • [33] J. C. Thiele, O. Bichler, A. Dupret, Spikegrad: An ann-equivalent computation model for implementing backpropagation with spikes, arXiv (2019) 1906.00851.