Datasets:
Download code/arima_prep.py from sleonca/sl-protostar-climate-ceviche: direct link, hf CLI and curl.
- Browser
- Download file 4.7 kB
-
https://huggingface.co/datasets/sleonca/sl-protostar-climate-ceviche/resolve/main/code/arima_prep.py
- Command line
-
hf download hf://datasets/sleonca/sl-protostar-climate-ceviche/code/arima_prep.py
-
curl -L -o arima_prep.py https://huggingface.co/datasets/sleonca/sl-protostar-climate-ceviche/resolve/main/code/arima_prep.py
4.7 kB
| """Step 2 of the ARIMA experiments: turn the valid annual history into regular series for ARIMA. | |
| ARIMA needs one value per year with no gaps. For each city x metric series, using only data | |
| up to the forecast origin (never after 2018): | |
| * keep the window train_start..origin; | |
| * invalid years (official 10-day rule, from common.long_valid) are NaN; | |
| * the series runs from its first to its last valid year inside the window; interior gaps are | |
| filled by linear interpolation (course week 2). Nothing is extrapolated: if the last valid | |
| year is before `origin`, the series simply ends there and the model forecasts further ahead; | |
| * a series is "weak" when more than 20 % of its years are imputed (or it has fewer than | |
| MIN_OBS valid years). Weak series use the fallback model (30-year average) in models_arima. | |
| Run as a script to print the imputation summary for the 1969-2018 window: | |
| python code/arima_prep.py | |
| """ | |
| from dataclasses import dataclass | |
| import numpy as np | |
| import pandas as pd | |
| from common import CUTOFF_YEAR, METRICS, load_annual, long_valid | |
| TRAIN_STARTS = (1949, 1969, 1979) | |
| MAX_IMPUTED_FRAC = 0.20 | |
| MIN_OBS = 15 | |
| # The six cities used for EDA, ACF/PACF and residual diagnostics. | |
| EDA_CITIES = { | |
| "USW00094823": "Pittsburgh", | |
| "USW00024233": "Seattle", | |
| "USW00023183": "Phoenix", | |
| "USW00012839": "Miami", | |
| "USW00014922": "Minneapolis", | |
| "USW00003017": "Denver", | |
| } | |
| class Series: | |
| """One regular annual series ready for ARIMA.""" | |
| ID: str | |
| metric: str | |
| years: np.ndarray # consecutive years, first..last valid year in the window | |
| y: np.ndarray # values (interior gaps linearly interpolated) | |
| n_imputed: int | |
| weak: bool | |
| def last_year(self) -> int: | |
| return int(self.years[-1]) if len(self.years) else -1 | |
| def wide_window(lv: pd.DataFrame, metric: str, origin: int, train_start: int) -> pd.DataFrame: | |
| """cities x years (train_start..origin) matrix of valid values; NaN = invalid or missing.""" | |
| if origin > CUTOFF_YEAR: | |
| raise RuntimeError(f"origin {origin} is after {CUTOFF_YEAR}: data rule violated") | |
| w = lv[(lv.metric == metric) & (lv.Year >= train_start) & (lv.Year <= origin)] | |
| w = w.assign(value=w.value.where(w.valid)) | |
| W = w.pivot(index="ID", columns="Year", values="value") | |
| return W.reindex(columns=range(train_start, origin + 1)) | |
| def regularize(row: pd.Series) -> tuple[np.ndarray, np.ndarray, int]: | |
| """Trim to first..last valid year, linearly interpolate interior gaps (no extrapolation).""" | |
| ok = row.notna().to_numpy() | |
| if not ok.any(): | |
| return np.array([], int), np.array([]), 0 | |
| i0, i1 = np.argmax(ok), len(ok) - 1 - np.argmax(ok[::-1]) | |
| r = row.iloc[i0:i1 + 1] | |
| n_imp = int(r.isna().sum()) | |
| y = r.interpolate(method="linear", limit_area="inside").to_numpy(float) | |
| return r.index.to_numpy(int), y, n_imp | |
| def prepare(lv: pd.DataFrame, metric: str, origin: int, train_start: int) -> dict[str, Series]: | |
| """All series of one metric, regularized for ARIMA, keyed by city ID.""" | |
| W = wide_window(lv, metric, origin, train_start) | |
| out = {} | |
| for cid, row in W.iterrows(): | |
| years, y, n_imp = regularize(row) | |
| n = len(y) | |
| weak = n - n_imp < MIN_OBS or (n > 0 and n_imp / n > MAX_IMPUTED_FRAC) | |
| out[cid] = Series(cid, metric, years, y, n_imp, bool(weak)) | |
| return out | |
| def imputation_table(lv: pd.DataFrame, origin: int, train_start: int) -> pd.DataFrame: | |
| rows = [] | |
| for m in METRICS: | |
| for s in prepare(lv, m, origin, train_start).values(): | |
| rows.append(dict(ID=s.ID, metric=m, first=s.years[0] if len(s.years) else None, | |
| last=s.last_year, n_years=len(s.y), n_imputed=s.n_imputed, | |
| frac_imputed=s.n_imputed / max(len(s.y), 1), weak=s.weak)) | |
| return pd.DataFrame(rows) | |
| if __name__ == "__main__": | |
| from common import ROOT | |
| lv = long_valid(load_annual()) | |
| out = ROOT / "results" | |
| out.mkdir(exist_ok=True) | |
| tabs = [] | |
| for ts in TRAIN_STARTS: | |
| t = imputation_table(lv, CUTOFF_YEAR, ts).assign(train_start=ts) | |
| tabs.append(t) | |
| print(f"\nWindow {ts}-{CUTOFF_YEAR}") | |
| print(t.groupby("metric").agg(series=("ID", "size"), imputed_years=("n_imputed", "sum"), | |
| with_any_gap=("n_imputed", lambda s: (s > 0).sum()), | |
| ends_before_2018=("last", lambda s: (s < CUTOFF_YEAR).sum()), | |
| weak=("weak", "sum")).to_string()) | |
| pd.concat(tabs).to_csv(out / "arima_imputation.csv", index=False) | |
| print(f"\nwrote {out / 'arima_imputation.csv'}") | |