code/ster_train_synth.py

"""
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")