t0-beta ONNX FP16

This is a first-party FP16-weight, FP32-compute ONNX export of t0-beta, the second public iteration of the probabilistic time-series forecasting foundation model from The Forecasting Company. It runs with ONNX Runtime, including ONNX Runtime Web's WASM and WebGPU providers.

It supports grouped univariate and multivariate targets, known-future covariates, and dynamic context lengths and forecast horizons.

Update (2026-10-18): numerical fix. This revision fixes a float32 precision issue in the graph's built-in input normalization. It affected long histories whose values sit far from zero relative to how much they vary (for example, a sensor reading about 50,000 that moves by less than 1): earlier revisions could return shifted or badly scaled forecasts for such series, and in extreme cases non-finite values. The input/output interface is unchanged. We recommend updating if you use an earlier revision; see CHANGELOG.md.

Model family: t0-beta (PyTorch/MLX) · ONNX INT8 · ONNX FP16

You can also use t0 on Retrocast, our platform for forecasting on your own data and comparing open-weight models.

An illustration of t0 in Retrocast, from the source model card. Data: Enedis open data.

Model details

Large weight matrices are stored in FP16 and cast to FP32 for computation. This is a weight-storage conversion; inputs, activations and outputs remain FP32. Compact weights reduce download size; expanded runtime weights and calculations use FP32, so this is not a proportional reduction in runtime memory.

What changes from t0-alpha?

Beta returns 21 native quantiles instead of five. The median is index 10, not alpha's index 2. The ordered levels are:

0.01, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.50,
0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 0.99

The graph includes beta's normalization: scaler_eps=0.01 and scaler_eps_mode=std_clamp. Pass raw observations; do not apply alpha's normalization outside the graph. All native quantiles are returned; arbitrary quantile interpolation and autoregressive rollout are not included in this export.

Intended use

This derivative is intended for local probabilistic forecasting in browsers, on CPUs and with the tested WebGPU configuration, including known-future covariates. It has been validated for numerical consistency and browser execution. Evaluate forecast accuracy and calibration on your own historical backtests and validate execution on the hardware you plan to use.

For the full forecasting API, including quantile interpolation, longer-horizon rollout and fine-tuning, use t0-beta with tfc-t0>=0.5.0. The source repository also supports MLX inference. These ONNX files do not require PyTorch or tfc-t0 at inference time. Forecasts are probabilistic estimates.

Artifact

Exported from the pinned beta checkpoint revision. Artifact SHA-256: 061e1cd100c565c2bd3d3bb222664ac0d4399859d1dcf4cb55f3f52d7d02a7ed. File hashes are recorded in manifest.json.

Graph contract

Group ids need not be contiguous. Give target and covariate rows the same id when they belong to the same multivariate series; different groups remain independent. Historical-only covariates can be supplied as additional target rows in the same group; the graph also forecasts those rows.

With no known-future covariates, pass arrays with zero covariate rows. Keep the second dimension of future_covariate_future: it still selects the horizon.

The graph accepts contexts within its exported 1–8192 observation range and left-pads them internally to the 32-step patch grid. Use NaN for missing observations. It has no separate public padding-mask input.

The compute horizon is selected by the width of future_covariate_future and must be a positive multiple of 32, up to 1024. For a 50-step forecast, pass width 64 and retain the first 50 outputs. Quantile outputs are float32 for both storage precisions.

Quickstart

pip install numpy "onnxruntime==1.29.0" huggingface_hub
hf auth login  # authenticate with an authorized account for private repositories

The example downloads this repository's artifact and runs on CPU:

import math

import numpy as np
import onnxruntime as ort
from huggingface_hub import hf_hub_download

model_path = hf_hub_download(
    repo_id="theforecastingcompany/t0-beta-onnx-fp16",
    filename="t0-beta-grouped-fp16.onnx",
)
session = ort.InferenceSession(model_path, providers=["CPUExecutionProvider"])

horizon = 50
compute_horizon = math.ceil(horizon / 32) * 32  # 64
history = (10 + np.sin(np.arange(97) / 6)).astype(np.float32)
target_context = history[None, :]
feeds = {
    "target_context": target_context,
    "target_group_ids": np.array([0], dtype=np.int32),
    "future_covariate_context": np.empty((0, history.size), dtype=np.float32),
    "future_covariate_future": np.empty((0, compute_horizon), dtype=np.float32),
    "future_covariate_group_ids": np.empty((0,), dtype=np.int32),
}
quantiles = session.run(["quantiles"], feeds)[0]
forecast = quantiles[:, :horizon, :]  # [1, 50, 21]
median = forecast[..., 10]           # [1, 50]
print(forecast.shape, median.shape)

