Pith. sign in

REVIEW 2 major objections 5 minor 52 references

SpikeFI: A Fault Injection Framework for Spiking Neural Networks

T0 review · 2 major / 5 minor · reviewed 2026-08-12 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read SpikeFI automates fault-injection testing for spiking neural networks, mapping hardware faults onto neuron and synapse models so designers can find which faults actually break accuracy.

desk verdict Useful open-source SNN fault injector with sound feed-forward optimizations; recurrent-SNN claim overreaches because late-start/early-stop break under feedback. read the letter →

arxiv 2412.06795 v1 pith:YRRJ7IRF submitted 2024-11-22 cs.NE cs.AI

Theofilos Spyrou , Said Hamdioui , Haralampos-G. Stratigopoulos This is my paper · ORCID
classification cs.NEcs.AI
keywords spikingneuralnetworksfaultinjectionneuromorphiccomputingreliabilityanalysismodelsGPUaccelerationtestgenerationtolerance
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

SpikeFI is a software fault-injection framework that automates reliability analysis of spiking neural networks before committing to silicon. It turns hardware-level faults into behavioral fault models at the neuron and synapse level, expressed through the Spike Response Model, and lets the user inject single or multiple, permanent or transient faults at chosen, random layer-wise, or random network-wise locations, either before, during, or after training. The authors argue this matters because SNNs are being deployed on neuromorphic processors in safety- and mission-critical settings, where rare hardware faults can corrupt a correct cognitive decision. If SpikeFI works as claimed, designers can find which faults are critical, generate compact tests for them, and evaluate fault-aware training strategies without slow register-transfer-level simulation. The tool is open-source and was demonstrated on two convolutional SNNs benchmarked on N-MNIST and IBM DVS128 Gesture data.

What carries the argument

The central object is the behavioral fault model, a mathematical rewrite of a hardware fault expressed in the Spike Response Model (SRM), where a neuron's membrane potential is a sum of convolutions of spike trains with a synaptic kernel and a refractory kernel. The mechanism that makes SpikeFI work is a set of hook functions inserted into the forward pass: one type overwrites the output spike trains of faulty neurons, another creates a copy of a layer with altered SRM parameters ($\tau_s$, $\tau_{ref}$, $\theta$) and replaces faulty neurons' outputs, and a third rewrites synaptic weights before the pass and restores them after. Two speedup techniques carry the scalability: late start, which resumes each fault round from a recorded golden layer output just before the leftmost faulty layer, and early stop, which halts simulation when the rightmost faulty layer's output matches the golden output. The golden layer outputs are computed once per batch in a preparation stage.

What would settle it

Run the same fault set through SpikeFI and through a lower-level simulation of the same hardware, such as register-transfer or transistor level, or on a real neuromorphic chip under radiation or aging, and compare which faults are labeled critical; a substantial disagreement in the critical-versus-benign labeling would disprove the claim that the behavioral fault models support trustworthy reliability analysis.

Watch

Extended reading notes

Core claim

The central claim is that SpikeFI provides a complete, GPU-accelerated, open-source workflow for automated fault injection in SNNs, covering the full space of fault type, fault site, fault duration, and injection phase, with speedups and visualization. The framework builds on an existing spike-based backpropagation training framework and adds an extensible library of neuron and synapse fault models adopted from the literature: dead, saturated, stuck-at-x, integration, refractory, and threshold faults for neurons; dead, saturated, perturbed, and bit-flipped faults for synapses. Faults are injected by intercepting the forward computation with hook functions: hard neuron faults overwrite output spike trains, parametric neuron faults recompute dynamics on a copy of the layer with altered SRM parameters, and synapse faults modify weights before the forward pass and restore them afterward. The demonstrated results on two convolutional SNNs show layer-wise resilience patterns, parametric fault sensitivities, synapse heat maps, and a learning-in-the-presence-of-faults experiment in which the N-MNIST network tolerates up to about 100 random faults and degrades beyond that.

Load-bearing premise

The analysis is only as good as the built-in behavioral fault models: the paper assumes the fault types it adopts from the literature faithfully represent the faults that actually occur in neuromorphic hardware, such as memory bit flips and analog parameter drift, so if real faults behave differently, SpikeFI's criticality rankings could mislead.

