Datasets:
File size: 13,877 Bytes
e46cc36 | 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 | """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
|