Pith. sign in

REVIEW 3 major objections 5 minor 36 references

InTreeger: An End-to-End Framework for Integer-Only Decision Tree Inference

T0 review · 3 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read InTreeger converts random-forest inference to pure integer arithmetic, claiming no accuracy loss and faster execution on ARM, x86, and RISC-V.

desk verdict Useful integer-only tree inference framework with a genuinely new leaf-probability conversion, but the 'no accuracy loss' claim overreaches and single-tree models hit an overflow bug. read the letter →

arxiv 2505.15391 v1 pith:NEIO3OTB submitted 2025-05-21 cs.LG

Duncan Bart , Bruno Endres Forlin , Ana-Lucia Varbanescu , Marco Ottavi , Kuan-Hsun Chen This is my paper · ORCID
classification cs.LG
keywords integer-onlyinferencedecisiontreesrandomforestsfixed-pointarithmeticedgecomputingcodegenerationembeddedsystemsquantization
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

InTreeger claims that a random-forest model can be converted into a C program that uses only integer arithmetic, with no change to its predictions. The conversion replaces split thresholds with their floating-point bit patterns and scales leaf class probabilities by the ensemble size, turning every operation into integer loads, adds, and comparisons. This matters for embedded and edge hardware, where floating-point units are expensive or absent: the generated code runs on any processor that supports freestanding C. The paper reports speedups of up to 2.1x across ARMv7, RISC-V, and x86, and about 21% energy savings in a real board measurement, while matched predictions on two datasets.

What carries the argument

The load-bearing object is a fixed-point encoding of class probabilities with scaling factor $2^{32}$/n, where n is the number of trees. At compile time every leaf probability p becomes floor(p * $2^{32}$ / n), so summing across trees yields the ensemble average scaled by $2^{32}$; no division happens at runtime. Split thresholds are handled by reinterpreting their IEEE-754 bit patterns as integers, so every inference operation is an integer load, add, compare, or store, which is what produces the speed and portability gains.

What would settle it

Run the same comparison on a model with more than 256 trees, where single-precision float is more accurate than the fixed-point encoding, or on a dataset with near-tied class scores; if any sample's predicted class flips between the floating-point and integer-only implementations, the claim fails.

Watch

Extended reading notes

Core claim

The central discovery is that all floating-point arithmetic in decision-tree inference can be removed without sacrificing accuracy. Thresholds are handled by reinterpreting IEEE-754 float bits as integers, and leaf probabilities are multiplied by $2^{32}$/n and truncated to 32-bit unsigned integers during code generation, so the ensemble sum stays within range. The resulting error is at most n/$2^{32}$, below single-precision float resolution for ensembles up to 256 trees, and the paper argues this never changes the predicted class in realistic settings.

Load-bearing premise

The whole accuracy guarantee rests on the assumption that the rounding error accumulated over the ensemble, at most n/$2^{32}$, is always smaller than the difference between the highest and second-highest class probabilities.

Editorial extensions

If this is right

  • Tree-based models can be deployed on microcontrollers without FPUs, since the generated code uses only integer operations and standard C.
  • The speedup grows with the number of classes, because each leaf adds one probability per class and integer adds are cheaper than float adds.
  • The end-to-end pipeline lets non-experts generate optimized models from a dataset without library setup or architecture-specific tuning.
  • On the measured ARMv7 board, completing the same 14.5M-inference workload took 7.79 seconds instead of 19.36 seconds, saving about 21% energy even with a noisy baseline.
  • The accuracy-preservation argument is bounded: the error is at most n/2^32, so ensemble sizes beyond 256 trees are where floating point becomes more precise.

Reading between the lines

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

  • The n/2^32 bound could be turned into a formal per-model guarantee by checking that the error never exceeds the margin between top-two class scores; the paper validates this empirically only on two datasets up to 100 trees.
  • The same fixed-point leaf encoding should extend to gradient-boosted trees and scalar-output regression forests, since the framework claims support for all tree-based models but only random forests are evaluated.
  • On cores with vectorized floating-point units the advantage may narrow; the clearest wins are on FPU-less or scalar pipelines where integer adds avoid separate register files and FPU latency.
  • The measured 21% energy saving is diluted by a noisy idle baseline; on a dedicated low-power platform the saving should approach the runtime ratio, and removing the FPU entirely could add further gains.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 5 minor

