| import argparse |
| import glob |
| import os |
| import re |
| import sys |
| from typing import List, Sequence, Tuple |
|
|
| import torch |
| from torch.utils.data import DataLoader |
|
|
| sys.path.append(os.path.join(os.path.dirname(__file__), "src")) |
|
|
| from gliomasam3_moe.data.brats_dataset import SegMambaNPZDataset, split_npz_paths |
| from gliomasam3_moe.models.gliomasam3_moe import GliomaSAM3_MoE |
| from train import evaluate_test, load_config |
|
|
|
|
| def _find_latest_ckpt(ckpt_dir: str) -> str: |
| pattern = os.path.join(ckpt_dir, "ckpt_step*.pt") |
| matches = [] |
| for path in glob.glob(pattern): |
| m = re.search(r"ckpt_step(\d+)\.pt$", path) |
| if m: |
| matches.append((int(m.group(1)), path)) |
| if not matches: |
| raise FileNotFoundError(f"No checkpoints found under {ckpt_dir}.") |
| matches.sort(key=lambda x: x[0]) |
| return matches[-1][1] |
|
|
|
|
| def _select_train_subset( |
| data_dir: str, |
| train_rate: float, |
| val_rate: float, |
| test_rate: float, |
| seed: int, |
| ) -> Tuple[Sequence[str], int, int]: |
| train_paths, _, test_paths = split_npz_paths( |
| data_dir, train_rate=train_rate, val_rate=val_rate, test_rate=test_rate, seed=seed |
| ) |
| test_n = len(test_paths) |
| if test_n == 0: |
| raise ValueError("Test split size is 0; cannot match train subset size.") |
| subset_n = min(len(train_paths), test_n) |
| rng = torch.Generator().manual_seed(seed) |
| perm = torch.randperm(len(train_paths), generator=rng).tolist() |
| subset_paths = [train_paths[i] for i in perm[:subset_n]] |
| return subset_paths, test_n, len(train_paths) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--config", type=str, default="configs/train.yaml") |
| parser.add_argument("--checkpoint", type=str, default=None, help="Path to ckpt_step*.pt (default: latest in ckpt_dir).") |
| parser.add_argument("--max_cases", type=int, default=0, help="Optional cap on subset size.") |
| args = parser.parse_args() |
|
|
| cfg = load_config(args.config) |
| data_dir = cfg.data.root_dir |
| if not os.path.isdir(data_dir): |
| raise FileNotFoundError(f"data.root_dir does not exist: {data_dir}") |
|
|
| if getattr(cfg.data, "format", "nifti") != "segmamba_npz": |
| raise ValueError("Only segmamba_npz format is supported for this evaluation script.") |
|
|
| ckpt_path = args.checkpoint or _find_latest_ckpt(cfg.train.ckpt_dir) |
| if not os.path.isfile(ckpt_path): |
| raise FileNotFoundError(f"Checkpoint not found: {ckpt_path}") |
|
|
| subset_paths, test_n, train_n = _select_train_subset( |
| data_dir, |
| 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), |
| seed=cfg.seed, |
| ) |
| if args.max_cases and args.max_cases > 0: |
| subset_paths = subset_paths[: min(len(subset_paths), args.max_cases)] |
|
|
| device = torch.device(cfg.device if torch.cuda.is_available() else "cpu") |
| model = GliomaSAM3_MoE(**cfg.model.__dict__).to(device) |
| ckpt = torch.load(ckpt_path, map_location=device) |
| model.load_state_dict(ckpt["model"], strict=True) |
|
|
| ensure_npy = bool(getattr(cfg.data, "segmamba_unpack", True)) |
| dataset = SegMambaNPZDataset( |
| data_dir=data_dir, |
| npz_paths=subset_paths, |
| test=False, |
| ensure_npy=ensure_npy, |
| map_et_to_4=True, |
| ) |
| loader = DataLoader( |
| dataset, |
| batch_size=1, |
| shuffle=False, |
| num_workers=max(0, int(cfg.train.num_workers)), |
| ) |
|
|
| metrics = evaluate_test(model, loader, cfg, device) |
| print(f"[TRAIN-SUBSET] ckpt={ckpt_path}") |
| print(f"[TRAIN-SUBSET] total_train={train_n} test_count={test_n} subset={len(subset_paths)}") |
| print( |
| f"[TRAIN-SUBSET] dice[WT,TC,ET]={metrics['dice']} " |
| f"hd95[WT,TC,ET]={metrics['hd95']}" |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
