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).

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

Tested with ONNX Runtime Web 1.29.0 on Chromium 152 / Apple Metal 3, using WASM (1 and 4 threads) and WebGPU. Seventeen CPU/WebGPU parity cases covered real and synthetic series, missing observations, grouped covariates, contexts up to 4096 and horizons up to 1024. Outputs were finite and ordered. These checks measure numerical consistency, not forecasting accuracy. Other hardware has not yet been validated. Details are in manifest.json.

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 on WASM and folds constant weight expansion. 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.