monai-weekly 1.5.dev2506__py3-none-any.whl → 1.5.dev2508__py3-none-any.whl

tests/handlers/test_handler_mlflow.py

@@ -0,0 +1,296 @@
+# 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 __future__ import annotations
+
+import glob
+import os
+import shutil
+import tempfile
+import unittest
+from concurrent.futures import ThreadPoolExecutor
+from unittest.mock import MagicMock
+
+import numpy as np
+from ignite.engine import Engine, Events
+from parameterized import parameterized
+
+from monai.apps import download_and_extract
+from monai.bundle import ConfigWorkflow, download
+from monai.handlers import MLFlowHandler
+from monai.utils import optional_import, path_to_uri
+from tests.test_utils import skip_if_downloading_fails, skip_if_quick
+
+_, has_dataset_tracking = optional_import("mlflow", "2.4.0")
+
+
+def get_event_filter(e):
+    def event_filter(_, event):
+        if event in e:
+            return True
+        return False
+
+    return event_filter
+
+
+def dummy_train(tracking_folder):
+    tempdir = tempfile.mkdtemp()
+
+    # set up engine
+    def _train_func(engine, batch):
+        return [batch + 1.0]
+
+    engine = Engine(_train_func)
+
+    # set up testing handler
+    test_path = os.path.join(tempdir, tracking_folder)
+    handler = MLFlowHandler(
+        iteration_log=False,
+        epoch_log=True,
+        tracking_uri=path_to_uri(test_path),
+        state_attributes=["test"],
+        close_on_complete=True,
+    )
+    handler.attach(engine)
+    engine.run(range(3), max_epochs=2)
+    return test_path
+
+
+class TestHandlerMLFlow(unittest.TestCase):
+    def setUp(self):
+        self.tmpdir_list = []
+
+    def tearDown(self):
+        for tmpdir in self.tmpdir_list:
+            if tmpdir and os.path.exists(tmpdir):
+                shutil.rmtree(tmpdir)
+
+    def test_multi_run(self):
+        with tempfile.TemporaryDirectory() as tempdir:
+            # set up the train function for engine
+            def _train_func(engine, batch):
+                return [batch + 1.0]
+
+            # create and run an engine several times to get several runs
+            create_engine_times = 3
+            for _ in range(create_engine_times):
+                engine = Engine(_train_func)
+
+                @engine.on(Events.EPOCH_COMPLETED)
+                def _update_metric(engine):
+                    current_metric = engine.state.metrics.get("acc", 0.1)
+                    engine.state.metrics["acc"] = current_metric + 0.1
+                    engine.state.test = current_metric
+
+                # set up testing handler
+                test_path = os.path.join(tempdir, "mlflow_test")
+                handler = MLFlowHandler(
+                    iteration_log=False,
+                    epoch_log=True,
+                    tracking_uri=path_to_uri(test_path),
+                    state_attributes=["test"],
+                    close_on_complete=True,
+                )
+                handler.attach(engine)
+                engine.run(range(3), max_epochs=2)
+                run_cnt = len(handler.client.search_runs(handler.experiment.experiment_id))
+                handler.close()
+            # the run count should equal to the times of creating engine
+            self.assertEqual(create_engine_times, run_cnt)
+
+    def test_metrics_track(self):
+        experiment_param = {"backbone": "efficientnet_b0"}
+        with tempfile.TemporaryDirectory() as tempdir:
+            # set up engine
+            def _train_func(engine, batch):
+                return [batch + 1.0]
+
+            engine = Engine(_train_func)
+
+            # set up dummy metric
+            @engine.on(Events.EPOCH_COMPLETED)
+            def _update_metric(engine):
+                current_metric = engine.state.metrics.get("acc", 0.1)
+                engine.state.metrics["acc"] = current_metric + 0.1
+                # log nested metrics
+                engine.state.metrics["acc_per_label"] = {
+                    "label_0": current_metric + 0.1,
+                    "label_1": current_metric + 0.2,
+                }
+                engine.state.test = current_metric
+
+            # set up testing handler
+            test_path = os.path.join(tempdir, "mlflow_test")
+            artifact_path = os.path.join(tempdir, "artifacts")
+            os.makedirs(artifact_path, exist_ok=True)
+            dummy_numpy = np.zeros((64, 64, 3))
+            dummy_path = os.path.join(artifact_path, "tmp.npy")
+            np.save(dummy_path, dummy_numpy)
+            handler = MLFlowHandler(
+                iteration_log=False,
+                epoch_log=True,
+                tracking_uri=path_to_uri(test_path),
+                state_attributes=["test"],
+                experiment_param=experiment_param,
+                artifacts=[artifact_path],
+                close_on_complete=False,
+            )
+            handler.attach(engine)
+            engine.run(range(3), max_epochs=2)
+            cur_run = handler.client.get_run(handler.cur_run.info.run_id)
+            self.assertTrue("label_0" in cur_run.data.metrics.keys())
+            handler.close()
+            # check logging output
+            self.assertTrue(len(glob.glob(test_path)) > 0)
+
+    @parameterized.expand([[True], [get_event_filter([1, 2])]])
+    def test_metrics_track_mock(self, epoch_log):
+        experiment_param = {"backbone": "efficientnet_b0"}
+        with tempfile.TemporaryDirectory() as tempdir:
+            # set up engine
+            def _train_func(engine, batch):
+                return [batch + 1.0]
+
+            engine = Engine(_train_func)
+
+            # set up dummy metric
+            @engine.on(Events.EPOCH_COMPLETED)
+            def _update_metric(engine):
+                current_metric = engine.state.metrics.get("acc", 0.1)
+                engine.state.metrics["acc"] = current_metric + 0.1
+                engine.state.test = current_metric
+
+            # set up testing handler
+            test_path = os.path.join(tempdir, "mlflow_test")
+            handler = MLFlowHandler(
+                iteration_log=False,
+                epoch_log=epoch_log,
+                tracking_uri=path_to_uri(test_path),
+                state_attributes=["test"],
+                experiment_param=experiment_param,
+                close_on_complete=True,
+            )
+            handler._default_epoch_log = MagicMock()
+            handler.attach(engine)
+
+            max_epochs = 4
+            engine.run(range(3), max_epochs=max_epochs)
+            handler.close()
+            # check logging output
+            if epoch_log is True:
+                self.assertEqual(handler._default_epoch_log.call_count, max_epochs)
+            else:
+                self.assertEqual(handler._default_epoch_log.call_count, 2)  # 2 = len([1, 2]) from event_filter
+
+    @parameterized.expand([[True], [get_event_filter([1, 3])]])
+    def test_metrics_track_iters_mock(self, iteration_log):
+        experiment_param = {"backbone": "efficientnet_b0"}
+        with tempfile.TemporaryDirectory() as tempdir:
+            # set up engine
+            def _train_func(engine, batch):
+                return [batch + 1.0]
+
+            engine = Engine(_train_func)
+
+            # set up dummy metric
+            @engine.on(Events.EPOCH_COMPLETED)
+            def _update_metric(engine):
+                current_metric = engine.state.metrics.get("acc", 0.1)
+                engine.state.metrics["acc"] = current_metric + 0.1
+                engine.state.test = current_metric
+
+            # set up testing handler
+            test_path = os.path.join(tempdir, "mlflow_test")
+            handler = MLFlowHandler(
+                iteration_log=iteration_log,
+                epoch_log=False,
+                tracking_uri=path_to_uri(test_path),
+                state_attributes=["test"],
+                experiment_param=experiment_param,
+                close_on_complete=True,
+            )
+            handler._default_iteration_log = MagicMock()
+            handler.attach(engine)
+
+            num_iters = 3
+            max_epochs = 2
+            engine.run(range(num_iters), max_epochs=max_epochs)
+            handler.close()
+            # check logging output
+            if iteration_log is True:
+                self.assertEqual(handler._default_iteration_log.call_count, num_iters * max_epochs)
+            else:
+                self.assertEqual(handler._default_iteration_log.call_count, 2)  # 2 = len([1, 3]) from event_filter
+
+    def test_multi_thread(self):
+        test_uri_list = ["monai_mlflow_test1", "monai_mlflow_test2"]
+        with ThreadPoolExecutor(2, "Training") as executor:
+            futures = {}
+            for t in test_uri_list:
+                futures[t] = executor.submit(dummy_train, t)
+
+            for _, future in futures.items():
+                res = future.result()
+                self.tmpdir_list.append(res)
+                self.assertTrue(len(glob.glob(res)) > 0)
+
+    @skip_if_quick
+    @unittest.skipUnless(has_dataset_tracking, reason="Requires mlflow version >= 2.4.0.")
+    def test_dataset_tracking(self):
+        test_bundle_name = "endoscopic_tool_segmentation"
+        with tempfile.TemporaryDirectory() as tempdir:
+            resource = "https://github.com/Project-MONAI/MONAI-extra-test-data/releases/download/0.8.1/endoscopic_tool_dataset.zip"
+            md5 = "f82da47259c0a617202fb54624798a55"
+            compressed_file = os.path.join(tempdir, "endoscopic_tool_segmentation.zip")
+            data_dir = os.path.join(tempdir, "endoscopic_tool_dataset")
+            with skip_if_downloading_fails():
+                if not os.path.exists(data_dir):
+                    download_and_extract(resource, compressed_file, tempdir, md5)
+
+                download(test_bundle_name, bundle_dir=tempdir)
+
+                bundle_root = os.path.join(tempdir, test_bundle_name)
+                config_file = os.path.join(bundle_root, "configs/inference.json")
+                meta_file = os.path.join(bundle_root, "configs/metadata.json")
+                logging_file = os.path.join(bundle_root, "configs/logging.conf")
+                workflow = ConfigWorkflow(
+                    workflow_type="infer",
+                    config_file=config_file,
+                    meta_file=meta_file,
+                    logging_file=logging_file,
+                    init_id="initialize",
+                    run_id="run",
+                    final_id="finalize",
+                )
+
+                tracking_path = os.path.join(bundle_root, "eval")
+                workflow.bundle_root = bundle_root
+                workflow.dataset_dir = data_dir
+                workflow.initialize()
+                infer_dataset = workflow.dataset
+                mlflow_handler = MLFlowHandler(
+                    iteration_log=False,
+                    epoch_log=False,
+                    dataset_dict={"test": infer_dataset},
+                    tracking_uri=path_to_uri(tracking_path),
+                )
+                mlflow_handler.attach(workflow.evaluator)
+                workflow.run()
+                workflow.finalize()
+
+                cur_run = mlflow_handler.client.get_run(mlflow_handler.cur_run.info.run_id)
+                logged_nontrain_set = [x for x in cur_run.inputs.dataset_inputs if x.dataset.name.startswith("test")]
+                self.assertEqual(len(logged_nontrain_set), 1)
+                mlflow_handler.close()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/handlers/test_handler_nvtx.py

