betaFeedback

WorksComputer Science

SNAPPerf: Software-Aware Tabular Foundation Model for Retraining-Free Performance Prediction of Configurable Systems

Abstract

Modern software systems expose hundreds of configuration options whose combinations can substantially affect execution time, memory and energy usage. Measuring software performance resulting from a configuration set requires running a realistic workload. Since the configuration space grows exponentially, exhaustive benchmarking is infeasible. Prior work therefore trains models on a small set of measured configurations to predict the performance of the rest. Yet these models are specific to a particular software version, hardware platform, and workload, so changes require new measurements and retraining, and such changes are becoming more frequent with coding agents. We challenge this per-system training assumption with SNAPPERF (Software-aware, No-retraining, Adaptive Prediction), a sample-efficient tabular foundation model specialized for configurable software. SNAPPERF is pretrained once on synthetic data. Each new update only requires a few measured configurations as context to predict the rest without any per-system training or hyperparameter tuning. Across 39,866 configurations from 12 real-world systems, spanning 6 domains and 4 performance metrics, SNAPPERF reduces prediction error by 38% over the prior state of the art at the same measurement budget, and by 25% over the best general-purpose tabular foundation model. It matches the state of the art's accuracy with 54% fewer measurements on average. These results suggest that knowledge about software can be encoded in pretraining data rather than in per-system models, opening a new research direction in software-aware pretraining.

Introduction

Web servers, compilers, databases or video encoders expose hundreds of configuration options, and their combinations can directly influence how fast a system runs and how much memory and energy it uses. The right settings can improve performance several-fold, yet few users update configurations [1], and poor settings are a frequent source of performance bugs [2]. Finding good settings is hard because the number of configurations grows exponentially with the number of options, and measuring a single configuration means running a realistic workload on the entire system, which can take hours. Profiling even a simple system can consume weeks of machine time [3], 1

The established approach is therefore to measure a small sample of configurations, fit a performance model to these measurements, and use this model to predict the performance of all the others [5, 6, 7].

Prior work has proposed increasingly sophisticated learners for this task: regression trees [6, 8], performance-influence models [9], sparse deep networks [10], hierarchical interaction networks [11], and divide-and-learn ensembles [4, 12]. All of these methods follow the same principle: a configuration performance model is learned from measurements of the system it predicts. Transfer and meta-learning can reuse measurements of the same system taken in another environment [3, 13, 14, 15, 16], but they still train a new model for each target environment.

As an example, consider a video platform that encodes uploads with the VP8 encoder (Table I). Varying only two of its 13 options changes the encoding time of the same job elevenfold, while measuring all 2,736 configurations would require about 18 hours of encoding time [12]. To select a configuration without evaluating every candidate, engineers might measure 121 configurations, use them to train and tune a model such as DaL [4, 12], and predict the remaining 2,615. After a software update [17] or migration to new hardware [13], however, option interactions may change and the model may no longer predict performance reliably. Engineers must then collect new measurements and train and tune another model. As coding agents accelerate software development, such system updates are likely to become more frequent.

We propose predicting configuration performance from a few measurements, without retraining a model for each system. SNAPPerf is a single model pretrained once, independently of any target system. For a new system, the frozen model receives a few measured configurations as context and predicts the performance of all remaining configurations without updating any parameters. SNAPPerf is a tabular foundation model [18, 19, 20], a transformer-based model that learns to predict the target column of a table from a few labeled rows by pretraining on many synthetic tables. Existing tabular foundation models are pretrained on general synthetic tables, which do not reflect the structure of configuration spaces, such as binary and numeric options, constraints between options and option interactions [9]. SNAPPerf is therefore pretrained only on synthetic configurable systems, generated from what the literature knows about real ones. A recent survey lists few-shot learning as an open direction for configuration performance prediction [21]. In the VP8 example, an encoder update would then require only a few new measurements, with no retraining or tuning.

Quality modeThreadsConstant bitrate…Encoding time
best1no…60.8 s
good2yes…22.3 s
real-time4no…5.7 s
… 121 measured of 2,736 configurations
best4yes…?
good1no…?
real-time2yes…?
… 2,615 configurations to predict

Table 1. The prediction task on the VP8 video encoder [12]: each row is a configuration and its measured performance, the encoding time of the same job. The performance of every unmeasured configuration must be predicted from a small measured sample.

