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