File size: 6,450 Bytes
6848dc2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Sun*+ 推論ラッパ。
 SunstarPlus.downscale(...)  : 観測なしダウンスケーリング (リード0, ERA5/再解析/NWP を地点へ)
 SunstarPlus.forecast(...)   : 観測同化 (時刻 t0 までの AMeDAS 観測 + 近傍局, リード 1/3/6/12/24h)
入力 fields: ERA5 互換の 0.25° 格子場 dict {変数名: (T,H,W)}。単位 = tp [mm/h], 気温/露点/skin [°C], 気圧 [hPa], 日射 [J/m2/h] (ERA5 の生単位)。
前後 >=24 h (観測特徴は >=200 h) の余白時刻を含めること。"""
import gzip, json, pickle
from pathlib import Path
import numpy as np, pandas as pd, lightgbm as lgb
from .features import *
from .obsfeats import obsfeats, neighbor_table, nb_mean, NB_NAMES, DB_KEYS

VARS = ["temp_c", "wind_u_ms", "wind_v_ms", "humidity_pct", "wind_speed_ms", "precip_mm"]
LABEL = {"temp_c": "気温 [°C]", "wind_u_ms": "風 u [m/s]", "wind_v_ms": "風 v [m/s]", "humidity_pct": "相対湿度 [%]", "wind_speed_ms": "風速 [m/s]", "precip_mm": "降水量 [mm/h]"}

def _post(var, x):
    if var == "humidity_pct": return np.clip(x, 0, 100)
    if var in ("precip_mm", "wind_speed_ms"): return np.maximum(x, 0)
    return x

class SunstarPlus:
    def __init__(self, root="."):
        self.root = Path(root); mdir = self.root / "models"
        self.cfg = json.load(open(mdir / "config.json"))
        self.models = {t: {v: [self._load(mdir / f) for f in self.cfg["models"][t][v]] for v in VARS} for t in "AB"}
        self.sigma = {}
        for t in "AB":
            for v, d in self.cfg.get("sigma", {}).get(t, {}).items():
                self.sigma[(t, v)] = dict(gbm=self._load(mdir / d["file"]), k=d["k"], ratio={int(k): x for k, x in d["ratio"].items()})
    @staticmethod
    def _load(p):
        p = Path(p)
        return lgb.Booster(model_str=gzip.open(p, "rt").read()) if p.suffix == ".gz" else lgb.Booster(model_file=str(p))
    # ------------------------------------------------------------------ helpers
    def _ens(self, models, X): return np.mean([m.predict(X) for m in models], 0)
    def _predict(self, task, X, base, lead, sigma, heldout):
        out = {}
        for v_i, var in enumerate(VARS):
            r = self._ens(self.models[task][var], X); mean = _post(var, base[:, v_i] + r)
            sg = None
            if sigma and (task, var) in self.sigma:
                d = self.sigma[(task, var)]; raw = np.maximum(d["gbm"].predict(np.concatenate([X, r[:, None]], 1)), 0.05) * np.sqrt(np.pi / 2) * d["k"]
                if heldout: raw = raw * d["ratio"].get(lead, 1.0)
                sg = np.maximum(raw, 0.05)
            out[var] = (mean, sg)
        return out
    # ------------------------------------------------------------------ public
    def downscale(self, times, fields, grid, stations, sigma=True, heldout=True):
        """times: DatetimeIndex (hourly UTC, 前後24h余白込み); fields: ERA5互換; grid: Grid; stations: DataFrame (stations_nationwide.csv 形式)
        returns {var: (mean (T,S), sigma (T,S) or None)}  (余白 24h は NaN になりやすいので使わないこと)
        heldout=True: 学習に使っていない地点向けに σ を拡大 (既知地点では False)"""
        ss = StaticSet(stations, grid); F, names, base, n_v2 = build_features(times, fields, ss)
        T, S, nf = F.shape; flag = (np.asarray(times) >= np.datetime64("2024-10-01")).astype(np.float32)
        X = np.concatenate([F.reshape(T * S, nf), np.repeat(flag, S)[:, None]], 1)
        B = np.stack([base["t2m"], base["u10"], base["v10"], base["rh"], base["spd10"], np.zeros_like(base["tp"])], 2).reshape(T * S, 6)
        res = self._predict("A", X, B, 0, sigma, heldout)
        return {v: (m.reshape(T, S), None if s is None else s.reshape(T, S)) for v, (m, s) in res.items()}
    def forecast(self, times, fields, grid, stations, obs, lead, neighbors=True, sigma=True, heldout=True):
        """obs: (T,S,7) 時刻 times に揃えた AMeDAS 実測 [気温,u,v,相対湿度,降水,風速,気圧(NaN可)] (欠測は NaN)。
        初期時刻 t0=times[i] の観測から times[i+lead] を予測。returns {var: (mean (T,S) 有効時刻 index, sigma)}。 t0 以降の観測は使わない。
        neighbors=True: 近傍局 (obs が有る他地点) の残差特徴を使う。stations に列 'has_obs' (bool) があればそれを近傍プールとする。"""
        ss = StaticSet(stations, grid); F, names, base, n_v2 = build_features(times, fields, ss)
        T, S, nf = F.shape; assert lead in (1, 3, 6, 12, 24)
        bb = dict(t2m=base["t2m"], d2m=base["d2m"], u10=base["u10"], v10=base["v10"], rh=base["rh"], spd10=base["spd10"])
        G, gnames, res = obsfeats(np.asarray(obs, np.float32), bb)
        dbase = np.stack([bb[k] for k in DB_KEYS], 2)
        pool = stations["has_obs"].values.astype(bool) if "has_obs" in stations else np.isfinite(obs[:, :, 0]).any(0)
        if neighbors:
            idx, w = neighbor_table(stations, pool)
            pk = obs[:, :, 4]; rr = [res["T"], res["U"], res["V"], res["RH"], res["SPD"]]
            nbf = []; wsum = None
            for r_ in rr:
                m0, den = nb_mean(r_, idx, w); nbf.append(m0); wsum = den if wsum is None else wsum
            nb6 = [nb_mean(roll_mean(r_, -5, 0), idx, w)[0] for r_ in rr]
            P0, _ = nb_mean(pk, idx, w); P3, _ = nb_mean(roll_mean(pk, -2, 0), idx, w)
            NB = np.stack(nbf + nb6 + [P0, P3, P3, wsum], 2)
        else: NB = np.full((T, S, len(NB_NAMES)), np.nan, np.float32)
        ti = np.arange(lead, T); t0 = ti - lead
        flag = (np.asarray(times)[ti] >= np.datetime64("2024-10-01")).astype(np.float32)
        parts = [F[ti].reshape(-1, nf), np.repeat(flag, S)[:, None], G[t0].reshape(len(ti) * S, -1),
                 (dbase[ti] - dbase[t0]).reshape(len(ti) * S, -1), np.full((len(ti) * S, 1), lead, np.float32), NB[t0].reshape(len(ti) * S, -1)]
        X = np.concatenate(parts, 1)
        B = np.stack([base["t2m"][ti], base["u10"][ti], base["v10"][ti], base["rh"][ti], base["spd10"][ti], np.zeros_like(base["tp"][ti])], 2).reshape(-1, 6)
        res_ = self._predict("B", X, B, lead, sigma, heldout)
        out = {}
        for v, (m, s) in res_.items():
            full = np.full((T, S), np.nan, np.float32); full[ti] = m.reshape(len(ti), S)
            sf = None
            if s is not None: sf = np.full((T, S), np.nan, np.float32); sf[ti] = s.reshape(len(ti), S)
            out[v] = (full, sf)
        return out