Pith. sign in

REVIEW 4 major objections 5 minor 31 references

Custom Algorithm-based Fault Tolerance for Attention Layers in Transformers

T0 review · 4 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read One fused checksum catches faults across the full attention path, softmax included.

desk verdict The fused checksum is neat and cheap, but it reuses the softmax intermediates, so it doesn't actually verify the softmax path as claimed. read the letter →

arxiv 2507.16676 v1 pith:T3YTLRY7 submitted 2025-07-22 cs.LG cs.AR

Vasileios Titopoulos , Kosmas Alexandridis , Giorgos Dimitrakopoulos This is my paper · ORCID
classification cs.LGcs.AR
keywords algorithm-basedfaulttoleranceattentionmechanismFlashAttention-2softmaxchecksumonlineerrordetectioninjectionhardwareacceleratortransformerreliability
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Flash-ABFT claims that the standard ABFT idea—compare the actual sum of an output matrix against a sum predicted from the inputs—can be applied to the whole attention formula softmax(QK^T)V, softmax division included, instead of checking QK^T and the value multiplication separately. The prediction is built from per-query checks that are accumulated in the same loop FlashAttention-2 already runs, so the checker adds one scalar state per query and a few shared adders. Because the checksum is small relative to the datapath, the reported hardware cost is low: 4.55% average area and 1.53% energy overhead in 28 nm synthesis. In fault-injection experiments with one bit-flip per run, the checker detects 96.94%–98.87% of faults, with 0.3%–0.51% silent failures and 0.62%–2.66% false positives across hidden dimensions 64–256. If these numbers hold on real hardware, attention accelerators can get online error detection without paying for per-multiplication checkers.

What carries the argument

The central object is the fused checksum identity: for one query, $\mathrm{check}(q_i) = \frac{1}{\sum_j e^{s_{ij}}} \sum_k e^{s_{ik}} \sum_r V_{kr}$, obtained by swapping the order of summation in the ABFT relation between column checksums of $\mathrm{softmax}(QK^T)$ and row checksums of $V$. This identity makes the checksum obey the same running-max-adjusted recurrence as the FlashAttention-2 output, so the hardware can maintain $o_i^* = o_{i-1}^* e^{m_{i-1}-m_i} + v_i^* e^{s_i-m_i}$, where $v_i^*$ is the value vector augmented with its row sum. One adder per parallel block computes the row sums of $V$, a per-query scalar accumulator tracks each check, and a global accumulator combines the per-query checks into the prediction used for the final comparison.

What would settle it

Run fault-injection campaigns on the same RTL design while flipping bits in combinational-logic signals and in the memory holding Q, K, V, not just in registers; if detection stays close to the reported 96.94%–98.87%, the claim generalizes, and a clear drop would show the reported rates are tied to the register-only fault model.

Watch

Extended reading notes

Core claim

Flash-ABFT establishes that a single scalar checksum—the sum of all entries of $\mathrm{attn}(Q,K,V)=\mathrm{softmax}(QK^T)V$—can be predicted online without ever materializing the softmax matrix. The prediction factors as a sum over query rows of per-query checks, each equal to the normalized dot product between the softmax weight vector and the per-row sums of $V$, so it can be accumulated in the same loop that FlashAttention-2 already executes. The per-query checksum and the output vector share one recurrence, meaning the checker is just one extra element appended to the output and value vectors. On the synthesized 28 nm FlashAttention-2 accelerator, the authors report 96.94%–98.87% fault detection, 0.3%–0.51% silent faults, 0.62%–2.66% false positives, 4.55% average area overhead, and 1.53% average energy overhead.

Load-bearing premise

Every reported fault-detection rate assumes faults are single bit-flips inside registers of the kernel or checker, with Q, K, and V delivered by separately protected memory; faults in combinational logic or in the input path are outside the fault-injection model, so the percentages may not describe real chips if those fault classes matter.

Editorial extensions

