Datasets:
File size: 10,673 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 | """Forecast models. Each is a pure function of training panels that end at the origin.
A model is described by a small dict (a "spec") so the backtest and the final refit run
exactly the same code:
{"type": "mean", "n": 30} 30-year average (organizers' baseline)
{"type": "ols", "n": 30} per-city straight line (organizers' baseline;
never floored: it stays a straight line)
{"type": "last"} last valid year repeated (organizers' baseline)
{"type": "recent", "n": 10} mean of the last n valid years
{"type": "ptrend", "n": 30, "k": 16, "lam": .5} line through the n-year centroid whose slope is
lam * own OLS slope + (1 - lam) * mean slope of
the k nearest cities (k = 0: all other cities)
{"type": "cdd_via_temp", "n": 30, "temp": spec} per-city regression cdd ~ annual_avg_temp on the
last n years, applied to the temperature forecast
{"type": "blend", "parts": [[w, spec], ...]} convex combination (weights shared by all cities)
`predict()` never sees a year after the panels' last year, so leakage is impossible by
construction; it also asserts that last year is <= 2018.
City-metrics a model cannot fit (fewer than 10 valid years in the window: no baseline, not
scored by the organizers) are filled by `fallback()`.
"""
import numpy as np
from .common import BASELINE_WINDOW, MIN_VALID_YEARS, TRAIN_END
from .data import Panel, assert_no_leak
EARTH_RADIUS_KM = 6371.0088
OWN_SLOPE_MIN_YEARS = 15 # a city's own slope needs this many valid years in the window
FALLBACK_YEARS = 10 # fallback level: the city's last 10 valid years, reaching back over gaps
FALLBACK_NEIGHBORS = 8 # ... moved by what its 8 nearest fitted cities forecast relative to those years
# ── Geography ────────────────────────────────────────────────────────────────
def distance_km(lat, lon) -> np.ndarray:
"""Great-circle (haversine) distance matrix between all cities, in km."""
la, lo = np.radians(np.asarray(lat, float)), np.radians(np.asarray(lon, float))
dla, dlo = la[:, None] - la[None, :], lo[:, None] - lo[None, :]
h = np.sin(dla / 2) ** 2 + np.cos(la)[:, None] * np.cos(la)[None, :] * np.sin(dlo / 2) ** 2
return 2 * EARTH_RADIUS_KM * np.arcsin(np.sqrt(np.clip(h, 0, 1)))
def neighbor_order(lat, lon) -> np.ndarray:
"""[n_city, n_city - 1]: for each city, the other cities from nearest to farthest."""
d = distance_km(lat, lon)
np.fill_diagonal(d, np.inf)
return np.argsort(d, axis=1, kind="stable")[:, :-1]
# ── Building blocks (p is a training panel; its last year is the origin) ─────
def window_mean(p: Panel, n: int, min_valid: int = 1) -> np.ndarray:
"""Mean of the valid years among the last n calendar years; NaN below min_valid."""
y = p.y[:, -n:]
count = np.isfinite(y).sum(axis=1)
total = np.where(np.isfinite(y), y, 0.0).sum(axis=1)
return np.where(count >= max(min_valid, 1), total / np.maximum(count, 1), np.nan)
def last_valid_mean(p: Panel, n: int) -> np.ndarray:
"""Mean of each city's last n valid years, reaching back over gaps; NaN if none."""
out = np.full(len(p.city_ids), np.nan)
for i, row in enumerate(p.y):
valid = row[np.isfinite(row)]
if valid.size:
out[i] = valid[-n:].mean()
return out
def ols(p: Panel, n: int):
"""Per-city least squares on the valid years of the last n calendar years.
Returns (count, mean year, mean value, slope); slope is NaN with < 2 valid years.
"""
years = p.years[-n:].astype(float)
y = p.y[:, -n:]
ok = np.isfinite(y)
count = ok.sum(axis=1)
safe = np.maximum(count, 1)
tbar = (ok * years).sum(axis=1) / safe
ybar = np.where(ok, y, 0.0).sum(axis=1) / safe
dt = (years[None, :] - tbar[:, None]) * ok
sxx = (dt ** 2).sum(axis=1)
sxy = (dt * np.where(ok, y, 0.0)).sum(axis=1)
slope = np.where(sxx > 0, sxy / np.where(sxx > 0, sxx, 1.0), np.nan)
none = count == 0
return count, np.where(none, np.nan, tbar), np.where(none, np.nan, ybar), slope
def pooled_slope(slope: np.ndarray, order: np.ndarray, k: int, lam: float) -> np.ndarray:
"""lam * own slope + (1 - lam) * mean slope of the k nearest cities with a slope.
k = 0 pools all other cities. A city without its own slope takes the neighbors' mean.
"""
neighbor = np.full(len(slope), np.nan)
for i in range(len(slope)):
s = slope[order[i]]
s = s[np.isfinite(s)]
if k:
s = s[:k]
if s.size:
neighbor[i] = s.mean()
own = np.where(np.isfinite(slope), slope, neighbor)
return lam * own + (1.0 - lam) * np.where(np.isfinite(neighbor), neighbor, own)
# ── Models ───────────────────────────────────────────────────────────────────
def _flat(value: np.ndarray, target_years) -> np.ndarray:
return np.repeat(value[:, None], len(target_years), axis=1)
def _predict(spec: dict, panels: dict[str, Panel], metric: str, order: np.ndarray,
target_years: np.ndarray) -> np.ndarray:
p = panels[metric]
kind = spec["type"]
if kind == "mean": # baseline rule: needs MIN_VALID_YEARS valid years in the window
return _flat(window_mean(p, spec["n"], spec.get("min_valid", MIN_VALID_YEARS)), target_years)
if kind == "recent":
return _flat(last_valid_mean(p, spec["n"]), target_years)
if kind == "last":
return _flat(last_valid_mean(p, 1), target_years)
if kind == "ols": # organizers' linear trend: a line through the valid years of the window
count, tbar, ybar, slope = ols(p, spec["n"])
line = ybar[:, None] + slope[:, None] * (target_years[None, :] - tbar[:, None])
return np.where((count >= spec.get("min_valid", MIN_VALID_YEARS))[:, None], line, np.nan)
if kind == "ptrend":
count, tbar, ybar, slope = ols(p, spec["n"])
own = np.where(count >= OWN_SLOPE_MIN_YEARS, slope, np.nan)
b = pooled_slope(own, order, spec["k"], spec["lam"])
line = ybar[:, None] + b[:, None] * (target_years[None, :] - tbar[:, None])
return np.where((count >= MIN_VALID_YEARS)[:, None], line, np.nan)
if kind == "cdd_via_temp":
assert metric == "cdd"
temp = panels["annual_avg_temp"]
n = spec["n"]
x, y = temp.y[:, -n:], p.y[:, -n:]
ok = np.isfinite(x) & np.isfinite(y)
count = ok.sum(axis=1)
safe = np.maximum(count, 1)
xbar = np.where(ok, x, 0.0).sum(axis=1) / safe
ybar = np.where(ok, y, 0.0).sum(axis=1) / safe
dx = (x - xbar[:, None]) * ok
sxx = (np.where(ok, dx, 0.0) ** 2).sum(axis=1)
sxy = (np.where(ok, dx, 0.0) * np.where(ok, y, 0.0)).sum(axis=1)
beta = np.where(sxx > 0, sxy / np.where(sxx > 0, sxx, 1.0), np.nan)
t_hat = predict(spec["temp"], panels, "annual_avg_temp", order, target_years)
out = ybar[:, None] + beta[:, None] * (t_hat - xbar[:, None])
return np.where((count >= MIN_VALID_YEARS)[:, None], out, np.nan)
if kind == "blend":
weights = np.array([w for w, _ in spec["parts"]], float)
assert (weights >= -1e-12).all() and abs(weights.sum() - 1.0) < 1e-9, "blend must be convex"
parts = [_predict(s, panels, metric, order, target_years) for _, s in spec["parts"]]
return sum(w * part for w, part in zip(weights, parts))
raise ValueError(f"unknown model type {kind!r}")
def fallback(p: Panel, raw: np.ndarray, order: np.ndarray) -> np.ndarray:
"""Fill the rows of `raw` ([n_city, n_year] forecasts) that the model could not fit.
Such a city-metric has fewer than 10 valid years in the window, so its recent level is
unknown. Its level is the mean of its last FALLBACK_YEARS valid years (reaching back over
gaps, possibly decades); the forecast is that level plus the regional change since those
years: the mean, over the FALLBACK_NEIGHBORS nearest fitted cities, of (their forecast minus
their own mean over the same years). Without usable neighbors the level itself is used; a
city-metric with no valid year at all stays NaN. Only training data enters.
"""
out = raw.copy()
fitted = np.isfinite(raw).all(axis=1)
for i in np.flatnonzero(~fitted):
idx = np.flatnonzero(np.isfinite(p.y[i]))[-FALLBACK_YEARS:]
if idx.size == 0:
continue
level = p.y[i, idx].mean()
deltas = []
for j in order[i]:
if not fitted[j]:
continue
same_years = p.y[j, idx]
ok = np.isfinite(same_years)
if ok.sum() >= max(3, (idx.size + 1) // 2):
deltas.append(raw[j] - same_years[ok].mean())
if len(deltas) == FALLBACK_NEIGHBORS:
break
out[i] = level + (np.mean(deltas, axis=0) if deltas else 0.0)
return out
def predict(spec: dict, panels: dict[str, Panel], metric: str, order: np.ndarray,
target_years, fill: bool = True) -> np.ndarray:
"""Forecast `metric` for `target_years` -> [n_city, n_year].
panels: training panels of every metric, all ending at the origin (<= 2018).
fill: fill what the model could not fit with `fallback` (those city-metrics have
no baseline and are not scored).
"""
target_years = np.asarray(target_years, dtype=float)
for q in panels.values():
assert_no_leak(q.years, f"training panel {q.metric}", TRAIN_END)
assert q.origin == panels[metric].origin, "panels must end at the same origin"
assert target_years.min() > panels[metric].origin, "targets must be after the origin"
out = _predict(spec, panels, metric, order, target_years)
if fill:
out = fallback(panels[metric], out, order)
if metric in ("cdd", "total_precip_in") and spec["type"] != "ols":
out = np.where(np.isfinite(out), np.maximum(out, 0.0), out) # physical floor (our models only)
return out
BASELINES = {
"30-year average": {"type": "mean", "n": BASELINE_WINDOW},
"Linear trend": {"type": "ols", "n": BASELINE_WINDOW},
"Last year repeated": {"type": "last"},
}
|