acceptodds
Under review as a conference paper at ICLR 2027

RobustNCL: Robustifying Neuromorphic Continual Learning under Transient Faults with Lightweight Detect-and-Cure Strategy

Abstract

In neural networks, continual learning (CL) is a prominent approach for enabling deployed systems to adapt to dynamic operational environments by effectively learning from new unseen data at run-time. Recently, neuromorphic continual learning (NCL) concept has emerged as energy-efficient alternative to CL by leveraging sparse event-based operations. However, NCL performance can be undermined by transient faults in the hardware platforms, which may come from high-energy particle strikes at any time. Currently, NCL reliability under transient faults has not been studied, and hence the corresponding fault-tolerance techniques remain unexplored. To address this, we propose a novel RobustNCL framework to improves NCL reliability in the presence of transient faults in the off-chip memory of hardware platforms through a lightweight detect-and-cure strategy. Specifically, it first monitors the presence of faults during weight data access from off-chip memory, and then cures the accessed weights if anomalous signatures are detected. Here, it provides three curing variants, including replacement with zero, min/max value and most-probable value from the original/clean weight distribution. To support this, the weight curing values are stored in the radiation-hardened memory. Experimental results show that, in the presence of high fault rates (e.g., for memory replay), RobustNCL maintains high accuracy close to the accuracy of fault-free models (i.e., within -0.5% accuracy for the best RobustNCL variant) and significantly improves accuracy from the baseline without fault mitigation across different NCL methods and datasets (i.e., Split MNIST, Split Fashion-MNIST, Split CIFAR-10, and Split CIFAR-100), while incurring negligible latency and energy overheads. These results highlight that our RobustNCL framework is a promising approach for enabling reliable and energy-efficient NCL systems.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Neuromorphic Continual Learning, Reliability, Robustness, Hardware Fault, Transient Fault, Soft Errors, DRAM Off-Chip Memory

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_EUq2OpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

Summary

In this paper, the authors proposed RobustNCL, which addresses the vulnerability of the Neuromorphic Continual Learning (NCL) framework to transient DRAM bit-flips. The paper proposes a lightweight detect-and-cure strategy that identifies anomalous weights using the clean weight distribution and replaces them with zero, the minimum/maximum boundary value, or the most probable synaptic weight. To accommodate the evolving model states in continual learning, the curing statistics are updated after each task and evaluated using both task-specific subnetwork and memory replay approaches. Experiments based on a spiking VGG-9 model on Split MNIST, Split Fashion-MNIST, Split CIFAR-10, and Split CIFAR-100 show that RobustNCL can maintain accuracy close to the fault-free baseline with relatively small reported latency, memory, and energy overheads.

Critical strengths

Strengths

  1. The proposed mechanism is simple and notably enhances the fault tolerance of SNNs.
  2. The detailed problems mentioned in subsection 3.2 are somewhat clear.
Critical weaknesses

Weaknesses

  1. I think this paper fits well with DAC or DATE. Although the proposed mechanism is practical in hardware aspects, it does not show interesting interactions between faults and learning. If the authors state the relations between hardware faults and learning aspects of CL, I can slightly change my opinion about this paper. For example, the authors should investigate how hardware faults affect CL and degrade SNNs' performance. This is because this venue is deeply related to learning methods of neural networks and other machine learning approaches.
  2. The detailed problems caused by hardware faults, such as bit flips, are not novel. Actually, the problems mentioned in this paper are already investigated by existing studies [1, 2, 3].
  3. Although the authors target hardware faults in NCL, they only provide experimental results based on software. I think they would demonstrate that their mechanism works well in a software environment for hardware simulations, such as Intel Lava. However, they do not even show these kinds of results. This critical problem severely damages the paper's reliability. For further improvement, I strongly recommend that the authors use real devices like BrainScaleS-2 or hardware simulation environments like Intel Lava to demonstrate that their mechanism is effective with hardware devices.
  4. Authors should use more types of network structures. They use only the VGG-9 structure for software simulations. They should use at least ResNet structures to show the effectiveness of their mechanism. This is because there are large SNN structures that can operate on neuromorphic devices, such as Intel Loihi and BrainChip Akida.
  5. The authors do not compare their mechanism to conventional approaches to enhance fault tolerance of hardware-based NCL, which is a significant weakness of this paper.

