🤖 AI

Reverso: Efficient Time Series Foundation Models for Zero-shot Forecasting

This paper introduces Reverso, a family of highly efficient zero-shot time series foundation models that leverage small hybrid architectures combining long convolutions and linear RNN layers to match the performance of much larger transformer-based models while reducing parameter counts by over two orders of magnitude.

Original authors: Xinghong Fu, Yanhong Li, Georgios Papaioannou, Yoon Kim

Published 2026-07-28

📖 9 min read🧠 Deep dive

CC BY 4.0

Original authors: Xinghong Fu, Yanhong Li, Georgios Papaioannou, Yoon Kim

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 are trying to predict the future, but instead of guessing the weather or the stock market, you are looking at a long, winding line of numbers that change over time. This is called time series forecasting. For decades, scientists have used math tricks and simple computer programs to guess what comes next in these lines. But recently, a new kind of super-smart computer brain called a foundation model has arrived. Think of these models like a master chef who has tasted every dish in the world. Instead of learning to cook just one recipe (like predicting electricity usage), they learn the "language" of all recipes at once. This allows them to guess the future of any new dish they've never seen before, just by looking at a few ingredients. This is called zero-shot forecasting. However, there's a catch: to become this master chef, these models usually need to be gigantic, requiring massive computers and huge amounts of electricity to run. They are like a giant, fuel-hungry truck that can carry a lot of cargo but is impossible to drive into a small city street.

This paper introduces Reverso, a new family of time series models that asks a simple question: Do we really need a giant truck to deliver the package, or can we build a sleek, efficient motorcycle that goes just as fast? The authors, a team of researchers, argue that the current obsession with making models bigger and bigger might be missing the point. They suggest that the secret to a great time series model isn't just raw size, but how cleverly the model looks at the data. They built Reverso to be tiny—some versions have only a few hundred thousand parameters (the model's "brain cells")—yet they perform just as well as the massive, billion-parameter giants. The paper suggests that by using a few smart tricks, we can make these models small enough to run on everyday devices, like a laptop or even a phone, without losing their ability to predict the future accurately.

The Problem with Giant Models

In the world of artificial intelligence, there's a popular idea that "bigger is better." If you want a model to be smart, you just give it more data and more brain cells. This has worked wonders for language and vision, leading to massive models that can write essays or recognize cats. But for time series, this approach has created models that are hundreds of millions of brain cells big. While they are good at predicting the future, they are a pain to use. They are too heavy to run on small devices, too expensive to train, and too slow to use in real-time situations. It's like trying to use a steamroller to fix a bicycle tire; it works, but it's wildly inefficient.

The authors of this paper decided to try a different path. Instead of just making the model bigger, they asked: How can we make the model smarter about how it looks at the data? They wanted to build a model that is "parameter-efficient," meaning it gets the most bang for its buck. They didn't just want a small model; they wanted a small model that could still compete with the giants.

The Reverso Recipe: Three Magic Tricks

To build Reverso, the authors cooked up a simple recipe with three main ingredients. Think of it like preparing a meal where you don't just throw everything into a pot; you prepare it in a way that brings out the best flavors.

1. The "Zoom Lens" Strategy (Multi-scale Input)
Imagine you are looking at a long road. If you only look at it from very close up, you see the cracks in the pavement. If you look from very far away, you see the whole highway but miss the details. Most models try to look at the road from just one distance. Reverso, however, uses a "zoom lens." It takes the same time series data and looks at it through four different lenses at once:

One lens sees the data as it is (high detail).
One lens skips every other point (medium detail).
One lens skips every three points (low detail).
One lens skips even more (very low detail).

By feeding the model these four different "views" of the same data simultaneously, the model can learn patterns that happen quickly (like a sudden spike) and patterns that happen slowly (like a seasonal trend) all at the same time. This is like having a team of four detectives, each looking at the crime scene from a different angle, and then combining their notes. This trick allows the model to understand long-term patterns without needing to remember a massive amount of data at once.

2. The "Hybrid Engine" (Sequence Mixing)
Once the model has its data, it needs to process it. Most models use a method called "attention," which is like a spotlight that scans the whole history of the data to find what's important. It's powerful but slow and heavy. Reverso uses a hybrid engine that switches between two different types of processing:

Long Convolutions: These are like a sliding window that scans the data to find repeating patterns, similar to how a rhythm section in a band keeps the beat.
DeltaNet Layers: These are a type of "linear recurrent" layer. Think of them as a memory bank that updates itself constantly, remembering the most important things without needing to re-read the entire history.

The authors found that mixing these two together—using the "sliding window" for some parts and the "memory bank" for others—was the sweet spot. It was faster and lighter than using just the heavy spotlight (attention) or just the memory bank. It's like driving a car that has both a turbocharger for speed and a hybrid battery for efficiency.

