File size: 8,434 Bytes
8d1a8f8 | 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 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 | """
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()
|