EFE-Time: Evolutionary Time-Series Preprocessing

• EFE-Time is a time-series instantiation of the Evolutionary Feature Engineering framework that uses LLM-guided search to discover invertible normalization programs for structured data.
• It customizes preprocessing by adapting to dataset-specific trends, scales, seasonality, and outliers, thereby enhancing the representation for fixed forecasting models.
• The method demonstrates measurable performance gains across multiple time-series models, with improvements up to 19% in metrics such as MASE, WQL, and MAE.

EFE-Time is the time-series instantiation of Evolutionary Feature Engineering (EFE), a framework that uses LLM-guided evolutionary search to discover preprocessing programs for structured data. In this setting, the searched object is a dataset-specific, invertible normalization program that is fitted on the observed history, applied before forecasting with a fixed time-series foundation model (TSFM), and inverted after prediction. The reported experiments target recent TSFMs such as Chronos-2 and show average improvements of 3.0% in MASE, 3.6% in WQL, and 3.7% in MAE across 10 datasets, with improvements as much as 19% on the COVID-Deaths dataset (Taga et al., 2 Jul 2026).

1. Position within the EFE framework

EFE-Time inherits the general EFE design choice of improving the representation rather than changing the downstream model itself. The framework treats many gains in structured-data prediction as a consequence of better preprocessing, while also taking the position that useful preprocessing is often dataset-specific rather than universal. For time series, this is motivated by the observation that a single normalization rule cannot handle all series equally well: some series require robust scaling, others detrending, seasonal adjustment, variance stabilization, or changepoint-aware normalization. The paper presents EFE-Time as an alternative to fixed transforms such as RevIN and arcsinh-style scaling, which are useful but inherently limited because they are not tailored to each dataset’s trend, scale, outliers, and seasonality (Taga et al., 2 Jul 2026).

Operationally, EFE-Time inserts a learned preprocessing module into an otherwise fixed forecasting pipeline. The transform is fitted on the observed history, the history is mapped into transformed space, forecasting is performed by the TSFM in that transformed space, and the resulting forecast is returned to original units by an inverse transform. The requirement that the learned program be approximately invertible is therefore structural rather than cosmetic: the model is evaluated on the original scale, and the preprocessing program is expected to preserve the semantic meaning of the forecast while making the input representation easier for the TSFM to extrapolate (Taga et al., 2 Jul 2026).

2. Forecasting formulation and optimization target

The formal setup is multiseries forecasting over a dataset

$\mathcal{D}=\{y^{(i)}_{1:T_i}\}_{i=1}^M.$

A validation instance is a rolling forecast window $j=(i,t)$ with

$$D^{\mathrm{fit}}_j = y^{(i)}_{1:t}, \qquad D^{\mathrm{in}}_j = (y^{(i)}_{1:t}, H), \qquad Y_j = y^{(i)}_{t+1:t+H}.$$

For a candidate program $p$, the fit/transform/postprocess pipeline is written as

$$\sigma_{j,p} = \mathrm{fit}_p(D^{\mathrm{fit}}_j;c),$$

$$\widetilde D_{j,p} = \mathrm{transform}_p(D^{\mathrm{in}}_j;\sigma_{j,p}),$$

$$\widehat Y_{j,p} = \mathrm{post}_p\!\left(\mathcal{B}_j(\widetilde D_{j,p});\sigma_{j,p}\right),$$

where for EFE-Time,

$$\mathrm{post}_p \equiv \mathrm{inverse\_transform}_p.$$

Candidate quality is measured by the validation average

$$\widehat L(p)=\frac{1}{K}\sum_{j=1}^K \ell(Y_j,\widehat Y_{j,p}).$$

The paper states that EFE-Time uses MASE as the selection loss and scores programs by improvement relative to the identity transformation, with an additional runtime penalty and a hard validity requirement that only invertible programs are admissible (Taga et al., 2 Jul 2026).

This formulation makes EFE-Time a search procedure over preprocessing programs rather than over forecasting-model parameters. The baseline forecaster remains fixed during evolution, so the optimization target is explicitly the quality of the transformed forecasting problem. A plausible implication is that EFE-Time measures whether a representation makes a pretrained TSFM more effective without altering its internal weights.

3. Program representation and admissibility constraints

An EFE-Time candidate is represented as a Python program with the standardized interface fit, transform, and inverse_transform. The transform is stateful: fit computes parameters from the observed history, transform maps the history into transformed space, and inverse_transform maps forecasts back. The returned state must include hist_len, because inverse transforms must operate on forecast-horizon arrays and may need alignment with seasonal phase or time-varying operations (Taga et al., 2 Jul 2026).

The fit method receives a compact metadata dictionary that includes prediction length, seasonal period, history length, number of valid observations, mean, standard deviation, median, minimum, maximum, range, positive fraction, zero fraction, skewness, coefficient of variation, trend strength, recent mean, and recent standard deviation. The paper emphasizes that the program must be executable, deterministic, and leakage-free, and that it must preserve the series structure needed by the downstream forecasting model (Taga et al., 2 Jul 2026).

The admissible search space is deliberately narrow. EFE-Time programs must be invertible or approximately invertible, length-preserving, order-preserving, NaN-preserving, and numerically stable. They must not collapse nonconstant series to constants, must not introduce new NaNs or infinities, and must be able to invert forecasts of arbitrary horizon length. This constrained design distinguishes EFE-Time from unrestricted symbolic transformation search: the goal is not arbitrary feature synthesis, but a transformation that can be safely embedded into a forecasting pipeline (Taga et al., 2 Jul 2026).

4. Evolutionary search procedure

