Datasets:
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()
|