Blame for Finest_Models/scripts/evaluate_v3.py

r"""
evaluate_v3.py — AtmosIQ v3 evaluation. Fresh file; never imports old models/ code.

Reports (spatial-held-out test nodes, full-graph forward, de-standardized to concentration):
  1. Per-pollutant R2/RMSE/MAE at ALL horizons 0-3 (blueprint §10 primary + forecast).
  2. HONEST XGBoost tag: 'BEAT' only if R2 > xgb AND R2 > 0. Negative-vs-negative is not a win.
  3. Reasoning ablations on identical days: no_graph (edges removed), no_physics (flat edge
     bias), no_temporal (window collapsed to 1 day). graph_gain = full - no_graph.
  4. ORPHAN eval: test nodes' satellite+static [MASK]ed -> gap-fill from neighbors only.
     This is the T-2 ungauged-cell deployment story measured directly.
  5. alpha_self per GAT layer (mean self-attention share; ~1.0 = graph unused).

PRE-REGISTERED SUCCESS CRITERIA (fixed before the run; no after-the-fact rationalizing):
  S1  graph_gain > +0.03 on pm2_5 AND pm10, and graph_gain > 0 on >=5/7 pollutants
  S2  orphan-eval pm2_5 R2 > 0 (graph carries real signal to blind nodes)
  S3  mean alpha_self < 0.9 on the full graph

Run: python data/models_v3/evaluate_v3.py --tensors data/tensors --ckpt data/ckpt_v3/atmosiq_v3_best.pt
"""
from __future__ import annotations
import os, sys, json, argparse, pathlib
import numpy as np, torch
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
import model as MODEL
from model import AtmosIQNet
from dataset_v3 import AtmosDataV3

POLL = ["pm2_5", "pm10", "no2", "so2", "co", "o3", "nh3"]


def load(a, dev):
    meta = json.load(open(pathlib.Path(a.tensors) / "meta.json"))
    data = AtmosDataV3(a.tensors, window=a.window, device=dev)
    cfg = {"calendar_num_dim": meta["dimsD_num"],
           "n_recon_channels": 9 + meta["dimsB"] + meta["dimsC_static"] + meta["dimsC_yearly"],
           "categorical": {"land_use_class": 4, "grap_stage": 3,
                           "n_landuse": meta["n_landuse"], "n_grap": meta["n_grap"]}}
    net = AtmosIQNet(cfg).to(dev)
    net.load_state_dict(torch.load(a.ckpt, map_location=dev)); net.eval()
    nz = np.load(pathlib.Path(a.tensors) / "norm.npz")
    assert "y_logmean" in nz, "norm.npz missing y_logmean/y_logstd — refusing to evaluate without de-standardization"
    ylm = torch.tensor(nz["y_logmean"]).float().to(dev)
    yls = torch.tensor(nz["y_logstd"]).float().to(dev)
    return meta, data, net, ylm, yls


def predict(net, b, ylm, yls, gm=None, mode="full"):
    ei, eh, nh = b["ei"], b["e_hat"], b["n_hat"]
    wu, wv, blh = b["wu"], b["wv"], b["blh"]
    groups_t = b["groups_t"]
    if mode == "no_graph":
        ei = torch.zeros(2, 0, dtype=torch.long, device=ei.device)
        eh = torch.zeros(0, device=eh.device); nh = torch.zeros(0, device=nh.device)
    if mode == "no_temporal":
        groups_t = groups_t[-1:]
        wu, wv, blh = wu[-1:], wv[-1:], blh[-1:]
        gm = gm[-1:] if gm is not None else None
    orig = MODEL.phys_log_bias
    if mode == "no_physics":
        MODEL.phys_log_bias = lambda *ar, **kw: torch.zeros_like(ar[4])   # ar[4] = e_hat -> [E]
    try:
        out = net(groups_t, ei, eh, nh, wu, wv, blh, b["comp"], gm)
    finally:
        MODEL.phys_log_bias = orig
    mu = out["mu"] * yls.view(1, 1, -1) + ylm.view(1, 1, -1)              # de-standardize
    return (torch.exp(mu.clamp(max=12)) - 1e-3).clamp_min(0)             # invert log(y+eps)


