File size: 9,351 Bytes
3ff1d30 | 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 157 158 159 160 161 162 163 164 165 166 167 168 169 | """Experiment 3: make the trend line less noisy.
Ideas per metric: A plain average, B own line, C shared slope (one slope for all cities),
D half slope (own slope x 0.5). Chosen per metric by a held-back test on past years only.
Run from the repo root: python code/exp03_shared_slope.py [--charts]
Writes outputs/exp03/: heldout_results.csv, decision.json (BEFORE the final forecast),
submission_exp03.csv (chosen), submission_exp03_shared_all.csv, submission_exp03_half_all.csv, run_log.json.
Score it (analysis only): python code/starter_score.py obs_2018_2021.csv
Data rule: only data up to 2018 is read; this module never reads observation/truth files.
"""
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: windows, line fit, fallbacks, constants (exp02 itself is unchanged)
ROOT = e2.ROOT
H, WINDOW, MIN_VALID, SEED, ORIGINS, CLIP0 = e2.H, e2.WINDOW, e2.MIN_VALID, e2.SEED, e2.ORIGINS, e2.CLIP0
HALF = 0.5 # fixed; no other factor is tried
CLOSE = 0.01 # winner must lead the runner-up by at least this much skill
METHODS = ["avg", "line", "shared", "half"] # ideas A, B, C, D
SIMPLICITY = ["avg", "line", "half", "shared"] # A, B, D, C (simplest first)
LABEL = {"avg": "A Plain average", "line": "B Own line", "shared": "C Shared slope", "half": "D Half slope"}
EXP03_LABEL = "Exp03 chosen per metric"
def make_forecast(train_df, cov, metric_plan, origin=2018):
"""Returns {(city_id, metric): [v(origin+1) .. v(origin+7)]}; metric_plan maps metric -> one of METHODS.
Pivot for C and D: forecast = city_mean + slope * (year - city_mean_year) over the 30-year window."""
assert_cutoff(train_df, "train_df")
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)
# A and B come from exp02's code so the shared parts (fallbacks, clipping) stay identical
base = e2.make_forecast(train_df, cov, {m: ("avg" if p == "avg" else "line") for m, p in metric_plan.items()}, origin)
out = {}
for metric, method in metric_plan.items():
if method not in METHODS:
raise ValueError(f"{metric}: method '{method}' unknown")
if method in ("avg", "line"):
out.update({k: v for k, v in base.items() if k[1] == metric})
continue
v = d[METRICS[metric]].where(flags[metric])
ser = e2._window_series(d, v, origin)
enough = sorted(c for c, s in ser.items() if len(s) >= MIN_VALID)
piv = {c: (float(ser[c].index.values.mean()), float(ser[c].values.mean())) for c in enough}
own = {c: e2._line(ser[c], years)[1] for c in enough}
if method == "shared": # least-squares slope through all demeaned points together
xs = np.concatenate([ser[c].index.values - piv[c][0] for c in enough])
ys = np.concatenate([ser[c].values - piv[c][1] for c in enough])
shared = float((xs * ys).sum() / (xs * xs).sum())
lo = 0.0 if metric in CLIP0 else -np.inf
for c in cities:
if c in piv:
slope = shared if method == "shared" else HALF * own[c]
vals = piv[c][1] + slope * (years - piv[c][0])
out[(c, metric)] = [float(x) for x in np.maximum(vals, lo)]
else: # fewer than 10 valid years: exp02's plain-average fallback
out[(c, metric)] = base[(c, metric)]
return out
# ---------------------------------------------------------------- held-back test
def heldout(train_df, cov, origins=ORIGINS):
flags_all = valid_flags(train_df, cov)
rows = []
for o in origins:
res = {m: make_forecast(train_df, cov, {k: m for k in METRICS}, o) for m in METHODS}
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)]
err = {m: [abs(res[m][(r.ID, metric)][r.Year - o - 1] - r.v) for r in t.itertuples()] for m in METHODS}
mae = {m: float(np.mean(err[m])) for m in METHODS}
for m in METHODS:
rows.append({"metric": metric, "method": m, "origin": str(o), "mae": mae[m],
"skill": 1 - mae[m] / mae["avg"], "n": len(err[m])})
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):
"""1) highest average skill; 2) must beat the plain average in >=2 of 3 origins, else A;
3) if it leads the second best by < CLOSE, take the simpler of the two (A, B, D, C).
Interpretation: the simpler pick in step 3 must also pass step 2, otherwise A."""
dec = {}
for metric in METRICS:
r = res[res.metric == metric]
sk = {m: float(r[(r.method == m) & (r.origin == "average")].skill.iloc[0]) for m in METHODS}
per = {m: {o: float(x) for o, x in zip(r[(r.method == m) & (r.origin != "average")].origin,
r[(r.method == m) & (r.origin != "average")].skill)} for m in METHODS}
beats = {m: sum(per[m][o] > 0 for o in per[m]) for m in METHODS} # origins beating the plain average
ranked = sorted(METHODS, key=lambda m: (-sk[m], SIMPLICITY.index(m)))
winner, second = ranked[0], ranked[1]
lead = sk[winner] - sk[second]
info = {"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}
pick, why = winner, f"{LABEL[winner]} has the highest average skill"
if pick != "avg" and beats[pick] < 2:
pick, why = "avg", f"rule 2: {LABEL[winner]} beat the plain average in only {beats[winner]} of 3 origins"
elif 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"
else:
why += f" (lead {lead:.4f} < {CLOSE}, but it is also the simpler one)"
if pick != "avg" and beats[pick] < 2:
pick, why = "avg", why + f"; but {LABEL[pick]} beat the plain average in only {beats[pick]} of 3 origins (rule 2)"
info.update(method=pick, reason=why)
dec[metric] = info
return dec
# ------------------------------------------------------------------------ main
def main(argv=None):
ap = argparse.ArgumentParser()
ap.add_argument("--out-dir", default=str(ROOT / "outputs" / "exp03"))
ap.add_argument("--charts", action="store_true")
a = ap.parse_args(argv)
out = Path(a.out_dir)
(out / "charts").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
plan = {m: d["method"] for m, d in dec.items()}
for name, p in (("submission_exp03.csv", plan),
("submission_exp03_shared_all.csv", {m: "shared" for m in METRICS}),
("submission_exp03_half_all.csv", {m: "half" for m in METRICS})):
sub = e2.to_rows(make_forecast(train_df, cov, p, 2018))
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": "exp03", "scorer_labels": [EXP03_LABEL, "Shared slope (all metrics)", "Half slope (all metrics)"],
"timestamp_utc": datetime.now(timezone.utc).isoformat(),
"config": {"METHODS": METHODS, "SIMPLICITY": SIMPLICITY, "HALF": HALF, "CLOSE": CLOSE, "WINDOW": WINDOW,
"ORIGINS": ORIGINS, "SEED": SEED, "resolved_plan": plan},
"dataset": e2.__dict__.get("REPO", "CMU-OSPO/protostar-climate-train-to-2018"), "dataset_revision": dataset_revision(),
"packages": {p: version(p) for p in ["pandas", "numpy", "scikit-learn", "matplotlib", "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 a.charts:
from exp03_charts import make_charts
make_charts(out, train_df, cov)
if __name__ == "__main__":
main()
|