code/scripts/v4_generate_pairs.py

"""
V4: Offline pair generation for cycle consistency training.
For each training mask, generate 2 images with different noise seeds,
saving to seed0/, seed1/, masks/ directories.

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

import argparse
import os
import random
import numpy as np
import torch
from PIL import Image
import torchvision.transforms as transforms
import torchvision.transforms.functional as TF
from torch.utils.data import Dataset, DataLoader
import torchvision.utils as vutils

from src.models.transformer.JiT_medical import JiTMedical


# ─── Config ───────────────────────────────────────────────────────────
DATASET_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",
        "multi_split": False,
        "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",
        "multi_split": False,
        "train_ratio": 0.9,
        "seed": 42,
    },
    "refuge2": {
        "data_root": "/data2/sichengli/Data/test/Segmentation/REFUGE2",
        "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",
        "multi_split": True,
        "val_ratio": 0.1,
        "seed": 42,
    },
}

MODEL_KWARGS = 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,
    mask_mode="spatial"
)

RESOLUTION = 256
BATCH_SIZE = 16
NUM_STEPS = 50
CFG_SCALE = 2.0
GEN_SEEDS = [0, 12345]


# ─── Dataset ──────────────────────────────────────────────────────────
class TrainMaskDataset(Dataset):
    """Load training split masks for any dataset."""
    def __init__(self, cfg):
        self.resolution = RESOLUTION
        self.mask_paths = []

        if cfg.get("multi_split"):
            # REFUGE2: combine train+val, then holdout
            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]
                    for ext in cfg["mask_ext"]:
                        candidate = os.path.join(mask_dir, base_name + ext)
                        if os.path.exists(candidate):
                            all_pairs.append(candidate)
                            break
            random.seed(cfg["seed"])
            random.shuffle(all_pairs)
            split_idx = int(len(all_pairs) * (1 - cfg.get("val_ratio", 0.1)))
            self.mask_paths = all_pairs[:split_idx]
        else:
            # CVC/Kvasir: simple 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"])
            train_indices = indices[:split_idx]
            self.mask_paths = [os.path.join(mask_dir, all_files[i]) for i in sorted(train_indices)]

        print(f"[TrainMaskDataset] {len(self.mask_paths)} training masks")

    def __len__(self):
        return len(self.mask_paths)

    def __getitem__(self, idx):
        mask = Image.open(self.mask_paths[idx]).convert("L")
        mask = TF.resize(mask, (self.resolution, self.resolution),
                         interpolation=transforms.InterpolationMode.NEAREST)
        mask_tensor = TF.to_tensor(mask)  # [1, H, W] in [0, 1]
        return mask_tensor, idx


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


@torch.no_grad()
def sample_batch_cfg(model, noise, mask, num_steps=50, cfg_scale=2.0, t_eps=0.05):
    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


def load_model(ckpt_path, device):
    ckpt = torch.load(ckpt_path, 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)
    return model


# ─── Main ─────────────────────────────────────────────────────────────
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--dataset", type=str, required=True, choices=["kvasir", "cvc", "refuge2"])
    args = parser.parse_args()

    cfg = DATASET_CONFIGS[args.dataset]
    device = torch.device("cuda:0")
    out_dir = f"/data/sichengli/Code/PixelGen/synergy_v4_workdir/{args.dataset}/generated"

    for subdir in ["seed0", "seed1", "masks"]:
        os.makedirs(os.path.join(out_dir, subdir), exist_ok=True)

    dataset = TrainMaskDataset(cfg)
    loader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=False,
                        num_workers=4, pin_memory=True)

    print(f"Loading PixelGen model for {args.dataset}...")
    model = load_model(cfg["ckpt"], device)

    # Save masks
    print("Saving resized masks...")
    for masks, indices in loader:
        for i in range(masks.shape[0]):
            idx = indices[i].item()
            mask_np = (masks[i, 0].numpy() * 255).astype(np.uint8)
            Image.fromarray(mask_np).save(os.path.join(out_dir, "masks", f"{idx:04d}.png"))

    # Generate for each seed
    for seed_idx, seed_val in enumerate(GEN_SEEDS):
        seed_dir = os.path.join(out_dir, f"seed{seed_idx}")
        print(f"\n{'='*60}")
        print(f"  [{args.dataset}] Generating with seed={seed_val} -> seed{seed_idx}/")
        print(f"  CFG={CFG_SCALE}, {NUM_STEPS} Euler steps")
        print(f"{'='*60}")

        torch.manual_seed(seed_val)
        for batch_idx, (masks, indices) in enumerate(loader):
            bs = masks.shape[0]
            masks = masks.to(device)
            noise = torch.randn(bs, 3, RESOLUTION, RESOLUTION, device=device)
            gen = sample_batch_cfg(model, noise, masks, NUM_STEPS, CFG_SCALE)
            gen = gen.clamp(-1, 1) * 0.5 + 0.5

            for i in range(bs):
                idx = indices[i].item()
                img_np = (gen[i].permute(1, 2, 0).cpu().numpy() * 255).clip(0, 255).astype(np.uint8)
                Image.fromarray(img_np).save(os.path.join(seed_dir, f"{idx:04d}.png"))

            print(f"  Batch {batch_idx+1}/{len(loader)} | {bs} images")

    # Preview grid
    print("\nSaving preview grid...")
    n_preview = min(8, len(dataset))
    grid_images = []
    for i in range(n_preview):
        mask_img = Image.open(os.path.join(out_dir, "masks", f"{i:04d}.png")).convert("RGB")
        seed0_img = Image.open(os.path.join(out_dir, "seed0", f"{i:04d}.png")).convert("RGB")
        seed1_img = Image.open(os.path.join(out_dir, "seed1", f"{i:04d}.png")).convert("RGB")
        grid_images.extend([TF.to_tensor(mask_img), TF.to_tensor(seed0_img), TF.to_tensor(seed1_img)])
    grid = vutils.make_grid(torch.stack(grid_images), nrow=3, padding=2, normalize=False)
    TF.to_pil_image(grid).save(os.path.join(out_dir, "grid.png"))

    print(f"\nDone! Generated {len(dataset)} x 2 = {len(dataset)*2} images")
    print(f"Output: {out_dir}")


if __name__ == "__main__":
    main()