If this is right

  • A FlashAttention-2 kernel needs one checksum comparison per full attention layer instead of one per matrix multiplication, removing redundant checkers from the datapath.
  • Faults in the softmax normalization, not just in the matrix products, are covered by the check, which earlier attention ABFT schemes that verify each multiplication separately cannot claim.
  • The checker merges into the existing output and value vector datapaths, so protection costs about 4.55% area and 1.53% energy in the synthesized design.
  • Larger hidden dimensions improve the detection/false-positive tradeoff: detection rises from 96.94% at d=64 to 98.87% at d=256, while false positives fall from 2.66% to 0.62%.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The same fused-checksum identity should transfer to any tiled or online-softmax attention implementation, not only FlashAttention-2, because it relies only on linearity and the row-normalizing property of softmax.
  • Because each query contributes its own check(q_i), a detected mismatch localizes the fault to at most a query row; the paper does not pursue this, but that locality is a plausible path to error correction by recomputing only the affected row.
  • Residual silent faults are attributed to floating-point rounding and invalid values; a second, differently weighted checksum would likely break the remaining cancellations and push that floor lower, at added hardware cost.
  • False positives are almost entirely faults that land in the checker's own registers; if that is the dominant mode, protecting only the checksum accumulators with lightweight replication should remove most false alarms.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper proposes Flash-ABFT, an algorithm-based fault-tolerance scheme for attention layers that maintains an online checksum alongside FlashAttention-2. The checksum is derived in Section III-A as the sum of all elements of the attention output matrix, re-expressed as a sum of per-query contributions. Section III-B integrates the checksum into the FlashAttention-2 recursion with negligible extra hardware. The authors synthesize an accelerator, report average area and energy overheads of 4.55% and 1.53%, and run fault-injection experiments on four LLM layers reporting 96.94%–98.87% detection, 0.3%–0.51% silent faults, and 0.62%–2.66% false positives.

Significance. The mathematical identity underlying the checksum is exact, and the online update is a clean extension of the FlashAttention-2 recursion, which is a genuine step toward low-overhead online checking of attention accelerators. The hardware integration is concrete, and the synthesis results provide a useful data point. However, the central advertised claim—that the method verifies the entire attention computation including softmax—is not supported, because the checksum reuses the same score/softmax intermediates as the output. The evaluation also relies on a fitted threshold and a restrictive fault model. With these caveats, the work has a defensible narrower contribution: a low-cost ABFT scheme for the value-multiplication and output-accumulation stage of FlashAttention.

major comments (4)
  1. [III-B, Alg. 3 lines 3-7, Eq. (10)] The predicted checksum is not independent of the output path. In Alg. 3, line 6 updates the output with factors e^{s_i-m_i} and e^{m_{i-1}-m_i}; line 7 updates the per-query checksum with the same two factors. Hence a fault that corrupts s_i, m_i, the exponential unit, or the registers holding these values enters both the output row and the checksum coherently. The equality c_N/ℓ_N = sum_k o_{N,k}/ℓ_N holds by construction even after such corruption, so the fault is silent. This directly contradicts the Abstract's claim of checking 'the entire three-matrix product of query, key and value matrices ... including the softmax operation.' At best, the scheme detects faults in the V-multiplication and output-accumulation stage, assuming the score/softmax path is correct. Since the paper's fault-injection campaign targets registers of the FlashAttention-2 kernel, some injected faults will fall in the score/max/exponent path and will be undetectable by design; Table I's 'silent' category does not separate these structural misses from rounding-induced misses.
  2. [IV-B, Table I] The error threshold of 10^-6 is set on the same data used to evaluate detection, as the paper states 'We found this limit out experimentally for the examined attention layers.' This is a fitted threshold and therefore inflates the detection percentages in Table I. The threshold should be determined from fault-free executions (e.g., the maximum checksum mismatch due to floating-point rounding) and then applied fixed at evaluation time, or the paper should report detection rates across a sweep of thresholds. As reported, the detection/false-positive numbers are not a valid predictive measure.
  3. [IV-B] The fault model only injects bit flips into storage elements and explicitly excludes faults in the Q/K/V memory by assuming separate protection. It does not cover combinational logic (dot-product multipliers, adders, comparators, exponential units) or faults in the input path. This is a serious coverage gap for a method marketed as checking the full attention operation, especially given the structural coupling identified in the first major comment. Additionally, no comparison is made to existing attention-specific ABFT schemes such as ATTNChecker [24] or ApproxABFT [23], or to a simple per-matrix-multiplication ABFT baseline, so the claimed advantage of a 'single check' is not quantified.
  4. [IV-A vs Abstract] The abstract reports '5.3% hardware area overhead and less than 1.9% energy overhead,' whereas Section IV-A reports an average area overhead of 4.55% and an average power overhead of 1.53% (Fig. 4). These numbers should be reconciled, or the abstract should cite the range per configuration, to avoid an inconsistency in the paper's headline claims.
