code/src/diffusion/flow_matching/sampling_medical.py

# Sampling for Medical Image Generation with Mask Conditioning
# Based on sampling.py with mask support

import torch
import torch.nn as nn
from typing import Callable
import logging

from src.diffusion.base.guidance import *
from src.diffusion.base.scheduling import BaseScheduler
from src.diffusion.base.sampling import BaseSampler

logger = logging.getLogger(__name__)


def shift_respace_fn(t, shift=3.0):
    return t / (t + (1 - t) * shift)


def ode_step_fn(x, v, dt, s, w):
    return x + v * dt


class EulerSamplerMedical(BaseSampler):
    """
    Euler sampler for mask-conditional medical image generation.
    """

    def __init__(
            self,
            w_scheduler: BaseScheduler = None,
            timeshift: float = 1.0,
            guidance_interval_min: float = 0.0,
            guidance_interval_max: float = 1.0,
            step_fn: Callable = ode_step_fn,
            last_step: float = None,
            last_step_fn: Callable = ode_step_fn,
            t_eps: float = 0.05,
            *args,
            **kwargs
    ):
        super().__init__(*args, **kwargs)
        self.step_fn = step_fn
        self.last_step = last_step
        self.last_step_fn = last_step_fn
        self.w_scheduler = w_scheduler
        self.timeshift = timeshift
        self.guidance_interval_min = guidance_interval_min
        self.guidance_interval_max = guidance_interval_max
        self.t_eps = t_eps

        if self.last_step is None or self.num_steps == 1:
            self.last_step = 1.0 / self.num_steps

        timesteps = torch.linspace(0.0, 1 - self.last_step, self.num_steps)
        timesteps = torch.cat([timesteps, torch.tensor([1.0])], dim=0)
        self.timesteps = shift_respace_fn(timesteps, self.timeshift)

        assert self.last_step > 0.0
        assert self.scheduler is not None

    def _impl_sampling(self, net, noise, condition, uncondition, mask=None):
        """
        Sampling with mask conditioning.

        Args:
            net: Denoiser network
            noise: Initial noise [N, 3, H, W]
            condition: Mask embedding [N, hidden_size]
            uncondition: Null embedding [N, hidden_size]
            mask: Optional mask tensor [N, C, H, W] for direct conditioning

        Returns:
            x_trajs: List of intermediate samples
            v_trajs: List of velocity predictions
        """
        batch_size = noise.shape[0]
        steps = self.timesteps.to(noise.device, noise.dtype)

        # CFG: concatenate uncondition and condition
        # Note: For mask conditioning, we handle this differently
        x = noise
        x_trajs = [noise]
        v_trajs = []

        for i, (t_cur, t_next) in enumerate(zip(steps[:-1], steps[1:])):
            dt = t_next - t_cur
            t_cur_batch = t_cur.repeat(batch_size)

            sigma = self.scheduler.sigma(t_cur_batch)
            dalpha_over_alpha = self.scheduler.dalpha_over_alpha(t_cur_batch)
            dsigma_mul_sigma = self.scheduler.dsigma_mul_sigma(t_cur_batch)

            if self.w_scheduler:
                w = self.w_scheduler.w(t_cur_batch)
            else:
                w = 0.0

            # CFG forward pass
            cfg_x = torch.cat([x, x], dim=0)
            cfg_t = t_cur_batch.repeat(2)

            # For mask conditioning, we need to handle y (class label)
            # and pass mask separately to the model
            y_uncond = torch.zeros(batch_size, dtype=torch.long, device=noise.device)
            y_cond = torch.zeros(batch_size, dtype=torch.long, device=noise.device)
            cfg_y = torch.cat([y_uncond, y_cond], dim=0)

            if mask is not None:
                cfg_mask = torch.cat([
                    torch.zeros_like(mask),  # Unconditional: zero mask
                    mask                      # Conditional: actual mask
                ], dim=0)
                out = net(cfg_x, cfg_t, cfg_y, mask=cfg_mask)
            else:
                out = net(cfg_x, cfg_t, cfg_y, mask=None)

            # Convert x-prediction to velocity
            out = (out - cfg_x) / (1.0 - cfg_t.view(-1, 1, 1, 1)).clamp_min(self.t_eps)

            # Apply CFG
            if t_cur > self.guidance_interval_min and t_cur <= self.guidance_interval_max:
                out = self.guidance_fn(out, self.guidance)
            else:
                out = self.guidance_fn(out, 1.0)

            v = out
            s = ((1 / dalpha_over_alpha) * v - x) / (sigma ** 2 - (1 / dalpha_over_alpha) * dsigma_mul_sigma)

            if i < self.num_steps - 1:
                x = self.step_fn(x, v, dt, s=s, w=w)
            else:
                x = self.last_step_fn(x, v, dt, s=s, w=w)

            x_trajs.append(x)
            v_trajs.append(v)

        v_trajs.append(torch.zeros_like(x))
        return x_trajs, v_trajs