Editorial extensions

If this is right

  • Designers can run exhaustive single-fault campaigns layer by layer and obtain critical-fault rankings for any SNN built in the supported training framework, with no modification to the model.
  • Parametric fault results show that shifting neuron thresholds or membrane time constants can be as damaging as outright neuron saturation, so these parameters become levers for reliability-aware design.
  • Training with injected faults is a workable mitigation: the N-MNIST SNN learns around up to about 100 random faults and then degrades, suggesting that re-training in the field is possible at the cost of bringing the network temporarily offline.
  • The speedup optimizations make full-network fault campaigns practical: about 190,000 fault rounds across two networks completed in about 3.5 days on one GPU, while early-stop tolerance above zero risks misclassifying critical faults as benign.
  • The tool's critical-versus-benign fault labeling feeds directly into test-pattern generation for post-manufacturing and online testing of neuromorphic chips.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If the behavioral fault models are representative, the reported output-layer vulnerabilities suggest that protecting or monitoring output-layer neurons is likely the highest-leverage point for hardware fault tolerance; the paper reports the data but does not draw this design rule.
  • The same golden-activation skipping idea behind late start and early stop could be ported to fault injection for conventional artificial neural networks, where layer outputs are deterministic and many injected faults are benign; that is an extension the paper leaves implicit.
  • The critical-versus-benign labels SpikeFI produces could serve as a reward signal for gradient-based search over input samples, automatically synthesizing test patterns that sensitize each critical fault and closing the loop between fault analysis and test generation.
  • Injecting SRM parameter faults during training could also act as a regularizer against threshold and time-constant drift in analog neuromorphic implementations, a use case not tested in the paper.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 5 minor

Summary. The paper presents SpikeFI, an open-source, GPU-accelerated fault injection framework for spiking neural networks built on SLAYER/PyTorch. The framework supports single and multiple faults, permanent and transient faults, specified/random layer-wise/network-wise fault sites, pre-/during/post-training injection, and several speedup optimizations (for-loop ordering, late start, early stop, batched inference) together with visualization utilities. The authors demonstrate the tool on two feed-forward convolutional SNNs for N-MNIST and DVS128 Gesture, reporting measured speedups and resilience analyses for neuron and synapse fault models. The central claim is that SpikeFI enables automated reliability analysis and test generation for arbitrary SNN models, including recurrent ones.

Significance. If the framework works as described, it is a useful community resource: it is one of the few openly available SNN fault injectors, it covers a broad space of fault models and injection scenarios, and it provides concrete speedup optimizations validated by runtime measurements. The demonstrations on standard neuromorphic benchmarks give quantitative evidence of the tool's usefulness, and the open-source release with demo networks supports reproducibility. The main caveat is that the speedup optimizations are only valid for acyclic feed-forward connectivity, while the paper also claims recurrent SNN support; this needs to be resolved before the tool can be used safely for recurrent networks.

major comments (2)
  1. [Sec. I, IV-A, IV-D2, IV-D3, V] The paper claims support for recurrent SNNs (Sec. I: "any SNN model, i.e., fully-connected, convolutional, or recurrent"; Sec. IV-A: "Any arbitrary SNN model"), but the late start and early stop optimizations are valid only for feed-forward acyclic networks. Late start (Sec. IV-D2) substitutes the golden output of layer l_left-1 and resumes simulation from l_left; this is correct only if no fault effect can propagate backward from later layers to earlier layers, which fails in recurrent topologies with feedback. Early stop (Sec. IV-D3) halts when the output of the rightmost faulty layer matches the golden output, again assuming no downstream feedback can later alter earlier-layer activity. Since the framework enables these optimizations by default (Algorithm 1: "By default, cmpn.run makes use of all available optimization options"), running SpikeFI on a recurrent network with default settings would silently produce incorrect fault classifications. All experiments in Sec. V are feed-forward convolutional networks, so the recurrent case is not exercised. This inconsistency is load-bearing for the central claim of arbitrary SNN support. The fix is either to disable these optimizations for recurrent topologies (ideally with an automatic topology check) or to restrict the support claim to feed-forward networks and clearly document that recurrent support requires disabling the optimizations.
  2. [Sec. V-B1 and Fig. 7] The text states that "the speedup increases exponentially with the number of fault rounds," but the measured data in Fig. 7 show a saturating increase (from about 9% to 24.9% and then leveling off), not exponential growth. The description should be corrected to "increases rapidly and then saturates" to match the reported measurements.