[1] Rachmad Vidya Wicaksana Putra, Muhammad Abdullah Hanif, and Muhammad Shafique, "SoftSNN: Low-Cost Fault Tolerance for Spiking Neural Network Accelerators under Soft Errors," in Proceedings of the 59th ACM/IEEE Design Automation Conference (DAC), pp. 151–156, 2022.

[2] Rachmad Vidya Wicaksana Putra, Muhammad Abdullah Hanif, and Muhammad Shafique, "RescueSNN: Enabling Reliable Executions on Spiking Neural Network Accelerators under Permanent Faults," Frontiers in Neuroscience, vol. 17, Art. no. 1159440, 2023.

[3] Thai-Hoang Nguyen, Muhammad Imran, Jaehyuk Choi, and Joon-Sung Yang, "CRAFT: Criticality-Aware Fault-Tolerance Enhancement Techniques for Emerging Memories-Based Deep Neural Networks," IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 42, no. 10, pp. 3289–3300, 2023.

Questions for authors

Questions

  1. Could you please explain why the characteristics of SNNs make them suitable for CL? For example, why are their event-driven and sparse spiking characteristics useful for CL? Although the authors cite some references, I recommend that they clearly state the reasons in the introduction in one or two sentences.
  2. In my opinion, DRAM is used to implement ANNs on real hardware devices. Furthermore, hardware faults occur less frequently in DRAM than in RRAM (memristors) because DRAM is more stable. However, the authors consider DRAM for hardware implementation of SNNs. Do you have any clear reasons to consider DRAM?
  3. During CL, synaptic weights are updated, which means that they can be affected by errors or faults caused by abnormal updates. Do you consider them? I think errors or faults during weight updates are also considerable [1].

[1] Hyun-Jong Lee and Jae-Han Lim, "Practical Mechanism for Fault-Tolerant Spiking Neural Networks via Simple Input Control Based on Learnable Fragmentation," in Proceedings of the 43rd International Conference on Machine Learning (ICML), PMLR, vol. 306, pp. 64616–64653, 2026.

5 comments
AuthorsOpenReview ↗

Response to Reviewer EUq2 [Weakness-1]

We would like to thank you for your valuable comments and constructive feedback. We have considered each comment and provide responses below.


Response to [Weakness-1]: "it does not show interesting interactions between faults and learning"

In Section 5 "Results and Discussion", we show that the baseline neuromorphic continual leaning (NCL) suffer from significant performance (accuracy) degradation when NCL training process is performed in the presence of transient faults in the main memory (i.e., DRAM).

The same results are shown in the following tables. Each dataset includes its lowest and highest tested fault rates.

The first table shows results for task-specific subnetworks (Subnet).

Split datasetFault rateNo protection (%)RobustNCLv2 (%)
MNIST5×10−95 \times 10^{-9}99.8499.81
MNIST10−510^{-5}51.2899.82
Fashion-MNIST5×10−95 \times 10^{-9}99.0199.01
Fashion-MNIST10−510^{-5}50.0099.04
CIFAR-105×10−95 \times 10^{-9}84.3584.85
CIFAR-1010−510^{-5}50.0085.25
CIFAR-10010−810^{-8}60.0070.73
CIFAR-10010−510^{-5}10.0070.59

The second table shows results for memory replay (MR).

Split datasetFault rateNo protection (%)RobustNCLv2 (%)
MNIST10−710^{-7}99.4099.39
MNIST5×10−45 \times 10^{-4}51.5099.51
Fashion-MNIST10−710^{-7}99.0399.07
Fashion-MNIST5×10−45 \times 10^{-4}50.0098.92
CIFAR-1010−710^{-7}88.8088.03
CIFAR-105×10−45 \times 10^{-4}50.0086.37
CIFAR-10010−810^{-8}66.6666.75
CIFAR-10010−510^{-5}10.0065.90

