The DOI matches its Crossref record; 40 of the 40 references it cites were found in a registry or an index; 1 of the 23 sources its claims cite were checked for support.
Fast and Accurate Error Simulation for CNNs Against Soft Errors
Open accessAbstract
The great quest for adopting AI-based computation for safety-/mission-critical applications motivates the interest towards methods for assessing the robustness of the application w.r.t. not only its training/tuning but also errors due to faults, in particular soft errors, affecting the underlying hardware. Two strategies exist: architecture-level fault injection and application-level functional error simulation. We present a framework for the reliability analysis of Convolutional Neural Networks (CNNs) via an error simulation engine that exploits a set of validated error models extracted from a detailed fault injection campaign. These error models are defined based on the corruption patterns of the output of the CNN operators induced by faults and bridge the gap between fault injection and error simulation, exploiting the advantages of both approaches. We compared our methodology against SASSIFI for the accuracy of functional error simulation w.r.t. fault injection, and against TensorFI in terms of speedup for the error simulation strategy. Experimental results show that our methodology achieves about 99% accuracy of the fault effects w.r.t. SASSIFI, and a speedup ranging from 44x up to 63x w.r.t. TensorFI, that only implements a limited set of error models.
Overview
CoChat Summary
TL;DR
CLASSES is a cross-layer framework that derives validated functional error models for CNN operators from architecture-level GPU fault injection and uses them in a TensorFlow-based error simulator for fast reliability analysis. It reports about 99% accuracy versus SASSIFI and 44x–63x speedup versus TensorFI on smaller CNNs.
Key findings
- CLASSES achieved an average 98.72% accuracy versus SASSIFI in reproducing fault effects on the final YOLO V3 output, with about 6x speedup: 137,004 relevant error simulation experiments took about 15 hours in CLASSES versus about 92 hours for the hybrid SASSIFI configuration.
- Against TensorFI, CLASSES achieved speedups of about 44x and 63x on LeNet-5 and CIFAR10 for 10,000 error simulation experiments: TensorFI took 18 min and 40 min, while CLASSES took 0.41 min and 0.63 min, respectively.
- The fault injection campaign ran 360,000 experiments and collected 137,004 corrupted tensors; for most operators, 85%–92% of corrupted output tensors contained only one erroneous value, while Convolution and Batch normalization showed multiple corrupted values in 22%–57% of cases.
- The analysis found that 93.65% of fault effects on average caused well-identifiable spatial patterns, and random patterns had less than 6.35% incidence; no error model was defined for random patterns.
Methods
- CLASSES combines architecture-level fault injection on individual CNN operators using SASSIFI on an NVIDIA GeForce GT 750M, followed by automated analysis of corrupted tensors to derive error models based on error cardinality, value domain, and spatial distribution.
- The error models are integrated into a TensorFlow-based functional error simulator that inserts saboteurs at operator output tensors and uses a usability-based output classifier for the downstream application.
- The main case study was YOLO V3 trained on COCO, with about 6,000 operator instances and 45 operator types; 11 operator types were considered for fault injection. LeNet-5 and CIFAR10 were used for performance comparison against TensorFI, and 10,000 random error simulations were run for timing.
Limitations
- The paper states that manual inspection is required to classify corrupted tensors not handled by the automated script, and future work will automate this via data mining; random spatial patterns are not modeled, though their incidence is less than 6.35%.
- The paper states that when a new CNN is considered, the fault injection and error modeling activities may need to be re-executed to guarantee an accurate and updated error model repository; it also notes that TensorFI comparison was only performance-based because TensorFI implements a reduced subset of error models, and YOLO could not be run with TensorFI due to unsupported operators and tensor data format.
- Evident from the text: the error models were extracted from one target GPU, the NVIDIA GeForce GT 750M implementing the Kepler architecture, and the paper says future work will extend the framework to other platforms and ML algorithms, so generalization beyond this setup is not yet demonstrated.
Model-written summary. Check it against the paper before relying on it.
Integrity signals
Registry
Cites
Statistics
Figures