minor comments (5)
  1. [Sec. III] The sentence "adopts all widespread and conventional fault models in the literature" is broader than what is demonstrated; Table I lists a specific set of fault models. A more precise wording would be "adopts the fault models listed in Table I, which are commonly used in prior SNN reliability studies."
  2. [Sec. V-C1] In the paragraph analyzing saturated and dead neurons, "an input with class label corresponding to this neuron is always mislassified" contains a typo: "mislassified" should be "misclassified."
  3. [Sec. IV-D3] The definition of the early-stop metric as the elementwise 1-norm of B^l is fine, but the paper should clarify that the norm is taken over the flattened matrix entries, not over time or neuron dimensions separately; currently the notation is slightly ambiguous.
  4. [Algorithm 1] The method name "then inject" is unconventional and could be confused with a Python keyword; consider renaming it (e.g., "inject_new_round") for clarity, although this is a minor API naming issue.
  5. [Sec. V-C5] The learning-curve experiment injects faults before training and then retrains, which is a pre-training scenario, but the text calls it "training in the presence of faults" without distinguishing pre-training from during-training injection; a sentence clarifying which of the three injection phases is demonstrated would help.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the framework's measurements and fault-model definitions are externally grounded, not derived from their own outputs.

full rationale

SpikeFI is a systems and tooling paper. Its central claims are feature support, measured speedups, and measured accuracy drops under fault injection. No fitted parameter is renamed as a prediction: the speedup percentages in Figs. 7-10 are direct runtime measurements on fixed networks and datasets (N-MNIST, DVS128 Gesture), and the accuracy and resiliency curves in Figs. 11-15 are simulations of explicitly defined fault models. The fault models themselves are imported from the published literature and from prior transistor-level modeling rather than being defined by the framework's results, and the equations in Table I are explicit behavioral definitions, not fitted outputs. Self-citations are present, for example [10], [18], [21], and [48], but they support fault-model provenance and prior use cases; they do not supply the empirical content of the speedup or accuracy measurements. The acknowledged early-stop-tolerance caveat in Section IV-D3 is a limitation, not a circular step. The claim of recurrent support is not exercised by the feed-forward experiments and the late-start/early-stop optimizations are only demonstrated on feed-forward topologies; this is a correctness and scope risk, not a circularity, and it does not raise the circularity score.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

The framework introduces no new physical entities or fitted theory. Its operating assumptions are the standard SRM neuron model, literature-based fault models, independent processing elements, and deterministic inference.

free parameters (3)
  • Synapse saturation values = +10 and -10
    In Section V-C3, saturated synapse faults are instantiated with +10 and -10, described as extreme relative to the trained weight distribution; these are user-chosen demonstration values, not fitted to a hypothesis.
  • Bit-flip quantizer precision = 8-bit integer representation
    In Section V-C3, bit-flipped synapse faults assume an 8-bit integer data format; this is a user-selected hardware assumption for the case study.
  • Early stop tolerance = epsilon=0 for most experiments; epsilon=1 shown in Fig. 9
    The early-stop tolerance is a user-set parameter; the paper warns that nonzero tolerance can misclassify critical faults as benign.
