Papers for

hardware reliability teams

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Neuromorphic continual learning made robust to memory faults during training

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 runtime. Recently, the neuromorphic continual learning (NCL) concept has emerged as an 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 improve NCL reliability in the presence of transient faults in the DRAM-based 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. It provides three curing variants: 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., 5x10^{-4} 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.

Thu 22 OctNeural and Evolutionary ComputingArtificial IntelligenceMachine Learning
The gist
Continual learning helps computers adapt by learning new information over time, but hardware errors can cause it to perform badly. The authors study neuromorphic continual learning, an energy-saving way to do this type of learning. They propose a system called RobustNCL that detects and fixes errors in memory that stores the model's data. Their method keeps the learning accurate even when errors are frequent, without adding much delay or power use.
Open → 2610.31954v1

Low overhead method detects faults in large language model math operations

Revisiting Cauchy-Schwarz Norm Bounds for SDC Detection in LLM Inference

Abstract: Large Language Models (LLMs) execute billions of floating-point operations per output token across many hardware accelerators. At this scale, hardware-induced faults can bypass system-level detection mechanisms and cause Silent Data Corruption (SDC). Algorithm-Based Fault Tolerance (ABFT) is the state-of-the-art technique for protecting matrix multiplication from such faults, but it incurs non-negligible computational overhead and requires thresholds to distinguish hardware-induced errors from floating-point roundoff. In this paper, we revisit Cauchy--Schwarz Norm Bounds (CSNB) as a low-overhead alternative for detecting SDC during LLM inference. We compare CSNB against ABFT through controlled fault injection and evaluate the runtime overhead of both verification and threshold determination across multiple model sizes, batch sizes, and generation lengths. Our results show that, on average, CSNB retains 99% of the fault detection capability of ABFT for the evaluated dense linear layers while reducing verification overhead by 87% and threshold determination overhead by 67%. For Mixture-of-Experts (MoE) router gate computations, however, CSNB retains only 55% of the fault detection capability of ABFT. These findings suggest that CSNB is a promising low-overhead alternative for protecting dense linear layers in LLM inference, while checksum-based verification remains preferable for the evaluated MoE router gate.

Tue 13 OctDistributed, Parallel, and Cluster Computing
The gist
Large language models use huge amounts of math operations that can have hidden errors caused by hardware faults, which are hard to detect. The authors looked at a simpler and faster way called Cauchy--Schwarz Norm Bounds (CSNB) to spot these hidden errors during model use. They found that CSNB catches almost as many problems as the best method, but much faster and with less extra work for most parts of the model. However, for some special parts called Mixture-of-Experts router gates, the simpler method is less effective. This suggests using the simpler approach most of the time, but sticking to the old method for certain model parts.
Open → 2610.18557v1

Complexity of neural network security checks placed in decision classes

Security Properties of Neural Networks as Decision Problems

Abstract: Certifying a deployed neural network raises decision problems that the verification literature has not classified: whether the model carries a backdoor planted in its training data, whether a fault in its stored parameters can drive it into an unsafe state, whether its output leaks a private part of its input. We formalise eight such problems and classify what we can. The organising observation is a logical one. The function computed by a piecewise linear network, together with all its node values, is definable by a quantifier-free formula of real addition of size linear in the network, so a property of the network is a quantifier-alternation sentence, which Sontag's 1985 theorem places in the polynomial hierarchy at the level of its prefix. Membership results are thus corollaries, and the argument makes plain what they need: that the quantified objects are inputs rather than the network's own parameters. Non-interference, monotonicity and counterfactual fairness have exactly the complexity of network equivalence and of interval verification, all co-NP- complete over ReLU. Detection of backdoor triggers from a quantised alphabet is Sigma_2^P-complete, one level above robustness certification, so it does not reduce to polynomially many robustness queries unless the hierarchy collapses. Inversion resistance is co-NP-complete for every l_p metric, p a fixed positive integer. Quantifying over parameters instead of inputs - the fault model of bit-flip attacks, radiation upsets and analog accelerators - makes verification exists-R-complete already for networks of identity nodes, for which every previously studied problem is in P, and it stays so when each parameter is confined to a box of inverse-polynomial width; the corresponding safety question is forall-R-complete for ReLU.

Wed 30 SeptLogic in Computer ScienceComputational ComplexityCryptography and Security
The gist
Checking whether a neural network is safe or has hidden problems is not well understood in terms of difficulty. The authors identify eight specific safety and privacy questions about neural networks and analyze their computational complexity. They show these problems fit into established complexity classes based on the network type and what is being checked. This helps clarify which security checks can be done efficiently and which are inherently harder to solve.
Open → 2609.39768v1

Graph circuit digital twin predicts routing delays in zynq ultrascale plus fpgas

GRACIDIT: Graph-Circuit Digital Twin for Configuration-Induced Routing Delay Prediction in Zynq UltraScale+ FPGAs

