File size: 5,708 Bytes
b5e8582
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Pre-registered test: does a 50/50 blend of Placeholder_v9-S and combined model v3 beat both on past years?

Rule (fixed before running): for forecast origins 1986, 1994, 2002 and 2010 (train on years <= origin, forecast the
next 7 years, as in the real task), score each model with the leaderboard formula on the rows the challenge would score (valid year, and
the city has a 30-year baseline). Submit the blend only if its mean Score over the four origins beats both
v9-S and v3; otherwise keep v9-S. No 2019+ data is read.

Run from the dataset root (final_submission/):  python code/blend_test.py
"""

import os
import sys
import tempfile
from pathlib import Path

import numpy as np
import pandas as pd

HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
ROOT = HERE.parent

import make_submission as ms                 # Meet's loader, constants and CSV round-trip (exactly as submitted)
from common import METRICS, assert_no_post_cutoff

ORIGINS = (1986, 1994, 2002, 2010)
LEAD = 7                                   # the real task forecasts 7 years (2019-2025); v9-S requires exactly 7
KEY = ["city_id", "year", "metric"]


def annual_table() -> pd.DataFrame:
    source = ms.ANNUAL if ms.ANNUAL.is_file() else ms.pinned_annual()
    annual = ms.load_annual(source)
    assert_no_post_cutoff(annual, "year", "blend test history")
    return annual


def v9s_forecasts(annual, cities, origin, years, tmpdir) -> pd.DataFrame:
    warm = pd.read_csv(ROOT / "data" / "daily_warm_days.csv", dtype={"city_id": str})
    warm_path = Path(tmpdir) / f"warm_{origin}.csv"
    warm[warm["year"] <= origin].to_csv(warm_path, index=False)
    os.environ["PROTOSTAR_ASSET_ROOT"] = str(ROOT)
    os.environ.pop("PROTOSTAR_ARTIFACT_DIR", None)
    os.environ["PROTOSTAR_FOLD_CUTOFF"] = str(origin)
    os.environ["PROTOSTAR_WARM_DAYS"] = str(warm_path)
    import importlib
    import placeholder_v9s
    importlib.reload(placeholder_v9s)                     # pick up this origin's warm-day file
    if hasattr(placeholder_v9s, "WARM_RELEASE"):
        placeholder_v9s.WARM_RELEASE = str(warm_path)
    train = ms._round_trip(annual[(annual.year <= origin) & annual.city_id.isin(cities)], {"city_id": str})
    targets = pd.MultiIndex.from_product([cities, years, list(METRICS)], names=KEY).to_frame(index=False)
    targets = ms._round_trip(targets, {"city_id": str, "metric": str})
    res = placeholder_v9s.forecast(train, targets, origin, seed=42)
    return res[KEY + ["predicted_value"]]


def v3_forecasts(valid, cities, origin, years) -> pd.DataFrame:
    import combo_v3 as cm
    from common import wide
    parts = []
    for metric in METRICS:
        table = wide(valid, metric).reindex(cities)
        pred = cm.forecast(table, metric, cm.METHOD[metric], origin, years)
        long = pred.stack().rename("predicted_value").reset_index()
        long.columns = ["city_id", "year", "predicted_value"]
        long["metric"] = metric
        parts.append(long)
    return pd.concat(parts)[KEY + ["predicted_value"]]


def score(valid, pred: pd.DataFrame, origin, years) -> dict:
    from common import thirty_year_mean, wide
    import combo_v3 as cm
    out = {}
    for metric in METRICS:
        table = wide(valid, metric)
        history = table.loc[:, :origin]
        actual = table.reindex(columns=years).where(thirty_year_mean(history, origin).notna(), axis=0)
        ref = cm.average_forecast(history, origin, years).reindex(index=actual.index, columns=years)
        p = (pred[pred.metric == metric].pivot(index="city_id", columns="year", values="predicted_value")
             .reindex(index=actual.index, columns=years))
        a, r, q = actual.stack(future_stack=True), ref.stack(future_stack=True), p.stack(future_stack=True)
        ok = a.notna() & r.notna() & q.notna()
        out[metric] = 1 - (q[ok] - a[ok]).abs().mean() / (r[ok] - a[ok]).abs().mean()
    out["Score"] = 100 * max(0.0, float(np.mean([out[m] for m in METRICS])))
    return out


def main() -> None:
    from common import load_valid_annual
    valid = load_valid_annual()          # load before the per-origin cutoff is set (scoring needs years after origin)
    annual = annual_table()
    cities = sorted(pd.read_csv(ROOT / "data" / "city_info.csv", dtype={"city_id": str}).city_id.unique())
    rows = []
    with tempfile.TemporaryDirectory() as tmp:
        for origin in ORIGINS:
            years = list(range(origin + 1, origin + 1 + LEAD))
            a = v9s_forecasts(annual, cities, origin, years, tmp)
            b = v3_forecasts(valid, cities, origin, years)
            m = a.merge(b, on=KEY, suffixes=("_v9s", "_v3"))
            blend = m[KEY].assign(predicted_value=0.5 * m.predicted_value_v9s + 0.5 * m.predicted_value_v3)
            for name, pred in [("v9-S", a), ("v3", b), ("blend 50/50", blend)]:
                s = score(valid, pred, origin, years)
                rows.append({"origin": origin, "model": name, **{k: round(v, 4) for k, v in s.items()}})
                print(f"origin {origin}  {name:12s} Score {s['Score']:5.2f}  " +
                      "  ".join(f"{k} {s[k]:+.3f}" for k in METRICS), flush=True)
    os.environ.pop("PROTOSTAR_FOLD_CUTOFF", None)
    r = pd.DataFrame(rows)
    (ROOT / "reports").mkdir(exist_ok=True)
    r.to_csv(ROOT / "reports" / "blend_test.csv", index=False)
    means = r.groupby("model")["Score"].mean()
    print("\nMean Score over origins 1986/1994/2002/2010:")
    print(means.round(2).to_string())
    win = means["blend 50/50"] > max(means["v9-S"], means["v3"])
    print("\nRULE:", "blend beats both -> submit the blend" if win else "blend does not beat both -> keep v9-S")


if __name__ == "__main__":
    main()