Download code/panel.py from Tonic/protostar-climate-2026: direct link, hf CLI and curl.
- Browser
- Download file 4.93 kB
-
https://huggingface.co/datasets/Tonic/protostar-climate-2026/resolve/main/code/panel.py
- Command line
-
hf download hf://datasets/Tonic/protostar-climate-2026/code/panel.py
-
curl -L -o panel.py https://huggingface.co/datasets/Tonic/protostar-climate-2026/resolve/main/code/panel.py
4.93 kB
| """Vectorised city x year panel for fast rolling-origin evaluation. | |
| values[metric]: (n_cities, n_years) float array, NaN where the year is not | |
| valid under the official <=10-missing-day rule. All statistics are computed | |
| from slices ending at the origin, so no post-origin data can leak. | |
| """ | |
| from __future__ import annotations | |
| from pathlib import Path | |
| import numpy as np | |
| import pandas as pd | |
| from dataset import (METRICS, add_validity, download, load_annual, load_cities, | |
| load_coverage, long_valid) | |
| YEAR_MIN = 1930 | |
| class Panel: | |
| def __init__(self, root: Path): | |
| data_root = download(root / "data" / "_source") | |
| annual = add_validity(load_annual(data_root), load_coverage(data_root)) | |
| cities_df = load_cities(data_root) | |
| long_df = long_valid(annual) | |
| self.cities = sorted(long_df["city_id"].unique()) | |
| self.years = np.arange(YEAR_MIN, 2019) | |
| self.year_idx = {int(y): i for i, y in enumerate(self.years)} | |
| geo = (long_df.drop_duplicates("city_id").set_index("city_id") | |
| .loc[self.cities]) | |
| self.lat = geo["Lat"].to_numpy(float) | |
| self.lon = geo["Lon"].to_numpy(float) | |
| self.values: dict[str, np.ndarray] = {} | |
| for metric in METRICS: | |
| sub = long_df[long_df["metric"] == metric] | |
| piv = sub.pivot(index="city_id", columns="Year", values="value") | |
| piv = piv.reindex(index=self.cities, columns=self.years) | |
| self.values[metric] = piv.to_numpy(float) | |
| self._neighbours() | |
| self._cache: dict = {} | |
| def _neighbours(self, k: int = 32): | |
| lat, lon = np.radians(self.lat), np.radians(self.lon) | |
| dlat = lat[:, None] - lat[None, :] | |
| dlon = lon[:, None] - lon[None, :] | |
| a = np.sin(dlat / 2) ** 2 + np.cos(lat[:, None]) * np.cos(lat[None, :]) * np.sin(dlon / 2) ** 2 | |
| dist = 6371 * 2 * np.arcsin(np.sqrt(np.clip(a, 0, 1))) | |
| np.fill_diagonal(dist, np.inf) | |
| self.nn_idx = np.argsort(dist, axis=1)[:, :k] # (210, k) nearest others | |
| def window(self, metric: str, origin: int, start: int): | |
| i0, i1 = self.year_idx[start], self.year_idx[origin] | |
| return self.values[metric][:, i0:i1 + 1], self.years[i0:i1 + 1] | |
| def stats(self, metric: str, origin: int, years_back: int | None = None, | |
| start: int | None = None) -> dict: | |
| """Per-city window stats + pooled slope. Cached per (metric, origin, window).""" | |
| if start is None: | |
| start = origin - years_back + 1 | |
| key = (metric, origin, int(start)) | |
| if key in self._cache: | |
| return self._cache[key] | |
| vals, yrs = self.window(metric, origin, int(start)) | |
| valid = np.isfinite(vals) | |
| n = valid.sum(axis=1) | |
| x = np.where(valid, yrs[None, :], 0.0) | |
| y = np.where(valid, vals, 0.0) | |
| sx, sy = x.sum(1), y.sum(1) | |
| sxx, sxy = (x * x).sum(1), (x * y).sum(1) | |
| with np.errstate(invalid="ignore", divide="ignore"): | |
| mean = np.where(n > 0, sy / np.maximum(n, 1), np.nan) | |
| mean_year = np.where(n > 0, sx / np.maximum(n, 1), np.nan) | |
| denom = sxx - sx * sx / np.maximum(n, 1) | |
| slope = np.where((n >= 5) & (denom > 0), | |
| (sxy - sx * sy / np.maximum(n, 1)) / np.where(denom > 0, denom, 1), | |
| np.nan) | |
| median = np.nanmedian(vals, axis=1) | |
| pooled_num = np.nansum(sxy - sx * sy / np.maximum(n, 1)) | |
| pooled_den = np.nansum(denom) | |
| out = {"n": n, "mean": mean, "median": median, "mean_year": mean_year, | |
| "slope": slope, | |
| "pooled_slope": float(pooled_num / pooled_den) if pooled_den > 0 else 0.0, | |
| "start": int(start)} | |
| self._cache[key] = out | |
| return out | |
| def regional_slope(self, metric: str, origin: int, years_back: int | None = None, | |
| start: int | None = None, k: int = 32) -> np.ndarray: | |
| st = self.stats(metric, origin, years_back, start) | |
| slopes = st["slope"] | |
| nn = slopes[self.nn_idx[:, :k]] # (210, k) | |
| with np.errstate(invalid="ignore"): | |
| reg = np.nanmedian(nn, axis=1) | |
| return np.where(np.isfinite(reg), reg, st["pooled_slope"]) | |
| def truth(self, metric: str, origin: int, horizon: int = 7): | |
| """(values (210,7), scored_mask) for origin+1..origin+7. | |
| Scored: truth valid AND city-metric has >=10 valid years in the | |
| 30-year window ending at origin (official baseline-eligibility rule). | |
| """ | |
| cols = [self.year_idx[origin + h] for h in range(1, horizon + 1)] | |
| vals = self.values[metric][:, cols] | |
| st = self.stats(metric, origin, years_back=30) | |
| eligible = (st["n"] >= 10)[:, None] | |
| return vals, np.isfinite(vals) & eligible | |