Datasets:
File size: 8,778 Bytes
b3952f1 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 | """Heat Seekers v8: climate-character temperature and simple shrinkage (research/V8_PROTOCOL.md). Data <= origin only."""
import hashlib, json
import numpy as np, pandas as pd
from v7lib import *
from v6lib import _win
REF8 = dict(REF7)
REF8['cdd'] = 'c_map' # v7 adopted CDD; v6_mats still returns v2b under REF7['cdd']
CANDS8 = {
'annual_avg_temp': ['t_c2nat', 't_c2nat50'],
'hottest_day_temp': ['h_clim30', 'h_shrink50', 'h_median30'],
'total_precip_in': ['p_clim30', 'p_shrink50', 'p_median30'],
'cdd': ['c_map_tchar'],
}
LAND_COLS = ['crop_share', 'pasture_share', 'water_share', 'developed_share', 'forest_share',
'impervious_pct', 'tree_canopy_pct', 'elev_m']
CLIMATE_COLS = ['dewpoint_f', 'wind_kt', 'visibility_mi', 'dewpoint_trend', 'dtr_mean', 'dtr_trend']
FEATURES = LAND_COLS + CLIMATE_COLS
LAMBDA_TREND = 10.0
GSOD_FIRST, MIN_DAYS, MIN_DEW_TREND = 1980, 300, 8
EXT8 = DATA / 'external_v8'
def check_ext8():
man = json.loads((EXT8 / 'manifest.json').read_text())['files']
for name, digest in man.items():
got = hashlib.sha256((EXT8 / name).read_bytes()).hexdigest()
assert got == digest, f'external_v8 file changed: {name}'
def _dtr_table():
"""Official-valid DTR from the pinned annual file; years 1870..2018, never after 2018."""
a = pd.read_parquet(DATA / 'annual_indices/train-00000-of-00001.parquet',
columns=['ID', 'Year', 'Avg Tmax', 'Avg Tmin', 'Miss Tmax', 'Miss Tmin'])
a = a[(a.Year >= Y0) & (a.Year <= Y1) & (a['Miss Tmax'] <= 10) & (a['Miss Tmin'] <= 10)
& a['Avg Tmax'].notna() & a['Avg Tmin'].notna()]
return pd.DataFrame({'city_id': a['ID'], 'year': a['Year'].astype(int),
'dtr': a['Avg Tmax'].to_numpy(float) - a['Avg Tmin'].to_numpy(float)})
class Ext8:
"""Land + GSOD + DTR. as_of(origin) uses years <= origin only."""
def __init__(self):
check_ext8()
self.land = pd.read_csv(EXT8 / 'land_features.csv').set_index('city_id')
g = pd.read_csv(EXT8 / 'gsod_yearly.csv')
assert g['year'].max() <= 2018
self.gsod = g[(g['days'] >= MIN_DAYS) & (g['year'] >= GSOD_FIRST)].copy()
self.dtr = _dtr_table()
assert self.dtr['year'].max() <= 2018
def cut(self, origin, junk=999999.0):
Q = Ext8.__new__(Ext8)
Q.land = self.land
Q.gsod = self.gsod.copy()
Q.dtr = self.dtr.copy()
Q.gsod.loc[Q.gsod['year'] > origin, ['dewpoint_f', 'wind_kt', 'visibility_mi', 'days']] = junk
Q.dtr.loc[Q.dtr['year'] > origin, 'dtr'] = junk
return Q
def as_of(self, origin, city_ids):
g = self.gsod[self.gsod['year'] <= origin]
means = g.groupby('city_id')[['dewpoint_f', 'wind_kt', 'visibility_mi']].mean()
trend = {}
for cid, gg in g.dropna(subset=['dewpoint_f']).groupby('city_id'):
if len(gg) >= MIN_DEW_TREND:
trend[cid] = np.polyfit(gg['year'], gg['dewpoint_f'], 1)[0]
d = self.dtr[self.dtr['year'] <= origin]
dtr_mean = d.sort_values('year').groupby('city_id').tail(15).groupby('city_id')['dtr'].mean()
dtr_trend = {cid: np.polyfit(gg['year'], gg['dtr'], 1)[0]
for cid, gg in d[d['year'] > origin - 30].groupby('city_id') if len(gg) >= 15}
f = pd.DataFrame(index=pd.Index(list(city_ids), name='city_id'))
f = f.join(self.land[LAND_COLS]).join(means)
f['dewpoint_trend'] = pd.Series(trend)
f['dtr_mean'] = dtr_mean
f['dtr_trend'] = pd.Series(dtr_trend)
return f[FEATURES].apply(lambda c: c.fillna(c.median()) if c.notna().any() else c.fillna(0.0))
def segment_slope(years, values, segments):
segs = np.unique(segments)
X = np.column_stack([(segments == s).astype(float) for s in segs] + [years - years.mean()])
coef, *_ = np.linalg.lstsq(X, values, rcond=None)
return float(coef[-1])
def city_slopes15(P, origin):
"""Segment-aware 30-year temperature slopes; cities with >=15 valid years."""
m = TM; 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() >= 15:
out[i] = segment_slope(yrs[ok], P.value[m][i, a:b][ok], P.seg[i, a:b][ok])
return out
def neighbor_mean_slopes(P, origin, slopes, k=10):
"""Mean slope of up to k nearest cities that have a slope; 0 if none. Ties by city id."""
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)))
ids = P.ids; have = np.isfinite(slopes); out = np.zeros(len(ids))
for i in range(len(ids)):
order = [j for j in range(len(ids)) if j != i]
order.sort(key=lambda j: (dist[i, j], ids[j]))
vals = [slopes[j] for j in order if have[j]][:k]
out[i] = float(np.mean(vals)) if vals else 0.0
return out
def ridge_predict(X, y, Xn, lam=LAMBDA_TREND):
mu, sd = X.mean(0), X.std(0); sd = np.where(sd == 0, 1.0, sd)
Z = (X - mu) / sd; ym = y.mean()
coef = np.linalg.solve(Z.T @ Z + lam * np.eye(Z.shape[1]), Z.T @ (y - ym))
return ym + ((Xn - mu) / sd) @ coef
def t_c2nat(P, origin, ext, v6t):
"""Parth C2 regional slope, 50% national pooling, 15-year (segment) level. Fallback: v7 temperature."""
slopes = city_slopes15(P, origin)
have = np.isfinite(slopes)
assert have.sum() >= 2, 'too few city slopes'
s_nat = float(slopes[have].mean())
nb = neighbor_mean_slopes(P, origin, slopes)
F = ext.as_of(origin, P.ids)
pred = ridge_predict(F.to_numpy(float)[have], slopes[have], F.to_numpy(float))
regional = 0.5 * nb + 0.5 * pred
s = 0.5 * regional + 0.5 * s_nat
hs = np.arange(1, H + 1); out = v6t.copy(); k1 = origin - Y0 + 1
n_level = 0
for i in range(len(P.ids)):
idx_win = np.where(P.valid[TM][i, max(0, origin - 14 - Y0):k1])[0] + max(0, origin - 14 - Y0)
segs_all = np.where(np.isfinite(P.seg[i, :k1]) & (P.seg[i, :k1] >= 0))[0]
cur = int(P.seg[i, segs_all[-1]]) if len(segs_all) else None
level_idx = idx_win
if cur is not None and (P.seg[i, idx_win] == cur).sum() >= 5:
level_idx = idx_win[P.seg[i, idx_win] == cur]
if len(level_idx) < 3:
level_idx = np.where(P.valid[TM][i, :k1])[0][-15:]
if not len(level_idx):
continue
n_level += 1
lev = P.value[TM][i, level_idx].mean(); cen = YEARS[level_idx].astype(float).mean()
out[i] = lev + s[i] * (origin + hs - cen)
return out, dict(s_nat=s_nat, n_slopes=int(have.sum()), n_level=n_level, mean_s=float(s.mean()))
def attach8(P):
return attach6(P)
def cut8(P, ext, origin, junk=999999.0):
return cut6(P, origin, junk), ext.cut(origin, junk)
def v7_ref_mats(P, origin):
"""v7 counting methods plus clim30, as matrices (n, H) and the v6_block frame."""
mats, info, f6 = v6_mats(P, origin)
mats['cdd'] = c_map(P, origin, mats[TM])
clim = {}
for m in METRICS:
g = f6[(f6.metric == m) & (f6.method == 'clim30')].pivot(index='city_id', columns='year', values='predicted_value')
clim[m] = g.reindex(P.ids).to_numpy()
return mats, clim, info, f6
def v8_block(P, origin, ext):
mats, clim, info, f6 = v7_ref_mats(P, origin)
# keep v7 refs + clim30; add c_map (not in v6_block)
keep = set(REF7.values()) | {'clim30'}
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)
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'])
t1, tinfo = t_c2nat(P, origin, ext, mats[TM])
add(TM, 't_c2nat', t1); add(TM, 't_c2nat50', 0.5 * t1 + 0.5 * mats[TM])
q = 'hottest_day_temp'; p = 'total_precip_in'
add(q, 'h_clim30', clim[q]); add(q, 'h_shrink50', 0.5 * mats[q] + 0.5 * clim[q])
add(q, 'h_median30', median30(P, q, origin))
add(p, 'p_clim30', clim[p]); add(p, 'p_shrink50', 0.5 * mats[p] + 0.5 * clim[p])
add(p, 'p_median30', median30(P, p, origin))
add('cdd', 'c_map_tchar', c_map(P, origin, t1))
info.update({f'c2_{k}': v for k, v in tinfo.items()})
return pd.concat(rows, ignore_index=True), info
|