code/scripts/evaluate_medical.py

"""
Medical Image Generation Evaluation
Compute FID, Precision, Recall between generated and real images.
Supports both CVC-ClinicDB and Kvasir-SEG experiments.

Usage:
  python scripts/evaluate_medical.py --dataset kvasir
  python scripts/evaluate_medical.py --dataset cvc
"""
import sys
sys.path.insert(0, "/data/sichengli/Code/PixelGen")

import argparse
import os
import gc
import random
import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Dataset
from PIL import Image
import torchvision.transforms as transforms
import torchvision.transforms.functional as TF
from torchmetrics.image.fid import FrechetInceptionDistance
from torchmetrics.image.inception import InceptionScore

from src.models.transformer.JiT_medical import JiTMedical


# ─── Config ───────────────────────────────────────────────────────────
CONFIGS = {
    "kvasir": {
        "data_root": "/data2/sichengli/Data/test/Segmentation/Kvasir-SEG/Kvasir-SEG",
        "img_subdir": "images",
        "mask_subdir": "masks",
        "file_ext": (".jpg", ".png", ".jpeg"),
        "ckpt": "/data/sichengli/Code/PixelGen/medical_workdirs/exp_PixelGen_Medical_Kvasir/epoch=12499-step=100000.ckpt",
        "out_dir": "/data/sichengli/Code/PixelGen/medical_workdirs/exp_PixelGen_Medical_Kvasir/eval_results",
        "train_ratio": 0.9,
        "seed": 42,
    },
    "cvc": {
        "data_root": "/data2/sichengli/Data/test/Segmentation/CVC-ClinicDB",
        "img_subdir": "PNG/Original",
        "mask_subdir": "PNG/Ground Truth",
        "file_ext": (".png",),
        "ckpt": "/data/sichengli/Code/PixelGen/medical_workdirs/exp_PixelGen_Medical_CVC/epoch=19999-step=100000.ckpt",
        "out_dir": "/data/sichengli/Code/PixelGen/medical_workdirs/exp_PixelGen_Medical_CVC/eval_results",
        "train_ratio": 0.9,
        "seed": 42,
    },
    "refuge2": {
        "data_root": "/data2/sichengli/Data/test/Segmentation/REFUGE2",
        "multi_split": True,
        "splits": ["train", "val"],
        "file_ext": (".jpg", ".png", ".jpeg"),
        "mask_ext": (".bmp", ".png"),
        "ckpt": "/data/sichengli/Code/PixelGen/medical_workdirs/exp_PixelGen_Medical_REFUGE2/epoch=16666-step=100000.ckpt",
        "out_dir": "/data/sichengli/Code/PixelGen/medical_workdirs/exp_PixelGen_Medical_REFUGE2/eval_results",
        "val_ratio": 0.1,
        "seed": 42,
    },
}

MODEL_CONFIGS = {
    "S/8": dict(
        input_size=256, patch_size=8, in_channels=3,
        hidden_size=512, depth=8, num_heads=8, mlp_ratio=4.0,
        attn_drop=0.0, proj_drop=0.1, num_classes=1,
        use_bottleneck=True, bottleneck_dim=64,
        in_context_len=64, in_context_start=2, mask_in_channels=1,
    ),
    "B/8": dict(
        input_size=256, patch_size=8, in_channels=3,
        hidden_size=768, depth=12, num_heads=12, mlp_ratio=4.0,
        attn_drop=0.0, proj_drop=0.1, num_classes=1,
        use_bottleneck=True, bottleneck_dim=128,
        in_context_len=64, in_context_start=4, mask_in_channels=1,
    ),
    "B/16": dict(
        input_size=256, patch_size=16, in_channels=3,
        hidden_size=768, depth=12, num_heads=12, mlp_ratio=4.0,
        attn_drop=0.0, proj_drop=0.1, num_classes=1,
        use_bottleneck=True, bottleneck_dim=128,
        in_context_len=32, in_context_start=4, mask_in_channels=1,
    ),
    "L/16": dict(
        input_size=256, patch_size=16, in_channels=3,
        hidden_size=1024, depth=24, num_heads=16, mlp_ratio=4.0,
        attn_drop=0.0, proj_drop=0.1, num_classes=1,
        use_bottleneck=True, bottleneck_dim=128,
        in_context_len=32, in_context_start=8, mask_in_channels=1,
    ),
    "XL/16": dict(
        input_size=256, patch_size=16, in_channels=3,
        hidden_size=1152, depth=28, num_heads=16, mlp_ratio=4.0,
        attn_drop=0.0, proj_drop=0.1, num_classes=1,
        use_bottleneck=True, bottleneck_dim=128,
        in_context_len=32, in_context_start=8, mask_in_channels=1,
    ),
}

