Pith. sign in

REVIEW 3 major objections 6 minor 56 references

ELATE: Evolutionary Language model for Automated Time-series Engineering

T0 review · 3 major / 6 minor · reviewed 2026-08-05 · deepseek-v4-flash

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

Pith's one-line read ELATE automates time-series feature engineering and cuts forecast error by 8.4%.

desk verdict First LLM-driven TS Auto-FE, plausible method and honest evaluation, but the 8.4% headline rests on one stochastic run per dataset. read the letter →

arxiv 2508.14667 v1 pith:IZNXFH6G submitted 2025-08-20 cs.LG cs.AI

Andrew Murray , Danial Dervovic , Michael Cashmore This is my paper
classification cs.LGcs.AI
keywords automatedfeatureengineeringtime-seriesforecastinglargelanguagemodelsevolutionarysearchSHAPselectionGrangercausalitymutualinformationinterpretablemachinelearning
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

The paper introduces ELATE, a system that automates feature engineering for time-series forecasting by having a language model propose Python code for new features inside an evolutionary loop. ELATE scores candidate features with Granger causality and mutual information, samples promising ones with an exponentially decaying temperature, and prunes the population with a SHAP-based filter at the end of each generation. The central claim is that the resulting feature set beats the raw features and eight baselines on seven forecasting domains, with an average RMSE reduction of 8.4% and MAE reduction of 9.6% versus no feature engineering. If this holds, feature engineering—often the most time-consuming and skill-dependent part of forecasting—could be largely delegated to an automated, interpretable process that completes in hours. The paper also shows the method is most effective on seasonal, predictable domains and roughly neutral on volatile stock returns.

What carries the argument

The central mechanism is an evolutionary population of features stored as code: the feature database, the language model, and the pruning filter. The language model proposes new transformations from a prompt containing the dataset description, few-shot examples sampled from the population by score, and a running list of previously generated feature names and scores. Each candidate is scored by the mean of Granger causality and mutual information with the target, and when the database fills to 100 features, a SHAP-based recursive feature elimination (with interventional values and correlation pruning) keeps the best 50. Sampling probabilities follow an exponentially decaying temperature, so e

What would settle it

Run ELATE on datasets where a known regime shift occurs between the validation and test windows, or interrupt the validation/test split at random points and compare the features chosen on validation with those chosen on test. If the average RMSE reduction versus Base drops to noise levels or reverses on multiple domains, the generality claim fails. Re-running ELATE with multiple seeds and early stopping would also show whether the 8.4% average survives optimizer variance.

Watch

Extended reading notes

Core claim

ELATE treats time-series automated feature engineering as an optimization problem, where the objective is a set of feature transformations that minimize forecast error. The discovery is that a language model used as a domain-aware mutation operator, combined with cheap time-series relevance evaluators and SHAP-based pruning, produces features that improve an XGBoost forecaster on six of seven domains, with reductions up to 18.5% in RMSE, an average of 8.4% across domains, and results on par with the best baseline in the remaining domain. The generated features are expressed as executable Python code with comments, making them reusable and interpretable, and the whole process runs in about th

Load-bearing premise

The penultimate 10% of each dataset, used to select and score features, represents the final 10% test period well enough that the chosen features generalize; the paper itself reports validation overfitting on two of seven domains.

Editorial extensions

If this is right

  • Practitioners can replace manual, day-long feature engineering with an automated loop that delivers forecasting accuracy gains in hours, with the paper citing a 10% forecast improvement as roughly a 5% cut in inventory costs and a 2% revenue gain in consumer goods.
  • Because ELATE returns executable code and a description for each feature, it produces auditable feature pipelines suitable for regulated applications such as healthcare and finance, where interpretability is a stated concern.
  • The method scales to large datasets—179,568 rows in the food-demand domain—where exhaustive expand-and-reduce baselines such as tsfresh exceed 128GB of RAM, showing that the evolutionary search avoids the memory blow-up of enumeration.
  • Using a cheaper language model, GPT-3.5 Turbo, still yields average RMSE and MAE reductions of 6.6% and 5.8% versus no feature engineering, at roughly one-fifth of the cost of GPT-4o.
  • ELATE is an anytime algorithm: users can stop after a few generations and still capture much of the improvement, since normalized RMSE drops sharply in the first generations on most domains.

