"""CDD delta method: shift-table from daily data + delta candidates. For each city-year we precompute CDD under uniform temperature shifts s in [-3, +6] F (0.25 steps): CDD(s) = sum_d max(0, (tmax+tmin)/2 + s - 65). A forecast for year y replays historical years t, each warmed by slope * (y - t), and aggregates (mean/median) the shifted CDDs. Build: python code/cdd_delta.py --build """ from __future__ import annotations import argparse import sys from pathlib import Path import numpy as np import pandas as pd sys.path.insert(0, str(Path(__file__).parent)) from dataset import download from panel import Panel SHIFTS = np.round(np.arange(-3.0, 6.01, 0.25), 2) YEAR0 = 1960 def build_shift_table(root: Path) -> Path: data_root = download(root / "data" / "_source") daily = pd.read_parquet(data_root / "daily" / "train-00000-of-00001.parquet") daily["Year"] = daily["Date"].astype(str).str.slice(0, 4).astype(int) daily = daily[daily["Year"] >= YEAR0] mean_temp = (daily["tmax"] + daily["tmin"]) / 2.0 daily = daily.assign(mean_temp=mean_temp).dropna(subset=["mean_temp"]) cities = sorted(daily["ID"].unique()) years = np.arange(YEAR0, 2019) table = np.full((len(cities), len(years), len(SHIFTS)), np.nan, dtype=np.float32) city_idx = {c: i for i, c in enumerate(cities)} grouped = daily.groupby(["ID", "Year"])["mean_temp"] for (city, year), arr in grouped: v = arr.to_numpy(float) if len(v) < 300: # too incomplete to replay continue excess = v[None, :] + SHIFTS[:, None] - 65.0 table[city_idx[city], int(year) - YEAR0] = np.clip(excess, 0, None).sum(axis=1) out = root / "data" / "cdd_shift_table.npz" np.savez_compressed(out, table=table, cities=np.array(cities), years=years, shifts=SHIFTS) print(f"wrote {out}: {table.shape}, finite city-years={np.isfinite(table[:, :, 18]).sum()}") return out class CddDelta: def __init__(self, root: Path, panel: Panel): path = root / "data" / "cdd_shift_table.npz" if not path.exists(): build_shift_table(root) z = np.load(path, allow_pickle=True) table, cities, years = z["table"], list(z["cities"]), z["years"] # Align to panel city order / year axis. self.panel = panel self.table = np.full((len(panel.cities), len(panel.years), len(SHIFTS)), np.nan, dtype=np.float32) year_pos = {int(y): i for i, y in enumerate(years)} for ci, city in enumerate(cities): pi = panel.cities.index(city) if city in panel.cities else None if pi is None: continue for y, yi in year_pos.items(): if y in panel.year_idx: self.table[pi, panel.year_idx[y]] = table[ci, yi] def forecast(self, origin: int, history_years: int = 15, aggregate: str = "median", trend: str = "nat", slope_mult: float = 1.0) -> np.ndarray: panel = self.panel temp = panel.stats("annual_avg_temp", origin, years_back=40) if trend == "nat": slope = np.full(len(panel.cities), temp["pooled_slope"]) elif trend == "reg": slope = panel.regional_slope("annual_avg_temp", origin, years_back=40) else: raise ValueError(trend) hist_years = list(range(origin - history_years + 1, origin + 1)) hist_idx = [panel.year_idx[y] for y in hist_years] # Valid historical years: official CDD valid in panel. valid_hist = np.isfinite(panel.values["cdd"][:, hist_idx]) & \ np.isfinite(self.table[:, hist_idx, 18]) out = np.full((len(panel.cities), 7), np.nan) for h, target in enumerate(range(origin + 1, origin + 8)): s = slope_mult * slope[:, None] * (target - np.array(hist_years, dtype=float)[None, :]) s_clip = np.clip(s, SHIFTS[0], SHIFTS[-1]) pos = (s_clip - SHIFTS[0]) / 0.25 lo = np.floor(pos).astype(int) frac = pos - lo hi = np.minimum(lo + 1, len(SHIFTS) - 1) cdd_lo = np.take_along_axis(self.table[:, hist_idx, :], lo[:, :, None], axis=2)[:, :, 0] cdd_hi = np.take_along_axis(self.table[:, hist_idx, :], hi[:, :, None], axis=2)[:, :, 0] shifted = cdd_lo * (1 - frac) + cdd_hi * frac shifted = np.where(valid_hist, shifted, np.nan) with np.errstate(invalid="ignore"): out[:, h] = (np.nanmedian(shifted, axis=1) if aggregate == "median" else np.nanmean(shifted, axis=1)) # Fallback: linear L15 candidate handled by caller blend; here use # city all-history median CDD for any remaining NaN. fallback = np.nanmedian(panel.values["cdd"][:, :panel.year_idx[origin] + 1], axis=1) bad = ~np.isfinite(out) if bad.any(): out[bad] = np.take(fallback[:, None], np.where(bad)[0], axis=0).ravel() \ if False else np.broadcast_to(fallback[:, None], out.shape)[bad] return np.maximum(out, 0.0) def validate_shift0(root: Path, panel: Panel) -> pd.DataFrame: """CDD(shift=0) from daily vs official annual cdd, on valid years.""" delta = CddDelta(root, panel) rows = [] zi = list(SHIFTS).index(0.0) official = panel.values["cdd"] mine = delta.table[:, :, zi] diff = np.abs(mine - official) mask = np.isfinite(diff) print(f"shift-0 validation: n={mask.sum()}, mean|diff|={np.nanmean(diff):.3f} " f"F-days, max|diff|={np.nanmax(diff):.2f}, " f"share exact(<0.6)={np.mean(diff[mask] < 0.6):.3f}") return pd.DataFrame({"mean_abs_diff": [float(np.nanmean(diff))], "max_abs_diff": [float(np.nanmax(diff))], "n": [int(mask.sum())]}) def main() -> None: ap = argparse.ArgumentParser() ap.add_argument("--build", action="store_true") args = ap.parse_args() root = Path(__file__).resolve().parent.parent if args.build: build_shift_table(root) panel = Panel(root) validate_shift0(root, panel) if __name__ == "__main__": main()