Remove old paths after relocating to projections_deferred/

Scripts_DL_Climate_to_LAI_CC/main.py

@@ -1,6 +0,0 @@
-def main():
-    print("Hello from wheat-climate-to-lai-cc-uv!")
-
-
-if __name__ == "__main__":
-    main()

Scripts_DL_Climate_to_LAI_CC/predict_cc_lai.py

@@ -1,646 +0,0 @@
-"""Generate per-state CC-projected LAI .npy files using per-state FFNN models.
-
-Pipeline
---------
-For each German federal state x climate-change scenario x future year, this
-script:
-
-  1. Loads the historical base-year .npy at
-     ``../{REGION}/data_LAI_geo_wx_2017_to_21/LAI_wx_geo_{REGION}_120d_{BASE}.npy``.
-     Shape ``(P, 120, 8)`` with channels
-     ``[DOY1, LAI, lon, lat, DOY2, SSI, Tmax, Tmin]`` and DOY range 50..169.
-  2. Applies the monthly CC deltas from ``CC_Delta_German_States.csv`` to the
-     climate channels (per-pixel, per-DOY, looked up by the month each DOY
-     belongs to):
-          SSI_new  = SSI  + Globrad_Delta(month)   (MJ m^-2 day^-1)
-          Tmax_new = Tmax + Tmax_Delta(month)      (deg C)
-          Tmin_new = Tmin + Tmin_Delta(month)      (deg C)
-     Tavg and Precip deltas exist in the CSV but are skipped: Tavg is a
-     derived quantity (not a model input) and the .npy has no precipitation
-     channel (the FFNN was not trained with precip).
-  3. Loads the per-state FFNN model + StandardScaler from
-     ``../wheat_climate_to_LAI_uv/output_trained_wheat_FFNN_LOYO_{REGION}/
-       fold_test_2021/`` (model trained on 2017-2020, held out 2021 -- the
-     most recent fold available, chosen for forward projection).
-  4. Runs inference on features
-     ``[DOY2, lon, lat, SSI_new, Tmax_new, Tmin_new]`` (same order as
-     training; same scaler) to get predicted LAI.
-  5. Writes the projected .npy with the SAME (P, 120, 8) shape and channel
-     order as the input -- the LAI channel is replaced with the prediction,
-     the climate channels reflect the CC-perturbed values, and DOY/lon/lat
-     are passed through unchanged.
-
-Future-year mapping (5 files per state per scenario)
-----------------------------------------------------
-There are 5 historical base years (2017-2021) and the prompt asks for
-"five year projection data" per scenario, so each base year is mapped to
-one future year offset by a fixed amount per decade:
-
-  CC2050 decade (2041_2050 deltas):
-      2017 -> 2041,  2018 -> 2042,  2019 -> 2043,  2020 -> 2044,  2021 -> 2045
-  CC2070 decade (2061_2070 deltas):
-      2017 -> 2061,  2018 -> 2062,  2019 -> 2063,  2020 -> 2064,  2021 -> 2065
-  CC2090 decade (2081_2090 deltas):
-      2017 -> 2081,  2018 -> 2082,  2019 -> 2083,  2020 -> 2084,  2021 -> 2085
-
-Outputs (one .npy per state per future year per scenario)
----------------------------------------------------------
-  ../{REGION}/data_LAI_geo_wx_CC2050_RCP26/LAI_wx_geo_{REGION}_120d_2041.npy ... 2045.npy
-  ../{REGION}/data_LAI_geo_wx_CC2050_RCP85/LAI_wx_geo_{REGION}_120d_2041.npy ... 2045.npy
-  ../{REGION}/data_LAI_geo_wx_CC2070_RCP26/LAI_wx_geo_{REGION}_120d_2061.npy ... 2065.npy
-  ../{REGION}/data_LAI_geo_wx_CC2070_RCP85/LAI_wx_geo_{REGION}_120d_2061.npy ... 2065.npy
-  ../{REGION}/data_LAI_geo_wx_CC2090_RCP26/LAI_wx_geo_{REGION}_120d_2081.npy ... 2085.npy
-  ../{REGION}/data_LAI_geo_wx_CC2090_RCP85/LAI_wx_geo_{REGION}_120d_2081.npy ... 2085.npy
-
-Total: 13 states x 5 years x 6 scenarios = 390 projection .npy files.
-
-Per-scenario manifest CSVs are written into ``cc_predictions_log/`` next to
-this script.
-
-Usage
------
-    python predict_cc_lai.py                            # all states, all scenarios
-    python predict_cc_lai.py --regions BadenW           # one state
-    python predict_cc_lai.py --scenarios CC2050_RCP26   # one scenario
-    python predict_cc_lai.py --dry-run                  # plan, do not write
-    python predict_cc_lai.py --gpus 0                   # restrict to GPU 0
-    python predict_cc_lai.py --overwrite                # overwrite existing .npy
-"""
-
-from __future__ import annotations
-
-import argparse
-import os
-import re
-import sys
-import time
-import warnings
-from dataclasses import dataclass
-from pathlib import Path
-
-import joblib
-import numpy as np
-import pandas as pd
-import torch
-import torch.nn as nn
-
-warnings.filterwarnings("ignore")
-
-BASE_DIR = Path(__file__).parent
-STATES_ROOT = BASE_DIR.parent
-TRAINED_ROOT = BASE_DIR.parent / "wheat_climate_to_LAI_uv"
-
-
-# ---------------------------------------------------------------------------
-# Constants (data conventions inherited from the training pipeline)
-# ---------------------------------------------------------------------------
-
-CROP = "wheat"
-
-REGIONS = [
-    "BadenW", "Bayern", "Brandenburg", "Hessen", "MecklenburgV",
-    "Niedersachsen", "NordrheinW", "RheinlandP", "Saarland", "Sachsen",
-    "SachsenA", "SchleswigH", "Thuringen",
-]
-
-# CC CSV uses the full German names; per-state folders use the project's short
-# names. Maps full-name -> short-name. Berlin, Bremen, Hamburg are in the CSV
-# but absent from our 13-state training set, so they are silently dropped.
-CSV_TO_REGION = {
-    "Baden-Wurttemberg":     "BadenW",
-    "Bayern":                "Bayern",
-    "Brandenburg":           "Brandenburg",
-    "Hessen":                "Hessen",
-    "Mecklenburg-Vorpommern": "MecklenburgV",
-    "Niedersachsen":         "Niedersachsen",
-    "Nordrhein-Westfalen":   "NordrheinW",
-    "Rheinland-Pfalz":       "RheinlandP",
-    "Saarland":              "Saarland",
-    "Sachsen":               "Sachsen",
-    "Sachsen-Anhalt":        "SachsenA",
-    "Schleswig-Holstein":    "SchleswigH",
-    "Thuringen":             "Thuringen",
-}
-
-# Feature order the FFNN was trained with (see wheat_climate_to_LAI_FFNN.py).
-FEATURE_COLS = ["DOY2", "lon", "lat", "SSI", "Tmax", "Tmin"]
-
-# Channel layout in the on-disk .npy: 8 channels, DOY1 == DOY2 (byte-identical),
-# kept as-is for backward compatibility with downstream tooling.
-NPY_CHANNELS = ["DOY1", "LAI", "lon", "lat", "DOY2", "SSI", "Tmax", "Tmin"]
-
-# Default FFNN architecture fallback if cv_summary.txt cannot be parsed.
-DEFAULT_HP = {
-    "n_layers": 3,
-    "hidden_sizes": [256, 320, 512],
-    "dropout_rate": 0.2,
-}
-
-# Months tagged in CC_Delta_German_States.csv (abbrev -> 1..12).
-MONTH_TO_INT = {
-    "Jan": 1, "Feb": 2, "Mar": 3, "Apr": 4, "May": 5, "Jun": 6,
-    "Jul": 7, "Aug": 8, "Sep": 9, "Oct": 10, "Nov": 11, "Dec": 12,
-}
-
-# Climate-change scenario catalogue: (folder_tag, decade_csv_key, rcp_csv_key,
-# year_offset_from_2017). Output folder name is ``data_LAI_geo_wx_{TAG}``.
-@dataclass(frozen=True)
-class Scenario:
-    tag: str             # e.g. "CC2050_RCP26"
-    decade: str          # CSV value, e.g. "2041_2050"
-    rcp: str             # CSV value, e.g. "RCP2.6"
-    year_offset: int     # base 2017 -> future first_year_of_decade
-
-ALL_SCENARIOS: list[Scenario] = [
-    Scenario("CC2050_RCP26", "2041_2050", "RCP2.6", 2041 - 2017),
-    Scenario("CC2050_RCP85", "2041_2050", "RCP8.5", 2041 - 2017),
-    Scenario("CC2070_RCP26", "2061_2070", "RCP2.6", 2061 - 2017),
-    Scenario("CC2070_RCP85", "2061_2070", "RCP8.5", 2061 - 2017),
-    Scenario("CC2090_RCP26", "2081_2090", "RCP2.6", 2081 - 2017),
-    Scenario("CC2090_RCP85", "2081_2090", "RCP8.5", 2081 - 2017),
-]
-
-BASE_YEARS = [2017, 2018, 2019, 2020, 2021]
-DOY_RANGE = range(50, 170)  # 50..169 inclusive (120 days)
-
-
-# ---------------------------------------------------------------------------
-# DOY -> month lookup (non-leap reference year)
-# ---------------------------------------------------------------------------
-# DOY 50..169 covers Feb..Jun in both leap and non-leap years to within +/-1
-# day. The CC deltas are monthly averages, so the +/-1-day shift at month
-# boundaries is well below the noise of the deltas themselves. We use the
-# non-leap reference year for a single deterministic mapping.
-
-def _build_doy_to_month(n_doys: int = 120, start_doy: int = 50) -> np.ndarray:
-    """Return an (n_doys,) int array mapping each DOY (start_doy..start_doy+n-1)
-    to a 1..12 month index, using a non-leap reference year."""
-    boundaries = [31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365]
-    months = np.empty(n_doys, dtype=np.int32)
-    for i in range(n_doys):
-        doy = start_doy + i
-        for m_idx, end_doy in enumerate(boundaries):
-            if doy <= end_doy:
-                months[i] = m_idx + 1  # 1..12
-                break
-    return months
-
-DOY_MONTH = _build_doy_to_month(n_doys=120, start_doy=50)  # shape (120,)
-
-
-# ---------------------------------------------------------------------------
-# Model definition (matches the training script's FFNN class exactly)
-# ---------------------------------------------------------------------------
-
-class FFNN(nn.Module):
-    def __init__(self, input_size: int,
-                 hidden_sizes: list[int] | tuple[int, ...] = (256, 320, 512),
-                 dropout_rate: float = 0.2):
-        super().__init__()
-        layers: list[nn.Module] = []
-        prev = input_size
-        for i, h in enumerate(hidden_sizes):
-            layers.append(nn.Linear(prev, h))
-            layers.append(nn.ReLU())
-            if i < len(hidden_sizes) - 1:
-                layers.append(nn.Dropout(dropout_rate))
-            prev = h
-        layers.append(nn.Linear(prev, 1))
-        self.network = nn.Sequential(*layers)
-
-    def forward(self, x):  # noqa: D401
-        return self.network(x)
-
-
-# ---------------------------------------------------------------------------
-# Per-state model + hyperparameter loading
-# ---------------------------------------------------------------------------
-
-_HP_LIST_RE = re.compile(r"\[\s*([\d,\s]+)\s*\]")
-
-
-def per_state_fold_dir(region: str, year: int = 2021) -> Path:
-    return TRAINED_ROOT / f"output_trained_{CROP}_FFNN_LOYO_{region}" / f"fold_test_{year}"
-
-
-def per_state_cv_summary(region: str) -> Path:
-    return TRAINED_ROOT / f"output_trained_{CROP}_FFNN_LOYO_{region}" / "cv_summary.txt"
-
-
-def load_per_state_hyperparameters(region: str) -> dict:
-    """Read n_layers / hidden_sizes / dropout_rate from per-state cv_summary.txt."""
-    hp = dict(DEFAULT_HP)
-    p = per_state_cv_summary(region)
-    if not p.is_file():
-        print(f"  [warn] {region}: cv_summary.txt missing, using DEFAULT_HP {DEFAULT_HP}")
-        return hp
-
-    in_block = False
-    for line in p.read_text().splitlines():
-        if "Hyperparameters used" in line:
-            in_block = True
-            continue
-        if not in_block:
-            continue
-        m = re.match(r"\s+([A-Za-z_]\w*)\s*:\s*(.+?)\s*$", line)
-        if not m:
-            continue
-        key, raw = m.group(1), m.group(2)
-        if key == "n_layers":
-            hp["n_layers"] = int(raw)
-        elif key == "hidden_sizes":
-            inner = _HP_LIST_RE.search(raw)
-            if inner:
-                hp["hidden_sizes"] = [int(x) for x in inner.group(1).split(",") if x.strip()]
-        elif key == "dropout_rate":
-            hp["dropout_rate"] = float(raw)
-    return hp
-
-
-def load_per_state_artifacts(region: str, device: torch.device) -> tuple[FFNN, object, dict]:
-    """Return (model, scaler, hyperparams) for the per-state FFNN (fold 2021)."""
-    fdir = per_state_fold_dir(region, 2021)
-    pth = fdir / f"FFNN_{CROP}_germany.pth"
-    scal = fdir / f"scaler_{CROP}_germany.pkl"
-    if not pth.is_file() or not scal.is_file():
-        raise FileNotFoundError(
-            f"Missing FFNN artifacts for {region} (fold_test_2021).\n"
-            f"  expected model:  {pth}\n  expected scaler: {scal}"
-        )
-
-    hp = load_per_state_hyperparameters(region)
-    hidden = hp["hidden_sizes"][: hp["n_layers"]]
-    model = FFNN(input_size=len(FEATURE_COLS), hidden_sizes=hidden,
-                 dropout_rate=hp["dropout_rate"]).to(device)
-    state = torch.load(pth, map_location=device)
-    model.load_state_dict(state)
-    model.eval()
-    scaler = joblib.load(scal)
-    return model, scaler, hp
-
-
-# ---------------------------------------------------------------------------
-# CC delta lookup
-# ---------------------------------------------------------------------------
-
-def load_cc_csv(csv_path: Path) -> pd.DataFrame:
-    df = pd.read_csv(csv_path)
-    df["RegionShort"] = df["State"].map(CSV_TO_REGION)
-    df["MonthInt"] = df["Month"].map(MONTH_TO_INT)
-    keep_cols = [
-        "RegionShort", "Decade", "MonthInt", "RCP",
-        "Tmax_Delta", "Tmin_Delta", "Globrad_Delta", "Precip_Delta",
-    ]
-    return df[keep_cols].copy()
-
-
-def monthly_delta_vector(cc_df: pd.DataFrame, region: str, decade: str, rcp: str
-                          ) -> np.ndarray:
-    """Return a (120,) array of (tmax_d, tmin_d, ssi_d) tuples ordered by DOY.
-
-    Shape is (120, 3) actually -- columns: [tmax_delta, tmin_delta, ssi_delta].
-    Aligned with DOY_RANGE.
-    """
-    sub = cc_df[(cc_df["RegionShort"] == region)
-                & (cc_df["Decade"] == decade)
-                & (cc_df["RCP"] == rcp)]
-    if sub.empty:
-        raise ValueError(f"No CC rows for region={region} decade={decade} rcp={rcp}")
-    by_month = {int(r.MonthInt): (float(r.Tmax_Delta), float(r.Tmin_Delta),
-                                   float(r.Globrad_Delta))
-                for r in sub.itertuples()}
-    out = np.zeros((len(DOY_MONTH), 3), dtype=np.float32)
-    for i, m in enumerate(DOY_MONTH):
-        if int(m) not in by_month:
-            raise ValueError(f"Missing month={int(m)} CC delta for {region}/{decade}/{rcp}")
-        out[i] = by_month[int(m)]
-    return out
-
-
-# ---------------------------------------------------------------------------
-# Per-(state, scenario, base_year) projection
-# ---------------------------------------------------------------------------
-
-def base_npy_path(region: str, base_year: int) -> Path:
-    return STATES_ROOT / region / "data_LAI_geo_wx_2017_to_21" / \
-        f"LAI_wx_geo_{region}_120d_{base_year}.npy"
-
-
-def scenario_output_path(region: str, scenario: Scenario, future_year: int) -> Path:
-    return STATES_ROOT / region / f"data_LAI_geo_wx_{scenario.tag}" / \
-        f"LAI_wx_geo_{region}_120d_{future_year}.npy"
-
-
-def project_one(region: str, scenario: Scenario, base_year: int,
-                model: FFNN, scaler, cc_df: pd.DataFrame,
-                device: torch.device, batch_size: int = 1_048_576,
-                ) -> dict | None:
-    """Build the CC-projected .npy for (region, scenario, base_year)."""
-    future_year = 2017 + (base_year - 2017) + scenario.year_offset
-
-    in_path = base_npy_path(region, base_year)
-    if not in_path.is_file():
-        print(f"  [skip] {region}/{base_year}: base .npy not found: {in_path}")
-        return None
-
-    arr = np.load(in_path)
-    if arr.ndim != 3 or arr.shape[1] != 120 or arr.shape[2] != 8:
-        print(f"  [skip] {region}/{base_year}: unexpected shape {arr.shape}, want (P, 120, 8)")
-        return None
-
-    in_dtype = arr.dtype
-    # Make a float32 working copy for inference. The original `arr` is kept
-    # untouched so DOY1/lon/lat/DOY2 passthrough channels stay bit-exact at
-    # the input dtype (otherwise a float64->float32->float64 round-trip on
-    # UTM-scale lon/lat introduces ~1e-3 m of noise that looks suspicious
-    # in downstream byte-equality checks).
-    work = np.asarray(arr, dtype=np.float32)
-    n_nan = int(np.isnan(work).sum())
-    n_inf = int(np.isinf(work).sum())
-    if n_nan or n_inf:
-        work = np.nan_to_num(work, nan=0.0, posinf=1e6, neginf=-1e6)
-
-    # Passthrough channels: keep original dtype (bit-exact views).
-    doy1_o = arr[:, :, 0]
-    lon_o = arr[:, :, 2]
-    lat_o = arr[:, :, 3]
-    doy2_o = arr[:, :, 4]
-
-    # Working-copy climate channels (float32) we will perturb and feed the model.
-    lon_f = work[:, :, 2]
-    lat_f = work[:, :, 3]
-    doy2_f = work[:, :, 4]
-    ssi_f = work[:, :, 5]
-    tmax_f = work[:, :, 6]
-    tmin_f = work[:, :, 7]
-
-    # Apply per-month CC deltas (deltas shape (120, 3) = tmax / tmin / ssi).
-    deltas = monthly_delta_vector(cc_df, region, scenario.decade, scenario.rcp)
-    tmax_d = deltas[:, 0]
-    tmin_d = deltas[:, 1]
-    ssi_d = deltas[:, 2]
-
-    # Broadcast (120,) -> (P, 120) and add; new arrays, do not mutate `work`.
-    ssi_new = ssi_f + ssi_d[None, :]
-    tmax_new = tmax_f + tmax_d[None, :]
-    tmin_new = tmin_f + tmin_d[None, :]
-
-    # Build feature matrix: (P*120, 6) in FEATURE_COLS order
-    # ['DOY2', 'lon', 'lat', 'SSI', 'Tmax', 'Tmin'].
-    P, T = arr.shape[0], arr.shape[1]
-    feats = np.stack([
-        doy2_f.reshape(-1),
-        lon_f.reshape(-1),
-        lat_f.reshape(-1),
-        ssi_new.reshape(-1),
-        tmax_new.reshape(-1),
-        tmin_new.reshape(-1),
-    ], axis=1)  # already float32
-
-    X = scaler.transform(feats).astype(np.float32, copy=False)
-    out = np.empty(X.shape[0], dtype=np.float32)
-    # Adaptive batching: halve the batch on CUDA OOM and retry that chunk.
-    # Some per-state models (e.g. Bayern, Niedersachsen) have wide
-    # [1024, 1024, 1024] hidden layers whose intermediate activations blow
-    # past the default 1M-row batch on 12 GB GPUs.
-    cur_bs = batch_size
-    min_bs = 4096
-    with torch.no_grad():
-        start = 0
-        while start < X.shape[0]:
-            end = min(start + cur_bs, X.shape[0])
-            try:
-                t = torch.from_numpy(X[start:end]).to(device)
-                y = model(t).squeeze(-1).cpu().numpy()
-                out[start:end] = y
-                start = end
-            except torch.cuda.OutOfMemoryError:
-                torch.cuda.empty_cache()
-                if cur_bs <= min_bs:
-                    raise
-                cur_bs = max(min_bs, cur_bs // 2)
-                print(f"     [retry] OOM at batch {start}; reducing batch_size -> {cur_bs}")
-    pred_lai = out.reshape(P, T)
-
-    # Assemble output array. Passthrough channels keep their bit-exact source
-    # views; predicted/perturbed channels are cast up to `in_dtype` for a
-    # uniform on-disk dtype that matches the base-year .npy.
-    proj = np.empty((P, T, 8), dtype=in_dtype)
-    proj[:, :, 0] = doy1_o            # DOY1 (passthrough)
-    proj[:, :, 1] = pred_lai          # LAI (predicted)
-    proj[:, :, 2] = lon_o             # lon  (passthrough)
-    proj[:, :, 3] = lat_o             # lat  (passthrough)
-    proj[:, :, 4] = doy2_o            # DOY2 (passthrough)
-    proj[:, :, 5] = ssi_new           # SSI  (perturbed)
-    proj[:, :, 6] = tmax_new          # Tmax (perturbed)
-    proj[:, :, 7] = tmin_new          # Tmin (perturbed)
-
-    out_path = scenario_output_path(region, scenario, future_year)
-    out_path.parent.mkdir(parents=True, exist_ok=True)
-    np.save(out_path, proj)
-
-    return {
-        "region": region,
-        "scenario": scenario.tag,
-        "decade": scenario.decade,
-        "rcp": scenario.rcp,
-        "base_year": base_year,
-        "future_year": future_year,
-        "pixels": int(P),
-        "doys": int(T),
-        "n_nan_in_base": n_nan,
-        "n_inf_in_base": n_inf,
-        "pred_lai_mean": float(pred_lai.mean()),
-        "pred_lai_min":  float(pred_lai.min()),
-        "pred_lai_max":  float(pred_lai.max()),
-        "obs_lai_mean":  float(arr[:, :, 1].mean()),
-        "tmax_delta_mean_C": float(tmax_d.mean()),
-        "tmin_delta_mean_C": float(tmin_d.mean()),
-        "ssi_delta_mean":    float(ssi_d.mean()),
-        "out_path": str(out_path.resolve()),
-    }
-
-
-# ---------------------------------------------------------------------------
-# Orchestration
-# ---------------------------------------------------------------------------
-
-def pick_device(gpus: list[int] | None) -> torch.device:
-    if not torch.cuda.is_available():
-        return torch.device("cpu")
-    if gpus is None:
-        return torch.device("cuda:0")
-    if len(gpus) != 1:
-        # If multiple selected we just use the first; this script is small enough
-        # to fit on a single GPU and benefit zero from DataParallel.
-        print(f"[info] multiple GPUs given ({gpus}); using cuda:{gpus[0]} only")
-    os.environ["CUDA_VISIBLE_DEVICES"] = ",".join(str(g) for g in gpus)
-    return torch.device("cuda:0")
-
-
-def parse_int_list(raw: str | None) -> list[int] | None:
-    if not raw:
-        return None
-    parts = []
-    for chunk in raw.split(","):
-        chunk = chunk.strip()
-        if "-" in chunk:
-            a, b = chunk.split("-")
-            parts.extend(range(int(a), int(b) + 1))
-        elif chunk:
-            parts.append(int(chunk))
-    return parts
-
-
-def parse_str_list(raw: str | None, valid: list[str]) -> list[str]:
-    if not raw or raw.lower() == "all":
-        return list(valid)
-    out = [s.strip() for s in raw.split(",") if s.strip()]
-    bad = [s for s in out if s not in valid]
-    if bad:
-        raise SystemExit(f"Unknown items {bad}; valid options: {valid}")
-    return out
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description=__doc__,
-                                  formatter_class=argparse.RawDescriptionHelpFormatter)
-    ap.add_argument("--csv", type=str,
-                    default=str(BASE_DIR / "CC_Delta_German_States.csv"),
-                    help="Path to CC_Delta_German_States.csv")
-    ap.add_argument("--regions", type=str, default="all",
-                    help='Comma-separated states, or "all" (default).')
-    ap.add_argument("--scenarios", type=str, default="all",
-                    help='Comma-separated scenario tags, or "all" (default). '
-                         "Tags: " + ", ".join(s.tag for s in ALL_SCENARIOS))
-    ap.add_argument("--base-years", type=str, default=",".join(map(str, BASE_YEARS)),
-                    help="Comma-separated historical base years (default: 2017-2021).")
-    ap.add_argument("--gpus", type=str, default=None,
-                    help="Restrict to specific GPU id(s), e.g. '0' or '1,2'.")
-    ap.add_argument("--batch-size", type=int, default=1_048_576,
-                    help="Inference batch size (default 1,048,576 rows).")
-    ap.add_argument("--overwrite", action="store_true",
-                    help="Overwrite existing .npy files (default: skip).")
-    ap.add_argument("--dry-run", action="store_true",
-                    help="Plan and print what would happen, do not write.")
-    ap.add_argument("--log-dir", type=str,
-                    default=str(BASE_DIR / "cc_predictions_log"),
-                    help="Directory for per-scenario manifest CSVs.")
-    args = ap.parse_args()
-
-    csv_path = Path(args.csv)
-    if not csv_path.is_file():
-        raise SystemExit(f"CC CSV not found: {csv_path}")
-
-    regions = parse_str_list(args.regions, REGIONS)
-    scenario_tags = parse_str_list(args.scenarios, [s.tag for s in ALL_SCENARIOS])
-    scenarios = [s for s in ALL_SCENARIOS if s.tag in scenario_tags]
-    base_years = parse_int_list(args.base_years) or BASE_YEARS
-    gpus = parse_int_list(args.gpus)
-
-    log_dir = Path(args.log_dir)
-    log_dir.mkdir(parents=True, exist_ok=True)
-
-    print("=" * 76)
-    print(f"CC LAI projection - {CROP}")
-    print(f"  CSV         : {csv_path}")
-    print(f"  States ({len(regions)}) : {regions}")
-    print(f"  Scenarios ({len(scenarios)}) : {[s.tag for s in scenarios]}")
-    print(f"  Base years  : {base_years}  -> 5 future years per scenario")
-    print(f"  Overwrite   : {args.overwrite}    Dry-run: {args.dry_run}")
-    print(f"  Log dir     : {log_dir}")
-    print("=" * 76)
-
-    cc_df = load_cc_csv(csv_path)
-    missing_in_csv = [r for r in regions if r not in cc_df["RegionShort"].dropna().unique()]
-    if missing_in_csv:
-        raise SystemExit(f"States missing from CC CSV: {missing_in_csv}")
-
-    device = pick_device(gpus)
-    print(f"[info] device: {device}")
-
-    total_planned = len(regions) * len(scenarios) * len(base_years)
-    print(f"[info] total planned projections: {total_planned}")
-    print()
-
-    if args.dry_run:
-        for region in regions:
-            print(f"-- {region}")
-            for sc in scenarios:
-                for by in base_years:
-                    fy = 2017 + (by - 2017) + sc.year_offset
-                    out_p = scenario_output_path(region, sc, fy)
-                    print(f"    {sc.tag}  base {by} -> {fy}   ->  {out_p}")
-        print("\n[dry-run] no files written.")
-        return 0
-
-    records: list[dict] = []
-    t0 = time.time()
-    n_done = 0
-    n_skip = 0
-    n_err = 0
-
-    for region in regions:
-        print(f"=== {region} ===")
-        try:
-            model, scaler, hp = load_per_state_artifacts(region, device)
-        except FileNotFoundError as e:
-            print(f"  [error] {e}")
-            n_err += len(scenarios) * len(base_years)
-            continue
-        print(f"  loaded FFNN  layers={hp['hidden_sizes'][:hp['n_layers']]} "
-              f"dropout={hp['dropout_rate']:.3f}")
-
-        for sc in scenarios:
-            for by in base_years:
-                fy = 2017 + (by - 2017) + sc.year_offset
-                out_p = scenario_output_path(region, sc, fy)
-                if out_p.is_file() and not args.overwrite:
-                    print(f"  [skip-exists] {sc.tag} {by}->{fy}")
-                    n_skip += 1
-                    continue
-                try:
-                    rec = project_one(region, sc, by, model, scaler, cc_df,
-                                      device, batch_size=args.batch_size)
-                except Exception as e:  # noqa: BLE001
-                    print(f"  [error] {region}/{sc.tag}/{by}: {type(e).__name__}: {e}")
-                    n_err += 1
-                    continue
-                if rec is None:
-                    n_err += 1
-                    continue
-                records.append(rec)
-                n_done += 1
-                print(f"  ok  {sc.tag} {by}->{fy}  "
-                      f"px={rec['pixels']:>6}  "
-                      f"mean(LAI pred)={rec['pred_lai_mean']:.3f}  "
-                      f"dTmax={rec['tmax_delta_mean_C']:+.2f}C  "
-                      f"dTmin={rec['tmin_delta_mean_C']:+.2f}C  "
-                      f"dSSI={rec['ssi_delta_mean']:+.2f}")
-
-        # Free model so next state's load isn't memory-pressured (CPU or GPU).
-        del model
-        if device.type == "cuda":
-            torch.cuda.empty_cache()
-
-    # Write manifest CSVs grouped by scenario.
-    if records:
-        all_df = pd.DataFrame.from_records(records)
-        all_df.to_csv(log_dir / "manifest_all.csv", index=False)
-        for sc in scenarios:
-            sub = all_df[all_df["scenario"] == sc.tag]
-            if not sub.empty:
-                sub.to_csv(log_dir / f"manifest_{sc.tag}.csv", index=False)
-
-    elapsed = time.time() - t0
-    print()
-    print("=" * 76)
-    print(f"Done in {elapsed:.1f}s  -- written={n_done}  skipped_existing={n_skip}  errors={n_err}")
-    if records:
-        print(f"Manifest CSVs in: {log_dir}")
-    print("=" * 76)
-    return 0 if n_err == 0 else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