On all four datasets, accuracy without protection falls as the fault rate increases. Our RobustNCL maintains much higher accuracy at the higher fault rates. These results show how faults reduce performance during continual learning and how RobustNCL reduces this loss.

This is interesting and important finding that, even when continual learning (CL) process updates the model weights when learning new tasks, it does not make the model automatically become more robust and adapt better to the faults. Moreover, the transient faults may happen at anytime, at any fault rate, and with a different fault map each time high-energy particle strikes the DRAM main memory during runtime operations, thereby making it even more challenging and difficult to make the model become robust against transient faults.

AuthorsOpenReview ↗

Response to Reviewer EUq2 [Weakness-2]

We would like to thank you for your valuable comments and constructive feedback. We have considered each comment and provide responses below.


Response to [Weakness-2]: "The detailed problems caused by hardware faults, such as bit flips, are not novel."

The transient faults problem is not new in the research community, but studying the impact of transient faults in the continual learning domain (especially in neuromorphic computing) is novel. Furthermore, the unpredictable nature of transient faults, which can occur at anytime, at any fault rate, and with different possible fault map each time the faults appear during the operational time of the system, combined with the dynamic nature of model (weight) updates in continual learning scenario, make the position of our study unique and relevant to the recent advances of AI systems toward smart and runtime adaptation.

The reference works mentioned have limitations that make them unsuitable for nauromorphic continual learning (NCL) scenario. Following are the reasons.

[1] Rachmad Vidya Wicaksana Putra, Muhammad Abdullah Hanif, and Muhammad Shafique, "SoftSNN: Low-Cost Fault Tolerance for Spiking Neural Network Accelerators under Soft Errors," in Proceedings of the 59th ACM/IEEE Design Automation Conference (DAC), pp. 151–156, 2022.

SoftSNN aims to mitigate transient faults in the compute engine of SNN accelerator that performs SNN inference, hence it employs fixed weight distributions to mitigate the transient faults in the model weights. Therefore, it does not have mechanisms that accommodate NCL training and dynamic ranges of weight distributions for transient fault mitigation.

[2] Rachmad Vidya Wicaksana Putra, Muhammad Abdullah Hanif, and Muhammad Shafique, "RescueSNN: Enabling Reliable Executions on Spiking Neural Network Accelerators under Permanent Faults," Frontiers in Neuroscience, vol. 17, Art. no. 1159440, 2023.

RescueSNN aims to mitigate permanent faults in the compute engine of SNN accelerator through fault-aware mapping that leverages a fixed fault map before deployments. Therefore, it does not have mechanisms that accommodate the dynamic nature of transient faults which may appear with a different fault rate and a different fault map each time high-energy particle strikes the DRAM main memory during runtime operations.

[3] Thai-Hoang Nguyen, Muhammad Imran, Jaehyuk Choi, and Joon-Sung Yang, "CRAFT: Criticality-Aware Fault-Tolerance Enhancement Techniques for Emerging Memories-Based Deep Neural Networks," IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 42, no. 10, pp. 3289–3300, 2023.

CRAFT aims to mitigate stuck-at faults (which are manifestation of permanent faults) on emerging memories for deep neural networks, hence it leverages a fixed fault map before deployments. Consequently, it also does not have mechanisms that accommodate the dynamic nature of transient faults which may appear with a different fault rate and a different fault map each time high-energy particle strikes the DRAM main memory during runtime operations.

AuthorsOpenReview ↗

Response to Reviewer EUq2 [Weakness-3 and Weakness-4]


Response to [Weakness-3]: "Although the authors target hardware faults in NCL, they only provide experimental results based on software."