EFE-Time uses the general EFE evolutionary loop. Search starts from the identity program, after which an LLM proposes refinements using dataset context, summary statistics, and downstream performance feedback on a validation set. The optimization history is written as

$\mathcal{H}_t=\{(p_i,s_i,a_i)\}_{i=1}^{t},$

with proposal, evaluation, and update steps

$j=(i,t)$0

$j=(i,t)$1

$j=(i,t)$2

and the final returned program

$j=(i,t)$3

This means that EFE-Time is not a one-shot code-generation system; it is an iterative evolutionary optimizer in which candidate programs are scored, critiqued, and reused as material for subsequent proposals (Taga et al., 2 Jul 2026).

The information exposed to the LLM is tightly controlled. Dataset context is computed once per dataset from the training split and includes metadata such as frequency, prediction length, seasonal period, number of evaluation series, and aggregate series statistics. Each iteration also provides an evaluation_summary containing baseline and candidate metrics, metric ratios, error counts, timing, and the fraction of series helped or harmed. By contrast, the prompt explicitly does not include raw time series values, future targets, per-series errors, baseline forecasts, sampled evaluation subsets, or test-set information. In the main experiments, the protocol uses 3 islands, exploitation ratio 0.70, exploration ratio 0.10, elite selection ratio 0.20, a code-diversity axis with 8 bins, Claude Opus-4.6 as the LLM backbone, 100 iterations, and 3 random seeds (Taga et al., 2 Jul 2026).

5. Empirical performance and cross-model transfer

EFE-Time is evaluated on 10 GIFT-Eval datasets: CovidDeaths, SolarHourly, M4Yearly, JenaWeather (H), SZ_TAXI_15T, bitbrains_storage/H, bitbrains_rnd/H, us_births_D, kdd_cup_2018_H, and restaurant. The main downstream model used during search is Chronos-2, and transfer experiments reuse the learned transform with TimesFM-2.5, Moirai-2-Small, and Reverso-Nano. The primary baseline is the identity transformation, i.e., raw-input forecasting without learned preprocessing (Taga et al., 2 Jul 2026).

For Chronos-2, the paper reports mean improvements over the 10 datasets of 3.0% average MASE improvement, 3.6% average WQL improvement, and 3.7% average MAE improvement. The strongest single-dataset gains occur on CovidDeaths, SolarHourly, and M4Yearly, with improvements as high as 19% on some metrics. On CovidDeaths, the reported Chronos-2 numbers are baseline MASE 35.444, EFE-Time MASE 31.853, yielding 10.1% improvement, together with 19.5% improvement in WQL and 17.2% improvement in MAE. The paper also notes that some datasets, including SZ_TAXI_15T, bitbrains_storage/H, and restaurant, show essentially near-zero change, while bitbrains_rnd/H, us_births_D, and kdd_cup_2018_H show small positive gains (Taga et al., 2 Jul 2026).

The learned normalizations transfer to other TSFMs without re-evolution. The reported average MASE improvements over all 10 datasets are 3.06% for TimesFM-2.5, 2.25% for Moirai-2-Small, and 2.42% for Reverso-Nano. On the three highlighted datasets—CovidDeaths, M4Yearly, and SolarHourly—the paper reports average MASE improvement greater than 6% across all TSFMs, reaching about 7% for TimesFM. The study also compares EFE-Time with fine-tuning and reports that EFE-Time + fine-tuning gives the best results overall, with the combination described as additive (Taga et al., 2 Jul 2026).

6. Learned transform families, interpretation, and limitations

The transformation families discovered by EFE-Time include robust scaling, variance stabilizations, history-only detrending, seasonal adjustment, and changepoint-aware rescaling. One example described in the paper fits a recent median $j=(i,t)$4 and robust scale $j=(i,t)$5, applies the affine transform $j=(i,t)$6, performs forecasting in normalized space, and then inverts through $j=(i,t)$7. The appendix’s worked example on Covid-Deaths describes the discovered program as a robust affine normalization that becomes the core of the final lineage and is later refined by branching for short or constant series, winsorisation, and numerical guards (Taga et al., 2 Jul 2026).

The paper’s interpretation is representational rather than architectural. On a synthetic exponential-growth benchmark, Chronos-2, TimesFM-2.5, and Moirai struggle in raw space, whereas EFE-Time learns a transform that makes the sequence approximately stationary and the forecasts markedly better after inverse transformation. The qualitative reading of the real-data experiments is similar: on CovidDeaths, the learned transform often makes the input look closer to a smooth periodic signal; on SolarHourly, it regularizes the diurnal cycle into a smoother periodic shape; on M4Yearly, the effect is more like per-series scale and trend correction. By contrast, for restaurant and some bitbrains settings, the search tends to stay close to identity because important drivers are exogenous and not encoded in the history window. This suggests that EFE-Time is most effective when errors are driven by scale, multiplicative growth, trend nonstationarity, or periodic structure rather than by missing external covariates (Taga et al., 2 Jul 2026).

The paper also identifies several limitations. Performance is strongest with frontier LLMs; smaller Qwen3.5 models can sometimes find useful transforms, but the behavior is less stable and does not scale monotonically with model size. The evolutionary process uses fixed hyperparameters such as the exploration–exploitation ratio and the number of islands. The authors state that the quality and structure of feedback strongly influence evolution, and that ablations on which feedback components matter most remain future work. They also note the practical cost of iterative LLM calls and repeated validation, and they emphasize that some series cannot be helped by input-only transforms when future behavior depends on exogenous variables not visible in the historical window. At the same time, the broader-impact discussion presents EFE-Time as relatively less risky than unrestricted feature generation because it learns invertible normalizations expressed as explicit Python code, which preserves interpretability and helps retain the semantic meaning of forecasts (Taga et al., 2 Jul 2026).