"""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"]]