File size: 8,218 Bytes
7215ff1 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 | 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
|