| """Ensemble of Chronos-2 variants. Quantile-averages multiple pipelines |
| across the same rolling windows, then scores the ensemble. |
| """ |
| from __future__ import annotations |
|
|
| import json |
| import math |
| import sys |
| import time |
| from typing import Iterable |
|
|
| import numpy as np |
| import torch |
|
|
| from chronos import BaseChronosPipeline |
| from experiments.features import load_multi_ba |
| from experiments.eval_c2 import rolling_eval_c2 |
|
|
|
|
| def ensemble_forecast(pipes, bas, on, context, horizon, batch_size, |
| q_levels: Iterable[float] = (0.1, 0.5, 0.9)): |
| """Produce ensemble forecasts by averaging each model's quantiles.""" |
| q_levels = list(q_levels) |
| per_ba = {} |
| all_win_mase = [] |
| for ba, bd in bas.items(): |
| start = bd.train_end if on == "val" else bd.val_end |
| end = bd.val_end if on == "val" else bd.test_end |
| origins = [o for o in range(start, end - horizon + 1, horizon) |
| if o - context >= 0] |
| if not origins: |
| continue |
|
|
| truths_list = [] |
| all_means = np.zeros((len(origins), horizon), dtype=np.float32) |
| all_quants = np.zeros((len(origins), horizon, len(q_levels)), dtype=np.float32) |
|
|
| for pipe in pipes: |
| for i in range(0, len(origins), batch_size): |
| batch_origins = origins[i:i + batch_size] |
| tasks = [] |
| for o in batch_origins: |
| past = {k: v[o - context:o] for k, v in bd.covariates.items()} |
| future = bd.future_at(o, horizon) |
| tasks.append({ |
| "target": bd.target[o - context:o].astype(np.float32), |
| "past_covariates": past, |
| "future_covariates": future, |
| }) |
| if len(pipes) == 1 or pipe is pipes[0]: |
| truths_list.append(bd.target[o:o + horizon].astype(np.float32)) |
| quants_list, means_list = pipe.predict_quantiles( |
| tasks, prediction_length=horizon, quantile_levels=q_levels, |
| batch_size=len(tasks), |
| ) |
| q = torch.stack([x.squeeze(0) for x in quants_list]).float().cpu().numpy() |
| m = torch.stack([x.squeeze(0) for x in means_list]).float().cpu().numpy() |
| all_means[i:i + len(batch_origins)] += m / len(pipes) |
| all_quants[i:i + len(batch_origins)] += q / len(pipes) |
|
|
| truths = np.stack(truths_list) |
| diff = truths - all_means |
| valid = ~np.isnan(truths) |
| abs_err = np.abs(diff)[valid] |
| sq_err = (diff * diff)[valid] |
|
|
| pb_total = 0.0 |
| for qi_idx, tau in enumerate(q_levels): |
| qi = all_quants[..., qi_idx] |
| pb = np.where(truths >= qi, tau * (truths - qi), (1 - tau) * (qi - truths)) |
| pb_total += pb[valid].mean() |
| crps = float(pb_total / len(q_levels)) |
|
|
| low_i, high_i = q_levels.index(min(q_levels)), q_levels.index(max(q_levels)) |
| pi = q_levels[high_i] - q_levels[low_i] |
| cov = float(((truths >= all_quants[..., low_i]) & |
| (truths <= all_quants[..., high_i]))[valid].mean()) |
|
|
| mae = float(abs_err.mean()) |
| rmse = float(math.sqrt(sq_err.mean())) |
| per_ba[ba] = { |
| "mae": mae, "rmse": rmse, "mase": mae / bd.denom_mae, |
| "crps": crps, f"cov_pi{int(pi * 100)}": cov, |
| "n_windows": len(origins), "n_points": int(len(abs_err)), |
| } |
| win_mae = np.where(valid, np.abs(diff), 0).sum(axis=1) / np.maximum(valid.sum(axis=1), 1) |
| all_win_mase.append(win_mae / bd.denom_mae) |
|
|
| macro = {k: float(np.mean([v[k] for v in per_ba.values()])) |
| for k in ("mae", "rmse", "mase", "crps")} |
| cov_keys = {k for v in per_ba.values() for k in v if k.startswith("cov_")} |
| for k in cov_keys: |
| macro[k] = float(np.mean([v[k] for v in per_ba.values()])) |
| macro["per_ba"] = per_ba |
| macro["n_bas"] = len(per_ba) |
|
|
| pooled = np.concatenate(all_win_mase) |
| rng = np.random.default_rng(42) |
| boots = np.empty(2000) |
| for b in range(2000): |
| idx = rng.integers(0, len(pooled), len(pooled)) |
| boots[b] = pooled[idx].mean() |
| macro["mase_ci_low"] = float(np.quantile(boots, 0.025)) |
| macro["mase_ci_high"] = float(np.quantile(boots, 0.975)) |
| return macro |
|
|
|
|
| def main() -> None: |
| cfg = json.loads(sys.argv[1]) |
| bas = load_multi_ba(cfg["bas"], with_gen=cfg.get("with_gen", False), |
| future_mode=cfg.get("future_mode", "persistence")) |
| pipes = [] |
| for p in cfg["paths"]: |
| pipe = BaseChronosPipeline.from_pretrained(p, device_map="cuda", torch_dtype=torch.bfloat16) |
| pipes.append(pipe) |
| print(f"[load] {p}", flush=True) |
| t0 = time.time() |
| m = ensemble_forecast(pipes, bas, cfg["on"], cfg["context"], cfg["horizon"], cfg.get("batch_size", 16)) |
| m["eval_s"] = round(time.time() - t0, 1) |
| print("METRIC:", json.dumps({k: (round(v, 4) if isinstance(v, (int, float)) and not isinstance(v, bool) else v) |
| for k, v in m.items() if k != "per_ba"} | {"per_ba": m.get("per_ba")})) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
