File size: 12,778 Bytes
d79a78d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
"""Checks that guard the submission: leakage, scoring, model invariants, the file itself.

Run: PYTHONPATH=code python -m protostar.tests     (also part of `make all`)
"""

import json

import numpy as np
import pandas as pd

from .backtest import (LONG, RECENT, Fold, Harness, blend_specs, climatology_specs, practice_check, select,
                       trend_specs)
from .common import (BASELINE_WINDOW, CONFIRMATION_FOLDS, FORECAST_YEARS, METRICS, MIN_VALID_YEARS, N_CITIES,
                     PRACTICE_FOLD, REPORTS, ROOT, SEED, SELECTION_FOLDS, TRAIN_END)
from .data import (LeakageError, Panel, assert_no_leak, cities, load_annual, load_city_info, long_table,
                   panels)
from .models import BASELINES, neighbor_order, predict
from .scoring import challenge_score, score_frames, skill


def setup():
    annual = load_annual()
    long = long_table(annual)
    geo = cities(annual)
    order = neighbor_order(geo["lat"].to_numpy(), geo["lon"].to_numpy())
    return annual, long, panels(long), order


def test_leak_guard(annual, long, P, order):
    """Data after 2018 cannot enter: the loaders, the panels and predict() all refuse it."""
    assert annual["Year"].max() == TRAIN_END
    for bad in (lambda: assert_no_leak([2018, 2019], "x"),
                lambda: panels(pd.concat([long, long.tail(1).assign(year=2019)])),
                lambda: predict(BASELINES["30-year average"],
                                {m: Panel(m, p.city_ids, p.years + 1, p.y) for m, p in P.items()},
                                "cdd", order, [2020])):
        try:
            bad()
        except LeakageError:
            continue
        raise AssertionError("a leak was not caught")


def test_no_peeking(annual, long, P, order):
    """Backtest forecasts do not change when every raw value after the origin is corrupted."""
    selected = json.loads((REPORTS / "backtest" / "selected.json").read_text())["selected"]
    rng = np.random.default_rng(SEED)
    measured = [c for c in annual.columns if c not in ("Name", "ID", "Lat", "Lon", "Year")]

    def specs(metric):   # everything the ladder can evaluate, and what ships
        out = list(BASELINES.values()) + climatology_specs() + trend_specs() + [selected[metric]]
        out += blend_specs(RECENT, LONG, trend_specs()[5])[::7]
        if metric == "cdd":
            out += [{"type": "cdd_via_temp", "n": BASELINE_WINDOW, "temp": t} for t in trend_specs()[:3]]
        return out

    for origin, first, last in (*SELECTION_FOLDS, *CONFIRMATION_FOLDS, PRACTICE_FOLD):
        bad = annual.copy()
        later = (bad["Year"] > origin).to_numpy()
        for c in measured:      # through the real path: raw table -> valid-year rule -> panels -> Fold
            if c.startswith("Miss"):
                bad.loc[later, c] = rng.integers(0, 12, size=later.sum())       # valid and invalid years
            else:
                bad.loc[later, c] = rng.normal(0, 1e6, size=later.sum())
        clean, dirty = Fold(P, origin, first, last), Fold(panels(long_table(bad)), origin, first, last)
        for m in METRICS:
            assert np.array_equal(clean.train[m].y, dirty.train[m].y, equal_nan=True), (origin, m)
            assert not np.array_equal(clean.truth[m], dirty.truth[m], equal_nan=True)   # the corruption is real
            for spec in specs(m):
                assert np.array_equal(clean.predict(spec, m, order), dirty.predict(spec, m, order),
                                      equal_nan=True), (origin, m, spec)


def test_neighbors_are_geography(annual, long, P, order):
    """The neighbor order comes from fixed station coordinates only (it cannot carry weather)."""
    assert (annual.groupby("ID")[["Lat", "Lon"]].nunique() == 1).all(axis=None)      # one location per city
    info = load_city_info().groupby("ID")[["Lat", "Lon"]].first().reindex(P["cdd"].city_ids)
    assert np.array_equal(order, neighbor_order(info["Lat"].to_numpy(), info["Lon"].to_numpy()))
    n = len(order)
    assert order.shape == (n, n - 1) and all(i not in order[i] and len(set(order[i])) == n - 1 for i in range(n))