class HeunSamplerMedical(BaseSampler):
    """
    Heun sampler for mask-conditional medical image generation.
    Second-order ODE solver for better quality.
    """

    def __init__(
            self,
            scheduler: BaseScheduler = None,
            w_scheduler: BaseScheduler = None,
            exact_heun: bool = True,
            guidance_interval_min: float = 0.0,
            guidance_interval_max: float = 1.0,
            timeshift: float = 1.0,
            step_fn: Callable = ode_step_fn,
            last_step: float = None,
            last_step_fn: Callable = ode_step_fn,
            t_eps: float = 0.05,
            *args,
            **kwargs
    ):
        super().__init__(*args, **kwargs)
        self.scheduler = scheduler
        self.exact_heun = exact_heun
        self.step_fn = step_fn
        self.last_step = last_step
        self.last_step_fn = last_step_fn
        self.w_scheduler = w_scheduler
        self.timeshift = timeshift
        self.guidance_interval_min = guidance_interval_min
        self.guidance_interval_max = guidance_interval_max
        self.t_eps = t_eps

        if self.last_step is None or self.num_steps == 1:
            self.last_step = 1.0 / self.num_steps

        timesteps = torch.linspace(0.0, 1 - self.last_step, self.num_steps)
        timesteps = torch.cat([timesteps, torch.tensor([1.0])], dim=0)
        self.timesteps = shift_respace_fn(timesteps, self.timeshift)

        assert self.last_step > 0.0
        assert self.scheduler is not None

    def _forward_with_cfg(self, net, x, t, mask=None):
        """Forward pass with CFG for mask conditioning."""
        batch_size = x.shape[0] // 2

        y = torch.zeros(x.shape[0], dtype=torch.long, device=x.device)

        if mask is not None:
            out = net(x, t, y, mask=mask)
        else:
            out = net(x, t, y, mask=None)

        return out

    def _impl_sampling(self, net, noise, condition, uncondition, mask=None):
        """
        Heun sampling with mask conditioning.
        """
        batch_size = noise.shape[0]
        steps = self.timesteps.to(noise.device)

        x = noise
        v_hat, s_hat = 0.0, 0.0
        x_trajs = [noise]
        v_trajs = []

        for i, (t_cur, t_next) in enumerate(zip(steps[:-1], steps[1:])):
            dt = t_next - t_cur
            t_cur_batch = t_cur.repeat(batch_size)

            sigma = self.scheduler.sigma(t_cur_batch)
            alpha_over_dalpha = 1 / self.scheduler.dalpha_over_alpha(t_cur_batch)
            dsigma_mul_sigma = self.scheduler.dsigma_mul_sigma(t_cur_batch)

            t_hat = t_next.repeat(batch_size)
            sigma_hat = self.scheduler.sigma(t_hat)
            alpha_over_dalpha_hat = 1 / self.scheduler.dalpha_over_alpha(t_hat)
            dsigma_mul_sigma_hat = self.scheduler.dsigma_mul_sigma(t_hat)

            if self.w_scheduler:
                w = self.w_scheduler.w(t_cur_batch)
            else:
                w = 0.0

            if i == 0 or self.exact_heun:
                # First evaluation
                cfg_x = torch.cat([x, x], dim=0)
                cfg_t = t_cur_batch.repeat(2)

                if mask is not None:
                    cfg_mask = torch.cat([torch.zeros_like(mask), mask], dim=0)
                else:
                    cfg_mask = None

                out = self._forward_with_cfg(net, cfg_x, cfg_t, cfg_mask)
                out = (out - cfg_x) / (1.0 - cfg_t.view(-1, 1, 1, 1)).clamp_min(self.t_eps)

                if t_cur > self.guidance_interval_min and t_cur <= self.guidance_interval_max:
                    out = self.guidance_fn(out, self.guidance)
                else:
                    out = self.guidance_fn(out, 1.0)

                v = out
                s = (alpha_over_dalpha * v - x) / (sigma ** 2 - alpha_over_dalpha * dsigma_mul_sigma)
            else:
                v = v_hat
                s = s_hat

            x_hat = self.step_fn(x, v, dt, s=s, w=w)

            # Heun correction
            if i < self.num_steps - 1:
                cfg_x_hat = torch.cat([x_hat, x_hat], dim=0)
                cfg_t_hat = t_hat.repeat(2)

                if mask is not None:
                    cfg_mask = torch.cat([torch.zeros_like(mask), mask], dim=0)
                else:
                    cfg_mask = None

                out = self._forward_with_cfg(net, cfg_x_hat, cfg_t_hat, cfg_mask)
                out = (out - cfg_x_hat) / (1.0 - cfg_t_hat.view(-1, 1, 1, 1)).clamp_min(self.t_eps)

                if t_cur > self.guidance_interval_min and t_cur <= self.guidance_interval_max:
                    out = self.guidance_fn(out, self.guidance)
                else:
                    out = self.guidance_fn(out, 1.0)

                v_hat = out
                s_hat = (alpha_over_dalpha_hat * v_hat - x_hat) / (sigma_hat ** 2 - alpha_over_dalpha_hat * dsigma_mul_sigma_hat)
                v = (v + v_hat) / 2
                s = (s + s_hat) / 2
                x = self.step_fn(x, v, dt, s=s, w=w)
            else:
                x = self.last_step_fn(x, v, dt, s=s, w=w)

            x_trajs.append(x)
            v_trajs.append(v)

        v_trajs.append(torch.zeros_like(x))
        return x_trajs, v_trajs