3. The "Smart Decoder" (Attention Head)
Finally, after the model has processed the data, it needs to make a prediction. Reverso uses a special "decoder" at the end that uses a lightweight form of attention. This is the part that actually says, "Based on everything I've seen, here is what I think will happen next." The authors found that this specific type of decoder was much better at making accurate predictions than a simple, blunt calculation.

The Results: Small but Mighty

The team trained three versions of Reverso: a tiny one (200,000 parameters), a small one (550,000 parameters), and a standard one (2.6 million parameters). They then tested these models against the biggest, heaviest models in the world, some of which have over a billion parameters.

The results were surprising. On the Gift-Eval benchmark (a giant test of forecasting skills across many different types of data), the standard Reverso model achieved a score of 0.706. This is incredibly competitive. It performed just as well as models that are 100 to 1,000 times larger.

It beat models like FlowState (2.6M parameters) and Tiny-Time Mixers (1M parameters).
It came very close to giants like TimesFM-2.5 (200M parameters) and Xihe-Max (1.5B parameters).

But the real magic wasn't just the accuracy; it was the speed and memory usage. Because Reverso is so small, it runs much faster and uses far less memory. The authors measured the "inference latency" (how long it takes to make a prediction) and found that Reverso was significantly faster than the massive models. It's like comparing a sports car to a freight train: the train can carry a lot, but the sports car gets you to the destination much quicker and uses less fuel.