Our results on the DaL benchmark [12] suggest that per-system training is not necessary for accurate prediction. Following the benchmark’s protocol, SNAPPerf achieves 38% lower prediction error than the state of the art for the same measurements and is more accurate in 57 of 60 cases. It matches the state of the art’s accuracy with 54% fewer measurements on average, and its error is 25% lower than that of the best general-purpose tabular foundation model.

This paper makes three contributions: (i) we propose SNAPPerf, to our knowledge the first tabular foundation model specialized for configurable software, which is pretrained only on synthetic data and predicts performance from a few measurements without per-system retraining; (ii) we evaluate it on the DaL benchmark against prior state-of-the-art methods, five general-purpose tabular foundation models and tuned baselines; and (iii) we outline a research agenda towards software-aware pretraining.

Configuration performance prediction. Learning approaches range from regression trees [6, 8] and performance-influence models [9] to deep networks such as DeepPerf [10] and HINNPerf [11], and to DaL [4, 12], the current state of the art, which divides the configuration space and learns a model for each part. White-box approaches instead instrument the code [22]. Complementary work studies which configurations to measure [5, 23, 24, 25, 26] and shows that this choice can matter as much as the learner [27]. All of these approaches train and tune a new model for every system and every change, each from a fresh set of measurements. Since measurements dominate the cost, the fewer a method needs, the cheaper each change becomes.

Transfer across environments. When a system has already been measured in another environment, such as other hardware, transfer and meta-learning reuse these measurements to need fewer new ones [3, 13, 14, 15, 16, 28]. They still require earlier measurements of the same system and train a new model for each new environment.

Configuration tuning. Tuners search for the best configuration, increasingly with multi-objective and causally guided search [29, 30, 31]. SNAPPerf is complementary to both sampling and tuning methods, since samplers can select its input configurations and tuners can use it as their performance model.

Foundation models in software engineering. Large language models already replace task-specific training in software engineering, for example by reasoning over app descriptions instead of training a classifier [32]. They operate on text, however, and are less suited to numerical tables such as performance measurements [21]. Related work also shows that a few dozen labels often suffice in software analytics [33], which supports predicting performance from few measurements.

Tabular foundation models. These are transformer-based models pretrained on large and varied corpora of mostly synthetic tables, which predict the target column of a new table from a few labeled rows given as context, without further training [18, 19]. They now achieve leading performance on general tabular benchmarks [34, 35, 36, 37]. Their pretraining data covers tabular problems in general. Continued pretraining on curated data can improve accuracy [38], but none has been tailored to software engineering.

The SNAPPerf Model

SNAPPerf consists of three components (Figure 1). ① Software-aware pretraining. SNAPPerf is pretrained once, on synthetic data. Each training example is a config urable system drawn at random from a generator, which we call the prior. Its configuration space contains binary and numeric options, groups of alternative options, and constraints between options. Its performance follows a performance-influence model [9], in which a few options and interactions dominate, numeric options can have nonlinear effects, and measurements contain noise. The prior is built from the performance-modeling literature and tuned only on separate development systems (Section IV). No system, configuration or measurement from the evaluation benchmark is used to design the prior or to train the model, so the benchmark cannot leak into pretraining. The model is a 12-layer transformer with 12M parameters, less than half the size of Nori [39]. It is trained from scratch for 38 hours on two NVIDIA H200 GPUs and learns to approximate Bayesian prediction for systems drawn from the prior [18].

Overview of SNAPPerf

Figure 1. Overview of SNAPPerf. ① A transformer-based model is pretrained once, offline, on about 29 million synthetic configurable systems. ② For any software and any update, a few measured configurations become the context of the frozen model, which ③ predicts every unmeasured configuration with its uncertainty. Existing approaches instead train and tune a new model after every change (bottom).

② Measurements as context. For a given system, the measured configurations, encoded as option vectors, become the model’s context. The model takes no gradient step and needs no hyperparameter search, so no part of the small sample is set aside for validation, and adapting to a change requires neither a training pipeline nor machine learning expertise.

③ Prediction with uncertainty. A single inference call predicts the full distribution of the performance of every unmeasured configuration. The point prediction minimizes the expected relative error, and the distribution provides an uncertainty estimate, which most existing methods lack [40]. On our benchmark, 90% prediction intervals contain 92% of the true values in the median case. They can later guide which configuration to measure next.

Use in practice. After a software update, a hardware change or a new workload, practitioners measure a few configurations and provide them as the new context; each additional measurement adds a row. There is no per-system model to store, version or maintain.

Preliminary Results

We evaluate SNAPPerf through three research questions:

