Download _backup/scripts/30_train_ca.py from TrendeX90/ca-cube: direct link, hf CLI and curl.
- Browser
- Download file 17.3 kB
-
https://huggingface.co/datasets/TrendeX90/ca-cube/resolve/main/_backup/scripts/30_train_ca.py
- Command line
-
hf download hf://datasets/TrendeX90/ca-cube/_backup/scripts/30_train_ca.py
-
curl -L -o 30_train_ca.py https://huggingface.co/datasets/TrendeX90/ca-cube/resolve/main/_backup/scripts/30_train_ca.py
17.3 kB
| """Train/evaluate expected greenness v2-ca exactly as locked in configs/model_v2_ca.yaml. | |
| python ca/30_train_ca.py --git-commit <hash> | |
| Training/evaluation on a 150k-cell sample; out-of-fold predictions for every eligible cell. | |
| Writes runs/v2_ca/: metrics.json, model_ca.ubj, feature_schema.json, conformal.json, climatology / weather | |
| climatology parquet, summer_residual.npy (cells x years, residual vs all-years climatology), expected_block.parquet. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| import time | |
| from pathlib import Path | |
| import numpy as np | |
| import pandas as pd | |
| import pyarrow.parquet as pq | |
| import xgboost as xgb | |
| from sklearn.linear_model import Ridge | |
| from sklearn.model_selection import GroupKFold | |
| CUBE = Path("/root/trendex-ca/data/cube") | |
| RUN = Path("/root/trendex-ca/runs/v2_ca") | |
| YEARS = np.arange(2001, 2026) | |
| MONTHS = np.arange(5, 10) | |
| CUBE_MONTHS = list(range(4, 11)) | |
| STATIC = ["elev_mean", "elev_std", "slope_mean", "steep_share", "aspect_sin", "aspect_cos", "tpi", | |
| "grass_frac", "barren_frac", "crop_frac", "lc_type1", "lat"] | |
| WEATHER = ["precip_m", "precip_2m", "precip_winter", "tair_m", "tair_prev", "soil_m", "swe_apr"] | |
| FEATURES = STATIC + ["month", "clim_ndvi"] + WEATHER | |
| FIXED = {"tree_method": "hist", "device": "cuda", "objective": "reg:squarederror"} | |
| SEEDS = [0, 1, 2] | |
| N_SAMPLE = 150_000 | |
| def log(m): | |
| print(f"[{time.strftime('%H:%M:%S')}] {m}", flush=True) | |
| def load_arrays(cells_all: pd.DataFrame, elig: np.ndarray) -> dict: | |
| """(n_elig, 25 years, 7 months Apr-Oct) arrays straight from the yearly files (rows = month blocks x all cells).""" | |
| n_all, idx = len(cells_all), np.nonzero(elig)[0] | |
| shape = (len(idx), len(YEARS), len(CUBE_MONTHS)) | |
| arr = {k: np.full(shape, np.nan, "float32") for k in ["ndvi", "precip", "precip_winter", "tair", "soil_moist", "swe"]} | |
| for j, yr in enumerate(YEARS): | |
| t = pq.read_table(CUBE / "monthly" / f"year={yr}" / "part.parquet", | |
| columns=["month", "ndvi", "ndvi_ok", "precip", "precip_winter", "tair", "soil_moist", "swe"]) | |
| months = t.column("month").to_numpy() | |
| assert len(months) % n_all == 0, "monthly file is not month-blocks x all cells" | |
| ok = t.column("ndvi_ok").to_numpy(zero_copy_only=False) | |
| cols = {k: t.column(k).to_numpy(zero_copy_only=False).astype("float32") for k in arr} | |
| cols["ndvi"] = np.where(ok, cols["ndvi"], np.nan) | |
| for b in range(len(months) // n_all): | |
| mo = int(months[b * n_all]) | |
| mi = CUBE_MONTHS.index(mo) | |
| for k in arr: | |
| arr[k][:, j, mi] = cols[k][b * n_all:(b + 1) * n_all][idx] | |
| log(f"loaded {yr}") | |
| return arr | |
| def build_features(cells: pd.DataFrame, arr: dict, run: Path) -> dict: | |
| mi = [CUBE_MONTHS.index(m) for m in MONTHS] | |
| prev = [CUBE_MONTHS.index(m - 1) for m in MONTHS] | |
| take = lambda a, ix: a[:, :, ix] # noqa: E731 | |
| anom = lambda x: x - np.nanmean(x, axis=1, keepdims=True) # noqa: E731 | |
| with np.errstate(all="ignore"): | |
| raw_m = {"precip_m": take(arr["precip"], mi), "precip_2m": take(arr["precip"], mi) + take(arr["precip"], prev), | |
| "tair_m": take(arr["tair"], mi), "tair_prev": take(arr["tair"], prev), "soil_m": take(arr["soil_moist"], mi)} | |
| raw_y = {"precip_winter": arr["precip_winter"][:, :, CUBE_MONTHS.index(5)], | |
| "swe_apr": arr["swe"][:, :, CUBE_MONTHS.index(4)]} | |
| f = {k: anom(v) for k, v in raw_m.items()} | |
| f |= {k: np.repeat(anom(v)[:, :, None], len(MONTHS), axis=2) for k, v in raw_y.items()} | |
| wc = pd.concat([pd.DataFrame({"cell_id": cells["cell_id"].values, "month": int(mo)} | | |
| {f"{k}_mean": np.nanmean(v[:, :, j], axis=1).astype("float32") for k, v in raw_m.items()} | | |
| {f"{k}_mean": np.nanmean(v, axis=1).astype("float32") for k, v in raw_y.items()}) | |
| for j, mo in enumerate(MONTHS)], ignore_index=True) | |
| wc.to_parquet(run / "weather_climatology.parquet", index=False) | |
| f["ndvi"] = take(arr["ndvi"], mi) | |
| return f | |
| def clim_fold(ndvi, train_years): | |
| tm = np.isin(YEARS, train_years)[None, :, None] | |
| fin = np.isfinite(ndvi) | |
| s = np.nansum(np.where(tm, ndvi, np.nan), axis=1, keepdims=True) | |
| n = np.sum(fin & tm, axis=1, keepdims=True).astype("float32") | |
| own = np.where(fin & tm, ndvi, 0.0) | |
| with np.errstate(all="ignore"): | |
| return ((s - own) / (n - (fin & tm))).astype("float32") | |
| def matrix(f: dict, cells: pd.DataFrame, rows: np.ndarray, years: np.ndarray, clim: np.ndarray): | |
| """Feature matrix for cell positions `rows`, the given years and May-Sep. Returns X, y, meta.""" | |
| yi = np.nonzero(np.isin(YEARS, years))[0] | |
| sub = lambda a: a[rows][:, yi].reshape(-1) # noqa: E731 | |
| nm = len(MONTHS) | |
| shape = (len(rows), len(yi), nm) | |
| cols = {} | |
| for k in STATIC: | |
| cols[k] = np.broadcast_to(cells[k].values.astype("float32")[rows][:, None, None], shape).reshape(-1) | |
| cols["month"] = np.broadcast_to(MONTHS.astype("float32")[None, None, :], shape).reshape(-1) | |
| cols["clim_ndvi"] = sub(clim) | |
| for k in WEATHER: | |
| cols[k] = sub(f[k]) | |
| X = np.column_stack([cols[k] for k in FEATURES]).astype("float32") | |
| ndvi = sub(f["ndvi"]) | |
| y = ndvi - cols["clim_ndvi"] | |
| meta = {"row": np.broadcast_to(rows[:, None, None], shape).reshape(-1), | |
| "year": np.broadcast_to(YEARS[yi][None, :, None], shape).reshape(-1), | |
| "month": cols["month"].astype("int8"), "ndvi": ndvi} | |
| return X, y.astype("float32"), meta | |
| class RidgeModel: | |
| def __init__(self, alpha): | |
| self.alpha = alpha | |
| def fit(self, X, y): | |
| self.med = np.nanmedian(X, axis=0) | |
| Z = np.where(np.isnan(X), self.med, X) | |
| self.mu, self.sd = Z.mean(0), Z.std(0) | |
| self.sd[self.sd == 0] = 1 | |
| self.r = Ridge(alpha=self.alpha).fit((Z - self.mu) / self.sd, y) | |
| return self | |
| def predict(self, X): | |
| Z = np.where(np.isnan(X), self.med, X) | |
| return self.r.predict((Z - self.mu) / self.sd) | |
| def fit_xgb(X, y, params, n_est, seed, Xv=None, yv=None): | |
| m = xgb.XGBRegressor(**FIXED, **params, n_estimators=n_est, random_state=seed, | |
| early_stopping_rounds=50 if Xv is not None else None) | |
| m.fit(X, y, eval_set=[(Xv, yv)] if Xv is not None else None, verbose=False) | |
| return m | |
| def boot(sse_a, sse_b, rng, n=2000): | |
| idx = rng.integers(0, len(sse_a), size=(n, len(sse_a))) | |
| dist = 1 - sse_a[idx].sum(1) / sse_b[idx].sum(1) | |
| return {"point": float(1 - sse_a.sum() / sse_b.sum()), "ci_lo": float(np.quantile(dist, 0.025)), | |
| "ci_hi": float(np.quantile(dist, 0.975)), "units": int(len(sse_a))} | |
| def score(y, preds, units, cuts, rng): | |
| out = {"n_rows": int(len(y))} | |
| sse = {} | |
| for k, p in preds.items(): | |
| e = y - p | |
| t, q = np.digitize(y, cuts), np.digitize(p, cuts) | |
| out[k] = {"rmse": float(np.sqrt(np.mean(e ** 2))), "mae": float(np.mean(np.abs(e))), | |
| "anomaly_corr": float(np.corrcoef(y, p)[0, 1]) if np.std(p) > 0 else None, | |
| "tercile_bacc": float(np.mean([np.mean(q[t == c] == c) for c in range(3) if np.any(t == c)]))} | |
| sse[k] = pd.Series(e ** 2).groupby(units).sum().values | |
| out["skill_xgb_vs_ridge"] = boot(sse["xgb"], sse["ridge"], rng) | |
| out["skill_xgb_vs_clim"] = boot(sse["xgb"], sse["clim"], rng) | |
| out["skill_ridge_vs_clim"] = boot(sse["ridge"], sse["clim"], rng) | |
| return out | |
| def finite(X, y, *extra): | |
| ok = np.isfinite(y) | |
| return (X[ok], y[ok]) + tuple(e[ok] for e in extra) | |
| def main(): | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument("--git-commit", required=True) | |
| a = ap.parse_args() | |
| RUN.mkdir(parents=True, exist_ok=True) | |
| rng = np.random.default_rng(0) | |
| metrics = {"protocol": "configs/model_v2_ca.yaml", "git_commit": a.git_commit, "features": FEATURES} | |
| cells_all = pd.read_parquet(CUBE / "cells.parquet") | |
| elig = cells_all["mask_reason"].isna().values | |
| cells = cells_all[elig].reset_index(drop=True) | |
| arr = load_arrays(cells_all, elig) | |
| f = build_features(cells, arr, RUN) | |
| del arr | |
| n = len(cells) | |
| sample = np.sort(np.random.default_rng(0).choice(n, size=min(N_SAMPLE, n), replace=False)) | |
| sb = ((cells["block_row"].values // 3).astype(np.int64) * 100000 + cells["block_col"].values // 3) | |
| metrics["data"] = {"eligible_cells": int(n), "sample_cells": int(len(sample)), | |
| "by_country_eligible": cells["country"].value_counts().astype(int).to_dict()} | |
| log(f"eligible cells {n}, sample {len(sample)}") | |
| # --- tuning on the inner split (sample only) | |
| c_in = clim_fold(f["ndvi"], np.arange(2001, 2016)) | |
| Xi, yi_ = finite(*matrix(f, cells, sample, np.arange(2001, 2016), c_in)[:2]) | |
| Xv, yv, mv = matrix(f, cells, sample, np.arange(2016, 2020), c_in) | |
| Xv, yv, mv_month = finite(Xv, yv, mv["month"]) | |
| ridge_rmse = {al: float(np.sqrt(np.mean((yv - RidgeModel(al).fit(Xi, yi_).predict(Xv)) ** 2))) | |
| for al in [1, 10, 100, 1000, 10000]} | |
| alpha = min(ridge_rmse, key=ridge_rmse.get) | |
| import optuna | |
| optuna.logging.set_verbosity(optuna.logging.WARNING) | |
| def objective(tr): | |
| p = {"max_depth": tr.suggest_int("max_depth", 4, 10), | |
| "learning_rate": tr.suggest_float("learning_rate", 0.03, 0.2, log=True), | |
| "min_child_weight": tr.suggest_float("min_child_weight", 1, 200, log=True), | |
| "subsample": tr.suggest_float("subsample", 0.5, 1.0), | |
| "colsample_bytree": tr.suggest_float("colsample_bytree", 0.5, 1.0), | |
| "reg_lambda": tr.suggest_float("reg_lambda", 1e-3, 30, log=True)} | |
| m = fit_xgb(Xi, yi_, p, 2000, 0, Xv, yv) | |
| tr.set_user_attr("n_est", int(m.best_iteration) + 1) | |
| return float(np.sqrt(np.mean((yv - m.predict(Xv)) ** 2))) | |
| st = optuna.create_study(direction="minimize", sampler=optuna.samplers.TPESampler(seed=0)) | |
| st.optimize(objective, n_trials=20, timeout=600) | |
| best, n_est = st.best_params, st.best_trial.user_attrs["n_est"] | |
| metrics["tuning"] = {"trials": len(st.trials), "best_params": best, "n_estimators": n_est, | |
| "inner_rmse_xgb": st.best_value, "ridge_alpha": alpha, "inner_rmse_ridge": ridge_rmse} | |
| log(f"tuning {len(st.trials)} trials, xgb {st.best_value:.4f} vs ridge {ridge_rmse[alpha]:.4f}, n_est {n_est}") | |
| cuts = np.quantile(yi_, [1 / 3, 2 / 3]) | |
| res_in = yv - fit_xgb(Xi, yi_, best, n_est, 0).predict(Xv) | |
| conf = {int(mo): [float(np.quantile(res_in[mv_month == mo], q)) for q in (0.1, 0.9)] for mo in MONTHS} | |
| del Xi, yi_, Xv, yv | |
| # --- temporal test | |
| c_t = clim_fold(f["ndvi"], np.arange(2001, 2020)) | |
| Xtr, ytr = finite(*matrix(f, cells, sample, np.arange(2001, 2020), c_t)[:2]) | |
| Xte, yte, mte = matrix(f, cells, sample, np.arange(2020, 2026), c_t) | |
| Xte, yte, te_year, te_month = finite(Xte, yte, mte["year"], mte["month"]) | |
| ridge = RidgeModel(alpha).fit(Xtr, ytr) | |
| p_r = ridge.predict(Xte) | |
| ps, seed_skill = [], [] | |
| for s in SEEDS: | |
| p = fit_xgb(Xtr, ytr, best, n_est, s).predict(Xte) | |
| ps.append(p) | |
| seed_skill.append(float(1 - np.mean((yte - p) ** 2) / np.mean((yte - p_r) ** 2))) | |
| p_x = np.mean(ps, axis=0) | |
| temporal = score(yte, {"xgb": p_x, "ridge": p_r, "clim": np.zeros_like(yte)}, te_year, cuts, rng) | |
| temporal["seed_skill_vs_ridge"] = {"values": seed_skill, "mean": float(np.mean(seed_skill)), "sd": float(np.std(seed_skill))} | |
| lo = np.array([conf[int(m)][0] for m in te_month]); hi = np.array([conf[int(m)][1] for m in te_month]) | |
| temporal["conformal_coverage_p10_p90"] = float(np.mean(((yte - p_x) >= lo) & ((yte - p_x) <= hi))) | |
| metrics["temporal_test"] = temporal | |
| log(f"temporal skill vs ridge {temporal['skill_xgb_vs_ridge']}") | |
| del Xtr, ytr, Xte, yte | |
| # --- spatial test (sample, all years, superblock groups) | |
| c_all = clim_fold(f["ndvi"], YEARS) | |
| Xa, ya, ma = matrix(f, cells, sample, YEARS, c_all) | |
| Xa, ya, rows_a = finite(Xa, ya, ma["row"]) | |
| groups = sb[rows_a] | |
| preds = {"xgb": np.zeros_like(ya), "ridge": np.zeros_like(ya)} | |
| for itr, ite in GroupKFold(5).split(Xa, groups=groups): | |
| preds["xgb"][ite] = fit_xgb(Xa[itr], ya[itr], best, n_est, 0).predict(Xa[ite]) | |
| preds["ridge"][ite] = RidgeModel(alpha).fit(Xa[itr], ya[itr]).predict(Xa[ite]) | |
| preds["clim"] = np.zeros_like(ya) | |
| spatial = score(ya, preds, groups, cuts, rng) | |
| metrics["spatial_test"] = spatial | |
| log(f"spatial skill vs ridge {spatial['skill_xgb_vs_ridge']}") | |
| passed = temporal["skill_xgb_vs_ridge"]["ci_lo"] > 0 and spatial["skill_xgb_vs_ridge"]["ci_lo"] > 0 | |
| chosen = "xgb" if passed else "ridge" | |
| metrics["gate"] = {"rule": "CI lower bound of skill_xgb_vs_ridge > 0 on temporal AND spatial tests", | |
| "passed": bool(passed), "shipped_model": chosen} | |
| log(f"GATE passed={passed} -> {chosen}") | |
| # --- production model (sample, all years) + importance | |
| prod = fit_xgb(Xa, ya, best, n_est, 0) if chosen == "xgb" else RidgeModel(alpha).fit(Xa, ya) | |
| if chosen == "xgb": | |
| booster = prod.get_booster() | |
| booster.feature_names = FEATURES | |
| booster.save_model(RUN / "model_ca.ubj") | |
| sel = np.random.default_rng(1).choice(len(Xa), size=min(200_000, len(Xa)), replace=False) | |
| contrib = booster.predict(xgb.DMatrix(Xa[sel], feature_names=FEATURES), pred_contribs=True) | |
| metrics["feature_importance_mean_abs"] = dict(sorted(zip(FEATURES, np.abs(contrib[:, :-1]).mean(0).round(6).tolist()), | |
| key=lambda kv: -kv[1])) | |
| del Xa, ya | |
| # --- out-of-fold for ALL eligible cells (5 year blocks), residual vs all-years climatology | |
| clim_all = np.nanmean(f["ndvi"], axis=1, keepdims=True) # (n, 1, 5) | |
| summer_res = np.full((n, len(YEARS)), np.nan, "float32") | |
| bcode, buniq = pd.factorize(cells["block_id"]) | |
| nb = len(buniq) | |
| acc = {k: np.zeros((nb, len(YEARS), len(MONTHS))) for k in ("observed", "expected", "residual", "n")} | |
| all_rows = np.arange(n) | |
| summer_idx = [list(MONTHS).index(m) for m in (6, 7, 8)] | |
| for blk in [np.arange(s, s + 5) for s in (2001, 2006, 2011, 2016, 2021)]: | |
| trn = np.setdiff1d(YEARS, blk) | |
| cf = clim_fold(f["ndvi"], trn) | |
| Xs, ys = finite(*matrix(f, cells, sample, trn, cf)[:2]) | |
| model = fit_xgb(Xs, ys, best, n_est, 0) if chosen == "xgb" else RidgeModel(alpha).fit(Xs, ys) | |
| del Xs, ys | |
| for chunk in np.array_split(all_rows, 10): | |
| X, _, meta = matrix(f, cells, chunk, blk, cf) | |
| pa_ = model.predict(X).astype("float32").reshape(len(chunk), len(blk), len(MONTHS)) | |
| yi = np.nonzero(np.isin(YEARS, blk))[0] | |
| expected = clim_all[chunk] + pa_ | |
| obs = f["ndvi"][chunk][:, yi] | |
| res = obs - expected | |
| with np.errstate(all="ignore"): | |
| summer_res[chunk[:, None], yi[None, :]] = np.nanmean(res[:, :, summer_idx], axis=2) | |
| bc = bcode[chunk] | |
| for j, yy in enumerate(yi): | |
| for k in range(len(MONTHS)): | |
| v = np.isfinite(res[:, j, k]) | |
| acc["n"][:, yy, k] += np.bincount(bc[v], minlength=nb) | |
| for name, val in (("observed", obs), ("expected", expected), ("residual", res)): | |
| acc[name][:, yy, k] += np.bincount(bc[v], weights=val[v, j, k], minlength=nb) | |
| log(f"oof block {blk[0]}-{blk[-1]} done") | |
| np.save(RUN / "summer_residual.npy", summer_res) | |
| cells[["cell_id", "block_id", "region", "country"]].to_parquet(RUN / "eligible_cells.parquet", index=False) | |
| B, Y, M = np.meshgrid(np.arange(nb), YEARS, MONTHS, indexing="ij") | |
| with np.errstate(all="ignore"): | |
| eb = pd.DataFrame({"block_id": np.asarray(buniq)[B.ravel()], "year": Y.ravel(), "month": M.ravel(), | |
| "observed": (acc["observed"] / acc["n"]).ravel(), "expected": (acc["expected"] / acc["n"]).ravel(), | |
| "residual": (acc["residual"] / acc["n"]).ravel(), "n_cells": acc["n"].ravel().astype(int)}) | |
| eb = eb[eb["n_cells"] > 0].reset_index(drop=True) | |
| eb["p10"] = eb["expected"] + eb["month"].map(lambda m: conf[int(m)][0]) | |
| eb["p90"] = eb["expected"] + eb["month"].map(lambda m: conf[int(m)][1]) | |
| eb.to_parquet(RUN / "expected_block.parquet", index=False) | |
| pd.concat([pd.DataFrame({"cell_id": cells["cell_id"].values, "month": int(mo), | |
| "clim_ndvi": clim_all[:, 0, j]}) for j, mo in enumerate(MONTHS)]) \ | |
| .to_parquet(RUN / "climatology.parquet", index=False) | |
| (RUN / "feature_schema.json").write_text(json.dumps({"features": FEATURES, "static": STATIC, "weather": WEATHER, | |
| "months": MONTHS.tolist(), "shipped_model": chosen, | |
| "target": "ndvi_anomaly = ndvi - clim_ndvi"}, indent=2)) | |
| (RUN / "conformal.json").write_text(json.dumps(conf, indent=2)) | |
| (RUN / "metrics.json").write_text(json.dumps(metrics, indent=2, default=float)) | |
| log("TRAIN_CA_DONE") | |
| if __name__ == "__main__": | |
| main() | |