We agree that hardware-level evaluation is important, but performing transient fault injection in real neuromorphic compute platforms may damage the hardware, which are typically very costly and have limited accessibility. Therefore, the purpose of software-level experiments is to enable us perform a comprehensive design space exploration (DSE) that considers a wide-range of different possible design scenarios that may happen in the real-world environments/deployments without damaging the actual hardware. Additionally, a comprehensive DSE also provides near-accurate experimental results, from which we can draw insightful key observations.

The transient faults may happen at anytime and at any fault rate. For instance, a fault rate of fR=1×10−4f_R = 1 \times 10^{-4} in DDR3-1600 2Gb DRAM chip means (1×10−4)×(2×1024×1024×1024)≈214,748(1 \times 10^{-4}) \times (2 \times 1024 \times 1024 \times 1024) \approx 214,748 faulty bits at the same time, and they may happen anytime (e.g., multiple times in one hour) in the operational lifetime of the system. Therefore, in our RobustNCL development, we consider a challenging transient fault model with a comprehensive DSE scenarios.

  • First: Transient faults are injected when (1) the clean weights of pre-trained model are deployed and stored in the DRAM main memory for the first time, and when (2) the model weights are updated after performing NCL training at runtime. Therefore, the model weights are always exposed and affected by faults.
  • Second: We explore a wide range of fault rates (i.e., between $ 1 \times 10^{-7} - 5 \times 10^{-4}$). These challenging conditions are explored in our work to ensure that our RobustNCL methodology can perform reliably in diverse operational environments. Therefore, we develop RobustNCL to always monitor the weights accessed from the DRAM main memory of the system hardware and curing them before performing inference or NCL training.

Response to [Weakness-4]: "Authors should use more types of network structures."

We agree that using more networks in the evaluation will strengthen the claim. However, our proposed RobustNCL framework is developed without any constraints of network structures, thereby making it applicable to any network structures that are used for performing continual learning process. Specifically, RobustNCL aims to monitor weight values accessed from DRAM main memory and then cure (replace) them if anoumalous signatures are detected. Therefore, it is applicable to any network architectures/strcutures.

Reviewer_3kswOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies the reliability of neuromorphic continual learning (NCL) under transient hardware faults, particularly bit-flip errors in DRAM-based off-chip memory. The authors propose RobustNCL, a lightweight detect-and-cure framework that identifies anomalous weight values during memory access and repairs them using three strategies: zero replacement, min/max clipping, and most-probable value replacement. The framework also updates weight distribution statistics as the model learns new tasks. Experiments on four benchmark datasets using task-specific subnetwork and memory replay methods show that RobustNCL can maintain accuracy close to fault-free models under high fault rates, with low reported latency, memory, and energy overheads.

Critical strengths
  1. The paper addresses a meaningful and practical problem by studying how transient hardware faults affect neuromorphic continual learning. The motivation is clear and highlights an important reliability challenge that deserves further attention. 2. The paper is well written and easy to follow. The authors clearly explain the problem motivation, the fault model, and the proposed detect-and-cure strategy. The overall organization is logical, and the illustrations help readers understand the framework and its main components.
Critical weaknesses
  1. RobustNCL detects and repairs transient faults by checking whether DRAM-accessed weights fall outside the minimum and maximum values of the clean weight distribution. However, bit-flips do not necessarily cause weight values to exceed this range. For example, flipping a sign or mantissa bit may significantly change a weight value while still keeping it within the normal range. Such errors would therefore remain undetected by the proposed mechanism.

    1. The paper highlights that traditional fault-tolerance techniques, such as Error Correcting Codes (ECC), Dual Modular Redundancy (DMR), and Triple Modular Redundancy (TMR), can introduce considerable hardware and energy overheads, motivating the lightweight design of RobustNCL. However, the experiments mainly compare the baseline without fault mitigation against the three RobustNCL variants, without direct performance and overhead comparisons with existing fault-tolerance methods.

    2. The fault-injection scenarios considered in the paper are relatively idealized, and the experimental evaluation is limited to a single network architecture. As a result, the current fault simulations may not fully represent the conditions of real-world dynamic operating environments, limiting the generality of the experimental findings.