@@ -0,0 +1,93 @@
+# 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 __future__ import annotations
+
+import unittest
+
+import torch
+from ignite.engine import Events
+from parameterized import parameterized
+
+from monai.engines import SupervisedEvaluator
+from monai.handlers import StatsHandler, from_engine
+from monai.handlers.nvtx_handlers import MarkHandler, RangeHandler, RangePopHandler, RangePushHandler
+from monai.utils import optional_import
+from tests.test_utils import assert_allclose
+
+_, has_nvtx = optional_import("torch._C._nvtx", descriptor="NVTX is not installed. Are you sure you have a CUDA build?")
+
+TENSOR_0 = torch.tensor([[[[1.0], [2.0]], [[3.0], [4.0]]]])
+
+TENSOR_1 = torch.tensor([[[[0.0], [-2.0]], [[-3.0], [4.0]]]])
+
+TENSOR_1_EXPECTED = torch.tensor([[[1.0], [0.5]], [[0.25], [5.0]]])
+
+TEST_CASE_0 = [[{"image": TENSOR_0}], TENSOR_0[0] + 1.0]
+TEST_CASE_1 = [[{"image": TENSOR_1}], TENSOR_1_EXPECTED]
+
+
+class TestHandlerDecollateBatch(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_0, TEST_CASE_1])
+    @unittest.skipUnless(has_nvtx, "CUDA is required for NVTX!")
+    def test_compute(self, data, expected):
+        # Set up handlers
+        handlers = [
+            # Mark with Ignite Event
+            MarkHandler(Events.STARTED),
+            # Mark with literal
+            MarkHandler("EPOCH_STARTED"),
+            # Mark with literal and providing the message
+            MarkHandler("EPOCH_STARTED", "Start of the epoch"),
+            # Define a range using one prefix (between BATCH_STARTED and BATCH_COMPLETED)
+            RangeHandler("Batch"),
+            # Define a range using a pair of events
+            RangeHandler((Events.STARTED, Events.COMPLETED)),
+            # Define a range using a pair of literals
+            RangeHandler(("GET_BATCH_STARTED", "GET_BATCH_COMPLETED"), msg="Batching!"),
+            # Define a range using a pair of literal and events
+            RangeHandler(("GET_BATCH_STARTED", Events.COMPLETED)),
+            # Define the start of range using literal
+            RangePushHandler("ITERATION_STARTED"),
+            # Define the start of range using event
+            RangePushHandler(Events.ITERATION_STARTED, "Iteration 2"),
+            # Define the start of range using literals and providing message
+            RangePushHandler("EPOCH_STARTED", "Epoch 2"),
+            # Define the end of range using Ignite Event
+            RangePopHandler(Events.ITERATION_COMPLETED),
+            RangePopHandler(Events.EPOCH_COMPLETED),
+            # Define the end of range using literal
+            RangePopHandler("ITERATION_COMPLETED"),
+            # Other handlers
+            StatsHandler(tag_name="train", output_transform=from_engine(["label"], first=True)),
+        ]
+
+        # Set up an engine
+        engine = SupervisedEvaluator(
+            device=torch.device("cpu:0"),
+            val_data_loader=data,
+            epoch_length=1,
+            network=torch.nn.PReLU(),
+            postprocessing=lambda x: dict(pred=x["pred"] + 1.0),
+            decollate=True,
+            val_handlers=handlers,
+        )
+        # Run the engine
+        engine.run()
+
+        # Get the output from the engine
+        output = engine.state.output[0]
+
+        assert_allclose(output["pred"], expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/handlers/test_handler_panoptic_quality.py

@@ -0,0 +1,89 @@
+# 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 __future__ import annotations
+
+import unittest
+
+import torch
+from ignite.engine import Engine, Events
+from parameterized import parameterized
+
+from monai.handlers import PanopticQuality, from_engine
+from tests.test_utils import SkipIfNoModule, assert_allclose
+
+sample_1_pred = torch.as_tensor(
+    [[[0, 1, 1, 1], [0, 0, 5, 5], [2, 0, 3, 3], [2, 2, 2, 0]], [[0, 1, 1, 1], [0, 0, 0, 0], [2, 0, 3, 3], [4, 2, 2, 0]]]
+)
+
+sample_1_gt = torch.as_tensor(
+    [[[0, 6, 6, 6], [1, 0, 5, 5], [1, 0, 3, 3], [1, 3, 2, 0]], [[0, 1, 1, 1], [0, 0, 1, 1], [2, 0, 3, 3], [4, 4, 4, 3]]]
+)
+
+sample_2_pred = torch.as_tensor(
+    [[[3, 1, 1, 1], [3, 1, 1, 4], [3, 1, 4, 4], [3, 2, 2, 4]], [[0, 1, 1, 1], [2, 2, 2, 2], [2, 0, 0, 3], [4, 2, 2, 3]]]
+)
+
+sample_2_gt = torch.as_tensor(
+    [[[0, 6, 6, 6], [1, 0, 5, 5], [1, 0, 3, 3], [1, 3, 2, 0]], [[0, 1, 1, 1], [2, 1, 1, 3], [2, 0, 0, 3], [4, 2, 2, 3]]]
+)
+
+TEST_CASE_1 = [{"num_classes": 4, "output_transform": from_engine(["pred", "label"])}, [0.6667, 0.1538, 0.6667, 0.5714]]
+TEST_CASE_2 = [
+    {
+        "num_classes": 5,
+        "output_transform": from_engine(["pred", "label"]),
+        "metric_name": "rq",
+        "match_iou_threshold": 0.3,
+    },
+    [0.6667, 0.7692, 0.8889, 0.5714, 0.0000],
+]
+TEST_CASE_3 = [
+    {
+        "num_classes": 5,
+        "reduction": "mean",
+        "output_transform": from_engine(["pred", "label"]),
+        "metric_name": "SQ",
+        "match_iou_threshold": 0.2,
+    },
+    0.8235,
+]
+
+
+@SkipIfNoModule("scipy.optimize")
+class TestHandlerPanopticQuality(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+    def test_compute(self, input_params, expected_avg):
+        metric = PanopticQuality(**input_params)
+
+        # set up engine
+
+        def _val_func(engine, batch):
+            pass
+
+        engine = Engine(_val_func)
+        metric.attach(engine=engine, name="panoptic_quality")
+        # test input a list of channel-first tensor
+        y_pred = [sample_1_pred, sample_2_pred]
+        y = [sample_1_gt, sample_2_gt]
+        engine.state.output = {"pred": y_pred, "label": y}
+        engine.fire_event(Events.ITERATION_COMPLETED)
+        y_pred = [sample_1_pred, sample_1_pred]
+        y = [sample_1_gt, sample_1_gt]
+        engine.state.output = {"pred": y_pred, "label": y}
+        engine.fire_event(Events.ITERATION_COMPLETED)
+
+        engine.fire_event(Events.EPOCH_COMPLETED)
+        assert_allclose(engine.state.metrics["panoptic_quality"], expected_avg, atol=1e-4, rtol=1e-4, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/handlers/test_handler_parameter_scheduler.py

@@ -0,0 +1,136 @@
+# 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 __future__ import annotations
+
+import unittest
+
+from ignite.engine import Engine, Events
+from torch.nn import Module
+
+from monai.handlers.parameter_scheduler import ParamSchedulerHandler
+from tests.test_utils import assert_allclose
+
+
+class ToyNet(Module):
+    def __init__(self, value):
+        super().__init__()
+        self.value = value
+
+    def forward(self, input):
+        return input
+
+    def get_value(self):
+        return self.value
+
+    def set_value(self, value):
+        self.value = value
+
+
+class TestHandlerParameterScheduler(unittest.TestCase):
+    def test_linear_scheduler(self):
+        # Testing step_constant
+        net = ToyNet(value=-1)
+        engine = Engine(lambda e, b: None)
+        ParamSchedulerHandler(
+            parameter_setter=net.set_value,
+            value_calculator="linear",
+            vc_kwargs={"initial_value": 0, "step_constant": 2, "step_max_value": 5, "max_value": 10},
+            epoch_level=True,
+            event=Events.EPOCH_COMPLETED,
+        ).attach(engine)
+        engine.run([0] * 8, max_epochs=2)
+        assert_allclose(net.get_value(), 0)
+
+        # Testing linear increase
+        net = ToyNet(value=-1)
+        engine = Engine(lambda e, b: None)
+        ParamSchedulerHandler(
+            parameter_setter=net.set_value,
+            value_calculator="linear",
+            vc_kwargs={"initial_value": 0, "step_constant": 2, "step_max_value": 5, "max_value": 10},
+            epoch_level=True,
+            event=Events.EPOCH_COMPLETED,
+        ).attach(engine)
+        engine.run([0] * 8, max_epochs=3)
+        assert_allclose(net.get_value(), 3.333333, atol=0.001, rtol=0.0)
+
+        # Testing max_value
+        net = ToyNet(value=-1)
+        engine = Engine(lambda e, b: None)
+        ParamSchedulerHandler(
+            parameter_setter=net.set_value,
+            value_calculator="linear",
+            vc_kwargs={"initial_value": 0, "step_constant": 2, "step_max_value": 5, "max_value": 10},
+            epoch_level=True,
+            event=Events.EPOCH_COMPLETED,
+        ).attach(engine)
+        engine.run([0] * 8, max_epochs=10)
+        assert_allclose(net.get_value(), 10)
+
+    def test_exponential_scheduler(self):
+        net = ToyNet(value=-1)
+        engine = Engine(lambda e, b: None)
+        ParamSchedulerHandler(
+            parameter_setter=net.set_value,
+            value_calculator="exponential",
+            vc_kwargs={"initial_value": 10, "gamma": 0.99},
+            epoch_level=True,
+            event=Events.EPOCH_COMPLETED,
+        ).attach(engine)
+        engine.run([0] * 8, max_epochs=2)
+        assert_allclose(net.get_value(), 10 * 0.99 * 0.99)
+
+    def test_step_scheduler(self):
+        net = ToyNet(value=-1)
+        engine = Engine(lambda e, b: None)
+        ParamSchedulerHandler(
+            parameter_setter=net.set_value,
+            value_calculator="step",
+            vc_kwargs={"initial_value": 10, "gamma": 0.99, "step_size": 5},
+            epoch_level=True,
+            event=Events.EPOCH_COMPLETED,
+        ).attach(engine)
+        engine.run([0] * 8, max_epochs=10)
+        assert_allclose(net.get_value(), 10 * 0.99 * 0.99)
+
+    def test_multistep_scheduler(self):
+        net = ToyNet(value=-1)
+        engine = Engine(lambda e, b: None)
+        ParamSchedulerHandler(
+            parameter_setter=net.set_value,
+            value_calculator="multistep",
+            vc_kwargs={"initial_value": 10, "gamma": 0.99, "milestones": [3, 6]},
+            epoch_level=True,
+            event=Events.EPOCH_COMPLETED,
+        ).attach(engine)
+        engine.run([0] * 8, max_epochs=10)
+        assert_allclose(net.get_value(), 10 * 0.99 * 0.99)
+
+    def test_custom_scheduler(self):
+        def custom_logic(initial_value, gamma, current_step):
+            return initial_value * gamma ** (current_step % 9)
+
+        net = ToyNet(value=-1)
+        engine = Engine(lambda e, b: None)
+        ParamSchedulerHandler(
+            parameter_setter=net.set_value,
+            value_calculator=custom_logic,
+            vc_kwargs={"initial_value": 10, "gamma": 0.99},
+            epoch_level=True,
+            event=Events.EPOCH_COMPLETED,
+        ).attach(engine)
+        engine.run([0] * 8, max_epochs=2)
+        assert_allclose(net.get_value(), 10 * 0.99 * 0.99)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/handlers/test_handler_post_processing.py

@@ -0,0 +1,74 @@
+# 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 __future__ import annotations
+
+import unittest
+
+import torch
+from parameterized import parameterized
+
+from monai.engines import SupervisedEvaluator
+from monai.handlers import PostProcessing
+from monai.transforms import Activationsd, AsDiscreted, Compose, CopyItemsd
+from tests.test_utils import assert_allclose
+
+# test lambda function as `transform`
+TEST_CASE_1 = [{"transform": lambda x: dict(pred=x["pred"] + 1.0)}, False, torch.tensor([[[[1.9975], [1.9997]]]])]
+# test composed postprocessing transforms as `transform`
+TEST_CASE_2 = [
+    {
+        "transform": Compose(
+            [
+                CopyItemsd(keys="filename", times=1, names="filename_bak"),
+                AsDiscreted(keys="pred", threshold=0.5, to_onehot=2),
+            ]
+        ),
+        "event": "iteration_completed",
+    },
+    True,
+    torch.tensor([[[[1.0], [1.0]], [[0.0], [0.0]]]]),
+]
+
+
+class TestHandlerPostProcessing(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2])
+    def test_compute(self, input_params, decollate, expected):
+        data = [
+            {"image": torch.tensor([[[[2.0], [3.0]]]]), "filename": ["test1"]},
+            {"image": torch.tensor([[[[6.0], [8.0]]]]), "filename": ["test2"]},
+        ]
+        # set up engine, PostProcessing handler works together with postprocessing transforms of engine
+        engine = SupervisedEvaluator(
+            device=torch.device("cpu:0"),
+            val_data_loader=data,
+            epoch_length=2,
+            network=torch.nn.PReLU(),
+            postprocessing=Compose([Activationsd(keys="pred", sigmoid=True)]),
+            val_handlers=[PostProcessing(**input_params)],
+            decollate=decollate,
+        )
+        engine.run()
+
+        if isinstance(engine.state.output, list):
+            # test decollated list items
+            for o, e in zip(engine.state.output, expected):
+                assert_allclose(o["pred"], e, atol=1e-4, rtol=1e-4, type_test=False)
+                filename = o.get("filename_bak")
+                if filename is not None:
+                    self.assertEqual(filename, "test2")
+        else:
+            # test batch data
+            assert_allclose(engine.state.output["pred"], expected, atol=1e-4, rtol=1e-4, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()