Reading between the lines

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

  • I infer that ELATE's feature code could be pooled across datasets and domains into a reusable library of transformations, since the paper stores code rather than feature vectors but does not propose cross-domain transfer.
  • A natural testable extension is to apply the same evaluator-and-prune loop to classification, anomaly detection, or probabilistic forecasting, because Granger causality and mutual information are not tied to RMSE; the paper only evaluates point forecasting.
  • I infer that the validation overfitting the paper observes on ETTh1 and ILI could be mitigated by early stopping on a separate holdout or by replacing SHAP with a less redundancy-sensitive importance measure, which the paper acknowledges but does not implement.
  • The reported gains likely depend on the language model's priors about each domain—the paper deliberately selects datasets with descriptive feature names. On domains the model knows poorly or where feature names carry little meaning, the 8.4% average could shrink, a boundary the paper does not address directly.
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

3 major / 6 minor

Summary. The paper presents ELATE, an evolutionary framework that uses an LLM (GPT-4o or GPT-3.5 Turbo) to propose time-series feature transformations in Python code, guided by fast evaluators (Granger causality and mutual information) and a SHAP-based pruning filter. Features are stored as code, enabling interpretability and reuse. Experiments on seven time-series forecasting datasets compare ELATE against no feature engineering, zero-shot LLM features, VEST, tsfresh, LSTM, and two ELATE ablations. The headline claim is that ELATE 4o+SHAP achieves average RMSE and MAE reductions of 8.4% and 9.6% versus the base features, outperforming all baselines on six of seven domains and matching them on trading. The paper also reports runtime and cost comparisons and includes detailed pseudocode, prompt templates, and generated feature examples.

Significance. If the empirical claims hold, ELATE is a useful contribution to automated feature engineering for time-series forecasting: it is, to the authors' knowledge, the first LLM-based method for this problem; it generates interpretable, multi-step feature transformations that expand-and-reduce methods miss; and it is memory-efficient compared with tsfresh. The manuscript is also commendably transparent in several respects: it provides full pseudocode for the algorithm, the exact prompt template, dataset descriptions, and a complete list of generated features, and it explicitly discusses validation overfitting and cost trade-offs. However, the central quantitative claim currently rests on a single stochastic run per dataset, and one of the baselines (tsfresh) completed on only one of seven datasets. These issues weaken the statistical support for the headline 8.4% improvement and for the claim of outperforming all baselines.

major comments (3)
  1. [§5, Table 2] The headline claim of an 8.4% average RMSE reduction rests on a single run per dataset. ELATE is stochastic at multiple levels: the LLM samples responses, features are drawn from the feature_db using probability-weighted random choices, and the evolutionary loop has no fixed seed. The ± intervals in Table 2 appear to be dispersion across walk-forward folds for a fixed feature set; they do not capture run-to-run variance of the feature search itself. The paper reports no repeated runs, no seed sensitivity analysis, and no significance test. I request repeated runs with different seeds (e.g., 5–10), reporting mean ± std over runs, together with a paired comparison (e.g., Wilcoxon signed-rank) across the seven datasets for ELATE vs Base, Zero-Shot, and VEST. Without this, the 8.4% improvement is not statistically established.
  2. [§5, Table 2] tsfresh is listed as a baseline, but it is reported only for the Store dataset; on 6/7 datasets it exceeded the allocated 128GB memory. Consequently, the statement that ELATE 4o+SHAP 'outperforms all baselines' is not actually supported against tsfresh on most datasets. The comparison against tsfresh is part of the paper's core claim and its argument that expand-and-reduce methods are memory-inefficient. I suggest either running tsfresh in a memory-bounded configuration (e.g., restricting extracted features, using a smaller lag set, or processing in chunks) and reporting those results, or explicitly qualifying the claim to the baselines that completed. As written, the 'all baselines' wording overstates the evidence.
  3. [§5, Figure 3] The authors themselves observe that ELATE overfits the validation set for ETTh1 and ILI. Because the SHAP filter and the RMSE-based acceptance step select the final feature set on the penultimate 10% of each dataset, and because no early stopping or alternative validation splits are used, the reported test improvements for those domains may reflect selection to validation noise rather than generalizable feature quality. This is particularly important because the paper does not report the generation count at which test performance is best or use early stopping. I ask for a robustness analysis: report test RMSE at the generation that minimizes validation RMSE, and/or repeat the validation/test split (e.g., rolling-origin evaluation) to show the improvement is not split-specific.
