<figure><img src="image_1.png" /></figure>

HAL
open science

# STDP-Trained Spiking Neural Network Reliability Assessment Through Fault Injections

Zalfa Jouni, Haralampos-G. Stratigopoulos

► To cite this version:

Zalfa Jouni, Haralampos-G. Stratigopoulos. STDP-Trained Spiking Neural Network Reliability Assessment Through Fault Injections. 31st IEEE International Symposium on On-Line Testing and Robust System Design, Jul 2025, Ischia, Italy. hal-05083335

HAL Id: hal-05083335

https://hal.science/hal-05083335v1

Submitted on 24 May 2025

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_2.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
# STDP-Trained Spiking Neural Network Reliability Assessment Through Fault Injections

Zalfa Jouni and Haralampos-G. Stratigopoulos

Sorbonne Université, CNRS, LIP6, Paris, France

***Abstract***—Spiking Neural Networks (SNNs) offer a promising computing paradigm suitable for low-power artificial intelligence. Spike-Timing Dependent Plasticity (STDP) is an unsupervised, biologically-inspired learning rule for SNNs. This work studies the reliability of STDP-trained SNNs under hardware faults which is largely unexplored. We present a thorough fault injection analysis of an STDP-trained SNN designed in Brian 2 simulator for MNIST classification. The analysis introduces faults in neurons and synapses before, during, and after training. We consider both permanent and transient, as well as single and multiple faults. We identify cases where the SNN exhibits inherent fault tolerance, cases where it adapts to faults through training, and cases where fault tolerance mechanisms are required.

***Index Terms***—Neuromorphic computing, spiking neural networks, STDP, fault injection analysis, reliability.

## I. INTRODUCTION

Spiking Neural Networks (SNNs) offer a promising alternative computing paradigm for artificial intelligence. In contrast to traditional Artificial Neural Networks (ANNs), SNNs enable lower power consumption and faster inference, making them particularly well-suited for edge computing applications [1]. These advantages stem from their closer resemblance to the biological brain. By encoding information in spike rates or timing and relying on asynchronous, event-driven (spike-based) processing and inherently sparse neuron activity, SNNs minimize unnecessary computation and access to weight memory.

One of the main challenges to implement SNNs is the development of efficient and accurate learning techniques due to the non-differentiability of spikes and the dependence of spikes on past inputs [2]. Main training approaches include gradient-based backpropagation adaptations [3]–[6] and ANN-to-SNN conversion [7]. Backpropagation uses surrogate gradients to approximate the derivative of the spike threshold, while ANN-to-SNN conversion trains an ANN and transfers its weights to an equivalent SNN. In addition, Spike-Timing Dependent Plasticity (STDP) [8] stands as a well-known, biologically plausible rule that adjusts synaptic strength based on the timing of pre-synaptic and post-synaptic spikes. Prior studies show that STDP proves effective for on-chip unsupervised learning [9]. For example, Intel’s Loihi neuromorphic processor has on-chip learning rules that allow local, unsupervised learning using STDP-based synaptic updates [10].

The design of efficient SNN hardware accelerators remains an intense research field [10]–[12]. Many assume that SNNs inherit the fault tolerance of the human brain. Indeed, biological neural networks regenerate, rewire, or adapt network elements to compensate for damage, a facet of neuroplasticity [13]. However, this ability of neuroplasticity is not inherent in hardware implementations. Recent fault injection studies at the software-level [14]–[22] and on actual hardware [23] disprove this assumption, demonstrating that hardware failures can impact the inference accuracy. Recently, fault injection frameworks for SNNs [24], [25] have emerged, enabling this analysis. The results show that most hardware-level faults prove benign, either exerting no local effect or becoming masked as information propagates through the network, while some faults prove critical and produce errors at the output. Different training algorithms exhibit varying levels of resilience to hardware failures [16]. Additionally, fault-aware training, which involves injecting faults during training to improve a network’s fault tolerance, is effective only for specific types of faults [17]. On the other hand, in the case of on-chip learning, the effect of hardware-level faults has not been explored for SNNs. For deep learning accelerator systems, the idea that hardware failures can be bypassed during training has been recently challenged [26].

Fault injection experiments are crucial not only for assessing the resilience of the application to hardware failures, but also for validating the fault coverage of test techniques [18], [27]–[32], for identifying critical fault types and locations to develop cost-effective fault tolerance techniques [14], [17], [21], [33]–[37], as well as for post-manufacturing tuning [38].

A key element of fault injection experiments is the fault model employed. In [39], a transistor-level simulation of a spiking neuron circuit was conducted, accounting for short and open defects as well as process variations, to identify all potential behavioral fault types in neurons. Observed behaviors include saturated neurons (continuous spiking without excitatory input), dead neurons (no spiking despite excitatory input), and spike timing variations (changes in time-to-first-spike and firing rate). The literature on SNN testing and reliability [40] employs this neuron fault model, while for synapse faults, common fault models include weight perturbation, weight zeroing (representing synapse disabling or equivalently dead synapse), weight saturation to extreme values, and bit-flips in synaptic weights stored as digital words.

