File size: 6,940 Bytes
c0058c4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
"""Learned forecaster: a model trained across cities and past forecast origins.

For a forecast origin o and horizon h (1..7), the target is how far year o+h lands from the
city's 30-year mean, in units of the city's 30-year standard deviation:

    z = (value[o+h] - mean30[o]) / sd30[o]

Features, all computed from years <= o:
    own_k   recent anomaly of the city: mean of last k years minus mean30, / sd30 (k = 1,3,5,10,15,20)
    reg_k   the same, averaged over cities within RADIUS_KM (regional signal, less noisy)
    nat_k   the same, averaged over all 210 cities
    slope*  pooled regional and own trends over 30 and 50 years, times the lead time
            from the 30-year window centre (h + 14.5), / sd30
    h       horizon

Training rows for a test origin O come only from origins o with o + 7 <= O, so every target
the model learns from is itself in the past at O. The prediction is mean30 + sd30 * z_hat.
"""

from __future__ import annotations

import numpy as np
import pandas as pd

import climate_lib as cl

RADIUS_KM = 1000
WINDOWS = (1, 3, 5, 10, 15, 20)
HORIZON = 7
FIRST_TRAIN_ORIGIN = 1940


def neighbour_weights(meta: pd.DataFrame, cities, radius_km=RADIUS_KM) -> np.ndarray:
    lat = np.radians(meta.loc[cities, "Lat"].values)
    lon = np.radians(meta.loc[cities, "Lon"].values)
    d = 6371 * np.arccos(np.clip(
        np.sin(lat)[:, None] * np.sin(lat)[None, :]
        + np.cos(lat)[:, None] * np.cos(lat)[None, :] * np.cos(lon[:, None] - lon[None, :]), -1, 1))
    return (d <= radius_km).astype(float)


def _nanmean_w(W: np.ndarray, X: np.ndarray) -> np.ndarray:
    """Weighted mean over cities (rows of X) ignoring NaN; W is cities x cities."""
    ok = ~np.isnan(X)
    return (W @ np.where(ok, X, 0)) / np.maximum(W @ ok, 1e-9)


def _slope(X: np.ndarray, x: np.ndarray) -> np.ndarray:
    """OLS slope per row of X (cities x years) ignoring NaN."""
    ok = ~np.isnan(X)
    n = ok.sum(1)
    xm = (ok * x).sum(1) / np.maximum(n, 1)
    ym = np.nansum(X, 1) / np.maximum(n, 1)
    dx = np.where(ok, x[None, :] - xm[:, None], 0)
    s = (dx * np.where(ok, X - ym[:, None], 0)).sum(1) / np.maximum((dx ** 2).sum(1), 1e-9)
    return np.where(n >= 10, s, 0.0)


