[Paper] EvoTSC: Evolving Feature Learning Models for Time Series Classification via Genetic Programming

Source: arXiv - 2604.25499v1

Overview

The paper introduces EvoTSC, a genetic‑programming framework that automatically designs compact, high‑performing feature‑learning pipelines for univariate time‑series classification. By embedding domain knowledge and using a Pareto‑based selection, EvoTSC tackles two pain points that developers often face: limited labeled data and the need for heavyweight models.

Key Contributions

• Multi‑layer GP representation that fuses expert‑crafted time‑series operators (e.g., shapelets, Fourier transforms) into evolvable programs.
• Pareto tournament selection that rewards models with stable accuracy across multiple training‑subset splits, directly combating over‑fitting.
• Lightweight evolved models that require far fewer parameters and less inference time than typical deep‑learning baselines.
• Comprehensive empirical evaluation on 85 univariate UCR/UEA datasets, showing statistically significant gains over 11 state‑of‑the‑art classifiers.
• Ablation study confirming the importance of each design element (knowledge injection, multi‑layer structure, selection strategy).

Methodology

1. Program Encoding – Each individual in the GP population is a three‑stage pipeline:

   • Pre‑processing (e.g., smoothing, differencing)
   • Feature extraction (shapelet transforms, autocorrelation, spectral coefficients)
   • Classifier (linear models, decision trees).
     The layers are linked by a small set of typed functions, allowing the evolutionary engine to recombine and mutate them while preserving syntactic validity.

2. Knowledge‑Guided Search – The authors curated a toolbox of operators that have historically performed well on time‑series data. By biasing the initial population and mutation probabilities toward these operators, the GP search space is dramatically narrowed to promising regions.

3. Pareto Tournament Selection – Instead of evaluating a model on a single train‑test split, EvoTSC measures performance on k different random subsamples of the training set. Individuals are ranked by a Pareto front that balances (i) mean accuracy and (ii) variance across subsamples. This encourages solutions that are robust to data scarcity.

4. Evolutionary Loop – Standard GP operators (crossover, subtree mutation, hoist mutation) are applied for a fixed number of generations (typically 50–100). The best individual on the Pareto front is returned as the final classifier.

The whole pipeline runs on a single CPU core, making it feasible for teams without GPU clusters.

Results & Findings

• EvoTSC outperformed all 11 competitors on 62 of the 85 datasets (p < 0.01, Wilcoxon signed‑rank test).
• Ablation experiments showed that removing the Pareto selection dropped average accuracy by ~3 %, while stripping out expert operators caused a ~5 % drop.
• Memory footprint and CPU usage were an order of magnitude lower than typical convolutional nets, confirming the claim of “resource‑efficient” models.

Practical Implications

• Rapid prototyping – Developers can feed raw sensor streams into EvoTSC and obtain a ready‑to‑deploy classifier without hand‑crafting features or tuning deep nets.
• Edge deployment – The tiny model size and low inference latency make EvoTSC ideal for IoT devices, wearables, or embedded controllers where power and compute are scarce.
• Data‑efficient learning – The Pareto selection explicitly favors models that generalize from few labeled examples, useful in domains like predictive maintenance or medical monitoring where annotation is costly.
• Explainability – Because the evolved pipelines consist of interpretable transformations (e.g., specific shapelet filters), engineers can trace which temporal patterns drive decisions, aiding compliance and debugging.

Limitations & Future Work

• Univariate focus – The current implementation handles only single‑channel series; extending to multivariate data (common in industrial IoT) will require richer operator sets.
• Scalability of search – While CPU‑friendly, the GP process can still take several hours on large datasets; hybridizing with surrogate models or parallel GP could speed this up.
• Operator library bias – The performance gains rely on the curated set of expert operators; discovering novel primitives automatically remains an open challenge.

The authors suggest exploring co‑evolution of feature operators and classifiers, and integrating reinforcement‑learning‑based reward shaping to further improve robustness on noisy, real‑world streams.

Authors

• Xuanhao Yang
• Bing Xue
• Mengjie Zhang

Paper Information

• arXiv ID: 2604.25499v1
• Categories: cs.LG, cs.NE
• Published: April 28, 2026
• PDF: Download PDF