RESOLUTION = 256
BATCH_SIZE = 16
NUM_SAMPLING_STEPS = 50


# ─── Dataset ──────────────────────────────────────────────────────────
class EvalDataset(Dataset):
    """Load real images and masks for a given split."""
    def __init__(self, cfg, split="train"):
        if cfg.get("multi_split"):
            # REFUGE2-style: multiple split folders, mask may have different extension
            all_pairs = []
            for s in cfg["splits"]:
                img_dir = os.path.join(cfg["data_root"], s, "images")
                mask_dir = os.path.join(cfg["data_root"], s, "mask")
                img_files = sorted([f for f in os.listdir(img_dir) if f.endswith(cfg["file_ext"])])
                for img_f in img_files:
                    base_name = os.path.splitext(img_f)[0]
                    img_path = os.path.join(img_dir, img_f)
                    for ext in cfg["mask_ext"]:
                        candidate = os.path.join(mask_dir, base_name + ext)
                        if os.path.exists(candidate):
                            all_pairs.append((img_path, candidate))
                            break
            # Use val_ratio to split train/val
            random.seed(cfg["seed"])
            random.shuffle(all_pairs)
            split_idx = int(len(all_pairs) * (1 - cfg.get("val_ratio", 0.1)))
            if split == "train":
                self.pairs = all_pairs[:split_idx]
            else:
                self.pairs = all_pairs[split_idx:]
            self.multi_split = True
        else:
            # CVC/Kvasir-style: single img/mask dirs with train_ratio split
            img_dir = os.path.join(cfg["data_root"], cfg["img_subdir"])
            mask_dir = os.path.join(cfg["data_root"], cfg["mask_subdir"])
            all_files = sorted([f for f in os.listdir(img_dir) if f.endswith(cfg["file_ext"])])

            random.seed(cfg["seed"])
            indices = list(range(len(all_files)))
            random.shuffle(indices)
            split_idx = int(len(indices) * cfg["train_ratio"])

            if split == "train":
                sel = indices[:split_idx]
            else:
                sel = indices[split_idx:]

            self.files = [all_files[i] for i in sorted(sel)]
            self.img_dir = img_dir
            self.mask_dir = mask_dir
            self.multi_split = False

    def __len__(self):
        return len(self.pairs) if self.multi_split else len(self.files)

    def __getitem__(self, idx):
        if self.multi_split:
            img_path, mask_path = self.pairs[idx]
            img = Image.open(img_path).convert("RGB")
            mask = Image.open(mask_path).convert("L")
        else:
            fname = self.files[idx]
            img = Image.open(os.path.join(self.img_dir, fname)).convert("RGB")
            mask = Image.open(os.path.join(self.mask_dir, fname)).convert("L")

        img = TF.resize(img, (RESOLUTION, RESOLUTION), interpolation=transforms.InterpolationMode.BILINEAR)
        img_tensor = TF.to_tensor(img)  # [3, H, W] in [0, 1]

        mask = TF.resize(mask, (RESOLUTION, RESOLUTION), interpolation=transforms.InterpolationMode.NEAREST)
        mask_tensor = TF.to_tensor(mask)  # [1, H, W] in [0, 1]

        return img_tensor, mask_tensor


# ─── Sampling ─────────────────────────────────────────────────────────
def shift_respace_fn(t, shift=1.0):
    return t / (t + (1 - t) * shift)