RQ1: How accurate is SNAPPerf compared with current state-of-the-art methods?

RQ2: How many measurements does SNAPPerf save?

RQ3: How does specialized pretraining compare with general-purpose tabular foundation models?

Experimental Setup

Subject systems. We use the 12 systems of the DaL benchmark [12], which span databases, web servers, video encoders, compression tools, scientific solvers and image processing. Together, they provide 39,866 measured configurations, that is, 39,866 table rows, each pairing a configuration with its measured performance. Depending on the system, the predicted metric is runtime, latency, energy or maximum load.

Development systems. All design decisions to create our model (prior, model size, checkpoint, point estimate) were made on synthetic data or on 16 development systems from

other studies [10, 16, 25, 29]. The benchmark was used only to evaluate the final model.

Protocol. Following prior work [4, 10, 11, 12], we use five measurement budgets per system, corresponding to 3% to 22% of all configurations. For each budget, we test on all remaining configurations and repeat each experiment 30 times with different random samples. We report the median mean relative error (MRE) over the 30 repetitions and rank methods in each case with Scott-Knott Effect Size Difference (ESD) [41], which splits methods into groups whose errors differ significantly and merges groups whose difference has a negligible effect size (A^12<0.6\hat{A}_{12} < 0.6 [42]). To compare SNAPPerf with DaL overall, we use a paired Wilcoxon signed-rank test [43]. All tests use 99% confidence.

Methods. We compare SNAPPerf with five general-purpose tabular foundation models: Nori [39], TabICL [35], TabPFN [34], TabFM [44] and Mitra 2 [36]. At prediction time, all six models average eight predictions, each made with the options presented in a different random order or encoding. We rerun DaL and HINNPerf, the current state of the art, with their public implementations on the same samples. We also compare with four classical learners with default settings and three tuned by a cross-validated grid search within each training sample.

RQ1: Accuracy

As shown in Table II, SNAPPerf has a 38% lower median error than the prior state-of-the-art model DaL and is more accurate in 57 of the 60 system-budget cases (p<0.001p < 0.001 over all runs), with a stable gain of 37% to 40% across budgets. SNAPPerf is in the top Scott-Knott group in 55 of 60 cases, compared with 15 cases for any general-purpose foundation model, 9 for DaL or HINNPerf and 4 for any tuned classical learner. Its mean error is also lowest, at 9.8% against 21.7% for DaL, as it avoids the occasional large misses of other methods. In the five cases where it is not in the top group, its error is within 0.12 percentage points of the best.

MethodMedian MREAvg. rankTop group (of 60)
Specialized foundation model (ours), no per-system training
SNAPPerf2.801.0855
General-purpose foundation models, no per-system training
Nori3.802.439
TabICL4.432.728
TabPFN4.133.154
Mitra 25.413.4812
TabFM5.113.633
State of the art (trained and tuned per system)
DaL4.723.577
HINNPerf6.414.526
Classical learners, tuned / default
XGBoost6.06/5.984.40/4.652/2
Random forest7.32/7.334.78/4.854/4
Decision tree7.93/7.694.88/5.032/3
Linear regression46.036.951

Table II. Results over 12 systems, 5 budgets and 30 repetitions. Median MRE: median relative error (%). Avg. rank: mean Scott-Knott ESD rank over the 60 cases (lower is better). Top group: cases in which a method is statistically tied for best (99% confidence); several methods can share a case.

Answer to RQ1: SNAPPerf achieves 38% lower error than DaL and is in the top group in 55 of 60 cases, without requiring any training on the target system.

RQ2: Measurement Savings

For each case, we give SNAPPerf growing subsets of the training sample in steps of 5 percentage points, evaluate each on the same test set as DaL, and find the smallest subset whose median error over the 30 repetitions does not exceed DaL’s error with the full sample (Figure 2). On average over the 60 cases, SNAPPerf needs 54% fewer measured configurations than DaL, twice the 27% saving of the best general-purpose model, Nori. The saving is 57% for the smallest training samples and 56% for the largest. Savings vary by system, from 10% on HSMGP to 93% on SQLite, where every method has a high error. The error of SNAPPerf keeps decreasing as it receives more measurements, indicating that it benefits from additional context at inference time rather than relying only on its pretraining.

Figure 2. Error given a growing share of the training sample, relative to DaL on the full sample. Below 1×, the model is more accurate than DaL. Lines: median over 60 cases; band: interquartile range of SNAPPerf. In the median case, SNAPPerf matches DaL’s accuracy with 43% of the sample, and Nori, the best general-purpose model, with 76%.