Scripts_ML_ET/apply_et_to_states.py

@@ -1,160 +0,0 @@
-"""Apply the trained ET model to per-state LAI+weather .npy files.
-
-Reads:
-    ../{state}/data_LAI_geo_wx_2017_to_21/LAI_wx_geo_{state}_120d_{year}.npy
-    each of shape (n_pixels, 120, 8) with channels:
-        [DOY1, LAI, lon, lat, DOY2, SSI(=SRad), Tmax, Tmin]
-
-Writes (per state, per year):
-    ../{state}/data_ET_2017_to_21/ET_{state}_120d_{year}.npy
-        shape (n_pixels, 120, 2) with channels [DOY, ET]
-    ../{state}/data_ET_2017_to_21/ET_{state}_120d_{year}_summary.csv
-        per-DOY mean/std/min/max across pixels (handy quick-look)
-
-Usage:
-    uv run python apply_et_to_states.py
-    uv run python apply_et_to_states.py --states BadenW Bayern --years 2020 2021
-    uv run python apply_et_to_states.py --bundle et_best_model.joblib
-"""
-
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-
-import joblib
-import numpy as np
-import pandas as pd
-
-HERE = Path(__file__).resolve().parent
-PROJECT_ROOT = HERE.parent
-DEFAULT_BUNDLE = HERE / "et_best_model.joblib"
-
-DEFAULT_STATES = [
-    "BadenW", "Bayern", "Brandenburg", "Hessen", "MecklenburgV",
-    "Niedersachsen", "NordrheinW", "RheinlandP", "Saarland",
-    "Sachsen", "SachsenA", "SchleswigH", "Thuringen",
-]
-DEFAULT_YEARS = [2017, 2018, 2019, 2020, 2021]
-
-NPY_CHANNELS = ["DOY1", "LAI", "lon", "lat", "DOY2", "SSI", "Tmax", "Tmin"]
-NPY_IDX = {name: i for i, name in enumerate(NPY_CHANNELS)}
-
-CSV_TO_NPY = {"DOY": "DOY2", "SLAI": "LAI", "Tmax": "Tmax", "Tmin": "Tmin", "SRad": "SSI"}
-
-
-def build_feature_matrix(arr: np.ndarray, feature_names: list[str]) -> np.ndarray:
-    """Map (pixels, 120, 8) -> (pixels*120, len(feature_names)) using CSV->npy mapping."""
-
-    pixels, days, n_chan = arr.shape
-    if n_chan != len(NPY_CHANNELS):
-        raise ValueError(
-            f"Expected {len(NPY_CHANNELS)} channels in .npy file, got {n_chan}. "
-            f"Update NPY_CHANNELS if the layout changed."
-        )
-
-    cols = []
-    for f in feature_names:
-        if f not in CSV_TO_NPY:
-            raise KeyError(
-                f"Don't know how to map training feature {f!r} to a channel in the .npy file. "
-                f"Known mappings: {CSV_TO_NPY}"
-            )
-        cols.append(arr[:, :, NPY_IDX[CSV_TO_NPY[f]]].reshape(-1))
-    return np.stack(cols, axis=1)
-
-
-def per_doy_summary(doy: np.ndarray, et: np.ndarray) -> pd.DataFrame:
-    """Summarise ET across pixels for each DOY column (length 120)."""
-
-    n_pixels, n_days = et.shape
-    doy_per_day = doy[0]
-    return pd.DataFrame({
-        "DOY": doy_per_day.astype(int),
-        "ET_mean": et.mean(axis=0),
-        "ET_std": et.std(axis=0),
-        "ET_min": et.min(axis=0),
-        "ET_max": et.max(axis=0),
-        "n_pixels": np.full(n_days, n_pixels, dtype=int),
-    })
-
-
-def process_one(arr_path: Path, out_dir: Path, model, feature_names: list[str]) -> Path:
-    arr = np.load(arr_path)
-    pixels, days, _ = arr.shape
-
-    X = build_feature_matrix(arr, feature_names)
-    yhat = model.predict(X).astype(np.float32).reshape(pixels, days)
-
-    doy = arr[:, :, NPY_IDX["DOY2"]].astype(np.float32)
-    out = np.stack([doy, yhat], axis=2)
-
-    out_dir.mkdir(parents=True, exist_ok=True)
-    out_path = out_dir / arr_path.name.replace("LAI_wx_geo_", "ET_")
-    np.save(out_path, out)
-
-    summary_path = out_path.with_name(out_path.stem + "_summary.csv")
-    per_doy_summary(doy, yhat).to_csv(summary_path, index=False)
-    return out_path
-
-
-def parse_args() -> argparse.Namespace:
-    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawTextHelpFormatter)
-    p.add_argument("--bundle", default=str(DEFAULT_BUNDLE),
-                   help=f"joblib bundle saved by train_et_models.py (default: {DEFAULT_BUNDLE.name})")
-    p.add_argument("--root", default=str(PROJECT_ROOT),
-                   help=f"Project root that contains per-state folders (default: {PROJECT_ROOT})")
-    p.add_argument("--states", nargs="+", default=DEFAULT_STATES,
-                   help="Subset of state folder names to process.")
-    p.add_argument("--years", nargs="+", type=int, default=DEFAULT_YEARS,
-                   help="Subset of years to process.")
-    p.add_argument("--out-folder", default="data_ET_2017_to_21",
-                   help="Output sub-folder name created inside each state directory.")
-    return p.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-    bundle_path = Path(args.bundle)
-    if not bundle_path.exists():
-        raise SystemExit(
-            f"Model bundle {bundle_path} not found. Run train_et_models.py first."
-        )
-
-    bundle = joblib.load(bundle_path)
-    model = bundle["model"]
-    feature_names = bundle["feature_names"]
-    metrics = bundle.get("metrics", {})
-    print(f"[load] {bundle_path}")
-    print(f"[load] model='{metrics.get('model', type(model).__name__)}'  "
-          f"test_R2={metrics.get('test_R2', float('nan')):.4f}  "
-          f"features={feature_names}")
-
-    root = Path(args.root)
-    n_done = n_skipped = 0
-    for state in args.states:
-        in_dir = root / state / "data_LAI_geo_wx_2017_to_21"
-        out_dir = root / state / args.out_folder
-        if not in_dir.is_dir():
-            print(f"[skip] {state}: no folder {in_dir}")
-            n_skipped += 1
-            continue
-        for year in args.years:
-            arr_path = in_dir / f"LAI_wx_geo_{state}_120d_{year}.npy"
-            if not arr_path.exists():
-                print(f"[skip] {state} {year}: missing {arr_path.name}")
-                n_skipped += 1
-                continue
-            out_path = process_one(arr_path, out_dir, model, feature_names)
-            arr_size_mb = arr_path.stat().st_size / 1e6
-            out_size_mb = out_path.stat().st_size / 1e6
-            print(f"[ok ] {state:14s} {year}  "
-                  f"in={arr_size_mb:6.1f}MB  out={out_size_mb:5.1f}MB  -> {out_path}")
-            n_done += 1
-
-    print(f"\n[done] {n_done} files written, {n_skipped} skipped")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