@torch.no_grad()
def sample_batch(model, noise, mask, num_steps=50, t_eps=0.05):
    """No-CFG sampling for evaluation (faster, avoids CFG artifacts)."""
    batch_size = noise.shape[0]
    timesteps = torch.linspace(0.0, 1 - 1.0 / num_steps, num_steps)
    timesteps = torch.cat([timesteps, torch.tensor([1.0])], dim=0)
    timesteps = shift_respace_fn(timesteps, 1.0).to(noise.device)
    y = torch.zeros(batch_size, dtype=torch.long, device=noise.device)
    x = noise
    for i in range(len(timesteps) - 1):
        t_cur = timesteps[i]
        t_next = timesteps[i + 1]
        dt = t_next - t_cur
        t_batch = t_cur.repeat(batch_size)
        pred_img = model(x, t_batch, y, mask=mask)
        v = (pred_img - x) / (1.0 - t_batch.view(-1, 1, 1, 1)).clamp_min(t_eps)
        x = x + v * dt
    return x


@torch.no_grad()
def sample_batch_cfg(model, noise, mask, num_steps=50, cfg_scale=2.0, t_eps=0.05):
    """CFG sampling for evaluation."""
    batch_size = noise.shape[0]
    timesteps = torch.linspace(0.0, 1 - 1.0 / num_steps, num_steps)
    timesteps = torch.cat([timesteps, torch.tensor([1.0])], dim=0)
    timesteps = shift_respace_fn(timesteps, 1.0).to(noise.device)
    y = torch.zeros(batch_size, dtype=torch.long, device=noise.device)
    x = noise
    for i in range(len(timesteps) - 1):
        t_cur = timesteps[i]
        t_next = timesteps[i + 1]
        dt = t_next - t_cur
        t_batch = t_cur.repeat(batch_size)
        cfg_x = torch.cat([x, x], dim=0)
        cfg_t = t_batch.repeat(2)
        cfg_y = torch.cat([y, y], dim=0)
        cfg_mask = torch.cat([torch.zeros_like(mask), mask], dim=0)
        pred = model(cfg_x, cfg_t, cfg_y, mask=cfg_mask)
        pred_v = (pred - cfg_x) / (1.0 - cfg_t.view(-1, 1, 1, 1)).clamp_min(t_eps)
        v_uncond, v_cond = pred_v.chunk(2)
        v = v_uncond + cfg_scale * (v_cond - v_uncond)
        x = x + v * dt
    return x


# ─── Inception Features for Precision/Recall ──────────────────────────
class InceptionV3Features(nn.Module):
    """Extract Inception V3 pool3 features (2048-d) for P&R computation."""
    def __init__(self, device):
        super().__init__()
        from torchvision.models import inception_v3, Inception_V3_Weights
        self.model = inception_v3(weights=Inception_V3_Weights.DEFAULT)
        self.model.fc = nn.Identity()
        self.model = self.model.to(device).eval()
        self.device = device
        self.transform = transforms.Normalize(
            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
        )

    @torch.no_grad()
    def forward(self, images):
        """images: [N, 3, H, W] in [0, 1], uint8 or float."""
        if images.dtype == torch.uint8:
            images = images.float() / 255.0
        # Resize to 299x299 for Inception
        images = torch.nn.functional.interpolate(images, size=(299, 299), mode="bilinear", align_corners=False)
        images = torch.stack([self.transform(img) for img in images])
        images = images.to(self.device)
        features = self.model(images)
        return features.cpu()


