diff --git a/datamint/lightning/__init__.py b/datamint/lightning/__init__.py index af35ec4e..1f3548bd 100644 --- a/datamint/lightning/__init__.py +++ b/datamint/lightning/__init__.py @@ -12,6 +12,7 @@ UNetPPTrainer, DeepLabV3PlusTrainer, TransUNetTrainer, + NNUNetTrainer, UNETRPPTrainer, ) @@ -27,5 +28,6 @@ "UNetPPTrainer", "DeepLabV3PlusTrainer", "TransUNetTrainer", + "NNUNetTrainer", "UNETRPPTrainer", ] diff --git a/datamint/lightning/datamodule.py b/datamint/lightning/datamodule.py index 029397ab..b354b63d 100644 --- a/datamint/lightning/datamodule.py +++ b/datamint/lightning/datamodule.py @@ -271,7 +271,7 @@ def get_mlflow_dataset_split(self, split: str) -> 'DatamintMLflowDataset | None' if getattr(mlds.source, "_split", "") != split: _LOGGER.warning( f"Requested MLflow dataset for split '{split}', but the dataset's " - f"split is '{getattr(mlds.source, "_split", "")}'. This may cause confusion in MLflow." + f"split is '{getattr(mlds.source, '_split', '')}'. This may cause confusion in MLflow." ) return mlds diff --git a/datamint/lightning/trainers/__init__.py b/datamint/lightning/trainers/__init__.py index ec55809d..b86fdc48 100644 --- a/datamint/lightning/trainers/__init__.py +++ b/datamint/lightning/trainers/__init__.py @@ -5,11 +5,8 @@ from .seg2d_trainer import SemanticSegmentation2DTrainer from .seg3d_trainer import SemanticSegmentation3DTrainer from .classification_trainer import ClassificationTrainer, ImageClassificationTrainer -from .specialized.unetpp import UNetPPTrainer -from .specialized.deeplabv3plus import DeepLabV3PlusTrainer -from .specialized.transunet import TransUNetTrainer +from .specialized import UNetPPTrainer, DeepLabV3PlusTrainer, TransUNetTrainer, UNETRPPTrainer, NNUNetTrainer from .vol_seg_trainer import VolumeSegmentationTrainer -from .specialized.unetrpp import UNETRPPTrainer __all__ = [ "BaseTrainer", @@ -23,4 +20,5 @@ "UNETRPPTrainer", "ClassificationTrainer", "ImageClassificationTrainer", + "NNUNetTrainer", ] diff --git a/datamint/lightning/trainers/specialized/__init__.py b/datamint/lightning/trainers/specialized/__init__.py index 27f2a970..f3dc0a50 100644 --- a/datamint/lightning/trainers/specialized/__init__.py +++ b/datamint/lightning/trainers/specialized/__init__.py @@ -1,2 +1,13 @@ from .unetpp import UNetPPTrainer -from .transunet import TransUNetTrainer \ No newline at end of file +from .deeplabv3plus import DeepLabV3PlusTrainer +from .transunet import TransUNetTrainer +from .unetrpp import UNETRPPTrainer +from .nnunet.trainer import NNUNetTrainer + +__all__ = [ + "UNetPPTrainer", + "DeepLabV3PlusTrainer", + "TransUNetTrainer", + "UNETRPPTrainer", + "NNUNetTrainer", +] \ No newline at end of file diff --git a/datamint/lightning/trainers/specialized/nnunet/__init__.py b/datamint/lightning/trainers/specialized/nnunet/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/datamint/lightning/trainers/specialized/nnunet/_nnunet_trainer_bridge.py b/datamint/lightning/trainers/specialized/nnunet/_nnunet_trainer_bridge.py new file mode 100644 index 00000000..de10d408 --- /dev/null +++ b/datamint/lightning/trainers/specialized/nnunet/_nnunet_trainer_bridge.py @@ -0,0 +1,153 @@ +from __future__ import annotations + +import json +import logging +import mlflow +from pathlib import Path + +import importlib.metadata as _importlib_metadata + +_LOGGER = logging.getLogger(__name__) + +# ── version guard ────────────────────────────────────────────────────────────── +def _parse_version(v: str) -> tuple[int, ...]: + try: + return tuple(int(x) for x in v.split('.')[:3]) + except ValueError: + return (0,) + + +try: + _nnunetv2_version = _importlib_metadata.version('nnunetv2') +except _importlib_metadata.PackageNotFoundError: + _nnunetv2_version = '0.0.0' + +_ver = _parse_version(_nnunetv2_version) +if not ((2, 4, 0) <= _ver < (3, 0, 0)): + raise ImportError( + f"nnunetv2>=2.4,<3.0 is required for Datamint integration. " + f"Currently installed: {_nnunetv2_version}. " + f'Run: pip install "nnunetv2>=2.4,<3.0"' + ) +# ────────────────────────────────────────────────────────────────────────────── + +from nnunetv2.training.nnUNetTrainer.nnUNetTrainer import nnUNetTrainer + + +# Keys logged by nnUNet that are not useful as MLflow metrics. +_SKIP_METRIC_KEYS = frozenset({'epoch_start_timestamps', 'epoch_end_timestamps'}) + + +class _MLflowLogger: + """MLflow sink compatible with nnUNet's MetaLogger external logger interface. + + Appended to ``self.logger.loggers`` so that every metric nnUNet emits via + ``self.logger.log()`` is forwarded to the active MLflow run. + """ + + def update_config(self, config: dict) -> None: + safe = {k: v for k, v in config.items() if isinstance(v, (int, float, str, bool))} + if safe: + try: + mlflow.log_params(safe) + except Exception: + pass + + def log(self, key: str, value, step: int) -> None: + if key in _SKIP_METRIC_KEYS: + return + try: + mlflow.log_metric(key, float(value), step=step) + except (TypeError, ValueError): + pass + + def log_summary(self, key: str, value) -> None: + try: + mlflow.log_metric(key, float(value)) + except (TypeError, ValueError): + pass + + +class _DatamintNNUNetTrainer(nnUNetTrainer): + """nnUNetTrainer subclass that mirrors per-epoch metrics into MLflow. + + This is an internal implementation detail — use :class:`NNUNetTrainer` + (the public Datamint trainer in ``trainer.py``) instead of instantiating + this class directly. + + Metrics flow via ``self.logger.loggers`` (MetaLogger's external logger + list) rather than by overriding ``self.log()`` — nnUNet calls + ``self.logger.log()``, not ``self.log()``. + + Additional overrides: ``save_checkpoint`` (record best path + upload + artifact) and ``perform_actual_validation`` (log per-class Dice from + ``summary.json``). + """ + + def __init__( + self, + plans: dict, + configuration: str, + fold: int | str, + dataset_json: dict, + device=None, + ) -> None: + import torch + if device is None: + device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + super().__init__(plans, configuration, fold, dataset_json, device) + self._best_checkpoint_path: Path | None = None + # Register the MLflow sink so all nnUNet metrics flow to MLflow. + self.logger.loggers.append(_MLflowLogger()) + + # ── helpers that wrap super() calls so tests can patch them ─────────────── + + def _super_save_checkpoint(self, filename: str, **kwargs) -> None: + super().save_checkpoint(filename, **kwargs) + + # ── overrides ───────────────────────────────────────────────────────────── + + def save_checkpoint(self, filename: str, **kwargs) -> None: + """Save checkpoint via nnUNet, record path, and upload to MLflow artifacts.""" + self._super_save_checkpoint(filename, **kwargs) + self._best_checkpoint_path = Path(filename) + mlflow.log_artifact(str(filename), artifact_path='nnunet_checkpoints') + + def _log_validation_summary(self) -> None: + """Read nnUNet's summary.json and push per-class Dice scores to MLflow. + + Called at the end of each validation epoch by :meth:`perform_actual_validation`. + Reads ``{output_folder}/validation/summary.json``. In nnUNet v2, + ``self.output_folder`` already includes ``fold_{fold}/``, so no extra + nesting is needed. + """ + summary_path = Path(self.output_folder) / 'validation' / 'summary.json' + try: + summary = json.loads(summary_path.read_text()) + except FileNotFoundError: + _LOGGER.warning( + "summary.json not found at '%s' — skipping per-class Dice logging.", + summary_path, + ) + return + + for class_name, metrics in summary.get('mean', {}).items(): + dice = metrics.get('Dice') + if dice is not None: + mlflow.log_metric( + f'val/dice_{class_name}', float(dice), step=self.current_epoch + ) + + foreground_mean = summary.get('foreground_mean') + if foreground_mean is not None: + mlflow.log_metric('val/dice_mean', float(foreground_mean), step=self.current_epoch) + + def perform_actual_validation(self, save_probabilities: bool = False) -> None: + """Run nnUNet validation, then log per-class Dice to MLflow.""" + super().perform_actual_validation(save_probabilities) + self._log_validation_summary() + + def print_to_log_file(self, *args, **kwargs) -> None: + """Write to nnUNet's log file and also forward to Python logging.""" + super().print_to_log_file(*args, **kwargs) + _LOGGER.info(' '.join(str(a) for a in args)) diff --git a/datamint/lightning/trainers/specialized/nnunet/data_export.py b/datamint/lightning/trainers/specialized/nnunet/data_export.py new file mode 100644 index 00000000..89497fdf --- /dev/null +++ b/datamint/lightning/trainers/specialized/nnunet/data_export.py @@ -0,0 +1,307 @@ +from __future__ import annotations + +import json +import logging +import warnings +from pathlib import Path +import nibabel as nib +import numpy as np + +_LOGGER = logging.getLogger(__name__) + +NNUNET_SUFFIX = '_0000.nii.gz' + + +class DatamintToNNUNetExporter: + """Exports a Datamint project's resources and annotations to nnUNet Task format. + + Directory layout produced under ``work_dir``: + :: + + Dataset{id:03d}_{name}/ + imagesTr/case_001_0000.nii.gz + labelsTr/case_001.nii.gz + imagesTs/case_003_0000.nii.gz (if test split present) + dataset.json + datamint_case_map.json + + Args: + work_dir: Root directory (becomes ``nnUNet_raw`` in practice). + dataset_id: 3-digit nnUNet dataset ID (e.g. 1 → ``001``). + dataset_name: Human-readable name appended to the dataset dir (e.g. ``CTLiver``). + """ + + def __init__(self, work_dir: Path | str, dataset_id: int, dataset_name: str) -> None: + self.work_dir = Path(work_dir) + self.dataset_id = dataset_id + self.dataset_name = dataset_name + self.dataset_dir = self.work_dir / f'Dataset{dataset_id:03d}_{dataset_name}' + + def _export_image(self, resource, case_id: str, split: str) -> Path: + """Write one resource's NIfTI file to the nnUNet images directory. + + Reads the cached NIfTI directly via ``fetch_file_data`` — bypasses any + albumentations transforms so voxel spacing and affine are preserved. + + Args: + resource: Datamint resource (NIfTI or DICOM). + case_id: nnUNet case identifier, e.g. ``'case_001'``. + split: ``'train'`` writes to ``imagesTr/``; anything else to ``imagesTs/``. + + Returns: + Path to the written ``.nii.gz`` file. + """ + nifti_data = resource.fetch_file_data(use_cache=True, auto_convert=True) + # fetch_file_data builds the Nifti1Image from a BytesIO / gzip stream and + # calls get_fdata() to populate nibabel's internal cache before closing the + # stream. Reading via dataobj (ArrayProxy) would try to re-open the now-closed + # stream — use get_fdata() to hit the cache instead. + arr = nifti_data.get_fdata() + + out_dir = self.dataset_dir / ('imagesTr' if split == 'train' else 'imagesTs') + out_dir.mkdir(parents=True, exist_ok=True) + + out_path = out_dir / f'{case_id}{NNUNET_SUFFIX}' + nib.save(nib.Nifti1Image(arr, nifti_data.affine, nifti_data.header), str(out_path)) + _LOGGER.debug("Exported image %s → %s", resource.id, out_path) + return out_path + + def _merge_segmentations( + self, + segs, + name_to_idx: 'dict[str, int] | None' = None, + ) -> np.ndarray: + """Merge N segmentation masks into one int32 label map. + + Datamint returns annotations as per-class binary masks (0/1) where the + class name is stored in ``ann.identifier``. When ``name_to_idx`` is + provided, each binary mask is scaled by its class index so the merged + output contains the correct integer labels (e.g., aorta=1, liver=6). + + If an annotation already contains class-valued data (values > 1), it is + used as-is so multi-class NIfTIs uploaded directly are also handled. + + When two masks assign different non-zero labels to the same voxel, the + higher class index wins. A ``UserWarning`` is raised whenever any + overlap is found so the caller can inspect whether it is intentional. + + Args: + segs: Sequence of annotation objects. + name_to_idx: Mapping ``{class_name: class_index}`` used to scale + binary masks to their correct integer class value. When + ``None`` the raw data is used unchanged. + + Returns: + Merged ``np.ndarray`` of shape ``(H, W, D)`` and dtype ``int32``. + """ + arrays = [] + for seg in segs: + data = seg.fetch_file_data(auto_convert=True, use_cache=True) + if isinstance(data, np.ndarray): + arr = data.astype(np.int32) + else: + arr = data.get_fdata().astype(np.int32) + + # Binary mask (values in {0, 1}): scale by the class index so the + # merged output encodes the correct integer label value. + if name_to_idx is not None and set(np.unique(arr)).issubset({0, 1}): + identifier = getattr(seg, 'identifier', None) + if identifier and identifier in name_to_idx: + arr = arr * name_to_idx[identifier] + + arrays.append(arr) + + shape = arrays[0].shape + merged = np.zeros(shape, dtype=np.int32) + overlap_detected = False + + for seg_data in arrays: + if not overlap_detected and np.any((merged > 0) & (seg_data > 0)): + overlap_detected = True + merged = np.maximum(merged, seg_data) + + if overlap_detected: + warnings.warn( + "Overlapping segmentations detected during merge. " + "Highest class index wins at overlapping voxels.", + UserWarning, + stacklevel=2, + ) + + return merged + + def _export_label( + self, + resource, + case_id: str, + class_map: dict, + annotations=None, + ) -> Path: + """Write the merged segmentation label map for one resource. + + Merges all segmentation annotations into a single int32 label map via + :meth:`_merge_segmentations` and saves it under ``labelsTr/``. The + affine is taken from the resource's cached NIfTI so image and label + share the same geometry. + + Args: + resource: Datamint resource whose annotations to export. + case_id: nnUNet case identifier, e.g. ``'case_001'``. + class_map: Mapping of ``{int: class_name}`` used to scale binary + masks to their correct integer label values. + annotations: Pre-fetched annotation list. When ``None`` the + annotations are fetched from the server. + + Returns: + Path to the written ``labelsTr/{case_id}.nii.gz`` file. + """ + if annotations is None: + annotations = resource.fetch_annotations(annotation_type='segmentation') + + if not annotations: + raise ValueError( + f"Resource '{resource.id}' has no segmentation annotations. " + "All training resources must have at least one segmentation annotation " + "for nnUNet export." + ) + + ref_nifti = resource.fetch_file_data(use_cache=True, auto_convert=True) + # affine is stored in the header, not via ArrayProxy — safe to read directly. + affine = ref_nifti.affine + + name_to_idx = {name: idx for idx, name in class_map.items()} + merged = self._merge_segmentations(annotations, name_to_idx) + + out_dir = self.dataset_dir / 'labelsTr' + out_dir.mkdir(parents=True, exist_ok=True) + out_path = out_dir / f'{case_id}.nii.gz' + nib.save(nib.Nifti1Image(merged, affine), str(out_path)) + _LOGGER.debug("Exported label %s → %s", resource.id, out_path) + return out_path + + def _write_dataset_json( + self, + labels: dict[str, int], + channel_names: dict[str, str], + num_training: int, + ) -> Path: + """Write nnUNet's ``dataset.json`` for this dataset. + + Args: + labels: Class name → integer label mapping, e.g. + ``{'background': 0, 'liver': 1}``. Note the direction: + name-keyed, int-valued — the inverse of Datamint's ``class_map``. + channel_names: Modality index (as string) → modality name, e.g. + ``{'0': 'CT'}``. + num_training: Number of training cases. + + Returns: + Path to the written ``dataset.json`` file. + """ + self.dataset_dir.mkdir(parents=True, exist_ok=True) + content = { + 'labels': labels, + 'channel_names': channel_names, + 'numTraining': num_training, + 'file_ending': '.nii.gz', + } + out_path = self.dataset_dir / 'dataset.json' + out_path.write_text(json.dumps(content, indent=2)) + _LOGGER.debug("Wrote dataset.json → %s", out_path) + return out_path + + def _write_case_map(self, mapping: dict[str, str]) -> Path: + """Write the sidecar JSON that maps nnUNet case IDs back to Datamint resource UUIDs. + + nnUNet uses sequential integer case names (``case_001``, ``case_002``, …) + that have no connection to Datamint's UUID-based resource IDs. This file + is read by the result importer to route each prediction back to the correct + resource. + + Args: + mapping: ``{case_id: resource_uuid}`` e.g. + ``{'case_001': 'res-uuid-001', 'case_002': 'res-uuid-002'}``. + + Returns: + Path to the written ``datamint_case_map.json`` file. + """ + self.dataset_dir.mkdir(parents=True, exist_ok=True) + out_path = self.dataset_dir / 'datamint_case_map.json' + out_path.write_text(json.dumps(mapping, indent=2)) + _LOGGER.debug("Wrote case map (%d entries) → %s", len(mapping), out_path) + return out_path + + def export(self, split: dict, channel_names: dict[str, str]) -> Path: + """Export a full Datamint project split to nnUNet Task format. + + Assigns sequential case IDs (``case_001``, ``case_002``, …) across all + splits in order: train first, then test. Train resources get both image + and label files; test resources get only images (nnUNet never expects + ``labelsTs/``). + + Args: + split: ``{'train': [resources…], 'test': [resources…]}``. + The ``'test'`` key is optional. + channel_names: Modality index → name, e.g. ``{'0': 'CT'}``. + Passed verbatim to ``dataset.json``. + + Returns: + Path to the dataset directory (``Dataset{id:03d}_{name}/``). + """ + train_resources = split.get('train', []) + test_resources = split.get('test', []) + + case_map: dict[str, str] = {} + global_class_map: dict[int, str] = {} + case_counter = 1 + + # Pass 1 — fetch annotations once per training resource, build the + # global class map, and cache to avoid a second API call in _export_label. + train_annotations: dict[str, list] = {} + for resource in train_resources: + annotations = resource.fetch_annotations(annotation_type='segmentation') + train_annotations[resource.id] = annotations + for ann in annotations: + # Prefer explicit class_map (int→name) if present. + class_map_attr = getattr(ann, 'class_map', None) + if class_map_attr: + global_class_map.update(class_map_attr) + else: + # Fallback: Datamint returns per-class binary masks where + # the class name lives in ann.identifier. Assign the next + # available integer index (1-based, background=0 is reserved). + identifier = getattr(ann, 'identifier', None) + if identifier and identifier not in global_class_map.values(): + next_idx = max(global_class_map.keys(), default=0) + 1 + global_class_map[next_idx] = identifier + + # Pass 2 — export images and labels using the complete class map. + for resource in train_resources: + case_id = f'case_{case_counter:03d}' + case_counter += 1 + case_map[case_id] = resource.id + + self._export_image(resource, case_id, 'train') + self._export_label( + resource, case_id, global_class_map, + annotations=train_annotations[resource.id], + ) + + for resource in test_resources: + case_id = f'case_{case_counter:03d}' + case_counter += 1 + case_map[case_id] = resource.id + self._export_image(resource, case_id, 'test') + + # nnUNet dataset.json expects name→int (inverse of Datamint's int→name). + labels: dict[str, int] = {'background': 0} + labels.update({name: idx for idx, name in global_class_map.items()}) + + self._write_dataset_json(labels, channel_names, num_training=len(train_resources)) + self._write_case_map(case_map) + + _LOGGER.info( + "Export complete: %d train, %d test → %s", + len(train_resources), len(test_resources), self.dataset_dir, + ) + return self.dataset_dir diff --git a/datamint/lightning/trainers/specialized/nnunet/data_import.py b/datamint/lightning/trainers/specialized/nnunet/data_import.py new file mode 100644 index 00000000..662ccf26 --- /dev/null +++ b/datamint/lightning/trainers/specialized/nnunet/data_import.py @@ -0,0 +1,129 @@ +from __future__ import annotations + +import json +import logging +from pathlib import Path +import nibabel as nib +import numpy as np + +_LOGGER = logging.getLogger(__name__) + + +class NNUNetToDatamintImporter: + """Imports nnUNet prediction NIfTI files back into Datamint as annotations. + + After ``nnUNetTrainer.run_training()`` completes, nnUNet writes one + ``case_NNN.nii.gz`` per input volume into a predictions directory. This + class matches those files back to their original Datamint resource UUIDs + (via the sidecar case map written during export) and uploads them as + :class:`VolumeSegmentation` annotations. + + Args: + api: Datamint API client instance. + dataset_dir: nnUNet dataset directory that contains + ``datamint_case_map.json`` (e.g. ``Dataset001_CTLiver/``). + """ + + def __init__(self, api, dataset_dir: Path | str) -> None: + self._api = api + self.dataset_dir = Path(dataset_dir) + + def _nifti_to_segmentation( + self, + nifti_path: Path, + class_map: dict[int, str], + model_id: str | None = None, + ): + """Load a prediction NIfTI and build a :class:`VolumeSegmentation`. + + Args: + nifti_path: Path to the nnUNet prediction ``.nii.gz`` file. + class_map: ``{label_int: class_name}`` — e.g. ``{1: 'liver'}``. + model_id: Optional MLflow model ID to tag the annotation with. + + Returns: + A :class:`VolumeSegmentation` instance ready for upload. + """ + from datamint.entities.annotations.volume_segmentation import VolumeSegmentation + + nifti = nib.load(str(nifti_path)) + kwargs = {} + if model_id is not None: + kwargs['ai_model_name'] = model_id + return VolumeSegmentation.from_semantic_segmentation(nifti, class_map, **kwargs) + + def _load_case_map(self) -> dict[str, str]: + """Read ``datamint_case_map.json`` and return ``{case_id: resource_uuid}``. + + Returns: + Dict mapping nnUNet case IDs (e.g. ``'case_001'``) to Datamint + resource UUIDs (e.g. ``'res-uuid-001'``). + """ + path = self.dataset_dir / 'datamint_case_map.json' + if not path.exists(): + raise FileNotFoundError( + f"Case map not found at '{path}'. " + "This file is written during export — re-run the export step or check " + "that 'dataset_dir' points to the correct nnUNet dataset directory." + ) + return json.loads(path.read_text()) + + def import_predictions( + self, + pred_dir: Path | str, + class_map: dict[int, str], + mlflow_model_id: str | None = None, + ) -> list: + """Upload nnUNet prediction NIfTI files to Datamint as volume annotations. + + For each ``*.nii.gz`` in ``pred_dir``: + + 1. Strip ``.nii.gz`` to get the case ID (e.g. ``case_001``). + 2. Look the case ID up in the case map to get the Datamint resource UUID. + 3. Build a :class:`VolumeSegmentation` from the NIfTI. + 4. Upload it via :py:meth:`api.annotations.upload_volume_segmentation`. + + Args: + pred_dir: Directory containing nnUNet prediction ``.nii.gz`` files. + class_map: ``{label_int: class_name}`` applied to every prediction. + mlflow_model_id: Optional MLflow model ID tagged on each annotation. + + Returns: + List of :class:`VolumeSegmentation` instances that were uploaded. + + Raises: + KeyError: If a prediction filename has no matching entry in the + case map. The error message includes the filename and the + available keys so the caller can diagnose the mismatch. + """ + pred_dir = Path(pred_dir) + case_map = self._load_case_map() + uploaded = [] + + for pred_path in sorted(pred_dir.glob('*.nii.gz')): + # Strip both .gz and .nii suffixes to get the bare case ID. + case_id = pred_path.name.replace('.nii.gz', '') + + if case_id not in case_map: + raise KeyError( + f"Prediction file '{pred_path.name}' (case_id='{case_id}') has no " + f"matching entry in the case map. " + f"Available case IDs: {sorted(case_map.keys())}" + ) + + resource_uuid = case_map[case_id] + seg = self._nifti_to_segmentation(pred_path, class_map, model_id=mlflow_model_id) + + self._api.annotations.upload_volume_segmentation( + resource=resource_uuid, + file_path=pred_path, + name=class_map, + ai_model_name=mlflow_model_id, + ) + _LOGGER.info( + "Imported prediction %s → resource %s", pred_path.name, resource_uuid + ) + uploaded.append(seg) + + _LOGGER.info("Import complete: %d predictions uploaded.", len(uploaded)) + return uploaded diff --git a/datamint/lightning/trainers/specialized/nnunet/inference_model.py b/datamint/lightning/trainers/specialized/nnunet/inference_model.py new file mode 100644 index 00000000..926c7be3 --- /dev/null +++ b/datamint/lightning/trainers/specialized/nnunet/inference_model.py @@ -0,0 +1,156 @@ +from __future__ import annotations + +import logging +import tempfile +from pathlib import Path + +import nibabel as nib + +from datamint.mlflow.flavors.model import BaseDatamintModel +from datamint.mlflow.flavors.task_type import TaskType + +_LOGGER = logging.getLogger(__name__) + + +class NNUNetInferenceModel(BaseDatamintModel): + """MLflow deploy adapter that runs nnUNet inference on Datamint resources. + + Registered as an MLflow ``pyfunc`` model. At serve time, ``load_context`` + initialises ``nnUNetPredictor`` from the bundle artifact; ``predict_volume`` + writes each resource to a temp NIfTI directory, calls + ``predict_from_files``, and converts the output NIfTIs back to + :class:`~datamint.entities.annotations.VolumeSegmentation` instances. + + The bundle must contain:: + + nnunet_bundle/ + nnUNetPlans.json + dataset_fingerprint.json + fold_0/ + checkpoint_best.pth + + All three are required by + ``nnUNetPredictor.initialize_from_trained_model_folder``. + """ + + task_type = TaskType.VOLUME_SEGMENTATION + + def __init__( + self, + class_map: dict[int, str], + configuration: str = '3d_fullres', + folds: tuple[int, ...] = (0,), + checkpoint_name: str = 'checkpoint_final.pth', + settings=None, + ) -> None: + super().__init__(settings=settings) + self.class_map = class_map + self.configuration = configuration + self.folds = folds + self.checkpoint_name = checkpoint_name + self._predictor = None + + def load_context(self, context) -> None: + """Initialise ``nnUNetPredictor`` from the MLflow bundle artifact. + + Called by MLflow at serve time before any ``predict`` call. Reads + ``context.artifacts['nnunet_bundle']`` for the bundle directory path + and calls ``initialize_from_trained_model_folder`` with the stored + ``folds`` and ``checkpoint_name``. + + NOTE: ``nnUNetPredictor`` is looked up through the module object (not + via ``from ... import``) so that + ``patch('nnunetv2.inference.predict_from_raw_data.nnUNetPredictor')`` + works correctly in tests. + """ + super().load_context(context) + import nnunetv2.inference.predict_from_raw_data as _pred_mod + + bundle_path = context.artifacts['nnunet_bundle'] + predictor = _pred_mod.nnUNetPredictor() + predictor.initialize_from_trained_model_folder( + model_training_output_dir=bundle_path, + use_folds=self.folds, + checkpoint_name=self.checkpoint_name, + ) + self._predictor = predictor + + def _write_resource_as_nifti(self, resource, out_dir: Path, case_index: int = 1) -> Path: + """Write one resource as a single-channel nnUNet input NIfTI. + + nnUNet expects files named ``case_{i:03d}_0000.nii.gz`` where the + ``_0000`` suffix is the channel index (always 0 for single-modality). + + Args: + resource: Datamint resource to write. + out_dir: Directory to write the NIfTI into. + case_index: 1-based sequential case number. + + Returns: + Path to the written file. + """ + nifti = resource.fetch_file_data(use_cache=True, auto_convert=True) + out_path = Path(out_dir) / f'case_{case_index:03d}_0000.nii.gz' + nib.save(nifti, str(out_path)) + return out_path + + def _nifti_to_annotation(self, pred_path: Path): + """Load a prediction NIfTI and build a :class:`VolumeSegmentation`. + + Args: + pred_path: Path to a ``.nii.gz`` prediction file written by + ``nnUNetPredictor.predict_from_files``. + + Returns: + A :class:`VolumeSegmentation` instance with ``class_map`` set to + ``self.class_map``. + """ + from datamint.entities.annotations.volume_segmentation import VolumeSegmentation + + nifti = nib.load(str(pred_path)) + return VolumeSegmentation.from_semantic_segmentation(nifti, self.class_map) + + def predict_volume(self, model_input, **kwargs): + """Run nnUNet inference on a list of Datamint resources. + + Writes each resource as a NIfTI to a temporary input directory, calls + ``nnUNetPredictor.predict_from_files``, then converts each output NIfTI + to a :class:`VolumeSegmentation`. The temp directory is always cleaned + up, even if prediction raises an exception. + + Args: + model_input: List of Datamint resource objects. + + Returns: + ``list[list[VolumeSegmentation]]`` — one inner list per resource, + containing the annotations produced for that resource. + """ + if self._predictor is None: + raise RuntimeError( + "Predictor is not initialised. " + "load_context() must be called before predict_volume()." + ) + + results = [] + with tempfile.TemporaryDirectory() as tmp: + in_dir = Path(tmp) / 'input' + out_dir = Path(tmp) / 'output' + in_dir.mkdir() + out_dir.mkdir() + + for i, resource in enumerate(model_input, start=1): + self._write_resource_as_nifti(resource, in_dir, case_index=i) + + self._predictor.predict_from_files( + str(in_dir), str(out_dir), save_probabilities=False + ) + + for pred_path in sorted(out_dir.glob('*.nii.gz')): + ann = self._nifti_to_annotation(pred_path) + results.append([ann]) + + return results + + def predict_default(self, model_input, **kwargs): + """Alias for :meth:`predict_volume`.""" + return self.predict_volume(model_input, **kwargs) diff --git a/datamint/lightning/trainers/specialized/nnunet/trainer.py b/datamint/lightning/trainers/specialized/nnunet/trainer.py new file mode 100644 index 00000000..c7843f7e --- /dev/null +++ b/datamint/lightning/trainers/specialized/nnunet/trainer.py @@ -0,0 +1,545 @@ +from __future__ import annotations + +import logging +import os +from pathlib import Path +from typing import Any, TYPE_CHECKING + +import filelock +import mlflow +import yaml +from rich import print as rprint + +from datamint.lightning.trainers.base_trainer import BaseTrainer +from datamint.dataset.volume_dataset import VolumeDataset +from datamint.lightning.trainers.specialized.nnunet.data_export import DatamintToNNUNetExporter + +if TYPE_CHECKING: + from datamint.entities import Project + +_LOGGER = logging.getLogger(__name__) + +# Registry file that maps project names → nnUNet dataset IDs. +REGISTRY_PATH = Path.home() / '.config' / 'datamintapi' / 'nnunet_dataset_ids.yaml' + + +class NNUNetTrainer(BaseTrainer): + """Datamint trainer that runs nnUNet v2 as the training backend. + + Exports the project data to nnUNet Task format, runs fingerprinting, + planning, preprocessing, and training via :class:`_DatamintNNUNetTrainer`, + then imports predictions back as Datamint annotations. + + Args: + project: Datamint project name or object. + configuration: nnUNet configuration — ``'2d'``, ``'3d_fullres'`` + (default), ``'3d_lowres'``, or ``'3d_cascade_fullres'``. + fold: Cross-validation fold index (0–4) or ``'all'``. + dataset_id: Fixed nnUNet dataset ID (1–999). When ``None`` the ID + is auto-assigned from the registry. + nnunet_work_dir: Root directory for all nnUNet I/O + (``nnUNet_raw``, ``nnUNet_preprocessed``, ``nnUNet_results`` + are created beneath it). Defaults to + ``~/.cache/datamint/nnunet/``. + continue_training: Resume from an existing checkpoint. + channel_names: Modality index → name mapping passed to + ``dataset.json``, e.g. ``{'0': 'CT'}``. + num_processes_preprocessing: Workers for nnUNet's preprocessing + step. ``None`` lets nnUNet choose. + max_epochs: Training epochs forwarded to nnUNetTrainer. + """ + + def __init__( + self, + dataset=None, + project: 'str | Project | None' = None, + *, + configuration: str = '3d_fullres', + fold: int | str = 0, + dataset_id: int | None = None, + nnunet_work_dir: Path | str | None = None, + continue_training: bool = False, + channel_names: dict[str, str] | None = None, + num_processes_preprocessing: int | None = None, + max_epochs: int = 1000, + **kwargs: Any, + ) -> None: + super().__init__( + dataset=dataset, + project=project, + max_epochs=max_epochs, + **kwargs, + ) + self.configuration = configuration + self.fold = fold + self._fixed_dataset_id = dataset_id + self.nnunet_work_dir = ( + Path(nnunet_work_dir) + if nnunet_work_dir is not None + else Path.home() / '.cache' / 'datamint' / 'nnunet' + ) + self.continue_training = continue_training + self.channel_names = channel_names or {'0': 'CT'} + self.num_processes_preprocessing = num_processes_preprocessing + + # ── BaseTrainer abstract methods bypassed by nnUNet ─────────────────────── + + def _build_dataset(self, project: 'str | Project', **kwargs) -> VolumeDataset: + return VolumeDataset(project=project, **kwargs) + + def _build_model(self, *args, **kwargs): + raise NotImplementedError( + "NNUNetTrainer bypasses the Lightning model pipeline — " + "_build_model is not used; nnUNet builds its own model internally." + ) + + def _train_transform(self): + raise NotImplementedError( + "NNUNetTrainer bypasses Lightning transforms — " + "nnUNet handles all augmentation internally." + ) + + def _eval_transform(self): + raise NotImplementedError( + "NNUNetTrainer bypasses Lightning transforms — " + "nnUNet handles all preprocessing internally." + ) + + def _loss(self): + raise NotImplementedError( + "NNUNetTrainer bypasses the Lightning loss — " + "nnUNet uses its own compound loss internally." + ) + + def _metrics(self): + raise NotImplementedError( + "NNUNetTrainer bypasses Lightning metrics — " + "nnUNet computes Dice internally and logs it via _DatamintNNUNetTrainer." + ) + + def _monitor_metric(self): + raise NotImplementedError( + "NNUNetTrainer bypasses Lightning checkpointing — " + "nnUNet manages its own checkpoint logic." + ) + + # ── nnUNet pipeline helpers ─────────────────────────────────────────────── + + def _assign_dataset_id(self) -> int: + """Return the nnUNet dataset ID for this project, assigning one if needed. + + IDs are stored in a YAML registry at :data:`REGISTRY_PATH` so that + concurrent training runs on different projects never share an ID. + A :class:`filelock.FileLock` guards the read-modify-write cycle. + + If ``dataset_id`` was passed to ``__init__``, that value is returned + directly without touching the registry. + + Returns: + Integer dataset ID in the range 1–999. + """ + if self._fixed_dataset_id is not None: + return self._fixed_dataset_id + + project_name = self._project_name + lock_path = str(REGISTRY_PATH) + '.lock' + + with filelock.FileLock(lock_path): + if REGISTRY_PATH.exists(): + registry: dict[str, int] = yaml.safe_load(REGISTRY_PATH.read_text()) or {} + else: + registry = {} + + if project_name in registry: + return registry[project_name] + + next_id = max(registry.values(), default=0) + 1 + registry[project_name] = next_id + + REGISTRY_PATH.parent.mkdir(parents=True, exist_ok=True) + REGISTRY_PATH.write_text(yaml.dump(registry)) + + return next_id + + def _set_nnunet_env(self) -> None: + """Set the three nnUNet environment variables required by all nnUNet internals. + + nnUNet reads ``nnUNet_raw``, ``nnUNet_preprocessed``, and + ``nnUNet_results`` from ``os.environ`` — there is no constructor + argument alternative. Directories are created if they do not exist. + """ + raw = self.nnunet_work_dir / 'raw' + preprocessed = self.nnunet_work_dir / 'preprocessed' + results = self.nnunet_work_dir / 'results' + + for d in (raw, preprocessed, results): + d.mkdir(parents=True, exist_ok=True) + + os.environ['nnUNet_raw'] = str(raw) + os.environ['nnUNet_preprocessed'] = str(preprocessed) + os.environ['nnUNet_results'] = str(results) + # Allow nnUNet's trainer class loader to find _DatamintNNUNetTrainer + # during inference (initialize_from_trained_model_folder reads the + # trainer class name from the checkpoint and looks it up by name). + os.environ['nnUNet_extTrainer'] = str(Path(__file__).parent) + _LOGGER.debug( + "nnUNet env set: raw=%s preprocessed=%s results=%s extTrainer=%s", + raw, preprocessed, results, Path(__file__).parent, + ) + + @property + def _dataset_name(self) -> str: + """Project name sanitised for use as an nnUNet dataset name (alphanumeric only).""" + return self._project_name.replace('_', '').replace(' ', '') + + def _run_fingerprint_and_plan(self, dataset_id: int) -> None: + """Run nnUNet fingerprinting and experiment planning. + + Calls ``DatasetFingerprintExtractor.run()`` then + ``ExperimentPlanner.plan_experiment()``, and raises ``RuntimeError`` + if either expected output file is missing afterwards. + + Args: + dataset_id: nnUNet integer dataset ID. + """ + preprocessed_dataset_dir = ( + self.nnunet_work_dir / 'preprocessed' + / f'Dataset{dataset_id:03d}_{self._dataset_name}' + ) + fp_file = preprocessed_dataset_dir / 'dataset_fingerprint.json' + plans_file = preprocessed_dataset_dir / 'nnUNetPlans.json' + + if fp_file.exists() and plans_file.exists(): + rprint(f"[green]✓[/green] Fingerprinting and planning already done for dataset — skipping.") + return + + from nnunetv2.experiment_planning.dataset_fingerprint.fingerprint_extractor import ( + DatasetFingerprintExtractor, + ) + from nnunetv2.experiment_planning.experiment_planners.default_experiment_planner import ExperimentPlanner + + rprint(f"[bold]→[/bold] Running dataset fingerprinting for dataset…") + DatasetFingerprintExtractor(dataset_id, num_processes=8).run() + + rprint(f"[bold]→[/bold] Running experiment planning for dataset…") + ExperimentPlanner(dataset_id, gpu_memory_target_in_gb=8.0).plan_experiment() + + if not fp_file.exists(): + raise RuntimeError( + f"dataset_fingerprint.json was not written to {fp_file}. " + "DatasetFingerprintExtractor may have failed silently." + ) + if not plans_file.exists(): + raise RuntimeError( + f"nnUNetPlans.json was not written to {plans_file}. " + "ExperimentPlanner may have failed silently." + ) + rprint("[green]✓[/green] Fingerprinting and planning complete.") + + def _run_preprocessing(self, dataset_id: int) -> None: + """Run nnUNet preprocessing for the configured configuration. + + Args: + dataset_id: nnUNet integer dataset ID. + """ + preprocessed_dataset_dir = ( + self.nnunet_work_dir / 'preprocessed' + / f'Dataset{dataset_id:03d}_{self._dataset_name}' + ) + + # nnUNet stores preprocessed cases in a subdirectory named by 'data_identifier' + # from nnUNetPlans.json (e.g. 'nnUNetPlans_2d'), not the bare configuration name. + plans_file = preprocessed_dataset_dir / 'nnUNetPlans.json' + config_dir = preprocessed_dataset_dir / self.configuration # fallback + if plans_file.exists(): + import json as _json_pre + _plans = _json_pre.loads(plans_file.read_text()) + data_id = ( + _plans.get('configurations', {}) + .get(self.configuration, {}) + .get('data_identifier') + ) + if data_id: + config_dir = preprocessed_dataset_dir / data_id + + if config_dir.exists() and any(config_dir.iterdir()): + rprint(f"[green]✓[/green] Preprocessing already done for dataset configuration '{self.configuration}' — skipping.") + return + + from nnunetv2.experiment_planning.plan_and_preprocess_api import preprocess + + rprint(f"[bold]→[/bold] Running preprocessing for dataset configuration '{self.configuration}'…") + num_proc = self.num_processes_preprocessing or 4 + preprocess( + [dataset_id], + plans_identifier='nnUNetPlans', + configurations=(self.configuration,), + num_processes=(num_proc,), + ) + + def _build_nnunet_trainer(self, dataset_id: int): + """Instantiate the nnUNet–MLflow bridge trainer. + + Reads ``nnUNetPlans.json`` and ``dataset.json`` from disk (written by + the planning and export steps) and constructs + :class:`_DatamintNNUNetTrainer` with those configs plus the active + MLflow run ID. + + Args: + dataset_id: nnUNet integer dataset ID. + run_id: Active MLflow run ID injected into the bridge for metric + logging. + + Returns: + A configured :class:`_DatamintNNUNetTrainer` instance ready to + call ``run_training()``. + """ + import json as _json + from datamint.lightning.trainers.specialized.nnunet._nnunet_trainer_bridge import ( + _DatamintNNUNetTrainer, + ) + + dataset_dir_name = f'Dataset{dataset_id:03d}_{self._dataset_name}' + + plans = _json.loads( + (self.nnunet_work_dir / 'preprocessed' / dataset_dir_name / 'nnUNetPlans.json') + .read_text() + ) + dataset_json = _json.loads( + (self.nnunet_work_dir / 'raw' / dataset_dir_name / 'dataset.json') + .read_text() + ) + + # nnUNet v2.8 pops 'continue_training' from the plans dict in __init__ + # to initialise its MetaLogger (append vs. new log file). + plans = {**plans, 'continue_training': self.continue_training} + + return _DatamintNNUNetTrainer( + plans=plans, + configuration=self.configuration, + fold=self.fold, + dataset_json=dataset_json, + ) + + def _run_prediction(self, dataset_id: int, bridge) -> Path | None: + """Run nnUNet inference on the test split and write predictions to disk. + + Uses ``nnUNetPredictor.predict_from_files`` on the ``imagesTs/`` + directory written during export. When ``fold='all'`` was used for + training, all five fold checkpoints are ensembled automatically. + + Args: + dataset_id: nnUNet integer dataset ID. + bridge: Trained :class:`_DatamintNNUNetTrainer` instance. + + Returns: + Path to the predictions directory, or ``None`` if there are no + test images (i.e. no test split was exported). + """ + import nnunetv2.inference.predict_from_raw_data as _pred_mod + + dataset_dir_name = f'Dataset{dataset_id:03d}_{self._dataset_name}' + imagesTs_dir = self.nnunet_work_dir / 'raw' / dataset_dir_name / 'imagesTs' + + if not imagesTs_dir.exists() or not any(imagesTs_dir.glob('*.nii.gz')): + return None + + use_folds = ('all',) if self.fold == 'all' else (self.fold,) + rprint(f"[bold]→[/bold] Running nnUNet prediction on test split (folds={use_folds})…") + + predictor = _pred_mod.nnUNetPredictor() + predictor.initialize_from_trained_model_folder( + model_training_output_dir=bridge.output_folder_base, + use_folds=use_folds, + checkpoint_name='checkpoint_best.pth', + ) + + pred_dir = Path(bridge.output_folder_base) / 'predictions_test' + pred_dir.mkdir(exist_ok=True) + predictor.predict_from_files(str(imagesTs_dir), str(pred_dir), save_probabilities=False) + rprint(f"[green]✓[/green] Predictions written to {pred_dir}") + return pred_dir + + def _import_predictions(self, dataset_id: int, pred_dir: 'Path | None') -> None: + """Upload nnUNet test predictions to Datamint as volume annotations. + + Reads the per-class label map from ``dataset.json`` and delegates + uploading to :class:`NNUNetToDatamintImporter`. + + Args: + dataset_id: nnUNet integer dataset ID. + pred_dir: Directory containing ``*.nii.gz`` prediction files + written by :meth:`_run_prediction`. When ``None`` (no test + split), this method is a no-op. + """ + if pred_dir is None: + return + + import json as _json + from datamint.lightning.trainers.specialized.nnunet.data_import import ( + NNUNetToDatamintImporter, + ) + + dataset_dir_name = f'Dataset{dataset_id:03d}_{self._dataset_name}' + dataset_dir = self.nnunet_work_dir / 'raw' / dataset_dir_name + + # Invert dataset.json labels (name→int) to class_map (int→name), + # dropping background (label 0) since it is never uploaded as an annotation. + dataset_json_path = dataset_dir / 'dataset.json' + labels: dict[str, int] = _json.loads(dataset_json_path.read_text()).get('labels', {}) + class_map: dict[int, str] = {v: k for k, v in labels.items() if v != 0} + + api = self.dataset._api + NNUNetToDatamintImporter(api, dataset_dir).import_predictions( + pred_dir, class_map=class_map + ) + + # ── Public entry point ──────────────────────────────────────────────────── + + def fit(self) -> dict: + """Run the full nnUNet training pipeline. + + Steps in order: + + 1. Assign a stable nnUNet dataset ID for this project. + 2. Set the three ``nnUNet_*`` environment variables. + 3. Export all project resources to nnUNet Task format on disk. + 4. Run dataset fingerprinting and experiment planning. + 5. Run preprocessing for the configured nnUNet configuration. + 6. Start an MLflow run. + 7. Instantiate ``_DatamintNNUNetTrainer`` and call ``run_training()``. + 8. Run inference on the test split (``_run_prediction``). + 9. Import predictions as Datamint annotations (``_import_predictions``). + + Returns: + ``{'bridge': bridge}`` — the trained bridge instance. + """ + dataset_id = self._assign_dataset_id() + self._set_nnunet_env() + + # Resolve train / test splits from the project's server-side assignments. + # nnUNet manages its own internal cross-validation within the train split, + # so Datamint's 'val' split is not used for that purpose — it is treated + # as a prediction target when no 'test' split exists. + splits = self.dataset.split(use_project_splits=True) + train_ds = splits.get('train') + test_ds = splits.get('test') + + train_resources = list(train_ds.resources) if train_ds is not None else list(self.dataset.resources) + test_resources = list(test_ds.resources) if test_ds is not None else [] + + if not test_resources: + _LOGGER.warning( + "No 'test' split found. All data will be used for training. " + "Predictions will not be run and test results will not be available." + ) + + split_dict: dict = {'train': train_resources} + if test_resources: + split_dict['test'] = test_resources + + exporter = DatamintToNNUNetExporter( + self.nnunet_work_dir / 'raw', + dataset_id=dataset_id, + dataset_name=self._dataset_name, + ) + exporter.export(split_dict, self.channel_names) + + self._run_fingerprint_and_plan(dataset_id) + self._run_preprocessing(dataset_id) + + model_name = self.register_model_name or self._project_name + + with self._start_mlflow_run() as run: + run_id = run.info.run_id + bridge = self._build_nnunet_trainer(dataset_id) + bridge.num_epochs = self.max_epochs + if self.continue_training: + from nnunetv2.run.run_training import maybe_load_checkpoint + maybe_load_checkpoint(bridge, continue_training=True, validation_only=False) + rprint("[bold]→[/bold] Resuming training from existing checkpoint.") + rprint(f"[bold]→[/bold] Starting nnUNet training (epochs={self.max_epochs}, fold={self.fold}, configuration='{self.configuration}')…") + bridge.run_training() + pred_dir = self._run_prediction(dataset_id, bridge) + self._import_predictions(dataset_id, pred_dir) + self._build_deploy_adapter(dataset_id, bridge) + mlflow.register_model(f"runs:/{run_id}/nnunet_model", model_name) + rprint(f"[green]✓[/green] Model registered as '[bold]{model_name}[/bold]' in MLflow registry.") + + return {'bridge': bridge, 'model_name': model_name} + + def _build_deploy_adapter(self, dataset_id: int, bridge) -> None: + """Assemble the nnUNet inference bundle and log it to MLflow as a pyfunc model. + + Copies ``nnUNetPlans.json``, ``dataset_fingerprint.json``, and + ``checkpoint_best.pth`` into a temporary bundle directory with the + layout expected by + ``nnUNetPredictor.initialize_from_trained_model_folder``, then logs the + bundle via ``mlflow.pyfunc.log_model``. + + Must be called inside an active MLflow run. + + Args: + dataset_id: nnUNet integer dataset ID. + bridge: Trained :class:`_DatamintNNUNetTrainer` instance — provides + ``_best_checkpoint_path`` and ``_fold``. + """ + import json as _json + import shutil + import datamint.mlflow.flavors.datamint_flavor as _datamint_flavor + from datamint.lightning.trainers.specialized.nnunet.inference_model import ( + NNUNetInferenceModel, + ) + + dataset_dir_name = f'Dataset{dataset_id:03d}_{self._dataset_name}' + preprocessed_dir = self.nnunet_work_dir / 'preprocessed' / dataset_dir_name + + import tempfile + with tempfile.TemporaryDirectory() as tmp: + bundle = Path(tmp) / 'nnunet_bundle' + bundle.mkdir() + + shutil.copy(preprocessed_dir / 'nnUNetPlans.json', bundle / 'nnUNetPlans.json') + shutil.copy( + preprocessed_dir / 'dataset_fingerprint.json', + bundle / 'dataset_fingerprint.json', + ) + + fold_dir = bundle / f'fold_{bridge.fold}' + fold_dir.mkdir() + + # nnUNet uses the final checkpoint for inference (not the best-by-validation). + final_ckpt = Path(bridge.output_folder) / 'checkpoint_final.pth' + if not final_ckpt.exists(): + raise RuntimeError( + f"checkpoint_final.pth not found at '{final_ckpt}'. " + "Training may not have completed successfully." + ) + import torch as _torch + # Patch trainer_name to the standard nnUNetTrainer so the deploy + # container doesn't need our custom _DatamintNNUNetTrainer class. + # _DatamintNNUNetTrainer only adds MLflow logging hooks — it uses + # the identical network architecture as the parent nnUNetTrainer. + ckpt = _torch.load(str(final_ckpt), map_location='cpu', weights_only=False) + ckpt['trainer_name'] = 'nnUNetTrainer' + _torch.save(ckpt, fold_dir / 'checkpoint_final.pth') + + labels: dict[str, int] = _json.loads( + (self.nnunet_work_dir / 'raw' / dataset_dir_name / 'dataset.json').read_text() + ).get('labels', {}) + class_map: dict[int, str] = {v: k for k, v in labels.items() if v != 0} + + folds = ('all',) if self.fold == 'all' else (bridge.fold,) + adapter = NNUNetInferenceModel( + class_map=class_map, + configuration=self.configuration, + folds=folds, + ) + import importlib.metadata as _imeta + _nnunet_ver = _imeta.version('nnunetv2') + _datamint_flavor.log_model( + datamint_model=adapter, + name='nnunet_model', + artifacts={'nnunet_bundle': str(bundle)}, + extra_pip_requirements=[f'nnunetv2=={_nnunet_ver}'], + ) diff --git a/notebooks/use_cases/nnunet_synapse_tutorial.ipynb b/notebooks/use_cases/nnunet_synapse_tutorial.ipynb new file mode 100644 index 00000000..f95c778e --- /dev/null +++ b/notebooks/use_cases/nnunet_synapse_tutorial.ipynb @@ -0,0 +1,1106 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a1b2c3d4", + "metadata": {}, + "source": [ + "# 3D Segmentation with nnU-Net and the Datamint Trainer API\n", + "\n", + "This notebook trains a volumetric segmentation model on the **Synapse Multi-Organ CT** dataset using Datamint's `NNUNetTrainer`.\n", + "\n", + "## What is nnU-Net?\n", + "\n", + "> Isensee, F., Jaeger, P. F., Kohl, S. A. A., Petersen, J., & Maier-Hein, K. H. (2021).\n", + "> nnU-Net: A self-configuring method for deep learning-based biomedical image segmentation.\n", + "> *Nature Methods*, 18(2), 203–211.\n", + "\n", + "nnU-Net is a **self-configuring** segmentation framework — you don't design a network architecture or tune hyperparameters. Instead, nnU-Net analyses your dataset and automatically decides:\n", + "\n", + "- **Architecture** — 2D U-Net, 3D U-Net full-resolution, or 3D cascade (two-stage for very large volumes)\n", + "- **Patch size and batch size** — derived from GPU memory target and the median image spacing\n", + "- **Preprocessing** — target spacing, intensity normalisation strategy (CT clipping, MRI z-score, etc.)\n", + "- **Data augmentation** — rotation, scaling, elastic deformations, mirroring, based on dataset characteristics\n", + "\n", + "This self-configuration happens in two offline phases (**fingerprinting** and **planning**) before any training starts, and the result is saved to `nnUNetPlans.json`. See Section 4 for a full breakdown of each pipeline step.\n", + "\n", + "## What You'll Learn\n", + "\n", + "1. Download and convert the Synapse Multi-Organ CT dataset to NIfTI\n", + "2. Upload 3D volumes and segmentation masks to a Datamint project\n", + "3. Train a `NNUNetTrainer` — the entire pipeline (export → fingerprint → preprocess → train → predict → import) runs in a single `trainer.fit()` call\n", + "4. Inspect MLflow-tracked metrics and visualise predictions on axial slices\n", + "\n", + "## Required Dependencies\n", + "\n", + "```bash\n", + "pip install datamint nibabel h5py \"nnunetv2>=2.4,<3.0\"\n", + "```\n", + "\n", + "## ⚠️ Dataset Access\n", + "\n", + "The Synapse dataset is hosted on Kaggle: https://www.kaggle.com/datasets/dogcdt/synapse" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b2c3d4e5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install -q datamint gdown nibabel h5py \"nnunetv2>=2.4,<3.0\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c3d4e5f6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/luan/Desktop/Datamint/Codes/datamint-python-api/datamint/env/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "from datamint import Api\n", + "\n", + "PROJECT_NAME = \"NNUNET__TEST_Synapse_Tutorial\"\n", + "api = Api()" + ] + }, + { + "cell_type": "markdown", + "id": "d4e5f6a7", + "metadata": {}, + "source": [ + "## 1. Setup: Create Project" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e5f6a7b8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + "
\n", + "
Entity
\n", + "
\n", + "

