🤖 machine learning

RocketPFN: Accurate Time Series Classification via In-Context Learning

RocketPFN is a training-free time series classification pipeline that combines random convolutional feature extraction with a pretrained tabular foundation model (TabPFN), achieving state-of-the-art accuracy on UCR and UEA benchmarks while significantly outperforming existing foundation models without requiring any target data training.

Original authors: Franco Martino O'Rourke, Ana Trisovic, Dimitris Bertsimas

Published 2026-06-23

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Franco Martino O'Rourke, Ana Trisovic, Dimitris Bertsimas

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a massive library of time-based stories—like heartbeats, stock market trends, or earthquake vibrations. Your job is to read a new story and instantly guess what kind of event it is. This is called Time Series Classification.

For years, the "gold standard" for doing this has been a super-complex, heavy-duty machine learning team called HC2. Think of HC2 as a squad of four different expert detectives, each using a different specialized tool (like shape detectors, dictionary lookups, or interval analyzers). They work together to solve the case. They are incredibly accurate, but they are slow and expensive. It takes them hours or even days to "study" a new dataset before they can make a guess.

Then, there's a newer, flashier approach called Foundation Models (like MOMENT or Mantis). These are like "super-learners" that have read millions of books beforehand. The idea is that they already know the language of time, so they should be able to solve new cases instantly without studying the specific dataset.

Enter RocketPFN.

The authors of this paper built a new pipeline called RocketPFN. They asked a simple question: Can we build a system that is as accurate as the slow, expensive detective squad (HC2) and smarter than the flash-in-the-pan super-learners, but does it without any training at all?

Here is how they did it, using two simple ingredients:

1. The "Random Noise" Scanner (Rocket)

Imagine you have a long, messy string of data. Instead of trying to understand the deep meaning of every single number, RocketPFN uses a "random noise scanner."

The Analogy: Think of this like throwing thousands of random nets into a river to catch fish. You don't design the nets to catch specific fish; you just throw them randomly.
The Magic: Even though the nets are random, if you throw enough of them (10,000 of them!), they catch a surprisingly good mix of patterns. Some nets catch the "peaks" (the highest points), and others catch the "frequency" (how often something happens).
The Result: This turns a complex time story into a simple list of numbers (features) that describes the story's shape, without needing to learn anything first.

2. The "Instant Expert" (TabPFN)

Once the random scanner turns the time story into a list of numbers, they pass it to TabPFN.

The Analogy: Imagine a genius student who has memorized the answers to millions of different math problems. When you give them a new problem, they don't need to study or take a test. They just look at the problem and the examples you give them right now, and they instantly say, "Based on what I've seen before, this looks like a 'Type A' problem."
The Magic: This student (TabPFN) is trained on synthetic data, not real time-series data. It uses "In-Context Learning," meaning it figures out the rules on the fly just by looking at your specific examples. It doesn't need to "train" on your data.

The Big Experiment

The authors combined these two: Random Scanner + Instant Expert.

Here is what they found:

Beating the Heavyweights: On 92 standard datasets, RocketPFN achieved the exact same accuracy as the slow, expensive HC2 detective squad (90% accuracy).
- The Catch: HC2 takes hours to train. RocketPFN takes about 30 seconds to run. It's like beating a marathon runner who spent years training by simply sprinting past them because you didn't need to train at all.
Beating the "Super-Learners": They also tested the "Super-Learner" foundation models (MOMENT, Mantis). Even though these models had been pre-trained on massive amounts of data (including the very datasets RocketPFN was tested on), RocketPFN still beat them.
- The Twist: RocketPFN did this using fewer features (simpler data) than the super-learners. It's like winning a chess game against a grandmaster who studied for 20 years, using only 3 moves instead of their 20.
The "Flattened" Failure: They tried feeding the raw time data directly to the Instant Expert without the Random Scanner. It failed miserably (like guessing 50/50).
- The Lesson: The "Random Scanner" is essential. It translates the time-based story into a format the Instant Expert can actually understand. Without it, the expert is blind.

The Bottom Line

The paper concludes that you don't always need a massive, expensive, pre-trained "brain" to understand time series data.

Sometimes, a simple, random filter combined with a smart, pre-trained classifier that learns on the fly is enough to beat the state-of-the-art. It suggests that the "magic" of complex foundation models might be overhyped for this specific task, and that a much simpler, training-free approach is actually the new benchmark to beat.

In short: You don't need to build a super-computer to solve these puzzles. Sometimes, a random net and a quick-witted genius are all you need.

Technical Summary: RocketPFN

Problem Statement

Time series classification (TSC) remains a fundamental challenge across scientific and engineering domains, ranging from seizure detection to industrial fault diagnosis. While the HIVE-COTE 2.0 (HC2) ensemble currently holds the state-of-the-art (SOTA) position on the UCR and UEA archives, it incurs a steep computational cost, requiring hours to days of training per dataset. Conversely, recent TSC foundation models (e.g., MOMENT, Mantis) invest heavily in pretraining to learn low-dimensional temporal embeddings, yet they have not yet surpassed HC2 or the efficient random-kernel family (Rocket) when used as zero-shot feature extractors.

