Datasets:
Download code/v3lib.py from tchaudha/heat-seekers-protostar: direct link, hf CLI and curl.
- Browser
- Download file 16.9 kB
-
https://huggingface.co/datasets/tchaudha/heat-seekers-protostar/resolve/main/code/v3lib.py
- Command line
-
hf download hf://datasets/tchaudha/heat-seekers-protostar/code/v3lib.py
-
curl -L -o v3lib.py https://huggingface.co/datasets/tchaudha/heat-seekers-protostar/resolve/main/code/v3lib.py
16.9 kB
| """Heat Seekers v3 ablations (SHEBE component ideas) on top of v2lib. Data <= 2018 only; every statistic for an | |
| origin O reads only years <= O (tested by the poisoned-future test in test_v3.py).""" | |
| import hashlib | |
| import numpy as np, pandas as pd | |
| from v2lib import * | |
| from v2lib import _win | |
| np.seterr(divide="ignore", invalid="ignore") | |
| def daily_tables(P): | |
| """Per city-year daily-derived tables, cached. Seasonal CDD increments over DGRID, seasonal means, | |
| JJA mean Tmax, active cooling days, top-3 independent (>=3 days apart) Tmax mean, calendar length.""" | |
| cache = ROOT / 'results/cache_v3_daily.npz' | |
| src = DATA / 'daily/train-00000-of-00001.parquet' | |
| tag = hashlib.sha256(src.read_bytes()).hexdigest()[:16] + f'_{len(DGRID)}_{Y0}_v3b' | |
| if cache.exists(): | |
| z = np.load(cache) | |
| if str(z['tag']) == tag: return {k: z[k] for k in z.files if k != 'tag'} | |
| d = pd.read_parquet(src, columns=['ID', 'Date', 'tmax', 'tmin']) | |
| dt = pd.to_datetime(d.Date); yr = dt.dt.year.to_numpy(); mo = dt.dt.month.to_numpy(); doy = dt.dt.dayofyear.to_numpy() | |
| assert yr.max() <= 2018 | |
| keep = yr >= Y0; d = d[keep]; yr, mo, doy = yr[keep], mo[keep], doy[keep] | |
| ci = np.searchsorted(P.ids, d.ID.to_numpy()); assert (P.ids[ci] == d.ID.to_numpy()).all() | |
| n, T = len(P.ids), len(YEARS); size = n * T | |
| key = ci * T + (yr - Y0) | |
| tmax = d.tmax.to_numpy(); tmin = d.tmin.to_numpy() | |
| pair = np.isfinite(tmax) & np.isfinite(tmin) | |
| tav = (tmax + tmin) / 2 | |
| warm = (mo >= 5) & (mo <= 10) | |
| out = {} | |
| for name, sel in (('warm', pair & warm), ('cool', pair & ~warm)): | |
| k = key[sel]; t = tav[sel] | |
| base = np.bincount(k, np.maximum(t - 65, 0), minlength=size) | |
| inc = np.empty((size, len(DGRID)), np.float32) | |
| for j, dl in enumerate(DGRID): | |
| inc[:, j] = np.bincount(k, np.maximum(t + dl - 65, 0), minlength=size) - base | |
| out['inc_' + name] = inc.reshape(n, T, len(DGRID)) | |
| cnt = np.bincount(k, minlength=size) | |
| out[name + '_mean'] = (np.bincount(k, t, minlength=size) / np.maximum(cnt, 1)).reshape(n, T) | |
| out[name + '_n'] = cnt.reshape(n, T) | |
| jja = np.isfinite(tmax) & (mo >= 6) & (mo <= 8) | |
| c = np.bincount(key[jja], minlength=size) | |
| out['jja_tmax'] = (np.bincount(key[jja], tmax[jja], minlength=size) / np.maximum(c, 1)).reshape(n, T) | |
| out['jja_n'] = c.reshape(n, T) | |
| out['active'] = np.bincount(key[pair], (tav[pair] > 65).astype(float), minlength=size).reshape(n, T) | |
| # top-3 independent hot days | |
| h3 = np.full(size, np.nan) | |
| m = np.isfinite(tmax); kk = key[m]; tx = tmax[m]; dd = doy[m] | |
| order = np.lexsort((-tx, kk)); kk, tx, dd = kk[order], tx[order], dd[order] | |
| starts = np.flatnonzero(np.r_[True, kk[1:] != kk[:-1]]); ends = np.r_[starts[1:], len(kk)] | |
| for s, e in zip(starts, ends): | |
| picked = []; days = [] | |
| for v, dy in zip(tx[s:e], dd[s:e]): | |
| if all(abs(dy - q) >= 3 for q in days): | |
| picked.append(v); days.append(dy) | |
| if len(picked) == 3: break | |
| if len(picked) == 3: h3[kk[s]] = np.mean(picked) | |
| out['h3'] = h3.reshape(n, T) | |
| out['ndays'] = np.array([366 if (y % 4 == 0 and (y % 100 != 0 or y % 400 == 0)) else 365 for y in YEARS]) | |
| np.savez(cache, tag=tag, **out) | |
| return out | |
| def attach(P): | |
| P.d3 = daily_tables(P) | |
| c = pd.read_parquet(DATA / 'coverage_and_stations/train-00000-of-00001.parquet') | |
| m = np.zeros((len(P.ids), len(YEARS))); ci = np.searchsorted(P.ids, c.ID.to_numpy()); ti = c.Year.to_numpy() - Y0 | |
| k = ti >= 0; m[ci[k], ti[k]] = c['Days Both'].to_numpy()[k]; P.days_both = m | |
| return P | |
| def cut(P, origin, junk=999999.0): | |
| """Poisoned copy for leakage tests (all v2 + v3 arrays after origin set to junk).""" | |
| Q = P.copy_cut(origin, junk); k = origin - Y0 + 1 | |
| for key, v in Q.d3.items(): | |
| if key == 'ndays': continue | |
| v = v.copy(); v[:, k:] = junk; Q.d3[key] = v | |
| Q.days_both = Q.days_both.copy(); Q.days_both[:, k:] = junk | |
| return Q | |
| # ---------------------------------------------------------------- slopes | |
| def _city_slope(x, y, s, est): | |
| xd = x.astype(float).copy(); yd = y.astype(float).copy() | |
| for g in np.unique(s): | |
| k = s == g; xd[k] -= x[k].mean(); yd[k] -= y[k].mean() | |
| den = (xd ** 2).sum(); dof = len(x) - len(np.unique(s)) - 1 | |
| if den <= 0 or dof < 7: return np.nan, np.nan | |
| b = (xd * yd).sum() / den | |
| if est == 'huber': | |
| for _ in range(20): | |
| r = yd - b * xd; sc = np.median(np.abs(r - np.median(r))) * 1.4826 + 1e-9 | |
| u = np.abs(r) / sc; w = np.where(u <= 1.345, 1.0, 1.345 / u) | |
| b = (w * xd * yd).sum() / (w * xd * xd).sum() | |
| elif est == 'ts': | |
| dx = x[None, :] - x[:, None]; dy = y[None, :] - y[:, None]; ok = (dx > 0) & (s[None, :] == s[:, None]) | |
| if ok.any(): b = float(np.median(dy[ok] / dx[ok])) | |
| res = yd - b * xd | |
| return b, (res ** 2).sum() / dof / den | |
| def city_slopes(P, val, valid, origin, W, est='ols'): | |
| a, bnd = _win(origin, W); yrs = YEARS[a:bnd] | |
| b = np.full(len(P.ids), np.nan); s2 = np.full(len(P.ids), np.nan) | |
| for i in range(len(P.ids)): | |
| ok = valid[i, a:bnd] | |
| if ok.sum() < 10: continue | |
| b[i], s2[i] = _city_slope(yrs[ok], val[i, a:bnd][ok], P.seg[i, a:bnd][ok], est) | |
| return b, s2 | |
| def idw(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 | |
| dist = 6371 * 2 * np.arcsin(np.sqrt(np.clip(h, 0, 1))); np.fill_diagonal(dist, np.inf) | |
| W = np.zeros_like(dist); nn = np.argsort(dist, axis=1)[:, :12] | |
| for i in range(len(dist)): W[i, nn[i]] = 1 / np.maximum(dist[i, nn[i]], 25) ** 2 | |
| return W | |
| def wmean(W, v): | |
| ok = np.isfinite(v); Wk = W * ok[None, :]; s = Wk.sum(1) | |
| return np.where(s > 0, (Wk @ np.where(ok, v, 0)) / np.maximum(s, 1e-300), np.nan) | |
| def eb(W, b, s2): | |
| ok = np.isfinite(b); Wk = W * ok[None, :]; Wk = Wk / np.maximum(Wk.sum(1, keepdims=True), 1e-300) | |
| bz = np.where(ok, b, 0); sz = np.where(ok, s2, 0) | |
| r = Wk @ bz | |
| tau2 = np.maximum((Wk * (bz[None, :] - r[:, None]) ** 2).sum(1) - Wk @ sz, 1e-6) | |
| B = s2 / (s2 + tau2) | |
| out = np.where(ok, B * r + (1 - B) * b, r) | |
| return np.where(np.isfinite(out), out, np.nanmean(b)) | |
| def temp_slope(P, origin, kind, W=None): | |
| T = 'annual_avg_temp' | |
| if kind == 'v2': | |
| b, _ = city_slopes(P, P.value[T], P.valid[T], origin, 30); return np.full(len(b), np.nanmean(b)) | |
| k, rest = kind.split('_', 1) if '_' in kind else (kind, '') | |
| if kind.startswith('nat'): | |
| b, _ = city_slopes(P, P.value[T], P.valid[T], origin, int(kind[3:])); return np.full(len(b), np.nanmean(b)) | |
| if kind.startswith('reg'): | |
| b, _ = city_slopes(P, P.value[T], P.valid[T], origin, int(kind[3:])) | |
| r = wmean(W, b); return np.where(np.isfinite(r), r, np.nanmean(b)) | |
| if kind.startswith('eb_'): | |
| _, est, w = kind.split('_'); b, s2 = city_slopes(P, P.value[T], P.valid[T], origin, int(w), est) | |
| return eb(W, b, s2) | |
| raise ValueError(kind) | |
| # ---------------------------------------------------------------- temperature | |
| def anomaly_composite(P, m, origin, W): | |
| """A[i, t] for t in [O-29, O]: IDW mean of neighbours' anomaly vs their own [O-29,O] mean.""" | |
| a, b = _win(origin, 30); v = P.value[m][:, a:b]; ok = P.valid[m][:, a:b] | |
| mu = np.where(ok.sum(1) > 0, np.nansum(np.where(ok, v, 0), 1) / np.maximum(ok.sum(1), 1), np.nan) | |
| an = np.where(ok, v - mu[:, None], np.nan) | |
| A = np.full(an.shape, np.nan) | |
| for t in range(an.shape[1]): A[:, t] = wmean(W, an[:, t]) | |
| return A, a, b | |
| def level_ra(P, origin, n, W, m='annual_avg_temp'): | |
| A, a, b = anomaly_composite(P, m, origin, W) | |
| yrs = YEARS[a:b]; lev = np.full(len(P.ids), np.nan); cen = np.full(len(P.ids), np.nan) | |
| for i in range(len(P.ids)): | |
| ok = P.valid[m][i, a:b] & np.isfinite(A[i]) | |
| if ok.sum() < 10: continue | |
| idx = np.where(P.valid[m][i, :b])[0]; cur = P.seg[i, idx[-1]] | |
| same = ok & (P.seg[i, a:b] == cur) | |
| use = same if same.sum() >= 8 else ok | |
| d = np.mean(P.value[m][i, a:b][use] - A[i][use]) | |
| rec = np.isfinite(A[i]) & (yrs > origin - n) | |
| lev[i] = d + A[i][rec].mean(); cen[i] = yrs[rec].mean() | |
| return lev, cen | |
| def level_v2(P, origin, L=15, m='annual_avg_temp', value=None): | |
| v = P.value[m] if value is None else value | |
| lev = np.empty(len(P.ids)); cen = np.empty(len(P.ids)) | |
| for i in range(len(P.ids)): | |
| ly = level_years(P, m, origin, i, L); lev[i] = v[i, ly].mean(); cen[i] = YEARS[ly].mean() | |
| return lev, cen | |
| def homogenised(P, origin, W, m='annual_avg_temp'): | |
| """Return value matrix with pre-move years shifted by detected steps (|jump|>0.35) inside [O-29,O].""" | |
| A, a, b = anomaly_composite(P, m, origin, W) | |
| v = P.value[m].copy(); yrs = YEARS[a:b]; njump = 0 | |
| for i in range(len(P.ids)): | |
| seg = P.seg[i, a:b]; ok = P.valid[m][i, a:b] & np.isfinite(A[i]) | |
| diff = P.value[m][i, a:b] - A[i] | |
| for j in range(len(yrs) - 1, 0, -1): | |
| if seg[j] != seg[j - 1] and seg[j] >= 0 and seg[j - 1] >= 0: | |
| pre = ok & (np.arange(len(yrs)) < j) & (np.arange(len(yrs)) >= j - 7) | |
| post = ok & (np.arange(len(yrs)) >= j) & (np.arange(len(yrs)) < j + 7) | |
| if pre.sum() >= 3 and post.sum() >= 3: | |
| jump = np.median(diff[post]) - np.median(diff[pre]) | |
| if abs(jump) > 0.35: | |
| v[i, :a + j] += jump; diff[:j] += jump; njump += 1 | |
| return v, njump | |
| def temp_forecast(P, origin, slope, level, cen, H=7): | |
| hs = np.arange(1, H + 1); return level[:, None] + slope[:, None] * (origin + hs[None] - cen[:, None]) | |
| # ---------------------------------------------------------------- CDD | |
| def season_slope(P, origin, W, kind): | |
| out = {} | |
| valid = P.valid['annual_avg_temp'] | |
| for s in ('warm', 'cool'): | |
| val = P.d3[s + '_mean']; vv = valid & (P.d3[s + '_n'] >= 150) | |
| b, s2 = city_slopes(P, val, vv, origin, 30) | |
| out[s] = np.full(len(b), np.nanmean(b)) if kind == 'nat' else eb(W, b, s2) | |
| return out | |
| def cdd_shift(P, origin, L, sw, sc=None, norm=None, H=7, jac=0.0, jac_slope=None): | |
| """Daily shift CDD. sw: slope for warm days (or all days if sc is None); sc: cool-season slope.""" | |
| hs = np.arange(1, H + 1); n = len(P.ids); out = np.empty((n, H)); m = 'cdd' | |
| for i in range(n): | |
| cy = level_years(P, m, origin, i, L); cyrs = YEARS[cy].astype(float); cv = P.value[m][i, cy] | |
| dy = (origin + hs)[None, :] - cyrs[:, None] | |
| vals = np.empty((len(cy), H)) | |
| for r, t in enumerate(cy): | |
| if sc is None: inc = interp_inc(P.inc[i, t], sw[i] * dy[r]) | |
| else: inc = interp_inc(P.d3['inc_warm'][i, t], sw[i] * dy[r]) + interp_inc(P.d3['inc_cool'][i, t], sc[i] * dy[r]) | |
| v = cv[r] + inc | |
| if norm == 'leap': v = v * np.array([P.d3['ndays'][min(origin + h - Y0, len(YEARS) - 1)] if origin + h <= Y1 else (366 if (origin + h) % 4 == 0 else 365) for h in hs]) / P.d3['ndays'][t] | |
| elif norm == 'cov': | |
| tgt = np.array([366 if (origin + h) % 4 == 0 else 365 for h in hs]); v = v * tgt / max(P.days_both[i, t], 1) | |
| vals[r] = v | |
| f = vals.mean(0) | |
| if jac: | |
| js = sw if jac_slope is None else jac_slope | |
| act = P.d3['active'][i, cy].mean() | |
| lin = cv.mean() + act * js[i] * (origin + hs - cyrs.mean()) | |
| f = (1 - jac) * f + jac * lin | |
| out[i] = f | |
| return np.maximum(out, 0) | |
| # ---------------------------------------------------------------- precip / hottest | |
| def huber_loc(y, c=1.345): | |
| mu = np.median(y) | |
| for _ in range(20): | |
| sc = np.median(np.abs(y - np.median(y))) * 1.4826 + 1e-9; u = np.abs(y - mu) / sc | |
| w = np.where(u <= c, 1.0, c / u); mu = (w * y).sum() / w.sum() | |
| return mu | |
| def window_stat(P, m, origin, N, f, minn=10): | |
| a, b = _win(origin, N); out = np.empty(len(P.ids)) | |
| base, _ = clim30(P, m, origin) | |
| for i in range(len(P.ids)): | |
| ok = P.valid[m][i, a:b] | |
| out[i] = f(P.value[m][i, a:b][ok]) if ok.sum() >= minn else base[i] | |
| return out | |
| def precip_ratio(P, origin, W): | |
| m = 'total_precip_in'; m30 = window_stat(P, m, origin, 30, np.mean); m15 = window_stat(P, m, origin, 15, np.mean, 8) | |
| r = np.where(m30 > 1, m15 / m30, np.nan); return np.clip(np.where(np.isfinite(wmean(W, r)), wmean(W, r), 1.0), 0.94, 1.06) | |
| def hot_topk15(P, origin): | |
| m = 'hottest_day_temp'; a, b = _win(origin, 30); a15, _ = _win(origin, 15) | |
| base, _ = clim30(P, m, origin); out = base.copy(); h3 = P.d3['h3'] | |
| for i in range(len(P.ids)): | |
| ok = P.valid[m][i, a:b] & np.isfinite(h3[i, a:b]) | |
| ok15 = P.valid[m][i, a15:b] & np.isfinite(h3[i, a15:b]) | |
| if ok.sum() >= 10 and ok15.sum() >= 5: | |
| off = np.mean(P.value[m][i, a:b][ok] - h3[i, a:b][ok]); out[i] = h3[i, a15:b][ok15].mean() + off | |
| return out | |
| def jja_slope(P, origin): | |
| vv = P.valid['hottest_day_temp'] & (P.d3['jja_n'] >= 80) | |
| b, _ = city_slopes(P, P.d3['jja_tmax'], vv, origin, 30); return np.nanmean(b) | |
| # ---------------------------------------------------------------- all candidates at one origin | |
| def v3_block(P, origin, H=7, extra_temp_slopes=()): | |
| ids = P.ids; hs = np.arange(1, H + 1); rows = [] | |
| def add(metric, method, mat): | |
| mat = np.asarray(mat, float) | |
| if mat.ndim == 1: mat = np.repeat(mat[:, None], H, 1) | |
| if metric in ('cdd', 'total_precip_in'): mat = np.maximum(mat, 0) | |
| for j, h in enumerate(hs): | |
| rows.append(pd.DataFrame({'city_id': ids, 'year': origin + h, 'metric': metric, 'method': method, 'predicted_value': mat[:, j]})) | |
| W = idw(P, origin); T = 'annual_avg_temp' | |
| for m in METRICS: add(m, 'clim30', clim30(P, m, origin)[0]) | |
| add('cdd', 'exp10', exp10(P, 'cdd', origin)) | |
| # temperature | |
| s_v2 = temp_slope(P, origin, 'v2'); lv, cv = level_v2(P, origin) | |
| add(T, 'v2', temp_forecast(P, origin, s_v2, lv, cv, H)) | |
| kinds = [f'nat{w}' for w in (30, 40, 50)] + [f'reg{w}' for w in (30, 40, 50)] + [f'eb_{e}_{w}' for e in ('ols', 'huber', 'ts') for w in (30, 40, 50)] | |
| slopes = {'v2': s_v2} | |
| for k in kinds: | |
| slopes[k] = temp_slope(P, origin, k, W); add(T, 'slope_' + k, temp_forecast(P, origin, slopes[k], lv, cv, H)) | |
| levels = {'v2': (lv, cv)} | |
| for n in (12, 15): | |
| l, c = level_ra(P, origin, n, W); fb = ~np.isfinite(l); l[fb] = lv[fb]; c[fb] = cv[fb] | |
| levels[f'ra{n}'] = (l, c); add(T, f'level_ra{n}', temp_forecast(P, origin, s_v2, l, c, H)) | |
| hv, _ = homogenised(P, origin, W) | |
| lh = np.empty(len(ids)); ch = np.empty(len(ids)); a, b = _win(origin, 30); bh = np.full(len(ids), np.nan) | |
| for i in range(len(ids)): | |
| idx = np.where(P.valid[T][i, :b])[0][-15:]; lh[i] = hv[i, idx].mean(); ch[i] = YEARS[idx].mean() | |
| ok = P.valid[T][i, a:b] | |
| if ok.sum() >= 10: bh[i] = np.polyfit(YEARS[a:b][ok] - origin, hv[i, a:b][ok], 1)[0] | |
| add(T, 'homog', temp_forecast(P, origin, np.full(len(ids), np.nanmean(bh)), lh, ch, H)) | |
| for (sk, lk) in extra_temp_slopes: | |
| l, c = levels[lk]; add(T, f'combo_{sk}+{lk}', temp_forecast(P, origin, slopes[sk], l, c, H)) | |
| # CDD | |
| add('cdd', 'v2b', cdd_shift(P, origin, 15, s_v2)) | |
| add('cdd', 'L20', cdd_shift(P, origin, 20, s_v2)) | |
| ss = {k: season_slope(P, origin, W, k) for k in ('nat', 'eb')} | |
| for k in ('nat', 'eb'): | |
| for L in (15, 20): add('cdd', f'season_{k}_L{L}', cdd_shift(P, origin, L, ss[k]['warm'], ss[k]['cool'])) | |
| for nm in ('leap', 'cov'): add('cdd', f'norm_{nm}', cdd_shift(P, origin, 15, s_v2, norm=nm)) | |
| add('cdd', 'jac', cdd_shift(P, origin, 15, s_v2, jac=0.35)) | |
| add('cdd', 'jacw', cdd_shift(P, origin, 15, s_v2, jac=0.35, jac_slope=ss['nat']['warm'])) | |
| for sk, _ in extra_temp_slopes: | |
| if sk != 'v2': add('cdd', f'tslope_{sk}', cdd_shift(P, origin, 15, slopes[sk])) | |
| # precipitation | |
| p = 'total_precip_in' | |
| h30 = window_stat(P, p, origin, 30, huber_loc); h45 = window_stat(P, p, origin, 45, huber_loc) | |
| m30 = clim30(P, p, origin)[0]; m45 = window_stat(P, p, origin, 45, np.mean); ratio = precip_ratio(P, origin, W) | |
| add(p, 'huber30', h30); add(p, 'blend3045', 0.5 * m30 + 0.5 * m45); add(p, 'ratio', m30 * ratio) | |
| add(p, 'shebe', 0.55 * h30 + 0.25 * h45 + 0.20 * m30 * ratio) | |
| # hottest | |
| q = 'hottest_day_temp'; hb = clim30(P, q, origin)[0]; hh = window_stat(P, q, origin, 30, huber_loc) | |
| add(q, 'huber30', hh); add(q, 'topk15', hot_topk15(P, origin)) | |
| js = jja_slope(P, origin) | |
| for beta in (0.25, 0.35, 0.5): | |
| add(q, f'jja{beta:g}', hb[:, None] + beta * js * (hs[None] + 14.5)) | |
| add(q, f'huber30+jja{beta:g}', hh[:, None] + beta * js * (hs[None] + 14.5)) | |
| return pd.concat(rows, ignore_index=True) | |