Summary. InTreeger is an end-to-end framework that trains a tree ensemble (or accepts a trained model) and compiles it into an integer-only C if-else tree. Threshold comparisons are handled by FlInt's bit-reinterpretation trick, and leaf class probabilities are converted to uint32 fixed-point values scaled by 2^32/n, where n is the number of trees, to avoid overflow when accumulating votes from the forest. The paper evaluates generated code on ARMv7, RISC-V, and x86 for the Shuttle and ESA datasets with up to 100 trees, reporting inference latency improvements up to 2.1x and a 21.3% energy reduction on a Raspberry Pi setup, and presents a FE310 microcontroller use case. The central claim is that this integer-only conversion preserves classification accuracy without loss of precision.

Significance. If the accuracy-preservation guarantee held, InTreeger would be a useful, low-friction deployment tool for tree models on FPU-less microcontrollers; the end-to-end pipeline, the parameter-free derivation of the scaling factor from overflow avoidance and a precision target rather than from fitted data, and the evaluation across three ISAs with energy measurements are all strengths. The method is simple and the engineering results are promising. However, the paper's headline guarantee is currently stronger than its evidence: the fixed-point conversion is not proven to preserve the argmax for all inputs, and the n=1 case can overflow. With a corrected and qualified accuracy claim, the contribution would be a solid and practically relevant systems result.

major comments (3)
  1. [Section III-A] The scaling formula 2^32/n has an unhandled overflow case for n=1. A pure leaf with p=1.0 converts to floor(2^32)=2^32, which does not fit in a uint32 and wraps to 0 in C, so the majority class receives zero weight in the accumulated result. Since Section II-A states that the framework supports all existing tree-based classification models, a single decision tree or a forest with one tree is in scope, and this is a concrete counterexample to the claimed 'without loss of precision' behavior. The paper's edge-case discussion covers precision loss for n>256 and for small probabilities, but not this n=1 overflow. Please add explicit handling for n=1 or restrict the claim to ensembles with at least two trees.
  2. [Section III-A and Section IV-B] The analysis bounds the absolute error in each accumulated class score by n/2^32, but classification is decided by the argmax of those scores. No lower bound on the margin between the top two classes is provided, so the error bound alone does not establish that the argmax is preserved; for n=100 the bound is about 2.3e-8, and an input whose top-two average probabilities differ by less than that can be flipped in the worst case. Section IV-B's evaluation on two datasets, 10 splits, and up to 100 trees is useful evidence but does not justify the statement 'This transformation will not impact the accuracy performance of the RF model in any realistic scenario.' Please supply a margin-aware argument, add a broader empirical search that includes small-margin inputs, or soften the claim to a property demonstrated for the tested configurations.
  3. [Section IV-A] The statement 'Therefore, we deem the obtained results to be generalizable to other datasets' is not supported by evaluating only two datasets. The accuracy-preservation question depends on worst-case rounding relative to classification margins, which is a function of leaf purity, tree depth, and class distribution, not merely dataset size, number of features, and number of classes. Please present this as a limitation or add datasets that stress small-margin predictions before claiming generalization.
minor comments (5)
  1. [Abstract and Section III-A] The text uses 'without loss of precision' and 'without loss of accuracy' interchangeably, while also conceding that the fixed-point representation is less precise than IEEE 754 for probabilities below about 0.001 and for forests with more than 256 trees. Please qualify the abstract's phrasing, for example to 'without loss of classification accuracy in the evaluated settings.'
  2. [Section II-A] The paper claims support for all existing tree-based classification models, but the evaluation covers only Random Forests. Either provide an example with gradient-boosted or extra-trees models, or state that other models are supported by the code path but not benchmarked in this work.
  3. [Figure 2] The y-axis appears to be logarithmic but is not labeled as such; please add an explicit 'log scale' label or state it in the caption.
  4. [Section IV-F] The energy measurement reports a single 14.5-million-inference run for each implementation; please report the number of repetitions and the standard deviation of the power measurements so the reader can assess the 21.3% energy-saving figure.
  5. [Artifact availability] The anonymous repository is mentioned only as a URL; for reproducibility, please include a fixed commit hash, a license, and a brief README with the exact commands needed to regenerate the C code and reproduce the reported measurements.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the integer conversion is parameter-free and the only self-citation (FlInt) is independent published support.