The vast majority of previous fault injection studies in SNNs considered convolutional and fully-connected SNNs

<footnote>This work was funded by the ANR RE-TRUSTING project under Grant N° ANR-21-CE24-0015-03 and by the European Network of Excellence dAIEDGE under Grant Agreement N° 101120726.</footnote>
trained with gradient-based backpropagation. Fault injection in a STDP-trained SNN has been explored in [15], [41]–[43], consistently using the MNIST dataset as a case study. In [41], the SNN architecture is a 2-layer network using memristors to implement synapses and neurons. The fault injection study examines the impact of memristor variations in both learning and inference phases. In [15], the SNN architecture is a 2-layer network using a memristor crossbar to implement the synaptic connections between two layers. Although a comprehensive fault model was proposed, fault injection experiments considered only dead neurons and dead synapses and random fault injection over many trials. Faults are introduced before training and after training. The work in [43] extends this analysis by briefly comparing the fault tolerance of the same SNN trained with different algorithms, including STDP. In [42], synapse bit-flips are investigated as a fault model, briefly reporting two experiments that demonstrate: (a) an STDP-trained SNN exhibits greater fault tolerance than a multi-layer perceptron (MLP) with the same topology, and (b) among different training algorithms, STDP maximizes fault tolerance.

In this paper, we conduct a comprehensive fault injection analysis on an STDP-trained SNN using the MNIST dataset providing new insights. Building on prior work [15], [41]–[43], we expand the scope by examining all major fault models, including dead neurons, saturated neurons, and synaptic weight perturbations via bit-flips. Notably, while saturated neuron faults are known to be the most detrimental for SNNs trained with backpropagation [17], this is the first study to investigate their impact on an STDP-trained SNN. Additionally, we explore both single and multiple faults, transient and permanent faults, and fault injection at different stages—before, during, and after training. The SNN follows a biologically inspired design with excitatory and inhibitory layers, Leaky Integrate & Fire (LIF) neurons, and conductance-based synapses. The fault injection framework operates at behavioral-level for hardware independence and runs on a GPU using Python and the Brian 2 simulator [44].

The rest of the paper is structured as follows. Section II describes the SNN architecture and the STDP algorithm used in this work. Section III details the fault injection setup, followed by the experimental results in Section IV. Finally, conclusions are drawn in Section V.

## II. FROM SPIKING DYNAMICS TO PLASTICITY: AN STDP-TRAINED SNN

### A. Spiking neural network architecture

The network processes input from the MNIST dataset, which consists of 60,000 training and 10,000 test images of handwritten digits (0–9) at a resolution of 28 × 28 pixels [46]. Pixel intensities are converted into Poisson-distributed spike trains and fed into the network’s first layer. Fig. 1 illustrates the SNN architecture [45], consisting of three layers of spiking neurons. The first layer has 784 input neurons (one per pixel), and these neurons are fully-connected, via excitatory synapses, to a second layer of 400 excitatory neurons.

<figure><img src="image_3.png" /><figcaption>Fig. 1: SNN architecture for STDP learning [45], featuring a 28x28 MNIST input layer, excitatory and inhibitory neuron layers, and a winner-take-all output mechanism from labeled excitatory groups.</figcaption></figure>

Each excitatory neuron in the second layer is paired one-to-one with an inhibitory neuron via excitatory synapses. When an excitatory neuron fires, it increases the likelihood that its paired inhibitory neuron is activated, which then inhibits all other excitatory neurons (except its paired one). This design implements a soft winner-take-all mechanism: when one excitatory neuron fires, it temporarily suppresses the activity of the others.

The neuron in this architecture follows the LIF model, chosen for its biomimetic and simple behavior. Its membrane potential, $V_m$, evolves according to:

$$ \tau_m \frac{dV_m}{dt} = (E_{rest} - V_m) + g_e (E_{exc} - V_m) + g_i (E_{inh} - V_m), \quad (1) $$

where $\tau_m$ is the time constant of the membrane potential, $E_{rest}$ is the resting membrane potential, $E_{exc}$ ($> 0$) and $E_{inh}$ ($< 0$) are the excitatory and inhibitory equilibrium potentials of synapses, respectively, and $g_e$ and $g_i$ are the excitatory and inhibitory synaptic conductances, respectively. When the neuron receives an excitatory input, $g_e$ increases, which raises $V_m$ and makes it more likely to fire. In contrast, an inhibitory input boosts $g_i$, lowering $V_m$ and reducing the chance of a spike. Once $V_m$ exceeds the threshold $v_{thres}$, the neuron fires and its membrane potential resets to $E_{rest}$. For a short refractory period thereafter, the neuron cannot fire again.

