Datasets:
Download code/models_extra.py from sleonca/sl-protostar-climate-ceviche: direct link, hf CLI and curl.
- Browser
- Download file 10.1 kB
-
https://huggingface.co/datasets/sleonca/sl-protostar-climate-ceviche/resolve/main/code/models_extra.py
- Command line
-
hf download hf://datasets/sleonca/sl-protostar-climate-ceviche/code/models_extra.py
-
curl -L -o models_extra.py https://huggingface.co/datasets/sleonca/sl-protostar-climate-ceviche/resolve/main/code/models_extra.py
10.1 kB
| """Additional forecasters (PROMPT_SIGUIENTE, Step A), with the repository signature | |
| fn(lv, origin, years, coords, metric, **kw) -> DataFrame[ID, metric, Year, pred] | |
| All of them use only data up to `origin` (the challenge data ends 2018-12-31). | |
| 1. ETS (statsmodels ExponentialSmoothing), one model per city and metric on the regular series of | |
| arima_prep (50-year window by default, interior gaps interpolated, weak series -> 30-year average): | |
| ets_holt Holt's linear trend | |
| ets_damped Holt's damped trend | |
| ets_pooled simple exponential smoothing of the series minus the pooled trend | |
| (models.temp_slope of that metric), forecast = SES level + pooled trend | |
| 2. Hierarchical model (statsmodels MixedLM) on the last 50 years up to the origin: | |
| value ~ region + region:t + (1 + t | city), t = (year - origin) / 10 | |
| Regions = 9 k-means clusters of the city coordinates (random_state 0), a proxy for climate regions. | |
| Each city's slope is shrunk towards its region's slope; the forecast extends the city's fitted line. | |
| For CDD, the shrunk *temperature* slope is passed to the shifted-daily-weather CDD model | |
| (as models.cdd_shift, averaging N = 10 and 20 years). | |
| 3. Tmax / Tmin separately: level_trend on `Avg Tmax` and `Avg Tmin` (validity as for the average | |
| temperature), each with its own pooled slope; annual_avg_temp = their mean (the official | |
| definition is (mean Tmax + mean Tmin) / 2). | |
| """ | |
| import warnings | |
| import numpy as np | |
| import pandas as pd | |
| from joblib import Parallel, delayed | |
| import models | |
| from arima_prep import prepare | |
| from common import MAX_MISS, load_annual | |
| from models_arima import _fallback, window_start | |
| N_JOBS = -1 | |
| # --------------------------------------------------------------------------- per-series runner (ETS) | |
| def _ets_forecast(cid, y, h, kind): | |
| from statsmodels.tsa.holtwinters import ExponentialSmoothing | |
| try: | |
| with warnings.catch_warnings(): | |
| warnings.simplefilter("ignore") | |
| if kind == "ses": | |
| m = ExponentialSmoothing(y, trend=None, initialization_method="estimated").fit() | |
| else: | |
| m = ExponentialSmoothing(y, trend="add", damped_trend=(kind == "damped"), | |
| initialization_method="estimated").fit() | |
| fc = np.asarray(m.forecast(h), float) | |
| if not np.all(np.isfinite(fc)): | |
| raise ValueError("non-finite") | |
| return cid, fc, "ok" | |
| except Exception as e: # noqa: BLE001 | |
| return cid, None, f"failed: {type(e).__name__}" | |
| def _run_series(lv, origin, years, metric, kind, train_start=1969, offset=None): | |
| S = prepare(lv, metric, origin, window_start(origin, train_start)) | |
| fb = _fallback(lv, origin, metric) | |
| tasks, log = [], [] | |
| for cid, s in S.items(): | |
| if s.weak or len(s.y) == 0: | |
| log.append(dict(ID=cid, status="weak")) | |
| continue | |
| y = s.y if offset is None else s.y - offset[cid] * (s.years - origin) | |
| tasks.append((cid, y, max(years) - s.last_year, s.last_year)) | |
| res = Parallel(n_jobs=N_JOBS)(delayed(_ets_forecast)(cid, y, h, kind) for cid, y, h, _ in tasks) | |
| last = {cid: ly for cid, _, _, ly in tasks} | |
| out = [] | |
| for cid, fc, status in res: | |
| log.append(dict(ID=cid, status=status)) | |
| for yr in years: | |
| p = fb.get(cid, np.nan) if fc is None else fc[yr - last[cid] - 1] + (0 if offset is None else offset[cid] * (yr - origin)) | |
| out.append((cid, yr, p)) | |
| for r in log: | |
| if r["status"] == "weak": | |
| out += [(r["ID"], yr, fb.get(r["ID"], np.nan)) for yr in years] | |
| df = pd.DataFrame(out, columns=["ID", "Year", "pred"]).assign(metric=metric)[["ID", "metric", "Year", "pred"]] | |
| df.attrs["log"] = pd.DataFrame(log).assign(metric=metric, origin=origin) | |
| return df | |
| def ets_holt(lv, origin, years, coords, metric, train_start=1969): | |
| return _run_series(lv, origin, years, metric, "holt", train_start) | |
| def ets_damped(lv, origin, years, coords, metric, train_start=1969): | |
| return _run_series(lv, origin, years, metric, "damped", train_start) | |
| def ets_pooled(lv, origin, years, coords, metric, L=50, slope_scale=1.0, train_start=1969): | |
| slope = models.temp_slope(lv, origin, coords, L=L, metric=metric) * slope_scale | |
| return _run_series(lv, origin, years, metric, "ses", train_start, offset=slope) | |
| # --------------------------------------------------------------------------- hierarchical (MixedLM) | |
| _REGIONS = {} | |
| def regions(coords: pd.DataFrame, k: int = 9) -> pd.Series: | |
| if k not in _REGIONS: | |
| from sklearn.cluster import KMeans | |
| lab = KMeans(n_clusters=k, n_init=10, random_state=0).fit_predict(coords[["Lat", "Lon"]].to_numpy()) | |
| _REGIONS[k] = pd.Series(lab, index=coords.index, name="region") | |
| return _REGIONS[k] | |
| def hier_fit(lv, origin, coords, metric, L=50, k_regions=9): | |
| """Fitted MixedLM line per city: returns (intercept at origin, slope per year) Series indexed by ID.""" | |
| import statsmodels.formula.api as smf | |
| w = lv[(lv.metric == metric) & lv.valid & (lv.Year > origin - L) & (lv.Year <= origin)].copy() | |
| w["t"] = (w.Year - origin) / 10.0 | |
| w["region"] = regions(coords, k_regions).reindex(w.ID).to_numpy().astype(str) | |
| with warnings.catch_warnings(): | |
| warnings.simplefilter("ignore") | |
| md = smf.mixedlm("value ~ 0 + C(region) + C(region):t", w, groups="ID", re_formula="~t") | |
| fit = None | |
| for method in (["lbfgs"], ["powell", "lbfgs"], ["nm", "lbfgs"]): | |
| try: | |
| fit = md.fit(method=method, reml=True) | |
| break | |
| except Exception: # noqa: BLE001 | |
| continue | |
| if fit is None: | |
| raise RuntimeError("MixedLM did not fit") | |
| ids = sorted(w.ID.unique()) | |
| reg = regions(coords, k_regions).reindex(ids).astype(str) | |
| fe = fit.fe_params | |
| b0 = np.array([fe.get(f"C(region)[{r}]", 0.0) for r in reg]) | |
| b1 = np.array([fe.get(f"C(region)[{r}]:t", 0.0) for r in reg]) | |
| re = fit.random_effects | |
| u0 = np.array([re[i].iloc[0] for i in ids]) | |
| u1 = np.array([re[i].iloc[1] for i in ids]) | |
| return (pd.Series(b0 + u0, index=ids), pd.Series((b1 + u1) / 10.0, index=ids), | |
| dict(converged=bool(getattr(fit, "converged", True)), n=len(w))) | |
| def _cdd_with_slope(lv, origin, years, slope: pd.Series, N: int): | |
| """models.cdd_shift with an externally supplied warming rate (°F/yr per city).""" | |
| tab, deltas = models.shift_table() | |
| W = models.wide(lv, "cdd", origin) | |
| valid = W.notna().stack() | |
| win = [ix for ix in valid[valid].index if ix[1] > origin - N and ix in tab.index] | |
| T = tab.loc[win] | |
| ids = T.index.get_level_values(0) | |
| ty = T.index.get_level_values(1).to_numpy() | |
| M = T.to_numpy() | |
| r = np.arange(len(M)) | |
| s = slope.reindex(ids).fillna(slope.mean()).to_numpy() | |
| out = [] | |
| for y in years: | |
| dl = np.clip(s * (y - ty), deltas[0], deltas[-1]) | |
| pos = np.interp(dl, deltas, np.arange(len(deltas))) | |
| lo = np.floor(pos).astype(int); hi = np.minimum(lo + 1, len(deltas) - 1); f = pos - lo | |
| agg = pd.Series(M[r, lo] * (1 - f) + M[r, hi] * f, index=ids).groupby(level=0).mean() | |
| out.append(pd.DataFrame({"ID": agg.index, "metric": "cdd", "Year": y, "pred": agg.values})) | |
| df = pd.concat(out, ignore_index=True) | |
| return df, set(W.index) - set(df.ID) # caller fills cities with no recent valid year | |
| def hierarchical(lv, origin, years, coords, metric, L=50, k_regions=9, cdd_N=(10, 20)): | |
| if metric == "cdd": | |
| _, slope, info = hier_fit(lv, origin, coords, "annual_avg_temp", L, k_regions) | |
| parts, miss = [], set() | |
| for N in cdd_N: | |
| d, m = _cdd_with_slope(lv, origin, years, slope, N) | |
| parts.append(d.set_index(["ID", "metric", "Year"]).pred) | |
| miss |= m | |
| df = (sum(parts) / len(parts)).rename("pred").reset_index().dropna(subset=["pred"]) | |
| if miss or set(models.wide(lv, "cdd", origin).index) - set(df.ID): | |
| fb = models.cdd_shift(lv, origin, years, coords, N=20, L=50) | |
| df = pd.concat([df, fb[~fb.ID.isin(df.ID)]], ignore_index=True) | |
| else: | |
| a, b, info = hier_fit(lv, origin, coords, metric, L, k_regions) | |
| df = pd.concat([pd.DataFrame({"ID": a.index, "metric": metric, "Year": y, "pred": (a + b * (y - origin)).values}) | |
| for y in years], ignore_index=True) | |
| fb = _fallback(lv, origin, metric) | |
| miss = sorted(set(fb.index) - set(a.index)) | |
| if miss: | |
| df = pd.concat([df] + [pd.DataFrame({"ID": miss, "metric": metric, "Year": y, "pred": fb.reindex(miss).values}) | |
| for y in years], ignore_index=True) | |
| df.attrs["log"] = pd.DataFrame([dict(metric=metric, origin=origin, **info)]) | |
| return df | |
| # --------------------------------------------------------------------------- Tmax / Tmin separately | |
| _TMM = None | |
| def _tmaxmin_long(): | |
| global _TMM | |
| if _TMM is None: | |
| a = load_annual() | |
| valid_t = a[["Miss Tmax", "Miss Tmin"]].max(axis=1) <= MAX_MISS | |
| _TMM = pd.concat([pd.DataFrame({"ID": a.ID, "Year": a.Year, "metric": m, "value": a[c], | |
| "valid": valid_t & a[c].notna(), "segment": a["Station Segment"]}) | |
| for m, c in (("avg_tmax", "Avg Tmax"), ("avg_tmin", "Avg Tmin"))], ignore_index=True) | |
| return _TMM | |
| def tmax_tmin(lv, origin, years, coords, metric="annual_avg_temp", k=15, L=50, slope_scale=1.25): | |
| """annual_avg_temp = mean of level_trend forecasts of Avg Tmax and Avg Tmin (pooled slope of each).""" | |
| assert metric == "annual_avg_temp", "tmax_tmin only forecasts annual_avg_temp" | |
| ext = _tmaxmin_long() | |
| ext = ext[ext.Year <= origin] | |
| parts = [models.level_trend(ext, origin, years, coords, m, k=k, L=L, slope_scale=slope_scale) | |
| .set_index(["ID", "Year"]).pred for m in ("avg_tmax", "avg_tmin")] | |
| p = ((parts[0] + parts[1]) / 2).rename("pred").reset_index() | |
| return p.assign(metric=metric)[["ID", "metric", "Year", "pred"]] | |