full rationale

The paper's central derivation in Section III-A converts leaf probabilities to fixed-point integers with a scaling factor 2^32/n, derived from overflow avoidance and a stated precision target; no parameter is fitted to the experimental accuracy data. The claim of no accuracy loss is an empirical claim tested on the Shuttle and ESA datasets against the floating-point implementation, not a prediction forced by construction. The threshold conversion reuses FlInt [26], a published DATE paper with its own x86/ARMv8 benchmarks, and the paper independently demonstrates it on RISC-V and ARMv7; this self-citation is independent evidence rather than a load-bearing circular argument. The main weakness is that Section III-A bounds the absolute accumulated error by n/2^32 but does not bound the margin between the top two classes, so the statement 'This transformation will not impact the accuracy performance of the RF model in any realistic scenario' is not formally established; that is a correctness/evidence gap, not a circularity. No step reduces to its own inputs by definition.

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

The conversion has no fitted parameters: the scaling factor is derived. The only postulates are standard properties of random forests, IEEE 754 arithmetic, and a prior empirical claim about tree-count saturation. The overflow edge case for n=1 is an unhandled assumption, noted in the ledger.

assumptions (4)
  • domain assumption Leaf probabilities lie in [0,1] and, after scaling by 2^32/n, fit into a 32-bit unsigned integer.
    Section III-A uses this to define the probability conversion; the assumption fails for a single tree with a pure leaf (p=1.0), where the scaled value overflows 2^32. No guard or 64-bit fallback is described.
  • standard math Training frameworks emit IEEE 754 single-precision floats for leaf probabilities.
    Section III-A compares the 24-bit mantissa of single precision to the 2^32 fixed-point grid.
  • domain assumption Random forest prediction is the unweighted average of per-tree class probabilities.
    Section II-A and Section III-A divide each scaled probability by n at code-generation time so the sum over n trees approximates the average without overflow.
  • domain assumption Forests larger than 256 trees are not a realistic scenario, so the precision loss from n/2^32 exceeding float precision is immaterial.
    Section III-A invokes ref [32] (no accuracy gain beyond 128 trees) to dismiss the n>256 edge case; this is a prior empirical claim, not a theorem.

how reviews work

0 comments
Cite this review

Pith. "Pith review of InTreeger: An End-to-End Framework for Integer-Only Decision Tree Inference." pith.science (2026). https://pith.science/paper/NEIO3OTB

@misc{pith2026250515391,
  author       = {Pith},
  title        = {Pith review of: InTreeger: An End-to-End Framework for Integer-Only Decision Tree Inference},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/NEIO3OTB}},
  note         = {Machine review of arXiv:2505.15391}
}
read the original abstract

Integer quantization has emerged as a critical technique to facilitate deployment on resource-constrained devices. Although they do reduce the complexity of the learning models, their inference performance is often prone to quantization-induced errors. To this end, we introduce InTreeger: an end-to-end framework that takes a training dataset as input, and outputs an architecture-agnostic integer-only C implementation of tree-based machine learning model, without loss of precision. This framework enables anyone, even those without prior experience in machine learning, to generate a highly optimized integer-only classification model that can run on any hardware simply by providing an input dataset and target variable. We evaluated our generated implementations across three different architectures (ARM, x86, and RISC-V), resulting in significant improvements in inference latency. In addition, we show the energy efficiency compared to typical decision tree implementations that rely on floating-point arithmetic. The results underscore the advantages of integer-only inference, making it particularly suitable for energy- and area-constrained devices such as embedded systems and edge computing platforms, while also enabling the execution of decision trees on existing ultra-low power devices.

Figures

Figures reproduced from arXiv: 2505.15391 by the authors.

