""" STER-GI Idea 6: Cross-Building Transformation Transfer (变换迁移补全) ====================================================================== - Learn transformation vectors from paired (cand→index) views - Apply learned transformations to unpaired buildings → synthetic views - Contrastive learning on (original, transformed) pairs """ 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.neighbors import NearestNeighbors 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"] 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) # Paired transformations cand_all,idx_all={},{} for sp,ids in [(trp,id_tc),(epd,id_ec)]: for bid in ids: if bid not in cand_all: cand_all[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 idx_all: idx_all[bid]=np.array([float(sp[pn]['index'].get(bid,0) or 0) for pn in PROPS],dtype=np.float32) common=sorted(set(cand_all.keys())&set(idx_all.keys())) src=np.array([cand_all[bid] for bid in common],dtype=np.float32) tgt=np.array([idx_all[bid] for bid in common],dtype=np.float32) transforms=tgt-src # learned transformation vectors print(f"Paired transforms: {len(transforms)}",flush=True) # Eval 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]) cv,iv,lbs=[],[],[] for cid,iid in all_pairs: if cid in cand_all and iid in idx_all: cv.append(cand_all[cid]); iv.append(idx_all[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"Buildings: {len(X_all)} | Eval: {len(lbs)}",flush=True) return X_all, src, transforms, cv, iv, lbs 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) 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 def main(): a=argparse.ArgumentParser() a.add_argument('--seed',type=int,default=1); a.add_argument('--k_nn',type=int,default=5) a.add_argument('--noise',type=float,default=0.1); a.add_argument('--enc_ep',type=int,default=100) args=a.parse_args() dev='cpu' print(f"Device: {dev} | k_nn: {args.k_nn} | noise: {args.noise}",flush=True) X_all,src,transforms,cv,iv,lbs=load_all(args.seed) sc=StandardScaler(); Xs=sc.fit_transform(X_all) src_s=sc.transform(src); cv_s,iv_s=sc.transform(cv),sc.transform(iv) print("\n=== Baseline ===",flush=True) b_raw=baseline_raw(cv_s,iv_s,lbs) # For each building, find k nearest paired buildings and apply their average transform print(f"\n=== Generating via k-NN Transform Transfer (k={args.k_nn}) ===",flush=True) nn_model=NearestNeighbors(n_neighbors=args.k_nn,metric='cosine') nn_model.fit(src_s) gens=[] bs=256 for i in range(0,len(Xs),bs): xb=Xs[i:i+bs] _,indices=nn_model.kneighbors(xb) # Average transform from k neighbors avg_transform=transforms[indices].mean(axis=1) # Add noise for diversity noise=np.random.randn(*avg_transform.shape).astype(np.float32)*args.noise gen=xb+avg_transform+noise gens.append(gen) # Also generate with different noise samples noise2=np.random.randn(*avg_transform.shape).astype(np.float32)*args.noise gens.append(xb+avg_transform+noise2) gens=np.concatenate(gens) print(f" Generated {len(gens)} transformed views",flush=True) # Encoder enc_path=f"saved_model_files/enc_i6_s{args.seed}_k{args.k_nn}.pt" print(f"\n=== Contrastive Encoder ({args.enc_ep} epochs) ===",flush=True) encoder=Encoder(Xs.shape[1]).to(dev) opt=torch.optim.Adam(encoder.parameters(),lr=1e-4) n_g=min(len(gens),len(Xs)); idx=np.random.permutation(n_g) data=np.zeros((n_g*2,Xs.shape[1]),dtype=np.float32) data[0::2]=Xs[idx]; data[1::2]=gens[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) print("\n=== RESULTS ===",flush=True) f1_i6=eval_pairs(encoder,cv_s,iv_s,lbs,dev,f"Idea6 (k-NN transform, k={args.k_nn})") print(f"\n Baseline (raw): F1={b_raw:.4f}") print(f" Idea6 (transform): F1={f1_i6:.4f}") print(f" Supervised XGBoost: F1=0.982") print(f" Δ over baseline: {f1_i6-b_raw:+.4f}",flush=True) if __name__=='__main__': main()