Upload folder using huggingface_hub

README.md

@@ -1,13 +1,37 @@
 ---
-title: Tinycast Forecaster
-emoji: 🏆
-colorFrom: green
+title: TinyCast Forecaster
+emoji: 📈
+colorFrom: gray
 colorTo: blue
 sdk: gradio
 sdk_version: 6.25.0
-python_version: '3.13'
 app_file: app.py
-pinned: false
+short_description: TinyCast zero-shot probabilistic time-series forecasting
+python_version: "3.12"
+startup_duration_timeout: 30m
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# TinyCast Forecaster
+
+A Gradio demo for [TinyCast](https://huggingface.co/raws-labs/tinycast), an attention-free,
+146,505-parameter time-series foundation model that forecasts unseen series zero-shot and
+returns nine quantile forecasts.
+
+## How it works
+
+1. Upload a CSV file with a value column (or paste numeric values directly)
+2. Select the frequency/domain of your time series
+3. Choose a forecast horizon (1–512 steps)
+4. Get a probabilistic forecast plot with quantile confidence bands
+
+The model replaces self-attention with dilated causal convolutions and a zero-parameter
+normalized-periodogram phase prior, so periodicity is computed from the context instead
+of learned. Every learned operation is a convolution, a matrix multiplication or a
+normalization, so the model streams in constant memory and runs on CPU.
+
+## Model
+
+- **Weights**: [raws-labs/tinycast](https://huggingface.co/raws-labs/tinycast)
+- **Code**: [github.com/raws-labs/tinycast](https://github.com/raws-labs/tinycast)
+- **Paper**: [arXiv:2608.15767](https://arxiv.org/abs/2608.15767)
+- **License**: Apache-2.0

app.py

@@ -0,0 +1,264 @@
+"""TinyCast: Probabilistic Zero-Shot Forecasting — Gradio demo.
+
+TinyCast is a 146K-parameter attention-free time-series foundation model that
+forecasts unseen series zero-shot and returns nine quantile forecasts.
+https://huggingface.co/raws-labs/tinycast
+"""
+
+import os
+import io
+import time
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import gradio as gr
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+import torch
+
+# ---------------------------------------------------------------------------
+# Model loading — at module scope, CPU (the model is 146K params, ~0.6 MB).
+# ---------------------------------------------------------------------------
+from huggingface_hub import hf_hub_download
+
+HF_REPO = "raws-labs/tinycast"
+
+# Download config.json and model.safetensors (config.json lands beside weights)
+_hf_config = hf_hub_download(HF_REPO, "config.json")
+WEIGHTS_PATH = hf_hub_download(HF_REPO, "model.safetensors")
+
+# The tinycast package ships on GitHub; we vendor it into the Space repo.
+import sys
+sys.path.insert(0, str(Path(__file__).parent))
+
+from tinycast import TinyCastPredictor
+
+
+# ---------------------------------------------------------------------------
+# Frequency → (freq_label, domain) mapping for the seasonal scale factor.
+# The model needs a pandas frequency string and a domain for the scale factor.
+# ---------------------------------------------------------------------------
+FREQ_MAP = {
+    "Hourly (H)": ("H", "Energy"),
+    "Daily (D)": ("D", "Sales"),
+    "Weekly (W)": ("W", "Sales"),
+    "Monthly (M)": ("M", "Sales"),
+    "Quarterly (Q)": ("Q", "Economic"),
+    "4-hourly (4H)": ("4H", "Energy"),
+    "10-minute (10T)": ("10T", "Energy"),
+    "Minute (T)": ("T", "Energy"),
+}
+
+
+def parse_csv(file_obj):
+    """Parse an uploaded CSV file into a numpy array of values."""
+    if file_obj is None:
+        return None, None
+    try:
+        df = pd.read_csv(file_obj.name)
+    except Exception:
+        df = pd.read_csv(file_obj)
+
+    # Try to find a value column: look for common names, else take last column
+    value_cols = [c for c in df.columns if c.lower() in ("value", "y", "target", "v", "measurement")]
+    if value_cols:
+        values = df[value_cols[0]].values
+    else:
+        values = df.iloc[:, -1].values
+
+    values = pd.to_numeric(pd.Series(values), errors="coerce").values.astype("float32")
+    return values, df
+
+
+def parse_text_input(text):
+    """Parse pasted numeric values (comma or newline separated)."""
+    if not text or not text.strip():
+        return None
+    parts = text.replace(",", " ").replace("\n", " ").split()
+    vals = []
+    for p in parts:
+        try:
+            vals.append(float(p))
+        except ValueError:
+            pass
+    if not vals:
+        return None
+    return np.array(vals, dtype="float32")
+
+
+def forecast(
+    csv_file,
+    text_input,
+    freq_choice,
+    prediction_length,
+    flip_invariance,
+):
+    """Run TinyCast zero-shot forecast and return a quantile plot."""
+    # Get the time series values
+    if csv_file is not None:
+        values, _ = parse_csv(csv_file)
+    else:
+        values = parse_text_input(text_input)
+
+    if values is None or len(values) < 10:
+        return None, "Please provide at least 10 data points (via CSV upload or text input)."
+
+    freq_str, domain = FREQ_MAP.get(freq_choice, ("H", "Energy"))
+
+    # Build gluonts-style entry
+    try:
+        start = pd.Period("2020-01-01 00", freq=freq_str.lower())
+    except Exception:
+        start = pd.Period("2020-01-01", freq="D")
+
+    entry = {"target": values, "start": start, "item_id": "input"}
+
+    # Build the predictor
+    t0 = time.perf_counter()
+    predictor = TinyCastPredictor(
+        prediction_length=int(prediction_length),
+        checkpoint_path=WEIGHTS_PATH,
+        freq=freq_str,
+        domain=domain,
+        device="cpu",
+        force_flip_invariance=bool(flip_invariance),
+    )
+    forecasts = predictor.predict([entry])
+    elapsed = time.perf_counter() - t0
+
+    fc = forecasts[0]
+    # forecast_array is (Q, prediction_length) with quantile levels ascending
+    arr = fc.forecast_array  # (Q, pl)
+    quantile_levels = [float(k) for k in fc.forecast_keys]
+    pl = arr.shape[1]
+
+    # Build the plot
+    fig, ax = plt.subplots(figsize=(12, 5))
+
+    # Plot context (last 200 points for readability)
+    context_show = min(200, len(values))
+    ctx_x = np.arange(-context_show, 0)
+    ax.plot(ctx_x, values[-context_show:], color="black", linewidth=1.0, label="Context (observed)")
+
+    # Plot forecast quantiles
+    fut_x = np.arange(0, pl)
+    q_colors = plt.cm.viridis(np.linspace(0.15, 0.85, len(quantile_levels)))
+
+    # Fill between outer quantiles for the confidence band
+    if len(quantile_levels) >= 2:
+        ax.fill_between(
+            fut_x, arr[0, :], arr[-1, :],
+            color="steelblue", alpha=0.15, label=f"{int(float(quantile_levels[0])*100)}%–{int(float(quantile_levels[-1])*100)}% interval",
+        )
+    if len(quantile_levels) >= 4:
+        mid_lo = len(quantile_levels) // 4
+        mid_hi = 3 * len(quantile_levels) // 4
+        ax.fill_between(
+            fut_x, arr[mid_lo, :], arr[mid_hi, :],
+            color="steelblue", alpha=0.25, label=f"{int(float(quantile_levels[mid_lo])*100)}%–{int(float(quantile_levels[mid_hi])*100)}% interval",
+        )
+
+    # Median line
+    qm = len(quantile_levels) // 2
+    ax.plot(fut_x, arr[qm, :], color="crimson", linewidth=2.0, label="Median forecast")
+
+    # Outer quantile lines
+    for i in [0, -1]:
+        ax.plot(fut_x, arr[i, :], color=q_colors[i], linewidth=0.8, linestyle="--", alpha=0.5)
+
+    ax.axvline(x=0, color="gray", linestyle=":", linewidth=0.8)
+    ax.set_xlabel("Time (relative)")
+    ax.set_ylabel("Value")
+    ax.set_title(f"TinyCast {int(prediction_length)}-step probabilistic forecast ({freq_choice})")
+    ax.legend(loc="upper left", fontsize=8)
+    fig.tight_layout()
+
+    # Summary text
+    info = (
+        f"Context: {len(values)} points | Frequency: {freq_str} | Domain: {domain} | "
+        f"Horizon: {pl} steps | Quantiles: {len(quantile_levels)} | "
+        f"Flip-invariance: {'on' if flip_invariance else 'off'} | "
+        f"Inference: {elapsed:.2f}s"
+    )
+
+    plt.close(fig)
+    return fig, info
+
+
+# ---------------------------------------------------------------------------
+# Build the Gradio UI
+# ---------------------------------------------------------------------------
+CSS = """
+#main-col { max-width: 1200px; margin: 0 auto; }
+.dark .gradio-container { color: var(--body-text-color); }
+"""
+
+with gr.Blocks(theme=gr.themes.Citrus(), css=CSS, title="TinyCast Forecaster") as demo:
+    gr.Markdown(
+        "# TinyCast: Probabilistic Zero-Shot Forecasting\n\n"
+        "An attention-free, 146K-parameter time-series foundation model that forecasts "
+        "unseen series zero-shot and returns nine quantile forecasts. "
+        "[Model](https://huggingface.co/raws-labs/tinycast) · "
+        "[Paper](https://arxiv.org/abs/2608.15767) · "
+        "[Code](https://github.com/raws-labs/tinycast)"
+    )
+
+    with gr.Column(elem_id="main-col"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### Input")
+                csv_input = gr.File(label="Upload CSV (value column or last column used)", file_types=[".csv"])
+                gr.Markdown("**— or —**")
+                text_input = gr.Textbox(
+                    label="Paste values (comma or newline separated)",
+                    placeholder="10.0, 12.3, 9.8, 11.1, ...",
+                    lines=3,
+                )
+                freq_choice = gr.Dropdown(
+                    choices=list(FREQ_MAP.keys()),
+                    value="Hourly (H)",
+                    label="Frequency / Domain",
+                )
+                prediction_length = gr.Slider(
+                    minimum=1, maximum=512, value=48, step=1,
+                    label="Forecast horizon (steps)",
+                )
+                flip_inv = gr.Checkbox(
+                    value=True,
+                    label="Flip-invariance symmetrization (improves accuracy)",
+                )
+                run_btn = gr.Button("Forecast", variant="primary")
+
+            with gr.Column(scale=2):
+                gr.Markdown("### Forecast")
+                plot_output = gr.Plot(label="Probabilistic forecast")
+                info_output = gr.Textbox(label="Summary", interactive=False)
+
+        gr.Markdown("### Examples")
+        gr.Examples(
+            examples=[
+                ["example_hourly_energy.csv", None, "Hourly (H)", 48, True],
+                ["example_daily_sales.csv", None, "Daily (D)", 30, True],
+                ["example_monthly_temp.csv", None, "Monthly (M)", 24, True],
+            ],
+            inputs=[csv_input, text_input, freq_choice, prediction_length, flip_inv],
+            outputs=[plot_output, info_output],
+            fn=forecast,
+            cache_examples=True,
+            cache_mode="lazy",
+        )
+
+        gr.Markdown(
+            "\n\n---\n"
+            "TinyCast replaces self-attention with dilated causal convolutions and a "
+            "zero-parameter normalized-periodogram phase prior. The model is 146,505 "
+            "parameters (~0.6 MB) and runs on CPU. License: Apache-2.0."
+        )
+
+
+if __name__ == "__main__":
+    demo.launch(mcp_server=True)

example_daily_sales.csv

@@ -0,0 +1,366 @@
+timestamp,value
+2023-01-01,50.91415
+2023-01-02,54.748363
+2023-01-03,62.10063
+2023-01-04,57.31053
+2023-01-05,40.008057
+2023-01-06,36.59418
+2023-01-07,42.865208
+2023-01-08,49.40127
+2023-01-09,58.16791
+2023-01-10,57.64015
+2023-01-11,57.47703
+2023-01-12,48.544537
+2023-01-13,41.048813
+2023-01-14,46.21341
+2023-01-15,52.102528
+2023-01-16,55.990437
+2023-01-17,61.655533
+2023-01-18,52.31219
+2023-01-19,49.196514
+2023-01-20,41.05094
+2023-01-21,42.627098
+2023-01-22,49.00721
+2023-01-23,62.585938
+2023-01-24,60.43569
+2023-01-25,54.253853
+2023-01-26,45.854763
+2023-01-27,43.147648
+2023-01-28,44.628017
+2023-01-29,52.6382
+2023-01-30,60.56078
+2023-01-31,67.674225
+2023-02-01,54.669594
+2023-02-02,45.724434
+2023-02-03,39.459404
+2023-02-04,45.72962
+2023-02-05,55.136917
+2023-02-06,59.276474
+2023-02-07,59.078808
+2023-02-08,53.765392
+2023-02-09,49.562943
+2023-02-10,44.480484
+2023-02-11,45.86115
+2023-02-12,50.10347
+2023-02-13,60.6648
+2023-02-14,62.299335
+2023-02-15,57.244904
+2023-02-16,50.575447
+2023-02-17,43.271507
+2023-02-18,46.618427
+2023-02-19,52.652737
+2023-02-20,61.185673
+2023-02-21,64.193146
+2023-02-22,52.56737
+2023-02-23,47.35215
+2023-02-24,41.539604
+2023-02-25,43.015053
+2023-02-26,51.974575
+2023-02-27,65.15314
+2023-02-28,60.051785
+2023-03-01,60.193672
+2023-03-02,43.612553
+2023-03-03,42.296066
+2023-03-04,45.769943
+2023-03-05,54.90867
+2023-03-06,63.151993
+2023-03-07,65.37932
+2023-03-08,56.592663
+2023-03-09,47.624107
+2023-03-10,46.224648
+2023-03-11,45.057774
+2023-03-12,49.67294
+2023-03-13,57.968452
+2023-03-14,60.590923
+2023-03-15,59.48032
+2023-03-16,49.78844
+2023-03-17,46.072178
+2023-03-18,44.69993
+2023-03-19,54.32562
+2023-03-20,63.595085
+2023-03-21,62.77124
+2023-03-22,59.709164
+2023-03-23,47.725384
+2023-03-24,43.26156
+2023-03-25,45.18647
+2023-03-26,50.61248
+2023-03-27,63.529232
+2023-03-28,62.64107
+2023-03-29,58.72632
+2023-03-30,51.503403
+2023-03-31,46.040314
+2023-04-01,48.67784
+2023-04-02,54.254543
+2023-04-03,61.14842
+2023-04-04,64.160126
+2023-04-05,53.976833
+2023-04-06,46.069824
+2023-04-07,41.082623
+2023-04-08,44.039944
+2023-04-09,56.099323
+2023-04-10,60.051876
+2023-04-11,63.61479
+2023-04-12,63.286522
+2023-04-13,49.69237
+2023-04-14,47.613266
+2023-04-15,44.580833
+2023-04-16,54.633686
+2023-04-17,60.26825
+2023-04-18,64.08218
+2023-04-19,62.25976
+2023-04-20,45.929203
+2023-04-21,47.053993
+2023-04-22,48.444893
+2023-04-23,53.81755
+2023-04-24,59.130142
+2023-04-25,65.665665
+2023-04-26,58.50036
+2023-04-27,52.15919
+2023-04-28,46.16628
+2023-04-29,52.88702
+2023-04-30,55.231934
+2023-05-01,60.74782
+2023-05-02,66.337105
+2023-05-03,61.098827
+2023-05-04,55.888725
+2023-05-05,48.956055
+2023-05-06,49.502296
+2023-05-07,60.689907
+2023-05-08,60.602024
+2023-05-09,64.23003
+2023-05-10,58.00911
+2023-05-11,50.991734
+2023-05-12,42.670662
+2023-05-13,50.687138
+2023-05-14,55.983334
+2023-05-15,60.105896
+2023-05-16,63.45254
+2023-05-17,62.07938
+2023-05-18,55.025543
+2023-05-19,53.140915
+2023-05-20,57.873272
+2023-05-21,58.24323
+2023-05-22,61.8997
+2023-05-23,60.45314
+2023-05-24,62.291973
+2023-05-25,50.42234
+2023-05-26,46.25465
+2023-05-27,47.645393
+2023-05-28,56.927628
+2023-05-29,68.41625
+2023-05-30,67.670425
+2023-05-31,61.362934
+2023-06-01,50.104202
+2023-06-02,42.82667
+2023-06-03,48.37276
+2023-06-04,57.53865
+2023-06-05,70.8721
+2023-06-06,67.9401
+2023-06-07,65.137054
+2023-06-08,52.063274
+2023-06-09,44.64589
+2023-06-10,47.286335
+2023-06-11,55.87432
+2023-06-12,72.30373
+2023-06-13,65.43512
+2023-06-14,65.054306
+2023-06-15,51.20238
+2023-06-16,51.34544
+2023-06-17,51.68654
+2023-06-18,57.930088
+2023-06-19,66.14603
+2023-06-20,66.28492
+2023-06-21,64.22705
+2023-06-22,52.896214
+2023-06-23,45.223904
+2023-06-24,47.04787
+2023-06-25,59.267765
+2023-06-26,71.35559
+2023-06-27,69.079254
+2023-06-28,62.882923
+2023-06-29,55.46864
+2023-06-30,53.168728
+2023-07-01,51.88983
+2023-07-02,57.867218
+2023-07-03,70.28718
+2023-07-04,70.23555
+2023-07-05,68.196106
+2023-07-06,55.510864
+2023-07-07,45.927315
+2023-07-08,47.477207
+2023-07-09,64.40279
+2023-07-10,72.48931
+2023-07-11,68.76072
+2023-07-12,62.789276
+2023-07-13,59.695496
+2023-07-14,46.629585
+2023-07-15,49.247505
+2023-07-16,61.72998
+2023-07-17,66.4845
+2023-07-18,69.63391
+2023-07-19,63.798508
+2023-07-20,56.673885
+2023-07-21,54.523167
+2023-07-22,52.55344
+2023-07-23,62.081818
+2023-07-24,61.867798
+2023-07-25,69.85313
+2023-07-26,62.109146
+2023-07-27,52.354725
+2023-07-28,48.016262
+2023-07-29,51.629314
+2023-07-30,63.247707
+2023-07-31,64.38914
+2023-08-01,70.44118
+2023-08-02,63.536327
+2023-08-03,55.378143
+2023-08-04,54.008995
+2023-08-05,54.59603
+2023-08-06,64.8622
+2023-08-07,68.2548
+2023-08-08,68.61145
+2023-08-09,64.66726
+2023-08-10,57.438652
+2023-08-11,51.88044
+2023-08-12,50.07852
+2023-08-13,61.47147
+2023-08-14,69.753
+2023-08-15,78.6017
+2023-08-16,71.319374
+2023-08-17,54.501434
+2023-08-18,50.83857
+2023-08-19,49.29136
+2023-08-20,59.777878
+2023-08-21,70.36513
+2023-08-22,75.01684
+2023-08-23,63.851585
+2023-08-24,55.448723
+2023-08-25,45.608852
+2023-08-26,53.543686
+2023-08-27,58.712757
+2023-08-28,68.18
+2023-08-29,69.1187
+2023-08-30,66.10605
+2023-08-31,52.487976
+2023-09-01,47.999584
+2023-09-02,60.76943
+2023-09-03,58.387733
+2023-09-04,66.82796
+2023-09-05,77.61002
+2023-09-06,75.45404
+2023-09-07,54.596462
+2023-09-08,51.645973
+2023-09-09,55.75635
+2023-09-10,67.786095
+2023-09-11,67.507744
+2023-09-12,71.71345
+2023-09-13,69.42085
+2023-09-14,59.76546
+2023-09-15,51.97225
+2023-09-16,54.680218
+2023-09-17,58.825314
+2023-09-18,70.10379
+2023-09-19,72.000114
+2023-09-20,68.135345
+2023-09-21,57.14518
+2023-09-22,54.865337
+2023-09-23,58.469833
+2023-09-24,63.76629
+2023-09-25,72.22359
+2023-09-26,73.30875
+2023-09-27,67.78909
+2023-09-28,56.996487
+2023-09-29,54.750202
+2023-09-30,55.489826
+2023-10-01,69.929504
+2023-10-02,76.23838
+2023-10-03,74.65682
+2023-10-04,65.84966
+2023-10-05,56.173927
+2023-10-06,57.72415
+2023-10-07,56.919933
+2023-10-08,65.44043
+2023-10-09,66.63456
+2023-10-10,76.63159
+2023-10-11,69.8521
+2023-10-12,56.52987
+2023-10-13,53.086147
+2023-10-14,57.27284
+2023-10-15,64.5074
+2023-10-16,71.341805
+2023-10-17,73.88882
+2023-10-18,68.08291
+2023-10-19,60.66885
+2023-10-20,59.265198
+2023-10-21,49.13171
+2023-10-22,63.98945
+2023-10-23,73.097855
+2023-10-24,75.43726
+2023-10-25,68.0731
+2023-10-26,55.290997
+2023-10-27,56.184708
+2023-10-28,62.363735
+2023-10-29,60.448418
+2023-10-30,75.509796
+2023-10-31,73.913704
+2023-11-01,69.354866
+2023-11-02,57.75247
+2023-11-03,54.54735
+2023-11-04,61.43182
+2023-11-05,67.147964
+2023-11-06,78.46525
+2023-11-07,78.78152
+2023-11-08,71.2061
+2023-11-09,66.492966
+2023-11-10,57.2177
+2023-11-11,60.36565
+2023-11-12,64.86029
+2023-11-13,73.817955
+2023-11-14,73.50701
+2023-11-15,73.20759
+2023-11-16,58.076252
+2023-11-17,58.59777
+2023-11-18,57.659733
+2023-11-19,69.61374
+2023-11-20,76.220924
+2023-11-21,81.41122
+2023-11-22,72.78116
+2023-11-23,57.24504
+2023-11-24,56.39986
+2023-11-25,55.065662
+2023-11-26,64.89516
+2023-11-27,78.852
+2023-11-28,78.21188
+2023-11-29,68.84205
+2023-11-30,59.27001
+2023-12-01,57.04907
+2023-12-02,55.282005
+2023-12-03,64.78658
+2023-12-04,75.60434
+2023-12-05,80.11521
+2023-12-06,73.11512
+2023-12-07,55.787292
+2023-12-08,58.21382
+2023-12-09,59.497787
+2023-12-10,68.39167
+2023-12-11,79.86694
+2023-12-12,70.80956
+2023-12-13,69.865524
+2023-12-14,64.78388
+2023-12-15,52.905937
+2023-12-16,64.05953
+2023-12-17,68.60507
+2023-12-18,77.908066
+2023-12-19,75.63645
+2023-12-20,74.43013
+2023-12-21,66.566574
+2023-12-22,58.699356
+2023-12-23,60.684887
+2023-12-24,68.661026
+2023-12-25,73.12828
+2023-12-26,77.25669
+2023-12-27,71.88127
+2023-12-28,64.86134
+2023-12-29,61.350193
+2023-12-30,57.15608
+2023-12-31,67.824974

example_hourly_energy.csv

@@ -0,0 +1,1025 @@
+timestamp,value
+2020-01-01 00:00:00,10.0251465
+2020-01-01 01:00:00,10.768732
+2020-01-01 02:00:00,11.665449
+2020-01-01 03:00:00,12.198282
+2020-01-01 04:00:00,12.565463
+2020-01-01 05:00:00,13.063052
+2020-01-01 06:00:00,13.372061
+2020-01-01 07:00:00,13.216603
+2020-01-01 08:00:00,12.604707
+2020-01-01 09:00:00,12.033376
+2020-01-01 10:00:00,11.558016
+2020-01-01 11:00:00,10.984669
+2020-01-01 12:00:00,9.751936
+2020-01-01 13:00:00,9.413419
+2020-01-01 14:00:00,8.500818
+2020-01-01 15:00:00,7.9982424
+2020-01-01 16:00:00,7.574732
+2020-01-01 17:00:00,7.3358727
+2020-01-01 18:00:00,7.394071
+2020-01-01 19:00:00,7.636869
+2020-01-01 20:00:00,7.7163033
+2020-01-01 21:00:00,8.505526
+2020-01-01 22:00:00,8.733487
+2020-01-01 23:00:00,9.672831
+2020-01-02 00:00:00,10.5716095
+2020-01-02 01:00:00,11.197558
+2020-01-02 02:00:00,11.76442
+2020-01-02 03:00:00,12.360337
+2020-01-02 04:00:00,12.939544
+2020-01-02 05:00:00,13.383874
+2020-01-02 06:00:00,13.248561
+2020-01-02 07:00:00,13.314223
+2020-01-02 08:00:00,13.031668
+2020-01-02 09:00:00,12.701431
+2020-01-02 10:00:00,12.020719
+2020-01-02 11:00:00,11.330495
+2020-01-02 12:00:00,10.356698
+2020-01-02 13:00:00,9.688904
+2020-01-02 14:00:00,9.151211
+2020-01-02 15:00:00,8.674222
+2020-01-02 16:00:00,7.6487126
+2020-01-02 17:00:00,7.904658
+2020-01-02 18:00:00,7.769175
+2020-01-02 19:00:00,7.7581353
+2020-01-02 20:00:00,7.953417
+2020-01-02 21:00:00,8.312751
+2020-01-02 22:00:00,9.286019
+2020-01-02 23:00:00,10.106877
+2020-01-03 00:00:00,10.847791
+2020-01-03 01:00:00,11.522441
+2020-01-03 02:00:00,12.049262
+2020-01-03 03:00:00,12.351599
+2020-01-03 04:00:00,13.062622
+2020-01-03 05:00:00,13.487353
+2020-01-03 06:00:00,13.192812
+2020-01-03 07:00:00,13.4188595
+2020-01-03 08:00:00,13.117062
+2020-01-03 09:00:00,12.683891
+2020-01-03 10:00:00,11.676296
+2020-01-03 11:00:00,11.046415
+2020-01-03 12:00:00,10.303629
+2020-01-03 13:00:00,9.368568
+2020-01-03 14:00:00,9.214399
+2020-01-03 15:00:00,8.133051
+2020-01-03 16:00:00,7.807804
+2020-01-03 17:00:00,7.376652
+2020-01-03 18:00:00,7.6284394
+2020-01-03 19:00:00,7.6632047
+2020-01-03 20:00:00,7.8102546
+2020-01-03 21:00:00,7.703994
+2020-01-03 22:00:00,8.760406
+2020-01-03 23:00:00,9.593914
+2020-01-04 00:00:00,10.417734
+2020-01-04 01:00:00,10.852821
+2020-01-04 02:00:00,12.047072
+2020-01-04 03:00:00,12.022374
+2020-01-04 04:00:00,12.613148
+2020-01-04 05:00:00,13.214197
+2020-01-04 06:00:00,13.121072
+2020-01-04 07:00:00,13.3912115
+2020-01-04 08:00:00,12.710301
+2020-01-04 09:00:00,12.050664
+2020-01-04 10:00:00,11.461852
+2020-01-04 11:00:00,10.576923
+2020-01-04 12:00:00,9.744464
+2020-01-04 13:00:00,9.33093
+2020-01-04 14:00:00,8.578868
+2020-01-04 15:00:00,8.081609
+2020-01-04 16:00:00,7.1764817
+2020-01-04 17:00:00,7.3470883
+2020-01-04 18:00:00,6.831262
+2020-01-04 19:00:00,7.2876945
+2020-01-04 20:00:00,7.1679893
+2020-01-04 21:00:00,7.5664434
+2020-01-04 22:00:00,8.367287
+2020-01-04 23:00:00,9.229887
+2020-01-05 00:00:00,9.81526
+2020-01-05 01:00:00,10.425717
+2020-01-05 02:00:00,10.981756
+2020-01-05 03:00:00,11.575
+2020-01-05 04:00:00,12.416953
+2020-01-05 05:00:00,12.79881
+2020-01-05 06:00:00,12.655396
+2020-01-05 07:00:00,12.356761
+2020-01-05 08:00:00,12.432598
+2020-01-05 09:00:00,11.511688
+2020-01-05 10:00:00,10.99086
+2020-01-05 11:00:00,10.521675
+2020-01-05 12:00:00,9.159056
+2020-01-05 13:00:00,8.898518
+2020-01-05 14:00:00,7.9705524
+2020-01-05 15:00:00,7.4771733
+2020-01-05 16:00:00,6.9537706
+2020-01-05 17:00:00,6.7005877
+2020-01-05 18:00:00,6.6883497
+2020-01-05 19:00:00,6.4922676
+2020-01-05 20:00:00,7.220683
+2020-01-05 21:00:00,7.5519567
+2020-01-05 22:00:00,8.19096
+2020-01-05 23:00:00,8.973553
+2020-01-06 00:00:00,9.6700535
+2020-01-06 01:00:00,10.45399
+2020-01-06 02:00:00,11.020703
+2020-01-06 03:00:00,11.339109
+2020-01-06 04:00:00,12.072465
+2020-01-06 05:00:00,12.244225
+2020-01-06 06:00:00,12.215451
+2020-01-06 07:00:00,12.449818
+2020-01-06 08:00:00,11.9857645
+2020-01-06 09:00:00,11.418504
+2020-01-06 10:00:00,10.796985
+2020-01-06 11:00:00,10.338858
+2020-01-06 12:00:00,9.5842705
+2020-01-06 13:00:00,9.005072
+2020-01-06 14:00:00,8.019431
+2020-01-06 15:00:00,7.615106
+2020-01-06 16:00:00,7.21694
+2020-01-06 17:00:00,6.8739743
+2020-01-06 18:00:00,6.0764546
+2020-01-06 19:00:00,6.9059014
+2020-01-06 20:00:00,7.036835
+2020-01-06 21:00:00,7.540072
+2020-01-06 22:00:00,8.161126
+2020-01-06 23:00:00,8.897796
+2020-01-07 00:00:00,9.672967
+2020-01-07 01:00:00,10.325688
+2020-01-07 02:00:00,10.753147
+2020-01-07 03:00:00,11.745984
+2020-01-07 04:00:00,12.097243
+2020-01-07 05:00:00,12.787666
+2020-01-07 06:00:00,12.630502
+2020-01-07 07:00:00,12.617562
+2020-01-07 08:00:00,12.146495
+2020-01-07 09:00:00,11.75318
+2020-01-07 10:00:00,11.247693
+2020-01-07 11:00:00,10.245748
+2020-01-07 12:00:00,9.843195
+2020-01-07 13:00:00,9.002382
+2020-01-07 14:00:00,8.080186
+2020-01-07 15:00:00,7.2338934
+2020-01-07 16:00:00,7.3571568
+2020-01-07 17:00:00,6.913296
+2020-01-07 18:00:00,6.7827377
+2020-01-07 19:00:00,6.9620357
+2020-01-07 20:00:00,7.6906977
+2020-01-07 21:00:00,7.812737
+2020-01-07 22:00:00,8.479959
+2020-01-07 23:00:00,8.907433
+2020-01-08 00:00:00,10.329468
+2020-01-08 01:00:00,10.97865
+2020-01-08 02:00:00,11.750752
+2020-01-08 03:00:00,12.186837
+2020-01-08 04:00:00,12.855928
+2020-01-08 05:00:00,13.064922
+2020-01-08 06:00:00,13.233898
+2020-01-08 07:00:00,12.996748
+2020-01-08 08:00:00,12.450676
+2020-01-08 09:00:00,12.49223
+2020-01-08 10:00:00,11.295678
+2020-01-08 11:00:00,10.928416
+2020-01-08 12:00:00,10.176038
+2020-01-08 13:00:00,9.248605
+2020-01-08 14:00:00,8.872624
+2020-01-08 15:00:00,8.1046295
+2020-01-08 16:00:00,7.59621
+2020-01-08 17:00:00,7.503101
+2020-01-08 18:00:00,7.216429
+2020-01-08 19:00:00,7.7061625
+2020-01-08 20:00:00,7.812301
+2020-01-08 21:00:00,8.137366
+2020-01-08 22:00:00,8.477673
+2020-01-08 23:00:00,9.340978
+2020-01-09 00:00:00,10.608282
+2020-01-09 01:00:00,11.168635
+2020-01-09 02:00:00,11.856494
+2020-01-09 03:00:00,12.873333
+2020-01-09 04:00:00,12.774559
+2020-01-09 05:00:00,13.222704
+2020-01-09 06:00:00,13.355967
+2020-01-09 07:00:00,13.473326
+2020-01-09 08:00:00,12.930806
+2020-01-09 09:00:00,12.470578
+2020-01-09 10:00:00,11.656756
+2020-01-09 11:00:00,11.40529
+2020-01-09 12:00:00,10.648692
+2020-01-09 13:00:00,9.619551
+2020-01-09 14:00:00,9.027083
+2020-01-09 15:00:00,8.117006
+2020-01-09 16:00:00,7.806163
+2020-01-09 17:00:00,7.877463
+2020-01-09 18:00:00,7.5271463
+2020-01-09 19:00:00,8.063946
+2020-01-09 20:00:00,7.7430873
+2020-01-09 21:00:00,8.491592
+2020-01-09 22:00:00,8.955315
+2020-01-09 23:00:00,9.82799
+2020-01-10 00:00:00,10.486022
+2020-01-10 01:00:00,11.147181
+2020-01-10 02:00:00,11.804263
+2020-01-10 03:00:00,13.20647
+2020-01-10 04:00:00,13.048044
+2020-01-10 05:00:00,12.952726
+2020-01-10 06:00:00,13.320765
+2020-01-10 07:00:00,13.475443
+2020-01-10 08:00:00,12.9310875
+2020-01-10 09:00:00,12.8167715
+2020-01-10 10:00:00,12.113599
+2020-01-10 11:00:00,11.148289
+2020-01-10 12:00:00,10.296473
+2020-01-10 13:00:00,9.401568
+2020-01-10 14:00:00,8.726533
+2020-01-10 15:00:00,7.9376044
+2020-01-10 16:00:00,7.9828897
+2020-01-10 17:00:00,7.746506
+2020-01-10 18:00:00,7.0605173
+2020-01-10 19:00:00,7.162796
+2020-01-10 20:00:00,7.3298817
+2020-01-10 21:00:00,7.951925
+2020-01-10 22:00:00,8.128733
+2020-01-10 23:00:00,9.228722
+2020-01-11 00:00:00,10.476325
+2020-01-11 01:00:00,10.907269
+2020-01-11 02:00:00,11.853587
+2020-01-11 03:00:00,12.188666
+2020-01-11 04:00:00,13.097588
+2020-01-11 05:00:00,13.067031
+2020-01-11 06:00:00,13.03486
+2020-01-11 07:00:00,13.501218
+2020-01-11 08:00:00,12.607703
+2020-01-11 09:00:00,11.933058
+2020-01-11 10:00:00,11.577747
+2020-01-11 11:00:00,10.787386
+2020-01-11 12:00:00,10.213264
+2020-01-11 13:00:00,9.02052
+2020-01-11 14:00:00,8.623578
+2020-01-11 15:00:00,7.993247
+2020-01-11 16:00:00,7.1938653
+2020-01-11 17:00:00,7.0419154
+2020-01-11 18:00:00,6.722589
+2020-01-11 19:00:00,7.4419746
+2020-01-11 20:00:00,7.1137185
+2020-01-11 21:00:00,7.6229253
+2020-01-11 22:00:00,8.104162
+2020-01-11 23:00:00,8.954372
+2020-01-12 00:00:00,9.781883
+2020-01-12 01:00:00,10.696381
+2020-01-12 02:00:00,11.127903
+2020-01-12 03:00:00,11.81815
+2020-01-12 04:00:00,12.033118
+2020-01-12 05:00:00,12.435387
+2020-01-12 06:00:00,13.239417
+2020-01-12 07:00:00,12.779882
+2020-01-12 08:00:00,12.101705
+2020-01-12 09:00:00,11.500287
+2020-01-12 10:00:00,10.938357
+2020-01-12 11:00:00,10.393133
+2020-01-12 12:00:00,9.61603
+2020-01-12 13:00:00,8.672372
+2020-01-12 14:00:00,7.8295655
+2020-01-12 15:00:00,7.7397933
+2020-01-12 16:00:00,7.059248
+2020-01-12 17:00:00,6.5852513
+2020-01-12 18:00:00,6.5053835
+2020-01-12 19:00:00,6.5380354
+2020-01-12 20:00:00,6.349278
+2020-01-12 21:00:00,7.42987
+2020-01-12 22:00:00,7.8081045
+2020-01-12 23:00:00,8.540043
+2020-01-13 00:00:00,9.384483
+2020-01-13 01:00:00,10.431634
+2020-01-13 02:00:00,10.771479
+2020-01-13 03:00:00,11.337608
+2020-01-13 04:00:00,12.227445
+2020-01-13 05:00:00,12.549001
+2020-01-13 06:00:00,12.308213
+2020-01-13 07:00:00,12.510607
+2020-01-13 08:00:00,12.041148
+2020-01-13 09:00:00,11.684723
+2020-01-13 10:00:00,10.753392
+2020-01-13 11:00:00,10.451753
+2020-01-13 12:00:00,9.753188
+2020-01-13 13:00:00,8.867994
+2020-01-13 14:00:00,8.133882
+2020-01-13 15:00:00,6.652283
+2020-01-13 16:00:00,6.9886127
+2020-01-13 17:00:00,6.638852
+2020-01-13 18:00:00,6.5201063
+2020-01-13 19:00:00,6.534049
+2020-01-13 20:00:00,6.9799843
+2020-01-13 21:00:00,7.537741
+2020-01-13 22:00:00,8.034123
+2020-01-13 23:00:00,8.7285795
+2020-01-14 00:00:00,9.855035
+2020-01-14 01:00:00,10.176398
+2020-01-14 02:00:00,11.339505
+2020-01-14 03:00:00,11.803129
+2020-01-14 04:00:00,12.097129
+2020-01-14 05:00:00,12.513638
+2020-01-14 06:00:00,12.504256
+2020-01-14 07:00:00,12.73588
+2020-01-14 08:00:00,12.385997
+2020-01-14 09:00:00,11.743945
+2020-01-14 10:00:00,11.029556
+2020-01-14 11:00:00,10.603166
+2020-01-14 12:00:00,9.974535
+2020-01-14 13:00:00,9.00083
+2020-01-14 14:00:00,8.401
+2020-01-14 15:00:00,7.6383348
+2020-01-14 16:00:00,7.26806
+2020-01-14 17:00:00,6.9145565
+2020-01-14 18:00:00,6.947548
+2020-01-14 19:00:00,6.707312
+2020-01-14 20:00:00,7.4562407
+2020-01-14 21:00:00,7.776711
+2020-01-14 22:00:00,8.534356
+2020-01-14 23:00:00,9.1367855
+2020-01-15 00:00:00,10.064073
+2020-01-15 01:00:00,10.58064
+2020-01-15 02:00:00,11.775196
+2020-01-15 03:00:00,11.836594
+2020-01-15 04:00:00,12.464749
+2020-01-15 05:00:00,13.037867
+2020-01-15 06:00:00,13.403829
+2020-01-15 07:00:00,13.082812
+2020-01-15 08:00:00,12.695872
+2020-01-15 09:00:00,12.001442
+2020-01-15 10:00:00,11.644415
+2020-01-15 11:00:00,10.972427
+2020-01-15 12:00:00,10.555056
+2020-01-15 13:00:00,9.581602
+2020-01-15 14:00:00,8.444181
+2020-01-15 15:00:00,8.550052
+2020-01-15 16:00:00,7.604582
+2020-01-15 17:00:00,7.223241
+2020-01-15 18:00:00,7.6067095
+2020-01-15 19:00:00,7.418415
+2020-01-15 20:00:00,7.6685295
+2020-01-15 21:00:00,8.2759905
+2020-01-15 22:00:00,9.035503
+2020-01-15 23:00:00,9.801196
+2020-01-16 00:00:00,10.115875
+2020-01-16 01:00:00,11.578452
+2020-01-16 02:00:00,12.102491
+2020-01-16 03:00:00,12.4688425
+2020-01-16 04:00:00,12.867357
+2020-01-16 05:00:00,13.146032
+2020-01-16 06:00:00,13.47516
+2020-01-16 07:00:00,13.226456
+2020-01-16 08:00:00,12.910539
+2020-01-16 09:00:00,12.755513
+2020-01-16 10:00:00,12.0507
+2020-01-16 11:00:00,11.180506
+2020-01-16 12:00:00,10.634314
+2020-01-16 13:00:00,9.988302
+2020-01-16 14:00:00,8.7755165
+2020-01-16 15:00:00,8.254877
+2020-01-16 16:00:00,8.08905
+2020-01-16 17:00:00,7.745661
+2020-01-16 18:00:00,7.5453396
+2020-01-16 19:00:00,7.8343573
+2020-01-16 20:00:00,7.6828833
+2020-01-16 21:00:00,8.079708
+2020-01-16 22:00:00,8.821114
+2020-01-16 23:00:00,9.739335
+2020-01-17 00:00:00,10.328247
+2020-01-17 01:00:00,11.161977
+2020-01-17 02:00:00,11.782786
+2020-01-17 03:00:00,12.469176
+2020-01-17 04:00:00,12.8625555
+2020-01-17 05:00:00,13.429552
+2020-01-17 06:00:00,13.609463
+2020-01-17 07:00:00,13.243746
+2020-01-17 08:00:00,12.989635
+2020-01-17 09:00:00,12.428476
+2020-01-17 10:00:00,12.01937
+2020-01-17 11:00:00,11.196568
+2020-01-17 12:00:00,10.709747
+2020-01-17 13:00:00,9.383434
+2020-01-17 14:00:00,8.939027
+2020-01-17 15:00:00,8.321032
+2020-01-17 16:00:00,7.6699224
+2020-01-17 17:00:00,7.545073
+2020-01-17 18:00:00,7.02404
+2020-01-17 19:00:00,7.822893
+2020-01-17 20:00:00,7.415175
+2020-01-17 21:00:00,8.328657
+2020-01-17 22:00:00,8.525776
+2020-01-17 23:00:00,9.687354
+2020-01-18 00:00:00,10.139987
+2020-01-18 01:00:00,11.008088
+2020-01-18 02:00:00,11.693339
+2020-01-18 03:00:00,12.506607
+2020-01-18 04:00:00,12.681145
+2020-01-18 05:00:00,12.43375
+2020-01-18 06:00:00,12.959249
+2020-01-18 07:00:00,13.027475
+2020-01-18 08:00:00,12.584504
+2020-01-18 09:00:00,12.331266
+2020-01-18 10:00:00,11.740431
+2020-01-18 11:00:00,10.765598
+2020-01-18 12:00:00,9.702071
+2020-01-18 13:00:00,9.48168
+2020-01-18 14:00:00,8.679246
+2020-01-18 15:00:00,7.7628593
+2020-01-18 16:00:00,7.74906
+2020-01-18 17:00:00,6.9394917
+2020-01-18 18:00:00,6.6613154
+2020-01-18 19:00:00,6.9416385
+2020-01-18 20:00:00,7.470113
+2020-01-18 21:00:00,7.5260496
+2020-01-18 22:00:00,8.707575
+2020-01-18 23:00:00,8.844292
+2020-01-19 00:00:00,9.973943
+2020-01-19 01:00:00,10.651715
+2020-01-19 02:00:00,11.219189
+2020-01-19 03:00:00,12.071411
+2020-01-19 04:00:00,12.016457
+2020-01-19 05:00:00,12.872382
+2020-01-19 06:00:00,12.675518
+2020-01-19 07:00:00,12.463147
+2020-01-19 08:00:00,12.4078245
+2020-01-19 09:00:00,11.979747
+2020-01-19 10:00:00,11.287434
+2020-01-19 11:00:00,10.797372
+2020-01-19 12:00:00,9.82523
+2020-01-19 13:00:00,9.077946
+2020-01-19 14:00:00,7.978908
+2020-01-19 15:00:00,7.476622
+2020-01-19 16:00:00,7.0815077
+2020-01-19 17:00:00,6.656616
+2020-01-19 18:00:00,6.609843
+2020-01-19 19:00:00,6.729162
+2020-01-19 20:00:00,7.1053357
+2020-01-19 21:00:00,7.3864164
+2020-01-19 22:00:00,7.952254
+2020-01-19 23:00:00,8.574917
+2020-01-20 00:00:00,9.334189
+2020-01-20 01:00:00,10.519664
+2020-01-20 02:00:00,10.98868
+2020-01-20 03:00:00,11.781853
+2020-01-20 04:00:00,11.840001
+2020-01-20 05:00:00,12.010493
+2020-01-20 06:00:00,12.290182
+2020-01-20 07:00:00,12.627453
+2020-01-20 08:00:00,12.313089
+2020-01-20 09:00:00,11.690872
+2020-01-20 10:00:00,10.845151
+2020-01-20 11:00:00,10.259013
+2020-01-20 12:00:00,9.452984
+2020-01-20 13:00:00,8.671585
+2020-01-20 14:00:00,7.5209994
+2020-01-20 15:00:00,7.2351527
+2020-01-20 16:00:00,6.898465
+2020-01-20 17:00:00,6.947227
+2020-01-20 18:00:00,6.581664
+2020-01-20 19:00:00,6.9403424
+2020-01-20 20:00:00,6.8901696
+2020-01-20 21:00:00,7.40478
+2020-01-20 22:00:00,7.3069963
+2020-01-20 23:00:00,8.91391
+2020-01-21 00:00:00,9.718503
+2020-01-21 01:00:00,10.750223
+2020-01-21 02:00:00,11.036121
+2020-01-21 03:00:00,11.786598
+2020-01-21 04:00:00,12.116884
+2020-01-21 05:00:00,12.336382
+2020-01-21 06:00:00,12.545633
+2020-01-21 07:00:00,12.531868
+2020-01-21 08:00:00,12.587503
+2020-01-21 09:00:00,11.855746
+2020-01-21 10:00:00,11.091891
+2020-01-21 11:00:00,10.571198
+2020-01-21 12:00:00,9.826572
+2020-01-21 13:00:00,8.8883505
+2020-01-21 14:00:00,8.545977
+2020-01-21 15:00:00,7.3358703
+2020-01-21 16:00:00,7.2118373
+2020-01-21 17:00:00,7.1058264
+2020-01-21 18:00:00,6.621053
+2020-01-21 19:00:00,7.0815177
+2020-01-21 20:00:00,7.5859814
+2020-01-21 21:00:00,7.9134316
+2020-01-21 22:00:00,8.124603
+2020-01-21 23:00:00,9.059208
+2020-01-22 00:00:00,10.246461
+2020-01-22 01:00:00,10.85482
+2020-01-22 02:00:00,11.535394
+2020-01-22 03:00:00,12.265543
+2020-01-22 04:00:00,12.816807
+2020-01-22 05:00:00,12.84904
+2020-01-22 06:00:00,13.053181
+2020-01-22 07:00:00,13.05577
+2020-01-22 08:00:00,12.6366625
+2020-01-22 09:00:00,12.259769
+2020-01-22 10:00:00,11.942245
+2020-01-22 11:00:00,10.782839
+2020-01-22 12:00:00,10.602274
+2020-01-22 13:00:00,9.833046
+2020-01-22 14:00:00,8.407312
+2020-01-22 15:00:00,8.116491
+2020-01-22 16:00:00,7.752122
+2020-01-22 17:00:00,7.2469583
+2020-01-22 18:00:00,7.163529
+2020-01-22 19:00:00,7.380883
+2020-01-22 20:00:00,7.889846
+2020-01-22 21:00:00,8.129967
+2020-01-22 22:00:00,9.231865
+2020-01-22 23:00:00,9.660523
+2020-01-23 00:00:00,10.3704
+2020-01-23 01:00:00,11.468608
+2020-01-23 02:00:00,12.038376
+2020-01-23 03:00:00,12.61854
+2020-01-23 04:00:00,12.964861
+2020-01-23 05:00:00,13.702632
+2020-01-23 06:00:00,13.612848
+2020-01-23 07:00:00,13.315376
+2020-01-23 08:00:00,12.748074
+2020-01-23 09:00:00,12.667852
+2020-01-23 10:00:00,11.749039
+2020-01-23 11:00:00,10.916231
+2020-01-23 12:00:00,10.431634
+2020-01-23 13:00:00,9.77112
+2020-01-23 14:00:00,9.250912
+2020-01-23 15:00:00,8.432026
+2020-01-23 16:00:00,8.061729
+2020-01-23 17:00:00,7.356696
+2020-01-23 18:00:00,7.4954934
+2020-01-23 19:00:00,7.626715
+2020-01-23 20:00:00,8.072975
+2020-01-23 21:00:00,8.398747
+2020-01-23 22:00:00,9.155231
+2020-01-23 23:00:00,9.613986
+2020-01-24 00:00:00,10.559055
+2020-01-24 01:00:00,11.342393
+2020-01-24 02:00:00,11.727831
+2020-01-24 03:00:00,12.628369
+2020-01-24 04:00:00,12.99944
+2020-01-24 05:00:00,12.975241
+2020-01-24 06:00:00,13.642166
+2020-01-24 07:00:00,13.267464
+2020-01-24 08:00:00,12.860611
+2020-01-24 09:00:00,12.469219
+2020-01-24 10:00:00,11.94076
+2020-01-24 11:00:00,11.480338
+2020-01-24 12:00:00,10.357729
+2020-01-24 13:00:00,9.69701
+2020-01-24 14:00:00,9.141242
+2020-01-24 15:00:00,8.3389435
+2020-01-24 16:00:00,7.955723
+2020-01-24 17:00:00,7.333064
+2020-01-24 18:00:00,7.465955
+2020-01-24 19:00:00,7.3875375
+2020-01-24 20:00:00,7.898466
+2020-01-24 21:00:00,7.9439836
+2020-01-24 22:00:00,8.594089
+2020-01-24 23:00:00,9.710923
+2020-01-25 00:00:00,10.177725
+2020-01-25 01:00:00,10.904611
+2020-01-25 02:00:00,11.698185
+2020-01-25 03:00:00,12.148561
+2020-01-25 04:00:00,13.011842
+2020-01-25 05:00:00,12.777354
+2020-01-25 06:00:00,13.0811405
+2020-01-25 07:00:00,13.060123
+2020-01-25 08:00:00,12.651708
+2020-01-25 09:00:00,12.016845
+2020-01-25 10:00:00,11.3636875
+2020-01-25 11:00:00,10.880232
+2020-01-25 12:00:00,9.793904
+2020-01-25 13:00:00,9.334096
+2020-01-25 14:00:00,8.157805
+2020-01-25 15:00:00,7.711701
+2020-01-25 16:00:00,7.334664
+2020-01-25 17:00:00,6.7588363
+2020-01-25 18:00:00,7.0191417
+2020-01-25 19:00:00,6.9691052
+2020-01-25 20:00:00,7.0473313
+2020-01-25 21:00:00,7.4097624
+2020-01-25 22:00:00,8.004211
+2020-01-25 23:00:00,9.033804
+2020-01-26 00:00:00,9.551692
+2020-01-26 01:00:00,10.269847
+2020-01-26 02:00:00,11.203754
+2020-01-26 03:00:00,12.310804
+2020-01-26 04:00:00,12.371924
+2020-01-26 05:00:00,12.753451
+2020-01-26 06:00:00,12.730799
+2020-01-26 07:00:00,12.72823
+2020-01-26 08:00:00,11.989372
+2020-01-26 09:00:00,11.681664
+2020-01-26 10:00:00,11.185744
+2020-01-26 11:00:00,10.3938875
+2020-01-26 12:00:00,9.570685
+2020-01-26 13:00:00,8.688068
+2020-01-26 14:00:00,8.035204
+2020-01-26 15:00:00,7.300478
+2020-01-26 16:00:00,6.4845443
+2020-01-26 17:00:00,6.421263
+2020-01-26 18:00:00,6.644646
+2020-01-26 19:00:00,6.955357
+2020-01-26 20:00:00,7.299203
+2020-01-26 21:00:00,7.4260883
+2020-01-26 22:00:00,8.200891
+2020-01-26 23:00:00,8.922175
+2020-01-27 00:00:00,9.374084
+2020-01-27 01:00:00,9.945586
+2020-01-27 02:00:00,11.011762
+2020-01-27 03:00:00,11.272024
+2020-01-27 04:00:00,12.035488
+2020-01-27 05:00:00,12.519751
+2020-01-27 06:00:00,12.215986
+2020-01-27 07:00:00,12.404586
+2020-01-27 08:00:00,12.347478
+2020-01-27 09:00:00,11.696767
+2020-01-27 10:00:00,11.110049
+2020-01-27 11:00:00,10.466522
+2020-01-27 12:00:00,9.859129
+2020-01-27 13:00:00,8.7708645
+2020-01-27 14:00:00,8.268114
+2020-01-27 15:00:00,7.393904
+2020-01-27 16:00:00,6.8272533
+2020-01-27 17:00:00,6.7069054
+2020-01-27 18:00:00,6.428353
+2020-01-27 19:00:00,6.545539
+2020-01-27 20:00:00,6.847363
+2020-01-27 21:00:00,6.9962325
+2020-01-27 22:00:00,8.107981
+2020-01-27 23:00:00,8.568477
+2020-01-28 00:00:00,9.58763
+2020-01-28 01:00:00,10.687465
+2020-01-28 02:00:00,11.029274
+2020-01-28 03:00:00,11.659365
+2020-01-28 04:00:00,12.530771
+2020-01-28 05:00:00,12.680895
+2020-01-28 06:00:00,12.88356
+2020-01-28 07:00:00,12.529809
+2020-01-28 08:00:00,12.466033
+2020-01-28 09:00:00,11.718071
+2020-01-28 10:00:00,11.1147995
+2020-01-28 11:00:00,10.662071
+2020-01-28 12:00:00,9.6633835
+2020-01-28 13:00:00,9.177021
+2020-01-28 14:00:00,8.795667
+2020-01-28 15:00:00,7.3763094
+2020-01-28 16:00:00,7.1041055
+2020-01-28 17:00:00,7.196842
+2020-01-28 18:00:00,6.859724
+2020-01-28 19:00:00,7.2414846
+2020-01-28 20:00:00,7.1253896
+2020-01-28 21:00:00,7.888966
+2020-01-28 22:00:00,8.432524
+2020-01-28 23:00:00,9.232922
+2020-01-29 00:00:00,10.066223
+2020-01-29 01:00:00,10.551151
+2020-01-29 02:00:00,11.322537
+2020-01-29 03:00:00,12.457151
+2020-01-29 04:00:00,12.73124
+2020-01-29 05:00:00,13.012003
+2020-01-29 06:00:00,13.102446
+2020-01-29 07:00:00,13.0984955
+2020-01-29 08:00:00,12.514266
+2020-01-29 09:00:00,12.086655
+2020-01-29 10:00:00,11.943572
+2020-01-29 11:00:00,11.006659
+2020-01-29 12:00:00,10.387002
+2020-01-29 13:00:00,9.336044
+2020-01-29 14:00:00,9.025345
+2020-01-29 15:00:00,8.213752
+2020-01-29 16:00:00,7.779833
+2020-01-29 17:00:00,7.5088787
+2020-01-29 18:00:00,7.1523433
+2020-01-29 19:00:00,7.055222
+2020-01-29 20:00:00,7.5270495
+2020-01-29 21:00:00,8.558337
+2020-01-29 22:00:00,9.126662
+2020-01-29 23:00:00,9.533144
+2020-01-30 00:00:00,10.330581
+2020-01-30 01:00:00,11.386077
+2020-01-30 02:00:00,11.879437
+2020-01-30 03:00:00,12.28483
+2020-01-30 04:00:00,13.284198
+2020-01-30 05:00:00,13.435271
+2020-01-30 06:00:00,12.947216
+2020-01-30 07:00:00,13.293421
+2020-01-30 08:00:00,13.092247
+2020-01-30 09:00:00,12.689511
+2020-01-30 10:00:00,12.008217
+2020-01-30 11:00:00,11.132272
+2020-01-30 12:00:00,10.464313
+2020-01-30 13:00:00,9.773787
+2020-01-30 14:00:00,8.940815
+2020-01-30 15:00:00,8.301156
+2020-01-30 16:00:00,8.150943
+2020-01-30 17:00:00,7.4125514
+2020-01-30 18:00:00,7.430107
+2020-01-30 19:00:00,7.195619
+2020-01-30 20:00:00,8.008719
+2020-01-30 21:00:00,8.541188
+2020-01-30 22:00:00,9.104113
+2020-01-30 23:00:00,9.89836
+2020-01-31 00:00:00,10.575605
+2020-01-31 01:00:00,11.327923
+2020-01-31 02:00:00,12.072576
+2020-01-31 03:00:00,12.539801
+2020-01-31 04:00:00,13.301179
+2020-01-31 05:00:00,13.286345
+2020-01-31 06:00:00,13.158014
+2020-01-31 07:00:00,13.509792
+2020-01-31 08:00:00,13.40123
+2020-01-31 09:00:00,12.352653
+2020-01-31 10:00:00,11.892793
+2020-01-31 11:00:00,11.041668
+2020-01-31 12:00:00,10.314799
+2020-01-31 13:00:00,9.611748
+2020-01-31 14:00:00,8.618164
+2020-01-31 15:00:00,8.1767025
+2020-01-31 16:00:00,7.448817
+2020-01-31 17:00:00,7.3147206
+2020-01-31 18:00:00,7.074531
+2020-01-31 19:00:00,7.1873207
+2020-01-31 20:00:00,7.3396015
+2020-01-31 21:00:00,8.388567
+2020-01-31 22:00:00,8.851811
+2020-01-31 23:00:00,9.073685
+2020-02-01 00:00:00,10.097576
+2020-02-01 01:00:00,10.842316
+2020-02-01 02:00:00,11.544481
+2020-02-01 03:00:00,11.997083
+2020-02-01 04:00:00,12.896331
+2020-02-01 05:00:00,12.948014
+2020-02-01 06:00:00,13.20489
+2020-02-01 07:00:00,13.096085
+2020-02-01 08:00:00,12.947686
+2020-02-01 09:00:00,11.814328
+2020-02-01 10:00:00,11.885085
+2020-02-01 11:00:00,11.048916
+2020-02-01 12:00:00,10.114614
+2020-02-01 13:00:00,9.681565
+2020-02-01 14:00:00,8.503631
+2020-02-01 15:00:00,7.9869933
+2020-02-01 16:00:00,7.17972
+2020-02-01 17:00:00,7.2361383
+2020-02-01 18:00:00,6.9223046
+2020-02-01 19:00:00,6.882573
+2020-02-01 20:00:00,7.677934
+2020-02-01 21:00:00,7.6525803
+2020-02-01 22:00:00,8.319101
+2020-02-01 23:00:00,8.98414
+2020-02-02 00:00:00,9.631924
+2020-02-02 01:00:00,10.649077
+2020-02-02 02:00:00,11.397682
+2020-02-02 03:00:00,11.926179
+2020-02-02 04:00:00,11.8443
+2020-02-02 05:00:00,12.802466
+2020-02-02 06:00:00,12.618207
+2020-02-02 07:00:00,12.328369
+2020-02-02 08:00:00,12.378646
+2020-02-02 09:00:00,11.880337
+2020-02-02 10:00:00,10.924859
+2020-02-02 11:00:00,10.891958
+2020-02-02 12:00:00,9.367159
+2020-02-02 13:00:00,8.474644
+2020-02-02 14:00:00,7.856046
+2020-02-02 15:00:00,7.7394776
+2020-02-02 16:00:00,6.9337397
+2020-02-02 17:00:00,6.5857534
+2020-02-02 18:00:00,6.537084
+2020-02-02 19:00:00,6.5246186
+2020-02-02 20:00:00,6.7984343
+2020-02-02 21:00:00,7.278495
+2020-02-02 22:00:00,8.163805
+2020-02-02 23:00:00,8.944671
+2020-02-03 00:00:00,9.3015175
+2020-02-03 01:00:00,10.333019
+2020-02-03 02:00:00,11.163226
+2020-02-03 03:00:00,11.4081135
+2020-02-03 04:00:00,11.998961
+2020-02-03 05:00:00,12.190515
+2020-02-03 06:00:00,12.241795
+2020-02-03 07:00:00,12.4185
+2020-02-03 08:00:00,11.952248
+2020-02-03 09:00:00,11.75069
+2020-02-03 10:00:00,10.999701
+2020-02-03 11:00:00,10.3677
+2020-02-03 12:00:00,9.45408
+2020-02-03 13:00:00,8.613581
+2020-02-03 14:00:00,8.004079
+2020-02-03 15:00:00,7.405739
+2020-02-03 16:00:00,6.7953157
+2020-02-03 17:00:00,6.7292604
+2020-02-03 18:00:00,6.6988344
+2020-02-03 19:00:00,6.6917815
+2020-02-03 20:00:00,7.3116093
+2020-02-03 21:00:00,7.32885
+2020-02-03 22:00:00,8.191
+2020-02-03 23:00:00,8.739497
+2020-02-04 00:00:00,9.656011
+2020-02-04 01:00:00,10.231482
+2020-02-04 02:00:00,11.356499
+2020-02-04 03:00:00,11.802971
+2020-02-04 04:00:00,12.496439
+2020-02-04 05:00:00,12.318415
+2020-02-04 06:00:00,12.589552
+2020-02-04 07:00:00,12.422355
+2020-02-04 08:00:00,12.210028
+2020-02-04 09:00:00,11.716783
+2020-02-04 10:00:00,11.225892
+2020-02-04 11:00:00,10.539373
+2020-02-04 12:00:00,9.774861
+2020-02-04 13:00:00,8.912492
+2020-02-04 14:00:00,8.354815
+2020-02-04 15:00:00,7.8886633
+2020-02-04 16:00:00,7.074091
+2020-02-04 17:00:00,6.9729905
+2020-02-04 18:00:00,6.873925
+2020-02-04 19:00:00,7.1029377
+2020-02-04 20:00:00,7.314631
+2020-02-04 21:00:00,7.8195643
+2020-02-04 22:00:00,8.264416
+2020-02-04 23:00:00,9.209188
+2020-02-05 00:00:00,9.815623
+2020-02-05 01:00:00,10.8982935
+2020-02-05 02:00:00,11.516722
+2020-02-05 03:00:00,12.185274
+2020-02-05 04:00:00,12.494359
+2020-02-05 05:00:00,13.1514845
+2020-02-05 06:00:00,13.249723
+2020-02-05 07:00:00,13.1994915
+2020-02-05 08:00:00,13.190931
+2020-02-05 09:00:00,12.275956
+2020-02-05 10:00:00,11.923351
+2020-02-05 11:00:00,10.951637
+2020-02-05 12:00:00,10.295759
+2020-02-05 13:00:00,9.530245
+2020-02-05 14:00:00,8.802918
+2020-02-05 15:00:00,8.276347
+2020-02-05 16:00:00,7.6227965
+2020-02-05 17:00:00,7.407319
+2020-02-05 18:00:00,7.418807
+2020-02-05 19:00:00,7.777937
+2020-02-05 20:00:00,7.573539
+2020-02-05 21:00:00,7.8710065
+2020-02-05 22:00:00,8.769709
+2020-02-05 23:00:00,9.620515
+2020-02-06 00:00:00,10.425911
+2020-02-06 01:00:00,11.1972
+2020-02-06 02:00:00,12.149677
+2020-02-06 03:00:00,12.739892
+2020-02-06 04:00:00,13.021235
+2020-02-06 05:00:00,13.245926
+2020-02-06 06:00:00,13.381283
+2020-02-06 07:00:00,13.284798
+2020-02-06 08:00:00,13.0183935
+2020-02-06 09:00:00,12.278732
+2020-02-06 10:00:00,11.885578
+2020-02-06 11:00:00,11.174444
+2020-02-06 12:00:00,10.449688
+2020-02-06 13:00:00,9.663966
+2020-02-06 14:00:00,9.128817
+2020-02-06 15:00:00,8.269147
+2020-02-06 16:00:00,7.81281
+2020-02-06 17:00:00,7.7102604
+2020-02-06 18:00:00,7.452937
+2020-02-06 19:00:00,7.645164
+2020-02-06 20:00:00,8.034392
+2020-02-06 21:00:00,8.459929
+2020-02-06 22:00:00,9.044448
+2020-02-06 23:00:00,9.675538
+2020-02-07 00:00:00,10.623843
+2020-02-07 01:00:00,11.29453
+2020-02-07 02:00:00,11.876816
+2020-02-07 03:00:00,12.5631
+2020-02-07 04:00:00,12.819887
+2020-02-07 05:00:00,13.163748
+2020-02-07 06:00:00,13.073903
+2020-02-07 07:00:00,13.203849
+2020-02-07 08:00:00,13.298198
+2020-02-07 09:00:00,12.433385
+2020-02-07 10:00:00,12.070627
+2020-02-07 11:00:00,11.178066
+2020-02-07 12:00:00,10.250806
+2020-02-07 13:00:00,9.870185
+2020-02-07 14:00:00,8.982967
+2020-02-07 15:00:00,7.881873
+2020-02-07 16:00:00,7.9502907
+2020-02-07 17:00:00,7.213408
+2020-02-07 18:00:00,7.276162
+2020-02-07 19:00:00,7.5327554
+2020-02-07 20:00:00,7.6236134
+2020-02-07 21:00:00,8.3684845
+2020-02-07 22:00:00,8.902253
+2020-02-07 23:00:00,9.141802
+2020-02-08 00:00:00,10.122455
+2020-02-08 01:00:00,11.032818
+2020-02-08 02:00:00,11.567671
+2020-02-08 03:00:00,12.243204
+2020-02-08 04:00:00,12.905411
+2020-02-08 05:00:00,13.090543
+2020-02-08 06:00:00,12.927136
+2020-02-08 07:00:00,13.025655
+2020-02-08 08:00:00,12.550143
+2020-02-08 09:00:00,11.934264
+2020-02-08 10:00:00,11.311354
+2020-02-08 11:00:00,10.852544
+2020-02-08 12:00:00,9.994377
+2020-02-08 13:00:00,9.205934
+2020-02-08 14:00:00,8.233393
+2020-02-08 15:00:00,7.7859116
+2020-02-08 16:00:00,7.1199694
+2020-02-08 17:00:00,6.823988
+2020-02-08 18:00:00,6.8557143
+2020-02-08 19:00:00,6.696135
+2020-02-08 20:00:00,7.3883996
+2020-02-08 21:00:00,8.2109165
+2020-02-08 22:00:00,8.409094
+2020-02-08 23:00:00,8.815016
+2020-02-09 00:00:00,9.728821
+2020-02-09 01:00:00,10.231735
+2020-02-09 02:00:00,11.174477
+2020-02-09 03:00:00,11.956767
+2020-02-09 04:00:00,12.434293
+2020-02-09 05:00:00,12.394519
+2020-02-09 06:00:00,12.748084
+2020-02-09 07:00:00,12.802916
+2020-02-09 08:00:00,12.609008
+2020-02-09 09:00:00,11.627608
+2020-02-09 10:00:00,10.960634
+2020-02-09 11:00:00,10.408355
+2020-02-09 12:00:00,9.023466
+2020-02-09 13:00:00,8.715037
+2020-02-09 14:00:00,8.032685
+2020-02-09 15:00:00,7.363449
+2020-02-09 16:00:00,6.6521363
+2020-02-09 17:00:00,6.6110544
+2020-02-09 18:00:00,6.3941936
+2020-02-09 19:00:00,6.795438
+2020-02-09 20:00:00,6.752792
+2020-02-09 21:00:00,7.350269
+2020-02-09 22:00:00,7.975624
+2020-02-09 23:00:00,8.8540945
+2020-02-10 00:00:00,9.003355
+2020-02-10 01:00:00,10.217049
+2020-02-10 02:00:00,11.157508
+2020-02-10 03:00:00,11.552127
+2020-02-10 04:00:00,11.794086
+2020-02-10 05:00:00,12.463447
+2020-02-10 06:00:00,12.567337
+2020-02-10 07:00:00,12.344029
+2020-02-10 08:00:00,11.867516
+2020-02-10 09:00:00,11.476329
+2020-02-10 10:00:00,10.942833
+2020-02-10 11:00:00,10.110067
+2020-02-10 12:00:00,9.1285
+2020-02-10 13:00:00,8.586722
+2020-02-10 14:00:00,8.009865
+2020-02-10 15:00:00,7.305326
+2020-02-10 16:00:00,6.9213724
+2020-02-10 17:00:00,6.660673
+2020-02-10 18:00:00,6.728831
+2020-02-10 19:00:00,7.1009297
+2020-02-10 20:00:00,7.115267
+2020-02-10 21:00:00,7.174452
+2020-02-10 22:00:00,7.5554914
+2020-02-10 23:00:00,8.802352
+2020-02-11 00:00:00,9.623362
+2020-02-11 01:00:00,10.165096
+2020-02-11 02:00:00,11.1878805
+2020-02-11 03:00:00,11.614379
+2020-02-11 04:00:00,12.338524
+2020-02-11 05:00:00,12.50653
+2020-02-11 06:00:00,12.767748
+2020-02-11 07:00:00,12.252229
+2020-02-11 08:00:00,12.228723
+2020-02-11 09:00:00,11.825585
+2020-02-11 10:00:00,10.965025
+2020-02-11 11:00:00,10.919291
+2020-02-11 12:00:00,9.674904
+2020-02-11 13:00:00,9.301591
+2020-02-11 14:00:00,8.184461
+2020-02-11 15:00:00,7.667546
+2020-02-11 16:00:00,7.491327
+2020-02-11 17:00:00,7.0335784
+2020-02-11 18:00:00,6.9271502
+2020-02-11 19:00:00,7.062455
+2020-02-11 20:00:00,7.054171
+2020-02-11 21:00:00,7.7447867
+2020-02-11 22:00:00,8.271346
+2020-02-11 23:00:00,9.24433
+2020-02-12 00:00:00,9.8912
+2020-02-12 01:00:00,10.786341
+2020-02-12 02:00:00,11.521907
+2020-02-12 03:00:00,12.170029
+2020-02-12 04:00:00,12.6656475
+2020-02-12 05:00:00,12.860258
+2020-02-12 06:00:00,12.90046
+2020-02-12 07:00:00,12.894316
+2020-02-12 08:00:00,12.959762
+2020-02-12 09:00:00,12.361292
+2020-02-12 10:00:00,11.800061
+2020-02-12 11:00:00,11.252397
+2020-02-12 12:00:00,9.981055
+2020-02-12 13:00:00,9.559168
+2020-02-12 14:00:00,8.534986
+2020-02-12 15:00:00,8.077829

example_monthly_temp.csv

@@ -0,0 +1,121 @@
+timestamp,value
+2015-01-01,13.516318
+2015-02-01,19.44832
+2015-03-01,25.592142
+2015-04-01,25.290962
+2015-05-01,25.0406
+2015-06-01,20.865656
+2015-07-01,14.045304
+2015-08-01,10.812928
+2015-09-01,5.864853
+2015-10-01,4.5164165
+2015-11-01,6.485497
+2015-12-01,7.7111044
+2016-01-01,16.78825
+2016-02-01,18.993366
+2016-03-01,25.160658
+2016-04-01,25.204481
+2016-05-01,25.958303
+2016-06-01,19.010046
+2016-07-01,14.532308
+2016-08-01,10.506654
+2016-09-01,3.0285394
+2016-10-01,6.2418823
+2016-11-01,8.652191
+2016-12-01,11.69021
+2017-01-01,16.132154
+2017-02-01,19.781033
+2017-03-01,25.583107
+2017-04-01,26.611046
+2017-05-01,24.249186
+2017-06-01,20.007671
+2017-07-01,14.45735
+2017-08-01,8.154652
+2017-09-01,8.17909
+2017-10-01,1.7419342
+2017-11-01,5.784525
+2017-12-01,10.24657
+2018-01-01,16.289822
+2018-02-01,22.642492
+2018-03-01,25.15024
+2018-04-01,24.562717
+2018-05-01,24.752445
+2018-06-01,18.1076
+2018-07-01,17.144907
+2018-08-01,9.765287
+2018-09-01,5.3291073
+2018-10-01,4.04141
+2018-11-01,6.247704
+2018-12-01,9.410823
+2019-01-01,18.434864
+2019-02-01,18.922728
+2019-03-01,23.709166
+2019-04-01,25.042074
+2019-05-01,23.702662
+2019-06-01,20.08302
+2019-07-01,14.277656
+2019-08-01,9.124888
+2019-09-01,5.046505
+2019-10-01,2.767738
+2019-11-01,6.664206
+2019-12-01,11.476564
+2020-01-01,14.185374
+2020-02-01,19.162077
+2020-03-01,23.18553
+2020-04-01,24.30904
+2020-05-01,21.50585
+2020-06-01,22.047663
+2020-07-01,15.6585
+2020-08-01,8.932458
+2020-09-01,6.7855034
+2020-10-01,4.3423142
+2020-11-01,6.0222898
+2020-12-01,10.545946
+2021-01-01,16.429447
+2021-02-01,22.279285
+2021-03-01,26.216118
+2021-04-01,24.626713
+2021-05-01,22.910631
+2021-06-01,20.149397
+2021-07-01,15.192514
+2021-08-01,8.898667
+2021-09-01,5.409033
+2021-10-01,6.2199106
+2021-11-01,8.802447
+2021-12-01,9.660249
+2022-01-01,14.028052
+2022-02-01,19.574944
+2022-03-01,22.167557
+2022-04-01,24.590693
+2022-05-01,24.29392
+2022-06-01,19.877985
+2022-07-01,16.851866
+2022-08-01,10.226332
+2022-09-01,7.061425
+2022-10-01,4.7768636
+2022-11-01,8.313245
+2022-12-01,8.166482
+2023-01-01,14.544613
+2023-02-01,18.239468
+2023-03-01,24.899664
+2023-04-01,26.275484
+2023-05-01,22.886602
+2023-06-01,22.48717
+2023-07-01,14.554106
+2023-08-01,7.9249344
+2023-09-01,5.917939
+2023-10-01,5.540031
+2023-11-01,5.9881577
+2023-12-01,13.398281
+2024-01-01,16.28308
+2024-02-01,22.59692
+2024-03-01,25.739082
+2024-04-01,22.471323
+2024-05-01,23.093616
+2024-06-01,15.907271
+2024-07-01,14.030405
+2024-08-01,11.672656
+2024-09-01,5.074929
+2024-10-01,4.044967
+2024-11-01,6.828947
+2024-12-01,11.180975

requirements.txt

@@ -0,0 +1,4 @@
+numpy
+pandas
+matplotlib
+gluonts

tinycast/__init__.py

@@ -0,0 +1,121 @@
+"""TinyCast: an attention-free, 146,505-parameter dilated-convolution
+time-series foundation model.
+
+Forecast:
+    >>> from tinycast import TinyCastPredictor, load_checkpoint
+    >>> predictor = TinyCastPredictor(
+    ...     prediction_length=48,
+    ...     checkpoint_path="model.safetensors",
+    ...     freq="H", domain="Energy", device="cpu",
+    ...     force_flip_invariance=True,
+    ... )
+    >>> forecasts = predictor.predict(gluonts_test_input)
+
+Evaluate:
+    >>> from tinycast import summarize_by_freq_bin
+    >>> summarize_by_freq_bin("all_results.csv")["overall"]["ncrps"]
+
+Train, then release:
+    >>> from tinycast import (TinyCastConfig, train, average_checkpoints,
+    ...                       export_safetensors)
+    >>> result = train(TinyCastConfig(), data=windows, max_steps=1000,
+    ...                output_dir="run/", batch_size=32, checkpoint_every=100)
+    >>> weights = average_checkpoints(result.checkpoints[-8:])
+    >>> export_safetensors(weights, "release/", expect_parameters=146_505)
+
+Rebuild the synthetic corpus (needs CUDA):
+    >>> from tinycast import build_shard, verify_shard
+    >>> build_shard()                       # published shard 0
+    >>> verify_shard("synth4096_0", shard=0)
+
+``tinycast.train`` is the training function, not the module: the two share a
+name and the function wins. Module-level recipe constants are reachable as
+``from tinycast.train import AR_CHUNKS``. A submodule the package does not
+import itself, ``tinycast.backbone`` and ``tinycast.periodogram`` among them,
+becomes an attribute only after ``import tinycast.backbone``.
+"""
+
+from .config import TinyCastConfig
+from .model import TinyCastForPrediction, TinyCastBackbone, PredictionOutput
+from .checkpoint import load_checkpoint, load_model
+from .predictor import TinyCastPredictor, ARRolloutPredictor
+
+# Training and the objectives it optimizes.
+from .losses import committing_loss, pinball_loss, seasonal_copy_baseline
+from .train import TrainResult, train, training_window_width
+
+# The synthetic pretraining corpus generators.
+from .synth import generate_gp, generate_spikes, generate_tsi
+
+# eval, export and corpus each carry a ``python -m`` entry point, so the package
+# must not import them eagerly: that puts them in sys.modules before runpy runs
+# them as __main__, which warns and executes the module body twice. Resolving
+# them on first attribute access (PEP 562) keeps ``from tinycast import
+# evaluate`` working and leaves the command line quiet.
+_LAZY_MODULES = ("eval", "export", "corpus")
+_LAZY_EXPORTS = {
+    "evaluate": "eval",
+    "summarize_by_freq_bin": "eval",
+    "export_safetensors": "export",
+    "average_checkpoints": "export",
+    "check_export_roundtrip": "export",
+    "ExportError": "export",
+    "build_shard": "corpus",
+    "verify_shard": "corpus",
+    "iter_shard_series": "corpus",
+}
+
+
+def __getattr__(name: str):
+    from importlib import import_module
+
+    if name in _LAZY_MODULES:
+        value = import_module(f".{name}", __name__)
+    else:
+        module = _LAZY_EXPORTS.get(name)
+        if module is None:
+            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+        value = getattr(import_module(f".{module}", __name__), name)
+    globals()[name] = value          # resolve once, then it is a plain global
+    return value
+
+
+def __dir__() -> list:
+    return sorted(set(globals()) | set(_LAZY_EXPORTS) | set(_LAZY_MODULES))
+
+
+__all__ = [
+    # model and inference
+    "TinyCastConfig",
+    "TinyCastForPrediction",
+    "TinyCastBackbone",
+    "PredictionOutput",
+    "load_checkpoint",
+    "load_model",
+    "TinyCastPredictor",
+    "ARRolloutPredictor",
+    # training
+    "train",
+    "TrainResult",
+    "training_window_width",
+    "pinball_loss",
+    "committing_loss",
+    "seasonal_copy_baseline",
+    # export
+    "export_safetensors",
+    "average_checkpoints",
+    "check_export_roundtrip",
+    "ExportError",
+    # evaluation
+    "evaluate",
+    "summarize_by_freq_bin",
+    # synthetic corpus
+    "build_shard",
+    "verify_shard",
+    "iter_shard_series",
+    "generate_gp",
+    "generate_spikes",
+    "generate_tsi",
+]
+
+__version__ = "1.0.0"

tinycast/backbone.py

@@ -0,0 +1,1070 @@
+"""Dilated-convolution forecasting backbone.
+
+An attention-free encoder: a stack of causal dilated convolutions. With
+kernel K=3 and dilations d_i = 2^(i-1) for i=1..N the receptive field is
+
+    RF = 1 + 2 * sum_i d_i = 1 + 2 * (2^N - 1)
+
+so N=10 layers cover RF=2047, sufficient for the L=2048 context with zero
+downsampling and no information loss at any time scale. Native multi-scale
+via the dilation schedule; deployment-friendly (no L^2 attention matrix, no
+softmax, pure matmul + element-wise; quantizes cleanly to INT8); streaming-
+friendly (left-only causal padding).
+
+Structural priors (zero-parameter):
+  - a normalized-periodogram period detector driving a phase encoding
+  - bounded recency basis (signed-linear/log, multi-scale exp decay)
+  - position-parameterized decoder queries (single-shot arbitrary horizon)
+  - no autoregressive rollout inside the backbone
+"""
+
+from __future__ import annotations
+
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .periodogram import significant_periods
+from .encoding import (
+    N_RECENCY_CHANNELS,
+    _norm_fp32,
+    _phase_encoding,
+    _positional_encoding,
+)
+
+
+class _SwiGLU(nn.Module):
+    """Standard SwiGLU FFN."""
+
+    def __init__(self, d: int, d_hidden: int) -> None:
+        super().__init__()
+        self.up = nn.Linear(d, 2 * d_hidden)
+        self.down = nn.Linear(d_hidden, d)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        gate, val = self.up(x).chunk(2, dim=-1)
+        return self.down(F.silu(gate) * val)
+
+
+class _DilatedConvBlock(nn.Module):
+    """Dilated Conv1d → RMSNorm → SwiGLU → RMSNorm with residuals.
+
+    ``causal=True``, which is what the released config sets, pads all (K-1)*d
+    timesteps on the left, so each output position sees only its own past. With
+    ``causal=False`` the padding is centered instead: length is still preserved
+    and each position gets a symmetric view of (K-1)*d/2 timesteps on either
+    side, at the cost of future-side context. Under both, the dilation scales
+    the per-layer receptive field without adding parameters.
+    """
+
+    def __init__(
+        self, d: int, kernel: int = 3, dilation: int = 1,
+        ffn_mult: float = 1.5, causal: bool = False, gated: bool = False,
+        separable: bool = False,
+    ) -> None:
+        super().__init__()
+        self.k = int(kernel)
+        self.dilation = int(dilation)
+        self.causal = bool(causal)
+        self.gated = bool(gated)
+        self.separable = bool(separable)
+        # Conv with dilation; padding handled in forward. Centered padding
+        # gives each position a symmetric view but feeds the right edge
+        # FUTURE-side zeros: at the deepest layer the last (most recent)
+        # position's representation is dominated by padding standing in for
+        # the unknown forecast, and the model learns a train/inference
+        # mismatch. Causal (all-left) padding removes both pathologies and
+        # is a prerequisite for honest streaming inference.
+        if self.separable:
+            # Depthwise-separable factorization: depthwise (per-channel, dilated,
+            # padding consumed in forward) + pointwise 1x1 (channel mix). Params
+            # D*K + D*D against a full conv's D*D*K: the receptive field is
+            # preserved at a fraction of the parameters per block. Padding
+            # before self.conv feeds the depthwise stage.
+            self.conv = nn.Sequential(
+                nn.Conv1d(d, d, kernel_size=self.k, dilation=self.dilation, groups=d),
+                nn.Conv1d(d, d, kernel_size=1),
+            )
+        else:
+            self.conv = nn.Conv1d(d, d, kernel_size=self.k, dilation=self.dilation)
+        # Lightweight gated conv (multiplicative gating): a cheap
+        # DEPTHWISE gate conv produces a sigmoid mask over the main conv output,
+        # conv_out * σ(gate). Adds data-dependent gating to the encoder at ~D·k
+        # params/block (vs doubling the full conv). Off by default.
+        self.gate = (
+            nn.Conv1d(d, d, kernel_size=self.k, dilation=self.dilation, groups=d)
+            if self.gated else None
+        )
+        self.norm1 = nn.RMSNorm(d)
+        d_hidden = int(d * ffn_mult)
+        self.ffn = _SwiGLU(d, d_hidden)
+        self.norm2 = nn.RMSNorm(d)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # x: (B, L, D). Conv1d takes (B, D, L).
+        x_t = x.transpose(1, 2)
+        # Effective kernel span = (K-1)*d + 1.
+        pad_total = (self.k - 1) * self.dilation
+        if self.causal:
+            left, right = pad_total, 0
+        else:
+            left = pad_total // 2
+            right = pad_total - left
+        x_t = F.pad(x_t, (left, right))
+        if self.separable and self.gate is None:
+            # Depthwise (B,D,L); then the pointwise 1x1 conv == a per-position
+            # Linear, run as F.linear (cublas GEMM) instead of an im2col/cudnn
+            # 1x1-conv kernel. Bit-identical channel contraction; params stay as
+            # conv.0/conv.1 so existing checkpoints load unchanged.
+            dw = self.conv[0](x_t).transpose(1, 2)                  # (B, L, D)
+            pw = self.conv[1]
+            conv_out = F.linear(dw, pw.weight.squeeze(-1), pw.bias)  # (B, L, D)
+        else:
+            conv_out = self.conv(x_t)
+            if self.gate is not None:
+                conv_out = conv_out * torch.sigmoid(self.gate(x_t))
+            conv_out = conv_out.transpose(1, 2)
+        x = _norm_fp32(self.norm1, x + conv_out)
+        x = _norm_fp32(self.norm2, x + self.ffn(x))
+        return x
+
+
+class DilatedConvBackbone(nn.Module):
+    """Dilated-conv encoder with a phase-conditioned, position-parameterized decoder.
+
+    Args:
+        seq_len:        L, the context length.
+        p_out:          H, the single-shot output length.
+        n_quantiles:    Q, the number of output channels.
+        d:              channel dimension.
+        n_layers:       number of dilated-conv blocks (10 → RF 2047 ≥ L=2048).
+        kernel:         conv kernel size (default 3).
+        ffn_mult:       SwiGLU hidden multiplier (default 1.5).
+        dilations:      explicit dilation schedule; if None, uses 2^(i-1).
+        top_k_periods:  the periodogram detector's top-K (default 4).
+        significance_alpha:   the periodogram detector's Bonferroni alpha (default 0.05).
+        n_harmonics:    Fourier harmonics per detected period (default 1).
+        pool_kind:      context-summary pooling: "mean_last" (default),
+                        "mean", "last". Concat the chosen pool(s) into the
+                        per-horizon query before query_proj.
+        causal:         if True, all conv padding is left-only (no future
+                        leakage, clean right edge, streaming-honest).
+        phase_bins:     if > 0, augment the global pool with a period-folded
+                        seasonal profile: for each period the periodogram
+                        detector returns, fold the encoder output into this many
+                        phase bins and let each decoder query gather the bin
+                        matching its own phase. 0 disables phase folding and
+                        leaves the plain global pool, which is the control the
+                        paper's phase-folding ablation is measured against.
+    """
+
+    def __init__(
+        self,
+        seq_len: int,
+        p_out: int,
+        n_quantiles: int = 1,
+        d: int = 80,
+        n_layers: int = 10,
+        kernel: int = 3,
+        ffn_mult: float = 1.5,
+        dilations: list[int] | None = None,
+        top_k_periods: int = 4,
+        significance_alpha: float = 0.05,
+        n_harmonics: int = 1,
+        pool_kind: str = "mean_last",
+        causal: bool = False,
+        phase_bins: int = 0,
+        phase_stats: str = "mean",
+        phase_recency_tau: float = 0.0,
+        recency_bins: int = 0,
+        sig_gate: bool = False,
+        cross_cycle: bool = False,
+        decoder_depth: int = 1,
+        horizon_kernel: int = 0,
+        horizon_recurrence: bool = False,
+        min_cycles: int = 0,
+        period_trust: str = "off",
+        gated_conv: bool = False,
+        residual_naive: bool = False,
+        residual_multi: bool = False,
+        residual_trend: bool = False,
+        decompose_kernel: int = 0,
+        periodogram_off: bool = False,
+        res_adaptive: bool = False,
+        res_period_target: int = 64,
+        res_r_max: float = 32.0,
+        with_missing: bool = False,
+        missing_channel: bool = False,
+        separable_conv: bool = False,
+        share_ffn: bool = False,
+        future_conv: bool = False,
+        future_conv_layers: int = 6,
+        future_conv_seed: int = 128,
+        base_seasonality: float = 24.0,
+        local_anchor: bool = False,
+    ) -> None:
+        super().__init__()
+        self.L = int(seq_len)
+        self.p_out = int(p_out)
+        self.n_quantiles = int(n_quantiles)
+        self.D = int(d)
+        self.K = int(top_k_periods)
+        self.significance_alpha = float(significance_alpha)
+        self.n_harmonics = int(n_harmonics)
+        self.pool_kind = str(pool_kind)
+        self.causal = bool(causal)
+        self.phase_bins = int(phase_bins)
+        if phase_stats not in ("mean", "mean_var"):
+            raise ValueError(f"phase_stats={phase_stats!r}; expected 'mean'|'mean_var'.")
+        self.phase_stats = str(phase_stats)
+        self.stat_mult = 2 if self.phase_stats == "mean_var" else 1
+        self.phase_recency_tau = float(phase_recency_tau)
+        self.recency_bins = int(recency_bins)
+        self.sig_gate = bool(sig_gate)
+        self.cross_cycle = bool(cross_cycle)
+        self.decoder_depth = max(1, int(decoder_depth))
+        self.horizon_kernel = int(horizon_kernel)
+        self.horizon_recurrence = bool(horizon_recurrence)
+        self.min_cycles = int(min_cycles)
+        if period_trust not in ("off", "coverage", "full"):
+            raise ValueError(f"period_trust={period_trust!r}; expected off|coverage|full")
+        self.period_trust = str(period_trust)
+        # Per-period reliability weight w_k = sigmoid(linear([margin, ln
+        # coverage])): a continuous down-weighting of long or weakly-supported
+        # periods, whose crossover is learned rather than set. It covers the
+        # same ground as the integer min_cycles cutoff, which stays available
+        # and independent; both are off in the released config. "coverage" uses
+        # ln(L/period) alone (min_cycles is its hard-threshold limit); "full"
+        # adds the significance margin ln(s_k/t_alpha) from the detector's
+        # periodogram scores.
+        if self.period_trust != "off":
+            n_feat = 1 if self.period_trust == "coverage" else 2
+            self.pt = nn.Linear(n_feat, 1)
+            with torch.no_grad():
+                self.pt.weight.zero_(); self.pt.weight[0, 0] = 1.0  # cov (or margin) coeff = 1
+                self.pt.bias.zero_()
+            # data-determined Bonferroni threshold t_alpha (no tuned knob)
+            n_fft = 1 << int(math.ceil(math.log2(max(2, self.L))))
+            self._n_bins = max(2, n_fft // 2)
+            self._t_alpha = math.log(self._n_bins / max(self.significance_alpha, 1e-12)) / self._n_bins
+        else:
+            self.pt = None
+        self.gated_conv = bool(gated_conv)
+        self.residual_naive = bool(residual_naive)
+        self.residual_multi = bool(residual_multi)
+        self.residual_trend = bool(residual_trend)
+        self.periodogram_off = bool(periodogram_off)
+        self.res_adaptive = bool(res_adaptive)
+        self.res_period_target = int(res_period_target)
+        self.res_r_max = float(res_r_max)
+        # Series decomposition: moving-avg trend / seasonal split fed
+        # as two input channels. 0 disables. Even kernel → +1 for centered.
+        self.decompose_kernel = int(decompose_kernel)
+        self.with_missing = bool(with_missing)
+        # Missing-value channel: feed the encoder a binary observed-mask so it
+        # can distinguish a genuinely-unobserved position from a real value (the
+        # faithful treatment, vs mean-fill which conflates the two).
+        self.missing_channel = bool(missing_channel)
+        if self.missing_channel and bool(res_adaptive):
+            raise NotImplementedError(
+                "missing_channel + res_adaptive: the observed-mask is not warped "
+                "through _resolution_adapt; not supported together."
+            )
+        # Recent-anchor channels: gradient-connected causal local level/scale so the
+        # encoder can re-anchor amplitude under non-stationarity (the denorm origin
+        # x_min is a frozen detached GLOBAL min, with no learned path to the
+        # recent regime).
+        self.local_anchor = bool(local_anchor)
+
+        if self.n_harmonics < 1:
+            raise ValueError(f"n_harmonics must be >= 1; got {self.n_harmonics}")
+        if pool_kind not in ("mean_last", "mean", "last"):
+            raise ValueError(
+                f"pool_kind={pool_kind!r}; expected 'mean_last' | 'mean' | 'last'."
+            )
+
+        # Positional encoding: phase channels + bounded recency channels.
+        n_phase = 2 * self.K * self.n_harmonics
+        n_pe = n_phase + N_RECENCY_CHANNELS
+        # Input channels: raw value, or [trend, seasonal] if decomposing.
+        n_value_ch = 2 if self.decompose_kernel > 0 else 1
+        if self.missing_channel:
+            n_value_ch += 1                                          # +observed-mask
+        if self.local_anchor:
+            n_value_ch += 2                                          # +[local-scale residual, log local-scale]
+        in_channels = n_value_ch + n_pe
+        self.in_proj = nn.Linear(in_channels, self.D)
+        if self.local_anchor:
+            # zero-init the 2 anchor columns (last of the value channels) so the
+            # model is baseline-equivalent at init and learns the anchor from zero.
+            with torch.no_grad():
+                self.in_proj.weight[:, n_value_ch - 2:n_value_ch].zero_()
+
+        # Dilation schedule.
+        if dilations is None:
+            dilations = [2**i for i in range(int(n_layers))]
+        if len(dilations) != int(n_layers):
+            raise ValueError(
+                f"dilations length {len(dilations)} != n_layers {n_layers}"
+            )
+        self.dilations = list(dilations)
+
+        # Receptive field sanity (informational only; fails soft if RF < L).
+        rf = 1 + (kernel - 1) * sum(self.dilations)
+        self.receptive_field = rf
+
+        self.encoder = nn.ModuleList([
+            _DilatedConvBlock(
+                self.D, kernel=int(kernel), dilation=int(d_i),
+                ffn_mult=float(ffn_mult), causal=self.causal,
+                gated=self.gated_conv, separable=bool(separable_conv),
+            )
+            for d_i in self.dilations
+        ])
+        # Cross-layer FFN weight sharing (weight-tied): the SwiGLU FFN is the
+        # largest param bucket and is dilation-independent, so one shared FFN
+        # across all blocks recovers ~(n_layers-1)/n_layers of FFN params. The
+        # per-block dilated convs (which carry the receptive field) stay distinct.
+        self.share_ffn = bool(share_ffn)
+        if self.share_ffn and len(self.encoder) > 1:
+            shared_ffn = self.encoder[0].ffn
+            for blk in self.encoder[1:]:
+                blk.ffn = shared_ffn
+
+        # Pooled context summary dim depends on pool_kind.
+        pool_dim = {"mean_last": 2 * self.D, "mean": self.D, "last": self.D}[
+            self.pool_kind
+        ]
+
+        # Phase-binned seasonal profile: K period-folded profiles, each
+        # gathered by the decoder query's own phase, then mixed to D. A global
+        # mean pool averages every phase of a cycle into one vector, so nothing
+        # that varies with phase survives it; folding by phase keeps the
+        # per-cycle waveform and hands each query the part of the cycle it is
+        # forecasting.
+        # Phase profile mixer: K periods × n_bins × (mean[,var]) → D.
+        if self.phase_bins > 0:
+            self.phase_mix = nn.Linear(self.K * self.stat_mult * self.D, self.D)
+        else:
+            self.phase_mix = None
+
+        # Recency profile mixer: rb log-distance bins × (mean[,var])
+        # → D. Always-valid aperiodic content path. Flattened (not gathered).
+        if self.recency_bins > 0:
+            self.recency_mix = nn.Linear(
+                self.recency_bins * self.stat_mult * self.D, self.D,
+            )
+        else:
+            self.recency_mix = None
+
+        # Cross-cycle conv branch: a depthwise conv across cycles
+        # at fixed phase, applied to the dominant period's [n_cycles × n_bins]
+        # fold. Adds one D-dim feature to the query. See _cross_cycle_profile.
+        if self.cross_cycle:
+            self.cc_bins = self.phase_bins if self.phase_bins > 0 else 16
+            self.cc_cycles = 8          # most-recent N cycles folded; older clamped
+            # Depthwise conv ACROSS the cycle axis (length cc_cycles) at fixed
+            # phase: models how each phase evolves cycle-to-cycle.
+            self.cc_conv = nn.Conv1d(
+                self.D, self.D, kernel_size=3, padding=1, groups=self.D,
+            )
+            self.cc_mix = nn.Linear(self.D, self.D)
+        else:
+            self.cc_conv = None
+
+        # Decoder query input: PE + pool [+ phase D] [+ recency D] [+ cc D].
+        # With sig_gate, phase & recency are blended into a single D (not
+        # concatenated), so they contribute D once, not 2·D.
+        query_in = n_pe + pool_dim
+        if self.sig_gate and self.phase_mix is not None and self.recency_mix is not None:
+            query_in += self.D
+        else:
+            query_in += self.D if self.phase_mix is not None else 0
+            query_in += self.D if self.recency_mix is not None else 0
+        query_in += self.D if self.cross_cycle else 0
+        self.query_proj = nn.Linear(query_in, self.D)
+        d_hidden = int(self.D * float(ffn_mult))
+        # Decoder: `decoder_depth` residual SwiGLU blocks (depth 1 is a single
+        # block). The decoder's inputs are rich (phase/recency profiles), and
+        # depth lets it process them.
+        self.decoder_ffns = nn.ModuleList(
+            [_SwiGLU(self.D, d_hidden) for _ in range(self.decoder_depth)]
+        )
+        self.decoder_norms = nn.ModuleList(
+            [nn.RMSNorm(self.D) for _ in range(self.decoder_depth)]
+        )
+        # Cross-horizon coherence: a causal depthwise conv across the
+        # horizon axis couples adjacent forecast steps (the cross-step mixing
+        # lost when attention was dropped). Causal + fixed kernel preserves the
+        # single-shot arbitrary-horizon property. horizon_kernel=0 disables.
+        if self.horizon_kernel > 0:
+            self.horizon_conv = nn.Conv1d(
+                self.D, self.D, kernel_size=self.horizon_kernel, groups=self.D,
+            )
+            self.horizon_norm = nn.RMSNorm(self.D)
+        else:
+            self.horizon_conv = None
+        # Horizon-recurrent decode-state: a gated diagonal recurrence over the
+        # SHORT horizon axis, scanning the precomputed query features. It never
+        # re-feeds predicted values, so the decoder stays single-shot rather
+        # than autoregressive. An unbounded carried state couples step h to ALL
+        # earlier steps (vs the fixed-span horizon_conv), the property that
+        # makes a recurrent decoder horizon-invariant. hr_o is zero-init so the
+        # block is identity at start and cannot regress the baseline.
+        if self.horizon_recurrence:
+            self.hr_z = nn.Linear(self.D, self.D)   # update gate
+            self.hr_c = nn.Linear(self.D, self.D)   # candidate
+            self.hr_o = nn.Linear(self.D, self.D)   # output proj (zero-init)
+            nn.init.zeros_(self.hr_o.weight); nn.init.zeros_(self.hr_o.bias)
+            self.hr_norm = nn.RMSNorm(self.D)
+        else:
+            self.hr_z = None
+        self.out_proj = nn.Linear(self.D, self.n_quantiles)
+
+
+        # Future-conv decoder (horizon-axis state evolution; the conv-native
+        # analog of a missing-token decoder). The rest of the decoder queries a
+        # STATIC pooled summary at every horizon position, which is why error
+        # grows with horizon. future_conv runs a CAUSAL dilated conv over
+        # [context-tail seed ++ seasonal-naive future fill], producing
+        # per-future-position hidden states that EVOLVE along the horizon (each
+        # future position is a causal-conv function of recent context + earlier
+        # future), and injects them additively into the decoder query. The fill
+        # is the dominant-period seasonal-naive continuation (it carries
+        # periodic structure, so the conv evolves a real waveform forward
+        # rather than zeros), which leaves the decoder predicting the residual
+        # over a copy. ``fc_out`` is zero-init => EXACT baseline at start
+        # (zero-init additive idiom), and disabling it restores that baseline.
+        # This differs from the two cheaper readouts in the same position: a
+        # recurrence over queries derived from the static summary adds no new
+        # dynamics, and a phase gather only COPIES context profiles, whereas
+        # this path RUNS the conv forward.
+        self.future_conv = bool(future_conv)
+        if self.future_conv:
+            if res_adaptive:
+                raise ValueError("future_conv is incompatible with res_adaptive")
+            self.fc_seed = int(future_conv_seed)
+            fc_in = 1 + n_pe                       # fill value + the same PE layout
+            self.fc_in_proj = nn.Linear(fc_in, self.D)
+            fc_dils = [2 ** i for i in range(int(future_conv_layers))]
+            self.fc_blocks = nn.ModuleList([
+                _DilatedConvBlock(
+                    self.D, kernel=int(kernel), dilation=int(d_i),
+                    ffn_mult=float(ffn_mult), causal=True,
+                    separable=True,   # auxiliary module: keep it light (~51K add)
+                )
+                for d_i in fc_dils
+            ])
+            # Weight-tie the FFN across fc blocks: the convs carry the horizon
+            # dynamics, and one shared FFN keeps the param add modest.
+            shared = self.fc_blocks[0].ffn
+            for blk in self.fc_blocks[1:]:
+                blk.ffn = shared
+            self.fc_out = nn.Linear(self.D, self.D)   # zero-init => exact baseline
+            nn.init.zeros_(self.fc_out.weight)
+            nn.init.zeros_(self.fc_out.bias)
+
+        self.base_seasonality = float(base_seasonality)
+
+    # ---- helpers ----------------------------------------------------------
+
+    def _future_conv_states(
+        self, h: torch.Tensor, fut_pe: torch.Tensor, fill: torch.Tensor,
+    ) -> torch.Tensor:
+        """Causal-conv continuation states at the H future positions.
+
+        h: (B, L, D) encoder output; fut_pe: (B, H, n_pe); fill: (B, H) the
+        seasonal-naive future continuation. Returns (B, H, D).
+        """
+        # self.L is static (asserted == L in forward), so using it instead of
+        # the traced h.shape[1] keeps dynamo from graph-splitting on a symint
+        # bound.
+        ft = self.fc_in_proj(torch.cat([fill.unsqueeze(-1), fut_pe], dim=-1))  # (B,H,D)
+        seed = h[:, -min(self.fc_seed, self.L):, :]               # (B, seed, D)
+        z = torch.cat([seed, ft], dim=1)                          # (B, seed+H, D)
+        for blk in self.fc_blocks:                                # causal: no future leak
+            z = blk(z)
+        return z[:, -ft.shape[1]:, :]                             # (B, H, D)
+
+    @torch.compiler.disable()
+    def _detect_periods(
+        self, x_fp32: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Run the significance-filtered periodogram in fp32 (no grad).
+
+        @torch.compiler.disable: the periodogram uses a complex rfft that
+        Inductor cannot codegen: left inside the compiled graph it forces an
+        eager fallback + graph break every forward, early in `forward`, blocking
+        fusion of the whole conv encoder/decoder downstream. Disabling compile on
+        this (no_grad, fp32, produces integer periods the rest only reads) makes a
+        clean eager boundary: the FFT runs eager, everything after fuses. Output
+        bit-identical (only where it compiles changes).
+
+        Returns ``(periods, n_valid, scores)``: the integer periods (0 =
+        rejected), the count of significant periods per sample, and the
+        per-period periodogram scores. ``n_valid`` is the periodicity-strength
+        signal the significance gate reads.
+        """
+        B, L = x_fp32.shape
+        if self.periodogram_off:
+            # Control: no period detection → phase encoding zeros out, phase
+            # machinery is inert. Tests whether the conv backbone matches with
+            # a phase-free (recency-only) decoder.
+            z = torch.zeros(B, self.K, dtype=torch.long, device=x_fp32.device)
+            return (z, torch.zeros(B, dtype=torch.long, device=x_fp32.device),
+                    torch.zeros(B, self.K, device=x_fp32.device))
+        with torch.no_grad():
+            periods, scores, n_valid = significant_periods(
+                x_fp32,
+                min_period=2,
+                max_period=L // 2,
+                top_k=self.K,
+                significance_alpha=self.significance_alpha,
+            )
+        periods = periods.long()
+        if self.min_cycles > 0:
+            # "Do no harm": only TRUST a period with >= min_cycles full
+            # cycles in the window (period <= L/min_cycles). Periods too long
+            # to be reliably estimated (e.g. an 8640-sample daily cycle in a
+            # 2048 window) are zeroed → the significance gate routes those
+            # series to the recency/local path instead of mis-locking phase.
+            max_p = L // self.min_cycles
+            keep = (periods > 0) & (periods <= max_p)
+            periods = torch.where(keep, periods, torch.zeros_like(periods))
+            n_valid = keep.sum(dim=1).long()
+        return periods, n_valid.long(), scores.float()
+
+    def _pool(self, h: torch.Tensor) -> torch.Tensor:
+        """Pool encoder output to a fixed-size summary.
+
+        h: (B, L, D)
+        Returns: (B, pool_dim)
+        """
+        if self.pool_kind == "mean":
+            return h.mean(dim=1)
+        if self.pool_kind == "last":
+            return h[:, -1, :]
+        # mean_last:
+        return torch.cat([h.mean(dim=1), h[:, -1, :]], dim=-1)
+
+    def _scatter_profile(
+        self, h: torch.Tensor, bins: torch.Tensor, nb: int,
+        weight: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        """Weighted scatter-mean (+ optional per-bin variance) of h into nb bins.
+
+        h:      (B, L, D)
+        bins:   (B, L) int in [0, nb)
+        weight: (B, L) non-negative, or None for uniform.
+        Returns (B, nb, stat_mult·D): per-bin mean, then per-bin variance if
+        ``phase_stats == 'mean_var'``. Empty bins → global mean
+        (and zero variance).
+        """
+        B, L, D = h.shape
+        oh = F.one_hot(bins, nb).to(h.dtype)                        # (B,L,nb)
+        if weight is not None:
+            oh = oh * weight.unsqueeze(-1)
+        cnt = oh.sum(dim=1).unsqueeze(-1)                           # (B,nb,1)
+        denom = cnt.clamp(min=1e-6)
+        mean = torch.bmm(oh.transpose(1, 2), h) / denom            # (B,nb,D)
+        gmean = h.mean(dim=1, keepdim=True)                        # (B,1,D)
+        empty = cnt <= 0
+        mean = torch.where(empty, gmean.expand(B, nb, D), mean)
+        if self.phase_stats == "mean_var":
+            sq = torch.bmm(oh.transpose(1, 2), h * h) / denom      # E[h²]
+            var = (sq - mean * mean).clamp(min=0.0)
+            var = torch.where(empty, torch.zeros_like(var), var)
+            return torch.cat([mean, var], dim=-1)                  # (B,nb,2D)
+        return mean                                                # (B,nb,D)
+
+    def _recency_weight(self, L: int, device) -> torch.Tensor | None:
+        """exp recency weight over context positions: recent positions weigh
+        more, so the folded profile tracks the CURRENT regime's waveform rather
+        than the window average. None if tau<=0 (uniform)."""
+        if self.phase_recency_tau <= 0.0:
+            return None
+        t = torch.arange(L, device=device).float()
+        dist = (L - 1 - t) / L                                      # 0 at now
+        return torch.exp(-dist / self.phase_recency_tau).view(1, L)
+
+    def _phase_profile(
+        self, h: torch.Tensor, periods: torch.Tensor,
+    ) -> torch.Tensor:
+        """Period-fold the encoder output into per-phase profiles.
+
+        Returns (B, K, n_bins, stat_mult·D). Each detected period p_k folds
+        the sequence into n_bins phase bins; per bin we keep the (recency-
+        weighted) mean [and variance]. Empty bins → global mean.
+        """
+        B, L, D = h.shape
+        K, nb = self.K, self.phase_bins
+        t = torch.arange(L, device=h.device).view(1, L).float()    # (1,L)
+        p_safe = periods.clamp(min=1).float()                      # (B,K)
+        weight = self._recency_weight(L, h.device)
+        if weight is not None:
+            weight = weight.expand(B, L)
+        profs = []
+        for k in range(K):
+            frac = (t % p_safe[:, k:k + 1]) / p_safe[:, k:k + 1]   # (B,L)
+            bins = torch.clamp((frac * nb).long(), max=nb - 1)     # (B,L)
+            profs.append(self._scatter_profile(h, bins, nb, weight))
+        return torch.stack(profs, dim=1)                           # (B,K,nb,S·D)
+
+    def _gather_phase(
+        self, prof: torch.Tensor, fut_pos: torch.Tensor,
+        periods: torch.Tensor, weight: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        """Gather each future query's matching phase bin per period, mix → D.
+
+        prof: (B, K, n_bins, S·D); fut_pos: (B, H); periods: (B, K).
+        weight: optional (B,K) per-period reliability weight (period_trust).
+        Returns (B, H, D).
+        """
+        B, K, nb, SD = prof.shape
+        H = fut_pos.shape[1]
+        p_safe = periods.clamp(min=1).float().view(B, 1, K)        # (B,1,K)
+        frac = (fut_pos.unsqueeze(-1).float() % p_safe) / p_safe   # (B,H,K)
+        fbins = torch.clamp((frac * nb).long(), max=nb - 1)        # (B,H,K)
+        idx = fbins.permute(0, 2, 1).unsqueeze(-1).expand(B, K, H, SD)
+        gathered = torch.gather(prof, 2, idx)                      # (B,K,H,S·D)
+        if weight is not None:
+            gathered = gathered * weight.view(B, K, 1, 1).to(gathered.dtype)
+        gathered = gathered.permute(0, 2, 1, 3).reshape(B, H, K * SD)
+        return self.phase_mix(gathered)                            # (B,H,D)
+
+    def _period_trust_weights(
+        self, periods: torch.Tensor, scores: torch.Tensor,
+    ) -> torch.Tensor:
+        """Hyperparameter-free per-period reliability weight w_k∈[0,1] (B,K).
+
+        ln-coverage = ln(L/period) (data/structure-determined); for 'full' also
+        the significance margin ln(s_k/t_alpha) (s_k = the periodogram score,
+        t_alpha = data-determined Bonferroni threshold). The sigmoid crossover
+        is LEARNED (the linear layer's weights and bias), not a hand-set
+        threshold. 0 on rejected slots.
+        """
+        valid = periods > 0
+        logcov = torch.log(float(self.L) / periods.clamp(min=1).float())   # (B,K)
+        if self.period_trust == "coverage":
+            feat = logcov.unsqueeze(-1)                                     # (B,K,1)
+        else:
+            margin = torch.log(scores.clamp(min=1e-12) / self._t_alpha)    # >=0 for survivors
+            feat = torch.stack([margin, logcov], dim=-1)                   # (B,K,2)
+        w = torch.sigmoid(self.pt(feat.to(self.pt.weight.dtype))).squeeze(-1)
+        return torch.where(valid, w, torch.zeros_like(w))
+
+    def _recency_feat(self, h: torch.Tensor) -> torch.Tensor:
+        """Recency-binned profile: bin context positions by
+        log-distance-from-now and pool. Always valid (no period needed);
+        the aperiodic content path. Flattened to a single (B, D) descriptor
+        (broadcast to all horizons; the query's own PE carries how-far-ahead).
+        """
+        B, L, D = h.shape
+        rb = self.recency_bins
+        t = torch.arange(L, device=h.device).view(1, L).float().expand(B, L)
+        dist = (L - 1 - t).clamp(min=0.0)                          # 0=now
+        frac = torch.log1p(dist) / math.log1p(float(L - 1) + 1e-9)
+        bins = torch.clamp((frac * rb).long(), max=rb - 1)         # (B,L)
+        prof = self._scatter_profile(h, bins, rb, None)           # (B,rb,S·D)
+        return self.recency_mix(prof.reshape(B, rb * self.stat_mult * D))
+
+    def _cross_cycle_profile(
+        self, h: torch.Tensor, periods: torch.Tensor,
+    ) -> torch.Tensor:
+        """Cross-cycle conv, true ragged form.
+
+        For the dominant period p0, fold the sequence into a
+        [cycles-back-from-now × phase] grid (B, nc, nb, D) by scatter-mean,
+        then convolve ACROSS the cycle axis at fixed phase (depthwise conv1d
+        over nc), modelling how each phase evolves cycle-to-cycle ("every
+        Monday 9am, trending up"). Read out the most-recent cycle (post-conv,
+        so it has seen the trend). Returns a (B, nb, D) phase profile the
+        decoder gathers by its own phase.
+
+        Per-sample period handled like phase-binning: phase resampled to nb
+        fixed bins; cycles-back clamped to nc (older cycles fold into the
+        oldest slot). Attention-free, fixed-shape, batchable.
+        """
+        B, L, D = h.shape
+        nb, nc = self.cc_bins, self.cc_cycles
+        t = torch.arange(L, device=h.device).view(1, L).float()    # (1,L)
+        p0 = periods[:, :1].clamp(min=1).float()                   # (B,1)
+        pbin = torch.clamp(((t % p0) / p0 * nb).long(), max=nb - 1)  # (B,L)
+        cyc = torch.clamp(((L - 1 - t) // p0).long(), max=nc - 1)   # (B,L) 0=now
+        comb = (cyc * nb + pbin).clamp(min=0, max=nc * nb - 1)      # (B,L)
+        oh = F.one_hot(comb, nc * nb).to(h.dtype)                  # (B,L,nc·nb)
+        cnt = oh.sum(dim=1).unsqueeze(-1).clamp(min=1e-6)
+        grid = (torch.bmm(oh.transpose(1, 2), h) / cnt).view(B, nc, nb, D)
+        # conv across cycles (nc) at fixed phase, per channel.
+        x = grid.permute(0, 2, 3, 1).reshape(B * nb, D, nc)        # (B·nb, D, nc)
+        x = self.cc_conv(x).reshape(B, nb, D, nc)
+        return x[..., 0]                                           # most-recent cycle (B,nb,D)
+
+    @staticmethod
+    def _prefix_integral(
+        f: torch.Tensor, Csum: torch.Tensor, xpad: torch.Tensor, L: int,
+    ) -> torch.Tensor:
+        """Integral of piecewise-constant x from 0 to fractional position f.
+        f: (B,M) in native units. Csum: (B,L+1) prefix sums; xpad: (B,L+1)."""
+        fc = f.clamp(0.0, float(L))
+        k = torch.floor(fc).long()
+        rem = (fc - k.float()).to(Csum.dtype)
+        return torch.gather(Csum, 1, k) + rem * torch.gather(xpad, 1, k)
+
+    def _resolution_adapt(
+        self, x: torch.Tensor, periods: torch.Tensor, H: int,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Resolution adaptation (the TinyCast premise; zero params).
+
+        Resample the context onto a canonical-period grid so the fixed dilation
+        schedule spans consistent CYCLE-fractions across all sampling rates: the
+        dominant detected period is warped to ``res_period_target`` samples/cycle.
+        All detected periods scale by the same ratio; the future native horizon
+        is queried at its canonical-mapped position (decoder is position-
+        parameterized, so outputs are native values and no output resampling
+        is needed).
+
+        Returns (x_canon (B,L), periods_canon (B,K), fut_pos_canon (B,H) float).
+        Aperiodic series (dominant period 0) pass through unchanged (r=1).
+        """
+        B, L = x.shape
+        pt = float(self.res_period_target)
+        p0 = periods[:, 0].float()                                  # (B,) dominant
+        r = torch.where(p0 > 0, pt / p0.clamp(min=1.0), torch.ones_like(p0))
+        # res_r_max=1.0 → downsample-only (high-freq squeezed to canonical;
+        # low-freq left at native, no history truncation / no Δ blow-up).
+        r = r.clamp(0.05, self.res_r_max).view(B, 1)                # canonical per native
+        j = torch.arange(L, device=x.device).view(1, L).float()     # canonical idx 0..L-1
+        # native time (center) for canonical index j; now = most recent canonical.
+        t = (L - 1) - ((L - 1) - j) / r                             # (B,L), <0 = pre-context
+        # Upsample/identity (r>=1): linear interpolation (true pass-through at
+        # r=1). Downsample (r<1): area-average over the native window w=1/r,
+        # ANTI-ALIASED (averages the whole window, not 2 endpoints). Zero params.
+        t0 = torch.floor(t)
+        frac = (t - t0).to(x.dtype)
+        x_lin = (torch.gather(x, 1, t0.clamp(0, L - 1).long()) * (1.0 - frac)
+                 + torch.gather(x, 1, (t0 + 1).clamp(0, L - 1).long()) * frac)
+        w = 1.0 / r                                                 # (B,1) native window width
+        lo, hi = t - w / 2.0, t + w / 2.0
+        Csum = F.pad(x.cumsum(dim=1), (1, 0))                       # (B,L+1): Csum[k]=Σ x[:k]
+        xpad = F.pad(x, (0, 1))                                     # (B,L+1): x[L]=0
+        denom = (hi.clamp(0.0, L) - lo.clamp(0.0, L)).clamp(min=1e-6)
+        x_area = (self._prefix_integral(hi, Csum, xpad, L)
+                  - self._prefix_integral(lo, Csum, xpad, L)) / denom
+        x_canon = torch.where(r < 1.0, x_area, x_lin)              # anti-alias only on downsample
+        x_canon = x_canon * (t >= 0).to(x.dtype)                   # mask pre-context → 0
+        periods_canon = torch.round(periods.float() * r).long()
+        periods_canon = torch.where(
+            periods > 0, periods_canon.clamp(min=2), torch.zeros_like(periods),
+        )
+        h_steps = torch.arange(1, H + 1, device=x.device).view(1, H).float()
+        fut_pos_canon = (L - 1) + h_steps * r                       # (B,H) canonical
+        return x_canon, periods_canon, fut_pos_canon
+
+    def _seasonal_naive(
+        self, x: torch.Tensor, fut_pos: torch.Tensor, periods: torch.Tensor,
+    ) -> torch.Tensor:
+        """Value-space seasonal-naive baseline (zero params).
+
+        Fold the (normalized) input x by the dominant period into phase bins,
+        take the per-phase mean VALUE, and gather the bin matching each future
+        query's phase. The network then learns only the residual on top of this
+        baseline: a target reframe, not added model complexity. Aperiodic /
+        empty-bin → fall back to the context mean (persistence-of-level).
+
+        x: (B, L)  fut_pos: (B, H)  periods: (B, K)  →  (B, H)
+        """
+        B, L = x.shape
+        nb = self.phase_bins if self.phase_bins > 0 else 16
+        t = torch.arange(L, device=x.device).view(1, L).float()
+        p0 = periods[:, :1].clamp(min=1).float()                   # (B,1) dominant
+        pbin = torch.clamp(((t % p0) / p0 * nb).long(), max=nb - 1)  # (B,L)
+        oh = F.one_hot(pbin, nb).to(x.dtype)                       # (B,L,nb)
+        cnt = oh.sum(dim=1)                                        # (B,nb)
+        base = torch.bmm(oh.transpose(1, 2), x.unsqueeze(-1)).squeeze(-1)  # (B,nb)
+        gmean = x.mean(dim=1, keepdim=True)                       # (B,1)
+        base = torch.where(cnt > 0, base / cnt.clamp(min=1.0), gmean.expand(B, nb))
+        fb = torch.clamp((fut_pos.float() % p0) / p0 * nb, max=nb - 1).long()  # (B,H)
+        return torch.gather(base, 1, fb)                          # (B,H)
+
+    def _super_naive(
+        self, x: torch.Tensor, fut_pos: torch.Tensor, periods: torch.Tensor,
+    ) -> torch.Tensor:
+        """Multi-seasonal "super-naive" baseline (zero params).
+
+        Greedy additive decomposition over ALL significant periods: start from
+        the context mean, then for each significant period (strongest first)
+        fold the running residual into per-phase means, subtract it (deflate),
+        and accumulate that component's value at the future phase. Result:
+        baseline(L+h) = mean + Σ_k s_k[phase_k(L+h)], the genuine multi-period
+        seasonal-naive forecast. Non-significant periods (p=0) contribute zero.
+
+        x: (B, L)  fut_pos: (B, H)  periods: (B, K)  →  (B, H)
+        """
+        B, L = x.shape
+        H = fut_pos.shape[1]
+        nb = self.phase_bins if self.phase_bins > 0 else 16
+        t = torch.arange(L, device=x.device).view(1, L).float()
+        if self.residual_trend:
+            # Level term = linear trend (closed-form LS), extrapolated forward.
+            # baseline = trend + seasonal, the classical decomposition.
+            tc = t - t.mean()                                     # centered (1,L)
+            xc = x - x.mean(dim=1, keepdim=True)                  # (B,L)
+            slope = (tc * xc).sum(1, keepdim=True) / (tc * tc).sum().clamp(min=1.0)
+            intercept = x.mean(dim=1, keepdim=True)               # value at centered t=0
+            tmean = t.mean()
+            trend_ctx = intercept + slope * (t - tmean)           # (B,L)
+            r = x - trend_ctx                                     # de-trended residual
+            baseline = intercept + slope * (fut_pos.float() - tmean)  # (B,H) trend extrap
+        else:
+            mean = x.mean(dim=1, keepdim=True)                    # (B,1)
+            r = x - mean                                          # residual
+            baseline = mean.expand(B, H).clone()                  # (B,H)
+        for k in range(self.K):
+            pk = periods[:, k:k + 1].float()                      # (B,1), 0 if not sig
+            sig = (pk > 0).to(x.dtype)                            # (B,1)
+            pks = pk.clamp(min=1.0)
+            pbin = torch.clamp((t % pks) / pks * nb, max=nb - 1).long()   # (B,L)
+            oh = F.one_hot(pbin, nb).to(x.dtype)                 # (B,L,nb)
+            cnt = oh.sum(dim=1).clamp(min=1.0)                   # (B,nb)
+            s_k = torch.bmm(oh.transpose(1, 2), r.unsqueeze(-1)).squeeze(-1) / cnt
+            s_k = s_k * sig                                      # (B,nb), zero if not sig
+            r = r - torch.gather(s_k, 1, pbin)                   # deflate
+            fb = torch.clamp((fut_pos.float() % pks) / pks * nb, max=nb - 1).long()
+            baseline = baseline + torch.gather(s_k, 1, fb)       # (B,H)
+        return baseline
+
+    def _gather_cc(
+        self, cc_prof: torch.Tensor, fut_pos: torch.Tensor,
+        periods: torch.Tensor,
+    ) -> torch.Tensor:
+        """Gather each future query's matching phase bin from the cross-cycle
+        profile (dominant period), mix → D. cc_prof: (B,nb,D)."""
+        B, nb, D = cc_prof.shape
+        H = fut_pos.shape[1]
+        p0 = periods[:, :1].clamp(min=1).float()                   # (B,1)
+        fb = torch.clamp((fut_pos.float() % p0) / p0 * nb, max=nb - 1).long()
+        gathered = torch.gather(cc_prof, 1, fb.unsqueeze(-1).expand(B, H, D))
+        return self.cc_mix(gathered)                               # (B,H,D)
+
+    # ---- forward ----------------------------------------------------------
+
+    def _local_anchor_channels(
+        self, x: torch.Tensor, scale_factor: torch.Tensor | float | None,
+    ) -> torch.Tensor:
+        """Two causal local-statistics channels exposing the recent level/scale to
+        the encoder (the gradient-connected re-anchoring signal WindowMinMax lacks):
+          ch1 = (x_t - m_t) / (s_t + eps)   local-scale residual (a causal z-score)
+          ch2 = log(s_t + eps)              log local scale (global normed range ~= 1)
+        m_t, s_t = causal boxcar mean / std over a trailing window w ~ one canonical
+        period round(base_seasonality / scale_factor), clamped [8, L//4], fallback 64.
+        Vectorized via cumsum + per-sample-window gather (O(L), no python loop).
+        """
+        B, L = x.shape
+        device = x.device
+        if scale_factor is not None:
+            sf = (scale_factor if torch.is_tensor(scale_factor)
+                  else x.new_tensor(scale_factor)).reshape(-1).float()
+            if sf.numel() == 1:
+                sf = sf.expand(B)
+            w = (self.base_seasonality / sf.clamp(min=1e-3)).round().long()
+            w = w.clamp(min=8, max=max(8, L // 4))
+        else:
+            w = torch.full((B,), 64, device=device, dtype=torch.long)
+        # Center by the per-series mean before a FP32 cumsum. The two-pass variance
+        # (E[x^2]-E[x]^2) over a length-L cumsum otherwise suffers catastrophic
+        # cancellation on long flat/sparse regions; variance is shift-invariant, so
+        # centering changes nothing but keeps the cumsum magnitudes small enough that
+        # fp32 stays accurate there, at no extra memory.
+        xf = x.float()
+        xc = xf - xf.mean(dim=1, keepdim=True)
+        cs = F.pad(torch.cumsum(xc, dim=1), (1, 0))           # (B, L+1), cs[:,0]=0
+        cs2 = F.pad(torch.cumsum(xc * xc, dim=1), (1, 0))
+        t = torch.arange(L, device=device).view(1, L).expand(B, L)
+        lo = (t - w.view(B, 1) + 1).clamp(min=0)              # trailing-window start
+        cnt = (t - lo + 1).float()                            # window length (>= 1)
+        sum_x = cs.gather(1, t + 1) - cs.gather(1, lo)
+        sum_x2 = cs2.gather(1, t + 1) - cs2.gather(1, lo)
+        m = sum_x / cnt                                       # centered local mean
+        s = (sum_x2 / cnt - m * m).clamp(min=0.0).sqrt()      # local std (shift-invariant)
+        eps = 1e-4   # floor vs the unit normed range -> flat regions give ch1 ~ 0, no blowup
+        ch1 = (xc - m) / (s + eps)                            # = (x - local mean)/(s+eps)
+        ch2 = torch.log(s + eps)
+        return torch.stack([ch1, ch2], dim=-1).to(x.dtype)    # (B, L, 2)
+
+    def forward(
+        self,
+        x_normed: torch.Tensor,
+        nan_mask: torch.Tensor | None = None,
+        scale_factor: torch.Tensor | float | None = None,
+        horizon: int | None = None,
+    ) -> torch.Tensor:
+        # observed-mask (1=observed, 0=missing) for the missing-value channel.
+        # res_adaptive is rejected with missing_channel (see __init__), so this
+        # mask stays aligned with x throughout.
+        obs_mask = None
+        if self.missing_channel and nan_mask is not None:
+            obs_mask = nan_mask[..., 0] if nan_mask.dim() == 3 else nan_mask  # (B,L)
+
+        if x_normed.dim() == 3 and x_normed.shape[-1] > 1:
+            x = x_normed[..., 0]
+        elif x_normed.dim() == 3:
+            x = x_normed.squeeze(-1)
+        else:
+            x = x_normed                                            # (B, L)
+
+        x = torch.nan_to_num(x, nan=0.0, posinf=0.0, neginf=0.0)
+        B, L = x.shape
+        assert L == self.L, f"context length mismatch: got {L}, expected {self.L}"
+        H = self.p_out if horizon is None else int(horizon)
+        device = x.device
+
+        # Period detection in fp32 (no grad).
+        periods, n_valid, scores = self._detect_periods(x.float())  # (B,K),(B,),(B,K)
+
+        # Resolution adaptation: warp context to a canonical cycle-resolution so
+        # the fixed dilations span consistent cycle-fractions across rates.
+        if self.res_adaptive:
+            x, periods, fut_pos = self._resolution_adapt(x, periods, H)
+            ctx_pos = torch.arange(L, device=device).view(1, L).expand(B, L)
+        else:
+            ctx_pos = torch.arange(L, device=device).view(1, L).expand(B, L)
+            fut_pos = torch.arange(L, L + H, device=device).view(1, H).expand(B, H)
+        with torch.amp.autocast(
+            device_type=device.type if x.is_cuda else "cpu", enabled=False,
+        ):
+            ctx_pe = _positional_encoding(
+                ctx_pos, periods, L, n_harmonics=self.n_harmonics,
+            )
+            fut_pe = _positional_encoding(
+                fut_pos, periods, L, n_harmonics=self.n_harmonics,
+            )
+        ctx_pe = ctx_pe.to(x.dtype)
+        fut_pe = fut_pe.to(x.dtype)
+
+        # Per-period reliability weight (period_trust; off in the released config).
+        # Down-weight unreliable/spurious periods continuously. Applied to the
+        # phase-encoding channels here, and to the phase-binning gather + gate below.
+        ptw = None
+        if self.pt is not None:
+            ptw = self._period_trust_weights(periods, scores).to(x.dtype)  # (B,K)
+            # phase channels are the first n_phase cols, laid out per period as
+            # n_harmonics*2 consecutive channels → repeat each w_k that many times.
+            rep = self.n_harmonics * 2
+            chan_w = ptw.repeat_interleave(rep, dim=1).view(B, 1, -1)        # (B,1,n_phase)
+            np_ = chan_w.shape[-1]
+            ctx_pe = torch.cat([ctx_pe[..., :np_] * chan_w, ctx_pe[..., np_:]], dim=-1)
+            fut_pe = torch.cat([fut_pe[..., :np_] * chan_w, fut_pe[..., np_:]], dim=-1)
+
+        # Embed context.
+        if self.decompose_kernel > 0:
+            # moving-average series decomposition: moving-average trend +
+            # seasonal residual, fed as two channels.
+            k = self.decompose_kernel
+            pad = k // 2
+            xp = F.pad(x.unsqueeze(1), (pad, pad), mode="replicate")  # (B,1,L+2pad)
+            trend = F.avg_pool1d(xp, kernel_size=k, stride=1)[..., :L].squeeze(1)
+            seasonal = x - trend
+            value_ch = torch.stack([trend, seasonal], dim=-1)       # (B,L,2)
+        else:
+            value_ch = x.unsqueeze(-1)                              # (B,L,1)
+        if self.missing_channel and obs_mask is not None:
+            value_ch = torch.cat(
+                [value_ch, obs_mask.unsqueeze(-1).to(value_ch.dtype)], dim=-1
+            )                                                       # (B,L,nv+1)
+        if self.local_anchor:
+            value_ch = torch.cat(
+                [value_ch, self._local_anchor_channels(x, scale_factor)], dim=-1
+            )                                                       # (B,L,nv+2)
+        ctx_in = torch.cat([value_ch, ctx_pe], dim=-1)             # (B,L,nv+n_pe)
+        h = self.in_proj(ctx_in)                                    # (B, L, D)
+
+        # Dilated-conv encoder.
+        for block in self.encoder:
+            h = block(h)
+
+        # Per-horizon context feature: static pooled summary, broadcast to all H.
+        summary = self._pool(h)                                     # (B, pool_dim)
+        ctx_feat = summary.unsqueeze(1).expand(B, H, -1)            # (B, H, pool_dim)
+
+        # Decoder: per-horizon query from PE(L+h) + context feature
+        # [+ phase profile] [+ recency profile] [+ cross-cycle feat].
+        q_parts = [fut_pe, ctx_feat]
+
+        phase_feat = None
+        if self.phase_mix is not None:
+            prof = self._phase_profile(h, periods)                  # (B,K,nb,S·D)
+            phase_feat = self._gather_phase(prof, fut_pos, periods, weight=ptw)  # (B,H,D)
+
+        rec_feat = None
+        if self.recency_mix is not None:
+            rec_feat = self._recency_feat(h).unsqueeze(1).expand(B, H, self.D)
+
+        if self.sig_gate and phase_feat is not None and rec_feat is not None:
+            # Blend by periodicity strength: many significant periods → trust
+            # the phase profile; few/none → lean on the recency profile. With
+            # period_trust, use the soft Σw instead of the integer n_valid.
+            strength = ptw.sum(dim=1) if ptw is not None else n_valid.float()
+            g = (strength / float(self.K)).clamp(0.0, 1.0).view(B, 1, 1)
+            q_parts.append(g * phase_feat + (1.0 - g) * rec_feat)
+        else:
+            if phase_feat is not None:
+                q_parts.append(phase_feat)
+            if rec_feat is not None:
+                q_parts.append(rec_feat)
+
+        if self.cross_cycle:
+            cc_prof = self._cross_cycle_profile(h, periods)         # (B,nb,D)
+            q_parts.append(self._gather_cc(cc_prof, fut_pos, periods))  # (B,H,D)
+
+        q_in = torch.cat(q_parts, dim=-1)
+        q = self.query_proj(q_in)                                   # (B, H, D)
+
+        if self.future_conv:
+            # Horizon-axis evolving states from a causal conv over context-tail
+            # + seasonal-naive fill, injected additively (fc_out zero-init =>
+            # exact baseline at init). Gives the static-summary decoder the
+            # per-horizon dynamics it lacks.
+            fill = self._seasonal_naive(x, fut_pos, periods)        # (B, H)
+            fut_states = self._future_conv_states(h, fut_pe, fill)  # (B, H, D)
+            q = q + self.fc_out(fut_states)
+
+        for ffn, norm in zip(self.decoder_ffns, self.decoder_norms):
+            q = _norm_fp32(norm, q + ffn(q))
+
+        if self.horizon_conv is not None:
+            # Causal conv over the horizon axis: pad (k-1) on the left so step
+            # h sees only h, h-1, …, h-(k-1): no future leakage, any H.
+            qt = F.pad(q.transpose(1, 2), (self.horizon_kernel - 1, 0))
+            hc = self.horizon_conv(qt).transpose(1, 2)             # (B,H,D)
+            q = _norm_fp32(self.horizon_norm, q + hc)
+
+        if self.hr_z is not None:
+            # gated-recurrence decode-state: gated diagonal recurrence over the H axis.
+            # Scans the query FEATURES only (no value feedback). Sequential
+            # scan: the horizon is short, so this is cheap and stable.
+            z = torch.sigmoid(self.hr_z(q))                        # (B,H,D) update gate
+            c = torch.tanh(self.hr_c(q))                           # (B,H,D) candidate
+            s = torch.zeros(B, self.D, dtype=q.dtype, device=q.device)
+            states = []
+            for t in range(q.shape[1]):
+                s = (1.0 - z[:, t]) * s + z[:, t] * c[:, t]
+                states.append(s)
+            hstate = torch.stack(states, dim=1)                    # (B,H,D)
+            q = _norm_fp32(self.hr_norm, q + self.hr_o(hstate))    # hr_o zero-init
+
+        y = self.out_proj(q)                                        # (B, H, Q)
+
+
+        if self.residual_naive:
+            # Learn the residual over a (multi-)seasonal-naive baseline.
+            if self.residual_multi:
+                baseline = self._super_naive(x, fut_pos, periods)   # (B, H)
+            else:
+                baseline = self._seasonal_naive(x, fut_pos, periods)  # (B, H)
+            y = y + baseline.unsqueeze(-1)
+
+        return y
+

tinycast/checkpoint.py

@@ -0,0 +1,45 @@
+"""Weight loading for TinyCast.
+
+The released weights are a ``model.safetensors`` + a ``config.json`` (the
+architecture config). ``load_checkpoint`` (aliased ``load_model``) handles the weight-tied
+FFN sharing: the file stores each unique parameter storage once (the true
+146,505-parameter footprint, ~0.6 MB) and restores the sharing on load.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Optional, Tuple
+
+from .config import TinyCastConfig
+from .model import TinyCastForPrediction
+
+
+def load_checkpoint(
+    weights_path: str,
+    config_path: Optional[str] = None,
+) -> Tuple[TinyCastForPrediction, TinyCastConfig]:
+    """Load TinyCastForPrediction from ``model.safetensors`` + ``config.json``.
+
+    ``config_path`` defaults to a sibling ``config.json`` next to the weights.
+    """
+    from safetensors.torch import load_model
+
+    st = Path(weights_path)
+    if config_path is None:
+        config_path = st.parent / "config.json"
+    with open(config_path) as f:
+        cfg_dict = json.load(f)
+    cfg = TinyCastConfig(**{
+        k: v for k, v in cfg_dict.items()
+        if k in TinyCastConfig.__dataclass_fields__
+    })
+    model = TinyCastForPrediction(cfg)
+    load_model(model, str(st))
+    model.eval()
+    return model, cfg
+
+
+# Explicit alias used by the notebook / README examples.
+load_model = load_checkpoint

tinycast/config.py

@@ -0,0 +1,49 @@
+"""TinyCast model configuration.
+
+Only the fields that shape the deployed model's construction / forward are
+kept. Field defaults are the released model's values, so ``TinyCastConfig()`` alone
+reconstructs the deployed architecture; loading from ``config.json`` overrides
+them.
+"""
+
+from dataclasses import asdict, dataclass, field
+from typing import List
+
+
+@dataclass
+class TinyCastConfig:
+    """Configuration for the deployed TinyCast (dilated-conv) model."""
+
+    # --- input / output geometry -------------------------------------------
+    quantiles: List[float] = field(
+        default_factory=lambda: [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
+    )
+    seq_len: int = 2048                   # L: encoder context window
+    output_token_len: int = 48            # p: single-shot / AR-chunk horizon
+
+    # --- period detector (shared structural prior) -------------------------
+    top_k_periods: int = 4
+    significance_alpha: float = 0.05
+    n_harmonics: int = 1
+
+    # --- dilated-conv backbone ---------------------------------------------
+    conv_dim: int = 64
+    n_layers: int = 10
+    kernel_size: int = 3
+    ffn_mult: float = 1.0
+    pool_kind: str = "mean_last"
+    causal: bool = True
+    phase_bins: int = 16
+    decoder_depth: int = 1
+    separable_conv: bool = True
+    share_ffn: bool = True
+    future_conv: bool = True
+    future_conv_layers: int = 6
+    future_conv_seed: int = 128
+
+    @property
+    def num_quantiles(self) -> int:
+        return len(self.quantiles)
+
+    def to_dict(self) -> dict:
+        return asdict(self)

tinycast/corpus.py

@@ -0,0 +1,661 @@
+"""The canonical synthetic corpus: recipe, shard builder and verifier.
+
+TinyCast's pretraining mix is GIFT-Eval-Pretrain and Chronos KernelSynth, taken
+from their publishers, plus four synthetic shards. This module is the record of
+how those four shards were made: four shards of 62,500 series at length 4,096,
+families mixed 70/15/15 over the generators in :mod:`tinycast.synth`.
+
+Everything that changes the generated bytes is a default in
+:data:`CANONICAL_RECIPE` rather than an argument, so ``build_shard()`` with no
+arguments reproduces published shard 0 and there is nothing to tune. Treat the
+values in that dictionary as versioned data: changing one produces a different
+corpus, not a differently configured build of the same one.
+
+WHAT REPRODUCIBILITY MEANS HERE. The shards are published as files, so the
+corpus can be downloaded and read without regenerating anything. Regeneration
+reproduces the published float16 payload exactly on the stack it was generated
+on: 0 of 327,680 values differ across 4 shards by 20 rows on an RTX 3090 with
+torch 2.10.0+cu128 and driver 580.159.03. Reproduction on other GPUs, CUDA
+versions or torch builds is untested, and the GP family runs through cuSOLVER,
+so it is not safe to assume it carries over. :func:`verify_shard` is how you
+find out for a given stack: it regenerates a prefix and reports how many
+float16 values differ.
+
+Verify against ``series.f16``, which is the payload, and not against
+``series_mean.f32``. That sidecar is a float32 sum with heavy cancellation on
+near-zero-mean rows, so its last bit moves with the numpy build while the f16
+payload it feeds is unaffected. ``series_stdev.f32`` does not cancel.
+
+CUDA IS REQUIRED, and is enforced rather than detected. The GP family samples
+by dense Cholesky, and off CUDA that factorization and the normal draws feeding
+it come from different generators, so the same seed gives different series: the
+CPU path moves up to 182 of the 4,096 float32 values in a row. The published
+shards came from the CUDA branch. A build with no GPU therefore fails here
+instead of falling back and quietly producing a different corpus.
+"""
+from __future__ import annotations
+
+import io
+import json
+import math
+import os
+import time
+from pathlib import Path
+from typing import Iterator, Optional, Tuple, Union
+
+import numpy as np
+
+from .synth import generate_gp, generate_spikes, generate_tsi
+
+_F16_BYTES = 2
+
+# ---------------------------------------------------------------------------
+# The canonical recipe.
+#
+# Every entry is a default. A reviewer runs the build with no flags and gets the
+# published corpus.
+# ---------------------------------------------------------------------------
+CANONICAL_RECIPE = {
+    "version": "tinycast-synth-4096/v1",
+    "n_shards": 4,
+    "series_per_shard": 62_500,
+    "length": 4096,
+    "mix": (0.70, 0.15, 0.15),          # gp, spikes, tsi
+    "chunk": 2048,                       # series generated per call
+    "device": "cuda",
+    # Part of the data, not a memory knob. cuSOLVER factorizes a batch of one on
+    # a different code path from a real batch, and these covariances are close
+    # to singular (periodic and linear kernels with only 1e-6 jitter), so the
+    # factors differ by around 1e-8 and the published rows do not reproduce at
+    # batch=1. Batches of 2, 4, 8 and 32 all agree with each other and with the
+    # published data. Lowering this to fit a smaller GPU changes the corpus.
+    "gp_batch": 32,
+    "scale_factor_range": (0.05, 6.0),   # log-uniform, per series
+    "verified_stack": "RTX 3090 / torch 2.10.0+cu128 / driver 580.159.03",
+    # Per-shard seed and family salts. The seed is 50,000 x shard, confirmed by
+    # reproducing all 62,500 scale factors of each shard bit for bit.
+    #
+    # The salts cannot be computed, which is why they are carried as data. They
+    # were a per-family hash of the family name taken under CPython's randomized
+    # string hashing, so every build process drew its own set and no two shards
+    # share a triple. Replacing them with a stable hash would make future builds
+    # reproducible while making the published shards unreproducible. They were
+    # recovered by brute force against the published bytes (997 candidates per
+    # family) and frozen here.
+    "shards": {
+        0: {"seed": 0,       "salt": {"gp": 724, "spikes": 351, "tsi": 900}},
+        1: {"seed": 50_000,  "salt": {"gp":  23, "spikes": 431, "tsi": 840}},
+        2: {"seed": 100_000, "salt": {"gp": 762, "spikes": 505, "tsi": 641}},
+        3: {"seed": 150_000, "salt": {"gp": 691, "spikes": 491, "tsi": 745}},
+    },
+}
+
+FAMILIES = ("gp", "spikes", "tsi")
+
+# Files a shard directory holds. The first six are the payload and its indices;
+# the last two attribute each row to a family.
+CACHE_FILES = (
+    "series.f16", "offsets.npy", "lengths.npy", "scale_factors.f32",
+    "series_mean.f32", "series_stdev.f32",
+)
+FAMILY_FILES = ("dataset_id.u16", "dataset_names.json")
+
+DEFAULT_OUT_DIR = "synth4096_{shard}"
+
+# Rows compared by verify_shard. Twenty is what the published fidelity statement
+# was measured over, and at 4,096 samples a row it is already 81,920 values.
+DEFAULT_VERIFY_ROWS = 20
+DEFAULT_VERIFY_SCALE_FACTORS = 4096
+
+
+# ---------------------------------------------------------------------------
+# Recipe lookups
+# ---------------------------------------------------------------------------
+
+def _shard_record(shard: int) -> dict:
+    try:
+        return CANONICAL_RECIPE["shards"][int(shard)]
+    except KeyError:
+        raise KeyError(
+            f"shard {shard} is not in the published corpus, which covers shards "
+            f"{sorted(CANONICAL_RECIPE['shards'])}."
+        ) from None
+
+
+def shard_seed(shard: int) -> int:
+    """Base seed for a shard. The scale-factor stream is drawn from it."""
+    return int(_shard_record(shard)["seed"])
+
+
+def family_salt(family: str, shard: int) -> int:
+    """Per-shard, per-family seed offset, looked up rather than computed.
+
+    See :data:`CANONICAL_RECIPE` for why these are data. A missing entry means
+    the salt has not been recovered for that shard, and generation refuses
+    rather than substituting a computed one: a computed salt would produce a
+    different corpus while appearing to succeed.
+    """
+    salt = _shard_record(shard)["salt"].get(family)
+    if salt is None:
+        raise RuntimeError(
+            f"the salt for family {family!r} on shard {shard} is not recorded, so "
+            f"that shard cannot be reproduced. It is a single integer in [0, 997) "
+            f"and is recoverable by brute force against the published bytes. "
+            f"Refusing to substitute a computed value."
+        )
+    return int(salt)
+
+
+def plan_counts(
+    n_series: Optional[int] = None, mix: Optional[tuple] = None,
+) -> Tuple[int, int, int]:
+    """Series per family, in emission order (gp, spikes, tsi).
+
+    This is also how a published shard's family boundaries are read. The
+    per-row family sidecars of the published shards were overwritten by a
+    post-processing step that collapsed them to a single label with all ids
+    zero, so the attribution cannot be recovered from the files themselves; the
+    payload, indices and scale factors were not touched. A shard that ends up
+    one row short lost a GP row to a covariance that failed to factorize (see
+    :func:`iter_shard_series`), which shifts the boundaries down by that many.
+    """
+    n_series = CANONICAL_RECIPE["series_per_shard"] if n_series is None else int(n_series)
+    mix = CANONICAL_RECIPE["mix"] if mix is None else tuple(mix)
+    n_gp = int(round(n_series * mix[0]))
+    n_spikes = int(round(n_series * mix[1]))
+    return n_gp, n_spikes, n_series - n_gp - n_spikes
+
+
+def _sample_scale_factor(rng: np.random.Generator) -> float:
+    """Log-uniform scale factor, one draw per emitted series.
+
+    Synthetic series carry no sampling frequency, so each gets a scale factor
+    drawn from the range that the real corpora's frequency-derived factors span.
+    """
+    low, high = CANONICAL_RECIPE["scale_factor_range"]
+    return float(np.exp(rng.uniform(math.log(low), math.log(high))))
+
+
+def _require_cuda(device: Optional[str]) -> str:
+    """Resolve and check the device, refusing anything but the canonical one."""
+    canonical = CANONICAL_RECIPE["device"]
+    device = canonical if device is None else str(device)
+    if device != canonical:
+        raise ValueError(
+            f"device={device!r} is not the device this corpus was generated on "
+            f"({canonical!r}). The GP family draws from a different generator on "
+            f"each branch, so the same seed gives different series and overriding "
+            f"the device does not reproduce the published shards."
+        )
+    try:
+        import torch
+    except ImportError as exc:
+        raise RuntimeError(
+            "torch is required: this corpus was generated on the CUDA branch."
+        ) from exc
+    if not torch.cuda.is_available():
+        raise RuntimeError(
+            "no CUDA device is available. This corpus was generated on the CUDA "
+            "branch, and a CPU run would produce different data rather than "
+            "reproducing it, so this fails instead of falling back."
+        )
+    return device
+
+
+# ---------------------------------------------------------------------------
+# Generation
+# ---------------------------------------------------------------------------
+
+def iter_shard_series(
+    shard: int = 0,
+    *,
+    max_series: Optional[int] = None,
+    device: Optional[str] = None,
+) -> Iterator[Tuple[np.ndarray, float, str]]:
+    """Yield ``(series, scale_factor, family_label)`` for one published shard.
+
+    Families are emitted in order, GP first, each generated in chunks of
+    ``CANONICAL_RECIPE["chunk"]`` series under a seed of
+    ``shard_seed + 1000 * chunk_index + family_salt``. GP rows whose covariance
+    failed to factorize come back non-finite and are dropped here, which is the
+    only way a shard ends up holding fewer rows than planned.
+
+    ``max_series`` truncates the emitted stream and leaves the plan alone, so
+    what it yields is the published prefix. Generation still runs in canonical
+    chunks, so the first chunk is produced in full however early the truncation
+    falls; :func:`verify_shard` is the cheap way to check a stack.
+    ``device`` exists only so that asking for a non-canonical one fails loudly.
+
+    Validation runs before the first row is generated. The refusals above are
+    worth nothing if they wait for the caller to start iterating, which is what
+    happens when a generator function does its own argument checking.
+    """
+    device = _require_cuda(device)
+    seed = shard_seed(shard)
+    salts = {f: family_salt(f, shard) for f in FAMILIES}
+    if max_series is not None and int(max_series) < 0:
+        raise ValueError("max_series must be non-negative")
+    return _iter_shard_series(shard, seed, salts, max_series, device)
+
+
+def _iter_shard_series(
+    shard: int,
+    seed: int,
+    salts: dict,
+    max_series: Optional[int],
+    device: str,
+) -> Iterator[Tuple[np.ndarray, float, str]]:
+    """Generator body for :func:`iter_shard_series`, validation already done."""
+    length = CANONICAL_RECIPE["length"]
+    chunk = CANONICAL_RECIPE["chunk"]
+    gp_batch = CANONICAL_RECIPE["gp_batch"]
+    counts = dict(zip(FAMILIES, plan_counts()))
+    generators = {
+        "gp": lambda n, s: generate_gp(n, length, seed=s, device=device,
+                                       batch=gp_batch),
+        "spikes": lambda n, s: generate_spikes(n, length, seed=s),
+        "tsi": lambda n, s: generate_tsi(n, length, seed=s),
+    }
+
+    rng = np.random.default_rng(seed)
+    emitted_total = 0
+    dropped = 0
+    for family in FAMILIES:
+        total = counts[family]
+        label = f"{family}_{length}"
+        generated = 0
+        chunk_index = 0
+        while generated < total:
+            cur = min(chunk, total - generated)
+            block = generators[family](cur, seed + 1000 * chunk_index + salts[family])
+            chunk_index += 1
+            generated += cur
+            for row in block:
+                if not np.isfinite(row).all():
+                    dropped += 1
+                    continue
+                yield row, _sample_scale_factor(rng), label
+                emitted_total += 1
+                if max_series is not None and emitted_total >= int(max_series):
+                    return
+        print(f"  {family}: {total} generated, {dropped} dropped so far", flush=True)
+
+
+# ---------------------------------------------------------------------------
+# Writing a shard
+# ---------------------------------------------------------------------------
+
+def normalize_for_f16(series: np.ndarray) -> Tuple[np.ndarray, float, float]:
+    """Per-series z-normalization ahead of the float16 cast.
+
+    float16 stores the payload at half the size of float32 but caps magnitudes
+    at 65,504, which raw series exceed. Storing a z-normalized payload with the
+    mean and standard deviation alongside it keeps any realistic magnitude in
+    range, and the read path is ``x = payload * stdev + mean`` with no
+    branching: a constant series is stored with ``stdev = 1`` so its payload is
+    identically zero and denormalizes exactly.
+    """
+    series = np.asarray(series, dtype=np.float32)
+    clean = np.where(np.isfinite(series), series, np.nan)
+    finite = clean[~np.isnan(clean)]
+    if finite.size == 0:
+        return clean, 0.0, 1.0
+    mu = float(finite.mean())
+    sd = float(finite.std())
+    sd_safe = sd if sd > 0.0 else 1.0
+    return ((clean - mu) / sd_safe).astype(np.float32, copy=False), mu, sd_safe
+
+
+def build_shard(
+    out_dir: Union[str, Path, None] = None,
+    shard: int = 0,
+    *,
+    max_series: Optional[int] = None,
+    overwrite: bool = False,
+) -> int:
+    """Generate one published shard and write it as a cache directory.
+
+    Called with no arguments this reproduces shard 0 into ``synth4096_0``. The
+    written files are the six payload and index files, the two family sidecars,
+    and ``recipe.json``, which records the recipe and the stack that produced
+    the directory. Returns the number of series written.
+
+    The payload is streamed to a temporary file and renamed on success, so an
+    interrupted build leaves no directory that looks complete.
+    """
+    _require_cuda(None)
+    for family in FAMILIES:                # refuse an unreproducible shard first
+        family_salt(family, shard)
+    out_dir = Path(DEFAULT_OUT_DIR.format(shard=shard) if out_dir is None else out_dir)
+    if all((out_dir / f).exists() for f in CACHE_FILES) and not overwrite:
+        raise RuntimeError(
+            f"{out_dir} already holds a shard. Pass overwrite=True to rebuild it, "
+            f"or build into a new directory."
+        )
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    length = CANONICAL_RECIPE["length"]
+    n_gp, n_spikes, n_tsi = plan_counts()
+    print(f"building shard {shard} into {out_dir}: gp={n_gp} spikes={n_spikes} "
+          f"tsi={n_tsi} length={length} device={CANONICAL_RECIPE['device']}",
+          flush=True)
+
+    offsets: list[int] = []
+    lengths: list[int] = []
+    scale_factors: list[float] = []
+    means: list[float] = []
+    stdevs: list[float] = []
+    labels: list[str] = []
+    label_ids: dict[str, int] = {}
+    ids: list[int] = []
+
+    tmp_payload = out_dir / "series.f16.tmp"
+    cursor = 0
+    n_written = 0
+    t0 = time.time()
+    try:
+        with open(tmp_payload, "wb") as fp:
+            for row, sf, label in iter_shard_series(shard, max_series=max_series):
+                normalized, mu, sd = normalize_for_f16(row)
+                payload = normalized.astype(np.float16, copy=False)
+                fp.write(payload.tobytes())
+                offsets.append(cursor)
+                lengths.append(int(payload.size))
+                scale_factors.append(float(sf))
+                means.append(mu)
+                stdevs.append(sd)
+                if label not in label_ids:
+                    label_ids[label] = len(labels)
+                    labels.append(label)
+                ids.append(label_ids[label])
+                cursor += int(payload.size) * _F16_BYTES
+                n_written += 1
+                if n_written % 10_000 == 0:
+                    rate = n_written / max(time.time() - t0, 1e-6)
+                    print(f"  {n_written:,} written, {rate:.0f} series/s, "
+                          f"{cursor / 1e9:.2f} GB", flush=True)
+            fp.flush()
+            os.fsync(fp.fileno())
+    except BaseException:
+        tmp_payload.unlink(missing_ok=True)
+        raise
+
+    if n_written == 0:
+        tmp_payload.unlink(missing_ok=True)
+        raise RuntimeError("no series were generated, so nothing was written")
+
+    os.replace(tmp_payload, out_dir / "series.f16")
+    np.save(out_dir / "offsets.npy", np.asarray(offsets, dtype=np.int64))
+    np.save(out_dir / "lengths.npy", np.asarray(lengths, dtype=np.int32))
+    _write_bytes(out_dir / "scale_factors.f32",
+                 np.asarray(scale_factors, dtype=np.float32).tobytes())
+    _write_bytes(out_dir / "series_mean.f32",
+                 np.asarray(means, dtype=np.float32).tobytes())
+    _write_bytes(out_dir / "series_stdev.f32",
+                 np.asarray(stdevs, dtype=np.float32).tobytes())
+    _write_bytes(out_dir / "dataset_id.u16",
+                 np.asarray(ids, dtype=np.uint16).tobytes())
+    _write_bytes(out_dir / "dataset_names.json",
+                 json.dumps({"version": 2, "datasets": labels}).encode("utf-8"))
+    _write_bytes(out_dir / "recipe.json",
+                 json.dumps(_provenance(shard, n_written), indent=2).encode("utf-8"))
+
+    print(f"wrote {n_written:,} series in {time.time() - t0:.0f}s "
+          f"({cursor / 1e9:.2f} GB) to {out_dir}", flush=True)
+    return n_written
+
+
+def _write_bytes(path: Path, data: bytes) -> None:
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    with open(tmp, "wb") as fp:
+        fp.write(data)
+        fp.flush()
+        os.fsync(fp.fileno())
+    os.replace(tmp, path)
+
+
+def _provenance(shard: int, n_written: int) -> dict:
+    record = {
+        "version": CANONICAL_RECIPE["version"],
+        "shard": int(shard),
+        "seed": shard_seed(shard),
+        "salt": dict(_shard_record(shard)["salt"]),
+        "series_written": int(n_written),
+        "series_planned": CANONICAL_RECIPE["series_per_shard"],
+        "length": CANONICAL_RECIPE["length"],
+        "mix": list(CANONICAL_RECIPE["mix"]),
+        "chunk": CANONICAL_RECIPE["chunk"],
+        "gp_batch": CANONICAL_RECIPE["gp_batch"],
+        "device": CANONICAL_RECIPE["device"],
+        "verified_stack": CANONICAL_RECIPE["verified_stack"],
+    }
+    try:
+        import torch
+        record["torch"] = torch.__version__
+        if torch.cuda.is_available():
+            record["gpu"] = torch.cuda.get_device_name(0)
+    except Exception:                      # provenance is best effort
+        pass
+    record["numpy"] = np.__version__
+    return record
+
+
+# ---------------------------------------------------------------------------
+# Verifying a shard against the published one
+# ---------------------------------------------------------------------------
+
+def _resolve_source(path_or_url: Union[str, Path]) -> Union[Path, str]:
+    """A local directory, or an https prefix ending in a slash.
+
+    ``hf://<owner>/<repo>[/<subdir>]`` is rewritten to the dataset's resolve
+    URL, which serves byte ranges. That matters: checking twenty rows pulls
+    about 160 KB rather than the half gigabyte a shard payload occupies.
+    """
+    text = str(path_or_url)
+    if text.startswith("hf://"):
+        parts = [p for p in text[len("hf://"):].split("/") if p]
+        if len(parts) < 2:
+            raise ValueError("hf:// source must be hf://<owner>/<repo>[/<subdir>]")
+        repo = "/".join(parts[:2])
+        subdir = "/".join(parts[2:])
+        url = f"https://huggingface.co/datasets/{repo}/resolve/main/"
+        return url + (subdir + "/" if subdir else "")
+    if text.startswith("http://") or text.startswith("https://"):
+        return text if text.endswith("/") else text + "/"
+    return Path(text)
+
+
+def _read_file(source: Union[Path, str], name: str) -> bytes:
+    if isinstance(source, Path):
+        return (source / name).read_bytes()
+    import urllib.request
+    with urllib.request.urlopen(source + name) as response:
+        return response.read()
+
+
+def _read_range(source: Union[Path, str], name: str, start: int, count: int) -> bytes:
+    if isinstance(source, Path):
+        with open(source / name, "rb") as fp:
+            fp.seek(start)
+            return fp.read(count)
+    import urllib.request
+    request = urllib.request.Request(
+        source + name, headers={"Range": f"bytes={start}-{start + count - 1}"})
+    with urllib.request.urlopen(request) as response:
+        data = response.read()
+    if len(data) != count:                 # server ignored the range header
+        data = data[start:start + count]
+    return data
+
+
+def verify_shard(
+    path_or_url: Union[str, Path],
+    shard: int = 0,
+    *,
+    n_rows: int = DEFAULT_VERIFY_ROWS,
+    n_scale_factors: int = DEFAULT_VERIFY_SCALE_FACTORS,
+    verbose: bool = True,
+) -> dict:
+    """Regenerate a prefix of a published shard and report how far it agrees.
+
+    ``path_or_url`` is a shard directory, an https prefix, or
+    ``hf://<owner>/<repo>[/<subdir>]``. The comparison is against
+    ``series.f16``, the payload, cast the same way the builder casts it. The
+    returned report gives ``values_differing`` out of ``values_compared``, which
+    is the number this module's fidelity claim is stated in.
+
+    ``n_rows`` rows are regenerated from the GP family, which is what a shard
+    opens with, rounded up to a whole number of GP batches so the batch shape
+    matches the published run. It must not exceed one chunk. Set it to 0 to skip
+    the payload check, which is the only part that needs a GPU; the scale-factor
+    check runs anywhere and still exercises the seed scheme.
+
+    A shard that holds fewer rows than planned lost GP rows to covariances that
+    failed to factorize. Those rows are dropped here too, so the compared prefix
+    stays aligned, but the scale-factor stream shifts by one draw per drop, and
+    a mismatch after the drop index is expected rather than a fidelity failure.
+    """
+    source = _resolve_source(path_or_url)
+    length = CANONICAL_RECIPE["length"]
+    chunk = CANONICAL_RECIPE["chunk"]
+    gp_batch = CANONICAL_RECIPE["gp_batch"]
+    n_rows = int(n_rows)
+    if n_rows > chunk:
+        raise ValueError(
+            f"n_rows={n_rows} exceeds one chunk ({chunk}); rows beyond the first "
+            f"chunk are generated under a different seed and would need the whole "
+            f"shard regenerated."
+        )
+
+    published_lengths = np.load(io.BytesIO(_read_file(source, "lengths.npy")))
+    published_offsets = np.load(io.BytesIO(_read_file(source, "offsets.npy")))
+    published_rows = int(published_lengths.size)
+    planned_rows = CANONICAL_RECIPE["series_per_shard"]
+
+    report = {
+        "source": str(path_or_url),
+        "shard": int(shard),
+        "published_rows": published_rows,
+        "planned_rows": planned_rows,
+        "rows_short_of_plan": max(planned_rows - published_rows, 0),
+        "rows_compared": 0,
+        "values_compared": 0,
+        "values_differing": None,
+        "scale_factors_compared": 0,
+        "scale_factors_differing": None,
+        "payload_checked": False,
+        "verified_stack": CANONICAL_RECIPE["verified_stack"],
+    }
+
+    if n_scale_factors:
+        published_sf = np.frombuffer(
+            _read_file(source, "scale_factors.f32"), dtype=np.float32)
+        n_sf = min(int(n_scale_factors), published_sf.size)
+        rng = np.random.default_rng(shard_seed(shard))
+        ours = np.asarray([_sample_scale_factor(rng) for _ in range(n_sf)],
+                          dtype=np.float32)
+        differing = int(np.count_nonzero(ours != published_sf[:n_sf]))
+        report["scale_factors_compared"] = n_sf
+        report["scale_factors_differing"] = differing
+
+    if n_rows > 0:
+        _require_cuda(None)
+        n_generate = int(math.ceil(n_rows / gp_batch) * gp_batch)
+        block = generate_gp(
+            n_generate, length,
+            seed=shard_seed(shard) + family_salt("gp", shard),
+            device=CANONICAL_RECIPE["device"], batch=gp_batch,
+        )
+        kept = [row for row in block if np.isfinite(row).all()]
+        if len(kept) < n_rows:
+            raise RuntimeError(
+                f"regeneration produced only {len(kept)} usable rows of the "
+                f"{n_rows} requested: {n_generate - len(kept)} covariances failed "
+                f"to factorize. Investigate that before reading anything into a "
+                f"comparison, since it is far above the published failure rate."
+            )
+        differing = 0
+        compared = 0
+        max_abs_diff = 0.0
+        for i in range(n_rows):
+            n = int(published_lengths[i])
+            if n != length:
+                raise RuntimeError(
+                    f"published row {i} has length {n}, not {length}: this is not "
+                    f"a shard of this corpus."
+                )
+            raw = _read_range(source, "series.f16",
+                              int(published_offsets[i]), n * _F16_BYTES)
+            theirs = np.frombuffer(raw, dtype=np.float16, count=n)
+            normalized, _, _ = normalize_for_f16(kept[i])
+            ours = normalized.astype(np.float16, copy=False)
+            delta = ours.astype(np.float32) - theirs.astype(np.float32)
+            differing += int(np.count_nonzero(delta))
+            max_abs_diff = max(max_abs_diff, float(np.abs(delta).max()))
+            compared += n
+        report.update({
+            "rows_compared": n_rows,
+            "values_compared": compared,
+            "values_differing": differing,
+            "max_abs_diff": max_abs_diff,
+            "payload_checked": True,
+        })
+
+    if verbose:
+        print(f"shard {shard} at {path_or_url}")
+        print(f"  published rows: {published_rows:,} of {planned_rows:,} planned")
+        if report["scale_factors_compared"]:
+            print(f"  scale factors: {report['scale_factors_differing']} of "
+                  f"{report['scale_factors_compared']:,} differ")
+        if report["payload_checked"]:
+            print(f"  payload: {report['values_differing']} of "
+                  f"{report['values_compared']:,} float16 values differ "
+                  f"across {report['rows_compared']} rows "
+                  f"(max abs difference {report['max_abs_diff']:g})")
+        else:
+            print("  payload: not checked (n_rows=0)")
+        print(f"  the published fidelity statement was measured on "
+              f"{CANONICAL_RECIPE['verified_stack']}")
+    return report
+
+
+# ---------------------------------------------------------------------------
+# Command line
+# ---------------------------------------------------------------------------
+
+def main(argv: Optional[list] = None) -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="python -m tinycast.corpus",
+        description="Build or verify a shard of TinyCast's synthetic corpus.")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    build = sub.add_parser("build", help="generate a shard (needs a CUDA GPU)")
+    build.add_argument("--shard", type=int, default=0)
+    build.add_argument("--out", default=None,
+                       help=f"output directory (default {DEFAULT_OUT_DIR})")
+    build.add_argument("--max-series", type=int, default=None,
+                       help="stop after this many series; the prefix is unchanged")
+    build.add_argument("--overwrite", action="store_true")
+
+    verify = sub.add_parser("verify", help="compare a published shard to a rebuild")
+    verify.add_argument("source",
+                        help="shard directory, https prefix, or hf://<owner>/<repo>")
+    verify.add_argument("--shard", type=int, default=0)
+    verify.add_argument("--rows", type=int, default=DEFAULT_VERIFY_ROWS,
+                        help="rows to regenerate and compare; 0 skips the payload")
+    verify.add_argument("--scale-factors", type=int,
+                        default=DEFAULT_VERIFY_SCALE_FACTORS)
+
+    args = parser.parse_args(argv)
+    if args.command == "build":
+        build_shard(args.out, args.shard, max_series=args.max_series,
+                    overwrite=args.overwrite)
+    else:
+        verify_shard(args.source, args.shard, n_rows=args.rows,
+                     n_scale_factors=args.scale_factors)
+
+
+if __name__ == "__main__":
+    main()

tinycast/downsample.py

@@ -0,0 +1,148 @@
+"""Eval-time period-alignment downsampling rule.
+
+Some datasets carry their dominant seasonality at a clean integer multiple of
+the canonical (samples-per-day) period for their sampling frequency, with the
+canonical period itself absent. For example, bizitobs_l2c at 5T has no daily
+cycle at all, only weekly (2016 samples = 7x the canonical 288). Models calibrated
+around the canonical period grid systematically mis-handle such series;
+downsampling the context by the multiple aliases the dominant period back onto
+the grid (weekly-at-5T becomes daily-at-35T) and restores in-distribution
+behaviour. This module derives the factor from the CONTEXT data (a k=7 alias
+on bizitobs_l2c/5T medium+long), so no per-dataset hand-tuning and no
+information beyond the model's own inputs is used.
+
+Fire conditions (all required, and deliberately narrow: downsampling a config
+whose canonical peak is intact makes MASE strictly worse, m4_hourly's strong
+weekly harmonic included):
+  1. sub-daily frequency (canonical period >= MIN_CANONICAL samples/day);
+  2. a dominant spectral peak at period P with P/canonical within
+     ``REL_TOL`` of an integer k in [2, MAX_K];
+  3. the canonical-period peak is ABSENT: power near the canonical period is
+     below ``CANONICAL_ABSENT`` x the dominant peak's power;
+  4. the dominant peak is significant: >= ``PEAK_SIG`` x median spectral power;
+  5. a >= ``QUORUM`` fraction of sampled series agree on the same k;
+  6. the downsampled context still fills the model window
+     (median len / k >= ``context_window``, else the aliasing starves the
+     encoder: on bizitobs_l2c/H, where T/k ~ 358, k=7 turns from a win into a
+     loss at long horizons);
+  7. the horizon spans at least one canonical day (H >= canonical, else the
+     coarse forecast's interpolation loses more than the aliasing gains: on
+     bizitobs_l2c/5T/short, H=48 against a canonical 288, by +0.05 MASE).
+"""
+from __future__ import annotations
+
+from typing import Iterable, Optional
+
+import numpy as np
+
+MIN_CANONICAL = 8          # rule inactive for daily-or-coarser frequencies
+MAX_K = 16
+REL_TOL = 0.06             # |P/canonical - k| <= REL_TOL * k (after sub-bin refinement)
+CANONICAL_ABSENT = 0.10    # canonical peak power < 10% of dominant peak power
+PEAK_SIG = 20.0            # dominant peak >= 20x median spectral power
+QUORUM = 0.7
+MIN_CYCLES = 3             # dominant period must repeat >= 3x in the analysed tail
+TAIL = 16384               # analyse at most this many trailing samples
+N_SAMPLE = 64              # series sampled per config
+
+
+def _series_factor(x: np.ndarray, canonical: int) -> int:
+    x = np.asarray(x, dtype=np.float64)
+    x = x[np.isfinite(x)]
+    if x.size < MIN_CYCLES * 2 * canonical:
+        return 1
+    x = x[-TAIL:]
+    n = x.size
+    x = x - x.mean()
+    p = np.abs(np.fft.rfft(x)) ** 2
+    p[0] = 0.0
+    med = np.median(p[1:])
+    if med <= 0.0:
+        return 1
+
+    periods = np.full(p.shape, np.inf)
+    periods[1:] = n / np.arange(1, p.shape[0], dtype=np.float64)
+
+    # Power near the canonical period (max over a +-10% band).
+    canon_band = (periods >= 0.9 * canonical) & (periods <= 1.1 * canonical)
+    canon_pow = p[canon_band].max() if canon_band.any() else 0.0
+
+    # Dominant peak among periods that are >= 1.5x canonical and repeat
+    # >= MIN_CYCLES times in the analysed tail.
+    cand = (periods >= 1.5 * canonical) & (periods <= n / MIN_CYCLES)
+    if not cand.any():
+        return 1
+    idx = int(np.flatnonzero(cand)[np.argmax(p[cand])])
+    peak_pow = p[idx]
+    if peak_pow < PEAK_SIG * med:
+        return 1
+    if canon_pow > CANONICAL_ABSENT * peak_pow:
+        return 1                      # canonical period present: do not alias
+
+    # Sub-bin peak refinement (parabolic on log-power): the raw frequency
+    # grid is coarse at long periods (spacing ~P^2/n, i.e. ~12% of P for
+    # weekly-at-5T in a 16k tail), which would let non-integer multiples
+    # masquerade as clean ones under any workable tolerance.
+    delta = 0.0
+    if 1 <= idx < p.shape[0] - 1 and p[idx - 1] > 0 and p[idx + 1] > 0:
+        lp = np.log(p[idx - 1:idx + 2])
+        denom = lp[0] - 2.0 * lp[1] + lp[2]
+        if denom < 0:
+            delta = float(np.clip(0.5 * (lp[0] - lp[2]) / denom, -0.5, 0.5))
+    refined_period = n / (idx + delta)
+
+    r = refined_period / canonical
+    k = int(round(r))
+    if k < 2 or k > MAX_K or abs(r - k) > REL_TOL * k:
+        return 1
+    return k
+
+
+def period_alignment_factor(
+    contexts: Iterable[np.ndarray],
+    freq_seconds: float,
+    horizon: int,
+    context_window: int = 2048,
+    n_sample: int = N_SAMPLE,
+) -> int:
+    """Downsample factor for one eval config, from context windows only.
+
+    ``contexts`` are the test INPUT series (the model's own inputs);
+    ``freq_seconds`` is the sampling interval; ``horizon`` the prediction
+    length; ``context_window`` the model's encoder window. Returns 1 unless
+    the config's series agree (>= QUORUM) on the same aliasing multiple k >= 2
+    and the horizon/window guards pass.
+    """
+    canonical = int(round(86400.0 / float(freq_seconds)))
+    if canonical < MIN_CANONICAL:
+        return 1
+    if int(horizon) < canonical:           # guard 7: >= one canonical day
+        return 1
+    ks = []
+    lens = []
+    for x in contexts:
+        x = np.asarray(x, dtype=np.float64)
+        ks.append(_series_factor(x, canonical))
+        lens.append(x.size)
+        if len(ks) >= n_sample:
+            break
+    if not ks:
+        return 1
+    vals, counts = np.unique(ks, return_counts=True)
+    best = int(vals[np.argmax(counts)])
+    if best == 1 or counts.max() / len(ks) < QUORUM:
+        return 1
+    if float(np.median(lens)) / best < context_window:   # guard 6
+        return 1
+    return best
+
+
+def freq_to_seconds(freq: str) -> Optional[float]:
+    """Sampling interval in seconds for a pandas-style freq string, or None."""
+    import pandas as pd
+
+    try:
+        off = pd.tseries.frequencies.to_offset(freq)
+        return pd.Timedelta(off).total_seconds()
+    except (ValueError, TypeError):
+        return None

tinycast/encoding.py

@@ -0,0 +1,123 @@
+"""Shared structural positional-encoding helpers (phase + bounded recency).
+
+A normalized-periodogram detector supplies top-K periods per sample. Those
+periods drive a structural positional encoding (sin/cos of phase) shared
+between context tokens and decoder horizon queries, plus a bounded
+recency/trend basis. Also holds the fp32 RMSNorm helper.
+"""
+
+from __future__ import annotations
+
+import math
+
+import torch
+import torch.nn as nn
+
+
+def _phase_encoding(
+    positions: torch.Tensor, periods: torch.Tensor,
+    n_harmonics: int = 1,
+) -> torch.Tensor:
+    """Compute sin/cos phase encoding for each position under each period.
+
+    For each detected period ``p_k``, emit Fourier-series channels up to
+    ``n_harmonics``: at harmonic m, the channels are sin(2π·m·t/p_k) and
+    cos(2π·m·t/p_k). The fundamental (m=1) is the base behavior; m=2,3,...
+    let the model represent non-sinusoidal periodic shapes (square-wave
+    traffic, sawtooth load) that the fundamental alone cannot.
+
+    Output channel ordering, per (period, harmonic):
+        [sin(1·φ_1), cos(1·φ_1), ..., sin(H·φ_1), cos(H·φ_1),
+         sin(1·φ_2), cos(1·φ_2), ..., sin(H·φ_K), cos(H·φ_K)]
+
+    Args:
+        positions:   (B, T) int tensor of absolute positions.
+        periods:     (B, K) int tensor of per-sample detected periods. Zero
+                     means "rejected by significance test" → all harmonics
+                     of that period come back zeroed.
+        n_harmonics: number of Fourier harmonics per period (default 1).
+    Returns:
+        (B, T, 2·K·n_harmonics) fp32 tensor.
+    """
+    B, T = positions.shape
+    K = periods.shape[1]
+    H = int(n_harmonics)
+    if H < 1:
+        raise ValueError(f"n_harmonics must be >= 1; got {H}")
+    valid = (periods > 0).view(B, 1, K).float()                   # (B,1,K)
+    p_safe = periods.clamp(min=1).view(B, 1, K).float()
+    pos = positions.view(B, T, 1).float()
+    phase_base = 2.0 * math.pi * pos / p_safe                     # (B,T,K)
+    # Build (B,T,K,H,2): for each (period k, harmonic m), [sin(m·φ_k), cos(m·φ_k)]
+    multipliers = torch.arange(1, H + 1, device=positions.device, dtype=phase_base.dtype)
+    phase_m = phase_base.unsqueeze(-1) * multipliers              # (B,T,K,H)
+    sin_m = torch.sin(phase_m) * valid.unsqueeze(-1)              # (B,T,K,H)
+    cos_m = torch.cos(phase_m) * valid.unsqueeze(-1)
+    pair = torch.stack([sin_m, cos_m], dim=-1)                    # (B,T,K,H,2)
+    return pair.reshape(B, T, K * H * 2)
+
+
+# Number of recency/trend channels added by the bounded-basis extension.
+N_RECENCY_CHANNELS = 5
+
+
+def _recency_encoding(
+    positions: torch.Tensor, L: int,
+) -> torch.Tensor:
+    """Bounded recency/trend channels for the shared positional encoding.
+
+    "Now" is anchored at position ``L-1`` (end of context). ``Δ = (t - (L-1)) / L``
+    is signed: negative for past, zero at "now", positive for future. All
+    channels are bounded so they're safe to evaluate at arbitrary future
+    horizons (the parameterized-query path goes well beyond training H).
+
+    Channels (5):
+        rec_lin:  Δ                            (signed linear distance from now)
+        rec_log:  sign(Δ) · log1p(|Δ|)/log(2)  (signed log-compressed distance)
+        rec_e05:  exp(-0.5 · |Δ|)              (long-memory decay)
+        rec_e2:   exp(-2.0 · |Δ|)              (medium-memory decay)
+        rec_e8:   exp(-8.0 · |Δ|)              (short-memory / locality kernel)
+    """
+    B, T = positions.shape
+    delta = (positions.float() - float(L - 1)) / float(L)         # (B, T)
+    abs_d = delta.abs()
+    rec_lin = delta
+    rec_log = torch.sign(delta) * torch.log1p(abs_d) / math.log(2.0)
+    rec_e05 = torch.exp(-0.5 * abs_d)
+    rec_e2 = torch.exp(-2.0 * abs_d)
+    rec_e8 = torch.exp(-8.0 * abs_d)
+    return torch.stack([rec_lin, rec_log, rec_e05, rec_e2, rec_e8], dim=-1)
+
+
+def _positional_encoding(
+    positions: torch.Tensor, periods: torch.Tensor, L: int,
+    n_harmonics: int = 1,
+) -> torch.Tensor:
+    """Full shared positional encoding (phase + bounded recency basis).
+
+    Returns (B, T, 2·K·n_harmonics + 5).
+    """
+    return torch.cat(
+        [
+            _phase_encoding(positions, periods, n_harmonics=n_harmonics),
+            _recency_encoding(positions, L),
+        ],
+        dim=-1,
+    )
+
+
+def _norm_fp32(norm: nn.Module, x: torch.Tensor) -> torch.Tensor:
+    """Apply RMSNorm in fp32 and cast the result back to the input's dtype.
+
+    Under bf16-mixed AMP, RMSNorm receives bf16 input but holds fp32 weights.
+    PyTorch's fused RMSNorm kernel falls back to a slow non-fused path on
+    dtype mismatch. Explicit fp32 promotion matches the weight dtype and lets
+    the fused kernel engage. This matters most under compile, where the unfused
+    dispatch breaks the graph and prevents downstream fusions.
+    """
+    if x.dtype == torch.float32:
+        return norm(x)
+    with torch.amp.autocast(
+        device_type=x.device.type if x.is_cuda else "cpu", enabled=False,
+    ):
+        return norm(x.float()).to(x.dtype)

tinycast/eval.py

@@ -0,0 +1,540 @@
+"""TinyCast GIFT-Eval driver.
+
+Runs the deployed TinyCast predictor against the GIFT-Eval benchmark and writes
+a results CSV in the leaderboard column order (98 lines incl. header, 15
+columns), plus a per-frequency-bin summary sidecar carrying the three
+normalized aggregates (nGMASE, nCRPS, nMSIS).
+
+``summarize_by_freq_bin`` also runs standalone on any leaderboard-format CSV, so
+the published aggregates can be re-derived offline from the pinned per-config
+results in ``reference/gift_eval_tinycast.csv`` without a GPU or benchmark data.
+Called that way it only returns and prints the summary; pass
+``write_sidecar=True`` to also write it beside the CSV.
+
+Usage:
+    python -m tinycast.eval --ckpt model.safetensors --flip \\
+        --output all_results.csv                       # full 97 configs
+    python -m tinycast.eval --ckpt model.safetensors --flip \\
+        --configs "m4_hourly/H/short" --output smoke.csv
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import math
+import os
+from pathlib import Path
+from typing import Iterable, List, Optional, Sequence
+
+import numpy as np
+
+MODEL_NAME_DEFAULT = "TinyCast"
+
+# ---------------------------------------------------------------------------
+# Dataset constants: the GIFT-Eval protocol's dataset / term layout.
+# ---------------------------------------------------------------------------
+PRETTY_NAMES = {
+    "saugeenday": "saugeen",
+    "temperature_rain_with_missing": "temperature_rain",
+    "kdd_cup_2018_with_missing": "kdd_cup_2018",
+    "car_parts_with_missing": "car_parts",
+}
+
+SHORT_DATASETS = (
+    "m4_yearly m4_quarterly m4_monthly m4_weekly m4_daily m4_hourly "
+    "electricity/15T electricity/H electricity/D electricity/W "
+    "solar/10T solar/H solar/D solar/W "
+    "hospital covid_deaths "
+    "us_births/D us_births/M us_births/W "
+    "saugeenday/D saugeenday/M saugeenday/W "
+    "temperature_rain_with_missing "
+    "kdd_cup_2018_with_missing/H kdd_cup_2018_with_missing/D "
+    "car_parts_with_missing restaurant "
+    "hierarchical_sales/D hierarchical_sales/W "
+    "LOOP_SEATTLE/5T LOOP_SEATTLE/H LOOP_SEATTLE/D "
+    "SZ_TAXI/15T SZ_TAXI/H "
+    "M_DENSE/H M_DENSE/D "
+    "ett1/15T ett1/H ett1/D ett1/W ett2/W ett2/D "
+    "jena_weather/10T jena_weather/H jena_weather/D "
+    "bitbrains_fast_storage/5T bitbrains_fast_storage/H "
+    "bitbrains_rnd/5T bitbrains_rnd/H "
+    "bizitobs_application bizitobs_service "
+    "bizitobs_l2c/5T bizitobs_l2c/H"
+)
+
+MED_LONG_DATASETS = (
+    "electricity/15T electricity/H "
+    "solar/10T solar/H "
+    "kdd_cup_2018_with_missing/H "
+    "LOOP_SEATTLE/5T LOOP_SEATTLE/H "
+    "SZ_TAXI/15T M_DENSE/H "
+    "ett1/15T ett1/H ett2/15T ett2/H "
+    "jena_weather/10T jena_weather/H "
+    "bitbrains_fast_storage/5T bitbrains_rnd/5T "
+    "bizitobs_application bizitobs_service "
+    "bizitobs_l2c/5T bizitobs_l2c/H"
+)
+
+# Leaderboard CSV column order (byte-identical for leaderboard submission).
+LEADERBOARD_COLUMNS = (
+    "dataset", "model",
+    "eval_metrics/MSE[mean]", "eval_metrics/MSE[0.5]",
+    "eval_metrics/MAE[0.5]", "eval_metrics/MASE[0.5]",
+    "eval_metrics/MAPE[0.5]", "eval_metrics/sMAPE[0.5]",
+    "eval_metrics/MSIS", "eval_metrics/RMSE[mean]",
+    "eval_metrics/NRMSE[mean]", "eval_metrics/ND[0.5]",
+    "eval_metrics/mean_weighted_sum_quantile_loss",
+    "domain", "num_variates",
+)
+
+REFERENCE_DIR = Path(__file__).parent / "reference"
+
+
+def _build_metrics():
+    from gluonts.ev.metrics import (
+        MAE, MAPE, MASE, MSE, MSIS, ND, NRMSE, RMSE, SMAPE,
+        MeanWeightedSumQuantileLoss,
+    )
+    return [
+        MSE(forecast_type="mean"),
+        MSE(forecast_type=0.5),
+        MAE(),
+        MASE(),
+        MAPE(),
+        SMAPE(),
+        MSIS(),
+        RMSE(),
+        NRMSE(),
+        ND(),
+        MeanWeightedSumQuantileLoss(
+            quantile_levels=[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
+        ),
+    ]
+
+
+def _load_dataset_properties() -> dict:
+    with open(REFERENCE_DIR / "dataset_properties.json") as f:
+        return json.load(f)
+
+
+def iter_configs(
+    configs_filter: Optional[Sequence[str]] = None,
+    term_filter: Optional[str] = None,
+) -> Iterable[tuple]:
+    """Yield ``(ds_name, term, ds_config_key, ds_key, ds_freq)`` per (dataset, term).
+
+    ``configs_filter`` matches by full ``ds_config_key`` (e.g.
+    ``ett1/15T/long``); if ``None`` (default), all 97 configs are yielded.
+    """
+    dataset_properties = _load_dataset_properties()
+    all_datasets = sorted(set(SHORT_DATASETS.split() + MED_LONG_DATASETS.split()))
+    med_long_set = set(MED_LONG_DATASETS.split())
+    all_terms = ["short", "medium", "long"] if term_filter is None else [term_filter]
+    wanted = set(configs_filter) if configs_filter is not None else None
+
+    for ds_name in all_datasets:
+        if "/" in ds_name:
+            ds_key = PRETTY_NAMES.get(ds_name.split("/")[0].lower(), ds_name.split("/")[0].lower())
+            ds_freq = ds_name.split("/")[1]
+        else:
+            ds_key = PRETTY_NAMES.get(ds_name.lower(), ds_name.lower())
+            ds_freq = dataset_properties[ds_key]["frequency"]
+
+        for term in all_terms:
+            if term in ("medium", "long") and ds_name not in med_long_set:
+                continue
+            ds_config_key = f"{ds_key}/{ds_freq}/{term}"
+            if wanted is not None and ds_config_key not in wanted:
+                continue
+            yield ds_name, term, ds_config_key, ds_key, ds_freq
+
+
+def evaluate(
+    ckpt_path: str,
+    output_csv: os.PathLike,
+    *,
+    model_name: str = MODEL_NAME_DEFAULT,
+    configs_filter: Optional[Sequence[str]] = None,
+    term_filter: Optional[str] = None,
+    force_flip_invariance: bool = True,
+    device: Optional[str] = None,
+    use_amp: int = 1,
+    period_align: bool = True,
+    batch_size: int = 64,
+    predictor_batch_size: Optional[int] = None,
+    strict_summary: bool = True,
+) -> dict:
+    """Run GIFT-Eval for TinyCast; stream rows to ``output_csv``.
+
+    ``device`` defaults to ``None``, which is the predictor's request to choose:
+    CUDA when it is present, CPU otherwise. Naming a device instead makes it a
+    requirement, and an absent one raises rather than being substituted.
+
+    Returns the ``summarize_by_freq_bin`` summary for the run it just wrote, so
+    a caller can assert on the aggregates without re-reading the CSV. The row
+    CSV is complete on disk before the summary runs, so a ``strict_summary``
+    failure costs no evaluation work: fix the reference and re-summarize.
+    """
+    from gluonts.model import evaluate_model
+    from gluonts.time_feature import get_seasonality
+    from gift_eval.data import Dataset
+
+    from .predictor import TinyCastPredictor
+
+    metrics = _build_metrics()
+    dataset_properties = _load_dataset_properties()
+
+    output_csv = Path(output_csv)
+    output_csv.parent.mkdir(parents=True, exist_ok=True)
+    with open(output_csv, "w", newline="") as f:
+        csv.writer(f).writerow(LEADERBOARD_COLUMNS)
+
+    configs = list(iter_configs(configs_filter, term_filter))
+    print(f"Evaluating {model_name} on {len(configs)} configs.")
+    print(f"Output: {output_csv}")
+
+    for i, (ds_name, term, ds_config, ds_key, ds_freq) in enumerate(configs):
+        print(f"[{i + 1}/{len(configs)}] {ds_config}", flush=True)
+
+        probe = Dataset(name=ds_name, term=term, to_univariate=False)
+        to_uni = probe.target_dim != 1
+        dataset = Dataset(name=ds_name, term=term, to_univariate=to_uni)
+        season_length = get_seasonality(dataset.freq)
+
+        per_cfg_kwargs = dict(
+            device=device,
+            force_flip_invariance=bool(force_flip_invariance),
+            use_amp=use_amp,
+        )
+        if predictor_batch_size is not None:
+            per_cfg_kwargs["batch_size"] = predictor_batch_size
+        # bizitobs_l2c has no daily cycle, so scale_factor /= 7.
+        if "l2c" in ds_name.lower():
+            per_cfg_kwargs["no_daily"] = True
+        # Period-alignment downsampling: derive the aliasing factor from the
+        # test INPUT contexts only (fires k=7 on bizitobs_l2c/5T med+long).
+        if period_align:
+            from .downsample import freq_to_seconds, period_alignment_factor
+            fs = freq_to_seconds(ds_freq)
+            if fs is not None:
+                k_align = period_alignment_factor(
+                    (np.asarray(e["target"], dtype=np.float64)
+                     for e in dataset.test_data.input),
+                    fs,
+                    horizon=dataset.prediction_length,
+                )
+                if k_align > 1:
+                    per_cfg_kwargs["downsample_factor"] = k_align
+                    print(f"  period-align: downsample_factor={k_align}", flush=True)
+
+        predictor = TinyCastPredictor(
+            prediction_length=dataset.prediction_length,
+            checkpoint_path=ckpt_path,
+            freq=ds_freq,
+            domain=dataset_properties[ds_key]["domain"],
+            **per_cfg_kwargs,
+        )
+
+        res = evaluate_model(
+            predictor,
+            test_data=dataset.test_data,
+            metrics=metrics,
+            batch_size=batch_size,
+            axis=None,
+            mask_invalid_label=True,
+            allow_nan_forecast=False,
+            seasonality=season_length,
+        )
+
+        with open(output_csv, "a", newline="") as f:
+            csv.writer(f).writerow([
+                ds_config, model_name,
+                res["MSE[mean]"].iloc[0], res["MSE[0.5]"].iloc[0],
+                res["MAE[0.5]"].iloc[0], res["MASE[0.5]"].iloc[0],
+                res["MAPE[0.5]"].iloc[0], res["sMAPE[0.5]"].iloc[0],
+                res["MSIS"].iloc[0], res["RMSE[mean]"].iloc[0],
+                res["NRMSE[mean]"].iloc[0], res["ND[0.5]"].iloc[0],
+                res["mean_weighted_sum_quantile_loss"].iloc[0],
+                dataset_properties[ds_key]["domain"],
+                dataset_properties[ds_key]["num_variates"],
+            ])
+
+        import gc
+        del predictor, res, dataset, probe
+        gc.collect()
+
+    print(f"Done. Results: {output_csv}")
+    # A partial run (--configs / --term) covers a subset of the 97 leaderboard
+    # configurations, but every configuration it does cover must be scored, so
+    # the strict reference check stays on.
+    return summarize_by_freq_bin(
+        output_csv, strict=strict_summary, write_sidecar=True,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Per-frequency-bin normalized summary (sidecar to the leaderboard CSV)
+# ---------------------------------------------------------------------------
+_FREQ_BIN_ORDER = ("sub_hourly", "hourly", "daily_or_coarser")
+
+# The three reported GIFT-Eval aggregates, each the geometric mean of the
+# per-configuration ratio of the column below to the same column of the
+# seasonal-naive reference. One construction, three columns.
+_NORMALIZED_METRICS = (
+    ("ngmase", "eval_metrics/MASE[0.5]"),
+    ("ncrps", "eval_metrics/mean_weighted_sum_quantile_loss"),
+    ("nmsis", "eval_metrics/MSIS"),
+)
+
+# The GIFT-Eval leaderboard calls the quantile-loss aggregate nWQL; the paper
+# calls it nCRPS. Same column, so the summary carries both spellings.
+_METRIC_ALIASES = (("nwql", "ncrps"),)
+
+
+def _freq_bin(freq: str) -> str:
+    f = freq.strip().upper()
+    if f == "H":
+        return "hourly"
+    if f.endswith("S") or f.endswith("T") or f == "MIN":
+        return "sub_hourly"
+    return "daily_or_coarser"
+
+
+def _positive_float(value) -> Optional[float]:
+    """Parse ``value``, returning ``None`` unless it is finite and positive.
+
+    Every aggregate here is a geometric mean, so a zero, a negative or a NaN is
+    not a small contribution: it is undefined.
+    """
+    try:
+        out = float(value)
+    except (ValueError, TypeError):
+        return None
+    return out if math.isfinite(out) and out > 0 else None
+
+
+def _read_reference_metrics(reference_csv: os.PathLike) -> dict:
+    """Map ``dataset`` to its seasonal-naive denominator per normalized metric."""
+    out: dict = {}
+    with open(reference_csv, newline="") as f:
+        for row in csv.DictReader(f):
+            ds = row.get("dataset")
+            if not ds:
+                continue
+            denominators = {}
+            for _, column in _NORMALIZED_METRICS:
+                den = _positive_float(row.get(column))
+                if den is not None:
+                    denominators[column] = den
+            out[ds] = denominators
+    return out
+
+
+def _geometric_mean(values: Sequence[float]) -> Optional[float]:
+    if not values:
+        return None
+    return math.exp(sum(math.log(v) for v in values) / len(values))
+
+
+def summarize_by_freq_bin(
+    output_csv: os.PathLike,
+    *,
+    seasonal_naive_csv: "os.PathLike | None" = None,
+    strict: bool = True,
+    write_sidecar: bool = False,
+) -> dict:
+    """Read ``output_csv``, print the per-frequency-bin summary and return it.
+
+    Three aggregates are reported, all built the same way: the geometric mean
+    over configurations of the ratio between a column and the same column of the
+    seasonal-naive reference. ``ngmase`` normalizes MASE (point accuracy),
+    ``ncrps`` normalizes the mean weighted sum quantile loss (probabilistic
+    accuracy, the leaderboard's CRPS column, carried under both keys),
+    and ``nmsis`` normalizes MSIS (interval score).
+
+    ``write_sidecar`` (default off) additionally writes the returned summary to
+    ``<stem>.bins.json`` beside ``output_csv``. It is off by default because the
+    common call re-derives the published aggregates from the pinned results
+    inside the installed package, where the sidecar path lands in
+    ``site-packages``: reading a file must not write one. ``evaluate`` turns it
+    on, since there the CSV is the caller's own output path.
+
+    ``strict`` (default on) raises when any configuration in ``output_csv`` is
+    left out of an aggregate, whether because its dataset key is unparseable,
+    because the reference file does not cover it, or because a value is missing
+    or non-positive. A geometric mean says nothing about how many terms it has,
+    so a reference file that has drifted away from the run would otherwise
+    quietly shrink the sample and return a number that looks publishable. The
+    dropped configurations are recorded under ``summary["dropped"]`` either way,
+    so a caller running with ``strict=False`` can still assert on the count.
+    """
+    output_csv = Path(output_csv)
+    if seasonal_naive_csv is None:
+        seasonal_naive_csv = REFERENCE_DIR / "seasonal_naive.csv"
+    seasonal_naive_csv = Path(seasonal_naive_csv)
+    reference = (
+        _read_reference_metrics(seasonal_naive_csv)
+        if seasonal_naive_csv.exists()
+        else {}
+    )
+
+    mase_per_bin = {b: [] for b in _FREQ_BIN_ORDER}
+    ratios = {key: {b: [] for b in _FREQ_BIN_ORDER}
+              for key, _ in _NORMALIZED_METRICS}
+    rows_per_bin = {b: 0 for b in _FREQ_BIN_ORDER}
+    dropped_reasons: dict = {}
+    n_rows = 0
+
+    def drop(dataset: str, reason: str) -> None:
+        dropped_reasons.setdefault(reason, []).append(dataset)
+
+    with open(output_csv, newline="") as f:
+        for row in csv.DictReader(f):
+            n_rows += 1
+            ds = row.get("dataset") or ""
+            parts = ds.split("/")
+            if len(parts) < 3:
+                drop(ds, "unparseable_dataset_key")
+                continue
+            bin_name = _freq_bin(parts[1])
+            rows_per_bin[bin_name] += 1
+
+            mase = _positive_float(row.get("eval_metrics/MASE[0.5]"))
+            if mase is not None:
+                mase_per_bin[bin_name].append(mase)
+
+            denominators = reference.get(ds)
+            if denominators is None:
+                drop(ds, "no_seasonal_naive_reference")
+                continue
+            for key, column in _NORMALIZED_METRICS:
+                numerator = _positive_float(row.get(column))
+                if numerator is None:
+                    drop(ds, f"no_value_{key}")
+                elif column not in denominators:
+                    drop(ds, f"no_reference_value_{key}")
+                else:
+                    ratios[key][bin_name].append(numerator / denominators[column])
+
+    summary: dict = {}
+    for bin_name in list(_FREQ_BIN_ORDER) + ["overall"]:
+        bins = _FREQ_BIN_ORDER if bin_name == "overall" else (bin_name,)
+        mase_vals = [v for b in bins for v in mase_per_bin[b]]
+        entry = {
+            "n": sum(rows_per_bin[b] for b in bins),
+            "gmean_mase": _geometric_mean(mase_vals),
+        }
+        for key, _ in _NORMALIZED_METRICS:
+            vals = [v for b in bins for v in ratios[key][b]]
+            entry[key] = _geometric_mean(vals)
+            entry[f"n_{key}"] = len(vals)
+        for alias, key in _METRIC_ALIASES:
+            entry[alias] = entry[key]
+            entry[f"n_{alias}"] = entry[f"n_{key}"]
+        summary[bin_name] = entry
+
+    n_dropped = sum(len(v) for v in dropped_reasons.values())
+    summary["dropped"] = {
+        "n_rows": n_rows,
+        "n_dropped": n_dropped,
+        "by_reason": {k: sorted(set(v)) for k, v in sorted(dropped_reasons.items())},
+    }
+    summary["reference"] = str(seasonal_naive_csv)
+
+    if write_sidecar:
+        sidecar = output_csv.with_suffix(".bins.json")
+        sidecar.write_text(json.dumps(summary, indent=2))
+
+    def fmt(value) -> str:
+        return f"{value:.4f}" if value is not None else "n/a"
+
+    header = "Per-frequency-bin GIFT-Eval aggregates"
+    if write_sidecar:
+        header += f"  (sidecar: {sidecar.name})"
+    print(header)
+    print(f"  {'bin':<18} {'n':>3}  {'nGMASE':>8} {'nCRPS':>8} {'nMSIS':>8}"
+          f" {'gmean MASE':>11}")
+    for bin_name in list(_FREQ_BIN_ORDER) + ["overall"]:
+        s = summary[bin_name]
+        print(f"  {bin_name:<18} {s['n']:>3}  {fmt(s['ngmase']):>8}"
+              f" {fmt(s['ncrps']):>8} {fmt(s['nmsis']):>8}"
+              f" {fmt(s['gmean_mase']):>11}")
+
+    if n_dropped:
+        detail = ", ".join(f"{reason}: {len(set(datasets))}"
+                           for reason, datasets in sorted(dropped_reasons.items()))
+        message = (
+            f"{n_dropped} of {n_rows} configurations in {output_csv} were left "
+            f"out of an aggregate ({detail}). The reference "
+            f"{seasonal_naive_csv} does not match this run, so the aggregates "
+            f"above are geometric means over an incomplete sample."
+        )
+        if strict:
+            raise ValueError(message)
+        print(f"  WARNING: {message}")
+
+    return summary
+
+
+def _parse_configs_arg(value: Optional[str]) -> Optional[List[str]]:
+    if value is None:
+        return None
+    return [c.strip() for c in value.split(",") if c.strip()]
+
+
+def main(argv: Optional[Sequence[str]] = None) -> None:
+    parser = argparse.ArgumentParser(
+        description="Run GIFT-Eval against the deployed TinyCast model."
+    )
+    parser.add_argument("--ckpt", required=True,
+                        help="Path to model.safetensors (config.json sibling).")
+    parser.add_argument("--configs", default=None,
+                        help="Comma-separated ds_config_keys (e.g. "
+                             "'ett1/15T/long,m4_hourly/H/short'). Default: all 97.")
+    parser.add_argument("--term", default=None, choices=["short", "medium", "long"])
+    parser.add_argument("--flip", dest="force_flip_invariance",
+                        action="store_true", default=True,
+                        help="Flip-invariance symmetrization (deployed default ON).")
+    parser.add_argument("--no-flip", dest="force_flip_invariance",
+                        action="store_false")
+    parser.add_argument("--no-period-align", action="store_true",
+                        help="Disable period-alignment downsampling (default ON).")
+    parser.add_argument("--dtype", default="bf16", choices=["bf16", "fp32-strict"],
+                        help="bf16 autocast at compute (CUDA only) or strict fp32.")
+    parser.add_argument("--device", default=None,
+                        help="cuda | cpu. Default: whichever is present "
+                             "(CUDA when available, else CPU). Naming one "
+                             "makes it a requirement: an absent device is an "
+                             "error, never a silent substitution.")
+    parser.add_argument("--batch-size", type=int, default=64,
+                        help="gluonts.evaluate_model aggregation batch size.")
+    parser.add_argument("--predictor-batch-size", type=int, default=None,
+                        help="Internal predictor batch size (default 256).")
+    parser.add_argument("--model-name", default=MODEL_NAME_DEFAULT,
+                        help="Value written to the 'model' CSV column.")
+    parser.add_argument("--output", default="all_results.csv",
+                        help="Output CSV path (leaderboard format).")
+    parser.add_argument("--no-strict-summary", action="store_true",
+                        help="Warn instead of failing when the seasonal-naive "
+                             "reference does not cover every evaluated config.")
+    args = parser.parse_args(argv)
+
+    evaluate(
+        ckpt_path=args.ckpt,
+        output_csv=args.output,
+        model_name=args.model_name,
+        configs_filter=_parse_configs_arg(args.configs),
+        term_filter=args.term,
+        force_flip_invariance=bool(args.force_flip_invariance),
+        device=args.device,
+        use_amp=0 if args.dtype == "fp32-strict" else 1,
+        period_align=not args.no_period_align,
+        batch_size=args.batch_size,
+        predictor_batch_size=args.predictor_batch_size,
+        strict_summary=not args.no_strict_summary,
+    )
+
+
+if __name__ == "__main__":
+    main()

tinycast/export.py

@@ -0,0 +1,517 @@
+"""Training checkpoint to released artifact.
+
+The released model is a ``model.safetensors`` + ``config.json`` pair; this module
+is the bridge that produces it from whatever a training run left on disk.
+
+Two things make that bridge non-trivial:
+
+* **Weight tying.** Both FFN stacks are shared, so a naive ``state_dict()`` has 177
+  entries summing to 321,225 values while the model has only 121 distinct
+  parameter tensors holding 146,505 values. The export writes each storage once and
+  records the aliases in the safetensors metadata, which is what
+  :func:`tinycast.checkpoint.load_checkpoint` reads back. A parameter count is only
+  meaningful when taken from a model instantiated from its config; never sum a
+  checkpoint's tensors.
+* **Checkpoint averaging.** The released weights are the uniform mean of the last
+  eight periodic checkpoints of the training run, so exporting the final checkpoint
+  alone does not reproduce them. :func:`average_checkpoints` is that mean.
+
+Loading is deliberately restricted: torch-serialized files are read with
+``weights_only=True`` and safetensors files with the safetensors reader, so no path
+handed to this module can execute code.
+
+Usage:
+    # the last eight periodic checkpoints, in training order
+    python -m tinycast.export --out-dir release/ --average CKPT [CKPT ...]
+
+    >>> from tinycast.export import export_safetensors, check_export_roundtrip
+    >>> export_safetensors(model, "release/")
+    >>> check_export_roundtrip(model, expect_parameters=146_505)
+"""
+from __future__ import annotations
+
+import json
+import math
+import tempfile
+from contextlib import nullcontext
+from pathlib import Path
+from typing import Dict, Iterable, List, Mapping, Optional, Sequence, Tuple, Union
+
+import torch
+import torch.nn as nn
+
+from .config import TinyCastConfig
+from .model import TinyCastForPrediction
+
+WEIGHTS_NAME = "model.safetensors"
+CONFIG_NAME = "config.json"
+
+#: Number of periodic checkpoints averaged to produce the released weights.
+RELEASE_AVERAGE_N = 8
+
+#: Keys a training checkpoint may nest its tensors under, most specific first.
+_STATE_DICT_KEYS = ("state_dict", "model_state_dict", "model", "weights")
+
+StateDict = Dict[str, torch.Tensor]
+
+
+class ExportError(RuntimeError):
+    """A checkpoint could not be read, averaged, or exported faithfully."""
+
+
+# ---------------------------------------------------------------------------
+# Safe loading
+# ---------------------------------------------------------------------------
+def load_state_dict_safely(path: Union[str, Path]) -> StateDict:
+    """Read a state dict from ``path`` without ever executing code from it.
+
+    ``.safetensors`` goes through the safetensors reader; everything else through
+    ``torch.load(..., weights_only=True)``. A training checkpoint that nests its
+    tensors under ``state_dict`` (or ``model_state_dict`` / ``model`` / ``weights``)
+    is unwrapped; the optimizer state, schedulers and step counters around it are
+    discarded, since none of them survive into the released artifact.
+    """
+    p = Path(path)
+    if not p.is_file():
+        raise ExportError(f"no such checkpoint: {p}")
+
+    if p.suffix == ".safetensors":
+        from safetensors.torch import load_file
+
+        return dict(load_file(str(p), device="cpu"))
+
+    obj = torch.load(str(p), map_location="cpu", weights_only=True)
+    return _unwrap_state_dict(obj, p)
+
+
+def _unwrap_state_dict(obj: object, origin: Path) -> StateDict:
+    if not isinstance(obj, Mapping):
+        raise ExportError(
+            f"{origin}: expected a state dict or a checkpoint mapping, got "
+            f"{type(obj).__name__}"
+        )
+    if _is_tensor_mapping(obj):
+        return dict(obj)
+    for key in _STATE_DICT_KEYS:
+        inner = obj.get(key)
+        if isinstance(inner, Mapping) and _is_tensor_mapping(inner):
+            return dict(inner)
+    raise ExportError(
+        f"{origin}: no tensor mapping found at the top level or under any of "
+        f"{_STATE_DICT_KEYS}"
+    )
+
+
+def _is_tensor_mapping(obj: Mapping) -> bool:
+    return bool(obj) and all(
+        isinstance(k, str) and isinstance(v, torch.Tensor) for k, v in obj.items()
+    )
+
+
+# ---------------------------------------------------------------------------
+# Checkpoint averaging
+# ---------------------------------------------------------------------------
+def average_checkpoints(paths: Sequence[Union[str, Path]]) -> StateDict:
+    """Uniform mean of several checkpoints, returned as a state dict.
+
+    This is how the released weights were made: the last
+    :data:`RELEASE_AVERAGE_N` periodic checkpoints of the training run, averaged
+    with equal weight. Floating-point tensors are accumulated in float32 in the
+    order given and cast back to the source dtype; integer and boolean entries (step
+    counters and the like) are taken from the last checkpoint in ``paths``, since a
+    mean of those is meaningless. Pass the checkpoints in training order so "last"
+    is the most recent one, and keep that order to reproduce the released weights
+    exactly: an eight-term float32 sum is not associative, so reordering ``paths``
+    moves the result by about one ulp.
+
+    All checkpoints must carry the same keys with the same shapes; a mismatch is an
+    error rather than a silent intersection, because a quietly dropped tensor would
+    export as a randomly initialized one.
+    """
+    paths = [Path(p) for p in paths]
+    if not paths:
+        raise ExportError("average_checkpoints needs at least one checkpoint")
+
+    states = [load_state_dict_safely(p) for p in paths]
+    reference = states[0]
+    for path, state in zip(paths[1:], states[1:]):
+        _assert_same_keys(reference, state, paths[0], path)
+
+    n = len(states)
+    averaged: StateDict = {}
+    for key, ref in reference.items():
+        tensors = [state[key] for state in states]
+        if ref.is_floating_point():
+            acc = tensors[0].to(torch.float32).clone()
+            for t in tensors[1:]:
+                acc += t.to(torch.float32)
+            averaged[key] = (acc / n).to(ref.dtype)
+        else:
+            averaged[key] = tensors[-1].clone()
+    return averaged
+
+
+def _assert_same_keys(a: StateDict, b: StateDict, path_a: Path, path_b: Path) -> None:
+    if a.keys() != b.keys():
+        only_a = sorted(set(a) - set(b))[:5]
+        only_b = sorted(set(b) - set(a))[:5]
+        raise ExportError(
+            f"checkpoint key mismatch between {path_a.name} and {path_b.name}: "
+            f"only in the first {only_a}, only in the second {only_b}"
+        )
+    for key in a:
+        if a[key].shape != b[key].shape:
+            raise ExportError(
+                f"shape mismatch for {key!r}: {tuple(a[key].shape)} in "
+                f"{path_a.name} vs {tuple(b[key].shape)} in {path_b.name}"
+            )
+
+
+# ---------------------------------------------------------------------------
+# Weight tying
+# ---------------------------------------------------------------------------
+def tied_parameter_groups(model: nn.Module) -> Dict[str, List[str]]:
+    """Map each shared parameter's canonical name to the names aliasing it.
+
+    Two names alias when they resolve to the same ``nn.Parameter`` object, which is
+    what ``share_ffn`` produces. The canonical name is the one ``named_parameters``
+    keeps, i.e. the first in registration order; only that one is written to the
+    safetensors file.
+    """
+    canonical = {id(p): name for name, p in model.named_parameters()}
+    groups: Dict[str, List[str]] = {name: [] for name in canonical.values()}
+    for name, param in model.named_parameters(remove_duplicate=False):
+        head = canonical[id(param)]
+        if name != head:
+            groups[head].append(name)
+    return {head: alias for head, alias in groups.items() if alias}
+
+
+def _assert_tied_values_agree(model: nn.Module, state: Mapping[str, torch.Tensor]) -> None:
+    """Refuse a state dict whose tied entries disagree.
+
+    Loading such a dict would keep whichever copy happened to be written last and
+    discard the others without a word.
+    """
+    for head, aliases in tied_parameter_groups(model).items():
+        if head not in state:
+            continue
+        for alias in aliases:
+            if alias in state and not torch.equal(state[head], state[alias]):
+                raise ExportError(
+                    f"tied parameters disagree in the checkpoint: {alias!r} differs "
+                    f"from {head!r}; the checkpoint does not come from this "
+                    f"architecture"
+                )
+
+
+# ---------------------------------------------------------------------------
+# Export
+# ---------------------------------------------------------------------------
+def export_safetensors(
+    model_or_state_dict: Union[nn.Module, Mapping[str, torch.Tensor]],
+    out_dir: Union[str, Path],
+    config: Optional[TinyCastConfig] = None,
+    expect_parameters: Optional[int] = None,
+) -> Dict[str, object]:
+    """Write the released ``model.safetensors`` + ``config.json`` pair to ``out_dir``.
+
+    Accepts either a live :class:`~tinycast.model.TinyCastForPrediction` or a state
+    dict from a training run (in which case ``config`` says which architecture to
+    rebuild; it defaults to the released one). Tied FFN weights are written once
+    each and their aliases recorded in the safetensors metadata, so the file holds
+    the model's true 146,505-value footprint rather than the 321,225 values a
+    ``state_dict`` reports.
+
+    Pass ``expect_parameters`` to pin the count (146,505 for the released model);
+    the check is against a model instantiated from ``config``, never against a sum
+    of checkpoint tensors.
+
+    Re-exporting the released weights reproduces the published ``config.json`` and
+    the published ``model.safetensors`` tensor payload and tensor index byte for
+    byte. The header's metadata block is the one exception: the safetensors writer
+    emits those keys in an order of its own that varies between runs. The mapping
+    they encode is stable and is what the loader reads, so a byte diff of the header
+    is not a defect.
+
+    Returns a report with the two paths, the tensor and parameter counts, and the
+    number of aliases carried in the metadata.
+    """
+    from safetensors.torch import save_model
+
+    model, config = _as_model(model_or_state_dict, config)
+    model.eval()
+
+    n_parameters = sum(p.numel() for p in model.parameters())
+    if expect_parameters is not None and n_parameters != expect_parameters:
+        raise ExportError(
+            f"the model instantiated from this config has {n_parameters:,} "
+            f"parameters, not the expected {expect_parameters:,}"
+        )
+
+    out = Path(out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    weights_path = out / WEIGHTS_NAME
+    config_path = out / CONFIG_NAME
+
+    # save_model can derive the alias map itself, but its choice of which name in a
+    # sharing group to keep is its own. Seeding the map (save_model preserves
+    # entries already present) makes the canonical name the one named_parameters
+    # reports, and the map is verified against the written file below.
+    alias_map = {
+        alias: head
+        for head, aliases in tied_parameter_groups(model).items()
+        for alias in aliases
+    }
+    save_model(model, str(weights_path), metadata=dict(sorted(alias_map.items())))
+    # No trailing newline: the released config.json has none, and a byte-for-byte
+    # match lets a reader diff this export against the published artifact.
+    with open(config_path, "w") as f:
+        json.dump(config.to_dict(), f, indent=2)
+
+    n_tensors, file_sum, written_aliases = _inspect_safetensors(weights_path)
+    if file_sum != n_parameters:
+        raise ExportError(
+            f"{weights_path.name} holds {file_sum:,} values but the model has "
+            f"{n_parameters:,} parameters; the tie deduplication is wrong"
+        )
+    if written_aliases != alias_map:
+        raise ExportError(
+            f"{weights_path.name} records {len(written_aliases)} tied aliases, "
+            f"expected the {len(alias_map)} sharing groups of the model; loading it "
+            f"would leave weights uninitialized"
+        )
+
+    return {
+        "weights_path": weights_path,
+        "config_path": config_path,
+        "num_tensors": n_tensors,
+        "num_parameters": n_parameters,
+        "num_tied_aliases": len(written_aliases),
+    }
+
+
+def _as_model(
+    model_or_state_dict: Union[nn.Module, Mapping[str, torch.Tensor]],
+    config: Optional[TinyCastConfig],
+) -> Tuple[TinyCastForPrediction, TinyCastConfig]:
+    if isinstance(model_or_state_dict, nn.Module):
+        model = model_or_state_dict
+        config = config or getattr(model, "config", None)
+        if config is None:
+            raise ExportError("the model carries no config; pass config=...")
+        return model, config
+
+    if not isinstance(model_or_state_dict, Mapping):
+        raise ExportError(
+            "expected a TinyCast model or a state dict, got "
+            f"{type(model_or_state_dict).__name__}"
+        )
+
+    config = config or TinyCastConfig()
+    model = TinyCastForPrediction(config)
+    state = dict(model_or_state_dict)
+    _assert_tied_values_agree(model, state)
+    missing, unexpected = model.load_state_dict(state, strict=False)
+    if missing or unexpected:
+        raise ExportError(
+            f"state dict does not match the architecture: {len(missing)} missing "
+            f"{sorted(missing)[:5]}, {len(unexpected)} unexpected "
+            f"{sorted(unexpected)[:5]}"
+        )
+    return model, config
+
+
+def _inspect_safetensors(path: Path) -> Tuple[int, int, Dict[str, str]]:
+    """Return (tensor count, summed values, alias map) read back from the header."""
+    import struct
+
+    with open(path, "rb") as f:
+        header_len = struct.unpack("<Q", f.read(8))[0]
+        header = json.loads(f.read(header_len))
+    metadata = header.pop("__metadata__", {}) or {}
+    total = 0
+    for spec in header.values():
+        n = 1
+        for dim in spec["shape"]:
+            n *= dim
+        total += n
+    return len(header), total, metadata
+
+
+# ---------------------------------------------------------------------------
+# Round-trip verification
+# ---------------------------------------------------------------------------
+def fixed_batch(
+    batch_size: int = 2, seq_len: int = 2048, seed: int = 0
+) -> torch.Tensor:
+    """A deterministic context batch: two seasonal components plus fixed noise.
+
+    Seasonality is present on purpose, so the round trip exercises the period
+    detector and the phase-folding path rather than the convolutions alone.
+    """
+    generator = torch.Generator().manual_seed(seed)
+    t = torch.arange(seq_len, dtype=torch.float32).unsqueeze(0)
+    offsets = torch.arange(batch_size, dtype=torch.float32).unsqueeze(1)
+    daily = torch.sin(2 * math.pi * (t + 7 * offsets) / 24.0)
+    weekly = 0.3 * torch.sin(2 * math.pi * t / 168.0)
+    noise = 0.05 * torch.randn(batch_size, seq_len, generator=generator)
+    return 10.0 + 3.0 * daily + weekly + noise
+
+
+@torch.no_grad()
+def check_export_roundtrip(
+    model: nn.Module,
+    out_dir: Optional[Union[str, Path]] = None,
+    config: Optional[TinyCastConfig] = None,
+    expect_parameters: Optional[int] = None,
+    prediction_length: int = 48,
+) -> Dict[str, object]:
+    """Export ``model``, load it back, and verify nothing was lost.
+
+    Three things are checked. The reloaded model must produce bitwise-identical
+    quantiles on a fixed batch. The FFN tie must be restored as object identity and
+    not merely as equal values, since equal-but-separate tensors would triple the
+    deployed footprint. And the file's tensors must sum to the instantiated
+    parameter count rather than to the inflated ``state_dict`` sum.
+
+    ``out_dir`` defaults to a temporary directory. Pass ``expect_parameters``
+    (146,505 for the released model) to pin the count. Returns a report; every
+    failure raises :class:`ExportError`.
+    """
+    from .checkpoint import load_checkpoint
+
+    scratch = tempfile.TemporaryDirectory() if out_dir is None else nullcontext(out_dir)
+    with scratch as tmp:
+        target = Path(tmp)
+        report = export_safetensors(
+            model, target, config=config, expect_parameters=expect_parameters
+        )
+
+        model.eval()
+        x = fixed_batch(seq_len=int(model.config.seq_len))
+        reference = model(
+            past_values=x, scale_factor=1.0, prediction_length=prediction_length,
+            batch_first=True,
+        ).quantile_outputs
+
+        reloaded, _ = load_checkpoint(str(report["weights_path"]))
+        reloaded.eval()
+        replayed = reloaded(
+            past_values=x, scale_factor=1.0, prediction_length=prediction_length,
+            batch_first=True,
+        ).quantile_outputs
+
+    if replayed.shape != reference.shape:
+        raise ExportError(
+            f"reloaded model returns {tuple(replayed.shape)}, expected "
+            f"{tuple(reference.shape)}"
+        )
+    if not torch.equal(reference, replayed):
+        gap = (reference - replayed).abs().max().item()
+        raise ExportError(
+            f"reloaded model is not bitwise identical: max absolute difference {gap}"
+        )
+
+    expected_groups = tied_parameter_groups(model)
+    restored_groups = tied_parameter_groups(reloaded)
+    if restored_groups != expected_groups:
+        raise ExportError(
+            "the FFN weight tie was not restored on load: "
+            f"{sum(len(a) for a in restored_groups.values())} aliases share storage, "
+            f"expected {sum(len(a) for a in expected_groups.values())}"
+        )
+
+    naive_sum = sum(t.numel() for t in reloaded.state_dict().values())
+    if report["num_parameters"] >= naive_sum:
+        raise ExportError(
+            f"the export did not deduplicate: {report['num_parameters']:,} values "
+            f"written against a state dict sum of {naive_sum:,}"
+        )
+
+    report = dict(report)
+    report["state_dict_sum"] = naive_sum
+    report["bitwise_identical"] = True
+    return report
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+def main(argv: Optional[Iterable[str]] = None) -> int:
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="python -m tinycast.export",
+        description="Convert training checkpoints into the released "
+                    "model.safetensors + config.json pair.",
+    )
+    parser.add_argument(
+        "--average", nargs="+", metavar="CKPT", required=True,
+        help=f"checkpoints to average, in training order (the release used "
+             f"the last {RELEASE_AVERAGE_N})",
+    )
+    parser.add_argument("--out-dir", required=True, help="directory to write into")
+    parser.add_argument(
+        "--config", default=None,
+        help="config.json to build the architecture from; defaults to the "
+             "released configuration",
+    )
+    parser.add_argument(
+        "--expect-parameters", type=int, default=None,
+        help="fail unless the instantiated model has this many parameters "
+             "(146505 for the released model)",
+    )
+    parser.add_argument(
+        "--no-check", action="store_true",
+        help="skip the reload / bitwise-identity round trip",
+    )
+    args = parser.parse_args(list(argv) if argv is not None else None)
+
+    config = TinyCastConfig()
+    if args.config:
+        with open(args.config) as f:
+            raw = json.load(f)
+        config = TinyCastConfig(**{
+            k: v for k, v in raw.items() if k in TinyCastConfig.__dataclass_fields__
+        })
+
+    if len(args.average) != RELEASE_AVERAGE_N:
+        print(
+            f"[export] averaging {len(args.average)} checkpoints; the released "
+            f"weights used {RELEASE_AVERAGE_N}",
+            flush=True,
+        )
+    state = average_checkpoints(args.average)
+    model, config = _as_model(state, config)
+
+    if args.no_check:
+        report = export_safetensors(
+            model, args.out_dir, config=config,
+            expect_parameters=args.expect_parameters,
+        )
+    else:
+        report = check_export_roundtrip(
+            model, args.out_dir, config=config,
+            expect_parameters=args.expect_parameters,
+        )
+
+    print(
+        f"[export] wrote {report['weights_path']} "
+        f"({report['num_tensors']} tensors, {report['num_parameters']:,} "
+        f"parameters, {report['num_tied_aliases']} tied aliases)",
+        flush=True,
+    )
+    print(f"[export] wrote {report['config_path']}", flush=True)
+    if not args.no_check:
+        print(
+            f"[export] round trip: bitwise identical, tie restored, "
+            f"{report['num_parameters']:,} values written against a state dict "
+            f"sum of {report['state_dict_sum']:,}",
+            flush=True,
+        )
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

tinycast/losses.py

@@ -0,0 +1,253 @@
+"""Training objectives for TinyCast.
+
+Two objectives supervise the model. The nine-quantile pinball loss trains the
+whole predictive distribution; the gated committing term acts on the median
+alone and is the paper's own addition. ``seasonal_copy_baseline`` builds the
+reference forecast the committing term measures the median against.
+
+All three work in the model's normalized output space. ``TinyCastBackbone.encode``
+returns ``(y_norm, x_min, x_range)``; normalize the target with those same
+statistics before calling anything here, so predictions, targets and the
+seasonal copy sit on one scale.
+
+Each function is self-contained and takes plain tensors, so it can be exercised
+without a model or a training loop.
+"""
+from __future__ import annotations
+
+from typing import Optional, Sequence, Union
+
+import torch
+
+# Cycles per canonical day, the constant the scale factor is expressed against:
+# a sample's seasonal lag is BASE_SEASONALITY divided by its scale factor. It is
+# defined once, in tinycast.scale, and re-exported here so the lag this module
+# folds at and the factor the model is conditioned on cannot drift apart.
+from .scale import BASE_SEASONALITY
+
+# Weight of the committing term in the shipped recipe.
+COMMIT_WEIGHT = 0.3
+
+_Reduction = str
+
+
+def _reduce(per_sample: torch.Tensor, reduction: _Reduction) -> torch.Tensor:
+    if reduction == "none":
+        return per_sample
+    if reduction == "mean":
+        return per_sample.mean()
+    if reduction == "sum":
+        return per_sample.sum()
+    raise ValueError(
+        f"Unknown reduction: {reduction!r}; expected 'mean', 'sum' or 'none'."
+    )
+
+
+def _as_bh(target: torch.Tensor, name: str) -> torch.Tensor:
+    """Accept ``(B, H)`` or ``(B, H, 1)`` and return ``(B, H)``."""
+    if target.dim() == 3 and target.shape[-1] == 1:
+        return target.squeeze(-1)
+    if target.dim() != 2:
+        raise ValueError(
+            f"{name} must be (B, H) or (B, H, 1), got {tuple(target.shape)}."
+        )
+    return target
+
+
+def _mask_like(mask: Optional[torch.Tensor], ref: torch.Tensor) -> torch.Tensor:
+    if mask is None:
+        return torch.ones_like(ref)
+    mask = _as_bh(mask, "mask").to(ref.dtype)
+    if mask.shape != ref.shape:
+        raise ValueError(
+            f"mask shape {tuple(mask.shape)} does not match "
+            f"{tuple(ref.shape)}."
+        )
+    return mask
+
+
+def pinball_loss(
+    pred: torch.Tensor,
+    target: torch.Tensor,
+    quantiles: Union[Sequence[float], torch.Tensor],
+    mask: Optional[torch.Tensor] = None,
+    *,
+    reduction: _Reduction = "mean",
+) -> torch.Tensor:
+    """Quantile (pinball) loss over all quantile levels.
+
+    Args:
+        pred: ``(B, H, Q)`` normalized quantile forecasts, ordered to match
+            ``quantiles``.
+        target: ``(B, H)`` or ``(B, H, 1)`` normalized targets.
+        quantiles: the ``Q`` levels, e.g. ``config.quantiles``.
+        mask: ``(B, H)`` observedness, 1 for an observed target position and 0
+            otherwise. ``None`` treats every position as observed.
+        reduction: ``"mean"`` (default) averages over the batch, ``"sum"`` adds,
+            ``"none"`` returns the ``(B,)`` per-sample losses.
+
+    The per-sample loss divides by the observed count times ``Q``, so a sample
+    with few observed positions is not down-weighted against a full one, and a
+    sample with none contributes zero rather than a division by zero.
+
+    A non-finite target position is replaced by the detached median forecast, so
+    it contributes no loss and no gradient. Mask such positions out as well: the
+    substitution is a guard, not the mechanism.
+    """
+    if pred.dim() != 3:
+        raise ValueError(f"pred must be (B, H, Q), got {tuple(pred.shape)}.")
+    target = _as_bh(target, "target")
+    if pred.shape[:2] != target.shape:
+        raise ValueError(
+            f"pred {tuple(pred.shape)} and target {tuple(target.shape)} "
+            "disagree on batch or horizon."
+        )
+
+    q = torch.as_tensor(quantiles, dtype=pred.dtype, device=pred.device)
+    q = q.reshape(-1)
+    n_q = pred.shape[-1]
+    if q.numel() != n_q:
+        raise ValueError(
+            f"pred carries {n_q} quantile channels but {q.numel()} levels "
+            "were given."
+        )
+
+    q_mid = n_q // 2
+    target_b = target.unsqueeze(-1)
+    fill = pred[..., q_mid: q_mid + 1].detach()
+    target_safe = torch.where(torch.isfinite(target_b), target_b, fill)
+
+    err = target_safe - pred
+    q = q.view(1, 1, -1)
+    loss = torch.maximum(q * err, (q - 1.0) * err)              # (B, H, Q)
+
+    obs = _mask_like(mask, target)
+    denom = obs.sum(dim=1).clamp(min=1.0) * float(n_q)
+    per_sample = (loss * obs.unsqueeze(-1)).sum(dim=(1, 2)) / denom
+    return _reduce(per_sample, reduction)
+
+
+def seasonal_copy_baseline(
+    context: torch.Tensor,
+    horizon: int,
+    scale_factor: Union[torch.Tensor, float],
+    *,
+    base_seasonality: float = BASE_SEASONALITY,
+) -> torch.Tensor:
+    """Repeat the last seasonal cycle of the context over the horizon.
+
+    Args:
+        context: ``(B, L)`` or ``(B, L, 1)`` context values, in whatever space
+            the caller wants the copy in (raw or normalized).
+        horizon: ``H``, how many steps to emit.
+        scale_factor: per-sample or scalar seasonal scale factor ``s``, the
+            value ``tinycast.scale.seasonal_scale_factor`` returns for the
+            sample's frequency.
+        base_seasonality: numerator of the lag, 24 by convention.
+
+    The lag is ``round(base_seasonality / s)`` clipped to ``[2, L // 2]``, and
+    position ``h`` of the copy is context position ``L - lag + (h mod lag)``.
+    Returns ``(B, H)``.
+    """
+    if context.dim() == 3 and context.shape[-1] == 1:
+        context = context.squeeze(-1)
+    if context.dim() != 2:
+        raise ValueError(
+            f"context must be (B, L) or (B, L, 1), got {tuple(context.shape)}."
+        )
+    b, length = context.shape
+    horizon = int(horizon)
+    if horizon < 1:
+        raise ValueError(f"horizon must be positive, got {horizon}.")
+    if length < 4:
+        raise ValueError(f"context is too short to fold a cycle: L={length}.")
+
+    sf = torch.as_tensor(scale_factor, dtype=torch.float32, device=context.device)
+    sf = sf.reshape(-1)
+    if sf.numel() == 1:
+        sf = sf.expand(b)
+    elif sf.numel() != b:
+        raise ValueError(
+            f"scale_factor carries {sf.numel()} entries for a batch of {b}."
+        )
+
+    lag = (base_seasonality / sf.clamp(min=1e-3)).round().long()
+    lag = lag.clamp(2, max(2, length // 2)).view(-1, 1)         # (B, 1)
+
+    h = torch.arange(horizon, device=context.device).view(1, horizon)
+    src = (length - lag + (h % lag)).clamp(0, length - 1)       # (B, H)
+    return torch.gather(context, 1, src)
+
+
+def committing_loss(
+    median: torch.Tensor,
+    target: torch.Tensor,
+    seasonal_copy: torch.Tensor,
+    mask: Optional[torch.Tensor] = None,
+    *,
+    weight: float = COMMIT_WEIGHT,
+    gated: bool = True,
+    reduction: _Reduction = "mean",
+) -> torch.Tensor:
+    """Gated committing term: penalize a median that hedges below the copy.
+
+    Args:
+        median: ``(B, H)`` normalized median forecast.
+        target: ``(B, H)`` normalized targets.
+        seasonal_copy: ``(B, H)`` the reference from
+            ``seasonal_copy_baseline``, in the same space as ``median``.
+        mask: ``(B, H)`` observedness; ``None`` treats every position as
+            observed.
+        weight: the multiplier the trainer applies, 0.3 in the shipped recipe.
+        gated: apply the window-level gate. With ``False`` the hinge is scored
+            on every window.
+        reduction: as in :func:`pinball_loss`.
+
+    The hinge ``relu(|median - target| - |copy - target|)`` is zero wherever the
+    median is already at least as close as the copy, so the term stops as soon
+    as the median reaches it. The gate multiplies the whole window by zero
+    unless the copy beats the median summed over the observed positions, which
+    keeps the term silent on windows the model already wins.
+
+    Positions where any of the three inputs is non-finite contribute nothing,
+    to the hinge and to the gate alike. The average is still taken over the
+    observed count, so masking is what sets the denominator.
+    """
+    median = _as_bh(median, "median")
+    target = _as_bh(target, "target")
+    seasonal_copy = _as_bh(seasonal_copy, "seasonal_copy")
+    if median.shape != target.shape or median.shape != seasonal_copy.shape:
+        raise ValueError(
+            f"median {tuple(median.shape)}, target {tuple(target.shape)} and "
+            f"seasonal_copy {tuple(seasonal_copy.shape)} must agree."
+        )
+
+    obs = _mask_like(mask, target)
+    med_err = (median - target).abs()
+    copy_err = (seasonal_copy - target).abs()
+
+    finite = (
+        torch.isfinite(med_err) & torch.isfinite(copy_err) & torch.isfinite(target)
+    ).to(obs.dtype)
+    scored = obs * finite
+
+    hinge = torch.relu(med_err - copy_err)
+    hinge = torch.where(torch.isfinite(hinge), hinge, torch.zeros_like(hinge))
+    denom = obs.sum(dim=1).clamp(min=1.0)
+    per_sample = (hinge * scored).sum(dim=1) / denom
+
+    if gated:
+        med_total = (torch.nan_to_num(med_err, 0.0, 0.0, 0.0) * scored).sum(dim=1)
+        copy_total = (torch.nan_to_num(copy_err, 0.0, 0.0, 0.0) * scored).sum(dim=1)
+        per_sample = per_sample * (copy_total < med_total).to(per_sample.dtype)
+
+    return _reduce(per_sample * float(weight), reduction)
+
+
+__all__ = [
+    "BASE_SEASONALITY",
+    "COMMIT_WEIGHT",
+    "pinball_loss",
+    "seasonal_copy_baseline",
+    "committing_loss",
+]

tinycast/model.py

@@ -0,0 +1,118 @@
+"""TinyCast model assembly.
+
+    model(past_values, scale_factor, prediction_length, batch_first).quantile_outputs
+"""
+
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+
+from .config import TinyCastConfig
+
+
+@dataclass
+class PredictionOutput:
+    quantile_outputs: torch.Tensor
+    prediction_outputs: torch.Tensor = None
+
+
+class TinyCastBackbone(nn.Module):
+    """Inner model: per-window min-max norm -> dilated-conv core -> denorm."""
+
+    def __init__(self, config: TinyCastConfig):
+        super().__init__()
+        self.config = config
+        from .backbone import DilatedConvBackbone
+        from .normalization import WindowMinMax
+
+        self.core = DilatedConvBackbone(
+            seq_len=int(config.seq_len),
+            p_out=int(config.output_token_len),
+            n_quantiles=int(config.num_quantiles),
+            d=int(config.conv_dim),
+            n_layers=int(config.n_layers),
+            kernel=int(config.kernel_size),
+            ffn_mult=float(config.ffn_mult),
+            top_k_periods=int(config.top_k_periods),
+            significance_alpha=float(config.significance_alpha),
+            n_harmonics=int(config.n_harmonics),
+            pool_kind=str(config.pool_kind),
+            causal=bool(config.causal),
+            phase_bins=int(config.phase_bins),
+            decoder_depth=int(config.decoder_depth),
+            separable_conv=bool(config.separable_conv),
+            share_ffn=bool(config.share_ffn),
+            future_conv=bool(config.future_conv),
+            future_conv_layers=int(config.future_conv_layers),
+            future_conv_seed=int(config.future_conv_seed),
+        )
+        self.norm = WindowMinMax(eps_clamp=1e-5)
+
+    def encode(
+        self,
+        past_values: torch.Tensor,
+        batch_first: bool = True,
+        scale_factor: "torch.Tensor | float | None" = None,
+        horizon: "int | None" = None,
+    ) -> "tuple[torch.Tensor, torch.Tensor, torch.Tensor]":
+        """per-window min-max norm -> dilated-conv core -> normalized y."""
+        x = past_values
+        if not batch_first:
+            x = x.transpose(0, 1)
+        if x.dim() == 2:
+            x = x.unsqueeze(-1)
+
+        x_normed, x_min, x_range = self.norm.transform(x)
+        nan_mask = (~torch.isnan(x)).to(x.dtype)
+        y_norm = self.core(
+            x_normed, nan_mask=nan_mask, scale_factor=scale_factor,
+            horizon=horizon,
+        )
+        return y_norm, x_min, x_range
+
+
+class TinyCastForPrediction(nn.Module):
+    """Top-level model container.
+
+    Usage:
+        model = TinyCastForPrediction(TinyCastConfig())
+        out = model(past_values=x, scale_factor=sf, prediction_length=pl,
+                    batch_first=False)
+        quantiles = out.quantile_outputs  # (B, Q, pred_len, 1)
+
+    NOTE: this ``forward`` is the SINGLE-SHOT arbitrary-horizon path. The
+    deployed GIFT-Eval inference uses the AR-rollout predictor
+    (``tinycast.predictor.TinyCastPredictor``), which calls ``self.model.encode``
+    in 48-step chunks. For horizons <= 48 the two paths coincide.
+    """
+
+    def __init__(self, config: TinyCastConfig):
+        super().__init__()
+        self.config = config
+        self.model = TinyCastBackbone(config)
+
+    def forward(self, past_values, scale_factor=None, prediction_length=None,
+                batch_first=None):
+        if scale_factor is None:
+            scale_factor = 1.0
+        if batch_first is None:
+            batch_first = True
+        ctx = past_values
+        if not batch_first:
+            ctx = ctx.transpose(0, 1)
+        if ctx.dim() == 2:
+            ctx = ctx.unsqueeze(-1)
+        ctx_len_max = int(self.config.seq_len)
+        ctx_in = ctx[:, -ctx_len_max:, :]
+        p_out_native = int(self.model.core.p_out)
+        pred_len = int(prediction_length) if prediction_length else p_out_native
+        y_norm, x_min, x_range = self.model.encode(
+            ctx_in, batch_first=True, scale_factor=scale_factor,
+            horizon=pred_len,
+        )
+        if y_norm.dim() == 2:
+            y_norm = y_norm.unsqueeze(-1)
+        y_pred = y_norm * x_range + x_min
+        quantile_outputs = y_pred.permute(0, 2, 1).unsqueeze(-1)
+        return PredictionOutput(quantile_outputs=quantile_outputs)

tinycast/normalization.py

@@ -0,0 +1,58 @@
+"""Per-context-window min-max normalization used by the encoder path."""
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+
+
+class WindowMinMax(nn.Module):
+    """Per-context-window min-max normalization for the encoder path.
+
+    Per-window statistics:
+
+        x_min   = x.min(1, keepdim=True)[0].detach()
+        x_max   = x.max(1, keepdim=True)[0].detach()
+        x_range = (x_max - x_min).clamp(min=1e-5).detach()
+        x_norm  = (x - x_min) / x_range            # → [0, 1]
+
+    Stats are detached: gradients do NOT flow through normalization.
+    Uses explicit ``transform`` / ``inverse_transform`` so the backbone can
+    hold the (x_min, x_range) tuple across encoder + decoder and apply the
+    inverse at loss / forecast time.
+    """
+
+    def __init__(self, eps_clamp: float = 1e-5) -> None:
+        super().__init__()
+        self.eps_clamp = eps_clamp
+
+    def transform(
+        self, x: torch.Tensor
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Normalize ``x: (B, L, 1)`` to [0, 1] per context window.
+
+        Returns ``(x_normalized, x_min, x_range)`` with stats detached and
+        ``x_range >= eps_clamp`` to avoid div-by-zero on constant series.
+
+        Robust to NaN / +inf / -inf in ``x``: those positions are filled
+        with 0 BEFORE computing min/max.
+        """
+        x_filled = torch.nan_to_num(x, nan=0.0, posinf=0.0, neginf=0.0)
+        x_min = x_filled.min(dim=1, keepdim=True).values.detach()
+        x_max = x_filled.max(dim=1, keepdim=True).values.detach()
+        x_range = (x_max - x_min).clamp(min=self.eps_clamp).detach()
+        x_normalized = (x_filled - x_min) / x_range
+        return x_normalized, x_min, x_range
+
+    @staticmethod
+    def inverse_transform(
+        y_pred_normalized: torch.Tensor,
+        x_min: torch.Tensor,
+        x_range: torch.Tensor,
+    ) -> torch.Tensor:
+        """Un-normalize ``(B, p)`` predictions back to raw magnitude.
+
+        ``x_min`` / ``x_range`` come from a prior ``transform`` call and are
+        ``(B, 1, 1)``; the trailing dim is squeezed for broadcasting against
+        ``(B, p)``.
+        """
+        return y_pred_normalized * x_range.squeeze(-1) + x_min.squeeze(-1)

tinycast/periodogram.py

@@ -0,0 +1,104 @@
+"""Normalized-periodogram period detector.
+
+A zero-parameter structural detector: it identifies the dominant seasonal
+periods of each series via a significance-filtered normalized periodogram.
+The dilated-conv encoder uses it to build its phase positional encoding.
+"""
+
+from __future__ import annotations
+
+import math
+
+import torch
+import torch.nn.functional as F
+
+
+def significant_periods(
+    x: torch.Tensor,
+    *,
+    min_period: int = 2,
+    max_period: int | None = None,
+    top_k: int = 16,
+    significance_alpha: float = 0.05,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Identify candidate periods via the normalized periodogram.
+
+    Score per frequency bin k:
+        I_norm[k] = |X[k]|² / sum_k' |X[k']|²
+
+    Under H_0 (white Gaussian noise), max(I_norm) follows an extreme-value
+    distribution. Peaks are filtered by a Bonferroni-corrected significance
+    threshold:
+
+        t_α = ln(N_bins / α) / N_bins
+
+    where N_bins is the number of valid frequency bins (data-determined,
+    not a knob) and α is the significance level (default 0.05). Peaks below
+    t_α are excluded by setting their score to -inf, so ``n_valid`` reflects
+    only periods that pass.
+
+    α is exposed for completeness but should normally stay at 0.05; smaller
+    (e.g. 0.01) is stricter, larger (0.10) laxer. Set α=1.0 to disable
+    filtering entirely.
+
+    Returns ``(periods, scores, n_valid)``: integer periods (0 = rejected),
+    per-slot scores, and the count of significant periods per sample.
+    """
+    B, L = x.shape
+    device = x.device
+    if max_period is None:
+        max_period = L // 2
+
+    with torch.amp.autocast(device_type=x.device.type if x.is_cuda else "cpu",
+                            enabled=False):
+        x_f = x.float()
+        x_c = x_f - x_f.mean(dim=1, keepdim=True)
+        n_fft = 1 << int(math.ceil(math.log2(max(2, L))))
+        X = torch.fft.rfft(x_c, n=n_fft)
+        power = (X * X.conj()).real
+        power = power[:, 1:]   # skip DC
+        n_bins = power.shape[1]
+        total = power.sum(dim=1, keepdim=True).clamp(min=1e-12)
+        I_norm = power / total
+
+        k_lo = max(0, (n_fft // max_period) - 1)
+        k_hi = min(n_bins - 1, max(0, (n_fft // max(2, min_period)) - 1))
+
+        I_left = I_norm[:, :-2]
+        I_mid = I_norm[:, 1:-1]
+        I_right = I_norm[:, 2:]
+        is_local_max = (I_mid > I_left) & (I_mid > I_right)
+        is_local_max_padded = F.pad(is_local_max, (1, 1), value=False)
+
+        valid = torch.zeros(n_bins, device=device, dtype=torch.bool)
+        if k_hi > k_lo:
+            valid[k_lo:k_hi + 1] = True
+        is_peak = is_local_max_padded & valid.unsqueeze(0)
+
+        neg_inf = torch.full_like(I_norm, float("-inf"))
+        scored = torch.where(is_peak, I_norm, neg_inf)
+
+        # Bonferroni-corrected significance threshold. N_bins = number of
+        # frequency bins eligible to compete; approximated by the full
+        # periodogram length (the local-max filter doesn't change the
+        # multiple-testing count substantively).
+        N_bins_eff = max(2, int(n_bins))
+        alpha = max(min(float(significance_alpha), 1.0), 1e-12)
+        sig_threshold = math.log(N_bins_eff / alpha) / N_bins_eff
+        scored = torch.where(
+            scored >= sig_threshold, scored, neg_inf,
+        )
+
+        scores, k_top = scored.topk(k=min(top_k, n_bins), dim=1)
+        freq_bins = k_top + 1   # undo the DC skip
+        # Round, don't truncate. The peak bin k for true period S has
+        # k_exact = n_fft / S. Truncating ``n_fft // k`` flips period 7 <-> 6
+        # for S=7 at L=2048 (depending on which side of the half-integer the
+        # peak lands), and that 14% period error becomes a full-cycle phase
+        # drift over a 48-step horizon.
+        periods_raw = torch.round(n_fft / freq_bins.clamp(min=1).float()).long()
+        finite = torch.isfinite(scores)
+        n_valid = finite.sum(dim=1).long()
+        periods = torch.where(finite, periods_raw, torch.zeros_like(periods_raw))
+
+    return periods.long(), scores, n_valid

tinycast/predictor.py

@@ -0,0 +1,518 @@
+"""GIFT-Eval gluonts predictor for TinyCast.
+
+``TinyCastPredictor`` is the deployed predictor. It wraps the model in the
+gluonts Predictor protocol and drives autoregressive-rollout decoding
+(48-step chunks), flip-invariance symmetrization, NaN-imputation and
+optional period-alignment downsampling.
+
+Anything that changes what the predictor emits says so:
+
+``device``          a named device must exist. ``device=None`` is the only
+                    request that selects one for you (CUDA when present, else
+                    CPU); the resolved device is ``predictor.device``.
+``TINYCAST_INT8``   ``w8`` or ``w8a8`` post-training fake quantization, off by
+                    default. Any other non-empty value is an error, not an
+                    inert setting.
+``TINYCAST_TILT_K`` an eval-only probe that moves the emitted median off the
+                    quantile grid, off (``0``) by default, with
+                    ``TINYCAST_TILT_MODE`` in {``adaptive``, ``fixed``}.
+
+The environment variables are read once, when the predictor is constructed, and
+an engaged one prints a line naming itself. Reproducing the published numbers
+means leaving them unset.
+"""
+from __future__ import annotations
+
+import math
+import os
+from typing import List, Optional, Tuple
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+from .checkpoint import load_checkpoint
+from .normalization import WindowMinMax
+from .scale import seasonal_scale_factor
+
+try:
+    from torch.amp import autocast as _autocast_fp
+except Exception:  # pragma: no cover
+    _autocast_fp = None
+
+
+def _resolve_device(requested: Optional[str]) -> torch.device:
+    """Return the requested device, or say why it is unavailable.
+
+    ``None`` is the request to choose: CUDA when it is available, CPU otherwise.
+    Every other value is a requirement. Falling back to CPU behind the caller's
+    back drops bf16 autocast for fp32 and moves every forecast by roughly 1e-3,
+    which is small enough to read as a regression and large enough to fail an
+    assertion against the published aggregates, so an absent accelerator is an
+    error rather than a substitution.
+    """
+    if requested is None:
+        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    dev = torch.device(requested)
+    if dev.type == "cuda":
+        if not torch.cuda.is_available():
+            raise RuntimeError(
+                f"device={requested!r} was requested but "
+                "torch.cuda.is_available() is False. Pass device='cpu' to run "
+                "on CPU (fp32, and about 1e-3 off the published numbers), or "
+                "device=None to take whichever device is present."
+            )
+        if dev.index is not None and dev.index >= torch.cuda.device_count():
+            raise RuntimeError(
+                f"device={requested!r} was requested but only "
+                f"{torch.cuda.device_count()} CUDA device(s) are visible."
+            )
+    if dev.type == "mps" and not torch.backends.mps.is_available():
+        raise RuntimeError(
+            f"device={requested!r} was requested but MPS is unavailable. "
+            "Pass device='cpu' to run on CPU."
+        )
+    return dev
+
+
+_INT8_MODES = ("w8", "w8a8")
+_INT8_OFF = ("", "0", "off", "no", "false", "none")
+_TILT_MODES = ("adaptive", "fixed")
+
+
+def _resolve_int8() -> Optional[str]:
+    """Read ``TINYCAST_INT8``: the quantization mode, or ``None`` when off.
+
+    Only ``w8`` and ``w8a8`` name a scheme. A truthy value such as ``1`` names
+    no scheme, and picking one for the caller would quantize a run that asked
+    for something else, so an unrecognized value raises. The alternative is what
+    this used to do: leave the run in fp32 while the caller believes they are
+    measuring INT8.
+    """
+    raw = os.environ.get("TINYCAST_INT8", "").strip().lower()
+    if raw in _INT8_OFF:
+        return None
+    if raw not in _INT8_MODES:
+        raise ValueError(
+            f"TINYCAST_INT8={raw!r} is not a quantization mode. Use 'w8' "
+            "(per-channel INT8 weights) or 'w8a8' (+ per-tensor dynamic INT8 "
+            "activations), or unset it to run in floating point."
+        )
+    return raw
+
+
+def _resolve_tilt() -> Tuple[float, str]:
+    """Read the tilt probe's variables, announcing an engaged one.
+
+    ``TINYCAST_INT8`` prints a line when it engages; this does the same, so
+    neither switch can invalidate a golden array without appearing in the log.
+    ``TINYCAST_TILT_MODE`` is checked only when the tilt is on, which keeps it
+    inert at ``K=0`` as documented.
+    """
+    raw = os.environ.get("TINYCAST_TILT_K", "").strip()
+    try:
+        k = float(raw) if raw else 0.0
+    except ValueError:
+        raise ValueError(
+            f"TINYCAST_TILT_K={raw!r} is not a number. Unset it, or set 0, to "
+            "emit the model's own median."
+        ) from None
+    mode = os.environ.get("TINYCAST_TILT_MODE", "adaptive").strip().lower()
+    if k != 0.0:
+        if mode not in _TILT_MODES:
+            raise ValueError(
+                f"TINYCAST_TILT_MODE={mode!r} is not a tilt rule. Use "
+                "'adaptive' (skew-following) or 'fixed'."
+            )
+        print(
+            f"[tilt] TINYCAST_TILT_K={k:g} {mode}: the emitted median is "
+            "re-interpolated off the quantile grid, so this is not the "
+            "published model's forecast (inert below 3 quantiles)",
+            flush=True,
+        )
+    return k, mode
+
+
+def _numpy_fill(arr: np.ndarray) -> np.ndarray:
+    mask = np.isnan(arr)
+    idx = np.where(~mask, np.arange(mask.shape[1]), 0)
+    np.maximum.accumulate(idx, axis=1, out=idx)
+    return arr[np.arange(idx.shape[0])[:, None], idx]
+
+
+class ARRolloutPredictor:
+    """Base predictor: AR rollout + flip + NaN-imputation + period downsample.
+
+    Subclasses install ``self.model`` (a callable ``(x, x_mark, y_mark)``).
+    ``device=None`` selects one; a named device must exist. Either way the
+    device that ran is ``self.device``.
+
+    Every setting that changes a forecast is a named parameter, so a keyword
+    that is not one raises. Absorbing unknown keywords would let a misspelling
+    such as ``force_flip_invarience=True`` construct a predictor with flip
+    symmetrization off and return a forecast that looks right and cannot be
+    reproduced.
+    """
+
+    def __init__(
+        self,
+        prediction_length: int,
+        device: Optional[str] = None,
+        seq_len: int = 2048,
+        input_token_len: int = 2048,
+        output_token_len: int = 48,
+        num_samples: int = 100,
+        batch_size: int = 256,
+        use_amp: int = 1,
+        downsample_factor: int = 1,
+        force_flip_invariance: bool = False,
+        adaptive_ar_rollout: bool = False,
+    ):
+        self.device = _resolve_device(device)
+        self.prediction_length = int(prediction_length)
+        self.num_samples = int(num_samples)
+        self.batch_size = int(batch_size)
+        self.seq_len = int(seq_len)
+        self.input_token_len = int(input_token_len)
+        self.output_token_len = int(output_token_len)
+        self.use_amp = int(use_amp)
+        self.downsample_factor = int(downsample_factor)
+        self.force_flip_invariance = bool(force_flip_invariance)
+        self.adaptive_ar_rollout = bool(adaptive_ar_rollout)
+        # Quantile levels emitted by the model (set by subclasses from cfg).
+        self.quantiles = [0.5]
+        self.model = None
+
+    def _downsample_if_needed(
+        self, series: torch.Tensor
+    ) -> Tuple[torch.Tensor, int]:
+        cur = series
+        if self.downsample_factor > 1:
+            cur = cur[::self.downsample_factor]
+        return cur, self.downsample_factor
+
+    def _left_pad_to_len(
+        self, arr: np.ndarray, target_len: int
+    ) -> Tuple[np.ndarray, int]:
+        if arr.shape[0] >= target_len:
+            return arr[-target_len:], 0
+        pad_len = target_len - arr.shape[0]
+        fill_value = arr[0] if arr.shape[0] > 0 else 0.0
+        padding = np.full((pad_len,), fill_value, dtype=arr.dtype)
+        return np.concatenate([padding, arr], axis=0), pad_len
+
+    def _prepare_context_matrix(
+        self, context: List[torch.Tensor]
+    ) -> Tuple[torch.Tensor, List[int]]:
+        xs = []
+        downsample_factors = []
+        for c in context:
+            cur, df = self._downsample_if_needed(c)
+            downsample_factors.append(df)
+
+            cur_np = cur.detach().cpu().float().numpy()
+            cur_np, _ = self._left_pad_to_len(cur_np, self.seq_len)
+
+            x2d = cur_np[None, :]
+            x_interp = np.copy(x2d)
+            series = x2d[0]
+            if np.any(np.isnan(series)):
+                valid_mask = ~np.isnan(series)
+                if np.sum(valid_mask) >= 2:
+                    valid_idx = np.where(valid_mask)[0]
+                    valid_val = series[valid_mask]
+                    x_interp[0] = np.interp(
+                        np.arange(len(series)), valid_idx, valid_val
+                    )
+                else:
+                    x_interp = _numpy_fill(x2d)
+            ff = _numpy_fill(x_interp)
+            bf = np.flip(_numpy_fill(np.flip(x_interp, axis=1)), axis=1)
+            x_imp = np.where(np.isnan(ff), bf, ff)
+            x_imp = np.where(np.isnan(x_imp), 0.0, x_imp)
+            xs.append(x_imp[0])
+
+        x = torch.tensor(
+            np.stack(xs), device=self.device, dtype=torch.float32
+        ).unsqueeze(-1)
+        return x, downsample_factors
+
+    def _decode_autoregressive(
+        self,
+        init_ctx: torch.Tensor,
+        use_bf16: bool,
+        downsample_factors: List[int],
+    ) -> torch.Tensor:
+        B, _, C = init_ctx.shape
+        roll_len = int(self.output_token_len)
+
+        if self.adaptive_ar_rollout:
+            try:
+                from .periodogram import significant_periods
+                periods, _s, _nv = significant_periods(
+                    init_ctx[:, -self.seq_len:, 0].float(),
+                    min_period=2, max_period=self.seq_len // 2, top_k=1,
+                )
+                pos = periods[periods > 0]
+                if pos.numel() > 0:
+                    p0 = int(pos.float().median().item())
+                    if 2 <= p0 < roll_len:
+                        roll_len = max(4, p0)
+            except Exception:
+                pass
+
+        target_pred_lens = [
+            int(self.prediction_length) // int(max(1, df))
+            for df in downsample_factors
+        ]
+        max_target_pred_len = max(target_pred_lens)
+        steps = math.ceil(max_target_pred_len / roll_len)
+        preds: List[torch.Tensor] = []
+        batch_ctx = init_ctx
+
+        y_mark = torch.zeros(
+            B, self.output_token_len, C,
+            device=self.device, dtype=init_ctx.dtype,
+        )
+
+        for _ in range(steps):
+            x_in = batch_ctx[:, -self.seq_len:, :]
+            x_mark = torch.zeros_like(x_in)
+            if _autocast_fp is not None and self.use_amp and use_bf16:
+                try:
+                    with _autocast_fp("cuda", dtype=torch.bfloat16):
+                        out = self.model(x_in, x_mark, y_mark)
+                except Exception:
+                    out = self.model(x_in, x_mark, y_mark)
+            else:
+                out = self.model(x_in, x_mark, y_mark)
+            chunk = out[:, -self.output_token_len:, :][:, :roll_len, :]  # (B, roll, Q)
+            preds.append(chunk)
+            # Feed only the MEDIAN quantile back into the context (the AR state
+            # is a univariate series); keep all Q in preds for the forecast.
+            q_mid = chunk.shape[-1] // 2
+            batch_ctx = torch.cat([batch_ctx, chunk[:, :, q_mid:q_mid + 1]], dim=1)
+
+        return torch.cat(preds, dim=1)                                   # (B, pl, Q)
+
+    @torch.no_grad()
+    def predict(self, test_data_input, use_bf16_if_available: bool = True):
+        from gluonts.itertools import batcher
+        from gluonts.model.forecast import SampleForecast, QuantileForecast
+
+        forecasts: List = []
+        use_bf16 = bool(
+            use_bf16_if_available
+            and self.device.type == "cuda"
+            and torch.cuda.is_available()
+            and torch.cuda.is_bf16_supported()
+        )
+
+        for batch in batcher(test_data_input, batch_size=self.batch_size):
+            targets = [
+                torch.tensor(entry["target"], dtype=torch.float32)
+                for entry in batch
+            ]
+            batch_ctx, dfs = self._prepare_context_matrix(targets)
+            pred_pos = self._decode_autoregressive(batch_ctx, use_bf16, dfs)  # (B,pl,Q)
+            if self.force_flip_invariance:
+                pred_neg = self._decode_autoregressive(-batch_ctx, use_bf16, dfs)
+                # Flip-symmetrize. For quantiles the tau-quantile of -y is
+                # -(the (1-tau)-quantile of y), so reverse the quantile axis on
+                # the negated branch. Q=1 (median) reverse is a no-op.
+                pred = 0.5 * (pred_pos - pred_neg.flip(dims=[-1]))
+            else:
+                pred = pred_pos
+
+            Q = pred.shape[-1]
+            pred_np = pred.float().detach().cpu().numpy()                 # (B, pl, Q)
+            if not np.isfinite(pred_np).all():
+                for qi in range(Q):
+                    pred_np[:, :, qi] = _numpy_fill(pred_np[:, :, qi])
+
+            for i, ts in enumerate(batch):
+                df = int(max(1, dfs[i]))
+                target_pl = int(self.prediction_length) // df
+                arr = pred_np[i, :target_pl, :]                          # (target_pl, Q)
+                if df > 1:
+                    new_len = int(self.prediction_length)
+                    src = np.linspace(0, 1, arr.shape[0])
+                    dst = np.linspace(0, 1, new_len)
+                    arr = np.stack([np.interp(dst, src, arr[:, qi])
+                                    for qi in range(Q)], axis=1)         # (new_len, Q)
+                start_date = ts["start"] + len(ts["target"])
+                if Q > 1:
+                    # Sort across quantiles to guarantee non-crossing, then a
+                    # QuantileForecast so gluonts scores WQL/CRPS over the deciles.
+                    arr = np.sort(arr, axis=1)
+                    forecasts.append(QuantileForecast(
+                        forecast_arrays=arr.T,                          # (Q, pl)
+                        start_date=start_date,
+                        forecast_keys=[str(q) for q in self.quantiles],
+                    ))
+                else:
+                    samples = np.repeat(arr[:, 0][None, :], self.num_samples, axis=0)
+                    forecasts.append(
+                        SampleForecast(samples=samples, start_date=start_date)
+                    )
+
+        return forecasts
+
+
+class _BackboneAdapter(nn.Module):
+    """Adapts the model wrapper to the ``(x, x_mark, y_mark) -> (B, p, Q)`` contract."""
+
+    def __init__(self, backbone: nn.Module, scale_factor: float = 1.0):
+        super().__init__()
+        self.backbone = backbone
+        self.scale_factor = float(scale_factor)
+        # single-shot counterfactual: emit this many steps in ONE forward.
+        self.pred_len_override = None
+        # Resolved once, and announced when on: a forecast must not change
+        # because a variable was exported after the predictor was built.
+        self.tilt_k, self.tilt_mode = _resolve_tilt()
+
+    def forward(self, x, x_mark=None, y_mark=None, **kwargs):
+        y_norm, x_min, x_range = self.backbone.encode(
+            x, batch_first=True, scale_factor=self.scale_factor,
+            horizon=self.pred_len_override,
+        )
+        # Match training: the chunk loss clamps y_norm to [-5,5] before the
+        # pinball loss, so the model is never optimized outside that band.
+        # Clamp at inference too: otherwise an un-penalized overshoot feeds
+        # back into the AR rollout context and compounds over chunks.
+        y_norm = y_norm.clamp(-5.0, 5.0)
+
+        # num_quantiles > 1 => y_norm is (B, p, Q). Manual inverse since
+        # WindowMinMax.inverse_transform squeezes x_min/x_range for the (B, p)
+        # point case; x_min/x_range are (B, 1, 1) so they broadcast directly.
+        if y_norm.dim() == 3:
+            tk = self.tilt_k
+            Q = y_norm.shape[-1]
+            if tk != 0.0 and Q >= 3:
+                # EVAL-ONLY de-hedge probe (no training); default off (tk=0).
+                qm = Q // 2
+                lo = y_norm[..., 0]; hi = y_norm[..., -1]; med = y_norm[..., qm]
+                if self.tilt_mode == "fixed":
+                    tau = torch.full_like(med, 0.5 + tk)
+                else:                                            # skew-adaptive
+                    asym = (hi + lo - 2 * med) / (hi - lo).abs().clamp(min=1e-6)
+                    tau = 0.5 + tk * torch.tanh(asym)            # >0 right-skew
+                tau = tau.clamp(qm / (Q + 1.0), (qm + 2) / (Q + 1.0))
+                idxf = (tau * (Q + 1) - 1).clamp(0, Q - 1 - 1e-4)
+                ilo = idxf.floor().long().clamp(0, Q - 2)
+                frac = (idxf - ilo.to(idxf.dtype)).clamp(0, 1)
+                qlo = torch.gather(y_norm, -1, ilo.unsqueeze(-1)).squeeze(-1)
+                qhi = torch.gather(y_norm, -1, (ilo + 1).unsqueeze(-1)).squeeze(-1)
+                y_norm = y_norm.clone()
+                y_norm[..., qm] = qlo * (1 - frac) + qhi * frac
+            return y_norm * x_range + x_min                    # (B, p, Q)
+        y_pred = WindowMinMax.inverse_transform(y_norm, x_min, x_range)
+        return y_pred.unsqueeze(-1)  # (B, p, 1)
+
+
+class TinyCastPredictor(ARRolloutPredictor):
+    """The deployed predictor: AR-rollout decoding around the TinyCast model."""
+
+    def __init__(
+        self,
+        prediction_length: int,
+        checkpoint_path: str,
+        device: Optional[str] = None,
+        num_samples: int = 100,
+        batch_size: int = 256,
+        use_amp: int = 1,
+        downsample_factor: int = 1,
+        force_flip_invariance: bool = False,
+        freq: Optional[str] = None,
+        domain: Optional[str] = None,
+        no_daily: bool = False,
+        single_shot: bool = False,
+        adaptive_ar_rollout: bool = False,
+        config_path: Optional[str] = None,
+    ):
+        self.single_shot = bool(single_shot)
+        # 1. Load the weights (safetensors + config.json).
+        model, cfg = load_checkpoint(checkpoint_path, config_path)
+
+        # 2. Eval-time scale_factor from (freq, domain). bizitobs_l2c has no
+        #    daily cycle -> /7.
+        if freq is not None and domain is not None:
+            sf_eval = seasonal_scale_factor(freq, domain)
+            if no_daily:
+                sf_eval /= 7
+        else:
+            sf_eval = 1.0
+        self._eval_scale_factor = float(sf_eval)
+
+        # 3. Base predictor bookkeeping (drives AR-rollout / batching / flip).
+        super().__init__(
+            prediction_length=prediction_length,
+            device=device,
+            seq_len=int(cfg.seq_len),
+            input_token_len=int(cfg.seq_len),
+            output_token_len=int(cfg.output_token_len),
+            num_samples=num_samples,
+            batch_size=batch_size,
+            use_amp=use_amp,
+            downsample_factor=downsample_factor,
+            force_flip_invariance=force_flip_invariance,
+            adaptive_ar_rollout=adaptive_ar_rollout,
+        )
+        self.quantiles = list(getattr(cfg, "quantiles", [0.5])) or [0.5]
+        self._missing_aware = bool(getattr(cfg, "missing_channel", False))
+
+        # 4. Install the model wrapped in the adapter interface.
+        backbone = model.model  # TinyCastForPrediction -> TinyCastBackbone
+        backbone.to(self.device).eval()
+        # Optional INT8 post-training fake-quant. Off by default;
+        # TINYCAST_INT8=w8 (weights) or w8a8 (+ dynamic activations).
+        # quantize_int8_ prints the mode it applied.
+        _int8 = _resolve_int8()
+        if _int8 is not None:
+            from .quant import quantize_int8_
+            quantize_int8_(backbone, _int8)
+        self.model = _BackboneAdapter(
+            backbone, scale_factor=self._eval_scale_factor,
+        ).to(self.device).eval()
+        if self.single_shot:
+            self.model.pred_len_override = int(prediction_length)
+
+    def _decode_autoregressive(self, init_ctx, use_bf16, downsample_factors):
+        """Single-shot override: one forward for the full horizon (no AR loop).
+        Default deployed behavior (single_shot=False) falls back to the base
+        AR rollout."""
+        if not self.single_shot:
+            return super()._decode_autoregressive(init_ctx, use_bf16, downsample_factors)
+        x_in = init_ctx[:, -self.seq_len:, :]
+        x_mark = torch.zeros_like(x_in)
+        use_cuda = bool(self.use_amp and use_bf16 and str(self.device).startswith("cuda"))
+        if use_cuda:
+            with torch.autocast("cuda", dtype=torch.bfloat16):
+                out = self.model(x_in, x_mark, None)
+        else:
+            out = self.model(x_in, x_mark, None)
+        return out  # (B, prediction_length, 1)
+
+    def _prepare_context_matrix(self, context):
+        """Missing-aware override: keep genuine gaps as NaN so the observed-mask
+        + observed-only normalization see true missingness. Falls back to the
+        base (interpolating) behavior when the model is not missing-aware
+        (the deployed model is not)."""
+        if not getattr(self, "_missing_aware", False):
+            return super()._prepare_context_matrix(context)
+        xs, dfs = [], []
+        for c in context:
+            cur, df = self._downsample_if_needed(c)
+            dfs.append(df)
+            a = cur.detach().cpu().float().numpy()
+            if a.shape[0] >= self.seq_len:
+                a = a[-self.seq_len:]
+            else:
+                pad = np.full((self.seq_len - a.shape[0],), np.nan, dtype=a.dtype)
+                a = np.concatenate([pad, a], axis=0)
+            xs.append(a)
+        x = torch.tensor(
+            np.stack(xs), device=self.device, dtype=torch.float32
+        ).unsqueeze(-1)
+        return x, dfs

tinycast/quant.py

@@ -0,0 +1,81 @@
+"""Post-training INT8 quantization (fake-quant) for TinyCast.
+
+Measures the GIFT-Eval accuracy of an INT8-deployed model by simulating INT8 arithmetic in
+floating point. Per-output-channel symmetric INT8 weights on every Linear and Conv1d; optional
+per-tensor dynamic INT8 activations. RMSNorm, the SiLU gate, the min-max (de)normalization,
+and the rFFT period detector stay in full precision: they are off the convolutional mixing path
+and run as fp/LUT ops on the target runtime.
+
+Modes (env ``TINYCAST_INT8``):
+  ``w8``    per-channel INT8 weights, fp activations. The ~145 KB weight footprint; isolates the
+            weight-quantization error.
+  ``w8a8``  + per-tensor dynamic INT8 activations (scale from each tensor's own range, so no
+            calibration set is needed; an optimistic but faithful estimate of full INT8 compute).
+
+The weight quant is applied in-place to the parameter tensors, so it is correct regardless of
+whether a module is invoked via ``__call__`` or functionally (the separable pointwise conv is run
+as ``F.linear(weight.squeeze(-1))``). Activation quant (``w8a8``) uses a forward-pre-hook on every
+Linear/Conv1d to quantize inputs, plus a forward-hook on Conv1d to quantize the depthwise output
+that feeds the functional pointwise, covering every activation site on the mixing path.
+"""
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+
+_QMIN, _QMAX = -128, 127  # int8 symmetric (zero-point 0)
+
+
+@torch.no_grad()
+def _fq_weight_per_outchannel(w: torch.Tensor) -> torch.Tensor:
+    """Symmetric per-output-channel (axis 0) int8 fake-quant of a weight tensor.
+
+    Linear weight is (out, in); Conv1d weight is (out, in/groups, k). Axis 0 is the output
+    channel in both, so a per-axis-0 scale is the standard per-channel weight scheme.
+    """
+    red = tuple(d for d in range(w.dim()) if d != 0)
+    amax = w.abs().amax(dim=red, keepdim=True).clamp_(min=1e-12)
+    scale = amax / _QMAX
+    return (torch.round(w / scale).clamp_(_QMIN, _QMAX) * scale).to(w.dtype)
+
+
+def _fq_act_dynamic(x: torch.Tensor) -> torch.Tensor:
+    """Per-tensor symmetric int8 fake-quant with a dynamic (this-tensor) scale."""
+    if not torch.is_floating_point(x):
+        return x
+    amax = x.detach().abs().amax().clamp(min=1e-12)
+    scale = amax / _QMAX
+    return torch.round(x / scale).clamp(_QMIN, _QMAX) * scale
+
+
+def _pre_hook(_mod, inp):
+    if not inp:
+        return None
+    return (_fq_act_dynamic(inp[0]),) + tuple(inp[1:])
+
+
+def _post_hook(_mod, _inp, out):
+    return _fq_act_dynamic(out)
+
+
+def quantize_int8_(model: nn.Module, mode: str = "w8") -> nn.Module:
+    """In-place INT8 fake-quant of ``model``. ``mode`` in {"w8", "w8a8"}. Returns ``model``."""
+    mode = mode.strip().lower()
+    if mode not in ("w8", "w8a8"):
+        raise ValueError(f"unknown INT8 mode {mode!r} (expected 'w8' or 'w8a8')")
+    n_w = 0
+    with torch.no_grad():
+        for m in model.modules():
+            if isinstance(m, (nn.Linear, nn.Conv1d)):
+                m.weight.data.copy_(_fq_weight_per_outchannel(m.weight.data))
+                n_w += 1
+                if mode == "w8a8":
+                    m.register_forward_pre_hook(_pre_hook)
+                    if isinstance(m, nn.Conv1d):
+                        m.register_forward_hook(_post_hook)
+    print(
+        f"[quant] INT8 {mode}: fake-quantized {n_w} Linear/Conv1d weight tensors"
+        + (" + per-tensor dynamic activation quant" if mode == "w8a8" else ""),
+        flush=True,
+    )
+    return model

tinycast/reference/dataset_properties.json

@@ -0,0 +1 @@
+{"m4_yearly": {"domain": "Econ/Fin", "frequency": "A", "num_variates": 1}, "m4_quarterly": {"domain": "Econ/Fin", "frequency": "Q", "num_variates": 1}, "m4_monthly": {"domain": "Econ/Fin", "frequency": "M", "num_variates": 1}, "m4_weekly": {"domain": "Econ/Fin", "frequency": "W", "num_variates": 1}, "m4_daily": {"domain": "Econ/Fin", "frequency": "D", "num_variates": 1}, "m4_hourly": {"domain": "Econ/Fin", "frequency": "H", "num_variates": 1}, "electricity": {"domain": "Energy", "frequency": "W", "num_variates": 1}, "ett1": {"domain": "Energy", "frequency": "W", "num_variates": 7}, "ett2": {"domain": "Energy", "frequency": "W", "num_variates": 7}, "solar": {"domain": "Energy", "frequency": "W", "num_variates": 1}, "hospital": {"domain": "Healthcare", "frequency": "M", "num_variates": 1}, "covid_deaths": {"domain": "Healthcare", "frequency": "D", "num_variates": 1}, "us_births": {"domain": "Healthcare", "frequency": "M", "num_variates": 1}, "saugeen": {"domain": "Nature", "frequency": "M", "num_variates": 1}, "temperature_rain": {"domain": "Nature", "frequency": "D", "num_variates": 1}, "kdd_cup_2018": {"domain": "Nature", "frequency": "D", "num_variates": 1}, "jena_weather": {"domain": "Nature", "frequency": "D", "num_variates": 21}, "car_parts": {"domain": "Sales", "frequency": "M", "num_variates": 1}, "restaurant": {"domain": "Sales", "frequency": "D", "num_variates": 1}, "hierarchical_sales": {"domain": "Sales", "frequency": "W-WED", "num_variates": 1}, "loop_seattle": {"domain": "Transport", "frequency": "D", "num_variates": 1}, "sz_taxi": {"domain": "Transport", "frequency": "H", "num_variates": 1}, "m_dense": {"domain": "Transport", "frequency": "D", "num_variates": 1}, "bitbrains_fast_storage": {"domain": "Web/CloudOps", "frequency": "H", "num_variates": 2}, "bitbrains_rnd": {"domain": "Web/CloudOps", "frequency": "H", "num_variates": 2}, "bizitobs_application": {"domain": "Web/CloudOps", "frequency": "10S", "num_variates": 2}, "bizitobs_service": {"domain": "Web/CloudOps", "frequency": "10S", "num_variates": 2}, "bizitobs_l2c": {"domain": "Web/CloudOps", "frequency": "H", "num_variates": 7}}

tinycast/reference/gift_eval_tinycast.csv

@@ -0,0 +1,98 @@
+dataset,model,eval_metrics/MSE[mean],eval_metrics/MSE[0.5],eval_metrics/MAE[0.5],eval_metrics/MASE[0.5],eval_metrics/MAPE[0.5],eval_metrics/sMAPE[0.5],eval_metrics/MSIS,eval_metrics/RMSE[mean],eval_metrics/NRMSE[mean],eval_metrics/ND[0.5],eval_metrics/mean_weighted_sum_quantile_loss,domain,num_variates
+loop_seattle/5T/short,TinyCast,44.24408692791981,44.24408692791981,3.7410070822826973,0.5934177626553161,0.10333592953204616,0.0790137582765152,4.834083147652098,6.651622879261858,0.11406064670352252,0.06415001194039043,0.05139483459546802,Transport,1
+loop_seattle/5T/medium,TinyCast,98.20614629692338,98.20614629692338,5.956920582994711,0.9436984543863005,0.20160873373718577,0.132715571219461,9.629173740418173,9.909901427205186,0.17631750976206734,0.10598585775643184,0.08725979064788297,Transport,1
+loop_seattle/5T/long,TinyCast,113.45040647216489,113.45040647216489,6.401010942068713,1.0107825740241352,0.21699007191552494,0.14103020212133877,12.857768236014797,10.65131008243422,0.1883173522634331,0.1131711895617032,0.09563315974138765,Transport,1
+loop_seattle/D/short,TinyCast,18.663410946557644,18.663410946557644,2.926714380065477,0.883553479359932,0.054177088301986365,0.05405887580631441,7.380008644327176,4.32011700611889,0.07720626099359222,0.0523042949903881,0.042698347325786395,Transport,1
+loop_seattle/H/short,TinyCast,63.06633140725992,63.06633140725992,4.349558852172275,0.8845625595564358,0.11818351171152795,0.09950442329946693,6.687267308602856,7.941431319810046,0.1405714099768551,0.07699161473599359,0.06068601926596376,Transport,1
+loop_seattle/H/medium,TinyCast,72.35113097073739,72.35113097073739,4.853164616162563,1.0019077460097932,0.13148091333938458,0.10949005741083954,8.615747092001905,8.505946800370749,0.15034165879301567,0.08577914204185315,0.06962011250734562,Transport,1
+loop_seattle/H/long,TinyCast,65.8910875654401,65.8910875654401,4.646866349678578,0.9738467480194081,0.14407944582482157,0.10641190073192427,10.483142999498524,8.11733254003063,0.14506757706093826,0.08304570977590309,0.06843967546853323,Transport,1
+m_dense/D/short,TinyCast,10480.7,10480.7,53.51029947916667,0.7748143251363052,0.1382961343888268,0.11246461091218171,7.494234233556761,102.37528998737928,0.17722676315524236,0.09263423989645812,0.07786557125473008,Transport,1
+m_dense/H/short,TinyCast,51430.0996875,51430.0996875,102.29150770399306,0.8921151875559064,0.3215289556467253,0.24313662423027887,7.9984136474443925,226.78205327472455,0.4022548907535992,0.18143966271724662,0.1437088438495966,Transport,1
+m_dense/H/medium,TinyCast,42422.50555555556,42422.50555555556,98.20399739583333,0.8434814150427642,0.3026363512886733,0.23359158833821614,8.648207997321895,205.96724388978836,0.3583569939963727,0.17086255387302987,0.1376271248660661,Transport,1
+m_dense/H/long,TinyCast,45079.36987654321,45079.36987654321,103.38788966049383,0.8902011815198739,0.3177976149730835,0.24438393675250772,9.89889499669728,212.31902853146067,0.36755564448629796,0.1789797300745008,0.1456864229304492,Transport,1
+sz_taxi/15T/short,TinyCast,17.307643725030733,17.307643725030733,2.8093365743774488,0.56131924208872,1298855927179.874,0.41046200974665864,4.0379503080516095,4.160245632775874,0.3890007772564103,0.2626849968660404,0.206862466845479,Transport,1
+sz_taxi/15T/medium,TinyCast,17.176065872061965,17.176065872061965,2.8675911667000533,0.5599120350379014,11519178918165.262,0.4170552441197583,5.753307664775564,4.144401750803361,0.38570572924704843,0.26687720173847523,0.22147479893996128,Transport,1
+sz_taxi/15T/long,TinyCast,16.577307302795585,16.577307302795585,2.84828851161859,0.537775482581525,8185874683847.322,0.41623861198751333,7.003358529588487,4.0715239533613925,0.376852965628887,0.2636324837740379,0.22561013457503432,Transport,1
+sz_taxi/H/short,TinyCast,7.586486685989249,7.586486685989249,1.9103956956129808,0.5823192162139363,1.3190546361809103,0.3059674409719614,4.111199385015859,2.754357762889427,0.2565854224458191,0.17796514788380788,0.13980384104042456,Transport,1
+bitbrains_fast_storage/5T/short,TinyCast,1900821.8495638215,1900821.8495638215,180.9161150882152,0.8707491108197133,2.5999596170141994,0.6328290414944234,14.628815830083955,1378.7029591481341,4.328786309811298,0.5680318570593322,0.4382953022346899,Web/CloudOps,2
+bitbrains_fast_storage/5T/medium,TinyCast,3698363.988009589,3698363.988009589,306.51702595059857,1.0739030132087344,5.425270140752215,0.7169551569543965,25.616906164417372,1923.1130980807106,5.842948631816825,0.9312833650782235,0.7348087900238709,Web/CloudOps,2
+bitbrains_fast_storage/5T/long,TinyCast,3801015.314638277,3801015.314638277,320.72388129341397,0.9810565674831482,3.724999236613369,0.7443551005073823,22.721673451081248,1949.6192742785133,5.152261640601248,0.8475774591551065,0.7107125865949239,Web/CloudOps,2
+bitbrains_fast_storage/H/short,TinyCast,3350219.742214611,3350219.742214611,342.13923596997927,1.035867798928794,4.369458581754894,0.5601783613841338,18.596723121472916,1830.360549786465,5.217122071810725,0.9752079500509765,0.7268432335817985,Web/CloudOps,2
+bitbrains_rnd/5T/short,TinyCast,1716487.2211356303,1716487.2211356303,127.88738486392651,1.727615235380808,1.348279409098898,0.6111930074239366,54.26260705883576,1310.1477859904319,5.360746534769076,0.5232782611098349,0.4328036309064437,Web/CloudOps,2
+bitbrains_rnd/5T/medium,TinyCast,2263940.9115963113,2263940.9115963113,148.47080556987703,4.488258259100947,0.4486479054342338,0.7040026541179003,164.2567076945487,1504.6397946340219,6.330786610708255,0.6246923624743488,0.5911119097203699,Web/CloudOps,2
+bitbrains_rnd/5T/long,TinyCast,2859365.748948195,2859365.748948195,212.117391142277,3.450989893916647,3.026372416404876,0.6839630832295709,122.2642737201257,1690.9659218766637,6.477709497487906,0.8125739386041303,0.7324299246088727,Web/CloudOps,2
+bitbrains_rnd/H/short,TinyCast,1951804.6616925949,1951804.6616925949,190.79642492003018,5.873774881374325,3.0833461830771283,0.5758552192726804,193.56051832268145,1397.0700274834453,6.114262106732073,0.83501852307995,0.6768112378253903,Web/CloudOps,2
+bizitobs_application/10S/short,TinyCast,1202011.5911111112,1202011.5911111112,511.65680555555554,1.4365212207493263,0.020941043429904514,0.02126424577501085,16.39675337008677,1096.3628920713759,0.04228233445947083,0.019732557839577083,0.015573763327225789,Web/CloudOps,2
+bizitobs_application/10S/medium,TinyCast,3821721.1733333333,3821721.1733333333,1116.08125,2.6158345668367957,0.03760443687438965,0.03825534502665202,41.57801287990864,1954.9222934258366,0.07676404478273681,0.043825225864110855,0.038683657904042684,Web/CloudOps,2
+bizitobs_application/10S/long,TinyCast,6377225.102222222,6377225.102222222,1519.8002777777779,3.2712700300710433,0.04648904588487413,0.047585703531901044,74.82748279411558,2525.3168320474606,0.09739137623221442,0.0586126218985649,0.05436535009286809,Web/CloudOps,2
+bizitobs_l2c/5T/short,TinyCast,20.910473051525297,20.910473051525297,2.7368809836251393,0.2856036998160157,0.14710997590632013,0.21205160390763056,2.9522126094428813,4.572797070888375,0.15704835442944587,0.09399556728286393,0.0764864945634414,Web/CloudOps,7
+bizitobs_l2c/5T/medium,TinyCast,57.513790521775746,57.513790521775746,4.788768947678435,0.4874476313438473,0.3732310604071342,0.6381389022576076,3.4790807741267313,7.583784709614043,0.39901860010963586,0.2519596685450198,0.19883974174097674,Web/CloudOps,7
+bizitobs_l2c/5T/long,TinyCast,58.49988337926971,58.49988337926971,4.703327181899804,0.481824424146925,0.3912872161892713,0.7234287770552564,3.577103266965183,7.648521646649744,0.4294530558989807,0.2640847897769059,0.2079641779499675,Web/CloudOps,7
+bizitobs_l2c/H/short,TinyCast,74.67544022817461,74.67544022817461,5.2198379758804565,0.5344963489050996,0.4788500010538444,0.6654215010385665,3.6846044295181293,8.641495254189207,0.46579872545263284,0.28136263513605253,0.22171674144342682,Web/CloudOps,7
+bizitobs_l2c/H/medium,TinyCast,100.58119419642857,100.58119419642857,5.87127685546875,0.6149229551869348,0.5341694058527017,0.8577732631138393,5.103138751198932,10.029017608740578,0.6072722494122171,0.35551473155605917,0.28786509557482653,Web/CloudOps,7
+bizitobs_l2c/H/long,TinyCast,116.8093501984127,116.8093501984127,6.622200520833333,0.7065034860463142,0.7182541012578003,0.8494622124565973,10.697783398926884,10.807837443189674,0.660173904369807,0.4045031206601936,0.3487624586820504,Web/CloudOps,7
+bizitobs_service/10S/short,TinyCast,4698.85648354828,4698.85648354828,24.49354755704365,0.9619385844153198,0.06322367875033585,0.05459318695875703,9.685720597059765,68.54820554579295,0.050782703545633356,0.018145603586067316,0.015078402238691998,Web/CloudOps,2
+bizitobs_service/10S/medium,TinyCast,28334.413174603174,28334.413174603174,45.6440091765873,1.2868080102589707,0.09811119200691344,0.08665448264470176,15.65923175791177,168.3282898820135,0.126687833856165,0.034352755886404615,0.02937165679843956,Web/CloudOps,2
+bizitobs_service/10S/long,TinyCast,134291.53185185185,134291.53185185185,80.87890873015873,1.5712950980940312,0.12657031508349867,0.1140683257895172,27.175007100786228,366.4580901711024,0.2714838685694251,0.05991768122102279,0.05634743240727026,Web/CloudOps,2
+car_parts/M/short,TinyCast,1.3387428151669534,1.3387428151669534,0.5610735126585066,1.0046851599906685,0.6434972493761926,1.7877842143111389,15.150192550816168,1.1570405417127583,2.774464529299755,1.3453967281875052,1.1563300613220318,Sales,1
+covid_deaths/D/short,TinyCast,717588.6957393484,717588.6957393484,197.66975054824562,42.86037270685185,0.12282604843133045,0.16853826186236212,757.6436637266253,847.1060711264844,0.3187277667256405,0.07437420210868682,0.06930300504974816,Healthcare,1
+electricity/15T/short,TinyCast,165728.66631018836,165728.66631018836,61.24668899398666,1.1455489449171512,0.17541189296660817,0.1813955271685565,11.767695984551851,407.09785839548255,0.8024701351167887,0.12072929832196289,0.09967619680692709,Energy,1
+electricity/15T/medium,TinyCast,265624.58404385735,265624.58404385735,60.785754127296244,0.9553742544827218,0.15863709329530282,0.1492815988739177,8.627838373799541,515.3877996653174,0.8880650716880526,0.10473997469812892,0.08532420164947832,Energy,1
+electricity/15T/long,TinyCast,329539.0969178984,329539.0969178984,65.92105753654045,1.0000069893761259,0.16357317447017727,0.15153064711775138,9.484122201829592,574.0549598408661,0.9056420994568655,0.10399855261656309,0.0851238115030191,Energy,1
+electricity/D/short,TinyCast,1781630419.9057298,1781630419.9057298,4758.490560810811,1.520750366833196,0.45952525278329504,0.10174649267798072,12.724417587455866,42209.364125816086,0.693640034801828,0.0781978034155274,0.060897143284970534,Energy,1
+electricity/H/short,TinyCast,2078730.2604737647,2078730.2604737647,195.37475414929088,1.0434622509358347,0.18948337904655863,0.13323683262732833,10.922461867297288,1441.7802400066955,0.6806232349328453,0.09223083622832991,0.07469545370451673,Energy,1
+electricity/H/medium,TinyCast,6897401.130664415,6897401.130664415,270.0492746164133,1.1544809599512351,0.22157058136251614,0.13467502826597633,12.652023545681958,2626.290374399681,1.0251276580896305,0.10540912884379984,0.08775565669684998,Energy,1
+electricity/H/long,TinyCast,10335719.401981981,10335719.401981981,313.20569266141143,1.311547092732918,0.3145948344492027,0.14959712349266505,17.97017321294264,3214.921367931412,1.26796404037728,0.12352823291340928,0.10533341183862409,Energy,1
+electricity/W/short,TinyCast,128317784322.07567,128317784322.07567,38548.00271677928,1.7224971059223015,0.2566139873716758,0.10849626687195923,13.930672069612124,358214.71818181296,0.8173277752266295,0.08795382127192254,0.06694613568802286,Energy,1
+ett1/15T/short,TinyCast,5.361727387564523,5.361727387564523,1.1755770910353887,0.7562283281562213,0.4924726026124937,0.2589161691211519,5.162023400363836,2.315540409400044,0.4377335221089301,0.2222330037862829,0.17693710721247993,Energy,7
+ett1/15T/medium,TinyCast,9.402190212673611,9.402190212673611,1.6372881014384921,1.0455030489866155,0.7463840016001188,0.4031215413411458,9.76289238797673,3.0662991068507344,0.5844396070118025,0.31206871255055085,0.2555580983731971,Energy,7
+ett1/15T/long,TinyCast,9.244584573412698,9.244584573412698,1.6541104077535962,1.074562293727344,0.846863059927027,0.4056002807617187,12.002302210050333,3.0404908441586693,0.5795205611595534,0.31527507920730885,0.26303683899141084,Energy,7
+ett1/D/short,TinyCast,42389.02222222222,42389.02222222222,136.02098214285715,1.6996648224499773,1.2227787078373016,0.4813387916201637,11.203052479321421,205.88594469322626,0.5407662630433157,0.3572636214602873,0.2856896872972474,Energy,7
+ett1/H/short,TinyCast,103.01610834030878,103.01610834030878,5.070075225830078,0.8571495009030993,0.4806339899698893,0.26966083163306825,6.066873579858822,10.149685135032946,0.4737273357601031,0.23664115653652637,0.18454077882381037,Energy,7
+ett1/H/medium,TinyCast,133.77725074404762,133.77725074404762,6.994163876488095,1.3686390900698875,2738232925694.1333,0.4431784130278088,10.267276553788607,11.56621159861982,0.5539941179660003,0.335003870076789,0.26499877408295125,Energy,7
+ett1/H/long,TinyCast,160.18366402116402,160.18366402116402,7.428542493386243,1.41610917545092,3416827299278.7944,0.47630111452132934,17.1122354162061,12.656368516330584,0.6060860764559786,0.35573681090224185,0.29712143678186426,Energy,7
+ett1/W/short,TinyCast,2011626.0,2011626.0,1035.6922433035713,1.6248616254535604,0.8583596774509975,0.5207679952893939,14.300083010139824,1418.318017935329,0.5643825913948318,0.4121266632529299,0.33461569724082,Energy,7
+ett2/15T/short,TinyCast,8.542245556059338,8.542245556059338,1.828979274204799,0.7977637055045982,0.11675881246605886,0.13770481972467333,5.960209582023153,2.922712020719684,0.13875154087160105,0.08682815505567654,0.06987016453124961,Energy,7
+ett2/15T/medium,TinyCast,13.07299045138889,13.07299045138889,2.295947808159722,0.9498484354639674,0.144159166678213,0.17323478577628967,9.902986035407816,3.6156590618293767,0.19268501622242679,0.12235521466375968,0.10234915555751511,Energy,7
+ett2/15T/long,TinyCast,12.420850694444445,12.420850694444445,2.2458406187996034,0.9552525869265864,0.14638871073557067,0.17425280131990947,12.429491781394304,3.524322728474855,0.18781753148114935,0.11968490788741563,0.10269056593429093,Energy,7
+ett2/D/short,TinyCast,119729.95555555556,119729.95555555556,209.34871031746033,1.391076627845421,0.4334957062251984,0.14021989126054069,14.639593650144755,346.02016640010385,0.19803647066492555,0.11981579039409214,0.09908310643497366,Energy,7
+ett2/H/short,TinyCast,105.86847446986607,105.86847446986607,6.4301946730840776,0.7491574015472658,0.12146225350857989,0.11259141308920724,5.280887719007807,10.289240713962624,0.13049619529847512,0.08155275624247994,0.06474864313547667,Energy,7
+ett2/H/medium,TinyCast,262.78627232142856,262.78627232142856,9.951085844494047,1.0705651377694565,0.18129692458733945,0.17153523763020834,8.362985316753157,16.210683894315764,0.21844939017662102,0.13409728105839946,0.10807732772305327,Energy,7
+ett2/H/long,TinyCast,216.7968253968254,216.7968253968254,9.040730406746032,1.0091326427196337,0.17643990593463876,0.1707823253813244,11.704296859619719,14.724022052307086,0.20163414956203768,0.12380584466037664,0.1061356610020145,Energy,7
+ett2/W/short,TinyCast,7161788.571428572,7161788.571428572,1640.3597935267858,1.036383892254434,0.17148779119764054,0.18681137902396067,14.537499283465852,2676.151821445968,0.22448810991134696,0.13760103842854057,0.12450411098056532,Energy,7
+hierarchical_sales/D/short,TinyCast,29.19706801138125,29.19706801138125,2.3333297571794906,0.7575841824952811,0.6457101283071776,1.0286102534621744,7.07832206053394,5.403431133213529,1.6577128322798675,0.7158397294343857,0.5878786597175552,Sales,1
+hierarchical_sales/W/short,TinyCast,480.91189833818856,480.91189833818856,9.262271881103516,0.7521108764594379,0.5638248297323311,0.4720336764545764,6.837358953125831,21.929703562478643,1.0068034171692506,0.42523543257561824,0.36087737376157075,Sales,1
+hospital/M/short,TinyCast,2635.1076773685354,2635.1076773685354,18.3890812163869,0.7787874084304148,0.19600348739922435,0.1764316086352571,5.629575597124316,51.33329988777787,0.18635179891223488,0.066756635020707,0.05370179299767255,Healthcare,1
+jena_weather/10T/short,TinyCast,737.4657753051273,737.4657753051273,5.181869942801339,0.2830066840085954,0.36903646614834207,0.552891525011214,3.213335159674428,27.156321092981784,0.1686747894840554,0.0321859068738754,0.02797473539661994,Nature,21
+jena_weather/10T/medium,TinyCast,1496.4421852453102,1496.4421852453102,9.826428064123377,0.599973524454999,0.6914869268521763,0.6612252459725604,9.462120068850538,38.68387500296875,0.23740228286464188,0.060304621877954157,0.05215981565067656,Nature,21
+jena_weather/10T/long,TinyCast,1347.9896732390873,1347.9896732390873,9.352307839368386,0.6377870157231208,0.7125753689503994,0.6615759794043485,11.832725243656402,36.714978867474336,0.22466525410274407,0.05722837604681763,0.05001671925210481,Nature,21
+jena_weather/D/short,TinyCast,360.4092757936508,360.4092757936508,10.167755611359127,1.2438429713883608,0.8665065087642766,0.44703078497023807,9.15185872707675,18.98444826150212,0.1143174071761791,0.06122650720635964,0.053621856678926466,Nature,21
+jena_weather/H/short,TinyCast,1122.6431671626983,1122.6431671626983,8.337321486190248,0.5583927058292222,1.16205769443803,0.6162634532254442,4.862676662693756,33.50586765273656,0.20538883687596202,0.05110725024217434,0.042352005732441994,Nature,21
+jena_weather/H/medium,TinyCast,1559.271626984127,1559.271626984127,11.34192863343254,0.82201669463664,2.19126262226046,0.6926077222067212,8.148551897694308,39.48761358937922,0.24163171080387966,0.0694032728341155,0.05921602679031589,Nature,21
+jena_weather/H/long,TinyCast,1451.1585978835978,1451.1585978835978,12.337256117724868,1.2372013048116568,2.376308798348106,0.7116374343791336,21.033421879854583,38.094075627105035,0.22936854067949444,0.0742839505914733,0.06403979708580165,Nature,21
+kdd_cup_2018/D/short,TinyCast,2911.8811459995677,2911.8811459995677,21.00633677958142,1.1915066063457622,0.509937226768345,0.4632225368907377,9.645711885756073,53.96184898610839,1.2088027347454506,0.47056425647458555,0.37499475175037367,Nature,1
+kdd_cup_2018/H/short,TinyCast,4428.40544507181,4428.40544507181,24.484380819274286,1.0194315529770632,1.0062891958892606,0.5246448799650837,7.7420535492651315,66.54626544797094,1.392933853478974,0.5125024326316768,0.3995833092562999,Nature,1
+kdd_cup_2018/H/medium,TinyCast,5057.902963232746,5057.902963232746,25.82511224428789,1.0797880779211075,1.123762793111469,0.5598105568251877,10.435659593711573,71.11893533534332,1.4886481232339814,0.5405663722817384,0.44898669999971397,Nature,1
+kdd_cup_2018/H/long,TinyCast,4177.368478330922,4177.368478330922,24.350837097055326,1.042253138917662,0.9913156556511691,0.6197239900842068,14.638124597812372,64.63256515357348,1.516541164902919,0.5713690423671467,0.4937515620723734,Nature,1
+m4_daily/D/short,TinyCast,386967.5754799081,386967.5754799081,185.35799083511822,3.4841999666237293,0.0395577275268352,0.0319446626195895,35.48001408762702,622.0671792338092,0.09609218717022147,0.028632686859902296,0.023237907721219753,Econ/Fin,1
+m4_hourly/H/short,TinyCast,2435120.026100816,2435120.026100816,284.8097814661293,1.0222185676333535,0.10936638276166194,0.10435770348842209,11.960363456937134,1560.4871118022143,0.21304096324626956,0.038882826860023555,0.028535365688984397,Econ/Fin,1
+m4_monthly/M/short,TinyCast,1975177.037971065,1975177.037971065,595.8976114818432,1.03344105749455,0.1709086054806356,0.14037018246562394,10.415824918873035,1405.409918127471,0.2920924274906528,0.12384798031418648,0.10211410097321605,Econ/Fin,1
+m4_quarterly/Q/short,TinyCast,1998109.2978125,1998109.2978125,628.8970325927735,1.376682755781824,0.12536339755853018,0.11501970611512662,12.067188115733634,1413.54494014605,0.23660253103085468,0.10526628863590991,0.08453829758462092,Econ/Fin,1
+m4_weekly/W/short,TinyCast,347017.66530962073,347017.66530962073,292.05628615813157,2.375093592561412,0.07180270041136153,0.07393041340574759,31.16335772623592,589.0820531213124,0.1073216119717094,0.053208124828930614,0.04581422383855976,Econ/Fin,1
+m4_yearly/A/short,TinyCast,4131320.0302225705,4131320.0302225705,983.0706571491143,3.703042215816235,0.17711929984939676,0.16428084468396,30.828436436413924,2032.564889547827,0.32593119996973857,0.15763993591905975,0.12227082973056771,Econ/Fin,1
+restaurant/D/short,TinyCast,149.795676893621,149.795676893621,7.48103590324233,0.7140542511073307,0.7216503356722676,0.4078460662006675,4.798367435523933,12.23910441550447,0.5632719429215224,0.34429460565324277,0.26898689146401417,Sales,1
+saugeen/D/short,TinyCast,1027.6305208333333,1027.6305208333333,12.28921875,2.729262467797945,0.3095691426595052,0.3312169138590495,24.78162106669607,32.056676696646726,1.0383233962018728,0.3980507234083472,0.32716491124571656,Nature,1
+saugeen/M/short,TinyCast,447.1129092261905,447.1129092261905,12.983006068638392,0.7607681767579312,0.36929300853184294,0.3627051852998279,5.014860167518044,21.145044554840513,0.6348376720758496,0.3897887908339379,0.29732434590218304,Nature,1
+saugeen/W/short,TinyCast,1091.752734375,1091.752734375,16.127630615234374,1.3084226666206766,0.43306527137756345,0.4202584266662598,10.76846426338361,33.041681772800246,0.9973906393072427,0.48682594065418355,0.39494308918125093,Nature,1
+solar/10T/short,TinyCast,35.38759293382185,35.38759293382185,2.7478948774128935,1.2092061910074965,5.3764949077865465,1.5784135191980069,11.732245439375333,5.948747173466178,1.73048987304251,0.7993623058580365,0.6564243312663933,Energy,1
+solar/10T/medium,TinyCast,23.771390239645545,23.771390239645545,2.0070813147585573,0.8818089939306053,3.4706532129371834,1.4721230927952096,12.145282983871581,4.8755912707737865,1.0819130604153002,0.44537931240658873,0.3800340063104551,Energy,1
+solar/10T/long,TinyCast,21.99100210123302,21.99100210123302,1.920834464439027,0.8426367678835721,2.7411416188370343,1.47795006596549,11.225711751477654,4.689456482496987,1.0135510118891753,0.4151576461729174,0.35299910057498773,Energy,1
+solar/D/short,TinyCast,134638.40486618006,134638.40486618006,244.66284215328466,0.9544751702039223,1.096048649326148,0.4143624967032105,5.675164959046651,366.9310628254033,0.5300904365706345,0.3534544930892344,0.28338941469586704,Energy,1
+solar/H/short,TinyCast,737.9774478966577,737.9774478966577,11.11688431729915,0.8602663353314536,3.558273438428383,1.4107715080574847,5.32781661862047,27.16574033404313,1.001338234099665,0.40977205752882306,0.3184018809689805,Energy,1
+solar/H/medium,TinyCast,714.6127889294404,714.6127889294404,11.019490916305505,0.8432656365847866,4.550756358452363,1.4003983546347514,8.402250632335997,26.73224249720626,0.9629577598666192,0.39694777902546247,0.33288960205553647,Energy,1
+solar/H/long,TinyCast,851.7509783049472,851.7509783049472,13.291783252230333,1.0149629411795078,4.150918191030254,1.440622485331762,9.849022779881642,29.18477305556696,1.0118894140680637,0.46085041474919114,0.37578656900544266,Energy,1
+solar/W/short,TinyCast,1670333.9124087591,1670333.9124087591,1046.5890810333028,1.145065110150808,0.23824922185744682,0.2054090378058218,9.42922974300857,1292.4139864643832,0.26381400658172083,0.21363499745728415,0.1759532259048021,Energy,1
+temperature_rain/D/short,TinyCast,181.9258203608153,181.9258203608153,6.207237948262678,1.4557875160071272,62.43454723924855,1.457818859810271,18.557788723998502,13.487988002693927,1.5878927988640386,0.7307560206098415,0.5897024269021723,Nature,1
+us_births/D/short,TinyCast,236075.30666666667,236075.30666666667,317.48578125,0.46719668126881475,0.03038674036661784,0.029927581151326498,4.298056948804611,485.87581403756525,0.04554691491119974,0.02976171574366844,0.024416986371726027,Healthcare,1
+us_births/M/short,TinyCast,84781968.0,84781968.0,8055.583333333333,0.9120966855713007,0.024705658356348675,0.02509211003780365,9.086494946974335,9207.712419488349,0.028599091997540623,0.025020586911060013,0.021844573174920206,Healthcare,1
+us_births/W/short,TinyCast,4135229.1428571427,4135229.1428571427,1572.802734375,1.4293763597578706,0.02104850539139339,0.021356597542762756,9.32450229299691,2033.526282804612,0.027604919892820882,0.021350642898871827,0.015937398238737275,Healthcare,1

tinycast/reference/seasonal_naive.csv

@@ -0,0 +1,98 @@
+dataset,model,eval_metrics/MSE[mean],eval_metrics/MSE[0.5],eval_metrics/MAE[0.5],eval_metrics/MASE[0.5],eval_metrics/MAPE[0.5],eval_metrics/sMAPE[0.5],eval_metrics/MSIS,eval_metrics/RMSE[mean],eval_metrics/NRMSE[mean],eval_metrics/ND[0.5],eval_metrics/mean_weighted_sum_quantile_loss,domain,num_variates
+bitbrains_fast_storage/H/short,Seasonal_Naive,4198734.112364942,4198734.112364942,323.91137144521844,1.2985124569638047,4.122732886534151,0.31268171558395724,34.57780677446709,2049.0812849579547,5.840547085975178,0.9232525964178199,1.0222395520114795,Web/CloudOps,2
+solar/H/short,Seasonal_Naive,1009.7531694199001,1009.7531694199001,12.29965959124688,0.9519362458316395,3.8670855712527974,0.6200499536903793,16.15202026601857,31.77661356123242,1.171296544389828,0.4533695432534923,0.5916559631947232,Energy,1
+solar/H/medium,Seasonal_Naive,993.4109489051095,993.4109489051095,12.224457306873479,0.9349685908749716,5.243116882202785,0.568037363492515,29.963349764914504,31.518422373353484,1.1353671382460326,0.4403534842165714,0.9459874672135314,Energy,1
+solar/H/long,Seasonal_Naive,1160.9764801297647,1160.9764801297647,13.995331508515815,1.0711966477927781,5.3301362264546865,0.7115105305381197,36.28762062617156,34.073104938202576,1.1813766446766685,0.48524364916713286,1.0779764182077312,Energy,1
+m_dense/D/short,Seasonal_Naive,39929.671111111114,39929.671111111114,118.38299768518519,1.6693368812171987,0.2532523956185716,0.2557375985604745,23.291872240434824,199.82410042612756,0.3459250756939904,0.20493848013227253,0.22686565739428607,Transport,1
+ett2/H/short,Seasonal_Naive,151.78024553571427,151.78024553571427,7.9655081612723215,0.9231678277377344,0.1445715792364967,0.13716111864362443,9.954323499249957,12.319912562015782,0.1562507702523094,0.10102480674150278,0.08895289185095483,Energy,7
+ett2/H/medium,Seasonal_Naive,338.06856398809526,338.06856398809526,11.509515671502976,1.2384249730532626,0.20117125149055434,0.19754707699730284,25.271323860489556,18.3866409109466,0.24777181028131637,0.15509812516606425,0.1862050814081793,Energy,7
+ett2/H/long,Seasonal_Naive,258.848330026455,258.848330026455,10.011796254960318,1.1284016697207502,0.19021284402568,0.18827246610449735,30.708493118791996,16.08876409257265,0.2203232414204263,0.1371038440641976,0.20790633225768584,Energy,7
+ett2/D/short,Seasonal_Naive,122878.94603174603,122878.94603174603,211.56051587301587,1.3901143157307532,0.4713712661985367,0.14168287004743305,32.70861808020462,350.5409334610525,0.20062382493032205,0.12108166507005774,0.15331100213050436,Energy,7
+electricity/15T/short,Seasonal_Naive,366722.87168918917,366722.87168918917,94.21436127533784,1.7170601412372184,0.30235384997180187,0.23004003312303262,26.97516311288429,605.5764788110492,1.193710612408421,0.18571507783204827,0.16489261500071847,Energy,1
+electricity/15T/medium,Seasonal_Naive,373592.9609594595,373592.9609594595,70.78214646677928,1.1507882041044137,0.21527551573127818,0.162019429539667,12.499327683031675,611.2225134592635,1.0531979612070823,0.12196476848793535,0.11275485280084273,Energy,1
+electricity/15T/long,Seasonal_Naive,432425.0750750751,432425.0750750751,73.83208042417418,1.1635317075319347,0.19999027586553747,0.1567721679648986,14.199582505532762,657.5903550654275,1.0374294291948993,0.11647916132088339,0.11255332426055248,Energy,1
+bitbrains_rnd/H/short,Seasonal_Naive,3710112.576957504,3710112.576957504,254.47180959890883,6.0373618687533925,4.792930625938438,0.36119250186151963,222.24992066836998,1926.1652517262125,8.429841528920612,1.1136931405932016,1.2432170953390527,Web/CloudOps,2
+loop_seattle/H/short,Seasonal_Naive,125.56935646488512,125.56935646488512,6.351615330169464,1.2928412613913995,0.1710389719335216,0.14238265652237242,14.224911524098493,11.205773354163698,0.1983535851600468,0.11243005123144872,0.10423508438727377,Transport,1
+loop_seattle/H/medium,Seasonal_Naive,153.75436661506708,153.75436661506708,7.21920260497291,1.4805126192799751,0.20086050437084785,0.16072294158463138,25.49530583293511,12.399772845301122,0.21916459102759323,0.1275985944423001,0.16208090743299983,Transport,1
+loop_seattle/H/long,Seasonal_Naive,167.0609584623323,167.0609584623323,7.511452824002408,1.5460268753677606,0.23476947145360338,0.16369716459260514,30.628061299733826,12.925206321847721,0.23099074580000042,0.13423972094936726,0.18709450197084374,Transport,1
+solar/W/short,Seasonal_Naive,2813150.8321167883,2813150.8321167883,1341.8134124087592,1.4703506784640206,0.3086572076282362,0.2534797557079009,11.583228430599936,1677.245012547895,0.3423676402558515,0.2738976644635694,0.20974762813186765,Energy,1
+bizitobs_application/10S/short,Seasonal_Naive,3938171.448888889,3938171.448888889,1054.6502083333332,2.2423302386755415,0.0340565554300944,0.03481890360514323,26.67150527524178,1984.4826653031992,0.07653356419683467,0.04067364297805646,0.03483868247005456,Web/CloudOps,2
+bizitobs_application/10S/medium,Seasonal_Naive,5143417.173333333,5143417.173333333,1276.9247916666666,2.6914183385868085,0.03906738917032877,0.03992526690165202,28.10250665325578,2267.9103098079813,0.08905416300729038,0.05014107835453231,0.04268912394422428,Web/CloudOps,2
+bizitobs_application/10S/long,Seasonal_Naive,5953087.1466666665,5953087.1466666665,1470.5443055555556,3.2063450561622804,0.04643516540527344,0.04741138034396701,21.30987046900455,2439.894904840507,0.09409699394104339,0.05671301593170149,0.04573090228155046,Web/CloudOps,2
+bizitobs_service/10S/short,Seasonal_Naive,73535.24306878306,73535.24306878306,55.138688409391534,1.225305042620374,0.08240041742879878,0.07553190362516535,16.350613928029045,271.1738244535838,0.2008942442703866,0.04084850431410673,0.03998233993351736,Web/CloudOps,2
+bizitobs_service/10S/medium,Seasonal_Naive,96480.73142857142,96480.73142857142,63.760550595238094,1.3205790727650968,0.0796314687577505,0.07705034528459821,17.448776648119132,310.6134759288003,0.23377502162466005,0.04798769290234763,0.04755831292581585,Web/CloudOps,2
+bizitobs_service/10S/long,Seasonal_Naive,130947.25079365079,130947.25079365079,75.32497354497355,1.367193469742303,0.08491984049479166,0.08144445348668981,17.936180702599792,361.8663438255218,0.26808215608217806,0.055803148480992645,0.05345299584740217,Web/CloudOps,2
+bizitobs_l2c/5T/short,Seasonal_Naive,174.3096912202381,174.3096912202381,9.685235305059523,0.9860210805885202,0.42617953698061745,0.5068802606491816,7.245192912077175,13.202639555037399,0.45343208257188783,0.3326301832497065,0.26206838623738704,Web/CloudOps,7
+bizitobs_l2c/5T/medium,Seasonal_Naive,294.66615646258504,294.66615646258504,12.864580676020408,1.2435997989335994,0.9360730119589105,1.1668089007914848,7.637297246345627,17.16584272509174,0.9031757619892758,0.6768661254104057,0.5203917750796179,Web/CloudOps,7
+bizitobs_l2c/5T/long,Seasonal_Naive,416.33936507936505,416.33936507936505,15.353609871031747,1.4542830442631411,1.0210265852224123,1.298652753589897,8.166517613570452,20.404395729336485,1.1456763155758307,0.862082240570442,0.6484921267253538,Web/CloudOps,7
+ett2/W/short,Seasonal_Naive,4688738.857142857,4688738.857142857,1323.111607142857,0.7785209533197451,0.12217171703066144,0.1269862311226981,16.565488704288857,2165.3495923621335,0.1816396339666693,0.11098877930205708,0.13367758870767996,Energy,7
+loop_seattle/5T/short,Seasonal_Naive,76.27992181453173,76.27992181453173,4.806023281794214,0.7623397118337274,0.13014939133965933,0.10246611478035911,9.641956549599044,8.733837748351622,0.14976603568936095,0.08241268902447142,0.08083202568463041,Transport,1
+loop_seattle/5T/medium,Seasonal_Naive,149.91421294504644,149.91421294504644,7.272513948013416,1.1532851467900647,0.22437167928437823,0.16228546394529234,12.161708217874148,12.243945971174751,0.217844961125775,0.12939296873911593,0.11727937998585615,Transport,1
+loop_seattle/5T/long,Seasonal_Naive,172.4441060371517,172.4441060371517,7.891544207229676,1.2506857542807588,0.23036973349395495,0.1761461930635284,12.853493858763652,13.131797517367975,0.2321728668857043,0.13952411620149754,0.12716656087996273,Transport,1
+loop_seattle/D/short,Seasonal_Naive,58.65786974329205,58.65786974329205,5.940060831075852,1.7323957056549062,0.11095823557630288,0.10706747427075271,21.844122635807963,7.658842585096788,0.13687375626545378,0.10615682844516516,0.1032547596878987,Transport,1
+bitbrains_rnd/5T/short,Seasonal_Naive,3407833.9580161185,3407833.9580161185,210.5518366560826,1.9708126376716957,3.046095137251105,0.38408369415249266,74.37164472655921,1846.0319493486884,7.553429809324837,0.8615173317922609,1.1015904440824371,Web/CloudOps,2
+bitbrains_rnd/5T/medium,Seasonal_Naive,3267017.897300195,3267017.897300195,204.8128727866788,4.542392314855541,2.750306364851926,0.3918429569214854,178.58186300111112,1807.489390646649,7.605029622998441,0.8617522032352579,1.169291300089368,Web/CloudOps,2
+bitbrains_rnd/5T/long,Seasonal_Naive,3851065.095876048,3851065.095876048,237.4491928177016,3.501257904408163,3.179405138911208,0.40348581728614835,137.13909859136817,1962.413079826989,7.517562382830161,0.909614361068727,1.175220506770106,Web/CloudOps,2
+electricity/W/short,Seasonal_Naive,317380739662.4144,317380739662.4144,56604.72342342342,2.0896995064573947,0.285636731125347,0.1196364761812733,15.938528356933686,563365.5471027798,1.2854142672489681,0.12915329923232946,0.0993032024444414,Energy,1
+solar/D/short,Seasonal_Naive,181869.82773722627,181869.82773722627,295.1889902676399,1.155861190610263,1.1535581565541362,0.49778203291324513,22.3811319807538,426.46198861941525,0.6160923187357285,0.4264475482750424,0.5590651164917229,Energy,1
+ett1/H/short,Seasonal_Naive,141.21642485119048,141.21642485119048,5.822230747767857,0.9773176243434534,0.5700293404715402,0.28737351553780693,9.542335004679739,11.883451722929264,0.5546493091237623,0.271747328730894,0.24036844107833774,Energy,7
+ett1/H/medium,Seasonal_Naive,204.51871279761906,204.51871279761906,8.163152785528274,1.5678007461285395,2345799664153.64,0.45697086879185267,22.421278808802057,14.301003908733787,0.6849841868181539,0.3909956677413786,0.4349118298516912,Energy,7
+ett1/H/long,Seasonal_Naive,199.49484126984126,199.49484126984126,7.749353091931217,1.4787012870437326,2646635889605.55,0.47721551158440806,25.35082572229849,14.124264273576916,0.6763804250290198,0.37109973563904386,0.47106248989542887,Energy,7
+temperature_rain/D/short,Seasonal_Naive,310.64911445557556,310.64911445557556,7.890313322375261,2.0115357653222166,97.02872693676676,1.3339967533230714,47.47823470729249,17.625240833973745,2.0749568489172328,0.9288984940737532,1.2679455200160903,Nature,1
+saugeen/W/short,Seasonal_Naive,1800.4892578125,1800.4892578125,24.552409362792968,1.990658004828632,0.824161148071289,0.557866096496582,23.291068065474015,42.43217243805106,1.2808504084686672,0.7411348925661494,0.7340352210434381,Nature,1
+covid_deaths/D/short,Seasonal_Naive,4435194.482205514,4435194.482205514,353.7093984962406,46.91239825526407,0.132724402667158,0.17781104711702989,1472.7784117419058,2105.990142950701,0.792389040211866,0.13308488253209907,0.12672327831223676,Healthcare,1
+us_births/D/short,Seasonal_Naive,2855120.2133333334,2855120.2133333334,1266.88,1.8648391912491094,0.12472813924153646,0.1233361307779948,22.730582398368462,1689.7100974230264,0.15839661042681866,0.11875971986174946,0.11952686561898423,Healthcare,1
+m4_weekly/W/short,Seasonal_Naive,453525.1459181487,453525.1459181487,347.99148275123207,2.777295047362158,0.08937289522218837,0.09161286714732429,26.631225199626535,673.442756229621,0.1226908336142798,0.06339865521526268,0.06087039452311706,Econ/Fin,1
+car_parts/M/short,Seasonal_Naive,2.5046831406935035,2.5046831406935035,0.6672313006509898,1.2014638390969912,0.8541762945076465,1.6763314144736843,20.368070639282948,1.5826190763078472,3.7949581992256025,1.5999522140809175,1.7217438941460104,Sales,1
+sz_taxi/H/short,Seasonal_Naive,12.029984433426817,12.029984433426817,2.4300792726696048,0.7381672994945998,1.552363729884482,0.38466275859082866,8.057108467274903,3.468426795166191,0.3231053592422672,0.22637687999566908,0.21382494112013678,Transport,1
+ett1/15T/short,Seasonal_Naive,8.776201520647321,8.776201520647321,1.4945350283668155,0.9341549587802876,0.6328330752819759,0.30603092738560267,8.439802226867357,2.962465446321243,0.5600292824430536,0.2825293306160358,0.24136394938567346,Energy,7
+ett1/15T/medium,Seasonal_Naive,12.883658234126985,12.883658234126985,1.8389095052083333,1.188305978388322,0.9080556087099148,0.42800251405065676,12.40964763458674,3.5893813163450585,0.6841396278696877,0.3504979699009272,0.32155116949786394,Energy,7
+ett1/15T/long,Seasonal_Naive,13.023148561507936,13.023148561507936,1.8557530381944445,1.190885705867336,0.9840622608053838,0.4204419926758006,13.893107103740524,3.608759975602137,0.6878332194845934,0.35370836394199906,0.3401793468576481,Energy,7
+saugeen/M/short,Seasonal_Naive,713.7325613839286,713.7325613839286,16.662892659505207,0.9763741730697157,0.4971456073579334,0.4422340847197033,10.586458554994822,26.71577364374703,0.8020876713555654,0.500270025848136,0.4450846286544009,Nature,1
+us_births/M/short,Seasonal_Naive,74172117.33333333,74172117.33333333,6704.75,0.7605310792868888,0.020606640726327896,0.020953829089800518,5.646371868808973,8612.323573422756,0.02674981830097076,0.020824907787592,0.016825596814792485,Healthcare,1
+m4_quarterly/Q/short,Seasonal_Naive,2487884.428,2487884.428,708.8467662760416,1.602247174616002,0.14192582162221273,0.12521366802851358,12.540135359281015,1577.302896719587,0.26401272904907985,0.11864846608179633,0.09805397548466407,Econ/Fin,1
+ett1/W/short,Seasonal_Naive,1571455.142857143,1571455.142857143,970.0256696428571,1.7689207877683926,0.6150428227015904,0.6251754760742188,12.799615221235317,1253.5769393448265,0.4988281842249676,0.38599636628003803,0.3118251468740881,Energy,7
+saugeen/D/short,Seasonal_Naive,994.7777083333333,994.7777083333333,15.3725,3.413049305768806,0.47135218302408854,0.4242374928792318,58.71112805300772,31.540096834558597,1.0215912513857213,0.49791893773514423,0.5850141736335629,Nature,1
+electricity/H/short,Seasonal_Naive,2887718.36009009,2887718.36009009,247.69792300112613,1.3577726051465433,0.3631860614314555,0.16452154722835458,18.287059022037134,1699.3287969342748,0.8022045515456071,0.11693110926995137,0.10566499518474065,Energy,1
+electricity/H/medium,Seasonal_Naive,8353587.978378379,8353587.978378379,308.2015061936937,1.3924537851702354,0.3866618745283321,0.15667597765115268,20.69150990156008,2890.2574242406813,1.128162669425473,0.1203011991361897,0.12738701179892217,Energy,1
+electricity/H/long,Seasonal_Naive,13526606.943327328,13526606.943327328,357.2064234234234,1.5240786163496851,0.36051114996741657,0.16771684918985819,24.628137038027603,3677.8535782882013,1.4505443840804357,0.14088210974822626,0.15341839756227935,Energy,1
+ett1/D/short,Seasonal_Naive,57976.62857142857,57976.62857142857,154.97894345238095,1.7783697877928102,1.1623038155691965,0.5164825923859127,23.47582377746543,240.7833643992636,0.6324254934604606,0.4070573356817528,0.40843357791503654,Energy,7
+bizitobs_l2c/H/short,Seasonal_Naive,281.8430679563492,281.8430679563492,12.53165302579365,1.2140641267600039,1.3605904339028776,1.138373051002047,7.486930567002142,16.788182389894065,0.9049260260934667,0.675488192208351,0.5211675771895117,Web/CloudOps,7
+bizitobs_l2c/H/medium,Seasonal_Naive,456.3732886904762,456.3732886904762,15.667392113095238,1.5102861226255864,1.6912910179529201,1.4024095456148358,18.533653530822832,21.362895138311103,1.293555748999092,0.9486843898499615,0.9042051354742671,Web/CloudOps,7
+bizitobs_l2c/H/long,Seasonal_Naive,309.27222222222224,309.27222222222224,13.635487971230159,1.4260541525613812,2.4383105011700468,0.9168538411458333,22.036198194504,17.586137217201003,1.0742120179443015,0.8328949597245134,0.9410651242377539,Web/CloudOps,7
+hospital/M/short,Seasonal_Naive,3464.0771403737504,3464.0771403737504,20.005975662755322,0.9205278266364826,0.23307140471364352,0.21025354682958836,6.599875528051222,58.85641120875236,0.21366243998041978,0.07262633732682543,0.06248817651596496,Healthcare,1
+m4_daily/D/short,Seasonal_Naive,497624.29605596676,497624.29605596676,180.83018393659805,3.278424296610481,0.04217648847004251,0.03045251709590828,32.19152086932198,705.4249046184624,0.10896865245350737,0.02793326594720746,0.024356147648337902,Econ/Fin,1
+bitbrains_fast_storage/5T/short,Seasonal_Naive,5404398.959598898,5404398.959598898,346.43736615760264,1.1360241737534567,5.932190463200192,0.4761820977820179,31.06038796757978,2324.736320445589,7.299097101583847,1.087727650212227,1.210386425305063,Web/CloudOps,2
+bitbrains_fast_storage/5T/medium,Seasonal_Naive,5191990.375993042,5191990.375993042,332.75293038959035,1.2202713595882653,5.768419487236171,0.4516151765437165,36.13464652226377,2278.593947150971,6.92299777327362,1.0109953109538277,1.1979128978088514,Web/CloudOps,2
+bitbrains_fast_storage/5T/long,Seasonal_Naive,6473012.871295428,6473012.871295428,404.5292260549034,1.1366422318753115,6.462525817893773,0.5033018991430218,32.16149564789198,2544.2116404291974,6.723591850916995,1.0690499817466734,1.1773077032683998,Web/CloudOps,2
+ett2/15T/short,Seasonal_Naive,14.617721121651785,14.617721121651785,2.534710984002976,1.067314800011479,0.15340707960692476,0.17031889997991706,8.528224043296179,3.8233128464267456,0.181506262086668,0.12033174753313121,0.09638438775638664,Energy,7
+ett2/15T/medium,Seasonal_Naive,14.948670634920635,14.948670634920635,2.4787872023809525,1.0512391501712754,0.1650384327009311,0.1899925877490716,13.312453415228259,3.8663510749698657,0.20604484738813625,0.1320990569451144,0.12412877798161984,Energy,7
+ett2/15T/long,Seasonal_Naive,13.674988839285714,13.674988839285714,2.362206101190476,1.0126577751121104,0.1609817984920091,0.1894470412273871,15.633896791936913,3.697970908388236,0.19707156352079597,0.12588623903557683,0.13282444765695306,Energy,7
+jena_weather/10T/short,Seasonal_Naive,1986.203373015873,1986.203373015873,10.556470114087302,0.7428874675800381,0.8774809708937492,0.39362146904346257,20.65580527060839,44.566841631597285,0.2768159431081858,0.06556891005829443,0.15520092375681044,Nature,21
+jena_weather/10T/medium,Seasonal_Naive,2572.8219336219336,2572.8219336219336,12.447531114718615,0.7160100391723763,0.8990536291309329,0.4023956803535614,27.512189615220795,50.72299215959104,0.311286135757249,0.07639028565640756,0.21183609008512827,Nature,21
+jena_weather/10T/long,Seasonal_Naive,2044.5376984126983,2044.5376984126983,11.441627397486773,0.7614923703210493,0.7718160693153647,0.4043349656668781,32.10701219708694,45.21656442513847,0.2766879110680792,0.0700132799578619,0.2371949131202996,Nature,21
+jena_weather/D/short,Seasonal_Naive,633.5864087301587,633.5864087301587,13.136656746031745,1.5734140297468562,1.7707135350571066,0.4854136849221913,31.00640730511845,25.17114238031637,0.15157141745411598,0.07910414448099358,0.2105908566035542,Nature,21
+us_births/W/short,Seasonal_Naive,5288246.857142857,5288246.857142857,1720.3214285714287,1.5634204337929731,0.023174324205943515,0.023229679891041348,13.279190377688378,2299.6188504060533,0.031217100406456557,0.023353194707727513,0.01929679613291714,Healthcare,1
+m_dense/H/short,Seasonal_Naive,145691.3111111111,145691.3111111111,180.18139756944444,1.4875444172240992,0.5399732053067908,0.3908195287297072,14.354127446705878,381.69531187992226,0.6770323708995337,0.31959690096169935,0.27479786933969136,Transport,1
+m_dense/H/medium,Seasonal_Naive,158402.70222222223,158402.70222222223,189.1006423611111,1.569946511898904,0.5428334697930458,0.397995368109809,22.89829990230752,397.99836962256796,0.6924668813918432,0.32901122738058514,0.3773835994986822,Transport,1
+m_dense/H/long,Seasonal_Naive,137584.05530864198,137584.05530864198,175.8238888888889,1.4779178744488217,0.4978060829089136,0.38833718102796383,27.64819460133164,370.92324719359664,0.6421229733186591,0.3043771431636812,0.4189507904607682,Transport,1
+kdd_cup_2018/D/short,Seasonal_Naive,3183.23772462431,3183.23772462431,23.884613481510574,1.4970343738270926,0.5893064466306873,0.5721879846611051,24.580612052672397,56.42018898075679,1.263872161836989,0.5350407118596068,0.674506129145155,Nature,1
+electricity/D/short,Seasonal_Naive,4108036968.189694,4108036968.189694,6964.321117117117,1.987041399842847,0.6052061423957089,0.13582226488305205,24.595303547998157,64093.9698270414,1.0532768308357283,0.11444692995228782,0.10405987098536745,Energy,1
+restaurant/D/short,Seasonal_Naive,269.8283833006444,269.8283833006444,10.66129634818343,1.0060757450046092,0.9434227416570351,0.5561225187815214,20.74904381007386,16.426453765211907,0.7559834619860213,0.49065755991884735,0.6770164746085788,Sales,1
+jena_weather/H/short,Seasonal_Naive,1941.9557226399331,1941.9557226399331,11.035693889672096,0.7229102185557323,1.1349936220434893,0.40077710759656054,17.382581140637207,44.06762669624872,0.2701317147149199,0.06764809310095782,0.15420788787522166,Nature,21
+jena_weather/H/medium,Seasonal_Naive,1951.8111111111111,1951.8111111111111,12.670400080605159,0.8886133410507664,1.7017065286708326,0.45474790719102887,42.286346185217376,44.1793063674738,0.27034101099927343,0.077532425227887,0.3428055217231077,Nature,21
+jena_weather/H/long,Seasonal_Naive,2714.1007936507935,2714.1007936507935,15.67983630952381,1.2677178473920059,1.8661278391921836,0.5020780815368567,51.127769997760254,52.097032484113655,0.31368185519406616,0.09440998667650671,0.41914340130808575,Nature,21
+m4_monthly/M/short,Seasonal_Naive,2652970.8577407408,2652970.8577407408,700.2370131655092,1.259717038974429,0.19222692431343927,0.15988281532570167,10.588031340884587,1628.794295711015,0.33851937015163663,0.14553329004027185,0.12192063664829357,Econ/Fin,1
+hierarchical_sales/D/short,Seasonal_Naive,58.96940884663084,58.96940884663084,3.4495245969408845,1.1348033996861053,1.219942090035255,1.1912773542022284,28.8672586949405,7.679154175209066,2.3558794594517027,1.058275945161004,1.7364572065613715,Sales,1
+m4_hourly/H/short,Seasonal_Naive,3614355.993558776,3614355.993558776,353.8562298711755,1.1932101877276544,0.1561203125786282,0.1391227341312525,9.229226853352637,1901.1459685039379,0.25954838815818215,0.04830918594592099,0.03757255147212195,Econ/Fin,1
+m4_yearly/A/short,Seasonal_Naive,4070174.893125562,4070174.893125562,1007.6444123429384,3.965954931783283,0.17520083696448324,0.16353434447586868,52.037766411775884,2017.4674453694568,0.323510256896443,0.1615804524853844,0.13714565740983498,Econ/Fin,1
+hierarchical_sales/W/short,Seasonal_Naive,1045.4721927966102,1045.4721927966102,13.569120762711865,1.0250133777288337,0.9503837463030324,0.5798107884238987,15.297190661198302,32.33376242871544,1.4844588487218926,0.6229649713667368,0.8322267526416594,Sales,1
+kdd_cup_2018/H/short,Seasonal_Naive,5615.976023835748,5615.976023835748,32.23957254610716,1.340425278558367,1.4218929148819215,0.6653979848821596,11.487358350395635,74.9398160114885,1.5686260624453057,0.6748326381021144,0.547536580422314,Nature,1
+kdd_cup_2018/H/medium,Seasonal_Naive,5785.5976861948375,5785.5976861948375,31.3213270934715,1.4289997072062277,1.6378374272295781,0.6550327560864638,21.848163370875977,76.06311646386071,1.592138770600474,0.6556120959870002,0.7587892026846513,Nature,1
+kdd_cup_2018/H/long,Seasonal_Naive,4863.8870949314805,4863.8870949314805,29.603438898808303,1.3355336658089667,1.3504101339311876,0.8098963463700346,25.694140506460055,69.74157364822995,1.6364191009705393,0.694616286015704,0.9362833347539716,Nature,1
+sz_taxi/15T/short,Seasonal_Naive,31.23822759271978,31.23822759271978,3.8183243114578564,0.7644167735543712,1312692316403.7466,0.538321787329966,7.055930253561324,5.58911688844667,0.5226063327326282,0.3570296534180041,0.3087068505119876,Transport,1
+sz_taxi/15T/medium,Seasonal_Naive,28.930445379273504,28.930445379273504,3.6711446647970085,0.7134840540400068,18917890105834.12,0.5172677325387286,10.816848306969383,5.378702945810774,0.5005780877467839,0.34166128798341444,0.379172158612487,Transport,1
+sz_taxi/15T/long,Seasonal_Naive,28.48211582977208,28.48211582977208,3.6789685719373217,0.6909431344941248,3284113398767.079,0.5217545990251068,12.685376303466118,5.336863857151696,0.4939706119705816,0.3405187776085254,0.4279704063043717,Transport,1
+solar/10T/short,Seasonal_Naive,37.917036857512166,37.917036857512166,2.5271684706936206,1.1057028063509833,4.40491207343912,0.925039670208932,18.785745549933484,6.157681126650857,1.7912687729072838,0.7351530344494263,0.8595386998005952,Energy,1
+solar/10T/medium,Seasonal_Naive,29.228987641008626,29.228987641008626,2.118083017100752,0.9270005404761702,3.219568147534267,0.6587355148950821,15.807425762449464,5.406383970918883,1.1996980737201242,0.4700110331163171,0.6550635536405177,Energy,1
+solar/10T/long,Seasonal_Naive,26.90307906275345,26.90307906275345,1.995840144718167,0.8709317964102903,2.310040346896705,0.6597688060895561,18.202191205836492,5.18681781661487,1.1210476934837867,0.4313689182665159,0.6738494837655387,Energy,1

tinycast/scale.py

@@ -0,0 +1,52 @@
+"""Seasonal discretization scale factor.
+
+Maps a pandas frequency string to the model's seasonal scale factor
+``s = base_seasonality / (samples per natural period)``, i.e. how many
+context samples fall in one canonical seasonal cycle at that sampling rate.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+# Cycles per canonical day: the unit every scale factor is expressed against.
+# ``tinycast.losses`` reads this so the seasonal lag the committing term folds
+# at and the scale factor the model is conditioned on cannot drift apart.
+BASE_SEASONALITY = 24.0
+
+
+def seasonal_scale_factor(freq: str, domain: Optional[str] = None) -> float:
+    """Seasonal scale factor for a pandas frequency string."""
+    has_weekly = domain in ["Transport", "Healthcare", "Sales"]
+
+    if freq == "4S":
+        factor = BASE_SEASONALITY / (3600.0 / 4)
+    elif freq == "10S":
+        factor = BASE_SEASONALITY / 360
+    elif freq == "T":
+        factor = BASE_SEASONALITY / (24.0 * 60)
+    elif freq[-1] == "T":
+        n_min = int(freq[:-1])
+        factor = BASE_SEASONALITY / (24 * 60 / n_min)
+    elif freq == "H":
+        factor = BASE_SEASONALITY / 24
+    elif freq == "6H":
+        factor = BASE_SEASONALITY / 4
+    elif freq == "D":
+        factor = BASE_SEASONALITY / 7 if has_weekly else BASE_SEASONALITY / 365
+    elif freq[-1] == "D" and "WED" not in freq:
+        n = int(freq[:-1])
+        factor = BASE_SEASONALITY / 7 if has_weekly else BASE_SEASONALITY / 365
+        factor *= n
+    elif freq == "W" or "W-" in freq:
+        factor = BASE_SEASONALITY / (365.0 / 7)
+    elif freq == "M" or "M-" in freq or freq == "MS":
+        factor = BASE_SEASONALITY / 12
+    elif "Q" in freq:
+        factor = BASE_SEASONALITY / 4.0
+    elif "A" in freq:
+        factor = BASE_SEASONALITY / 4.0
+    else:
+        raise NotImplementedError(
+            f"{freq} not implemented. Add {freq} option to seasonal_scale_factor."
+        )
+    return factor

tinycast/synth.py

@@ -0,0 +1,338 @@
+"""Synthetic series generators: Gaussian process, spike trains, TSI.
+
+These are the three families in TinyCast's synthetic pretraining shards. They
+follow the recipe published by Reverso (arXiv 2602.17634, Appendix A),
+implemented from its Algorithms 1 to 3 and Table 8:
+
+* :func:`generate_gp` is Algorithm 1: a Gaussian process over a 38-entry kernel
+  bank (Constant; Linear with sigma in {0, 1, 10}; RBF with l in {0.1, 1, 10};
+  RationalQuadratic with alpha in {0.1, 1, 10}; Matern with nu in
+  {0.5, 1.5, 2.5} crossed with l in {0.1, 1, 10}; Periodic over a 19-period set
+  normalized by series length), with J ~ U{1,5} kernels composed by random sum
+  or product, and a mean function that is a linear trend with probability 1/2.
+* :func:`generate_spikes` is Algorithm 2: trapezoid pulse trains (a quarter of
+  the pulse ramping up, half flat, the remainder ramping down) tiled at a fixed
+  period over a baseline, in an upward or downward variant, plus white noise.
+* :func:`generate_tsi` is Algorithm 3, the trend-seasonal-impulse process: an
+  optional trend, K ~ U{1,3} seasonal components (sine, sawtooth or square),
+  noise, sparse outliers and level shifts.
+
+All three return float32 with no normalization applied. The corpus builder
+z-normalizes per series on write, which is why the absolute scale of any
+parameter below does not matter and the shape does.
+
+DOCUMENTED ASSUMPTIONS. The source paper leaves the following symbolic, and
+neither Kairos (arXiv 2509.25826) nor Chronos-2 (arXiv 2510.15821), which the
+respective algorithms defer to, publishes them. We record the choices we made
+rather than presenting the families as an exact replication:
+
+  A1  Algorithm 1 trend units. The slope m ~ U[-0.01, 0.01] is applied per
+      index step (mu_t = m*t + c with t = 0..L-1), not per unit of the [0,1]
+      kernel grid. On the [0,1] grid the sampled trend would be at most 1% of
+      the GP's unit scale, which makes the probability-1/2 branch pointless.
+      Index units give trend-dominated series about half the time, which is a
+      realistic class, and the per-series z-normalization on write removes the
+      magnitude difference.
+  A2  Algorithm 2 numeric ranges: baseline U[-1, 1], period U{16, L//8}, pulse
+      width U{4, p}, amplitude U[0.5, 3], noise sigma U[0.01, 0.3]. Under
+      z-normalization the levels are immaterial; shape, sparsity and period are
+      what the model sees.
+  A3  Algorithm 3 probabilities and ranges: P_trend = 0.5, P_seasonal = 0.8,
+      P_noise = 0.8, P_outlier = 0.2, P_shift = 0.2; trend types linear,
+      exponential, quadratic and piecewise linear; periods taken from the
+      Algorithm 1 period set in index steps, filtered to at most L/2; amplitude
+      U[0.5, 2]; noise sigma U[0.05, 0.5], normal or Laplace; U{1, L//100}
+      outliers at +/- U[3, 8] standard deviations; U{1,3} level shifts of
+      magnitude +/- U[0.5, 3].
+  A4  The family mix. The paper gives a total series count but not the
+      proportions, and describes spikes and TSI as additions to a GP majority.
+      :mod:`tinycast.corpus` uses 70/15/15.
+
+DEVICE. :func:`generate_gp` draws from numpy on the CPU path and from torch on
+the CUDA path, so the same seed produces different series on the two branches.
+The published shards came from the CUDA branch, and :mod:`tinycast.corpus`
+refuses anything else for that reason. The CPU branch is kept here because it
+is useful at small scale and because spikes and TSI are numpy either way.
+"""
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+# Algorithm 1 / Table 8 period set. Table 8 specifies the periodic kernel's p
+# as a fraction of the series length, so these enter the bank divided by L.
+PERIODS = (24, 48, 96, 168, 336, 672, 7, 14, 30, 60,
+           365, 730, 4, 26, 52, 6, 12, 40, 10)
+
+# Jitter added to the diagonal before factorization, and the larger retry value
+# the CPU path falls back to. The CUDA path does not retry: see generate_gp.
+GP_JITTER = 1e-6
+GP_JITTER_RETRY = 1e-4
+
+
+def kernel_bank(length: int) -> list[tuple[str, tuple]]:
+    """The 38 Table-8 kernels as (tag, params) pairs, for a series length.
+
+    Only the periodic entries depend on ``length``, and they depend on it
+    because Table 8 normalizes the period by the series length.
+    """
+    bank: list[tuple[str, tuple]] = [("const", (1.0,))]
+    bank += [("linear", (s,)) for s in (0.0, 1.0, 10.0)]
+    bank += [("rbf", (l,)) for l in (0.1, 1.0, 10.0)]
+    bank += [("rq", (a,)) for a in (0.1, 1.0, 10.0)]
+    bank += [("matern", (nu, l)) for nu in (0.5, 1.5, 2.5) for l in (0.1, 1.0, 10.0)]
+    bank += [("periodic", (p / length,)) for p in PERIODS]
+    return bank
+
+
+def _matern(d: np.ndarray, nu: float, l: float) -> np.ndarray:
+    """Matern closed forms for nu in {0.5, 1.5, 2.5}, so no Bessel call."""
+    if nu == 0.5:
+        return np.exp(-d / l)
+    if nu == 1.5:
+        a = math.sqrt(3.0) * d / l
+        return (1.0 + a) * np.exp(-a)
+    if nu == 2.5:
+        a = math.sqrt(5.0) * d / l
+        return (1.0 + a + a * a / 3.0) * np.exp(-a)
+    raise ValueError(f"unsupported Matern nu={nu}")
+
+
+def _dense_kernel(tag: str, params: tuple, t: np.ndarray) -> np.ndarray:
+    d = np.abs(t[:, None] - t[None, :])
+    if tag == "const":
+        return np.full_like(d, params[0])
+    if tag == "linear":            # sigma^2 + x.x'
+        return params[0] ** 2 + np.outer(t, t)
+    if tag == "rbf":
+        return np.exp(-(d ** 2) / (2.0 * params[0] ** 2))
+    if tag == "rq":                # Table 8's form carries no lengthscale (l=1)
+        return (1.0 + d ** 2 / (2.0 * params[0])) ** (-params[0])
+    if tag == "matern":
+        return _matern(d, *params)
+    if tag == "periodic":          # Table 8: exp(-2 sin^2(pi d / p)), l=1
+        return np.exp(-2.0 * np.sin(np.pi * d / params[0]) ** 2)
+    raise ValueError(tag)
+
+
+def generate_gp(
+    num_series: int,
+    length: int,
+    seed: int | None = None,
+    max_kernels: int = 5,
+    device: str | None = None,
+    batch: int = 32,
+) -> np.ndarray:
+    """Algorithm 1: GP samples with composed Table-8 kernels and a trend mean.
+
+    Sampling is by dense jittered Cholesky. A circulant or FFT sampler is not
+    an option here because the composed bank is not stationary: the linear and
+    periodic entries break both stationarity and circularity.
+
+    ``device='cuda'`` batches the covariance construction and the factorization
+    on the GPU, which is what production volume at length 4096 needs. Both
+    paths work in float64; float32 loses the high-frequency modes of the
+    periodic entries outright. The CUDA path uses ``cholesky_ex`` and writes
+    NaN for any row whose covariance failed to factorize, leaving the caller to
+    drop it, while the CPU path retries once at a larger jitter and raises if
+    that also fails.
+
+    ``device=None`` selects the numpy path; any device string selects the torch
+    path on that device, so ``'cpu'`` runs the batched code on the CPU and is a
+    third result rather than a cheap stand-in for either. The paths do not agree
+    row by row. ``batch`` is part of the data on the torch path rather than a
+    memory knob: see :mod:`tinycast.corpus`.
+
+    Returns float32 of shape ``(num_series, length)``, unnormalized.
+    """
+    rng = np.random.default_rng(seed)
+    bank = kernel_bank(length)
+    t = np.linspace(0.0, 1.0, length)
+    idx = np.arange(length, dtype=np.float64)
+    out = np.empty((num_series, length), dtype=np.float32)
+
+    def compose_indices():
+        n_k = int(rng.integers(1, max_kernels + 1))
+        picks = [int(rng.integers(0, len(bank))) for _ in range(n_k)]
+        ops = [int(rng.integers(0, 2)) for _ in range(n_k - 1)]
+        return picks, ops
+
+    def mean_fn():
+        # ASSUMPTION A1: the trend is in index units.
+        if rng.uniform() < 0.5:
+            m = rng.uniform(-0.01, 0.01)
+            c = rng.uniform(-0.1, 0.1)
+            return m * idx + c
+        return np.zeros(length)
+
+    if device is None:
+        for i in range(num_series):
+            picks, ops = compose_indices()
+            K = _dense_kernel(*bank[picks[0]], t)
+            for op, pi in zip(ops, picks[1:]):
+                Kn = _dense_kernel(*bank[pi], t)
+                K = K + Kn if op == 0 else K * Kn
+            K = K + GP_JITTER * np.eye(length)
+            try:
+                Lc = np.linalg.cholesky(K)
+            except np.linalg.LinAlgError:
+                K += (GP_JITTER_RETRY - GP_JITTER) * np.eye(length)
+                Lc = np.linalg.cholesky(K)
+            out[i] = (Lc @ rng.standard_normal(length) + mean_fn()).astype(np.float32)
+        return out
+
+    import torch
+
+    dev = torch.device(device)
+    g = torch.Generator(device=dev)
+    g.manual_seed(int(seed) if seed is not None else 0)
+    tt = torch.linspace(0.0, 1.0, length, device=dev, dtype=torch.float64)
+    dd = (tt[:, None] - tt[None, :]).abs()
+    d2 = dd * dd
+    outer = tt[:, None] * tt[None, :]
+    eye = torch.eye(length, device=dev, dtype=torch.float64)
+
+    def _k(tag: str, params: tuple) -> "torch.Tensor":
+        if tag == "const":
+            return torch.full_like(dd, params[0])
+        if tag == "linear":
+            return params[0] ** 2 + outer
+        if tag == "rbf":
+            return torch.exp(-d2 / (2.0 * params[0] ** 2))
+        if tag == "rq":
+            return (1.0 + d2 / (2.0 * params[0])).pow(-params[0])
+        if tag == "matern":
+            nu, l = params
+            if nu == 0.5:
+                return torch.exp(-dd / l)
+            if nu == 1.5:
+                a = math.sqrt(3.0) * dd / l
+                return (1.0 + a) * torch.exp(-a)
+            a = math.sqrt(5.0) * dd / l
+            return (1.0 + a + a * a / 3.0) * torch.exp(-a)
+        return torch.exp(-2.0 * torch.sin(math.pi * dd / params[0]) ** 2)
+
+    Ks = torch.empty((batch, length, length), device=dev, dtype=torch.float64)
+    done = 0
+    while done < num_series:
+        b = min(batch, num_series - done)
+        means = np.empty((b, length), dtype=np.float64)
+        for i in range(b):
+            picks, ops = compose_indices()
+            K = _k(*bank[picks[0]])
+            for op, pi in zip(ops, picks[1:]):
+                Kn = _k(*bank[pi])
+                K = K + Kn if op == 0 else K * Kn
+            Ks[i] = K
+            means[i] = mean_fn()
+        Kb = Ks[:b] + GP_JITTER * eye
+        Lc, info = torch.linalg.cholesky_ex(Kb)
+        z = torch.randn(b, length, 1, generator=g, device=dev, dtype=torch.float64)
+        s = torch.matmul(Lc, z).squeeze(-1)
+        bad = info > 0
+        if bool(bad.any()):
+            s[bad] = float("nan")
+        out[done:done + b] = (s.cpu().numpy() + means).astype(np.float32)
+        done += b
+    return out
+
+
+def generate_spikes(
+    num_series: int, length: int, seed: int | None = None,
+) -> np.ndarray:
+    """Algorithm 2: trapezoid pulse trains over a baseline, plus white noise.
+
+    The numeric ranges are ASSUMPTION A2. Levels wash out under the per-series
+    z-normalization the corpus applies on write, so what this family
+    contributes is the pulse shape and its spacing.
+    """
+    rng = np.random.default_rng(seed)
+    out = np.empty((num_series, length), dtype=np.float32)
+    for i in range(num_series):
+        b = rng.uniform(-1.0, 1.0)
+        p = int(rng.integers(16, max(17, length // 8) + 1))
+        w = int(rng.integers(4, p + 1))
+        a = rng.uniform(0.5, 3.0)
+        sigma = rng.uniform(0.01, 0.3)
+        sign = -1.0 if rng.integers(0, 2) == 0 else 1.0   # downward or upward
+        up = w // 4
+        flat = w // 2
+        down = w - up - flat
+        pulse = np.concatenate([
+            np.linspace(0.0, a, max(up, 1)),
+            np.full(max(flat, 1), a),
+            np.linspace(a, 0.0, max(down, 1)),
+        ])[:w]
+        x = np.full(length, b)
+        for start in range(0, length, p):
+            seg = min(w, length - start)
+            x[start:start + seg] += sign * pulse[:seg]
+        x += rng.normal(0.0, sigma, length)
+        out[i] = x.astype(np.float32)
+    return out
+
+
+def generate_tsi(
+    num_series: int, length: int, seed: int | None = None,
+    p_trend: float = 0.5, p_seas: float = 0.8, p_noise: float = 0.8,
+    p_out: float = 0.2, p_shift: float = 0.2,
+) -> np.ndarray:
+    """Algorithm 3: trend, seasonal components, noise, outliers, level shifts.
+
+    The probabilities and ranges are ASSUMPTION A3: the source paper states the
+    structure and defers the numbers, and the work it defers to does not
+    publish them either.
+    """
+    rng = np.random.default_rng(seed)
+    t = np.arange(length, dtype=np.float64)
+    tn = t / max(length - 1, 1)
+    periods = [p for p in PERIODS if p <= length // 2]
+    out = np.empty((num_series, length), dtype=np.float32)
+    for i in range(num_series):
+        x = np.zeros(length)
+        if rng.uniform() < p_trend:
+            kind = rng.integers(0, 4)
+            if kind == 0:                                  # linear
+                x += rng.uniform(-2.0, 2.0) * tn
+            elif kind == 1:                                # exponential
+                x += np.exp(rng.uniform(0.5, 2.0) * tn) - 1.0
+            elif kind == 2:                                # quadratic
+                x += rng.uniform(-2.0, 2.0) * tn ** 2
+            else:                                          # piecewise linear
+                cp = int(rng.integers(1, length - 1))
+                s1, s2 = rng.uniform(-2.0, 2.0, 2)
+                x[:cp] += s1 * tn[:cp]
+                x[cp:] += s1 * tn[cp] + s2 * (tn[cp:] - tn[cp])
+        if rng.uniform() < p_seas and periods:
+            n_comp = int(rng.integers(1, 4))
+            chosen = rng.choice(periods, size=min(n_comp, len(periods)), replace=False)
+            for p in chosen:
+                amp = rng.uniform(0.5, 2.0)
+                phi = rng.uniform(0.0, 2.0 * np.pi)
+                arg = 2.0 * np.pi * t / p + phi
+                wave = rng.integers(0, 3)
+                if wave == 0:
+                    x += amp * np.sin(arg)
+                elif wave == 1:                            # sawtooth
+                    x += amp * (2.0 * ((arg / (2.0 * np.pi)) % 1.0) - 1.0)
+                else:                                      # square
+                    x += amp * np.sign(np.sin(arg))
+        if rng.uniform() < p_noise:
+            sigma = rng.uniform(0.05, 0.5)
+            if rng.integers(0, 2) == 0:
+                x += rng.normal(0.0, sigma, length)
+            else:
+                x += rng.laplace(0.0, sigma / math.sqrt(2.0), length)
+        if rng.uniform() < p_out:
+            n = int(rng.integers(1, max(2, length // 100)))
+            pos = rng.integers(0, length, n)
+            mag = rng.uniform(3.0, 8.0, n) * max(x.std(), 0.1)
+            x[pos] += mag * rng.choice([-1.0, 1.0], n)
+        if rng.uniform() < p_shift:
+            n = int(rng.integers(1, 4))
+            for _ in range(n):
+                pos = int(rng.integers(1, length))
+                x[pos:] += rng.uniform(0.5, 3.0) * (1.0 if rng.integers(0, 2) else -1.0)
+        out[i] = x.astype(np.float32)
+    return out

tinycast/train.py

@@ -0,0 +1,714 @@
+"""Training entry point for TinyCast.
+
+``train`` runs the shipped recipe: a four-block autoregressive rollout under
+scheduled sampling, the nine-quantile pinball loss plus the gated committing
+term, AdamW, and a warmup-stable-decay learning-rate schedule. It runs
+single-process, and CPU is a first-class device.
+
+What a short run does and does not reproduce. The released 146,505-parameter
+checkpoint is 36,621 optimizer steps at an effective batch of 4096, in
+bf16-mixed across eight GPUs, over GIFT-Eval-Pretrain plus Chronos KernelSynth
+plus four synthetic shards, with the final weights the uniform mean of the last
+eight periodic checkpoints. A short run on a small corpus reproduces the
+mechanics: the rollout, the objective, the schedule shape, the optimizer. It
+does not reproduce the checkpoint or its numbers.
+
+``max_steps`` reshapes the run rather than truncating it. Warmup, stable and
+decay are fractions of ``max_steps``, and the scheduled-sampling feedback
+probability ramps over its first half, so a 200-step run warms up, holds and
+decays inside 200 steps and reaches full feedback by step 100. A 200-step run
+is therefore not a prefix of a 36,621-step run, and their step-100 states are
+not comparable.
+
+Two further departures from the released run, both deliberate. This entry point
+trains in the model's own precision instead of bf16-mixed, and it writes
+periodic checkpoints but does not average them.
+"""
+from __future__ import annotations
+
+import collections.abc
+import json
+import math
+import os
+import random
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple
+
+import torch
+
+from .config import TinyCastConfig
+from .losses import (
+    COMMIT_WEIGHT,
+    committing_loss,
+    pinball_loss,
+    seasonal_copy_baseline,
+)
+from .model import TinyCastForPrediction
+
+# --- the shipped recipe ----------------------------------------------------
+# Every value below can be overridden by an attribute of the same name on the
+# config object passed to ``train``; the defaults are what the released
+# checkpoint was trained with.
+AR_CHUNKS = 4                    # K: blocks rolled out per training window
+SCHEDULED_SAMPLING_MAX = 0.5     # peak probability of feeding our own median
+LEARNING_RATE = 3e-3
+MIN_LEARNING_RATE = 1e-5
+WARMUP_FRACTION = 0.05
+DECAY_FRACTION = 0.35
+WEIGHT_DECAY = 0.01
+GRAD_CLIP = 1.0
+ADAM_BETAS = (0.9, 0.95)
+COMMIT_GATED = True
+
+# Guards carried over from the released run: predictions are optimized inside a
+# fixed normalized band, and a window whose context is flat is not scored.
+_PRED_CLAMP = 5.0
+_TARGET_CLAMP = 10.0
+_MIN_RANGE = 1e-4
+
+
+@dataclass
+class TrainResult:
+    """What a finished run leaves behind.
+
+    Attributes:
+        checkpoint_path: the final ``model.safetensors``, next to a
+            ``config.json``, so ``tinycast.load_checkpoint`` reads it directly.
+        steps: optimizer steps actually run.
+        losses: one training loss per optimizer step, in order.
+        learning_rates: the learning rate each of those steps used.
+        checkpoints: the periodic checkpoints written along the way, oldest
+            first. The released weights are the uniform mean of the last eight
+            of these; ``train`` writes them but does not average them.
+        window_width: the sample width the run required, ``L + K * p``.
+    """
+
+    checkpoint_path: str
+    steps: int
+    losses: List[float] = field(default_factory=list)
+    learning_rates: List[float] = field(default_factory=list)
+    checkpoints: List[str] = field(default_factory=list)
+    window_width: int = 0
+
+
+def training_window_width(
+    config: TinyCastConfig, chunks: Optional[int] = None
+) -> int:
+    """Sample width the rollout consumes: ``L + K * p``.
+
+    ``L`` is the encoder context, ``p`` the horizon unit and ``K`` the number of
+    autoregressive blocks. Each block re-normalizes a context that has slid
+    forward by ``p``, so the last block still needs a full ``L`` of history
+    behind it. Call this instead of hard-coding the width.
+    """
+    k = int(_setting(config, "ar_chunks", AR_CHUNKS) if chunks is None else chunks)
+    if k < 1:
+        raise ValueError(f"ar_chunks must be at least 1, got {k}.")
+    return int(config.seq_len) + k * int(config.output_token_len)
+
+
+def _setting(config: Any, name: str, default: Any) -> Any:
+    value = getattr(config, name, None)
+    return default if value is None else value
+
+
+# --- reproducibility -------------------------------------------------------
+
+def _seed_everything(seed: int) -> None:
+    random.seed(seed)
+    try:
+        import numpy as np
+
+        np.random.seed(seed % (2 ** 32))
+    except ImportError:
+        pass
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+
+class _Determinism:
+    """Turn deterministic kernels on, then put the process back as it was.
+
+    The flags are process-global, so a library function has no business leaving
+    them changed. Entered only when the caller asks for ``deterministic=True``.
+    """
+
+    def __init__(self, enabled: bool, device: torch.device) -> None:
+        self.enabled = bool(enabled)
+        self.device = device
+        self._saved: Dict[str, Any] = {}
+
+    def __enter__(self) -> "_Determinism":
+        if not self.enabled:
+            return self
+        self._saved["algorithms"] = torch.are_deterministic_algorithms_enabled()
+        self._saved["cudnn_deterministic"] = torch.backends.cudnn.deterministic
+        self._saved["cudnn_benchmark"] = torch.backends.cudnn.benchmark
+        self._saved["cublas"] = os.environ.get("CUBLAS_WORKSPACE_CONFIG")
+        if self.device.type == "cuda" and self._saved["cublas"] is None:
+            # cuBLAS needs this set before its handle is created for the
+            # deterministic reduction path to be available.
+            os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+        torch.use_deterministic_algorithms(True, warn_only=True)
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        if not self.enabled:
+            return
+        torch.use_deterministic_algorithms(self._saved["algorithms"])
+        torch.backends.cudnn.deterministic = self._saved["cudnn_deterministic"]
+        torch.backends.cudnn.benchmark = self._saved["cudnn_benchmark"]
+        if self._saved["cublas"] is None:
+            os.environ.pop("CUBLAS_WORKSPACE_CONFIG", None)
+        else:
+            os.environ["CUBLAS_WORKSPACE_CONFIG"] = self._saved["cublas"]
+
+
+def _resolve_device(device: str) -> torch.device:
+    """Return the requested device, or say why it is unavailable.
+
+    A silent fall back to CPU would change the numbers with no signal, so a
+    request for an absent accelerator is an error.
+    """
+    dev = torch.device(device)
+    if dev.type == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError(
+            "device='cuda' was requested but torch.cuda.is_available() is "
+            "False. Pass device='cpu' to train on CPU."
+        )
+    if dev.type == "mps" and not torch.backends.mps.is_available():
+        raise RuntimeError(
+            "device='mps' was requested but MPS is unavailable. Pass "
+            "device='cpu' to train on CPU."
+        )
+    return dev
+
+
+# --- data ------------------------------------------------------------------
+
+class _SampleBatcher:
+    """Group a plain iterable of samples into collated batches.
+
+    Re-iterated once per epoch, so a list, a sequence or any object with a
+    fresh ``__iter__`` works. A one-shot generator is exhausted after its first
+    pass and ``_epochs`` reports that rather than looping on nothing.
+    """
+
+    def __init__(self, samples: Iterable[Any], batch_size: int) -> None:
+        self.samples = samples
+        self.batch_size = int(batch_size)
+
+    def __iter__(self):
+        from torch.utils.data import default_collate
+
+        buffer: List[Any] = []
+        for sample in self.samples:
+            buffer.append(sample)
+            if len(buffer) == self.batch_size:
+                yield default_collate(buffer)
+                buffer = []
+        # A short tail is dropped, matching drop_last on the DataLoader path:
+        # a partial batch changes the effective batch size mid-run.
+
+
+def _build_loader(
+    data: Any,
+    batch_size: int,
+    num_workers: int,
+    device: torch.device,
+    seed: int,
+) -> Iterable[Any]:
+    from torch.utils.data import DataLoader, Dataset, IterableDataset
+
+    if isinstance(data, DataLoader):
+        # The caller has already made every batching decision; respect it.
+        return data
+
+    pin_memory = device.type == "cuda"
+
+    def worker_init(worker_id: int) -> None:
+        _seed_everything(seed + 1 + worker_id)
+
+    if isinstance(data, IterableDataset):
+        return DataLoader(
+            data,
+            batch_size=batch_size,
+            num_workers=num_workers,
+            pin_memory=pin_memory,
+            worker_init_fn=worker_init,
+        )
+    if isinstance(data, Dataset):
+        generator = torch.Generator().manual_seed(seed)
+        return DataLoader(
+            data,
+            batch_size=batch_size,
+            shuffle=True,
+            drop_last=True,
+            num_workers=num_workers,
+            pin_memory=pin_memory,
+            generator=generator,
+            worker_init_fn=worker_init,
+        )
+    if isinstance(data, collections.abc.Iterable):
+        if num_workers:
+            raise ValueError(
+                "num_workers > 0 needs a Dataset or a DataLoader; a plain "
+                "iterable is batched in this process."
+            )
+        return _SampleBatcher(data, batch_size)
+    raise TypeError(
+        "data must be a Dataset, an IterableDataset, a DataLoader or an "
+        f"iterable of samples, got {type(data).__name__}."
+    )
+
+
+def _epochs(loader: Iterable[Any]):
+    """Yield batches forever, restarting the loader between passes."""
+    while True:
+        produced = False
+        for batch in loader:
+            produced = True
+            yield batch
+        if not produced:
+            raise ValueError(
+                "the training data yielded no batches. A one-shot generator is "
+                "exhausted after one pass: pass a Dataset, a DataLoader or a "
+                "re-iterable sequence, and check that it holds at least one "
+                "full batch."
+            )
+
+
+def _unpack_batch(
+    batch: Any, width: int, device: torch.device, dtype: torch.dtype
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Normalize a batch to ``(window, mask, scale_factor)`` on ``device``.
+
+    Accepts a mapping with a ``window`` key (plus optional ``mask`` and
+    ``scale_factor``), a bare tensor of windows, or a positional
+    ``(window, mask, scale_factor)`` sequence.
+    """
+    mask: Any = None
+    scale: Any = None
+    if isinstance(batch, dict):
+        if "window" not in batch:
+            raise KeyError(
+                f"batch dict needs a 'window' key, got {sorted(batch)}."
+            )
+        window = batch["window"]
+        mask = batch.get("mask")
+        scale = batch.get("scale_factor")
+    elif torch.is_tensor(batch):
+        window = batch
+    elif isinstance(batch, (tuple, list)):
+        window = batch[0]
+        mask = batch[1] if len(batch) > 1 else None
+        scale = batch[2] if len(batch) > 2 else None
+    else:
+        raise TypeError(
+            "a batch must be a dict, a tensor or a sequence, got "
+            f"{type(batch).__name__}."
+        )
+
+    window = torch.as_tensor(window).to(device=device, dtype=dtype)
+    if window.dim() == 3 and window.shape[-1] == 1:
+        window = window.squeeze(-1)
+    if window.dim() != 2:
+        raise ValueError(
+            f"window must be (B, L + K*p), got {tuple(window.shape)}."
+        )
+    if window.shape[1] != width:
+        raise ValueError(
+            f"window is {window.shape[1]} long but the rollout needs "
+            f"{width} = seq_len + ar_chunks * output_token_len. Use "
+            "tinycast.train.training_window_width(config) to size the dataset."
+        )
+
+    if mask is None:
+        observed = torch.isfinite(window).to(dtype)
+    else:
+        observed = torch.as_tensor(mask).to(device=device, dtype=dtype)
+        if observed.dim() == 3 and observed.shape[-1] == 1:
+            observed = observed.squeeze(-1)
+        if observed.shape != window.shape:
+            raise ValueError(
+                f"mask {tuple(observed.shape)} does not match window "
+                f"{tuple(window.shape)}."
+            )
+        observed = observed * torch.isfinite(window).to(dtype)
+    window = torch.nan_to_num(window, nan=0.0, posinf=0.0, neginf=0.0)
+
+    if scale is None:
+        # No metadata: one sample per canonical cycle. Datasets that carry a
+        # frequency should supply tinycast.scale.seasonal_scale_factor instead,
+        # since the local anchor channels and the seasonal copy both read it.
+        scale_factor = torch.ones(
+            window.shape[0], device=device, dtype=torch.float32
+        )
+    else:
+        scale_factor = torch.as_tensor(scale).to(
+            device=device, dtype=torch.float32
+        ).reshape(-1)
+        if scale_factor.numel() == 1:
+            scale_factor = scale_factor.expand(window.shape[0])
+        elif scale_factor.numel() != window.shape[0]:
+            raise ValueError(
+                f"scale_factor carries {scale_factor.numel()} entries for a "
+                f"batch of {window.shape[0]}."
+            )
+    return window, observed, scale_factor
+
+
+# --- schedule --------------------------------------------------------------
+
+def _wsd_lambda(
+    max_steps: int,
+    warmup_fraction: float,
+    decay_fraction: float,
+    min_ratio: float,
+) -> Callable[[int], float]:
+    """Warmup, stable, decay multiplier.
+
+    Linear to the peak over the warmup span, held there, then down to the floor
+    as ``1 - sqrt(progress)``: a sharp initial drop and a shallow tail. All
+    three spans are fractions of ``max_steps``, which is why ``max_steps``
+    reshapes a run instead of truncating one.
+    """
+    warmup_steps = max(1, int(max_steps * warmup_fraction))
+    decay_steps = max(1, int(max_steps * decay_fraction))
+    decay_start = max(warmup_steps + 1, max_steps - decay_steps)
+
+    def lr_lambda(step: int) -> float:
+        if step < warmup_steps:
+            return step / warmup_steps
+        if step < decay_start:
+            return 1.0
+        span = max(1, max_steps - decay_start)
+        progress = min(1.0, (step - decay_start) / span)
+        return min_ratio + (1.0 - min_ratio) * (1.0 - math.sqrt(progress))
+
+    return lr_lambda
+
+
+# --- the rollout -----------------------------------------------------------
+
+def _chunk_loss(
+    backbone: torch.nn.Module,
+    context: torch.Tensor,
+    target: torch.Tensor,
+    target_mask: torch.Tensor,
+    scale_factor: torch.Tensor,
+    quantiles: torch.Tensor,
+    commit_weight: float,
+    commit_gated: bool,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """One block: encode the context, score the block, hand back its median.
+
+    Returns the scalar block loss and the raw-magnitude median forecast the
+    next block feeds on.
+    """
+    horizon = target.shape[1]
+    y_norm, x_min, x_range = backbone.encode(
+        context, batch_first=True, scale_factor=scale_factor, horizon=horizon,
+    )
+    y_norm = y_norm.clamp(-_PRED_CLAMP, _PRED_CLAMP)
+    x_min_b = x_min.squeeze(-1)                                  # (B, 1)
+    x_range_b = x_range.squeeze(-1)                              # (B, 1)
+    target_norm = ((target - x_min_b) / x_range_b).clamp(
+        -_TARGET_CLAMP, _TARGET_CLAMP
+    )
+
+    # A sample is scored only if its context has range to normalize by, its
+    # forecast is finite, and it has an observed target position.
+    non_batch = tuple(range(1, y_norm.dim()))
+    valid = (
+        (x_range_b.squeeze(-1) > _MIN_RANGE)
+        & torch.isfinite(y_norm).all(dim=non_batch)
+        & (target_mask.sum(dim=1) > 0)
+    ).to(y_norm.dtype)
+
+    per_sample = pinball_loss(
+        y_norm, target_norm, quantiles, target_mask, reduction="none",
+    )
+    per_sample = torch.nan_to_num(per_sample, 0.0, 0.0, 0.0) * valid
+
+    q_mid = y_norm.shape[-1] // 2
+    median_norm = y_norm[..., q_mid]                             # (B, H)
+
+    if commit_weight > 0.0:
+        copy_raw = seasonal_copy_baseline(context, horizon, scale_factor)
+        copy_norm = (copy_raw - x_min_b) / x_range_b
+        commit = committing_loss(
+            median_norm, target_norm, copy_norm, target_mask,
+            weight=commit_weight, gated=commit_gated, reduction="none",
+        )
+        per_sample = per_sample + torch.nan_to_num(commit, 0.0, 0.0, 0.0) * valid
+
+    n_valid = valid.sum()
+    if float(n_valid) < 1.0:
+        loss = per_sample.sum() * 0.0
+    else:
+        loss = per_sample.sum() / n_valid
+    if not torch.isfinite(loss):
+        loss = per_sample.sum() * 0.0
+
+    median_raw = median_norm * x_range_b + x_min_b
+    return loss, median_raw
+
+
+def _rollout_loss(
+    backbone: torch.nn.Module,
+    window: torch.Tensor,
+    observed: torch.Tensor,
+    scale_factor: torch.Tensor,
+    *,
+    seq_len: int,
+    horizon_unit: int,
+    chunks: int,
+    epsilon: float,
+    quantiles: torch.Tensor,
+    commit_weight: float,
+    commit_gated: bool,
+) -> torch.Tensor:
+    """Roll out ``chunks`` blocks under scheduled sampling and average them.
+
+    Each block re-normalizes its own context window. Between blocks the model's
+    own median replaces the true values with probability ``epsilon``, so the
+    context the model sees late in the rollout is built the way it will be at
+    inference. Fed values are detached: they are inputs, not a gradient path.
+
+    An unobserved target position is always replaced by the median, whatever
+    ``epsilon`` says, rather than by the zero its mask stands for. On gap-free
+    data this makes no difference; on gappy data it keeps a filler value out of
+    the next context.
+    """
+    length, unit = int(seq_len), int(horizon_unit)
+    series = window
+    total = window.new_zeros(())
+    for k in range(chunks):
+        context = series[:, k * unit: k * unit + length]
+        start = length + k * unit
+        stop = start + unit
+        target = window[:, start:stop]
+        target_mask = observed[:, start:stop]
+        loss_k, median_raw = _chunk_loss(
+            backbone, context, target, target_mask, scale_factor,
+            quantiles, commit_weight, commit_gated,
+        )
+        total = total + loss_k
+        if k < chunks - 1:
+            use_pred = (
+                torch.rand(window.shape[0], 1, device=window.device) < epsilon
+            ) | (target_mask < 0.5)
+            fed = torch.where(use_pred, median_raw, target)
+            series = series.clone()
+            series[:, start:stop] = fed.detach()
+    return total / float(chunks)
+
+
+# --- checkpoints -----------------------------------------------------------
+
+def _save(model: torch.nn.Module, path: Path) -> None:
+    """Write the model in the released format.
+
+    ``safetensors`` stores each unique storage once, so the two weight-tied FFN
+    stacks are written once and ``tinycast.load_checkpoint`` restores the
+    sharing on load.
+    """
+    from safetensors.torch import save_model
+
+    save_model(model, str(path))
+
+
+# --- entry point -----------------------------------------------------------
+
+def train(
+    config: TinyCastConfig,
+    *,
+    data: Any,
+    max_steps: int,
+    output_dir: str,
+    seed: int = 42,
+    device: str = "cpu",
+    batch_size: int,
+    accumulate_grad_batches: int = 1,
+    num_workers: int = 0,
+    checkpoint_every: Optional[int] = None,
+    callbacks: Sequence[Callable[[Dict[str, Any]], None]] = (),
+    deterministic: bool = False,
+) -> TrainResult:
+    """Train a TinyCast model and return where it landed.
+
+    Args:
+        config: the architecture. Optional attributes named after the module
+            constants (``ar_chunks``, ``learning_rate``, ``commit_weight`` and
+            so on) override the shipped recipe; absent ones take it.
+        data: a ``Dataset``, an ``IterableDataset``, a ``DataLoader``, or a
+            plain iterable of samples. A sample is a mapping with a ``window``
+            of ``L + K * p`` values and optionally a ``mask`` and a
+            ``scale_factor``; a bare tensor or a positional triple works too.
+            Use :func:`training_window_width` to size the window.
+        max_steps: optimizer steps. This RESHAPES the run: the warmup, stable
+            and decay spans of the schedule are fractions of it, and the
+            scheduled-sampling probability ramps over its first half. A short
+            run is not a prefix of a long one.
+        output_dir: created if absent. Receives ``model.safetensors``,
+            ``config.json`` and any periodic checkpoints.
+        seed: seeds Python, NumPy, torch, the sampler and the workers, inside
+            this call.
+        device: ``"cpu"``, ``"cuda"``, ``"cuda:1"``, ``"mps"``. An unavailable
+            accelerator raises rather than falling back.
+        batch_size: samples per micro-batch. The effective batch is this times
+            ``accumulate_grad_batches``.
+        accumulate_grad_batches: micro-batches per optimizer step.
+        num_workers: DataLoader workers. Zero, single-process, by default.
+        checkpoint_every: write a checkpoint every this many optimizer steps.
+        callbacks: called after each optimizer step with a dict carrying
+            ``step``, ``loss``, ``lr``, ``epsilon`` and ``grad_norm``.
+        deterministic: request deterministic kernels for the duration of the
+            call, then restore the process flags. An op with no deterministic
+            implementation warns rather than raising, so this tightens
+            reproducibility without ruling a device out.
+
+    Returns:
+        A :class:`TrainResult`.
+
+    Nothing here reaches the network and nothing is uploaded.
+    """
+    if int(max_steps) < 1:
+        raise ValueError(f"max_steps must be at least 1, got {max_steps}.")
+    if int(batch_size) < 1:
+        raise ValueError(f"batch_size must be at least 1, got {batch_size}.")
+    if int(accumulate_grad_batches) < 1:
+        raise ValueError(
+            "accumulate_grad_batches must be at least 1, got "
+            f"{accumulate_grad_batches}."
+        )
+    max_steps = int(max_steps)
+    accumulate_grad_batches = int(accumulate_grad_batches)
+
+    chunks = int(_setting(config, "ar_chunks", AR_CHUNKS))
+    width = training_window_width(config, chunks)
+    seq_len = int(config.seq_len)
+    horizon_unit = int(config.output_token_len)
+    eps_max = float(_setting(config, "scheduled_sampling_max", SCHEDULED_SAMPLING_MAX))
+    peak_lr = float(_setting(config, "learning_rate", LEARNING_RATE))
+    min_lr = float(_setting(config, "min_learning_rate", MIN_LEARNING_RATE))
+    warmup_fraction = float(_setting(config, "warmup_fraction", WARMUP_FRACTION))
+    decay_fraction = float(_setting(config, "decay_fraction", DECAY_FRACTION))
+    weight_decay = float(_setting(config, "weight_decay", WEIGHT_DECAY))
+    grad_clip = float(_setting(config, "grad_clip", GRAD_CLIP))
+    commit_weight = float(_setting(config, "commit_weight", COMMIT_WEIGHT))
+    commit_gated = bool(_setting(config, "commit_gated", COMMIT_GATED))
+    if warmup_fraction + decay_fraction > 1.0:
+        raise ValueError(
+            "warmup_fraction + decay_fraction must not exceed 1.0, got "
+            f"{warmup_fraction} + {decay_fraction}."
+        )
+
+    torch_device = _resolve_device(device)
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+
+    with _Determinism(deterministic, torch_device):
+        _seed_everything(int(seed))
+
+        model = TinyCastForPrediction(config).to(torch_device)
+        model.train()
+        backbone = model.model
+        param_dtype = next(model.parameters()).dtype
+        quantiles = torch.tensor(
+            list(config.quantiles), dtype=param_dtype, device=torch_device,
+        )
+
+        optimizer = torch.optim.AdamW(
+            model.parameters(),
+            lr=peak_lr,
+            betas=ADAM_BETAS,
+            weight_decay=weight_decay,
+        )
+        scheduler = torch.optim.lr_scheduler.LambdaLR(
+            optimizer,
+            _wsd_lambda(max_steps, warmup_fraction, decay_fraction,
+                        min_lr / peak_lr),
+        )
+
+        loader = _build_loader(
+            data, int(batch_size), int(num_workers), torch_device, int(seed),
+        )
+        batches = _epochs(loader)
+
+        losses: List[float] = []
+        learning_rates: List[float] = []
+        written: List[str] = []
+
+        for step in range(max_steps):
+            # The feedback probability ramps to its maximum over the first half
+            # of the run, so it too is a function of max_steps.
+            epsilon = eps_max * min(1.0, step / max(1.0, 0.5 * max_steps))
+            lr = float(scheduler.get_last_lr()[0])
+
+            optimizer.zero_grad(set_to_none=True)
+            step_loss = 0.0
+            for _ in range(accumulate_grad_batches):
+                window, observed, scale_factor = _unpack_batch(
+                    next(batches), width, torch_device, param_dtype,
+                )
+                loss = _rollout_loss(
+                    backbone, window, observed, scale_factor,
+                    seq_len=seq_len,
+                    horizon_unit=horizon_unit,
+                    chunks=chunks,
+                    epsilon=epsilon,
+                    quantiles=quantiles,
+                    commit_weight=commit_weight,
+                    commit_gated=commit_gated,
+                )
+                (loss / accumulate_grad_batches).backward()
+                step_loss += float(loss.detach()) / accumulate_grad_batches
+
+            if grad_clip > 0.0:
+                grad_norm = float(
+                    torch.nn.utils.clip_grad_norm_(model.parameters(), grad_clip)
+                )
+            else:
+                grad_norm = float("nan")
+            optimizer.step()
+            scheduler.step()
+
+            losses.append(step_loss)
+            learning_rates.append(lr)
+            record = {
+                "step": step + 1,
+                "loss": step_loss,
+                "lr": lr,
+                "epsilon": epsilon,
+                "grad_norm": grad_norm,
+            }
+            for callback in callbacks:
+                callback(record)
+
+            if checkpoint_every and (step + 1) % int(checkpoint_every) == 0:
+                path = out / f"step-{step + 1:06d}.safetensors"
+                _save(model, path)
+                written.append(str(path))
+
+        final = out / "model.safetensors"
+        _save(model, final)
+        with open(out / "config.json", "w") as handle:
+            json.dump(config.to_dict(), handle, indent=2)
+
+    return TrainResult(
+        checkpoint_path=str(final),
+        steps=max_steps,
+        losses=losses,
+        learning_rates=learning_rates,
+        checkpoints=written,
+        window_width=width,
+    )
+
+
+__all__ = ["TrainResult", "train", "training_window_width"]