source_code/gliomasam3_moe/train.py

import argparse
import os
import sys
import warnings
from types import SimpleNamespace
from typing import Any, Dict, List, Sequence

import yaml
import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torch.cuda.amp import autocast, GradScaler
from tqdm import tqdm

sys.path.append(os.path.join(os.path.dirname(__file__), "src"))

from gliomasam3_moe.models.gliomasam3_moe import GliomaSAM3_MoE
from gliomasam3_moe.losses.brats_losses import LossComputer
from gliomasam3_moe.data.brats_dataset import BraTSDataset, SyntheticBraTSDataset, SegMambaNPZDataset, split_npz_paths
from gliomasam3_moe.data.transforms_segmamba_like import (
    get_train_transforms,
    get_synthetic_transforms,
    get_npz_train_transforms,
)
from gliomasam3_moe.utils.brats_regions import label_to_regions
from gliomasam3_moe.utils.postprocess import remove_small_components
from gliomasam3_moe.utils.seed import set_seed


def _to_namespace(obj: Any):
    if isinstance(obj, dict):
        return SimpleNamespace(**{k: _to_namespace(v) for k, v in obj.items()})
    return obj


def _to_dict(obj: Any):
    if isinstance(obj, SimpleNamespace):
        return {k: _to_dict(v) for k, v in obj.__dict__.items()}
    return obj


def load_config(path: str) -> SimpleNamespace:
    with open(path, "r") as f:
        cfg = yaml.safe_load(f)
    return _to_namespace(cfg)


def str2bool(v: str) -> bool:
    return str(v).lower() in {"1", "true", "yes", "y"}


def fourier_amplitude_mix(x: torch.Tensor, p: float = 0.0) -> torch.Tensor:
    """Fourier amplitude mixing (keep phase, mix amplitude within batch)."""
    if p <= 0 or x.shape[0] < 2:
        return x
    b = x.shape[0]
    device = x.device
    mask = torch.rand(b, device=device) < p
    if mask.sum() == 0:
        return x
    perm = torch.randperm(b, device=device)
    x_fft = torch.fft.fftn(x, dim=(2, 3, 4))
    x_fft_perm = x_fft[perm]
    amp = torch.abs(x_fft)
    amp_perm = torch.abs(x_fft_perm)
    phase = torch.angle(x_fft)
    lam = torch.rand(b, device=device).view(b, 1, 1, 1, 1)
    amp_mix = amp * (1.0 - lam) + amp_perm * lam
    x_fft_mix = amp_mix * torch.exp(1j * phase)
    x_mix = torch.fft.ifftn(x_fft_mix, dim=(2, 3, 4)).real
    x_out = x.clone()
    x_out[mask] = x_mix[mask]
    return x_out


def compute_dice(pred: torch.Tensor, gt: torch.Tensor, eps: float = 1e-5) -> torch.Tensor:
    """Compute Dice per-channel for [WT,TC,ET]."""
    dims = (0, 2, 3, 4)
    inter = (pred * gt).sum(dims)
    union = pred.sum(dims) + gt.sum(dims)
    dice = (2.0 * inter + eps) / (union + eps)
    return dice


def _gaussian_weight(roi_size: Sequence[int], device: torch.device) -> torch.Tensor:
    sigmas = [s * 0.125 for s in roi_size]
    grids = []
    for size, sigma in zip(roi_size, sigmas):
        center = (size - 1) / 2.0
        x = torch.arange(size, device=device, dtype=torch.float32)
        grids.append(torch.exp(-0.5 * ((x - center) / max(sigma, 1e-6)) ** 2))
    w = grids[0][:, None, None] * grids[1][None, :, None] * grids[2][None, None, :]
    w = w / w.max()
    return w


