"""Heat Seekers v2: trend-aware, origin-safe forecasts. Offline; uses only data <= 2018-12-31. All functions take an `origin` and only read array columns for years <= origin (asserted by the poisoned-future test in test_v2.py). """ from pathlib import Path import hashlib, json import numpy as np import pandas as pd ROOT = Path(__file__).resolve().parents[1] DATA = ROOT / 'data' TEMPLATE = ROOT / 'research/official/protostar-climate-submission-template/submission.csv' METRICS = ['annual_avg_temp', 'total_precip_in', 'hottest_day_temp', 'cdd'] COLS = {'annual_avg_temp': 'Avg Temp', 'total_precip_in': 'ToT Prcp', 'hottest_day_temp': 'Max Tmax', 'cdd': 'cdd'} KEY = ['city_id', 'year', 'metric'] Y0, Y1 = 1870, 2018 YEARS = np.arange(Y0, Y1 + 1) DGRID = np.round(np.arange(-8.0, 12.0001, 0.1), 4) # CDD shift grid, deg F def check_inputs(): for e in json.loads((DATA / 'manifest.json').read_text()): p = DATA / e['file'] assert hashlib.sha256(p.read_bytes()).hexdigest() == e['sha256'], f'Input changed: {p}' class Panel: """City x year arrays (years 1870..2018).""" def __init__(self, check=True, daily=True): if check: check_inputs() a = pd.read_parquet(DATA / 'annual_indices/train-00000-of-00001.parquet') c = pd.read_parquet(DATA / 'coverage_and_stations/train-00000-of-00001.parquet') assert a.Year.max() <= 2018 and c.Year.max() <= 2018 a = a.merge(c.drop(columns='Name'), on=['ID', 'Year'], validate='one_to_one') a = a[a.Year >= Y0] self.ids = np.array(sorted(a.ID.unique())) n, T = len(self.ids), len(YEARS) ci = np.searchsorted(self.ids, a.ID.to_numpy()); ti = a.Year.to_numpy() - Y0 def mat(col, fill=np.nan): m = np.full((n, T), fill, float); m[ci, ti] = a[col].to_numpy(float); return m self.value = {m: mat(COLS[m]) for m in METRICS} temp_ok = (mat('Miss Tmax', 999) <= 10) & (mat('Miss Tmin', 999) <= 10) prcp_ok = mat('Miss Prcp', 999) <= 10 self.valid = {m: ((prcp_ok if m == 'total_precip_in' else temp_ok) & np.isfinite(self.value[m])) for m in METRICS} self.seg = mat('Station Segment', -1) self.lat = mat('Lat'); self.lon = mat('Lon') self.names = a.groupby('ID').Name.first().reindex(self.ids).to_numpy() self.inc = cdd_increment_table(self.ids) if daily else None def copy_cut(self, origin, junk=999999.0): """Return a copy where every year > origin is replaced by junk (for leakage tests).""" import copy p = copy.deepcopy(self); k = origin - Y0 + 1 for m in METRICS: p.value[m][:, k:] = junk; p.valid[m][:, k:] = True p.seg[:, k:] = junk; p.lat[:, k:] = junk; p.lon[:, k:] = junk if p.inc is not None: p.inc[:, k:, :] = junk return p def cdd_increment_table(ids): """inc[c, t, d] = CDD of year t with every day's (Tmax+Tmin)/2 shifted by DGRID[d], minus unshifted CDD. Only days with both temperatures count, matching the official CDD (paired days).""" cache = ROOT / 'results/cache_cdd_increment.npy' src = DATA / 'daily/train-00000-of-00001.parquet' tag = hashlib.sha256(src.read_bytes()).hexdigest()[:16] + f'_{len(DGRID)}_{Y0}' tagf = cache.with_suffix('.tag') if cache.exists() and tagf.exists() and tagf.read_text() == tag: return np.load(cache) d = pd.read_parquet(src, columns=['ID', 'Date', 'tmax', 'tmin']) d = d[d.tmax.notna() & d.tmin.notna()] yr = pd.to_datetime(d.Date).dt.year.to_numpy() assert yr.max() <= 2018 keep = yr >= Y0; d = d[keep]; yr = yr[keep] ci = np.searchsorted(ids, d.ID.to_numpy()); assert (ids[ci] == d.ID.to_numpy()).all() key = ci * len(YEARS) + (yr - Y0) tav = ((d.tmax.to_numpy() + d.tmin.to_numpy()) / 2.0) size = len(ids) * len(YEARS) base = np.bincount(key, np.maximum(tav - 65, 0), minlength=size) out = np.empty((size, len(DGRID))) for j, dl in enumerate(DGRID): out[:, j] = np.bincount(key, np.maximum(tav + dl - 65, 0), minlength=size) - base out = out.reshape(len(ids), len(YEARS), len(DGRID)) cache.parent.mkdir(exist_ok=True); np.save(cache, out); tagf.write_text(tag) return out def interp_inc(inc_ct, shift): shift = np.clip(shift, DGRID[0], DGRID[-1]) return np.interp(shift, DGRID, inc_ct) # ---------------------------------------------------------------- per-origin statistics def _win(origin, n): k1 = origin - Y0 + 1; return max(0, k1 - n), k1 def clim30(P, m, origin): """Official 30-year mean (>=10 valid years in [O-29,O]); fallback = last 30 valid years at any time.""" a, b = _win(origin, 30) v = P.value[m][:, a:b]; ok = P.valid[m][:, a:b] n = ok.sum(1); mean = np.where(n > 0, np.nansum(np.where(ok, v, 0), 1) / np.maximum(n, 1), np.nan) eligible = n >= 10 out = mean.copy() for i in np.where(~eligible)[0]: out[i] = last_valid(P, m, origin, i, 30).mean() return out, eligible def last_valid(P, m, origin, i, L, years=False): k1 = origin - Y0 + 1 idx = np.where(P.valid[m][i, :k1])[0][-L:] assert len(idx), f'no valid history {P.ids[i]} {m} {origin}' return (YEARS[idx] if years else P.value[m][i, idx]) def median30(P, m, origin): a, b = _win(origin, 30); out = np.empty(len(P.ids)) for i in range(len(P.ids)): ok = P.valid[m][i, a:b] out[i] = np.median(P.value[m][i, a:b][ok]) if ok.sum() >= 10 else np.median(last_valid(P, m, origin, i, 30)) return out def meanN(P, m, origin, N): a, b = _win(origin, N); out = np.empty(len(P.ids)) for i in range(len(P.ids)): ok = P.valid[m][i, a:b] out[i] = P.value[m][i, a:b][ok].mean() if ok.sum() >= 10 else last_valid(P, m, origin, i, 30).mean() return out def exp10(P, m, origin): k1 = origin - Y0 + 1; out = np.empty(len(P.ids)) w = 2.0 ** ((YEARS[:k1] - origin) / 10) for i in range(len(P.ids)): ok = P.valid[m][i, :k1]; out[i] = np.average(P.value[m][i, :k1][ok], weights=w[ok]) return out def lin30(P, m, origin): """Official linear trend: OLS through valid years in [O-29,O]; returns (level at origin, slope). Fallback (<10 valid): flat at clim30 fallback.""" a, b = _win(origin, 30); yrs = YEARS[a:b] lev = np.empty(len(P.ids)); sl = np.zeros(len(P.ids)) base, elig = clim30(P, m, origin) for i in range(len(P.ids)): ok = P.valid[m][i, a:b] if ok.sum() >= 10: x = yrs[ok] - origin; y = P.value[m][i, a:b][ok] s, c = np.polyfit(x, y, 1); lev[i] = c; sl[i] = s else: lev[i] = base[i] return lev, sl def seg_slope(P, m, origin): """Own 30-year OLS slope with one intercept per station segment (common slope). NaN if <10 valid years.""" a, b = _win(origin, 30); yrs = YEARS[a:b].astype(float); out = np.full(len(P.ids), np.nan) for i in range(len(P.ids)): ok = P.valid[m][i, a:b] if ok.sum() < 10: continue x = yrs[ok]; y = P.value[m][i, a:b][ok]; s = P.seg[i, a:b][ok] xd = x.copy(); yd = y.copy() for g in np.unique(s): k = s == g; xd[k] -= x[k].mean(); yd[k] -= y[k].mean() den = (xd ** 2).sum() if den > 0 and len(x) - len(np.unique(s)) >= 8: out[i] = (xd * yd).sum() / den return out def coords(P, origin): k1 = origin - Y0 + 1; lat = np.empty(len(P.ids)); lon = np.empty(len(P.ids)) for i in range(len(P.ids)): j = np.where(np.isfinite(P.lat[i, :k1]))[0][-1]; lat[i] = P.lat[i, j]; lon[i] = P.lon[i, j] return lat, lon def regional(P, own, origin, kind): fin = np.isfinite(own) if kind == 'national': return np.full(len(own), own[fin].mean()) 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 = 2 * np.arcsin(np.sqrt(np.clip(h, 0, 1))) np.fill_diagonal(dist, np.inf); dist[:, ~fin] = np.inf nn = np.argsort(dist, axis=1)[:, :10] return own[nn].mean(1) def level_years(P, m, origin, i, L): """Last L valid years in the current station segment; if fewer than L/2 exist there, the last L valid years.""" k1 = origin - Y0 + 1 idx = np.where(P.valid[m][i, :k1])[0] assert len(idx), f'no valid history {P.ids[i]} {m} {origin}' cur = P.seg[i, idx[-1]] same = idx[P.seg[i, idx] == cur][-L:] return same if len(same) >= L / 2 else idx[-L:] # ---------------------------------------------------------------- forecasts def temp_configs(): out = [] for L in (10, 15, 20): for a in (0.0, 0.25, 0.5): for R in ('knn10', 'national'): out.append((L, a, R)) out.append((L, 1.0, 'none')) return out def cfg_name(L, a, R): return f'L{L}_a{a:g}_{R}' def slopes(P, origin, cache=None): """Temperature slope components (CDD and hottest-day trend use the temperature slope).""" own = seg_slope(P, 'annual_avg_temp', origin) reg = {k: regional(P, own, origin, k) for k in ('knn10', 'national')} return own, reg def combined_slope(own, reg, a, R): if R == 'none': r = reg['knn10']; s = np.where(np.isfinite(own), own, r) else: r = reg[R]; s = np.where(np.isfinite(own), a * own + (1 - a) * r, r) return s def forecast_block(P, origin, which='all', configs=None, H=7): """Return long DataFrame: city_id, year, metric, method, predicted_value for horizons 1..H.""" ids = P.ids; n = len(ids); hs = np.arange(1, H + 1) rows = [] def add(metric, method, mat): # mat: n x H mat = np.asarray(mat, float) 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]})) flat = lambda v: np.repeat(np.asarray(v)[:, None], H, 1) configs = configs or temp_configs() own, reg = slopes(P, origin) for m in METRICS: base, _ = clim30(P, m, origin); add(m, 'clim30', flat(base)) lev, sl = lin30(P, m, origin); add(m, 'lin30', lev[:, None] + sl[:, None] * hs[None]) # reference only if which == 'baselines' or m in ('annual_avg_temp', 'cdd'): add(m, 'exp10', flat(exp10(P, m, origin))) if which == 'baselines': return pd.concat(rows, ignore_index=True) # precipitation / hottest alternatives add('total_precip_in', 'median30', flat(median30(P, 'total_precip_in', origin))) add('total_precip_in', 'mean60', flat(meanN(P, 'total_precip_in', origin, 60))) add('hottest_day_temp', 'median30', flat(median30(P, 'hottest_day_temp', origin))) hb, _ = clim30(P, 'hottest_day_temp', origin) s_ref = combined_slope(own, reg, 0.25, 'knn10') for beta in (0.5, 1.0): add('hottest_day_temp', f'trend_beta{beta:g}', hb[:, None] + beta * s_ref[:, None] * (hs[None] + 14.5)) # temperature level + trend, and CDD daily shift T = 'annual_avg_temp' for (L, a, R) in configs: s = combined_slope(own, reg, a, R) tmat = np.empty((n, H)); cmean = np.empty((n, H)); cmed = np.empty((n, H)) for i in range(n): ly = level_years(P, T, origin, i, L) yrs = YEARS[ly].astype(float) tmat[i] = P.value[T][i, ly].mean() + s[i] * (origin + hs - yrs.mean()) cy = level_years(P, 'cdd', origin, i, L) cyrs = YEARS[cy].astype(float); cv = P.value['cdd'][i, cy] shift = s[i] * ((origin + hs)[None, :] - cyrs[:, None]) # nyears x H vals = np.empty_like(shift) for r, t in enumerate(cy): vals[r] = cv[r] + interp_inc(P.inc[i, t], shift[r]) cmean[i] = vals.mean(0); cmed[i] = np.median(vals, 0) name = cfg_name(L, a, R) add(T, 'LT_' + name, tmat) add('cdd', 'SHmean_' + name, cmean); add('cdd', 'SHmedian_' + name, cmed) return pd.concat(rows, ignore_index=True) # ---------------------------------------------------------------- scoring def truth_rows(P, origin, H=7): """Eligible scored rows for an origin (official rules), with clim30 eligibility from [O-29,O].""" out = [] for m in METRICS: _, elig = clim30(P, m, origin) for h in range(1, H + 1): t = origin + h - Y0 ok = P.valid[m][:, t] & elig out.append(pd.DataFrame({'city_id': P.ids[ok], 'year': origin + h, 'metric': m, 'value': P.value[m][ok, t]})) return pd.concat(out, ignore_index=True) def score_origin(P, pred, origin, H=7): """Left-join truth to every method's forecast and assert full coverage; return per-row errors.""" truth = truth_rows(P, origin, H) out = [] for method, g in pred.groupby('method'): mets = g.metric.unique() t = truth[truth.metric.isin(mets)] r = t.merge(g[KEY + ['predicted_value']], on=KEY, how='left', validate='one_to_one') assert r.predicted_value.notna().all() and np.isfinite(r.predicted_value).all(), f'coverage gap {method} {origin}' assert len(r) == len(t) r['method'] = method; out.append(r) r = pd.concat(out, ignore_index=True) r['error'] = (r.predicted_value - r.value).abs(); r['origin'] = origin; r['horizon'] = r.year - origin r['split'] = np.where(r.horizon <= 3, 'live_like', 'final_like') return r def skill_table(rows): """Per origin/method/metric/split MAE and unclipped skill vs clim30 of the same origin & split.""" parts = [] for split in ('live_like', 'final_like', 'all'): r = rows if split == 'all' else rows[rows.split == split] mae = r.groupby(['origin', 'metric', 'method']).error.mean().rename('mae').reset_index() ref = mae[mae.method == 'clim30'][['origin', 'metric', 'mae']].rename(columns={'mae': 'ref_mae'}) mae = mae.merge(ref, on=['origin', 'metric'], how='left', validate='many_to_one') assert mae.ref_mae.notna().all() mae['skill'] = 1 - mae.mae / mae.ref_mae; mae['split'] = split; parts.append(mae) return pd.concat(parts, ignore_index=True) # ---------------------------------------------------------------- submission def validate(df): template = pd.read_csv(TEMPLATE) assert list(df.columns) == KEY + ['predicted_value'] assert len(df) == 5880 and not df.duplicated(KEY).any() assert df[KEY].reset_index(drop=True).equals(template[KEY]), 'Template order/keys differ' assert np.isfinite(df.predicted_value).all() assert (df.loc[df.metric.isin(['cdd', 'total_precip_in']), 'predicted_value'] >= 0).all()