Forecasting with covariates

The following continues the example above. Two target rows share a group, so they are forecast jointly. A calendar covariate belongs to that same group and is supplied over both history and the full compute horizon.

targets = np.concatenate([target_context, target_context * 1.2], axis=0)
calendar = np.sin(2 * np.pi * np.arange(history.size + compute_horizon) / 7)
calendar = calendar.astype(np.float32)[None, :]
with_covariates = {
    "target_context": targets,
    "target_group_ids": np.array([7, 7], dtype=np.int32),
    "future_covariate_context": calendar[:, :history.size],
    "future_covariate_future": calendar[:, history.size:],
    "future_covariate_group_ids": np.array([7], dtype=np.int32),
}
forecast_with_covariates = session.run(["quantiles"], with_covariates)[0][:, :horizon, :]
print(forecast_with_covariates.shape)  # [2, 50, 21]

Only use covariates available at the forecast origin, such as calendar features, planned promotions or weather forecasts. Unknown entries may be marked with NaN; do not substitute later observed target values.

Browser runtime

Use ONNX Runtime Web 1.29.0 and this repository's webgpu-options.js. Download the model and helper, then serve both through your application. The helper is specific to this artifact: it places affected mask operations and integer shape calculations on WASM and allows constant weight expansion to be folded, while matrix operations run on WebGPU.

import * as ort from "onnxruntime-web/webgpu";
import { webgpuOptions } from "./webgpu-options.js";

ort.env.wasm.numThreads = 1;
const response = await fetch("./t0-beta-grouped-fp16.onnx");
if (!response.ok) throw new Error(`Model download failed: ${response.status}`);
const modelBytes = await response.arrayBuffer();
const session = await ort.InferenceSession.create(modelBytes, webgpuOptions);

Feed tensors using the names, dtypes and shapes in the graph contract above. For WASM-only execution, create the session with { executionProviders: ["wasm"] }. Use WASM when WebGPU is unavailable.

Evaluation and validation

Source-model benchmarks

The pinned t0-beta model card reports the following results for the original checkpoint:

These are source-model results. GIFT-Eval and fev-bench have not been run on this ONNX derivative; its conversion checks below measure numerical drift.

This ONNX artifact

Native validation passed 66 synthetic series/context/horizon cases against the reference PyTorch implementation, with finite, ordered outputs. The cases include missing values and long histories with a large level and small variation. Across these cases, the worst per-series mean drift was 0.0253% and the worst point drift was 0.245%. Drift is absolute error divided by the reference series' full forecast range across the horizon and all quantiles, not relative error on an individual prediction. The gates were 2% mean and 10% point drift.

Browser validation passed 16 cases for this exact artifact: 8 fixtures each on single-thread WASM and WebGPU, with ONNX Runtime Web 1.29.0, Chromium 152 and Apple Metal 3. Fixtures cover contexts 1, 33, 97, 512 and 8192, horizons 32, 64 and 1024, and two long histories with a large level and small variation. Browser outputs matched native CPU outputs at rtol=0.001, atol=0.001, with no non-finite values or quantile crossings. Other hardware has not been validated. Recorded timings include first-use compilation and are not warm-inference benchmarks.

FP16 weight storage provides a closer numerical match in these checks; the INT8 sibling has a smaller download.

Acknowledgements

t0-beta continues the t0-alpha model family. The underlying model builds on ideas from Toto, Chronos-2 and TiRex. Thanks also to Siddharth7113/tsfm-onnx for the Apache-2.0 ONNX export work that informed parts of this pipeline. See NOTICE for code-level attributions.

Citation

@misc{tfc-t0,
  title  = {t0: A time-series forecasting foundation model},
  author = {The Forecasting Company},
  year   = {2026},
  url    = {https://huggingface.co/theforecastingcompany/t0-beta},
}

License and contact

Apache-2.0. See LICENSE and NOTICE. For issues and bug reports, use the tfc-t0 issue tracker.