minor comments (6)
  1. [§5, Table 2] The nature of the ± values is not stated. Please clarify whether they are standard deviations across walk-forward folds, standard errors, or something else.
  2. [§4, Algorithm 11] The number of LLM responses per prompt (nresp) is a parameter in Algorithm 11 but is never given in the experiments. This is needed to reproduce cost and runtime numbers. Also state the LLM sampling temperature and any other decoding parameters.
  3. [§4, Algorithm 9] The pseudocode uses 'residuals' in some lines and 'residual' in the constructor (Algorithm 4). Please make variable names consistent.
  4. [Appendix A, Energy] In the Energy dataset description, 'price_actual' is described as 'Actual energy price for that dat in EUR/MWh'; 'dat' should be 'day'.
  5. [§3] The sentence 'As far as we are aware, ELATE is the first method for TS Auto-FE that leverages LLMs' appears twice, with slightly different wording. Please keep only one instance.
  6. [§5, Figure 3] The normalized RMSE plots would be easier to read with a horizontal line at 1.0 (the generation-0 baseline) shown on both the validation and test panels.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: ELATE's main result is a held-out test-set benchmark, with selection guided by validation scores only; no load-bearing self-citation or definitional reduction found.

full rationale

The paper's central claim is an empirical benchmark result: ELATE 4o+SHAP improves RMSE and MAE versus baselines on seven datasets, with the final 10% of each dataset reserved for testing and the penultimate 10% used for validation. Feature generation and selection are guided by validation-period scores (Granger causality, mutual information, SHAP, and validation RMSE), while the reported errors in Table 2 are computed on the held-out test period. This is a genuine out-of-sample evaluation: the test numbers are not equal by construction to the selection scores, and no fitted constant is renamed as a prediction. The paper itself flags validation overfitting for ETTh1 and ILI (Section 5, Figure 3) and lists limitations in Section 6 (e.g., no guarantee that validation RMSE decreases each generation, human-in-the-loop recommended), but these are statistical-validity and generalizability concerns, not circularity. The method borrows its evolutionary sampling idea from Romera-Paredes et al. [45] and uses standard external tools (Granger causality, mutual information, SHAP, XGBoost); there is no load-bearing self-citation chain or imported uniqueness theorem. The ELATE 4o+FRESH ablation reuses its evaluator scores within the feature filter, but this is an alternative pruning configuration and does not affect the main held-out comparison; even there it is a heuristic filter, not a derivation of the result from its inputs. Overall, the derivation chain is self-contained against an external test set, so no circular step is present.

Assumptions & free parameters 10 free parameters · 7 assumptions · 0 invented entities

ELATE is an algorithmic system, not a new physical or formal entity. The free parameters are hand-set hyperparameters and unspecified configuration choices that the evaluation depends on. The axioms are domain assumptions about the transferability of LLM knowledge, the usefulness of the evaluators and SHAP filter, and the validity of a single split and single run.

free parameters (10)
  • T0 = 10
    Initial temperature for feature sampling; chosen by hand with no sensitivity analysis (Section 4).
  • K = 5
    Temperature decay rate for feature sampling (Section 4).
  • epsilon = 0.1
    Temperature floor to avoid division by zero in sampling probabilities (Section 4).
  • Nmax = 100
    Maximum number of features in feature_db before pruning (Section 5).
  • N = 50
    Number of features kept per generation after SHAP pruning (Section 5).
  • G = 10
    Number of evolutionary generations (Section 5).
  • nprompt
    Number of example features included in the prompt; used in the method but value not reported (Section 4).
  • nresp
    Number of LLM responses sampled per prompt; used in Algorithm 11 but value not reported (Appendix C).
  • initial_seed_features = 2 LLM-generated features, code not disclosed
    feature_db is initialized with two LLM-generated features, which are never shown; the optimization path depends on them (Section 4, Algorithm 12).
  • XGBoost_hyperparameters
    The paper uses the same model hyperparameters for every dataset but does not specify them, and all evaluations depend on this choice (Section 5).