minor comments (5)
  1. [III heading] The Section III heading contains a typo: 'ATTENTION-SPEFICIC ABFT' should be 'ATTENTION-SPECIFIC ABFT'.
  2. [II, III] Alg. 2 and Alg. 3 are referred to as 'Alg, 2' and 'Alg, 3' with commas; please use a consistent notation.
  3. [IV-B, Table I] The categorization in Table I counts faults injected into the checksum accumulators as 'False Positive.' This conflates faults inside the checker hardware with false alarms of the detection mechanism; a separate category would clarify the robustness of the checker itself.
  4. [IV-B] The claim that for 1-5 injected faults 'the possibility of having a false alarm is almost zero on average' is not supported by any table or figure; please include the data or qualify the claim.
  5. [IV-B] The last paragraph of Section IV-B correctly notes that the impact on end-to-end LLM accuracy is not quantified; given that this is a dependability paper, this limitation should be emphasized earlier in the evaluation section.

Circularity Check

2 steps flagged · score 7.0 of 10

The central softmax-inclusive detection claim reduces to an identity: the predicted checksum is the output row-sum computed from the same faulty intermediates (Eq. 8 / Alg. 3), so score-path faults are undetectable by construction; a fitted 1e-6 tolerance further conditions the reported detection rates.

  1. self definitional [Section III-B, Eq. (10); Alg. 3 lines 6-7; Eq. (8)]
    "Increasing by one element the output ⃗oi and the value vector ⃗vi, i.e., o∗ i = [ci ⃗oi] and v∗ i = [sumrowi(V ) ⃗vi] the merged incremental update of per-query checksum and the output shown in (9) can be written as: o∗ i = o∗ i−1 · emi−1−mi + v∗ i · esi−mi (10)"

    Alg. 3 computes c_i at line 7 with the same factors e^{s_i−m_i} and e^{m_{i−1}−m_i} used for o_i at line 6, and Eq. (10) literally appends c_i to o_i. Hence check(q_i)=c_N/ℓ_N is, in exact arithmetic, the sum of the elements of the computed output row o_N/ℓ_N for every score set. A bit-flip in a score, a maximum, a sum-of-exponents, or a shared V operand changes both the output and the 'predicted' checksum coherently, so the identity check=sum(output) still holds. The claimed online check of the Q·K^T/softmax part of attention is therefore not an independent ABFT prediction; it is a tautological re-expression of the output row-sum.

  2. fitted input called prediction [Section IV-B, paragraph before Table I]
    "To prevent silent faults due to rounding during our fault-injection campaigns, we consider a fault detected if the predicted checksum differs by the true output checksum by more than 10−6. We found this limit out experimentally for the examined attention layers."

    The 10^-6 bound that classifies a fault as detected/silent is set on the same 10,000 fault-injection campaigns used to produce Table I, so the reported detection percentages are measurements conditional on a fitted threshold, not parameter-free predictions. Changing the tolerance would directly change the reported 96.94%-98.87% detection figures, making the accuracy claim partly self-generated by the chosen operating point.

full rationale

The derivation of the checksum identity (Eqs. 3-8) is mathematically correct, and the hardware overhead measurements are independent, so this is not a wholesale circular paper. However, the central validation claim is circular in a structural sense. In Alg. 3, the per-query check c_i is updated with exactly the same exponentials of s_i−m_i and the same max-rescaling as the output vector o_i; Eq. (10) makes this explicit by appending c_i to o_i. Consequently check(q_i) equals the sum of the output row in exact arithmetic for any values of the scores, maxima, exponents, and shared V operands. The 'predicted' checksum is therefore not an independent ABFT prediction: faults in the score/softmax path (which the abstract explicitly claims to check) affect predicted and actual checksums coherently and are silent by construction. The detection percentages are also defined relative to a 1e-6 tolerance calibrated on the same fault-injection data, a mild secondary fit. What remains independent is detection of differential faults between the check accumulator and the output datapath, plus the area/energy overhead numbers. Score 7 reflects a central claim that reduces by construction while the paper retains some independent content.