Scripts_ML_ET/apply_et_to_states_CC.py

@@ -1,148 +0,0 @@
-"""Apply the trained ET model to per-state LAI+weather .npy files
-under climate-change (CC) scenarios.
-
-Reads (per state, per scenario, per year):
-    ../{state}/data_LAI_geo_wx_CC{ref_year}_{rcp}/LAI_wx_geo_{state}_120d_{file_year}.npy
-    each of shape (n_pixels, 120, 8) with channels:
-        [DOY1, LAI, lon, lat, DOY2, SSI(=SRad), Tmax, Tmin]
-
-Note: each CC folder typically contains 5 yearly files spanning a 5-year window
-ending shortly before the reference year, e.g.:
-    CC2050 -> 2041..2045
-    CC2070 -> 2061..2065
-    CC2090 -> 2081..2085
-This script discovers every .npy in each scenario folder, so it works regardless
-of which file_years are present.
-
-Writes (per state, per scenario, per year):
-    ../{state}/data_ET_CC{ref_year}_{rcp}_ML/ET_{state}_120d_{file_year}.npy
-        shape (n_pixels, 120, 2) with channels [DOY, ET]
-    ../{state}/data_ET_CC{ref_year}_{rcp}_ML/ET_{state}_120d_{file_year}_summary.csv
-        per-DOY mean/std/min/max across pixels.
-
-Usage:
-    uv run python apply_et_to_states_CC.py
-    uv run python apply_et_to_states_CC.py --states BadenW Bayern
-    uv run python apply_et_to_states_CC.py --ref-years 2050 2090 --rcps RCP85
-    uv run python apply_et_to_states_CC.py --bundle et_best_model.joblib
-"""
-
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-
-import joblib
-import numpy as np
-
-from apply_et_to_states import (
-    DEFAULT_STATES,
-    NPY_IDX,
-    build_feature_matrix,
-    per_doy_summary,
-)
-
-HERE = Path(__file__).resolve().parent
-PROJECT_ROOT = HERE.parent
-DEFAULT_BUNDLE = HERE / "et_best_model.joblib"
-
-DEFAULT_REF_YEARS = [2050, 2070, 2090]
-DEFAULT_RCPS = ["RCP26", "RCP85"]
-
-
-def process_one(arr_path: Path, out_dir: Path, model, feature_names: list[str]) -> Path | None:
-    """Run inference on a single CC .npy file. Returns None if the file is empty/corrupt."""
-
-    if arr_path.stat().st_size == 0:
-        return None
-    try:
-        arr = np.load(arr_path)
-    except (EOFError, ValueError, OSError):
-        return None
-    if arr.ndim != 3:
-        return None
-    pixels, days, _ = arr.shape
-
-    X = build_feature_matrix(arr, feature_names)
-    yhat = model.predict(X).astype(np.float32).reshape(pixels, days)
-
-    doy = arr[:, :, NPY_IDX["DOY2"]].astype(np.float32)
-    out = np.stack([doy, yhat], axis=2)
-
-    out_dir.mkdir(parents=True, exist_ok=True)
-    out_path = out_dir / arr_path.name.replace("LAI_wx_geo_", "ET_")
-    np.save(out_path, out)
-
-    summary_path = out_path.with_name(out_path.stem + "_summary.csv")
-    per_doy_summary(doy, yhat).to_csv(summary_path, index=False)
-    return out_path
-
-
-def parse_args() -> argparse.Namespace:
-    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawTextHelpFormatter)
-    p.add_argument("--bundle", default=str(DEFAULT_BUNDLE),
-                   help=f"joblib bundle saved by train_et_models.py (default: {DEFAULT_BUNDLE.name})")
-    p.add_argument("--root", default=str(PROJECT_ROOT),
-                   help=f"Project root that contains per-state folders (default: {PROJECT_ROOT})")
-    p.add_argument("--states", nargs="+", default=DEFAULT_STATES,
-                   help="Subset of state folder names to process.")
-    p.add_argument("--ref-years", nargs="+", type=int, default=DEFAULT_REF_YEARS,
-                   help="Reference years (folder labels): default 2050 2070 2090.")
-    p.add_argument("--rcps", nargs="+", default=DEFAULT_RCPS,
-                   help="Scenario tags (default: RCP26 RCP85).")
-    return p.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-    bundle_path = Path(args.bundle)
-    if not bundle_path.exists():
-        raise SystemExit(
-            f"Model bundle {bundle_path} not found. Run train_et_models.py first."
-        )
-
-    bundle = joblib.load(bundle_path)
-    model = bundle["model"]
-    feature_names = bundle["feature_names"]
-    metrics = bundle.get("metrics", {})
-    print(f"[load] {bundle_path}")
-    print(f"[load] model='{metrics.get('model', type(model).__name__)}'  "
-          f"test_R2={metrics.get('test_R2', float('nan')):.4f}  "
-          f"features={feature_names}")
-
-    root = Path(args.root)
-    n_done = n_skipped = 0
-    for state in args.states:
-        for ref_year in args.ref_years:
-            for rcp in args.rcps:
-                in_dir = root / state / f"data_LAI_geo_wx_CC{ref_year}_{rcp}"
-                out_dir = root / state / f"data_ET_CC{ref_year}_{rcp}_ML"
-                if not in_dir.is_dir():
-                    print(f"[skip] {state} CC{ref_year} {rcp}: no folder {in_dir}")
-                    n_skipped += 1
-                    continue
-                arr_paths = sorted(in_dir.glob(f"LAI_wx_geo_{state}_120d_*.npy"))
-                if not arr_paths:
-                    print(f"[skip] {state} CC{ref_year} {rcp}: no .npy files in {in_dir}")
-                    n_skipped += 1
-                    continue
-                for arr_path in arr_paths:
-                    file_year = arr_path.stem.split("_")[-1]
-                    out_path = process_one(arr_path, out_dir, model, feature_names)
-                    if out_path is None:
-                        print(f"[skip] {state:14s} CC{ref_year} {rcp}  "
-                              f"yr={file_year}  empty/corrupt input ({arr_path.name})")
-                        n_skipped += 1
-                        continue
-                    in_mb = arr_path.stat().st_size / 1e6
-                    out_mb = out_path.stat().st_size / 1e6
-                    print(f"[ok ] {state:14s} CC{ref_year} {rcp}  "
-                          f"yr={file_year}  in={in_mb:6.1f}MB  out={out_mb:5.1f}MB  -> {out_path}")
-                    n_done += 1
-
-    print(f"\n[done] {n_done} files written, {n_skipped} skipped")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

