Fuzzy PyTorch: Rapid Numerical Variability Evaluation for Deep Learning Models
Authors: Inés Gonzalez Pepe
Hiba Akhaddar
Tristan Glatard
Yohan Chatelain
Venue: Accepted by TMLR ()

Abstract: We introduce Fuzzy PyTorch, a framework for rapid evaluation of numerical variability in deep learning (DL) models. As DL is increasingly applied to diverse tasks, understanding variability from floating-point arithmetic is essential to ensure robust and reliable performance. Tools assessing such variability must be scalable, efficient, and integrate seamlessly with existing frameworks while minimizing code modifications. Fuzzy PyTorch enables this by integrating stochastic arithmetic into PyTorch through Probabilistic Rounding with Instruction Set Management, a novel library interfacing with Verificarlo, a numerical analysis compiler. The library offers stochastic rounding mode and a novel mode; up-down rounding.
Comparative evaluations show Fuzzy PyTorch maintains model performance and achieves runtime reductions of $5\times$ to $60\times$ versus Verrou, a state-of-the-art tool. We further demonstrate scalability by running models from 1 to 341 million parameters, confirming applicability across small and large DL architectures. Overall, Fuzzy PyTorch provides an efficient, scalable, and practical solution for assessing numerical variability in deep learning, enabling researchers and practitioners to quantify and manage floating-point uncertainty without compromising performance or computational efficiency.

