Datasets:
File size: 7,078 Bytes
b47743b | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 | """PROMPT_SIGUIENTE Step A: pre-2019 backtest of the new candidates (code/models_extra.py) and the
per-metric weighted ensemble.
* New models are scored with the unchanged backtest.run() (origins 1990..2011, 7-year horizon). Their
predictions are cached in results/extra_backtest/preds/<model>.parquet.
* Weighted ensemble, per metric, of four components: the current model ("ours"), the ARIMA ensemble B, the
best ETS variant for that metric (highest mean S_m) and the hierarchical model. Weights are non-negative,
sum to 1, on a 0.1 grid (286 combinations), chosen by the mean S_m over the 6 origins.
Overfitting check: weights chosen on origins 1990-2006 only, then evaluated on the 2011 origin.
Outputs: results/extra_backtest/{summary.csv, metrics_by_origin.csv, ensemble_weights.csv, holdout_check.csv}
Run: python code/extra_backtest.py [--force]
"""
import argparse
import itertools
import time
import warnings
warnings.filterwarnings("ignore")
import numpy as np
import pandas as pd
import backtest
import models_extra as mx
from arima_backtest import PREDS as ARIMA_PREDS
from backtest import COORDS, H, LV, ORIGINS
from common import METRICS, ROOT
OUT = ROOT / "results" / "extra_backtest"
PREDS = OUT / "preds"
ALL = list(METRICS)
TEMP = ["annual_avg_temp"]
NEW = {
"ets_holt": (mx.ets_holt, {}, ALL),
"ets_damped": (mx.ets_damped, {}, ALL),
"ets_pooled": (mx.ets_pooled, {}, ALL),
"hierarchical": (mx.hierarchical, {}, ALL),
"tmax_tmin": (mx.tmax_tmin, dict(slope_scale=1.25), TEMP),
"tmax_tmin_s1": (mx.tmax_tmin, dict(slope_scale=1.0), TEMP),
}
ETS = ["ets_holt", "ets_damped", "ets_pooled"]
GRID = [w for w in itertools.product(range(11), repeat=4) if sum(w) == 10] # tenths, 286 combos
COMPONENTS = ["ours", "arima_ensemble_B", "best_ets", "hierarchical"]
def years_for(o):
return list(range(o + 1, min(o + H, 2018) + 1))
def compute(name, force=False):
f = PREDS / f"{name}.parquet"
if f.exists() and not force:
return pd.read_parquet(f)
fn, kw, mets = NEW[name]
parts = []
for m in mets:
for o in ORIGINS:
p = fn(LV, o, years_for(o), COORDS, m, **kw)[["ID", "metric", "Year", "pred"]].assign(origin=o)
p.attrs = {}
parts.append(p)
df = pd.concat(parts, ignore_index=True)
df.to_parquet(f)
return df
def as_series(df):
return df.set_index(["ID", "metric", "Year", "origin"]).pred
def run_cached(pred: pd.Series, metric, origins=ORIGINS):
p = pred.rename("pred").reset_index()
def fn(lv, o, yrs, coords, m):
return p[(p.origin == o) & (p.metric == m) & p.Year.isin(yrs)][["ID", "metric", "Year", "pred"]]
return backtest.run(fn, metric, origins=origins).set_index("origin").S
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--force", action="store_true")
args = ap.parse_args()
PREDS.mkdir(parents=True, exist_ok=True)
P = {}
for name in NEW:
t0 = time.time()
P[name] = as_series(compute(name, args.force))
print(f"{name:14s} {time.time() - t0:6.1f}s", flush=True)
ours = as_series(pd.read_parquet(ARIMA_PREDS / "ours.parquet"))
pa49 = as_series(pd.read_parquet(ARIMA_PREDS / "pooled_auto_at_1949.parquet"))
ensB = ours.copy()
tm = ensB.index.get_level_values("metric") == "annual_avg_temp"
ensB[tm] = (0.75 * ours + 0.25 * pa49).reindex(ensB.index)[tm]
P["ours"], P["arima_ensemble_B"] = ours, ensB
rows = []
S = {}
for name, pred in P.items():
for m in ALL:
if m not in pred.index.get_level_values("metric"):
continue
s = run_cached(pred, m)
S[(name, m)] = s
rows += [dict(model=name, metric=m, origin=o, S=v) for o, v in s.items()]
mo = pd.DataFrame(rows)
mo.to_csv(OUT / "metrics_by_origin.csv", index=False)
# weighted ensemble per metric
wrows, hold, ens_parts = [], [], []
for m in ALL:
best_ets = max(ETS, key=lambda n: S[(n, m)].mean())
comps = {"ours": P["ours"], "arima_ensemble_B": P["arima_ensemble_B"], "best_ets": P[best_ets], "hierarchical": P["hierarchical"]}
X = pd.concat([c.xs(m, level="metric", drop_level=False) for c in comps.values()], axis=1, keys=COMPONENTS).dropna()
def evaluate(w, origins):
return run_cached(pd.Series(X.to_numpy() @ (np.array(w) / 10), index=X.index), m, origins)
# S per origin for every grid point, computed once on all origins
res = {w: evaluate(w, ORIGINS) for w in GRID}
full = max(GRID, key=lambda w: (res[w].mean(), -sum(1 for x in w if x)))
early = max(GRID, key=lambda w: (res[w].loc[ORIGINS[:-1]].mean(), -sum(1 for x in w if x)))
wrows.append(dict(metric=m, best_ets=best_ets, **{f"w_{c}": full[i] / 10 for i, c in enumerate(COMPONENTS)},
S_mean=res[full].mean(), S_2011=res[full].loc[2011],
S_mean_ours=S[("ours", m)].mean(), S_2011_ours=S[("ours", m)].loc[2011]))
hold.append(dict(metric=m, **{f"w_{c}": early[i] / 10 for i, c in enumerate(COMPONENTS)},
S_1990_2006_fit=res[early].loc[ORIGINS[:-1]].mean(), S_2011_holdout=res[early].loc[2011],
S_2011_ours=S[("ours", m)].loc[2011], S_2011_fullweights=res[full].loc[2011]))
ens_parts.append(pd.Series(X.to_numpy() @ (np.array(full) / 10), index=X.index))
for o, v in res[full].items():
mo.loc[len(mo)] = dict(model="weighted_ensemble", metric=m, origin=o, S=v)
W = pd.DataFrame(wrows)
W.to_csv(OUT / "ensemble_weights.csv", index=False)
Hd = pd.DataFrame(hold)
Hd.to_csv(OUT / "holdout_check.csv", index=False)
pd.concat(ens_parts).rename("pred").reset_index().to_parquet(PREDS / "weighted_ensemble.parquet")
mo.to_csv(OUT / "metrics_by_origin.csv", index=False)
summ = mo.groupby(["model", "metric"]).S.agg(S_mean="mean").reset_index()
summ = summ.merge(mo[mo.origin == 2011].rename(columns={"S": "S_2011"})[["model", "metric", "S_2011"]], on=["model", "metric"])
summ.to_csv(OUT / "summary.csv", index=False)
full_models = [n for n in summ.model.unique() if (summ.model == n).sum() == 4]
sc = mo[mo.model.isin(full_models)].groupby(["model", "origin"]).S.mean().clip(lower=0).mul(100).unstack()
sc["mean"] = sc[ORIGINS].mean(1)
sc.sort_values("mean", ascending=False).to_csv(OUT / "score_by_origin.csv")
pd.set_option("display.width", 220)
print("\nMean S_m (6 origins):\n", summ.pivot(index="model", columns="metric", values="S_mean")[ALL].round(4).to_string())
print("\nS_m at 2011:\n", summ.pivot(index="model", columns="metric", values="S_2011")[ALL].round(4).to_string())
print("\nComposite Score:\n", sc.sort_values("mean", ascending=False).round(2).to_string())
print("\nEnsemble weights (all 6 origins):\n", W.round(4).to_string(index=False))
print("\nHoldout check (weights from 1990-2006, scored on 2011):\n", Hd.round(4).to_string(index=False))
if __name__ == "__main__":
main()
|