Questions for authors
  1. Could the authors further analyze the detection capability of RobustNCL for different types of bit-flips, particularly those that change weight values but still keep them within the normal weight distribution range?

    1. Could the authors further compare RobustNCL with representative fault-tolerance techniques or lightweight weight protection strategies? In particular, it would be helpful to compare fault mitigation effectiveness, memory overhead, latency, and energy consumption under the same fault rates to better demonstrate the advantages of RobustNCL.
2 comments
AuthorsOpenReview ↗

Response to Reviewer 3ksw [Weakness-1, Weakness-2, and Question-2]

We would like to thank you for your valuable comments and constructive feedback. We have considered each comment and provide responses below.


Response to [Weakness-1]: "bit-flips do not necessarily cause weight values to exceed this range"

A sign or mantissa bit-flip can change a weight value without moving it outside the stored minimum and maximum values. However, based on our comprehensive experiments across different fault rates and different layers in the investigated model, we observe that weight changes that do not exceed the clean weight distribution range, typically do not greatly affect on accuracy. Furthermore, a continued training on new tasks can also help the model to adapt better to this type of weight changes.


Response to [Weakness-2]: "the experiments mainly compare the baseline without fault mitigation against the three RobustNCL variants, without direct performance and overhead comparisons with existing fault-tolerance methods" and [Question-2]: "Could the authors further compare RobustNCL with representative fault-tolerance techniques or lightweight weight protection strategies?"

We have performed experiments on a standard fault mitigation of Triple Modular Redundancy (TMR), run them in a single Nvidia RTX 4090 GPU device, and provided new results below for the Split MNIST, Split Fashion-MNIST, and Split CIFAR-10 datasets. For each dataset and continual learning method (i.e., subnetworks (Subnet) and memory replay (MR)), TMR and RobustNCL are tested at the same eight fault rates: $ 1 \times 10^{-7}, 5 \times 10^{-7}, 1 \times 10^{-6}, 5 \times 10^{-6}, 1 \times 10^{-5}, 5 \times 10^{-5}, 1 \times 10^{-4}, 5 \times 10^{-4}$.

The first table gives averages results over eight fault rates or task-specific subnetworks (Subnet).

Split datasetProtectionAccuracy (%)Training time (s)Training energy (MJ)GPU memory (MB)
MNISTTMR99.821370.30.17581816.1
MNISTRobustNCLv299.781387.80.17181806.2
Fashion-MNISTTMR99.011366.60.17311790.0
Fashion-MNISTRobustNCLv299.031380.90.16951781.5
CIFAR-10TMR84.341134.60.14401792.1
CIFAR-10RobustNCLv285.151153.20.14181802.2

The second table gives averages over eight fault rates for memory replay (MR).

Split datasetProtectionAccuracy (%)Training time (s)Training energy (MJ)GPU memory (MB)
MNISTTMR99.411484.70.26855769.3
MNISTRobustNCLv299.371443.60.23135651.8
Fashion-MNISTTMR99.021687.10.31615752.5
Fashion-MNISTRobustNCLv299.021479.00.25775682.2
CIFAR-10TMR88.411291.70.24885777.7
CIFAR-10RobustNCLv288.191226.90.22225700.1

For memory replay (MR), RobustNCLv2 has lower average training time, energy consumption, and GPU memory usage on all three datasets. The average accuracy difference between RobustNCLv2 and TMR is at most 0.22 percentage points. With Subnet, average accuracy achieved by RobustNCLv2 is comparable to or higher than TMR. Moreover, our RobustNCLv2 icurs less training energy, while training time and memory use are close. These results also justify the lightweight overheads that RobustNCL incurs.

