r"""dataset_v3.py — AtmosIQ v3 loader. TP-1: NO random-node subgraph sampler. Training runs on the FULL pruned training graph (fold-0 nodes, both-endpoint edges = structural holdout, SSL_ROADMAP §5). Runtime assert: mean degree >= MIN_DEG or ABORT. VRAM ladder (P1-6): full-GPU -> "light" (Y/M/comp on CPU RAM, features on GPU) -> full-CPU. Subgraph-on-random-nodes does not exist in this file by design. """ from __future__ import annotations import pathlib, numpy as np, torch MIN_DEG = 4.0 # TP-1 assert threshold (KNN k~8 graph; block-pruning should keep ~6-8) class AtmosDataV3: def __init__(self, tdir, window=7, device="cuda", tier=0): """tier 0 = all GPU; tier 1 = labels (Y/M/comp) on CPU; tier 2 = all CPU.""" t = pathlib.Path(tdir); self.w = window; self.dev = device cuda_ok = (device == "cuda" and torch.cuda.is_available()) big = device if (cuda_ok and tier <= 1) else "cpu" lab = device if (cuda_ok and tier == 0) else "cpu" def L(f, store, f16=True): a = torch.tensor(np.load(t / f)) if a.dtype == torch.float64: a = a.float() if f16 and a.dtype == torch.float32: a = a.half() return a.to(store) try: self.A = L("groupA.npy", big); self.B = L("groupB.npy", big) self.Cstat = L("groupC_static.npy", big); self.Cyear = L("groupC_yearly.npy", big) self.LU = torch.tensor(np.load(t / "groupC_landuse.npy")).long().to(big) self.yod = torch.tensor(np.load(t / "year_of_day.npy")).long().to(big) self.cal = L("calendar_num.npy", big) self.grap = torch.tensor(np.load(t / "grap.npy")).long().to(big) self.PH = L("physics.npy", big) self.comp = L("completeness.npy", lab) self.Y = L("targets.npy", lab) self.M = torch.tensor(np.load(t / "target_mask.npy")).to(lab) # uint8 ed = np.load(t / "edges.npz") self.ei = torch.tensor(ed["ei"]).long().to(big) self.e_hat = torch.tensor(ed["e_hat"]).float().to(big) self.n_hat = torch.tensor(ed["n_hat"]).float().to(big) self.split = torch.tensor(np.load(t / "node_split.npy")).long().to(big) except torch.cuda.OutOfMemoryError: if tier >= 2: raise nxt = tier + 1 print(f"!! OOM at data tier {tier} -> retry tier {nxt} " f"({'labels->CPU' if nxt==1 else 'all->CPU'})") torch.cuda.empty_cache() return AtmosDataV3.__init__(self, tdir, window, device, tier=nxt) self.store = big; self.tier = tier self.D, self.N, _ = self.A.shape print(f"data tier={tier} features on {big}, labels on {lab} " f"A{tuple(self.A.shape)} f16 E={self.ei.shape[1]:,}") # ---------------- graph views (TP-1) ---------------- def graph_view(self, folds, name=""): """Node set = union of folds; edges with BOTH endpoints inside (pruned). folds=None -> full national graph (identity).""" if folds is None: nodes = torch.arange(self.N, device=self.store) ei = self.ei.to(self.dev); eh = self.e_hat.to(self.dev); nh = self.n_hat.to(self.dev) else: keep = torch.zeros(self.N, dtype=torch.bool, device=self.store) for f in folds: keep |= (self.split == f) nodes = torch.where(keep)[0] remap = torch.full((self.N,), -1, dtype=torch.long, device=self.store) remap[nodes] = torch.arange(len(nodes), device=self.store) src, dst = self.ei ke = (remap[src] >= 0) & (remap[dst] >= 0) ei = torch.stack([remap[src[ke]], remap[dst[ke]]]).to(self.dev) eh = self.e_hat[ke].to(self.dev); nh = self.n_hat[ke].to(self.dev) deg = ei.shape[1] / max(len(nodes), 1) print(f"graph_view[{name}] nodes={len(nodes):,} edges={ei.shape[1]:,} mean_deg={deg:.2f}") if folds is not None and deg < MIN_DEG: raise SystemExit(f"ABORT TP-1: mean degree {deg:.2f} < {MIN_DEG} — pruned graph broken; " f"training on an edge-starved graph is the run-#1 bug. Fix split/edges first.") return dict(nodes=nodes, ei=ei, e_hat=eh, n_hat=nh, mean_deg=deg) def target_days(self, fold=0): fn = (self.split == fold) M = self.M.to(self.store) if self.M.device != self.split.device else self.M has = ((M.sum(-1) > 0) & fn.unsqueeze(0)).sum(-1) return [t for t in range(self.w - 1, self.D) if has[t] > 0] def full_window(self, t, horizons=4): """Window on the full national graph (view built once, cached). Eval-only.""" if not hasattr(self, "_fv"): self._fv = self.graph_view(None, "full") return self.window(t, self._fv, horizons) # ---------------- window assembly ---------------- def _groups(self, day, nodes): yi = int(self.yod[day]) static_num = torch.cat([self.Cstat[nodes], self.Cyear[yi][nodes]], -1).float() return {"satellite": self.A[day, nodes].float(), "meteorology": self.B[day, nodes].float(), "static_num": static_num, "landuse": self.LU[yi][nodes], "calendar_num": self.cal[day].unsqueeze(0).expand(len(nodes), -1).float(), "grap": self.grap[day].expand(len(nodes))} def window(self, t, view, horizons=4): nodes = view["nodes"] nl = nodes.to(self.Y.device) # label-side index (may be CPU on tier 1) days = range(t - self.w + 1, t + 1) groups_t = [{k: v.to(self.dev) for k, v in self._groups(d, nodes).items()} for d in days] wu = torch.stack([self.PH[d, nodes, 0] for d in days]).float().to(self.dev) wv = torch.stack([self.PH[d, nodes, 1] for d in days]).float().to(self.dev) blh = torch.stack([self.PH[d, nodes, 2] for d in days]).float().to(self.dev) ys = []; ms = [] for h in range(horizons): d2 = t + h; valid = d2 < self.D; d2 = min(d2, self.D - 1) ys.append(self.Y[d2, nl].float()) ms.append(self.M[d2, nl].float() * (1.0 if valid else 0.0)) y = torch.stack(ys, 1).to(self.dev); m = torch.stack(ms, 1).to(self.dev) return dict(groups_t=groups_t, ei=view["ei"], e_hat=view["e_hat"], n_hat=view["n_hat"], wu=wu, wv=wv, blh=blh, comp=self.comp[t, nl].float().to(self.dev), y=y, m=m) # ---------------- SSL masking (SSL_ROADMAP §1, unchanged semantics) ---------------- A_FLAGMAP = [0, 2, 1, 3, 4, 7, 8] RECON_GROUP = ["satellite"] * 9 + ["meteorology"] * 12 + ["static"] * 9 def ssl_mask(groups_t, p_group=0.15, p_blackout=0.10, p_node=0.05): dev = groups_t[-1]["satellite"].device N = groups_t[-1]["satellite"].shape[0]; T = len(groups_t) black = (torch.rand(N, device=dev) < p_blackout) node_m = (torch.rand(N, device=dev) < p_node) gm_t = [] for _ in range(T): pick = torch.randint(0, 3, (N,), device=dev) fg = (torch.rand(N, device=dev) < p_group) gm_t.append({"satellite": ((fg & (pick == 0)) | black | node_m).float(), "meteorology": ((fg & (pick == 1)) | node_m).float(), "static": ((fg & (pick == 2)) | node_m).float()}) return gm_t def recon_from_groups(groups_t): T = len(groups_t) A = torch.stack([groups_t[t]["satellite"][:, :9] for t in range(T)], 1) Bv = torch.stack([groups_t[t]["meteorology"] for t in range(T)], 1) C = torch.stack([groups_t[t]["static_num"] for t in range(T)], 1) target = torch.cat([A, Bv, C], -1) Aobs = torch.ones_like(A) for k, fl in enumerate(A_FLAGMAP): Aobs[:, :, k] = torch.stack([groups_t[t]["satellite"][:, 9 + fl] for t in range(T)], 1) obs = torch.cat([Aobs, torch.ones_like(Bv), torch.ones_like(C)], -1) return target, obs def recon_masked(gm_t): T = len(gm_t); N = gm_t[0]["satellite"].shape[0] out = torch.zeros(N, T, len(RECON_GROUP), device=gm_t[0]["satellite"].device) for t in range(T): for c, g in enumerate(RECON_GROUP): out[:, t, c] = gm_t[t][g] return out