- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This paper proposes RIFT, a software-based technique to protect Transformer inference from radiation-induced transient hardware faults in space environments. RIFT is a 5-stage pipeline applied to pre-trained models without requiring retraining or architectural changes.
In Stage 1, hidden states of each layer are screened via spectral, temporal, and cross-layer residual signals, and Stage 2 re-executes flagged layers to assess replay consistency through a thresholded functional coherence gate. If the replay discrepancy exceeds the threshold, the pipeline proceeds to Stages 3–4, which recover the hidden state through uncertainty-aware spectral shrinkage, replay blending, and gated temporal and cross-layer fusion, while Stage 5 adjusts the output distribution's temperature based on the estimated fault severity.
In software fault injection experiments across four fault types (SEU, MBU, SET, and bus corruption) on LLaMA-3-8B, Qwen2.5-VL-7B, and OpenVLA-7B, RIFT demonstrates higher output quality than existing baselines and achieves performance close to TMR. On LLaMA-3-8B, the runtime overhead is reported as 5.5% in a fault-free environment and 8.2% under SEU faults. The authors also conduct controlled fault injection experiments with a small model on a satellite-mounted GPU in Low Earth Orbit (LEO).
Critical strengths
The evaluation scope is comprehensive. The authors evaluate RIFT across three model categories (LLM, VLM, and VLA) and four fault types (SEU, MBU, SET, and bus corruption), comparing it against six baselines as well as TMR. They also present results across model scales ranging from 3B to 72B and on additional models. Furthermore, the paper includes additional experiments on sustained fault bursts, compound faults, nonuniform fault placement, adaptation under domain shifts, and statistical stability over long contexts.
Critical weaknesses
The recovery mechanism in Stages 3–4 is not sufficiently justified. When the original execution and replay disagree, the discrepancy alone does not reveal which execution was corrupted. RIFT instead performs approximate recovery by blending the original layer output, the re-executed output, the previous corrected hidden state, and a linear cross-layer prediction. Therefore, the potentially corrupted original output is mixed back into the final state. However, a simpler alternative could be considered: Selective TMR, which triggers a third execution only when the replay discrepancy exceeds the coherence threshold and selects an output through majority voting based on numerical agreement. The paper reports that the re-execution rate during clean execution is approximately 5%. If, for instance, only 10% of these cases result in a discrepancy exceeding the threshold (p_corrupt = 0.5%), the additional layer-forward computation required for the third execution would be only about 0.5% overall. In this case, the total additional layer-forward compute needed for both the second and third executions would be approximately 5.5% of the original layer-forward computation.
Furthermore, under the paper's assumptions of approximately deterministic clean execution and independent transient faults, majority voting across three runs could identify a correct output when at least two executions are fault-free and agree within numerical tolerance. While the paper provides ablation studies removing individual components of Stages 3–4, it lacks a comparison against Selective TMR. Moreover, the p_corrupt value in the main experimental setup is not reported. Consequently, it is difficult to assess whether RIFT's recovery (Blend) in Stages 3–4 provides meaningful advantages over simple selective re-execution in terms of recovery accuracy or execution cost.
Questions for authors
-
What are the empirically measured values of p_flag and p_corrupt under fault-free and fault-injected conditions? Specifically, what proportion of re-executed layer-steps proceed to Stages 3–4? How does RIFT compare against Selective TMR in terms of recovery accuracy and end-to-end latency? This baseline would use exactly the same Stage 1 and Stage 2 as RIFT, but replace Stages 3–4 with a third execution and majority voting whenever the Stage 2 coherence gate detects a discrepancy.
-
Is it possible to evaluate the recovery quality strictly on cases where Stages 3–4 are actually triggered? Instead of using the re-executed result directly, RIFT recovers the state by blending the potentially corrupted original output, the re-executed output, the previous hidden state, and the cross-layer prediction. This approximate recovery may leave residual errors compared to a fault-free hidden state. If actual recovery occurs in only a small fraction of all layer-steps, these recovery errors might be masked by aggregate task metrics. It would be helpful to separately report the hidden-state reconstruction error or subsequent token agreement specifically for cases where recovery was performed. Additionally, how does RIFT compare against simpler baselines that use the re-executed result as-is, or rely solely on the previous token state or inter-layer prediction, rather than blending multiple states?