Figure 1
Figure 1. The overview of InTreeger. From input dataset to [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. The differences between the observed probabilities for [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. The results show that the standard floating-point [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (3 more)
Figure 3
Figure 3. Figure 3: Performance evaluation (elapsed cycles) of the inference for the two datasets over the selected architectures and [PITH_FULL_IMAGE:figures/full_fig_p006_3.png]
Figure 4
Figure 4. Figure 4: A schematic overview of the setup that was used for [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]
Figure 5
Figure 5. Figure 5: The power consumption profile of a floating-point [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

36 extracted references · 33 canonical work pages

  1. [1]

    Tabular data: Deep learning is not all you need,

    R. Shwartz-Ziv and A. Armon, “Tabular data: Deep learning is not all you need,” Information Fusion , vol. 81, pp. 84–90, 2022

    work page 2022

  2. [2]

    Catboost: unbiased boosting with categorical features,

    L. Prokhorenkova, G. Gusev, A. V orobev, A. V . Dorogush, and A. Gulin, “Catboost: unbiased boosting with categorical features,” in Advances in Neural Information Processing Systems , S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett, Eds., vol. 31, 2018

    work page 2018

  3. [3]

    Tree-based machine learning performed in- memory with memristive analog cam,

    G. Pedretti, C. E. Graves, S. Serebryakov, R. Mao, X. Sheng, M. Foltin, C. Li, and J. P. Strachan, “Tree-based machine learning performed in- memory with memristive analog cam,” Nature Communications, vol. 12, no. 1, p. 5806, Oct 2021

    work page 2021

  4. [4]

    Treebeard: An optimizing compiler for decision tree based ml infer- ence,

    A. Prasad, S. Rajendra, K. Rajan, R. Govindarajan, and U. Bondhugula, “Treebeard: An optimizing compiler for decision tree based ml infer- ence,” in 55th IEEE/ACM International Symposium on Microarchitecture (MICRO), 2022, pp. 494–511

    work page 2022

  5. [5]

    Lightgbm: a highly efficient gradient boosting decision tree,

    G. Ke, Q. Meng, T. Finley, T. Wang, W. Chen, W. Ma, Q. Ye, and T.-Y . Liu, “Lightgbm: a highly efficient gradient boosting decision tree,” in Proceedings of the 31st International Conference on Neural Information Processing Systems, 2017, p. 3149–3157

    work page 2017

  6. [6]

    Efficient realization of decision trees for real-time inference,

    K.-H. Chen, C. Su, C. Hakert, S. Buschj ¨ager, C.-L. Lee, J.-K. Lee, K. Morik, and J.-J. Chen, “Efficient realization of decision trees for real-time inference,” ACM Trans. Embed. Comput. Syst. , vol. 21, no. 6, 2022

    work page 2022

  7. [7]

    Dynamic decision tree ensembles for energy-efficient inference on iot edge nodes,

    F. Daghero, A. Burrello, E. Macii, P. Montuschi, M. Poncino, and D. Jahier Pagliari, “Dynamic decision tree ensembles for energy-efficient inference on iot edge nodes,” IEEE Internet of Things Journal , vol. 11, no. 1, pp. 742–757, 2024

    work page 2024

  8. [8]

    Treehouse: An mlir-based compilation flow for real-time tree-based inference,

    C. Su, C.-H. Ku, J. K. Lee, and K.-H. Chen, “Treehouse: An mlir-based compilation flow for real-time tree-based inference,” ACM Trans. Embed. Comput. Syst. , Nov. 2024. [Online]. Available: https://doi.org/10.1145/3704727

    work page doi:10.1145/3704727 2024

Show all 36 references
  1. [9]

    Comparison of tree-based model with deep learning model in predicting effluent ph and concentration by capacitive deionization,

    Z. Ullah, N. Yoon, B. K. Tarus, S. Park, and M. Son, “Comparison of tree-based model with deep learning model in predicting effluent ph and concentration by capacitive deionization,” Desalination, vol. 558, p. 116614, 2023

    2023

  2. [10]

    iNEMO inertial module: Always-on 3D accelerometer and 3D gyro-scope,

    “iNEMO inertial module: Always-on 3D accelerometer and 3D gyro-scope,” Data Sheet, STMicroelectronics, 2019, https://www.st.com/resource/en/datasheet/lsm6dsox.pdf

    2019

  3. [11]

    Optimizing random forest- based inference on risc-v mcus at the extreme edge,

    E. Tabanelli, G. Tagliavini, and L. Benini, “Optimizing random forest- based inference on risc-v mcus at the extreme edge,” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems , vol. 41, no. 11, pp. 4516–4526, 2022

    2022

  4. [12]

    Random forests,

    L. Breiman, “Random forests,” Mach. Learn. , vol. 45, no. 1, p. 5–32, oct 2001

    2001

  5. [13]

    Extremely randomized trees,

    P. Geurts, D. Ernst, and L. Wehenkel, “Extremely randomized trees,” Machine Learning , vol. 63, no. 1, pp. 3–42, Apr 2006

    2006

  6. [14]

    Greedy function approximation: A gradient boosting machine

    J. H. Friedman, “Greedy function approximation: A gradient boosting machine.” The Annals of Statistics , vol. 29, no. 5, pp. 1189 – 1232, 2001

    2001

  7. [15]

    Scikit-learn: Machine learning in Python,

    F. Pedregosa, G. Varoquaux, A. Gramfort, V . Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V . Dubourg, J. Vander- plas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duch- esnay, “Scikit-learn: Machine learning in Python,” Journal of Machine ...

    2011

  8. [16]

    Classification and regression by randomforest,

    A. Liaw and M. Wiener, “Classification and regression by randomforest,” R News , vol. 2, no. 3, pp. 18–22, 2002. [Online]. Available: https://CRAN.R-project.org/doc/Rnews/

    2002

  9. [17]

    Language-based deployment optimization for random forests (invited paper),

    J. Malcher, D. Biebert, K.-H. Chen, S. Buschj ¨ager, C. Hakert, and J.- J. Chen, “Language-based deployment optimization for random forests (invited paper),” in Proceedings of the 25th ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, and Tools for Em- bedde...

    2024

  10. [18]

    ranger: A fast implementation of random forests for high dimensional data in c++ and r,

    M. N. Wright and A. Ziegler, “ranger: A fast implementation of random forests for high dimensional data in c++ and r,” Journal of Statistical Software, vol. 77, no. 1, p. 1–17, 2017

    2017

  11. [19]

    Runtime optimizations for tree- based machine learning models,

    N. Asadi, J. Lin, and A. P. de Vries, “Runtime optimizations for tree- based machine learning models,” IEEE Transactions on Knowledge and Data Engineering , vol. 26, no. 9, pp. 2281–2292, 2014

    2014

  12. [20]

    Realization of random forest for real-time evaluation through tree framing,

    S. Buschj ¨ager, K. Chen, J. Chen, and K. Morik, “Realization of random forest for real-time evaluation through tree framing,” in IEEE Interna- tional Conference on Data Mining, ICDM 2018, Singapore, November 17-20, 2018 , 2018, pp. 19–28

    2018

  13. [21]

    Accelerating a random forest classifier: Multi-core, gp-gpu, or fpga?

    B. Van Essen, C. Macaraeg, M. Gokhale, and R. Prenger, “Accelerating a random forest classifier: Multi-core, gp-gpu, or fpga?” in IEEE 20th International Symposium on Field-Programmable Custom Computing Machines, 2012, pp. 232–239

    2012

  14. [22]

    Decision tree and random forest im- plementations for fast filtering of sensor data,

    S. Buschj ¨ager and K. Morik, “Decision tree and random forest im- plementations for fast filtering of sensor data,” IEEE Transactions on Circuits and Systems I: Regular Papers , vol. 65, no. 1, pp. 209–222, 2018

    2018

  15. [23]

    A digital 3d tcam accelerator for the inference phase of random forest,

    C.-L. Tsai, C.-F. Wu, Y .-H. Chang, H.-W. Hu, Y .-C. Lee, H.-P. Li, and T.- W. Kuo, “A digital 3d tcam accelerator for the inference phase of random forest,” in 60th ACM/IEEE Design Automation Conference (DAC) , 2023, pp. 1–6

    2023

  16. [24]

    Immediate split trees: Im- mediate encoding of floating point split values in random forests,

    C. Hakert, K.-H. Chen, and J.-J. Chen, “Immediate split trees: Im- mediate encoding of floating point split values in random forests,” in Machine Learning and Knowledge Discovery in Databases , M.-R. Amini, S. Canu, A. Fischer, T. Guns, P. Kralj Novak, and G. Tsoumakas, Eds., ...

    2023

  17. [25]

    Efficient realization of decision trees for real-time inference,

    K. Chen, C. Su, C. Hakert, S. Buschj ¨ager, C. Lee, J. Lee, K. Morik, and J. Chen, “Efficient realization of decision trees for real-time inference,” ACM Trans. Embed. Comput. Syst. , vol. 21, no. 6, pp. 68:1–68:26, 2022

    2022

  18. [26]

    Flint: Exploiting floating point enabled integer arithmetic for efficient random forest inference,

    C. Hakert, K.-H. Chen, and J.-J. Chen, “Flint: Exploiting floating point enabled integer arithmetic for efficient random forest inference,” in Design, Automation & Test in Europe Conference & Exhibition , 2024, pp. 1–2. 8

    2024

  19. [27]

    Treelite: toolbox for decision tree deployment,

    H. Cho and M. Li, “Treelite: toolbox for decision tree deployment,” in Proceedings of Machine Learning and Systems (MLSys) , 2018

    2018

  20. [28]

    Quantization and training of neural networks for efficient integer-arithmetic-only inference,

    B. Jacob, S. Kligys, B. Chen, M. Zhu, M. Tang, A. G. Howard, H. Adam, and D. Kalenichenko, “Quantization and training of neural networks for efficient integer-arithmetic-only inference,” in 2018 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2018, Salt Lake C...

    2018

  21. [29]

    Xgboost: A scalable tree boosting system,

    T. Chen and C. Guestrin, “Xgboost: A scalable tree boosting system,” in Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining , 2016, p. 785–794

    2016

  22. [30]

    Fast gradient boosting decision trees with bit-level data structures,

    L. Devos, W. Meert, and J. Davis, “Fast gradient boosting decision trees with bit-level data structures,” in Machine Learning and Knowledge Discovery in Databases , U. Brefeld, E. Fromont, A. Hotho, A. Knobbe, M. Maathuis, and C. Robardet, Eds., 2020, pp. 590–606

    2020

  23. [31]

    Ieee standard for floating-point arithmetic,

    “Ieee standard for floating-point arithmetic,” IEEE Std 754-2019 (Revi- sion of IEEE 754-2008) , pp. 1–84, 2019

    2019

  24. [32]

    How many trees in a random forest?

    T. M. Oshiro, P. S. Perez, and J. A. Baranauskas, “How many trees in a random forest?” in Machine Learning and Data Mining in Pattern Recognition: 8th International Conference, MLDM 2012, Berlin, Ger- many, July 13-20, 2012. Proceedings 8 . Springer, 2012, pp. 154–168

    2012

  25. [33]

    Js220 joulescope precision energy analyzer,

    Joulescope, “Js220 joulescope precision energy analyzer,” 2025, accessed: 2025-01-21. [Online]. Available: https://www.joulescope. com/products/js220-joulescope-precision-energy-analyzer

    2025

  26. [34]

    Statlog (Shuttle),

    “Statlog (Shuttle),” UCI Machine Learning Repository, DOI: https://doi.org/10.24432/C5WS31

    doi

  27. [35]

    Esa anomaly dataset,

    G. De Canio, K. Kotowski, and C. Haskamp, “Esa anomaly dataset,” Jun. 2024. [Online]. Available: https://zenodo.org/doi/10.5281/zenodo. 12528696

    2024 doi

  28. [36]

    Joulescope, Joulescope™ JS220 User’s Guide Precision DC Energy Analyzer, Joulescope. 9

Pith tools

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