Pith. sign in

REVIEW 4 major objections 5 minor 46 references

Evaluation of Large Language Model-Driven AutoML in Data and Model Management from Human-Centered Perspective

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

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

Pith's one-line read A conversational LLM interface can cut ML implementation time by about half while raising task completion and accuracy, a 15-professional study claims.

desk verdict New evaluation, muddled baseline: the 15-person user study is a useful extension but the non-LLM condition is described inconsistently and the results contradict themselves, so the headline claims do not hold. read the letter →

arxiv 2507.05962 v1 pith:EFZK5RYN submitted 2025-07-08 cs.HC

Jiapeng Yao , Lantian Zhang , Jiping Huang This is my paper
classification cs.HC
keywords largelanguagemodelsautomatedmachinelearninghuman-computerinteractionnaturalinterfaceuserstudydeepmodelmanagementdata
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

This paper sets out to show that a conversational, LLM-driven AutoML interface makes machine learning implementation much more accessible than traditional code- and GUI-based AutoML without sacrificing quality. In a within-subjects study of 15 professionals, it reports that users with the natural-language interface completed image and text classification at higher rates (93.33% and 100% versus 73.33% and 66.67%), in roughly half the time, and with accuracy higher for 93.34% of participants and comparable for the rest, none lower. It also reports that syntax errors, error-resolution time, and required training time fell sharply. If true, AutoML stops being a tool for people who already know Python and ML jargon and becomes something a domain expert can drive by describing the task. The paper itself notes that its sample over-represents Python-proficient users and that LLM latency and GPU overhead remain deployment barriers.

What carries the argument

The load-bearing object is the paper's LLM-based AutoML prototype: a Gradio-based conversational front end backed by five specialized modules (modality inference, automated feature engineering, model selection, pipeline assembly, and hyperparameter optimization), which together turn a sentence like 'classify these product images' into an executable model-training pipeline. Model selection is formalized as $M_{\text{selected}} = \arg\max_{m\in\mathcal{M}} P(m\mid t,d)$, choosing a pretrained model given the task description and input data characteristics. This module arrangement carries the argument because it is what lets the interface bypass the syntax, configuration, and preprocessing steps that dominate baseline failures, while the non-LLM condition uses AutoGluon in a Jupyter notebook.

What would settle it

Re-run the two tasks with matched hardware, count LLM query latency as part of task time, and recruit a majority of non-Python users; if the LLM condition's completion-time advantage falls below about 50% or its accuracy and completion advantages disappear, the paper's central claim is not supported.

Watch

Extended reading notes

Core claim

The central claim is that replacing the standard AutoML interaction (GUI forms and notebook code) with natural language raises implementation success rates, cuts task time, and matches or beats accuracy across expertise levels. The reported numbers are 93.34% of users achieving higher accuracy and 6.67% comparable accuracy with none lower, 60% finishing more than 50% faster, completion rates rising from 73.33% to 93.33% for image classification and 66.67% to 100% for text classification, and a 73% reduction in error-resolution time. The authors attribute the effect to three mechanisms: the LLM automates pipeline construction and model selection, natural language removes the syntax barrier, and context-aware guidance shortens trial-and-error. On that evidence they conclude that natural language is an effective universal interface for complex technical systems and a route to democratizing ML inside organizations.

Load-bearing premise

The measured gains are attributed to the natural-language interface on the assumption that the two conditions were otherwise identical, but the LLM condition had extra query latency and GPU overhead and the sample was mostly Python-proficient, so if those differences drove the results, the 50% time saving and 93.34% accuracy claim do not follow.

Editorial extensions