Published in Transactions on Machine Learning Research (01/2026)
Fuzzy PyTorch: Rapid Numerical Variability Evaluation for Deep Learning Models
Inés Gonzalez-Pepe
Deportment of Computer Science and Software Engineering Concordia University Montreal, Cenada
Hiba Akhaddar
h. www.aaaadlioee...ooo...ooeoeeeee
Department of Computer Science and Software Engineering Concordia University Montreal, Canada
Tristan Glatard
bristan.glatarnl@camm..co
Krembil Centre for Neuroinformatics Centre for Addiction and Mental Health Toronto, Conada
Yohan Chatelain
yohan. Aahannchaaellaing @camb.
Krembil Centre for Neuroinformaties Centre for Addiction and Mental Health Toronto, Canada
Reviewed on OpenReview: https: // openreview. net/ otee://wwrr..re00003323//0001110
Abstract
We introduce Fuzzy PyTorch, a framework for rapid evaluation of numerical variability in deep learning (DL) models. As DL is increasingly applied to diverse tasks, understanding variability from floating- point arithmotic is essential to ensure robust and reliable perfor- mance. Tools assessing such variability must be scalable, efficient, and integrate seamlessly with existing frameworks while minimizing code modifications. Fuzzy PyToorh enables this by integrating stochastic arithmetic into PyTTorch through Probabilistic Rounding with Instruction Set Management, novel library interfacing with Verificarlo, numerical anal- ysis compiler. The library offers stochastic rounding mode and novel mode; up-down rounding. Comparative evaluations show Fuzzy PyTorch maintains model performance and achieves runtime reductions 3x to 60x versus Verrou, a state-of-the-art tool. We further demonstrate scalability by running models from applicability across small and large DT. architectures. Overall, Fuzzy PyTorch provides efficient, scalable, and practical solution for asscssing numerical variability in deep lcarning, enabling researchers and practilioners to quantify and manage loating-point uncertainty without compromising performance or computational efficiency.
341 million parameters, confirming
1 Introduction
Many scientific domains have increasingly adopted deep learning (DL) models for computational analysis. However, Whese models often rely on numerical computations that are sensitive to variations in floating- point precision and rounding modes. Understanding numerical variability DL models is therefore essential for ensuring reliable and reproducible outcomes. This particularly critical in high-stakes applications such medical imaging (Des Ligneris al.) 2023 Gonzalez-Pepp al. 2023 Vila et al., (2024), remote
sensing (Vicuna al. 2021 J, and scientific simulations (Chatelain et al.] 2022 Meanwhile, the importance

---

Published in Transactions on Machine Learning Research (01/2026)
of numerical variability is beginning to gain industry-wide recognition. For example, variability analysis is
now supported in Amazon Web Services' (AWS) Neuron SDK (AWS Neuron Team n.d.j. AWS Trainium
chips, AMD M1300 GPUs, Tesla DIs and Blackwell architecture NVIDIA GPUs (El Arar 2025 This
reflects a growing demand for tools and frameworks that enable low-level control over numerical behavior in AT systems.
Although exact methods such as interval arithmetic (Hickey et al. 2001), symbolic execution (Solovyev et al., 2018), and formal verification (Boldo & Melquiond 2011) cxist to evaluate numerical accuracy, these approaches often require extensive modifications to the codebase and do not scale efficiently to complex deep learning workloads. Instead, we adopt stochastic arithmetic, technique that introduces controlled random perturbations to floating-pos point operations. This enables statistical estimation of the numerical variability without modifying the underlying model architecture, making it more practical for large-scale applications. Stochastic arithmetic encompasses various techniques, including Monte Carlo Arithmetic (MCA) (Parkrr 1997), CESTAC (Brunet & Chatclin 1986) and Stochastic Rounding (Forsythe 1959). To leverage stochas- tie arithmetic, researchers have developed lools such as Verificarlo (Denis et al. 2016), Verrou (Févotte & Lathuiliere 2016), the stochastic rounding library by Fasi and Mikaitis (aasi & Mikaitis 2021 and CADNA (Jézéquel & Chesncaux 2008).
While stochastic arithmetic has been widely explored in numerical analysis, it remains underused in deep learning, despite recent studies demonstrating its potential to assess uncertainty in neural network training and inference (Faraone & Leong 2019 Kloberdanz et al. 2022 Beuzeville et al.) 2024 Arar et al.] 2025). A major practical challenge of stochastic arithmetic is the need to run programs multiple times, typically 10 times or more, to obtain stable statistical estimates of their variability. However, currently available stochastic arithmetic tools, especially Verrou, one of the more accessible stochastic arithmetic frameworks for DL, introduce slowdowns of 10x to 1000 on DL models with only few million parameters. In such settings, collecting enough samples takes days or weeks, even with parallelization, and scaling these analyses to modern large language models becomes effectively infcasible. For numerical variability research to keep pace with rapidly growing DL archilect it is therefore essential to develop tools that introduce minimal computational overhead. This motivates the design goals of Fuzzy PyTorcc, which prioritizes speed and scalability that numerical variability studies remain tractable even on increasingly large models.
Fuzzy PyTorch integrates stochastic arithmetic, more specifically Monte Carlo Arithmetic (MCA), into the PyTorch framework through a novel library named Probabilistic Rounding with Instruction Set Management (PRISM). PRISM implements two modes: stochastic rounding (SR) and Up-Down round- ing (LD). SR bypasses exact operations and therefore preserves exact values by probabilsttially rounding values based on their proximity to representable matiing-point numbers. Meanwhile, UD a newly pro- posed rounding mode that is faster at the level of individual operations, as it randomly rounds up or down with equal probability. Both modes are optimized using vectorized CPU instructions through the Highway library (Google| 2024a), minimizing computational overhead. Fuzzy PyToorc seamlessly integrates with Py- Torch by extending the Verificarlo compiler, providing fast, practical framework for numerical variability analysis in deep learning. By integrating directly with the PyTorch execution pipeline and avoiding the major bottlenecks present in traditional approaches, such as the strict serialization in Verron or the lack of vectorized support in CADNA and standard MCA, Fuzzy PyTorch enables full-scale analyses that were previously computationally prohibitive. Compared to stato-of-the-art tools, Fuzzy PyTorch achieves similar numerical-error characteristies but with markedly lower runtime, allowing researchers to evaluate numerical variability across full DL workflows. This efficiency makes large-scale, systematic studies of floating- pointt behavior feasible, directly supporting rescarch on reproducibility, robustness, and numerical uncertainty in modern neural networks and helping advance reproducible and principled DL research.
This work proposes three main contributions:
1. PRISM: We introduce PRISM, which implements fast probabilistic rounding methods for the sys- lematic analysis of floating-pon point errors.
Stochastic arithmetic in PyTorch:
We seamlessly integrate stochastic arithmetic into PyTorch, enabling efficient. and transparent instrumentation of deep learning operations.
2

---

Published in Transactions on Machine Learning Research (01/2026)
3. Comparative evaluation with Verrou: We perform comprehensive evaluation against Verrou, state-of-the-art tool for numerical variability analysis, showcasing the enhanced performance and flexibility of Fuzzy Py'Trrh on use cases ranging from digit classification with MNIST (LeCun 1998), whole brain MRI segmentation with the FastSurfer neuroimaging model (Henschel et al. 2020), and Parkinson's 's classification from speech data with the WavLM model (Chen et al. 2022
The remainder of this paper is structured as follows: Section D details the design and implementation of Fuzzy Pytorch, including the UD rounding mode, the PRISM library implementation and PyTTrch instrumenta- tion. Section
X presents results validating numerical accuracy and demonstrating 5-60x runtime speedups concludes with discussion of limitations and future directions. Supplementary mate- rial, including additional information on existing rounding modes, use cases, the algorithm for probabilistic rounding and further statistical analysis of the harmonic series, is provided in the Appendix.
over Verrou. Section |
2 Fuzzy Pytorch Design and Implementation
Fuzzy Pytorch implements new rounding mode, Up-Down rounding (subsection 2.1 a faster alternative to stochastic rounding implemented in the PRISM library (subsection 2.2p. The PRISM library implements the SR and UD rounding modes and the modifications to the Verificarlo compiler for compiling PyTorch with the PRISM library.
2.1 Up-Down Rounding
The Up-Down Rounding (UD) technique rounds the result of already rounded floating-poiis point operation to the next or previous peating-point number with equal probabilities. Although UD rounding does not preserve exact floating-point operations, it produces results similar to SR rounding on large code bases, while generally being significantly faster. UD rounding is defined as:
OuD (x) = {on (x) - <(xr) with probability 1 OnnN (z) + e(x)
(1)
with probability 1tf
where (()) is the unit in the last place Muller et al. 2018 x * 0 and 0 otherwise, and Ggw is the IEFF- 754 round-to-ncarest with tics-to-cven rounding mode. Additional details and formal definitions of stochastic rounding, as well as the other rounding modes used for comparison to UD (CESTAC, and IEEE-754), are provided in Appendix A
2.2 PRISM
PRISM a C++ library that implements the SR (Appendix(A.22) (.2.2) and UD rounding (sub-section 2.1 modes. We do not currently plan to support CESTAC, as it is not as commonly used as SR, but we consider as a future work direction. PRISM leverages the Highway library (Google) 2025 to use vectorized instructions available modern CPUs, thereby minimizing the overhead rntrodueed by stochastic arithmetic. Highway selects the best architecture target to generate the most efficient code for the CPU, either at compile time (static dispatch) or runtime (dynamic dispatch).
PRISM provides probabilistic rounding (SR and UD) for the floating-point operations (+.-,+,x, x, v. Fused Multiply-Add (FMA)). The SR operators (except. FMA) are implemented us- ing the rounding-mode-free algorithms by (Fasi & Mikaitis 2021). We extend these algorithms to support the FMA instruction (described in Algorithm [T. Our FMA implementation is inspired by Verrou and is based on the ErrFmaNearest Algorithm by (Boldo & Muller 2010).
PRISM's interface offers functions for scalar and vector instructions, supporting both static and dynamic dispatch. The static dispatch versions accept vector types as imputs, while the dynamic dispatch versions accept pointers to scalar types. Dynamic dispatch is necessary because vector types may not be available at runtime (e.g., 512-bit AVX-512 registers on AVX2 architecture with 256-bit registers). Although slightly slower, dynamic dispatch enhances portability, enabling x86-64 binaries to run on any architecture
3

---

Published in Transactions on Machine Learning Research (01/2026)
Algorithm 1: FMA With Stochastic Rounding Without the Change of the Rounding Mode
1: function (a E be F,
Compute g == (a b F
Z t rand()
a oR b
u2) + TwoProdFMA((, b)
6:
(01.02) - TwoSum(c, u2)
7:
(2), - TwoSum(u1,,a)
8:
Y - ORN(ORN(61 - -r) 82)
T + C
10:
round < (R T, Z)
11:
@ PRN (r1 round)
12: Return result
13: end function
Finally, PRISM supports multithreaded execution by assigning a separate random generator to each thread, ensuring that concurrent executions do not share the same seed state. This enables optimal performance without requiring any syuchronization mechanism and prevents correlations in the generated floating- point perturbations across threads.
We modified the Verificarlo compiler (Denis el al. 2016 to use the PRISM library. Verificarlo replaces toating-pointtooo floating point operations with generic calls to configurable backends (e.g., MCA, IEEE, VPREC (Chatelain et al. 2019)) at the LLVM (Lattner & Adve 2004) Intermediate Representation (IR) level. In its current version, Verificarlo scrializes the vectorized instructions, which can cause additional slowdowns. It adheres the Interflop (Defour et al., 2021) interface, which exposes scalar arithmetic operations but not vectorized ones. Specifically, we implemented new LLVM instrumentation passes to replace scalar and vectorized floating-ooin operations with calls to the PRISM library. We also ensured ABI compatibility between the PRISM library and the source code to prevent incorrect register use during argument passing,
2.3 PyTorch Instrumentation
We instrumented PyTorch version 2.2.1 with Verificarlo 2.0.0, using the PRISM library as the backend. Verificarlo was built with LLVM version 7.0.0, including support for FORTRAN code through LLVM's flang compiler. We used Python 3.8.5. To ensure compatibility with Verificarlo, we modified only one line in the PyTorch codebase. Specifically, we removed the noexcept keyword from the move constructor of the Module class sorch//carc/js//api//nooo errors related to LLVM compatibility but should no longer be required with more recent LLVM versions.
This adjustment was necessary to prevent compilation
To achieve complete instrumentation, we compiled the open-source BLAS and LAPACK libraries (Anderson) et al. 1999 with Verificarlo, replacing the proprietary Intel MKL library the default BLAS implemen- tation. Architecture-specffi instructions (-march-native) were enabled to leverage vectorized operations. Additionally, the ONNX /Community 2024) runtime was compiled with the PRISM library to ensure compre- hensive instrumentation of the entire model execution. We disabled the use of the Intel MKL DNN (Corpo- ration 2024) library avoid reliance on proprietary software. We did not instrument the protobuf (Google) 2024b) third-party library to avoid perturbing model serialization. We conducted the experiments using the software versions listed above. While have also instrumented PyTorch 2.6.0 with Python 3.10 and LLVM 11.0.0 via Verificarlo 2.2.0 (the code is available for compilation in our documentation), these were not used in the experiments reported in this paper.
We excluded specific functions from instrumentation because they were susceptible to producing erroneous outputs under our rounding modes. Correct instrumentation alternatives are under development. In particu- lar, PyTorch's exponential and logarithmic functions the SLEEF (SIMD Library for Evaluating Elementary Functions) third-party library exhibited large output deviations when perturbed, especially when input val- ues approached zero. Similarly, the torch. argmax operation became unreliable under UD rounding, likely
4

---

Published in Transactions on Machine Learning Research (01/2026)
because approximate rounding alter comparisons when input values are close, affecting the selected in- dex. As these functions are sensitive and integral to correct model behavior, they were not instrumented to ensure the reliability of the current results.
2.4 Availability of Data and Code
The code and data used this study are available on GitHub at https:://itthub.cco http://ttuuu..ooo//iigtttaaaaaaa team/ fuzzy-pytorch The repository includes the PRISM library, the modified Verificarlo compiler, the Dockerfile to build Fuzzy PyTorch, and the scripts used to run the experiments.
2.5 Computational Infrastructure
All experiments except for the WavLM experiment were conducted on a server equipped with 8 compute nodes with 32 cores Intel(R) (R) Gold 6130 CPU @ 2.10GHz 22MB cache L3. The WavLM experiment was conducted on the Narval cluster from École de Technologie Supéricure (ETS, Montréal), managed by Calcul Québec and The Digital Alliance of Canada which includes AMD Rome 7502, AMD Rome 7532, and AMD Milan 7413 CPUs with 48 to 64 physical cores, 249 GB to 4000 GB of RAM and Linux kernel 3.10.
3 Results
We evaluated the accuracy, runtime efficiency, and numerical variability of Fuzzy Pylorch using Verrou, CADNA, and the stochastic rounding library of Fasi and Mikaitis as baselines. We performed (1) a sanity check with the harmonic series, a classical example in numerical analysis, (2) a computational overhead assessment with the NAS Parallel Beuchmarks, demonstrating Fuzzy PyTorch's performance in an HPC context, and (3) runtime performance and numerical variability assessments in three practical deep-lcarning applications: MNIST digit classification, FastSurfer CNN brain segmentation, and WavLM-based speech classification.
3.1 Numerical Error Estimation Baselines
We compared the PRISM library with several state-of-the-art tools for numerical variability analysis. Ver- rou (Nethercote & Seward 2007) Valgrind- based Dynamic Binary Instrumentation tool that perturbs foating-point operations by replacing them with custom rounding functions, supporting modes such Stochastic Rounding (SR, called average rounding) and asynchronous CESTAC (called random rounding), and can instrument binaries without recompilation, though multithreading is serialized due to Valgrind. The Verificarlo MCA backend (Parker 1997) implements Monte Carlo Arithmetic by injecting uniform perturbations with a usor-defined virtual precision t, performing computations at twice the target preci- sion to avoid double rounding, and offering modes including Random Rounding (equivalent[] to SR when = p), but incurs overhead from serializing vectorized instructions and using 128-bit arithmetic for binary64. synchronous stochastic arithmetic library via overloaded stochastic types that propagate three perturbed values per operation and estimate significance loss (e.g., "compulational wero"), with OpenMP support for threads but no vectorized instruction support. Finally, the stochastic rounding library of Fasi and Mikaitis (FM) (Fasi & Mikaitis 2021) offers C functions implementing SR for scalar maatingg-pni operations (excluding FMA), requiring explicit replacement of each arithmetic operation and lacking vectorized interfaces. We will refer to this library as FM SR in the remainder of the paper.
CADNA (Jézéquel & Chesneaux 2008) provides a CESTAC-
3.2 Harmonic Series Validates Expected Variability Patterns
To evaluate the accuracy of the UD and SR rounding modes, analyzed the harmonic series Σ 1 for ranging from 102 to 10 While this series is divergent in real arithmetic, it converges in floating- point arithmetic for 2 248 within IEEE-754 binary32 format due to numerical absorption (Malone 2013). We
The MCA RR mode is biased for imputs close power of two, see de Oliveira Castro 2022
5

---

Published in Transactions on Machine Learning Research (01/2026)
performed computations in IEEE-754 binary32 format and compared PRISM against established baselines: CESTAC (via CADNA), MCA RR (via Verificarlo), Verrou (SR and CESTAC modes) and FM SR. A binary64 computation served as the reference value.
Figure 1 presents the standard deviation and mean values obtained from three repetitions per mode (the three internal values extracted from a single run for CADNA). The results show that PRISM SR exhibits variability comparable to MCA RR, Verrou SR, and FM SR (Levene's test, p 0.29; see Extended Data Table 2. In contrast, UD rounding displays higher variability, which is expected it applies perturbations to values that have already been rounded. Finally, CADNA exhibits the highest variability it ensures different rounding directions across its three internal repetitions.
As shown in Figure 1 the mean values exhibit three distinct behaviors:
The MCA SR, Verrou SR, PRISM SR, and FM SR modes closely approximate the binary64 reference value. This aligns with expectations, as SR rounding converges to the expected value.
The CESTAC and Verrou CESTAC modes diverge more rapidly. This behavior consistent with the known bias introduced by CESTAC rounding.
3. The PRISM UD mode converges toward the binary32 result, expected, since UD rounding applies random perturbations to values that have already been rounded using the round-to-ncarest mode.
IEEE binary64
PRISM UD
Verrou CESTAC
MCA
CESTAC FM SR
IEEE binary32
Standard Deviation
10
-
Avera 0
10-4
10-5
10-6
10-7
102
10a
10a
10a
106
10
106
10
Iteration
Figure 1: Comparison of probabilistic rounding on the harmonic series example.
3.3 PRISM UD Minimizes Runtime Slowdowns for NAS Parallel Benchmarks
We evaluated the runtime overhead introducod by PRISM using the C++ NAS Parallel Benchmarks version 3.4.1 Löff et al.] 2021) (Appendix Table D. The Integer Sort. (IS) benchmark was excluded, as it does involve doating-poine operations.
Experiments were performed using the scrial implementation on datasct classes S and A, corresponding to the smallest benchmark workloads. PRISM SR and UD modes were compared against CESTAC (via CADNA), MCA RR (via Verificarlo), Verrou (SR and CESTAC modes) and FM SR. All benchmarks were compiled with marchhhaswelll -maes to enable AVX2 instructions and executed using IEEE-754 binary64 arithmetic. Runtimes were averaged over three independent repetitions. An uninstrumented execution was used the baseline.

---

Published in Transactions on Machine Learning Research (01/2026)
Figure 2 shows that PRISM SR induces runtime slowdowns that comparable to, lower than, those observed for Verrou SR and CADNA. PRISM UD consistently yields the lowest overhead among the evaluated tools. These trends are consistent across dataset classes
Method
PRISM UD
PRISM SR
CESTAC
Verrou CESTAC
Verrou SR
FM SR
MCA RR
Class=
C
bt
mg
Benchmark
cg
ep
50
100
150
200
50
100
150
200
Slowdown (relative to IEEE)
Slowdown (relative to IEEE)
Figure 2: Comparison of slowdowns across numerical variability analysis tools for NAS Parallel Benchmarks on datasct and A, relative to the IEEE binary64 bascline.
3.4 Fuzzy PyTorch Achieves Significant Runtime Speedup
To further evaluate Fuzzy PyTorch's efficiency in practical DL workflows, we measured inference runtime for MNIST, FastSurfer and WavLM (sce model descriptions in Appendix [ We compared PRISM UD and SR modes against Verrou's CESTAC and SR modes. All experiments were executed using a single thread, Verrou enforces serialization of multithreaded execution.

---

Published in Transactions on Machine Learning Research (01/2026)
Method IEEE
Verrou CESTAC
Verrou SR
PRISM UD PRISM SR
10
Mean Runtime (sec)
10
10
10
10
10
MNIST
FastSurfer
WavLM
Figure 3: Comparison of instrumentation runtimes across DL models
As seen in Figure 3 Fuzzy Py'Torch achieves speedups ranging from 5x to 60x for UD mode and 7x 49x for SR mode compared to Verrou. This improvement is notable considering that Verrou's PyTorch instrumentation relies on the highly optimized Intel MKL library, whereas Fuzzy PyTorch uses the standard Netlib BLAS/LAPACK implementation.
In contrast to the NAS Parallel Benchmarks, where PRISM UD consistently outperformed PRISM SR, the relative performance of UD and SR varies across deep learning workloads. For WavLM, SR achieves a larger speedup (7.89x relative Verrou) than UD (5.65x). UD retains an advantage for the CNN-basod architectures FastSurfer (UD: 60.43x, SR: 49.07x) and MNIST (UD: 39.22x, SR: 30.81x).
We attribute the UD slowdown WavLM to its transformer- architecture. Transformer models are computationally more complex than CNNs: self-attention layers introduce quadratic cost in sequence length with heavier intermediate memory usage. Unlike UD which incurs a constant perturbation cost for every operation, SR bypasses exact operations, reducing its relative overhead.
3.5 Comparable Numerical Variability between Fuzzy PyTorch and Verrou
To assess Fuzzy PyTorch beyond runtime performance, we evaluated the numerical variability it introduces compared to Verrou across MNIST, FastSurfer and WavLM.
evaluated standard classification metrics, including accuracy and weighted precision, recall, and Fl score, and quantified numerical variability using the significant digits metric (Sohier ctt al. 2021). In binary32 arithmetic, the theoretical upper bound 7.23 significant digits; across all metrics we observed a maximum of approximately 6.17 significant digits, with the loss function exhibiting noticeably higher variability. Variability effectively confined the loss across both Fuzzy PyTorch and Verrou, which is expected given that MNIST is a well-solved task with highly stable predictions. UD rounding consistently introduces greater variability than stochastic rounding for both tools. Fuzzy PyTorrc shows slightly lower significant digits overall, which we attribute to its instrumentation of AVX-512 vector instructions, allowing a wider class of floating-poin operations to be perturbed compared to Verrou.
For MNIST in Figure 4a
In the WavLM use case (Figure μbb. as with MNIST, we evaluated numerical variability across accuracy and the weighted variants of precision, recall, and F1 score. On average, we observe 6.17 significant digits across all performance metrics, indicating high numerical comparable that observed across IEEE executions.
8

---

Published in Transactions on Machine Learning Research (01/2026)
Significant Digits
6.5
Sig Significant Digits
5.5
Accuracy
Precision
Recall
Average Loss per Batch
F1
Precsion
Recall
Accuracy
Metrics
Metrics
(a) MNIST
(b) WavLM
Fuzzy UD
Verrou CESTAC
Fuzzy SR
Verrou SR
Figure Significant digits across MNIST and WayLM model metrics for different instrumentation tools.
To investigate whether this apparent stability conceals underlying instability, we analyzed the model's output probabilitics before the final max operation. As shown in Figure 5 the number of significant digits drops, averaging around across all modes and tools, with a standard deviation of approximately half digit. This suggests that Consistent with findings from previous cases, also note that PRISM UD mode introduces the highest level of numerical perturbation-ovan surpassing Verrou's CESTAC mode.
numerical instability is indeed present. but is masked by the final operation.
Healthy Control Class Probability
Parkinson's Disease Class Probability
Fuzzy
Fuzoy
Significant Dight
Number of Subjects
Stochastic rounding mode
Healthy Control Class Probability
Parkinson's Disease Class Probability
Fudcy Vercuu
Fucay Vetto
10 20
30
50
60
10
20
30
40
60
70
Number of Subjects
Up-Down rounding
Figure 5: Significant digits for rounding modes across WavLM model's class probabilities
For the FastSurfer use case, we assess variability at inference using the minimum Carensen-Dice scores be- tween MCA ilerations (Figure Gb. The minimum Sørensen Dice score captures the most extreme cases of variability across brain regions, offering a global measure of segmentation consistency, Across all modes, co- efficients remain extremely high, with the lowest observed value approaching 0.9985. Variability magnitudes are similar across methods, though slightly higher for PRISM UD, likely due to its lack of preservation of exact operations. Similarly to the MNIST results, PRISM UD shows the highest variability but still main-

---

Published in Transactions on Machine Learning Research (01/2026)
tains comparable segmentation accuracy. These results confirm that our MCA-based instrumentation for FastSurfer operates correctly, producing consistent and interpretable variability measurements across modes. Left-Pallidm
Fuzzy
Fuzzy Verrou
Verrou
Left- Thalamul
WM-hypointensilles
Righttchorrid-pleeus
Right-VentraIDC
LeftLLateral-Ventriie
Right-Thalamuus
Left-Inf-Lar--e
Right Putamen
Right-Palidum
Left Hippocampus
Righi-Lateral-Veniiin
Lelt-Cerebral- Matter
Right-Inf-Let-Vent
Left- Coeb-Cerbbrll-Crteex
Fight-Hippocampus
Lefi www.-eeeelllm-hhiceee Matter
Right Ceret-Cerebral-o White Matter
Left: Cerebellum Cortex
Right Cerebral Cortex
Left-Caudate
Right-Crrebellum White-Matie
Left-Amygdala
Sight-Cerebellum-Core
Left-Accumbens-anc
Right-Caudate
CSF
Right-Amyydalaa
Brain-Stem
Right Accumbersss area
Ath-Ventricle
Left- hiftchhhrrd-peeuus
Ventricle
Left-VentraIDC
0.9885
0.999 0.9995
0.9885
0.999
0.9995
Sorensen Dice Scores
Figure 6: Minimum Sørensen- Dice score across instrumentation tools and different labelled brain regions.
For all use cases, we verified that no random processes present after fixing the random seeds by running multiple iterations of the ΙEEE implementations of each model. In FastSurfer, this yielded perfect minimum Serensen-Dice score (1.0, standard deviation 0), confirming determinism. For MNIST and WavLM, all metrics, including loss, retained 6.17 significant digits.
3.6 Model Embeddings Are Comparable
To verify that numerical perturbations propagate correctly through the model architectures, we analyzed the variability of internal feature maps (embeddings). Figure 7 illustrates one embedding from each use case: the output of the second decoder block for FastSurfer, the first convolutional layer for MNIST and the output of the ECAPA-TDNE transformer component of the WavLM model.
Numerical variability followed consistent, task-dependent patterns across all tools and rounding modes, although, for WavLM, we can visibly see the slightly higher numerical uncertainty with Fuzzy PyTorch's UD mode compared to the other modes.
While the numerical uncertainty within the MNIST and WavLM embeddings aligns with the observed stability of its outputs, FastSurfer presented a notable discrepancy: substantial uncertainty the background of its embeddings despite its stable outputs. Further investigation uncovered that this instability was confined to the background region outside the brain and originated from unstable indices being generated by the max-pooling operation across stochastic arithmetic iterations. Post-processing steps in FastSurfer effectively masked the background, thereby mitigating the impact of these instabilities on the final outputs for this specific use case. This finding directly motivated the development of Conservative & Aggressive NaNs, two approaches for leveraging numerical uncertainty into computational efficiency gains while preserving model performance PGouzalez-Pepe et al. 2026).
Overall, these findings demonstrate consistency between the global patterns observed in Fuzzy PyTorch and Verrou's i results, reinforcing the reliability of Fuzzy Pyroor in assessing variability throughout DL models.
10

---

Published in Transactions on Machine Learning Research (01/2026)
Fuzzy UD
Verrou CESTAC
Fuzzy SR
Verrou
FastSurfer
Fuzzy UD
Verrou CESTAC
Fuzzy SR
Verrou SR
MNIST
Fuzzy
Verrou CESTAC
Fuzzy
Verrou
WayLM
5
Significant Digits
Figure Model embeddings across stochastic arithmetic implementations
11

---

Published in Transactions on Machine Learning Research (01/2026)
4 Conclusion
Fuzzy PyTorch is a framework designed to evaluate numerical variability in DL models, addressing the challenges posed by floating-point arithmetic limitations. By leveraging vectorized CPU instructions via the Highway library, it minimizes computational overhead while maintaining flexibility. The framework supports two rounding modes, SR and UD, allowing researchers to balance precision and computational efficiency, making it versatile tool for enhancing model robustness and reproducibility. Across harmonic scries tests and deep learning lasks, SR consistently provides the most accurate and stable results, while UD drifts toward lower precision and CESTAC diverges due to bias. Fuzzy Py PyTorch reproduces these variability patterns and achieves accuracy comparable to state-of-the-at tools such as Verrou across MNIST classification, FastSurfer segmentation, and WavLM Parkinson's 's detection.
Fuzzy PyTorch crucially achicves substantial specdups, with minimal slowdowns for PRISM SR and especially PRISM UD in NAS parallel benchmarks. In deep learning tasks, it reaches up to 60x acceleration despite using less optimized CPU libraries (OpenBLAS and LAPACK versus Intel MKL). While PRISM UD is fastest in smaller benchmarks, its advantage decreases in DL. experiments, likely because it does not skip exact operations. Importantly, such speed is not only beneficial for small numerical tests but becomes essential in large-scale DL workloads, where evaluating numerical variability can otherwise be prohibitively slow. The ability to run multiple stochastic executions at scale is critical for feasible, timely numerical analysis. This efficiency gain enables the scalable, systematic evaluation of numerical variability in large DL models, capability unmatched by existing methods.
As numerical variability becomes increasingly recognized across the Al industry, the availability of system- level controls-such as AWS Neuron's bardware-supported rounding modes highllghtss the pressing need for software frameworks like Fuzzy PyTorch. These frameworks make it possible to perform fine-grained evaluations of numerical behavior across diverse architectures, from CPUs to accelerators, and ensure that both academic and industrial workflows benefit from deeper guarantees of computational robustness. By systematically analyzing variability, we can identify sources of instability that can be leveraged for practical improvements. For example, during our work with the FastSSurfer CNN, Fuzzy PyTorch revealed regions of numerical instability that subsequently exploited to implement Conservative & Aggressive NaNs, yielding significant computational efficiency gains (Gonzalez-Pepe et al., 2026). This illustrates how efficient variability analysis not only ensures reproducibility but also enables optimization and the development of novel techniques that improve performance in large-scale deep learning models.
While our current implementation is CPU-based, the main conclusions from CPU testing are expected to generalize GPU architectures. Future work, involves extending the framework to GPU architectures, although it poses significant technical challenges. The GPU tooling ecosystem is far more fragmented than its CPU counterpart, requiring specialized approaches for different vendor platforms. A successful GPU im- plementation would need to address multiple compilation targets and runtime environments. For NVIDIA GPUs, dynamic instrumentation frameworks like NVBit (Villa et al.) 2019) could enable analysis of closed- source libraries, but this approach is complex and platform-specific. Alternatively, compiler- based solutions using IREE (Liu et al., 2022) with specific compilation targets could offer broader hardware support, though this would require substantial development effort to integrate with existing PyTorch workflows. Nonethe- less, we expect to make the Fuzzy PyTorc framework applicable to GPU-based deep learning workloads once Verificarlo extends its support to GPU architectures. Future directions for Fuzzy PyTorch, beyond GPU support, include exploring the impact of numerical variability on diverse DL model architectures, opti- mizing SR mode performance, extending PRISM with additional floating-poit formats and specialized DL instructions.
In summary, Fuzzy PyTorch provides an efficient, reliable, and versatile tool for assessing numerical vari- ability in DL models. It empowers researchers to deepen their understanding of numerical behavior in DL models and enhances their ability to develop robust and reproducible systems.
12

---

Published in Transactions on Machine Learning Research (01/2026)
References
Edward Anderson, Zhaojun Bai, Christian Bischof, L Susan Blackford, James Demmel, Jack Dongarra, Jeremy Du Croz, Anne Greenbaum, Sven Hammarling, Alan McKenney, et al. LAPACK users' guide. SIAM, 1999.
El-Mehdi El Arar, Silviu-loan Filip, Theo Mary, and Elisa Riccietti. Mixed precision accumulation for neural network inference guided by componentwise forward error analysis. arXiv preprint urXiv:2508.1550: 2025.
AWS Neuron Team. Rounding modes, http::///wssooe--eeuuro htt.a//ww....aattooooooooooooooe /hmnra///rrcc//euuooorffaarrrrru
html n.d. Accessed: 2025-06-25.
Théo Beuzoville, Alfredo Buttari, Serge Gratton, and Theo Mary. Deterministic and probabilistic backward error analysis of neural networks floating-poit arithmetic. 2024.
Sylvie Boldo and Guillaume Melquiond. Floeq: A unified library for proving floating-point algorithms in coq. In 2011 IEEE 20th Symposium on Computer Arithmetic, pp.
TEEE, 2011.
Sylvie Boldo and Jean-Michel Muller. Exact and approximated error of the fmna. IEEE Transactions on Computers, 60(2)1157-164; 2010.
Brian M Bot, Christine Suver, Elias Chaibub Neto, Michael Kellen, Arno Klein, Christopher Bare, Megan Doerr, Abhishek Pratap, John Wilbanks, E Dorsey, et al. The mPower study, Parkinson disease mobile data collected using ResearchKit. Scientific data, 3(1):1-9, 2016.
Marie-Christine Brunet and Françoise Chatelin. CESTAC, a tool for a stochastic round-off error analysis in scientific computing. In Numerical Mathematics and Applications, pp. 11 20. Elsevier, 1986.
Yohan Chatclain, Eric Potit, Pablo de Oliveira Castro, Ghislain Lartigue, and David Defour. Automatic exploration of reduced Noating-point representations in iterative methods. In Euro-Par Par 2019: Parallel Processing: 25th International Conference Parallel and Distributed Computing, Götlingen, Germang, August 26 30, 2019, Proceedings 25, pp. 481 494. Springer, 2019.
Yohan Chatelain, Nigel Yong Sao Young, Gregory Kiar, and Tristan Glatard. Pytracer: Automatically profiling numerical instabilities in python. IEEE Transactions on Computers, 1796)117,, 2022.
Sanyuan Chen, Chengyi Wang, Zhengyang Chen, Yu Wu, Shujie Liu, Zhuo Chen, Jinyu Li, Naoyuki Kanda, Takuya Yoshioka, Xiong Xiao, et al. Wavlm: Large-scale self-supervised pre-training for full stack speech processing. IEEE Journal of Selected Topics in Signal Processing, 16(6):1505 1518, 2022.
ONNX Community. Onnx: Open neural network exchange, 2024. URL Accessed: 2024-12-21.
hwt.ggittuu..ooooooo cttpp/xx/ccooooo///////oaaaacctt conn//ona
Intel Corporation. oneDNN: Deep Learning Open Source Performance Library, 2024. URL https::///gtuuub. con/oneapi-src/onebiil Accessed: 2024-12-21.
Pablo de Oliveira Castro. High Performance Computing code optimizations: Tuning performance and accu- racy, PhD thesis, Université Paris-Saclay, 2022.
Decp-MI. Fastsurfer, 2024. URL https: htwpaaaaw.oooeeeeeea///aattreree Accessod: 2024-12-17.
David Defour, François Févotte, Stef Graillat, Fabienne Jézéquel, Wilfried Kirschenmann, Jean-Lau Lamotte, Bruno Lathuilière, Yves Lhuillier, Eric Petit, Julien Signoles, el al. InterFLOP, Interoperable Tools for Computing, Debugging, Validation and Optimization of Floating-Point Programs. In TSC-HPC 2021 DIGITAL, 2021.
Christophe Denis, Pablo de Oliveira Castro, and Eric Petit. Verificarlo: checking floating point accuracy through Monte Carlo Arithmetic. In 2016 IEEE 23nd Symposium on Computer Arithmetic (ARITH), 2016.
13

---

Published in Transactions on Machine Learning Research (01/2026)
Morgane Des Ligneris, Axel Bonnet, Yohan Chatelain, Tristan Glatard, Michaäl Sdika, Gael Vila, Valentine Wargnier-Dauchelle, Sorina Pop, and Carole Frindel. Reproducibility of tumor segmentation outcomes with a deep learning model. In 2023 IEEE 20th International Symposium on Biomedical Imaging (ISBI), pp. 1-5. IEEE, 2023.
Brecht Desplanques, Jenthe Thienpondt, and Kris Demuynck. Ecapa-tdnn: Emphasized channel attention, propagation and aggregation in tdnn based speaker verification. arXiv preprint orXiv:2005.071.3 2020.
El-Mehdi El Arar. Probabilistic enror analysis of limited-precision stochastic rounding. httpa://githus: com/ http:////..aaa.a.aa..aaaaaaaa/aa
pdf 2025, Accessed: June 25, 2025.
Julian Faraone and Philip Leong. Monte Carlo Deep Neural Network Arithmetic. 2019.
Massimiliano Fasi and Mantas Mikaitis. Algorithms for stochastically rounded clementary arithmetic oper- alions in ieee 754 floating-poin arithmetic. IEEE Transactions on Emerging Topics in Computing, 9():
1451-1466, 2021.
François Févotte and Bruno Lathuiliere. VERROU: CESTAC evaluation without recompilation. SCAN 2016, pp. 47, 2016.
George E. Forsythe. Reprint of note rounding-off errors. STAM revieu, 1(1):66, 1959.
Inés Conzalez-Pepe, Vimuyan Sivakolunthu, Hae Lang Park, Yohan Chatelain, and Tristan Glatard. Nu- merical Uncertainty of Convolutional Neural Networks Inference for Structural Brain MRI Analysis. In International Workshop on Uncertainty for Safe Utilization of Machine Learning in Medical Imaging, pp. 64 13- Springer, 2023.
Inés Gonzalez- Pepe, Vinuyan Sivakolunthu, Jacob Fortin, Yohan Chatelain, and Tristan Glatard. Conserva- tive Aggressive NaNs Accelerate U-Nets for Neuroimaging. arXio preprint or Xrx::266011111 17180, 2026.
Google. Highway, 2024a. URL https://gittiii attp:://gtthub.cc///oogg////aaa Accessed: 2024-12-17.
Google. Protocol buffers, 2024b. URL http::///ggttt...oooorooooobboap 12-21.
Accessed: 2024-
Google. Highway: Petformance-portable length-agnostic simd with runtime dispatch. https://github.
com/google/nighway 2025. GitHub repository, accessed December 17, 2025.
Leonie Henschel, Sailesh Conjeti, Santiago Estrada, Kersten Diers, Bruce Fischl, and Martin Reuter. Fastsurfer-a fast and accurate deep learning based neuroimaging pipeline. Neurolmage, 219:117012, 2020.
Timothy Hickey, Qun Ju, and Maarten H Van Emden. Interval arithmetic: From principles to implementa- tion. Journal of the ACM (JACM), 48(5):1038 1068, 2001.
Nicholas Higham and Theo Mary. A new approach to probabilistic rounding error analysis. STAM journal scientific computing, 41(5):A2815 A2835, 2019.
TEEE Computer Society. TEEE Standard for Floating- Soating-Point Arithmetic. https://teeexploree wee...eeeee... .rg/ document/4610935) aug 2008 IEEE Std 754-2008.
Fabienne Jézéquel and Joan-Maric Chesncaux. CADNA: a library for estimating round-off error propagation. Computer Physics Communications, 178(12):933 955, 2008.
Eliska Kloberdanz, Kyle G Kloberdanz, and Wei Lc. DeepStability: A Study of Unstable Numerical Methods and Their Solutions in Deep Learning. arXie preprint arXiv:2202.03: 03493, 2022.
Chris Lattner and Vikram Adve. LLVM: A compilation framework for lifelong program analysis & transfor- mation. In International symposium on code generalion and oplàmizalion, 2004. CGO 2004., pp. 75 86.
IEEE, 2004.
Yann LeCun. The MNIST database of handwritten digits. http:// lecun. com/erdb/ /mnist/ 1998.
14

---

Published in Transactions on Machine Learning Research (01/2026)
Hsin-I Cindy Liu, Marius Brehler, Mahesh Ravishankar, Nicolas Vasilache, Ben Vanik, and Stella Laurenzo. Iiny An ML execution environment for embedded systems from compilation to deployment. IEEE micro, 42(5):9 16, 2022.
Júnior Löff, Dalvan Griebler, Gabriele Mencagli, Gabriell Araujo, Massimo Torquati, Marco Danelutto, and Luiz Gustavo Fernandes. The NAS parallel benchmarks for evaluating C++ parallel programming frameworks on shared-memory architectures. Fulure Generalion Compuler Systems, 125:743-7888 2021.
David Malone. To what does the harmonic series converge? Irish Mathematical Society Bulletin, (71):59-66, 2013.
Jean-Michel Muller, Nicolas Brisebarre, Florent De Dinechin, Claude-Pierre Jeannerod, Vincent Lefevre, Guillaume Melquiond, Nathalie Revol, Damien Stehlé, Serge Torres, et al. Handbook of floating-por point arithmetic, volume 1. Springer, 2018.
Nicholas Nethercote and Julian Seward. Valgrind: a Framework for Heavyweight Dynamic Binary Instru- mentation. ACM Sigplan notices, 42(6):89 100, 2007.
Douglass Stott Parker. Monte Carlo arithmetic: exploiting randomness in flonting--ooot point arithmetic. Citescer, 1997.
Abbijit Guha Roy, Sailesh Conjeti, Nassir Navab, Christian Wachinger, Alzheimer's Disease Neuroimag- ing Initiative, et QuickNAT: A fully convolutional network for quick and accurate segmentation of neuroanatomy. Neurolmage, 186:713 727, 2019.
Devan Sohier, Pablo De Oliveira Castro, François Févotte, Bruno Lathuilière, Eric Petit, and Olivier Jamond. Confidence intervals for stochastic arithmetic. ACM Transactions on Mathematical Software (TOMS), 47 (2):1-33, 2021.
Alexey Solovyev, Marek S Baranowski, Ian Briggs, Charles Jacobsen, Zvonimir Rakamaric, and Ganesh Gopalakrishnan. Rigorous estimation of floating-point round-off errors with symbolic taylor expansions. " (TOPLAS), 41 (1):1 2018.
ACM Transactions on Programming Languages and Systems
Verificarlo. significantdigits, 2024. URL httppp///tttaaaoccc///eee/////ss
Ac-
cessed: 2024-12-17.
Mare Vicuna, Martin Khannouz, Gregory Kiar, Yohan Chatelain, and Tristan Glatard. Reducing numerical procision preserves classification accuracy in mondrian forests. In 2021 IEEE International Conference Big Dala (Big Dalu), pp. 2785 2790. IEEE, 2021.
Gaäl Vila, Emmanuel Medernach, Ines Gonzalez-Pepe, Axel Bonnet, Yohan Chatelain, Michaöl Sdika, Tris- tan Glatard, and Sorina Camarasu Pop. The impact of hardware variability on applications packaged with docker and guix: A case study in neuroimaging. In Proceedings of the 2nd ACM Conference Reproducibility and Replicabilily, pp. 75 84, 2024.
Oreste Villa, Mark Stephenson, David Nellans, and Stephen W Kookler. Nvbit: A dynamic binary in- strumentation framework for nvidia gpus. In Proceedings of the 52nd Annuual IEEE/ACM, International Symposium on Micraarchitecture, pp.
2019.
Xi-Nian Zuo, Jeffrey S Anderson, Pierre Bellec, Rasmus M Birn, Bharat Biswal, Janusch Blautzik, John Breitner, Randy I, Buckner, Vince D Calhoun, F Xavier Castellanos, et al. An Open Science Resource for Establishing Reliability and Reproducibility in Functional Connectomics. Scientific Data, 1(1):1 13, 2014.
15

---

Published in Transactions on Machine Learning Research (01/2026)
A Numerical Variability Estimation
Measuring numerical variability in DL models can involve family of techniques that introduce randomness into foating-poin computations. These methods rely on non-deterministic rounding. Unlike standard IEEE-754 rounding modes, this approach rounds to either of the two closest floating-point point numbers based on computed probabilities. The specific stochastic arithmetic technique is determined by how this probability is computed. We use the lerm Probabilistic Rounding (PR), introduced in (Higham & Mary 2019), as an umbrella term for this class of techniques. Moreover, because IEEE rounding is deterministic rather than probabilistie, we present it in its own subsection to emphasize this difference.
A.1 IEEE-754 Rounding
The IEEE-754 cound-to-neares mode, also known as round-to- to to-nnerest, ties-to-even, is the default rounding mode used in most floating-point hardware and software implementations. When a real number cannot be exactly represented in floating point, it is rounded to the closest representable number. If the number lies exactly halfway between two Hoating-point values, the tie is broken by rounding to the one with even least significant bit (i.e., the one whose mantissa ends in 0).
Formally, the rounding function (T) maps x E R to the nearest floating-poit point number / f F such that:
Onx (x) arg min JEF
| -
with ties resolved to the floating-pois number f such that the significand f is even. This method minimizes rounding bias over repeated operations and is the most widely adopted deterministic rounding strategy defined by the IEEE-754 standard (IEEE Computer Society 2008), which specifies several modes including nouueeto-nearest (lie-lo-even tie-lo-odd), rounding Loward t:o,, and rounding Loward zero.
A.2 Probabilistic Rounding
Let F be the set of normalized binary floating point numbers with elements æ = (-1)).mm. .m.2", where E (0, is the sign bit, 2--1 the rounding functions [x] R + F and [x] R + F be such that [x] max Fly S x} and [x] = min(y E F 2 x}, which return the previous and next representable floating point numbers to Probabilistic Rounding can be defined as:
2" is the significand, E Z is the exponent and p is the precision. Let
[x]
with probability Po
(2,
(2)
[x] with probability 1 1- Po
where p. R + [0, 1].
The existing stochastic arithmetic techniques can then be reinterpreted with the PR definition.
A.2.1 CESTAC Rounding
The Contrôle Estimation STochastique des Arrondis de Calculs (CESTAC) technique simulates the round- off error floating-point arithmetic by rounding upward or downward the result of each floating-poin operation with equal probabilities.
with probability
CESTAC (x)
(3)
with probability
CESTAC is implemented in the CADNA library Jézéquel & Chesneaux 2008
16

---

Published in Transactions on Machine Learning Research (01/2026)
A.2.2 Stochastic Rounding
(SR) technique rounds the result of each floating-poin with a probability that depends on the distance bet ween the exact value and the two closest represenlable floating- point numbers. The probability computed as:
The Stochastic Rounding (Forsythe 1959
[x]
with probability Pun
Onn (a:)
(4)
xx]
with probability - PsR
where (2) is defined as:
Psa (2)
SR implementations include, but are not limited to, the Random Rounding (RR) mode of MCA in Verificarlo, the implementation of Fasi and Mikaitis and the average rounding mode of Verrou.
B NAS Parallel Benchmarks description
Benchmark bt Block Triangular Solver
Description
cg
Conjugate Gradient
op
Embarrassingly Parallel
ft
Fast Fourier Transform
lu
Lower-Upper Symmetric Gauss-Seidel
mg
Multi- Solver
sp Scalar Pentadiagonal Solver
Table 1: NAS Parallel Benchmarks description
C Deep Learning Use Cases
We evaluated the accuracy and performance of Fuzzy PyTTrch across three deep-learning models demonstrat- ing real-world applicability -MNIST (handwritten digit classification), WavLM (applied to speech-based Parkinson's is disease identification), and Fast.Surfer (brain segmentation using CNN).
MNIST To evaluate the performance and behavior of Fuzzy PyTorch, conducted experiments
small CNN trained the MNIST dataset (LeCun 1998). The model architecture consisted of convolutional. ReLU, max-pooling, convolutional, ReLU, dropout, flatten, lincar, ReLU, dropout, and lincar layers, followed by a log-sofumax output layer. The lask, a classification problem to identify digits from the inpul images, is well-established and widely considered solved. This experiment served as baseline to demonstrate the feasibility and potential benefits of Fuzzy PyTorch in a controlled, well-understood context. order to quantify the numerical variability in MNIST, we use the significant bit metric (Parker 1997] Sohier et al., 2021), which calculates the amount of shared information among the perturbed results; the more significant bits, the greater the precision. We estimate the number of significant bits using the non-parametric method described in (Sohier et al. 2021 which is implemented in the ceciificatt_diiiii package (Verificarlo, 2024
WavLM The model for Parkinson's identification from speech is a pipeline composed of the WavLM Large (Chen et al. 2022) model in a frozen configuration to extract features from the audio recordings that are fed to the Emphasized Channel Attention, Propagation, and Aggregation Time Delay Neural Network ESCAPA-TDNNY (Desplanques et al.] 2020) and linear layer classifier followed by max operation obtain binary classification to determine whether subject has Parkinson's disease healthy control
17

---

Published in Transactions on Machine Learning Research (01/2026)
subject. The model trained the mPower speech dataset (Bot et al. 2016). We will refer to this pipeline as WavLM in this work. For this use case, we also use significant bits to quantify the model's numerical variability.
CDB
Long-Range
CDB
MaxPool Indices
UnPool Indices
CDB
CDB
CDB
CDB
CDB
CDB
CDB
Batch Norm
Softmax
Figure 8: Illustration FastSurfer's architecture. The CNN consists four competitive dense blocks (CDB) in the encoder and decoder part, separated by a bottleneck layer. Figure reproduced from (Henschel et. al. 2020).
FastSurfer FastSurfer (Henschel al. 2020 is a CNN model that performs whole-brain segmentation, cortical surface reconstruction, fast spherical mapping, and cortical thickness analysis from anatomical MRI. The FastSurfer CNN is inspired by the QuickNAT model (Roy et al., 2019), which is composed of three 2D fully convolutional neural networks each associated with dilferent 2D slice orientation -tat each have the same as QuickNAT. A diagram of the model's architecture is available in the Appendix Figure S We focus exclu- sively on the task whole-brain segmentation, defined as voxel-wise anatomical labeling of brain regions. This segmentation step is entirely performed by the CNN, without surface reconstruction, and uses the pro-trained FastSurfer model (v2.1.0) available on GitHub (Deep-MI 2024). FastSurfer has demonstratod unseen datasets, and high lest-retest reliability. This model serves ideal benchmark for studying numerical variability in high--dimensionl medical imaging tasks due to its scientific relevance and architectural complexity. In our experiments, we applicd FastSurfer to segment five subjects from the CoRR dataset (Zuo et al.) 2014). By comparing Fuzzy PyTorch and Verrou instru- mentation on Fast.Surfer inference, we aim to partially replicate previous findings on numerical uncertainty in FastSurfer (Gonzalez-Pere et al. 2023), thereby validating the accuracy, reliability, and applicability of Fuzzy PyTorch to realistic largo-scale segmentation tasks. For FastSurfer, we cannot compute significant bits its segmentations Sørensen-Dice Dice score across pairs of stochastic arithmetic runs. The Sorensen-Dice score measures the overlap between two segmentation results and is commonly used to quantify similarity between labeled regions in medical imaging. Further details on the Sørensen- Corensen-Dice score are provided in Appendix D
U-net architecture with skip connections, unpooling layers and dense connections
high accuracy, strong gemeralization
composed of categorical integer labels. Therefore, we compute the minimum
D Sørensen-Dice Scores
The neuroimaging use casc, the FastSurfer convolutional neural network (CNN), produces brain segmenta- tions from anatomical Magnetic Resonance Images (MRI), which label different brain regions. In order evaluate brain segmentations, cannot. the significant. bits metric. Segmentation tools like Fast
18

---

Published in Transactions on Machine Learning Research (01/2026)
generate categorical variables encoded integers to represent segmentation labels, even though they rely floating-point operations. Therefore, the significant bits metric cannot be applied as it is only useful for programs that produce floating-point outputs.
To assess the impact of numerical perturbations on segmentation stability, we compute the minimum Sørensen-Dice score across pairs of stochastic arithmetic runs. The Sprensen-Dice score measures the over- lap between two segmentation results and is commonly used to quantify similarity between labeled regions in medical imaging. For each subject, run FastSurfer multiple times with SA-enabled perturbations, producing N different segmentations. Each segmentation output assigns class label to every vaxel in the brain MRI. Let S; and Sj represent the set of voxels assigned to specific brain region in the i-th and j-th stochastic arithmetic iterations, respectively. The Sørensen-Dice score between these two segmentations is given by:
2 (2:1))) |S + [S
min Sorensen-Dice Score
min (J.(......
ifj
where [S, the number overlapping voxels classified as part of the same region both segmentations, and [S|] and [Sy] are the total number of voxels assigned to that region in each iteration.
E Statistical Analysis of Harmonic Series Variance Homogeneity
Descriptive Statistics by Method
Method
Mean Std. Dev.
95% CI
F-statistic vs. PRISM SR
p-value
PRISM SR.
1.65
10-1
1.08,
10-1
MCA RR
2.41 10-4
3.437,3.45 10-4
F 1.58
p 0.210
Verrou SR
1.48 10 10-4
[1.00, 1.96
10-4
F 0.21
p 0.651
FM SR
2.10 10-1
1.27, x 10-1
F = 0.78
p 0.380
Table 2: Statistical analysis of variance homogeneity across stochastic rounding methods in harmonic series computation. Levene's test confirms homogeneity of variances across stochastic rounding implementations (F 1.26, = 0.29), supporting the validity of comparative analyses. All pairwise F-tests compare against PRISM SR as the reference method. Tests performed at a 0.05 significance level.
19


Reviews:
[{"review_id": "vVIs8UhGEg", "reviewer": "Reviewer_xFR1", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "No", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The paper introduces the framework “Fuzzy Pytorch” for the evaluation of numerical variability in DL models. As DL models rely on computations sensitive to floating-point precision, assessing numerical variability is essential to ensure confidence in empirical results. The authors employ Stochastic Arithmetic to introduce controlled random perturbations into floating-point operations. This way, they enable statistical estimation of numerical variability. The proposed approach is practical as it requires no model modifications.\n\nTo this end, the authors introduce the PRISM library, which provides two rounding mechanisms: 1) stochastic rounding based on proximity to the representable floating-point number, and 2) up-down rounding. The benefits of PRISM include its easy applicability to existing PyTorch models and parallel execution capabilities, which enhance scalability. PRISM is evaluated across diverse use cases, including simple digit classification, segmentation, and speech classification.", "claims_and_evidence_yn": "No", "claims_explanation": "- **Criticism of motivation and necessity:** My biggest concern with the paper is the problematic  motivation for the proposed framework. It is not sufficiently clear to me why a faster evaluation of numerical variability in DL models is necessary, especially given existing frameworks. The shortcomings that Fuzzy-PyTorch is supposed to fix are unclear to me. \nThe authors’ motivation is primarily based on the increased evaluation speed. Yet, if evaluation is performed only once, why is speed so critical? Are other frameworks considered infeasible in certain contexts? As long as this remains resolved and the subsequent results lack the necessary basis for relevance.\n- **Unclear rationale/necessity of up-down (UD) rounding:** Another important point is the introduction of UD rounding. There is really no real justification for why this specific type of rounding is necessary.  What are the specific problems it solves in existing approaches? It remains unclear whether UD rounding was introduced solely to reduce computation time. Assuming the main argument is speed, this is inconsistent with experiments, as UD rounding does not offer speed-ups in transformer architectures. On the other hand, there is no complexity analysis that would prove a general speed advantage. Without a clear explanation of the rationale, the introduction of this technique does not appear justified.\n- **Lack of Recommendations:** The next point relates to the use of the Sørensen-Dice score. Although this is justified for the segmentation problem presented, the authors do not provide any recommendations for other use cases and tasks. I believe a framework should be modular in design and go beyond a specific use case. There is a lack of recommendations on how users can transfer the tool to new use cases.\n- **Minor Problems:** The paper has shortcomings in terms of readability and structure. In particular, the introduction lacks a clear line of argumentation. This structural weakness directly contributes to the fact that the motivation behind the framework, which was criticized in my first point, remains unclear. Additionally, there are some issues with acronyms. In some cases, abbreviations are introduced without being used or defined multiple times.", "audience_yn": "Yes", "audience_explanation": "I believe that the problem of numerical variability is an interesting and important topic for the DL community.", "requested_changes": "Given the criticism in the section “Claims and evidence,” could you comment on each of the points mentioned? Ideally, the issues raised there should be taken into account in a revision.", "broader_impact_concerns": "N/A", "additional_comments": "There may be a problem with anonymity, as the GitHub link in the manuscript clearly reveals the lab that implemented the library. I would like to bring this issue to the attention of the AE.", "extra_scores": {}, "extra_text": {}}, {"review_id": "pyPPRhURE7", "reviewer": "Reviewer_58Bm", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "No", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This paper presents Fuzzy PyTorch, a new package for assessing floating-point precision in PyTorch. The package integrates with PyTorch and can be used easily without modifying the original codebase. Numerical experiments on various benchmark datasets demonstrate that the package delivers significant speedups compared to existing packages.", "claims_and_evidence_yn": "No", "claims_explanation": "**Weaknesses**\n\nAlthough the package itself can be a valuable contribution, I find the paper not sufficiently well written. I also have some concerns regarding the application of the package in the deep learning context.\n\n1. Organization of the results and repetitive contents\n\n   The organization of the contents sometimes looks redundant and confusing. For example,\n\n   - The paragraphs before the contribution section jump back and forth between the features of Fuzzy PyTorch and the existing packages.\n\n   - **Section 2.1** simply enumerates the existing rounding approaches. Since the package only implements two of them, I think they can be placed in the appendix.\n\n     Similarly, **Section 4.1** enumerates some existing packages and **Section 4.2** enumerates the descriptions of the benchmark problems. The details can also be put in the appendix.\n\n   - It seems **Section 2.3** should be part of the experiment setup.\n\n   There are also a number of typos/inconsistencies throughout the paper (see **Minor issues**).\n\n2. Compatibility issues when reproducing the experiments\n\n   When I try to reproduce the experiments in the paper, I notice several compatibility issues (see **reproducibility issues** below. Moreover, the project's GitHub does not contain sufficient troubleshooting details.\n\n3. Missing documentation\n\n   The project's GitHub repo only tells how to reproduce the experiment. It does not provide documentation or examples for using the package.\n\n4. Missing support for GPU floating-point assessment\n\n   Currently, the package is written to run on a CPU. Although the authors mention that \"the main conclusions from CPU testing are expected to generalize to GPU architectures,\" most deep learning training tasks are actually done on GPU. Therefore, I believe having GPU support is necessary for the package to be truly useful to the community. I understand that it is unlikely to add GPU support in the near term, but this should be an important future step for this project.\n\nOverall, I believe that the package has the potential to become a useful tool for deep learning. However, the paper is not well written, and the package still has some compatibility issues. Please carefully address the first three weaknesses in the revision.\n\n**Questions**\n\n1. Could you please add troubleshooting instructions and documentations to your github repository?\n2. How much extra work do you think is required for adding GPU support?\n3. In **Section 3.3**, multiple PyTorch and Python versions are mentioned. Which versions does your package actually support?\n\n**Minor issues**\n\nPlease carefully proofread the paper and fix typos/inconsistencies.\n\n1. Page 1\n\n   up-down and Up-Down rounding are used inconsistently.\n\n2. Page 1\n\n   Why are some references (Anonymized)?\n\n3. Page 2\n\n   \"SR preserves exact values\" is unclear.\n\n4. Page 2\n\n   In the contributions, FastSUfer and WavLM should have corresponding references when they first appear.\n\n5. Page 3\n\n   The introductory paragraph for the first component is too long.\n\n6. Page 3\n\n   $p$ the precision => $p$ is the precision.\n\n7. Page 3\n\n   $\\mathbb{R} \\rightarrow [0, 1]$ misses \".\"\n\n8. Page 3\n\n   $\\mathbb{F}$ => $\\mathcal{F}$\n\n9. Page 3\n\n   \"is the most widely adopted deterministic rounding strategy defined by the IEEE-754 standard\" seems unclear. Does IEEE-754 define multiple rounding strategies?\n\n10. Page 3\n\n    CESTAC means \"Controle et Estimation STochastique des Arrondis de Calculs\"\n\n11. Page 4\n\n    You might use UD directly after it's defined.\n\n12. Page 4\n\n    \"the result of each floating-point operation rounded with...\" is unclear.\n\n13. Page 6\n\n    \"input regions such as zero\" is unclear.\n\n14. Page 8\n\n    class \"S\" is not defined.\n\n**Reproducibility issues**\n\nI encountered the following issues when running the experiments on a Mac mini with an Apple M1 chip and macOS 15.7.2 (24G325). It seems that the package assumes a linux environment has some compatibility issues on arm64 architecture. I would suggest the authors explicitly mention the supported platform/architecture\n\n1. When I run `./build.sh` directly, I get the following error\n\n```\n30.33 Need to get 0 B/5991 kB of archives.\n30.33 After this operation, 0 B of additional disk space will be used.\n30.33 Get:1 /bazelisk-amd64.deb bazelisk amd64 1.26.0 [5991 kB]\n30.39 debconf: delaying package configuration, since apt-utils is not installed\n30.41 dpkg: error processing archive /bazelisk-amd64.deb (--unpack):\n30.41  package architecture (amd64) does not match system (arm64)\n30.41 Errors were encountered while processing:\n30.41  /bazelisk-amd64.deb\n30.42 E: Sub-process /usr/bin/dpkg returned an error code (1)\n------\nDockerfile-tools:3\n--------------------\n   2 |     \n   3 | >>> RUN apt-get update && \\\n   4 | >>>   apt-get install -y --no-install-recommends build-essential git wget curl bc \\\n   5 | >>>   automake libtool parallel \\\n   6 | >>>   clang-15 libclang-15-dev llvm-15 llvm-15-dev llvm-15-tools \\\n   7 | >>>   libomp-15-dev libomp5-15 \\\n   8 | >>>   libgmp-dev libgmpxx4ldbl libmpfr-dev libmpfr6 \\\n   9 | >>>   python3-pip && \\\n  10 | >>>   wget --no-check-certificate https://github.com/bazelbuild/bazelisk/releases/download/v1.26.0/bazelisk-amd64.deb && \\\n  11 | >>>   apt install -y  ./bazelisk-amd64.deb && \\\n  12 | >>>   apt-get clean && \\\n  13 | >>>   rm -rf /var/lib/apt/lists/*\n  14 |     \n--------------------\nERROR: failed to build: failed to solve: process \"/bin/sh -c apt-get update &&   apt-get install -y --no-install-recommends build-essential git wget curl bc   automake libtool parallel   clang-15 libclang-15-dev llvm-15 llvm-15-dev llvm-15-tools   libomp-15-dev libomp5-15   libgmp-dev libgmpxx4ldbl libmpfr-dev libmpfr6   python3-pip &&   wget --no-check-certificate https://github.com/bazelbuild/bazelisk/releases/download/v1.26.0/bazelisk-amd64.deb &&   apt install -y  ./bazelisk-amd64.deb &&   apt-get clean &&   rm -rf /var/lib/apt/lists/*\" did not complete successfully: exit code: 100\n```\n\nThe `install.sh` script also seems to have some compatibility issues\n\n```\n22.05 error: unknown FP unit 'sse'\n22.06 make: *** [Makefile:38: stochrndhp.o] Error 1\n22.06 make: Leaving directory '/build/tools/stochastic-rounding-evaluation/performance'\n------\nDockerfile-tools:30\n--------------------\n  29 |     \n  30 | >>> RUN chmod +x /build/tools/install.sh && \\\n  31 | >>>   cd /build/tools && \\\n  32 | >>>   /build/tools/install.sh\n--------------------\n\n```", "audience_yn": "Yes", "audience_explanation": "The software implementation is likely a good contribution to the community.", "requested_changes": "See weaknesses and minor issues.", "broader_impact_concerns": "N.A.", "additional_comments": "N.A.", "extra_scores": {}, "extra_text": {}}, {"review_id": "UvmNKjM05D", "reviewer": "Reviewer_gaX7", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "In this article, the authors introduce Fuzzy PyTorch, a framework enabling large-scale, efficient stochastic arithmetic (SA) instrumentation for deep-learning models through PyTorch. The work provides a full-stack system for perturbing floating-point operations in PyTorch, enabling fast evaluation of numerical variability. Experiments on the harmonic series, NAS Parallel Benchmarks, MNIST, WavLM, and FastSurfer illustrate the performance gains obtained by the new framework.", "claims_and_evidence_yn": "Yes", "claims_explanation": "The paper identifies an increasingly critical issue, namely numerical variability in deep learning, which is receiving recently renewed attention due to mixed-precision hardware, accelerators (AWS Trainium, AMD MI300, NVIDIA Blackwell), and scientific use cases. The motivation is solid, and the authors correctly position their work within this broader context.\nThe PRISM library is convincingly presented as a performance-oriented alternative to existing SA runtimes.", "audience_yn": "Yes", "audience_explanation": "The topic of this article is clearly in the scope of the journal.", "requested_changes": "Here are my comments and requested changes : \n- Add an outline of the article at the end of the introduction. It should briefly summarize the structure (Sections 2–6 + Appendix).\n- Add a short introductory paragraph at the beginning of Section 2, similar to the introduction you already provide at the start of Section 3.\n- The introduction of the new term probabilistic rounding is unclear. Could you please justify why this new term is necessary rather than using the established term stochastic arithmetic (SA). Alternatively, consider removing “probabilistic rounding” and using SA consistently, unless a strong motivation is provided.\n- IEEE-754 rounding (2.1.1) is not a probabilistic rounding method. It could be better to move it before Section 2.1, or introduce a short transitional subsection distinguishing deterministic and probabilistic rounding.\n- My main concern is about the Up-Down Rounding. Indeed, I don't really understand the interest of this method compared to IEEE-754. Could you please extend this point ? Can it be seen as a stochastic version of IEEE-754 in order to add variability and robustness ? Could you also developp the definition of $\\epsilon$ please ?\n- Clarify in Section 3.1 that PRISM currently supports SR and UD only, and explicitly state whether support for CESTAC is planned or out of scope.\n- Several figures, especially Figure 2, are difficult to interpret. Please revise them with more distinct shapes/colors, possibly larger markers or thicker lines and more detailed commentary in the text (particularly for Figure 2).", "broader_impact_concerns": "None", "additional_comments": "None", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Decision: Accept (poster)