| 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 |
|
|
| 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) |
| 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]:,}") |
|
|
| |
| 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) |
|
|
| |
| 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) |
| 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) |
|
|
| |
| 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 |
|
|
