The foundation-model promise, checked against the benchmarks.

Google's TimesFM is a 200M-parameter decoder-only forecasting model trained on a 100B-point time-series corpus. The ICML 2024 version is available on GitHub and Hugging Face, and Google reports competitive zero-shot performance on Monash datasets plus long-horizon ETT comparisons against PatchTST and LLMTime.

ARIMA · AutoRegressive Integrated Moving Average · Classical · params N/A (statistical)

Best for · Single low-frequency series with clear linear trends. Financial reporting, inventory planning.

Prophet · Meta Prophet · Classical · params N/A (statistical)

Best for · Business metrics with strong seasonal patterns. Daily/weekly KPI dashboards.

N-BEATS · Neural Basis Expansion Analysis · Deep Learning · params ~4M

Best for · High-accuracy univariate forecasting where you can afford training time.

PatchTST · Patch Time Series Transformer · Transformer · params ~6M

Best for · Multivariate long-horizon forecasting with sufficient training data. Energy, weather.

TimesFM · Google Time Series Foundation Model · Foundation · params 200M

Best for · Rapid prototyping and cold-start forecasting where you need a strong baseline before training a task-specific model.

Chronos · Amazon Chronos · Foundation · params 8M-710M

Best for · Probabilistic forecasting with uncertainty quantification. Demand planning, risk assessment.

Moirai · Salesforce Moirai · Foundation · params 14M-311M

Best for · Multivariate zero-shot forecasting. IoT sensor networks, multi-asset portfolios.

Lag-Llama · Lag-Llama · Foundation · params ~7M

Best for · Resource-constrained deployments needing probabilistic forecasts. Edge/embedded scenarios.

Timer · Timer (Generative Pre-trained Transformer for Time Series) · Foundation · params ~67M

Best for · General-purpose time series tasks beyond just forecasting. Multi-task deployments.

• Zero-shot performance is genuinely competitive. Timer reaches 0.368 MSE on ETTh1-96 without seeing a single ETTh1 training example. PatchTST, trained specifically on ETTh1, gets 0.370. That is a paradigm shift.
• Cold start is no longer blank slate. New product launched yesterday, limited historical data: a foundation model can give a reasonable first forecast before a domain model is trained.
• Multi-task capability is emerging. Timer handles forecasting, imputation and anomaly detection from the same weights. Moirai handles any number of variates. Not toy demos.

• “Foundation models will replace all forecasting.” On Traffic (862 channels, strong cross-channel dependencies) fine-tuned PatchTST (0.360) still beats all zero-shot foundation models. Domain-specific architectures with domain-specific training data win on domain-specific tasks.
• “Bigger model = better forecast.” Chronos-Large (710M) does not consistently beat Chronos-Base (200M). Lag-Llama at 7M parameters is competitive with models 100× its size on many univariate tasks.
• “No need to understand your data.” Foundation models still benefit enormously from proper preprocessing: normalisation, missing-value handling, choice of context length. Garbage in, garbage out still applies.
• “Inference cost does not matter.” Running Chronos-Large hourly on 100,000 retail SKUs requires serious GPU infrastructure. ARIMA on the same task runs on a single CPU in minutes.

import pandas as pd
from statsmodels.tsa.arima.model import ARIMA

# Load and fit
df = pd.read_csv("ETTh1.csv", parse_dates=["date"], index_col="date")
series = df["OT"]  # Oil Temperature target

model = ARIMA(series, order=(2, 1, 2))  # (p, d, q)
fitted = model.fit()

# Forecast next 96 steps
forecast = fitted.forecast(steps=96)
print(f"AIC: {fitted.aic:.1f}")
print(forecast.head())

from transformers import PatchTSTForPrediction, PatchTSTConfig
import torch

config = PatchTSTConfig(
    num_input_channels=7,     # ETTh1 has 7 features
    context_length=512,       # lookback window
    prediction_length=96,     # forecast horizon
    patch_length=16,          # each patch = 16 time steps
    stride=8,                 # overlap between patches
    d_model=128,
    num_attention_heads=4,
    num_hidden_layers=3,
)

model = PatchTSTForPrediction(config)

# Shape: (batch, channels, context_length)
past_values = torch.randn(32, 7, 512)
outputs = model(past_values=past_values)

# outputs.prediction_outputs: (32, 7, 96)
predictions = outputs.prediction_outputs
print(f"Forecast shape: {predictions.shape}")

import torch
from chronos import ChronosPipeline

pipeline = ChronosPipeline.from_pretrained(
    "amazon/chronos-t5-base",  # 200M params
    device_map="cuda",
    torch_dtype=torch.bfloat16,
)

# Context: last 512 observations
context = torch.tensor(df["OT"].values[-512:])

# Generate 96-step probabilistic forecast
forecast = pipeline.predict(
    context=context,
    prediction_length=96,
    num_samples=20,
)

median = forecast.median(dim=1).values
low = forecast.quantile(0.1, dim=1).values
high = forecast.quantile(0.9, dim=1).values

print(f"Median forecast: {median.shape}")
print(f"80% interval width: {(high - low).mean():.4f}")

import timesfm

tfm = timesfm.TimesFm(
    context_len=512,
    horizon_len=96,
    input_patch_len=32,
    output_patch_len=128,
    num_layers=20,
    model_dims=1280,
    backend="gpu",
)
tfm.load_from_checkpoint(repo_id="google/timesfm-1.0-200m")

forecast_input = df["OT"].values[-512:]
point_forecast, experimental_quantiles = tfm.forecast(
    [forecast_input],
    freq=[0],  # 0 = high-frequency (hourly)
)

print(f"Point forecast shape: {point_forecast.shape}")