ReCast: Reliability-aware Codebook Assisted Lightweight Time Series Forecasting

ReCast is a lightweight, reliability-aware time series forecasting framework that utilizes a learnable codebook to encode recurring local patterns and a dual-path architecture to model residuals, employing a distributionally robust optimization strategy to ensure robustness against distribution shifts and non-stationarity.

The Gist

Imagine you are trying to predict the weather for next week. You could try to memorize the entire history of the atmosphere (which is huge, messy, and constantly changing), or you could look for patterns.

Most current computer programs try to memorize the whole history, breaking it down into "trends" (is it getting hotter overall?) and "seasons" (is it summer?). But real life is messy. Sometimes a sudden storm hits, or a traffic jam happens for no obvious reason. These "local" messes break the big, global rules.

ReCast is a new, smarter way to forecast these messy time series (like stock prices, electricity usage, or traffic). Think of it as a smart librarian with a sketchbook who doesn't try to memorize every single second of data, but instead learns to recognize and reuse common "shapes."

Here is how ReCast works, broken down into simple analogies:

1. The "Lego" Approach (Patch-wise Quantization)

Instead of looking at a long, continuous line of data, ReCast chops it up into small chunks called patches (like cutting a long movie into short clips).

• The Problem: There are too many unique clips to memorize.
• The Solution: ReCast has a Codebook (a sketchbook of "standard shapes"). When it sees a new chunk of data, it asks: "Does this look like a 'spike'? A 'dip'? A 'flat line'?"
• It doesn't store the messy details; it just assigns the chunk a label from its sketchbook (e.g., "This is Shape #7"). This turns complex data into simple, easy-to-handle numbers. It's like turning a high-definition photo into a simple emoji.

2. The "Two-Track" System (Dual-Path Forecasting)

Here is the clever part. Sometimes, just matching a shape isn't enough because real life has tiny, annoying details (noise) that don't fit the perfect "Shape #7."

ReCast uses two paths to solve this:

• Path A (The Efficient One): It predicts the future using only the "shapes" (the emojis). This is super fast and lightweight because it's just guessing which shape comes next.
• Path B (The Detail-Oriented One): It looks at what Path A missed. It calculates the difference between the real data and the "shape" prediction. It then uses a second, small brain to predict just those tiny, messy leftovers (the residuals).

The Result: You get the speed of the simple shape prediction, plus the accuracy of the detail correction. It's like a chef who quickly guesses the main ingredients of a soup (Path A) and then adds the perfect pinch of salt to fix the taste (Path B).

3. The "Smart Librarian" (Reliability-Aware Codebook)

The most important part of ReCast is how it updates its Codebook (the sketchbook of shapes).

In the real world, patterns change. A "spike" in electricity usage in winter looks different than in summer. If the librarian keeps the same old sketches, they will get it wrong. But if they change the sketches too fast, they get confused.

ReCast uses a Reliability-Aware Update Strategy:

• Every time it sees new data, it creates "draft sketches" (pseudo codebooks).
• Before adding these to the main sketchbook, it asks three questions:
  1. Quality: Is this new sketch actually a good fit for the data?
  2. Consistency: Does this new sketch make sense compared to what we knew yesterday?
  3. Novelty: Is this a weird, rare pattern we haven't seen before?
• It uses a mathematical "safety filter" (called Distributionally Robust Optimization) to decide how much to trust the new sketch. If the new sketch is shaky or noisy, it ignores it. If it's solid, it updates the book.

This ensures the system stays stable (doesn't panic over one weird day) but also adaptable (learns when the world actually changes).

Why is this a big deal?

• Lightweight: Because it turns complex data into simple "shapes," it doesn't need a supercomputer to run. It's like solving a puzzle with 10 pieces instead of 10,000.
• Robust: It handles "distribution shifts" (when the rules of the game change) better than other models because its librarian is constantly checking if the new rules make sense before updating the book.
• Accurate: By combining the "big picture" shapes with the "tiny details," it beats the current state-of-the-art models in accuracy.

In summary: ReCast is a forecasting system that ignores the noise, focuses on recurring patterns, and uses a smart, cautious librarian to update its knowledge base, ensuring it stays fast, accurate, and ready for whatever the future throws at it.

Technical Summary

1. Problem Statement

Time series forecasting is critical for domains like finance, energy, and healthcare. However, existing state-of-the-art (SOTA) methods face two primary limitations:

• Ineffectiveness on Local Patterns: Conventional methods often rely on global decomposition (trend, seasonality, residual). These struggle with real-world series dominated by local, complex, and highly dynamic patterns rather than clear global regularities.
• High Complexity: Many advanced models (e.g., Transformers) have high computational complexity and sensitivity to noise, making them unsuitable for resource-constrained or real-time environments.
• Distribution Shifts: Real-world data is non-stationary. Static models or those with fixed representations fail to adapt to evolving data distributions.

2. Methodology: The ReCast Framework

ReCast proposes a Reliability-aware Codebook-Assisted framework that combines patch-wise quantization with a dual-path architecture to achieve lightweight, robust forecasting.

A. Patch-wise Quantization

• Input Processing: The input time series is normalized and segmented into non-overlapping patches.
• Downsampling: Patches are downsampled to reduce dimensionality and suppress redundant local fluctuations, focusing on salient structures.
• Vector Quantization (VQ): Each downsampled patch is mapped to the nearest codeword in a learnable codebook ($S$). This converts continuous time series segments into discrete embeddings (indices), effectively capturing recurring local shapes.

B. Dual-Path Forecasting Architecture

To balance efficiency with representational fidelity, ReCast decomposes the prediction task into two complementary paths:

1. Quantization Path (Regular Structures): A lightweight Multi-Layer Perceptron (MLP) predicts the future discrete indices based on the current discrete embeddings. This path efficiently models stable, recurring local patterns.
2. Residual Path (Irregular Fluctuations): Since quantization discards subtle variations, a residual branch is introduced. It calculates the difference between the original input and its reconstructed approximation (via codebook lookup). A separate MLP predicts this residual signal.

• Final Prediction: The outputs of both paths are combined and denormalized to produce the final forecast.

C. Reliability-Aware Codebook Updating

A static codebook cannot handle non-stationary data. ReCast introduces an incremental updating mechanism centered on a Reliability-Aware Scoring strategy:

• Pseudo Codebook Construction: At each epoch, the model clusters randomly sampled patches to generate a "pseudo codebook" ($\hat{S}_t$) representing current data patterns.
• Reliability Scoring: Instead of updating the codebook uniformly, ReCast assigns weights to each cluster center based on three factors:
  1. Representational Quality ($w_{rep}$): How well the codeword reconstructs its assigned patches.
  2. Historical Consistency ($w_{\Delta}$): The deviation from the previous epoch's codeword (identifying necessary adjustments).
  3. OOD Sensitivity ($w_{je}$): Measures the rarity of the pattern to prevent codebook collapse and ensure adaptability to Out-of-Distribution (OOD) data.
• Distributionally Rob Optimization (DRO) Fusion: To fuse these three scores robustly, ReCast employs a DRO scheme. It treats the fusion as a minimization problem under the worst-case weighting distribution within a KL-divergence neighborhood. This ensures the update is conservative and robust against noisy or biased metrics.
• Incremental Update: The final codebook is updated using a weighted correction formula: $S_t = S_{t-1} + \frac{1}{t}( \hat{W}_t \hat{S}_t - S_{t-1} )$, where $\hat{W}_t$ are the fused reliability weights.

3. Key Contributions

1. Lightweight Dual-Path Framework: A novel architecture that captures both stable recurring shapes (via quantization) and irregular fluctuations (via residuals), significantly reducing model complexity while maintaining high accuracy.
2. Reliability-Aware Updating Mechanism: An incremental codebook update strategy driven by a multi-factor reliability score fused via DRO. This ensures the model adapts to distribution shifts without overfitting or becoming unstable.
3. Efficiency and Portability: The framework is computationally efficient (using MLPs and discrete embeddings) and portable, as demonstrated by its ability to improve performance when integrated into other backbone architectures (e.g., iTransformer, TimesNet).

4. Experimental Results

• Datasets: Evaluated on 8 real-world datasets (ECL, Traffic, Weather, Solar, and 4 ETT datasets).
• Baselines: Compared against 8 SOTA models, including Transformers (iTransformer, PatchTST), CNNs (TimesNet), and MLPs (PatchMLP, DLinear).
• Performance:
  • ReCast achieved the best performance in 12 out of 16 forecasting metrics (MSE/MAE across different horizons).
  • It outperformed heavy Transformer models while being significantly faster and having fewer parameters.
• Ablation Studies:
  • Removing the residual path degraded performance, confirming the need to capture fine-grained variations.
  • Removing the reliability-aware scoring or DRO fusion led to instability and lower accuracy, highlighting the importance of robust codebook updates.
  • Random sampling and downsampling were proven essential for reducing overfitting and computational cost.
• Efficiency: ReCast demonstrated superior training speed and parameter efficiency compared to SOTA models, making it suitable for deployment in resource-limited settings.

5. Significance

ReCast addresses the critical trade-off between model complexity and forecasting accuracy in time series analysis. By leveraging discrete codebooks to model local patterns and using a reliability-aware mechanism to handle non-stationarity, it offers a scalable solution for real-world applications where data is noisy, dynamic, and computational resources are limited. The introduction of DRO for reliability fusion provides a theoretical foundation for robust adaptive learning in time series, moving beyond static or heuristic codebook updates.