Download code/cdd_delta.py from Tonic/protostar-climate-2026: direct link, hf CLI and curl.
- Browser
- Download file 6.42 kB
-
https://huggingface.co/datasets/Tonic/protostar-climate-2026/resolve/main/code/cdd_delta.py
- Command line
-
hf download hf://datasets/Tonic/protostar-climate-2026/code/cdd_delta.py
-
curl -L -o cdd_delta.py https://huggingface.co/datasets/Tonic/protostar-climate-2026/resolve/main/code/cdd_delta.py
6.42 kB
| """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() | |