tchaudha's picture
v9: first-difference-correlation neighbour weights for temperature (pre-registered V9 protocol; idea from a Gemini brainstorm)
b3952f1 verified
Raw History Blame Contribute Delete
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