Scripts_ML_ET/et_model_comparison.csv

@@ -1,8 +0,0 @@
-model,train_R2,test_R2,test_RMSE,test_MAE,short
-ExT,0.9999997520230427,0.5841162854181792,0.7558305771305526,0.5596282568807341,et
-RF,0.9402780130180641,0.5629794742046232,0.774799653377884,0.5795767837483615,rf
-XGB,0.9728913671761259,0.5560205752051268,0.7809440533807773,0.5812149235239816,xgb
-GB,0.7737269432350296,0.5324292475100935,0.8014236767702441,0.5977385514514458,gb
-HGB,0.9164845177233168,0.5179223543091451,0.8137612335814248,0.6045447165895007,hgb
-LightGBM,0.9914365906915804,0.5177557205984851,0.8139018627304726,0.6018338876139192,lgbm
-SVR,0.5280836507420024,0.48929983633173046,0.8375707429625091,0.6342273220726324,svr

Scripts_ML_ET/main.py

@@ -1,6 +0,0 @@
-def main():
-    print("Hello from sim-et-wh-uv!")
-
-
-if __name__ == "__main__":
-    main()

Scripts_ML_ET/train_et_models.py

@@ -1,249 +0,0 @@
-"""Train ML regressors to simulate ET from DOY, LAI, Tmax, Tmin, SRad.
-
-Inputs:  combined_wheat_RSCM_out_v2.csv  (columns include DOY, SLAI, Tmax, Tmin, SRad, ET)
-Models:  SVR, RandomForest, ExtraTrees, HistGradientBoosting, GradientBoosting, XGBoost, LightGBM
-Output:  et_best_model.joblib  (chosen model bundled with its StandardScaler and feature names)
-         et_model_comparison.csv
-         et_parity_<model>.png  (one parity plot per model on the test split)
-
-Usage:
-    uv run python train_et_models.py                # interactive: pick the model after table is shown
-    uv run python train_et_models.py --auto         # auto-pick the model with the best test R^2
-    uv run python train_et_models.py --pick xgb     # pick a specific model by short name
-"""
-
-from __future__ import annotations
-
-import argparse
-import sys
-from pathlib import Path
-
-import joblib
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-from sklearn.ensemble import (
-    ExtraTreesRegressor,
-    GradientBoostingRegressor,
-    HistGradientBoostingRegressor,
-    RandomForestRegressor,
-)
-from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
-from sklearn.model_selection import train_test_split
-from sklearn.pipeline import Pipeline
-from sklearn.preprocessing import StandardScaler
-from sklearn.svm import SVR
-
-import lightgbm as lgb
-import xgboost as xgb
-
-HERE = Path(__file__).resolve().parent
-CSV_PATH = HERE / "combined_wheat_RSCM_out_v2.csv"
-OUT_BUNDLE = HERE / "et_best_model.joblib"
-OUT_TABLE = HERE / "et_model_comparison.csv"
-
-FEATURE_COLS = ["DOY", "SLAI", "Tmax", "Tmin", "SRad"]
-TARGET_COL = "ET"
-RANDOM_STATE = 42
-
-
-def build_models() -> dict[str, tuple[str, Pipeline]]:
-    """Return short_name -> (display_name, sklearn Pipeline)."""
-
-    return {
-        "svr": (
-            "Support Vector Regression",
-            Pipeline([
-                ("scaler", StandardScaler()),
-                ("model", SVR(kernel="rbf", C=10.0, gamma="scale", epsilon=0.1)),
-            ]),
-        ),
-        "rf": (
-            "Random Forest",
-            Pipeline([
-                ("scaler", StandardScaler(with_mean=False, with_std=False)),
-                ("model", RandomForestRegressor(
-                    n_estimators=400, max_depth=None, n_jobs=-1, random_state=RANDOM_STATE,
-                )),
-            ]),
-        ),
-        "et": (
-            "Extra Trees",
-            Pipeline([
-                ("scaler", StandardScaler(with_mean=False, with_std=False)),
-                ("model", ExtraTreesRegressor(
-                    n_estimators=500, max_depth=None, n_jobs=-1, random_state=RANDOM_STATE,
-                )),
-            ]),
-        ),
-        "hgb": (
-            "Histogram Gradient Boosting",
-            Pipeline([
-                ("scaler", StandardScaler(with_mean=False, with_std=False)),
-                ("model", HistGradientBoostingRegressor(
-                    max_iter=500, learning_rate=0.05, max_depth=None,
-                    random_state=RANDOM_STATE,
-                )),
-            ]),
-        ),
-        "gb": (
-            "Gradient Boosting",
-            Pipeline([
-                ("scaler", StandardScaler(with_mean=False, with_std=False)),
-                ("model", GradientBoostingRegressor(
-                    n_estimators=400, learning_rate=0.05, max_depth=4,
-                    random_state=RANDOM_STATE,
-                )),
-            ]),
-        ),
-        "xgb": (
-            "XGBoost",
-            Pipeline([
-                ("scaler", StandardScaler(with_mean=False, with_std=False)),
-                ("model", xgb.XGBRegressor(
-                    n_estimators=600, learning_rate=0.05, max_depth=6,
-                    subsample=0.9, colsample_bytree=0.9,
-                    objective="reg:squarederror", tree_method="hist",
-                    n_jobs=-1, random_state=RANDOM_STATE, verbosity=0,
-                )),
-            ]),
-        ),
-        "lgbm": (
-            "LightGBM",
-            Pipeline([
-                ("scaler", StandardScaler(with_mean=False, with_std=False)),
-                ("model", lgb.LGBMRegressor(
-                    n_estimators=800, learning_rate=0.05, num_leaves=63,
-                    subsample=0.9, colsample_bytree=0.9, min_child_samples=20,
-                    n_jobs=-1, random_state=RANDOM_STATE, verbosity=-1,
-                )),
-            ]),
-        ),
-    }
-
-
-def load_dataset(csv_path: Path) -> tuple[np.ndarray, np.ndarray, pd.DataFrame]:
-    df = pd.read_csv(csv_path)
-    needed = FEATURE_COLS + [TARGET_COL]
-    missing = [c for c in needed if c not in df.columns]
-    if missing:
-        raise SystemExit(f"CSV {csv_path} is missing required columns: {missing}")
-
-    df = df.dropna(subset=needed).copy()
-    X = df[FEATURE_COLS].to_numpy(dtype=np.float64)
-    y = df[TARGET_COL].to_numpy(dtype=np.float64)
-    return X, y, df
-
-
-def evaluate(name: str, model: Pipeline, X_train, X_test, y_train, y_test) -> dict:
-    model.fit(X_train, y_train)
-    yhat_train = model.predict(X_train)
-    yhat_test = model.predict(X_test)
-    return {
-        "model": name,
-        "train_R2": r2_score(y_train, yhat_train),
-        "test_R2": r2_score(y_test, yhat_test),
-        "test_RMSE": float(np.sqrt(mean_squared_error(y_test, yhat_test))),
-        "test_MAE": mean_absolute_error(y_test, yhat_test),
-        "_yhat_test": yhat_test,
-        "_pipeline": model,
-    }
-
-
-def parity_plot(y_true, y_pred, title: str, out_png: Path) -> None:
-    fig, ax = plt.subplots(figsize=(5.0, 5.0))
-    ax.scatter(y_true, y_pred, s=8, alpha=0.4, edgecolor="none")
-    lo = float(min(y_true.min(), y_pred.min()))
-    hi = float(max(y_true.max(), y_pred.max()))
-    ax.plot([lo, hi], [lo, hi], "k--", lw=1.0)
-    r2 = r2_score(y_true, y_pred)
-    rmse = float(np.sqrt(mean_squared_error(y_true, y_pred)))
-    ax.set_xlabel(f"Observed {TARGET_COL}")
-    ax.set_ylabel(f"Predicted {TARGET_COL}")
-    ax.set_title(f"{title}\nR^2 = {r2:.3f} | RMSE = {rmse:.3f}")
-    ax.grid(True, alpha=0.3)
-    fig.tight_layout()
-    fig.savefig(out_png, dpi=140)
-    plt.close(fig)
-
-
-def parse_args() -> argparse.Namespace:
-    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawTextHelpFormatter)
-    p.add_argument("--csv", default=str(CSV_PATH), help=f"Path to CSV (default: {CSV_PATH.name})")
-    p.add_argument("--test-size", type=float, default=0.2)
-    p.add_argument("--seed", type=int, default=RANDOM_STATE)
-    p.add_argument("--auto", action="store_true",
-                   help="Skip the prompt and pick the model with the best test R^2.")
-    p.add_argument("--pick", default=None,
-                   help="Pick a specific model by short name (svr, rf, et, hgb, gb, xgb, lgbm).")
-    return p.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-
-    print(f"[load] {args.csv}")
-    X, y, df = load_dataset(Path(args.csv))
-    print(f"[load] features={FEATURE_COLS}  target={TARGET_COL}  rows={len(df):,}")
-
-    X_train, X_test, y_train, y_test = train_test_split(
-        X, y, test_size=args.test_size, random_state=args.seed,
-    )
-    print(f"[split] train={len(X_train):,}  test={len(X_test):,}")
-
-    models = build_models()
-    results: list[dict] = []
-    for short, (display, pipe) in models.items():
-        print(f"[fit ] {display:32s} ...", end=" ", flush=True)
-        res = evaluate(display, pipe, X_train, X_test, y_train, y_test)
-        res["short"] = short
-        results.append(res)
-        print(f"R2={res['test_R2']:.3f}  RMSE={res['test_RMSE']:.3f}  MAE={res['test_MAE']:.3f}")
-        parity_plot(y_test, res["_yhat_test"], display,
-                    HERE / f"et_parity_{short}.png")
-
-    table = pd.DataFrame([
-        {k: v for k, v in r.items() if not k.startswith("_") and k != "short"}
-        | {"short": r["short"]}
-        for r in results
-    ]).sort_values("test_R2", ascending=False).reset_index(drop=True)
-    print("\n=== Model comparison (sorted by test R^2) ===")
-    print(table.to_string(index=False, float_format=lambda v: f"{v:.4f}"))
-    table.to_csv(OUT_TABLE, index=False)
-    print(f"[save] {OUT_TABLE}")
-
-    by_short = {r["short"]: r for r in results}
-    if args.pick is not None:
-        if args.pick not in by_short:
-            raise SystemExit(f"--pick {args.pick!r} unknown. choose one of {list(by_short)}")
-        chosen = by_short[args.pick]
-    elif args.auto or not sys.stdin.isatty():
-        chosen = by_short[table.iloc[0]["short"]]
-        print(f"[auto] picking {chosen['model']} (best test R^2)")
-    else:
-        prompt = (
-            "\nEnter the short name of the model to keep "
-            f"({'/'.join(by_short)}), or press Enter for the best test R^2: "
-        )
-        ans = input(prompt).strip().lower()
-        if not ans:
-            chosen = by_short[table.iloc[0]["short"]]
-        elif ans in by_short:
-            chosen = by_short[ans]
-        else:
-            raise SystemExit(f"Unknown choice {ans!r}; expected one of {list(by_short)}")
-
-    bundle = {
-        "model": chosen["_pipeline"],
-        "feature_names": FEATURE_COLS,
-        "target_name": TARGET_COL,
-        "metrics": {k: chosen[k] for k in ("model", "train_R2", "test_R2", "test_RMSE", "test_MAE")},
-    }
-    joblib.dump(bundle, OUT_BUNDLE)
-    print(f"\n[save] {OUT_BUNDLE}")
-    print(f"[done] kept: {chosen['model']}  test_R2={chosen['test_R2']:.4f}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

Scripts_ML_GPP/apply_gpp_to_states.py

@@ -1,160 +0,0 @@
-"""Apply the trained GPP model to per-state LAI+weather .npy files.
-
-Reads:
-    ../{state}/data_LAI_geo_wx_2017_to_21/LAI_wx_geo_{state}_120d_{year}.npy
-    each of shape (n_pixels, 120, 8) with channels:
-        [DOY1, LAI, lon, lat, DOY2, SSI(=SRad), Tmax, Tmin]
-
-Writes (per state, per year):
-    ../{state}/data_GPP_2017_to_21/GPP_{state}_120d_{year}.npy
-        shape (n_pixels, 120, 2) with channels [DOY, GPP]
-    ../{state}/data_GPP_2017_to_21/GPP_{state}_120d_{year}_summary.csv
-        per-DOY mean/std/min/max across pixels (handy quick-look)
-
-Usage:
-    uv run python apply_gpp_to_states.py
-    uv run python apply_gpp_to_states.py --states BadenW Bayern --years 2020 2021
-    uv run python apply_gpp_to_states.py --bundle gpp_best_model.joblib
-"""
-
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-
-import joblib
-import numpy as np
-import pandas as pd
-
-HERE = Path(__file__).resolve().parent
-PROJECT_ROOT = HERE.parent
-DEFAULT_BUNDLE = HERE / "gpp_best_model.joblib"
-
-DEFAULT_STATES = [
-    "BadenW", "Bayern", "Brandenburg", "Hessen", "MecklenburgV",
-    "Niedersachsen", "NordrheinW", "RheinlandP", "Saarland",
-    "Sachsen", "SachsenA", "SchleswigH", "Thuringen",
-]
-DEFAULT_YEARS = [2017, 2018, 2019, 2020, 2021]
-
-NPY_CHANNELS = ["DOY1", "LAI", "lon", "lat", "DOY2", "SSI", "Tmax", "Tmin"]
-NPY_IDX = {name: i for i, name in enumerate(NPY_CHANNELS)}
-
-CSV_TO_NPY = {"DOY": "DOY2", "SLAI": "LAI", "Tmax": "Tmax", "Tmin": "Tmin", "SRad": "SSI"}
-
-
-def build_feature_matrix(arr: np.ndarray, feature_names: list[str]) -> np.ndarray:
-    """Map (pixels, 120, 8) -> (pixels*120, len(feature_names)) using CSV->npy mapping."""
-
-    pixels, days, n_chan = arr.shape
-    if n_chan != len(NPY_CHANNELS):
-        raise ValueError(
-            f"Expected {len(NPY_CHANNELS)} channels in .npy file, got {n_chan}. "
-            f"Update NPY_CHANNELS if the layout changed."
-        )
-
-    cols = []
-    for f in feature_names:
-        if f not in CSV_TO_NPY:
-            raise KeyError(
-                f"Don't know how to map training feature {f!r} to a channel in the .npy file. "
-                f"Known mappings: {CSV_TO_NPY}"
-            )
-        cols.append(arr[:, :, NPY_IDX[CSV_TO_NPY[f]]].reshape(-1))
-    return np.stack(cols, axis=1)
-
-
-def per_doy_summary(doy: np.ndarray, gpp: np.ndarray) -> pd.DataFrame:
-    """Summarise GPP across pixels for each DOY column (length 120)."""
-
-    n_pixels, n_days = gpp.shape
-    doy_per_day = doy[0]
-    return pd.DataFrame({
-        "DOY": doy_per_day.astype(int),
-        "GPP_mean": gpp.mean(axis=0),
-        "GPP_std": gpp.std(axis=0),
-        "GPP_min": gpp.min(axis=0),
-        "GPP_max": gpp.max(axis=0),
-        "n_pixels": np.full(n_days, n_pixels, dtype=int),
-    })
-
-
-def process_one(arr_path: Path, out_dir: Path, model, feature_names: list[str]) -> Path:
-    arr = np.load(arr_path)
-    pixels, days, _ = arr.shape
-
-    X = build_feature_matrix(arr, feature_names)
-    yhat = model.predict(X).astype(np.float32).reshape(pixels, days)
-
-    doy = arr[:, :, NPY_IDX["DOY2"]].astype(np.float32)
-    out = np.stack([doy, yhat], axis=2)
-
-    out_dir.mkdir(parents=True, exist_ok=True)
-    out_path = out_dir / arr_path.name.replace("LAI_wx_geo_", "GPP_")
-    np.save(out_path, out)
-
-    summary_path = out_path.with_name(out_path.stem + "_summary.csv")
-    per_doy_summary(doy, yhat).to_csv(summary_path, index=False)
-    return out_path
-
-
-def parse_args() -> argparse.Namespace:
-    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawTextHelpFormatter)
-    p.add_argument("--bundle", default=str(DEFAULT_BUNDLE),
-                   help=f"joblib bundle saved by train_gpp_models.py (default: {DEFAULT_BUNDLE.name})")
-    p.add_argument("--root", default=str(PROJECT_ROOT),
-                   help=f"Project root that contains per-state folders (default: {PROJECT_ROOT})")
-    p.add_argument("--states", nargs="+", default=DEFAULT_STATES,
-                   help="Subset of state folder names to process.")
-    p.add_argument("--years", nargs="+", type=int, default=DEFAULT_YEARS,
-                   help="Subset of years to process.")
-    p.add_argument("--out-folder", default="data_GPP_2017_to_21",
-                   help="Output sub-folder name created inside each state directory.")
-    return p.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-    bundle_path = Path(args.bundle)
-    if not bundle_path.exists():
-        raise SystemExit(
-            f"Model bundle {bundle_path} not found. Run train_gpp_models.py first."
-        )
-
-    bundle = joblib.load(bundle_path)
-    model = bundle["model"]
-    feature_names = bundle["feature_names"]
-    metrics = bundle.get("metrics", {})
-    print(f"[load] {bundle_path}")
-    print(f"[load] model='{metrics.get('model', type(model).__name__)}'  "
-          f"test_R2={metrics.get('test_R2', float('nan')):.4f}  "
-          f"features={feature_names}")
-
-    root = Path(args.root)
-    n_done = n_skipped = 0
-    for state in args.states:
-        in_dir = root / state / "data_LAI_geo_wx_2017_to_21"
-        out_dir = root / state / args.out_folder
-        if not in_dir.is_dir():
-            print(f"[skip] {state}: no folder {in_dir}")
-            n_skipped += 1
-            continue
-        for year in args.years:
-            arr_path = in_dir / f"LAI_wx_geo_{state}_120d_{year}.npy"
-            if not arr_path.exists():
-                print(f"[skip] {state} {year}: missing {arr_path.name}")
-                n_skipped += 1
-                continue
-            out_path = process_one(arr_path, out_dir, model, feature_names)
-            arr_size_mb = arr_path.stat().st_size / 1e6
-            out_size_mb = out_path.stat().st_size / 1e6
-            print(f"[ok ] {state:14s} {year}  "
-                  f"in={arr_size_mb:6.1f}MB  out={out_size_mb:5.1f}MB  -> {out_path}")
-            n_done += 1
-
-    print(f"\n[done] {n_done} files written, {n_skipped} skipped")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