def test_selection_reproduces(annual, long, P, order):
    """Re-running the ladder with the coordinate-only neighbor order gives exactly selected.json and ladder.csv."""
    chosen, log, _ = select(Harness(P, order))
    assert chosen == json.loads((REPORTS / "backtest" / "selected.json").read_text())["selected"]
    saved = pd.read_csv(REPORTS / "backtest" / "ladder.csv")   # written by backtest.main with its own order
    assert list(log["spec"]) == list(saved["spec"])
    for col in ("gain_mean_skill", "se_gain", "confirmation_mean_skill"):
        assert np.allclose(log[col], saved[col], rtol=0, atol=1e-12), col


def test_scoring_matches_space(annual, long, P, order):
    """The array scorer of the backtest equals the Space's table scorer (scoring.score_frames)."""
    origin, first, last = 2011, 2012, 2018
    f = Fold(P, origin, first, last)
    ids = P["cdd"].city_ids
    years = np.arange(first, last + 1)

    def frame(spec_by_metric, col):
        parts = []
        for m in METRICS:
            pred = predict(spec_by_metric[m], f.train, m, order, years, fill=col == "predicted_value")
            parts.append(pd.DataFrame({"city_id": np.repeat(ids, len(years)), "year": np.tile(years, len(ids)),
                                       "metric": m, col: pred.ravel()}))
        return pd.concat(parts, ignore_index=True)

    selected = json.loads((REPORTS / "backtest" / "selected.json").read_text())["selected"]
    sub = frame(selected, "predicted_value")
    ref = frame({m: BASELINES["30-year average"] for m in METRICS}, "predicted_value")
    # answer key built like the organizers': valid test years; scored if the city-metric has a baseline
    truth = long[long["year"].between(first, last)].rename(columns={"value": "actual_value"})
    win = long[long["year"].between(origin - BASELINE_WINDOW + 1, origin) & long["valid"]]
    n_valid = win.groupby(["city_id", "metric"]).size().rename("n").reset_index()
    truth = truth.merge(n_valid, on=["city_id", "metric"], how="left")
    truth["scored"] = truth["valid"] & (truth["n"].fillna(0) >= MIN_VALID_YEARS)
    res = score_frames(sub, truth, ref)
    skills = {m: f.skill(selected[m], m, order) for m in METRICS}
    for m in METRICS:
        assert abs(res["mae"][m] - f.mae(selected[m], m, order)) < 1e-9, m
        assert abs(res["skill"][m] - skills[m]) < 1e-9, m
    assert abs(res["score"] - challenge_score(skills)) < 1e-9
    assert res["n_rows"] == sum(int(f.scored[m].sum()) for m in METRICS)


def test_practice_run(annual, long, P, order):
    """The harness reproduces the organizers' published practice-run numbers (About tab, notebook, discussion #3)."""
    t = practice_check(P, order).set_index(["rule", "model"])
    notebook = {"30-year average": {"annual_avg_temp": 1.657, "total_precip_in": 6.198,
                                    "hottest_day_temp": 2.563, "cdd": 212.636}}
    for m, value in notebook["30-year average"].items():
        assert abs(t.loc[("example notebook (no minimum)", "30-year average"), m] - value) < 6e-4, m
    own_rows = {"annual_avg_temp": 1.513, "total_precip_in": 6.207, "hottest_day_temp": 2.568, "cdd": 184.059}
    for m, value in own_rows.items():   # the notebook's model column, scored the notebook's way
        assert abs(t.loc[("example notebook, scored on the rows the model covers", "10-year mean"), m] - value) < 6e-4, m
    official = "official (>= 10 valid years in the window)"
    assert abs(t.loc[(official, "30-year average"), "cdd"] - 211.7) < 0.05     # organizer: 211.7 / 174.6
    assert abs(t.loc[(official, "Linear trend"), "cdd"] - 174.6) < 0.05