assumptions (4)
  • domain assumption The Spike Response Model (SRM) with synaptic kernel e and refractory kernel as implemented in SLAYER faithfully describes the SNN behavior.
    Section II-B and IV-C use the SRM equations from SLAYER as the substrate for all fault effects; if SLAYER's dynamics differ from the target hardware, fault impact results would not transfer.
  • domain assumption The built-in neuron and synapse fault models, taken from the literature, cover the relevant hardware-level fault mechanisms.
    Section III states SpikeFI adopts 'all widespread and conventional fault models in the literature'; representativeness of these models is assumed, not derived.
  • domain assumption Each neuron and synapse fails independently according to the injected fault configuration.
    Section III paragraph 1 states 'we consider that the processing elements of the SNN are discrete entities that can fail independently'; no correlated-fault or common-cause modeling is included.
  • domain assumption The network inference is deterministic, so golden layer outputs recorded in the preparation stage remain valid during fault rounds.
    Section IV-D2 and IV-E1 rely on reusing precomputed golden outputs for late start and early stop; this requires dropout-free, deterministic inference.

how reviews work

0 comments
Cite this review

Pith. "Pith review of SpikeFI: A Fault Injection Framework for Spiking Neural Networks." pith.science (2026). https://pith.science/paper/YRRJ7IRF

@misc{pith2026241206795,
  author       = {Pith},
  title        = {Pith review of: SpikeFI: A Fault Injection Framework for Spiking Neural Networks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YRRJ7IRF}},
  note         = {Machine review of arXiv:2412.06795}
}
read the original abstract

Neuromorphic computing and spiking neural networks (SNNs) are gaining traction across various artificial intelligence (AI) tasks thanks to their potential for efficient energy usage and faster computation speed. This comparative advantage comes from mimicking the structure, function, and efficiency of the biological brain, which arguably is the most brilliant and green computing machine. As SNNs are eventually deployed on a hardware processor, the reliability of the application in light of hardware-level faults becomes a concern, especially for safety- and mission-critical applications. In this work, we propose SpikeFI, a fault injection framework for SNNs that can be used for automating the reliability analysis and test generation. SpikeFI is built upon the SLAYER PyTorch framework with fault injection experiments accelerated on a single or multiple GPUs. It has a comprehensive integrated neuron and synapse fault model library, in accordance to the literature in the domain, which is extendable by the user if needed. It supports: single and multiple faults; permanent and transient faults; specified, random layer-wise, and random network-wise fault locations; and pre-, during, and post-training fault injection. It also offers several optimization speedups and built-in functions for results visualization. SpikeFI is open-source and available for download via GitHub at https://github.com/SpikeFI.

Figures

Figures reproduced from arXiv: 2412.06795 by the authors.

