forecasting/README.md

Forecasting track — leaderboard substrate

This directory holds the per-method substrate for the OpenMHC Track-3 (forecasting) leaderboard. Each method ships two files:

forecasting/<method>.parquet         # per-(user × channel × metric) raw values
forecasting/<method>.meta.json       # display + diagnostic sidecar

See SCHEMA.md for the exact column / field schema (including the fallback_rate diagnostic).

What's it for

The substrate parquets are the canonical inputs for:

• The OpenMHC HF Space (MyHeartCounts/OpenMHC) — it downloads these parquets + the sidecars and runs the canonical forecasting reducers to produce the live leaderboard table (skill / fair-skill / mean-rank vs seasonal_naive).
• Independent re-aggregation (skill / rank / fairness reducers in src/forecasting_evaluation/metrics/).
• The cluster-bootstrap reference at forecasting/bootstrap/ (per-draw CIs) is reduced from these substrates, so any change here must be matched by a bootstrap refresh (see "Refreshing" below) or the CIs drift off the points.

Loading

from huggingface_hub import hf_hub_download
import pandas as pd, json

parquet = hf_hub_download(
    "MyHeartCounts/OpenMHC-leaderboard-data",
    "forecasting/chronos2_zeroshot.parquet",
    repo_type="dataset",
)
df = pd.read_parquet(parquet)
print(df.shape, df.columns.tolist())

# Display + diagnostic sidecar (incl. fallback_rate)
meta_p = hf_hub_download(
    "MyHeartCounts/OpenMHC-leaderboard-data",
    "forecasting/chronos2_zeroshot.meta.json",
    repo_type="dataset",
)
print(json.loads(open(meta_p).read()))
# -> {"display_name": "Chronos-2 (zero-shot)", "type": "Foundation Model", ...,
#     "fallback_rate": 0.0}

Pooled substrate

The pooled per-user frame across all methods is the concatenation of the per-method parquets (~7,370 rows/method × 10 methods for the canonical config):

import glob, pandas as pd
pooled = pd.concat(
    [pd.read_parquet(p) for p in glob.glob("forecasting/*.parquet")],
    ignore_index=True,
)

fallback_rate is on by default

The invalid-prediction rate is always produced and always threaded into the sidecar — there is no opt-in flag:

• The eval harness always records overall_fallback_rate (fraction of forecast cells the model emitted as NaN, which the harness substituted with Seasonal-Naive before scoring) at the top level of each run's results.json, and evaluate_forecasting carries it in the substrate parquet's meta.
• stage_leaderboard_substrates.py emits each upload command with --results-json <runs>/<method>/hydra/results.json, so upload_leaderboard_substrate.py auto-extracts the rate and writes the fallback_rate sidecar key by default. Existing display fields are preserved.

A fallback_rate > ~5% means the headline scores are inflated with baseline performance on the substituted cells and should be read with caution.

Refreshing (full paper-results reproduction)

Single source of truth — avoid regressing to an old run. The canonical run is pinned in exactly one place: run_label / output_root in configs/paper/sweep_forecasting.yaml (currently forecasting_full_20260622). The substrate-staging and bootstrap-draws scripts default to it (they read output_root from that file), so a bare stage_leaderboard_substrates.py or produce_forecasting_bootstrap_draws.py cannot silently rebuild the leaderboard from a stale substrate. To re-point the canonical run, edit only the sweep config. Likewise the methodology is fixed in the sweep + code: within_user_aggregation: micro (binary AUROC is pooled per user over all the user's horizon cells — the eval emits one pooled row/user; the legacy per-window "macro" path is not used for the leaderboard). All steps run from the OpenMHC code repo on Simurgh (SC); see jobs/sc-cluster/forecasting_eval/README.md for cluster details.

LABEL=forecasting_full_20260622

# (1) Eval + aggregate — fan out all 10 model jobs under one label, then chain
#     the paper pipeline (substrate + skill/rank + bootstrap CIs + fairness).
#     Each run writes results.json with the top-level overall_fallback_rate.
MHC_FORECAST_RUN_LABEL=$LABEL jobs/sc-cluster/forecasting_eval/submit_pipeline.sh
#   re-aggregate only (metrics already on disk):
#   sbatch --export=ALL,MHC_FORECAST_RUN_LABEL=$LABEL \
#     jobs/sc-cluster/forecasting_eval/run_paper_pipeline.sbatch
# -> results/forecasting_eval/simurgh/summary/$LABEL/
#      {forecasting_per_user_errors.parquet, skill_rank_models.json,
#       forecasting_skill_score*.csv, forecasting_grouped_metric_rank*.csv,
#       forecasting_fairness_skill_score*.csv}

# (2) Bootstrap-draws reference for the leaderboard CIs (n_boot=1000; CPU ~30 min).
sbatch scripts/paper_results/forecasting/produce_forecasting_bootstrap_draws.sbatch \
    --summary-dir results/forecasting_eval/simurgh/summary/$LABEL
# -> $LABEL/bootstrap_draws.parquet (+ .meta.json)

# (3) Stage per-method substrates + emit the upload commands (each already
#     carries --results-json so fallback_rate is auto-filled).
python scripts/paper_results/forecasting/stage_leaderboard_substrates.py
#   ^ prints one `upload_leaderboard_substrate.py ... --track forecasting
#     --results-json <runs>/<method>/hydra/results.json` per method; run them
#     (HF auth required: HF_TOKEN or `huggingface-cli login`). This writes
#     forecasting/<method>.{parquet,meta.json} with fallback_rate.

# (4) Upload the bootstrap-draws reference (overwrites forecasting/bootstrap/).
python tools/upload_leaderboard_bootstrap.py \
    --dir results/forecasting_eval/simurgh/summary/$LABEL --track forecasting

# (5) Docs — keep this README + SCHEMA.md in sync on the dataset repo:
python - <<'PY'
from huggingface_hub import HfApi
api = HfApi()
for src, dst in [
    ("tools/leaderboard_docs/forecasting/SCHEMA.md", "forecasting/SCHEMA.md"),
    ("tools/leaderboard_docs/forecasting/README.md", "forecasting/README.md"),
]:
    api.upload_file(path_or_fileobj=src, path_in_repo=dst,
                    repo_id="MyHeartCounts/OpenMHC-leaderboard-data", repo_type="dataset",
                    commit_message=f"docs(forecasting): sync {dst}")
PY

Steps (2) and (4) keep the bootstrap CIs on the same canonical substrate as the point numbers — always run them together when the substrates change.