t0-alpha ONNX INT8

This is a first-party INT8-weight, FP32-compute ONNX export of t0-alpha. It runs with ONNX Runtime, including ONNX Runtime Web's WASM and WebGPU execution providers (see below).

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-alpha (PyTorch/MLX) · ONNX FP16 · ONNX INT8 · Collection

The graph supports dynamic context lengths and forecast horizons, grouped targets, and known-future covariates. It powers Finish This Chart, our in-browser forecasting game.

Intended use

This size-optimized derivative has been tested for export parity and browser execution, but not as broadly as the full model. For production or consequential use, we recommend t0-alpha. Provided as-is.

Artifact

Graph contract

The graph uses ONNX opset 20 and per-channel signed INT8 weight quantization with FP32 activations. It has been exported and tested for context lengths from 1 to 4096, 1 to 64 target rows, 0 to 64 known-future covariate rows, and compute horizons from 32 to 1024.

The graph determines its compute horizon from the width of future_covariate_future, which must be a multiple of 32. To request 50 steps, for example, pass a width of 64 and keep the first 50 outputs. Context length is independently flexible: the graph left-pads it to a patch boundary internally. The graph does not include autoregressive rollout beyond 1024 steps.

Group ids need not be contiguous. Give target and covariate rows the same id when they belong to the same multivariate series. If no known-future covariates are available, pass covariate arrays with zero rows; the horizon dimension is still retained.

import math

import numpy as np
import onnxruntime as ort

target_context = np.asarray([1.0, 1.3, 1.2, 1.7, 2.1], dtype=np.float32)[None, :]
target_group_ids = np.asarray([0], dtype=np.int32)
horizon = 24
compute_horizon = math.ceil(horizon / 32) * 32
future_covariate_context = np.empty((0, target_context.shape[1]), dtype=np.float32)
future_covariate_future = np.empty((0, compute_horizon), dtype=np.float32)
future_covariate_group_ids = np.empty((0,), dtype=np.int32)

session = ort.InferenceSession("t0-alpha-grouped-int8.onnx")
quantiles = session.run(
    None,
    {
        "target_context": target_context,
        "target_group_ids": target_group_ids,
        "future_covariate_context": future_covariate_context,
        "future_covariate_future": future_covariate_future,
        "future_covariate_group_ids": future_covariate_group_ids,
    },
)[0]
forecast = quantiles[:, :horizon, :]

Validation status

Native validation compared 66 synthetic series/context/horizon cases against the reference PyTorch implementation with ONNX Runtime 1.29.0. They cover contexts 1–4096, horizons 32–1024, missing values, and long histories with a large level and small variation. Outputs were finite and ordered. The worst per-series mean drift was 0.538% and the worst point drift 5.23%, except in two cases that forecast 1024 steps from 56–96 observations left-padded to a 4096-step context. There, INT8 weight quantization reaches 10% and 21% at single points (mean drift 0.26%). For long horizons from short histories, prefer the FP16 sibling, whose worst point drift is 0.45%. 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.

Browser validation passed 16 cases for this exact artifact: 8 fixtures each on single-thread WASM and WebGPU (with the supplied webgpu-options.js), with ONNX Runtime Web 1.29.0, Chromium 152 and Apple Metal 3. Fixtures cover contexts 1, 33, 97, 512 and 4096, 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.

These checks measure numerical consistency, not forecasting accuracy. Other hardware has not yet been validated.

Acknowledgements

Thanks to Siddharth7113/tsfm-onnx for their Apache-2.0 ONNX export work, which informed parts of this export.

License

Apache-2.0. See LICENSE.

Browser runtime

The same ONNX file supports CPU and WebGPU. For WebGPU, use the accompanying webgpu-options.js, which keeps affected mask operations and integer shape calculations on WASM and folds constant weight expansion. Use the helper from the same revision as the model. Use WASM when WebGPU is unavailable.

import * as ort from "onnxruntime-web/webgpu";
import { webgpuOptions } from "./webgpu-options.js";
const session = await ort.InferenceSession.create(modelBytes, webgpuOptions);

Weights are stored in INT8, while calculations and expanded runtime weights use FP32. This reduces download size, not runtime weight memory. Predictions can differ from the previous export. See CHANGELOG.md.