sleonca's picture
Upload folder using huggingface_hub
b47743b verified
Raw History Blame Contribute Delete
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"]]