In this paper
AbstractIntroductionBackground and Related WorkProblem StatementMethodsMBU SimulationLatent Space Redundancy: Projection HealingRobust ProjectionWeight HealingFault Aware TrainingBenchmarking ProtocolEvaluation MetricsResultsBenchmarking ResultsAblation ResultsContribution of the Runtime Heal Beyond Fault-Aware TrainingMAD Despike and Basis SwapSingle-Component RemovalsGeneralization to Unseen Fault ModelsPer-Bit-Position Damage and DetectionOverheadDiscussionComparisonsOperational EnvironmentsScope and LimitsConclusionCompute OverheadModel Architectures and CapacitiesMBU Multiplicity ModelGate Threshold SweepSurrogate vs. True INT8 Bit-Flip FATArchitectural Validations and Sensitivityfc1 Heal No-OpMemory-Layout SensitivitySensitivity to the Green Rank Subspace DimensionBaseline ImplementationsData availabilityAcknowledgmentsConflict of interestFundingReferencesWorksPhysics and Astronomy
A Radiation-Hardened, Fault-Aware Quantized Neural Network That Self-Heals
Abstract
Deep learning (DL) models are increasingly being deployed into radiation-challenging environments in spacecraft, particle accelerators, and, soon, space-based data centers. Instantiated as a learned orchestration of numbers stored in persistent memory, models are susceptible to continual degradation as high-energy particles corrupt data. At inference time, new data passed through the network fundamentally break the off-line assumptions and guarantees of a static model determined during training. To preserve the quality and efficacy of the models, fault tolerance against bit flips is a clear objective. In this work we developed a runtime method for repairing the quantized weights of neural networks (NNs) after bit flips on commodity, commercial off-the-shelf (COTS) hardware, without storing extra replicas. Our work extends the well-established Fault-Aware Training (FAT) paradigm by adding an alignment penalty to concentrate undamaged activations and weights into a low-rank subspace, and we then reconstruct flagged corrupted coordinates from the uncorrupted survivors. We call this method Projection Healing and apply it to six regression benchmarks on quantized NNs. Holding a FAT checkpoint fixed and toggling only the runtime heal gives a further ∼23% reduction in the native-unit excess integral. Across those datasets the method extends the operational scrub interval by a median of 2.04× at a +5% RMSE degradation and 1.96× at +50%, compared with 1.62× and 1.07× for classical Single Error Correction, Double Error Detection (SECDED). This introduces a new path towards designing resilient data-driven models, complementing established hardware redundancy, ECC, and FAT-based techniques.
Introduction
Deep learning algorithms are now frequently deployed into radiation-challenging environments, including low-Earth orbit [1, 2], aerospace electronics [3, 4, 5], nuclear facilities [6], and particle accelerators [7, 8, 9]. These environments present a unique risk of introducing hardware-level faults due to incident particles ionizing a track through the silicon in the hardware. This results in flipped bits which, when the deposited charge exceeds a critical threshold of the transistor node, cause computation faults manifested at the software level as bit flips (if left uncorrected). The typical solution to this problem requires fabricating custom edge silicon where the designer introduces hardware redundancy to strategically protect critical components on a chip [10]. Examples of these custom-designed solutions are full triple modular redundancy (TMR) where, at the cost of chip footprint and redundant calculations [11, 12], one can protect datapaths and computation. However, this often leaves the Static Random Access Memory (SRAM) underprotected as dense memory arrays scale unfavorably to this method in both footprint and power consumption, falling back to standard software error correcting codes (ECC). Commercial off-the-shelf (COTS) hardware used in small satellites often faces similar challenges where memory typically has no ECC [13]. This work targets that case with a software repair on the processor and memory on a commodity part already has, rather than a radiation-hardened fabrication process or a custom datapath.
When extrapolated into the future, these risks are further elevated. As transistors shrink [14, 15] and compute densifies, the probability of multiple faults increases with future deployment. For example, conventional frontier deep learning accelerators, such as the Nvidia H100, use 3D-stacked high-bandwidth memory for model weights. That stacking raises the chance of spatially correlated bit flips. Stacked HBM itself predates the H100. This fundamentally shifts us from the realm of Single Event Upset (SEU) flips, where one cell is disrupted, to Multi-Bit Upset (MBU) flips, where a cluster of adjacent cells is affected [16]. As the computing paradigm advances, we expect the next generation of deployed model weights to remain an unprotected radiation target under the status quo.
Needless to say, there are further engineering constraints to account for. In nearly all of the deployment settings, there is a non-negotiable need for systems to run on the edge with constraints on bandwidth, power, physical footprint, latency, and cost [17, 18]. In most settings, cheap, small, power-efficient commodity solutions are ideal, and in many categories, the current solution of custom-fabricated hardware redundancy underserves in many areas.
Background and Related Work
Classically, fault tolerance uses a mix of spatial and algorithmic redundancy [19]. As mentioned, TMR [11] triplicates blocks and votes, at over area and power, and ECC algorithms like Single Error Correction, Double Error Detection (SECDED) protect memory at a cost of storage. Other methods used commonly are checksums called Algorithm-Based Fault Tolerance [20] to verify computations. This idea has been adapted for Deep Neural Networks (DNNs) [21, 22]. The downside of this method is it adds memory overhead and also introduces unrecoverable threats as checksums can also be unprotected.
There are also a number of co-designed algorithms custom for DNNs specifically. For example, activation clipping is a common strategy to limit intermediate values from catastrophic failures due to floating-point exponent bit flips [23, 24, 25, 26, 27]. The downside is this manual clipping primarily protects classification models and leaves regression-based tasks underserved. This is because, unlike classifiers, regression models do not exhibit terminal-phase neural collapse [28] and depend on both the direction and the magnitude of latent vectors. Amplitude clipping used to harden classifiers [29] can be damaging, inert, or too rigid for regression. Furthermore, a quantization of the model at deployment time (such as to INT8) often alleviates most of the risks in these catastrophic failure modes by reducing the radiation sensitivity and dynamic cross-section of neural networks [30, 31, 32], at a cost of absolute model performance. However, in the current state, most production models undergo quantization before deployment for inference throughput and hence act as a double protection against faults.
This leaves the remaining bits to carry more significance in the performance of the model. This changes the risk profile as it has been shown that single bit upsets are more likely to cause critical failures [31, 32] where small targeted attacks on quantized models can dramatically increase the damage [33, 34, 35]. However, it is not always true that bit significance correlates to fault sensitivity. In PrioriFI [10], it was shown that bit-level monotonicity (a more-significant bit is always more damaging) fails for a large fraction of pairwise comparisons on quantized edge NNs, once downstream nonlinearities mask the larger integer step. In studies like PrioriFI and FKeras [12] a thorough ranking of bits was determined via direct sensitivity measurements so that designers can efficiently target TMR or ECC on the most important subset of bits for selective hardware hardening. Other methods of determining selective hardening include BinFI, which locates SDC-causing bits by search [36]; Aspis and related gradient heuristics rank weights [37]. Beyond the passive hardening of designs, there are also active techniques as well. These methods include active checks on quantile markers for silent data corruption [38], in-place zero-space ECC [39], functional ECC [40], and weight-scaling [41, 42].
Another direction in hardening neural networks is to teach them the environment they will be deployed in at training time, called Fault-Aware Training (FAT). Fault-injection frameworks like Li et al.’s error-propagation study [43] and Ares [44] have laid the foundation in software-simulated bit flips. These injection methods are then folded in during training [45, 46, 47, 48]. The most related FAT strategy is Stutz et al. [49] where they trained quantized networks against random bit errors in stored weights and combined that with weight clipping. Cavagnero et al. harden networks by fault-aware training and clipped activations at zero inference storage [24], and Chen et al. restrict ranges after training [25]. Table 3 includes standalone unaligned surrogate FAT, with the alignment penalties and both runtime heals removed. Unaligned weight-bit-flip FAT and in-place zero-space ECC are still not arms. The goal is to regulate and harden the representation.
| Dataset | Full | No wt. heal | No act. heal | No heal | Unaligned | Gain | Vs. unaligned | Clean |
| CalHousing | 15.9% | 8.0% | +0.3% | |||||
| Friedman | 23.5% | 14.0% | +1.0% | |||||
| SDSS | 22.3% | −0.2% | +0.4% | |||||
| JetPt | 23.2% | 23.1% | +0.1% | |||||
| CMAPSS | 33.7% | 25.4% | −0.2% | |||||
| CHF | 22.0% | 11.9% | +1.6% | |||||
| Mean | 23.4% | 13.7% | +0.5% |
Table 3. Native-unit excess on , meanstd across seeds. Not normalized by the unprotected integral. Gain is (No heal − Full)/No heal from unrounded values. Unaligned is a from-scratch retrain with the alignment penalties and both runtime heals removed; the surrogate curriculum and range penalty stay. Vs. unaligned is (Unaligned − Full)/Unaligned. Clean is the fault-free RMSE change from toggling the heal on one frozen aligned checkpoint. The SDSS row uses the colors , , , , and .
There have also been successful implementations of co-designing hardware with DNNs. ECON-T demonstrates a rad-tolerant NN ASIC [50] that runs a quantized NN while supporting full datapath TMR plus full-module TMR with autocorrect on the C weight store on a real beam line [51]. That ASIC is the specialized-hardware reference for true TMR. The complementary case, and the target of this paper, is an unmodified commodity processor.
Problem Statement
With all the major advances towards safe, reliable execution of DNNs against radiation faults, there remains an underserved sector. Particularly, how one might cheaply, on commodity commercial off-the-shelf (COTS) hardware, protect quantized neural networks against MBUs with a memory-light, architecture-independent method that preserves internal representation magnitudes critical for regression tasks.
Methods
The repair is arithmetic on the weights and activations already used at inference, so it runs as software on generic compute rather than in specialized radiation-hardened silicon. We outline that solution in three parts. First, we lay the foundations by discussing our fault injection simulation in Section 4.1 as groundwork for how we benchmark our models. Then we propose our new technique of Projection Healing that actively corrects the weights and activations at runtime in Section 4.2. Alongside runtime protection, we also discuss FAT curriculum training that builds on top of established practice with an alignment penalty that routes signal to where the healing mechanism can recover it in Section 4.3.
MBU Simulation
To simulate in software the effects of bit flips that would occur in hardware, we proceed by corrupting the binary representation of stored parameters. We assume a row-major fan-in storage layout common for PyTorch Linear.weight tensors. Here a strike location is picked uniformly across the bit address and a contiguous burst of bits is flipped. Since the multiplicity is not fixed and depends on a variety of parameters (incident angle, energy, materials, etc.) we simplify the modeling by assuming it follows a truncated discrete power law of on , with and . We motivate the selection of the distribution’s parameters by setting 33% of strikes to be multi-bit ( bit) which amounts to . We read the checkerboard entries in Table II of [52] as the share of upset events that are multi-cell, MCU/(MCU + SEU), and match that share to . At our operating point those odds are , while . The mean multiplicity is and the median multiplicity is 1. Here these numbers are derived from the study’s CORIMS simulator. Appendix § 10 details how sensitive these results are to our choice in parameters.
At injection time, we corrupt stored INT8 weights and per-tensor INT8 biases. Per-channel weight scales (used to de quantize) remain protected float metadata and are not struck for our experiments. Biases are one-dimensional and are not passed through the row projection. The activation heal is their downstream correction, together with weight faults the weight gate misses, including the structurally inert fc weight heal. Transient activations are never injected. When benchmarking, the corrupted INT8 data is dequantized into floating point right before inference.
Latent Space Redundancy: Projection Healing
To achieve active corrections live during runtime, we implement the idea of Projection Healing. Projection healing’s primary goal is to detect corrupted vectors and rebuild affected coordinates under the assumption they should live in a low-rank subspace shown in Figure 1a,Figure 1c. This mechanism wraps around the linear layer backbone of a standard MLP and it requires no additional parameters or restrictions on layer width. We achieve this by aligning, at training, clean representations into the low-rank “Green space” so that injected fault noise is left occupying the orthogonal complement denoted as a “Red space”.

