| """ |
| 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) |
|
|
| |
| 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 |
| print(f"Paired transforms: {len(transforms)}",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]) |
| 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) |
|
|
| |
| 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) |
| |
| avg_transform=transforms[indices].mean(axis=1) |
| |
| noise=np.random.randn(*avg_transform.shape).astype(np.float32)*args.noise |
| gen=xb+avg_transform+noise |
| gens.append(gen) |
| |
| 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) |
|
|
| |
| 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() |
|
|
