tchaudha's picture
v7: CDD from temperature-to-CDD map (pre-registered V7 protocol; idea credited to PstarAlu @8c8dc3f)
e46cc36 verified
Raw History Blame Contribute Delete
13.9 kB
"""Heat Seekers v7: second-round ideas (research/V7_PROTOCOL.md). Every statistic for origin T reads years <= T only."""
import numpy as np, pandas as pd
from v6lib import *
from v6lib import _win, cal_years, h_os2 as _h_os2, nudge_D
from v2lib import lin30, seg_slope, level_years
REF7 = {'annual_avg_temp': 't_regdep75_nat', 'cdd': 'v2b', 'total_precip_in': 'p_nudge', 'hottest_day_temp': 'h_nudge'}
CANDS7 = {'annual_avg_temp': ['t_twoscale', 't_twoscale50', 't_arma25', 'r25_temp'],
'cdd': ['c_map', 'c_map_blend', 'c_et50', 'r25_cdd'],
'total_precip_in': ['p_wet', 'p_wet_f1', 'p_nudge_wet', 'p_nudge_cyc', 'r25_precip'],
'hottest_day_temp': ['h_mix_os2', 'r25_hot']}
R25 = {'annual_avg_temp': 'r25_temp', 'cdd': 'r25_cdd', 'total_precip_in': 'r25_precip', 'hottest_day_temp': 'r25_hot'}
TRAIN_START = 1965; H = 7; TM = 'annual_avg_temp'
def attach7(P):
P = attach6(P)
a = pd.read_parquet(DATA / 'annual_indices/train-00000-of-00001.parquet', columns=['ID', 'Year', 'Wet Days'])
a = a[(a.Year >= Y0) & (a.Year <= Y1)]; W = np.full((len(P.ids), len(YEARS)), np.nan)
W[np.searchsorted(P.ids, a.ID.to_numpy()), a.Year.to_numpy() - Y0] = a['Wet Days'].to_numpy(float); P.wet = W
return P
def cut7(P, origin, junk=999999.0):
Q = cut6(P, origin, junk); k = origin - Y0 + 1; Q.wet = P.wet.copy(); Q.wet[:, k:] = junk; return Q
def dist_km(P, origin):
lat, lon = coords(P, origin); la, lo = np.radians(lat), np.radians(lon)
h = np.sin((la[:, None] - la[None]) / 2) ** 2 + np.cos(la[:, None]) * np.cos(la[None]) * np.sin((lo[:, None] - lo[None]) / 2) ** 2
return 6371.0 * 2 * np.arcsin(np.sqrt(np.clip(h, 0, 1)))
def nanmean_w(Wm, X):
ok = np.isfinite(X); num = Wm @ np.where(ok, X, 0); den = Wm @ ok
return np.where(den > 0, num / np.maximum(den, 1e-300), np.nan)
def v6_mats(P, origin):
f, info = v6_block(P, origin, H); out = {}
for m, meth in REF7.items():
g = f[(f.metric == m) & (f.method == meth)].pivot(index='city_id', columns='year', values='predicted_value')
out[m] = g.reindex(P.ids).to_numpy()
return out, info, f
def ar1_pooled(X):
x0 = X[:, :-1]; x1 = X[:, 1:]; ok = np.isfinite(x0) & np.isfinite(x1)
den = (x0[ok] ** 2).sum()
return (x0[ok] * x1[ok]).sum() / den if den > 0 else 0.0
def t_twoscale(P, origin, s2, v6t):
an, mu, a, b = anomalies(P, TM, origin); yrs = YEARS[a:b].astype(float); hs = np.arange(1, H + 1)
N = np.array([np.nanmedian(an[:, t]) if np.isfinite(an[:, t]).any() else np.nan for t in range(an.shape[1])])
D = an - N[None]; D = D - np.nanmean(D, 1, keepdims=True)
Wm = (dist_km(P, origin) <= 300.0).astype(float)
DR = np.where(np.isfinite(D), nanmean_w(Wm, D), np.nan); DL = D - DR
ks = []
for X in (DR, DL):
k = ar1_pooled(X); k = k + (1 + 3 * k) / 30.0; ks.append(min(max(k, 0.0), 0.95))
kR, kL = ks
f15 = np.isfinite(N) & (yrs >= origin - 14); Nhat = N[f15].mean() + s2 * (origin + hs - yrs[f15].mean())
out = v6t.copy()
for i in range(len(P.ids)):
if not np.isfinite(mu[i]): continue
idx = np.where(np.isfinite(D[i]))[0]
if not len(idx): continue
j = idx[-1]; lead = origin + hs - yrs[j]
dr = DR[i, j] if np.isfinite(DR[i, j]) else 0.0; dl = DL[i, j] if np.isfinite(DL[i, j]) else 0.0
out[i] = mu[i] + Nhat + dr * kR ** lead + dl * kL ** lead
return out, dict(kR=kR, kL=kL)
def t_arma(P, origin, v6t):
hs = np.arange(1, H + 1); a50, b = _win(origin, 50); y50 = YEARS[a50:b].astype(float); sl = []
for i in range(len(P.ids)):
ok = P.valid[TM][i, a50:b]
if ok.sum() >= 20: sl.append(np.polyfit(y50[ok], P.value[TM][i, a50:b][ok], 1)[0])
r = float(np.mean(sl)); a70, _ = _win(origin, 70); y70 = YEARS[a70:b].astype(float); out = v6t.copy()
for i in range(len(P.ids)):
ok = P.valid[TM][i, a70:b]
if ok.sum() < 20: continue
e = np.where(ok, P.value[TM][i, a70:b] - r * y70, np.nan); lev = np.nanmean(e); z = e - lev
x0, x1 = z[:-1], z[1:]; k = np.isfinite(x0) & np.isfinite(x1); den = (x0[k] ** 2).sum()
phi = float(np.clip((x0[k] * x1[k]).sum() / den if den > 0 else 0.0, 0, 0.95))
j = np.where(ok)[0][-1]; out[i] = lev + r * (origin + hs) + phi ** (origin + hs - y70[j]) * z[j]
return out, r
def c_map(P, origin, v6t):
n = len(P.ids); k1 = origin - Y0 + 1; out = np.full((n, H), np.nan)
for i in range(n):
idx = np.where(P.valid[TM][i, :k1] & np.isfinite(P.value['cdd'][i, :k1]))[0]
maps = []
for nn in (30, 10):
comp = idx[P.days_both[i, idx] >= 360][-nn:]; use = comp if len(comp) >= 5 else idx[-nn:]
vals = np.empty((len(use), H))
for r, t in enumerate(use):
vals[r] = P.value['cdd'][i, t] + interp_inc(P.inc[i, t], v6t[i] - P.value[TM][i, t])
maps.append(vals.mean(0))
out[i] = np.maximum((maps[0] + maps[1]) / 2, 0)
return out
def p_wet(P, origin, F):
m = 'total_precip_in'; k1 = origin - Y0 + 1; base = clim30(P, m, origin)[0]; n = len(P.ids); preds = []
for N in (6, 8, 10):
rw = np.full(n, np.nan); ri = np.full(n, np.nan)
for i in range(n):
ok = P.valid[m][i, :k1] & np.isfinite(P.wet[i, :k1]) & (P.wet[i, :k1] > 0) & np.isfinite(P.value[m][i, :k1])
idx = np.where(ok)[0]
if len(idx) < N: continue
W = P.wet[i, idx]; I = P.value[m][i, idx] / W
w30, i30 = W[-30:].mean(), I[-30:].mean()
if w30 > 0 and i30 > 0: rw[i] = W[-N:].mean() / w30; ri[i] = I[-N:].mean() / i30
rwn, rin = np.nanmean(rw), np.nanmean(ri)
rws = 0.5 * np.where(np.isfinite(rw), rw, rwn) + 0.5 * rwn; ris = np.where(np.isfinite(ri), ri, rin)
preds.append(F * base * rws ** 1.1 * ris ** 0.5)
p = np.mean(preds, 0); return np.where(np.isfinite(p), p, base)
def p_cycle(P, origin):
m = 'total_precip_in'; a, b = _win(origin, 60); v = P.value[m][:, a:b]; ok = P.valid[m][:, a:b]; yrs = YEARS[a:b].astype(float)
nv = ok.sum(1); mu = np.where(nv >= 30, np.nansum(np.where(ok, v, 0), 1) / np.maximum(nv, 1), np.nan)
an = np.where(ok & np.isfinite(mu)[:, None], v - mu[:, None], np.nan)
d = dist_km(P, origin); R = nanmean_w((d <= 300.0).astype(float), an)
fit = np.isfinite(R).sum(1) >= 20; best = None
for p in np.arange(8.0, 30.0 + 1e-9, 0.5):
sse = 0.0; co = np.full((len(P.ids), 2), np.nan)
for i in np.where(fit)[0]:
k = np.isfinite(R[i]); X = np.column_stack([np.ones(k.sum()), np.sin(2 * np.pi * yrs[k] / p), np.cos(2 * np.pi * yrs[k] / p)])
c, *_ = np.linalg.lstsq(X, R[i, k], rcond=None); sse += ((R[i, k] - X @ c) ** 2).sum(); co[i] = c[1:]
if best is None or sse < best[0]: best = (sse, p, co)
_, p, co = best; G = np.exp(-d ** 2 / (2 * 300.0 ** 2)) * np.isfinite(co[:, 0])[None]
cs = (G @ np.nan_to_num(co)) / np.maximum(G.sum(1, keepdims=True), 1e-300)
y = origin + np.arange(1, H + 1)
return 0.5 * (cs[:, :1] * np.sin(2 * np.pi * y / p)[None] + cs[:, 1:] * np.cos(2 * np.pi * y / p)[None]), p
# ------------------------------------------------------------------ learned candidates: per-origin examples
def origin_examples(P, o):
"""Per metric: v6 base (n,H), ridge features (n,H,6), ET features for CDD (n,H,14), labels (n,H) (NaN unless scored)."""
mats, info, _ = v6_mats(P, o); s2 = info['s_v2']; n = len(P.ids); hs = np.arange(1, H + 1); a, b = _win(o, 30)
yrs = YEARS[a:b].astype(float); lat, lon = coords(P, o); ex = {}
tmu = clim30(P, TM, o)[0]
for m in METRICS:
v = P.value[m][:, a:b]; ok = P.valid[m][:, a:b]; nv = ok.sum(1)
mu = np.where(nv >= 10, np.nansum(np.where(ok, v, 0), 1) / np.maximum(nv, 1), np.nan)
r5 = np.array([v[i, -5:][ok[i, -5:]].mean() if ok[i, -5:].any() else np.nan for i in range(n)])
sl = np.full(n, np.nan); cen = np.full(n, np.nan)
for i in range(n):
if nv[i] >= 10: sl[i] = np.polyfit(yrs[ok[i]], v[i, ok[i]], 1)[0]; cen[i] = yrs[ok[i]].mean()
base = mats[m]
Xr = np.stack([base, base - mu[:, None], np.repeat((r5 - mu)[:, None], H, 1), sl[:, None] * (o + hs[None] - cen[:, None]),
np.repeat(hs[None].astype(float), n, 0), np.repeat((nv / 30.0)[:, None], H, 1)], -1)
lab = np.full((n, H), np.nan)
for j, h in enumerate(hs):
t = o + h - Y0
if o + h <= Y1:
g = P.valid[m][:, t] & (nv >= 10); lab[g, j] = P.value[m][g, t]
ex[m] = dict(base=base, Xr=Xr, y=lab, mu=mu)
if m == 'cdd':
sd = np.array([np.std(v[i, ok[i]], ddof=1) if nv[i] >= 3 else np.nan for i in range(n)]); sc = np.maximum(np.nan_to_num(sd, nan=25.0), 25.0)
lv = {L: np.array([P.value[m][i, level_years(P, m, o, i, L)].mean() for i in range(n)]) for L in (15, 10, 5)}
last = np.array([P.value[m][i, np.where(P.valid[m][i, :b])[0][-1]] for i in range(n)])
lev, ls = lin30(P, m, o); lin = lev[:, None] + ls[:, None] * hs[None]; own = seg_slope(P, m, o)
muf = np.where(np.isfinite(mu), mu, clim30(P, m, o)[0])
rel = lambda q: (q - muf) / sc
cols = [np.repeat((hs / 7.0)[None], n, 0), (base - muf[:, None]) / sc[:, None]] + [np.repeat(rel(lv[L])[:, None], H, 1) for L in (15, 10, 5)] + \
[np.repeat(rel(last)[:, None], H, 1), (lin - muf[:, None]) / sc[:, None], np.repeat((own / sc)[:, None], H, 1),
np.full((n, H), s2), mats[TM] - tmu[:, None], np.repeat(sc[:, None], H, 1), np.repeat(nv[:, None].astype(float), H, 1),
np.repeat(lat[:, None], H, 1), np.repeat(lon[:, None], H, 1), np.repeat(muf[:, None], H, 1)]
ex[m].update(Xe=np.stack(cols, -1), sc=sc, muf=muf)
return ex
def training_rows(EX, T, m, key):
X, y, w, ty = [], [], [], []
for o in range(TRAIN_START, T):
e = EX[o][m]
for j in range(H):
if o + j + 1 > T: break
g = np.isfinite(e['y'][:, j])
X.append(e[key][g, j]); ty.append(np.full(g.sum(), o + j + 1))
y.append(e['y'][g, j] - e['base'][g, j] if key == 'Xr' else (e['y'][g, j] - e['muf'][g]) / e['sc'][g])
w.append(np.ones(g.sum()) if key == 'Xr' else e['sc'][g])
X = np.vstack(X); y = np.concatenate(y); w = np.concatenate(w); ty = np.concatenate(ty)
assert ty.max() <= T
_, inv, cnt = np.unique(ty, return_inverse=True, return_counts=True); w = w / cnt[inv]
return X, y, w
def ridge25(X, r, w, Xp):
keep = np.isfinite(X).all(1); X, r, w = X[keep], r[keep], w[keep]; w = w / w.sum()
xm = w @ X; xs = np.sqrt(w @ ((X - xm) ** 2)); xs = np.where(xs <= 1e-12, 1.0, xs)
mu = float(w @ r); ys = float(np.sqrt(w @ ((r - mu) ** 2))) or 1.0; Z = (X - xm) / xs
coef = np.linalg.solve(Z.T @ (w[:, None] * Z) + 10.0 * np.eye(X.shape[1]), Z.T @ (w * ((r - mu) / ys)))
corr = mu + ys * (((Xp - xm) / xs) @ coef)
return np.where(np.isfinite(Xp).all(-1), 0.25 * corr, 0.0)
def extra_trees(X, z, w, Xp):
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.impute import SimpleImputer
imp = SimpleImputer(strategy='median', keep_empty_features=True); Xi = imp.fit_transform(X)
mod = ExtraTreesRegressor(n_estimators=128, max_depth=8, min_samples_leaf=100, max_features=0.8, bootstrap=False,
random_state=20261108, n_jobs=4).fit(Xi, z, sample_weight=w / w.mean())
mod.n_jobs = 1 # parallel predict sums trees in thread order -> float nondeterminism
sh = Xp.shape; return np.clip(mod.predict(imp.transform(Xp.reshape(-1, sh[-1]))).reshape(sh[:-1]), -2, 2)
# ------------------------------------------------------------------ full block
def v7_block(P, origin, EX):
"""EX: dict pseudo-origin -> origin_examples, must contain TRAIN_START..origin (origin entry = forecast features)."""
mats, info, f6 = v6_mats(P, origin); s2 = info['s_v2']; ids = P.ids; hs = np.arange(1, H + 1); rows = []
f6 = f6[f6.method.isin(list(REF7.values()) + ['clim30'])]; rows.append(f6)
def add(metric, method, M):
M = np.asarray(M, float)
if M.ndim == 1: M = np.repeat(M[:, None], H, 1)
if metric in ('cdd', 'total_precip_in'): M = np.maximum(M, 0)
assert np.isfinite(M).all(), method
for j, h in enumerate(hs):
rows.append(pd.DataFrame({'city_id': ids, 'year': origin + h, 'metric': metric, 'method': method, 'predicted_value': M[:, j]}))
v6t = mats[TM]
t1, kk = t_twoscale(P, origin, s2, v6t); add(TM, 't_twoscale', t1); add(TM, 't_twoscale50', 0.5 * t1 + 0.5 * v6t)
ar, rate = t_arma(P, origin, v6t); add(TM, 't_arma25', 0.75 * v6t + 0.25 * ar)
cm = c_map(P, origin, v6t); add('cdd', 'c_map', cm); add('cdd', 'c_map_blend', 0.5 * cm + 0.5 * mats['cdd'])
p = 'total_precip_in'; pb = clim30(P, p, origin)[0]
add(p, 'p_wet', p_wet(P, origin, 1.01)); pw1 = p_wet(P, origin, 1.0); add(p, 'p_wet_f1', pw1)
add(p, 'p_nudge_wet', mats[p] * np.where(pb > 0, pw1 / pb, 1.0)[:, None])
cyc, per = p_cycle(P, origin); add(p, 'p_nudge_cyc', mats[p] + cyc)
q = 'hottest_day_temp'; hb = clim30(P, q, origin)[0]; Dh = nudge_D(P, q, origin, False)
add(q, 'h_mix_os2', 0.5 * mats[q] + 0.5 * (_h_os2(P, origin, hb) + 0.3 * Dh)[:, None])
e0 = EX[origin]
for m in METRICS:
X, r, w = training_rows(EX, origin, m, 'Xr'); add(m, R25[m], mats[m] + ridge25(X, r, w, e0[m]['Xr']))
X, z, w = training_rows(EX, origin, 'cdd', 'Xe'); c = e0['cdd']
et = np.maximum(c['muf'][:, None] + extra_trees(X, z, w, c['Xe']) * c['sc'][:, None], 0); add('cdd', 'c_et50', 0.5 * et + 0.5 * mats['cdd'])
info.update(kR=kk['kR'], kL=kk['kL'], arma_rate=rate, cycle_period=per)
return pd.concat(rows, ignore_index=True), info