# Medical Visualization Callback # Saves mask + generated image grids during training for visual quality monitoring import os import torch import numpy as np from PIL import Image, ImageDraw, ImageFont import lightning.pytorch as pl from lightning.pytorch import Callback from lightning_utilities.core.rank_zero import rank_zero_info class MedicalVisualizationCallback(Callback): """ Periodically generates and saves visualization grids during training. Each grid shows: [Mask | Generated (CFG) | Generated (No-CFG)] for a fixed set of masks, allowing visual comparison across training. """ def __init__( self, every_n_steps: int = 5000, num_samples: int = 8, num_sampling_steps: int = 50, cfg_scale: float = 2.0, save_dir: str = "training_vis", t_eps: float = 0.05, ): super().__init__() self.every_n_steps = every_n_steps self.num_samples = num_samples self.num_sampling_steps = num_sampling_steps self.cfg_scale = cfg_scale self.save_dir = save_dir self.t_eps = t_eps self._fixed_noise = None self._fixed_masks = None def _shift_respace_fn(self, t, shift=1.0): return t / (t + (1 - t) * shift) @torch.no_grad() def _sample(self, model, noise, mask, cfg_scale=None): """Euler sampling with optional CFG, directly passing mask to model.""" bs = noise.shape[0] timesteps = torch.linspace(0.0, 1 - 1.0 / self.num_sampling_steps, self.num_sampling_steps) timesteps = torch.cat([timesteps, torch.tensor([1.0])], dim=0) timesteps = self._shift_respace_fn(timesteps, 1.0).to(noise.device) y = torch.zeros(bs, 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(bs) if cfg_scale is not None and cfg_scale > 1.0: # CFG: concat unconditional + conditional 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(self.t_eps) v_uncond, v_cond = pred_v.chunk(2) v = v_uncond + cfg_scale * (v_cond - v_uncond) else: # No CFG pred = model(x, t_batch, y, mask=mask) v = (pred - x) / (1.0 - t_batch.view(-1, 1, 1, 1)).clamp_min(self.t_eps) x = x + v * dt return x.clamp(-1, 1) * 0.5 + 0.5 # [-1,1] -> [0,1] def _mask_to_rgb(self, mask_tensor): """Convert single-channel mask [1, H, W] to RGB [H, W, 3] uint8.""" m = mask_tensor[0].cpu().numpy() unique_vals = np.unique(m) if len(unique_vals) <= 3: # Multi-class: colorize (e.g., REFUGE2: 0=black, ~0.5=blue, ~1.0=red) rgb = np.zeros((*m.shape, 3), dtype=np.uint8) rgb[m < 0.1] = [0, 0, 0] # background rgb[(m >= 0.1) & (m < 0.7)] = [0, 120, 255] # class 1 (blue) rgb[m >= 0.7] = [255, 60, 60] # class 2 (red) else: # Binary or continuous: grayscale m_uint8 = (m * 255).astype(np.uint8) rgb = np.stack([m_uint8] * 3, axis=-1) return rgb def _make_grid(self, masks, gen_cfg, gen_nocfg, step): """Create visualization grid: Mask | CFG | No-CFG.""" n = masks.shape[0] h, w = masks.shape[2], masks.shape[3] pad = 4 col_labels = ["Mask", f"CFG={self.cfg_scale}", "No-CFG"] n_cols = len(col_labels) header_h = 30 canvas_w = n_cols * w + (n_cols + 1) * pad canvas_h = n * h + (n + 1) * pad + header_h canvas = np.ones((canvas_h, canvas_w, 3), dtype=np.uint8) * 40 # Header try: font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 16) except (IOError, OSError): font = ImageFont.load_default() img_pil = Image.fromarray(canvas) draw = ImageDraw.Draw(img_pil) for col_idx, label in enumerate(col_labels): x_pos = pad + col_idx * (w + pad) + w // 2 draw.text((x_pos, 6), label, fill=(255, 255, 255), font=font, anchor="mt") # Step info draw.text((canvas_w - 10, 6), f"step={step}", fill=(180, 180, 180), font=font, anchor="rt") canvas = np.array(img_pil) for row in range(n): y_pos = header_h + pad + row * (h + pad) # Mask column mask_rgb = self._mask_to_rgb(masks[row]) x_pos = pad canvas[y_pos:y_pos + h, x_pos:x_pos + w] = mask_rgb # CFG generated img_cfg = (gen_cfg[row].permute(1, 2, 0).cpu().numpy() * 255).clip(0, 255).astype(np.uint8) x_pos = pad + (w + pad) canvas[y_pos:y_pos + h, x_pos:x_pos + w] = img_cfg # No-CFG generated img_nocfg = (gen_nocfg[row].permute(1, 2, 0).cpu().numpy() * 255).clip(0, 255).astype(np.uint8) x_pos = pad + 2 * (w + pad) canvas[y_pos:y_pos + h, x_pos:x_pos + w] = img_nocfg return canvas def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch_idx): step = trainer.global_step if step == 0 or step % self.every_n_steps != 0: return if not trainer.is_global_zero: return # Initialize fixed noise and masks from first validation batch if self._fixed_masks is None: eval_dl = trainer.datamodule.val_dataloader() for eval_batch in eval_dl: xT, y, metadata = eval_batch mask = metadata.get('mask', None) if isinstance(metadata, dict) else None if mask is None: rank_zero_info("[MedicalVis] No mask in eval batch, skipping visualization") return n = min(self.num_samples, mask.shape[0]) self._fixed_masks = mask[:n].to(pl_module.device) self._fixed_noise = torch.randn( n, 3, pl_module.denoiser.input_size, pl_module.denoiser.input_size, device=pl_module.device, generator=torch.Generator(device=pl_module.device).manual_seed(42) ) break if self._fixed_masks is None: return # Generate samples using EMA model model = pl_module.ema_denoiser was_training = model.training model.eval() noise = self._fixed_noise masks = self._fixed_masks gen_cfg = self._sample(model, noise, masks, cfg_scale=self.cfg_scale) gen_nocfg = self._sample(model, noise, masks, cfg_scale=None) if was_training: model.train() # Save grid save_path = os.path.join(trainer.default_root_dir, self.save_dir) os.makedirs(save_path, exist_ok=True) grid = self._make_grid(masks, gen_cfg, gen_nocfg, step) Image.fromarray(grid).save(os.path.join(save_path, f"vis_step_{step:06d}.png")) rank_zero_info(f"[MedicalVis] Saved visualization at step {step}")