File size: 7,507 Bytes
e18eb8a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 | # 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}")
|