If this is right

  • If the results hold, non-programmers can complete standard vision and text classification tasks they currently fail, with completion rising from 73.33% to 93.33% on images and from 66.67% to 100% on text.
  • Reported average task time falls from 17.3 to 8.5 minutes on images and 15.8 to 7.2 minutes on text, implying a sustained efficiency gain across expertise levels.
  • Because 93.34% of users beat baseline accuracy and none do worse, organizations could give domain staff an ML implementation route without a measured accuracy penalty.
  • The reported 73% drop in error-resolution time and 12.3-versus-45.7-minute training time imply the interface also acts as a learning tool, not just an execution tool.
  • The same results carry trade-offs: 25-40-second query latency and roughly 12GB of extra VRAM mean the approach suits asynchronous, well-resourced settings rather than real-time interactive tuning.

Reading between the lines

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

  • The paper does not rule out that its accuracy gains come from the LLM selecting stronger pretrained models rather than from natural language itself; a control with identical model choices in a GUI would isolate the interface effect.
  • The reported 25-40-second LLM query latency, if counted as task time, would shrink the 50% time saving, so a transparent time breakdown is the cheapest test of the efficiency claim.
  • With 73.33% of participants Python-proficient, the strongest democratization claim, that true non-experts benefit, is the least tested; a replication with mostly non-programmers is the decisive extension.
  • The failure cases the paper lists (custom loss functions and custom augmentation pipelines) suggest a hybrid design that keeps natural language for task setup while adding explicit code or configuration for expert control.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper presents an LLM-driven AutoML prototype built on the AutoM3L framework with a Gradio conversational interface, and reports a within-subjects user study with 15 participants comparing this interface to a non-LLM Jupyter/AutoGluon baseline on image classification and text sentiment analysis tasks. The abstract and conclusion claim that 93.34% of users achieved superior accuracy, that implementation time was cut by approximately 50%, that error resolution time fell by 73%, and that benefits held across all expertise levels. Section 4 reports completion rates, task completion times, classification accuracy, error metrics, and user-experience ratings; Section 5 discusses limitations including the technical skew of the participant pool.

Significance. If the reported effect sizes were valid, the paper would provide a practically valuable human-centered evaluation of LLM-based AutoML, with a concretely described prototype and a quantitative within-subjects protocol. The manuscript deserves credit for defining time, accuracy, and satisfaction metrics (Eqs. 2-4), reporting effect sizes, and openly acknowledging the overrepresentation of Python-proficient participants in Section 5. However, the central comparison is undermined by an incoherent baseline description and by internal contradictions among the headline numbers, so the paper's main empirical claims are not currently supported by the data as reported.

major comments (4)
  1. [§3.2, §4.3, §4.7] The baseline condition is not coherently defined. Section 3.2 describes the non-LLM condition as a Jupyter notebook pre-configured with AutoGluon (v0.7.0), but the error analysis in Section 4.3 attributes 78% of baseline failures to syntax errors, import statement mistakes, tensor-dimension errors, and manual model architecture/hyperparameter configuration, and the user examples in Section 4.7 describe data-loader configuration, tensor-dimension debugging, and manual grid search. These are manual PyTorch-level operations that AutoGluon's high-level fit/predict API is specifically designed to prevent. If the baseline was genuinely AutoGluon, the reported error profile and 45.7-minute learning-curve training time are implausible; if the baseline was hand-written PyTorch, the study compares LLM-generated code with manual coding rather than LLM-based AutoML with traditional AutoML. Under either reading, the central claims of a 50% time reduction and 93.34% accuracy advantage do not follow from the stated experimental design.
  2. [§4.3, Table 4, §4.4] The error metrics contradict one another. Section 4.3 states that 'the LLM condition eliminated syntax errors entirely through natural language parsing,' while Table 4 reports 2.1 syntax errors per session in the LLM condition (compared with 7.8 in baseline) and Section 4.4 reports a 73% reduction in syntax errors. The values 2.1 and 7.8 are consistent with a 73% reduction, but they directly contradict 'eliminated entirely.' The manuscript must reconcile these statements and specify which metric (syntax errors per session, error resolution time, or something else) supports the abstract's claim of a 73% reduction.
  3. [§4.3, §4.5, abstract] The number 93.34% is used for two different quantities. In the abstract and Section 4.3 it denotes the percentage of participants (46.67% higher plus 46.67% significantly higher) who achieved superior accuracy in the LLM condition relative to baseline. In Section 4.5 it denotes the average classification accuracy of the LLM-condition model over N=1000 test cases: 'Implementation accuracy ... achieved 93.34% for the LLM condition compared to 69.85% for baseline.' These are different constructs, and the paper never reports the per-participant accuracy differences or their distribution that would substantiate the 46.67%/46.67%/6.67% split.
  4. [§3.4, §4.2, §5] The generalization claim 'across all expertise levels' is not supported by the sample. Section 4.2 reports that 73.33% of participants were Python-proficient and only 26.67% were beginners, so with n=15 the study contains roughly four self-identified beginners. Section 5 acknowledges this overrepresentation, but the abstract and conclusion nonetheless claim that natural language interfaces cut implementation time and improve accuracy across all expertise levels. The paper reports no statistical interaction between expertise level and condition, so the cross-expertise generalization is asserted rather than demonstrated.