Scripts_ML_GPP/apply_gpp_to_states_CC.py

@@ -1,148 +0,0 @@
-"""Apply the trained GPP model to per-state LAI+weather .npy files
-under climate-change (CC) scenarios.
-
-Reads (per state, per scenario, per year):
-    ../{state}/data_LAI_geo_wx_CC{ref_year}_{rcp}/LAI_wx_geo_{state}_120d_{file_year}.npy
-    each of shape (n_pixels, 120, 8) with channels:
-        [DOY1, LAI, lon, lat, DOY2, SSI(=SRad), Tmax, Tmin]
-
-Note: each CC folder typically contains 5 yearly files spanning a 5-year window
-ending shortly before the reference year, e.g.:
-    CC2050 -> 2041..2045
-    CC2070 -> 2061..2065
-    CC2090 -> 2081..2085
-This script discovers every .npy in each scenario folder, so it works regardless
-of which file_years are present.
-
-Writes (per state, per scenario, per year):
-    ../{state}/data_GPP_CC{ref_year}_{rcp}_ML/GPP_{state}_120d_{file_year}.npy
-        shape (n_pixels, 120, 2) with channels [DOY, GPP]
-    ../{state}/data_GPP_CC{ref_year}_{rcp}_ML/GPP_{state}_120d_{file_year}_summary.csv
-        per-DOY mean/std/min/max across pixels.
-
-Usage:
-    uv run python apply_gpp_to_states_CC.py
-    uv run python apply_gpp_to_states_CC.py --states BadenW Bayern
-    uv run python apply_gpp_to_states_CC.py --ref-years 2050 2090 --rcps RCP85
-    uv run python apply_gpp_to_states_CC.py --bundle gpp_best_model.joblib
-"""
-
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-
-import joblib
-import numpy as np
-
-from apply_gpp_to_states import (
-    DEFAULT_STATES,
-    NPY_IDX,
-    build_feature_matrix,
-    per_doy_summary,
-)
-
-HERE = Path(__file__).resolve().parent
-PROJECT_ROOT = HERE.parent
-DEFAULT_BUNDLE = HERE / "gpp_best_model.joblib"
-
-DEFAULT_REF_YEARS = [2050, 2070, 2090]
-DEFAULT_RCPS = ["RCP26", "RCP85"]
-
-
-def process_one(arr_path: Path, out_dir: Path, model, feature_names: list[str]) -> Path | None:
-    """Run inference on a single CC .npy file. Returns None if the file is empty/corrupt."""
-
-    if arr_path.stat().st_size == 0:
-        return None
-    try:
-        arr = np.load(arr_path)
-    except (EOFError, ValueError, OSError):
-        return None
-    if arr.ndim != 3:
-        return None
-    pixels, days, _ = arr.shape
-
-    X = build_feature_matrix(arr, feature_names)
-    yhat = model.predict(X).astype(np.float32).reshape(pixels, days)
-
-    doy = arr[:, :, NPY_IDX["DOY2"]].astype(np.float32)
-    out = np.stack([doy, yhat], axis=2)
-
-    out_dir.mkdir(parents=True, exist_ok=True)
-    out_path = out_dir / arr_path.name.replace("LAI_wx_geo_", "GPP_")
-    np.save(out_path, out)
-
-    summary_path = out_path.with_name(out_path.stem + "_summary.csv")
-    per_doy_summary(doy, yhat).to_csv(summary_path, index=False)
-    return out_path
-
-
-def parse_args() -> argparse.Namespace:
-    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawTextHelpFormatter)
-    p.add_argument("--bundle", default=str(DEFAULT_BUNDLE),
-                   help=f"joblib bundle saved by train_gpp_models.py (default: {DEFAULT_BUNDLE.name})")
-    p.add_argument("--root", default=str(PROJECT_ROOT),
-                   help=f"Project root that contains per-state folders (default: {PROJECT_ROOT})")
-    p.add_argument("--states", nargs="+", default=DEFAULT_STATES,
-                   help="Subset of state folder names to process.")
-    p.add_argument("--ref-years", nargs="+", type=int, default=DEFAULT_REF_YEARS,
-                   help="Reference years (folder labels): default 2050 2070 2090.")
-    p.add_argument("--rcps", nargs="+", default=DEFAULT_RCPS,
-                   help="Scenario tags (default: RCP26 RCP85).")
-    return p.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-    bundle_path = Path(args.bundle)
-    if not bundle_path.exists():
-        raise SystemExit(
-            f"Model bundle {bundle_path} not found. Run train_gpp_models.py first."
-        )
-
-    bundle = joblib.load(bundle_path)
-    model = bundle["model"]
-    feature_names = bundle["feature_names"]
-    metrics = bundle.get("metrics", {})
-    print(f"[load] {bundle_path}")
-    print(f"[load] model='{metrics.get('model', type(model).__name__)}'  "
-          f"test_R2={metrics.get('test_R2', float('nan')):.4f}  "
-          f"features={feature_names}")
-
-    root = Path(args.root)
-    n_done = n_skipped = 0
-    for state in args.states:
-        for ref_year in args.ref_years:
-            for rcp in args.rcps:
-                in_dir = root / state / f"data_LAI_geo_wx_CC{ref_year}_{rcp}"
-                out_dir = root / state / f"data_GPP_CC{ref_year}_{rcp}_ML"
-                if not in_dir.is_dir():
-                    print(f"[skip] {state} CC{ref_year} {rcp}: no folder {in_dir}")
-                    n_skipped += 1
-                    continue
-                arr_paths = sorted(in_dir.glob(f"LAI_wx_geo_{state}_120d_*.npy"))
-                if not arr_paths:
-                    print(f"[skip] {state} CC{ref_year} {rcp}: no .npy files in {in_dir}")
-                    n_skipped += 1
-                    continue
-                for arr_path in arr_paths:
-                    file_year = arr_path.stem.split("_")[-1]
-                    out_path = process_one(arr_path, out_dir, model, feature_names)
-                    if out_path is None:
-                        print(f"[skip] {state:14s} CC{ref_year} {rcp}  "
-                              f"yr={file_year}  empty/corrupt input ({arr_path.name})")
-                        n_skipped += 1
-                        continue
-                    in_mb = arr_path.stat().st_size / 1e6
-                    out_mb = out_path.stat().st_size / 1e6
-                    print(f"[ok ] {state:14s} CC{ref_year} {rcp}  "
-                          f"yr={file_year}  in={in_mb:6.1f}MB  out={out_mb:5.1f}MB  -> {out_path}")
-                    n_done += 1
-
-    print(f"\n[done] {n_done} files written, {n_skipped} skipped")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