Project

\n", + "
\n", + "
\n", + "\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Name\n", + " NNUNET__TEST_Synapse_Tutorial\n", + "
Created At\n", + " 2026-06-08T13:03:02.401Z\n", + "
Created By\n", + " luandalmazo@gmail.com\n", + "
Archived\n", + " False\n", + "
Resource Count\n", + " 12\n", + "
Description\n", + " Testing nnunet on Synapse Multi-Organ CT\n", + "
\n", + "
\n", + "\n", + "
" + ], + "text/plain": [ + "Project(id='d92c9a2d-bb49-47cd-80c6-076279b533e8', name='NNUNET__TEST_Synapse_Tutorial', created_at='2026-06-08T13:03:02.401Z', created_by='luandalmazo@gmail.com', dataset_id='e54a7dd1-ee3e-47eb-8df1-2cd5f05a07e3', archived=False, resource_count=12, description='Testing nnunet on Synapse Multi-Organ CT', most_recent_experiment=None, annotators=[], is_annotation_only=False)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "proj = api.projects.create(\n", + " name=PROJECT_NAME,\n", + " description=\"Testing nnunet on Synapse Multi-Organ CT\",\n", + " exists_ok=True,\n", + ")\n", + "proj" + ] + }, + { + "cell_type": "markdown", + "id": "f6a7b8c9", + "metadata": {}, + "source": [ + "## 2. Dataset Preparation: Download Synapse\n", + "\n", + "**Label map** (8 abdominal organs):\n", + "\n", + "| Value | Organ |\n", + "|---|---|\n", + "| 1 | Aorta |\n", + "| 2 | Gallbladder |\n", + "| 3 | Spleen |\n", + "| 4 | Left Kidney |\n", + "| 5 | Right Kidney |\n", + "| 6 | Liver |\n", + "| 7 | Stomach |\n", + "| 8 | Pancreas |\n", + "\n", + "\n", + "> Download the dataset from Kaggle:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cfa546e1", + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + " 0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0\n", + "100 607M 100 607M 0 0 24.4M 0 0:00:24 0:00:24 --:--:-- 26.2M\n" + ] + } + ], + "source": [ + "!curl -L -o /tmp/synapse.zip https://www.kaggle.com/api/v1/datasets/download/dogcdt/synapse" + ] + }, + { + "cell_type": "markdown", + "id": "6b2bbb2b", + "metadata": {}, + "source": [ + "Unzip the dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5ae1ffef", + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [], + "source": [ + "!unzip /tmp/synapse.zip -d /tmp/" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a7b8c9d0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 12 volume files\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "\n", + "DATA_DIR = Path(\"/tmp/Synapse\")\n", + "H5_DIR = DATA_DIR / \"test_vol_h5\"\n", + "\n", + "h5_files = sorted(H5_DIR.glob(\"*.npy.gz\")) or sorted(H5_DIR.glob(\"*.h5\"))\n", + "print(f\"Found {len(h5_files)} volume files\")" + ] + }, + { + "cell_type": "markdown", + "id": "b8c9d0e1", + "metadata": {}, + "source": [ + "### 2.1 Convert to NIfTI\n", + "\n", + "Datamint accepts NIfTI (`.nii.gz`) for 3D volumes. We load each H5 file, extract the image and label arrays, and save them as NIfTI with `nibabel`.\n", + "\n", + "The HDF5 files contain:\n", + "- `'image'` — float array `(H, W, D)` with HU values clipped to `[-125, 275]` and normalised to `[0, 1]`\n", + "- `'label'` — int array `(H, W, D)` with organ label values 0–8" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c9d0e1f2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Converted 12 volumes, spatial size: (50, 256, 512)\n" + ] + } + ], + "source": [ + "import h5py\n", + "import numpy as np\n", + "import nibabel as nib\n", + "\n", + "NII_DIR = DATA_DIR / 'nifti' / 'images'\n", + "LABEL_DIR = DATA_DIR / 'nifti' / 'labels'\n", + "NII_DIR.mkdir(parents=True, exist_ok=True)\n", + "LABEL_DIR.mkdir(parents=True, exist_ok=True)\n", + "\n", + "nii_image_paths = []\n", + "nii_label_paths = []\n", + "\n", + "for h5_path in h5_files:\n", + " case_id = h5_path.stem.split('.')[0] # 'case0001.h5' -> 'case0001'\n", + "\n", + " with h5py.File(h5_path, 'r') as f:\n", + " image = f['image'][:] # (H, W, D) float\n", + " label = f['label'][:] # (H, W, D) int\n", + "\n", + " # Downsample 512x512 -> 256x256 in-plane (test purposes)\n", + " # Reduces sliding-window patch count by ~4x during validation.\n", + " image = image[::2, ::2, :] # nearest-neighbour for images (float)\n", + " label = label[::2, ::2, :] # nearest-neighbour for labels (int), preserves class ids\n", + "\n", + " img_nii = nib.Nifti1Image(image.astype(np.float32), affine=np.eye(4))\n", + " lbl_nii = nib.Nifti1Image(label.astype(np.uint8), affine=np.eye(4))\n", + "\n", + " img_path = NII_DIR / f'{case_id}.nii.gz'\n", + " lbl_path = LABEL_DIR / f'{case_id}_label.nii.gz'\n", + "\n", + " nib.save(img_nii, img_path)\n", + " nib.save(lbl_nii, lbl_path)\n", + "\n", + " nii_image_paths.append(img_path)\n", + " nii_label_paths.append(lbl_path)\n", + "\n", + "print(f'Converted {len(nii_image_paths)} volumes, spatial size: {image.shape}')\n" + ] + }, + { + "cell_type": "markdown", + "id": "d0e1f2a3", + "metadata": {}, + "source": [ + "## 3. Upload to Datamint\n", + "\n", + "### 3.1 Upload CT Volumes" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e1f2a3b4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Uploading resources: 100%|██████████| 12/12 [00:13<00:00, 1.17s/file, file=case0036.nii.gz]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Uploaded 12 volumes\n" + ] + } + ], + "source": [ + "uploaded = api.resources.upload_resources(\n", + " [str(p) for p in nii_image_paths],\n", + " tags=['synapse', 'ct', 'abdomen'],\n", + " publish_to=proj,\n", + " progress_bar=True,\n", + ")\n", + "print(f\"Uploaded {len(uploaded)} volumes\")" + ] + }, + { + "cell_type": "markdown", + "id": "f2a3b4c5", + "metadata": {}, + "source": [ + "### 3.2 Upload Segmentation Masks\n", + "\n", + "Each label file contains integer values 0–8 (0 = background). `upload_volume_segmentation` maps each integer to its organ name." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a3b4c5d6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 12/12 [01:07<00:00, 5.63s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Segmentation masks uploaded!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from tqdm.auto import tqdm\n", + "\n", + "SYNAPSE_CLASSES = {\n", + " 1: 'aorta',\n", + " 2: 'gallbladder',\n", + " 3: 'spleen',\n", + " 4: 'left_kidney',\n", + " 5: 'right_kidney',\n", + " 6: 'liver',\n", + " 7: 'stomach',\n", + " 8: 'pancreas',\n", + "}\n", + "\n", + "all_resources = list(api.resources.get_list(project_name=PROJECT_NAME))\n", + "# r.filename is 'case0001.nii.gz'; strip the full extension to get 'case0001'\n", + "stem_to_resource = {r.filename.replace('.nii.gz', ''): r for r in all_resources}\n", + "\n", + "for img_path, lbl_path in tqdm(zip(nii_image_paths, nii_label_paths), total=len(nii_image_paths)):\n", + " case_id = img_path.name.replace('.nii.gz', '') # Path.stem gives 'case0001.nii', use .name instead\n", + " resource = stem_to_resource[case_id]\n", + " api.annotations.upload_volume_segmentation(\n", + " resource=resource,\n", + " file_path=str(lbl_path),\n", + " name=SYNAPSE_CLASSES,\n", + " imported_from='Synapse Multi-Organ CT',\n", + " )\n", + "\n", + "print('Segmentation masks uploaded!')\n" + ] + }, + { + "cell_type": "markdown", + "id": "b4c5d6e7", + "metadata": {}, + "source": [ + "### 3.3 Assign Train / Test Splits\n", + "\n", + "nnU-Net manages its own internal cross-validation within the training data, so there is no separate validation split here. We only need to tell Datamint which resources are for **training** and which are for **testing** (held-out evaluation after training)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c5d6e7f8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train: 8 Test: 3\n" + ] + } + ], + "source": [ + "import random\n", + "\n", + "all_resources = list(api.resources.get_list(project_name=PROJECT_NAME))\n", + "all_resources.sort(key=lambda r: r.filename)\n", + "\n", + "random.seed(42)\n", + "random.shuffle(all_resources)\n", + "\n", + "n = len(all_resources)\n", + "n_train = int(0.70 * n)\n", + "n_test = int(0.30 * n)\n", + "\n", + "api.projects.assign_splits(proj, all_resources[:n_train], split_name='train')\n", + "api.projects.assign_splits(proj, all_resources[n_train:n_train + n_test], split_name='test')\n", + "\n", + "print(f\"Train: {n_train} Test: {n_test}\")" + ] + }, + { + "cell_type": "markdown", + "id": "d6e7f8a9", + "metadata": {}, + "source": [ + "## 4. Train with nnU-Net\n", + "\n", + "`NNUNetTrainer.fit()` runs the **full nnU-Net pipeline** in a single call. Here is what happens under the hood:\n", + "\n", + "| Step | Description |\n", + "|------|-------------|\n", + "| **1. Export** | Each Datamint resource is written as a `.nii.gz` file in nnU-Net's directory layout (`imagesTr/`, `labelsTr/`, `imagesTs/`) along with a `dataset.json` containing the label map |\n", + "| **2. Fingerprinting** | Analyses all training volumes: median voxel spacing, intensity histogram, image size distribution. Result: `dataset_fingerprint.json` |\n", + "| **3. Planning** | Uses the fingerprint to select patch size, batch size, network depth, and pooling strides. Result: `nnUNetPlans.json`. This is the \"self-configuring\" step. |\n", + "| **4. Preprocessing** | Resamples all volumes to the planned target spacing, clips/normalises intensities, and writes compressed `.b2nd` (blosc2) files for fast GPU loading during training |\n", + "| **5. Training** | Runs the nnU-Net trainer for `max_epochs` epochs. Dice and loss are logged to MLflow every epoch. |\n", + "| **6. Prediction** | Runs sliding-window inference on the `imagesTs/` test images using `checkpoint_best.pth` |\n", + "| **7. Import** | Uploads predictions back to Datamint as volume segmentation annotations |\n", + "| **8. Register** | Bundles `nnUNetPlans.json` + `dataset_fingerprint.json` + `checkpoint_final.pth` into an MLflow `pyfunc` model for one-click deployment |\n", + "\n", + "> **Skip logic:** fingerprinting, planning, and preprocessing are skipped on re-runs if their output files already exist. \n", + "> **Resume training:** pass `continue_training=True` to load from the last checkpoint.\n", + "\n", + "### Configuration Reference\n", + "\n", + "| Parameter | Values | Notes |\n", + "|-----------|--------|-------|\n", + "| `configuration` | `'2d'`, `'3d_fullres'`\\*, `'3d_lowres'`, `'3d_cascade_fullres'` | `2d` is faster and good for anisotropic data; `3d_fullres` is best for isotropic volumes |\n", + "| `fold` | `0`–`4` or `'all'` | `fold=0` trains on 80% of training data; `'all'` trains and ensembles 5 folds |\n", + "| `max_epochs` | int | nnU-Net's default is 1000; use 2–5 here just to validate the pipeline |" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e7f8a9b0", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ['MLFLOW_ENABLE_ARTIFACTS_PROGRESS_BAR'] = 'false'\n", + "\n", + "from datamint.lightning import NNUNetTrainer\n", + "\n", + "trainer = NNUNetTrainer(\n", + " project=PROJECT_NAME,\n", + " # '2d' is fast and GPU-light. Use '3d_fullres' for best accuracy on isotropic data (needs ~8 GB VRAM).\n", + " configuration='2d',\n", + " # One of the 5 cross-validation folds (0–4). fold=0 trains on the first 80% of cases.\n", + " fold=0,\n", + " # For a real experiment use max_epochs=1000 (nnU-Net's default).\n", + " # Setting 2 here just to verify the pipeline runs end-to-end quickly.\n", + " max_epochs=2,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f8a9b0c1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
→ Running dataset fingerprinting for dataset…\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m→\u001b[0m Running dataset fingerprinting for dataset…\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using as reader/writer\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Extracting dataset fingerprint: 100%|██████████| 8/8 [00:03<00:00, 2.64it/s]\n" + ] + }, + { + "data": { + "text/html": [ + "
→ Running experiment planning for dataset…\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m→\u001b[0m Running experiment planning for dataset…\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dropping 3d_lowres config because the image size difference to 3d_fullres is too small. 3d_fullres: [432. 255. 50.], 3d_lowres: [432, 255, 50]\n", + "2D U-Net configuration:\n", + "{'data_identifier': 'nnUNetPlans_2d', 'preprocessor_name': 'DefaultPreprocessor', 'batch_size': 154, 'patch_size': (np.int64(256), np.int64(56)), 'median_image_size_in_voxels': array([255., 50.]), 'spacing': array([1., 1.]), 'normalization_schemes': ['CTNormalization'], 'use_mask_for_norm': [False], 'resampling_fn_data': 'resample_data_or_seg_to_shape', 'resampling_fn_seg': 'resample_data_or_seg_to_shape', 'resampling_fn_data_kwargs': {'is_seg': False, 'order': 3, 'order_z': 0, 'force_separate_z': None}, 'resampling_fn_seg_kwargs': {'is_seg': True, 'order': 1, 'order_z': 0, 'force_separate_z': None}, 'resampling_fn_probabilities': 'resample_data_or_seg_to_shape', 'resampling_fn_probabilities_kwargs': {'is_seg': False, 'order': 1, 'order_z': 0, 'force_separate_z': None}, 'architecture': {'network_class_name': 'dynamic_network_architectures.architectures.unet.PlainConvUNet', 'arch_kwargs': {'n_stages': 6, 'features_per_stage': (32, 64, 128, 256, 512, 512), 'conv_op': 'torch.nn.modules.conv.Conv2d', 'kernel_sizes': ((3, 3), (3, 3), (3, 3), (3, 3), (3, 3), (3, 3)), 'strides': ((1, 1), (2, 2), (2, 2), (2, 2), (2, 1), (2, 1)), 'n_conv_per_stage': (2, 2, 2, 2, 2, 2), 'n_conv_per_stage_decoder': (2, 2, 2, 2, 2), 'conv_bias': True, 'norm_op': 'torch.nn.modules.instancenorm.InstanceNorm2d', 'norm_op_kwargs': {'eps': 1e-05, 'affine': True}, 'dropout_op': None, 'dropout_op_kwargs': None, 'nonlin': 'torch.nn.LeakyReLU', 'nonlin_kwargs': {'inplace': True}}, '_kw_requires_import': ('conv_op', 'norm_op', 'dropout_op', 'nonlin')}, 'batch_dice': True}\n", + "\n", + "Using as reader/writer\n", + "3D fullres U-Net configuration:\n", + "{'data_identifier': 'nnUNetPlans_3d_fullres', 'preprocessor_name': 'DefaultPreprocessor', 'batch_size': 2, 'patch_size': (np.int64(256), np.int64(224), np.int64(40)), 'median_image_size_in_voxels': array([432., 255., 50.]), 'spacing': array([1., 1., 1.]), 'normalization_schemes': ['CTNormalization'], 'use_mask_for_norm': [False], 'resampling_fn_data': 'resample_data_or_seg_to_shape', 'resampling_fn_seg': 'resample_data_or_seg_to_shape', 'resampling_fn_data_kwargs': {'is_seg': False, 'order': 3, 'order_z': 0, 'force_separate_z': None}, 'resampling_fn_seg_kwargs': {'is_seg': True, 'order': 1, 'order_z': 0, 'force_separate_z': None}, 'resampling_fn_probabilities': 'resample_data_or_seg_to_shape', 'resampling_fn_probabilities_kwargs': {'is_seg': False, 'order': 1, 'order_z': 0, 'force_separate_z': None}, 'architecture': {'network_class_name': 'dynamic_network_architectures.architectures.unet.PlainConvUNet', 'arch_kwargs': {'n_stages': 6, 'features_per_stage': (32, 64, 128, 256, 320, 320), 'conv_op': 'torch.nn.modules.conv.Conv3d', 'kernel_sizes': ((3, 3, 3), (3, 3, 3), (3, 3, 3), (3, 3, 3), (3, 3, 3), (3, 3, 3)), 'strides': ((1, 1, 1), (2, 2, 2), (2, 2, 2), (2, 2, 2), (2, 2, 1), (2, 2, 1)), 'n_conv_per_stage': (2, 2, 2, 2, 2, 2), 'n_conv_per_stage_decoder': (2, 2, 2, 2, 2), 'conv_bias': True, 'norm_op': 'torch.nn.modules.instancenorm.InstanceNorm3d', 'norm_op_kwargs': {'eps': 1e-05, 'affine': True}, 'dropout_op': None, 'dropout_op_kwargs': None, 'nonlin': 'torch.nn.LeakyReLU', 'nonlin_kwargs': {'inplace': True}}, '_kw_requires_import': ('conv_op', 'norm_op', 'dropout_op', 'nonlin')}, 'batch_dice': False}\n", + "\n", + "Plans were saved to /home/luan/.cache/datamint/nnunet/preprocessed/Dataset001_NNUNETTESTSynapseTutorial/nnUNetPlans.json\n" + ] + }, + { + "data": { + "text/html": [ + "
✓ Fingerprinting and planning complete.\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[32m✓\u001b[0m Fingerprinting and planning complete.\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
→ Running preprocessing for dataset configuration '2d'…\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m→\u001b[0m Running preprocessing for dataset configuration \u001b[32m'2d'\u001b[0m…\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Preprocessing dataset Dataset001_NNUNETTESTSynapseTutorial\n", + "Configuration: 2d...\n", + "{'data_identifier': 'nnUNetPlans_2d', 'preprocessor_name': 'DefaultPreprocessor', 'batch_size': 154, 'patch_size': [256, 56], 'median_image_size_in_voxels': [255.0, 50.0], 'spacing': [1.0, 1.0], 'normalization_schemes': ['CTNormalization'], 'use_mask_for_norm': [False], 'resampling_fn_data': 'resample_data_or_seg_to_shape', 'resampling_fn_seg': 'resample_data_or_seg_to_shape', 'resampling_fn_data_kwargs': {'is_seg': False, 'order': 3, 'order_z': 0, 'force_separate_z': None}, 'resampling_fn_seg_kwargs': {'is_seg': True, 'order': 1, 'order_z': 0, 'force_separate_z': None}, 'resampling_fn_probabilities': 'resample_data_or_seg_to_shape', 'resampling_fn_probabilities_kwargs': {'is_seg': False, 'order': 1, 'order_z': 0, 'force_separate_z': None}, 'architecture': {'network_class_name': 'dynamic_network_architectures.architectures.unet.PlainConvUNet', 'arch_kwargs': {'n_stages': 6, 'features_per_stage': [32, 64, 128, 256, 512, 512], 'conv_op': 'torch.nn.modules.conv.Conv2d', 'kernel_sizes': [[3, 3], [3, 3], [3, 3], [3, 3], [3, 3], [3, 3]], 'strides': [[1, 1], [2, 2], [2, 2], [2, 2], [2, 1], [2, 1]], 'n_conv_per_stage': [2, 2, 2, 2, 2, 2], 'n_conv_per_stage_decoder': [2, 2, 2, 2, 2], 'conv_bias': True, 'norm_op': 'torch.nn.modules.instancenorm.InstanceNorm2d', 'norm_op_kwargs': {'eps': 1e-05, 'affine': True}, 'dropout_op': None, 'dropout_op_kwargs': None, 'nonlin': 'torch.nn.LeakyReLU', 'nonlin_kwargs': {'inplace': True}}, '_kw_requires_import': ['conv_op', 'norm_op', 'dropout_op', 'nonlin']}, 'batch_dice': True}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Preprocessing cases: 100%|██████████| 8/8 [00:03<00:00, 2.34it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using device: cuda:0\n", + "\n", + "#######################################################################\n", + "Please cite the following paper when using nnU-Net:\n", + "Isensee, F., Jaeger, P. F., Kohl, S. A., Petersen, J., & Maier-Hein, K. H. (2021). nnU-Net: a self-configuring method for deep learning-based biomedical image segmentation. Nature methods, 18(2), 203-211.\n", + "#######################################################################\n", + "\n" + ] + }, + { + "data": { + "text/html": [ + "
→ Starting nnUNet training (epochs=2, fold=0, configuration='2d')…\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m→\u001b[0m Starting nnUNet training \u001b[1m(\u001b[0m\u001b[33mepochs\u001b[0m=\u001b[1;36m2\u001b[0m, \u001b[33mfold\u001b[0m=\u001b[1;36m0\u001b[0m, \u001b[33mconfiguration\u001b[0m=\u001b[32m'2d'\u001b[0m\u001b[1m)\u001b[0m…\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-06-10 10:03:37.573223: Using torch.compile...\n", + "2026-06-10 10:03:38.179415: do_dummy_2d_data_aug: False\n", + "2026-06-10 10:03:38.179789: Creating new 5-fold cross-validation split...\n", + "2026-06-10 10:03:38.180498: Desired fold for training: 0\n", + "2026-06-10 10:03:38.180549: This split has 6 training and 2 validation cases.\n", + "using pin_memory on device 0\n", + "using pin_memory on device 0\n", + "\n", + "This is the configuration used by this training:\n", + "Configuration name: 2d\n", + " {'data_identifier': 'nnUNetPlans_2d', 'preprocessor_name': 'DefaultPreprocessor', 'batch_size': 154, 'patch_size': [256, 56], 'median_image_size_in_voxels': [255.0, 50.0], 'spacing': [1.0, 1.0], 'normalization_schemes': ['CTNormalization'], 'use_mask_for_norm': [False], 'resampling_fn_data': 'resample_data_or_seg_to_shape', 'resampling_fn_seg': 'resample_data_or_seg_to_shape', 'resampling_fn_data_kwargs': {'is_seg': False, 'order': 3, 'order_z': 0, 'force_separate_z': None}, 'resampling_fn_seg_kwargs': {'is_seg': True, 'order': 1, 'order_z': 0, 'force_separate_z': None}, 'resampling_fn_probabilities': 'resample_data_or_seg_to_shape', 'resampling_fn_probabilities_kwargs': {'is_seg': False, 'order': 1, 'order_z': 0, 'force_separate_z': None}, 'architecture': {'network_class_name': 'dynamic_network_architectures.architectures.unet.PlainConvUNet', 'arch_kwargs': {'n_stages': 6, 'features_per_stage': [32, 64, 128, 256, 512, 512], 'conv_op': 'torch.nn.modules.conv.Conv2d', 'kernel_sizes': [[3, 3], [3, 3], [3, 3], [3, 3], [3, 3], [3, 3]], 'strides': [[1, 1], [2, 2], [2, 2], [2, 2], [2, 1], [2, 1]], 'n_conv_per_stage': [2, 2, 2, 2, 2, 2], 'n_conv_per_stage_decoder': [2, 2, 2, 2, 2], 'conv_bias': True, 'norm_op': 'torch.nn.modules.instancenorm.InstanceNorm2d', 'norm_op_kwargs': {'eps': 1e-05, 'affine': True}, 'dropout_op': None, 'dropout_op_kwargs': None, 'nonlin': 'torch.nn.LeakyReLU', 'nonlin_kwargs': {'inplace': True}}, '_kw_requires_import': ['conv_op', 'norm_op', 'dropout_op', 'nonlin']}, 'batch_dice': True} \n", + "\n", + "These are the global plan.json settings:\n", + " {'dataset_name': 'Dataset001_NNUNETTESTSynapseTutorial', 'plans_name': 'nnUNetPlans', 'original_median_spacing_after_transp': [1.0, 1.0, 1.0], 'original_median_shape_after_transp': [432, 255, 50], 'image_reader_writer': 'SimpleITKIO', 'transpose_forward': [0, 1, 2], 'transpose_backward': [0, 1, 2], 'experiment_planner_used': 'ExperimentPlanner', 'label_manager': 'LabelManager', 'foreground_intensity_properties_per_channel': {'0': {'max': 1.0, 'mean': 0.5385783910751343, 'median': 0.5568627715110779, 'min': 0.0, 'percentile_00_5': 0.0, 'percentile_99_5': 1.0, 'std': 0.17045406997203827}}} \n", + "\n", + "2026-06-10 10:03:39.983892: Unable to plot network architecture: nnUNet_compile is enabled!\n", + "2026-06-10 10:03:39.991411: \n", + "2026-06-10 10:03:39.991675: Epoch 0\n", + "2026-06-10 10:03:39.991861: Current learning rate: 0.01\n", + "2026-06-10 10:06:32.835347: train_loss 0.3134\n", + "2026-06-10 10:06:32.835597: val_loss 0.1853\n", + "2026-06-10 10:06:32.835830: Pseudo dice [np.float32(0.3984), np.float32(0.0), np.float32(0.0), np.float32(0.0), np.float32(0.0), np.float32(0.0), np.float32(0.0), np.float32(0.0)]\n", + "2026-06-10 10:06:32.835887: Epoch time: 172.85 s\n", + "2026-06-10 10:06:32.835922: Yayy! New best EMA pseudo Dice: 0.049800001084804535\n", + "2026-06-10 10:07:05.255845: \n", + "2026-06-10 10:07:05.256197: Epoch 1\n", + "2026-06-10 10:07:05.256353: Current learning rate: 0.00536\n", + "2026-06-10 10:09:53.133245: train_loss 0.0396\n", + "2026-06-10 10:09:53.133483: val_loss 0.1051\n", + "2026-06-10 10:09:53.133731: Pseudo dice [np.float32(0.6944), np.float32(0.0), np.float32(0.0), np.float32(0.0), np.float32(0.0), np.float32(0.0), np.float32(0.0), np.float32(0.0)]\n", + "2026-06-10 10:09:53.133804: Epoch time: 167.88 s\n", + "2026-06-10 10:09:53.133839: Yayy! New best EMA pseudo Dice: 0.05350000038743019\n", + "2026-06-10 10:10:31.374071: Training done.\n" + ] + }, + { + "data": { + "text/html": [ + "
→ Running nnUNet prediction on test split (folds=(0,))…\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m→\u001b[0m Running nnUNet prediction on test split \u001b[1m(\u001b[0m\u001b[33mfolds\u001b[0m=\u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m,\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m…\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Trainer '_DatamintNNUNetTrainer' not found in nnunetv2.training.nnUNetTrainer.\n", + "Searching in external trainer paths from environment variable 'nnUNet_extTrainer'...\n", + "Searching in: /home/luan/Desktop/Datamint/Codes/datamint-python-api/datamint/lightning/trainers/specialized/nnunet\n", + "Searching for class _DatamintNNUNetTrainer in folder /home/luan/Desktop/Datamint/Codes/datamint-python-api/datamint/lightning/trainers/specialized/nnunet with current module None\n", + " Inspecting module: _nnunet_trainer_bridge\n", + "Found class _DatamintNNUNetTrainer in _nnunet_trainer_bridge\n", + "Using trainer '_DatamintNNUNetTrainer' from: /home/luan/Desktop/Datamint/Codes/datamint-python-api/datamint/lightning/trainers/specialized/nnunet\n", + "There are 3 cases in the source folder\n", + "I am process 0 out of 1 (max process ID is 0, we start counting with 0!)\n", + "There are 3 cases that I would like to predict\n", + "\n", + "Predicting case_009:\n", + "perform_everything_on_device: True\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 846/846 [00:14<00:00, 58.12it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sending off prediction to background worker for resampling and export\n", + "done with case_009\n", + "\n", + "Predicting case_010:\n", + "perform_everything_on_device: True\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 926/926 [00:14<00:00, 65.53it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sending off prediction to background worker for resampling and export\n", + "done with case_010\n", + "\n", + "Predicting case_011:\n", + "perform_everything_on_device: True\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 858/858 [00:12<00:00, 66.76it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sending off prediction to background worker for resampling and export\n", + "done with case_011\n", + "GPU prediction completed. Waiting for remaining segmentation exports to finish...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Collecting results: 100%|██████████| 3/3 [00:01<00:00, 1.82it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Segmentation export complete.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/html": [ + "
✓ Predictions written to \n",
+       "/home/luan/.cache/datamint/nnunet/results/Dataset001_NNUNETTESTSynapseTutorial/_DatamintNNUNetTrainer__nnUNetPlans_\n",
+       "_2d/predictions_test\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[32m✓\u001b[0m Predictions written to \n", + "\u001b[35m/home/luan/.cache/datamint/nnunet/results/Dataset001_NNUNETTESTSynapseTutorial/_DatamintNNUNetTrainer__nnUNetPlans_\u001b[0m\n", + "\u001b[35m_2d/\u001b[0m\u001b[95mpredictions_test\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026/06/10 10:11:39 WARNING mlflow.types.type_hints: Union type hint with multiple non-None types is inferred as AnyType, and MLflow doesn't validate the data against its element types.\n", + "2026/06/10 10:11:39 WARNING mlflow.types.type_hints: Union type hint with multiple non-None types is inferred as AnyType, and MLflow doesn't validate the data against its element types.\n", + "2026/06/10 10:11:39 INFO mlflow.models.signature: Failed to infer output type hint, setting output schema to AnyType. Invalid type hint `dict`, it must include a valid element type. Type hints must be a list[...] where collection element type is one of these types: [, , , , , ], pydantic BaseModel subclasses, lists and dictionaries of primitive types, or typing.Any. Check https://mlflow.org/docs/latest/model/python_model.html#supported-type-hints for more details.\n", + "2026/06/10 10:11:44 WARNING mlflow.utils.environment: Encountered an unexpected error while inferring pip requirements (model URI: /tmp/tmp93us5tsy/model, flavor: python_function). Fall back to return ['cloudpickle==3.1.2']. Set logging level to DEBUG to see the full traceback. \n", + "Registered model 'NNUNET__TEST_Synapse_Tutorial' already exists. Creating a new version of this model...\n", + "2026/06/10 10:12:20 WARNING mlflow.tracking._model_registry.fluent: Run with id 3d2803c2e2684a7fb7bd08b67a955963 has no artifacts at artifact path 'nnunet_model', registering model based on models:/m-46910b960f4340f3b5294ca67aa7f1c3 instead\n", + "2026/06/10 10:12:21 INFO mlflow.store.model_registry.abstract_store: Waiting up to 300 seconds for model version to finish creation. Model name: NNUNET__TEST_Synapse_Tutorial, version 7\n", + "Created version '7' of model 'NNUNET__TEST_Synapse_Tutorial'.\n" + ] + }, + { + "data": { + "text/html": [ + "
✓ Model registered as 'NNUNET__TEST_Synapse_Tutorial' in MLflow registry.\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[32m✓\u001b[0m Model registered as \u001b[32m'\u001b[0m\u001b[1;32mNNUNET__TEST_Synapse_Tutorial\u001b[0m\u001b[32m'\u001b[0m in MLflow registry.\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🏃 View run delightful-perch-614 at: http://api.datamint.io:5000/#/experiments/20/runs/3d2803c2e2684a7fb7bd08b67a955963\n", + "🧪 View experiment at: http://api.datamint.io:5000/#/experiments/20\n" + ] + } + ], + "source": [ + "results = trainer.fit()" + ] + }, + { + "cell_type": "markdown", + "id": "b0eb4977", + "metadata": {}, + "source": [ + "### What `fit()` returns\n", + "\n", + "`NNUNetTrainer.fit()` returns a dict with two keys:\n", + "\n", + "| Key | Type | Description |\n", + "|-----|------|-------------|\n", + "| `'bridge'` | `_DatamintNNUNetTrainer` | The trained nnU-Net trainer instance. Provides `output_folder` (fold checkpoint dir) and `output_folder_base` (configuration-level dir where predictions are written). |\n", + "| `'model_name'` | `str` | The MLflow registered model name. Pass this to `api.deploy.start(model_name=...)` to deploy the model. |\n", + "\n", + "Metrics (Dice, loss) are tracked in MLflow and can be viewed in the MLflow UI or retrieved via `mlflow.MlflowClient()`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a9b0c1d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Registered model : NNUNET__TEST_Synapse_Tutorial\n", + "Fold output dir : /home/luan/.cache/datamint/nnunet/results/Dataset001_NNUNETTESTSynapseTutorial/_DatamintNNUNetTrainer__nnUNetPlans__2d/fold_0\n", + "Predictions dir : /home/luan/.cache/datamint/nnunet/results/Dataset001_NNUNETTESTSynapseTutorial/_DatamintNNUNetTrainer__nnUNetPlans__2d/predictions_test\n", + "Final checkpoint : ✓ exists\n", + "Predictions : 3 file(s) — ['case_009.nii.gz', 'case_010.nii.gz', 'case_011.nii.gz']\n" + ] + } + ], + "source": [ + "bridge = results['bridge']\n", + "model_name = results['model_name']\n", + "\n", + "print(f\"Registered model : {model_name}\")\n", + "print(f\"Fold output dir : {bridge.output_folder}\")\n", + "print(f\"Predictions dir : {bridge.output_folder_base}/predictions_test\")\n", + "\n", + "# Check that the final checkpoint exists\n", + "from pathlib import Path\n", + "final_ckpt = Path(bridge.output_folder) / 'checkpoint_final.pth'\n", + "print(f\"Final checkpoint : {'✓ exists' if final_ckpt.exists() else '✗ not found'}\")\n", + "\n", + "# List prediction files (if any)\n", + "pred_dir = Path(bridge.output_folder_base) / 'predictions_test'\n", + "if pred_dir.exists():\n", + " preds = sorted(pred_dir.glob('*.nii.gz'))\n", + " print(f\"Predictions : {len(preds)} file(s) — {[p.name for p in preds]}\")\n", + "else:\n", + " print(\"Predictions : none (no 'test' split was assigned, or prediction step was skipped)\")" + ] + }, + { + "cell_type": "markdown", + "id": "b0c1d2e3", + "metadata": {}, + "source": [ + "## 5. Visualise Predictions\n", + "\n", + "After training, nnU-Net writes test-set predictions to `{output_folder_base}/predictions_test/` as NIfTI label maps. Each integer value in the label map corresponds to an organ class (matching the `SYNAPSE_CLASSES` dict we defined earlier).\n", + "\n", + "The cell below loads up to two test cases, displays three axial slices per case, and overlays the predicted segmentation on the raw CT." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c1d2e3f4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "from pathlib import Path\n", + "import nibabel as nib\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "bridge = results['bridge']\n", + "pred_dir = Path(bridge.output_folder_base) / 'predictions_test'\n", + "pred_files = sorted(pred_dir.glob('*.nii.gz')) if pred_dir.exists() else []\n", + "\n", + "if not pred_files:\n", + " print(\n", + " \"No predictions found.\\n\"\n", + " \"Make sure a 'test' split was assigned before training and that training completed.\\n\"\n", + " f\"Expected prediction dir: {pred_dir}\"\n", + " )\n", + "else:\n", + " # Locate the exported test images so we can display CT + prediction side-by-side.\n", + " # The exporter writes them to: nnunet_work_dir/raw/Dataset{id}_{name}/imagesTs/\n", + " raw_dir = trainer.nnunet_work_dir / 'raw'\n", + " dataset_dir = sorted(raw_dir.glob('Dataset*'))[0]\n", + " imagesTs_dir = dataset_dir / 'imagesTs'\n", + "\n", + " SYNAPSE_CLASSES = {\n", + " 1: 'aorta', 2: 'gallbladder', 3: 'spleen',\n", + " 4: 'left_kidney', 5: 'right_kidney', 6: 'liver',\n", + " 7: 'stomach', 8: 'pancreas',\n", + " }\n", + " num_classes = len(SYNAPSE_CLASSES)\n", + " CMAP = plt.get_cmap('tab10', num_classes + 1)\n", + "\n", + " for pred_path in pred_files[:1]: # show at most 2 cases to keep the notebook manageable\n", + " case_id = pred_path.name.replace('.nii.gz', '')\n", + " # Test images are stored as {case_id}_0000.nii.gz (channel-0 suffix added by exporter)\n", + " img_path = imagesTs_dir / f'{case_id}_0000.nii.gz'\n", + "\n", + " pred_nii = nib.load(str(pred_path))\n", + " pred_vol = pred_nii.get_fdata().astype(np.int32)\n", + "\n", + " if img_path.exists():\n", + " ct_vol = nib.load(str(img_path)).get_fdata()\n", + " else:\n", + " ct_vol = np.zeros_like(pred_vol, dtype=np.float32)\n", + "\n", + " # nnU-Net uses (H, W, D) orientation; pick 3 evenly-spaced axial slices\n", + " D = pred_vol.shape[2]\n", + " slice_indices = [D // 4, D // 2, 3 * D // 4]\n", + "\n", + " fig, axes = plt.subplots(len(slice_indices), 2, figsize=(10, 4 * len(slice_indices)))\n", + " fig.suptitle(f'nnU-Net predictions — case: {case_id}', fontsize=13)\n", + "\n", + " for row, s in enumerate(slice_indices):\n", + " ct_slice = ct_vol[:, :, s]\n", + " pred_slice = pred_vol[:, :, s]\n", + "\n", + " axes[row, 0].imshow(ct_slice, cmap='gray')\n", + " axes[row, 0].set_title(f'CT — axial')\n", + " axes[row, 0].axis('off')\n", + "\n", + " axes[row, 1].imshow(ct_slice, cmap='gray')\n", + " axes[row, 1].imshow(pred_slice, cmap=CMAP, alpha=0.5, vmin=0, vmax=num_classes)\n", + " axes[row, 1].set_title(f'nnU-Net prediction')\n", + " axes[row, 1].axis('off')\n", + "\n", + " handles = [plt.Rectangle((0, 0), 1, 1, color=CMAP(i + 1)) for i in range(num_classes)]\n", + " labels = list(SYNAPSE_CLASSES.values())\n", + " fig.legend(handles, labels, loc='lower center', ncol=4, fontsize=9, title='Organ classes')\n", + " plt.tight_layout()\n", + " plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index 572f7534..6359b53d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -64,6 +64,8 @@ pytest-cov = { version = "^7.1.0", optional = true } responses = { version = "^0.20.0", optional = true } aioresponses = { version = "^0.7.8", optional = true } respx = { version = ">=0.22.0", optional = true } +nnunetv2 = { version = ">=2.4,<3.0", optional = true } +filelock = { version = ">=3.0", optional = true } [tool.poetry.group.dev.dependencies] # for `poetry install` @@ -77,6 +79,7 @@ respx = ">=0.22.0" [tool.poetry.extras] docs = ["sphinx", "sphinx_rtd_theme", "sphinx-tabs", "setuptools"] dev = ["pytest", "pytest-cov", "responses", "aioresponses", "respx"] +nnunet = ["nnunetv2", "filelock"] [build-system] requires = ["poetry-core>=1.0.0"] diff --git a/tests/test_nnunet_data_export.py b/tests/test_nnunet_data_export.py new file mode 100644 index 00000000..0842038c --- /dev/null +++ b/tests/test_nnunet_data_export.py @@ -0,0 +1,117 @@ +""" +Testing the DatamintToNNUNetExporter class to ensure it correctly writes dataset.json, preserves voxel spacing, merges segmentations, and creates the expected directory structure for nnUNet. +""" +import pytest +pytest.importorskip("nnunetv2", minversion="2.4") +import json +import numpy as np +import nibabel as nib +import pytest +from unittest.mock import MagicMock +from datamint.lightning.trainers.specialized.nnunet.data_export import DatamintToNNUNetExporter + + +def _make_nifti(shape=(64, 64, 32), zooms=(1.5, 1.5, 2.0)) -> nib.Nifti1Image: + data = np.zeros(shape, dtype=np.int16) + affine = np.diag([*zooms, 1.0]) + img = nib.Nifti1Image(data, affine) + img.header.set_zooms(zooms) + return img + + +def _make_resource(resource_id: str, nifti: nib.Nifti1Image) -> MagicMock: + resource = MagicMock() + resource.id = resource_id + resource.fetch_file_data.return_value = nifti + return resource + + +def _make_seg(label_value: int, shape=(64, 64, 32)) -> MagicMock: + arr = np.zeros(shape, dtype=np.int32) + arr[10:20, 10:20, 5:15] = 1 + seg = MagicMock() + seg.fetch_file_data.return_value = arr + seg.identifier = 'liver' if label_value == 1 else 'tumor' + seg.class_map = {label_value: seg.identifier} + return seg + + +def test_dataset_json_is_written(tmp_path): + exp = DatamintToNNUNetExporter(tmp_path, dataset_id=1, dataset_name='CTLiver') + exp._write_dataset_json( + labels={'background': 0, 'liver': 1}, + channel_names={'0': 'CT'}, + num_training=10, + ) + content = json.loads((tmp_path / 'Dataset001_CTLiver' / 'dataset.json').read_text()) + assert content['labels'] == {'background': 0, 'liver': 1} + assert content['channel_names'] == {'0': 'CT'} + assert content['numTraining'] == 10 + assert content['file_ending'] == '.nii.gz' + + +def test_export_image_preserves_voxel_spacing(tmp_path): + zooms = (1.5, 1.5, 2.0) + resource = _make_resource('res-001', _make_nifti(zooms=zooms)) + exp = DatamintToNNUNetExporter(tmp_path, dataset_id=1, dataset_name='CTLiver') + exp._export_image(resource, case_id='case_001', split='train') + + out = tmp_path / 'Dataset001_CTLiver' / 'imagesTr' / 'case_001_0000.nii.gz' + assert out.exists() + assert nib.load(str(out)).header.get_zooms() == pytest.approx(zooms, abs=1e-4) + + +def test_merge_segmentations_highest_class_wins(tmp_path): + shape = (32, 32, 16) + liver = np.zeros(shape, dtype=np.int32); liver[5:15, 5:15, 2:8] = 1 + tumor = np.zeros(shape, dtype=np.int32); tumor[10:20, 10:20, 4:10] = 2 + + liver_seg = MagicMock(); liver_seg.fetch_file_data.return_value = liver + tumor_seg = MagicMock(); tumor_seg.fetch_file_data.return_value = tumor + + exp = DatamintToNNUNetExporter(tmp_path, dataset_id=1, dataset_name='CTLiver') + merged = exp._merge_segmentations([liver_seg, tumor_seg]) + + assert merged[12, 12, 5] == 2 # overlap → tumor wins + assert merged[6, 6, 3] == 1 # no overlap → liver preserved + + +def test_merge_segmentations_warns_on_overlap(tmp_path): + shape = (32, 32, 16) + seg1 = MagicMock(); seg1.fetch_file_data.return_value = np.ones(shape, dtype=np.int32) + seg2 = MagicMock(); seg2.fetch_file_data.return_value = np.ones(shape, dtype=np.int32) * 2 + + exp = DatamintToNNUNetExporter(tmp_path, dataset_id=1, dataset_name='CTLiver') + with pytest.warns(UserWarning, match='overlap'): + exp._merge_segmentations([seg1, seg2]) + + +def test_case_map_is_written(tmp_path): + exp = DatamintToNNUNetExporter(tmp_path, dataset_id=1, dataset_name='CTLiver') + mapping = {'case_001': 'res-uuid-001', 'case_002': 'res-uuid-002'} + exp._write_case_map(mapping) + loaded = json.loads( + (tmp_path / 'Dataset001_CTLiver' / 'datamint_case_map.json').read_text() + ) + assert loaded == mapping + + +def test_export_creates_full_directory_structure(tmp_path): + nifti = _make_nifti() + resources = [_make_resource(f'res-00{i}', nifti) for i in range(3)] + for r in resources: + r.fetch_annotations.return_value = [_make_seg(1)] + + split = {'train': [resources[0], resources[1]], 'test': [resources[2]]} + exp = DatamintToNNUNetExporter(tmp_path, dataset_id=1, dataset_name='CTLiver') + dataset_path = exp.export(split, channel_names={'0': 'CT'}) + + assert (dataset_path / 'dataset.json').exists() + assert (dataset_path / 'imagesTr' / 'case_001_0000.nii.gz').exists() + assert (dataset_path / 'labelsTr' / 'case_001.nii.gz').exists() + assert (dataset_path / 'imagesTs' / 'case_003_0000.nii.gz').exists() + assert not (dataset_path / 'labelsTs').exists() + + label_arr = nib.load(str(dataset_path / 'labelsTr' / 'case_001.nii.gz')).get_fdata() + assert label_arr[15, 15, 7] == 1 # liver voxel scaled to class index 1 + assert label_arr[0, 0, 0] == 0 # background preserved diff --git a/tests/test_nnunet_data_import.py b/tests/test_nnunet_data_import.py new file mode 100644 index 00000000..8077f7b9 --- /dev/null +++ b/tests/test_nnunet_data_import.py @@ -0,0 +1,60 @@ +""" +Test the NNUNetToDatamintImporter class for importing nnUNet predictions into Datamint. +""" +import pytest +pytest.importorskip("nnunetv2", minversion="2.4") +import json +import numpy as np +import nibabel as nib +import pytest +from pathlib import Path +from unittest.mock import MagicMock +from datamint.lightning.trainers.specialized.nnunet.data_import import NNUNetToDatamintImporter + + +def _write_pred(path: Path, shape=(64, 64, 32)): + arr = np.zeros(shape, dtype=np.int32) + arr[10:20, 10:20, 5:15] = 1 + nib.save(nib.Nifti1Image(arr, np.eye(4)), str(path)) + + +@pytest.fixture() +def setup(tmp_path): + pred_dir = tmp_path / 'predictions' + pred_dir.mkdir() + _write_pred(pred_dir / 'case_001.nii.gz') + + dataset_dir = tmp_path / 'Dataset001_CTLiver' + dataset_dir.mkdir() + (dataset_dir / 'datamint_case_map.json').write_text( + json.dumps({'case_001': 'res-uuid-001'}) + ) + + api = MagicMock() + return api, dataset_dir, pred_dir + + +def test_import_creates_volume_segmentation(setup): + api, dataset_dir, pred_dir = setup + segs = NNUNetToDatamintImporter(api, dataset_dir).import_predictions( + pred_dir, class_map={1: 'liver'} + ) + assert len(segs) == 1 + assert segs[0].class_map == {1: 'liver'} + + +def test_import_uploads_to_correct_resource(setup): + api, dataset_dir, pred_dir = setup + NNUNetToDatamintImporter(api, dataset_dir).import_predictions( + pred_dir, class_map={1: 'liver'} + ) + assert api.annotations.upload_volume_segmentation.call_args.kwargs['resource'] == 'res-uuid-001' + + +def test_import_raises_on_missing_case(setup): + api, dataset_dir, pred_dir = setup + _write_pred(pred_dir / 'case_999.nii.gz') + with pytest.raises(KeyError, match='case_999'): + NNUNetToDatamintImporter(api, dataset_dir).import_predictions( + pred_dir, class_map={1: 'liver'} + ) diff --git a/tests/test_nnunet_inference_model.py b/tests/test_nnunet_inference_model.py new file mode 100644 index 00000000..396ba79e --- /dev/null +++ b/tests/test_nnunet_inference_model.py @@ -0,0 +1,99 @@ +"""" +Test nnU-Net prediction pipeline using NNUNetInferenceModel. This includes loading the model context, running inference on a mock resource, and verifying that the output segmentation has the expected class map. +We also check that temporary directories are cleaned up after prediction. +""" +import pytest +pytest.importorskip("nnunetv2", minversion="2.4") + +import sys +import numpy as np +import nibabel as nib +from pathlib import Path +from unittest.mock import MagicMock, patch +from datamint.lightning.trainers.specialized.nnunet.inference_model import NNUNetInferenceModel + +# Fake nnunetv2 submodules so patch() can resolve them +def _mock_nnunetv2(): + root = MagicMock() + root.__version__ = '2.4.0' + inference_mod = MagicMock() + pred_mod = MagicMock() + root.inference = inference_mod + inference_mod.predict_from_raw_data = pred_mod + sys.modules.setdefault('nnunetv2', root) + sys.modules.setdefault('nnunetv2.inference', inference_mod) + sys.modules.setdefault('nnunetv2.inference.predict_from_raw_data', pred_mod) + +_mock_nnunetv2() + +def _make_bundle(tmp_path, fold=0): + bundle = tmp_path / 'nnunet_bundle' + fold_dir = bundle / f'fold_{fold}' + fold_dir.mkdir(parents=True) + (bundle / 'nnUNetPlans.json').write_text('{}') + (bundle / 'dataset_fingerprint.json').write_text('{}') + (fold_dir / 'checkpoint_best.pth').write_bytes(b'fake') + return bundle + + +def _make_context(bundle_path): + ctx = MagicMock() + ctx.artifacts = {'nnunet_bundle': str(bundle_path)} + ctx.model_config = {} + return ctx + + +def _make_resource(shape=(64, 64, 32)): + arr = np.zeros(shape, dtype=np.int16) + resource = MagicMock() + resource.id = 'res-001' + resource.fetch_file_data.return_value = nib.Nifti1Image(arr, np.eye(4)) + return resource + + +def test_load_context_initializes_predictor(tmp_path): + bundle = _make_bundle(tmp_path) + model = NNUNetInferenceModel(class_map={1: 'liver'}, configuration='3d_fullres', folds=(0,)) + with patch('nnunetv2.inference.predict_from_raw_data.nnUNetPredictor') as MockPred: + model.load_context(_make_context(bundle)) + MockPred.return_value.initialize_from_trained_model_folder.assert_called_once_with( + model_training_output_dir=str(bundle), + use_folds=(0,), + checkpoint_name='checkpoint_final.pth', + ) + assert model._predictor is not None + + +def test_predict_volume_returns_volume_segmentation(tmp_path): + bundle = _make_bundle(tmp_path) + model = NNUNetInferenceModel(class_map={1: 'liver'}, configuration='3d_fullres', folds=(0,)) + + def fake_predict(src, dst, **kw): + arr = np.zeros((64, 64, 32), dtype=np.int32) + arr[10:20, 10:20, 5:15] = 1 + nib.save(nib.Nifti1Image(arr, np.eye(4)), str(Path(dst) / 'case_001.nii.gz')) + + with patch('nnunetv2.inference.predict_from_raw_data.nnUNetPredictor') as MockPred: + MockPred.return_value.predict_from_files.side_effect = fake_predict + model.load_context(_make_context(bundle)) + results = model.predict_volume([_make_resource()]) + + assert len(results) == 1 and results[0][0].class_map == {1: 'liver'} + + +def test_predict_volume_cleans_up_temp_dir(tmp_path): + bundle = _make_bundle(tmp_path) + model = NNUNetInferenceModel(class_map={1: 'liver'}, configuration='3d_fullres', folds=(0,)) + captured = [] + + def fake_predict(src, dst, **kw): + captured.append(dst) + arr = np.zeros((64, 64, 32), dtype=np.int32) + nib.save(nib.Nifti1Image(arr, np.eye(4)), str(Path(dst) / 'case_001.nii.gz')) + + with patch('nnunetv2.inference.predict_from_raw_data.nnUNetPredictor') as MockPred: + MockPred.return_value.predict_from_files.side_effect = fake_predict + model.load_context(_make_context(bundle)) + model.predict_volume([_make_resource()]) + + assert captured and not Path(captured[0]).exists() diff --git a/tests/test_nnunet_integration.py b/tests/test_nnunet_integration.py new file mode 100644 index 00000000..c7383b3b --- /dev/null +++ b/tests/test_nnunet_integration.py @@ -0,0 +1,107 @@ +""" +End-to-end integration test for the full nnUNet pipeline. + +Run with: + pytest tests/test_nnunet.py -v -s + +Requirements: + - pip install ".[nnunet]" + - A real Datamint project named PROJECT_NAME with NIfTI volumes + segmentations + - Enough disk space for nnUNet preprocessing (~2–5 GB for a small dataset) +""" +import random +import pytest +pytest.importorskip("nnunetv2", minversion="2.4") +from pathlib import Path + +PROJECT_NAME = "NNUNET__TEST_Synapse_Tutorial" +WORK_DIR = Path.home() / '.cache' / 'datamint' / 'nnunet_integration_test' + + +@pytest.mark.integration +def test_full_nnunet_pipeline(): + from datamint import Api + from datamint.lightning import NNUNetTrainer + import mlflow + + api = Api() + + proj = api.projects.create( + name=PROJECT_NAME, + description="Testing nnunet on Synapse Multi-Organ CT", + exists_ok=True, + ) + + # -- Assign train/test splits randomly (nnUNet requires splits to be defined) -- + all_resources = list(api.resources.get_list(project_name=PROJECT_NAME)) + all_resources.sort(key=lambda r: r.filename) + + random.seed(42) + random.shuffle(all_resources) + + n = len(all_resources) + n_train = int(0.70 * n) + n_test = int(0.30 * n) + + api.projects.assign_splits(proj, all_resources[:n_train], split_name='train') + api.projects.assign_splits(proj, all_resources[n_train:n_train + n_test], split_name='test') + + print(f"Train: {n_train} Test: {n_test}") + + trainer = NNUNetTrainer( + project=PROJECT_NAME, + configuration='2d', + fold=0, + max_epochs=2, + nnunet_work_dir=WORK_DIR, + continue_training=True + ) + + results = trainer.fit() + + # Testing the full pipeline is a bit tricky since there are many steps and potential failure points. + # Here we check for key outputs at each stage to verify that the pipeline ran end-to-end: + # 1. The trainer's fit() method returned a 'bridge' object, which indicates that the deploy adapter ran and + # produced an output folder. + assert 'bridge' in results + bridge = results['bridge'] + assert bridge is not None + + # 2. The exporter wrote the expected dataset structure for nnUNet, including dataset.json, imagesTr/, labelsTr/, + # and datamint_case_map.json. + dataset_dir = WORK_DIR / 'raw' / f'Dataset001_{trainer._dataset_name}' + assert (dataset_dir / 'dataset.json').exists(), "dataset.json not written by exporter" + assert (dataset_dir / 'imagesTr').exists(), "imagesTr directory missing" + assert (dataset_dir / 'labelsTr').exists(), "labelsTr directory missing" + assert (dataset_dir / 'datamint_case_map.json').exists(), "case map not written" + + # 3. The fingerprinting and planning steps ran and produced dataset_fingerprint.json and nnUNetPlans.json + # in the preprocessed directory. + preprocessed_dir = WORK_DIR / 'preprocessed' / f'Dataset001_{trainer._dataset_name}' + assert (preprocessed_dir / 'dataset_fingerprint.json').exists(), \ + "dataset_fingerprint.json missing — fingerprinting failed" + assert (preprocessed_dir / 'nnUNetPlans.json').exists(), \ + "nnUNetPlans.json missing — experiment planning failed" + + # 4. The training step ran and produced a checkpoint_final.pth in the trainer's output folder. + final_ckpt = Path(bridge.output_folder) / 'checkpoint_final.pth' + assert final_ckpt.exists(), \ + f"checkpoint_final.pth not found at {final_ckpt} — training did not complete" + + # 5. The deploy adapter registered the model in MLflow and returned the model name. We check that the model exists in the registry. + assert 'model_name' in results, "fit() did not return model_name, deploy adapter may have failed" + model_name = results['model_name'] + client = mlflow.MlflowClient() + registered = client.get_registered_model(model_name) + assert registered is not None, f"Model '{model_name}' not found in MLflow registry" + + # 6. Finally, we check that the predictions were imported back into Datamint as volume annotations. + # We look for any resources in the project that have segmentation annotations, + # if none are found, it's a strong signal that the import step failed. + resources = list(api.resources.get_list(project_name=PROJECT_NAME)) + assert len(resources) > 0, "No resources found in project" + + annotated = [r for r in resources if r.fetch_annotations(annotation_type='segmentation')] + assert len(annotated) > 0, \ + "No segmentation annotations found after import, _import_predictions may have failed" + diff --git a/tests/test_nnunet_trainer.py b/tests/test_nnunet_trainer.py new file mode 100644 index 00000000..5596f9f5 --- /dev/null +++ b/tests/test_nnunet_trainer.py @@ -0,0 +1,134 @@ +""" +Test nnU-Net training pipeline using NNUNetTrainer. We mock the dataset building, nnUNet environment setup, fingerprinting/planning, preprocessing, training, prediction, and import steps to verify that they are +called in the correct order during fit(). We also test the dataset ID assignment logic and that the expected files are written during fingerprinting/planning. +""" +import os +import sys +import pytest +from unittest.mock import MagicMock, patch +import datamint.lightning.trainers.specialized.nnunet.trainer as _trainer_mod +from datamint.lightning.trainers.specialized.nnunet.trainer import NNUNetTrainer + +# Fake nnunetv2 submodules so patch() can resolve them when the trainer imports them. +def _mock_nnunetv2(): + root = MagicMock() + root.__version__ = '2.4.0' + submodules = { + 'nnunetv2': root, + 'nnunetv2.experiment_planning': MagicMock(), + 'nnunetv2.experiment_planning.dataset_fingerprint': MagicMock(), + 'nnunetv2.experiment_planning.dataset_fingerprint.fingerprint_extractor': MagicMock(), + 'nnunetv2.experiment_planning.experiment_planners': MagicMock(), + 'nnunetv2.experiment_planning.experiment_planners.default_experiment_planner': MagicMock(), + 'nnunetv2.experiment_planning.plan_and_preprocess_api': MagicMock(), + 'nnunetv2.training': MagicMock(), + 'nnunetv2.training.nnUNetTrainer': MagicMock(), + 'nnunetv2.training.nnUNetTrainer.nnUNetTrainer': MagicMock(), + } + + class _FakeNNUNetTrainer: + def log(self, *a, **kw): pass + def save_checkpoint(self, *a, **kw): pass + def perform_actual_validation(self, *a, **kw): pass + def print_to_log_file(self, *a, **kw): pass + submodules['nnunetv2.training.nnUNetTrainer.nnUNetTrainer'].nnUNetTrainer = _FakeNNUNetTrainer + for name, mod in submodules.items(): + sys.modules.setdefault(name, mod) + +_mock_nnunetv2() + +@pytest.fixture() +def trainer(tmp_path): + mock_dataset = MagicMock( + resources=[MagicMock(id='res-001'), MagicMock(id='res-002')], + seglabel_list=['liver', 'tumor'], + ) + with patch.object(NNUNetTrainer, '_build_dataset', return_value=mock_dataset): + t = NNUNetTrainer( + project='CT_Liver', + configuration='3d_fullres', + fold=0, + nnunet_work_dir=tmp_path, + ) + yield t + + +# -- Dataset ID assignment tests +def test_assign_dataset_id_increments(tmp_path): + registry = tmp_path / 'nnunet_dataset_ids.yaml' + registry.write_text('CT_Brain: 1\n') + with patch.object(_trainer_mod, 'REGISTRY_PATH', registry): + t1 = NNUNetTrainer(project='CT_Liver', nnunet_work_dir=tmp_path) + t2 = NNUNetTrainer(project='CT_Kidney', nnunet_work_dir=tmp_path) + id1 = t1._assign_dataset_id() + id2 = t2._assign_dataset_id() + assert id1 == 2 and id2 == 3 and id1 != id2 + + +def test_assign_dataset_id_is_stable_for_same_project(tmp_path): + registry = tmp_path / 'nnunet_dataset_ids.yaml' + with patch.object(_trainer_mod, 'REGISTRY_PATH', registry): + t = NNUNetTrainer(project='CT_Liver', nnunet_work_dir=tmp_path) + assert t._assign_dataset_id() == t._assign_dataset_id() + + +# -- nnUNet environment variable setup tests +def test_set_nnunet_env_sets_all_three_vars(trainer, tmp_path, monkeypatch): + monkeypatch.delenv('nnUNet_raw', raising=False) + monkeypatch.delenv('nnUNet_preprocessed', raising=False) + monkeypatch.delenv('nnUNet_results', raising=False) + trainer._set_nnunet_env() + assert all(k in os.environ for k in ('nnUNet_raw', 'nnUNet_preprocessed', 'nnUNet_results')) + assert os.environ['nnUNet_raw'].startswith(str(tmp_path)) + + +# -- nnUNet fingerprinting and planning tests +def test_fingerprint_and_plan_writes_expected_files(trainer, tmp_path): + preprocessed_dir = tmp_path / 'preprocessed' / 'Dataset001_CTLiver' + preprocessed_dir.mkdir(parents=True) + trainer._set_nnunet_env() + + def fake_fp(): + (preprocessed_dir / 'dataset_fingerprint.json').write_text('{}') + + def fake_plan(): + (preprocessed_dir / 'nnUNetPlans.json').write_text('{}') + + with patch('nnunetv2.experiment_planning.dataset_fingerprint' + '.fingerprint_extractor.DatasetFingerprintExtractor') as MockFP, \ + patch('nnunetv2.experiment_planning.experiment_planners.default_experiment_planner.ExperimentPlanner') as MockPlan: + MockFP.return_value.run.side_effect = fake_fp + MockPlan.return_value.plan_experiment.side_effect = fake_plan + trainer._run_fingerprint_and_plan(dataset_id=1) + + assert (preprocessed_dir / 'dataset_fingerprint.json').exists() + assert (preprocessed_dir / 'nnUNetPlans.json').exists() + + +def test_fingerprint_raises_if_json_not_written(trainer): + with patch('nnunetv2.experiment_planning.dataset_fingerprint' + '.fingerprint_extractor.DatasetFingerprintExtractor') as MockFP, \ + patch('nnunetv2.experiment_planning.experiment_planners.default_experiment_planner.ExperimentPlanner'): + MockFP.return_value.run.return_value = None + with pytest.raises(RuntimeError, match='dataset_fingerprint.json'): + trainer._run_fingerprint_and_plan(dataset_id=1) + + +# -- Full pipeline execution order test +def test_fit_calls_pipeline_steps_in_order(trainer): + order = [] + with patch.object(trainer, '_assign_dataset_id', side_effect=lambda: order.append('id') or 1), \ + patch.object(_trainer_mod, 'DatamintToNNUNetExporter'), \ + patch.object(trainer, '_set_nnunet_env', side_effect=lambda: order.append('env')), \ + patch.object(trainer, '_run_fingerprint_and_plan', side_effect=lambda _: order.append('fp')), \ + patch.object(trainer, '_run_preprocessing', side_effect=lambda _: order.append('pre')), \ + patch.object(trainer, '_build_nnunet_trainer', + return_value=MagicMock(run_training=lambda: order.append('train'))), \ + patch.object(trainer, '_run_prediction', side_effect=lambda *_: order.append('pred')), \ + patch.object(trainer, '_import_predictions', side_effect=lambda *_: order.append('imp')), \ + patch.object(trainer, '_build_deploy_adapter', side_effect=lambda *_: order.append('deploy')), \ + patch('datamint.lightning.trainers.specialized.nnunet.trainer.mlflow.register_model', + side_effect=lambda *_: order.append('register')), \ + patch.object(trainer, '_start_mlflow_run'): + trainer.fit() + assert order == ['id', 'env', 'fp', 'pre', 'train', 'pred', 'imp', 'deploy', 'register'] diff --git a/tests/test_nnunet_trainer_bridge.py b/tests/test_nnunet_trainer_bridge.py new file mode 100644 index 00000000..c3b48ae9 --- /dev/null +++ b/tests/test_nnunet_trainer_bridge.py @@ -0,0 +1,128 @@ +""" Test the _DatamintNNUNetTrainer bridge class that extends nnUNetTrainer to log checkpoints and validation summaries to MLflow. We verify that checkpoints are logged as artifacts, that validation metrics are +logged correctly, and that the version guard prevents usage with old nnunetv2 versions.""" +import json +import importlib.metadata as _meta +import pytest + +try: + _ver = tuple(int(x) for x in _meta.version('nnunetv2').split('.')[:2]) + if not ((2, 4) <= _ver < (3, 0)): + pytest.skip("nnunetv2>=2.4,<3.0 required", allow_module_level=True) +except _meta.PackageNotFoundError: + pytest.skip("nnunetv2 not installed", allow_module_level=True) + +from unittest.mock import MagicMock, patch +import sys + +# Mock nnunetv2 BEFORE importing the bridge so tests run without nnunetv2 installed. +class _FakeNNUNetTrainer: + def save_checkpoint(self, *a, **kw): pass + def perform_actual_validation(self, *a, **kw): pass + def print_to_log_file(self, *a, **kw): pass + +_nnunetv2_mock = MagicMock() +_nnunetv2_mock.__version__ = '2.4.0' +sys.modules.setdefault('nnunetv2', _nnunetv2_mock) +sys.modules.setdefault('nnunetv2.training', MagicMock()) +sys.modules.setdefault('nnunetv2.training.nnUNetTrainer', MagicMock()) + +_trainer_module_mock = MagicMock() +_trainer_module_mock.nnUNetTrainer = _FakeNNUNetTrainer +sys.modules.setdefault('nnunetv2.training.nnUNetTrainer.nnUNetTrainer', _trainer_module_mock) + +from datamint.lightning.trainers.specialized.nnunet._nnunet_trainer_bridge import ( + _DatamintNNUNetTrainer, + _MLflowLogger, + _SKIP_METRIC_KEYS, +) + + +@pytest.fixture() +def bridge(): + b = _DatamintNNUNetTrainer.__new__(_DatamintNNUNetTrainer) + b._best_checkpoint_path = None + b.current_epoch = 5 + return b + + +@pytest.fixture() +def mlflow_logger(): + return _MLflowLogger() + + +# -- Tests for _MLflowLogger +def test_mlflow_logger_log_emits_metric(mlflow_logger): + with patch('mlflow.log_metric') as mock_log: + mlflow_logger.log('train_losses', 0.42, step=3) + mock_log.assert_called_once_with('train_losses', 0.42, step=3) + + +def test_mlflow_logger_skips_timestamp_keys(mlflow_logger): + with patch('mlflow.log_metric') as mock_log: + for key in _SKIP_METRIC_KEYS: + mlflow_logger.log(key, 12345.0, step=0) + mock_log.assert_not_called() + + +def test_mlflow_logger_log_summary(mlflow_logger): + with patch('mlflow.log_metric') as mock_log: + mlflow_logger.log_summary('final_val/foreground_dice', 0.88) + mock_log.assert_called_once_with('final_val/foreground_dice', 0.88) + + +def test_mlflow_logger_update_config_logs_params(mlflow_logger): + with patch('mlflow.log_params') as mock_params: + mlflow_logger.update_config({'lr': 0.01, 'epochs': 100, 'name': 'test'}) + mock_params.assert_called_once_with({'lr': 0.01, 'epochs': 100, 'name': 'test'}) + + +def test_mlflow_logger_skips_non_scalar_config(mlflow_logger): + with patch('mlflow.log_params') as mock_params: + mlflow_logger.update_config({'lr': 0.01, 'bad': [1, 2, 3]}) + mock_params.assert_called_once_with({'lr': 0.01}) + + +# -- Tests for _DatamintNNUNetTrainer +def test_save_checkpoint_records_path(bridge, tmp_path): + ckpt = tmp_path / 'checkpoint_best.pth'; ckpt.touch() + with patch('mlflow.log_artifact'), \ + patch.object(_DatamintNNUNetTrainer, '_super_save_checkpoint'): + bridge.save_checkpoint(str(ckpt)) + assert bridge._best_checkpoint_path == ckpt + + +def test_save_checkpoint_logs_artifact(bridge, tmp_path): + ckpt = tmp_path / 'checkpoint_best.pth'; ckpt.touch() + with patch('mlflow.log_artifact') as mock_artifact, \ + patch.object(_DatamintNNUNetTrainer, '_super_save_checkpoint'): + bridge.save_checkpoint(str(ckpt)) + mock_artifact.assert_called_once_with(str(ckpt), artifact_path='nnunet_checkpoints') + + +def test_log_validation_summary_logs_per_class_dice(bridge, tmp_path): + summary = { + 'foreground_mean': 0.85, + 'mean': {'liver': {'Dice': 0.91}, 'tumor': {'Dice': 0.74}}, + } + val_dir = tmp_path / 'validation' + val_dir.mkdir(parents=True) + (val_dir / 'summary.json').write_text(json.dumps(summary)) + bridge.fold = 0 + bridge.output_folder = str(tmp_path) + + with patch('mlflow.log_metric') as mock_log: + bridge._log_validation_summary() + + calls = {c.args[0]: c.args[1] for c in mock_log.call_args_list} + assert calls['val/dice_liver'] == pytest.approx(0.91) + assert calls['val/dice_tumor'] == pytest.approx(0.74) + assert calls['val/dice_mean'] == pytest.approx(0.85) + + +def test_version_guard_raises_on_old_nnunet(): + import importlib + import importlib.metadata as _meta + import datamint.lightning.trainers.specialized.nnunet._nnunet_trainer_bridge as m + with patch.object(_meta, 'version', return_value='1.0.0'): + with pytest.raises(ImportError, match='nnunetv2>=2.4'): + importlib.reload(m)