Carry-Through Checksum: A Lightweight Fault-Detection for CNN Inference at the Edge
Kyrylo Nazarevych, Mohammad Hasan Ahmadilivani, Krister Kaldre, Davide Bertozzi, Jaan Raik
cs.AR · cs.LG
Quick verdict
Novel zero-overhead checksum channels detect soft errors in edge-GPU CNN inference (86–96% TPR); promising, but no ABFT baseline and weight-only fault model.
Summary
The paper targets silent data corruption in CNN inference on resource-constrained embedded GPUs, where soft errors can flip predictions in safety-critical settings. Instead of classical algorithm-based fault tolerance (ABFT) with per-operation checksum rows, the authors embed detection into the network itself: in every convolutional layer they structurally prune the least important output channel (selected by combined L1-norm in adjacent layers) and install a 'carry-through filter' whose center-tap kernel sums input feature maps across channels; downstream kernels zero their slice on the checksum channel so the checksum propagates to a dedicated accumulated-checksum neuron in the final FC layer. A deviation threshold tau, tuned either by fault-injection (FI) campaigns or purely from the fault-free distribution, flags critical faults and triggers re-execution. On VGG/ResNet/MobileNetV2 variants over CIFAR-10/100 deployed via TensorRT on a Jetson Orin NX, the scheme detects on average 95.86% (FP32) and 86.56% (FP16) of critical weight bit-flips with ~1% false-positive rate, keeps accuracy within 1% of baseline after fine-tuning, and adds -0.5% to +0.5% inference latency; the full detect-and-re-execute pipeline averages 2.27% overhead under FI. Main limitations: the fault model covers only parameter bit-flips (not activations/compute), no head-to-head comparison with existing ABFT methods is provided, and re-execution assumes transient rather than persistent weight corruption - an assumption the fault model itself calls into question.
Review complete
Assessment at a glance
6
risk flags identified
● high 1
● medium 3
● low 2
5 strengths · 5 weaknesses · 5 author questions
Levels reflect verification complexity — not a quality score. Evolve never rates your paper.
Key claims under review
- Embedding carry-through filters via channel-swap pruning adds zero compute and memory overhead to CONV/FC layers while carrying an end-to-end checksum.
- A single output verification detects on average 95.86% (FP32) and 86.56% (FP16) of critical weight bit-flips across six CNNs and two datasets at ~1% false-positive rate.
- A distribution-based threshold requiring no fault injection matches FI-based threshold tuning in detection performance.
- The complete detect-and-re-execute pipeline incurs 2.27% average run-time overhead on a Jetson Orin NX under fault injection, with near-zero (0.93% average) cost in fault-free operation.
Strengths
Architecturally elegant zero-overhead mechanism
Section II-A swaps the least important output channel (combined L1-norm of current-layer and next-layer filters) for a center-tap summation filter, preserving layer dimensions exactly; Fig. 3 confirms -0.5% to +0.5% latency change, which the authors correctly attribute to run-time fluctuation.
Fits the unmodified embedded-GPU inference pipeline
Unlike per-operation ABFT, detection needs one output comparison; the scheme is actually deployed via TensorRT 8.5.2/CUDA 11.4 on a Jetson Orin NX 16GB (Section III-A), not merely simulated on desktop GPUs.
FI-free threshold tuning works as well as FI-based tuning
Broad evaluation sweep with architectural adaptations
Honest FP16 accounting
Weaknesses
No baseline comparison against prior ABFT
Fault model restricted to weight bit-flips
Re-execution mitigation conflicts with the paper's own fault model
Thin statistical reporting
Deployment costs and design ambiguities understated
Full Review Report
$1.99 · one-timeUnlock the complete preliminary analysis Evolve produced for this paper.
Report preview
Scope & Claims
The paper (accepted at IEEE ATS'26) targets silent data corruption (SDC) from soft errors in CNN inference on embedded GPUs (NVIDIA Jetson class), where a corrupted prediction can drive unsafe decisions. It argues that classical Algorithm-Based Fault Tolerance (ABFT) [12]-[16] needs per-operation checksum rows/columns whose overhead is 'prohibitive' on embedded GPUs and which break the standard GPU execution flow. The proposed alternative, *carry-through checksum*, embeds detection into the network itself and claims: (1) zero compute/memory overhead in CONV/FC layers, (2) end-to-end detection with a single output verification, (3) 95.86%/86.56% average detection of critical faults in FP32/FP16 at ~1% false-positive rate, and (4) 2.27% average run-time overhead for the full detect-and-re-execute pipeline on a Jetson Orin NX under fault injection.
The remaining sections cover Methodology Assessment, Statistical Evidence, Results & Reproducibility, Limitations & Risks, and Verdict & Recommendations.
- All 5 strengths & 5 weaknesses, analyzed in detail
- 6 risk flags with severity, section & reviewer questions
- Methods & statistical evidence assessment
- 5 questions a peer reviewer would ask
- Full six-dimension evaluation report & recommendations
One-time purchase · this paper only
One-time purchase, this paper only. AI-generated preliminary analysis — not peer review.
Frequently asked questions
What is the carry-through checksum method?
It is a fault-detection scheme for CNN inference in which each convolutional layer's least important output channel is replaced by a dedicated filter that sums the layer's input feature maps across channels. This running checksum propagates through the network to one extra output neuron, so a single comparison at the end of an inference can detect soft errors that corrupted the prediction - without adding any extra convolution work.
How much overhead does carry-through checksum add?
Almost none per inference: latency changes between -0.5% and +0.5% versus the unmodified CNN on an NVIDIA Jetson Orin NX, because the checksum filter replaces a pruned channel rather than adding one. When detection triggers re-execution, the measured average overhead is 2.27% across the test set under fault injection, and 0.93% in fault-free operation.
What detection accuracy does it achieve?
Across VGG-11/19, ResNet-20/56, and MobileNetV2 variants on CIFAR-10 and CIFAR-100, it detects on average 95.86% of classification-changing weight bit-flip faults in FP32 and 86.56% in FP16, with false-positive rates around 1%. Detection is weaker in FP16 because the smaller numeric range and rounding shrink checksum deviations below the threshold.
Does the method require retraining the network?
Sometimes. Replacing a channel with the checksum filter is a structured pruning step, so models whose accuracy drops by more than 1% are fine-tuned for 25 epochs (SGD, learning rate 0.001). After fine-tuning, all reported models stay within 1 percentage point of their unmodified baselines; some ResNet variants drop drastically before fine-tuning (e.g., ResNet-56 on CIFAR-100 falls to 18.61%) and depend fully on that recovery step.
About this review
This is an AI-generated preliminary review by Evolve.Pub, produced from the openly available text of the paper. It is not peer review and does not represent the authors' views. The canonical record of the paper is at the publisher link above.
- Figure 3's per-bar values arrive garbled from text extraction; the aggregate overhead ranges quoted in prose (-0.5%..+0.5%, 0.66-1.35%, 1.2-3.8%) are used instead.
- Tables II-III were extracted inline; row/column alignment was cross-checked against the prose averages, but individual cells could be misaligned by extraction.
- The extracted text appears complete (copyright notice through references); no missing-section gaps were detected, supporting high confidence.
Go deeper on this paper
Wrote a paper? Stress-test it before reviewers do.
Upload your manuscript for the same structured scrutiny — reasoning, statistics, evidence, figures, and reproducibility.