Upload code/ster_train_synth.py with huggingface_hub

code/ster_train_synth.py

@@ -0,0 +1,777 @@
+"""
+STER-GI: Train ALL 6 ideas on synthetic cross-LoD data.
+Uses aggressive noise model to simulate LoD1.2 ↔ LoD2.2 differences.
+
+Baseline: F1≈0.66 (raw cosine, cross-LoD)
+Target:  F1≥0.80 (+20%)
+
+Usage:
+  python ster_train_synth.py --idea 3  --epochs 200
+  python ster_train_synth.py --idea 3p --epochs 200 --t0 200
+  python ster_train_synth.py --idea 1  --epochs 200
+  python ster_train_synth.py --idea 2  --epochs 200
+  python ster_train_synth.py --idea 4  --epochs 200 --t0 200 --keep_frac 0.5
+  python ster_train_synth.py --idea 5  --epochs 100 --rounds 3
+  python ster_train_synth.py --idea 6  --epochs 200 --knn 5
+"""
+import os, sys, json, time, argparse
+import numpy as np
+from collections import OrderedDict
+import warnings
+warnings.filterwarnings('ignore')
+
+import torch, torch.nn as nn, torch.nn.functional as F
+import joblib
+from ddpm import DDPM, BetaSchedule
+
+DEV = 'cuda' if torch.cuda.is_available() else 'cpu'
+print(f"Device: {DEV}")
+torch.set_num_threads(1)
+import os as _os
+_os.environ['OMP_NUM_THREADS'] = '1'
+_os.environ['MKL_NUM_THREADS'] = '1'
+
+PROP_NAMES = ["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"]
+
+# ============================================================
+# Encoder (25→128→128→64, L2-normalized output)
+# ============================================================
+class Encoder(nn.Module):
+    def __init__(self, d=25, h=128, o=64):
+        super().__init__()
+        self.net = nn.Sequential(OrderedDict([
+            ('0', nn.Linear(d, h)), ('1', nn.BatchNorm1d(h)), ('2', nn.ReLU()),
+            ('3', nn.Linear(h, h)), ('4', nn.BatchNorm1d(h)), ('5', nn.ReLU()),
+            ('6', 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))
+
+# ============================================================
+# InfoNCE Loss
+# ============================================================
+def infonce_loss(z_a, z_b, tau=0.1):
+    B = z_a.shape[0]
+    z_a = F.normalize(z_a, dim=-1)
+    z_b = F.normalize(z_b, dim=-1)
+    sim = torch.mm(z_a, z_b.T) / tau
+    labels = torch.arange(B, device=z_a.device)
+    return (F.cross_entropy(sim, labels) + F.cross_entropy(sim.T, labels)) / 2
+
+# ============================================================
+# Data: Aggressive LoD Noise
+# ============================================================
+def aggressive_lod_noise(props, seed=42):
+    """Simulate LoD1.2 → LoD2.2 transformation."""
+    rng = np.random.RandomState(seed)
+    p = props.copy().astype(np.float64)
+    N, D = p.shape
+    for j, pn in enumerate(PROP_NAMES):
+        if pn in ['volume', 'convex_hull_volume']:
+            p[:, j] *= rng.uniform(0.3, 3.0, N)
+        elif pn in ['area', 'convex_hull_area', 'perimeter', 'circumference']:
+            p[:, j] *= rng.uniform(0.5, 2.0, N)
+        elif pn in ['height_diff', 'aligned_bounding_box_height']:
+            p[:, j] += rng.randn(N) * 5.0
+            p[:, j] = np.maximum(0.1, p[:, j])
+        elif pn == 'num_vertices':
+            p[:, j] *= rng.uniform(0.3, 0.8, N)
+        elif pn == 'num_floors':
+            p[:, j] += rng.randint(-2, 3, N).astype(np.float64)
+            p[:, j] = np.maximum(1, p[:, j])
+        else:
+            p[:, j] *= rng.uniform(0.5, 1.5, N)
+    p += rng.randn(N, D) * 0.1
+    return p.astype(np.float32)
+
+def load_and_split_data():
+    """Load all building properties, split into train/test, apply LoD noise."""
+    all_mats, all_ids = [], []
+    for suf in ['Hague_allmodels_v1_train_matching_medium_neg_samples_num=2_vector_normalization=True_seed=1',
+                'Hague_allmodels_v1_test_matching_medium_neg_samples_num=2_vector_normalization=True_seed=1']:
+        pdict = joblib.load(f'data/property_dicts/{suf}.joblib')
+        for side in ['cands', 'index']:
+            ids = list(pdict[PROP_NAMES[0]][side].keys())
+            mat = np.zeros((len(ids), len(PROP_NAMES)), dtype=np.float32)
+            for j, pn in enumerate(PROP_NAMES):
+                for i, bid in enumerate(ids):
+                    val = pdict[pn][side].get(bid)
+                    if val is not None:
+                        mat[i, j] = float(val)
+            mat = np.nan_to_num(mat, nan=0.0, posinf=1e6, neginf=-1e6)
+            all_mats.append(mat)
+            all_ids.extend(ids)
+    
+    X = np.vstack(all_mats)
+    N = len(X)
+    rng = np.random.RandomState(42)
+    perm = rng.permutation(N)
+    n_train = int(N * 0.6)
+    train_props = X[perm[:n_train]]
+    test_props = X[perm[n_train:]]
+    test_ids = [all_ids[i] for i in perm[n_train:]]
+    
+    train_coarse = aggressive_lod_noise(train_props, seed=1)
+    test_coarse = aggressive_lod_noise(test_props, seed=123)
+    
+    # Z-score standardize (fit on train only)
+    all_cat = np.vstack([train_props, train_coarse])
+    mean = all_cat.mean(axis=0, keepdims=True)
+    std = all_cat.std(axis=0, keepdims=True)
+    std[std < 1e-8] = 1.0
+    
+    train_fine_n = (train_props - mean) / std
+    train_coarse_n = (train_coarse - mean) / std
+    test_fine_n = (test_props - mean) / std
+    test_coarse_n = (test_coarse - mean) / std
+    
+    print(f"Train: {len(train_fine_n)} pairs, Test: {len(test_fine_n)} pairs")
+    return (train_fine_n, train_coarse_n), (test_fine_n, test_coarse_n, test_ids)
+
+
+# ============================================================
+# Contrastive Trainer
+# ============================================================
+class ContrastiveTrainer:
+    def __init__(self, d=25, h=128, o=64, lr=3e-4, tau=0.1):
+        self.encoder = Encoder(d, h, o).to(DEV)
+        self.optimizer = torch.optim.AdamW(self.encoder.parameters(), lr=lr, weight_decay=1e-5)
+        self.tau = tau
+    
+    def train_epoch(self, pairs_a, pairs_b, batch_size=256):
+        N = len(pairs_a)
+        idx = np.random.permutation(N)
+        total_loss = 0
+        n_batches = 0
+        for start in range(0, N, batch_size):
+            batch_idx = idx[start:start+batch_size]
+            ba = torch.tensor(pairs_a[batch_idx], dtype=torch.float32).to(DEV)
+            bb = torch.tensor(pairs_b[batch_idx], dtype=torch.float32).to(DEV)
+            z_a = self.encoder(ba)
+            z_b = self.encoder(bb)
+            loss = infonce_loss(z_a, z_b, self.tau)
+            self.optimizer.zero_grad()
+            loss.backward()
+            self.optimizer.step()
+            total_loss += loss.item()
+            n_batches += 1
+        return total_loss / max(n_batches, 1)
+    
+    def save(self, path):
+        torch.save({'e': self.encoder.state_dict()}, path)
+
+# ============================================================
+# Evaluation
+# ============================================================
+def evaluate_encoder(enc, test_fine, test_coarse):
+    fine_t = torch.tensor(test_fine, dtype=torch.float32).to(DEV)
+    coarse_t = torch.tensor(test_coarse, dtype=torch.float32).to(DEV)
+    N = len(test_fine)
+    bs = 512
+    emb_fine, emb_coarse = [], []
+    with torch.no_grad():
+        for start in range(0, N, bs):
+            emb_fine.append(enc(fine_t[start:start+bs]).cpu().numpy())
+            emb_coarse.append(enc(coarse_t[start:start+bs]).cpu().numpy())
+    emb_fine = np.vstack(emb_fine)
+    emb_coarse = np.vstack(emb_coarse)
+    pos_sims = np.sum(emb_fine * emb_coarse, axis=1)
+    rng = np.random.RandomState(42)
+    neg_idx = rng.permutation(N)
+    neg_sims = np.sum(emb_fine * emb_coarse[neg_idx], axis=1)
+    all_sims = np.concatenate([pos_sims, neg_sims])
+    all_labels = np.concatenate([np.ones(N, dtype=np.int32), np.zeros(N, dtype=np.int32)])
+    best_f1 = 0.0
+    for t in np.linspace(0.1, 0.999, 100):
+        pred = (all_sims >= t).astype(np.int32)
+        tp = float(((pred == 1) & (all_labels == 1)).sum())
+        fp = float(((pred == 1) & (all_labels == 0)).sum())
+        fn = float(((pred == 0) & (all_labels == 1)).sum())
+        p = tp / (tp + fp + 1e-9)
+        r = tp / (tp + fn + 1e-9)
+        f1 = 2.0 * p * r / (p + r + 1e-9)
+        if f1 > best_f1: best_f1 = f1
+    return float(best_f1)
+
+def baseline_f1(test_fine, test_coarse):
+    fn = test_fine / (np.linalg.norm(test_fine, axis=1, keepdims=True) + 1e-8)
+    cn = test_coarse / (np.linalg.norm(test_coarse, axis=1, keepdims=True) + 1e-8)
+    pos = np.sum(fn * cn, axis=1)
+    rng = np.random.RandomState(42)
+    neg_idx = rng.permutation(len(cn))
+    neg = np.sum(fn * cn[neg_idx], axis=1)
+    all_sims = np.concatenate([pos, neg])
+    all_labels = np.concatenate([np.ones(len(pos), dtype=np.int32), np.zeros(len(neg), dtype=np.int32)])
+    best_f1 = 0.0
+    for t in np.linspace(0.1, 0.999, 100):
+        pred = (all_sims >= t).astype(np.int32)
+        tp = float(((pred == 1) & (all_labels == 1)).sum())
+        fp = float(((pred == 1) & (all_labels == 0)).sum())
+        fn = float(((pred == 0) & (all_labels == 1)).sum())
+        p = tp / (tp + fp + 1e-9)
+        r = tp / (tp + fn + 1e-9)
+        f1 = 2.0 * p * r / (p + r + 1e-9)
+        if f1 > best_f1: best_f1 = f1
+    return float(best_f1)
+
+# ============================================================
+# Idea 1: Detail-Spectrum Imagination (Conditional Diffusion)
+# ============================================================
+class ConditionalDenoiser(nn.Module):
+    def __init__(self, d=25, h=256, T=1000):
+        super().__init__()
+        self.t_emb = nn.Embedding(T, h)
+        self.net = nn.Sequential(OrderedDict([
+            ('in', nn.Linear(d + d + h, h)),
+            ('n1', nn.LayerNorm(h)), ('a1', nn.SiLU()),
+            ('h1', nn.Linear(h, h)),
+            ('n2', nn.LayerNorm(h)), ('a2', nn.SiLU()),
+            ('h2', nn.Linear(h, h)),
+            ('n3', nn.LayerNorm(h)), ('a3', nn.SiLU()),
+            ('out', nn.Linear(h, d)),
+        ]))
+    def forward(self, x, t, condition):
+        te = self.t_emb(t)
+        return self.net(torch.cat([x, condition, te], dim=-1))
+
+class ConditionalDDPM:
+    def __init__(self, d=25, h=256, T=1000):
+        self.d, self.h, self.T = d, h, T
+        self.schedule = BetaSchedule(T)
+        self.denoiser = ConditionalDenoiser(d, h, T).to(DEV)
+        self.optimizer = torch.optim.AdamW(self.denoiser.parameters(), lr=3e-4)
+    
+    def train_step(self, x_src, x_tgt):
+        B = x_tgt.shape[0]
+        t = torch.randint(0, self.T, (B,), device=DEV)
+        x_t, noise = self.schedule.forward_diffuse(x_tgt, t)
+        pred = self.denoiser(x_t, t, x_src)
+        loss = F.mse_loss(pred, noise)
+        self.optimizer.zero_grad()
+        loss.backward()
+        self.optimizer.step()
+        return loss.item()
+    
+    @torch.no_grad()
+    def sample(self, x_src, steps=None):
+        if steps is None: steps = min(self.T, 100)
+        self.denoiser.eval()
+        n = x_src.shape[0]
+        x = torch.randn(n, self.d, device=DEV)
+        step_size = self.T // steps
+        for t_idx in reversed(range(0, self.T, step_size)):
+            t = torch.full((n,), t_idx, device=DEV, dtype=torch.long)
+            pred_noise = self.denoiser(x, t, x_src)
+            alpha = self.schedule.alphas[t_idx]
+            alpha_bar = self.schedule.alpha_bars[t_idx]
+            beta = self.schedule.betas[t_idx]
+            if t_idx > 0:
+                noise = torch.randn_like(x)
+                x = (1.0/torch.sqrt(alpha)) * (
+                    x - (beta/torch.sqrt(1.0-alpha_bar)) * pred_noise
+                ) + torch.sqrt(beta) * noise
+            else:
+                x = (1.0/torch.sqrt(alpha)) * (
+                    x - (beta/torch.sqrt(1.0-alpha_bar)) * pred_noise
+                )
+        self.denoiser.train()
+        return x
+    
+    def save(self, path):
+        torch.save({'denoiser': self.denoiser.state_dict(),
+                     'd': self.d, 'h': self.h, 'T': self.T}, path)
+    
+    @classmethod
+    def load(cls, path):
+        state = torch.load(path, map_location=DEV)
+        model = cls(d=state['d'], h=state['h'], T=state['T'])
+        model.denoiser.load_state_dict(state['denoiser'])
+        model.denoiser.to(DEV)
+        return model
+
+def train_idea1_synth(train_fine, train_coarse, test_fine, test_coarse,
+                       epochs=200, batch_size=256):
+    """
+    Idea 1: Detail-Spectrum Imagination
+    - Train conditional DDPM on (train_fine → train_coarse) to learn LoD transformation
+    - Generate cross-LoD views for train buildings (conditioned on train_fine)
+    - Interpolate: tau*src + (1-tau)*generated = intermediate detail levels
+    - Train InfoNCE encoder on (original, interpolated) pairs
+    """
+    print(f"Idea 1: Detail-Spectrum Imagination ({len(train_fine)} pairs)")
+    
+    print("  Training conditional DDPM (fine→coarse)...")
+    cddpm = ConditionalDDPM(d=train_fine.shape[1])
+    N_train = len(train_fine)
+    for ep in range(300):
+        perm = torch.randperm(N_train)
+        ep_loss = 0
+        n_batches = 0
+        for start in range(0, N_train, batch_size):
+            idx = perm[start:start+batch_size]
+            src = torch.tensor(train_fine[idx], dtype=torch.float32).to(DEV)
+            tgt = torch.tensor(train_coarse[idx], dtype=torch.float32).to(DEV)
+            ep_loss += cddpm.train_step(src, tgt)
+            n_batches += 1
+        if ep % 100 == 0:
+            print(f"    C-DDPM ep {ep}: loss={ep_loss/max(n_batches,1):.6f}")
+    cddpm.save('saved_model_files/cdiff_synth.pt')
+    
+    # Generate coarse-detail views for all train buildings
+    print("  Generating detail-spectrum views via C-DDPM...")
+    train_fine_t = torch.tensor(train_fine, dtype=torch.float32).to(DEV)
+    gen_views = []
+    for start in range(0, len(train_fine), batch_size):
+        batch = train_fine_t[start:start+batch_size]
+        gen = cddpm.sample(batch)
+        gen_views.append(gen.cpu().numpy())
+    gen_views = np.vstack(gen_views)
+    
+    # Create interpolated views at multiple tau levels
+    combined_a, combined_b = [], []
+    for tau in [0.3, 0.7]:
+        interpolated = tau * train_fine[:len(gen_views)] + (1 - tau) * gen_views
+        combined_a.append(train_fine[:len(gen_views)])
+        combined_b.append(interpolated)
+    
+    combined_a = np.vstack(combined_a)
+    combined_b = np.vstack(combined_b)
+    print(f"  Combined: {len(combined_a)} pairs (x2 tau levels)")
+    
+    # Train InfoNCE
+    trainer = ContrastiveTrainer(d=train_fine.shape[1])
+    best_f1 = 0.0
+    for ep in range(epochs):
+        loss = trainer.train_epoch(combined_a, combined_b, batch_size)
+        if ep % 20 == 0:
+            f1 = evaluate_encoder(trainer.encoder, test_fine, test_coarse)
+            print(f"  Ep {ep}: loss={loss:.4f}, F1={f1:.4f}")
+            if f1 > best_f1:
+                best_f1 = f1
+                trainer.save('saved_model_files/enc_synth_i1.pt')
+    
+    return {'encoder_path': 'saved_model_files/enc_synth_i1.pt',
+            'best_test_f1': best_f1, 'method': 'conditional_ddpm+interpolation'}
+
+# ============================================================
+# Idea 2: Identity-Realization Disentanglement (VAE)
+# ============================================================
+class DisentangledVAE(nn.Module):
+    def __init__(self, d=25, id_dim=32, style_dim=64):
+        super().__init__()
+        self.shared = nn.Sequential(
+            nn.Linear(d, 128), nn.ReLU(),
+            nn.Linear(128, 128), nn.ReLU()
+        )
+        self.id_mu = nn.Linear(128, id_dim)
+        self.id_logvar = nn.Linear(128, id_dim)
+        self.style_mu = nn.Linear(128, style_dim)
+        self.style_logvar = nn.Linear(128, style_dim)
+        self.decoder = nn.Sequential(
+            nn.Linear(id_dim + style_dim, 128), nn.ReLU(),
+            nn.Linear(128, 128), nn.ReLU(),
+            nn.Linear(128, d)
+        )
+    
+    def encode(self, x):
+        h = self.shared(x)
+        return self.id_mu(h), self.id_logvar(h), self.style_mu(h), self.style_logvar(h)
+    
+    def reparameterize(self, mu, logvar):
+        std = torch.exp(0.5 * logvar)
+        eps = torch.randn_like(std)
+        return mu + eps * std
+    
+    def decode(self, z_id, z_style):
+        return self.decoder(torch.cat([z_id, z_style], dim=-1))
+    
+    def forward(self, x):
+        im, il, sm, sl = self.encode(x)
+        z_id = self.reparameterize(im, il)
+        z_style = self.reparameterize(sm, sl)
+        recon = self.decode(z_id, z_style)
+        return recon, im, il, sm, sl, z_id, z_style
+
+def train_idea2_synth(train_fine, train_coarse, test_fine, test_coarse,
+                       epochs=200, batch_size=256):
+    """
+    Idea 2: Identity-Realization Disentanglement
+    - Train VAE on paired (fine, coarse) data
+    - Same building → same identity, different LoD → different style
+    - Generate new views by resampling style
+    """
+    print(f"Idea 2: Identity-Realization VAE ({len(train_fine)} pairs)")
+    
+    d = train_fine.shape[1]
+    vae = DisentangledVAE(d=d).to(DEV)
+    vae_opt = torch.optim.AdamW(vae.parameters(), lr=3e-4)
+    
+    print("  Training VAE...")
+    N = len(train_fine)
+    for ep in range(500):
+        idx = np.random.permutation(N)[:batch_size]
+        x1 = torch.tensor(train_fine[idx], dtype=torch.float32).to(DEV)
+        x2 = torch.tensor(train_coarse[idx], dtype=torch.float32).to(DEV)
+        
+        recon1, im1, il1, sm1, sl1, zi1, zs1 = vae(x1)
+        recon2, im2, il2, sm2, sl2, zi2, zs2 = vae(x2)
+        
+        recon_loss = F.mse_loss(recon1, x1) + F.mse_loss(recon2, x2)
+        
+        kl_loss = 0
+        for mu, lv in [(im1, il1), (sm1, sl1), (im2, il2), (sm2, sl2)]:
+            kl_loss += (-0.5 * (1 + lv - mu.pow(2) - lv.exp()).sum(-1)).mean()
+        
+        id_cons_loss = F.mse_loss(zi1, zi2)
+        total_loss = recon_loss + 0.0001 * kl_loss + 0.05 * id_cons_loss
+        
+        vae_opt.zero_grad()
+        total_loss.backward()
+        torch.nn.utils.clip_grad_norm_(vae.parameters(), 1.0)
+        vae_opt.step()
+        
+        if ep % 100 == 0:
+            print(f"  VAE ep {ep}: recon={recon_loss:.4f}, kl={kl_loss:.4f}, id={id_cons_loss:.4f}")
+    
+    # Generate style-augmented views
+    print("  Generating style-augmented views...")
+    train_fine_t = torch.tensor(train_fine, dtype=torch.float32).to(DEV)
+    gen_views = []
+    with torch.no_grad():
+        for start in range(0, len(train_fine), batch_size):
+            batch = train_fine_t[start:start+batch_size]
+            _, im, _, _, _, _, _ = vae(batch)
+            zi = vae.reparameterize(im, torch.zeros_like(im))
+            for _ in range(3):
+                zs = torch.randn(len(batch), 64).to(DEV) * 0.5
+                gen_views.append(vae.decode(zi, zs).cpu().numpy())
+    gen_views = np.vstack(gen_views)
+    anchors = np.tile(train_fine, (3, 1))[:len(gen_views)]
+    print(f"  Generated {len(gen_views)} style-augmented views")
+    
+    # Train InfoNCE
+    trainer = ContrastiveTrainer(d=d)
+    best_f1 = 0.0
+    for ep in range(epochs):
+        loss = trainer.train_epoch(anchors, gen_views, batch_size)
+        if ep % 20 == 0:
+            f1 = evaluate_encoder(trainer.encoder, test_fine, test_coarse)
+            print(f"  Ep {ep}: loss={loss:.4f}, F1={f1:.4f}")
+            if f1 > best_f1:
+                best_f1 = f1
+                trainer.save('saved_model_files/enc_synth_i2.pt')
+    
+    torch.save({'vae': vae.state_dict()}, 'saved_model_files/vae_synth.pt')
+    return {'encoder_path': 'saved_model_files/enc_synth_i2.pt',
+            'best_test_f1': best_f1, 'method': 'vae+style_sampling'}
+
+# ============================================================
+# Idea 3: Denoise-to-Sibling (Direct InfoNCE on cross-LoD pairs)
+# ============================================================
+def train_idea3_synth(train_fine, train_coarse, test_fine, test_coarse,
+                       epochs=200, batch_size=256):
+    """Train on (fine, coarse) cross-LoD pairs directly."""
+    print(f"Idea 3 (Synth): Direct training on {len(train_fine)} cross-LoD pairs")
+    trainer = ContrastiveTrainer()
+    best_f1 = 0.0
+    for ep in range(epochs):
+        loss = trainer.train_epoch(train_fine, train_coarse, batch_size)
+        if ep % 20 == 0:
+            f1 = evaluate_encoder(trainer.encoder, test_fine, test_coarse)
+            print(f"  Ep {ep}: loss={loss:.4f}, test F1={f1:.4f}")
+            if f1 > best_f1:
+                best_f1 = f1
+                trainer.save('saved_model_files/enc_synth_i3.pt')
+    return {'encoder_path': 'saved_model_files/enc_synth_i3.pt',
+            'best_test_f1': best_f1}
+
+# ============================================================
+# Idea 3+: SDEdit augmentation (DDPM → siblings → contrastive)
+# ============================================================
+def train_idea3_ddpm_synth(train_fine, train_coarse, test_fine, test_coarse,
+                            epochs=200, batch_size=256, t0=200):
+    """Train DDPM on fine props, generate siblings, combine with cross-LoD pairs."""
+    print(f"Idea 3+DDPM: SDEdit t0={t0}")
+    bsd = min(batch_size, 256)
+    
+    ddpm = DDPM(d=train_fine.shape[1])
+    all_props_t = torch.tensor(np.vstack([train_fine, train_coarse]), dtype=torch.float32).to(DEV)
+    N_all = all_props_t.shape[0]
+    
+    print("  Training DDPM...")
+    for ep in range(300):
+        perm = torch.randperm(N_all)
+        ep_loss = 0
+        n_batches = 0
+        for start in range(0, N_all, bsd):
+            batch = all_props_t[perm[start:start+bsd]]
+            ep_loss += ddpm.train_step(batch)
+            n_batches += 1
+        if ep % 100 == 0:
+            print(f"    DDPM ep {ep}: loss={ep_loss/max(n_batches,1):.6f}")
+    
+    print("  Generating SDEdit siblings...")
+    fine_t = torch.tensor(train_fine, dtype=torch.float32).to(DEV)
+    sibs = []
+    for start in range(0, len(train_fine), bsd):
+        batch = fine_t[start:start+bsd]
+        sib = ddpm.sdedit(batch, t0=t0)
+        sibs.append(sib.cpu().numpy())
+    sibs = np.vstack(sibs)
+    
+    combined_a = np.vstack([train_fine, train_fine[:len(sibs)]])
+    combined_b = np.vstack([train_coarse, sibs])
+    print(f"  Combined: {len(combined_a)} pairs ({len(train_fine)} cross-LoD + {len(sibs)} SDEdit)")
+    
+    trainer = ContrastiveTrainer()
+    best_f1 = 0.0
+    for ep in range(epochs):
+        loss = trainer.train_epoch(combined_a, combined_b, batch_size)
+        if ep % 20 == 0:
+            f1 = evaluate_encoder(trainer.encoder, test_fine, test_coarse)
+            print(f"  Ep {ep}: loss={loss:.4f}, F1={f1:.4f}")
+            if f1 > best_f1:
+                best_f1 = f1
+                trainer.save(f'saved_model_files/enc_synth_i3p_t{t0}.pt')
+    
+    ddpm.save(f'saved_model_files/diff_synth.pt')
+    return {'encoder_path': f'saved_model_files/enc_synth_i3p_t{t0}.pt',
+            'best_test_f1': best_f1, 't0': t0}
+
+# ============================================================
+# Idea 4: Grammar Score Guard (DDPM score filter)
+# ============================================================
+def train_idea4_synth(train_fine, train_coarse, test_fine, test_coarse,
+                       epochs=200, batch_size=256, t0=200, keep_frac=0.5):
+    """
+    Idea 4: Grammar Score Guard
+    - Train DDPM → generate SDEdit siblings → score by DDPM → filter
+    """
+    print(f"Idea 4: Grammar Guard, t0={t0}, keep={keep_frac}")
+    bsd = min(batch_size, 256)
+    
+    ddpm = DDPM(d=train_fine.shape[1])
+    all_props_t = torch.tensor(np.vstack([train_fine, train_coarse]), dtype=torch.float32).to(DEV)
+    N_all = all_props_t.shape[0]
+    
+    print("  Training DDPM...")
+    for ep in range(300):
+        perm = torch.randperm(N_all)
+        ep_loss = 0
+        n_batches = 0
+        for start in range(0, N_all, bsd):
+            batch = all_props_t[perm[start:start+bsd]]
+            ep_loss += ddpm.train_step(batch)
+            n_batches += 1
+        if ep % 100 == 0:
+            print(f"    DDPM ep {ep}: loss={ep_loss/max(n_batches,1):.6f}")
+    
+    print("  Generating SDEdit siblings...")
+    fine_t = torch.tensor(train_fine, dtype=torch.float32).to(DEV)
+    sibs = []
+    for start in range(0, len(train_fine), bsd):
+        batch = fine_t[start:start+bsd]
+        sib = ddpm.sdedit(batch, t0=t0)
+        sibs.append(sib.cpu().numpy())
+    sibs = np.vstack(sibs)
+    
+    print("  Scoring siblings...")
+    sibs_t = torch.tensor(sibs, dtype=torch.float32).to(DEV)
+    scores = ddpm.score(sibs_t)  # (N, 5 time scales)
+    mean_score = scores.mean(dim=-1).cpu().numpy()
+    
+    n_keep = int(len(mean_score) * keep_frac)
+    keep_idx = np.argsort(mean_score)[:n_keep]
+    print(f"  Kept {n_keep}/{len(mean_score)} (score {mean_score.min():.3f}-{mean_score.max():.3f})")
+    
+    filtered_origs = train_fine[keep_idx]
+    filtered_sibs = sibs[keep_idx]
+    
+    trainer = ContrastiveTrainer()
+    best_f1 = 0.0
+    for ep in range(epochs):
+        loss = trainer.train_epoch(filtered_origs, filtered_sibs, batch_size)
+        if ep % 20 == 0:
+            f1 = evaluate_encoder(trainer.encoder, test_fine, test_coarse)
+            print(f"  Ep {ep}: loss={loss:.4f}, F1={f1:.4f}")
+            if f1 > best_f1:
+                best_f1 = f1
+                trainer.save(f'saved_model_files/enc_synth_i4_t{t0}_k{keep_frac}.pt')
+    
+    return {'encoder_path': f'saved_model_files/enc_synth_i4_t{t0}_k{keep_frac}.pt',
+            'best_test_f1': best_f1, 'n_kept': n_keep, 't0': t0, 'keep_frac': keep_frac}
+
+# ============================================================
+# Idea 5: Adversarial Hard-Positive
+# ============================================================
+def train_idea5_synth(train_fine, train_coarse, test_fine, test_coarse,
+                       epochs=100, batch_size=256, rounds=3):
+    """
+    Idea 5: Adversarial Hard-Positive
+    - Progressive rounds with increasing SDEdit difficulty (t0=100,200,300)
+    """
+    print(f"Idea 5: Adversarial Hard-Positive, rounds={rounds}")
+    bsd = min(batch_size, 256)
+    
+    ddpm = DDPM(d=train_fine.shape[1])
+    all_props_t = torch.tensor(np.vstack([train_fine, train_coarse]), dtype=torch.float32).to(DEV)
+    N_all = all_props_t.shape[0]
+    
+    print("  Training DDPM...")
+    for ep in range(300):
+        perm = torch.randperm(N_all)
+        ep_loss = 0
+        n_batches = 0
+        for start in range(0, N_all, bsd):
+            batch = all_props_t[perm[start:start+bsd]]
+            ep_loss += ddpm.train_step(batch)
+            n_batches += 1
+        if ep % 100 == 0:
+            print(f"    DDPM ep {ep}: loss={ep_loss/max(n_batches,1):.6f}")
+    
+    trainer = ContrastiveTrainer()
+    best_f1_overall = 0.0
+    best_round = 0
+    
+    for r in range(rounds):
+        t0 = 100 + r * 100
+        print(f"\n  --- Round {r+1}/{rounds} (t0={t0}) ---")
+        
+        fine_t = torch.tensor(train_fine, dtype=torch.float32).to(DEV)
+        sibs = []
+        for start in range(0, len(train_fine), bsd):
+            batch = fine_t[start:start+bsd]
+            sib = ddpm.sdedit(batch, t0=t0)
+            sibs.append(sib.cpu().numpy())
+        sibs = np.vstack(sibs)
+        
+        for ep in range(epochs):
+            loss = trainer.train_epoch(train_fine, sibs, batch_size)
+            if ep % 20 == 0:
+                f1 = evaluate_encoder(trainer.encoder, test_fine, test_coarse)
+                print(f"    Ep {ep}: loss={loss:.4f}, F1={f1:.4f}")
+                if f1 > best_f1_overall:
+                    best_f1_overall = f1
+                    best_round = r + 1
+                    trainer.save('saved_model_files/enc_synth_i5.pt')
+    
+    return {'encoder_path': 'saved_model_files/enc_synth_i5.pt',
+            'best_test_f1': best_f1_overall, 'best_round': best_round, 'rounds': rounds}
+
+# ============================================================
+# Idea 6: Cross-Building Transformation Transfer
+# ============================================================
+def train_idea6_synth(train_fine, train_coarse, test_fine, test_coarse,
+                       epochs=200, batch_size=256, knn=5):
+    """
+    Idea 6: Cross-Building Transformation Transfer
+    - Learn (fine→coarse) delta vectors from train pairs
+    - For each train building, find k nearest neighbors' deltas → average
+    - Apply averaged delta to create synthetic views
+    """
+    print(f"Idea 6: Cross-Building Transform, k={knn}")
+    from sklearn.neighbors import NearestNeighbors
+    
+    deltas = train_coarse - train_fine  # (N_train, 25)
+    print(f"  Delta stats: mean_norm={np.linalg.norm(deltas.mean(axis=0)):.3f}, std_norm={np.linalg.norm(deltas.std(axis=0)):.3f}")
+    
+    nn = NearestNeighbors(n_neighbors=min(knn+1, len(train_fine)), metric='cosine')
+    nn.fit(train_fine)
+    
+    dist, idx = nn.kneighbors(train_fine)
+    
+    avg_deltas = np.zeros_like(train_fine)
+    for i in range(len(train_fine)):
+        neighbor_idx = idx[i][idx[i] != i][:knn]
+        if len(neighbor_idx) > 0:
+            avg_deltas[i] = deltas[neighbor_idx].mean(axis=0)
+        else:
+            avg_deltas[i] = deltas[i]
+    
+    synthetic_views = train_fine + avg_deltas
+    print(f"  Generated {len(synthetic_views)} cross-building views")
+    
+    trainer = ContrastiveTrainer()
+    best_f1 = 0.0
+    for ep in range(epochs):
+        loss = trainer.train_epoch(train_fine, synthetic_views, batch_size)
+        if ep % 20 == 0:
+            f1 = evaluate_encoder(trainer.encoder, test_fine, test_coarse)
+            print(f"  Ep {ep}: loss={loss:.4f}, F1={f1:.4f}")
+            if f1 > best_f1:
+                best_f1 = f1
+                trainer.save(f'saved_model_files/enc_synth_i6_k{knn}.pt')
+    
+    return {'encoder_path': f'saved_model_files/enc_synth_i6_k{knn}.pt',
+            'best_test_f1': best_f1, 'k': knn}
+
+# ============================================================
+# Main
+# ============================================================
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--idea', type=str, required=True,
+                       choices=['1','2','3','3p','4','5','6'],
+                       help='Which STER-GI idea to train')
+    parser.add_argument('--epochs', type=int, default=200)
+    parser.add_argument('--batch_size', type=int, default=256)
+    parser.add_argument('--t0', type=int, default=200, help='t0 for SDEdit (Idea 3p,4)')
+    parser.add_argument('--keep_frac', type=float, default=0.5, help='Keep fraction for Idea 4')
+    parser.add_argument('--rounds', type=int, default=3, help='Adversarial rounds for Idea 5')
+    parser.add_argument('--knn', type=int, default=5, help='k for Idea 6')
+    parser.add_argument('--out', type=str, default='experiments/synth_train_results.json')
+    args = parser.parse_args()
+    
+    os.makedirs('saved_model_files', exist_ok=True)
+    os.makedirs('experiments', exist_ok=True)
+    
+    print("Loading and splitting data...")
+    (train_fine, train_coarse), (test_fine, test_coarse, test_ids) = load_and_split_data()
+    
+    bl_f1 = baseline_f1(test_fine, test_coarse)
+    print(f"\nCross-LoD Baseline F1: {bl_f1:.4f}")
+    
+    t0_time = time.time()
+    
+    if os.path.exists(args.out):
+        result = json.load(open(args.out))
+    else:
+        result = {'baseline_f1': bl_f1}
+    
+    idea_map = {
+        '1': lambda: train_idea1_synth(train_fine, train_coarse, test_fine, test_coarse,
+                                        epochs=args.epochs, batch_size=args.batch_size),
+        '2': lambda: train_idea2_synth(train_fine, train_coarse, test_fine, test_coarse,
+                                        epochs=args.epochs, batch_size=args.batch_size),
+        '3': lambda: train_idea3_synth(train_fine, train_coarse, test_fine, test_coarse,
+                                        epochs=args.epochs, batch_size=args.batch_size),
+        '3p': lambda: train_idea3_ddpm_synth(train_fine, train_coarse, test_fine, test_coarse,
+                                            epochs=args.epochs, batch_size=args.batch_size, t0=args.t0),
+        '4': lambda: train_idea4_synth(train_fine, train_coarse, test_fine, test_coarse,
+                                        epochs=args.epochs, batch_size=args.batch_size,
+                                        t0=args.t0, keep_frac=args.keep_frac),
+        '5': lambda: train_idea5_synth(train_fine, train_coarse, test_fine, test_coarse,
+                                        epochs=args.epochs, batch_size=args.batch_size, rounds=args.rounds),
+        '6': lambda: train_idea6_synth(train_fine, train_coarse, test_fine, test_coarse,
+                                        epochs=args.epochs, batch_size=args.batch_size, knn=args.knn),
+    }
+    
+    idea_key = f'idea{args.idea}'
+    res = idea_map[args.idea]()
+    result[idea_key] = res
+    
+    delta = res['best_test_f1'] - result.get('baseline_f1', bl_f1)
+    result[idea_key]['delta'] = round(delta, 6)
+    print(f"\nIdea {args.idea}: Best F1={res['best_test_f1']:.4f} (Δ={delta:+.4f})")
+    
+    result['total_time'] = round(time.time() - t0_time, 1)
+    json.dump(result, open(args.out, 'w'), indent=2)
+    print(f"Results saved to {args.out}")
+    print(f"Total time: {result['total_time']:.1f}s")