Figure 1. System architecture. (a) Two-pass projection healing on a row. The first DCT-II reconstruction forms the syndrome, the gate sets the blend weights, and a second projection of the surviving coordinates supplies the repaired entries. The weight-alignment term shown is . (b) Training uses four forwards: a clean pass, a contiguous input-block mask, a contiguous weight-block mask, and a contiguous weight sign flip. The range penalty is analytic on the weight rows, and the loss keeps the projection-healing terms separate from the fault-aware terms. (c) A hidden layer heals its weight rows, heals the pre-activation, and then applies the nonlinearity. The drawing continues through the next weight matrix to the clean output.
The choice in this low-rank subspace needs to be made ahead of time and also needs to be chosen so it can be reliably computed on the fly at runtime without dependence on stored parameters. To do this we chose the type-II Discrete Cosine Transform (DCT-II). DCT-II satisfies the constraint of providing a reliable runtime computable/checksummable basis while the type-II was chosen as it is the most common published type. We know we can do this because neuron ordering in an MLP is arbitrary and any fixed rank- orthogonal basis can align with the data should training forcefully route the model in such a way (§ 5.2.2). This is where the FAT alignment penalty comes into play (§ 4.3) where we force 95% of clean activation signal into the low-rank subspace. For each layer we set a fixed Green rank , forming with . Appendix § 14 sweeps this dimension against the clean-accuracy tax.
Robust Projection
To actually carry out the projection mechanism, we understand that any single injection only weakly changes the direction of the whole vector. Thus a standard projection would retain some fraction of the perturbation post-projection reconstruction which can continue to poison downstream inference. Thus we implement a robust single-pass projection for each row in the weight matrix and output hidden vector . The robust projection first forms a provisional reconstruction and a per-coordinate syndrome normalized by the peak amplitude of the row:
In our implementation we use in this denominator, in the concentration test, in the red-energy ratio, and as the range-penalty floor. We then define a row-level master switch which is a function and a coordinate-level correction . Firstly, a row is flagged only when its peak score is both large and concentrated:
with . However, we know a priori that certain coordinates of this vector need to be corrected; we can surgically make this correction by applying a per-coordinate gate defined by a scaled and shifted sigmoid .
For our experiments we use for activation healing, and weight-row healing uses . Appendix § 11 sweeps the weight-gate center parameters and marks as that operating point. We chose where the logistic is a near-hard switch on both paths. The DCT-II basis is a closed form of , is checksummable, and can be regenerated rather than stored as persistent model state. Flagged coordinates are down-weighted to form a surrogate , from which an uncontaminated reconstruction is derived, yielding the healed row:
The intuition behind the need for a double reconstruction is that if we used a single projection it would both see the spike and keep a piece of it. So we need the second pass there so the repair is constructed from the coordinates that were not corrupted. If we projected once, it would have mixed together corrupted signal instead of surgically removing it. However, during training, projection healing is not active and instead there is a simple alignment regularization applied instead.
Weight Healing
Now that we have a mechanism for healing, at inference we apply it to every weight row before the linear map, including the readout. Healed values are not written back to the INT8 SRAM and instead they live in the float working copy that dequantizing inference already materializes. The heal therefore sees whatever INT8 damage has accumulated since the last golden-copy reload, and it repairs only the coordinates the gate can flag, not the whole image. In the benchmark that snapshot is injected in one go. Because nothing is written back, that one-shot dump is the same stored state as strikes arriving over time on SRAM. We do not model faults in the float working copy, nor a stream of strikes interleaved with inference. For sequential inference, rather than retaining that working copy, the healed INT8 image can be written back on a tunable cadence. § 5.4 and Appendix § 8 give the cost of one writeback every iterations.
Fault Aware Training
To turn the projection healing live we need to apply FAT to our model. Firstly we build on top of established FAT practice [24, 45, 47]. Since MBUs cascade across adjacent bits, each corrupted forward draws one contiguous block, not independent Bernoulli dropout and not a two-dimensional sub-block. The input mask zeros a contiguous 25% of features. Separately, every linear layer from through receives one contiguous fan-in block: zeros on 25% of columns, or, on a different forward, sign inversion on 15% of columns. The weight-block and sign-flip passes are not applied together. This ensures we do not overly rely on any particular input feature for estimation. We note that this is mismatched to how our evaluator injects faults. In fact, these simulate spatial MBUs but are not true INT8 bit flips; they do not follow the power-law multiplicity (Appendix § 10). This was intentionally done so that training never observes the fault distribution it is graded against and cannot overfit to a particular process. We also verified in Appendix § 12 whether this mismatch leaves performance on the table and we observe a small 3.3% difference in mean excess AUC at the nearest available curriculum severity. In direct comparison to DieHardNet [24], which corrupts intermediate feature maps for noise tolerance, we corrupt structural weights to simulate SRAM and DRAM flips directly. At training time to ensure stability we regularize the network by the squared deviation between the clean prediction and predictions under input-block masking , weight-block dropout , and sign flips .
Beyond the standard fault injection we also have the important alignment penalty. First, we probe individually the pre-activations and quantify on average how much of the vectors live outside of the “green” subspace . By first computing the normalized orthogonal syndrome for a against the assumed DCT-II basis ,
A minibatch of clean pre-activations is scored with the fan-out basis of length ,
Next, we define a similar metric for the weights. Depth weights reduce early-layer pressure. The activation hinge in Eq. (8) sums over the three hidden layers and excludes the scalar readout. Width scales are with over those three hidden widths. Weight matrices are scored row-wise with the fan-in basis of length , then averaged over output neurons and over :
With these quantified metrics and we use hinges above a dead zone to hold residual Red content at a measured operating point without degrading clean accuracy. The activation hinge loss is applied per layer before the weighted mean; the weight hinge is applied after averaging across layers giving us penalty metrics and . We note that layer is excluded from the weight-alignment sum due to small fan-in.
We also constrain the weight ranges in the network via a range penalty. We want to ensure that the weights do not vary drastically, which could make the healing mechanism falsely identify corrupted bits. A range penalty is applied on every Linear layer, including , by penalizing the ratio of peak to mean absolute weight, with the readout weighted three times more heavily than hidden layers:
Together, the full objective separates the alignment terms from the FAT terms:
FAT coefficients scale dynamically via an exponential moving average of task MSE, and is annealed over the first 40 epochs. The six base multipliers were tuned once on a development split to balance clean accuracy against alignment, and kept fixed across all datasets. For our work we chose to use as the plateau values for . Here the red coefficient ramps linearly, , and is not decayed afterward. We set other parameters , , , , and . Both the alignment group and the FAT group are multiplied by an exponential moving average (EMA) scale factor , where and the reference MSE is 0.25. Training is AdamW at learning rate , weight decay , minibatch size 256, dropout 0.1, LeakyReLU negative slope 0.01, and gradient clip 1. Optimization runs for at most 500 epochs with ReduceLROnPlateau (factor 0.5, patience 5, floor ) and keeps the best validation checkpoint.
Benchmarking Protocol
For our benchmarking test, we use six regression-specific datasets. The first two are generic tabular benchmarks and the remaining four are domain problems. The generic tabular datasets are California Housing [53], which predicts house values, and Friedman #1 [54] (), which provides a nonlinear synthetic target. The other four datasets are SDSS photometric redshift, which predicts continuous from the reference magnitude and the colors , , , and [55, 56], targeting spaceborne observability. NASA C-MAPSS FD001 [57, 58] predicts Remaining Useful Life from turbofan sensors. NRC Critical Heat Flux [6] predicts boiling-crisis thresholds from the public US NRC critical heat flux tube database (NUREG/KM-0011). CMS Jet regresses generator-level jet transverse momentum from the EnergyFlow CMS2011A Jets MOD HDF5 simulation sample (companion to the CMS 2011A Open Data jet record) [59, 60, 61], an off-detector trigger-side HEP task [62]. Per-dataset architectures and INT8 footprints are detailed in Appendix § 9.
Features and targets are standardized for training. Predictions are inverse-transformed to native units for reporting RMSE. Post-training, weights are quantized to symmetric per-channel INT8; activations remain floating point.
Evaluation Metrics
We define the MBU intensity as the fraction of corrupted weight bits since the last scrub
where follows the truncated power law of Eq. (14) at , , and .
We report three metrics. Firstly, RMSE degradation evaluates held-out RMSE against a logarithmically swept . Second, Operational and breakdown thresholds are the intensities at which median RMSE rises , , or above each model’s own clean baseline. Here means this own-baseline threshold. And third, Relative excess AUC integrates against for , scaled by the unprotected curve’s integral, where is the best clean RMSE across models. A value below 1 indicates less excess error. Note that some results report the unnormalized native-unit excess , or the absolute integral as opposed to the relative in order to characterize absolute performance. Those are identified in each caption. Thresholds use each model’s own clean RMSE; excess AUC uses the shared floor . The two conventions diverge when the alignment tax already exceeds the operational tolerance.
Each intensity data point represents a median of 400 independent MBU realizations. The tables report meanstandard deviation across 8 seeds of each per-seed median of 400 individual realizations.
Results
To gauge the performance of our design we investigate the benchmarking results first in § 5.1 and then isolate the mechanisms in Sections 5.2.1, § 5.2.2, 5.2.3, and 5.2.4. Lastly, we investigate bit-level sensitivity in § 5.3.
Benchmarking Results
We first investigate trends in model performance as a function of intensity. In Figure 2 we see across the 6 regression benchmarks that all models trend towards higher error rates monotonically. The unprotected quantized INT8 network consistently degrades the most rapidly, while comparative benchmark models like RedNet and Diehard (implementations of the published methods; see Appendix § 15) provide intermediate protection. Likewise with classically protected ECC weights (SECDED+Interleaved) but all models collapse once MBUs become dominant at higher . Nearly all models later become indistinguishable from an untrained network at –. Thus characterizing performance is really about the approach towards that collapse.