Assumptions & free parameters 1 free parameters · 4 assumptions · 0 invented entities

The central checksum derivation is mathematically self-contained and introduces no new entities. The only fitted parameter is the detection threshold, which is set on the same data used to report detection accuracy. The fault model and the precision choice are explicit design assumptions that limit but do not invalidate the claims.

free parameters (1)
  • error_threshold = 1e-6
    The threshold for declaring a fault is set experimentally on the same benchmarks used to report detection rates (Section IV-B), making the reported percentages partly dependent on this fitted constant.
assumptions (4)
  • standard math Finite summations can be reordered (commutativity and associativity of addition)
    Used to derive Eq. (7) from Eq. (6) by interchanging the order of summation over indices i and k.
  • domain assumption Input matrices Q, K, V are loaded fault-free
    Explicitly assumed in Section IV-B: 'input data fetched are fault-free'.
  • domain assumption Faults occur only in storage elements with uniform bit-flip probability
    Fault injection methodology in Section IV-B restricts faults to registers, excluding combinational logic faults.
  • ad hoc to paper Double-precision accumulators keep rounding noise below the 1e-6 threshold
    The choice of double precision for checksum accumulators and the threshold value are tuned together to avoid false alarms in the reported experiments.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Custom Algorithm-based Fault Tolerance for Attention Layers in Transformers." pith.science (2026). https://pith.science/paper/T3YTLRY7

@misc{pith2026250716676,
  author       = {Pith},
  title        = {Pith review of: Custom Algorithm-based Fault Tolerance for Attention Layers in Transformers},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/T3YTLRY7}},
  note         = {Machine review of arXiv:2507.16676}
}
read the original abstract

Transformers and large language models (LLMs), powered by the attention mechanism, have transformed numerous AI applications, driving the need for specialized hardware accelerators. A major challenge in these accelerators is efficiently detecting errors caused by random hardware faults. Traditional algorithm-based fault tolerance (ABFT) techniques verify individual matrix multiplications but fall short in handling the full attention mechanism, particularly due to intermediate softmax normalization. This work proposes Flash-ABFT, a novel method that computes an online checksum across the entire three-matrix product of query, key and value matrices, of an attention layer, including the softmax operation, with a single check. This approach significantly reduces overhead by eliminating redundant checks while maintaining high fault-detection accuracy. Experimental results demonstrate that Flash-ABFT incurs only 5.3% hardware area overhead and less than 1.9% energy overhead, making it a cost-effective and robust solution for error detection in attention accelerators.

Figures

Figures reproduced from arXiv: 2507.16676 by the authors.