def sliding_window_inference_3d(
    inputs: torch.Tensor,
    roi_size: Sequence[int],
    overlap: float,
    predictor,
) -> torch.Tensor:
    """Simple 3D sliding window inference with gaussian weighting.

    Returns blended probabilities (after sigmoid). If the predictor returns
    (logits, aux) and aux contains "pi_et", ET probabilities are gated.
    """
    b, c, d, h, w = inputs.shape
    if b != 1:
        raise ValueError("sliding_window_inference_3d expects batch size 1.")
    rz, ry, rx = [int(x) for x in roi_size]
    pad_d = max(0, rz - d)
    pad_h = max(0, ry - h)
    pad_w = max(0, rx - w)
    if pad_d > 0 or pad_h > 0 or pad_w > 0:
        pd0, pd1 = pad_d // 2, pad_d - pad_d // 2
        ph0, ph1 = pad_h // 2, pad_h - pad_h // 2
        pw0, pw1 = pad_w // 2, pad_w - pad_w // 2
        inputs = F.pad(inputs, (pw0, pw1, ph0, ph1, pd0, pd1))
        d, h, w = inputs.shape[-3:]
    sz = max(1, int(rz * (1.0 - overlap)))
    sy = max(1, int(ry * (1.0 - overlap)))
    sx = max(1, int(rx * (1.0 - overlap)))

    def _starts(dim, roi, step):
        if dim <= roi:
            return [0]
        starts = list(range(0, dim - roi + 1, step))
        if starts[-1] != dim - roi:
            starts.append(dim - roi)
        return starts

    zs = _starts(d, rz, sz)
    ys = _starts(h, ry, sy)
    xs = _starts(w, rx, sx)

    weight = _gaussian_weight((rz, ry, rx), inputs.device)[None, None]
    out = torch.zeros((1, 3, d, h, w), device=inputs.device, dtype=torch.float32)
    count = torch.zeros((1, 1, d, h, w), device=inputs.device, dtype=torch.float32)

    for z in zs:
        for y in ys:
            for x in xs:
                patch = inputs[:, :, z : z + rz, y : y + ry, x : x + rx]
                pred = predictor(patch)
                aux = None
                if isinstance(pred, (tuple, list)):
                    logits = pred[0]
                    if len(pred) > 1:
                        aux = pred[1]
                else:
                    logits = pred
                probs = torch.sigmoid(logits)
                if isinstance(aux, dict) and "pi_et" in aux:
                    pi_et = aux["pi_et"].view(probs.shape[0], 1, 1, 1, 1)
                    probs[:, 2:3] = probs[:, 2:3] * pi_et
                out[:, :, z : z + rz, y : y + ry, x : x + rx] += probs * weight
                count[:, :, z : z + rz, y : y + ry, x : x + rx] += weight

    out = out / count.clamp(min=1e-6)
    if pad_d > 0 or pad_h > 0 or pad_w > 0:
        out = out[:, :, pd0 : pd0 + (d - pad_d), ph0 : ph0 + (h - pad_h), pw0 : pw0 + (w - pad_w)]
    return out


def _compute_hd95(pred: torch.Tensor, gt: torch.Tensor, spacing: Sequence[float]) -> List[float]:
    try:
        from medpy import metric
    except Exception:
        return [float("nan")] * 3

    pred_np = pred.detach().cpu().numpy()
    gt_np = gt.detach().cpu().numpy()
    out = []
    for c in range(3):
        p = pred_np[c] > 0
        g = gt_np[c] > 0
        if p.sum() > 0 and g.sum() > 0:
            out.append(metric.binary.hd95(p, g, voxelspacing=spacing))
        else:
            out.append(50.0)
    return out


@torch.no_grad()
def evaluate_test(
    model: torch.nn.Module,
    loader: DataLoader,
    cfg,
    device: torch.device,
) -> Dict[str, List[float]]:
    model.eval()
    roi = getattr(cfg.infer, "roi_size", cfg.data.crop_size)
    overlap = float(getattr(cfg.infer, "overlap", 0.5))
    threshold = float(getattr(cfg.infer, "threshold", 0.5))
    et_min = int(getattr(cfg.infer, "et_cc_min_size", 0))
    spacing = getattr(cfg.data, "spacing", [1.0, 1.0, 1.0])

    dice_all: List[List[float]] = []
    hd95_all: List[List[float]] = []

    max_cases = int(getattr(cfg.train, "test_max_cases", 0))
    for idx, batch in enumerate(loader):
        if max_cases and idx >= max_cases:
            break
        image = batch["image"].to(device)
        label = batch["label"].to(device)

        probs = sliding_window_inference_3d(
            inputs=image,
            roi_size=roi,
            overlap=overlap,
            predictor=lambda x: model(x),
        )
        pred = (probs > threshold).float()
        if et_min > 0:
            pred[:, 2] = remove_small_components(pred[:, 2], et_min)

        gt = label_to_regions(label)
        dice = compute_dice(pred, gt).detach().cpu().tolist()
        hd95 = _compute_hd95(pred[0], gt[0], spacing)
        dice_all.append(dice)
        hd95_all.append(hd95)

    mean_dice = torch.tensor(dice_all).mean(dim=0).tolist()
    mean_hd95 = torch.tensor(hd95_all).mean(dim=0).tolist()
    return {"dice": mean_dice, "hd95": mean_hd95}