Figure 2. MBU sweeps on six datasets ((a)–(f)). Log x-axis: accumulated weight-bit fraction over . Linear y-axis: held-out test RMSE in native target units (mean across 8 seeds; shaded bands are across-seed std). Curves: unprotected, Clipped, Ranger [25], SECDED+interleaving, RedNet, Diehard, and Our Model (RedNet/Diehard are proxy implementations; Appendix § 15). The dashed line is the untrained-random floor and the gray band is the uninformative region above it. Ranger matches Clipped by construction under INT8 (Appendix § 15). SECDED dominates at low then saturates; Our Model stays below the software defenses longest. The SDSS panel uses the color features of § 4.4.
Beyond visual comparisons, we can quantify the improvement by computing the relative excess area under the curve (AUC). Table 1 shows two stacked panels (a) the early operational window () and (b) the wide window (). We see that in the early operational stage () the effects are nearly flat. This is due to the effects being dominated by SEU-like disruptions and is thus a prime setting for classical algorithms like SECDED with interleaving to shine, producing a median excess AUC of 0.49 vs. our proposed model’s 0.76. The operational-window mean for our method is 1.11, worse than the unprotected baseline of 1.00, because SDSS and CMAPSS dominate the average. On CMAPSS the unprotected excess over this window is near zero, so a small clean gap above the shared floor inflates the ratio. The median, 0.76, is the summary we use for that window. However we see that this picture changes once we consider the complete window ranging from . Here when MBU becomes a dominant source of error we see that our model still maintains a wide-window mean 0.71 (median 0.72) vs. SECDED 0.99 where single-bit correction is insufficient. We also see that the other models, DieHard and RedNet, are also effectively inert at in the wide-window regime but still yield meaningful gains over a standard ECC or unprotected network as they incorporate FAT and specialized layer ordering to combat these faults.
| Dataset | Clipped | Ranger | RedNet | Diehard | SECDED | SECDED(b7) | Ours |
| CalHousing | 0.99 ± 0.05 | 1.03 ± 0.11 | 0.92 ± 0.17 | 0.60 ± 0.15 | 0.46 ± 0.04 | 0.66 ± 0.02 | 0.47 ± 0.15 |
| Friedman | 1.00 ± 0.00 | 1.00 ± 0.00 | 1.38 ± 0.30 | 0.79 ± 0.21 | 0.53 ± 0.08 | 0.56 ± 0.07 | 0.60 ± 0.30 |
| SDSS | 1.00 ± 0.29 | 1.03 ± 0.09 | 1.20 ± 0.55 | 0.96 ± 0.41 | 0.44 ± 0.15 | 0.64 ± 0.11 | 1.13 ± 0.61 |
| JetPt | 1.00 ± 0.00 | 1.00 ± 0.01 | 2.72 ± 1.90 | 1.64 ± 1.02 | 0.55 ± 0.11 | 0.57 ± 0.11 | 0.69 ± 0.59 |
| CMAPSS | 1.00 ± 0.00 | 1.00 ± 0.00 | 0.81 ± 1.78 | 3.44 ± 6.17 | 0.81 ± 0.29 | 0.81 ± 0.30 | 2.96 ± 4.61 |
| CHF | 1.00 ± 0.00 | 1.00 ± 0.00 | 0.95 ± 0.13 | 0.75 ± 0.08 | 0.42 ± 0.02 | 0.64 ± 0.04 | 0.82 ± 0.14 |
| Median | 1.00 | 1.00 | 1.07 | 0.88 | 0.49 | 0.64 | 0.76 |
| Mean | 1.00 | 1.01 | 1.33 | 1.36 | 0.54 | 0.65 | 1.11 |
| Dataset | Clipped | Ranger | RedNet | Diehard | SECDED | SECDED(b7) | Ours |
| CalHousing | 0.94 ± 0.06 | 0.96 ± 0.05 | 0.78 ± 0.12 | 0.75 ± 0.15 | 0.98 ± 0.01 | 1.00 ± 0.01 | 0.58 ± 0.10 |
| Friedman | 1.00 ± 0.00 | 1.00 ± 0.00 | 0.96 ± 0.02 | 0.98 ± 0.02 | 0.99 ± 0.00 | 1.00 ± 0.00 | 0.79 ± 0.02 |
| SDSS | 0.97 ± 0.04 | 0.98 ± 0.03 | 0.91 ± 0.17 | 0.88 ± 0.14 | 1.00 ± 0.01 | 1.01 ± 0.01 | 0.71 ± 0.10 |
| JetPt | 1.00 ± 0.00 | 1.00 ± 0.00 | 0.95 ± 0.02 | 0.99 ± 0.02 | 1.00 ± 0.00 | 1.01 ± 0.00 | 0.78 ± 0.02 |
| CMAPSS | 1.00 ± 0.00 | 1.00 ± 0.00 | 0.89 ± 0.03 | 1.00 ± 0.02 | 1.01 ± 0.00 | 1.01 ± 0.01 | 0.69 ± 0.04 |
| CHF | 1.00 ± 0.00 | 0.99 ± 0.01 | 0.89 ± 0.08 | 0.88 ± 0.07 | 0.98 ± 0.00 | 1.00 ± 0.00 | 0.73 ± 0.07 |
| Median | 1.00 | 0.99 | 0.90 | 0.93 | 0.99 | 1.00 | 0.72 |
| Mean | 0.98 | 0.99 | 0.90 | 0.91 | 0.99 | 1.00 | 0.71 |
Table 1. Normalized relative excess AUC, divided by the unprotected integral. Sampled knots begin at . (a) Early window through . (b) Wide window through 1. Lower is better. Entries are mean±std across eight seeds. The early-window mean is unstable where the unprotected denominator is near zero; use the median row there. (a) Operational window (). (b) Wide window ().
We can also measure the breakdown and degradation thresholds in Table 2 which reports the intensities at which median RMSE rises , , and above each model’s own clean baseline. We see that at we extend the median interval by over the unprotected baseline so the healing mechanism does suppress early dominant errors similar to that of the classical
| Dataset | Unprot. | SECDED | Ours | Unprot. | SECDED | Ours | Unprot. | SECDED | Ours |
| CalHousing | |||||||||
| Friedman | |||||||||
| SDSS | |||||||||
| JetPt | |||||||||
| CMAPSS | |||||||||
| CHF | |||||||||
| Median Extension | – | – | – |
Table 2. Exposure intensity at which median test RMSE rises +5%, +10%, and +50% above each model’s own clean baseline, not the shared unprotected floor. Bold indicates the largest . The +50% column is , not untrained-network collapse. +5% RMSE (Operational); +10% RMSE (Degraded); +50% RMSE (Breakdown).
SECDED error-correcting method. However we see classical performance drop as the model experiences more faults as SECDED eventually loses its lead at the 10–50% degradation stages while our method maintains the lead over unprotected.
Despite these gains in robustness, routing capacity into the low-rank subspace incurs an “alignment tax” on fault-free held-out RMSE, (Ours − Unprot)/Unprot. Across the six datasets the median tax is +0.3% and the mean is ∼2%, with CHF the only material outlier (+11.8 ± 5.8%); the other five sit within a few percent and are consistent with zero within seed scatter. CHF therefore begins at already beyond the unprotected model’s +5% and +10% RMSE budgets. Its own-baseline +5% intensity is a drift from that degraded clean floor. Against the shared floor the stored CHF means give +12.4%, and the shared-floor +5% threshold is on all eight seeds. We do not convert the CHF own-baseline threshold into a calendar lifetime at the unprotected clean RMSE. Relative to the 10–50% RMSE degradations that define the operational windows, this trade-off is negligible except on CHF.
Ablation Results
Given the improvements over other baseline techniques, we seek to pin down the weight-bearing mechanism providing the performance improvements. We first check the projection healing mechanism over FAT in Section 5.2.1, then the basis and MAD comparison (§ 5.2.2), then single-component removals (Section 5.2.3). Per-bit gate coverage is § 5.3.
Contribution of the Runtime Heal Beyond Fault-Aware Training
Since it has been established in the literature that FAT can substantially improve model robustness, we isolate the two possibly confounded mechanisms from each other by ablating the two. We isolate the projection heal by holding a fully FAT-trained checkpoint fixed and toggling projection healing to be off. Any performance difference is then due to the runtime mechanism. The 23.4% figure is the mean of (No heal − Full)/No heal on the native-unit excess integral in Table 3, from 22.3% on SDSS to 33.7% on CMAPSS. Against standalone unaligned FAT the same full stack averages 13.7%, a tie on SDSS (−0.2%) and 25.4% on CMAPSS. Clean is the fault-free RMSE change from toggling the runtime heal on that same frozen checkpoint. We also see that removing the activation heal still hurts under weight-only injection because unflagged weight faults propagate into pre-activations where the activation gate can repair them.
MAD Despike and Basis Swap
To verify that our surgical healing mechanism with projections cannot be trivialized via simpler statistical methods, we implement a MAD despiker. By holding the FAT curriculum and alignment fixed, we replace the masked projection with per-row MAD median fill. Here the fixed training objective includes the penalty, which penalizes the ratio of row peak absolute weight to row mean absolute weight, aligning it to the MAD despiker mechanism by suppressing extreme clean feature values, protecting it from spuriously amputating legitimate heavy tails. We see that MAD despiker cannot replicate our performance in Table 4 as, under the same absolute re-integration used for the basis swap, MAD is strictly worse on all six (–).
| Full (DCT) | Arbitrary basis | MAD despike | |
| CalHousing | 2.24 | 2.22 (0.99) | 2.87 (1.28) |
| Friedman | 5.38 | 5.02 (0.93) | 10.05 (1.87) |
| SDSS | 0.10 | 0.11 (1.09) | 0.12 (1.22) |
| JetPt | 101.4 | 98.6 (0.97) | 120.3 (1.19) |
| CMAPSS | 65.8 | 64.5 (0.98) | 70.6 (1.07) |
| CHF | 1529 | 2721 (1.78) | 2843 (1.86) |
Table 4. Absolute integral in native target units. Parentheses are the ratio to the DCT column. Lower is better. CHF, not the other five datasets, is sensitive to the basis.
Arbitrary fixed orthogonal basis. We also verify whether our choice in the DCT-II basis is privileged and potentially “overfitted” to this problem by checking if we chose a random arbitrary orthogonal basis if we could replicate similar performance. Table 4 shows near-parity on four datasets, CHF is the exception: the arbitrary basis is worse, in the same direction as its +11.8% alignment tax. Our choice in DCT-II basis remains rooted not in performance gain but in the fact that it is an analytic closed form, that can be reproduced with bit-exactness and it can be audited against a published definition and checksummed in flight. The pseudorandom basis chosen for the experiment does not have such similar properties as either the basis needs to be stored (exposed to faults) or the basis needs to be orthogonalized on the fly where bit-exact regeneration is not guaranteed and can be slow compared to closed-form methods closed-form cosines against Gaussian sampling followed by an orthogonalization.
Single-Component Removals
Lastly, we investigate dropping single mechanisms and retraining models from scratch to see how they individually affect performance. In Table 5 we see that removing weight alignment is the single most damaging variation: the heal needs that aligned low-rank subspace. While removing the range penalty is slightly better on the mean. We see that precision is better on Friedman, SDSS, JetPt, and CMAPSS, tied on CHF, and worse on CalHousing. The other removals degrade the mean. Here the no-weight-align arm has a mean 1.83, which is the evidence that the runtime heal fails without the aligned subspace.
| Configuration | CalH. | Fried. | SDSS | JetPt | CMAPSS | CHF | Mean |
| Unprotected | 1.00 | 1.00 | 1.00 | 1.00 | 1.00 | 1.00 | 1.00 |
| Full (Ours) | |||||||
| No concentration flag | |||||||
| No act. heal | |||||||
| No weight heal | |||||||
| No weight align | |||||||
| No act. red | |||||||
| No MBU loss | |||||||
| No range pen. |
Table 5. Normalized relative excess AUC, same definition as Table 1, on knots from to 1. Lower is better. Each column is a from-scratch retrain except the unprotected reference.
Generalization to Unseen Fault Models
We replace the surrogate FAT curriculum with an exact evaluation fault injector, to check that the reported resilience is not an artifact of matching the training curriculum to the evaluation distribution (Appendix § 12). We see that across the six-dataset geometric mean excess AUC differs by only 3.3%. Note that this 3.3% does not measure unaligned weight-bit-flip FAT. The no-heal column of Table 3 still contains the alignment penalties. The no-weight-align row of Table 5 removes subspace alignment but is still our surrogate curriculum with eval-time healing.
Per-Bit-Position Damage and Detection
Since half the battle of designing a healing mechanism is detecting where and when to correct a parameter, one key metric is to uncover how sensitive the mechanism is to weight corruption at the bit level. In Figure 3(a) and Figure 3(c), bits 0–5 contribute little SBU damage and bits 6 and 7 dominate. The parenthetical values < 0.01 and 0.04 are gate-detection excesses from Figure 3(b) and Table 9, not the damage axis of Figure 3(a). Under a fixed burst width , the sign bit accounts for most of the plotted damage. Pooling the six-dataset mean relative-RMSE damages it gives a share of 12.8% (bits 0–5), 31.6% (bit 6), and 55.5% (bit 7). This makes sense as under INT8, bit 7 is the largest step in the word, so we calibrated the gate to the band where active reconstruction is both feasible and consequential in Figure 3(b) and Figure 3(d). The sharp change between bits 6 and 7 is attributed to the syndrome algebra of § 4.2. A coordinate is corrected only when its row is flagged and the coordinate itself clears the gate center, .