In ECC-based solution, protection provided by the widely-used SECDED-ECC is limited to the bits covered by the same ECC codeword. It means that multiple faults that are distributed across different codewords, which are potentially in DRAM memory cells across different banks and chips, may be corrected independently. Meanwhile, clustered faults within one codeword can exceed its correction capability. Consequently, SECDED-ECC incurs additional memory, processing latency, hardware complexity, and power/energy consumption for facilitating ECC encoding and decoding processes.

AuthorsOpenReview ↗

Response to Reviewer 3ksw [Weakness-3 and Question-1]

We would like to thank you for your valuable comments and constructive feedback. We have considered each comment and provide responses below.


Response to Weakness-3: "The fault-injection scenarios considered in the paper are relatively idealized"

We would like to clarify that the transient faults may happen at anytime and at any fault rate. For instance, a fault rate of fR=1×10−4f_R = 1 \times 10^{-4} in DDR3-1600 2Gb DRAM chip means (1×10−4)×(2×1024×1024×1024)≈214,748(1 \times 10^{-4}) \times (2 \times 1024 \times 1024 \times 1024) \approx 214,748 faulty bits at the same time, and they may happen anytime (e.g., multiple times in one hour) in the operational lifetime of the system. Therefore, in our RobustNCL development, we consider a challenging transient fault model.

  • First: Transient faults are injected when (1) the clean weights of pre-trained model are deployed and stored in the DRAM main memory for the first time, and when (2) the model weights are updated after performing neuromorphic continual leaning (NCL) training at runtime. Therefore, the model weights are always exposed and affected by faults.
  • Second: We explore a wide range of fault rates (i.e., between $ 1 \times 10^{-7} - 5 \times 10^{-4}$). These challenging conditions are explored in this work to ensure that our RobustNCL methodology can perform reliably in diverse operational environments. Therefore, we develop RobustNCL to always monitor the weights accessed from the DRAM main memory of the system hardware and curing them before performing inference or NCL training.

Response to Question-1: "Could the authors further analyze the detection capability of RobustNCL for different types of bit-flips, particularly those that change weight values but still keep them within the normal weight distribution range?"

Bit-flips in weight values may lead to two possible conditions: (1) the affected weight values shift beyond the clean fault-free weight distribution range, or (2) the affected weight values change but stay within the clean fault-free weight distribution range. For the first condition where "the affected weight values shift beyond the clean range", the faults will be detected and cured by our RobustNCL framework. For the second condition where "the affected weight values stay within the clean range", the faults will be treated as safe weight values, because weight changes that do not exceed the clean weight distribution range, typically do not greatly affect on accuracy. These observations are drawn as the result of our comprehensive experiments that explore the impact of transient faults across different fault rates (covering low and high rates), different possible timing windows for transient fault injection, and different targeted layers in the investigated model. This design space exploration has been conducted when we were developing RobustNCL's detect-and-cure (D&C) strategy. Furthermore, a continued training on new tasks can also help the model to adapt better to this type of weight changes.

Reviewer_LQZaOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents the first study of transient (soft-error) bit-flips in off-chip DRAM affecting neuromorphic continual learning (NCL). The proposed RobustNCL framework records per-layer weight statistics (min, max, most-probable value) from the clean model. Then, at runtime, any weight read from DRAM outside [wmin,wmax][w_min, w_max] is deemed faulty and "cured" by replacement with zero (v1), the clipped min/max (v2), or the most-probable value (v3). Curing values are stored in radiation-hardened memory. Evaluated with a VGG9 SNN using task-specific subnetwork (Subnet) and memory replay (MR) methods on Split MNIST, Split FMNIST, Split CIFAR-10, and Split CIFAR-100. As expected, the experiments show a better performance under random bit-errors with the new method.