Abstract: Configuration-induced perturbations in SRAM-based FPGAs may activate dormant programmable routing branches and increase path delay without immediately producing a functional error. Although prior studies have separately investigated the electrical origin of these delay changes, their in-situ detection, and the topology of commercial routing fabrics, a scalable method for predicting their timing impact at the granularity of programmable interconnect points and routed nets remains unavailable. This paper presents GRACIDIT, a graph-circuit digital twin framework for predicting configuration-induced routing delay degradation in Zynq UltraScale+ FPGAs. The proposed framework extracts the routing-resource graph of the XCZU7EV programmable fabric from the vendor design database, identifies inactive programmable interconnect points adjacent to active routes, and represents each candidate perturbation through its branch topology, geometric span, fan-out, physical region, and downstream loading. These graph features are combined with a calibrated reduced-order electrical model to estimate the delay introduced by single and cumulative routing-branch activations. Controlled configuration-equivalent perturbations are generated on a ZCU104 platform and characterized using complementary routing-domain oscillators and phase-sweep probes. The resulting model associates predicted delay shifts with available timing slack to rank vulnerable programmable interconnect points and routed nets and to construct a spatial vulnerability atlas of the programmable fabric. Experimental evaluation demonstrates a mean absolute prediction error of 7.8 ps, achieves 87.4 percent recall for slack-violating perturbations, and attains a Recall at 10 value of 0.90 for the most vulnerable routing resources.

Thu 24 SeptHardware ArchitectureEmerging Technologies
The gist
Some programmable chips can slow down unexpectedly due to certain unused circuit pieces becoming active after configuration, which is hard to predict and can affect performance. The authors present GRACIDIT, a method that builds a detailed model of the chip’s routing resources and uses electrical simulations to estimate these delay changes. By testing on a real FPGA, they show their approach can accurately predict which routes are vulnerable to delay increases and rank them by risk. This helps designers know where timing problems might arise before actual functional errors occur.
Open → 2609.30534v1

Error supervising neural network detects CNN parameter faults

ESupNNet: An Error Supervising Neural Network architecture for error detection against soft errors in parameters

Abstract: This work presents a novel approach to detect misclassification errors in CNNs caused by soft errors in their parameters. We propose an architecture that uses inter-class relations induced by the CNN that needs protection. The architecture has minimal resources overhead and does not require modifying the CNN, which makes it a competent solution that can be used with other error protection techniques. We have validated the architecture with five different combinations of modern dataset-model pairs: ImageNet-1K for ResNet-50 and EfficientNetV2-Small; CIFAR-10 for MobileNetV3, ShuffleNetV2-Small with 2.0x output channels and MNASNet with depth multiplier of 1.3. The validation process was done rigorously with statistical significance, from the creation of the datasets used by the architecture to the acquisition of experimental results. Results show great performance with over 90% accuracy in detecting single errors and great error detection over multiple Bit Error Rates, which can be potentially increased with hyperparameter tuning.

Tue 22 SeptHardware Architecture
The gist
Deep learning models like CNNs can sometimes make mistakes because of tiny errors in their settings caused by things like hardware glitches. The authors created a small extra neural network that watches the main CNN’s behavior to catch when these errors might cause a wrong answer. This helper network uses relationships between categories the CNN knows to spot problems without changing the original model. They tested this system on several popular image recognition models and datasets and found it detects errors with over 90% accuracy.
Open → 2609.26374v1

Detecting and correcting silent errors in integer GPU math with syndrome decoding

Syndrome Decoding for Silent Data Corruption in Quantized Integer GPU Arithmetic

Abstract: Quantized neural network inference runs integer matrix multiplications on GPU tensor cores, and the INT32 accumulators inside those cores have neither parity nor ECC. A transient fault in this datapath returns a valid but wrong integer and raises no interrupt. Checksum based Algorithm Based Fault Tolerance (ABFT) can detect such silent data corruptions (SDCs), but its verdict is binary. It cannot identify the corrupted element or its magnitude, and unweighted row and column checksums are blind by construction to errors that cancel on both axes. We present SProbe, a trailing verification kernel that reads the output of an unmodified vendor GEMM. A randomized Freivalds gate with three independent evaluation points in a 61 bit prime field misses a nonzero error with probability at most $2^{-141}$. When the gate fires, per row power sum syndromes over three primes are decoded with the Reed Solomon chain of Berlekamp Massey, Chien search, and Forney, recovering the column and exact magnitude of up to four colliding errors per row. SProbe then repairs the accumulator in place or recomputes the GEMM. On an NVIDIA H100, SProbe detects every injected fault across seven fault classes and four matrix sizes, including constructed patterns that TR-ABFT never detects and patterns that a weighted grid code detects but cannot correct. The gate costs 49% of the cuBLASLt GEMM time at N=16384 and 11% at N=65536. In an INT8 medical LLM, protection eliminates all observed silent corruptions at a 30% throughput cost. Our measurements also show that recomputation is faster than in place recovery in every configuration we tested, that diagnosis rather than repair dominates recovery cost, and we report the defects we found while validating the verifier itself.

Thu 17 SeptDistributed, Parallel, and Cluster Computing
The gist
Integer math on GPUs can sometimes produce wrong answers silently, without any obvious errors. The authors present SProbe, a tool that checks results using advanced math to both detect and fix these silent mistakes. It uses special error-checking codes to find exactly where errors happened and corrects them efficiently. This means GPU computations for certain AI tasks get safer, though with some speed cost.
Open → 2609.19743v1