| r"""dataset_v2.py — 4-group loader, GPU-RESIDENT. Big arrays live on GPU as float16 |
| (indexing is GPU-native -> no CPU-index / per-window transfer stall). If they don't fit |
| in VRAM, auto-fallback to CPU (RAM). Subgraph on the pruned training graph (structural |
| holdout §5); 3-mode SSL masking (§1). Physics = raw wind_1330 + BLH.""" |
| from __future__ import annotations |
| import json, pathlib, numpy as np, torch |
|
|
| class AtmosData: |
| def __init__(self, tdir, window=7, device="cuda", gpu_resident=True): |
| t=pathlib.Path(tdir); self.w=window; self.dev=device |
| |
| store=device if (gpu_resident and device=="cuda" and torch.cuda.is_available()) else "cpu" |
| def L(f, keepf16=True): |
| a=torch.tensor(np.load(t/f)) |
| if a.dtype==torch.float64: a=a.float() |
| if keepf16 and a.dtype==torch.float32: a=a.half() |
| return a |
| try: |
| self.A=L("groupA.npy").to(store); self.B=L("groupB.npy").to(store) |
| self.Cstat=L("groupC_static.npy").to(store); self.Cyear=L("groupC_yearly.npy").to(store) |
| self.LUyear=torch.tensor(np.load(t/"groupC_landuse.npy")).long().to(store) |
| self.yod=torch.tensor(np.load(t/"year_of_day.npy")).long().to(store) |
| self.cal=L("calendar_num.npy").to(store); self.grap=torch.tensor(np.load(t/"grap.npy")).long().to(store) |
| self.PH=L("physics.npy").to(store) |
| self.comp=L("completeness.npy").to(store) |
| self.Y=L("targets.npy").to(store); self.M=torch.tensor(np.load(t/"target_mask.npy")).float().to(store) |
| ed=np.load(t/"edges.npz") |
| self.ei=torch.tensor(ed["ei"]).long().to(store) |
| self.e_hat=torch.tensor(ed["e_hat"]).float().to(store); self.n_hat=torch.tensor(ed["n_hat"]).float().to(store) |
| self.split=torch.tensor(np.load(t/"node_split.npy")).long().to(store) |
| self.store=store |
| except torch.cuda.OutOfMemoryError: |
| print("!! GPU too small for resident data -> falling back to CPU (RAM). Slower.") |
| torch.cuda.empty_cache() |
| return AtmosData.__init__(self, tdir, window, device, gpu_resident=False) |
| self.D,self.N,_=self.A.shape |
| print(f"data resident on: {store} (A{tuple(self.A.shape)} f16)") |
|
|
| def target_days(self, fold=0): |
| fn=(self.split==fold) |
| has=((self.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 _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.LUyear[yi][nodes], |
| "calendar_num":self.cal[day].unsqueeze(0).expand(len(nodes),-1).float(), |
| "grap":self.grap[day].expand(len(nodes))} |
|
|
| def subgraph(self, size=512, fold=0): |
| cand=torch.where(self.split==fold)[0] |
| nodes=cand[torch.randperm(len(cand),device=cand.device)[:size]] |
| nset=torch.full((self.N,),-1,dtype=torch.long,device=self.store); nset[nodes]=torch.arange(len(nodes),device=self.store) |
| src,dst=self.ei; keep=(nset[src]>=0)&(nset[dst]>=0) |
| ei=torch.stack([nset[src[keep]],nset[dst[keep]]]).to(self.dev) |
| return nodes, ei, self.e_hat[keep].to(self.dev), self.n_hat[keep].to(self.dev) |
|
|
| A_FLAGMAP=[0,2,1,3,4,7,8] |
| RECON_GROUP=["satellite"]*9+["meteorology"]*12+["static"]*9 |
| def recon_from_groups(self, groups_t): |
| """target+observed from already-loaded window groups (no re-index).""" |
| 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(self.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 window(self, t, nodes, ei, e_hat, n_hat, horizons=4): |
| 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,nodes].float()); ms.append(self.M[d2,nodes]*(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=ei.to(self.dev), e_hat=e_hat.to(self.dev), n_hat=n_hat.to(self.dev), |
| wu=wu, wv=wv, blh=blh, comp=self.comp[t,nodes].float().to(self.dev), y=y, m=m) |
|
|
| 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_masked(gm_t, recon_group): |
| 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 |