def collect(data, net, ylm, yls, days, mode="full", orphan=False):
    te = (data.split == 2)
    Ys = {p: {h: [] for h in range(4)} for p in POLL}
    Ps = {p: {h: [] for h in range(4)} for p in POLL}
    with torch.no_grad():
        for t in days:
            b = data.full_window(t)
            gm = None
            if orphan:
                o = te.float().to(b["comp"].device)
                gm = [{"satellite": o, "static": o} for _ in b["groups_t"]]
            pred = predict(net, b, ylm, yls, gm, mode)
            m = b["m"] * te.float().view(-1, 1, 1).to(pred.device)
            y = b["y"]
            for j, p in enumerate(POLL):
                for h in range(4):
                    mm = m[:, h, j] > 0
                    if mm.any():
                        Ys[p][h].append(y[mm, h, j].cpu()); Ps[p][h].append(pred[mm, h, j].cpu())
    return Ys, Ps


def r2_table(Ys, Ps, horizons=(0,)):
    out = {}
    for p in POLL:
        out[p] = {}
        for h in horizons:
            if not Ys[p][h]:
                out[p][h] = None; continue
            y = torch.cat(Ys[p][h]).numpy(); pr = torch.cat(Ps[p][h]).numpy()
            pr = np.nan_to_num(pr, nan=float(np.mean(y)))
            ss = ((y - pr) ** 2).sum(); st = ((y - y.mean()) ** 2).sum() + 1e-9
            out[p][h] = (1 - ss / st, float(np.sqrt(((y - pr) ** 2).mean())),
                         float(np.abs(y - pr).mean()), len(y))
    return out


