test.py

# test.py
import os
import torch
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
from models.wgan_gp import Generator
from train_utils.preprocess_s1 import preprocess_s1


# ---------------------------------------------------------------
# Helper: reconstruct and plot real samples
# ---------------------------------------------------------------
def compute_graph_metrics(nodes, A_soft, node_mask):
    """

    Evaluate connectivity and degree stats from generated graphs.

    Returns a dict with mean metrics across the batch:

      - 'connectivity': average number of connected components (lower is better; 1.0 means fully connected)

      - 'degree_mean': average node degree over valid nodes

      - 'degree_var' : variance of node degrees over valid nodes

    Notes:

      * A_soft is binarized at 0.5 to build an undirected simple graph.

      * node_mask indicates which nodes are valid (not padding).

    """
    metrics = {'connectivity': [], 'degree_mean': [], 'degree_var': []}

    # Move to CPU/NumPy
    if isinstance(nodes, torch.Tensor):     nodes = nodes.detach().cpu().numpy()
    if isinstance(A_soft, torch.Tensor):    A = (A_soft.detach().cpu().numpy() > 0.5).astype(int)
    else:                                   A = (A_soft > 0.5).astype(int)
    if isinstance(node_mask, torch.Tensor): node_mask = node_mask.detach().cpu().numpy()

    B, N, _ = nodes.shape
    for b in range(B):
        valid = node_mask[b] > 0.5
        idxs = np.where(valid)[0]

        if idxs.size == 0:
            metrics['connectivity'].append(0)
            metrics['degree_mean'].append(0)
            metrics['degree_var'].append(0)
            continue

        G = nx.Graph()
        G.add_nodes_from(idxs)

        # add edges only among valid nodes
        Ab = A[b]
        for i in range(len(idxs)):
            for j in range(i + 1, len(idxs)):
                u, v = idxs[i], idxs[j]
                if Ab[u, v] > 0:
                    G.add_edge(u, v)

        if len(G.nodes) > 0:
            degs = [d for _, d in G.degree()]
            metrics['connectivity'].append(nx.number_connected_components(G))
            metrics['degree_mean'].append(np.mean(degs))
            metrics['degree_var'].append(np.var(degs))
        else:
            metrics['connectivity'].append(0)
            metrics['degree_mean'].append(0)
            metrics['degree_var'].append(0)

    # Return batch means
    return {k: float(np.mean(v)) if len(v) > 0 else 0.0 for k, v in metrics.items()}


def reconstruct_sample(sample_np, metadata, index=None):
    """

    Reconstruct nodal coordinates, ele_nod, pel from a flattened dataset sample.

    """
    max_nodes = metadata['max_nodes']
    max_elements = metadata['max_elements']

    nodal_end = max_nodes * 2
    ele_end = nodal_end + max_elements * 2
    pel_end = ele_end + max_elements * 4

    nodal_flat = sample_np[:nodal_end]
    ele_flat = sample_np[nodal_end:ele_end]
    pel_flat = sample_np[ele_end:pel_end]

    # Estimate actual counts (nonzero or non-negative)
    nodal_coord = nodal_flat.reshape(-1, 2)
    valid_nodes = np.where(np.abs(nodal_coord).sum(-1) > 0)[0]
    nodal_coord = nodal_coord[valid_nodes]

    ele_nod = ele_flat.reshape(-1, 2).astype(int)
    valid_edges = (ele_nod[:, 0] >= 0) & (ele_nod[:, 1] >= 0)
    ele_nod = ele_nod[valid_edges]
    pel = pel_flat.reshape(-1, 4)[valid_edges]

    # Filter to existing node indices
    ele_nod = ele_nod[
        (ele_nod[:, 0] < len(nodal_coord)) & (ele_nod[:, 1] < len(nodal_coord))
    ]

    return nodal_coord, ele_nod, pel


def plot_truss(nodal_coord, ele_nod, title="Truss", ax=None, color_nodes="blue"):
    """Plot truss structure with nodes and connecting edges."""
    if ax is None:
        fig, ax = plt.subplots(figsize=(5, 4))
    if len(nodal_coord) == 0:
        return ax

    # Plot nodes
    ax.scatter(nodal_coord[:, 0], nodal_coord[:, 1], c=color_nodes, s=40, label="nodes")

    # Plot edges
    for e in ele_nod:
        if 0 <= e[0] < len(nodal_coord) and 0 <= e[1] < len(nodal_coord):
            x1, y1 = nodal_coord[e[0]]
            x2, y2 = nodal_coord[e[1]]
            ax.plot([x1, x2], [y1, y2], "k-", lw=1.2, alpha=0.7)

    ax.set_aspect("equal")
    ax.set_title(title)
    ax.grid(alpha=0.3)
    return ax