Figure 1
Figure 1. An encoder-only transformer layer. For instance, BERT-base [5] [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. A block-parallel hardware architecture for FlashAttention-2 kernel. the difference between the current and previous maximum values. The term e mi−1−mi ensures that ℓi remains properly updated, when mi surpasses the previous maximum mi−1. Similarly, the output vector ⃗oi is updated by weighting the new value vector ⃗vi with its incremental softmax importance and adjusting the previous output ⃗oi−1. Finally, the atten… view at source ↗
Figure 3
Figure 3. A block-parallel hardware architecture for FlashAttention-2 kernel [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: The area and average power consumption of the FlashAttention-2 [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

31 extracted references · 21 canonical work pages

  1. [24]

    ATTNChecker: Highly-optimized fault tolerant attention for large language model train- ing,

    Y . Liang, X. Li, J. Ren, A. Li, B. Fang, and J. Chen, “ATTNChecker: Highly-optimized fault tolerant attention for large language model train- ing,” in ACM SIGPLAN Symp. on Principles and Practice of Parallel Programming (PPoPP), 2025, p. 252–266

    work page 2025

  2. [23]

    Approxabft: Approximate algorithm-based fault tolerance for neural network pro- cessing,

    X. Xinghua, L. Cheng, M. Feng, L. Tao, and H. Yinhe, “Approxabft: Approximate algorithm-based fault tolerance for neural network pro- cessing,” arXiv preprint arXiv:2302.10469 , 2025

    arXiv 2025

  3. [1]

    Exploring the limits of transfer learning with a unified text-to-text transformer,

    C. Raffel et al., “Exploring the limits of transfer learning with a unified text-to-text transformer,”Journal of Machine Learning Research, vol. 21, no. 140, pp. 1–67, 2020

    work page 2020

  4. [2]

    Llama: Open and efficient foundation language models,

    H. Touvron et al. , “Llama: Open and efficient foundation language models,” arXiv preprint arXiv:2302.13971 , 2023

    arXiv 2023

  5. [3]

    An image is worth 16x16 words: Transformers for image recognition at scale,

    A. Dosovitskiy et al., “An image is worth 16x16 words: Transformers for image recognition at scale,” inIntern. Conf. on Learning Representations (ICLR), 2021

    work page 2021

  6. [4]

    Attention is all you need,

    A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin, “Attention is all you need,” Advances in neural information processing systems , vol. 30, 2017

    2017

  7. [5]

    BERT: Pre-training of deep bidirectional transformers for language understanding,

    J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova, “BERT: Pre-training of deep bidirectional transformers for language understanding,” in North American Chapter of the Association for Computational Linguistics , 2019

    work page 2019

  8. [6]

    ALBERT: A lite bert for self-supervised learning of language represen- tations,

    Z. Lan, M. Chen, S. Goodman, K. Gimpel, P. Sharma, and R. Soricut, “ALBERT: A lite bert for self-supervised learning of language represen- tations,” in Intern. Conf. on Learning Representations (ICLR) , 2020

    work page 2020

Show all 31 references
  1. [7]

    Longformer: The long- document transformer,

    I. Beltagy, M. E. Peters, and A. Cohan, “Longformer: The long- document transformer,” arXiv preprint arXiv:2004.05150 , 2020

    2004 arXiv

  2. [8]

    Generating long sequences with sparse transformers,

    R. Child et al. , “Generating long sequences with sparse transformers,” arXiv preprint arXiv:1904.10509 , 2019

    1904 arXiv

  3. [9]

    Transformers are rnns: Fast autoregressive transformers with linear attention,

    A. Katharopoulos et al. , “Transformers are rnns: Fast autoregressive transformers with linear attention,” 2020

    2020

  4. [10]

    Linformer: Self-attention with linear complexity,

    S. Wang et al., “Linformer: Self-attention with linear complexity,” arXiv preprint arXiv:2006.04768, 2020

    2006 arXiv

  5. [11]

    Flashattention: Fast and memory-efficient exact attention with IO-awareness,

    T. Dao, D. Fu, S. Ermon, A. Rudra, and C. R ´e, “Flashattention: Fast and memory-efficient exact attention with IO-awareness,” Advances in neural information processing systems, vol. 35, pp. 16 344–16 359, 2022

    2022

  6. [12]

    Flashattention-2: Faster attention with better parallelism and work partitioning,

    T. Dao, “Flashattention-2: Faster attention with better parallelism and work partitioning,” arXiv preprint arXiv:2307.08691 , 2023

    2023 arXiv

  7. [13]

    Self-attention does not need O(n2) memory,

    M. N. Rabe and C. Staats, “Self-attention does not need O(n2) memory,” arXiv preprint arXiv:2112.05682 , 2021

    2021 arXiv

  8. [14]

    Testability and dependability of ai hardware: Survey, trends, challenges, and perspectives,

    F. Su, C. Liu, and H.-G. Stratigopoulos, “Testability and dependability of ai hardware: Survey, trends, challenges, and perspectives,” IEEE Design & Test, vol. 40, no. 2, pp. 8–58, 2023

    2023

  9. [15]

    Radiation-induced soft errors in advanced semiconductor technologies,

    R. Baumann, “Radiation-induced soft errors in advanced semiconductor technologies,” IEEE Trans. on Device and Materials Reliability , vol. 5, no. 3, pp. 305–316, 2005

    2005

  10. [16]

    Designing reliable systems from unreliable components: the challenges of transistor variability and degradation,

    S. Borkar, “Designing reliable systems from unreliable components: the challenges of transistor variability and degradation,” IEEE Micro , vol. 25, no. 6, pp. 10–16, 2005

    2005

  11. [17]

    Koren and C

    I. Koren and C. Krishna, Fault-Tolerant Systems. Morgan Kaufmann, 2020

    2020

  12. [18]

    Algorithm-based fault tolerance for matrix operations,

    K.-H. Huang and J. A. Abraham, “Algorithm-based fault tolerance for matrix operations,” IEEE Trans. on Computers , vol. C-33, no. 6, pp. 518–528, 1984

    1984

  13. [19]

    Towards practical algorithm based fault tolerance in dense linear algebra,

    P. Wu et al., “Towards practical algorithm based fault tolerance in dense linear algebra,” in Proc. of the ACM Intern. Symp.on High-Performance Parallel and Distributed Computing , 2016, p. 31–42

    2016

  14. [20]

    Low-cost online convolution checksum checker,

    D. Filippas, N. Margomenos, N. Mitianoudis, C. Nicopoulos, and G. Dimitrakopoulos, “Low-cost online convolution checksum checker,” IEEE Trans. on VLSI Systems , vol. 30, no. 2, pp. 201–212, 2022

    2022

  15. [21]

    Making convolutions resilient via algorithm-based error detection techniques,

    S. K. S. Hari, M. B. Sullivan, T. Tsai, and S. W. Keckler, “Making convolutions resilient via algorithm-based error detection techniques,” IEEE Trans. on Dependable and Secure Computing , vol. 19, no. 4, pp. 2546–2558, 2021

    2021

  16. [22]

    GCN-ABFT: Low-cost online error checking for graph convolutional networks,

    C. Peltekis and G. Dimitrakopoulos, “GCN-ABFT: Low-cost online error checking for graph convolutional networks,” IEEE Trans. on Computer-Aided Design of Integrated Circuits and Systems , vol. 44, no. 7, pp. 2836–2840, 2025

    2025

  17. [25]

    Error resilient transformers: A novel soft error vulnerability guided approach to error checking and suppression,

    K. Ma, C. Amarnath, and A. Chatterjee, “Error resilient transformers: A novel soft error vulnerability guided approach to error checking and suppression,” in IEEE European Test Symposium (ETS) , 2023, pp. 1–6

    2023

  18. [26]

    Language models are unsupervised multitask learn- ers,

    A. Radford et al., “Language models are unsupervised multitask learn- ers,” OpenAI blog, p. 9, 2019

    2019

  19. [27]

    Attention is all you need,

    A. Vaswani et al., “Attention is all you need,” in Intern. Conf. on Neural Information Processing Systems (NIPS) , 2017, p. 6000–6010

    2017

  20. [28]

    Mnnfast: a fast and scalable system architecture for memory-augmented neural networks,

    H. Jang, J. Kim, J.-E. Jo, J. Lee, and J. Kim, “Mnnfast: a fast and scalable system architecture for memory-augmented neural networks,” in Intern. Symp. on Computer Architecture (ISCA) , 2019, p. 250–263

    2019

  21. [29]

    Online normalizer calculation for softmax,

    M. Milakov and N. Gimelshein, “Online normalizer calculation for softmax,” arXiv preprint arXiv:1805.02867 , 2018

    2018 arXiv

  22. [30]

    Huggingface’s trans- formers: State-of-the-art natural language processing,

    T. Wolf, L. Debut, V . Sanh, J. Chaumond, C. Delangue, A. Moi, P. Cistac, T. Rault, R. Louf, M. Funtowicz et al., “Huggingface’s trans- formers: State-of-the-art natural language processing,” arXiv preprint arXiv:1910.03771, 2019

    1910 arXiv

  23. [31]

    Automatic detection of floating- point exceptions,

    E. T. Barr, T. V o, V . Le, and Z. Su, “Automatic detection of floating- point exceptions,” in ACM SIGPLAN Symposium on Principles of Programming Languages (PoPL), 2013, p. 549–560

    2013

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.