"""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