Student or educator? Sign up with your school email and get 6 months of Pro free.

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 access
Bolchini, Cristiana, Cassano, Luca, Miele, Antonio, Toschi, Alessandro·2023·IEEE Transactions on Computers

Abstract

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

Crossref · 10.1109/tc.2022.3184274

Cites

40 of 40 references verified0 citation errors · 0 not checkable

Statistics

Nothing to recompute.

Figures

Fig. 1 The typical topology of a CNN described in terms of a sequence of layers for features learning and a final classification layer, integrating a fully-connected Neural Network.
Fig. 1 The typical topology of a CNN described in terms of a sequence of layers for features learning and a final classification layer, integrating a fully-connected Neural Network.From the PDF
Fig. 2 NVIDIA GPU architecture hierarchically organized in a grid of streaming multicores; each multicore is a SIMD unit, having centralized scheduling and dispatching units and a set of processing elements such as streaming cores, load/store units (LD/STs) and special functional units (SFUs).
Fig. 2 NVIDIA GPU architecture hierarchically organized in a grid of streaming multicores; each multicore is a SIMD unit, having centralized scheduling and dispatching units and a set of processing elements such as streaming cores, load/store units (LD/STs) and special functional units (SFUs).From the PDF
Fig. 3 Comparison of the proposed approach w.r.t. the literature, highlighting the various contributions in radiation testing, architectural fault injection, functional error simulation, and error quantification/ classification.
Fig. 3 Comparison of the proposed approach w.r.t. the literature, highlighting the various contributions in radiation testing, architectural fault injection, functional error simulation, and error quantification/ classification.From the PDF
Fig. 4 The proposed cross-layer reliability analysis framework: the system under analysis (top most part), the fault injection and error modeling part applied at the granularity of the single CNN operator (green left side) and the error simulation environment for the overall usability-based reliability analysis (blue right side).
Fig. 4 The proposed cross-layer reliability analysis framework: the system under analysis (top most part), the fault injection and error modeling part applied at the granularity of the single CNN operator (green left side) and the error simulation environment for the overall usability-based reliability analysis (blue right side).From the PDF
Fig. 5 CLASSES internal organization.
Fig. 5 CLASSES internal organization.From the PDF
Fig. 6 Error injection strategy . The sequence of operators in the CNN is accelerated onto the GPU until the operator to be corrupted is reached. The output tensor of this operator is fed into a saboteur (executed on a host CPU) that corrupts it by applying an error model. The corrupted tensor is then used as input of the remaining part of the operators (again, accelerated onto the GPU) to complete the execution of the CNN.
Fig. 6 Error injection strategy . The sequence of operators in the CNN is accelerated onto the GPU until the operator to be corrupted is reached. The output tensor of this operator is fed into a saboteur (executed on a host CPU) that corrupts it by applying an error model. The corrupted tensor is then used as input of the remaining part of the operators (again, accelerated onto the GPU) to complete the execution of the CNN.From the PDF
Image 7
From the PDF
Image 8
From the PDF
Fig. 9 Spatial distribution patterns (erroneous values are colored in red). (a) Single point: the fault causes the corruption of a single value of a single feature map. (b) Same row: the fault causes the total or partial corruption of a row in a single feature map. (c) Bullet wake: the fault corrupts the same location in all or multiple feature maps. (d) Shatter glass: the fault causes the combination of the effects of same row and bullet wake patterns.
Fig. 9 Spatial distribution patterns (erroneous values are colored in red). (a) Single point: the fault causes the corruption of a single value of a single feature map. (b) Same row: the fault causes the total or partial corruption of a row in a single feature map. (c) Bullet wake: the fault corrupts the same location in all or multiple feature maps. (d) Shatter glass: the fault causes the combination of the effects of same row and bullet wake patterns.From the PDF
Image 10
From the PDF
Image 11
From the PDF
Image 12
From the PDF
Image 13
From the PDF

Verification

Claims the paper makes

1 Valid · 4 Not valid · 17 Not checked · 87 Own results and interpretations

46 more claims

Create a free account to see all 109 claims and every source verdict.

See all claims — free account
  • It may state two separate claims as one. 35
  • Probably not a substantial claim. 35

Create a free account to see these claims.

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.

1 of 1

Citations

Cites

Show all 35 references

Cited by

See all 3

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
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.