The synapse in this architecture follows a biological plausible conductance-based model. In this model, when a spike occurs, the synaptic conductance is immediately increased by an amount equal to the synaptic weight, $w_{syn}$. In the absence of spikes, the conductance decays exponentially over time. For both excitatory ($k = e$) and inhibitory ($k = i$) synapses, the dynamics are described by:

$$ g_k \rightarrow g_k + w_{syn,k} \quad (\text{upon spike}) \quad (2) $$

$$ \frac{dg_k}{dt} = -\frac{g_k}{\tau_{g_k}}, \quad (3) $$

where $k \in \{e, i\}$ and $\tau_{g_k}$ is the time constant of a synaptic potential, noting that $\tau_{g_e} < \tau_{g_i}$.

### B. STDP learning technique

Most state-of-the-art learning approaches, such as backpropagation, rely on labeled data. By contrast, unsupervised
<figure><img src="image_4.png" /><figcaption>Fig. 2: STDP mechanism in a conductance-based synapse: (a) biological schematic of spiking neurons connected via synapses, (b) neuron model receiving three weighted inputs, (c) temporal representation of pre- and post-synaptic spikes, where $\Delta T$ is the spike timing difference, (d) STDP curve for weight update, (e) the time evolution of pre- and post-synaptic voltages ($V_{pre}$ and $V_{post}$) and the resulting weight update ($w_{syn}$). Figure updated from [47].</figcaption></figure>

learning autonomously discovers patterns in unlabeled data. Following [45], the learning process here is divided into two phases: training and labeling. During training, the network self-organizes without any supervision or reinforcement. It relies on a biologically plausible STDP rule, as shown in Fig. 2, which adjusts synaptic weights based on pre- and post-synaptic spike timing. If a pre-synaptic neuron spikes shortly before a post-synaptic neuron, the randomly initialized weight is strengthened; otherwise, it is weakened. Only the input-excitatory synapses are updated by STDP, while the synapses responsible for lateral inhibition remain constant. The STDP curve in Fig. 2 illustrates synaptic weight $w_{syn}$ updates, determined by the difference between pre-synaptic $t_{pre}$ and post-synaptic $t_{post}$ spike times, as follows:

$$w_{syn}(\Delta t) = \begin{cases} A^{+} \exp(-\frac{\Delta t}{\tau^{+}}) & \text{if } \Delta t > 0 \\ -A^{-} \exp(-\frac{\Delta t}{\tau^{-}}) & \text{if } \Delta t < 0 \end{cases}, \Delta t = t_{post} - t_{pre} \quad (4)$$

Throughout training, the input inhomogeneity and lateral inhibition often unbalance firing rates among excitatory neurons. To avoid dominance by any single neuron, each neuron's threshold is defined as $v_{thres} + \theta$, where $\theta$ increases after each spike and decays exponentially. As a result, frequently firing neurons become harder to excite, helping balance their overall firing rates.

After training, the network enters a labeling phase in which meaningful labels are assigned to the excitatory-layer neurons. During this phase, a subset of the training inputs is presented again, and the firing activity of each neuron is monitored to determine which input class most frequently triggers it. Based on this information, the excitatory neurons are partitioned into 10 labeled groups, each corresponding to a digit (0-9) as

illustrated in Fig. 1. During testing, new inputs are applied to the network, and the firing rates of neurons within each labeled group are summed. The group with the highest total activity is then selected as the network's predicted digit.

### III. FAULT INJECTION SETUP

#### A. SNN case study and training framework

The fault injection experiment is conducted on the STDP-trained SNN using the MNIST dataset, described in Section II. For the purpose of the experiment, we utilize the open-source, Python-based Brian 2 simulator for SNNs [44], leveraging GPU acceleration. Although it may require longer simulation times compared to other frameworks, such as Lava [48], the Intel's open-source framework for neuromorphic computing on Loihi, it provides greater flexibility and user-friendly tools for building custom SNN model architectures, training algorithms, and neuron/synapse models. The baseline classification accuracy for the fault-free network is 90.7%.

#### B. Fault model

We employ the most commonly used fault model for SNNs. For neurons, this includes worst-case faulty behaviors, namely dead and saturated neurons, which could result from hard faults, such as short and open defects. We do not report results for spike timing variation faults that could result from process variations, for example affecting the neuron's threshold or time constants, as spike timing variations prove to have no impact on the classification accuracy. For synapses, we consider the more realistic hardware-aware fault model that takes into consideration that synapses are stored as digital words in an on-chip memory. We treat the SNN as a distributed system, where neurons can fail independently. However, for synapses we assume that the memory can suffer a Bit Error Rate (BER), thus many synapses can be affected simultaneously. More specifically, the faults are implemented in Brian 2 as follows:

