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