def save_checkpoint(path: str, model: torch.nn.Module, optimizer: torch.optim.Optimizer, cfg: SimpleNamespace, step: int):
    os.makedirs(os.path.dirname(path), exist_ok=True)
    torch.save(
        {
            "model": model.state_dict(),
            "optimizer": optimizer.state_dict(),
            "config": _to_dict(cfg),
            "step": step,
        },
        path,
    )


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", type=str, default="configs/debug.yaml")
    parser.add_argument("--synthetic", type=str, default=None, help="Override synthetic flag.")
    args = parser.parse_args()

    cfg = load_config(args.config)
    if args.synthetic is not None:
        cfg.synthetic = str2bool(args.synthetic)

    # Clean up noisy warnings in training logs.
    warnings.filterwarnings("ignore", category=FutureWarning, message=".*GradScaler.*")
    warnings.filterwarnings("ignore", category=FutureWarning, message=".*autocast.*")
    warnings.filterwarnings("ignore", category=UserWarning, message="The given NumPy array is not writable.*")

    set_seed(cfg.seed)
    device = torch.device(cfg.device if torch.cuda.is_available() else "cpu")

    if cfg.synthetic:
        transforms = get_synthetic_transforms(cfg)
        dataset = SyntheticBraTSDataset(
            num_cases=cfg.data.synthetic_cases,
            shape=cfg.data.synthetic_shape,
            transforms=transforms,
            seed=cfg.seed,
        )
    else:
        data_format = getattr(cfg.data, "format", "nifti")
        if data_format == "segmamba_npz":
            train_rate = getattr(cfg.data, "train_rate", 0.7)
            val_rate = getattr(cfg.data, "val_rate", 0.1)
            test_rate = getattr(cfg.data, "test_rate", 0.2)
            train_paths, _, _ = split_npz_paths(
                cfg.data.root_dir, train_rate=train_rate, val_rate=val_rate, test_rate=test_rate, seed=cfg.seed
            )
            ensure_npy = bool(getattr(cfg.data, "segmamba_unpack", True))
            transforms = get_npz_train_transforms(cfg)
            dataset = SegMambaNPZDataset(
                data_dir=cfg.data.root_dir,
                npz_paths=train_paths,
                test=False,
                ensure_npy=ensure_npy,
                map_et_to_4=True,
                transforms=transforms,
            )
    loader = DataLoader(
        dataset,
        batch_size=cfg.data.batch_size,
        shuffle=True,
        num_workers=cfg.train.num_workers,
    )

    test_loader = None
    if not cfg.synthetic and getattr(cfg.train, "test_every_epochs", 0):
        data_format = getattr(cfg.data, "format", "nifti")
        if data_format == "segmamba_npz":
            train_rate = getattr(cfg.data, "train_rate", 0.7)
            val_rate = getattr(cfg.data, "val_rate", 0.1)
            test_rate = getattr(cfg.data, "test_rate", 0.2)
            _, _, test_paths = split_npz_paths(
                cfg.data.root_dir, train_rate=train_rate, val_rate=val_rate, test_rate=test_rate, seed=cfg.seed
            )
            ensure_npy = bool(getattr(cfg.data, "segmamba_unpack", True))
            test_ds = SegMambaNPZDataset(
                data_dir=cfg.data.root_dir,
                npz_paths=test_paths,
                test=False,
                ensure_npy=ensure_npy,
                map_et_to_4=True,
            )
            test_loader = DataLoader(
                test_ds,
                batch_size=1,
                shuffle=False,
                num_workers=max(0, int(cfg.train.num_workers)),
            )
        else:
            print("[WARN] test_every_epochs is set but only segmamba_npz is supported; skipping test.")

    model = GliomaSAM3_MoE(**cfg.model.__dict__).to(device)
    loss_fn = LossComputer(**cfg.loss.__dict__).to(device)
    optimizer = torch.optim.AdamW(model.parameters(), lr=cfg.train.lr, weight_decay=cfg.train.weight_decay)
    scaler = GradScaler(enabled=bool(cfg.amp and device.type == "cuda"))

    model.train()
    step = 0
    for epoch in range(cfg.train.epochs):
        pbar = tqdm(
            loader,
            desc=f"Epoch {epoch + 1}/{cfg.train.epochs}",
            leave=False,
            dynamic_ncols=True,
        )
        for batch in pbar:
            step += 1
            image = batch["image"].to(device)
            label = batch["label"].to(device)
            image = fourier_amplitude_mix(image, p=cfg.train.fourier_mix_prob)

            optimizer.zero_grad(set_to_none=True)
            with autocast(enabled=bool(cfg.amp and device.type == "cuda")):
                logits, aux = model(image, label=label if cfg.train.use_label_prompt else None)
                loss, logs = loss_fn(logits, aux, label)
            scaler.scale(loss).backward()
            scaler.step(optimizer)
            scaler.update()

            if step % cfg.train.log_every == 0:
                with torch.no_grad():
                    gt = label_to_regions(label)
                    pred = (torch.sigmoid(logits) > 0.5).float()
                    dice = compute_dice(pred, gt).detach().cpu().numpy().tolist()
                pbar.set_postfix(
                    {
                        "step": step,
                        "loss": f"{logs['loss_total']:.4f}",
                        "dice": [f"{d:.3f}" for d in dice],
                    }
                )

            if step % cfg.train.save_every == 0:
                ckpt_path = os.path.join(cfg.train.ckpt_dir, f"ckpt_step{step}.pt")
                save_checkpoint(ckpt_path, model, optimizer, cfg, step)

            if step >= cfg.train.max_steps:
                break
        test_every = int(getattr(cfg.train, "test_every_epochs", 0))
        if test_loader is not None and test_every > 0 and (epoch + 1) % test_every == 0:
            metrics = evaluate_test(model, test_loader, cfg, device)
            print(
                f"[TEST] epoch={epoch + 1} dice[WT,TC,ET]={metrics['dice']} "
                f"hd95[WT,TC,ET]={metrics['hd95']}"
            )
            model.train()

        if step >= cfg.train.max_steps:
            break


if __name__ == "__main__":
    main()