Answer to RQ2: SNAPPerf reaches DaL’s accuracy with 54% fewer measurements on average.

RQ3: Specialized vs. General-Purpose Pretraining

All six foundation models predict in the same way, by conditioning on the measured configurations, and differ mainly in their pretraining data. Among the five general-purpose models, accuracy varies widely. In a typical case, the least accurate model has twice the error of the most accurate one, and the best model differs from system to system (Figure 3). In contrast, SNAPPerf is the most accurate model on 11 of the 12 systems, and on VP8 its error is within 4% of the best. It is more accurate than Nori, the best general-purpose model overall, in 58 of 60 cases, with a 25% lower error in the median case. Even against the best general-purpose model of each case, selected with knowledge of the test results, SNAPPerf is more accurate in 54 of 60 cases. The largest improvements occur on systems where the general-purpose models perform poorly, such as BDB-C, kanzi and nginx. On the 16 development systems used for model selection, the error of SNAPPerf is also 32% lower than that of Nori on average.

Figure 3. Error of each foundation model relative to the most accurate one in the same case, median over five budgets. Bold marks the best model per system.

Answer to RQ3: Specialized pretraining reduces error by 25% compared with the best general-purpose tabular foundation model.

Future Plans

The field has encoded its knowledge of configuration spaces in architectures, such as sparsity in DeepPerf or space division in DaL; SNAPPerf shows that it can instead be encoded in pretraining data. We plan three steps.

Step 1: Understand the prior. We will ablate its elements, such as interactions, constraints and noise, and extend it to coverage-based sampling designs [25] and several metrics at once. Success criterion: each element measurably improves accuracy on held-out systems.

Step 2: Follow software evolution. We will reuse measurements across releases and use predictive uncertainty to choose the next configuration to measure [45]. Success criterion: after an update, SNAPPerf needs fewer new measurements than when measuring from scratch.

Step 3: From prediction to tuning. Since better accuracy does not guarantee better tuning [46], we will integrate SNAPPerf into configuration tuners [29], [31]. Success criterion: tuners using SNAPPerf find better configurations for the same measurement budget.

Conclusion

SNAPPerf predicts the performance of configurable software from a few measurements with a model pretrained once on synthetic configurable systems. Its error is 38% lower than the state of the art, which it matches with 54% fewer measurements, suggesting that software knowledge belongs in pretraining data rather than in per-system models. We envision performance prediction that is available immediately after every software change, without retraining.

References