What Reverso Can (and Can't) Do

The paper shows that Reverso is excellent at zero-shot forecasting (predicting the future without prior training on that specific data), classification (sorting data into categories), and anomaly detection (spotting weird, unexpected events). For example, in tests to find anomalies, Reverso detected more strange events than other models, even when the threshold for "strange" was very strict.

However, the authors are honest about the limits.

It's mostly for single lines of data: Reverso is currently trained as a "univariate" model, meaning it looks at one line of numbers at a time. It doesn't yet handle multiple lines of data that depend on each other (multivariate) as well as some of the giant models that use complex attention mechanisms.
Short sequences are tricky: While Reverso is amazing at long-term predictions, it sometimes lags behind the giant models when the data is very short.
It predicts numbers, not probabilities: Reverso gives a single best guess (a point prediction). It doesn't naturally tell you how confident it is (like "I'm 90% sure it will rain"). The authors suggest that you could add this feature later, but it's not built-in yet.

Why This Matters

The main lesson from Reverso is that size isn't everything. The paper suggests that for many real-world tasks, the bottleneck isn't how big the model is, but how well it is designed. By using a clever mix of multi-scale inputs and hybrid processing, you can build a model that is small enough to run on a laptop or a phone but smart enough to compete with the supercomputers.

This is a big deal because it means we might not need to keep building bigger and bigger models that require massive data centers. Instead, we can build efficient, compact models that can be deployed anywhere—on your smartwatch, in a self-driving car, or in a remote weather station. The authors conclude that careful design can shift the "performance-efficiency frontier," making powerful AI accessible to everyone, not just those with unlimited computing power.

In short, Reverso proves that you don't need to be a giant to see the future clearly; you just need to know how to look at it from the right angles.

Technical Summary: Reverso: Efficient Time Series Foundation Models for Zero-shot Forecasting

1. Problem Statement

Time series forecasting is a fundamental machine learning task with applications ranging from weather prediction to supply chain logistics. While recent advancements in foundation models (TSFMs) have demonstrated promising zero-shot capabilities across diverse domains, the prevailing trend has been to scale model size and dataset volume to improve performance. This approach has led to TSFMs with hundreds of millions of parameters (e.g., 1.5B parameters), which are computationally expensive to train and prohibitively difficult to deploy in memory-constrained environments such as edge devices.

The paper addresses the challenge of developing parameter-efficient time series foundation models that maintain competitive zero-shot performance without relying on massive scaling. The authors posit that for many workloads, the limiting factor is not merely model scale, but how effectively model capacity is allocated to the specific structure of time-series data.

2. Methodology

The authors propose Reverso, a family of parameter-efficient TSFMs (ranging from 0.2M to 2.6M parameters) built on a simple, three-component architecture combined with a specific training and inference recipe.

2.1. Architecture

The Reverso architecture (Figure 1) consists of:

Multi-scale Input Strategy: Instead of feeding a single raw sequence, the model constructs a multi-scale input $t \in \mathbb{R}^{L \times C}$ . For a sequence of length $L$ , the model creates $C$ channels (where $C=4$ in practice) by taking the most recent data points and downsampling them by strides of $1, 2, \dots, 2^{C-1}$ . This allows the model to condition on longer contexts (effective context length of 16,384) without increasing the input sequence length $L$ (set to 2048), providing an inductive bias for multi-scale temporal patterns.
Hybrid Sequence-Mixing Layers: The core of the model alternates between two types of layers to mix information across the sequence dimension:
- Long Convolutions: Utilizing depthwise separable convolutions with a kernel size equal to the sequence length ( $k=L$ ), implemented via FFT for efficiency ( $O(dL \log L)$ ).
- DeltaNet Layers: A modern linear RNN variant that learns state transitions using query, key, and value vectors. To capture bidirectional context, the authors employ a "state-weaving" strategy where the last time step of the previous layer is added to the first hidden state of the current layer.
- These sequence mixing layers are followed by standard MLP channel-mixing layers (dimension expansion factor of 4 with ReLU).
Attention-Based Decoder Head: Unlike simple linear projection heads, Reverso uses an attention-based decoder. It transforms the final hidden states into query vectors, which attend over keys and values derived from the same states, before projecting to the final prediction output.

2.2. Training and Inference Recipe

Pretraining: The models are pretrained on the Gift-Eval dataset (approx. 4.5M time series, 230B points), which includes real-world data (weather, traffic, energy) and synthetic data generated via Gaussian Processes (KernelSynth), spike processes, and TSI (Trend, Seasonality, Irregularity) patterns.
Data Augmentation: The training pipeline incorporates a specific sequence of augmentations: downsampling, amplitude modulation, sign flips (y-axis), temporal reversals (x-axis), censoring, and Mixup.
Normalization: Inputs are normalized to $[0, 1]$ via min-max scaling, which the authors found superior to z-score normalization.
Inference Strategies:
- Inference-time Downsampling: If the input seasonality exceeds the context length, the model dynamically downsamples the input using FFT-based peak detection to ensure full periods fit within the context window.
- Flip Equivariance: To reduce error, the model averages predictions from the original input and its temporally reversed version.

3. Key Contributions

Parameter-Efficient Architecture: Introduction of a hybrid architecture combining long convolutions and DeltaNet layers with a multi-scale input strategy, achieving strong performance with only 2.6M parameters.
Performance-Efficiency Frontier: Demonstration that Reverso pushes the Pareto frontier, achieving competitive zero-shot forecasting, classification, and anomaly detection results while using orders of magnitude fewer parameters and less memory than state-of-the-art TSFMs (e.g., Chronos-2, TimesFM-2.5, Xihe).
Comprehensive Evaluation: Extensive benchmarking across zero-shot forecasting (Gift-Eval, LTSF), classification (UCR, UEA), anomaly detection, and imputation tasks.
Mechanistic Insights: Ablation studies and visualization reveal that the hybrid architecture allows convolutional filters to learn position-specific information while DeltaNet layers capture periodic information, with the multi-scale input significantly aiding long-horizon forecasting.

4. Experimental Results

Zero-Shot Forecasting (Gift-Eval): Reverso (2.6M params) achieved a MASE of 0.706, outperforming similarly sized models like Super-Linear (2.5M, MASE 0.857) and FlowState (2.6M, MASE 0.735). It also approached the performance of much larger models like Xihe-Max (1.5B params, MASE 0.701) and TimesFM-2.5 (200M params, MASE 0.700).
Long Sequence Forecasting (LTSF): On the LTSF benchmark (ETT, Electricity, Weather), Reverso outperformed Sundial (444M params) and Super-Linear (2.6M params) with significantly lower parameter counts.
Efficiency: Reverso variants demonstrated lower inference latency and peak memory usage compared to larger TSFMs on a single H100 GPU, making them suitable for edge deployment.
Downstream Tasks:
- Classification: Achieved 81% accuracy on UCR and 74% on multivariate UEA, matching larger baselines like TiRex (30M) and Chronos-Bolt (205M) without task-specific fine-tuning.
- Anomaly Detection: Detected more anomalies than baselines (Timer, Anomaly Transformer) in zero-shot settings on the UCR Anomaly Archive.
- Imputation: Achieved the lowest MSE across seven standard benchmarks compared to Timer and TimesNet.

5. Significance and Limitations

Significance:
The paper argues that competitive zero-shot time-series forecasting does not strictly require massive model scaling. By carefully designing the architecture (hybrid sequence mixing, multi-scale inputs) and training recipe, it is possible to shift the performance-efficiency frontier, making compact foundation models a practical alternative for deployment-constrained settings.

Limitations:

Univariate Focus: Reverso is primarily trained as a univariate model. While it can be adapted for multivariate tasks, it does not natively learn cross-channel dependencies as effectively as models with specialized attention mechanisms (e.g., Chronos-2).
Short Sequence Performance: While near state-of-the-art on long sequences, performance on shorter sequences still lags behind larger TSFMs.
Point Prediction: The current focus is on point prediction. While the authors suggest conformal methods could be applied for uncertainty estimation, the model itself does not natively output distributional predictions.

The authors conclude that their work demonstrates that "careful architecture and recipe design can significantly shift the TSFM performance–efficiency frontier," offering a viable path for efficient time series foundation modeling.