Datasets:
Download code/v7lib.py from tchaudha/heat-seekers-protostar: direct link, hf CLI and curl.
- Browser
- Download file 13.9 kB
-
https://huggingface.co/datasets/tchaudha/heat-seekers-protostar/resolve/main/code/v7lib.py
- Command line
-
hf download hf://datasets/tchaudha/heat-seekers-protostar/code/v7lib.py
-
curl -L -o v7lib.py https://huggingface.co/datasets/tchaudha/heat-seekers-protostar/resolve/main/code/v7lib.py
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 | |