minor comments (5)
  1. [Table 1, §3.2] Table 1 defines three experimental conditions (LLM-AutoML, Traditional AutoML, Manual Coding), but Sections 3.2 and 4 compare only two conditions; please clarify whether the Manual Coding condition was included in the user study or deferred.
  2. [§4.4, Table 4, abstract] Section 4.4 reports a 68% reduction in error resolution time (1.8 vs. 5.6 minutes), while the abstract states that the approach 'reduced error resolution time by 73%'; the discrepancy should be reconciled.
  3. [§4.4] The manuscript mentions 'a 78% decrease in requests for technical assistance' but does not report the base rates or the measurement instrument for this metric; please provide the supporting data.
  4. [§4.5, Eq. (5)] The statistical reporting omits the standard deviations of the paired differences, making it impossible to verify the reported Cohen's d values (d=2.18, 2.05, 2.36); these should be included.
  5. [Throughout] There are several citation and formatting inconsistencies, including citations without parentheses in running text (e.g., 'Liu et al. (2024b); Luo et al. (2024a)' in Section 3.1) and an incomplete rendering of Figure 3; a careful copyedit is needed.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the central claims are empirical measurements; baseline inconsistencies are validity concerns, not self-referential reductions.

full rationale

The paper is an empirical within-subjects user study, not a derivation. The central quantitative claims (93.34% superior accuracy, ~50% time reduction, 73% error-resolution reduction) are measurements of observed participants relative to a baseline; no equation in Section 3.3 defines the result as equivalent to its input, no parameter is fitted to the outcome and then called a prediction, and no load-bearing premise is justified by a self-citation (the present authors do not overlap with the cited AutoM3L/Shen works). Any concerns about the baseline—AutoGluon in Section 3.2 versus manual PyTorch-style syntax and tensor-dimension errors in Sections 4.3 and 4.7—are threats to construct validity and causal attribution, not circularity. The 25–40 s latency and 12 GB VRAM overhead in Table 5 are explicitly reported as costs, not hidden as inputs. Accordingly no circular step is exhibited.

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

The evaluation depends on several domain assumptions about participant representativeness, baseline comparability, and measurement validity, plus two arbitrary categorization thresholds. No new mathematical entities or fitted constants are introduced beyond the prototype system built on existing AutoM3L components.

free parameters (2)
  • Accuracy improvement thresholds = 10% and 25%
    Defined in Section 4.3 and Table 3 as the boundaries between 'higher' and 'significantly higher' relative accuracy. These thresholds are chosen without justification and directly determine the 46.67%/46.67% split.
  • Time reduction thresholds = 25% and 50%
    Defined in Section 4.3 as the boundaries between 'moderately faster' and 'significantly faster' completion times. The arbitrary bins determine the reported 60%/40% result.