Verification
Claims the paper makes
1 Valid · 4 Not valid · 17 Not checked · 87 Own results and interpretations
A result the paper reports from its own data — it cites no other source for it, so there is none to check. The quote shows it is in the paper.
In the paper
“Experimental results show that our methodology achieves about 99% accuracy of the fault effects w.r.t. SASSIFI”
- Also stated in: § 1 INTRODUCTION · p. 2 · plain
“CLASSES achieves about 99% accuracy in terms of effect of the fault on the final YOLO V3 output”
plainstates an association- Asserted: passes — The authors put it forward as true.
- Checkable: passes — It can be checked against evidence.
- Load-bearing: passes — The paper’s conclusions depend on it.
- Based: passes — The paper gives a reason why it holds.
- Also stated in: § 1 INTRODUCTION · p. 2 · plain
A result the paper reports from its own data — it cites no other source for it, so there is none to check. The quote shows it is in the paper.
In the paper
“We first analyzed the number of erroneous values found in a corrupted output tensor; such a number is strongly dependent on the operator under analysis.”
boostedstates an association- Asserted: passes — The authors put it forward as true.
- Checkable: passes — It can be checked against evidence.
- Load-bearing: passes — The paper’s conclusions depend on it.
- Based: passes — The paper gives a reason why it holds.
A result the paper reports from its own data — it cites no other source for it, so there is none to check. The quote shows it is in the paper.
In the paper
“To perform the same 137,004 relevant error simulation experiments CLASSES took about 15 hours”
plain- Asserted: passes — The authors put it forward as true.
- Checkable: passes — It can be checked against evidence.
- Load-bearing: passes — The paper’s conclusions depend on it.
- Based: passes — The paper gives a reason why it holds.
A result the paper states — it cites no source for it, so there is none to check. The quote shows it is in the paper.
In the paper
“Most of the faults that cause less than 16 erroneous values in the output tensor affect only a single feature map.”
plainstates an association- Asserted: passes — The authors put it forward as true.
- Checkable: passes — It can be checked against evidence.
- Load-bearing: unclear — It is unclear whether the paper’s conclusions depend on it.
- Based: passes — The paper gives a reason why it holds.
A result the paper reports from its own data — it cites no other source for it, so there is none to check. The quote shows it is in the paper.
In the paper
“corresponding to a 6x speedup with respect to the hybrid SASSIFI configuration.”
- Also stated in: § 9 CONCLUSION · p. 13 · plain
“with about 6x speedup w.r.t. SASSIFI”
plainstates a cause- Asserted: passes — The authors put it forward as true.
- Checkable: passes — It can be checked against evidence.
- Load-bearing: passes — The paper’s conclusions depend on it.
- Based: passes — The paper gives a reason why it holds.
- Also stated in: § 9 CONCLUSION · p. 13 · plain
46 more claims
Create a free account to see all 109 claims and every source verdict.
- It may state two separate claims as one. 35
- Probably not a substantial claim. 35
Self-check
Percentages, sums and reported differences re-computed from the paper’s own numbers.
Each contradiction between two passages listed here was confirmed by an independent check.
Rated minor: it would not touch a result — a value no result rests on, a p-value that stays on the same side of the significance level, or a conflict that is clerical, resolved elsewhere in the paper, or outside its own findings.
In the paper
§ 6.3.3 Spatial Distribution · p. 10
“spatial distributions involving multiple feature maps only appear for the Convolution ( 1 , 2 , or 3 ) and the Batch normalization operators”
§ 6.4 Error Model Definition · p. 11
“| Add | 90.3% | 1.8% | 0.8% | 0.0% | 0.0% | 7.1% |”
Citations
Cites
Microsoft COCO: Common Objects in Context
Lin, T.-Y., Maire, M., Belongie, S., Hays, J., Perona, P., Ramanan, D., Dollár, P., & Zitnick, C. L. (2014) · Lecture Notes in Computer Science · doi:10.1007/978-3-319-10602-1_48 · Cited by 45,460
PyTorch: An Imperative Style, High-Performance Deep Learning Library
Paszke, A., Gross, S., Massa, F., Lerer, A., Bradbury, J., Chanan, G., Killeen, T., Lin, Z., Gimelshein, N., Antiga, L., et al. (2019) · arXiv · doi:10.48550/arxiv.1912.01703 · Cited by 31,473
YOLOv3: An Incremental Improvement
Redmon, J., & Farhadi, A. (2018) · arXiv · doi:10.48550/arxiv.1804.02767 · Cited by 17,141
Backpropagation Applied to Handwritten Zip Code Recognition
LeCun, Y., Boser, B., Denker, J. S., Henderson, D., Howard, R. E., Hubbard, W., & Jackel, L. D. (1989) · Neural Computation · doi:10.1162/neco.1989.1.4.541 · Cited by 11,891 · cited 8×
“Due to implementation limitations for existing tools, we used both the YOLO V3 CNN [24], and two smaller size benchmarks, LeNet-5 [25] and CIFAR10 [26].”
MethodResultInfluentialCaffe: Convolutional Architecture for Fast Feature Embedding
Jia, Y., Shelhamer, E., Donahue, J., Karayev, S., Long, J., Girshick, R., Guadarrama, S., & Darrell, T. (2014) · Proceedings of the 22nd ACM international conference on Multimedia · doi:10.1145/2647868.2654889 · Cited by 11,077 · cited 8×
“Nonetheless, this implementation choice considerably simplifies the development and integration in SASSIFI; Caffe is a stand-alone library accelerated onto GPU.”
MethodInfluentialTensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems
Abadi, M., Agarwal, A., Barham, P., Brevdo, E., Chen, Z., Citro, C., Corrado, G. S., Davis, A., Dean, J., Devin, M., et al. (2016) · arXiv · doi:10.48550/arxiv.1603.04467 · Cited by 9,408
Caffe: Convolutional Architecture for Fast Feature Embedding
Jia, Y., Shelhamer, E., Donahue, J., Karayev, S., Long, J., Girshick, R., Guadarrama, S., & Darrell, T. J. (2014) · arXiv (Cornell University) · doi:10.48550/arxiv.1408.5093 · Cited by 3,752
Microsoft COCO: Common Objects in Context
Lin, T.-Y., Maire, M., Belongie, S., Bourdev, L., Girshick, R., Hays, J., Perona, P., Ramanan, D., Zitnick, C. L., & Dollár, P. (2014) · arXiv · doi:10.48550/arxiv.1405.0312 · Cited by 2,579
NVIDIA Tesla: A Unified Graphics and Computing Architecture
Lindholm, E., Nickolls, J., Oberman, S., & Montrym, J. (2008) · IEEE Micro · doi:10.1109/mm.2008.31 · Cited by 1,362 · cited 1×
“With reference to the NVIDIA architecture [30], a GPU is a many-core organized in an array of Streaming Multiprocessors (SMs) (left-hand side of Fig.”
MethodA Survey of Techniques for Approximate Computing
Mittal, S. (2016) · ACM Computing Surveys · doi:10.1145/2893356 · Cited by 1,058 · cited 1×
“tations provide resiliency to a certain level of inexactness [8].”
Background
Cited by
A Systematic Literature Review on Hardware Reliability Assessment Methods for Deep Neural Networks
Ahmadilivani, M. H., Taheri, M., Raik, J., Daneshtalab, M., & Jenihhin, M. (2023) · ACM Computing Surveys · doi:10.1145/3638242 · Cited by 132
Rech, P. (2024) · IEEE Transactions on Nuclear Science · doi:10.1109/tns.2024.3349956 · Cited by 75
“2) Low Level and Software Fault Injection [154], [163], [164]: Similar to the previous hybrid approach, the RTL fault injection or low-level fault simulation is used only to characterize the fault effect at the output of basic machine instructions.”
MethodCross-Layer Reliability Evaluation and Efficient Hardening of Large Vision Transformers Models
Roquet, L., Fernandes dos Santos, F., Rech, P., Traiola, M., Sentieys, O., & Kritikakou, A. (2024) · Proceedings of the 61st ACM/IEEE Design Automation Conference · doi:10.1145/3649329.3655688 · Cited by 16
“We inject faults in general-purpose registers, memory load instructions, and arithmetic floating-point operations.”
Metadata
- Authors
- Bolchini, C., Cassano, L., Miele, A., & Toschi, A.
- Affiliations
- Politecnico di Milano (IT)
- Venue
- IEEE Transactions on Computers
- Published
- 2023-04-01
- Volume
- 72
- Issue
- 4
- Pages
- 984-997
- ISSN
- 0018-9340 (ISSN-L)
- 1557-9956
- 2326-3814
- OpenAlex
- W4281645879
- Cited by
- 1
- References
- 35
- Citations by year
- 2023: 1
- FWCI
- 0.07
- Type
- journal article
- Language
- en
- Open access
- hybrid
- doi.org
- Licence
- Locations
- IEEE Transactions on Computers (publishedVersion, cc-by-nc-nd)
- arXiv (Cornell University) (submittedVersion)
- arXiv (Cornell University)
- Topics
- Physical Sciences › Engineering › Electrical and Electronic Engineering › Radiation Effects in Electronics
- Physical Sciences › Computer Science › Hardware and Architecture › VLSI and Analog Circuit Testing
- Physical Sciences › Computer Science › Software › Software Testing and Debugging Techniques
- Keywords
- soft errors, convolutional neural networks, fault injection, error model, reliability analysis, hardware faults, safety-critical AI
About these checks
Registry, retraction, Cites and statistics results are computed, not judged, with one exception: a printed reference that no index lists is read once by a model before it counts as a citation error. Claims are extracted by a model and kept only when their quote appears verbatim in the text; each cited source is then checked, with a model’s help, for whether it says what the claim relies on. Those verdicts can be wrong — read the claim’s quote and the cited source before relying on one.
The claim verdicts this report counts are experimental: their accuracy is not yet measured.
A language model drew the claims from the paper on 2026-10-10, under version 3 of the claim definition (model deepseek-v4.1-flash, prompt extract-v3).
A second model labelled each claim on 2026-10-10 (model jev-1.13-20260917, definition revision gold-guideline-v0.2).
Statistics and arithmetic are recomputed, not judged.
Confidence bands are shown only for fields calibrated on our annotated test set. None is calibrated yet, so no band is shown.
What counts as a claim ›How we measure confidence ›How we check this ›
Are you an author, or do you see a problem with this page? Request a review
How to cite
Cite CoChat for the checks on this page, and the paper for its own findings.
- This page
- CoChat. (2026). Citation check: Fast and Accurate Error Simulation for CNNs Against Soft Errors. https://app.cochat.ai/papers/10.1109/tc.2022.3184274
- The paper
- Bolchini, C., Cassano, L., Miele, A., & Toschi, A. (2023). Fast and Accurate Error Simulation for CNNs Against Soft Errors. IEEE Transactions on Computers. https://doi.org/10.1109/tc.2022.3184274
Data sources
Bibliographic data: Semantic Scholar, OpenAlex, Crossref.
Contains information from the Semantic Scholar Academic Graph Datasets, made available under the ODC Attribution License (ODC-BY 1.0).
Semantic Scholar’s data is described in: Kinney, R., et al. (2023). The Semantic Scholar Open Data Platform. arXiv:2301.10140.