Datasets:
Download code/v9lib.py from tchaudha/heat-seekers-protostar: direct link, hf CLI and curl.
- Browser
- Download file 16.6 kB
-
https://huggingface.co/datasets/tchaudha/heat-seekers-protostar/resolve/main/code/v9lib.py
- Command line
-
hf download hf://datasets/tchaudha/heat-seekers-protostar/code/v9lib.py
-
curl -L -o v9lib.py https://huggingface.co/datasets/tchaudha/heat-seekers-protostar/resolve/main/code/v9lib.py
16.6 kB
| """Heat Seekers v9: Gemini part-1/part-2 candidates (research/V9_PROTOCOL.md). Data <= origin only.""" | |
| import hashlib | |
| import numpy as np, pandas as pd | |
| from v8lib import * | |
| from v6lib import _win, anomalies, regional, neighbours, nudge_D | |
| from v2lib import interp_inc, median30 | |
| REF9 = dict(REF8) | |
| CANDS9 = { | |
| 'annual_avg_temp': ['t_ewma_d', 't_huber', 't_fdw', 't_eb45'], | |
| 'hottest_day_temp': ['h_ewma_d', 'h_hl', 'h_q10'], | |
| 'total_precip_in': ['p_ewma_d', 'p_cbrt', 'p_eb_ratio'], | |
| 'cdd': ['c_pmean', 'c_detrend'], | |
| } | |
| HL10 = 10.0 | |
| K_WINSOR = 1.65 | |
| def q10_table(P): | |
| """Mean of the 10 highest daily Tmax values per city-year, years 1870..2018 only.""" | |
| cache = ROOT / 'results/cache_v9_q10.npz' | |
| src = DATA / 'daily/train-00000-of-00001.parquet' | |
| tag = hashlib.sha256(src.read_bytes()).hexdigest()[:16] + f'_{Y0}_v9q10' | |
| if cache.exists(): | |
| z = np.load(cache) | |
| if str(z['tag']) == tag: | |
| return z['q10'], z['nq'] | |
| d = pd.read_parquet(src, columns=['ID', 'Date', 'tmax']); d = d[d.tmax.notna()] | |
| d['yr'] = pd.to_datetime(d.Date).dt.year; assert d.yr.max() <= 2018; d = d[d.yr >= Y0] | |
| top = (d.sort_values('tmax', ascending=False).groupby(['ID', 'yr'], sort=False).head(10) | |
| .groupby(['ID', 'yr'], sort=False).tmax.agg(['mean', 'count'])) | |
| q10 = np.full((len(P.ids), len(YEARS)), np.nan); nq = np.zeros((len(P.ids), len(YEARS)), np.int16) | |
| ids = top.index.get_level_values(0).to_numpy(); yrs = top.index.get_level_values(1).to_numpy() | |
| ci = np.searchsorted(P.ids, ids); ok = (ci < len(P.ids)) & (P.ids[np.minimum(ci, len(P.ids) - 1)] == ids) | |
| q10[ci[ok], yrs[ok] - Y0] = top['mean'].to_numpy()[ok] | |
| nq[ci[ok], yrs[ok] - Y0] = top['count'].to_numpy()[ok] | |
| q10 = np.where(nq >= 10, q10, np.nan) | |
| np.savez(cache, tag=tag, q10=q10, nq=nq) | |
| return q10, nq | |
| def attach9(P): | |
| P = attach6(P); P.q10, P.q10n = q10_table(P); return P | |
| def cut9(P, origin, junk=999999.0): | |
| Q = cut6(P, origin, junk); k = origin - Y0 + 1 | |
| Q.q10 = P.q10.copy(); Q.q10n = P.q10n.copy() | |
| Q.q10[:, k:] = junk; Q.q10n[:, k:] = 0 | |
| return Q | |
| def ewma(D, yrs, origin, half=HL10): | |
| w = 2.0 ** ((yrs - origin) / half) | |
| num = np.nansum(np.where(np.isfinite(D), D * w[None], 0.0), 1) | |
| den = np.nansum(np.where(np.isfinite(D), w[None], 0.0), 1) | |
| return np.where(den > 0, num / den, np.nan) | |
| def winsor_mean(x, k=K_WINSOR): | |
| x = np.asarray(x, float); x = x[np.isfinite(x)] | |
| if x.size == 0: return np.nan | |
| if x.size == 1: return float(x[0]) | |
| med = np.median(x); mad = np.median(np.abs(x - med)) | |
| if mad == 0: return float(x.mean()) | |
| scale = 1.4826 * mad; lo, hi = med - k * scale, med + k * scale | |
| return float(np.clip(x, lo, hi).mean()) | |
| def hodges_lehmann(x): | |
| x = np.asarray(x, float); x = x[np.isfinite(x)]; n = len(x) | |
| if n == 0: return np.nan | |
| s = (x[:, None] + x[None, :]) / 2.0 | |
| return float(np.median(s[np.triu_indices(n)])) | |
| def nudge_D_arr(P, value, valid, origin, ratio=False, k=31): | |
| a, b = _win(origin, 30); v = value[:, a:b]; ok = valid[:, a:b]; n = ok.sum(1) | |
| mu = np.where(n >= 10, np.nansum(np.where(ok, v, 0), 1) / np.maximum(n, 1), np.nan) | |
| if ratio: mu = np.where(mu > 0, mu, np.nan); an = np.where(ok, v / mu[:, None] - 1, np.nan) | |
| else: an = np.where(ok, v - mu[:, None], np.nan) | |
| R = regional(an, neighbours(P, origin, k)) | |
| d = an - R; yrs = YEARS[a:b]; last10 = yrs >= origin - 9; D = np.zeros(len(P.ids)) | |
| for i in range(len(P.ids)): | |
| kk = np.isfinite(d[i]) & last10 | |
| if kk.sum() >= 5: D[i] = d[i, kk].mean() | |
| return D | |
| def departures(P, m, origin, ratio=False, k=32): | |
| an, mu, a, b = anomalies(P, m, origin, ratio); R = regional(an, neighbours(P, origin, k)) | |
| return an, mu, R, a, b | |
| def rhat_nat(R, yrs, origin, s2, hs): | |
| out = np.full((len(R), len(hs)), np.nan) | |
| for i in range(len(R)): | |
| f = np.isfinite(R[i]); f15 = f & (yrs >= origin - 14) | |
| if f15.sum() == 0: continue | |
| out[i] = R[i, f15].mean() + s2 * (origin + hs - yrs[f15].mean()) | |
| return out | |
| def blend75(view, t4): | |
| v = np.asarray(view, float) | |
| return np.where(np.isfinite(v), 0.75 * v + 0.25 * t4, t4) | |
| def t_ewma_d(P, origin, s2, t4): | |
| an, mu, R, a, b = departures(P, TM, origin, k=32) | |
| yrs = YEARS[a:b].astype(float); hs = np.arange(1, H + 1) | |
| Dep = ewma(an - R, yrs, origin) | |
| rhat = rhat_nat(R, yrs, origin, s2, hs) | |
| out = np.full((len(P.ids), H), np.nan) | |
| ok = np.isfinite(mu) & np.isfinite(Dep) | |
| out[ok] = mu[ok, None] + rhat[ok] + Dep[ok, None] | |
| return blend75(out, t4) | |
| def t_huber(P, origin, s2, t4): | |
| a, b = _win(origin, 30); v = P.value[TM][:, a:b]; ok = P.valid[TM][:, a:b] | |
| mu = np.array([winsor_mean(v[i, ok[i]]) if ok[i].sum() >= 10 else np.nan for i in range(len(P.ids))]) | |
| an = np.where(ok & np.isfinite(mu)[:, None], v - mu[:, None], np.nan) | |
| R = regional(an, neighbours(P, origin, 32)) | |
| yrs = YEARS[a:b].astype(float); hs = np.arange(1, H + 1) | |
| rhat = rhat_nat(R, yrs, origin, s2, hs) | |
| out = np.full((len(P.ids), H), np.nan) | |
| for i in range(len(P.ids)): | |
| if not np.isfinite(mu[i]): continue | |
| k = np.isfinite(an[i]) & np.isfinite(R[i]) & (yrs >= origin - 14) | |
| idx = np.where(k)[0][-5:] | |
| if len(idx) < 3: continue | |
| dep = winsor_mean(an[i, idx] - R[i, idx]) | |
| if not np.isfinite(dep) or not np.isfinite(rhat[i, 0]): continue | |
| out[i] = mu[i] + rhat[i] + dep | |
| return blend75(out, t4) | |
| def regional_fdw(an, nn, min_pairs=10): | |
| """Weighted regional anomaly; nn is (n, k) neighbour indices. Equal-weight fallback if all weights 0.""" | |
| n, t = an.shape; R = np.full_like(an, np.nan) | |
| dlt = an[:, 1:] - an[:, :-1] | |
| pair = np.isfinite(an[:, 1:]) & np.isfinite(an[:, :-1]) | |
| eq = regional(an, nn) # v7 equal-weight fallback (min 10 finite) | |
| for i in range(n): | |
| w = np.zeros(nn.shape[1]) | |
| di, pi = dlt[i], pair[i] | |
| for u, j in enumerate(nn[i]): | |
| both = pi & pair[j] | |
| if both.sum() < min_pairs: continue | |
| x, y = di[both], dlt[j, both] | |
| sx, sy = x.std(), y.std() | |
| if sx <= 0 or sy <= 0: continue | |
| w[u] = max(0.0, float(np.corrcoef(x, y)[0, 1])) | |
| if w.sum() <= 0: | |
| R[i] = eq[i]; continue | |
| w = w / w.sum() | |
| vals = an[nn[i]] # k x t | |
| num = np.nansum(np.where(np.isfinite(vals), vals * w[:, None], 0.0), 0) | |
| den = np.nansum(np.where(np.isfinite(vals), w[:, None], 0.0), 0) | |
| R[i] = np.where(den > 0, num / den, np.nan) | |
| return R | |
| def t_fdw(P, origin, s2, t4): | |
| an, mu, _, a, b = departures(P, TM, origin, k=32) | |
| R = regional_fdw(an, neighbours(P, origin, 32)) | |
| yrs = YEARS[a:b].astype(float); hs = np.arange(1, H + 1) | |
| rhat = rhat_nat(R, yrs, origin, s2, hs) | |
| out = np.full((len(P.ids), H), np.nan) | |
| for i in range(len(P.ids)): | |
| if not np.isfinite(mu[i]): continue | |
| k = np.isfinite(an[i]) & np.isfinite(R[i]) & (yrs >= origin - 14) | |
| idx = np.where(k)[0][-5:] | |
| if len(idx) < 3: continue | |
| if not np.isfinite(rhat[i, 0]): continue | |
| out[i] = mu[i] + rhat[i] + (an[i, idx] - R[i, idx]).mean() | |
| return blend75(out, t4) | |
| def t_eb45(P, origin, v7t): | |
| hs = np.arange(1, H + 1); n = len(P.ids) | |
| a19, b = _win(origin, 19); a45, _ = _win(origin, 45) | |
| A = np.full(n, np.nan); s = np.full(n, np.nan); svar = np.full(n, np.nan) | |
| for i in range(n): | |
| ok19 = P.valid[TM][i, a19:b] | |
| if ok19.sum() >= 10: A[i] = P.value[TM][i, a19:b][ok19].mean() | |
| ok = P.valid[TM][i, a45:b] | |
| if ok.sum() < 20: continue | |
| yrs = YEARS[a45:b][ok].astype(float); y = P.value[TM][i, a45:b][ok] | |
| xc = yrs - yrs.mean(); den = (xc ** 2).sum() | |
| if den <= 0: continue | |
| sl = float((xc * (y - y.mean())).sum() / den) | |
| rss = ((y - y.mean() - sl * xc) ** 2).sum() | |
| if ok.sum() <= 2: continue | |
| s[i] = sl; svar[i] = (rss / (ok.sum() - 2)) / den | |
| nn = neighbours(P, origin, 10); have = np.isfinite(s) | |
| s_nat = float(s[have].mean()) if have.any() else 0.0 | |
| s_reg = np.full(n, np.nan) | |
| for i in range(n): | |
| vals = s[nn[i]]; vals = vals[np.isfinite(vals)] | |
| s_reg[i] = float(vals.mean()) if len(vals) else s_nat | |
| both = have & np.isfinite(s_reg) & np.isfinite(svar) | |
| if both.sum() >= 2: | |
| tau = max(0.0, float(np.var(s[both] - s_reg[both], ddof=1) - np.mean(svar[both]))) | |
| else: | |
| tau = 0.0 | |
| sp = s_reg.copy() | |
| den = tau + svar | |
| use = have & np.isfinite(s_reg) & np.isfinite(svar) & (den > 0) | |
| sp[use] = (tau * s[use] + svar[use] * s_reg[use]) / den[use] | |
| out = A[:, None] + sp[:, None] * (9.0 + hs[None]) | |
| return np.where(np.isfinite(A)[:, None] & np.isfinite(sp)[:, None], out, v7t) | |
| def h_ewma_d(P, origin): | |
| an, mu, R, a, b = departures(P, 'hottest_day_temp', origin, k=31) | |
| Dep = ewma(an - R, YEARS[a:b].astype(float), origin) | |
| base, _ = clim30(P, 'hottest_day_temp', origin) | |
| return np.where(np.isfinite(Dep), base + 0.3 * Dep, base + 0.3 * nudge_D(P, 'hottest_day_temp', origin, False)) | |
| def h_hl(P, origin): | |
| m = 'hottest_day_temp'; a, b = _win(origin, 30); loc = np.empty(len(P.ids)) | |
| for i in range(len(P.ids)): | |
| ok = P.valid[m][i, a:b] | |
| loc[i] = hodges_lehmann(P.value[m][i, a:b][ok]) if ok.sum() >= 10 else np.median(last_valid(P, m, origin, i, 30)) | |
| return loc + 0.3 * nudge_D(P, m, origin, False) | |
| def h_q10(P, origin): | |
| m = 'hottest_day_temp'; a, b = _win(origin, 30) | |
| qok = P.valid[m][:, a:b] & np.isfinite(P.q10[:, a:b]) | |
| n = len(P.ids); muq = np.full(n, np.nan); gap = np.full(n, np.nan) | |
| for i in range(n): | |
| if qok[i].sum() < 10: continue | |
| muq[i] = P.q10[i, a:b][qok[i]].mean() | |
| gap[i] = P.value[m][i, a:b][qok[i]].mean() - muq[i] | |
| nn = neighbours(P, origin, 10); greg = np.full(n, np.nan) | |
| for i in range(n): | |
| vals = gap[nn[i]]; vals = vals[np.isfinite(vals)] | |
| if len(vals): greg[i] = vals.mean() | |
| shrunk = np.where(np.isfinite(gap) & np.isfinite(greg), 0.5 * gap + 0.5 * greg, gap) | |
| valid_q = P.valid[m] & np.isfinite(P.q10) | |
| Dq = nudge_D_arr(P, P.q10, valid_q, origin, False, 31) | |
| out = muq + 0.5 * shrunk + 0.3 * Dq | |
| return out | |
| def p_ewma_d(P, origin): | |
| an, mu, R, a, b = departures(P, 'total_precip_in', origin, ratio=True, k=31) | |
| Dep = ewma(an - R, YEARS[a:b].astype(float), origin) | |
| base, _ = clim30(P, 'total_precip_in', origin) | |
| d0 = nudge_D(P, 'total_precip_in', origin, True) | |
| D = np.where(np.isfinite(Dep), Dep, d0) | |
| return np.maximum(base * (1 + 0.3 * D), 0) | |
| def p_cbrt(P, origin, v7p): | |
| m = 'total_precip_in'; z = np.where(P.valid[m], np.cbrt(np.maximum(P.value[m], 0.0)), np.nan) | |
| valid = P.valid[m] & np.isfinite(z) | |
| a, b = _win(origin, 30); muz = np.full(len(P.ids), np.nan) | |
| for i in range(len(P.ids)): | |
| ok = valid[i, a:b] | |
| if ok.sum() >= 10: muz[i] = z[i, a:b][ok].mean() | |
| Dz = nudge_D_arr(P, z, valid, origin, False, 31) | |
| out = np.maximum((muz + 0.3 * Dz) ** 3, 0) | |
| return np.where(np.isfinite(muz), out, v7p[:, 0] if v7p.ndim == 2 else v7p) | |
| def p_eb_ratio(P, origin, v7p): | |
| m = 'total_precip_in'; n = len(P.ids); k1 = origin - Y0 + 1 | |
| z = np.where(P.valid[m], np.cbrt(np.maximum(P.value[m], 0.0)), np.nan) | |
| valid = P.valid[m] & np.isfinite(z) | |
| a, b = _win(origin, 30) | |
| ell30 = np.full(n, np.nan); ellinf = np.full(n, np.nan); sig = np.full(n, np.nan) | |
| for i in range(n): | |
| ok30 = valid[i, a:b]; okall = valid[i, :k1] | |
| if ok30.sum() >= 10: | |
| x = z[i, a:b][ok30]; ell30[i] = x.mean() | |
| if ok30.sum() >= 2: sig[i] = x.var(ddof=1) / ok30.sum() | |
| if okall.sum() >= 10: ellinf[i] = z[i, :k1][okall].mean() | |
| nn = neighbours(P, origin, 31) | |
| def nb_mean(arr): | |
| out = np.full(n, np.nan) | |
| for i in range(n): | |
| vals = arr[nn[i]]; vals = vals[np.isfinite(vals)] | |
| if len(vals): out[i] = vals.mean() | |
| return out | |
| n30, ninf = nb_mean(ell30), nb_mean(ellinf) | |
| r = np.where((ninf > 0) & np.isfinite(ellinf), ellinf / ninf, 1.0) | |
| prior = r * n30 | |
| both = np.isfinite(ell30) & np.isfinite(prior) & np.isfinite(sig) | |
| if both.sum() >= 2: | |
| tau = max(0.0, float(np.var(ell30[both] - prior[both], ddof=1) - np.mean(sig[both]))) | |
| else: | |
| tau = 0.0 | |
| w = np.ones(n) | |
| den = tau + sig | |
| use = both & (den > 0); w[use] = tau / den[use]; w = np.clip(w, 0, 1) | |
| mix = w * ell30 + (1 - w) * prior | |
| out = np.maximum(mix ** 3, 0) | |
| ok = np.isfinite(ell30) & np.isfinite(prior) | |
| base = v7p[:, 0] if v7p.ndim == 2 else v7p | |
| return np.where(ok, out, base) | |
| def c_map_sets(P, origin, v6t): | |
| """Per city: (S30 idx, S10 idx, mid temps not needed).""" | |
| n = len(P.ids); k1 = origin - Y0 + 1; sets = [] | |
| for i in range(n): | |
| idx = np.where(P.valid[TM][i, :k1] & np.isfinite(P.value['cdd'][i, :k1]))[0] | |
| row = {} | |
| for nn, key in ((30, 's30'), (10, 's10')): | |
| comp = idx[P.days_both[i, idx] >= 360][-nn:]; use = comp if len(comp) >= 5 else idx[-nn:] | |
| row[key] = use | |
| sets.append(row) | |
| return sets | |
| def shifted_cdd(P, i, use, target): | |
| """CDD_τ + inc(target - T_τ) for each year in use; target may be a scalar or length-H array.""" | |
| tgt = np.asarray(target, float) | |
| if tgt.ndim == 0: tgt = np.repeat(tgt, H) | |
| out = np.empty((len(use), H)) | |
| for r, t in enumerate(use): | |
| out[r] = P.value['cdd'][i, t] + interp_inc(P.inc[i, t], tgt - P.value[TM][i, t]) | |
| return out | |
| def inc_only(P, i, use, delta): | |
| d = np.asarray(delta, float) | |
| if d.ndim == 0: d = np.repeat(d, H) | |
| out = np.empty((len(use), H)) | |
| for r, t in enumerate(use): | |
| out[r] = interp_inc(P.inc[i, t], d) | |
| return out | |
| def c_pmean(P, origin, v6t): | |
| n = len(P.ids); out = np.full((n, H), np.nan); sets = c_map_sets(P, origin, v6t) | |
| for i in range(n): | |
| v30 = np.maximum(shifted_cdd(P, i, sets[i]['s30'], v6t[i]), 0) | |
| map30 = (np.sqrt(v30).mean(0)) ** 2 | |
| v10 = shifted_cdd(P, i, sets[i]['s10'], v6t[i]) | |
| n10 = len(v10); k = int(np.floor(0.10 * n10)) | |
| if k == 0: map10 = v10.mean(0) | |
| else: map10 = np.sort(v10, 0)[k:n10 - k].mean(0) | |
| out[i] = np.maximum((map30 + map10) / 2, 0) | |
| return out | |
| def c_detrend(P, origin, v6t): | |
| n = len(P.ids); out = np.full((n, H), np.nan); sets = c_map_sets(P, origin, v6t) | |
| for i in range(n): | |
| s30 = sets[i]['s30']; Tmid = P.value[TM][i, s30].mean() | |
| at_mid = shifted_cdd(P, i, s30, Tmid) # CDD + inc(Tmid - T_τ) | |
| second = inc_only(P, i, s30, v6t[i] - Tmid) | |
| map30 = at_mid.mean(0) + second.mean(0) | |
| map10 = shifted_cdd(P, i, sets[i]['s10'], v6t[i]).mean(0) | |
| out[i] = np.maximum((map30 + map10) / 2, 0) | |
| return out | |
| def v9_block(P, origin): | |
| mats, clim, info, f6 = v7_ref_mats(P, origin) | |
| keep = set(REF7.values()) | {'clim30', 't_dettrim_v2'} | |
| f6 = f6[f6.method.isin(keep)] | |
| rows = [f6]; ids = P.ids; hs = np.arange(1, H + 1) | |
| 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) | |
| # where a city-level candidate is undefined it must already have been filled with v7 | |
| 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]})) | |
| add('cdd', 'c_map', mats['cdd']) | |
| t4 = f6[(f6.metric == TM) & (f6.method == 't_dettrim_v2')].pivot(index='city_id', columns='year', values='predicted_value') | |
| t4 = t4.reindex(P.ids).to_numpy(); s2 = info['s_v2']; v7t = mats[TM] | |
| add(TM, 't_ewma_d', t_ewma_d(P, origin, s2, t4)) | |
| add(TM, 't_huber', t_huber(P, origin, s2, t4)) | |
| add(TM, 't_fdw', t_fdw(P, origin, s2, t4)) | |
| add(TM, 't_eb45', t_eb45(P, origin, v7t)) | |
| q = 'hottest_day_temp'; p = 'total_precip_in' | |
| hq = h_q10(P, origin) | |
| hq = np.where(np.isfinite(hq), hq, mats[q][:, 0]) | |
| add(q, 'h_ewma_d', h_ewma_d(P, origin)) | |
| add(q, 'h_hl', h_hl(P, origin)) | |
| add(q, 'h_q10', hq) | |
| add(p, 'p_ewma_d', p_ewma_d(P, origin)) | |
| add(p, 'p_cbrt', p_cbrt(P, origin, mats[p])) | |
| add(p, 'p_eb_ratio', p_eb_ratio(P, origin, mats[p])) | |
| add('cdd', 'c_pmean', c_pmean(P, origin, v7t)) | |
| add('cdd', 'c_detrend', c_detrend(P, origin, v7t)) | |
| return pd.concat(rows, ignore_index=True), info | |