def test_model_invariants(annual, long, P, order):
    """Baselines equal independent computations (groupby mean, numpy.polyfit); lam=1 is plain OLS."""
    train = {m: p.upto(2011) for m, p in P.items()}
    years = np.arange(2012, 2019)
    for m in METRICS:
        # the 30-year average equals a plain groupby mean of the valid years
        ref = (long[(long["metric"] == m) & long["valid"] & long["year"].between(1982, 2011)]
               .groupby("city_id")["value"].agg(["mean", "size"]))
        ref = ref["mean"].where(ref["size"] >= MIN_VALID_YEARS).reindex(P[m].city_ids).to_numpy()
        got = predict(BASELINES["30-year average"], train, m, order, years, fill=False)[:, 0]
        assert np.allclose(got, ref, equal_nan=True), m
        # a pooled trend with full weight on the own slope is the per-city OLS line
        own = predict({"type": "ptrend", "n": 30, "k": 8, "lam": 1.0}, train, m, order, years, fill=False)
        line = predict(BASELINES["Linear trend"], train, m, order, years, fill=False)
        n_valid = np.isfinite(train[m].y[:, -30:]).sum(axis=1)
        full = n_valid >= 15
        floored = np.maximum(line, 0.0) if m in ("cdd", "total_precip_in") else line    # our models are floored at 0
        assert np.allclose(own[full], floored[full], equal_nan=True), m
        # the OLS line equals numpy.polyfit on every complete city, and the baseline line is never floored
        for i in np.flatnonzero(n_valid == 30):
            coef = np.polyfit(train[m].years[-30:], train[m].y[i, -30:], 1)
            assert np.allclose(line[i], np.polyval(coef, years)), (m, i)
        filled = predict(BASELINES["Linear trend"], train, m, order, years)
        assert np.array_equal(filled[np.isfinite(line)], line[np.isfinite(line)]), m
    assert skill(1.0, 2.0) == 0.5 and challenge_score({m: -1.0 for m in METRICS}) == 0.0


def test_submission_file(annual, long, P, order):
    """submission.csv is complete and is exactly what the selected models produce."""
    sub = pd.read_csv(ROOT / "submission.csv", dtype={"city_id": str, "metric": str})
    assert list(sub.columns) == ["city_id", "year", "metric", "predicted_value"]
    assert len(sub) == N_CITIES * len(FORECAST_YEARS) * len(METRICS) == 5880
    assert not sub.duplicated(["city_id", "year", "metric"]).any()
    assert set(sub["city_id"]) == set(P["cdd"].city_ids) and set(sub["year"]) == set(FORECAST_YEARS)
    assert set(sub["metric"]) == set(METRICS) and np.isfinite(sub["predicted_value"]).all()
    selected = json.loads((REPORTS / "backtest" / "selected.json").read_text())["selected"]
    ids = list(P["cdd"].city_ids)
    for m in METRICS:
        pred = predict(selected[m], P, m, order, np.array(FORECAST_YEARS))
        got = (sub[sub["metric"] == m].pivot(index="city_id", columns="year", values="predicted_value")
               .reindex(index=ids, columns=list(FORECAST_YEARS)).to_numpy())
        assert np.abs(got - pred).max() < 0.0051 + 0.05 * (m == "cdd"), m   # rounding only


def test_fallback_is_unscored(annual, long, P, order):
    """The fallback fills exactly the 9 city-metrics without a baseline, and never a scored backtest row."""
    selected = json.loads((REPORTS / "backtest" / "selected.json").read_text())["selected"]
    years = np.array(FORECAST_YEARS)
    n = 0
    for m in METRICS:
        raw = predict(selected[m], P, m, order, years, fill=False)
        filled = predict(selected[m], P, m, order, years)
        unfitted = ~np.isfinite(raw).all(axis=1)
        no_baseline = np.isfinite(P[m].y[:, -BASELINE_WINDOW:]).sum(axis=1) < MIN_VALID_YEARS
        assert (unfitted == no_baseline).all(), m
        assert np.array_equal(raw[~unfitted], filled[~unfitted]) and np.isfinite(filled).all(), m
        n += int(unfitted.sum())
    assert n == 9, n   # the organizers' count (63 rows)
    for origin, first, last in ((2011, 2012, 2018), (2004, 2005, 2011), (1997, 1998, 2004), (1990, 1991, 1997)):
        f = Fold(P, origin, first, last)
        for m in METRICS:
            raw = predict(selected[m], f.train, m, order, f.years, fill=False)
            assert np.isfinite(raw[f.scored[m]]).all(), (origin, m)


def test_external_data_capped(annual, long, P, order):
    """The NOAA extract (analysis only) holds nothing after 2018-12-31 and matches its manifest."""
    from .ghcnd import EXT, load_ghcnd
    if not (EXT / "MANIFEST.csv").exists():
        return
    noaa = load_ghcnd()          # asserts sha256 per file and the 2018-12-31 cap
    assert noaa["Date"].max() <= pd.Timestamp("2018-12-31")


def main():
    ctx = setup()
    tests = [test_leak_guard, test_no_peeking, test_neighbors_are_geography, test_selection_reproduces,
             test_scoring_matches_space, test_practice_run, test_model_invariants, test_submission_file,
             test_fallback_is_unscored, test_external_data_capped]
    for t in tests:
        t(*ctx)
        print(f"ok  {t.__name__}: {t.__doc__.strip().splitlines()[0]}")
    print(f"{len(tests)} checks passed")


if __name__ == "__main__":
    main()