assumptions (4)
  • domain assumption The within-subjects sample of 15 participants is large enough to support population-level claims about accessibility.
    Participants were recruited through university networks and professional technology communities, and 73.33% already knew Python. The authors acknowledge in Section 5 that this overrepresents technically skilled users.
  • domain assumption The baseline condition, AutoGluon in Jupyter, is a faithful representative of traditional ML implementation.
    Section 3.2 defines the non-LLM condition as AutoGluon, but Section 4.3 describes baseline failures involving imports, tensor dimensions, and hyperparameter misconfigurations, which are more consistent with manual PyTorch coding. The baseline identity is therefore ambiguous.
  • domain assumption Task completion time measured automatically reflects user productivity rather than system latency or interface differences.
    Section 4.6 reports 25-40 second query latency and 12 GB additional VRAM for the LLM condition, but these overheads are not subtracted from the completion-time comparison.
  • domain assumption Self-reported Likert ratings of complexity and efficiency correspond to actual usability.
    Section 4.4 relies on subjective 5-point scales without validation against objective behavioral measures other than the time and error metrics already in question.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Evaluation of Large Language Model-Driven AutoML in Data and Model Management from Human-Centered Perspective." pith.science (2026). https://pith.science/paper/EFZK5RYN

@misc{pith2026250705962,
  author       = {Pith},
  title        = {Pith review of: Evaluation of Large Language Model-Driven AutoML in Data and Model Management from Human-Centered Perspective},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/EFZK5RYN}},
  note         = {Machine review of arXiv:2507.05962}
}
read the original abstract

As organizations increasingly seek to leverage machine learning (ML) capabilities, the technical complexity of implementing ML solutions creates significant barriers to adoption and impacts operational efficiency. This research examines how Large Language Models (LLMs) can transform the accessibility of ML technologies within organizations through a human-centered Automated Machine Learning (AutoML) approach. Through a comprehensive user study involving 15 professionals across various roles and technical backgrounds, we evaluate the organizational impact of an LLM-based AutoML framework compared to traditional implementation methods. Our research offers four significant contributions to both management practice and technical innovation: First, we present pioneering evidence that LLM-based interfaces can dramatically improve ML implementation success rates, with 93.34% of users achieved superior performance in the LLM condition, with 46.67% showing higher accuracy (10-25% improvement over baseline) and 46.67% demonstrating significantly higher accuracy (>25% improvement over baseline), while 6.67% maintained comparable performance levels; and 60% reporting substantially reduced development time. Second, we demonstrate how natural language interfaces can effectively bridge the technical skills gap in organizations, cutting implementation time by 50% while improving accuracy across all expertise levels. Third, we provide valuable insights for organizations designing human-AI collaborative systems, showing that our approach reduced error resolution time by 73% and significantly accelerated employee learning curves. Finally, we establish empirical support for natural language as an effective interface for complex technical systems, offering organizations a path to democratize ML capabilities without compromising quality or performance.

Figures

Figures reproduced from arXiv: 2507.05962 by the authors.