The central question addressed is whether a training-free pipeline—combining random convolutional feature extraction with in-context classification via a pretrained tabular foundation model—can match the accuracy of the most complex, training-intensive ensembles without fitting any parameters to the target data.

Methodology: RocketPFN

RocketPFN is a two-stage, training-free pipeline designed to bridge the gap between random feature extraction and powerful in-context learning.

Random Convolutional Feature Extraction (Rocket):
- Input time series are first z-normalized.
- Instead of using the standard 10,000 kernels (producing 20,000 features) which exceeds the input capacity of the downstream classifier, the method generates $G$ independent groups of $k=1,000$ random convolutional kernels.
- Each kernel produces two summary statistics: the global maximum and the proportion of positive values (PPV).
- This results in $G$ feature matrices, each with $2,000$ features, aligning with the input constraints of TabPFN v2.5.
In-Context Classification (TabPFN v2.5):
- Each feature matrix is passed to TabPFN v2.5, a Prior-data Fitted Network pretrained on millions of synthetic tabular datasets.
- TabPFN performs classification via in-context learning: it receives the labeled training set and unlabeled test points as context and predicts class probabilities in a single forward pass without gradient updates.
- The final prediction is an average of the probability estimates across the $G$ groups.

Design Rationale: The pipeline addresses a dimensionality mismatch (Rocket's 20,000 features vs. TabPFN's 2,000 feature limit) by ensembling multiple smaller groups rather than truncating features. This preserves the diversity of the random projections while leveraging TabPFN's ability to learn non-linear decision boundaries, unlike the ridge regression typically used with Rocket.

Key Contributions

The paper presents four primary contributions:

SOTA Accuracy without Training: RocketPFN ( $G=10$ ) achieves a mean accuracy of 0.900 on 92 UCR datasets, statistically matching HC2 (Wilcoxon $p=0.50$ ) and significantly outperforming every individual classifier within the HC2 ensemble. It requires no parameter fitting on target data.
Superiority of In-Context Learning: Replacing the standard ridge regression classifier with TabPFN on the same random convolutional features yields a significant accuracy gain (+0.018), demonstrating that in-context learning extracts more discriminative information than linear models in this regime.
Necessity of Temporal Encoding: The paper demonstrates that applying TabPFN directly to flattened time series fails on trivially solvable tasks (e.g., ShapeletSim), achieving near-random accuracy. The convolutional feature extraction step is essential to restore temporal inductive bias.
Benchmark for Foundation Models: RocketPFN significantly outperforms zero-shot TSC foundation models (MOMENT, Mantis, MantisV2) when paired with the same downstream classifier. This holds even when the foundation models were pretrained on corpora including the UCR training splits, and even when RocketPFN is restricted to fewer features (200) than the foundation models' embedding dimensions.

Experimental Results

UCR Archive (92 datasets): RocketPFN ( $G=10$ ) matches HC2 in mean accuracy (0.900). It significantly outperforms HC2's components (Arsenal, DrCIF, TDE, STC) and other SOTA methods like InceptionTime and TS-CHIEF ( $p < 0.005$ ). Even with a reduced budget ( $G=1$ , 1,000 kernels), RocketPFN significantly outperforms all HC2 components.
UEA Archive (20 datasets): RocketPFN ( $G=10$ ) achieves a mean accuracy of 0.747, statistically indistinguishable from HC2 (0.747, $p=0.37$ ), though the small dataset size limits statistical power.
Foundation Model Comparison: On 103 UCR datasets, RocketPFN ( $G=1, k=100$ ) significantly outperforms MOMENT, Mantis, and MantisV2 (all paired with TabPFN) with $p < 0.001$ . This result persists despite the foundation models having larger embedding dimensions (256–1,024) compared to RocketPFN's 200 features.
Efficiency: The pipeline is training-free. On a GPU, the median inference time is 30 seconds per fold for $G=10$ and 3.7 seconds for $G=1$ .

Significance and Claims

The authors propose RocketPFN as a reference point for evaluating zero-shot TSC foundation models. The paper argues that the high pretraining costs and design complexity required to learn low-dimensional temporal embeddings must be justified by concrete conditions where those embeddings outperform this training-free baseline.

The results suggest that the bar for zero-shot temporal representation learning is higher than current foundation models suggest. The paper posits that tabular pre-fitted networks (like TabPFN) may serve as a general backbone for classification problems beyond structured tabular data, provided suitable feature extractors (like random convolutions) bridge the gap between the source modality and the tabular interface.

Limitations: The approach is currently limited by TabPFN v2.5's support for up to 10 classes, excluding 25 UCR and 7 UEA datasets. Additionally, the UEA benchmark results are considered inconclusive due to the small number of datasets (20), though the mean accuracy remains competitive. Timing comparisons are structural (inference-only vs. training-heavy) rather than a controlled hardware benchmark.