Figure 3. Per-bit-position curves on the six published checkpoints. (a) SBU relative RMSE damage vs. bit index. (b) SBU row-level gate detection excess vs. bit index (dotted: raw fire rate). (c)–(d) Short bursts () with forced start bit: relative damage and baseline-corrected false-negative rate vs. start bit. Low-order bits are nearly silent; the sign bit dominates both damage and detection.
| Bit 6 | Bit 7 | FPR (%) | Cost (%) | Rel. AUC | |
| 0.04 | 0.27 | 0.58 | 24.7 | 23.9 | – |
| 0.08 | 0.27 | 0.58 | 24.7 | 13.6 | – |
| 0.12 | 0.27 | 0.58 | 24.7 | 8.6 | – |
| 0.14* | 0.27 | 0.58 | 24.7 | 6.6 | 1.10 |
| 0.20 | 0.21 | 0.62 | 22.0 | 3.1 | 1.04 |
| 0.27 | 0.09 | 0.71 | 15.0 | 1.3 | 1.01 |
| 0.35† | 0.04 | 0.77 | 9.1 | 0.5 | 1.00 |
| 0.45 | 0.02 | 0.74 | 5.1 | 0.1 | 1.01 |
| 0.57 | 0.01 | 0.62 | 2.6 | 0.0 | – |
Table 9. Weight-gate center sweep at on seed 0. Bit columns are row-detection excess. FPR is the zero-fault row fire rate. Cost is the clean-RMSE penalty versus the heal-off end. Rel. AUC is the ratio to . Dashes are ladder ends without that ratio. The dagger is the weight operating point, not the activation center .
However, this would call into question the need for projection healing if only a few bits require real protection, which should be easily achieved via classical ECC. To address this we benchmark this specific case with a dedicated SECDED(b7) arm in Table 1 where we specifically target ECC protection on the sensitive signed bit and we discover that, over the full window, our model still outperforms the targeted bit protection. This is because the leftover bits still add up since even if bit 7 is the largest single step, it is not the total error. Bits 0–5 are 12.8% of pooled SBU damage and bit 6 alone is 31.6%, using the aggregation above. SECDED(b7) leaves those unprotected. So at low enough lower-order bits are also flipped that the unprotected remainder dominates. This argument can still appear contradictory as it appears from Figure 3(b) and Figure 3(d) that the projection healing mechanism is predominantly sensitive to perturbations in bit 7. The key here is understanding this does not make the mechanism identical to SECDED (b7). This is because projection healing can correct all bits at once, while ECC is restricted to just 1 bit to correct. So under high multiplicity, bit 7 can often be flipped, which triggers both mechanisms (ECC and projection heal) but the damage is often not just bit 7 but multiple. Both methods equally detect the syndrome, but only the projection heal can apply the actual remedy. Hence we see performance improvements over SECDED (b7) at high intensity in Table 1.
Overhead
Projection Healing adds an activation heal on every inference and a weight heal only at scheduled writeback. If the weight image is scrubbed once every inference iterations, its projection cost is amortized by . We use as an illustrative accounting cadence. On the square , reference, the resulting average is 2.5× baseline multiply-accumulates at batch size 1 and 2.002× at batch size 256, reported as 2.5× and 2.0× in Table 6. The persistent model remains 1.0× INT8 with no long-lived FP32 replica; a transient 4× FP32 buffer exists only during each scrub. Appendix § 8 gives the closed form.
| Method | Persistent ROM | ||
| Unprotected | |||
| Hardware TMR | |||
| SECDED+intlv (72,64) | |||
| SECDED(b7) UEP | |||
| Clip. / Diehard | |||
| Ours (heal every pass) | |||
| Ours (writeback, ) |
Table 6. Square-layer reference (, ), with both projection passes always executed. Healing weights on every iteration costs . Periodic INT8 writeback every iterations amortizes the weight term to . “ROM” counts persistent model storage; periodic writeback uses a transient FP32 buffer during the scrub but retains no FP32 weight replica. Requantization, checksum, memory-traffic, and atomic-write costs are excluded.
Discussion
Comparisons
We see across multiple datasets that projection healing provides measurable and significant improvement in reliability against MBU threats on static weights at high intensity regimes. We demonstrate this by isolating the mechanism and found that models receive a reduction in the native-unit excess integral of Table 3 in absolute terms. Across all datasets the method extends the operational scrub interval by a median of at a RMSE degradation and at , compared to and for classical Single Error Correction, Double Error Detection (SECDED). We further demonstrated that although significant bits are the primary damage contributor, strategically correcting those bits (SECDED (b7)) underperforms at high intensity regimes as multiple bits still remain uncorrected.
We also demonstrated when compared to other models designed specifically for radiation-hardening techniques like DieHard and RedNet that those methods also fall short. In the wide window, Table 1 shows mean relative excess AUC near 0.9 for RedNet and Diehard and 0.71 (median 0.72) for our method. That is further protection beyond those proxy baselines, whose main inference-time mechanism is activation bounding.
Operational Environments
We seek to characterize these improvements in real operational environments in order to translate measured gains to what might be theoretically expected on the field. Firstly, we know that can be interpreted as accumulated corruption until the weight image is scrubbed, thus the real practical payoff made possible is a longer window before a golden-copy reload is required. We seek to produce an illustrative conversion of performance into real calendar time in various settings.
Firstly, we model as a cumulative exposure with standard cross-section with flux , per-bit cross-section , and exposure . For COTS sub-100 nm CMOS SRAM, to high-energy hadrons is of order , with node-dependent scatter of roughly an order of magnitude [14, 52]. Mean multiplicity cancels between in Eq. (12) and an empirical per-bit upset rate only when that rate already folds in .
In low Earth orbit, at upsets per bit per day [63], the CHF own-baseline intensities are (1.7 years) and (6.0 years). Those times measure drift from each model’s own clean RMSE. CHF already carries an alignment tax, so a budget measured from the unprotected floor is exhausted at .
Commercial avionics (12 km). At upsets per bit per hour [3], a -hour lifetime accumulates only , orders of magnitude below where even unprotected baselines degrade measurably, so the defense is unmotivated for benign aerospace and terrestrial use.
Reactor core instrumentation. Fluxes of – [64] give , so a parameter bank reaches in one second and in three.
Scope and Limits
Despite the success presented, there are also clear limitations where this method proves to be neutral compared to other methods specifically at the low-intensity regimes where SBU dominates. We have shown that in lower intensity regimes, classical error-correction codes work in protecting these models, like with SECDED, when dominant errors are introduced by SBU rather than MBU. MBU becomes an issue at high intensity when the tail of MBU becomes problematic for single-bit correction to catch up.
Furthermore, this method only makes operational sense in engineering regimes where specific trade-offs deem it necessary. At the illustrative cadence, average square-layer arithmetic is at batch size 1 and at batch size 256. On the six published widths the analytic single-sample range is –. The persistent footprint stays at INT8, but the scrub still needs transient workspace and reliable atomic writes. The cadence is not a measured radiation guarantee and must be tuned to the deployment upset rate. This could prove attractive in certain sectors where lead times are high, specifically given that advanced chip manufacturing is becoming a multi-year endeavor.
There also remain architectural limitations as well. We know that alignment with the pre-determined subspace comes at a cost in absolute model performance. This method also only makes sense if one’s science case can tolerate a median and mean clean-RMSE tax, with CHF at as the worst case, for added survivability over the duration of its deployment time. Furthermore, the healing mechanism only works when FAT has aligned the subspace (the no-weight-align arm in Section 5.2.3 and Table 5, not the frozen-checkpoint toggle in Section 5.2.1). This means pre-trained models cannot be post-corrected by updating their gradients to realign their weights to the predetermined subspace. This makes the barrier to entry larger than passive techniques like simple error correction.
Conclusion
In this work we introduce Projection Healing, a software mechanism that corrects corrupted INT8 weights and pre-activations at runtime on unmodified commodity hardware. The mechanism works by projecting corrupted vectors into a protected low-rank subspace made possible by routing the network through this subspace via FAT-aligned training regularization. With periodic INT8 writeback every iterations, the analytic square-layer average is baseline multiply-accumulates at batch size 1 and at batch size 256, while retaining no long-lived FP32 weight replica (Appendix § 8). The cadence and repeated writeback behavior remain deployment parameters rather than evaluated radiation guarantees. We successfully demonstrated across six INT8 regression benchmarks that our method has the lowest relative excess AUC among the defenses we evaluated, which exclude in-place zero-space ECC and standalone unaligned weight-bit-flip FAT (Table 1) which then extends the median scrub interval over unprotected storage at every tolerance we tested (Table 2). Further, isolated on a frozen FAT checkpoint, the heal still contributes an additive gain (Section 5.2.1). Replacing the projection with a MAD despite under the same alignment is worse (Table 4). ECC remains competitive at low intensities, before multi-bit bursts saturate it. We believe our approach can sit alongside selective hardware protection on commodity hardware, where full weight TMR proves too expensive.
Compute Overhead
For a square layer the unprotected matmul costs multiply-accumulates. Each robust heal is two projections, multiply-accumulates, plus an gate. Activation healing runs every iteration, while weight healing and INT8 writeback run once every iterations. Always executing both projection passes gives the average
At , , and , this is at and at . Healing the weights every iteration in the special case , giving and , respectively. On the published shapes, using and no activation heal on the scalar readout, periodic writeback gives single-sample ratios for CalHousing and – for the five wider models; at the ratios are and –. These are analytic multiply-accumulate ratios. They omit quantization, checksum, memory traffic, and transactional-write costs. The reported fault campaign did not run repeated writeback cycles, so it does not establish that is an optimal or safe radiation cadence. The DCT basis is re-derivable and is omitted from the persistent-ROM column.
Model Architectures and Capacities
All six benchmarks use the same three-hidden-layer template of § 4.2: – with LeakyReLU, a linear readout, and INT8 post-training quantization. Widths land near two capacity bands ( parameters for CalHousing, for the rest). Table 7 lists exact shapes, parameter counts, and INT8 footprints. Baselines are evaluated at the same widths so compares equal SRAM cross-sections within a dataset.
| Dataset | Arch. | Params | INT8 bits |
| CalHousing | 18 017 | 144 136 | |
| Friedman | 68 257 | 546 056 | |
| SDSS | 67 257 | 538 056 | |
| JetPt | 68 857 | 550 856 | |
| CMAPSS | 70 457 | 563 656 | |
| CHF | 67 257 | 538 056 |
Table 7. Per-dataset MLP shapes. INT8 bits equal parameter count times 8, counting each bias element as one stored byte. Per-channel scales are extra protected metadata and are not in this count.
MBU Multiplicity Model
Every fault in this paper draws its burst width from a single discrete power-law distribution in Eq. (14). To pick the parameter we wish to strike, we uniformly sample a bit address in the flattened parameter store and flip contiguous bits with set parameters , with some normalization factor .
Physical motivation and parameter choice. Multiplicity in irradiated SRAM is a random variable: one ionizing track may upset a single cell or a cluster of adjacent cells, and measured cluster-size distributions are consistently dominated by single-bit events with a long tail that grows as feature size shrinks and as incidence approaches grazing [14, 15, 16, 52]. We chose a truncated discrete power law since it is the simplest two-parameter family capturing a SBU-dominated distribution with a heavy tail. Given cutoff bits (32 INT8 words) Eq. (14) places in one-to-one correspondence with the multi-bit fraction , so fixing one determines the other. We set and derive . This fraction is the same Table 2 checkerboard event share cited in Section 4.1, 29.1% at 45 nm and 38.5% at 32 nm [52], not a Table 3 citation and not the odds MCU/SEU. Table 8 separates strike fractions from flipped-bit shares. of strikes, while those strikes are only 25.4% of flipped bits. To further motivate our choice in distribution parameter we disentangle injection model impact by studying sensitivity in a sweep documented in Figure 4. Here we re-run the evaluation sweep on the frozen eight-seed checkpoints at five alternative settings spanning and a range in cutoff, with each comparison depends upon the multiplicity spectrum. We report early-onset scrub-interval ratios at the +5% median-RMSE threshold of Table 2, rather than solely wide-window relative excess AUC: in the saturated integral SECDED sits at 0.98–0.99 with almost no headroom, so spectrum dependence of the ECC comparison is invisible there.
| Quantity | Value | Bit share |
| 1.4895 | – | |
| (SBU) | 67.1% | 25.4% |
| 32.9% | 74.6% | |
| 4.90% | 42.9% | |
| 0.82% | 21.8% | |
| 0.09% | 6.3% | |
| Mean multiplicity | 2.65 | – |
| Std. dev. | 7.97 | – |
| Mean INT8 words spanned | 1.21 | – |
Table 8. Properties of the truncated discrete power-law multiplicity on with , . Exact arithmetic, not measurements. The median of is 1. Bit share is the fraction of flipped bits, not the fraction of strikes.