1. **Dead neuron:** A fault in the neuron that leads to zero-spike output under any input condition. For the excitatory and inhibitory neurons, this fault is modeled by setting the adaptive threshold $\theta$ at a high value, preventing the membrane potential from exceeding $v_{thres} + \theta$. For the input neurons, we set their outputs to zero regardless the pixel intensity.

2. **Saturated neuron:** A fault in the neuron that causes continuous firing under any input condition. For the excitatory and inhibitory neurons, this fault is modeled by setting the adaptive threshold $\theta$ at a very low negative value, ensuring that the membrane potential always exceeds $v_{thres} + \theta$. For the input neurons, we set their firing rate to maximum, i.e., they generate a spike at every time-step regardless the pixel intensity.

3. **Synapse weight perturbation:** We consider bit flips arising from radiation, voltage and temperature fluctuations, etc., affecting the memory that stores the synaptic weights. The Python-modeled real synaptic weights are first converted into an 8-bit representation. A BER probability determines the bit-flipping process, leading
to a multi-bit fault scenario with a uniformly random distribution. The altered bit representation is then converted back into real-valued weights.

### C. Fault injection scenarios

We consider the following fault injection scenarios grouped under three categories. For each scenario, in Section IV, we will report the classification accuracy relative to the fault-free baseline.

1) *Faults occurring after training:* STDP learning is conducted on a fault-free network, but permanent faults may arise over the hardware's lifetime, potentially impacting inference. This scenario is analogous to training the SNN in software and then deploying it onto faulty hardware. We consider three scenarios:

a) *Scenario 1a:* Single and multiple dead neuron faults.

b) *Scenario 1b:* Single saturated neuron faults. We do not consider multiple saturated faults since, as we will see, even a single saturated neuron fault drastically affects the classification accuracy.

c) *Scenario 1c:* Synapse weight perturbation faults considering different BER probabilities.

The objective is to categorize different fault types and locations as either benign or critical, and study the classification drop as a function of fault density for neurons and BER for synapses.

2) *Faults occurring prior to training:* STDP learning is conducted on-chip on a faulty network, which may impact training quality. These faults remain present during training, labeling, and inference. We consider two scenarios:

a) *Scenario 2a:* Single and multiple dead neuron faults.

b) *Scenario 2b:* Single and multiple saturated neuron faults.

The goal here is to assess whether biologically inspired STDP learning can adapt to faulty hardware, demonstrating inherent robustness. Note that synapse faults in this category are irrelevant since they are overwritten during training.

3) *Transient faults occurring during training:* Here, we assume that learning takes place on-chip and bit-flips affect synapse weights during the process.

a) *Scenario 3a:* At the end of every epoch of the training process, the memory storing the synapses undergoes a specific BER. We consider different BER probabilities.

The aim is to determine whether learning can still succeed despite transient faults. Bit-flips are regarded as transient since weights may be updated throughout the training process.

## IV. FAULT INJECTION RESULTS

Herein, we present the results for the fault injection scenarios defined in Section III-C.

### 1) *Faults occurring after training:*

a) *Scenario 1a:* We consider randomly distributed dead neuron faults across the three layers of the SNN. Fig. 3 illustrates the accuracy obtained for 6 faulty networks, each with an increasing number of faults, ranging from a single fault (0.08% of neurons) to 40% of neurons being faulty. The

<figure><img src="image_5.png" /><figcaption>Fig. 3: Accuracy for varying percentages of randomly selected dead neurons occurring after training (left), and the distribution of these faults across excitatory, inhibitory, and input layers (right).</figcaption></figure>

results show that classification accuracy remains largely stable around the baseline of 90.7%, even with fault densities as high as 10%, a value which may be considered unrealistic. For less than 10% dead neurons we observe minor fluctuations and we notice that the network can in fact benefit from disabling some neurons. Additionally, neither the proportion of dead neurons within a specific layer nor their exact locations within the layer seem to play a role. For the extreme fault density of 40% the accuracy drops only by 8%.

b) *Scenario 1b:* Fig. 4 presents the accuracy when a single saturated neuron is introduced at a random location within each layer. As it can be seen, the accuracy drop varies with the neuron location within the layer, but as a general observation it is significant for all neurons and appears to be more pronounced for the inhibitory layer.

Specifically for the inhibitory layer, the accuracy drops to around 10%. The reason that the inhibitory layer is more critical stems from the role of inhibitory neurons in the network. When an excitatory neuron spikes, its corresponding inhibitory neuron suppresses all other excitatory neurons, ensuring a soft winner-takes-all mechanism. This mechanism helps in selecting the most active excitatory neuron while maintaining a well-balanced network. However, if an inhibitory neuron becomes permanently saturated, throughout the inference process it continuously suppresses all excitatory neurons except the one link to it. As a result, the other excitatory neurons are unable to spike or contribute to decision-making. This forces the network regardless of the input image to always select as the winner the same group of excitatory neurons (the one that contains the excitatory neuron linked to the saturated inhibitory neuron), where each group corresponds to a specific class. Therefore, given that the dataset has an equal number of images per class and consists of 10 classes, if the same class consistently dominates, the accuracy drops to around 10% (the overall average accuracy of the fault-free network is 90.7% but the accuracy varies across classes).

