Unicorns_final_submission / code /exp05_levels_slopes.py
Jessiter's picture
Submission: Experiment 5B forecast, code, outputs, policy deck (from GitHub branch Jessica @ 5614334)
7a1f343 verified
Raw History Blame Contribute Delete
12.6 kB
"""Experiment 5: better levels and better slopes.
Exp03 forecasts temperature and cdd as `30-year mean + one shared slope x (year - mean year)`.
Exp05 tests three fixes to that, each chosen per metric on held-back past years only:
1. Recent level (Optimal Climate Normals, Huang, van den Dool & Barnston 1996, J. Climate 9:809-817):
use the mean of the city's last K valid years (K = 10 or 15, the two OCN values) instead of 30.
2. Station-aware level: if the city's record switched stations inside the 30-year window, use only
the years at its latest station (when there are >= 10 valid ones), since a move can shift the level.
3. Scaled cdd slope: one shared slope gives Seattle and Miami the same cdd rise per year. Instead,
cdd slope of city c = shared temperature slope x (cdd change per 1 F of annual temperature in c),
the second factor fitted on the city's own past years.
plus an equal-weight ensemble of the non-baseline candidates.
Candidates per metric (all fixed before any run):
avg 30-year mean (A, the reference) r10 / r15 mean of the last 10 / 15 valid years
shared 30-year mean + shared slope (exp03's C) r10s / r15s recent level + shared slope
stn station-aware level + shared slope scaled 30-year mean + scaled slope (cdd only)
r15sc 15-year level + scaled slope (cdd only) ens mean of every non-baseline candidate
Decision rule: exp03's, unchanged (highest average skill over origins 1998/2004/2011; must beat the plain
average in >= 2 of 3 origins; a lead under 0.01 over the runner-up goes to the simpler of the two).
Run from the repo root: python code/exp05_levels_slopes.py
Writes outputs/exp05/: heldout_results.csv, decision.json (BEFORE the final forecast), submission_exp05.csv,
candidate forecasts submission_exp05_<method>_all.csv, run_log.json.
Data rule: only data up to 2018 is read (shared.load_train guards it); this module never reads
observation/truth files, and no choice here uses any 2019-2025 value.
"""
import argparse
import json
import sys
from datetime import datetime, timezone
from importlib.metadata import version
from pathlib import Path
import numpy as np
import pandas as pd
sys.path.insert(0, str(Path(__file__).resolve().parent))
from shared import METRICS, assert_cutoff, dataset_revision, load_train, valid_flags
import exp02_line_forest as e2 # reuse: window helper, plain-average fallbacks, row writer, git helper
ROOT = e2.ROOT
H, WINDOW, MIN_VALID, SEED, ORIGINS, CLIP0 = e2.H, e2.WINDOW, e2.MIN_VALID, e2.SEED, e2.ORIGINS, e2.CLIP0
CLOSE = 0.01
RECENT = (10, 15) # OCN window lengths; no other values are tried
COMMON = ["avg", "r10", "r15", "shared", "stn", "r10s", "r15s"]
CDD_ONLY = ["scaled", "r15sc"]
CANDIDATES = {m: COMMON + (CDD_ONLY if m == "cdd" else []) + ["ens"] for m in METRICS}
SIMPLICITY = ["avg", "r10", "r15", "shared", "stn", "r10s", "r15s", "scaled", "r15sc", "ens"] # simplest first
LABEL = {"avg": "A Plain average", "r10": "Recent 10-yr mean", "r15": "Recent 15-yr mean",
"shared": "C Shared slope (exp03)", "stn": "Station-aware level + shared slope",
"r10s": "Recent 10-yr level + shared slope", "r15s": "Recent 15-yr level + shared slope",
"scaled": "30-yr level + scaled cdd slope", "r15sc": "Recent 15-yr level + scaled cdd slope",
"ens": "Ensemble mean of non-baseline candidates"}
EXP05_LABEL = "Exp05 chosen per metric"
def _shared_slope(ser, cities):
"""Least-squares slope through every city's demeaned (year, value) points: exp03's idea C."""
xs = np.concatenate([ser[c].index.values - ser[c].index.values.mean() for c in cities])
ys = np.concatenate([ser[c].values - ser[c].values.mean() for c in cities])
return float((xs * ys).sum() / (xs * xs).sum())
def _segment_years(seg, city, s):
"""Valid years of series `s` recorded at the city's latest station segment."""
g = seg.get(city)
if g is None:
return s
latest = g.reindex(s.index).dropna()
if latest.empty:
return s
keep = latest.index[latest == latest.iloc[-1]]
return s.loc[keep]
def make_all(train_df, cov, origin=2018):
"""Every candidate for every metric: {method: {(city_id, metric): [7 floats]}}."""
assert_cutoff(train_df, "train_df")
assert_cutoff(cov, "cov")
cities = sorted(train_df["ID"].unique())
d = train_df[train_df["Year"] <= origin]
flags = valid_flags(d, cov)
years = np.arange(origin + 1, origin + H + 1, dtype=float)
base = e2.make_forecast(train_df, cov, {m: "avg" for m in METRICS}, origin) # A + all fallbacks
seg = {c: g.set_index("Year")["Station Segment"] for c, g in cov[cov["Year"] <= origin].groupby("ID")}
ser = {}
for metric, col in METRICS.items():
ser[metric] = e2._window_series(d, d[col].where(flags[metric]), origin)
enough = {m: sorted(c for c, s in ser[m].items() if len(s) >= MIN_VALID) for m in METRICS}
slope = {m: _shared_slope(ser[m], enough[m]) for m in METRICS}
# cdd sensitivity per city: OLS slope of cdd on Avg Temp over years where both are valid
sens = {}
t_ser, c_ser = ser["annual_avg_temp"], ser["cdd"]
for c in enough["cdd"]:
if c in t_ser:
j = c_ser[c].index.intersection(t_ser[c].index)
if len(j) >= MIN_VALID and np.ptp(t_ser[c].loc[j].values) > 0:
sens[c] = float(np.polyfit(t_ser[c].loc[j].values, c_ser[c].loc[j].values, 1)[0])
out = {m: {} for m in SIMPLICITY}
for metric in METRICS:
lo = 0.0 if metric in CLIP0 else -np.inf
for c in cities:
key = (c, metric)
fallback = base[key]
s = ser[metric].get(c)
if c not in enough[metric]:
for m in CANDIDATES[metric]:
out[m][key] = list(fallback)
continue
def level(sub):
return float(sub.values.mean()), float(sub.index.values.mean())
def path(lv, piv, b):
return [float(x) for x in np.maximum(lv + b * (years - piv), lo)]
full = level(s)
rec = {k: level(s.iloc[-k:]) for k in RECENT}
st = _segment_years(seg, c, s)
stn = level(st) if len(st) >= MIN_VALID else full
b = slope[metric]
out["avg"][key] = list(fallback)
out["r10"][key] = path(*rec[10], 0.0)
out["r15"][key] = path(*rec[15], 0.0)
out["shared"][key] = path(*full, b)
out["stn"][key] = path(*stn, b)
out["r10s"][key] = path(*rec[10], b)
out["r15s"][key] = path(*rec[15], b)
if metric == "cdd":
bc = sens[c] * slope["annual_avg_temp"] if c in sens else b
out["scaled"][key] = path(*full, bc)
out["r15sc"][key] = path(*rec[15], bc)
members = [m for m in CANDIDATES[metric] if m not in ("avg", "ens")]
out["ens"][key] = [float(x) for x in np.mean([out[m][key] for m in members], axis=0)]
return out
# ---------------------------------------------------------------- held-back test
def heldout(train_df, cov, origins=ORIGINS):
"""Same scoring as exp03: pooled MAE over valid city-years of cities with >= 10 valid window years."""
flags_all = valid_flags(train_df, cov)
rows = []
for o in origins:
res = make_all(train_df, cov, o)
past = train_df["Year"] <= o
for metric, col in METRICS.items():
v = train_df[col].where(flags_all[metric])
win = e2._window_series(train_df[past], v[past], o)
ok = {c for c, s in win.items() if len(s) >= MIN_VALID}
t = train_df.assign(v=v)[train_df["Year"].between(o + 1, o + H)].dropna(subset=["v"])
t = t[t["ID"].isin(ok)]
mae = {m: float(np.mean([abs(res[m][(r.ID, metric)][r.Year - o - 1] - r.v) for r in t.itertuples()]))
for m in CANDIDATES[metric]}
for m in CANDIDATES[metric]:
rows.append({"metric": metric, "method": m, "origin": str(o), "mae": mae[m],
"skill": 1 - mae[m] / mae["avg"], "n": len(t)})
df = pd.DataFrame(rows)
avg = df.groupby(["metric", "method"], sort=False)[["mae", "skill", "n"]].mean().reset_index()
avg.insert(2, "origin", "average")
return pd.concat([df, avg], ignore_index=True)
def decide(res, candidates=None, simplicity=None, label=None):
"""exp03's rule, over this metric's candidates (exp06 passes its own candidate set)."""
CANDIDATES_, SIMPLICITY_, LABEL_ = candidates or CANDIDATES, simplicity or SIMPLICITY, label or LABEL
dec = {}
for metric in METRICS:
cands = CANDIDATES_[metric]
r = res[res.metric == metric]
sk = {m: float(r[(r.method == m) & (r.origin == "average")].skill.iloc[0]) for m in cands}
per = {m: dict(zip(r[(r.method == m) & (r.origin != "average")].origin,
r[(r.method == m) & (r.origin != "average")].skill.astype(float))) for m in cands}
beats = {m: sum(x > 0 for x in per[m].values()) for m in cands}
ranked = sorted(cands, key=lambda m: (-sk[m], SIMPLICITY_.index(m)))
winner, second = ranked[0], ranked[1]
lead = sk[winner] - sk[second]
pick, why = winner, f"{LABEL_[winner]} has the highest average skill"
if lead < CLOSE:
simpler = min((winner, second), key=SIMPLICITY_.index)
if simpler != winner:
pick, why = simpler, f"rule 3: lead of {lead:.4f} over {LABEL_[second]} is under {CLOSE}, so the simpler idea wins"
if pick != "avg" and beats[pick] < 2:
why += f"; but {LABEL_[pick]} beat the plain average in only {beats[pick]} of 3 origins (rule 2)"
pick = "avg"
dec[metric] = {"avg_skill": sk, "per_origin_skill": per, "origins_beating_plain_average": beats,
"ranked_by_avg_skill": ranked, "highest": winner, "runner_up": second,
"lead_over_runner_up": lead, "method": pick, "reason": why}
return dec
def to_rows(fc):
return e2.to_rows(fc)
# ------------------------------------------------------------------------ main
def main(argv=None):
ap = argparse.ArgumentParser()
ap.add_argument("--out-dir", default=str(ROOT / "outputs" / "exp05"))
a = ap.parse_args(argv)
out = Path(a.out_dir)
out.mkdir(parents=True, exist_ok=True)
train_df, cov = load_train()
res = heldout(train_df, cov)
res.to_csv(out / "heldout_results.csv", index=False)
dec = decide(res)
(out / "decision.json").write_text(json.dumps(dec, indent=2)) # before any final forecast
final = make_all(train_df, cov, 2018)
plan = {m: d["method"] for m, d in dec.items()}
chosen = {k: v for metric, meth in plan.items() for k, v in final[meth].items() if k[1] == metric}
files = {"submission_exp05.csv": chosen}
for m in SIMPLICITY: # each candidate for every metric it applies to (avg elsewhere), for analysis
files[f"submission_exp05_{m}_all.csv"] = {k: (final[m] if k[1] in [x for x in METRICS if m in CANDIDATES[x]]
else final["avg"])[k] for k in final["avg"]}
for name, fc in files.items():
sub = to_rows(fc)
assert len(sub) == 210 * 7 * 4 and np.isfinite(sub.predicted_value).all()
assert (sub[sub.metric.isin(CLIP0)].predicted_value >= 0).all()
sub.to_csv(out / name, index=False)
(out / "run_log.json").write_text(json.dumps({
"experiment": "exp05", "timestamp_utc": datetime.now(timezone.utc).isoformat(),
"config": {"CANDIDATES": CANDIDATES, "SIMPLICITY": SIMPLICITY, "RECENT": RECENT, "CLOSE": CLOSE,
"WINDOW": WINDOW, "ORIGINS": ORIGINS, "MIN_VALID": MIN_VALID, "resolved_plan": plan},
"dataset": "CMU-OSPO/protostar-climate-train-to-2018", "dataset_revision": dataset_revision(),
"packages": {p: version(p) for p in ["pandas", "numpy", "scikit-learn", "huggingface_hub"]},
"git_commit": e2.git("rev-parse", "HEAD"), "git_dirty": bool(e2.git("status", "--porcelain"))}, indent=2))
for m, d in dec.items():
print(f"{m}: {d['method']} ({d['reason']})")
print("wrote", out)
if __name__ == "__main__":
main()