t0-alpha ONNX FP16

This first-party ONNX export stores FP16 weights and uses FP32 calculations. It preserves the grouped, dynamic interface of the INT8 graph.

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

Intended use

This derivative is intended for local ONNX Runtime inference. Provider coverage and accuracy should be validated on the target hardware before deployment. For production or consequential use, we recommend t0-alpha. Provided as-is.

CPU and WebGPU usage notes are below. Other accelerator providers have not been validated for this replacement.

Artifact

Graph contract

The graph uses ONNX opset 20. Its public inputs and output remain float32 so callers can switch between the FP16 and INT8 artifacts without changing their data preparation.

The compute horizon is determined by the width of future_covariate_future, which must be a multiple of 32. To request 50 steps, pass a width of 64 and keep the first 50 outputs. Context length is independently flexible and is left-padded 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-fp16.onnx",
    providers=["CPUExecutionProvider"],
)
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, :]

The example uses CPU. For the tested browser WebGPU configuration, see below.

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 FP16, 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.