# ---------------------------------------------------------------
# Main evaluation + visualization
# ---------------------------------------------------------------
def evaluate_and_visualize(checkpoints_path, n_samples=6, device="cpu"):
    """

    Load the trained generator, generate samples, plot real vs generated trusses,

    show loss curves, and basic topology metrics.

    """
    device = torch.device(device)

    # ---- Load model + metadata ----
    metadata = np.load(os.path.join(checkpoints_path, "metadata.npy"), allow_pickle=True).item()
    generator_state = torch.load(os.path.join(checkpoints_path, "generator.pth"), map_location=device)
    epoch_losses = np.load(os.path.join(checkpoints_path, "epoch_losses.npy"), allow_pickle=True)

    generator = Generator(latent_dim=128, nmax=metadata["max_nodes"], cond_dim=4).to(device)
    generator.load_state_dict(generator_state)
    generator.eval()
    print(f"✅ Generator loaded. Using max_nodes={metadata['max_nodes']}, max_elements={metadata['max_elements']}")

    # ---- Load some real samples ----
    real_data, _ = preprocess_s1(normalize_type=None)
    real_samples = real_data[:n_samples]

    # ---- Generate fake trusses ----
    with torch.no_grad():
        z = torch.randn(n_samples, 128, device=device)
        # Conditioning: average-case normalized values
        cond_vals = [1.0, 1.0, 0.5, 0.5]
        cond = torch.tensor([cond_vals] * n_samples, dtype=torch.float32, device=device)
        nodes, node_mask, A_soft, _, _ = generator(z, cond)

        nodes = nodes.cpu().numpy()
        node_mask = node_mask.cpu().numpy()
        A_soft = A_soft.cpu().numpy()

    # ---- Build graph structures from generator outputs ----
    fake_nodal_coords, fake_ele_nods = [], []
    for b in range(n_samples):
        valid_nodes = np.where(node_mask[b] > 0.5)[0]
        coords = nodes[b, valid_nodes]
        edges = []
        for i in range(len(valid_nodes)):
            for j in range(i + 1, len(valid_nodes)):
                if A_soft[b, valid_nodes[i], valid_nodes[j]] > 0.5:
                    edges.append([i, j])
        fake_nodal_coords.append(coords)
        fake_ele_nods.append(np.array(edges, dtype=int))

    # ---- Plot real vs generated ----
    fig, axes = plt.subplots(2, n_samples, figsize=(3 * n_samples, 6))
    axes = axes.flatten()

    for i in range(n_samples):
        nodal_real, ele_nod_real, _ = reconstruct_sample(real_samples[i], metadata)
        plot_truss(nodal_real, ele_nod_real, f"Real {i+1}", ax=axes[i], color_nodes="tab:blue")
        plot_truss(fake_nodal_coords[i], fake_ele_nods[i], f"Gen {i+1}", ax=axes[i + n_samples], color_nodes="tab:orange")

    plt.tight_layout()
    plt.show()

    # ---- Plot training losses ----
    if isinstance(epoch_losses, np.ndarray) and epoch_losses.size > 0:
        # Convert to list of dicts if needed
        if not isinstance(epoch_losses[0], dict):
            epoch_losses = list(epoch_losses)
    else:
        print("⚠️ No training losses found.")
        epoch_losses = []

    if len(epoch_losses) > 0:
        epochs = [e["epoch"] for e in epoch_losses]
        d_losses = [e["d_loss"] for e in epoch_losses]
        g_losses = [e["g_loss"] for e in epoch_losses]

        plt.figure(figsize=(9, 4))
        plt.plot(epochs, d_losses, "r-", label="Discriminator Loss")
        plt.plot(epochs, g_losses, "b-", label="Generator Loss")
        plt.xlabel("Epoch")
        plt.ylabel("Loss")
        plt.title("Training Loss Curves (WGAN-GP)")
        plt.grid(alpha=0.3)
        plt.legend()
        plt.show()

        final = epoch_losses[-1]
        print(f"📉 Final Epoch {final['epoch']}: D={final['d_loss']:.3f}, G={final['g_loss']:.3f}")
    else:
        print("⚠️ No losses to plot.")

    # ---- Compute metrics for generated batch ----
    batch_size = min(5, n_samples)
    nodes_batch = torch.tensor(nodes[:batch_size], dtype=torch.float32)
    node_mask_batch = torch.tensor(node_mask[:batch_size], dtype=torch.float32)
    A_soft_batch = torch.tensor(A_soft[:batch_size], dtype=torch.float32)
    metrics = compute_graph_metrics(nodes_batch, A_soft_batch, node_mask_batch)
    print(f"📊 Generated graph metrics:\n{metrics}")


# ---------------------------------------------------------------
# Entry point
# ---------------------------------------------------------------
if __name__ == "__main__":
    evaluate_and_visualize("models/checkpoints", n_samples=6)