Figure 1
Figure 1. shows a simulation of a neuron following the SRM. The neuron is receiving input from many neurons. The pre￾synaptic spike trains from 20 out of these neurons are shown in Fig. 1a. Fig. 1b shows the evolution of the neuron’s membrane potential and its output spike train. 0 20 40 60 80 100 120 140 160 Time t (ms) S1 S3 S5 S7 S9 S11 S13 S15 S2 S4 S6 S8 S10 S12 S14 Incoming spike trains from pre-synaptic neurons (a) Inp… view at source ↗
Figure 2
Figure 2. The organization of an FI campaign. jump directly into using SpikeFI. SpikeFI is offered as open￾source software and is available for download and to contribute via the GitHub platform: github.com/SpikeFI/. SpikeFI supports the following features and scenarios: 1) Flexible fault modeling scheme: SpikeFI has an integrated comprehensive library of predefined fault models to select from, as described in Section III. Fa… view at source ↗
Figure 3
Figure 3. FI implementation into SLAYER. the modification, SpikeFI makes use of PyTorch pre-hook and hook functions, i.e., a function called right before and right after the evaluation of a module, respectively. Let us first consider neuron hard faults in layer l. The fault function of the fault model returns the output of the faulty neurons and updates the output of layer l for these neurons while the rest of the neurons ret… view at source ↗
Figures from the paper (10 more)
Figure 4
Figure 4. Figure 4: Flowchart of a FI campaign in SpikeFI. AL f to assess if the faulty network changes the top-1 prediction of an input sample which contributes to accuracy loss. The user can define a misprediction tolerance value. If the accuracy drop is larger than this tolerance value…
Figure 5
Figure 5. Figure 5: N-MNIST SNN. as a FI campaign data object using the function cmpn.export and stored using the cmpn.save function. Depending on the preferred results visualization, the user can choose among a set of plotting functions, as it will be demonstrated in Section V-C. The FI …
Figure 7
Figure 7. Figure 7: Speedup and runtime when using fault rounds in the inner [PITH_FULL_IMAGE:figures/full_fig_p009_7.png]
Figure 8
Figure 8. Figure 8: Speedup using the late start and early stop optimizations. [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]
Figure 10
Figure 10. Figure 10: Speedup using batched inference. SC1 SC2 SC3 SF1 SF2 Layers 0 10 20 30 40 50 60 70 80 90 100 Faults (%) Dead. Satu. Dead. Satu. Dead. Satu. Dead. Satu. Dead. Satu. (a) N-MNIST SNN. SC1 SC2 SF1 SF2 Layers 0 10 20 30 40 50 60 70 80 90 100 Faults (%) Dead. Satu. Dead. Sa…
Figure 11
Figure 11. Figure 11: Resiliency analysis for dead and saturated neuron faults. [PITH_FULL_IMAGE:figures/full_fig_p011_11.png]
Figure 12
Figure 12. Figure 12: Resiliency analysis for neuron parametric faults. [PITH_FULL_IMAGE:figures/full_fig_p012_12.png]
Figure 13
Figure 13. Figure 13: Resiliency analysis for synapse faults in synapses connecting [PITH_FULL_IMAGE:figures/full_fig_p013_13.png]
Figure 14
Figure 14. Figure 14: Resiliency analysis for bit-flips in synapses connecting the last two layers for the N-MNIST SNN (top heat maps) and IBM DVS128 [PITH_FULL_IMAGE:figures/full_fig_p014_14.png]
Figure 15
Figure 15. Figure 15: Learning curves of the training of the N-MNIST SNN in the [PITH_FULL_IMAGE:figures/full_fig_p014_15.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

52 extracted references · 51 canonical work pages

  1. [1]

    Towards spike-based machine intelligence with neuromorphic computing,

    K. Roy, A. Jaiswal, and P. Panda, “Towards spike-based machine intelligence with neuromorphic computing,” Nature, vol. 575, no. 7784, pp. 607–617, Nov. 2019

    work page 2019

  2. [2]

    Opportunities for neuromorphic computing algorithms and applications,

    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

    work page 2022

  3. [3]

    The SpiNNaker Project,

    S. B. Furber, F. Galluppi, S. Temple, and L. A. Plana, “The SpiNNaker Project,” Proc. IEEE, vol. 102, no. 5, pp. 652–665, May 2014

    2014

  4. [4]

    A million spiking-neuron integrated circuit with a scalable communication network and interface,

    P. A. Merolla et al., “A million spiking-neuron integrated circuit with a scalable communication network and interface,” Science, vol. 345, no. 6197, pp. 668–673, Aug. 2014. 14 (a) Bit 0 (LSB). (b) Bit 1. (c) Bit 2. (d) Bit 3. (e) Bit 4. (f) Bit 5. (g) Bit 6. (h) Bit 7 (MSB). (i) Bit 0 (LSB). (j) Bit 1. (k) Bit 2. (l) Bit 3. (m) Bit 4. (n) Bit 5. (o) Bit ...

    work page 2014

  5. [5]

    Loihi: A neuromorphic manycore processor with on-chip learning,

    M. Davies et al. , “Loihi: A neuromorphic manycore processor with on-chip learning,” IEEE Micro , vol. 38, no. 1, pp. 82–99, Jan./Feb. 2018

    work page 2018

  6. [6]

    A wafer-scale neuromorphic hardware system for large-scale neural modeling,

    J. Schemmel, D. Br ¨uderle, A. Gr¨ubl, M. Hock, K. Meier, and S. Millner, “A wafer-scale neuromorphic hardware system for large-scale neural modeling,” in Proc. IEEE Int. Symp. Circuits Syst. (ISCAS) , May/Jun. 2010, pp. 1947–1950

    work page 2010

  7. [7]

    Neurogrid: A mixed-analog-digital multichip system for large-scale neural simulations,

    B. V . Benjamin et al. , “Neurogrid: A mixed-analog-digital multichip system for large-scale neural simulations,” Proc. IEEE, vol. 102, no. 5, pp. 699–716, Apr. 2014

    work page 2014

  8. [8]

    Machine learning-based test pattern generation for neuromorphic chips,

    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

    work page 2021

Show all 52 references
  1. [9]

    Automatic test configuration and pattern generation (atcpg) for neuromorphic chips,

    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

    2022

  2. [10]

    Compact functional testing for neuromorphic computing circuits,

    S. A. El-Sayed, T. Spyrou, L. A. Camu ˜nas-Mesa, and H.-G. Stratigopou- los, “Compact functional testing for neuromorphic computing circuits,” IEEE Trans. Comput.-Aided Design Integr. Circuits Syst., vol. 42, no. 7, pp. 2391–2403, Jul. 2023

    2023

  3. [11]

    On-line testing of neuromorphic hardware,

    T. Spyrou and H.-G. Stratigopoulos, “On-line testing of neuromorphic hardware,” in Proc. IEEE Eur. Test Symp. (ETS) , May 2023

    2023

  4. [12]

    Resilience and robustness of spiking neural networks for neuromorphic systems,

    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

    2020

  5. [13]

    Automatic abstraction and fault tolerance in cortical microachitectures,

    A. Hashmi, H. Berry, O. Temam, and M. Lipasti, “Automatic abstraction and fault tolerance in cortical microachitectures,” in Proc. ACM/IEEE Annual Int. Symp. Comput. Archit. (ISCA) , Jun. 2011, pp. 1–10

    2011

  6. [14]

    Assessing self-repair on FPGAs with biologically realistic astrocyte-neuron networks,

    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

    2017

  7. [15]

    Homeostatic fault tolerance in spiking neural networks: A dynamic hardware perspective,

    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

    2018

  8. [16]

    SPAN- NER: A self-repairing spiking neural network hardware architecture,

    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

    2018

  9. [17]

    Self-testing analog spiking neuron circuit,

    S. A. El-Sayed, L. A. Camu ˜nas-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. 15

    2019

  10. [18]

    Neuron fault tolerance in spiking neural networks,

    T. Spyrou, S. A. El-Sayed, E. Afacan, L. A. Camu ˜nas-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

    2021

  11. [19]

    SoftSNN: Low-cost fault tolerance for spiking neural network accelerators under soft errors,

    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

    2022

  12. [20]

    A resilience framework for synapse weight errors and firing threshold perturbations in RRAM spiking neural networks,

    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

    2023

  13. [21]

    Reliability analysis of a spiking neural network hardware accelerator,

    T. Spyrou, S. A. El-Sayed, E. Afacan, L. A. Camu ˜nas-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

    2022

  14. [22]

    Special session: Reliability of hardware-implemented spiking neural networks (SNN),

    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

    2019

  15. [23]

    SpikingJET: Enhancing fault injection for fully and convolutional spiking neural networks,

    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

    2024

  16. [24]

    Training spiking neural networks using lessons from deep learning,

    J. K. Eshraghian et al., “Training spiking neural networks using lessons from deep learning,” Proc. IEEE, vol. 111, no. 9, pp. 1016–1054, Sep. 2023

    2023

  17. [25]

    SLAYER: Spike layer error reassign- ment in time,

    S. B. Shrestha and G. Orchard, “SLAYER: Spike layer error reassign- ment in time,” in Proc. Adv. Neural Inf. Process. Syst. (NeurIPS) , Dec. 2018, pp. 1412–1421

    2018

  18. [26]

    Understanding error propagation in deep learning neural network (DNN) accelerators and applications,

    G. Li et al., “Understanding error propagation in deep learning neural network (DNN) accelerators and applications,” in Proc. Int. Conf. High Perform. Comput., Netw., Storage Anal. (SC) , Nov. 2017

    2017

  19. [27]

    Ares: A framework for quantifying the resilience of deep neural networks,

    B. Reagen et al., “Ares: A framework for quantifying the resilience of deep neural networks,” in Proc. 55th ACM/ESDA/IEEE Design Autom. Conf. (DAC), Jun. 2018

    2018

  20. [28]

    PyTorchFI: A runtime perturbation tool for DNNs,

    A. Mahmoud et al. , “PyTorchFI: A runtime perturbation tool for DNNs,” in Proc. 50th Annu. IEEE/IFIP Int. Conf. Dependable Syst. Netw. Workshops (DSN-W), Jun./Jul. 2020, pp. 25–31

    2020

  21. [29]

    TensorFI: A flexible fault injection framework for tensor- flow applications,

    Z. Chen, N. Narayanan, B. Fang, G. Li, K. Pattabiraman, and N. De- Bardeleben, “TensorFI: A flexible fault injection framework for tensor- flow applications,” in Proc. IEEE Int. Symp. Softw. Rel. Eng. (ISSRE) , Oct. 2020, pp. 426–435

    2020

  22. [30]

    Fault injection for TensorFlow applications,

    N. Narayanan, Z. Chen, B. Fang, G. Li, K. Pattabiraman, and N. De- Bardeleben, “Fault injection for TensorFlow applications,” IEEE Trans. Dependable Secure Comput. , vol. 20, no. 4, pp. 2677–2695, Jul./Aug. 2023

    2023

  23. [31]

    FIdelity: Efficient resilience analysis framework for deep learning accelerators,

    Y . He, P. Balaprakash, and Y . Li, “FIdelity: Efficient resilience analysis framework for deep learning accelerators,” in Proc. 53rd Annu. IEEE/ACM Int. Symp. Microarchit. (MICRO) , Oct. 2020, pp. 270–281

    2020

  24. [32]

    Fast and accurate error simulation for CNNs against soft errors,

    C. Bolchini, L. Cassano, A. Miele, and A. Toschi, “Fast and accurate error simulation for CNNs against soft errors,” IEEE Trans. Comput. , vol. 72, no. 4, pp. 984–997, Apr. 2023

    2023

  25. [33]

    Emulating the effects of radiation-induced soft-errors for the reliability assessment of neural networks,

    L. M. Luza et al., “Emulating the effects of radiation-induced soft-errors for the reliability assessment of neural networks,” IEEE Trans. Emerg. Topics Comput., vol. 10, no. 4, pp. 1867–1882, Oct./Dec. 2022

    2022

  26. [34]

    BinFI: An efficient fault injector for safety-critical machine learning systems,

    Z. Chen, G. Li, K. Pattabiraman, and N. DeBardeleben, “ BinFI: An efficient fault injector for safety-critical machine learning systems,” in Proc. Int. Conf. High Perform. Comput., Netw., Storage Anal. (SC), Nov. 2019

    2019

  27. [35]

    Functional criticality analysis of structural faults in AI accelerators,

    A. Chaudhuri, J. Talukdar, F. Su, and K. Chakrabarty, “Functional criticality analysis of structural faults in AI accelerators,” IEEE Trans. Comput.-Aided Design Integr. Circuits Syst. , vol. 41, no. 12, pp. 5657– 5670, Dec. 2022

    2022

  28. [36]

    SCI-FI: a smart, accurate and unintrusive fault-injector for deep neural networks,

    A. Gavarini, A. Ruospo, and E. Sanchez, “SCI-FI: a smart, accurate and unintrusive fault-injector for deep neural networks,” in Proc. IEEE Eur. Test Symp. (ETS), May 2023

    2023

  29. [37]

    Assessing convolutional neural networks reliability through statistical fault injections,

    A. Ruospo et al. , “Assessing convolutional neural networks reliability through statistical fault injections,” in Proc. Design Autom. Test Europe Conf. (DATE), Apr. 2023

    2023

  30. [38]

    SASSIFI: An architecture-level fault injection tool for GPU application resilience evaluation,

    S. K. S. Hari, T. Tsai, M. Stephenson, S. W. Keckler, and J. Emer, “SASSIFI: An architecture-level fault injection tool for GPU application resilience evaluation,” in IEEE Int. Symp. Perform. Anal. Syst. Softw. (ISPASS), Apr. 2017, pp. 249–258

    2017

  31. [39]

    NVBitFI: Dynamic fault injection for GPUs,

    T. Tsai, S. K. S. Hari, M. Sullivan, O. Villa, and S. W. Keckler, “NVBitFI: Dynamic fault injection for GPUs,” in Proc. 51st Annu. IEEE/IFIP Int. Conf. Dependable Syst. Netw. (DSN) , Jun. 2021, pp. 284–291

    2021

  32. [40]

    Testability and dependability of AI hardware: Survey, trends, challenges, and perspectives,

    F. Su, C. Liu, and H.-G. Stratigopoulos, “Testability and dependability of AI hardware: Survey, trends, challenges, and perspectives,” IEEE Des. Test, vol. 40, no. 2, pp. 8–58, Apr. 2023

    2023

  33. [41]

    A survey on deep learning resilience assessment methodologies,

    A. Ruospo, E. Sanchez, L. M. Luza, L. Dilillo, M. Traiola, and A. Bo- sio, “A survey on deep learning resilience assessment methodologies,” Computer, vol. 56, no. 2, pp. 57–66, Feb. 2023

    2023

  34. [42]

    Testing and reliability of spiking neural networks: A review of the state-of-the-art,

    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

    2023

  35. [43]

    A systematic literature review on hardware reliability assessment methods for deep neural networks,

    M. H. Ahmadilivani, M. Taheri, J. Raik, M. Daneshtalab, and M. Jeni- hhin, “A systematic literature review on hardware reliability assessment methods for deep neural networks,” ACM Comput. Surv., vol. 56, no. 6, Jan. 2024

    2024

  36. [44]

    Artificial neural networks for space and safety-critical applications: Reliability issues and potential solutions,

    P. Rech, “Artificial neural networks for space and safety-critical applications: Reliability issues and potential solutions,” IEEE Trans. Nucl. Sci., vol. 71, no. 4, pp. 377–404, Jan. 2024

    2024

  37. [45]

    Networks of spiking neurons: The third generation of neural network models,

    W. Maass, “Networks of spiking neurons: The third generation of neural network models,” Neural Netw., vol. 10, no. 9, pp. 1659–1671, Dec. 1997

    1997

  38. [46]

    Gerstner, W

    W. Gerstner, W. M. Kistler, R. Naud, and L. Paninski, Neuronal dynamics: From single neurons to networks and models of cognition , Cambridge University Press, 2014

    2014

  39. [47]

    Deep learning in spiking neural networks,

    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, Mar. 2019

    2019

  40. [48]

    Spiking neuron hardware-level fault modeling,

    S. A. El-Sayed, T. Spyrou, E. Afacan, L. A. Camu ˜nas-Mesa, B. Linares- Barranco, and H.-G. Stratigopoulos, “Spiking neuron hardware-level fault modeling,” in Proc. 26th IEEE Int. Symp. On-Line Test. Robust Syst. Des. (IOLTS) , Jul. 2020

    2020

  41. [49]

    PyTorch: An imperative style, high-performance deep learning library,

    A. Paszke et al., “PyTorch: An imperative style, high-performance deep learning library,” in Advances in Neural Information Processing Systems 32, H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alch ´e-Buc, E. Fox, and R. Garnett, Eds., pp. 8024–8035. Curran Associates, Inc., 2019

    2019

  42. [50]

    Converting static image datasets to spiking neuromorphic datasets using saccades,

    G. Orchard, A. Jayawant, G. K. Cohen, and N. Thakor, “Converting static image datasets to spiking neuromorphic datasets using saccades,” Front. Neurosci., vol. 9, Nov. 2015, Article 437

    2015

  43. [51]

    A low power, fully event-based gesture recognition system,

    A. Amir et al. , “A low power, fully event-based gesture recognition system,” in Proc. IEEE Conf. Comput. Vis. Pattern Recognit. (CVPR) , Jul. 2017

    2017

  44. [52]

    Gradient-based learning applied to document recognition,

    Y . LeCun, L. Bottou, Y . Bengio, and P. Haffner, “Gradient-based learning applied to document recognition,” Proc. IEEE , vol. 86, no. 11, pp. 2278–2324, Nov. 1998

    1998

Pith tools

Reviewed August 12, 2026 · model on record in the stance chip above.