"""STER-GI Idea 3: Denoise-to-Sibling — Zero-Shot 3D GER""" import numpy as np, joblib, pickle as pkl, torch, torch.nn as nn, torch.nn.functional as F, time, os, argparse, sys from torch.utils.data import DataLoader, TensorDataset from sklearn.preprocessing import StandardScaler from sklearn.metrics import precision_score, recall_score, f1_score PROPS = ["bounding_box_width","bounding_box_length","area","perimeter","perimeter_ind", "volume","convex_hull_area","convex_hull_volume","ave_centroid_distance","height_diff", "num_floors","axes_symmetry","compactness_2d","compactness_3d","density","elongation", "shape_ind","hemisphericality","fractality","cubeness","circumference", "aligned_bounding_box_width","aligned_bounding_box_length","aligned_bounding_box_height","num_vertices"] # ===== Data ===== def get_vecs(prop_dict, source): ids = list(prop_dict[PROPS[0]][source].keys()) X = np.zeros((len(ids), len(PROPS)), dtype=np.float32) for i, bid in enumerate(ids): for j, pn in enumerate(PROPS): v = prop_dict[pn][source].get(bid, None) X[i,j] = float(v) if v is not None and not (isinstance(v,float) and np.isnan(v)) else 0.0 return X, ids def load_all(seed): tp = f"data/property_dicts/Hague_allmodels_v1_train_matching_medium_neg_samples_num=2_vector_normalization=True_seed={seed}.joblib" ep = f"data/property_dicts/Hague_allmodels_v1_test_matching_medium_neg_samples_num=2_vector_normalization=True_seed={seed}.joblib" trp = joblib.load(tp); epd = joblib.load(ep) Xtc, id_tc = get_vecs(trp, 'cands'); Xti, id_ti = get_vecs(trp, 'index') Xec, id_ec = get_vecs(epd, 'cands'); Xei, id_ei = get_vecs(epd, 'index') X_all = np.concatenate([Xtc, Xti, Xec, Xei], axis=0) print(f"Buildings: {len(X_all)} (train cands={len(Xtc)} index={len(Xti)} test cands={len(Xec)} index={len(Xei)})", flush=True) part = pkl.load(open(f"data/dataset_partitions/Hague_seed{seed}.pkl", 'rb')) all_pairs = list(part['train']['negative_sampling']['medium'][2]) + list(part['test']['matching']['negative_sampling']['medium'][2]) cand_map, index_map = {}, {} for sp, ids in [(trp,id_tc),(epd,id_ec)]: for bid in ids: if bid not in cand_map: cand_map[bid] = np.array([float(sp[pn]['cands'].get(bid,0) or 0) for pn in PROPS], dtype=np.float32) for sp, ids in [(trp,id_ti),(epd,id_ei)]: for bid in ids: if bid not in index_map: index_map[bid] = np.array([float(sp[pn]['index'].get(bid,0) or 0) for pn in PROPS], dtype=np.float32) cv, iv, lbs = [], [], [] for cid, iid in all_pairs: if cid in cand_map and iid in index_map: cv.append(cand_map[cid]); iv.append(index_map[iid]); lbs.append(1 if cid == iid else 0) cv, iv, lbs = np.array(cv,dtype=np.float32), np.array(iv,dtype=np.float32), np.array(lbs,dtype=np.int32) print(f"Eval pairs: {len(lbs)} ({lbs.sum()} pos, {(1-lbs).sum()} neg)", flush=True) return X_all, cv, iv, lbs # ===== Diffusion ===== class DiffMLP(nn.Module): def __init__(self,d,h=256,L=4): super().__init__() self.te = nn.Sequential(nn.Linear(1,h),nn.SiLU(),nn.Linear(h,h)) net = [nn.Linear(d+h,h),nn.SiLU()] for _ in range(L-1): net += [nn.Linear(h,h),nn.SiLU()] net.append(nn.Linear(h,d)); self.net = nn.Sequential(*net) def forward(self,x,t): return self.net(torch.cat([x,self.te(t.unsqueeze(-1).float())],-1)) class DiffSched: def __init__(self,S=1000): self.S=S; self.b=torch.linspace(1e-4,0.02,S); self.a=1-self.b; self.ab=torch.cumprod(self.a,0) def noise(self,x0,t): ab=self.ab[t].view(-1,1); eps=torch.randn_like(x0) return torch.sqrt(ab)*x0+torch.sqrt(1-ab)*eps, eps @torch.no_grad() def step(self,m,xt,t): a=self.a[t].view(-1,1); ab=self.ab[t].view(-1,1); b_=self.b[t].view(-1,1) e=m(xt,t.float()); x0h=(xt-torch.sqrt(1-ab)*e)/torch.sqrt(a) if t.min()==0: return x0h abp=self.ab[t-1].view(-1,1) mu=torch.sqrt(abp)*b_/(1-ab)*x0h+torch.sqrt(a)*(1-abp)/(1-ab)*xt return mu+torch.sqrt(b_*(1-abp)/(1-ab))*torch.randn_like(xt) @torch.no_grad() def sdedit(self,m,x0,t0,dev): n=x0.shape[0]; xt=torch.sqrt(self.ab[t0])*x0+torch.sqrt(1-self.ab[t0])*torch.randn_like(x0) for t in range(t0,-1,-1): xt=self.step(m,xt,torch.full((n,),t,device=dev,dtype=torch.long)) return xt # ===== Encoder ===== class Encoder(nn.Module): def __init__(self,d,h=128,o=64): super().__init__() self.net=nn.Sequential(nn.Linear(d,h),nn.BatchNorm1d(h),nn.ReLU(), nn.Linear(h,h),nn.BatchNorm1d(h),nn.ReLU(),nn.Linear(h,o)) def forward(self,x): z = self.net(x); return z / (torch.norm(z, dim=-1, keepdim=True).clamp(min=1e-8)) def infonce(emb,temp=0.07): n=emb.shape[0]//2; sim=emb@emb.T/temp sim=sim.masked_fill(torch.eye(2*n,device=emb.device,dtype=torch.bool),-1e9) return F.cross_entropy(sim,torch.arange(2*n,device=emb.device)^1) # ===== Eval ===== def eval_pairs(encoder, cv, iv, lbs, dev, tag=""): encoder.eval() with torch.no_grad(): ce = encoder(torch.FloatTensor(cv).to(dev)).cpu().numpy() ie = encoder(torch.FloatTensor(iv).to(dev)).cpu().numpy() sims = np.sum(ce * ie, axis=1) best_f1, best_th = 0, 0 for th in np.arange(0.3, 1.0, 0.02): pred = (sims >= th).astype(np.int32) f = f1_score(lbs, pred, zero_division=0) if f > best_f1: best_f1, best_th = f, th p = precision_score(lbs, (sims>=best_th).astype(np.int32), zero_division=0) r = recall_score(lbs, (sims>=best_th).astype(np.int32), zero_division=0) print(f" {tag}: P={p:.4f} R={r:.4f} F1={best_f1:.4f} (th={best_th:.2f})", flush=True) return best_f1 def baseline_raw(cv, iv, lbs): cn = cv/(np.linalg.norm(cv,axis=1,keepdims=True)+1e-8) i_n = iv/(np.linalg.norm(iv,axis=1,keepdims=True)+1e-8) sims = np.sum(cn * i_n, axis=1) best_f1, best_th = 0, 0 for th in np.arange(0.3, 1.0, 0.02): pred = (sims >= th).astype(np.int32) f = f1_score(lbs, pred, zero_division=0) if f > best_f1: best_f1, best_th = f, th p = precision_score(lbs, (sims>=best_th).astype(np.int32), zero_division=0) r = recall_score(lbs, (sims>=best_th).astype(np.int32), zero_division=0) print(f" Baseline Raw: P={p:.4f} R={r:.4f} F1={best_f1:.4f} (th={best_th:.2f})", flush=True) return best_f1 # ===== Main ===== def main(): a = argparse.ArgumentParser() a.add_argument('--seed',type=int,default=1); a.add_argument('--t0',type=int,default=200) a.add_argument('--skip_diff',action='store_true'); a.add_argument('--skip_enc',action='store_true') a.add_argument('--diff_ep',type=int,default=100); a.add_argument('--enc_ep',type=int,default=100) args = a.parse_args() dev = 'cpu' print(f"Device: {dev} | t0: {args.t0} | Seed: {args.seed}", flush=True) X_all, cv, iv, lbs = load_all(args.seed) sc = StandardScaler(); Xs = sc.fit_transform(X_all) cv_s, iv_s = sc.transform(cv), sc.transform(iv) print("\n=== Baseline ===", flush=True) b_raw = baseline_raw(cv_s, iv_s, lbs) # Diffusion diff_path = f"saved_model_files/diff_i3_s{args.seed}.pt" sib_path = f"saved_model_files/sib_i3_s{args.seed}_t{args.t0}.npz" if args.skip_diff and os.path.exists(diff_path): print(f"Loading cached diffusion: {diff_path}", flush=True) ck = torch.load(diff_path, map_location=dev) model = DiffMLP(Xs.shape[1]).to(dev); model.load_state_dict(ck['m']) sched = DiffSched(); [setattr(sched,x,getattr(sched,x).to(dev)) for x in ['b','a','ab']] else: print(f"\n=== Diffusion ({args.diff_ep} epochs) ===", flush=True) model = DiffMLP(Xs.shape[1]).to(dev); sched = DiffSched() [setattr(sched,x,getattr(sched,x).to(dev)) for x in ['b','a','ab']] opt = torch.optim.Adam(model.parameters(), lr=1e-3) ds = TensorDataset(torch.FloatTensor(Xs)); dl = DataLoader(ds, batch_size=512, shuffle=True) model.train(); t0_t = time.time() for ep in range(args.diff_ep): tot = 0 for (xb,) in dl: xb = xb.to(dev); bs = xb.shape[0] t = torch.randint(0, 1000, (bs,), device=dev) xt, noise = sched.noise(xb, t) loss = F.mse_loss(model(xt, t.float()), noise) opt.zero_grad(); loss.backward(); opt.step(); tot += loss.item()*bs if (ep+1)%10==0: print(f" Diff ep {ep+1}/{args.diff_ep}: loss={tot/len(ds):.6f} t={time.time()-t0_t:.0f}s", flush=True) print(f" Done: loss={tot/len(ds):.6f}", flush=True) torch.save({'m':model.state_dict()}, diff_path) # Siblings if os.path.exists(sib_path): d = np.load(sib_path); origs, sibs = d['o'], d['s'] print(f"Loaded cached siblings: {len(origs)} pairs", flush=True) else: print("\n=== Generating Siblings ===", flush=True) model.eval(); origs, sibs = [], [] with torch.no_grad(): for i in range(0, len(Xs), 512): xb = torch.FloatTensor(Xs[i:i+512]).to(dev) for _ in range(2): # 2 siblings per building origs.append(xb.cpu().numpy()); sibs.append(sched.sdedit(model, xb, args.t0, dev).cpu().numpy()) origs = np.concatenate(origs); sibs = np.concatenate(sibs) l2 = np.mean(np.linalg.norm(origs - sibs, axis=1)) print(f" {len(origs)} pairs, mean L2 diff: {l2:.4f}", flush=True) np.savez_compressed(sib_path, o=origs, s=sibs) # Encoder enc_path = f"saved_model_files/enc_i3_s{args.seed}_t{args.t0}.pt" if args.skip_enc and os.path.exists(enc_path): print(f"Loading cached encoder: {enc_path}", flush=True) ck = torch.load(enc_path, map_location=dev) encoder = Encoder(Xs.shape[1]).to(dev); encoder.load_state_dict(ck['e']) else: print(f"\n=== Encoder ({args.enc_ep} epochs) ===", flush=True) encoder = Encoder(Xs.shape[1]).to(dev) opt = torch.optim.Adam(encoder.parameters(), lr=1e-4) # Build paired data: shuffle at pair level (NOT sample level) n = len(origs); idx = np.random.permutation(n) data = np.zeros((n*2, Xs.shape[1]), dtype=np.float32) data[0::2] = origs[idx]; data[1::2] = sibs[idx] ds = TensorDataset(torch.FloatTensor(data)); dl = DataLoader(ds, batch_size=1024, shuffle=False) encoder.train(); t0_t = time.time() for ep in range(args.enc_ep): tot = 0 for (xb,) in dl: xb = xb.to(dev); emb = encoder(xb); loss = infonce(emb, 0.07) opt.zero_grad(); loss.backward(); torch.nn.utils.clip_grad_norm_(encoder.parameters(), 1.0); opt.step(); tot += loss.item()*xb.shape[0] if (ep+1)%10==0: print(f" Enc ep {ep+1}/{args.enc_ep}: loss={tot/len(ds):.4f} t={time.time()-t0_t:.0f}s", flush=True) print(f" Done: loss={tot/len(ds):.4f}", flush=True) torch.save({'e':encoder.state_dict()}, enc_path) # Results print("\n=== RESULTS ===", flush=True) f1_i3 = eval_pairs(encoder, cv_s, iv_s, lbs, dev, f"Idea3 (t0={args.t0})") print(f"\n Baseline (raw): F1={b_raw:.4f}") print(f" Idea3 (denoise-sib): F1={f1_i3:.4f}") print(f" Supervised XGBoost: F1=0.982 (reference)") print(f" Δ over baseline: {f1_i3-b_raw:+.4f}", flush=True) if __name__=='__main__': main()