sleonca's picture
Upload folder using huggingface_hub
b47743b verified
Raw History Blame Contribute Delete
9.02 kB
"""Forecast models. Each takes the valid history up to `origin` and returns predictions
for `years` (origin+1 .. origin+7). Nothing here looks past `origin`.
"""
import numpy as np
import pandas as pd
from common import METRICS
def wide(lv: pd.DataFrame, metric: str, origin: int, seg_only_min: int = 0) -> pd.DataFrame:
"""cities x years matrix of valid values up to origin (NaN = invalid/missing).
seg_only_min > 0: drop years recorded before the city's latest station change (as of
origin) when the current station has at least that many valid years, so a relocation
does not bias the city's level.
"""
w = lv[(lv.metric == metric) & (lv.Year <= origin)]
w = w.assign(value=w.value.where(w.valid))
if seg_only_min:
last = w.groupby("ID")["segment"].transform("max")
cur = w.segment == last
n_cur = (cur & w.value.notna()).groupby(w.ID).transform("sum")
w = w.assign(value=w.value.where(cur | (n_cur < seg_only_min)))
return w.pivot(index="ID", columns="Year", values="value")
def _ols_slope(M: np.ndarray, x: np.ndarray, min_n: int = 10) -> np.ndarray:
"""Per-row OLS slope of M against x, ignoring NaN."""
ok = ~np.isnan(M)
n = ok.sum(1)
X = np.where(ok, x, np.nan)
xm = np.nanmean(X, 1, keepdims=True)
ym = np.nanmean(M, 1, keepdims=True)
num = np.nansum((X - xm) * (M - ym), 1)
den = np.nansum((X - xm) ** 2, 1)
s = num / den
s[n < min_n] = np.nan
return s
def knn_mean(values: pd.Series, coords: pd.DataFrame, k: int) -> pd.Series:
"""Average of `values` over each city's k nearest cities (itself included), by great-circle distance."""
c = coords.loc[values.index]
lat, lon = np.radians(c.Lat.values), np.radians(c.Lon.values)
d = np.arccos(np.clip(np.sin(lat[:, None]) * np.sin(lat) + np.cos(lat[:, None]) * np.cos(lat) * np.cos(lon[:, None] - lon), -1, 1))
v = values.values
d = np.where(np.isnan(v)[None, :], np.inf, d)
idx = np.argsort(d, 1)[:, :k]
return pd.Series(np.nanmean(v[idx], 1), index=values.index)
def level_trend(lv, origin, years, coords, metric, k=15, L=40, w_city=0.0, k_nn=None,
stat="mean", slope_scale=1.0, fallback=30, seg_only_min=0):
"""Level = mean (or median) of the last k valid years; extended to each target year with a slope.
slope = w_city * city OLS slope over the last L years + (1 - w_city) * pooled slope
(pooled over the k_nn nearest cities, or all cities if k_nn is None).
"""
W = wide(lv, metric, origin)
Wl = wide(lv, metric, origin, seg_only_min) if seg_only_min else W
cols = [y for y in W.columns if y > origin - k]
R = Wl[cols]
level = (R.median(1) if stat == "median" else R.mean(1))
center = R.notna().mul(np.array(cols), axis=1).sum(1) / R.notna().sum(1)
# fall back to a longer window if too few recent valid years
few = R.notna().sum(1) < max(3, k // 3)
if few.any():
R2 = Wl[[y for y in W.columns if y > origin - fallback]]
level[few] = R2.mean(1)[few]
center[few] = (R2.notna().mul(np.array(R2.columns), axis=1).sum(1) / R2.notna().sum(1))[few]
S = W[[y for y in W.columns if y > origin - L]]
city_slope = pd.Series(_ols_slope(S.values, np.array(S.columns, float)), index=W.index)
pooled = knn_mean(city_slope, coords, k_nn) if k_nn else pd.Series(np.nanmean(city_slope), index=W.index)
slope = (w_city * city_slope.fillna(pooled) + (1 - w_city) * pooled) * slope_scale
out = []
for y in years:
out.append(pd.DataFrame({"ID": W.index, "metric": metric, "Year": y,
"pred": (level + slope * (y - center)).values}))
return pd.concat(out, ignore_index=True)
def baseline30_model(lv, origin, years, coords, metric):
return level_trend(lv, origin, years, coords, metric, k=30, slope_scale=0.0)
def linear30_model(lv, origin, years, coords, metric):
return level_trend(lv, origin, years, coords, metric, k=30, L=30, w_city=1.0)
def _knn_index(coords: pd.DataFrame, ids, k: int) -> np.ndarray:
c = coords.loc[ids]
lat, lon = np.radians(c.Lat.values), np.radians(c.Lon.values)
d = np.arccos(np.clip(np.sin(lat[:, None]) * np.sin(lat) + np.cos(lat[:, None]) * np.cos(lat) * np.cos(lon[:, None] - lon), -1, 1))
return np.argsort(d, 1)[:, :k]
def regional_anom(lv, origin, years, coords, metric, k_nn=15, L=50, k_off=30, ref=30,
slope_scale=1.0, w_nat=0.0, fit="ols"):
"""value = city reference mean + city offset vs. its region + regional anomaly trend.
Regional anomaly: average over the k_nn nearest cities of (value - own `ref`-year mean),
which cancels most of the year-to-year noise shared by neighbours. Its linear trend over
the last L years (optionally shrunk toward the national trend with weight w_nat) is
extrapolated to the target years. The city offset is the city's mean departure from its
regional anomaly over the last k_off years.
"""
W = wide(lv, metric, origin)
yrs = np.array(W.columns, float)
V = W.values
refmask = yrs > origin - ref
mref = np.nanmean(V[:, refmask], 1)
A = V - mref[:, None]
idx = _knn_index(coords, W.index, k_nn) if k_nn else np.tile(np.arange(len(W)), (len(W), 1))
Rg = np.nanmean(A[idx], 1) # cities x years
Nat = np.nanmean(A, 0)
win = yrs > origin - L
x = yrs[win]
def line(Y): # rows: series; returns slope, intercept at x-mean
s = _ols_slope(Y[:, win], x, min_n=10)
xm = x.mean()
b = np.nanmean(Y[:, win], 1) - s * (np.nanmean(np.where(~np.isnan(Y[:, win]), x, np.nan), 1) - xm)
return s, b, xm
s_r, b_r, xm = line(Rg)
s_n, b_n, _ = line(Nat[None, :])
s = ((1 - w_nat) * s_r + w_nat * s_n[0]) * slope_scale
# anchor regional line at its own mean over the window
offwin = yrs > origin - k_off
off = np.nanmean((A - Rg)[:, offwin], 1)
off = np.where(np.isnan(off), 0, off)
out = []
for y in years:
p = mref + off + b_r + s * (y - xm)
out.append(pd.DataFrame({"ID": W.index, "metric": metric, "Year": y, "pred": p}))
return pd.concat(out, ignore_index=True)
_SHIFT = None
def shift_table():
global _SHIFT
if _SHIFT is None:
from common import ROOT
t = pd.read_parquet(ROOT / "data" / "processed" / "shift_table.parquet").set_index(["ID", "Year"])
cols = [c for c in t.columns if c.startswith("cdd_")]
_SHIFT = (t[cols], np.array([float(c[4:]) for c in cols]))
return _SHIFT
def temp_slope(lv, origin, coords, L=50, k_nn=None, w_city=0.0, metric="annual_avg_temp"):
"""Warming rate (°F/yr) per city: pooled (all cities or k nearest) mean of city OLS slopes."""
W = wide(lv, metric, origin)
S = W[[y for y in W.columns if y > origin - L]]
cs = pd.Series(_ols_slope(S.values, np.array(S.columns, float)), index=W.index)
pooled = knn_mean(cs, coords, k_nn) if k_nn else pd.Series(np.nanmean(cs), index=W.index)
return w_city * cs.fillna(pooled) + (1 - w_city) * pooled
def cdd_shift(lv, origin, years, coords, metric="cdd", N=20, L=50, k_nn=None, w_city=0.0,
slope_scale=1.0, stat="mean", seg_only_min=0):
"""CDD forecast from shifted daily weather.
For target year y, each valid past year t in the last N years has its daily mean
temperatures shifted by slope * (y - t) (the warming expected between t and y), and its
CDD recomputed from the shifted days. The forecast is the average over those years.
This respects that CDD responds nonlinearly to warming (more days cross 65 °F).
"""
tab, deltas = shift_table()
s = temp_slope(lv, origin, coords, L=L, k_nn=k_nn, w_city=w_city) * slope_scale
W = wide(lv, "cdd", origin, seg_only_min)
valid = W.notna().stack()
valid = valid[valid].index
win = [ix for ix in valid if ix[1] > origin - N]
T = tab.loc[win]
ids = T.index.get_level_values(0)
ty = T.index.get_level_values(1).to_numpy()
M = T.to_numpy()
out = []
for y in years:
dl = s.loc[ids].to_numpy() * (y - ty)
dl = np.clip(dl, deltas[0], deltas[-1])
# linear interpolation along delta grid, row by row
pos = np.interp(dl, deltas, np.arange(len(deltas)))
lo = np.floor(pos).astype(int); hi = np.minimum(lo + 1, len(deltas) - 1); f = pos - lo
r = np.arange(len(M))
v = M[r, lo] * (1 - f) + M[r, hi] * f
ser = pd.Series(v, index=ids)
agg = ser.groupby(level=0).median() if stat == "median" else ser.groupby(level=0).mean()
out.append(pd.DataFrame({"ID": agg.index, "metric": metric, "Year": y, "pred": agg.values}))
df = pd.concat(out, ignore_index=True)
# cities with no valid years in the window: fall back to the pooled level+trend model
miss = set(W.index) - set(df.ID)
if miss:
fb = level_trend(lv, origin, years, coords, metric, k=30, L=L)
df = pd.concat([df, fb[fb.ID.isin(miss)]], ignore_index=True)
return df