Datasets:
Download code/models_arima.py from sleonca/sl-protostar-climate-ceviche: direct link, hf CLI and curl.
- Browser
- Download file 9.28 kB
-
https://huggingface.co/datasets/sleonca/sl-protostar-climate-ceviche/resolve/main/code/models_arima.py
- Command line
-
hf download hf://datasets/sleonca/sl-protostar-climate-ceviche/code/models_arima.py
-
curl -L -o models_arima.py https://huggingface.co/datasets/sleonca/sl-protostar-climate-ceviche/resolve/main/code/models_arima.py
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 | |