| r""" |
| train_v3.py — AtmosIQ v3.1 training. Architecture FROZEN (model.py verbatim). Protocol pins: |
| TP-1 full pruned-graph training (mean-degree assert in dataset_v3; sampler deleted) |
| TP-2 ORPHAN masking in finetune (p_orphan labeled nodes: Group A blackout all T, |
| completeness->0, labels still supervised -> gradient must route via neighbors) |
| TP-3 physics losses ON by default (lam_phys=0.05) |
| TP-4 loud guards: per-epoch skip-rate; > max_skip -> hard ABORT |
| TP-5 coordinate jitter in finetune (Gaussian on projection_x/y, sigma=0.1 std ~15-25km): |
| kills exact-position lookup shortcut while keeping coarse positional signal |
| P0-1 stride-sampled val/probe-eval days (season-balanced, deterministic) |
| P0-2 finetune val on train+val graph ONLY (test nodes never context for model selection); |
| probe EVAL stays full-graph per SSL_ROADMAP §7 pin (held-out nodes must be present) |
| Stages: pretrain -> probe (raw-space R², branch suggestion, PROVISIONAL until refs.json |
| space confirmed) -> finetune (early stop on season-balanced val NLL). |
| Checkpoints: <tensors>/../encoder_v3.pt , atmosiq_v3_best.pt , train_state_v3.json |
| Run: python data/models_v3/train_v3.py --tensors data/tensors --stage all |
| """ |
| from __future__ import annotations |
| import os, sys, json, argparse, pathlib, time |
| import numpy as np, torch, torch.nn as nn, torch.nn.functional as F |
| torch.set_num_threads(os.cpu_count() or 8) |
| sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent)) |
| from model import AtmosIQNet, student_t_nll, ssl_recon_loss |
| from dataset_v3 import AtmosDataV3, ssl_mask, recon_from_groups, recon_masked |
|
|
| POLL = ["pm2_5", "pm10", "no2", "so2", "co", "o3", "nh3"] |
| COORD_IDX = (1, 2) |
|
|
| def stride(days, k): |
| """Season-balanced deterministic subset: every len/k-th day (P0-1).""" |
| if not k or k >= len(days): return list(days) |
| s = max(1, len(days) // k) |
| return list(days)[::s][:k] |
|
|
| def grads_finite(net): |
| for p in net.parameters(): |
| if p.grad is not None and not torch.isfinite(p.grad).all(): return False |
| return True |
|
|
| def build_model(meta, dev): |
| n_recon = 9 + meta["dimsB"] + meta["dimsC_static"] + meta["dimsC_yearly"] |
| cfg = {"calendar_num_dim": meta["dimsD_num"], "n_recon_channels": n_recon, |
| "categorical": {"land_use_class": 4, "grap_stage": 3, |
| "n_landuse": meta["n_landuse"], "n_grap": meta["n_grap"]}} |
| return AtmosIQNet(cfg).to(dev), cfg |
|
|
| def epoch_guard(name, skips, steps, max_skip): |
| rate = skips / max(steps, 1) |
| print(f" [{name}] skip_rate={rate:.1%} ({skips}/{steps})", flush=True) |
| if rate > max_skip: |
| raise SystemExit(f"ABORT TP-4: {name} skip-rate {rate:.1%} > {max_skip:.0%} — " |
| f"numerics broke; fix before continuing (no zombie runs).") |
|
|
| def jitter_coords(groups_t, sigma): |
| """TP-5: one noise draw per window (static must not wiggle per day), finetune only.""" |
| if sigma <= 0: return groups_t |
| N = groups_t[0]["static_num"].shape[0]; dev = groups_t[0]["static_num"].device |
| noise = torch.randn(N, len(COORD_IDX), device=dev) * sigma |
| out = [] |
| for g in groups_t: |
| g2 = dict(g); s = g2["static_num"].clone() |
| s[:, COORD_IDX[0]] += noise[:, 0]; s[:, COORD_IDX[1]] += noise[:, 1] |
| g2["static_num"] = s; out.append(g2) |
| return out |
|
|
| def smoothness(net, b, gm, h_seq): |
| """§3 with detached anchor (P1-4, memory): gradient flows through the perturbed |
| branch only — pulls h(x+delta) toward h(x). Recorded deviation from symmetric form.""" |
| noisy = [{k: (v + 0.1 * torch.randn_like(v) if k in ("satellite", "meteorology", "static_num", "calendar_num") else v) |
| for k, v in g.items()} for g in b["groups_t"]] |
| h2 = net.encode(noisy, b["ei"], b["e_hat"], b["n_hat"], b["wu"], b["wv"], b["blh"], gm) |
| return ((h_seq.detach() - h2) ** 2).mean() |
|
|
| |
| def pretrain(data, net, a, dev, tv): |
| opt = torch.optim.AdamW(net.parameters(), lr=a.lr, weight_decay=1e-4) |
| days = list(range(data.w - 1, data.D)) |
| for ep in range(a.ssl_epochs): |
| net.train(); np.random.shuffle(days); tot = 0; n_ok = 0; skips = 0; t0 = time.time() |
| used = days[:a.days_per_epoch] if a.days_per_epoch else days |
| for i, t in enumerate(used): |
| b = data.window(t, tv) |
| gm = ssl_mask(b["groups_t"]) |
| h_seq = net.encode(b["groups_t"], b["ei"], b["e_hat"], b["n_hat"], b["wu"], b["wv"], b["blh"], gm) |
| recon = net.recon(h_seq) |
| tgt, obs = recon_from_groups(b["groups_t"]) |
| L_rec = ssl_recon_loss(recon, tgt, recon_masked(gm) * obs) |
| loss = L_rec |
| if a.lam_smooth > 0 and (i % a.smooth_every == 0): |
| loss = loss + a.lam_smooth * smoothness(net, b, gm, h_seq) |
| opt.zero_grad() |
| if not torch.isfinite(loss): skips += 1; continue |
| loss.backward() |
| if not grads_finite(net): opt.zero_grad(); skips += 1; continue |
| torch.nn.utils.clip_grad_norm_(net.parameters(), 5.0) |
| opt.step(); tot += L_rec.item(); n_ok += 1 |
| if (i + 1) % a.log_every == 0: |
| print(f" [SSL {ep+1}] {i+1}/{len(used)} recon={tot/max(n_ok,1):.4f} " |
| f"{(time.time()-t0)/(i+1):.2f}s/it", flush=True) |
| print(f"[SSL {ep+1}/{a.ssl_epochs}] recon_mse={tot/max(n_ok,1):.4f} {time.time()-t0:.0f}s", flush=True) |
| epoch_guard(f"SSL {ep+1}", skips, len(used), a.max_skip) |
| ck = pathlib.Path(a.tensors).parent / "encoder_v3.pt" |
| torch.save(net.state_dict(), ck); print(f"-> {ck}") |
|
|
| |
| def probe(data, net, meta, a, dev, tv): |
| ck = pathlib.Path(a.tensors).parent / "encoder_v3.pt" |
| if ck.exists(): |
| net.load_state_dict(torch.load(ck, map_location=dev)); print("loaded encoder_v3.pt") |
| for p in net.parameters(): p.requires_grad = False |
| net.eval() |
| nz = np.load(pathlib.Path(a.tensors) / "norm.npz") |
| ylm = torch.tensor(nz["y_logmean"]).float().to(dev) |
| yls = torch.tensor(nz["y_logstd"]).float().to(dev) |
| lin = nn.Linear(meta.get("d_model", 96), 7).to(dev) |
| opt = torch.optim.Adam(lin.parameters(), lr=1e-2) |
| tr_days = data.target_days(0) |
| tr_node_mask = (data.split[tv["nodes"]] == 0).float().unsqueeze(-1).to(dev) |
| for ep in range(a.probe_epochs): |
| np.random.shuffle(tr_days); tot = 0; t0 = time.time(); dd = tr_days[:a.probe_days] |
| for i, t in enumerate(dd): |
| b = data.window(t, tv) |
| with torch.no_grad(): |
| z = net.encode(b["groups_t"], b["ei"], b["e_hat"], b["n_hat"], b["wu"], b["wv"], b["blh"])[:, -1] |
| pred = lin(z) |
| yl = (torch.log(b["y"][:, 0, :].clamp_min(0) + 1e-3) - ylm) / yls |
| m = b["m"][:, 0, :] * tr_node_mask |
| loss = ((pred - yl) ** 2 * m).sum() / m.sum().clamp_min(1) |
| opt.zero_grad(); loss.backward(); opt.step(); tot += loss.item() |
| if (i + 1) % 10 == 0: |
| print(f" [PROBE {ep+1}] {i+1}/{len(dd)} mse={tot/(i+1):.3f} {(time.time()-t0)/(i+1):.2f}s/it", flush=True) |
| print(f"[PROBE {ep+1}/{a.probe_epochs}] {time.time()-t0:.0f}s", flush=True) |
| |
| fv = data.graph_view(None, "full") |
| te = (data.split == 2).float().unsqueeze(-1).to(dev) |
| ev_days = stride(data.target_days(2), a.probe_days) |
| ys = []; ps = []; ms = [] |
| with torch.no_grad(): |
| for t in ev_days: |
| b = data.window(t, fv) |
| z = net.encode(b["groups_t"], b["ei"], b["e_hat"], b["n_hat"], b["wu"], b["wv"], b["blh"])[:, -1] |
| mu = lin(z) * yls.view(1, -1) + ylm.view(1, -1) |
| pred = (torch.exp(mu.clamp(max=12)) - 1e-3).clamp_min(0) |
| ys.append(b["y"][:, 0, :]); ps.append(pred); ms.append(b["m"][:, 0, :] * te) |
| Y = torch.cat(ys); P = torch.cat(ps); M = torch.cat(ms) |
| assert int((M.sum(-1) > 0).sum()) > 0, "probe eval produced no held-out predictions — full-graph forward broken" |
| refs = json.load(open(a.refs)) if a.refs and os.path.exists(a.refs) else {} |
| print(f"\n§7 LINEAR PROBE — spatial-held-out RAW-space R², {len(ev_days)} season-balanced days:") |
| print("NOTE: branch PROVISIONAL until refs.json R²-space (raw vs log) is confirmed against M1 eval code.") |
| res = {} |
| for j, pn in enumerate(POLL): |
| mm = M[:, j] > 0 |
| if mm.sum() < 5: print(f" {pn}: n<5 skip"); continue |
| y = Y[mm, j].cpu().numpy(); p = P[mm, j].cpu().numpy() |
| r2 = 1 - ((y - p) ** 2).sum() / (((y - y.mean()) ** 2).sum() + 1e-9) |
| xg = refs.get(pn, {}).get("xgboost") |
| gap = float(r2 / xg) if (xg is not None and xg > 0) else None |
| res[pn] = dict(r2=float(r2), xgb=xg, gap_closed=gap) |
| gtag = f" gap_closed={gap:+.0%}" if gap is not None else "" |
| print(f" {pn}: probe R²={r2:+.3f}" + (f" (xgb {xg:+.2f}){gtag}" if xg is not None else "")) |
| pm = res.get("pm2_5", {}) |
| sparse_set = ["so2", "co", "o3", "nh3"] |
| pm_pass = pm.get("xgb") is not None and pm.get("r2", -9) >= pm["xgb"] |
| sp_pass = any(res.get(s, {}).get("xgb") is not None and res[s]["r2"] >= res[s]["xgb"] for s in sparse_set) |
| if pm_pass and sp_pass: verdict = "FROZEN (pm2_5 AND >=1 sparse match-or-beat)" |
| elif pm.get("gap_closed") is not None and pm["gap_closed"] < 0.5: verdict = "REFUTED (<50% gap on pm2_5)" |
| else: verdict = "INCONCLUSIVE" |
| print(f" suggested branch: {verdict} — decision is joint, not automatic.") |
| json.dump(res | {"suggested_branch": verdict, "provisional_refs_space": True}, |
| open(pathlib.Path(a.tensors).parent / "probe_result_v3.json", "w"), indent=1) |
|
|
| |
| def physics_losses(pred_log, b): |
| pm = pred_log[:, 0, 0] |
| blh = b["blh"][-1]; rain = b["groups_t"][-1]["meteorology"][:, 7] |
| pm = torch.nan_to_num(pm); blh = torch.nan_to_num(blh); rain = torch.nan_to_num(rain) |
| L_blh = F.relu((pm - pm.mean()) * (blh - blh.mean())).mean().clamp(max=10.0) |
| L_rain = F.relu((pm - pm.mean()) * (rain - rain.mean())).mean().clamp(max=10.0) |
| return torch.nan_to_num(L_blh + L_rain) |
|
|
| def orphan_masks(b, p_orphan): |
| """TP-2: p_orphan of today-labeled nodes -> Group A blackout all T + completeness 0.""" |
| T = len(b["groups_t"]) |
| lab = (b["m"].sum(1).sum(-1) > 0) |
| orph = lab & (torch.rand(lab.shape[0], device=lab.device) < p_orphan) |
| of = orph.float() |
| return [{"satellite": of} for _ in range(T)], b["comp"] * (1 - of), int(orph.sum()) |
|
|
| def finetune(data, net, a, dev, tv, ylm, yls): |
| """LP-FT schedule: freeze_epochs of head-only training at --lr (linear-probe phase, |
| protects the pretrained representation), then unfreeze ALL at --unfreeze_lr. |
| Motivation: probe R2 (frozen encoder) exceeded full-FT R2 on pm2_5 -> naive FT was |
| degrading the representation. Val logs BOTH nll and mu-quality (log-space mse), |
| because nll can worsen through sigma calibration alone.""" |
| ck = pathlib.Path(a.tensors).parent / "encoder_v3.pt" |
| if ck.exists(): |
| net.load_state_dict(torch.load(ck, map_location=dev), strict=False); print("loaded pretrained encoder_v3") |
| enc_p = [p for n, p in net.named_parameters() if not n.startswith("head.")] |
| head_p = [p for n, p in net.named_parameters() if n.startswith("head.")] |
| def make_opt(stage): |
| if stage == "head": |
| for p in enc_p: p.requires_grad = False |
| for p in head_p: p.requires_grad = True |
| return torch.optim.AdamW(head_p, lr=a.lr, weight_decay=a.weight_decay) |
| for p in net.parameters(): p.requires_grad = True |
| return torch.optim.AdamW(net.parameters(), lr=a.unfreeze_lr, weight_decay=a.weight_decay) |
| opt = make_opt("head" if a.freeze_epochs > 0 else "all") |
| print(f"LP-FT: {a.freeze_epochs} head-only epochs @lr={a.lr}, then ALL @lr={a.unfreeze_lr}") |
| tr = data.target_days(0) |
| vv = data.graph_view([0, 1], "train+val") |
| van = (data.split[vv["nodes"]] == 1).float().view(-1, 1, 1).to(dev) |
| va_days = stride(data.target_days(1), a.val_days) |
| print(f"val protocol: {len(va_days)} stride-sampled days on train+val graph") |
| best = 1e9; bad = 0 |
| for ep in range(a.ft_epochs): |
| if a.freeze_epochs > 0 and ep == a.freeze_epochs: |
| opt = make_opt("all") |
| print(f" [FT] encoder UNFROZEN at epoch {ep+1}, lr -> {a.unfreeze_lr}", flush=True) |
| net.train(); np.random.shuffle(tr); tot = 0; n_ok = 0; skips = 0; n_orph = 0; t0 = time.time() |
| used = tr[:a.days_per_epoch] if a.days_per_epoch else tr |
| for i, t in enumerate(used): |
| b = data.window(t, tv) |
| b["groups_t"] = jitter_coords(b["groups_t"], a.coord_jitter) |
| gm_t, comp, k = (None, b["comp"], 0) if a.p_orphan <= 0 else orphan_masks(b, a.p_orphan) |
| n_orph += k |
| out = net(b["groups_t"], b["ei"], b["e_hat"], b["n_hat"], b["wu"], b["wv"], b["blh"], comp, gm_t) |
| nll = student_t_nll(out["mu"], out["log_sigma"], out["nu"], b["y"], b["m"], ylm, yls) |
| phys = physics_losses(out["mu"], b) if a.lam_phys > 0 else torch.tensor(0., device=dev) |
| loss = nll + a.lam_phys * phys |
| opt.zero_grad() |
| if not torch.isfinite(loss): skips += 1; continue |
| loss.backward() |
| if not grads_finite(net): opt.zero_grad(); skips += 1; continue |
| torch.nn.utils.clip_grad_norm_(net.parameters(), 5.0) |
| opt.step(); tot += nll.item(); n_ok += 1 |
| if (i + 1) % a.log_every == 0: |
| print(f" [FT {ep+1}] {i+1}/{len(used)} nll={tot/max(n_ok,1):.3f} " |
| f"{(time.time()-t0)/(i+1):.2f}s/it", flush=True) |
| |
| net.eval(); vt = 0; se = 0.0; sn = 0.0 |
| with torch.no_grad(): |
| for t in va_days: |
| b = data.window(t, vv) |
| out = net(b["groups_t"], b["ei"], b["e_hat"], b["n_hat"], b["wu"], b["wv"], b["blh"], b["comp"]) |
| vt += student_t_nll(out["mu"], out["log_sigma"], out["nu"], b["y"], b["m"] * van, ylm, yls).item() |
| yl = (torch.log(b["y"].clamp_min(0) + 1e-3) - ylm.view(1, 1, -1)) / yls.view(1, 1, -1) |
| mm = b["m"] * van |
| se += (((out["mu"] - yl) ** 2) * mm).sum().item(); sn += mm.sum().item() |
| vm = vt / max(len(va_days), 1); vmse = se / max(sn, 1.0) |
| print(f"[FT {ep+1}/{a.ft_epochs}] train_nll={tot/max(n_ok,1):.3f} val_nll={vm:.3f} " |
| f"val_mse={vmse:.3f} orphaned={n_orph} {time.time()-t0:.0f}s", flush=True) |
| epoch_guard(f"FT {ep+1}", skips, len(used), a.max_skip) |
| if vmse < best: |
| best = vmse; bad = 0 |
| torch.save(net.state_dict(), pathlib.Path(a.tensors).parent / "atmosiq_v3_best.pt") |
| else: |
| bad += 1 |
| if bad >= a.patience: |
| print(f"early stop (no val_mse improve for {a.patience} epochs)"); break |
| print(f"done. best val_mse={best:.3f} -> atmosiq_v3_best.pt") |
|
|
| |
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--tensors", default="data/tensors") |
| ap.add_argument("--stage", default="all", choices=["pretrain", "probe", "finetune", "all"]) |
| ap.add_argument("--window", type=int, default=7) |
| ap.add_argument("--ssl_epochs", type=int, default=8) |
| ap.add_argument("--probe_epochs", type=int, default=15) |
| ap.add_argument("--ft_epochs", type=int, default=30) |
| ap.add_argument("--lr", type=float, default=3e-4) |
| ap.add_argument("--lam_smooth", type=float, default=0.1) |
| ap.add_argument("--lam_phys", type=float, default=0.0) |
| ap.add_argument("--p_orphan", type=float, default=0.0) |
| ap.add_argument("--coord_jitter", type=float, default=0.1) |
| ap.add_argument("--smooth_every", type=int, default=4) |
| ap.add_argument("--days_per_epoch", type=int, default=800) |
| ap.add_argument("--probe_days", type=int, default=60) |
| ap.add_argument("--val_days", type=int, default=25) |
| ap.add_argument("--patience", type=int, default=5) |
| ap.add_argument("--freeze_epochs", type=int, default=3, help="LP phase: head-only epochs before unfreezing encoder") |
| ap.add_argument("--unfreeze_lr", type=float, default=5e-5, help="lr for all params after unfreeze") |
| ap.add_argument("--weight_decay", type=float, default=1e-3) |
| ap.add_argument("--max_skip", type=float, default=0.20) |
| ap.add_argument("--log_every", type=int, default=100) |
| ap.add_argument("--refs", default="data/models/refs.json") |
| ap.add_argument("--pm25_weight", type=float, default=1.0, |
| help="P4 ablation: pm2_5 weight in TRAIN loss only (val stays unweighted)") |
| ap.add_argument("--seed", type=int, default=42) |
| a = ap.parse_args() |
| torch.manual_seed(a.seed); np.random.seed(a.seed) |
| dev = "cuda" if torch.cuda.is_available() else "cpu"; print("device:", dev) |
| if dev == "cpu": |
| raise SystemExit("ABORT: CUDA unavailable — full-graph training on CPU would take days. " |
| "Fix torch/driver match (nvidia-smi CUDA Version vs torch build).") |
| meta = json.load(open(pathlib.Path(a.tensors) / "meta.json")) |
| data = AtmosDataV3(a.tensors, window=a.window, device=dev) |
| nz = np.load(pathlib.Path(a.tensors) / "norm.npz") |
| assert "y_logmean" in nz, "norm.npz missing y_logmean/y_logstd — run add_ystats.py first" |
| ylm = torch.tensor(nz["y_logmean"]).float().to(dev) |
| yls = torch.tensor(nz["y_logstd"]).float().to(dev) |
| net, cfg = build_model(meta, dev) |
| print(f"model params: {sum(p.numel() for p in net.parameters()):,}") |
| tv = data.graph_view([0], "train") |
| json.dump({"pins": {"TP1_full_graph": True, "TP2_p_orphan": a.p_orphan, |
| "TP3_lam_phys": a.lam_phys, "TP4_max_skip": a.max_skip, |
| "TP5_coord_jitter": a.coord_jitter, |
| "P0_1_stride_days": True, "P0_2_val_graph": "train+val only"}, |
| "seed": a.seed, "lr": a.lr, "weight_decay": a.weight_decay, |
| "train_mean_deg": tv["mean_deg"], "data_tier": data.tier}, |
| open(pathlib.Path(a.tensors).parent / "train_state_v3.json", "w"), indent=1) |
| if a.stage in ("pretrain", "all"): pretrain(data, net, a, dev, tv) |
| if a.stage in ("probe", "all"): probe(data, net, meta, a, dev, tv) |
| if a.stage in ("finetune", "all"): finetune(data, net, a, dev, tv, ylm, yls) |
|
|
| if __name__ == "__main__": |
| main() |