In the excitatory layer, after the training and labeling phases in STDP learning, each excitatory neuron is assigned to one of 10 possible groups, each corresponding to one class, where the number of neurons per group may vary. The classification decision is based on the spike count across neurons within a group, with the group exhibiting the highest spiking activ-
<figure><img src="image_6.png" /><figcaption>Fig. 4: Accuracy for a single saturated neuron occurring after training at various locations in the (a) input, (b) excitatory, and (c) inhibitory layers.</figcaption></figure>

<figure><img src="image_7.png" /><figcaption>Fig. 5: Accuracy drop plotted against the neuron group size for each class. Each circle represents one experiment with a single saturated neuron in the given group occurring after training.</figcaption></figure>

ity determining the predicted class. If an excitatory neuron becomes permanently saturated during inference, it increases its group's overall spiking activity, but this does not necessarily guarantee that the group will win the competition. Consequently, saturated neurons in the excitatory layer are less critical than those in the inhibitory layer.

Fig. 5 illustrates the relationship between accuracy and the

<figure><img src="image_8.png" /><figcaption>Fig. 6: Accuracy as a function of BER probability in synaptic weights, introduced after training. The markers represent the mean of accuracy, with error bars indicating the range of accuracy variations.</figcaption></figure>

<figure><img src="image_9.png" /><figcaption>Fig. 7: Accuracy as a function of percentage of randomly distributed dead neurons introduced before the training process begins.</figcaption></figure>

size of the labeled group containing the saturated neuron. In this experiment, a single random neuron within a group was made faulty. The results indicate that the accuracy drop is highly dependent on the size of the labeled group where the saturation occurs. When the affected excitatory neuron belongs to a larger group (e.g., 55 neurons), the accuracy drop remains relatively small (less than 15%). However, if the neuron is part of a smaller group (e.g., 30 neurons), the accuracy drop is significantly more pronounced (around 40%). Overall, the larger the labeled group, the less impact a single saturated neuron in this group has on the accuracy of the network.

We did not extend our analysis to multiple saturated neuron faults, as we did for dead neurons, since even a single saturated fault in any layer already results in a significant accuracy drop.

c) *Scenario 1c:* Fig. 6 presents the accuracy as a function of BER probability in weights. For each BER probability, 100 experiments were conducted, and the average, minimum, and maximum accuracy are reported. When the BER is below $10^{-2}$, a relatively high and likely unrealistic value, the accuracy remains close to the baseline and can even improve by up to 4%, effectively discovering a “better” network. However, for BER values exceeding $10^{-2}$, accuracy declines rapidly, essentially leading to the network becoming untrained.

## 2) *Faults occurring prior to training:*

a) *Scenario 2a:* Fig. 7 illustrates the post-training accuracy as a function of the percentage of dead neurons randomly distributed across the network layers, ranging from 0.08% (single neuron) to 40%. The results show that the network maintains a relatively high accuracy, experiencing only a minor
<figure><img src="image_10.png" /><figcaption>Fig. 8: Impact of a single saturated neuron occurring prior to training. The x-axis shows the neuron index in the input (green), excitatory (blue), and inhibitory (orange) layers.</figcaption></figure>

accuracy drop of less than 5%, when up to 10% of the neurons are dead. Beyond this percentage, accuracy declines sharply, dropping to approximately 10% for 40% dead neurons. This trend indicates that as the density of dead neurons rises and more neurons become inactive, the effective size of the network decreases, making it increasingly difficult for the network to learn the task. Comparing Fig. 7 to Fig. 3, we observe that a cluster of dead neurons has a significantly greater impact if it occurs already from training rather than after the network has already been trained. This is because if several neurons become dead during the lifetime of the chip, their group size is reduced, but the remaining healthy neurons can still carry out the task.

b) *Scenario 2b:* Fig. 8 presents the results of a single saturated neuron fault occurring in either the input, excitatory, or inhibitory layer. To assess the impact of fault location, the saturated neuron is chosen from four evenly spaced neurons within each layer. As shown, neuron saturation in the input layer has no effect on classification accuracy. In the excitatory layer, accuracy can decline by up to 10%, whereas in the inhibitory layer, it is completely compromised reducing from the baseline value by 83%. This occurs because a saturated neuron in the inhibitory layer suppresses excitatory activity in all neurons in the excitatory layer except the one that connects to it. Consequently, the training process will fail entirely. Comparing Fig. 8 with Fig. 4, we observe that the network can fully adapt to saturated faults in the input layer and partially adapt to those in the excitatory layer.

