use detection inferer

configs/inference.json

@@ -13,7 +13,7 @@
     "test_datalist": "$monai.data.load_decathlon_datalist(@data_list_file_path, is_segmentation=True, data_list_key='validation', base_dir=@data_file_base_dir)",
     "device": "$torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')",
     "amp": true,
-    "val_patch_size": [
+    "infer_patch_size": [
         512,
         512,
         192
@@ -67,7 +67,7 @@
     "detector_ops": [
         "$@detector.set_target_keys(box_key='box', label_key='label')",
         "$@detector.set_box_selector_parameters(score_thresh=0.02,topk_candidates_per_level=1000,nms_thresh=0.22,detections_per_img=300)",
-        "$@detector.set_sliding_window_inferer(roi_size=@val_patch_size,overlap=0.25,sw_batch_size=1,mode='constant',device='cpu')"
+        "$@detector.set_sliding_window_inferer(roi_size=@infer_patch_size,overlap=0.25,sw_batch_size=1,mode='constant',device='cpu')"
     ],
     "preprocessing": {
         "_target_": "Compose",
@@ -135,14 +135,8 @@
         "collate_fn": "$monai.data.utils.no_collation"
     },
     "inferer": {
-        "_target_": "SlidingWindowInferer",
-        "roi_size": [
-            240,
-            240,
-            160
-        ],
-        "sw_batch_size": 1,
-        "overlap": 0.5
+        "_target_": "scripts.detection_inferer.RetinaNetInferer",
+        "detector": "@detector"
     },
     "postprocessing": {
         "_target_": "Compose",
@@ -203,7 +197,8 @@
         "_requires_": "@detector_ops",
         "device": "@device",
         "val_data_loader": "@dataloader",
-        "detector": "@detector",
+        "network": "@network",
+        "inferer": "@inferer",
         "val_handlers": "@handlers",
         "amp": "@amp"
     },

configs/metadata.json

@@ -1,7 +1,8 @@
 {
     "schema": "https://github.com/Project-MONAI/MONAI-extra-test-data/releases/download/0.8.1/meta_schema_20220324.json",
-    "version": "0.4.5",
+    "version": "0.5.0",
     "changelog": {
+        "0.5.0": "use detection inferer",
         "0.4.5": "fixed some small changes with formatting in readme",
         "0.4.4": "add data resource to readme",
         "0.4.3": "update val patch size to avoid warning in monai 1.0.1",

configs/train.json

@@ -399,6 +399,10 @@
             "num_workers": 2,
             "collate_fn": "$monai.data.utils.no_collation"
         },
+        "inferer": {
+            "_target_": "scripts.detection_inferer.RetinaNetInferer",
+            "detector": "@detector"
+        },
         "handlers": [
             {
                 "_target_": "StatsHandler",
@@ -435,7 +439,8 @@
             "_requires_": "@detector_ops",
             "device": "@device",
             "val_data_loader": "@validate#dataloader",
-            "detector": "@detector",
+            "network": "@network",
+            "inferer": "@validate#inferer",
             "key_val_metric": "@validate#key_metric",
             "val_handlers": "@validate#handlers",
             "amp": "@amp"

scripts/detection_inferer.py

@@ -0,0 +1,59 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, List, Union
+
+import numpy as np
+import torch
+from monai.apps.detection.networks.retinanet_detector import RetinaNetDetector
+from monai.inferers.inferer import Inferer
+from torch import Tensor
+
+
+class RetinaNetInferer(Inferer):
+    """
+    RetinaNet Inferer takes RetinaNet as input
+
+    Args:
+        detector: the RetinaNetDetector that converts network output BxCxMxN or BxCxMxNxP
+            map into boxes and classification scores.
+        args: other optional args to be passed to detector.
+        kwargs: other optional keyword args to be passed to detector.
+    """
+
+    def __init__(self, detector: RetinaNetDetector, *args, **kwargs) -> None:
+        Inferer.__init__(self)
+        self.detector = detector
+        self.sliding_window_size = None
+        if self.detector.inferer is not None:
+            if hasattr(self.detector.inferer, "roi_size"):
+                self.sliding_window_size = np.prod(self.detector.inferer.roi_size)
+
+    def __call__(self, inputs: Union[List[Tensor], Tensor], network: torch.nn.Module, *args: Any, **kwargs: Any):
+        """Unified callable function API of Inferers.
+        Args:
+            inputs: model input data for inference.
+            network: target detection network to execute inference.
+                supports callable that fullfilles requirements of network in
+                monai.apps.detection.networks.retinanet_detector.RetinaNetDetector``
+            args: optional args to be passed to ``network``.
+            kwargs: optional keyword args to be passed to ``network``.
+        """
+        self.detector.network = network
+        self.detector.training = self.detector.network.training
+
+        # if image smaller than sliding window roi size, no need to use sliding window inferer
+        # use sliding window inferer only when image is large
+        use_inferer = self.sliding_window_size is not None and not all(
+            [data_i[0, ...].numel() < self.sliding_window_size for data_i in inputs]
+        )
+
+        return self.detector(inputs, use_inferer=use_inferer, *args, **kwargs)

scripts/evaluator.py

@@ -13,19 +13,18 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple, Union
 
-import numpy as np
 import torch
+from monai.apps.detection.networks.retinanet_detector import RetinaNetDetector
 from monai.config import IgniteInfo
-from monai.engines.evaluator import Evaluator
+from monai.engines.evaluator import SupervisedEvaluator
 from monai.engines.utils import IterationEvents, default_metric_cmp_fn
-from monai.inferers import Inferer
-from monai.networks.utils import eval_mode, train_mode
 from monai.transforms import Transform
 from monai.utils import ForwardMode, min_version, optional_import
 from monai.utils.enums import CommonKeys as Keys
-from monai.utils.module import look_up_option
 from torch.utils.data import DataLoader
 
+from .detection_inferer import RetinaNetInferer
+
 if TYPE_CHECKING:
     from ignite.engine import Engine, EventEnum
     from ignite.metrics import Metric
@@ -67,17 +66,17 @@ def detection_prepare_val_batch(
     return inputs, None
 
 
-class DetectionEvaluator(Evaluator):
+class DetectionEvaluator(SupervisedEvaluator):
     """
-    Supervised detection evaluation method with image and label, inherits from ``Evaluator`` and ``Workflow``.
+    Supervised detection evaluation method with image and label, inherits from ``SupervisedEvaluator`` and ``Workflow``.
     Args:
         device: an object representing the device on which to run.
-        val_data_loader: Ignite engine use data_loader to run, must be Iterable or torch.DataLoader.
-        detector: detector to train in the trainer, should be regular PyTorch `torch.nn.Module`.
+        val_data_loader: Ignite engine use data_loader to run, must be Iterable, typically be torch.DataLoader.
+        network: detector to evaluate in the evaluator, should be regular PyTorch `torch.nn.Module`.
         epoch_length: number of iterations for one epoch, default to `len(val_data_loader)`.
         non_blocking: if True and this copy is between CPU and GPU, the copy may occur asynchronously
             with respect to the host. For other cases, this argument has no effect.
-        prepare_batch: function to parse expected data (usually `image`,`box`, `label` and other detector args)
+        prepare_batch: function to parse expected data (usually `image`, `label` and other network args)
             from `engine.state.batch` for every iteration, for more details please refer to:
             https://pytorch.org/ignite/generated/ignite.engine.create_supervised_trainer.html.
         iteration_update: the callable function for every iteration, expect to accept `engine`
@@ -117,12 +116,12 @@ class DetectionEvaluator(Evaluator):
         self,
         device: torch.device,
         val_data_loader: Iterable | DataLoader,
-        detector: torch.nn.Module,
+        network: RetinaNetDetector,
         epoch_length: int | None = None,
         non_blocking: bool = False,
         prepare_batch: Callable = detection_prepare_val_batch,
         iteration_update: Callable[[Engine, Any], Any] | None = None,
-        inferer: Inferer | None = None,
+        inferer: RetinaNetInferer | None = None,
         postprocessing: Transform | None = None,
         key_val_metric: dict[str, Metric] | None = None,
         additional_metrics: dict[str, Metric] | None = None,
@@ -139,10 +138,12 @@ class DetectionEvaluator(Evaluator):
         super().__init__(
             device=device,
             val_data_loader=val_data_loader,
+            network=network,
             epoch_length=epoch_length,
             non_blocking=non_blocking,
             prepare_batch=prepare_batch,
             iteration_update=iteration_update,
+            inferer=inferer,
             postprocessing=postprocessing,
             key_val_metric=key_val_metric,
             additional_metrics=additional_metrics,
@@ -157,16 +158,6 @@ class DetectionEvaluator(Evaluator):
             amp_kwargs=amp_kwargs,
         )
 
-        self.detector = detector
-
-        mode = look_up_option(mode, ForwardMode)
-        if mode == ForwardMode.EVAL:
-            self.mode = eval_mode
-        elif mode == ForwardMode.TRAIN:
-            self.mode = train_mode
-        else:
-            raise ValueError(f"unsupported mode: {mode}, should be 'eval' or 'train'.")
-
     def _register_decollate(self):
         """
         Register the decollate operation for batch data, will execute after model forward and loss forward.
@@ -181,48 +172,3 @@ class DetectionEvaluator(Evaluator):
                     if engine.state.output[k] is not None:
                         output_list[i][k] = engine.state.output[k][i]
             engine.state.output = output_list
-
-    def _iteration(self, engine, batchdata: dict[str, torch.Tensor]):
-        """
-        callback function for the Supervised Evaluation processing logic of 1 iteration in Ignite Engine.
-        Return below items in a dictionary:
-            - IMAGE: image Tensor data for model input, already moved to device.
-            - LABEL: label Tensor data corresponding to the image, already moved to device.
-            - PRED: prediction result of model.
-        Args:
-            engine: `SupervisedEvaluator` to execute operation for an iteration.
-            batchdata: input data for this iteration, usually can be dictionary or tuple of Tensor data.
-        Raises:
-            ValueError: When ``batchdata`` is None.
-        """
-
-        if batchdata is None:
-            raise ValueError("Must provide batch data for current iteration.")
-
-        batch = engine.prepare_batch(batchdata, engine.state.device, engine.non_blocking, **engine.to_kwargs)
-        if len(batch) == 2:
-            inputs, targets = batch
-            args: tuple = ()
-            kwargs: dict = {}
-        else:
-            inputs, targets, args, kwargs = batch
-        # put iteration outputs into engine.state
-        engine.state.output = {Keys.IMAGE: inputs, Keys.LABEL: targets}
-
-        # execute forward computation
-        sliding_window_size = np.prod(engine.detector.inferer.roi_size)
-
-        with engine.mode(engine.detector):
-
-            use_inferer = not all([val_data_i[0, ...].numel() < sliding_window_size for val_data_i in inputs])
-
-            if engine.amp:
-                with torch.cuda.amp.autocast(**engine.amp_kwargs):
-                    engine.state.output[Keys.PRED] = engine.detector(inputs, use_inferer=use_inferer)
-            else:
-                engine.state.output[Keys.PRED] = engine.detector(inputs, use_inferer=use_inferer)
-
-        engine.fire_event(IterationEvents.FORWARD_COMPLETED)
-        engine.fire_event(IterationEvents.MODEL_COMPLETED)
-
-        return engine.state.output

scripts/warmup_scheduler.py

@@ -39,6 +39,7 @@ class GradualWarmupScheduler(_LRScheduler):
         super(GradualWarmupScheduler, self).__init__(optimizer)
 
     def get_lr(self):
+        self.last_epoch = max(1, self.last_epoch)  # to avoid epoch=0 thus lr=0
         if self.last_epoch > self.total_epoch:
             if self.after_scheduler:
                 if not self.finished: