Predicting demand, energy consumption, or traffic often means training a different model for each dataset. IBM is proposing an alternative: a foundation model capable of generating forecasts without task-specific training, even when it has never seen that particular time series before.
The company launched Granite Time Series PatchTST-FM-r2, a new version of its Granite TSFM model family. With approximately 385 million parameters, it combines an updated architecture, probabilistic forecasting, support for missing values, and strong performance in zero-shot forecasting evaluations.
A general model for time series
In a zero-shot scenario, the model receives the recent history of a series and calculates its possible future values without requiring fine-tuning or a model trained specifically for that task. Does the data represent sales, sensors, prices, or electricity consumption? The same architecture can work with all of these cases, as long as the information is organized as a time series.
PatchTST-FM-r2 supports contexts of up to 8,192 steps, flexible forecast lengths, and an output of 99 quantiles. This makes it possible to obtain both a point forecast and an uncertainty range.
For example, instead of receiving only an answer such as “expected demand will be 1,200 units,” the system can estimate different scenarios and help answer a more useful question: how likely is it that demand will fall between 1,100 and 1,350 units?
Results on GIFT-Eval
IBM reports that, as of September 8, 2026, PatchTST-FM-r2 ranks second among the replicable and zero-shot models in the GIFT-Eval benchmark, both in CRPS and MASE. In both metrics, lower values indicate better performance.
The model achieved a geometric mean CRPS of 0.467 and a MASE of 0.6846. It came immediately behind TimesFM-3 in the comparison of zero-shot models and was the best-performing model with a permissive license in that category.
GIFT-Eval brings together heterogeneous datasets and scenarios to evaluate forecasting models. The comparison also distinguishes between strictly zero-shot models and pretrained models that may have included the evaluation data during training.
When both categories are included, PatchTST-FM-r2 remains near the top: it ranks third in CRPS and fourth in MASE among replicable models. IBM says it outperforms alternatives such as Chronos-2, Timer-S1, and some Toto variants, although several competitors are considerably larger.
A benchmark result does not guarantee the same performance in your company. Data frequency, behavior changes, and the quality of the historical record remain decisive.
What changes in the architecture
PatchTST-FM-r2 preserves the idea of dividing a time series into small segments called patches. This representation makes it possible to process data windows efficiently, but the internal architecture was redesigned to better capture short- and long-term relationships.
The previous version, PatchTST-FM-r1, used standard Transformer blocks. The new version uses Conformer blocks, which combine two mechanisms:
- Multi-head attention, useful for identifying distant relationships between different parts of the series.
- Temporal convolution, which helps detect local patterns and short-term variations.
This combination originally comes from architectures used in speech processing. Applied to time series, it allows convolution to capture nearby interactions while attention focuses on more distant dependencies.
The Conformer blocks use convolution kernels of sizes 3 and 5 following an alternating {5, 5, 3, 3} pattern. In addition, the model expands the architecture from 20 to 30 blocks.
Smoother forecasts with uncertainty
The model uses patches with 50% overlap and weighting through a Hamming window. It then applies a reconstruction strategy known as overlap-and-add, which helps smooth the boundaries between segments and can improve forecast accuracy.
The output of 99 quantiles makes it possible to build forecast distributions and uncertainty intervals. This capability is especially important in real-world operations, where an average forecast may not be enough to plan inventory, capacity, or resources.
Training data and licenses
IBM documents four main sources used to pretrain PatchTST-FM-r2:
- Selected datasets from GiftEvalPretrain.
- Synthetic data generated with KernelSynth and modified periodic kernels.
- A TSMixup corpus inspired by the Chronos approach, limited to data outside the GIFT-Eval evaluation set.
- Nearly 500,000 synthetic CauKer sequences, each with a length of 4,096 steps.
This information does not eliminate the need to review governance, privacy, or regulatory compliance before deploying the model. However, it provides more context than a system whose training corpus is completely opaque.
PatchTST-FM-r2 is available under a dual license: Apache 2.0 and OpenMDW 1.0. Users can choose either one. Both offer broad permissions to use, modify, and distribute the model, which is especially relevant for companies that need to incorporate AI into commercial products.
The weights, architecture, inference pipeline, and code used to reproduce the benchmark results are also available. The implementation is part of the Granite-TSFM repository and remains compatible with PatchTST-FM-r1 checkpoints.
How to try it with Python
The most direct way to evaluate it is with your own time series. First, install IBM’s package:
pip install "granite-tsfm>=0.3.9"
Then you can load the model from Hugging Face and create a forecasting pipeline:
import pandas as pd
from tsfm_public import PatchTSTFMForPrediction, TimeSeriesForecastingPipeline
model = PatchTSTFMForPrediction.from_pretrained(
"ibm-granite/granite-timeseries-patchtst-fm-r2"
)
df = pd.read_csv(
"https://raw.githubusercontent.com/zhouhaoyi/ETDataset/main/ETT-small/ETTh1.csv",
parse_dates=["date"],
)
pipe = TimeSeriesForecastingPipeline(
model=model,
id_columns=[],
timestamp_column="date",
target_columns=["HUFL"],
max_context_length=model.config.context_length,
context_length=512,
prediction_length=64,
impute_method=None,
quantile_levels=[0.1, 0.5, 0.9],
explode_forecasts=True,
freq="1h",
)
forecast = pipe(df.iloc[-512:])
The example uses public electricity consumption data, but the same workflow can be adapted to demand, telemetry, CPU utilization, energy, transactions, traffic, or prices. You do not need to tune the model for each task to generate an initial forecast.
That said, it is a good idea to validate the result against traditional methods and against historical data from your own operation. A foundation model can speed up experimentation, but it does not replace error evaluation, data-drift detection, or business oversight.
From static data to real-time streams
IBM is also connecting the Granite Time Series family with streaming applications through an early-access integration with Confluent Cloud. The approach uses Apache Flink to generate forecasts and detect anomalies directly on data arriving continuously.
The initial portfolio includes PatchTST-FM-r1, FlowState-r1.1, TTM-r3, and TSPulse. Instead of moving data to a separate machine learning environment, organizations can run inference on operational streams such as industrial sensors, infrastructure metrics, or transactions.
The importance of this launch is not limited to second place on a leaderboard. IBM is betting on open, replicable time-series models with licenses compatible with commercial use. For a technical team, that could reduce the time needed to move from an experiment to a test with real data.
The question now is not whether AI can forecast the future. The practical question is whether your data has the quality, stability, and context needed for that forecast to be useful.
Original source
https://huggingface.co/blog/ibm-research/ibm-releases-sota-granite-time-series