train.py

# train.py
import os
import torch
import torch.optim as optim
import numpy as np
from torch.utils.data import DataLoader, Dataset
import torch.nn.functional as F
import math

from models.wgan_gp import Generator, Discriminator, gradient_penalty, aux_losses
from train_utils.preprocess_s1 import preprocess_s1

# ----------------------------
# Utility: vectorized adjacency
# ----------------------------
def build_adj_from_eleblock_vectorized(ele_block, nmax_batch):
    """
    Vectorized adjacency build from a padded ele_nod block.
    ele_block: float tensor [B, max_elems*2] (padded with -1 for invalid)
    nmax_batch: int, number of nodes to consider for this batch (<= global nmax)
    Returns:
        A_real: float tensor [B, nmax_batch, nmax_batch] with 0/1 entries.
    """
    B = ele_block.size(0)
    device = ele_block.device
    # reshape to [B, M, 2]
    pairs = ele_block.view(B, -1, 2).long()
    rows = pairs[..., 0]  # [B, M]
    cols = pairs[..., 1]  # [B, M]
    # valid entries: both in [0, nmax_batch)
    valid = (rows >= 0) & (cols >= 0) & (rows < nmax_batch) & (cols < nmax_batch)
    if valid.any():
        bidx = torch.arange(B, device=device).unsqueeze(1).expand_as(rows)
        b_sel = bidx[valid]
        r_sel = rows[valid]
        c_sel = cols[valid]
        A = torch.zeros(B, nmax_batch, nmax_batch, device=device)
        A[b_sel, r_sel, c_sel] = 1.0
        A[b_sel, c_sel, r_sel] = 1.0
        # zero diagonal
        idx = torch.arange(nmax_batch, device=device)
        A[:, idx, idx] = 0.0
        return A
    else:
        return torch.zeros(B, nmax_batch, nmax_batch, device=device)


# ----------------------------
# Dataset with size info (from legacy padded matrix)
# ----------------------------
class TrussFlatDataset(Dataset):
    """
    Uses preprocess_s1() output (padded flat vectors), but carries per-sample sizes.
    """
    def __init__(self, data_array: np.ndarray, metadata: dict):
        super().__init__()
        self.data = torch.tensor(data_array, dtype=torch.float32)
        self.meta = metadata
        self.max_nodes = int(self.meta['max_nodes'])
        self.max_elems = int(self.meta['max_elements'])
        self.size_info = torch.tensor(self.meta['size_info'], dtype=torch.long)  # [N, 2] = (n_nodes, n_elems)

    def __len__(self):
        return self.data.size(0)

    def __getitem__(self, idx):
        flat = self.data[idx]
        n_nodes, n_elems = self.size_info[idx].tolist()
        return flat, n_nodes, n_elems


