""" Visualize the step-by-step denoising process for each dataset. For each sample: - Save predicted x0 at EVERY step as individual images - Create a combined grid showing the full progression """ import sys sys.path.insert(0, "/data/sichengli/Code/PixelGen") import torch import numpy as np from PIL import Image, ImageDraw, ImageFont import torchvision.transforms as transforms import torchvision.transforms.functional as TF import os, random from src.models.transformer.JiT_medical import JiTMedical device = torch.device("cuda:0") 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" ) NUM_STEPS = 50 CFG_SCALE = 2.0 DATASETS = { "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_base": "/data/sichengli/Code/PixelGen/medical_workdirs/exp_PixelGen_Medical_CVC/sampling_process", "multi_split": False, "n_samples": 3, }, "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_base": "/data/sichengli/Code/PixelGen/medical_workdirs/exp_PixelGen_Medical_Kvasir/sampling_process", "multi_split": False, "n_samples": 3, }, "refuge2": { "data_root": "/data2/sichengli/Data/test/Segmentation/REFUGE2", "img_subdir": None, "mask_subdir": None, "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_base": "/data/sichengli/Code/PixelGen/medical_workdirs/exp_PixelGen_Medical_REFUGE2/sampling_process", "multi_split": True, "splits": ["train", "val"], "n_samples": 3, }, } def load_model(ckpt_path): 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) model.load_state_dict(ema_state, strict=False) model = model.to(device).eval().to(torch.float32) return model def shift_respace_fn(t, shift=1.0): return t / (t + (1 - t) * shift) @torch.no_grad() def sample_with_intermediates(model, noise, mask, num_steps=50, cfg_scale=2.0, t_eps=0.05): """ Euler ODE sampler with CFG. Returns predicted x0 at every step. """ 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.clone() intermediates = [] # list of (step_idx, t_value, x0_pred, x_t) 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 forward 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) # The model predicts x0; extract conditional prediction pred_uncond, pred_cond = pred.chunk(2) # Velocity from x0 prediction 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) # Save the CFG-guided x0 prediction: x0 = x_t + v * (1 - t) x0_pred = x + v * (1.0 - t_cur) intermediates.append({ "step": i + 1, "t": t_cur.item(), "x0_pred": x0_pred.clamp(-1, 1).cpu(), "x_t": x.clamp(-1, 1).cpu(), }) # Euler step x = x + v * dt # Final result intermediates.append({ "step": num_steps, "t": 1.0, "x0_pred": x.clamp(-1, 1).cpu(), "x_t": x.clamp(-1, 1).cpu(), }) return x, intermediates def load_samples(cfg, n_samples, seed=777): """Load random image-mask pairs from dataset.""" pairs = [] # (img_tensor, mask_tensor, name) if cfg["multi_split"]: all_pairs = [] for split in cfg["splits"]: img_dir = os.path.join(cfg["data_root"], split, "images") mask_dir = os.path.join(cfg["data_root"], split, "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 = os.path.splitext(img_f)[0] for ext in cfg["mask_ext"]: cand = os.path.join(mask_dir, base + ext) if os.path.exists(cand): all_pairs.append((os.path.join(img_dir, img_f), cand, f"{split}_{base}")) break random.seed(seed) selected = random.sample(all_pairs, min(n_samples, len(all_pairs))) for img_path, mask_path, name in selected: img = Image.open(img_path).convert("RGB") img = TF.resize(img, (256, 256)) mask = Image.open(mask_path).convert("L") mask = TF.resize(mask, (256, 256), interpolation=transforms.InterpolationMode.NEAREST) pairs.append((TF.to_tensor(img), TF.to_tensor(mask), name)) else: 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(seed) selected = random.sample(all_files, min(n_samples, len(all_files))) for fname in selected: img = Image.open(os.path.join(img_dir, fname)).convert("RGB") img = TF.resize(img, (256, 256)) mask = Image.open(os.path.join(mask_dir, fname)).convert("L") mask = TF.resize(mask, (256, 256), interpolation=transforms.InterpolationMode.NEAREST) name = os.path.splitext(fname)[0] pairs.append((TF.to_tensor(img), TF.to_tensor(mask), name)) return pairs def tensor_to_uint8(t): """Convert [-1,1] or [0,1] tensor to uint8 numpy [H,W,3].""" img = t.clamp(-1, 1) * 0.5 + 0.5 # [-1,1] -> [0,1] return (img.permute(1, 2, 0).numpy() * 255).clip(0, 255).astype(np.uint8) def mask_to_rgb(mask_tensor): """Convert [1,H,W] mask tensor to [H,W,3] uint8.""" m = mask_tensor[0].numpy() if len(np.unique(m)) > 2: # Multi-class (REFUGE2): colorize rgb = np.zeros((*m.shape, 3), dtype=np.uint8) rgb[m > 0.7] = [255, 80, 80] # optic disc = red rgb[(m > 0.3) & (m <= 0.7)] = [80, 80, 255] # optic cup = blue return rgb else: # Binary mask m_rgb = np.stack([m, m, m], axis=-1) return (m_rgb * 255).clip(0, 255).astype(np.uint8) def process_dataset(ds_name, cfg): print(f"\n{'='*60}") print(f" Processing: {ds_name.upper()}") print(f"{'='*60}") out_base = cfg["out_base"] os.makedirs(out_base, exist_ok=True) # Load model model = load_model(cfg["ckpt"]) # Load samples samples = load_samples(cfg, cfg["n_samples"]) print(f" Loaded {len(samples)} samples") # Steps to show in combined grid (select ~12 representative steps) grid_steps = [1, 3, 5, 8, 10, 15, 20, 25, 30, 35, 40, 45, 50] for sample_idx, (real_img, mask_tensor, name) in enumerate(samples): print(f"\n Sample {sample_idx+1}/{len(samples)}: {name}") sample_dir = os.path.join(out_base, name) os.makedirs(sample_dir, exist_ok=True) # Generate with intermediates mask_gpu = mask_tensor.unsqueeze(0).to(device) torch.manual_seed(sample_idx * 100 + 42) noise = torch.randn(1, 3, 256, 256, device=device) _, intermediates = sample_with_intermediates(model, noise, mask_gpu, NUM_STEPS, CFG_SCALE) # Save mask and real image Image.fromarray(mask_to_rgb(mask_tensor)).save(os.path.join(sample_dir, "mask.png")) Image.fromarray((real_img.permute(1, 2, 0).numpy() * 255).clip(0, 255).astype(np.uint8)).save( os.path.join(sample_dir, "real.png")) # Save initial noise noise_vis = tensor_to_uint8(noise[0].cpu()) Image.fromarray(noise_vis).save(os.path.join(sample_dir, "step_00_noise.png")) # Save every step's x0 prediction for item in intermediates: step = item["step"] x0 = tensor_to_uint8(item["x0_pred"][0]) Image.fromarray(x0).save(os.path.join(sample_dir, f"step_{step:02d}_x0pred.png")) print(f" Saved {len(intermediates)+2} individual images to {sample_dir}/") # ─── Combined grid for this sample ─── # Layout: Noise | step1 | step3 | ... | step50 | Real # With Mask on top-left or as first column h, w = 256, 256 pad = 3 # Columns: Mask, Noise, selected steps, Real col_items = [("Mask", mask_to_rgb(mask_tensor))] col_items.append(("Noise", noise_vis)) for item in intermediates: if item["step"] in grid_steps: label = f"Step {item['step']}" col_items.append((label, tensor_to_uint8(item["x0_pred"][0]))) col_items.append(("Real", (real_img.permute(1, 2, 0).numpy() * 255).clip(0, 255).astype(np.uint8))) n_cols = len(col_items) label_h = 30 canvas_w = n_cols * w + (n_cols + 1) * pad canvas_h = h + 2 * pad + label_h canvas = np.ones((canvas_h, canvas_w, 3), dtype=np.uint8) * 30 try: font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 14) except Exception: font = ImageFont.load_default() pil_canvas = Image.fromarray(canvas) draw = ImageDraw.Draw(pil_canvas) for col, (label, _) in enumerate(col_items): x_pos = pad + col * (w + pad) + w // 2 bbox = draw.textbbox((0, 0), label, font=font) text_w = bbox[2] - bbox[0] draw.text((x_pos - text_w // 2, 6), label, fill=(255, 255, 255), font=font) canvas = np.array(pil_canvas) for col, (_, img_np) in enumerate(col_items): x = pad + col * (w + pad) y = label_h + pad canvas[y:y+h, x:x+w] = img_np grid_path = os.path.join(sample_dir, f"progression_grid.png") Image.fromarray(canvas).save(grid_path) print(f" Saved grid: {grid_path} ({canvas_w}x{canvas_h})") # ─── Final combined image: all samples for this dataset ─── all_samples_data = [] for sample_idx, (real_img, mask_tensor, name) in enumerate(samples): sample_dir = os.path.join(out_base, name) mask_gpu = mask_tensor.unsqueeze(0).to(device) torch.manual_seed(sample_idx * 100 + 42) noise = torch.randn(1, 3, 256, 256, device=device) noise_vis = tensor_to_uint8(noise[0].cpu()) # Re-read saved step images for grid row_imgs = [("Mask", mask_to_rgb(mask_tensor)), ("Noise", noise_vis)] for step in grid_steps: fpath = os.path.join(sample_dir, f"step_{step:02d}_x0pred.png") if os.path.exists(fpath): row_imgs.append((f"Step {step}", np.array(Image.open(fpath)))) row_imgs.append(("Real", (real_img.permute(1, 2, 0).numpy() * 255).clip(0, 255).astype(np.uint8))) all_samples_data.append(row_imgs) # Build combined grid n_rows = len(all_samples_data) n_cols = len(all_samples_data[0]) h, w = 256, 256 pad = 3 label_h = 30 canvas_w = n_cols * w + (n_cols + 1) * pad canvas_h = n_rows * h + (n_rows + 1) * pad + label_h canvas = np.ones((canvas_h, canvas_w, 3), dtype=np.uint8) * 30 pil_canvas = Image.fromarray(canvas) draw = ImageDraw.Draw(pil_canvas) for col, (label, _) in enumerate(all_samples_data[0]): x_pos = pad + col * (w + pad) + w // 2 bbox = draw.textbbox((0, 0), label, font=font) text_w = bbox[2] - bbox[0] draw.text((x_pos - text_w // 2, 6), label, fill=(255, 255, 255), font=font) canvas = np.array(pil_canvas) for row_idx, row_imgs in enumerate(all_samples_data): y = label_h + pad + row_idx * (h + pad) for col_idx, (_, img_np) in enumerate(row_imgs): x = pad + col_idx * (w + pad) canvas[y:y+h, x:x+w] = img_np combined_path = os.path.join(out_base, f"all_samples_progression.png") Image.fromarray(canvas).save(combined_path) print(f"\n Combined grid saved: {combined_path} ({canvas_w}x{canvas_h})") del model import gc gc.collect() torch.cuda.empty_cache() if __name__ == "__main__": for ds_name, cfg in DATASETS.items(): process_dataset(ds_name, cfg) print("\nAll done!")