def compute_precision_recall(real_features, gen_features, k=3):
    """
    Compute Precision and Recall using k-NN manifold estimation.
    Based on 'Improved Precision and Recall Metric for Assessing Generative Models' (Kynkaanniemi et al.)
    """
    from scipy.spatial.distance import cdist

    real_np = real_features.numpy()
    gen_np = gen_features.numpy()

    # Compute pairwise distances
    # For real manifold: k-th nearest neighbor distance among real samples
    real_real_dist = cdist(real_np, real_np, metric="euclidean")
    np.fill_diagonal(real_real_dist, np.inf)
    real_kth = np.sort(real_real_dist, axis=1)[:, k - 1]  # k-th NN distance for each real sample

    # For generated manifold: k-th nearest neighbor distance among generated samples
    gen_gen_dist = cdist(gen_np, gen_np, metric="euclidean")
    np.fill_diagonal(gen_gen_dist, np.inf)
    gen_kth = np.sort(gen_gen_dist, axis=1)[:, k - 1]

    # Precision: fraction of generated samples falling within the real manifold
    gen_real_dist = cdist(gen_np, real_np, metric="euclidean")
    precision = np.mean(np.min(gen_real_dist, axis=1) <= real_kth[np.argmin(gen_real_dist, axis=1)])

    # Recall: fraction of real samples falling within the generated manifold
    real_gen_dist = cdist(real_np, gen_np, metric="euclidean")
    recall = np.mean(np.min(real_gen_dist, axis=1) <= gen_kth[np.argmin(real_gen_dist, axis=1)])

    return precision, recall