assumptions (7)
  • domain assumption LLM domain knowledge from feature names and descriptions transfers into useful, lookahead-free Python feature code.
    The whole ELATE search depends on GPT-4o/GPT-3.5 Turbo generating valid transformations from prompt context (Section 4, Prompt Construction).
  • domain assumption Granger causality and mutual information are reliable guides for evolutionary feature selection.
    These two evaluators drive sampling probabilities; if they are uninformative for a domain, the search degrades (Section 4, Evaluator).
  • domain assumption TreeSHAP interventional importance on the validation set identifies the best subset of features for forecasting.
    The SHAP filter prunes features and selects the best feature set each generation (Section 4, SHAP Filter).
  • domain assumption The penultimate 10% validation split is representative of the final 10% test split for every dataset.
    Feature selection and the RMSE keep/rollback check use validation; the paper observes overfitting on ETTh1 and ILI, showing this assumption can fail (Section 5, Figure 3).
  • domain assumption A single stochastic run of the algorithm is representative of ELATE performance.
    LLM sampling and feature sampling are random, but Table 2 reports one run per dataset with no repeated seeds or significance tests (Section 5).
  • domain assumption XGBoost with fixed hyperparameters is a fair base model for all domains.
    All feature sets are evaluated through this single model; improvements could be model-specific (Section 5).
  • domain assumption The AST allow-list and prompt constraints are sufficient to prevent lookahead leakage and invalid code execution.
    Safety and temporal validity of generated features rely on this parser and prompt rules, not on verification of the resulting time alignment (Section 4, AST Parser and prompt template).

how reviews work

0 comments
Cite this review

Pith. "Pith review of ELATE: Evolutionary Language model for Automated Time-series Engineering." pith.science (2026). https://pith.science/paper/IZNXFH6G

@misc{pith2026250814667,
  author       = {Pith},
  title        = {Pith review of: ELATE: Evolutionary Language model for Automated Time-series Engineering},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/IZNXFH6G}},
  note         = {Machine review of arXiv:2508.14667}
}
read the original abstract

Time-series prediction involves forecasting future values using machine learning models. Feature engineering, whereby existing features are transformed to make new ones, is critical for enhancing model performance, but is often manual and time-intensive. Existing automation attempts rely on exhaustive enumeration, which can be computationally costly and lacks domain-specific insights. We introduce ELATE (Evolutionary Language model for Automated Time-series Engineering), which leverages a language model within an evolutionary framework to automate feature engineering for time-series data. ELATE employs time-series statistical measures and feature importance metrics to guide and prune features, while the language model proposes new, contextually relevant feature transformations. Our experiments demonstrate that ELATE improves forecasting accuracy by an average of 8.4% across various domains.

Figures

Figures reproduced from arXiv: 2508.14667 by the authors.

Figure 1
Figure 1. Figure showing architecture of ELATE. Features are stored in the feature_db. The right loop (1-5) adds new members to the population, while the left loop (6-8) prunes low scoring members at the end of each generation. The process works by maintaining a population of features within the feature_db. The feature_db is initialized using XI . In our experiments, we used two LLM generated features. On each genera￾tion k, … view at source ↗
Figure 2
Figure 2. Prompt template used within ELATE (top) and an example dataset description for the ETTh1 domain (bottom). T0 = 10, K = 5 and ϵ = 0.1 in our experiments. Given the temperature T at any given iteration, we can com￾pute the probability of sampling a feature Xj as: PXj = e (E(Xj ,Y )/T )/ P Xk∈XF e (E(Xk,Y )/T ) , where X F is the set of fea￾tures currently in the feature_db. The lower the temperature, the higher probab… view at source ↗
Figure 3
Figure 3. Figure showing normalized RMSE for both the validation (left) and test (right) sets across each domain, plotted against the generation number. RMSE values are normalized relative to their values prior to feature engineering (generation 0) A large proportion of the runtime of ELATE is spent in the SHAP filter. ELATE is required to compute evaluator scores each time a feature is added, in addition to computing SHAP va… view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: Example feature for the Store (top) and Trading (bottom) datasets. Note: when the code is compiled and executed, only the final feature is returned as a Pandas [40] series. tiplied by trading volume, yields the money flow volume, reflecting the net money movement into …

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