Figure 4. Sensitivity to the assumed multiplicity spectrum. Both axes use . (a) Measured sensitivity of +5% RMSE, derived from Table 2. (b) Sensitivity of the six-dataset mean relative excess AUC over the wide window .
The unprotected comparison is stable: at +5% rarely changing. The SECDED comparison is the sensitive one. At +5%, Ours/SECDED rises from 0.75× at a 10% multi-bit fraction (SECDED ahead) through 1.16× at the assumed 33% to 1.31× at 40%. The advantage over ECC therefore narrows as the environment becomes more single-bit dominated and reverses toward the pure-SBU limit, as Section C argued. The +10% column tracks the same monotone trend. However the knob is nearly inert: a sweep in at fixed keeps the +5% Ours/SECDED ratio inside 1.12×–1.16×. This is to conclude that the assumed operating point does not dramatically benefit our work such that the narrative could have inverted under changes to the modeled multiplicity distribution.
Gate Threshold Sweep
We wanted to experiment how sensitive the gate threshold is. In Table 9 it shows a one-dimensional sweep of the weight-gate center at fixed . Here bit 6 and bit 7 are mean row-detection excess and FPR is the zero-fault per-row fire rate. The cost is the clean-RMSE penalty relative to the heal-off and Rel. AUC is the wide-window excess integral divided by the value. We see that by lowering we can get more detection on these bit 6 faults but performance doesn’t improve as this allows more false positives to sweep in and harm the overall score (Table 9).
Surrogate vs. True INT8 Bit-Flip FAT
Section 4.3 trains under surrogates, instead of direct INT8 bit flips. Here we study the differences this may or may not create. We compare the surrogate FAT against an exact-fault-model variant. To implement the exact bit flips, we first draw INT8 spatial MBUs with exactly the evaluation geometry as our benchmark, and then pass through a straight-through estimator [65] so gradients still reach the float masters. In this experiment, every arm is trained on five seeds, paired on data split and evaluation fault stream, and swept at 200 realizations per intensity knot. We report the nearest available curriculum severity without interpolating between discrete bands. As noted in Section 5.2.4, the aggregate performance difference at this nearest severity is only 3.3% (Table 10), with the direction of the small residual varying by dataset.
| Dataset | BF (orig.) | BF (near) | Surr.+STE |
| CalHousing | 1.09† | 0.88† | 0.98 |
| Friedman | 1.07† | 1.04† | 1.05† |
| SDSS | 0.87† | 0.92† | 0.97 |
| JetPt | 1.14† | 0.89† | 0.94† |
| CMAPSS | 1.15† | 1.06† | 1.07† |
| CHF | 1.07† | 1.02† | 1.02† |
| Geo. mean | 1.06 | 0.97 | 1.00 |
| (0.91–1.03) | (0.97–1.04) |
Table 10. Full-stack curriculum ablation. Every arm still includes subspace alignment and eval-time Projection Healing. Entries are paired ratios of wide-window excess AUC to the published surrogate curriculum; below one favors that column’s arm. BF (orig.) is the original bit-flip severity, about 6× milder than the surrogate. BF (near) matches the surrogate on measured severity. Surr.+STE sends the surrogate masks through the bit-flip arm’s straight-through estimator. A dagger marks a paired bootstrap interval that excludes parity. Parentheses on the geometric-mean row are bootstrap ranges. This is not a standalone unaligned FAT baseline. The SDSS entry in BF (orig.) uses the color features, and that column’s geometric mean has no bootstrap range because BF (near) and Surr.+STE were not rerun.
Architectural Validations and Sensitivity
fc1 Heal No-Op
The first-layer weight heal never fires on these networks. Their fan-ins are only , so a rank-32 DCT keeps every direction except one. That leftover direction spreads a fault almost evenly across the row. The gate requires a sharp peak, , which this even spread cannot produce, so the row is never flagged. Turning the fc1 weight heal on or off is therefore bit-identical. A different basis that discarded a spikier direction could still trigger the gate, and a wider input layer would retain only 32 of directions, so this no-op is specific to the DCT on these narrow layers. The layer is defended by the activation heal on its output, and retaining the call is harmless.
Memory-Layout Sensitivity
In our work we assumed a row-major fan-in addressing, under which a burst walks the fan-in of a single healed row. However other arrangements exist, like column-major addressing, which instead strides across rows at a fixed fan-in index, spreading damage over many healed rows at once. Table 11 reports the ratio of column-major to row-major wide-window excess AUC under fixed burst widths of 3, 24, and 64 bits (1, 3, and 8 INT8 words). At one word the mean ratio is indistinguishable (1.00), as expected when the layouts differ only by a 1–2 bit spill. Wider bursts leave the six-dataset mean near parity (1.01 at three words, 1.00 at eight). JetPt carries the remaining degradation, SDSS stays near parity, and CMAPSS still improves. A further caveat is that physical and logical adjacency differ: production SRAMs bit-interleave and scramble addresses so that a physically contiguous multi-cell upset lands in several logical words [15, 52]. Our injector draws bursts contiguous in the flattened logical address space, which is pessimistic for the interleaved SECDED baseline (it defeats the interleave more often than physical clustering would). Table 11 shows the opposite direction for Projection Healing: A ratio above 1 means column-major striding raises wide-window excess AUC relative to row-major. Spreading a burst across rows can drop each row below , so scrambling would be expected to help SECDED and slightly hurt the row-local heal. “Interleaving” elsewhere in the paper means SECDED word interleaving, not this tensor layout.
| Dataset | (1w) | (3w) | (8w) |
| CalHousing | 1.02 | 1.04 | 1.08 |
| Friedman | 0.99 | 1.04 | 1.01 |
| SDSS | 1.00 | 1.02 | 0.99 |
| JetPt | 1.04 | 1.06 | 1.16 |
| CMAPSS | 0.93 | 0.84 | 0.76 |
| CHF | 1.03 | 1.07 | 1.00 |
| Mean | 1.00 | 1.01 | 1.00 |
Table 11. Ratio of column-major to row-major wide-window excess AUC. A ratio above 1 means the column-major layout degrades Projection Healing relative to row-major. This is tensor layout, not SECDED word interleaving.
Sensitivity to the Green Rank Subspace Dimension
One main architectural fix is the Green rank at on all hidden layers. While this isolates the architectural parameters, Projection Healing is a relative mechanism: the robust reconstruction depends on the ratio of the retained subspace to the full dimension . As noted in Appendix § 13, applying to a network with forces the basis to clamp to rank , spanning nearly the entire feature space and making the gate structurally inert.
To determine this sensitivity we evaluate a down-scaled version of the CalHousing benchmark with hidden dimensions . Table 12 shows the results aggregated over an eight-seed campaign under identical spatial MBU injection. Projection Healing does not experience a brittle collapse as the subspace is restricted. Instead, resilience relative to the unprotected baseline falls as the subspace shrinks. A very tight bottleneck of introduces a minor alignment tax on the clean RMSE (0.71 vs. 0.53) but still removes 30% of the excess AUC compared to the unprotected network. The optimal configuration for this capacity is (), which minimizes the relative damage (0.54 excess AUC) with minimal impact on clean convergence.
| Model | Clean RMSE | Rel. AUC | |
| Unprotected | — | ||
| 0.06, 0.06, 0.08 | |||
| 0.13, 0.13, 0.17 | |||
| 0.25, 0.25, 0.33 | |||
| 0.50, 0.50, 0.67 |
Table 12. Sensitivity of Projection Healing to the Green rank on a narrow architecture. Column heads are abbreviated so the table fits the column; is the retained-rank ratio on each hidden layer.
Baseline Implementations
To ensure reproducibility and fair comparison in our simulated PyTorch environment, we specify the precise algorithmic implementations of each competitor arm evaluated in § 4:
Clipped: Both weights and activations are clamped to the maximum dynamic ranges observed during a clean training pass. The clipping thresholds are static and applied per-layer.
Ranger [25]: Applies selective state-restriction to bound values based on training statistics. In our INT8 quantized environment, the bounds track the native quantization range, resulting in performance equivalent to the Clipped baseline.
SECDED+interleaving: A standard (72, 64) single-error-correction double-error-detection code in the Hamming/Hsiao family [66, 67] is applied over the weight memory (a 1.125 storage overhead). To mitigate multi-bit bursts (MBUs), it is augmented with a physical interleaving depth of 4, dispersing adjacent spatial faults across different logical words, thus protecting a contiguous spatial span of 256 bits (32 bytes). Check bits are modeled as protected and do not take strikes. The implementation models miscorrection: odd-weight errors alias to valid single-error syndromes, causing the decoder to flip an innocent bit and increase total damage [68].
SECDED(b7) / unequal-error-protection: The same (72, 64) SECDED decoder and interleave depth, but applied only to the gathered INT8 sign bits (bit 7) of the weight store. Sixty-four sign bits form one ECC data word, so the check-bit cost is 8/512 = 1.6% of payload storage, one-eighth the full-SECDED overhead, while targeting the bit position that Figure 3 attributes the largest share of relative damage to. Lower-order bits are left unprotected. Miscorrection is modeled identically to the original with the caveat that an aliased flip now lands on a sign bit by construction, whereas a full-word miscorrection hits bit 7 only about one-eighth of the time.
RedNet proxy (LogClip): each hidden layer is a linear map followed by LogClip, zeroed above . There is no confidence head and no early exit. Scalar regression has no softmax probability to threshold. The original method [23] also uses layer-sensitivity-aware spatial protection, which this proxy does not implement.
Diehard proxy: uses ReLU6 hidden units and the spatial-MBU training injector. It does not clamp activations to and does not add a heavy penalty beyond the campaign weight decay.
Not evaluated. In-place zero-space ECC [39] trains weights so check bits occupy non-informative sign-extension slots and then protects those words with SEC-DED at no extra persistent ROM. We expect its single-bit window to resemble evaluated SECDED and its multi-bit ceiling to resemble SECDED once bursts exceed one correction. We do not report a six-dataset number for it. Standalone unaligned weight-bit-flip FAT [49] is also absent. The unaligned column of Table 3 removes subspace alignment and both runtime heals and keeps the surrogate curriculum. Appendix § 12 changes only the training injector on the full aligned, healed stack.
Data availability
The code and data supporting this study are not yet public at submission. The training code, fault-injection harness, and benchmark preprocessing scripts will be released, with the repository and license identified, when the paper has been accepted or on the request of the referee/reviewers.
Acknowledgments
P. Xiangyuan Ma thanks Jingxun Liang and Renfei Zhou for helpful discussions at the early stages of the project, and Joshua S. Bloom thanks Benjamin P. Nachman for useful comments at the later stages of the work. P. Xiangyuan Ma also thanks Tatsu K. for some early encouraging discussions regarding this project over bouldering at the gym while struggling to climb a stubborn V5 together. During the preparation of this manuscript, the authors used GPT-5.6 Sol, DeepSeek V4, Claude Opus 5.5, GLM-5.3, Kimi K3, and Gemini 3.1 Pro in code development and in writing and proof-editing. The authors reviewed and revised the assisted text and code and take responsibility for the content. The research directions, the experimental design, the evaluations, and the interpretation of the results are the work of the authors.
Conflict of interest
A provisional patent application regarding the methods in this manuscript has been filed by the University of California.
Funding
P. Xiangyuan Ma acknowledges support from the Schmidt Science Foundation. We also acknowledge support from the Google Cloud Research Credits Program.
References
References
- [1]Dario Izzo, Marcus Märtens, and Binfeng Pan. A survey on artificial intelligence trends in spacecraft guidance dynamics and control. Astrodynamics, 3(4):287–299, 2019.arxiv.org/abs/1812.02948
- [2]Gianluca Furano, Gabriele Meoni, Aidan Dunne, D Mandorlo, Martin Lingenauber, C Freire, and A Orlandic. Machine learning for space applications. IEEE Aerospace and Electronic Systems Magazine, 35(10):14–24, 2020.
- [3]Eugene Normand. Single event upset at ground level. IEEE Transactions on Nuclear Science, 43(6):2742–2750, 1996.DOI
- [4]International Electrotechnical Commission. IEC TS 62396-1: Process management for avionics—atmospheric radiation effects—Part 1: Accommodation of atmospheric radiation effects via single event effects within avionics electronic equipment. Technical Specification IEC TS 62396-1:2006, International Electrotechnical Commission, 2006.
- [5]Allen H Taber and Eugene Normand. Single event upset in avionics. IEEE Transactions on Nuclear Science, 40(2):120–126, 1993.DOI
- [6]Jean-Marie Le Corre et al. OECD/NEA benchmark on artificial intelligence and machine learning for scientific computing in nuclear engineering. Phase 1: Critical Heat Flux Exercise Specifications. Technical report, OECD Nuclear Energy Agency, 2024.
- [7]Kim Albertsson et al. Machine learning in high energy physics community white paper. Journal of Physics: Conference Series, 1085, 2018.
- [8]Alexander Radovic, Mike Williams, David Rousseau, Michael Kagan, Daniele Bonacorsi, Alexander Himmel, Adam Aurisano, Kazuhiro Terao, and Taritree Wongjirad. Machine learning at the energy and intensity frontiers of particle physics. Nature, 560(7716):41–48, 2018.DOI
- [9]Dan Guest, Kyle Cranmer, and Daniel Whiteson. Deep learning and its application to LHC physics. Annual Review of Nuclear and Particle Science, 68:161–181, 2018.DOI
- [10]Olivia Weng, Andres Meza, Nhan Tran, and Ryan Kastner. PrioriFI: More informed fault injection for edge neural networks. In Proceedings of the 31st ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2, pages 1461–1475. ACM, 2026.DOI
- [11]Robert E Lyons and Wouter Vanderkulkk. The use of triple-modular redundancy to improve computer reliability. IBM journal of research and development, 6(2):200–209, 1962.DOI
- [12]Olivia Weng, Andres Meza, Quinlan Bock, Benjamin Hawks, Javier Campos, Nhan Tran, Javier Mauricio Duarte, and Ryan Kastner. FKeras: A sensitivity analysis tool for edge neural networks. ACM Journal on Autonomous Transportation Systems, 1(3):1–27, 2024.DOI
- [13]Mahadev Satyanarayanan. The emergence of edge computing. Computer, 50(1):30–39, 2017.DOI
- [14]Paul E Dodd and Lloyd W Massengill. Basic mechanisms and modeling of single-event upset in digital microelectronics. IEEE Transactions on Nuclear Science, 50(3):583–602, 2003.DOI
- [15]Robert C Baumann. Radiation-induced soft errors in advanced semiconductor technologies. IEEE Transactions on Device and Materials Reliability, 5(3):305–316, 2005.DOI
- [16]Jeffrey D Black, Dolores R Ball II, William H Robinson, Daniel M Fleetwood, Ronald D Schrimpf, Robert A Reed, Dolores A Black, Kevin M Warren, Alan D Tipton, Paul E Dodd, Nadim F Haddad, Michael A Xapsos, Hak S Kim, and Mark Friendlich. Characterizing SRAM single event upset in terms of single and multiple node charge collection. IEEE Transactions on Nuclear Science, 55(6):2943–2947, 2008.DOI
- [17]Bradley Denby and Brandon Lucia. Orbital edge computing: Nanosatellite constellations as a new class of computer system. In Proceedings of the Twenty-Fifth International Conference on Architectural Support for Programming Languages and Operating Systems, pages 939–954, 2020.DOI
- [18]Zhi Zhou, Xu Chen, En Li, Liekiang Zeng, Ke Luo, and Junshan Zhang. Edge intelligence: Paving the last mile of artificial intelligence with edge computing. Proceedings of the IEEE, 107(8):1738–1762, 2019.arxiv.org/abs/1905.10083
- [19]Israel Koren and C Mani Krishna. Fault-Tolerant Systems. Morgan Kaufmann, 2020.
- [20]Kuang-Hua Huang and Jacob A Abraham. Algorithm-based fault tolerance for matrix operations. IEEE Transactions on computers, C-33(6):518–528, 1984.DOI
- [21]Kai Zhao, Sheng Di, Sihuan Li, Xin Liang, Yujia Zhai, Jieyang Chen, Kaiming Ouyang, Franck Cappello, and Zizhong Chen. FT-CNN: Algorithm-based fault tolerance for convolutional neural networks. IEEE Transactions on Parallel and Distributed Systems, 32(7):1677–1689, 2021.DOI
- [22]Siva Kumar Sastry Hari, Michael B Sullivan, Timothy Tsai, and Stephen W Keckler. Making convolutions resilient via algorithm-based error detection techniques. arXiv preprint arXiv:2006.04984, 2020.arxiv.org/abs/2006.04984
- [23]Meiqi Wang, Han Qiu, Longnv Xu, Di Wang, Yuanjie Li, Tianwei Zhang, Jun Liu, and Hewu Li. A Case for Application-Aware Space Radiation Tolerance in Orbital Computing. arXiv preprint arXiv:2407.11853, 2024.arxiv.org/abs/2407.11853
- [24]Niccolò Cavagnero, Fernando Fernandes dos Santos, Marco Ciccone, Giuseppe Averta, Tatiana Tommasi, and Paolo Rech. Transient-fault-aware design and training to enhance DNNs reliability with zero-overhead. In 2022 IEEE 28th International Symposium on On-Line Testing and Robust System Design (IOLTS), pages 1–7. IEEE, 2022.arxiv.org/abs/2205.14420
- [25]Zitao Chen, Guanpeng Li, and Karthik Pattabiraman. A low-cost fault corrector for deep neural networks through range restriction. In 2021 51st Annual IEEE/IFIP International Conference on Dependable Systems and Networks (DSN), pages 1–13. IEEE, 2021. Also available as arXiv:2003.13874.arxiv.org/abs/2003.13874
- [26]Seyedhamidreza Mousavi, Mohammad Hasan Ahmadilivani, Jaan Raik, Maksim Jenihhin, and Masoud Daneshtalab. ProAct: Progressive training for hybrid clipped activation function to enhance resilience of DNNs. arXiv preprint arXiv:2406.06313, 2024.arxiv.org/abs/2406.06313
- [27]Behnam Ghavami, Mani Sadati, Zhenman Fang, and Lesley Shannon. FitAct: Error resilient deep neural networks via fine-grained post-trainable activation functions. In Proceedings of the 2022 Design, Automation & Test in Europe Conference & Exhibition (DATE), pages 1239–1244. IEEE, 2022.arxiv.org/abs/2112.13544
- [28]Vardan Papyan, XY Han, and David L Donoho. Prevalence of neural collapse during the terminal phase of deep learning training. Proceedings of the National Academy of Sciences, 117(40):24652–24663, 2020.DOI
- [29]Le-Ha Hoang, Muhammad Abdullah Hanif, and Muhammad Shafique. FT-ClipAct: Resilience analysis of deep neural networks and improving their fault tolerance using clipped activation. In 2020 Design, Automation & Test in Europe Conference & Exhibition (DATE), pages 1241–1246. IEEE, 2020. Also available as arXiv:1912.00941.arxiv.org/abs/1912.00941
- [30]Benoit Jacob, Skirmantas Kligys, Bo Chen, Menglong Zhu, Matthew Tang, Andrew Howard, Hartwig Adam, and Dmitry Kalenichenko. Quantization and training of neural networks for efficient integer-arithmetic-only inference. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2704–2713, 2018.arxiv.org/abs/1712.05877
- [31]F. Libano, B. Wilson, M. Wirthlin, P. Rech, and J. Brunhaver. Understanding the impact of quantization, accuracy, and radiation on the reliability of convolutional neural networks on FPGAs. IEEE Transactions on Nuclear Science, 67(7):1478–1484, 2020.DOI
- [32]F. Libano, P. Rech, B. Neuman, J. Leavitt, M. Wirthlin, and J. Brunhaver. How reduced data precision and degree of parallelism impact the reliability of convolutional neural networks on FPGAs. IEEE Transactions on Nuclear Science, 68(5):811–818, 2021.DOI
- [33]Adnan Siraj Rakin, Zhezhi He, and Deliang Fan. Bit-flip attack: Crushing neural network with progressive bit search. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 1211–1220, 2019.arxiv.org/abs/1903.12269
- [34]Fan Yao, Adnan Siraj Rakin, and Deliang Fan. DeepHammer: Depleting the intelligence of deep neural networks through targeted chain of bit flips. In Proceedings of the 29th USENIX Security Symposium (USENIX Security 20), pages 1463–1480. USENIX Association, 2020.arxiv.org/abs/2003.13746
- [35]Sanghyun Hong, Pietro Frigo, Yigitcan Kaya, Cristiano Giuffrida, and Tudor Dumitras. Terminal brain damage: Exposing the graceless degradation in deep neural networks under hardware fault attacks. In 28th USENIX Security Symposium, pages 497–514, 2019.
- [36]Zitao Chen, Guanpeng Li, Karthik Pattabiraman, and Nathan DeBardeleben. BinFI: An efficient fault injector for safety-critical machine learning systems. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis, pages 1–23, 2019.
- [37]Anna Schmedding, Lishan Yang, Adwait Jog, and Evgenia Smirni. Aspis: Lightweight neural network protection against soft errors. In 2024 IEEE 35th International Symposium on Software Reliability Engineering (ISSRE), pages 248–259, 2024.DOI
- [38]Florian Geissler, Syed Qutუბ, Michael Paulitsch, and Karthik Pattabiraman. A low-cost strategic monitoring approach for scalable and interpretable error detection in deep neural networks. In Computer Safety, Reliability, and Security, pages 75–88. Springer, 2023.DOI
- [39]Hui Guan, Lin Ning, Zhen Lin, Xipeng Shen, Huiyang Zhou, and Seung-Hwan Lim. In-place zero-space memory protection for CNN. In Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.arxiv.org/abs/1910.14479
- [40]Kunping Huang, Paul H Siegel, and Anxiao Jiang. Functional error correction for robust neural networks. arXiv preprint arXiv:2001.03814, 2020.arxiv.org/abs/2001.03814
- [41]Ninnart Fuengfusin and Hakaru Tamukoh. Harden deep neural networks against fault injections through weight scaling. arXiv preprint arXiv:2411.18993, 2024.arxiv.org/abs/2411.18993
- [42]Ninnart Fuengfusin and Hakaru Tamukoh. Enhancing neural network robustness against fault injection through non-linear weight transformations. arXiv preprint arXiv:2411.19027, 2024.arxiv.org/abs/2411.19027
- [43]Guanpeng Li, Siva Kumar Sastry Hari, Michael Sullivan, Timothy Tsai, Karthik Pattabiraman, Joel Emer, and Stephen W Keckler. Understanding error propagation in deep learning neural network (DNN) accelerators and applications. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis (SC), pages 1–12. ACM, 2017.DOI
- [44]Brandon Reagen, Udit Gupta, Lillian Pentecost, Paul Whatmough, Sae Kyu Lee, Niamh Mulholland, David Brooks, and Gu-Yeon Wei. Ares: A framework for quantifying the resilience of deep neural networks. In Proceedings of the 55th Annual Design Automation Conference (DAC), pages 1–6. ACM, 2018.DOI
- [45]Ussama Zahid, Giulio Gambardella, Nicholas J. Fraser, Michaela Blott, and Kees A. Vissers. FAT: Training neural networks for reliable inference under hardware faults. In 2020 IEEE International Test Conference (ITC), pages 1–10. IEEE, 2020.arxiv.org/abs/2011.05873
- [46]Giulio Gambardella, Johannes Kappauf, Michaela Blott, Christoph Doehring, Martin Kumm, Peter Zipf, and Kees Vissers. Efficient error-tolerant quantized neural network accelerators. In 2019 IEEE International Symposium on Defect and Fault Tolerance in VLSI and Nanotechnology Systems (DFT), pages 1–6. IEEE, 2019. Also available as arXiv:1912.07394.DOI
- [47]Toon Vinck, Naïn Jonckers, Gert Dekkers, Jeffrey Prinzie, and Peter Karsmakers. Mitigating multiple single-event upsets during deep neural network inference using fault-aware training. Journal of Instrumentation, 20(02):C02044, 2025.arxiv.org/abs/2502.09374
- [48]Akul Malhotra and Sumeet Kumar Gupta. Memory faults in activation-sparse quantized deep neural networks: Analysis and mitigation using sharpness-aware training. arXiv preprint arXiv:2406.10528, 2024.arxiv.org/abs/2406.10528
- [49]David Stutz, Nandhini Chandramoorthy, Matthias Hein, and Bernt Schiele. Bit error robustness for energy-efficient DNN accelerators. In Proceedings of Machine Learning and Systems (MLSys), volume 3, pages 569–598, 2021. Also available as arXiv:2006.13977.arxiv.org/abs/2006.13977
- [50]Giuseppe Di Guglielmo, Farah Fahim, Christian Herwig, Manuel Blanco Valentin, Javier Duarte, Cristian Gingu, et al. A reconfigurable neural network ASIC for detector front-end data compression at the HL-LHC. IEEE Transactions on Nuclear Science, 68(8):2179–2186, 2021.
- [51]Davide Braga, Grace Cummings, Cristinel Gingu, James Hirschauer, James Hoff, Pamela Klabbers, et al. First test results of the HGCAL concentrator ASICs: ECON-T and ECON-D. Journal of Instrumentation, 19(03):C03050, 2024.DOI
- [52]Eishi Ibe, Hitoshi Taniguchi, Yasuo Yahagi, Ken-ichi Shimbo, and Tadanobu Toba. Impact of scaling on neutron-induced soft error in SRAMs from a 250 nm to a 22 nm design rule. IEEE Transactions on Electron Devices, 57(7):1527–1538, 2010.DOI
- [53]R Kelley Pace and Ronald Barry. Sparse spatial autoregressions. Statistics & Probability Letters, 33(3):291–297, 1997.
- [54]Jerome H. Friedman. Multivariate adaptive regression splines. The Annals of Statistics, 19(1):1–67, 1991.DOI
- [55]R Beck, L Dobos, T Budavári, AS Szalay, and I Csabai. Photometric redshifts for the SDSS Data Release 12. Monthly Notices of the Royal Astronomical Society, 460(2):1371–1381, 2016.DOI
- [56]Adrian A Collister and Ofer Lahav. ANNz: Estimating photometric redshifts using artificial neural networks. Publications of the Astronomical Society of the Pacific, 116(818):345–351, 2004.DOI
- [57]Abhinav Saxena, Kai Goebel, Don Simon, and Neil Eklund. Damage propagation modeling for aircraft engine run-to-failure simulation. In 2008 International Conference on Prognostics and Health Management, pages 1–9. IEEE, 2008.DOI
- [58]Jiawei Xiong, Olga Fink, Jian Zhou, and Yizhong Ma. Controlled physics-informed data generation for deep learning-based remaining useful life prediction under unseen operation conditions. Mechanical Systems and Signal Processing, 197:110359, 2023. Also available as arXiv:2304.11702.DOI
- [59]CMS Collaboration. Jet primary dataset in AOD format from RunA of 2011 (/Jet/Run2011A-12Oct2013-v1/AOD). CERN Open Data Portal, 2016. Record 21.DOI
- [60]Patrick Komiske, Radha Mastandrea, Eric Metodiev, Preksha Naik, and Jesse Thaler. CMS 2011A simulation | Pythia 6 QCD 470-600 | pT > 375 GeV | MOD HDF5 format. Zenodo, 2019.
- [61]Patrick T. Komiske, Radha Mastandrea, Eric M. Metodiev, Preksha Naik, and Jesse Thaler. Exploring the space of jets with CMS open data. Physical Review D, 101(3):034009, 2020.DOI
- [62]Javier Duarte et al. Fast inference of deep neural networks in FPGAs for particle physics. Journal of Instrumentation, 13(07):P07027, 2018.DOI
- [63]D Falguere, D Boscher, T Nuns, S Duzellier, S Boudarie, R Ecoffet, et al. In-flight observations of the radiation environment and its effects on devices in the SAC-C polar orbit. IEEE Transactions on Nuclear Science, 49(6):2882–2888, 2002.DOI
- [64]B.H. Kang, B.C. Lee, et al. Design characteristics and startup tests of HANARO. Journal of the Korean Nuclear Society, 27(5):652–661, 1995.
- [65]Yoshua Bengio, Nicholas Léonard, and Aaron Courville. Estimating or propagating gradients through stochastic neurons for conditional computation. arXiv:1308.3432, 2013.arxiv.org/abs/1308.3432
- [66]Richard W. Hamming. Error detecting and error correcting codes. Bell System Technical Journal, 29(2):147–160, 1950.DOI
- [67]M. Y. Hsiao. A class of optimal minimum odd-weight-column SEC-DED codes. IBM Journal of Research and Development, 14(4):395–401, 1970.DOI
- [68]C. L. Chen and M. Y. Hsiao. Error-correcting codes for semiconductor memory applications: a state-of-the-art review. IBM Journal of Research and Development, 28(2):124–134, 1984.