Datasets:
Download code/protostar/backtest.py from AlecAlameddine/protostar-climate: direct link, hf CLI and curl.
- Browser
- Download file 22.7 kB
-
https://huggingface.co/datasets/AlecAlameddine/protostar-climate/resolve/main/code/protostar/backtest.py
- Command line
-
hf download hf://datasets/AlecAlameddine/protostar-climate/code/protostar/backtest.py
-
curl -L -o backtest.py https://huggingface.co/datasets/AlecAlameddine/protostar-climate/resolve/main/code/protostar/backtest.py
22.7 kB
| """Backtest harness and model selection. | |
| Folds simulate the real task (train up to an origin, forecast the next 7 years): | |
| selection folds <=2011 -> 2012-2018 and <=2004 -> 2005-2011 (candidates are ranked here) | |
| confirmation folds <=1997 -> 1998-2004 and <=1990 -> 1991-1997 (veto only, never ranking) | |
| practice fold <=2010 -> 2011-2018 (organizers' published numbers) | |
| Selection climbs a ladder per metric: climatology -> trend (pooled slope; for cdd also the | |
| regression on forecast temperature, competing on the same rung) -> blend. The best candidate of a rung (mean skill over | |
| the two selection folds) replaces the incumbent only if | |
| 1. its gain is positive on BOTH selection folds (i.e. larger than one fold-to-fold | |
| standard error) and larger than 2 standard errors of a paired bootstrap over cities, and | |
| 2. it does not lose to the 30-year average on the confirmation folds (mean skill >= 0). | |
| Otherwise the simpler model stays ("stop adding complexity when gains < noise"). | |
| Writes reports/backtest/{candidates.csv, table.csv, selected.json, BACKTEST.md}. | |
| Run: PYTHONPATH=code python -m protostar.backtest | |
| """ | |
| import json | |
| import numpy as np | |
| import pandas as pd | |
| from .common import (BASELINE_WINDOW, CONFIRMATION_FOLDS, METRICS, MIN_VALID_YEARS, PRACTICE_FOLD, | |
| REPORTS, SEED, SELECTION_FOLDS, UNITS) | |
| from .data import Panel, cities, load_annual, long_table, panels | |
| from .models import BASELINES, neighbor_order, predict, window_mean | |
| from .scoring import challenge_score, skill | |
| OUT = REPORTS / "backtest" | |
| N_BOOT = 2000 | |
| SE_MULT = 2.0 # a rung must gain more than this many standard errors | |
| K_GRID = (8, 16, 32) # nearest cities pooled for the slope | |
| LAM_GRID = (0.0, 0.25, 0.5, 0.75, 1.0) # weight of the city's own slope | |
| W_STEP = 0.1 # blend weights on a simplex grid | |
| def key(spec: dict) -> str: | |
| return json.dumps(spec, sort_keys=True) | |
| class Fold: | |
| """One origin: training panels, truth, scored rows, and cached per-city errors.""" | |
| def __init__(self, P: dict[str, Panel], origin: int, first: int, last: int, | |
| min_valid: int = MIN_VALID_YEARS): | |
| self.origin, self.first, self.last = origin, first, last | |
| self.name = f"<={origin} -> {first}-{last}" | |
| self.years = np.arange(first, last + 1) | |
| self.train = {m: p.upto(origin) for m, p in P.items()} | |
| truth = {m: p.between(first, last).y for m, p in P.items()} | |
| self.truth = truth | |
| # scored = valid test year of a city-metric that has a 30-year-average baseline | |
| self.scored = {m: (np.isfinite(window_mean(self.train[m], BASELINE_WINDOW, min_valid))[:, None] | |
| & np.isfinite(truth[m])) for m in P} | |
| # the reference of the skill: the 30-year average under this fold's minimum of valid years | |
| self.ref = {"type": "mean", "n": BASELINE_WINDOW, "min_valid": min_valid} | |
| self._cache = {} | |
| def predict(self, spec: dict, metric: str, order: np.ndarray) -> np.ndarray: | |
| """Forecast of `spec` for the test years, from the training panels only.""" | |
| return predict(spec, self.train, metric, order, self.years) | |
| def errors(self, spec: dict, metric: str, order: np.ndarray): | |
| """(sum of |error| per city, scored rows per city) of `spec` on this fold.""" | |
| k = (metric, key(spec)) | |
| if k not in self._cache: | |
| pred = self.predict(spec, metric, order) | |
| mask = self.scored[metric] | |
| err = np.abs(np.where(mask, pred - self.truth[metric], 0.0)) | |
| assert np.isfinite(err).all(), f"non-finite prediction on a scored row: {spec}" | |
| self._cache[k] = (err.sum(axis=1), mask.sum(axis=1)) | |
| return self._cache[k] | |
| def mae(self, spec, metric, order) -> float: | |
| s, n = self.errors(spec, metric, order) | |
| return float(s.sum() / n.sum()) | |
| def skill(self, spec, metric, order) -> float: | |
| return skill(self.mae(spec, metric, order), self.mae(self.ref, metric, order)) | |
| def bias(self, spec, metric, order) -> float: | |
| """Mean signed error (forecast - actual) over the scored rows, as a share of the mean actual.""" | |
| mask = self.scored[metric] | |
| diff = np.where(mask, self.predict(spec, metric, order) - self.truth[metric], 0.0) | |
| return float(diff.sum() / np.where(mask, self.truth[metric], 0.0).sum()) | |
| class Harness: | |
| def __init__(self, P: dict[str, Panel], order: np.ndarray): | |
| self.P, self.order = P, order | |
| self.sel = [Fold(P, *f) for f in SELECTION_FOLDS] | |
| self.hold = [Fold(P, *f) for f in CONFIRMATION_FOLDS] | |
| rng = np.random.default_rng(SEED) | |
| n = len(order) | |
| self.boot = rng.multinomial(n, np.full(n, 1.0 / n), size=N_BOOT).astype(float) # [B, C] | |
| # mean skill over the selection folds, and its per-fold values | |
| def skills(self, spec, metric, folds=None): | |
| return [f.skill(spec, metric, self.order) for f in (folds or self.sel)] | |
| def mean_skill(self, spec, metric) -> float: | |
| return float(np.mean(self.skills(spec, metric))) | |
| def paired(self, spec_a, spec_b, metric): | |
| """Gain of a over b in mean selection-fold skill: (gain, bootstrap SE, per-fold gains).""" | |
| per_fold, boot = [], np.zeros(N_BOOT) | |
| for f in self.sel: | |
| (sa, n), (sb, _), (sr, _) = (f.errors(s, metric, self.order) for s in (spec_a, spec_b, f.ref)) | |
| per_fold.append(float((sb.sum() - sa.sum()) / sr.sum())) | |
| boot += (self.boot @ (sb - sa)) / (self.boot @ sr) / len(self.sel) | |
| return float(np.mean(per_fold)), float(boot.std(ddof=1)), per_fold | |
| def best(self, specs, metric): | |
| return max(specs, key=lambda s: self.mean_skill(s, metric)) | |
| # ── Candidate families ─────────────────────────────────────────────────────── | |
| RECENT = {"type": "recent", "n": 10} # 10-year mean (2009-2018 for complete records) | |
| LONG = {"type": "mean", "n": BASELINE_WINDOW} # 30-year mean (1989-2018) | |
| def climatology_specs(): | |
| return [LONG, RECENT] | |
| def sensitivity_specs(metric): | |
| """Not used for selection: how much the choices of window, k and pooling matter.""" | |
| out = [{"type": "mean", "n": n, "min_valid": min(MIN_VALID_YEARS, n // 2)} for n in (15, 20, 40, 50)] | |
| out += [{"type": "ptrend", "n": n, "k": k, "lam": lam} | |
| for n, k, lam in ((30, 64, 0.5), (30, 0, 0.5), (30, 0, 0.0), (40, 32, 0.5), (40, 0, 0.5), (50, 32, 0.5))] | |
| if metric == "cdd": | |
| out += [{"type": "blend", "parts": [[0.5, {"type": "ptrend", "n": 30, "k": 32, "lam": 0.5}], | |
| [0.5, {"type": "cdd_via_temp", "n": 30, | |
| "temp": {"type": "ptrend", "n": 30, "k": 32, "lam": 0.5}}]]}] | |
| return out | |
| def trend_specs(k_grid=K_GRID): | |
| return [{"type": "ptrend", "n": BASELINE_WINDOW, "k": k, "lam": lam} | |
| for k in k_grid for lam in LAM_GRID if not (lam == 1.0 and k != k_grid[0])] | |
| def blend_specs(recent, long, trend): | |
| steps = int(round(1 / W_STEP)) | |
| out = [] | |
| for i in range(steps + 1): | |
| for j in range(steps + 1 - i): | |
| w = (i / steps, j / steps, (steps - i - j) / steps) | |
| parts = [[wi, s] for wi, s in zip(w, (recent, long, trend)) if wi > 0] | |
| if len(parts) > 1: | |
| out.append({"type": "blend", "parts": parts}) | |
| return out | |
| def label(spec: dict) -> str: | |
| t = spec["type"] | |
| if t == "mean": | |
| return f"{spec['n']}-year mean" | |
| if t == "recent": | |
| return f"mean of last {spec['n']} valid years" | |
| if t == "last": | |
| return "last year repeated" | |
| if t == "ols": | |
| return f"per-city OLS line ({spec['n']} y)" | |
| if t == "ptrend": | |
| k = "all" if spec["k"] == 0 else spec["k"] | |
| window = "" if spec["n"] == BASELINE_WINDOW else f"{spec['n']} y, " | |
| return f"pooled trend ({window}k={k}, own-slope weight {spec['lam']:g})" | |
| if t == "cdd_via_temp": | |
| window = "" if spec["n"] == BASELINE_WINDOW else f" ({spec['n']} y)" | |
| return f"cdd ~ temp regression{window} on [{label(spec['temp'])}]" | |
| if t == "blend": | |
| return "blend: " + " + ".join(f"{w:g} x [{label(s)}]" for w, s in spec["parts"]) | |
| return t | |
| # ── Selection ladder ───────────────────────────────────────────────────────── | |
| def climb(h: Harness, metric: str, rungs: list[tuple[str, list[dict]]], log: list[dict]) -> dict: | |
| """Climb the ladder for one metric; returns the selected spec.""" | |
| incumbent = BASELINES["30-year average"] | |
| for rung, specs in rungs: | |
| cand = h.best(specs, metric) | |
| gain, se, per_fold = h.paired(cand, incumbent, metric) | |
| confirm = float(np.mean(h.skills(cand, metric, h.hold))) | |
| consistent = bool(gain > SE_MULT * se and min(per_fold) > 0) | |
| accept = bool(consistent and confirm >= 0) | |
| log.append({"metric": metric, "rung": rung, "candidate": label(cand), "spec": key(cand), | |
| "n_candidates": len(specs), "incumbent": label(incumbent), | |
| "gain_mean_skill": gain, "se_gain": se, | |
| **{f"gain_{f.name}": g for f, g in zip(h.sel, per_fold)}, | |
| "confirmation_mean_skill": confirm, | |
| "verdict": "accepted" if accept else | |
| ("vetoed: loses to the 30-year average on the confirmation folds" if consistent | |
| else "rejected: worse than the incumbent" if gain <= 0 | |
| else "rejected: gain within noise"), | |
| "accepted": accept}) | |
| if accept: | |
| incumbent = cand | |
| return incumbent | |
| def select(h: Harness): | |
| log, chosen, rung_best = [], {}, {} | |
| def ladder(metric, trend_like): | |
| rung_best[(metric, "climatology")] = RECENT | |
| rung_best[(metric, "trend")] = comp = h.best(trend_like, metric) | |
| blends = blend_specs(RECENT, LONG, comp) | |
| rung_best[(metric, "blend")] = h.best(blends, metric) | |
| rungs = [("1 climatology (10-year mean)", [RECENT]), | |
| ("2-3 trend" if metric == "cdd" else "2 pooled trend", trend_like), | |
| ("4 blend (recent, long, trend)", blends)] | |
| return climb(h, metric, rungs, log) | |
| chosen["annual_avg_temp"] = ladder("annual_avg_temp", trend_specs()) | |
| # cdd: the direct pooled trend and the regression on forecast temperature compete on one rung | |
| temps = {key(s): s for s in (chosen["annual_avg_temp"], rung_best[("annual_avg_temp", "trend")])} | |
| via = [{"type": "cdd_via_temp", "n": BASELINE_WINDOW, "temp": t} for t in temps.values()] | |
| chosen["cdd"] = ladder("cdd", trend_specs() + via) | |
| chosen["total_precip_in"] = ladder("total_precip_in", trend_specs()) | |
| chosen["hottest_day_temp"] = ladder("hottest_day_temp", trend_specs()) | |
| return chosen, pd.DataFrame(log), rung_best | |
| # ── Reporting ──────────────────────────────────────────────────────────────── | |
| def fold_row(f: Fold, name: str, system: dict[str, dict], order) -> dict: | |
| row = {"model": name, "fold": f.name} | |
| skills = {} | |
| for m in METRICS: | |
| row[f"mae_{m}"] = f.mae(system[m], m, order) | |
| skills[m] = f.skill(system[m], m, order) | |
| row[f"skill_{m}"] = skills[m] | |
| row[f"bias_{m}"] = f.bias(system[m], m, order) | |
| row["score"] = challenge_score(skills) | |
| row["n_rows"] = int(sum(f.scored[m].sum() for m in METRICS)) | |
| return row | |
| def systems(chosen: dict, rung_best: dict, h: Harness) -> dict[str, dict[str, dict]]: | |
| """Named full systems (one spec per metric) for the model x fold table.""" | |
| same = lambda s: {m: s for m in METRICS} | |
| out = {name: same(spec) for name, spec in BASELINES.items()} | |
| out["1 climatology: 10-year mean"] = same(RECENT) | |
| for k in K_GRID: | |
| out[f"2 pooled trend k={k}, own-slope weight 0.5"] = same({"type": "ptrend", "n": 30, "k": k, "lam": 0.5}) | |
| direct = {m: h.best(trend_specs(), m) for m in METRICS} | |
| out["2 pooled trend, best (k, weight) per metric"] = direct | |
| via = {"type": "cdd_via_temp", "n": BASELINE_WINDOW, "temp": chosen["annual_avg_temp"]} | |
| out["3 as 2, but cdd ~ temp regression on forecast temp"] = {**direct, "cdd": via} | |
| out["4 best blend (recent, long, trend) per metric"] = {m: rung_best[(m, "blend")] for m in METRICS} | |
| out["FINAL (selected per metric)"] = chosen | |
| return out | |
| def practice_check(P, order) -> pd.DataFrame: | |
| """Reproduce the organizers' practice-run numbers (train <= 2010, test 2011-2018). | |
| official rule: baselines need >= 10 valid years in 1981-2010 (About tab, Space discussion #3) | |
| notebook rule: no minimum; the line needs 2 valid years. The notebook scores its 10-year mean | |
| on every valid test row that has a forecast, 6 rows more than its reference. | |
| """ | |
| rows = [] | |
| for rule, mv, line_mv in (("official (>= 10 valid years in the window)", MIN_VALID_YEARS, MIN_VALID_YEARS), | |
| ("example notebook (no minimum)", 1, 2)): | |
| f = Fold(P, *PRACTICE_FOLD, min_valid=mv) | |
| for name, spec in (("30-year average", f.ref), | |
| ("Linear trend", {"type": "ols", "n": BASELINE_WINDOW, "min_valid": line_mv}), | |
| ("10-year mean", RECENT)): | |
| rows.append({"rule": rule, "model": name, **{m: f.mae(spec, m, order) for m in METRICS}}) | |
| f = Fold(P, *PRACTICE_FOLD, min_valid=1) | |
| own_rows = {} | |
| for m in METRICS: | |
| pred = predict(RECENT, f.train, m, order, f.years, fill=False) | |
| mask = np.isfinite(f.truth[m]) & np.isfinite(pred) | |
| own_rows[m] = float(np.abs(pred - f.truth[m])[mask].mean()) | |
| rows.append({"rule": "example notebook, scored on the rows the model covers", "model": "10-year mean", **own_rows}) | |
| return pd.DataFrame(rows) | |
| def md_table(df: pd.DataFrame, fmt: dict | None = None) -> str: | |
| fmt = fmt or {} | |
| cols = list(df.columns) | |
| lines = ["| " + " | ".join(cols) + " |", "|" + "|".join("---" for _ in cols) + "|"] | |
| for _, r in df.iterrows(): | |
| cells = [] | |
| for c in cols: | |
| v = r[c] | |
| cells.append(fmt[c].format(v) if c in fmt and pd.notna(v) else str(v)) | |
| lines.append("| " + " | ".join(cells) + " |") | |
| return "\n".join(lines) | |
| def main(): | |
| OUT.mkdir(parents=True, exist_ok=True) | |
| annual = load_annual() | |
| P = panels(long_table(annual)) | |
| geo = cities(annual) | |
| assert list(geo["city_id"]) == list(P["cdd"].city_ids) | |
| order = neighbor_order(geo["lat"].to_numpy(), geo["lon"].to_numpy()) | |
| h = Harness(P, order) | |
| practice = practice_check(P, order) | |
| chosen, log, rung_best = select(h) | |
| # every candidate on every fold (for the record) | |
| cands = [] | |
| for m in METRICS: | |
| used = (climatology_specs() + trend_specs() + list(BASELINES.values()) + [chosen[m]] | |
| + [json.loads(r["spec"]) for _, r in log[log["metric"] == m].iterrows()] | |
| + blend_specs(RECENT, LONG, rung_best[(m, "trend")])) | |
| specs = {key(s): ("selection", s) for s in used} | |
| specs.update({key(s): ("sensitivity only", s) for s in sensitivity_specs(m) if key(s) not in specs}) | |
| for role, s in specs.values(): | |
| for kind, folds in (("selection", h.sel), ("confirmation", h.hold)): | |
| for f in folds: | |
| cands.append({"metric": m, "model": label(s), "role": role, "fold": f.name, "fold_kind": kind, | |
| "n_rows": int(f.scored[m].sum()), "mae": f.mae(s, m, order), | |
| "mae_30y_average": f.mae(f.ref, m, order), | |
| "skill": f.skill(s, m, order), "spec": key(s)}) | |
| cands = pd.DataFrame(cands) | |
| assert not cands.duplicated(["metric", "model", "fold"]).any(), "two specs share a label" | |
| cands.to_csv(OUT / "candidates.csv", index=False) | |
| table = pd.DataFrame([fold_row(f, name, system, order) | |
| for name, system in systems(chosen, rung_best, h).items() | |
| for f in h.sel + h.hold]) | |
| table["fold_kind"] = np.where(table["fold"].isin([f.name for f in h.sel]), "selection", "confirmation") | |
| table.to_csv(OUT / "table.csv", index=False) | |
| log.to_csv(OUT / "ladder.csv", index=False) | |
| practice.to_csv(OUT / "practice_run.csv", index=False) | |
| # gate: the final system must beat both baselines' Score on both selection folds | |
| final = table[table["model"] == "FINAL (selected per metric)"].set_index("fold") | |
| gate = {} | |
| for f in h.sel: | |
| others = table[(table["fold"] == f.name) & table["model"].isin(["30-year average", "Linear trend"])] | |
| gate[f.name] = bool((final.loc[f.name, "score"] > others["score"]).all()) | |
| (OUT / "selected.json").write_text(json.dumps( | |
| {"selected": chosen, "labels": {m: label(s) for m, s in chosen.items()}, | |
| "gate_beats_both_baselines_on_both_selection_folds": gate}, indent=1) + "\n") | |
| if not all(gate.values()): | |
| raise SystemExit(f"GATE FAILED: the final system does not beat both baselines on both folds: {gate}") | |
| write_report(table, log, practice, chosen, gate, h, cands) | |
| pd.set_option("display.width", 250, "display.max_columns", 30, "display.max_colwidth", 70) | |
| print(practice.round(3).to_string(index=False), "\n") | |
| print(log.drop(columns=["spec", "incumbent"]).round(4).to_string(index=False), "\n") | |
| print(table.drop(columns=[c for c in table if c.startswith("mae_")]).round(4).to_string(index=False)) | |
| print("\nselected:", json.dumps({m: label(s) for m, s in chosen.items()}, indent=1)) | |
| print("gate:", gate) | |
| def write_report(table, log, practice, chosen, gate, h, cands): | |
| sk = {f"skill_{m}": "{:+.1%}" for m in METRICS} | |
| mae = {"mae_annual_avg_temp": "{:.3f}", "mae_total_precip_in": "{:.3f}", | |
| "mae_hottest_day_temp": "{:.3f}", "mae_cdd": "{:.1f}"} | |
| t = table[["model", "fold_kind", "fold", "score", *sk, *mae, "n_rows"]] | |
| lad = log[["metric", "rung", "candidate", "n_candidates", "incumbent", "gain_mean_skill", "se_gain", | |
| *[f"gain_{f.name}" for f in h.sel], "confirmation_mean_skill", "verdict"]] | |
| sens = (cands.pivot(index=["metric", "role", "model"], columns="fold", values="skill") | |
| .reindex(pd.MultiIndex.from_frame(cands[["metric", "role", "model"]].drop_duplicates())) | |
| [[f.name for f in h.sel + h.hold]].reset_index()) | |
| sens["mean selection"] = sens[[f.name for f in h.sel]].mean(axis=1) | |
| sens["mean confirmation"] = sens[[f.name for f in h.hold]].mean(axis=1) | |
| sens = sens[~sens["model"].str.startswith("blend: 0.") | |
| | sens["model"].isin([label(s) for s in chosen.values()]) | |
| | (sens["role"] == "sensitivity only")] | |
| text = f"""# Backtest report | |
| Generated by `python -m protostar.backtest` (do not edit). Scoring is the challenge's: | |
| MAE per metric over valid years (10-day rule) of city-metrics with a baseline (>= {MIN_VALID_YEARS} | |
| valid years in the 30-year window), skill `S = 1 - MAE / MAE(30-year average)`, and | |
| `Score = 100 * max(0, mean of the four S)`. Every fold trains on years <= origin only. | |
| ## Harness check against the organizers' practice run (train <= 2010, test 2011-2018) | |
| Published (temp / precip / hottest day / cdd): | |
| - official rule, CDD only: 30-year average 212 and linear trend 175 (About tab); 211.7 and 174.6 | |
| (organizer, Space discussion #3); | |
| - example notebook: 30-year average 1.657 / 6.198 / 2.563 / 212.636 and its 10-year mean | |
| 1.513 / 6.207 / 2.568 / 184.059. The notebook scores its model on every valid test row that has | |
| a forecast, 6 rows more than its reference (last table row); on the reference's rows the same | |
| model gives the "example notebook (no minimum) / 10-year mean" row. | |
| Our linear trend is a per-city least-squares line on the valid years of the window (x = calendar | |
| year), not floored at zero; the organizers' fit is not published beyond these numbers. | |
| {md_table(practice, {m: "{:.3f}" for m in METRICS})} | |
| ## Model x fold x metric | |
| `selection` folds rank the candidates; `confirmation` folds can only veto (see the ladder). | |
| Rows 1-4 are the rungs of the plan applied to all four metrics; FINAL is the per-metric choice. | |
| {md_table(t, {"score": "{:.2f}", **sk, **mae})} | |
| ## Selection ladder | |
| The best candidate of a rung (mean skill over the two selection folds) replaces the incumbent only | |
| if its gain is positive on both selection folds and larger than {SE_MULT:g} standard errors (paired | |
| bootstrap over cities, {N_BOOT} resamples, seed {SEED}), and its mean skill on the confirmation | |
| folds is not negative. Gains are in skill units (0.01 = 1 % of the 30-year-average MAE). | |
| Caveats. (1) Cities are spatially correlated, so a bootstrap over cities gives a lower bound on | |
| the standard error; that is why a gain must also hold on both folds. (2) The test is applied to | |
| the best of `n_candidates` with no adjustment for that choice; the accepted rungs clear it by a | |
| wide margin and the one marginal case was vetoed. (3) The veto compares with the 30-year average, | |
| not with the incumbent: `confirmation_mean_skill` of an accepted rung can be below the | |
| incumbent's (compare the rows of the table above). (4) Because the veto decided the hottest-day | |
| model, the confirmation folds are a clean holdout only for the other three metrics. | |
| {md_table(lad, {c: "{:+.4f}" for c in lad.columns if c.startswith("gain_")} | {"se_gain": "{:.4f}", "confirmation_mean_skill": "{:+.4f}"})} | |
| ## Selected | |
| {chr(10).join(f"- `{m}` ({UNITS[m]}): {label(s)}" for m, s in chosen.items())} | |
| Gate (final system beats both the 30-year average and the linear trend on the Score, on both | |
| selection folds): {gate} | |
| ## Candidates, skill per fold (and choices we did not let the backtest make) | |
| Every candidate is in `candidates.csv`; this table leaves out the 63 blends of each metric (the | |
| best one of each is in the ladder above). `sensitivity only` rows were never candidates: they | |
| show how much the window length (40 or 50 years), the number of pooled neighbors (k=64, all | |
| cities) and other climatology windows would matter. Pooled-trend rows whose label names no | |
| window use the 30-year window. | |
| {md_table(sens, {c: "{:+.1%}" for c in sens.columns if c not in ("metric", "role", "model")})} | |
| """ | |
| (OUT / "BACKTEST.md").write_text(text) | |
| if __name__ == "__main__": | |
| main() | |