# ─── Main ─────────────────────────────────────────────────────────────
def evaluate(dataset_name, use_cfg=False, cfg_scale=2.0, model_kwargs=None):
    cfg = CONFIGS[dataset_name]
    device = torch.device("cuda:0")
    os.makedirs(cfg["out_dir"], exist_ok=True)

    print(f"\n{'='*60}")
    print(f"  Evaluating: {dataset_name.upper()}")
    print(f"  Checkpoint: {os.path.basename(cfg['ckpt'])}")
    print(f"  Sampling: {'CFG=' + str(cfg_scale) if use_cfg else 'No-CFG'}")
    print(f"{'='*60}\n")

    # Load dataset (train split for FID comparison)
    dataset = EvalDataset(cfg, split="train")
    loader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=4, pin_memory=True)
    num_samples = len(dataset)
    print(f"Dataset: {num_samples} training images")

    # Load model
    print("Loading model...")
    ckpt = torch.load(cfg["ckpt"], map_location="cpu", weights_only=False)
    state_dict = ckpt["state_dict"]
    ema_state = {}
    for k, v in state_dict.items():
        if k.startswith("ema_denoiser."):
            new_k = k.replace("ema_denoiser.", "").replace("_orig_mod.", "")
            ema_state[new_k] = v
    model = JiTMedical(**model_kwargs)
    result = model.load_state_dict(ema_state, strict=False)
    print(f"Loaded EMA ({len(ema_state)} keys), missing: {result.missing_keys}, unexpected: {result.unexpected_keys}")
    model = model.to(device).eval().to(torch.float32)

    # Initialize metrics
    fid_metric = FrechetInceptionDistance(feature=2048, normalize=True).to(device)
    inception_features = InceptionV3Features(device)

    all_real_features = []
    all_gen_features = []

    # Generate and compute metrics
    print(f"\nGenerating {num_samples} images and computing features...")
    torch.manual_seed(0)  # Reproducible noise

    batch_idx = 0
    for real_imgs, masks in loader:
        bs = real_imgs.shape[0]
        batch_idx += 1
        print(f"  Batch {batch_idx}/{len(loader)} ({bs} samples)...", end="\r")

        masks = masks.to(device)
        noise = torch.randn(bs, 3, RESOLUTION, RESOLUTION, device=device)

        # Generate
        if use_cfg:
            gen = sample_batch_cfg(model, noise, masks, NUM_SAMPLING_STEPS, cfg_scale)
        else:
            gen = sample_batch(model, noise, masks, NUM_SAMPLING_STEPS)
        gen = gen.clamp(-1, 1) * 0.5 + 0.5  # [-1,1] -> [0,1]

        # FID: update with real and generated (expects [0,1] float with normalize=True)
        fid_metric.update(real_imgs.to(device), real=True)
        fid_metric.update(gen, real=False)

        # Inception features for P&R
        real_feat = inception_features(real_imgs)
        gen_feat = inception_features(gen.cpu())
        all_real_features.append(real_feat)
        all_gen_features.append(gen_feat)

    print(f"\n\nComputing FID...")
    fid_value = fid_metric.compute().item()
    print(f"FID = {fid_value:.4f}")

    # Compute Precision & Recall
    print("Computing Precision & Recall...")
    real_features = torch.cat(all_real_features, dim=0)
    gen_features = torch.cat(all_gen_features, dim=0)
    precision, recall = compute_precision_recall(real_features, gen_features, k=3)
    print(f"Precision = {precision:.4f}")
    print(f"Recall = {recall:.4f}")

    # Save results
    mode_str = f"cfg{cfg_scale}" if use_cfg else "no_cfg"
    result_file = os.path.join(cfg["out_dir"], f"metrics_{mode_str}.txt")
    with open(result_file, "w") as f:
        f.write(f"Dataset: {dataset_name}\n")
        f.write(f"Checkpoint: {cfg['ckpt']}\n")
        f.write(f"Sampling: {'CFG=' + str(cfg_scale) if use_cfg else 'No-CFG'}\n")
        f.write(f"Num samples: {num_samples}\n")
        f.write(f"Num steps: {NUM_SAMPLING_STEPS}\n")
        f.write(f"\n")
        f.write(f"FID: {fid_value:.4f}\n")
        f.write(f"Precision: {precision:.4f}\n")
        f.write(f"Recall: {recall:.4f}\n")
    print(f"\nResults saved: {result_file}")

    # Print summary
    print(f"\n{'='*40}")
    print(f"  {dataset_name.upper()} Results ({mode_str})")
    print(f"  FID:       {fid_value:.4f}")
    print(f"  Precision: {precision:.4f}")
    print(f"  Recall:    {recall:.4f}")
    print(f"{'='*40}\n")

    return fid_value, precision, recall


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--dataset", type=str, required=True, choices=["kvasir", "cvc", "refuge2", "all"])
    parser.add_argument("--cfg", action="store_true", help="Use CFG sampling")
    parser.add_argument("--cfg_scale", type=float, default=2.0)
    parser.add_argument("--mask_mode", type=str, default="spatial", choices=["global", "spatial", "cross_attention"])
    parser.add_argument("--model", type=str, default="B/16", choices=["S/8", "B/8", "B/16", "L/16", "XL/16"])
    parser.add_argument("--ckpt", type=str, default=None, help="Override checkpoint path")
    args = parser.parse_args()

    # Build model kwargs
    model_kwargs = MODEL_CONFIGS[args.model].copy()
    model_kwargs["mask_mode"] = args.mask_mode

    datasets = ["cvc", "kvasir", "refuge2"] if args.dataset == "all" else [args.dataset]

    all_results = {}
    for ds in datasets:
        # Override checkpoint if provided
        if args.ckpt:
            CONFIGS[ds]["ckpt"] = args.ckpt

        # Always run No-CFG
        fid_nc, prec_nc, rec_nc = evaluate(ds, use_cfg=False, model_kwargs=model_kwargs)
        all_results[f"{ds}_no_cfg"] = (fid_nc, prec_nc, rec_nc)

        # Also run CFG if requested
        if args.cfg:
            fid_c, prec_c, rec_c = evaluate(ds, use_cfg=True, cfg_scale=args.cfg_scale, model_kwargs=model_kwargs)
            all_results[f"{ds}_cfg{args.cfg_scale}"] = (fid_c, prec_c, rec_c)

        # Clean up
        gc.collect()
        torch.cuda.empty_cache()

    # Final summary
    if len(all_results) > 1:
        print("\n" + "=" * 60)
        print("  SUMMARY")
        print("=" * 60)
        print(f"{'Experiment':<25s} | {'FID':>8s} | {'Precision':>10s} | {'Recall':>8s}")
        print("-" * 60)
        for name, (fid, prec, rec) in all_results.items():
            print(f"{name:<25s} | {fid:>8.2f} | {prec:>10.4f} | {rec:>8.4f}")
        print("=" * 60)