Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+timesfm_2p5_200m_ctx2048_fp16.aimodel/main.mlirb filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,68 @@
+---
+license: apache-2.0
+library_name: coreai
+pipeline_tag: time-series-forecasting
+base_model: google/timesfm-2.5-200m-transformers
+tags: [core-ai, coreaikit, timesfm, time-series, forecasting, on-device, apple]
+---
+
+# TimesFM 2.5 200M — Core AI
+
+[`google/timesfm-2.5-200m-transformers`](https://huggingface.co/google/timesfm-2.5-200m-transformers)
+(Apache-2.0, 200M) converted to **Apple Core AI** `.aimodel` — the
+[zoo](https://github.com/john-rocky/coreai-models-community)'s **first time-series forecasting
+foundation model**. A decoder-only patched transformer: feed it any univariate series, get a
+**128-step point + 10-quantile forecast**, entirely on device.
+
+TimesFM is a **decoder-only transformer over time-series *patches*** (32 points/patch), with the
+familiar LLM stack — RoPE, RMSNorm sandwich-norm, QK-norm, a learnable per-dim attention scale — but
+numeric patches in and quantile forecasts out. The zoo port runs it as **one stateless Core AI graph
++ a host DSP wrapper** (RevIN normalization, flip-invariance, continuous-quantile head): no LLM
+runtime, just CoreAIKit's `GraphModel`.
+
+## Contents
+
+- `timesfm_2p5_200m_ctx2048_fp16.aimodel` — the transformer graph (fp16, ~463 MB). Fixed context
+  **2048** (64 patches); **shorter series are front-padded + masked by the host**, so one bundle
+  covers every context length ≤ 2048.
+  Inputs `tok_in[1,64,64]`, `cos/sin[1,64,80]`, `attn_bias[1,1,64,64]` →
+  outputs `proj_point[1,64,1280]`, `proj_q[1,64,10240]`.
+- `host/` — the Python host-DSP reference (`timesfm_core.py`, `host_forecast.py`): patching,
+  two-level RevIN (global + per-patch causal Welford), flip-invariance (2 graph calls on ±input),
+  continuous-quantile head, denormalization, positivity clamp. This is the exact spec the Swift
+  `Forecaster` follows.
+
+## Gates (vs the HF `TimesFm2_5ModelForPrediction` fp32 oracle)
+
+- Re-authored graph vs HF projections: **cos 1.0000000** (MAE ~1e-6).
+- Independent host DSP + graph vs HF final forecast: **cos 1.0000000** (rel ~1e-8).
+- Core AI **fp16** graph, Mac GPU: **cos ≥ 0.99998**; end-to-end forecast **cos 0.9999999**,
+  values match HF to 2–3 decimals — including a front-padded short-context case.
+- Mac GPU **~7 ms/graph → ~14 ms per 128-step forecast** (flip = 2 calls). iOS h18p AOT: clean.
+
+## Use (Python, Core AI runtime)
+
+```python
+import numpy as np, torch, coreai.runtime as rt, asyncio
+from host_forecast import forecast          # host/host_forecast.py
+from timesfm_core import EngineCore          # thin engine adapter (see host/)
+
+CFG = dict(patch=32, horizon=128, hidden=1280, layers=20, heads=16,
+           head_dim=80, inter=1280, q=9, oql=1024, eps=1e-6)
+model = asyncio.run(rt.AIModel.load("timesfm_2p5_200m_ctx2048_fp16.aimodel",
+                                    rt.SpecializationOptions.from_preferred_compute_unit_kind(
+                                        rt.ComputeUnitKind.gpu())))
+core = EngineCore(model.load_function("main"), torch.float16)
+series = torch.tensor(my_1d_series, dtype=torch.float32)     # any length ≤ 2048
+mean_pred, full_pred = forecast(core, series, ctx_len=2048, cfg=CFG)   # (128,), (128,10)
+```
+
+## Use (CoreAIKit, Swift)
+
+```swift
+let forecaster = try await KitForecaster(catalog: "timesfm-2.5-200m")
+let out = try await forecaster.forecast(series)          // [Float] → point + quantiles
+// out.mean (128-step), out.quantiles (128 × 10)
+```
+
+Base model: TimesFM 2.5 (Google Research). Core AI export: coreai-model-zoo. Apache-2.0.

host/host_forecast.py

@@ -0,0 +1,160 @@
+"""Independent host DSP + TimesFmCore graph -> final forecast.  Ladder 2.
+
+Reproduces TimesFm2_5ModelForPrediction.forward host-side (everything except the
+transformer, which is the exportable core). Validates the spec the Swift host will follow.
+Only the default path: window_size=None, force_flip_invariance=True, truncate from config.
+"""
+import math
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+TOL = 1e-6
+DECODE_INDEX = 5
+THETA = 10000.0
+
+
+def _welford_stats(patched, masks_bool):
+    """patched (B,N,P), masks_bool (B,N,P) True=invalid. Returns ctx_mu,ctx_sigma (B,N)
+    = running (causal) mean/std over valid values across patches (Welford)."""
+    B, N, P = patched.shape
+    count = torch.zeros(B); mean = torch.zeros(B); std = torch.zeros(B)
+    mus, sigmas = [], []
+    for i in range(N):
+        nv = patched[:, i, :]; mk = masks_bool[:, i, :]
+        is_valid = (~mk).float()
+        inc = is_valid.sum(-1)
+        inc_safe = torch.where(inc == 0, torch.ones_like(inc), inc)
+        im = (nv * is_valid).sum(-1) / inc_safe
+        im = torch.where(inc == 0, torch.zeros_like(im), im)
+        cen = nv - im.unsqueeze(-1)
+        iv = ((cen * is_valid) ** 2).sum(-1) / inc_safe
+        iv = torch.where(inc == 0, torch.zeros_like(iv), iv)
+        isd = torch.sqrt(torch.clamp(iv, min=0.0))
+        nc = count + inc
+        nc_safe = torch.where(nc == 0, torch.ones_like(nc), nc)
+        nm = (count * mean + im * inc) / nc_safe
+        nm = torch.where(nc == 0, torch.zeros_like(nm), nm)
+        nvar = (count * std**2 + inc * isd**2 + count * (mean - nm)**2 + inc * (im - nm)**2) / nc_safe
+        nvar = torch.where(nc == 0, torch.zeros_like(nvar), nvar)
+        count, mean, std = nc, nm, torch.sqrt(torch.clamp(nvar, min=0.0))
+        mus.append(mean); sigmas.append(std)
+    return torch.stack(mus, 1), torch.stack(sigmas, 1)
+
+
+def _revin(x, loc, scale, reverse=False, mask=None):
+    while loc.dim() < x.dim():
+        loc = loc.unsqueeze(-1); scale = scale.unsqueeze(-1)
+    if reverse:
+        return x * scale + loc
+    safe = torch.where(scale < TOL, torch.ones_like(scale), scale)
+    normed = (x - loc) / safe
+    if mask is not None:
+        normed = torch.where(mask, torch.zeros_like(normed), normed)
+    return normed
+
+
+def _rope(pos, head_dim):
+    inv = 1.0 / (THETA ** (torch.arange(0, head_dim, 2, dtype=torch.float32) / head_dim))
+    freqs = pos.float().unsqueeze(-1) * inv.view(1, 1, -1)
+    emb = torch.cat([freqs, freqs], -1)
+    return emb.cos(), emb.sin()
+
+
+def _run_graph(core, normalized_ts, input_padding, cfg):
+    """Host replica of TimesFm2_5Model.forward, graph replaced by `core`.
+    Returns point_forecast (B,H,Q), quantile_spreads (B,Lq,Q)."""
+    B, L = normalized_ts.shape
+    P = cfg["patch"]
+    patched = normalized_ts.view(B, -1, P)
+    masks_bool = input_padding[:, :L].view(B, -1, P) >= 0.5
+    ctx_mu, ctx_sigma = _welford_stats(patched, masks_bool)
+    normed = _revin(patched, ctx_mu, ctx_sigma, mask=masks_bool)
+    tok_in = torch.cat([normed, masks_bool.float()], -1)          # (B,N,2P)
+    patch_padding = masks_bool[..., -1]                            # (B,N)
+    N = tok_in.shape[1]
+    num_masked = patch_padding.int().sum(-1, keepdim=True)
+    pos = torch.arange(N).unsqueeze(0) - num_masked                # (B,N)
+    cos, sin = _rope(pos, cfg["head_dim"])
+    # Single additive mask (fp16-safe fill): allowed = causal AND key-not-padded.
+    # One combined mask (never add two fills -> no fp16 -inf overflow -> no all-masked-row NaN).
+    NEG = -1e4
+    i = torch.arange(N).view(N, 1)
+    j = torch.arange(N).view(1, N)
+    causal_ok = (j <= i)                                           # (N,N)
+    key_ok = ~patch_padding                                        # (B,N)
+    allowed = causal_ok[None] & key_ok[:, None, :]                 # (B,N,N)
+    attn_bias = torch.where(allowed[:, None], torch.zeros(1), torch.full((1,), NEG))  # (B,1,N,N)
+    with torch.no_grad():
+        pp, pq = core(tok_in, cos, sin, attn_bias)
+    Q = cfg["q"] + 1
+    point = _revin(pp, ctx_mu, ctx_sigma, reverse=True).view(B, N, cfg["horizon"], Q)[:, -1]
+    quant = _revin(pq, ctx_mu, ctx_sigma, reverse=True).view(B, N, cfg["oql"], Q)[:, -1]
+    return point, quant
+
+
+def forecast(core, series_1d, ctx_len, cfg, force_flip=True, truncate_neg=True):
+    """series_1d: 1D torch tensor. Returns mean_pred (H,), full_pred (H,Q)."""
+    ts = series_1d[-ctx_len:]
+    input_min = ts.min()
+    # _preprocess: pad front if short
+    L = ts.shape[0]
+    if L < ctx_len:
+        pad = ctx_len - L
+        input_ts = torch.cat([torch.zeros(pad), ts])[None]
+        input_padding = torch.cat([torch.ones(pad), torch.zeros(L + cfg["horizon"])])[None]
+    else:
+        input_ts = ts[None]
+        input_padding = torch.zeros(ctx_len + cfg["horizon"])[None]
+
+    mu_g = input_ts.mean(1, keepdim=True)
+    sigma_g = input_ts.std(1, keepdim=True)                        # unbiased (ddof=1)
+    normalized = _revin(input_ts, mu_g, sigma_g)
+
+    pf, qs = _run_graph(core, normalized, input_padding, cfg)
+    if force_flip:
+        fpf, fqs = _run_graph(core, -normalized, input_padding, cfg)
+        def flipq(x):
+            return torch.cat([x[..., :1], torch.flip(x[..., 1:], (-1,))], -1)
+        pf = (pf - flipq(fpf)) / 2
+        qs = (qs - flipq(fqs)) / 2
+
+    H = min(cfg["horizon"], pf.shape[1])
+    full = pf[:, :H, :].clone()
+    mqh = min(H, qs.shape[1])
+    for idx in range(1, cfg["q"] + 1):
+        if idx == DECODE_INDEX:
+            continue
+        full[:, :mqh, idx] = qs[:, :mqh, idx] - qs[:, :mqh, DECODE_INDEX] + full[:, :mqh, DECODE_INDEX]
+
+    full_pred = _revin(full, mu_g, sigma_g, reverse=True)          # (1,H,Q)
+    mean_pred = full_pred[:, :, DECODE_INDEX]
+    if truncate_neg and (input_min >= 0):
+        full_pred = torch.clamp(full_pred, min=0.0)
+        mean_pred = torch.clamp(mean_pred, min=0.0)
+    return mean_pred[0], full_pred[0]
+
+
+if __name__ == "__main__":
+    from transformers import TimesFm2_5ModelForPrediction
+    from timesfm_core import load_core_from_hf
+    cfg = dict(patch=32, horizon=128, hidden=1280, layers=20, heads=16, head_dim=80,
+               inter=1280, q=9, oql=1024, eps=1e-6)
+    z = np.load("oracle.npz", allow_pickle=True)
+    CTX = int(z["ctx_len"]); series = z["series"]; names = z["series_names"]
+    hf = TimesFm2_5ModelForPrediction.from_pretrained(
+        "google/timesfm-2.5-200m-transformers").to(torch.float32).eval()
+    core = load_core_from_hf(hf, cfg)
+
+    print("== Ladder 2: independent host DSP + core vs HF oracle final forecast ==")
+    worst = 1.0
+    for i, nm in enumerate(names):
+        mp, fp = forecast(core, torch.tensor(series[i]), CTX, cfg)
+        omp, ofp = z["mean_pred"][i], z["full_pred"][i]
+        cm = float(mp.numpy().ravel() @ omp.ravel() / (np.linalg.norm(mp.numpy())*np.linalg.norm(omp)+1e-12))
+        cf = float(fp.numpy().ravel() @ ofp.ravel() / (np.linalg.norm(fp.numpy())*np.linalg.norm(ofp)+1e-12))
+        mae = float(np.abs(mp.numpy() - omp).mean())
+        rel = mae / (np.abs(omp).mean() + 1e-9)
+        worst = min(worst, cm, cf)
+        print(f"  {str(nm):8s} mean cos={cm:.8f} full cos={cf:.8f} MAE={mae:.3e} rel={rel:.3e}")
+    print("RESULT:", "PASS" if worst > 0.9999 else "FAIL", f"(min cos={worst:.8f})")

host/timesfm_core.py

@@ -0,0 +1,212 @@
+"""Re-authored, torch.export-clean TimesFM 2.5 graph core.
+
+Graph boundary = pure feed-forward transformer over patch tokens:
+    tok_in (B,N,2P) -> input_ff_layer -> 20 decoder layers
+      -> output_projection_point (B,N,H*Q), output_projection_quantiles (B,N,Lq*Q)
+No data-dependent control flow, no KV cache, static shapes. Host does all RevIN/flip.
+"""
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class RMSNorm(nn.Module):
+    def __init__(self, dim, eps=1e-6):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(dim))
+        self.eps = eps
+
+    def forward(self, x):
+        dt = x.dtype
+        x = x.float()
+        x = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
+        return self.weight * x.to(dt)
+
+
+class ResidualBlock(nn.Module):
+    def __init__(self, in_dims, hid_dims, out_dims, bias):
+        super().__init__()
+        self.input_layer = nn.Linear(in_dims, hid_dims, bias=bias)
+        self.output_layer = nn.Linear(hid_dims, out_dims, bias=bias)
+        self.residual_layer = nn.Linear(in_dims, out_dims, bias=bias)
+
+    def forward(self, x):
+        h = F.silu(self.input_layer(x))
+        return self.output_layer(h) + self.residual_layer(x)
+
+
+def rotate_half(x):
+    x1 = x[..., : x.shape[-1] // 2]
+    x2 = x[..., x.shape[-1] // 2 :]
+    return torch.cat((-x2, x1), dim=-1)
+
+
+class Attention(nn.Module):
+    def __init__(self, cfg):
+        super().__init__()
+        self.n_heads = cfg["heads"]
+        self.head_dim = cfg["head_dim"]
+        d = cfg["hidden"]
+        self.q_proj = nn.Linear(d, self.n_heads * self.head_dim, bias=False)
+        self.k_proj = nn.Linear(d, self.n_heads * self.head_dim, bias=False)
+        self.v_proj = nn.Linear(d, self.n_heads * self.head_dim, bias=False)
+        self.o_proj = nn.Linear(self.n_heads * self.head_dim, d, bias=False)
+        self.q_norm = RMSNorm(self.head_dim, cfg["eps"])
+        self.k_norm = RMSNorm(self.head_dim, cfg["eps"])
+        self.scaling = nn.Parameter(torch.ones(self.head_dim))
+
+    def forward(self, x, cos, sin, attn_bias):
+        B, N, _ = x.shape
+        shp = (B, N, self.n_heads, self.head_dim)
+        q = self.q_proj(x).view(shp).transpose(1, 2)  # B,h,N,hd
+        k = self.k_proj(x).view(shp).transpose(1, 2)
+        v = self.v_proj(x).view(shp).transpose(1, 2)
+        # RoPE (cos/sin: B,N,hd -> unsqueeze head dim)
+        c = cos.unsqueeze(1)
+        s = sin.unsqueeze(1)
+        q = q * c + rotate_half(q) * s
+        k = k * c + rotate_half(k) * s
+        q = self.q_norm(q)
+        k = self.k_norm(k)
+        scale = F.softplus(self.scaling).mul(1.442695041 / math.sqrt(self.head_dim))
+        q = q * scale[None, None, None, :]
+        aw = torch.matmul(q, k.transpose(2, 3)) + attn_bias  # scaling folded into q
+        aw = F.softmax(aw, dim=-1, dtype=torch.float32).to(q.dtype)
+        o = torch.matmul(aw, v).transpose(1, 2).reshape(B, N, -1)
+        return self.o_proj(o)
+
+
+class DecoderLayer(nn.Module):
+    def __init__(self, cfg):
+        super().__init__()
+        d = cfg["hidden"]
+        self.self_attn = Attention(cfg)
+        self.input_layernorm = RMSNorm(d, cfg["eps"])
+        self.post_attention_layernorm = RMSNorm(d, cfg["eps"])
+        self.pre_feedforward_layernorm = RMSNorm(d, cfg["eps"])
+        self.post_feedforward_layernorm = RMSNorm(d, cfg["eps"])
+        self.mlp_fc1 = nn.Linear(d, cfg["inter"], bias=False)
+        self.mlp_fc2 = nn.Linear(cfg["inter"], d, bias=False)
+
+    def forward(self, x, cos, sin, attn_bias):
+        r = x
+        x = self.input_layernorm(x)
+        x = self.self_attn(x, cos, sin, attn_bias)
+        x = self.post_attention_layernorm(x) + r
+        r = x
+        x = self.pre_feedforward_layernorm(x)
+        x = self.mlp_fc2(F.silu(self.mlp_fc1(x)))
+        x = self.post_feedforward_layernorm(x) + r
+        return x
+
+
+class TimesFmCore(nn.Module):
+    """The exportable graph. Inputs: tok_in (B,N,2P), cos/sin (B,N,hd), attn_bias (B,1,N,N).
+    Outputs: proj_point (B,N,H*Q), proj_q (B,N,Lq*Q)."""
+
+    def __init__(self, cfg):
+        super().__init__()
+        self.cfg = cfg
+        P = cfg["patch"]
+        d = cfg["hidden"]
+        Q = cfg["q"] + 1
+        self.input_ff_layer = ResidualBlock(2 * P, d, d, bias=True)
+        self.layers = nn.ModuleList([DecoderLayer(cfg) for _ in range(cfg["layers"])])
+        self.output_projection_point = ResidualBlock(d, d, cfg["horizon"] * Q, bias=False)
+        self.output_projection_quantiles = ResidualBlock(d, d, cfg["oql"] * Q, bias=False)
+
+    def forward(self, tok_in, cos, sin, attn_bias):
+        x = self.input_ff_layer(tok_in)
+        for layer in self.layers:
+            x = layer(x, cos, sin, attn_bias)
+        return self.output_projection_point(x), self.output_projection_quantiles(x)
+
+
+class EngineCore:
+    """Callable matching TimesFmCore.forward, backed by a loaded Core AI graph function.
+
+    Pass `model.load_function("main")` and the bundle dtype. Usable as the `core` argument to
+    host_forecast.forecast(). coreai.runtime is imported lazily so this module still imports in a
+    plain torch/transformers env (for the oracle)."""
+
+    def __init__(self, fn, dtype):
+        self.fn, self.dtype = fn, dtype
+
+    def to(self, *a, **k):
+        return self
+
+    def __call__(self, tok_in, cos, sin, attn_bias):
+        import asyncio
+        import numpy as np
+        import coreai.runtime as rt
+        d = self.dtype
+        out = asyncio.run(self.fn({
+            "tok_in": rt.NDArray(tok_in.to(d).numpy()),
+            "cos": rt.NDArray(cos.to(d).numpy()),
+            "sin": rt.NDArray(sin.to(d).numpy()),
+            "attn_bias": rt.NDArray(attn_bias.to(d).numpy()),
+        }))
+        pp = torch.tensor(out["proj_point"].numpy().astype(np.float32))
+        pq = torch.tensor(out["proj_q"].numpy().astype(np.float32))
+        return pp, pq
+
+
+def rope_cos_sin(position_ids, head_dim, theta=10000.0):
+    """position_ids: (B,N) float -> cos,sin (B,N,head_dim)."""
+    inv = 1.0 / (theta ** (torch.arange(0, head_dim, 2, dtype=torch.float32) / head_dim))
+    freqs = position_ids.float().unsqueeze(-1) * inv.view(1, 1, -1)  # B,N,hd/2
+    emb = torch.cat([freqs, freqs], dim=-1)
+    return emb.cos(), emb.sin()
+
+
+def _map_key(k):
+    if k.startswith("model.input_ff_layer."):
+        return k[len("model."):]
+    if k.startswith("model.layers."):
+        # raw checkpoint uses mlp.ff0/ff1 (transformers remaps to fc1/fc2)
+        return (k[len("model."):]
+                .replace(".mlp.ff0.", ".mlp_fc1.").replace(".mlp.ff1.", ".mlp_fc2.")
+                .replace(".mlp.fc1.", ".mlp_fc1.").replace(".mlp.fc2.", ".mlp_fc2."))
+    if k.startswith("output_projection_point.") or k.startswith("output_projection_quantiles."):
+        return k
+    return None  # rotary buffers etc.
+
+
+def load_core_from_safetensors(path, cfg):
+    """Load TimesFmCore weights directly from a model.safetensors (no transformers dep)."""
+    from safetensors.torch import load_file
+    sd = load_file(path)
+    core = TimesFmCore(cfg)
+    new = {}
+    for k, v in sd.items():
+        nk = _map_key(k)
+        if nk is not None:
+            new[nk] = v
+    missing, unexpected = core.load_state_dict(new, strict=False)
+    assert not [m for m in missing if "inv_freq" not in m], f"missing: {missing}"
+    assert not unexpected, f"unexpected: {unexpected}"
+    return core.eval()
+
+
+def load_core_from_hf(hf_model, cfg):
+    """Copy weights from a loaded HF TimesFm2_5ModelForPrediction into TimesFmCore."""
+    core = TimesFmCore(cfg)
+    sd = hf_model.state_dict()
+    new = {}
+    for k, v in sd.items():
+        nk = k
+        if k.startswith("model.input_ff_layer."):
+            nk = k[len("model."):]
+        elif k.startswith("model.layers."):
+            # model.layers.i.mlp.fc1 -> layers.i.mlp_fc1
+            nk = k[len("model."):].replace(".mlp.fc1.", ".mlp_fc1.").replace(".mlp.fc2.", ".mlp_fc2.")
+        elif k.startswith("output_projection_point.") or k.startswith("output_projection_quantiles."):
+            nk = k
+        else:
+            continue  # rotary_emb buffers etc.
+        new[nk] = v
+    missing, unexpected = core.load_state_dict(new, strict=False)
+    assert not [m for m in missing if "inv_freq" not in m], f"missing: {missing}"
+    assert not unexpected, f"unexpected: {unexpected}"
+    return core.eval()

timesfm_2p5_200m_ctx2048_fp16.aimodel/main.hash

@@ -0,0 +1 @@
+�qǣ��%6�����@L���z�B]�:г

timesfm_2p5_200m_ctx2048_fp16.aimodel/main.mlirb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a671c7a38bb02536cd18dc069dc010ff404ccaeaff7a15a7425d0296193ad0b3
+size 462927671

timesfm_2p5_200m_ctx2048_fp16.aimodel/metadata.json

@@ -0,0 +1,7 @@
+{
+  "assetVersion" : "2.0",
+  "author" : "Google (TimesFM 2.5); Core AI export: coreai-model-zoo",
+  "license" : "Apache-2.0",
+  "creationDate" : "20260708T124500Z",
+  "description" : "TimesFM 2.5 200M decoder-only time-series forecasting transformer (graph core). Inputs: patch tokens + RoPE cos\/sin + causal mask; outputs: point\/quantile projections. Host does RevIN\/flip\/quantile-head. https:\/\/huggingface.co\/google\/timesfm-2.5-200m-transformers"
+}