File size: 18,958 Bytes
42ef3d0
 
a20bccd
e7f2757
a20bccd
 
 
42ef3d0
 
e7f2757
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a20bccd
 
 
42ef3d0
 
e7f2757
 
 
42ef3d0
 
 
 
 
e7f2757
 
42ef3d0
 
 
 
 
 
 
e7f2757
 
 
42ef3d0
 
e7f2757
42ef3d0
 
a20bccd
42ef3d0
e7f2757
 
 
 
 
 
 
 
 
42ef3d0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
e7f2757
 
 
 
 
 
 
 
 
 
 
 
 
 
42ef3d0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
e7f2757
42ef3d0
 
 
 
 
 
 
 
 
e7f2757
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a20bccd
 
 
 
 
 
 
 
 
 
 
 
 
 
e7f2757
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a20bccd
e7f2757
a20bccd
42ef3d0
 
e7f2757
42ef3d0
e7f2757
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
42ef3d0
 
 
e7f2757
 
42ef3d0
 
 
 
e7f2757
42ef3d0
 
 
e7f2757
a20bccd
 
e7f2757
 
 
42ef3d0
e7f2757
42ef3d0
 
e7f2757
42ef3d0
 
 
 
e7f2757
 
 
 
 
 
 
 
 
 
 
42ef3d0
 
a20bccd
 
e7f2757
 
 
42ef3d0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
e7f2757
 
 
 
 
 
 
 
 
42ef3d0
 
e7f2757
42ef3d0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
"""Combined model: for each metric, the simple forecast that backtests best across past windows.

    annual_avg_temp                    -> the city's level now (mean of its last 10 years), plus the
                                          warming rate shared by all cities, carried forward
    cdd                                -> the city's level now, growing at the rate shared by all
                                          cities in percent (a city with little air-conditioning
                                          need gets a proportionally small rise)
    total_precip_in, hottest_day_temp  -> the city's 30-year average

Why: temperature and cooling degree days drift upward, so a flat average lags behind. A city's own
30-year trend line catches the drift, but one city's slope is noisy (a few odd years tilt it). All
210 cities share most of the warming, so the median slope across cities is a much steadier
estimate of how fast each city warms; the last-10-year mean gives the city's current level.
Precipitation and the hottest day are mostly year-to-year noise: nothing beat the 30-year average.

El Nino adjustment (tested, NOT used: USE_ENSO = False). It lowered the mean backtest Score from 5.2
to 5.0 (worse in 2 of 4 windows), so the selection rule keeps it out; the backtest still reports it as
"combo_enso", and code/enso_test.py runs a 38-year one-year-ahead test of it. How it works
(temperature and CDD, first forecast year only): the Oceanic Nino Index (ONI)
at the end of the last training year (mean of its Aug-Oct and Sep-Nov seasons) shifts each city's
next-year forecast by the city's El Nino sensitivity: the slope of its past one-year-ahead forecast
misses on that year-end ONI, averaged over the city and its 8 nearest cities. Only years before the
forecast origin are used to fit it. ONI comes from data/ocean_indices.csv (archived NOAA copies
from 2018 or earlier, see code/prepare_ocean_indices.py).

Candidates per metric (all scored in the backtest):
    average          city's 30-year average (the leaderboard's reference)
    trend            straight line through the city's last 30 years
    last10           city's mean of its last 10 years
    blend            half trend, half last10
    level_allcities  last10 level + median 30-year slope across all cities
    level_neighbors  last10 level + mean 30-year slope of the city and its 8 nearest cities
    level_allcities_pct  (precipitation and CDD only, which start at zero) last10 level growing at
                     the median relative slope across cities (% of the city's 30-year mean per
                     year), so cities with almost no CDD do not get the same absolute rise as Miami

Selection rule (fixed before looking at any 2019+ result): per metric, the candidate with the
highest mean skill over the backtest windows (test years 1987-1994, 1995-2002, 2003-2010,
2011-2018). All windows end before 2019; leaderboard scores were not used. METHOD below holds the
choice, and the backtest warns if it no longer matches the rule.

Usage (from the repository root):
    python code/combo_model.py                # backtests -> reports/backtest_combo.csv, forecasts -> submission.csv
    python code/combo_model.py --no-backtest  # forecasts only

Inputs: data/annual_valid.csv (records up to 2018, guarded by load_valid_annual()), the city
coordinates in data/city_info.csv, and the ONI in data/ocean_indices.csv (guarded too).
"""