Fig. 9 displays the confusion matrix when 1% of neurons, randomly chosen in the input and excitatory layers, are saturated. The accuracy drops significantly to 19.28%, with most inputs being predominantly misclassified as digit 8. Thus, while the network can adapt effectively to a single saturated neuron fault, the training fails when multiple faults are present.

3) *Transient faults occurring during training:*

a) *Scenario 3a:* Fig. 10 shows the accuracy when transient bit-flips occur at 30%, 60%, and 90% of the training process, with varying BERs. In all cases, even for an extremely high BER of $10^{-1}$, the learning successfully completes, achieving an accuracy very close to the baseline. Moreover, we observe that the earlier the transient faults occur, the higher

<figure><img src="image_11.png" /><figcaption>Fig. 9: Confusion matrix considering 1% saturated neuron faults exclusively in the input and excitatory layers occurring before training begins.</figcaption></figure>

<figure><img src="image_12.png" /><figcaption>Fig. 10: Accuracy as a function of the synaptic weight BER probability, with bit flips introduced during training at 30%, 60%, and 90% of the process.</figcaption></figure>

the final accuracy, and the higher the BER the lower the accuracy is, although the accuracy discrepancies are small. This experiment shows that the network training can adapt to a high rate of multiple bit-flips occurring during the process.

V. CONCLUSION

We investigated the impact of dead and saturated neuron faults, as well as synapse weight variations, on an STDP-trained SNN for the MNIST dataset. This study considered various scenarios, including fault injection before, during, and after training, single and multiple faults, as well as permanent and transient faults. In comparison to previous studies [15], [41]–[43], this work is the first to examine the impact of saturated neuron faults, which has proven in our study to be by far the most lethal, a conclusion that has also been drawn for SNNs trained with backpropagation [17]. Our experiments demonstrated that dead neurons up to 5% or synaptic weights affected by a BER as high as $10^{-2}$ do not impact classification accuracy, and learning can compensate for them. In contrast, learning fails when saturated neurons are present in the excitatory and inhibitory layers, and accuracy is significantly affected if neurons become saturated during the chip's lifetime, with the last inhibitory layer being the most critical. These findings suggest that testing and fault tolerance strategies could focus exclusively on saturated neuron faults, thereby significantly reducing costs.
REFERENCES

[1] C. D. Schuman, S. R. Kulkarni, M. Parsa, J. P. Mitchell, P. Date, and B. Kay, "Opportunities for neuromorphic computing algorithms and applications," *Nat. Comput. Sci.*, vol. 2, no. 1, pp. 10–19, Jan. 2022.

[2] A. Tavanaei, M. Ghodrati, S. R. Kheradpisheh, T. Masquelier, and A. Maida, "Deep learning in spiking neural networks," *Neural Netw.*, vol. 111, pp. 47–63, 2019.

[3] S. M. Bohté, J. N. Kok, and H. La Poutré, "SpikeProp: backpropagation for networks of spiking neurons," in *Proc. Eur. Symp. Artif. Neural Netw. (ESANN)*, 2000, vol. 48, pp. 419–424.

[4] Y. Wu, L. Deng, G. Li, J. Zhu, and L. Shi, "Spatio-temporal backpropagation for training high-performance spiking neural networks," *Front. Neurosci.*, vol. 12, May 2018.

[5] S. B. Shrestha and G. Orchard, "SLAYER: Spike layer error reassignment in time," in *Proc. Adv. Neural Inf. Process. Syst. (NeurIPS)*, Dec. 2018, pp. 1479–1428.

[6] E. O. Neftci, H. Mostafa, and F. Zenke, "Surrogate gradient learning in spiking neural networks: Bringing the power of gradient-based optimization to spiking neural networks," *IEEE Signal Process. Mag.*, vol. 36, no. 6, pp. 51–63, Nov. 2019.

[7] A. Sengupta, Y. Ye, R. Wang, C. Liu, and K. Roy, "Going deeper in spiking neural networks: VGG and residual architectures," *Front. Neurosci.*, vol. 13, Mar. 2019.

[8] H. Markram, W. Gerstner, and P. J. Sjöström, "Spike-timing-dependent plasticity: A comprehensive overview," *Front. Synaptic Neurosci.*, vol. 4, Jul. 2012.

[9] C. D. Schuman et al., "A survey of neuromorphic computing and neural networks in hardware," *arXiv:1705.06963*, 2017.

[10] G. Orchard et al., "Efficient neuromorphic signal processing with Loihi 2," in *IEEE Workshop Signal Process. Syst. (SiPS)*, Nov. 2021, pp. 254–259.

