File size: 5,270 Bytes
4897f1f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 | """Ridge regression: one linear model per horizon, the simplest model that uses weather forecasts.
Two variants, to measure what the extra features buy:
- `small`: five inputs per horizon. The current reading and the 24-hour mean (the persistence signal), plus
the forecast inversion strength, wind, and precipitation for the 24 hours ending at the target hour.
- `full`: every gold feature, with the station one-hot encoded and hour, day of year, and wind direction as
sin/cos pairs (a linear model can't use an angle or a station code directly).
PM2.5 is skewed, so the target and the PM2.5 inputs are log1p-transformed: the model is linear in log space,
which makes a weather effect multiplicative (an inversion doubles a high reading's growth, not a low one's).
Missing inputs are filled with the training median, plus an indicator column. Features are standardized, so
the coefficients are comparable: `coefficients()` shows them for the write-up.
"""
import json
from pathlib import Path
import joblib
import numpy as np
import pandas as pd
from sklearn.impute import SimpleImputer
from sklearn.linear_model import Ridge
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from .common import HORIZONS, LABELS, PREDS, feature_columns
ALPHA = 1.0
SMALL = ["pm25_ugm3", "pm25_mean_24h", "wx{h}_inversion_mean_24h", "wx{h}_wind_mean_24h", "wx{h}_precip_24h_mm"]
CYCLIC = {"hour_local": 24, "doy_local": 366}
def _is_pm(c):
return c.startswith(("pm25_", "region_pm25")) and c not in ("pm25_obs_24h", "pm25_change_24h", "pm25_std_24h")
class LinearForecaster:
def __init__(self, variant="small", alpha=ALPHA):
self.cfg = {"variant": variant, "alpha": alpha}
self.models = {}
self.features = {}
self.stations = None
def _matrix(self, df, h):
"""The design matrix for horizon h, in a fixed column order."""
if self.cfg["variant"] == "small":
cols = [c.format(h=h) for c in SMALL]
X = df[cols].astype("float64")
else:
# A horizon's model sees only its own weather block (wx24_* for t+24), like the small variant.
cols = [c for c in feature_columns(df)
if c != "station_id" and (not c.startswith("wx") or c.startswith(f"wx{h}_"))
and (not c.startswith("fireworks_") or c == f"fireworks_t{h}")]
X = df[cols].astype("float64")
for c, period in CYCLIC.items():
X[f"{c}_sin"], X[f"{c}_cos"] = np.sin(2 * np.pi * X[c] / period), np.cos(2 * np.pi * X[c] / period)
rad = np.deg2rad(X[f"wx{h}_wind_dir_deg"])
X[f"wx{h}_wind_dir_sin"], X[f"wx{h}_wind_dir_cos"] = np.sin(rad), np.cos(rad)
X = X.drop(columns=[*CYCLIC, f"wx{h}_wind_dir_deg"])
stations = pd.Categorical(df["station_id"], categories=self.stations)
X = pd.concat([X, pd.get_dummies(stations, prefix="station", dtype="float64").set_index(X.index)], axis=1)
for c in X.columns:
if _is_pm(c):
X[c] = np.log1p(X[c].clip(lower=0))
return X
def fit(self, train):
self.stations = sorted(train["station_id"].unique())
for h, label in zip(HORIZONS, LABELS):
rows = train[train[label].notna()]
X = self._matrix(rows, h)
self.features[h] = list(X.columns)
model = make_pipeline(SimpleImputer(strategy="median", add_indicator=True, keep_empty_features=True),
StandardScaler(), Ridge(alpha=self.cfg["alpha"]))
self.models[h] = model.fit(X.to_numpy(), np.log1p(rows[label].clip(lower=0)).to_numpy())
return self
def predict(self, df):
return pd.DataFrame({p: np.expm1(self.models[h].predict(self._matrix(df, h).to_numpy())).clip(min=0)
for h, p in zip(HORIZONS, PREDS)}, index=df.index)
def coefficients(self):
"""Standardized coefficients per horizon (log-space effect of a one-standard-deviation change)."""
out = {}
for h, model in self.models.items():
imputer, ridge = model.named_steps["simpleimputer"], model.named_steps["ridge"]
names = self.features[h] + [f"{self.features[h][i]}_missing" for i in imputer.indicator_.features_]
out[h] = pd.Series(ridge.coef_, index=[n.replace(f"wx{h}_", "wx_") for n in names])
return pd.DataFrame(out).sort_values(HORIZONS[0], key=abs, ascending=False)
def save(self, path):
path = Path(path)
path.mkdir(parents=True, exist_ok=True)
for h, model in self.models.items():
joblib.dump(model, path / f"t{h}.joblib")
(path / "meta.json").write_text(json.dumps({
"cfg": self.cfg, "stations": self.stations, "features": {str(h): f for h, f in self.features.items()},
}, indent=2))
@classmethod
def load(cls, path):
path = Path(path)
meta = json.loads((path / "meta.json").read_text())
m = cls(**meta["cfg"])
m.stations, m.features = meta["stations"], {int(h): f for h, f in meta["features"].items()}
m.models = {h: joblib.load(path / f"t{h}.joblib") for h in HORIZONS}
return m
|