import argparse

import numpy as np
import pandas as pd

from common import (CUTOFF_YEAR, DATA_DIR, FORECAST_YEARS, METRICS, MIN_VALID_YEARS, REPORTS_DIR,
                    SUBMISSION_PATH, assert_no_post_cutoff, load_valid_annual, mae,
                    thirty_year_mean, wide)

METHOD = {
    "annual_avg_temp": "level_allcities",
    "total_precip_in": "average",
    "hottest_day_temp": "average",
    "cdd": "level_allcities_pct",
}
WINDOW = 30          # years used for averages and slopes
LEVEL_YEARS = 10     # years used for a city's current level
NEIGHBORS = 8        # nearest cities pooled in level_neighbors (plus the city itself)
NON_NEGATIVE = ("total_precip_in", "cdd")
USE_ENSO = False                             # El Nino adjustment in the submitted forecasts (tested; see docstring)
ENSO_METRICS = ("annual_avg_temp", "cdd")   # metrics the El Nino adjustment applies to
ENSO_FIRST_ORIGIN = 1955                     # earliest year used to fit El Nino sensitivities
ENSO_MIN_YEARS = 15                          # years a city needs for its own sensitivity
OCEAN_PATH = DATA_DIR / "ocean_indices.csv"
# Backtests: train on data up to each year, test on the 8 years after it (all before 2019).
BACKTEST_ENDS = (2010, 2002, 1994, 1986)
TEST_LENGTH = 8


def average_forecast(history: pd.DataFrame, last_year: int, years: list[int]) -> pd.DataFrame:
    """Each city's 30-year average, repeated for every forecast year.

    Cities without enough valid years for an official baseline (they are not scored) fall back
    to the mean of whatever valid years they have, so every row still gets a number.
    """
    level = thirty_year_mean(history, last_year)
    level = level.fillna(history.loc[:, last_year - WINDOW + 1:last_year].mean(axis=1))
    level = level.fillna(history.mean(axis=1))
    return pd.DataFrame({y: level for y in years})


def city_slopes(history: pd.DataFrame, last_year: int) -> pd.Series:
    """Each city's least-squares slope (units per year) over its valid years in the last 30.

    NaN when a city has fewer than MIN_VALID_YEARS valid years there.
    """
    window = history.loc[:, last_year - WINDOW + 1:last_year]
    slopes = {}
    for city, row in window.iterrows():
        ok = row.dropna()
        slopes[city] = (np.polyfit(ok.index.to_numpy(dtype=float), ok.to_numpy(), 1)[0]
                        if len(ok) >= MIN_VALID_YEARS else np.nan)
    return pd.Series(slopes)


def trend_forecast(history: pd.DataFrame, last_year: int, years: list[int]) -> pd.DataFrame:
    """A least-squares line through each city's valid years in the last 30, extended to `years`.

    Needs MIN_VALID_YEARS valid years (the same minimum as the official baseline); otherwise the
    city gets its average forecast instead.
    """
    window = history.loc[:, last_year - WINDOW + 1:last_year]
    fallback = average_forecast(history, last_year, years)
    x_future = np.array(years, dtype=float)
    rows = {}
    for city, row in window.iterrows():
        ok = row.dropna()
        if len(ok) < MIN_VALID_YEARS:
            rows[city] = fallback.loc[city].to_numpy()
            continue
        slope, intercept = np.polyfit(ok.index.to_numpy(dtype=float), ok.to_numpy(), 1)
        rows[city] = intercept + slope * x_future
    return pd.DataFrame.from_dict(rows, orient="index", columns=years).reindex(history.index)


def last10_forecast(history: pd.DataFrame, last_year: int, years: list[int]) -> pd.DataFrame:
    """Each city's mean of its last 10 years (the challenge's 'Ocarina of Ten' reference)."""
    level = history.loc[:, last_year - LEVEL_YEARS + 1:last_year].mean(axis=1)
    level = level.fillna(average_forecast(history, last_year, years)[years[0]])
    return pd.DataFrame({y: level for y in years})