Critical strengths
  1. Real and timely problem: Transient faults in DRAM are a genuine reliability concern for deployed systems, and the gap of NCL reliability under hardware faults is plausibly unaddressed. As far as I know, this is indeed the "first study" on this combination (NCL+transient errors), although substantial literature around the issue exists (and is mentioned in the paper)
  2. Sound core contribution with a decent experimental analysis: Sign- and exponent-bit flips in FP32 weights are catastrophic, and hence outlier removal is a sensible, cheap mitigation. The curing variants are simple and easy to implement and seem to get the job done. The experiments are mostly fitting: two NCL method families (architecture-based Subnet, memory replay) across four task incremental learning and a sweep of fault rates.
Critical weaknesses
  1. No comparison against standard mitigations: The method is compared only against no mitigation. The obvious alternative a system designer would probably use is something like SECDED ECC on the weight DRAM (commodity ECC DDR3 exists), or consider checkpoint/recompute approaches. The first are not discussed, while the latter are dismissed in one sentence as "high overhead" with no quantification. Without a head-to-head comparison or a stronger theoretical argument, the central claim of a "lightweight" alternative is unsupported.
  2. Fault rates are orders of magnitude unrealistic: fR=1e−5–5e−4f_R = 1e-5–5e-4 faulty bits per cell per injection point on a 2Gb chip implies ~2e4–1e52e4–1e5 bit flips per injection. Real DRAM soft-error rates (~1000 FIT/chip) give roughly 0.01–0.02 errors per chip-year which is about 6+ orders of magnitude lower (this was a back-of-an-envelope style calculation, so take it with a grain of salt). The authors show that accuracy does not degrade even under higher fault rates and hence it's reasonable to assume that their method will retain accuracy even at lower fault rates. However, is the overhead in these situations justified? Is the trade-off of using their method still worth it with smaller error rates? I am missing an experiment with more realistic fault rates and/or a discussion about real-world deployment. Somewhat related here is the fact that the paper described a near-circular detection without coverage analysis: The detector catches exactly the faults the model produces (exponent flips producing 1e36/1e37 values, see Fig. 6). Mantissa flips that remain within the clean range and are silently missed. The paper never reports what fraction of injected faults are detected vs. missed, so the mechanism's effectiveness cannot be verified. The reported near-zero residual damage implies either (a) almost all injected faults are trivially detectable, or (b) something else is off
Questions for authors
  1. Did you consider and compare against existing methods such as using SECDED ECC or checkpointing approaches?
  2. Did you check how your method performs in more realistic, lower bit-error regimes? In particular, did you check what kinds of errors your method detects vs. which actually occur?
2 comments
AuthorsOpenReview ↗

Response to Reviewer LQZa [Weakness-1 and Question-1]

We would like to thank you for your valuable comments and constructive feedback. We have considered each comment and provide responses below.


Response to [Weakness-1]: "No comparison against standard mitigations" and to [Question-1]: "Did you consider and compare against existing methods such as using SECDED ECC or checkpointing approaches?"

We have performed experiments on a standard fault mitigation of Triple Modular Redundancy (TMR), run them in a single Nvidia RTX 4090 GPU device, and provided new results below for the Split MNIST, Split Fashion-MNIST, and Split CIFAR-10 datasets. For each dataset and continual learning method (i.e., subnetworks (Subnet) and memory replay (MR)), TMR and RobustNCL are tested at the same eight fault rates: $ 1 \times 10^{-7}, 5 \times 10^{-7}, 1 \times 10^{-6}, 5 \times 10^{-6}, 1 \times 10^{-5}, 5 \times 10^{-5}, 1 \times 10^{-4}, 5 \times 10^{-4}$.

The first table gives averages results over eight fault rates or task-specific subnetworks (Subnet).

Split datasetProtectionAccuracy (%)Training time (s)Training energy (MJ)GPU memory (MB)
MNISTTMR99.821370.30.17581816.1
MNISTRobustNCLv299.781387.80.17181806.2
Fashion-MNISTTMR99.011366.60.17311790.0
Fashion-MNISTRobustNCLv299.031380.90.16951781.5
CIFAR-10TMR84.341134.60.14401792.1
CIFAR-10RobustNCLv285.151153.20.14181802.2