56 extracted references · 46 canonical work pages

  1. [1]

    Data science salaries around the world in 2025

    365 DataScience. Data science salaries around the world in 2025. https://365datascience.com/career-advice/ data-science-salaries-around-the-world, 2025. Accessed: 2025/04/14

    work page 2025

  2. [2]

    Barandas, D

    M. Barandas, D. Folgado, L. Fernandes, et al. TSFEL: Time series feature extraction library. SoftwareX, 11:100456, 2020

    work page 2020

  3. [3]

    Benjamini and D

    Y . Benjamini and D. Yekutieli. The control of the false discovery rate in multiple testing under dependency. Annals of Statistics, pages 1165– 1188, 2001

    work page 2001

  4. [4]

    G. E. Box, G. M. Jenkins, G. C. Reinsel, and G. M. Ljung. Time series analysis: forecasting and control. John Wiley & Sons, 2015

    work page 2015

  5. [5]

    T. B. Brown. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020

    arXiv 2005

  6. [6]

    Bubeck, V

    S. Bubeck, V . Chandrasekaran, R. Eldan, et al. Sparks of artificial general intelligence: Early experiments with GPT-4. arXiv preprint arXiv:2303.12712, 2023

    arXiv 2023

  7. [7]

    Cerqueira, N

    V . Cerqueira, N. Moniz, and C. Soares. Vest: Automatic feature engi- neering for forecasting. Machine Learning, pages 1–23, 2021

    work page 2021

  8. [8]

    H. Chen, J. D. Janizek, S. Lundberg, and S.-I. Lee. True to the model or true to the data? arXiv preprint arXiv:2006.16234, 2020

    arXiv 2006

