sleonca's picture
Upload folder using huggingface_hub
b47743b verified
Raw History Blame Contribute Delete
9.28 kB
"""Step 6 of the ARIMA experiments: ARIMA / auto-ARIMA forecasters with the repository's model signature
fn(lv, origin, years, coords, metric, **kw) -> DataFrame[ID, metric, Year, pred]
One model is fitted per city and metric on the regular series from arima_prep (data <= origin only).
Training window: `train_start` names the window used for the final forecast at origin 2018
(1949 -> 70 years, 1969 -> 50 years, 1979 -> 40 years). At an earlier backtest origin the same
*length* is used, ending at that origin, so the backtest measures the configuration that is
actually used for 2019-2025.
Trend handling (pmdarima / statsmodels SARIMAX conventions, checked in Step 6):
d=0, trend='ct' ARMA around a deterministic linear trend
d=0, trend='c' ARMA around a constant mean
d=1, trend='c' ARIMA with drift (the constant of the differenced series)
In auto-ARIMA, d is chosen first by pmdarima.ndiffs(test=...) with max_d=1, which is exactly
what pmdarima.auto_arima does internally. Fixing d before the search lets the trend
depend on d ('ct' for d=0, drift for d=1).
Fallback: weak series (arima_prep) and fits that fail or produce non-finite forecasts use the
30-year average (common.baseline30). Every prediction frame carries `.attrs["log"]` with the chosen
order, AICc and status per series, which arima_backtest.py collects into results/arima_orders.csv.
"""
import warnings
import numpy as np
import pandas as pd
import pmdarima as pm
from joblib import Parallel, delayed
from pmdarima.arima import ndiffs
import models
from arima_prep import prepare
from common import CUTOFF_YEAR, baseline30
N_JOBS = -1
RANDOM_STATE = 0
AUTO_KW = dict(seasonal=False, max_p=3, max_q=3, max_d=1, start_p=0, start_q=0,
information_criterion="aicc", stepwise=True, suppress_warnings=True,
error_action="ignore", random_state=RANDOM_STATE)
# --------------------------------------------------------------------------- single-series core
def fit_series(y: np.ndarray, spec: dict):
"""Fit one series. spec: kind 'fixed' (order, trend) or 'auto' (d or test, trend0).
Returns the fitted pmdarima.ARIMA."""
with warnings.catch_warnings():
warnings.simplefilter("ignore")
if spec["kind"] == "fixed":
return pm.ARIMA(order=spec["order"], trend=spec["trend"], suppress_warnings=True).fit(y)
d = spec.get("d")
if d is None:
d = ndiffs(y, alpha=0.05, test=spec.get("test", "kpss"), max_d=1)
trend = spec.get("trend0", "ct") if d == 0 else "c"
return pm.auto_arima(y, d=d, trend=trend, **AUTO_KW)
def _fit_forecast(cid, y, h, spec):
try:
m = fit_series(y, spec)
fc = np.asarray(m.predict(h), float)
if not np.all(np.isfinite(fc)):
raise ValueError("non-finite forecast")
return cid, fc, dict(order=str(m.order), d=m.order[1], trend=m.trend, aicc=m.aicc(), status="ok")
except Exception as e: # noqa: BLE001 - any failure falls back to the 30-year average
return cid, None, dict(order=None, d=None, trend=None, aicc=np.nan, status=f"failed: {type(e).__name__}")
def window_start(origin: int, train_start: int) -> int:
return origin - (CUTOFF_YEAR - train_start)
def _fallback(lv, origin, metric):
b = baseline30(lv[lv.metric == metric], origin).xs(metric, level="metric")
allmean = lv[(lv.metric == metric) & lv.valid & (lv.Year <= origin)].groupby("ID").value.mean()
return b.reindex(allmean.index).fillna(allmean)
def run_arima(lv, origin, years, coords, metric, spec, train_start=1969, offset=None):
"""Fit `spec` to every city's series and forecast `years`.
offset: optional Series of per-city slopes (units/yr); the model is fitted to
y - slope*(year - origin) and the slope term is added back to the forecast."""
S = prepare(lv, metric, origin, window_start(origin, train_start))
fb = _fallback(lv, origin, metric)
ymax = max(years)
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, ymax - s.last_year, s.last_year))
res = Parallel(n_jobs=N_JOBS)(delayed(_fit_forecast)(cid, y, h, spec) for cid, y, h, _ in tasks)
last = {cid: ly for cid, _, _, ly in tasks}
out = []
for cid, fc, info in res:
log.append(dict(ID=cid, **info))
for yr in years:
if fc is None:
p = fb.get(cid, np.nan)
else:
p = 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
# --------------------------------------------------------------------------- candidate models
def arima_fixed(lv, origin, years, coords, metric, order=(1, 0, 0), trend="ct", train_start=1969):
"""Fixed order from the ACF/PACF step, e.g. (1,0,0)+'ct', (0,1,1) with drift ('c')."""
return run_arima(lv, origin, years, coords, metric, dict(kind="fixed", order=order, trend=trend), train_start)
def auto_arima_model(lv, origin, years, coords, metric, test="kpss", trend0="ct", train_start=1969):
"""pmdarima auto-ARIMA: d in {0,1} by `test`, then stepwise AICc search over p,q <= 3.
trend0 is the deterministic term used when d=0; with d=1 a drift is always allowed."""
return run_arima(lv, origin, years, coords, metric, dict(kind="auto", test=test, trend0=trend0), train_start)
def auto_arima_d0_trend(lv, origin, years, coords, metric, trend0="ct", train_start=1969):
"""auto-ARIMA forced to d=0 with a deterministic linear trend: ARMA around the city's own trend."""
return run_arima(lv, origin, years, coords, metric, dict(kind="auto", d=0, trend0=trend0), train_start)
def pooled_trend_arima(lv, origin, years, coords, metric, L=50, k_nn=None, slope_scale=1.0,
order=None, train_start=1969):
"""ARIMA with a pooled-trend regressor (the most promising variant).
The trend rate is models.temp_slope (mean of the cities' OLS slopes of this metric over the
last L years, all cities or the k_nn nearest), computed with data <= origin only. It is
removed from the series, a d=0 ARMA with constant is fitted to the remainder (auto-ARIMA, or
a fixed `order`), and the forecast is ARMA(remainder) + pooled trend."""
slope = models.temp_slope(lv, origin, coords, L=L, k_nn=k_nn, metric=metric) * slope_scale
spec = (dict(kind="auto", d=0, trend0="c") if order is None
else dict(kind="fixed", order=order, trend="c"))
return run_arima(lv, origin, years, coords, metric, spec, train_start, offset=slope)
def cdd_hybrid(lv, origin, years, coords, metric="cdd", N=10, temp_fn=pooled_trend_arima, temp_kw=None):
"""CDD from an ARIMA temperature forecast and shifted daily weather.
For target year y and each valid past year t in the last N years, the daily mean temperatures
of year t are shifted by (forecast annual mean temperature of y) - (observed annual mean of t),
and CDD is read from data/processed/shift_table.parquet (as in models.cdd_shift). The forecast
is the mean over those N years. This keeps CDD's nonlinear response to warming while the
temperature path comes from ARIMA."""
assert metric == "cdd"
tab, deltas = models.shift_table()
tp = temp_fn(lv, origin, years, coords, "annual_avg_temp", **(temp_kw or {}))
tlog = tp.attrs.pop("log", pd.DataFrame())
Tp = tp.pivot(index="ID", columns="Year", values="pred")
Tobs = models.wide(lv, "annual_avg_temp", origin)
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()
tobs = Tobs.stack().reindex(pd.MultiIndex.from_arrays([ids, ty])).to_numpy()
M = T.to_numpy()
r = np.arange(len(M))
out = []
for y in years:
dl = np.clip(Tp[y].reindex(ids).to_numpy() - tobs, 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
v = pd.Series(M[r, lo] * (1 - f) + M[r, hi] * f, index=ids)
agg = v.groupby(level=0).mean()
out.append(pd.DataFrame({"ID": agg.index, "metric": metric, "Year": y, "pred": agg.values}))
df = pd.concat(out, ignore_index=True).dropna(subset=["pred"])
miss = set(W.index) - set(df.ID)
if miss: # no valid recent year: fall back to the existing CDD model
fb = models.cdd_shift(lv, origin, years, coords, N=20, L=50)
df = pd.concat([df, fb[fb.ID.isin(miss)]], ignore_index=True)
df.attrs["log"] = tlog.assign(note="temperature model inside cdd_hybrid")
return df