[11] A. Shrestha, H. Fang, Z. Mei, D. P. Rider, Q. Wu, and Q. Qiu, "A survey on neuromorphic computing: Models and hardware," *IEEE Circuits Syst. Mag.*, vol. 22, no. 2, May 2022.

[12] F. Akopyan et al., "TrueNorth: Design and tool flow of a 65 mW 1 million neuron programmable neurosynaptic chip," *IEEE Trans. Comput.-Aided Design Integr. Circuits Syst.*, vol. 34, no. 10, pp. 1537–1557, Oct. 2015.

[13] Moheb Costandi, *Neuroplasticity*, MIT Press, Cambridge, MA, USA, 2016.

[14] A. Hashmi, H. Berry, O. Temam, and M. Lipasti, "Automatic abstraction and fault tolerance in cortical microarchitectures," in *Proc. ACM/IEEE Annual Int. Symp. Comput. Archit. (ISCA)*, Jun. 2011, pp. 1–10.

[15] E. Vatajelu, G. Di Natale, and L. Anghel, "Special session: Reliability of hardware-implemented spiking neural networks (SNN)," in *Proc. IEEE VLSI Test Symp. (VTS)*, Apr. 2019.

[16] C. D. Schuman et al., "Resilience and robustness of spiking neural networks for neuromorphic systems," in *Proc. Int. Jt. Conf. Neural Netw. (IJCNN)*, Jul. 2020.

[17] T. Spyrou, S. A. El-Sayed, E. Afacan, L. A. Camuñas-Mesa, B. Linares-Barranco, and H.-G. Stratigopoulos, "Neuron fault tolerance in spiking neural networks," in *Proc. Design Autom. Test Europe Conf. (DATE)*, Feb. 2021, pp. 743–748.

[18] H.-Y. Tseng, I-W. Chiu, M.-T. Wu, and J. C.-M. Li, "Machine learning-based test pattern generation for neuromorphic chips," in *Proc. IEEE/ACM Int. Conf. Comput.-Aided Design (ICCAD)*, Nov. 2021.

[19] R. V. W. Putra, M. A. Hanif, and M. Shafique, "ReSpawn: Energy-efficient fault-tolerance for spiking neural networks considering unreliable memories," in *Proc. ACM/IEEE Int. Conf. Comput.-Aided Design (ICCAD)*, Nov. 2021.

[20] Y.-Z. Hsieh, H.-Y. Tseng, I. Chiu, and J. C. M. Li, "Fault modeling and testing of spiking neural network chips," in *Proc. IEEE Int. Test Conf. Asia (ITC-Asia)*, Aug. 2021.

[21] R. V. W. Putra, M. A. Hanif, and M. Shafique, "SoftSNN: Low-cost fault tolerance for spiking neural network accelerators under soft errors," in *Proc. 59th Design Autom. Conf. (DAC)*, Jul. 2022, p. 151–156.

[22] A. Siddique and K. A. Hoque, "Improving reliability of spiking neural networks through fault aware threshold voltage optimization," in *Proc. Design Autom. Test Europe Conf. (DATE)*, Apr. 2023.

[23] T. Spyrou, S. A. El-Sayed, E. Afacan, L. A. Camuñas-Mesa, B. Linares-Barranco, and H.-G. Stratigopoulos, "Reliability analysis of a spiking neural network hardware accelerator," in *Proc. Design Autom. Test Europe Conf. (DATE)*, Mar. 2022, pp. 370–375.

[24] A. B. Gogebakan, E. Magliano, A. Carpegna, A. Ruospo, A. Savino, and S. Di Carlo, "SpikingJET: Enhancing fault injection for fully and convolutional spiking neural networks," in *Proc. IEEE Int. Symp. On-Line Test. Robust Syst. Des. (IOLTS)*, Jul. 2024.

[25] T. Spyrou, S. Hamdioui, and H.-G. Stratigopoulos, "SpikeFI: A fault injection framework for spiking neural networks," *arXiv:2412.06795*, 2024.

[26] Y. He et al., "Understanding and mitigating hardware failures in deep learning training systems," in *Proc. 50th Annu. Int. Symp. Comput. Archit. (ISCA)*, Jun. 2023.

[27] S. A. El-Sayed, L. A. Camuñas-Mesa, B. Linares-Barranco, and H.-G. Stratigopoulos, "Self-testing analog spiking neuron circuit," in *Proc. Int. Conf. Synth. Model. Anal. Simulat. Methods Appl. Circuit Design (SMACD)*, Jul. 2019.

[28] I.-W. Chiu, X.-P. Chen, J. S.-I. Hu, and C.-M. J. Li, "Automatic test configuration and pattern generation (atcpg) for neuromorphic chips," in *Proc. IEEE/ACM Int. Conf. Comput.-Aided Design (ICCAD)*, Oct./Nov. 2022.