class FeatureBuilder:
    """Builds features for every (city, origin, horizon) of one metric. Station offsets are
    recomputed at each origin with data up to that origin only."""

    def __init__(self, panel, meta, metric, adjust_stations=True):
        self.panel, self.meta, self.metric, self.adjust = panel, meta, metric, adjust_stations
        self.full = cl.wide(panel, metric, cl.CUTOFF)
        self.cities = self.full.index
        self.W = neighbour_weights(meta, self.cities)
        self.Wall = np.ones_like(self.W)
        self._cache = {}

    def origin_block(self, o: int) -> pd.DataFrame:
        if o in self._cache:
            return self._cache[o]
        w = self.full.loc[:, [y for y in self.full.columns if y <= o]]
        if self.adjust:
            w = w + cl.segment_offsets(self.panel, self.metric, o)
        last = w.loc[:, [y for y in w.columns if y > o - 50]]
        years = np.array(last.columns, float)
        X = last.values
        w30 = X[:, years > o - 30]
        mean30 = np.nanmean(w30, 1)
        sd30 = np.nanstd(w30, 1)
        n30 = (~np.isnan(w30)).sum(1)
        sd = np.where(sd30 > 1e-6, sd30, np.nan)
        A = (X - mean30[:, None]) / sd[:, None]  # standardised anomalies
        A_reg, A_nat = _nanmean_w(self.W, A), _nanmean_w(self.Wall, A)
        f = {"mean30": mean30, "sd30": sd30, "n30": n30}
        for k in WINDOWS:
            sel = years > o - k
            f[f"own_{k}"] = np.nanmean(A[:, sel], 1)
            f[f"reg_{k}"] = np.nanmean(A_reg[:, sel], 1)
            f[f"nat_{k}"] = np.nanmean(A_nat[:, sel], 1)
        for k in (30, 50):
            sel = years > o - k
            f[f"own_slope{k}"] = _slope(A[:, sel], years[sel])
            f[f"reg_slope{k}"] = _slope(A_reg[:, sel], years[sel])
        block = pd.DataFrame(f, index=self.cities)
        for c in [c for c in block.columns if c.startswith(("own_", "reg_", "nat_"))]:
            block[c] = block[c].fillna(0.0)
        self._cache[o] = block
        return block

    def rows(self, origins, with_target=True) -> pd.DataFrame:
        out = []
        for o in origins:
            b = self.origin_block(o)
            for h in range(1, HORIZON + 1):
                r = b.copy()
                r["h"] = h
                lead = h + 14.5
                for c in [c for c in b.columns if "slope" in c]:
                    r[c + "_x_lead"] = b[c] * lead
                r["origin"], r["year"] = o, o + h
                if with_target:
                    if o + h > cl.CUTOFF:
                        continue
                    r["truth"] = self.full[o + h]
                    r["z"] = (r["truth"] - r["mean30"]) / r["sd30"]
                out.append(r.reset_index().rename(columns={"index": "city_id", "ID": "city_id"}))
        return pd.concat(out, ignore_index=True)


FEATURES = ([f"{s}_{k}" for s in ("own", "reg", "nat") for k in WINDOWS]
            + [f"{s}_slope{k}_x_lead" for s in ("own", "reg") for k in (30, 50)])


def make_ridge(alpha=10.0):
    from sklearn.linear_model import Ridge
    return Ridge(alpha=alpha)


def make_gbm():
    from sklearn.ensemble import HistGradientBoostingRegressor
    return HistGradientBoostingRegressor(loss="absolute_error", max_iter=300, learning_rate=0.03,
                                         max_leaf_nodes=15, min_samples_leaf=200, random_state=0)


def f_learned(panel, meta, origin, years, *, make_model=make_ridge, metrics=cl.METRICS,
              builders=None, clip_z=4.0, return_models=False, train_span=None, features=None):
    """Fit one model per metric on origins FIRST_TRAIN_ORIGIN..origin-7 (or only the last
    `train_span` of them), predict origin+h."""
    features = features or FEATURES
    preds, models = [], {}
    for m in metrics:
        fb = builders[m] if builders else FeatureBuilder(panel, meta, m)
        start = FIRST_TRAIN_ORIGIN if train_span is None else origin - HORIZON + 1 - train_span
        train = fb.rows(range(start, origin - HORIZON + 1))
        train = train[(train.n30 >= 10) & train.z.notna() & np.isfinite(train.z)]
        train = train[train.z.abs() <= clip_z]
        model = make_model().fit(train[features], train.z)
        models[m] = model
        test = fb.rows([origin], with_target=False)
        test = test[test.year.isin(years)]
        z = model.predict(test[features])
        val = test.mean30 + test.sd30.fillna(0) * z
        if m in ("cdd", "total_precip_in"):
            val = val.clip(lower=0)
        preds.append(pd.DataFrame({"city_id": test.city_id, "year": test.year, "metric": m,
                                   "predicted_value": val.values}))
    out = pd.concat(preds, ignore_index=True)
    return (out, models) if return_models else out