def blend_forecast(history: pd.DataFrame, last_year: int, years: list[int]) -> pd.DataFrame:
    """Equal-weight average of the 30-year trend line and the 10-year mean."""
    return 0.5 * trend_forecast(history, last_year, years) + 0.5 * last10_forecast(history, last_year, years)


def level_plus_slope(history: pd.DataFrame, last_year: int, years: list[int],
                     slope: pd.Series) -> pd.DataFrame:
    """City level (mean of its valid years in the last 10) carried forward at `slope` per year.

    The line passes through the level at the mean of the years it was computed from, so a city
    with a missing recent year is not shifted. Cities with no valid recent year get their average.
    """
    recent = history.loc[:, last_year - LEVEL_YEARS + 1:last_year]
    level = recent.mean(axis=1)
    center = recent.notna().mul(recent.columns.to_numpy(dtype=float), axis=1).sum(axis=1) / recent.notna().sum(axis=1)
    pred = pd.DataFrame({y: level + slope.reindex(history.index) * (y - center) for y in years})
    return pred.fillna(average_forecast(history, last_year, years))


def level_allcities_forecast(history: pd.DataFrame, last_year: int, years: list[int]) -> pd.DataFrame:
    """City level + the median 30-year slope across all cities."""
    shared = float(np.nanmedian(city_slopes(history, last_year)))
    return level_plus_slope(history, last_year, years, pd.Series(shared, index=history.index))


def level_allcities_pct_forecast(history: pd.DataFrame, last_year: int, years: list[int]) -> pd.DataFrame:
    """City level + a slope proportional to it: the median across cities of slope / 30-year mean.

    Only cities whose 30-year mean is at least a tenth of the median city's enter the median, so
    near-zero means (e.g., CDD on the foggy Pacific coast) do not produce extreme ratios.
    """
    slopes = city_slopes(history, last_year)
    means = history.loc[:, last_year - WINDOW + 1:last_year].mean(axis=1)
    usable = slopes.notna() & (means >= 0.1 * means.median()) & (means > 0)
    relative = float(np.median(slopes[usable] / means[usable]))
    level = history.loc[:, last_year - LEVEL_YEARS + 1:last_year].mean(axis=1)
    return level_plus_slope(history, last_year, years, relative * level)


def _neighbor_index() -> dict[str, list[str]]:
    """For each city, itself and its NEIGHBORS nearest cities by great-circle distance."""
    cities = pd.read_csv(DATA_DIR / "city_info.csv", dtype={"city_id": str}).set_index("city_id")
    lat, lon = np.radians(cities["lat"].to_numpy()), np.radians(cities["lon"].to_numpy())
    cos_d = (np.sin(lat[:, None]) * np.sin(lat) +
             np.cos(lat[:, None]) * np.cos(lat) * np.cos(lon[:, None] - lon))
    dist = np.arccos(np.clip(cos_d, -1, 1))
    ids = cities.index.to_numpy()
    return {ids[i]: list(ids[np.argsort(dist[i], kind="stable")]) for i in range(len(ids))}


def level_neighbors_forecast(history: pd.DataFrame, last_year: int, years: list[int]) -> pd.DataFrame:
    """City level + the mean 30-year slope of the city and its nearest cities that have one."""
    slopes = city_slopes(history, last_year)
    shared = float(np.nanmedian(slopes))
    order = _neighbor_index()
    pooled = {}
    for city in history.index:
        near = [c for c in order.get(city, [city]) if c in slopes.index and not np.isnan(slopes[c])]
        pooled[city] = slopes[near[:NEIGHBORS + 1]].mean() if near else shared
    return level_plus_slope(history, last_year, years, pd.Series(pooled))


FORECASTERS = {
    "average": average_forecast,
    "trend": trend_forecast,
    "last10": last10_forecast,
    "blend": blend_forecast,
    "level_allcities": level_allcities_forecast,
    "level_neighbors": level_neighbors_forecast,
    "level_allcities_pct": level_allcities_pct_forecast,
}
RATIO_ONLY = {"level_allcities_pct"}   # candidates that only make sense for metrics that start at zero