Scripts_ML_GPP/gpp_model_comparison.csv

@@ -1,8 +0,0 @@
-model,train_R2,test_R2,test_RMSE,test_MAE,short
-ExT,0.9999957154007364,0.7362586543064307,2.7146117209808143,2.04557304587156,et
-RF,0.9649085840575606,0.724795323367248,2.7729785866539265,2.1082658587811256,rf
-XGB,0.9834621347498868,0.7140691320624206,2.8265009276259936,2.103869253974442,xgb
-GB,0.8717985317627104,0.7127967590072579,2.8327828160243502,2.1704373565995185,gb
-HGB,0.9534688493650066,0.7078201243981701,2.8572205231836296,2.1661548654525165,hgb
-SVR,0.7097001689945401,0.7044915973771844,2.8734492304788954,2.1869617198118716,svr
-LightGBM,0.9942791618090159,0.6894203391848521,2.945812608689964,2.222975569060012,lgbm

Scripts_ML_GPP/main.py

@@ -1,6 +0,0 @@
-def main():
-    print("Hello from sim-gpp-wh-uv!")
-
-
-if __name__ == "__main__":
-    main()

Scripts_ML_GPP/train_gpp_models.py

@@ -1,249 +0,0 @@
-"""Train ML regressors to simulate GPP from DOY, LAI, Tmax, Tmin, SRad.
-
-Inputs:  combined_wheat_RSCM_out_v2.csv  (columns include DOY, SLAI, Tmax, Tmin, SRad, GPP)
-Models:  SVR, RandomForest, ExtraTrees, HistGradientBoosting, GradientBoosting, XGBoost, LightGBM
-Output:  gpp_best_model.joblib  (chosen model bundled with its StandardScaler and feature names)
-         gpp_model_comparison.csv
-         gpp_parity_<model>.png  (one parity plot per model on the test split)
-
-Usage:
-    uv run python train_gpp_models.py                # interactive: pick the model after table is shown
-    uv run python train_gpp_models.py --auto         # auto-pick the model with the best test R^2
-    uv run python train_gpp_models.py --pick xgb     # pick a specific model by short name
-"""
-
-from __future__ import annotations
-
-import argparse
-import sys
-from pathlib import Path
-
-import joblib
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-from sklearn.ensemble import (
-    ExtraTreesRegressor,
-    GradientBoostingRegressor,
-    HistGradientBoostingRegressor,
-    RandomForestRegressor,
-)
-from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
-from sklearn.model_selection import train_test_split
-from sklearn.pipeline import Pipeline
-from sklearn.preprocessing import StandardScaler
-from sklearn.svm import SVR
-
-import lightgbm as lgb
-import xgboost as xgb
-
-HERE = Path(__file__).resolve().parent
-CSV_PATH = HERE / "combined_wheat_RSCM_out_v2.csv"
-OUT_BUNDLE = HERE / "gpp_best_model.joblib"
-OUT_TABLE = HERE / "gpp_model_comparison.csv"
-
-FEATURE_COLS = ["DOY", "SLAI", "Tmax", "Tmin", "SRad"]
-TARGET_COL = "GPP"
-RANDOM_STATE = 42
-
-
-def build_models() -> dict[str, tuple[str, Pipeline]]:
-    """Return short_name -> (display_name, sklearn Pipeline)."""
-
-    return {
-        "svr": (
-            "Support Vector Regression",
-            Pipeline([
-                ("scaler", StandardScaler()),
-                ("model", SVR(kernel="rbf", C=10.0, gamma="scale", epsilon=0.1)),
-            ]),
-        ),
-        "rf": (
-            "Random Forest",
-            Pipeline([
-                ("scaler", StandardScaler(with_mean=False, with_std=False)),
-                ("model", RandomForestRegressor(
-                    n_estimators=400, max_depth=None, n_jobs=-1, random_state=RANDOM_STATE,
-                )),
-            ]),
-        ),
-        "et": (
-            "Extra Trees",
-            Pipeline([
-                ("scaler", StandardScaler(with_mean=False, with_std=False)),
-                ("model", ExtraTreesRegressor(
-                    n_estimators=500, max_depth=None, n_jobs=-1, random_state=RANDOM_STATE,
-                )),
-            ]),
-        ),
-        "hgb": (
-            "Histogram Gradient Boosting",
-            Pipeline([
-                ("scaler", StandardScaler(with_mean=False, with_std=False)),
-                ("model", HistGradientBoostingRegressor(
-                    max_iter=500, learning_rate=0.05, max_depth=None,
-                    random_state=RANDOM_STATE,
-                )),
-            ]),
-        ),
-        "gb": (
-            "Gradient Boosting",
-            Pipeline([
-                ("scaler", StandardScaler(with_mean=False, with_std=False)),
-                ("model", GradientBoostingRegressor(
-                    n_estimators=400, learning_rate=0.05, max_depth=4,
-                    random_state=RANDOM_STATE,
-                )),
-            ]),
-        ),
-        "xgb": (
-            "XGBoost",
-            Pipeline([
-                ("scaler", StandardScaler(with_mean=False, with_std=False)),
-                ("model", xgb.XGBRegressor(
-                    n_estimators=600, learning_rate=0.05, max_depth=6,
-                    subsample=0.9, colsample_bytree=0.9,
-                    objective="reg:squarederror", tree_method="hist",
-                    n_jobs=-1, random_state=RANDOM_STATE, verbosity=0,
-                )),
-            ]),
-        ),
-        "lgbm": (
-            "LightGBM",
-            Pipeline([
-                ("scaler", StandardScaler(with_mean=False, with_std=False)),
-                ("model", lgb.LGBMRegressor(
-                    n_estimators=800, learning_rate=0.05, num_leaves=63,
-                    subsample=0.9, colsample_bytree=0.9, min_child_samples=20,
-                    n_jobs=-1, random_state=RANDOM_STATE, verbosity=-1,
-                )),
-            ]),
-        ),
-    }
-
-
-def load_dataset(csv_path: Path) -> tuple[np.ndarray, np.ndarray, pd.DataFrame]:
-    df = pd.read_csv(csv_path)
-    needed = FEATURE_COLS + [TARGET_COL]
-    missing = [c for c in needed if c not in df.columns]
-    if missing:
-        raise SystemExit(f"CSV {csv_path} is missing required columns: {missing}")
-
-    df = df.dropna(subset=needed).copy()
-    X = df[FEATURE_COLS].to_numpy(dtype=np.float64)
-    y = df[TARGET_COL].to_numpy(dtype=np.float64)
-    return X, y, df
-
-
-def evaluate(name: str, model: Pipeline, X_train, X_test, y_train, y_test) -> dict:
-    model.fit(X_train, y_train)
-    yhat_train = model.predict(X_train)
-    yhat_test = model.predict(X_test)
-    return {
-        "model": name,
-        "train_R2": r2_score(y_train, yhat_train),
-        "test_R2": r2_score(y_test, yhat_test),
-        "test_RMSE": float(np.sqrt(mean_squared_error(y_test, yhat_test))),
-        "test_MAE": mean_absolute_error(y_test, yhat_test),
-        "_yhat_test": yhat_test,
-        "_pipeline": model,
-    }
-
-
-def parity_plot(y_true, y_pred, title: str, out_png: Path) -> None:
-    fig, ax = plt.subplots(figsize=(5.0, 5.0))
-    ax.scatter(y_true, y_pred, s=8, alpha=0.4, edgecolor="none")
-    lo = float(min(y_true.min(), y_pred.min()))
-    hi = float(max(y_true.max(), y_pred.max()))
-    ax.plot([lo, hi], [lo, hi], "k--", lw=1.0)
-    r2 = r2_score(y_true, y_pred)
-    rmse = float(np.sqrt(mean_squared_error(y_true, y_pred)))
-    ax.set_xlabel(f"Observed {TARGET_COL}")
-    ax.set_ylabel(f"Predicted {TARGET_COL}")
-    ax.set_title(f"{title}\nR^2 = {r2:.3f} | RMSE = {rmse:.3f}")
-    ax.grid(True, alpha=0.3)
-    fig.tight_layout()
-    fig.savefig(out_png, dpi=140)
-    plt.close(fig)
-
-
-def parse_args() -> argparse.Namespace:
-    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawTextHelpFormatter)
-    p.add_argument("--csv", default=str(CSV_PATH), help=f"Path to CSV (default: {CSV_PATH.name})")
-    p.add_argument("--test-size", type=float, default=0.2)
-    p.add_argument("--seed", type=int, default=RANDOM_STATE)
-    p.add_argument("--auto", action="store_true",
-                   help="Skip the prompt and pick the model with the best test R^2.")
-    p.add_argument("--pick", default=None,
-                   help="Pick a specific model by short name (svr, rf, et, hgb, gb, xgb, lgbm).")
-    return p.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-
-    print(f"[load] {args.csv}")
-    X, y, df = load_dataset(Path(args.csv))
-    print(f"[load] features={FEATURE_COLS}  target={TARGET_COL}  rows={len(df):,}")
-
-    X_train, X_test, y_train, y_test = train_test_split(
-        X, y, test_size=args.test_size, random_state=args.seed,
-    )
-    print(f"[split] train={len(X_train):,}  test={len(X_test):,}")
-
-    models = build_models()
-    results: list[dict] = []
-    for short, (display, pipe) in models.items():
-        print(f"[fit ] {display:32s} ...", end=" ", flush=True)
-        res = evaluate(display, pipe, X_train, X_test, y_train, y_test)
-        res["short"] = short
-        results.append(res)
-        print(f"R2={res['test_R2']:.3f}  RMSE={res['test_RMSE']:.3f}  MAE={res['test_MAE']:.3f}")
-        parity_plot(y_test, res["_yhat_test"], display,
-                    HERE / f"gpp_parity_{short}.png")
-
-    table = pd.DataFrame([
-        {k: v for k, v in r.items() if not k.startswith("_") and k != "short"}
-        | {"short": r["short"]}
-        for r in results
-    ]).sort_values("test_R2", ascending=False).reset_index(drop=True)
-    print("\n=== Model comparison (sorted by test R^2) ===")
-    print(table.to_string(index=False, float_format=lambda v: f"{v:.4f}"))
-    table.to_csv(OUT_TABLE, index=False)
-    print(f"[save] {OUT_TABLE}")
-
-    by_short = {r["short"]: r for r in results}
-    if args.pick is not None:
-        if args.pick not in by_short:
-            raise SystemExit(f"--pick {args.pick!r} unknown. choose one of {list(by_short)}")
-        chosen = by_short[args.pick]
-    elif args.auto or not sys.stdin.isatty():
-        chosen = by_short[table.iloc[0]["short"]]
-        print(f"[auto] picking {chosen['model']} (best test R^2)")
-    else:
-        prompt = (
-            "\nEnter the short name of the model to keep "
-            f"({'/'.join(by_short)}), or press Enter for the best test R^2: "
-        )
-        ans = input(prompt).strip().lower()
-        if not ans:
-            chosen = by_short[table.iloc[0]["short"]]
-        elif ans in by_short:
-            chosen = by_short[ans]
-        else:
-            raise SystemExit(f"Unknown choice {ans!r}; expected one of {list(by_short)}")
-
-    bundle = {
-        "model": chosen["_pipeline"],
-        "feature_names": FEATURE_COLS,
-        "target_name": TARGET_COL,
-        "metrics": {k: chosen[k] for k in ("model", "train_R2", "test_R2", "test_RMSE", "test_MAE")},
-    }
-    joblib.dump(bundle, OUT_BUNDLE)
-    print(f"\n[save] {OUT_BUNDLE}")
-    print(f"[done] kept: {chosen['model']}  test_R2={chosen['test_R2']:.4f}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())