References

  1. [1]T. Xu, L. Jin, X. Fan, Y. Zhou, S. Pasupathy, and R. Taldwaker, “Hey, you have given me too many knobs!: Understanding and dealing with over-designed configuration in system software,” in Proc. ESEC/FSE, 2015, pp. 307–319.DOI
  2. [2]T. Xu, H. Han, and T. Yu, “An empirical study on performance bugs for highly configurable software systems,” in Proc. ESEM, 2016.DOI
  3. [3]J. Gong and T. Chen, “Predicting configuration performance in multiple environments with sequential meta-learning,” Proc. ACM Softw. Eng., vol. 1, no. FSE, 2024.arxiv.org/abs/2402.03183
  4. [4]J. Gong, “Predicting software performance with divide-and-learn,” in Proc. ESEC/FSE, 2023, pp. 858–870.arxiv.org/abs/2306.06651
  5. [5]N. Siegmund, S. Kolesnikov, C. Kästner, S. Apel, D. Batory, M. Rosenmüller, and G. Saake, “Predicting performance via automated feature-interaction detection,” in Proc. ICSE, 2012, pp. 167–177.
  6. [6]J. Guo, K. Czarnecki, S. Apel, N. Siegmund, and A. Wa̧sowski, “Variability-aware performance prediction: A statistical learning approach,” in Proc. ASE, 2013, pp. 301–311.DOI
  7. [7]J. A. Pereira, M. Acher, H. Martin, J.-M. Jézéquel, G. Botterweck, and A. Ventresque, “Learning software configuration spaces: A systematic literature review,” J. Syst. Softw., vol. 182, p. 111044, 2021.
  8. [8]J. Guo, D. Yang, N. Siegmund, S. Apel, A. Sarkar, P. Valov, K. Czarnecki, A. Wa̧sowski, and H. Yu, “Data-efficient performance learning for configurable systems,” Empir. Softw. Eng., vol. 23, no. 3, pp. 1826–1867, 2018.DOI
  9. [9]N. Siegmund, A. Grebhahn, S. Apel, and C. Kästner, “Performance-influence models for highly configurable systems,” in Proc. ESEC/FSE, 2015, pp. 284–294.DOI
  10. [10]H. Ha and H. Zhang, “DeepPerf: Performance prediction for configurable software with deep sparse neural network,” in Proc. ICSE, 2019, pp. 1095–1106.
  11. [11]J. Cheng, C. Gao, and Z. Zheng, “HINNPerf: Hierarchical interaction neural network for performance prediction of configurable systems,” ACM Trans. Softw. Eng. Methodol., vol. 32, no. 2, 2023.DOI
  12. [12]J. Gong, T. Chen, and R. Bahsoon, “Dividable configuration performance learning,” IEEE Trans. Softw. Eng., vol. 51, no. 1, pp. 106–134, 2025.arxiv.org/abs/2409.07629
  13. [13]P. Valov, J.-C. Petkovich, J. Guo, S. Frechmeister, and K. Czarnecki, “Transferring performance prediction models across different hardware platforms,” in Proc. ICPE, 2017, pp. 39–50.DOI
  14. [14]P. Jamshidi, N. Siegmund, M. Velez, K. Kästner, A. Patel, and Y. Agarwal, “Transfer learning for performance modeling of configurable systems: An exploratory analysis,” in Proc. ASE, 2017, pp. 497–508.arxiv.org/abs/1709.02280
  15. [15]P. Jamshidi, M. Velez, C. Kästner, and N. Siegmund, “Learning to sample: Exploiting similarities across environments to learn performance models for configurable systems,” in Proc. ESEC/FSE, 2018, pp. 71–82.DOI
  16. [16]R. Krishna, V. Nair, P. Jamshidi, and T. Menzies, “Whence to learn? Transferring knowledge in configurable systems using BEETLE,” IEEE Trans. Softw. Eng., vol. 47, no. 12, pp. 2956–2972, 2021.arxiv.org/abs/1911.01817
  17. [17]S. Mühlbauer, S. Apel, and N. Siegmund, “Accurate modeling of performance histories for evolving software systems,” in Proc. ASE, 2019, pp. 640–652.
  18. [18]S. Müller, N. Hollmann, S. Pineda Arango, J. Grabocka, and F. Hutter, “Transformers can do Bayesian inference,” in Proc. ICLR, 2022.arxiv.org/abs/2112.10510
  19. [19]N. Hollmann, S. Müller, L. Purucker, A. Krishnakumar, M. Körfer, S. B. Hoo, R. T. Schirrmeister, and F. Hutter, “Accurate predictions on small data with a tabular foundation model,” Nature, vol. 637, pp. 319–326, 2025.DOI
  20. [20]B. van Breugel and M. van der Schaar, “Position: Why tabular foundation models should be a research priority,” in Proc. ICML, 2024, pp. 48 976–48 993.arxiv.org/abs/2405.01147
  21. [21]J. Gong and T. Chen, “Deep configuration performance learning: A systematic survey and taxonomy,” ACM Trans. Softw. Eng. Methodol., vol. 34, no. 1, 2025.arxiv.org/abs/2403.03322
  22. [22]M. Velez, P. Jamshidi, N. Siegmund, S. Apel, and C. Kästner, “White-box analysis over machine learning: Modeling performance of configurable systems,” in Proc. ICSE, 2021, pp. 1072–1084.arxiv.org/abs/2101.05362
  23. [23]D. R. Kuhn, D. R. Wallace, and A. M. Gallo, “Software fault interactions and implications for software testing,” IEEE Trans. Softw. Eng., vol. 30, no. 6, pp. 418–421, 2004.DOI
  24. [24]A. Sarkar, J. Guo, N. Siegmund, S. Apel, and K. Czarnecki, “Cost-efficient sampling for performance prediction of configurable systems,” in Proc. ASE, 2015, pp. 342–352.DOI
  25. [25]C. Kaltenecker, A. Grebhahn, N. Siegmund, J. Guo, and S. Apel, “Distance-based sampling of software configuration spaces,” in Proc. ICSE, 2019, pp. 1084–1094.
  26. [26]X. Wang, Z. Li, and Z. Ding, “LLM4Perf: Large language models are effective samplers for multi-objective performance modeling,” in Proc. ICSE, 2026, pp. 4065–4077.arxiv.org/abs/2512.16070
  27. [27]C. Kaltenecker, A. Grebhahn, N. Siegmund, and S. Apel, “The interplay of sampling and machine learning for software performance prediction,” IEEE Softw., vol. 37, no. 4, pp. 58–66, 2020.
  28. [28]J. Dorn, S. Mühlbauer, S. Jahns, S. Apel, and N. Siegmund, “Bayesian multi-level performance models for multi-factor variability of configurable software systems,” in Proc. ICSE, 2026, pp. 2747–2759.DOI
  29. [29]V. Nair, Z. Yu, T. Menzies, N. Siegmund, and S. Apel, “Finding faster configurations using FLASH,” IEEE Trans. Softw. Eng., vol. 46, no. 7, pp. 794–811, 2020.
  30. [30]T. Chen and M. Li, “Multi-objectivizing software configuration tuning,” in Proc. ESEC/FSE, 2021, pp. 453–465.DOI
  31. [31]P. Chen and T. Chen, “PromiseTune: Unveiling causally promising and explainable configuration tuning,” in Proc. ICSE, 2026, pp. 14–26.DOI
  32. [32]M. Alecci, J. Samhi, T. F. Bissyandé, and J. Klein, “Replacing training with reasoning: Reinterpreting classic ML pipelines with LLMs,” in Proc. ICSE-NIER, 2026, pp. 41–45.DOI
  33. [33]K. K. Ganguly and T. Menzies, “How low can you go? The data-light SE challenge,” in Proc. FSE, 2026.
  34. [34]L. Grinsztajn et al., “TabPFN-3: Technical report,” arXiv:2605.13986, 2026.arxiv.org/abs/2605.13986
  35. [35]J. Qu, D. Holzmüller, G. Varoquaux, and M. Le Morvan, “TabICL: A tabular foundation model for in-context learning on large data,” in Proc. ICML, 2025.arxiv.org/abs/2502.05564
  36. [36]X. Zhang, D. C. Maddix, J. Yin et al., “Mitra: Mixed synthetic priors for enhancing tabular foundation models,” in Proc. NeurIPS, 2025.
  37. [37]J. Ma, V. Thomas, R. Hossainzadeh, A. Labach, H. Kamari, J. C. Cresswell, K. Golestan, G. Yu, A. L. Caterini, and M. Volkovs, “TabDPT: Scaling tabular foundation models on real data,” in Proc. NeurIPS, 2025.arxiv.org/abs/2410.18164
  38. [38]A. Garg, M. Ali, N. Hollmann, L. Purucker, S. Müller, and F. Hutter, “Real-TabPFN: Improving tabular foundation models via continued pre-training with real-world data,” arXiv:2507.03971, 2025.arxiv.org/abs/2507.03971
  39. [39]P.-h. Li, A. Narayanan, S. S. Narasimhan, R. Mallampalli, A. Agrawal, B. Ajan, R. Shah, and S. Agarwal, “Synthefy-Nori: A tabular foundation model for regression,” Technical report, Synthefy, 2026.
  40. [40]J. Dorn, S. Apel, and N. Siegmund, “Mastering uncertainty in performance estimations of configurable software systems,” in Proc. ASE, 2020, pp. 684–696.
  41. [41]N. Mittas and L. Angelis, “Ranking and clustering software cost estimation models through a multiple comparisons algorithm,” IEEE Trans. Softw. Eng., vol. 39, no. 4, pp. 537–551, 2013.DOI
  42. [42]A. Vargha and H. D. Delaney, “A critique and improvement of the CL common language effect size statistics for McGraw and Wong,” J. Educ. Behav. Stat., vol. 25, no. 2, pp. 101–132, 2000.
  43. [43]F. Wilcoxon, “Individual comparisons by ranking methods,” Biometrics Bulletin, vol. 1, no. 6, pp. 80–83, 1945.
  44. [44]Google Research, “TabFM: A tabular foundation model,” https://github.com/google-research/tabfm, 2026.
  45. [45]S. Müller, M. Feurer, N. Hollmann, and F. Hutter, “PFNs4BO: In-context learning for Bayesian optimization,” in Proc. ICML, 2023, pp. 25 444–25 470.arxiv.org/abs/2305.17535
  46. [46]P. Chen, J. Gong, and T. Chen, “Accuracy can lie: On the impact of surrogate model in configuration tuning,” IEEE Trans. Softw. Eng., 2025.DOI

Paper details

vlnc:W_48q4b6up
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents