Datasets:
Download code/arima_backtest.py from sleonca/sl-protostar-climate-ceviche: direct link, hf CLI and curl.
- Browser
- Download file 15.1 kB
-
https://huggingface.co/datasets/sleonca/sl-protostar-climate-ceviche/resolve/main/code/arima_backtest.py
- Command line
-
hf download hf://datasets/sleonca/sl-protostar-climate-ceviche/code/arima_backtest.py
-
curl -L -o arima_backtest.py https://huggingface.co/datasets/sleonca/sl-protostar-climate-ceviche/resolve/main/code/arima_backtest.py
15.1 kB
| """Step 8 of the ARIMA experiments: rolling-origin backtest on pre-2019 data only. | |
| Origins 1990, 1994, 1998, 2002, 2006, 2011 with a 7-year horizon (backtest.ORIGINS / backtest.H). | |
| No random K-fold: every model sees only data up to its origin. | |
| * Each model's predictions for every (metric, origin) are computed once and cached in | |
| results/arima_backtest/preds/<model>.parquet (delete the folder, or pass --force, to recompute). | |
| * The official MAE and skill S_m come from backtest.run() (unchanged), fed the cached predictions. | |
| * On the same rows (valid years, cities with a 30-year baseline) we add RMSE, MAPE, mean bias | |
| (forecast - actual) and MAE by horizon (1-7 years). | |
| * Composite Score per origin = 100 x max(0, mean of the four S_m), averaged over origins, | |
| as in 02_backtest.py; computed for models that cover all four metrics. | |
| * Reference models: last year repeated, 30-year average, 30-year linear trend, and our current | |
| model (final_model.forecast). | |
| Outputs: results/arima_backtest/{metrics_by_origin.csv, summary.csv, score_by_origin.csv, | |
| mae_by_horizon.csv, fallbacks.csv, *.png} and results/arima_orders.csv. | |
| Run: python code/arima_backtest.py [--force] [--only name1,name2] | |
| """ | |
| import argparse | |
| import time | |
| import warnings | |
| warnings.filterwarnings("ignore") | |
| import matplotlib | |
| matplotlib.use("Agg") | |
| import matplotlib.pyplot as plt | |
| import numpy as np | |
| import pandas as pd | |
| import backtest | |
| import final_model | |
| import models | |
| import models_arima as ma | |
| from arima_prep import EDA_CITIES | |
| from backtest import COORDS, H, LV, ORIGINS | |
| from common import METRICS, ROOT, baseline30 | |
| OUT = ROOT / "results" / "arima_backtest" | |
| PREDS = OUT / "preds" | |
| ALL = list(METRICS) | |
| def last_year(lv, o, yrs, coords, metric): # identical to 02_backtest.last_year | |
| W = models.wide(lv, metric, o) | |
| last = W.ffill(axis=1).iloc[:, -1] | |
| return pd.concat([pd.DataFrame({"ID": W.index, "metric": metric, "Year": y, "pred": last.values}) for y in yrs]) | |
| def P(fn, metrics=ALL, **kw): | |
| return dict(fn=fn, kw=kw, metrics=metrics) | |
| MODELS = { | |
| # reference models | |
| "last_year": P(last_year), | |
| "avg_30yr": P(models.baseline30_model), | |
| "linear_trend": P(models.linear30_model), | |
| "ours": P(final_model.forecast), | |
| # fixed orders proposed by ACF/PACF (Step 5), 50-year window | |
| "arima_000_ct": P(ma.arima_fixed, order=(0, 0, 0), trend="ct"), | |
| "arima_100_ct": P(ma.arima_fixed, order=(1, 0, 0), trend="ct"), | |
| "arima_101_ct": P(ma.arima_fixed, order=(1, 0, 1), trend="ct"), | |
| "arima_100_c": P(ma.arima_fixed, order=(1, 0, 0), trend="c"), | |
| "arima_010_drift": P(ma.arima_fixed, order=(0, 1, 0), trend="c"), | |
| "arima_011_drift": P(ma.arima_fixed, order=(0, 1, 1), trend="c"), | |
| "arima_111_drift": P(ma.arima_fixed, order=(1, 1, 1), trend="c"), | |
| # auto-ARIMA (pmdarima, stepwise AICc, p,q <= 3, d <= 1) | |
| "auto_kpss": P(ma.auto_arima_model, test="kpss", trend0="ct"), | |
| "auto_kpss_c": P(ma.auto_arima_model, test="kpss", trend0="c"), | |
| "auto_adf": P(ma.auto_arima_model, test="adf", trend0="ct"), | |
| "auto_d0_ct": P(ma.auto_arima_d0_trend, trend0="ct"), | |
| "auto_d0_c": P(ma.auto_arima_d0_trend, trend0="c"), | |
| # ARMA around the pooled (all-city, 50-yr) trend rate | |
| "pooled_auto": P(ma.pooled_trend_arima), | |
| "pooled_000": P(ma.pooled_trend_arima, order=(0, 0, 0)), | |
| # training-window length (named by the start year at origin 2018) | |
| "auto_kpss@1949": P(ma.auto_arima_model, test="kpss", trend0="ct", train_start=1949), | |
| "auto_kpss@1979": P(ma.auto_arima_model, test="kpss", trend0="ct", train_start=1979), | |
| "auto_d0_ct@1949": P(ma.auto_arima_d0_trend, trend0="ct", train_start=1949), | |
| "auto_d0_ct@1979": P(ma.auto_arima_d0_trend, trend0="ct", train_start=1979), | |
| "pooled_auto@1949": P(ma.pooled_trend_arima, train_start=1949), | |
| "pooled_auto@1979": P(ma.pooled_trend_arima, train_start=1979), | |
| # CDD from the ARIMA temperature forecast (pooled_auto) + shifted daily weather | |
| "cdd_hybrid_N10": P(ma.cdd_hybrid, metrics=["cdd"], N=10), | |
| "cdd_hybrid_N20": P(ma.cdd_hybrid, metrics=["cdd"], N=20), | |
| } | |
| REFERENCE = ["last_year", "avg_30yr", "linear_trend", "ours"] | |
| # fixed colour per model (validated categorical palette, fixed order); 30-yr average = neutral grey | |
| COLORS = {"ours": "#2a78d6", "arima_011_drift": "#eb6834", "arima_100_ct": "#1baf7a", | |
| "linear_trend": "#eda100", "auto_kpss": "#e87ba4", "auto_d0_ct": "#008300", | |
| "pooled_auto": "#6250d6", "cdd_hybrid_N10": "#e34948", "avg_30yr": "#77776f"} | |
| PLOT_MODELS = list(COLORS) | |
| def years_for(o): | |
| return list(range(o + 1, min(o + H, 2018) + 1)) | |
| def compute_preds(name, spec, force=False): | |
| f = PREDS / f"{name.replace('@', '_at_')}.parquet" | |
| if f.exists() and not force: | |
| return pd.read_parquet(f), None | |
| parts, logs = [], [] | |
| for m in spec["metrics"]: | |
| for o in ORIGINS: | |
| p = spec["fn"](LV, o, years_for(o), COORDS, m, **spec["kw"]) | |
| lg = p.attrs.get("log") | |
| if lg is not None and len(lg): | |
| logs.append(lg.assign(model=name, metric=m, origin=o)) | |
| q = p[["ID", "metric", "Year", "pred"]].assign(origin=o) | |
| q.attrs = {} # the log travels separately; pandas compares attrs on concat | |
| parts.append(q) | |
| df = pd.concat(parts, ignore_index=True) | |
| df.to_parquet(f) | |
| return df, (pd.concat(logs, ignore_index=True) if logs else None) | |
| def official(name, preds, metric): | |
| """MAE and S_m through the unchanged backtest.run(), fed the cached predictions.""" | |
| def cached(lv, o, yrs, coords, m): | |
| return preds[(preds.origin == o) & (preds.metric == m) & preds.Year.isin(yrs)][["ID", "metric", "Year", "pred"]] | |
| return backtest.run(cached, metric) | |
| def detail(preds, metric): | |
| """Per-row errors on exactly the rows common.score() uses.""" | |
| rows = [] | |
| for o in ORIGINS: | |
| yrs = years_for(o) | |
| lvm = LV[LV.metric == metric] | |
| truth = lvm[lvm.Year.isin(yrs) & lvm.valid][["ID", "metric", "Year", "value"]] | |
| b = baseline30(lvm, o).rename("base").reset_index() | |
| df = truth.merge(b, on=["ID", "metric"]).dropna(subset=["base"]) | |
| df = df.merge(preds[(preds.origin == o) & (preds.metric == metric)].drop(columns="origin"), | |
| on=["ID", "metric", "Year"], how="left") | |
| rows.append(df.assign(origin=o, h=df.Year - o, e=df.pred - df.value, eb=df.base - df.value)) | |
| return pd.concat(rows, ignore_index=True) | |
| def stats(d): | |
| ae = d.e.abs() | |
| nz = d.value.abs() > 1e-9 | |
| return pd.Series(dict(n=len(d), MAE=ae.mean(), RMSE=np.sqrt((d.e ** 2).mean()), | |
| MAPE=100 * (ae[nz] / d.value.abs()[nz]).mean(), bias=d.e.mean(), | |
| MAE_base=d.eb.abs().mean(), S=1 - ae.mean() / d.eb.abs().mean())) | |
| # --------------------------------------------------------------------------- plots | |
| def style(ax): | |
| ax.grid(axis="y", color="#e4e4e0", lw=0.8); ax.set_axisbelow(True) | |
| for s in ("top", "right"): | |
| ax.spines[s].set_visible(False) | |
| ax.spines["left"].set_color("#b8b8b0"); ax.spines["bottom"].set_color("#b8b8b0") | |
| ax.tick_params(colors="#55554f", labelsize=8) | |
| def plot_bars(summary): | |
| fig, axes = plt.subplots(1, 4, figsize=(18, 0.32 * summary.model.nunique() + 2), sharey=True) | |
| order = summary[summary.metric == "annual_avg_temp"].sort_values("S").model.tolist() | |
| order += [m for m in summary.model.unique() if m not in order] | |
| for ax, m in zip(axes, ALL): | |
| s = summary[summary.metric == m].set_index("model").reindex(order) | |
| col = [COLORS.get(k, "#9d9d95") for k in s.index] | |
| ax.barh(range(len(s)), s.S.values, color=col, height=0.7, edgecolor="white", linewidth=1) | |
| ax.axvline(0, color="#55554f", lw=0.8) | |
| ref = s.S.get("ours", np.nan) | |
| if np.isfinite(ref): | |
| ax.axvline(ref, color=COLORS["ours"], lw=1, ls="--") | |
| ax.set_yticks(range(len(s))); ax.set_yticklabels(s.index, fontsize=8) | |
| ax.set_title(f"{m}: mean S_m over 6 origins", fontsize=10); style(ax) | |
| ax.set_xlim(max(-0.4, np.nanmin(s.S.values) - 0.02), None) | |
| for i, v in enumerate(s.S.values): | |
| if np.isfinite(v): | |
| ax.text(v, i, f" {v:.3f}", va="center", fontsize=6.5, color="#2b2b28") | |
| fig.suptitle("Skill vs 30-year average (S_m = 1 - MAE/MAE_30yr); dashed = current model; " | |
| "bars clipped at -0.4", fontsize=11) | |
| fig.tight_layout(); fig.savefig(OUT / "skill_by_model_metric.png", dpi=110); plt.close(fig) | |
| def plot_score_lines(score): | |
| fig, ax = plt.subplots(figsize=(10, 5.5)) | |
| for name in PLOT_MODELS: | |
| if name not in score.index: | |
| continue | |
| r = score.loc[name, ORIGINS] | |
| ax.plot(ORIGINS, r.values, marker="o", ms=5, lw=2 if name == "ours" else 1.5, | |
| color=COLORS[name], ls="--" if name == "avg_30yr" else "-", label=f"{name} (mean {score.loc[name, 'mean']:.1f})") | |
| ax.set_xticks(ORIGINS); ax.set_xlabel("forecast origin (forecasts origin+1 .. origin+7)") | |
| ax.set_ylabel("composite Score (0-100)"); style(ax) | |
| ax.legend(fontsize=8, frameon=False, loc="upper left") | |
| ax.set_title("Composite Score by origin", fontsize=11) | |
| fig.tight_layout(); fig.savefig(OUT / "score_by_origin.png", dpi=110); plt.close(fig) | |
| def plot_horizon(hz): | |
| fig, axes = plt.subplots(1, 4, figsize=(18, 4.5)) | |
| for ax, m in zip(axes, ALL): | |
| for name in PLOT_MODELS: | |
| s = hz[(hz.model == name) & (hz.metric == m)] | |
| if len(s): | |
| ax.plot(s.h, s.MAE, marker="o", ms=4, lw=1.5, color=COLORS[name], | |
| ls="--" if name == "avg_30yr" else "-", label=name) | |
| ax.set_title(m, fontsize=10); ax.set_xlabel("horizon (years ahead)"); ax.set_xticks(range(1, 8)); style(ax) | |
| axes[0].set_ylabel("MAE (pooled over origins)") | |
| h, l = axes[3].get_legend_handles_labels() | |
| fig.legend(h, l, loc="lower center", ncol=len(l), fontsize=8, frameon=False) | |
| fig.tight_layout(rect=(0, 0.07, 1, 1)); fig.savefig(OUT / "mae_by_horizon.png", dpi=110); plt.close(fig) | |
| def plot_cities(allpreds, cities=("USW00094823", "USW00023183", "USW00024233")): | |
| for cid in cities: | |
| fig, axes = plt.subplots(4, 1, figsize=(13, 13), sharex=True) | |
| for ax, m in zip(axes, ALL): | |
| t = LV[(LV.ID == cid) & (LV.metric == m) & (LV.Year >= 1970) & LV.valid] | |
| ax.plot(t.Year, t.value, color="#2b2b28", lw=1.2, marker=".", ms=4, label="actual") | |
| for name in PLOT_MODELS: | |
| p = allpreds.get(name) | |
| if p is None: | |
| continue | |
| p = p[(p.ID == cid) & (p.metric == m)] | |
| for i, o in enumerate(ORIGINS): | |
| q = p[p.origin == o].sort_values("Year") | |
| ax.plot(q.Year, q.pred, color=COLORS[name], lw=1.5, ls="--" if name == "avg_30yr" else "-", | |
| label=name if i == 0 else None) | |
| for o in ORIGINS: | |
| ax.axvline(o + 0.5, color="#d0d0c8", lw=0.8) | |
| ax.set_title(f"{EDA_CITIES[cid]} - {m}", fontsize=10); style(ax) | |
| h, l = axes[3].get_legend_handles_labels() | |
| fig.legend(h, l, loc="lower center", ncol=len(l), fontsize=8, frameon=False) | |
| fig.suptitle("Actual series and each model's 7-year forecasts from every backtest origin (grey lines = origins)", fontsize=11) | |
| fig.tight_layout(rect=(0, 0.03, 1, 0.98)) | |
| fig.savefig(OUT / f"forecasts_{EDA_CITIES[cid].lower()}.png", dpi=100); plt.close(fig) | |
| # --------------------------------------------------------------------------- main | |
| def main(): | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument("--force", action="store_true") | |
| ap.add_argument("--only", default="") | |
| args = ap.parse_args() | |
| PREDS.mkdir(parents=True, exist_ok=True) | |
| names = [n for n in MODELS if not args.only or n in args.only.split(",")] | |
| orders_f = ROOT / "results" / "arima_orders.csv" | |
| old_orders = pd.read_csv(orders_f) if orders_f.exists() else pd.DataFrame(columns=["model"]) | |
| allpreds, new_logs, rows, dets = {}, [], [], [] | |
| for name in names: | |
| t0 = time.time() | |
| preds, lg = compute_preds(name, MODELS[name], args.force) | |
| allpreds[name] = preds | |
| if lg is not None: | |
| new_logs.append(lg) | |
| for m in MODELS[name]["metrics"]: | |
| off = official(name, preds, m) | |
| d = detail(preds, m) | |
| for o in ORIGINS: | |
| s = stats(d[d.origin == o]) | |
| r = off[off.origin == o].iloc[0] | |
| assert abs(s.MAE - r.mae) < 1e-9 and abs(s.S - r.S) < 1e-9, (name, m, o) | |
| rows.append(dict(model=name, metric=m, origin=o, **s)) | |
| dets.append(d.assign(model=name)[["model", "metric", "origin", "h", "e", "eb"]]) | |
| print(f"{name:18s} {time.time() - t0:6.1f}s", flush=True) | |
| if new_logs: | |
| nl = pd.concat(new_logs, ignore_index=True) | |
| old_orders = old_orders[~old_orders.model.isin(nl.model.unique())] | |
| pd.concat([old_orders, nl], ignore_index=True).to_csv(orders_f, index=False) | |
| orders = pd.read_csv(orders_f) if orders_f.exists() else None | |
| mo = pd.DataFrame(rows) | |
| mo.to_csv(OUT / "metrics_by_origin.csv", index=False) | |
| summary = mo.groupby(["model", "metric"], sort=False)[["MAE", "RMSE", "MAPE", "bias", "S"]].mean().reset_index() | |
| s2011 = mo[mo.origin == 2011].set_index(["model", "metric"]).S.rename("S_2011") | |
| summary = summary.join(s2011, on=["model", "metric"]) | |
| summary.to_csv(OUT / "summary.csv", index=False) | |
| full = [n for n in names if set(MODELS[n]["metrics"]) == set(ALL)] | |
| score = (mo[mo.model.isin(full)].groupby(["model", "origin"]).S.mean().clip(lower=0).mul(100).unstack()) | |
| score["mean"] = score[ORIGINS].mean(1) | |
| score = score.sort_values("mean", ascending=False) | |
| score.to_csv(OUT / "score_by_origin.csv") | |
| det = pd.concat(dets, ignore_index=True) | |
| hz = det.groupby(["model", "metric", "h"]).apply(lambda d: d.e.abs().mean(), include_groups=False).rename("MAE").reset_index() | |
| hz.to_csv(OUT / "mae_by_horizon.csv", index=False) | |
| if orders is not None and len(orders): | |
| fb = (orders.assign(fallback=orders.status != "ok") | |
| .groupby(["model", "metric"]).agg(series=("ID", "size"), fallback=("fallback", "sum"), | |
| weak=("status", lambda s: (s == "weak").sum()), | |
| failed=("status", lambda s: s.str.startswith("failed").sum()))) | |
| fb.to_csv(OUT / "fallbacks.csv") | |
| pd.set_option("display.width", 250); pd.set_option("display.max_rows", 200) | |
| print("\nComposite Score by origin:\n", score.round(1).to_string()) | |
| print("\nMean S_m by metric (and origin 2011):") | |
| print(summary.pivot(index="model", columns="metric", values="S")[ALL].round(3).to_string()) | |
| print(summary.pivot(index="model", columns="metric", values="S_2011")[ALL].round(3).to_string()) | |
| if len(names) == len(MODELS): | |
| plot_bars(summary); plot_score_lines(score); plot_horizon(hz); plot_cities(allpreds) | |
| if __name__ == "__main__": | |
| main() | |