def forecast(table: pd.DataFrame, metric: str, method: str, last_year: int, years: list[int]) -> pd.DataFrame:
    history = table.loc[:, :last_year]
    pred = FORECASTERS[method](history, last_year, years)
    return pred.clip(lower=0) if metric in NON_NEGATIVE else pred


def load_oni_year_end() -> pd.Series:
    """ONI known at the end of each year: mean of the Aug-Oct and Sep-Nov seasons (months 9, 10)."""
    ocean = pd.read_csv(OCEAN_PATH)
    assert_no_post_cutoff(ocean, year_col="year", source=str(OCEAN_PATH))
    oni = ocean[ocean["index"] == "oni"].pivot(index="year", columns="month", values="value")
    return oni.reindex(columns=[9, 10]).mean(axis=1, skipna=False).dropna()


def enso_shift(table: pd.DataFrame, metric: str, last_year: int, oni_end: pd.Series) -> pd.Series:
    """Per-city change to the forecast for last_year + 1 from the year-end ONI of last_year.

    Fits, for each city, the slope of its one-year-ahead forecast misses (actual minus the METHOD
    forecast made the year before) on the year-end ONI, using origins ENSO_FIRST_ORIGIN to
    last_year - 1 (all outcomes known by last_year). The slope is averaged over the city and its
    NEIGHBORS nearest cities, then multiplied by the ONI at the end of last_year. Zero for other
    metrics, or when that ONI is unknown.
    """
    zero = pd.Series(0.0, index=table.index)
    if metric not in ENSO_METRICS or last_year not in oni_end.index:
        return zero
    origins = [y for y in range(ENSO_FIRST_ORIGIN, last_year) if y in oni_end.index]
    misses = pd.DataFrame({
        y: table[y + 1] - forecast(table, metric, METHOD[metric], y, [y + 1])[y + 1]
        for y in origins if y + 1 in table.columns})
    x = oni_end.reindex(misses.columns).to_numpy()
    slopes = {}
    for city, row in misses.iterrows():
        ok = ~np.isnan(row.to_numpy())
        slopes[city] = (np.polyfit(x[ok], row.to_numpy()[ok], 1)[0]
                        if ok.sum() >= ENSO_MIN_YEARS else np.nan)
    slopes = pd.Series(slopes)
    order = _neighbor_index()
    pooled = {}
    for city in table.index:
        near = [c for c in order.get(city, [city]) if c in slopes.index and not np.isnan(slopes[c])]
        pooled[city] = slopes[near[:NEIGHBORS + 1]].mean() if near else 0.0
    return pd.Series(pooled).reindex(table.index).fillna(0.0) * float(oni_end[last_year])


def combo(table: pd.DataFrame, metric: str, last_year: int, years: list[int],
          oni_end: pd.Series, enso: bool = USE_ENSO) -> pd.DataFrame:
    """The model: METHOD per metric, plus (if enso) the El Nino shift on the first forecast year."""
    pred = forecast(table, metric, METHOD[metric], last_year, years)
    if enso:
        pred[years[0]] = pred[years[0]] + enso_shift(table, metric, last_year, oni_end)
    return pred.clip(lower=0) if metric in NON_NEGATIVE else pred


def backtest(annual: pd.DataFrame) -> pd.DataFrame:
    """MAE and skill of every candidate and of the combo, on each window in BACKTEST_ENDS."""
    oni_end = load_oni_year_end()
    rows = []
    for last_year in BACKTEST_ENDS:
        years = list(range(last_year + 1, last_year + 1 + TEST_LENGTH))
        assert years[-1] <= CUTOFF_YEAR, "backtests must stay inside the training data"
        window = f"train<={last_year}, test {years[0]}-{years[-1]}"
        for metric in METRICS:
            table = wide(annual, metric)
            # Rows the challenge would score: valid year, and the city has a 30-year baseline
            actual = table[years].where(thirty_year_mean(table.loc[:, :last_year], last_year).notna(), axis=0)
            preds = {name: forecast(table, metric, name, last_year, years) for name in FORECASTERS
                     if name not in RATIO_ONLY or metric in NON_NEGATIVE}
            preds["combo"] = combo(table, metric, last_year, years, oni_end)
            preds["combo_enso"] = combo(table, metric, last_year, years, oni_end, enso=True)
            for name, pred in preds.items():
                pred = pred.reindex(index=actual.index, columns=years)
                rows.append({"window": window, "model": name, "metric": metric,
                             "mae": mae(actual.stack(future_stack=True), pred.stack(future_stack=True))})
    report = pd.DataFrame(rows)
    ref = report[report["model"] == "average"].set_index(["window", "metric"])["mae"]
    report["skill"] = 1 - report["mae"] / pd.MultiIndex.from_frame(report[["window", "metric"]]).map(ref)
    return report