Show all 56 references
  1. [9]

    Chen and C

    T. Chen and C. Guestrin. XGBoost: A scalable tree boosting system. In International Conference on Knowledge Discovery and Data Mining , pages 785–794, 2016

    2016

  2. [10]

    X. Chen, Q. Lin, C. Luo, et al. Neural feature search: A neural archi- tecture for automated feature engineering. In International Conference on Data Mining, pages 71–80. IEEE, 2019

    2019

  3. [11]

    Y .-W. Chen, Q. Song, and X. Hu. Techniques for automated machine learning. SIGKDD Explorations Newsletter, 22(2):35–50, 2021

    2021

  4. [12]

    Christ, A

    M. Christ, A. W. Kempa-Liehr, and M. Feindt. Distributed and parallel time series feature extraction for industrial big data applications. arXiv preprint arXiv:1610.07717, 2016

    2016 arXiv

  5. [13]

    Christ, N

    M. Christ, N. Braun, J. Neuffer, and A. W. Kempa-Liehr. Time series feature extraction on basis of scalable hypothesis tests (tsfresh–a python package). Neurocomputing, 307:72–77, 2018

    2018

  6. [14]

    M. Chui, J. Manyika, M. Miremadi, et al. Notes from the AI Frontier: Insights from Hundreds of Use Cases, 2018. Discussion Paper

    2018

  7. [15]

    De Brabandere, T

    A. De Brabandere, T. Op De Beéck, K. Hendrickx, W. Meert, and J. Davis. TSFuse: Automated feature construction for multiple time series data. Machine Learning, pages 1–56, 2022

    2022

  8. [16]

    Dor and Y

    O. Dor and Y . Reich. Strengthening learning algorithms by feature dis- covery. Information Sciences, 189:176–190, 2012

    2012

  9. [17]

    B. D. Fulcher. Feature-based time-series analysis. In Feature Engi- neering for Machine Learning and Data Analytics, pages 87–116. CRC press, 2018

    2018

  10. [18]

    B. D. Fulcher and N. S. Jones. HCTSA: A computational framework for automated time-series phenotyping using massive feature extraction. Cell Systems, 5(5):527–531, 2017

    2017

  11. [19]

    S. Galli. Python feature engineering cookbook. Packt Publishing Ltd, 2024

    2024

  12. [20]

    N. Gong, C. K. Reddy, W. Ying, and Y . Fu. Evolutionary Large Lan- guage Model for Automated Feature Transformation. arXiv preprint arXiv:2405.16203, 2024

    2024 arXiv

  13. [21]

    Hollmann, S

    N. Hollmann, S. Müller, and F. Hutter. Large language models for auto- mated data science: Introducing CAAFE for context-aware automated feature engineering. In NeurIPS, pages 44753–44775, 2024

    2024

  14. [22]

    Hooker, D

    S. Hooker, D. Erhan, P.-J. Kindermans, and B. Kim. A benchmark for interpretability methods in deep neural networks. In NeurIPS, pages 9737–9748, 2019

    2019

  15. [23]

    F. Horn, R. Pack, and M. Rieger. The autofeat python library for au- tomated feature engineering and selection. In Machine Learning and Knowledge Discovery in Databases, pages 111–120. Springer, 2020

    2020

  16. [24]

    Hyndman, Y

    R. Hyndman, Y . Kang, P. Montero-Manso, et al. tsfeatures: Time series feature extraction. R package version 1.0, 2019

    2019

  17. [25]

    M. Jin, S. Wang, L. Ma, et al. Time-LLM: Time series forecasting by re- programming large language models.arXiv preprint arXiv:2310.01728, 2023

    2023 arXiv

  18. [26]

    J. M. Kanter and K. Veeramachaneni. Deep feature synthesis: Towards automating data science endeavors. In International Conference on Data Science and Advanced Analytics, pages 1–10. IEEE, 2015

    2015

  19. [27]

    G. Katz, E. C. R. Shin, and D. Song. Explorekit: Automatic feature generation and selection. In International Conference on Data Mining, pages 979–984. IEEE, 2016

    2016

  20. [28]

    A. Kaul, S. Maheshwary, and V . Pudi. Autolearn—automated feature generation and selection. In International Conference on Data Mining, pages 217–226. IEEE, 2017

    2017

  21. [29]

    Khurana, D

    U. Khurana, D. Turaga, H. Samulowitz, and S. Parthasrathy. Cognito: Automated feature engineering for supervised learning. InInternational Conference on Data Mining Workshops, pages 1304–1307. IEEE, 2016

    2016

  22. [30]

    Khurana, H

    U. Khurana, H. Samulowitz, and D. Turaga. Feature engineering for predictive modeling using reinforcement learning. In AAAI, number 1, pages 3407–3414, 2018

    2018

  23. [31]

    H. T. Lam, J.-M. Thiebaut, M. Sinn, et al. One button machine for automating feature engineering in relational databases. arXiv preprint arXiv:1706.00327, 2017

    2017 arXiv

  24. [32]

    L. Li, H. Wang, L. Zha, et al. Learning a Data-Driven Policy Network for Pre-Training Automated Feature Engineering. In ICLR, 2022

    2022

  25. [33]

    Lim and S

    B. Lim and S. Zohren. Time-series forecasting with deep learning: a survey. Philosophical Transactions of the Royal Society A, 379(2194): 20200209, 2021

    2021

  26. [34]

    F. Liu, X. Tong, M. Yuan, et al. Evolution of heuristics: Towards ef- ficient automatic algorithm design using large language model. arXiv preprint arXiv:2401.02051, 2024

    2024 arXiv

  27. [35]

    C. H. Lubba, S. S. Sethi, P. Knaute, et al. CATCH22: CAnonical Time- series CHaracteristics: Selected through highly comparative time-series analysis. Data Mining and Knowledge Discovery , 33(6):1821–1852, 2019

    2019

  28. [36]

    S. M. Lundberg and S.-I. Lee. A unified approach to interpreting model predictions. In NeurIPS, page 4768–4777, 2017

    2017

  29. [37]

    S. M. Lundberg, G. G. Erion, and S.-I. Lee. Consistent individualized feature attribution for tree ensembles.arXiv preprint arXiv:1802.03888, 2018

    2018 arXiv

  30. [38]

    Makridakis, E

    S. Makridakis, E. Spiliotis, and V . Assimakopoulos. The M4 Compe- tition: 100,000 time series and 61 forecasting methods. International Journal of Forecasting, 36(1):54–74, 2020

    2020

  31. [39]

    F. J. Massey Jr. The Kolmogorov-Smirnov test for goodness of fit.Jour- nal of the American Statistical Association, 46(253):68–78, 1951

    1951

  32. [40]

    McKinney et al

    W. McKinney et al. Pandas: a foundational Python library for data anal- ysis and statistics. Python for High Performance and Scientific Comput- ing, 14(9):1–9, 2011

    2011

  33. [41]

    Mudelsee

    M. Mudelsee. Trend analysis of climate time series: A review of meth- ods. Earth-Science Reviews, 190:310–322, 2019

    2019

  34. [42]

    Nargesian, H

    F. Nargesian, H. Samulowitz, U. Khurana, et al. Learning Feature En- gineering for Classification. In IJCAI, pages 2529–2535, 2017

    2017

  35. [43]

    Nguyen, T

    M. Nguyen, T. He, L. An, et al. Predicting Alzheimer’s disease progres- sion using deep recurrent neural networks. NeuroImage, 222:117203, 2020

    2020

  36. [44]

    OpenAI platform pricing

    OpenAI. OpenAI platform pricing. https://platform.openai.com/docs/ pricing, 2025. Accessed: 2025/04/16

    2025

  37. [45]

    Romera-Paredes, M

    B. Romera-Paredes, M. Barekatain, A. Novikov, et al. Mathematical discoveries from program search with large language models. Nature, 625(7995):468–475, 2024

    2024

  38. [46]

    Roondiwala, H

    M. Roondiwala, H. Patel, S. Varma, et al. Predicting stock prices us- ing LSTM. International Journal of Science and Research, 6(4):1754– 1756, 2017

    2017

  39. [47]

    P. K. Sen. Estimates of the regression coefficient based on Kendall’s tau. Journal of the American Statistical Association , 63(324):1379– 1389, 1968

    1968

  40. [48]

    Shojaie and E

    A. Shojaie and E. B. Fox. Granger causality: A review and recent ad- vances. Annual Review of Statistics and its Application, 9(1):289–319, 2022

    2022

  41. [49]

    M. G. Smith and L. Bull. Feature construction and selection using ge- netic programming and a genetic algorithm. In European Conference on Genetic Programming, pages 229–237. Springer, 2003

    2003

  42. [50]

    M. Tan, M. Merrill, V . Gupta, et al. Are language models actually useful for time series forecasting? NeurIPS, 37:60162–60191, 2024

    2024

  43. [51]

    Verdonck, B

    T. Verdonck, B. Baesens, M. Óskarsdóttir, and S. vanden Broucke. Spe- cial issue on feature engineering editorial. Machine Learning, 113(7): 3917–3928, 2024

    2024

  44. [52]

    H. Wu, J. Xu, J. Wang, and M. Long. Autoformer: Decomposition transformers with auto-correlation for long-term series forecasting. In NeurIPS, pages 22419–22430, 2021

    2021

  45. [53]

    Zavota, A

    S. Zavota, A. Palakadan, S. Taherian, and M. Sehmi. Leveraging MLOps on AWS to accelerate data preparation and feature engineering for production. https://aws.amazon.com/blogs/apn/leveraging-mlops- on-aws-to-accelerate-data-preparation-and-feature-engineering-for- production, ...

    2023

  46. [54]

    Zhang, R

    X. Zhang, R. R. Chowdhury, R. K. Gupta, and J. Shang. Large language models for time series: A survey. arXiv preprint arXiv:2402.01801 , 2024

    2024 arXiv

  47. [55]

    H. Zhou, S. Zhang, J. Peng, et al. Informer: Beyond efficient trans- former for long sequence time-series forecasting. In AAAI, number 12, pages 11106–11115, 2021

    2021

  48. [56]

    hour_sin

    G. Zhu, Z. Xu, C. Yuan, and Y . Huang. DIFER: differentiable automated feature engineering. In AutoML, pages 17–1. PMLR, 2022. A Dataset Descriptions ILI The following contains CDC data on outpatient hospital admissions as a result of influenza-like illnesses in the United Sta...

    2022

Pith tools

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