[29] S. A. El-Sayed, T. Spyrou, L. A. Camuñas-Mesa, and H.-G. Stratigopoulos, "Compact functional testing for neuromorphic computing circuits," *IEEE Trans. Comput.-Aided Design Integr. Circuits Syst.*, vol. 42, no. 7, pp. 2391–2403, 2023.

[30] T. Spyrou and H.-G. Stratigopoulos, "On-line testing of neuromorphic hardware," in *Proc. IEEE Eur. Test Symp. (ETS)*, May 2023.

[31] X.-P. Chen, H.-Y. Huang, C.-Y. Hsiao, J. S.-I. Hu, and C.-M. J. Li, "Test compression for neuromorphic chips," in *Proc. IEEE Eur. Test Symp. (ETS)*, May 2024.

[32] S. Raptis and H.-G. Stratigopoulos, "Minimum time maximum fault coverage testing of spiking neural networks," in *Proc. Design, Automat. Test Eur. Conf. Exhib. (DATE)*, Mar./Apr. 2025.

[33] S. Karim et al., "Assessing self-repair on FPGAs with biologically realistic astrocyte-neuron networks," in *Proc. IEEE Comput. Soc. Annu. Symp. VLSI (ISVLSI)*, Jul. 2017, pp. 421–426.

[34] A. P. Johnson et al., "Homeostatic fault tolerance in spiking neural networks: A dynamic hardware perspective," *IEEE Trans. Circuits Syst. I, Reg. Papers*, vol. 65, no. 2, pp. 687–699, 2018.

[35] J. Liu, J. Harkin, L. P. Maguire, L. J. McDaid, and J. J. Wade, "SPAN-NER: A self-repairing spiking neural network hardware architecture," *IEEE Trans. Neural Netw. Learn. Syst.*, vol. 29, no. 4, pp. 1287–1300, Apr. 2018.

[36] M. Isik, A. Paul, M. L. Varshika, and A. Das, "A design methodology for fault-tolerant computing using astrocyte neural networks," in *Proc. 19th ACM Int. Conf. Comput. Frontiers (CF)*, May 2022, p. 169–172.

[37] A. Saha, C. Amarnath, and A. Chatterjee, "A resilience framework for synapse weight errors and firing threshold perturbations in RRAM spiking neural networks," in *Proc. IEEE Eur. Test Symp. (ETS)*, May 2023.

[38] A. Saha, K. Ma, C. Amarnath, and A. Chatterjee, "Post-manufacture criticality-aware gain tuning of timing encoded spiking neural networks for yield recovery," in *Proc. IEEE Eur. Test Symp. (ETS)*, May 2024.

[39] S. A. El-Sayed, T. Spyrou, E. Afacan, L. A. Camuñas-Mesa, B. Linares-Barranco, and H.-G. Stratigopoulos, "Spiking neuron hardware-level fault modeling," in *Proc. IEEE Int. Symp. On-Line Test. Robust Syst. Des. (IOLTS)*, Jul. 2020.

[40] H. Stratigopoulos, T. Spyrou, and S. Raptis, "Testing and reliability of spiking neural networks: A review of the state-of-the-art," in *Proc. IEEE Int. Symp. Defect Fault Toler. VLSI Nanotechnol. Syst. (DFT)*, Oct. 2023.

[41] E. I. Vatajelu and L. Anghel, "Fully-connected single-layer STT-MTJ-based spiking neural network under process variability," in *Proc. IEEE Int. Symp. Nanoscale Architectures (NANOARCH)*, Jul. 2017, pp. 21–26.

[42] F. Pavanello et al., "Special session: Neuromorphic hardware design and reliability from traditional CMOS to emerging technologies," in *Proc. IEEE VLSI Test Symp. (VTS)*, Apr. 2023.

[43] A. Bosio et al., "Resiliency approaches in convolutional, photonic, and spiking neural networks," in *Proc. IEEE Lat. Am. Test Symp. (LATS)*, Apr. 2024.

[44] M. Stimberg, R. Brette, and D. FM Goodman, "Brian 2, an intuitive and efficient neural simulator," *eLife*, vol. 8, Oct. 2019.

[45] P. U. Diehl and M. Cook, "Unsupervised learning of digit recognition using spike-timing-dependent plasticity," *Front. Comput. Neurosci.*, vol. 9, Aug. 2015.

[46] Y. LeCun, C. Cortes, and C. J. Burges, "The MNIST database of handwritten digits," http://yann.lecun.com/exdb/mnist/, Online.
[47] P. Stoliar, H. Yamada, Y. Toyosaki, and A. Sawa, "Spike-shape dependence of the spike-timing dependent synaptic plasticity in ferroelectric-tunnel-junction synapses," *Sci. Rep.*, vol. 9, Nov. 2019.

[48] "Lava: An open-source framework for neuromorphic computing," https://lava-nc.org/, 2025.