# ----------------------------
# Length-bucketed sampler
# ----------------------------
def make_length_buckets(size_info: np.ndarray, bucket_width_nodes=16, bucket_width_elems=32):
    """
    Assign samples to (node_bucket, elem_bucket) bins to reduce padding overhead per batch.
    Returns: list of lists of indices (buckets).
    """
    buckets = {}
    for i, (n, e) in enumerate(size_info):
        bn = (int(n) // bucket_width_nodes) * bucket_width_nodes
        be = (int(e) // bucket_width_elems) * bucket_width_elems
        key = (bn, be)
        buckets.setdefault(key, []).append(i)
    # Return buckets sorted by size (optional)
    return [idxs for _, idxs in sorted(buckets.items(), key=lambda kv: (kv[0][0], kv[0][1]))]


def bucketed_batch_sampler(size_info: np.ndarray, batch_size=16,
                           bucket_width_nodes=16, bucket_width_elems=32):
    """
    Yields lists of indices; each batch comes from a single bucket.
    """
    buckets = make_length_buckets(size_info, bucket_width_nodes, bucket_width_elems)
    for idxs in buckets:
        # shuffle within each bucket:
        idxs = np.array(idxs)
        perm = np.random.permutation(len(idxs))
        idxs = idxs[perm]
        # emit batches
        for start in range(0, len(idxs), batch_size):
            yield idxs[start:start+batch_size].tolist()


# ----------------------------
# Collate: dynamic per-batch padding & masks
# ----------------------------
def collate_truss(batch, max_nodes_global, max_elems_global):
    """
    batch: list of (flat, n_nodes, n_elems)
    Returns tensors cropped to per-batch maximum sizes (dramatically smaller than global),
    along with masks and split blocks.
    """
    flats, n_nodes_list, n_elems_list = zip(*batch)
    B = len(flats)
    # Per-batch maxima
    nmax_b = max(n_nodes_list)
    emax_b = max(n_elems_list)

    flats = torch.stack(flats, 0)  # [B, total_dim]
    # split from flat (global layout)
    node_end = max_nodes_global * 2
    ele_end  = node_end + max_elems_global * 2

    nodes_full = flats[:, :node_end].view(B, max_nodes_global, 2)
    ele_block_full = flats[:, node_end:ele_end]  # [B, max_elems_global*2]

    # Crop to batch maxima (big speed/memory win)
    nodes = nodes_full[:, :nmax_b, :]                     # [B, nmax_b, 2]
    ele_block = ele_block_full[:, : (emax_b * 2)]         # [B, emax_b*2]

    # Node mask from coords (nonzero rows). More robust: consider a tiny eps.
    node_mask = (nodes.abs().sum(-1) > 0).float()         # [B, nmax_b]

    # Build dense adjacency (vectorized) for real graphs
    A_real = build_adj_from_eleblock_vectorized(ele_block, nmax_b)
    # Mask adjacency by node existence
    m = node_mask.unsqueeze(-1) * node_mask.unsqueeze(-2)
    A_real = A_real * m
    # Ensure zero diagonal
    idx = torch.arange(nmax_b, device=A_real.device)
    A_real[:, idx, idx] = 0.0

    # Prepare conditioning per sample (normalized by GLOBAL maxima)
    n_nodes_norm = torch.tensor([n / max_nodes_global for n in n_nodes_list], dtype=torch.float32, device=flats.device).unsqueeze(1)
    n_elems_norm = torch.tensor([e / max_elems_global for e in n_elems_list], dtype=torch.float32, device=flats.device).unsqueeze(1)
    # If height/spacing are needed here, you can plug them from file; for now random as before
    height = torch.rand(B, 1, device=flats.device) * 0.8 + 0.2
    spacing = torch.rand(B, 1, device=flats.device) * 0.8 + 0.2
    cond = torch.cat([n_nodes_norm, n_elems_norm, height, spacing], dim=1)  # [B,4]

    return nodes, node_mask, A_real, cond, nmax_b


# ----------------------------
# Connectivity penalty (vectorized)
# ----------------------------
def connectivity_penalty(fake_nodes_mask, fake_A_soft):
    """
    Penalize if too many isolated/invalid nodes: encourages edges incident to active nodes.
    fake_nodes_mask: [B, N]
    fake_A_soft:     [B, N, N]
    Returns scalar tensor.
    """
    # degree per node = sum_j A_ij
    deg = fake_A_soft.sum(dim=-1)  # [B, N]
    active = (fake_nodes_mask > 0.5).float()
    iso = (deg < 1e-3).float() * active
    # penalty: mean number of isolated active nodes
    return iso.mean()


# ----------------------------
# Training
# ----------------------------
def train_wgan_gp(device='cuda',
                  n_epochs=100, batch_size=16, latent_dim=128,
                  n_critic=5, lr_g=2e-4, lr_d=1e-4,
                  lambda_gp=10, lambda_connect=5.0,
                  save_path='models/checkpoints',
                  bucket_width_nodes=16, bucket_width_elems=32):
    """
    Train WGAN-GP with:
      - vectorized adjacency build
      - length-bucketed batching
      - dynamic per-batch padding & masking
    """
    if not torch.cuda.is_available():
        print("⚠️ CUDA not available, training on CPU will be slow.")
        device = 'cpu'
    device = torch.device(device)

    # Load preprocessed (legacy padded) data but with size_info for bucketing
    data_array, metadata = preprocess_s1()
    dataset = TrussFlatDataset(data_array, metadata)

    # Bucketed batch sampler (reduces padding)
    size_info = metadata['size_info']
    sampler = list(bucketed_batch_sampler(size_info,
                                          batch_size=batch_size,
                                          bucket_width_nodes=bucket_width_nodes,
                                          bucket_width_elems=bucket_width_elems))

    # We’ll build our own DataLoader-like loop b/c we use a custom sampler + collate
    max_nodes_global = metadata['max_nodes']
    max_elems_global = metadata['max_elements']

    # Init models at GLOBAL maxima; we’ll slice per-batch for the critic pass
    cond_dim = 4  # [normed n_nodes, n_elems, height, spacing]
    generator = Generator(latent_dim=latent_dim, nmax=max_nodes_global, cond_dim=cond_dim).to(device)
    discriminator = Discriminator(nmax=max_nodes_global, cond_dim=cond_dim).to(device)

    opt_g = optim.Adam(generator.parameters(), lr=lr_g, betas=(0.0, 0.99))
    opt_d = optim.Adam(discriminator.parameters(), lr=lr_d, betas=(0.0, 0.99))

    best_score = float('-inf')
    g_loss_ema = 0.0
    epoch_losses = []
    os.makedirs(save_path, exist_ok=True)

    print(f"Starting training on {len(dataset)} samples with {len(sampler)} bucketed batches per epoch...")

    try:
        for epoch in range(n_epochs):
            epoch_d_loss, epoch_g_loss = 0.0, 0.0

            # Shuffle order of batches each epoch for better mixing
            perm_batches = np.random.permutation(len(sampler)).tolist()

            for b_id in perm_batches:
                idxs = sampler[b_id]
                batch = [dataset[i] for i in idxs]

                # --- Collate (dynamic crop + vectorized adjacency)
                nodes_real, node_mask_real, A_real, cond, nmax_b = collate_truss(
                    batch, max_nodes_global, max_elems_global
                )
                nodes_real = nodes_real.to(device)
                node_mask_real = node_mask_real.to(device)
                A_real = A_real.to(device)
                cond = cond.to(device)
                bs = nodes_real.size(0)

                # ---- Train Discriminator ----
                for _ in range(n_critic):
                    z = torch.randn(bs, latent_dim, device=device)
                    nodes_f, nmask_f, A_f, elog_f, nlog_f = generator(z, cond)

                    # Slice generator outputs to per-batch effective size for the critic:
                    nodes_f_b = nodes_f[:, :nmax_b, :]
                    nmask_f_b = nmask_f[:, :nmax_b]
                    A_f_b = A_f[:, :nmax_b, :nmax_b]
                    elog_f_b = elog_f[:, :nmax_b, :nmax_b]  # just for aux losses later

                    d_real = discriminator(nodes_real, A_real, node_mask_real, cond)
                    d_fake = discriminator(nodes_f_b.detach(), A_f_b.detach(), nmask_f_b.detach(), cond)

                    gp = gradient_penalty(
                        discriminator,
                        (nodes_real, node_mask_real, A_real, cond),
                        (nodes_f_b.detach(), nmask_f_b.detach(), A_f_b.detach(), cond),
                        lambda_gp
                    )
                    loss_d = -(d_real.mean() - d_fake.mean()) + gp
                    opt_d.zero_grad(set_to_none=True)
                    loss_d.backward()
                    opt_d.step()

                # ---- Train Generator ----
                z = torch.randn(bs, latent_dim, device=device)
                nodes_f, nmask_f, A_f, elog_f, nlog_f = generator(z, cond)
                nodes_f_b = nodes_f[:, :nmax_b, :]
                nmask_f_b = nmask_f[:, :nmax_b]
                A_f_b = A_f[:, :nmax_b, :nmax_b]
                elog_f_b = elog_f[:, :nmax_b, :nmax_b]

                d_fake = discriminator(nodes_f_b, A_f_b, nmask_f_b, cond)
                adv_loss = -d_fake.mean()

                L_nodes, L_mask, L_edges = aux_losses(
                    nodes_f_b, nmask_f_b, elog_f_b,
                    nodes_real, node_mask_real, A_real
                )

                loss_g = adv_loss + 10 * L_nodes + 1 * L_mask + 5 * L_edges

                if lambda_connect > 0:
                    loss_g += lambda_connect * connectivity_penalty(nmask_f_b, A_f_b)

                opt_g.zero_grad(set_to_none=True)
                loss_g.backward()
                opt_g.step()

                epoch_d_loss += loss_d.item()
                epoch_g_loss += loss_g.item()

            # ---- Logging & checkpointing ----
            num_batches = len(sampler)
            epoch_d_loss /= num_batches
            epoch_g_loss /= num_batches
            epoch_losses.append({'epoch': epoch + 1,
                                 'd_loss': epoch_d_loss,
                                 'g_loss': epoch_g_loss})

            # quick graph stats (last batch’s fakes)
            with torch.no_grad():
                deg_mean = float(A_f_b.mean().item() * nmax_b)  # rough proxy
                conn_proxy = float((A_f_b.sum(dim=-1) > 0.5).float().mean().item())

            print(f"[{epoch+1}/{n_epochs}] D: {epoch_d_loss:.3f} | G: {epoch_g_loss:.3f} "
                  f"| N_b:{nmax_b:3d} | DegMean~{deg_mean:.2f} | Conn~{conn_proxy:.2f}")

            # Use exponential moving average to judge improvement
            ema_beta = 0.9
            if epoch == 0:
                g_loss_ema = epoch_g_loss
            else:
                g_loss_ema = ema_beta * g_loss_ema + (1 - ema_beta) * epoch_g_loss

            # Evaluate composite "stability score"
            # Here we prioritize low |G_loss| (close to zero) and high connectivity
            score = -abs(epoch_g_loss) + 0.5 * conn_proxy  # weights can be tuned

            if score > best_score:
                best_score = score
                torch.save(generator.state_dict(), os.path.join(save_path, f'generator_best.pth'))
                torch.save(discriminator.state_dict(), os.path.join(save_path, f'discriminator_best.pth'))
                np.save(os.path.join(save_path, 'metadata.npy'), metadata)
                print(f"✅ New best model at epoch {epoch+1}: score={score:.3f}, G_loss={epoch_g_loss:.3f}, Conn={conn_proxy:.2f}")

            # Also save periodic checkpoints (for recovery)
            if (epoch + 1) % 10 == 0:
                torch.save(generator.state_dict(), os.path.join(save_path, f'generator_epoch{epoch+1}.pth'))
                torch.save(discriminator.state_dict(), os.path.join(save_path, f'discriminator_epoch{epoch+1}.pth'))
                np.save(os.path.join(save_path, 'metadata.npy'), metadata)
                print(f"💾 Periodic checkpoint saved at epoch {epoch+1}")

        # Final save
        np.save(os.path.join(save_path, 'epoch_losses.npy'), epoch_losses)
        print(f"Training complete. Models saved to {save_path}.")

    except KeyboardInterrupt:
        print("\n⚠️ Training interrupted by user. Saving current state...")
        os.makedirs(save_path, exist_ok=True)
        np.save(os.path.join(save_path, 'epoch_losses.npy'), epoch_losses)
        torch.save(generator.state_dict(), os.path.join(save_path, 'generator_interrupted.pth'))
        torch.save(discriminator.state_dict(), os.path.join(save_path, 'discriminator_interrupted.pth'))
        np.save(os.path.join(save_path, 'metadata.npy'), metadata)
        print(f"🟡 Interrupted state saved to {save_path}.")
        raise


if __name__ == '__main__':
    train_wgan_gp(device='cuda' if torch.cuda.is_available() else 'cpu')