def attn_stats(net, b):
    """Mean alpha_self per GAT layer on a real full-graph window (replicates model.encode)."""
    with torch.no_grad():
        T = len(b["groups_t"]); N = b["groups_t"][0]["satellite"].shape[0]
        H = torch.cat([net.assemble(g) for g in b["groups_t"]], 0)
        src, dst = b["ei"][0], b["ei"][1]
        offs = (torch.arange(T, device=src.device) * N).view(T, 1)
        ei_b = torch.stack([(src.unsqueeze(0) + offs).reshape(-1),
                            (dst.unsqueeze(0) + offs).reshape(-1)])
        lb = torch.cat([MODEL.phys_log_bias(b["wu"][t], b["wv"][t], b["blh"][t],
                                            src, b["e_hat"], b["n_hat"]) for t in range(T)])
        stats = []
        for g in net.gats:
            H, att = g(H, ei_b, lb, return_attn=True)
            stats.append(float(att["alpha_self"].mean()))
    return stats


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--tensors", default="data/tensors")
    ap.add_argument("--ckpt", default="data/ckpt_v3/atmosiq_v3_best.pt")
    ap.add_argument("--window", type=int, default=7)
    ap.add_argument("--refs", default="data/models/refs.json")
    ap.add_argument("--test_days", type=int, default=0, help="0 = all test days for the main table")
    ap.add_argument("--abl_days", type=int, default=250, help="days for ablation/orphan arms")
    a = ap.parse_args()
    dev = "cuda" if torch.cuda.is_available() else "cpu"; print("device:", dev)
    meta, data, net, ylm, yls = load(a, dev)
    print(f"loaded {a.ckpt} ({sum(p.numel() for p in net.parameters()):,} params)")
    days = data.target_days(2)
    if a.test_days:                     # P0-1: season-balanced stride, not first-K
        s = max(1, len(days) // a.test_days)
        days = days[::s][:a.test_days]
    refs = json.load(open(a.refs)) if os.path.exists(a.refs) else {}
    print(f"test days: {len(days)} | held-out test nodes: {int((data.split == 2).sum())}")

    # 1) full model, all horizons
    Ys, Ps = collect(data, net, ylm, yls, days)
    tab = r2_table(Ys, Ps, horizons=(0, 1, 2, 3))
    print("\n===== v3 — SPATIAL-HELD-OUT (full model, concentration units) =====")
    print(f"{'pollutant':8} {'h':>2} {'n':>7} {'R2':>8} {'RMSE':>8} {'MAE':>8}   vs XGBoost (h0)")
    for p in POLL:
        for h in range(4):
            r = tab[p][h]
            if r is None: continue
            r2, rmse, mae, n = r
            cmpi = ""
            if h == 0:
                xg = refs.get(p, {}).get("xgboost")
                if xg is not None:
                    tag = "BEAT" if (r2 > xg and r2 > 0) else (">=xgb but R2<0" if r2 > xg else "below")
                    cmpi = f"xgb {xg:+.2f}  {tag}"
            print(f"{p:8} {h:>2} {n:>7} {r2:>+8.3f} {rmse:>8.2f} {mae:>8.2f}   {cmpi}")

    # 2-3) reasoning ablations on identical day subset
    abl_days = days[:a.abl_days]
    print(f"\n===== reasoning ablations ({len(abl_days)} test days, horizon 0) =====")
    arms = {}
    for mode in ["full", "no_graph", "no_physics", "no_temporal"]:
        Ys2, Ps2 = collect(data, net, ylm, yls, abl_days, mode=mode)
        arms[mode] = r2_table(Ys2, Ps2)
    print(f"{'pollutant':8} {'full':>8} {'no_graph':>9} {'no_phys':>9} {'no_temp':>9} {'graph_gain':>11}")
    gains = {}
    for p in POLL:
        row = [(arms[m][p][0][0] if arms[m][p][0] else float("nan"))
               for m in ["full", "no_graph", "no_physics", "no_temporal"]]
        gains[p] = row[0] - row[1]
        print(f"{p:8} {row[0]:>+8.3f} {row[1]:>+9.3f} {row[2]:>+9.3f} {row[3]:>+9.3f} {gains[p]:>+11.3f}")

    # 4) orphan eval — the T-2 deployment measurement
    Yo, Po = collect(data, net, ylm, yls, abl_days, orphan=True)
    otab = r2_table(Yo, Po)
    print("\n===== ORPHAN eval (test nodes satellite+static MASKED -> neighbors only) =====")
    for p in POLL:
        if otab[p][0] and arms["full"][p][0]:
            print(f"  {p:8} orphan R2={otab[p][0][0]:+.3f}   (full={arms['full'][p][0][0]:+.3f})")

    # 5) attention distribution
    st = attn_stats(net, data.full_window(days[0]))
    print(f"\nalpha_self per GAT layer (full graph): {['%.3f' % s for s in st]}   (~1.0 = graph unused)")

    # verdict against pre-registered criteria
    ok1 = (gains.get("pm2_5", 0) > 0.03 and gains.get("pm10", 0) > 0.03
           and sum(1 for g in gains.values() if g > 0) >= 5)
    ok2 = bool(otab["pm2_5"][0] and otab["pm2_5"][0][0] > 0)
    ok3 = (sum(st) / len(st) < 0.9)
    print("\n===== PRE-REGISTERED CRITERIA =====")
    print(f"  S1 graph_gain (pm2_5&pm10 > +0.03, >=5/7 positive): {'PASS' if ok1 else 'FAIL'}")
    print(f"  S2 orphan pm2_5 R2 > 0:                             {'PASS' if ok2 else 'FAIL'}")
    print(f"  S3 mean alpha_self < 0.9:                           {'PASS' if ok3 else 'FAIL'}")


if __name__ == "__main__":
    main()