Figure 1
Figure 1. Architecture of the proposed LLM-based AutoML framework. The system consists of two main components: a conversational web interface (Frontend) built with Gradio for user interaction, and a backend framework implementing five specialized LLM modules. The workflow begins when users provide natural language instructions and data through the web interface. The Modality Inference LLM (MI-LLM) analyzes input to determine … view at source ↗
Figure 2
Figure 2. The flow of user study design [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. Participant demographics and technical background analysis. 4.2 Participant Demographics and Background The study participants represented diverse technical backgrounds and experience levels spanning different age groups, with a majority (53.33%) between 18-24 years and the remainder (46.67%) between 25-34 years, as shown in [PITH_FULL_IMAGE:figures/full_fig_p009_3.png] view at source ↗

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

46 extracted references · 33 canonical work pages

  1. [1]

    Abid, A., Abdalla, A., Abid, A., Khan, D., Alfozan, A., and Zou, J. (2019). Gradio: Hassle-free sharing and testing of ml models in the wild. arXiv preprint arXiv:1906.02569

    arXiv 2019

  2. [2]

    B., Li, R., Kocetkov, D., Mou, C., Akiki, C., Ferrandis, C

    Allal, L. B., Li, R., Kocetkov, D., Mou, C., Akiki, C., Ferrandis, C. M., et al. (2023). Santacoder: don’t reach for the stars! arXiv preprint arXiv:2301.03988

    arXiv 2023

  3. [3]

    Austin, J., Odena, A., Nye, M., Bosma, M., Michalewski, H., Dohan, D., et al. (2021). Program synthesis with large language models. arXiv preprint arXiv:2108.07732

    arXiv 2021

  4. [4]

    N., Hoos, H., B¨ack, T., et al

    Baratchi, M., Wang, C., Limmer, S., van Rijn, J. N., Hoos, H., B¨ack, T., et al. (2024). Automated machine learning: past, present and future. Artificial Intelligence Review 57, 1–88

    work page 2024

  5. [5]

    G., Soares, C., and Vilalta, R

    Brazdil, P., Carrier, C. G., Soares, C., and Vilalta, R. (2008).Metalearning: Applications to data mining (Springer Science & Business Media)

    work page 2008

  6. [6]

    Chami, J. C. and Santos, V . (2024). Collaborative automated machine learning (automl) process framework. Edelweiss Applied Science and Technology 8, 7675–7685

    work page 2024

  7. [7]

    Chen, L., Guo, Q., Jia, H., Zeng, Z., Wang, X., Xu, Y ., et al. (2024a). A survey on evaluating large language models in code generation tasks. arXiv preprint arXiv:2408.16498

    arXiv 2024

  8. [8]

    Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H. P. D. O., Kaplan, J., et al. (2021). Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374

    arXiv 2021

Show all 46 references
  1. [9]

    Chen, S., Zhai, W., Chai, C., and Shi, X. (2024b). Llm2automl: Zero-code automl framework leveraging large language models. In 2024 International Conference on Intelligent Robotics and Automatic Control (IRAC) (IEEE), 285–290

    2024

  2. [10]

    Chon, H., Lee, S., Yeo, J., and Lee, D. (2024). Is functional correctness enough to evaluate code language models? exploring diversity of generated codes. arXiv preprint arXiv:2408.14504

    2024 arXiv

  3. [11]

    Deng, J., Dong, W., Socher, R., Li, L.-J., Li, K., and Fei-Fei, L. (2009). Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition (Ieee), 248–255

    2009

  4. [12]

    Erickson, N., Mueller, J., Shirkov, A., Zhang, H., Larroy, P., Li, M., et al. (2020). Autogluon-tabular: Robust and accurate automl for structured data. arXiv preprint arXiv:2003.06505

    2020 arXiv

  5. [13]

    Feurer, M., Klein, A., Eggensperger, K., Springenberg, J., Blum, M., and Hutter, F. (2015). Efficient and robust automated machine learning. Advances in neural information processing systems 28

    2015

  6. [14]

    He, K., Zhang, X., Ren, S., and Sun, J. (2016). Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition. 770–778

    2016

  7. [15]

    Hutter, F., Hoos, H., and Leyton-Brown, K. (2014). An efficient approach for assessing hyperparameter importance. In International conference on machine learning (PMLR), 754–762

    2014

  8. [16]

    Hutter, F., Kotthoff, L., and Vanschoren, J. (2019). Automated machine learning: methods, systems, challenges (Springer Nature)

    2019

  9. [17]

    Jin, H., Song, Q., and Hu, X. (2019). Auto-keras: An efficient neural architecture search system. In Proceedings of the 25th ACM SIGKDD international conference on knowledge discovery & data mining. 1946–1956

    2019

  10. [18]

    Kazemitabaar, M., Chow, J., Ma, C. K. T., Ericson, B. J., Weintrop, D., and Grossman, T. (2023). Studying the effect of ai code generators on supporting novice learners in introductory programming. In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems...

    2023

  11. [19]

    D., and Liang, X

    Ke, J., Shen, Y ., Guo, Y ., Wright, J. D., and Liang, X. (2020b). A prediction model of microsatellite status from histology images. In Proceedings of the 2020 10th International Conference on Biomedical Engineering and Technology. 334–338

    2020

  12. [20]

    and Poirier, S

    LeDell, E. and Poirier, S. (2020). H2o automl: Scalable automatic machine learning. In Proceedings of the AutoML Workshop at ICML (ICML San Diego, CA, USA), vol. 2020

    2020

  13. [21]

    G., and Shen, Y

    Liu, Y ., Chen, Z., Wang, Y . G., and Shen, Y . (2024b). Autoproteinengine: A large language model driven agent framework for multimodal automl in protein engineering. arXiv preprint arXiv:2411.04440

    2024 arXiv

  14. [22]

    G., and Shen, Y

    Liu, Y ., Chen, Z., Wang, Y . G., and Shen, Y . (2024c). Toursynbio-search: A large language model driven agent framework for unified search method for protein engineering. In 2024 IEEE International Conference on Bioinformatics and Biomedicine (BIBM) (IEEE), 5395–5400

    2024

  15. [23]

    G., Horv´ath, T., Cerri, R., Vanschoren, J., and De Carvalho, A

    Mantovani, R. G., Horv´ath, T., Cerri, R., Vanschoren, J., and De Carvalho, A. C. (2016). Hyper-parameter tuning of a decision tree induction algorithm. In 2016 5th Brazilian Conference on Intelligent Systems (BRACIS) (IEEE), 37–42

    2016

  16. [24]

    and Zhu, H

    Miah, T. and Zhu, H. (2024). User centric evaluation of code generation tools. In 2024 IEEE International Conference on Artificial Intelligence Testing (AITest)(IEEE), 109–119

    2024

  17. [25]

    Olson, R. S. and Moore, J. H. (2016). Tpot: A tree-based pipeline optimization tool for automating machine learning. In Workshop on automatic machine learning (PMLR), 66–74

    2016

  18. [26]

    L., Srinivas, V

    Patibandla, R. L., Srinivas, V . S., Mohanty, S. N., and Pattanaik, C. R. (2021). Automatic machine learning: An exploratory review. In 2021 9th International Conference on Reliability, Infocom Technologies and Optimization (Trends and Future Directions)(ICRITO)(IEEE), 1–9

    2021

  19. [27]

    Pham, H., Guan, M., Zoph, B., Le, Q., and Dean, J. (2018). Efficient neural architecture search via parameters sharing. In International conference on machine learning (PMLR), 4095–4104

    2018

  20. [28]

    and Giraud-Carrier, C

    Sanders, S. and Giraud-Carrier, C. (2017). Informing the use of hyperparameter optimization through metalearning. In 2017 IEEE International Conference on Data Mining (ICDM) (IEEE), 1051–1056

    2017

  21. [29]

    Shen, Y . (2024). Knowledgeie: Unifying online-offline distillation based on knowledge inheritance and evolution. In 2024 International Joint Conference on Neural Networks (IJCNN) (IEEE), 1–8 Frontiers 17 Sample et al. Running Title

    2024

  22. [30]

    Shen, Y ., Chen, Z., Mamalakis, M., Liu, Y ., Li, T., Su, Y ., et al. (2024a). Toursynbio: A multi-modal large model and agent framework to bridge text and protein sequences for protein engineering. In 2024 IEEE International Conference on Bioinformatics and Biomedicine (BIBM)...

    2024

  23. [31]

    Shen, Y ., Guo, P., Wu, J., Huang, Q., Le, N., Zhou, J., et al. (2023). Movit: Memorizing vision transformers for medical image analysis. In International Workshop on Machine Learning in Medical Imaging (Springer), 205–213

    2023

  24. [32]

    Shen, Y ., Li, C., Liu, B., Li, C.-Y ., Porras, T., and Unberath, M. (2025a). Operating room workflow analysis via reasoning segmentation over digital twins. arXiv preprint arXiv:2503.21054

    2025 arXiv

  25. [33]

    Shen, Y ., Liu, B., Li, C., Seenivasan, L., and Unberath, M. (2025b). Online reasoning video segmentation with just-in-time digital twins. arXiv preprint arXiv:2503.21056

    2025 arXiv

  26. [34]

    Shen, Y ., Xu, L., Yang, Y ., Li, Y ., and Guo, Y . (2022). Self-distillation from the last mini-batch for consistency regularization. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition. 11943–11952

    2022

  27. [35]

    D., Ng, A

    Socher, R., Perelygin, A., Wu, J., Chuang, J., Manning, C. D., Ng, A. Y ., et al. (2013). Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference on empirical methods in natural language processing. 1631–1642

    2013

  28. [36]

    Sun, Y ., Song, Q., Gui, X., Ma, F., and Wang, T. (2023). Automl in the wild: Obstacles, workarounds, and expectations. In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems. 1–15

    2023

  29. [37]

    C., and Antoniol, G

    Tambon, F., Moradi-Dakhel, A., Nikanjam, A., Khomh, F., Desmarais, M. C., and Antoniol, G. (2025). Bugs in large language models generated code: An empirical study. Empirical Software Engineering 30, 1–48

    2025

  30. [38]

    Trirat, P., Jeong, W., and Hwang, S. J. (2024). Automl-agent: A multi-agent llm framework for full-pipeline automl. arXiv preprint arXiv:2410.02958

    2024 arXiv

  31. [39]

    Tsai, Y .-D., Tsai, Y .-C., Huang, B.-W., Yang, C.-P., and Lin, S.-D. (2023). Automl-gpt: Large language model for automl. arXiv preprint arXiv:2309.01125

    2023 arXiv

  32. [40]

    Wang, C., He, Z., He, J., Ye, J., and Shen, Y . (2024). Histology image artifact restoration with lightweight transformer based diffusion model. In International Conference on Artificial Intelligence in Medicine (Springer), 81–89

    2024

  33. [41]

    and Shen, Y

    Wang, L. and Shen, Y . (2024). Evaluating causal reasoning capabilities of large language models: A systematic analysis across three scenarios. Electronics 13, 4584

    2024

  34. [42]

    Wen, Y ., Wang, Y ., Yi, K., Ke, J., and Shen, Y . (2024). Diffimpute: Tabular data imputation with denoising diffusion probabilistic model. In 2024 IEEE International Conference on Multimedia and Expo (ICME) (IEEE), 1–6

    2024

  35. [43]

    Zan, D., Chen, B., Zhang, F., Lu, D., Wu, B., Guan, B., et al. (2022). Large language models meet nl2code: A survey. arXiv preprint arXiv:2212.09420 Frontiers 18 Sample et al. Running Title

    2022 arXiv

  36. [44]

    Zhang, S., Gong, C., Wu, L., Liu, X., and Zhou, M. (2023). Automl-gpt: Automatic machine learning with gpt. arXiv preprint arXiv:2305.02499

    2023 arXiv

  37. [45]

    Zimmer, L., Lindauer, M., and Hutter, F. (2021). Auto-pytorch: Multi-fidelity metalearning for efficient and robust autodl. IEEE transactions on pattern analysis and machine intelligence 43, 3079–3090

    2021

  38. [46]

    Zoph, B. (2016). Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578 Frontiers 19

    2016 arXiv

Pith tools

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