The second table gives averages over eight fault rates for memory replay (MR).

Split datasetProtectionAccuracy (%)Training time (s)Training energy (MJ)GPU memory (MB)
MNISTTMR99.411484.70.26855769.3
MNISTRobustNCLv299.371443.60.23135651.8
Fashion-MNISTTMR99.021687.10.31615752.5
Fashion-MNISTRobustNCLv299.021479.00.25775682.2
CIFAR-10TMR88.411291.70.24885777.7
CIFAR-10RobustNCLv288.191226.90.22225700.1

For memory replay (MR), RobustNCLv2 has lower average training time, energy consumption, and GPU memory usage on all three datasets. The average accuracy difference between RobustNCLv2 and TMR is at most 0.22 percentage points. With Subnet, average accuracy achieved by RobustNCLv2 is comparable to or higher than TMR. Moreover, our RobustNCLv2 icurs less training energy, while training time and memory use are close. These results also justify the lightweight overheads that RobustNCL incurs.

In ECC-based solution, protection provided by the widely-used SECDED-ECC is limited to the bits covered by the same ECC codeword. It means that multiple faults that are distributed across different codewords, which are potentially in DRAM memory cells across different banks and chips, may be corrected independently. Meanwhile, clustered faults within one codeword can exceed its correction capability. Consequently, SECDED-ECC incurs additional memory, processing latency, hardware complexity, and power/energy consumption for facilitating ECC encoding and decoding processes.

AuthorsOpenReview ↗

Response to Reviewer LQZa [Weakness-2a, Weakness-2b, and Question-2]

We would like to thank you for your valuable comments and constructive feedback. We have considered each comment and provide responses below.


Response to [Weakness-2a]: "Fault rates are orders of magnitude unrealistic"

We would like to clarify that the transient faults may happen at anytime and at any fault rate. For instance, a fault rate of fR=1×10−4f_R = 1 \times 10^{-4} in DDR3-1600 2Gb DRAM chip means (1×10−4)×(2×1024×1024×1024≈214,748)(1 \times 10^{-4}) \times (2 \times 1024 \times 1024 \times 1024 \approx 214,748) faulty bits at the same time, and they may happen anytime (e.g., every one hour) in the operational lifetime of the system. Therefore, we develop RobustNCL to be able to mitigate such transient fault behavior by always monitoring the weights accessed from the main memory (i.e., DRAM) of the system hardware and curing them before performing inference or training for continual learning purpose.


Response to [Weakness-2b]: "Mantissa flips that remain within the clean range and are silently missed."

A sign or mantissa bit-flip can change a weight value without moving it outside the stored minimum and maximum values. Such weight changes (that do not exceed the clean weight distribution range) typically do not greatly affect on accuracy. These observations are drawn as the result of our comprehensive experiments that explore the impact of transient faults across different fault rates (covering low and high rates), different possible timing windows for transient fault injection, and different targeted layers in the investigated model. This design space exploration has been conducted when we were developing RobustNCL's detect-and-cure (D&C) strategy. Furthermore, a continued training on new tasks can also help the model to adapt better to this type of weight changes. Furthermore, a continued training on new tasks can also help the model to adapt better to this type of weight changes.


Response to [Question-2]: "Did you check how your method performs in more realistic, lower bit-error regimes? In particular, did you check what kinds of errors your method detects vs. which actually occur?"

Our RobustNCL aims to minimize the negative impact of transient faults, which typically manifest as "bit-flip" and can happen at anytime and at any fault rate. Specifically, RobustNCL solves this problem by curing (replacing) the accessed weights when anomalous signatures are detected with safe weight values based on the information of clean/fault-free weight distribution in each network layer. As a result, the high accuracy of deployed spiking neural networks (SNNs) is maintained without catastrophic degradation. This fault mitigation approach makes our RobustNCL applicable to any bit error rates at anytime, highlighting its lightweight and scalable solution for practical neuromorphic continual learning (NCL) applications.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.