def check_choice(report: pd.DataFrame) -> None:
    """Warn if METHOD is not the candidate with the highest mean skill (the selection rule)."""
    mean_skill = (report[~report["model"].str.startswith("combo")]
                  .groupby(["metric", "model"])["skill"].mean().unstack("model"))
    for metric, row in mean_skill.iterrows():
        best = row.idxmax()
        flag = "" if best == METHOD[metric] else f"   <-- WARNING: rule picks {best}"
        print(f"  {metric:18s} METHOD={METHOD[metric]:16s} best={best:16s} "
              f"(mean skill {row[best]:.3f}){flag}")


def scores(report: pd.DataFrame) -> pd.DataFrame:
    """Leaderboard formula per window and model: 100 * max(0, mean skill over the 4 metrics)."""
    s = 100 * (report[~report["model"].isin(RATIO_ONLY)]            # those cover only 2 metrics
               .groupby(["window", "model"])["skill"].mean().clip(lower=0))
    table = s.unstack("window").round(1)
    table["mean"] = table.mean(axis=1).round(1)
    return table


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    parser.add_argument("--no-backtest", action="store_true", help="skip the backtests")
    args = parser.parse_args()

    annual = load_valid_annual()

    if not args.no_backtest:
        report = backtest(annual)
        REPORTS_DIR.mkdir(exist_ok=True)
        report.round(4).to_csv(REPORTS_DIR / "backtest_combo.csv", index=False)
        print("Skill vs the 30-year average, per metric (higher is better):")
        print(report.pivot_table(index=["metric", "model"], columns="window", values="skill")
              .round(3).to_string())
        print("\nScore (0-100, same formula as the leaderboard; 'combo' = submitted model, 'combo_enso' = with El Nino shift):")
        print(scores(report).to_string())
        print("\nSelection rule check (highest mean skill per metric):")
        check_choice(report)

    oni_end = load_oni_year_end() if USE_ENSO else pd.Series(dtype=float)
    if USE_ENSO and CUTOFF_YEAR not in oni_end.index:
        raise SystemExit(f"{OCEAN_PATH} has no ONI for Sep-Oct {CUTOFF_YEAR}: "
                         "run python code/prepare_ocean_indices.py")
    parts = []
    for metric in METRICS:
        pred = combo(wide(annual, metric), metric, CUTOFF_YEAR, FORECAST_YEARS, oni_end)
        long = pred.stack().rename("predicted_value").reset_index()
        long.columns = ["city_id", "year", "predicted_value"]
        long["metric"] = metric
        parts.append(long)
    order = {m: i for i, m in enumerate(METRICS)}
    submission = (pd.concat(parts)[["city_id", "year", "metric", "predicted_value"]]
                  .sort_values(["city_id", "year", "metric"],
                               key=lambda s: s.map(order) if s.name == "metric" else s))
    submission["predicted_value"] = submission["predicted_value"].round(3)

    expected = annual["city_id"].nunique() * len(FORECAST_YEARS) * len(METRICS)
    if len(submission) != expected or not np.isfinite(submission["predicted_value"]).all():
        raise SystemExit(f"Incomplete forecasts: {len(submission)} rows (expected {expected}) "
                         "or non-finite values")
    submission.to_csv(SUBMISSION_PATH, index=False)
    print(f"\nWrote {len(submission):,} forecasts to {SUBMISSION_PATH}")


if __name__ == "__main__":
    main()