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

tests/integration/test_auto3dseg_ensemble.py

@@ -0,0 +1,211 @@
+# 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 os
+import tempfile
+import unittest
+
+import nibabel as nib
+import numpy as np
+import torch
+
+from monai.apps.auto3dseg import (
+    AlgoEnsembleBestByFold,
+    AlgoEnsembleBestN,
+    AlgoEnsembleBuilder,
+    BundleGen,
+    DataAnalyzer,
+    EnsembleRunner,
+)
+from monai.bundle.config_parser import ConfigParser
+from monai.data import create_test_image_3d
+from monai.transforms import SaveImage
+from monai.utils import check_parent_dir, optional_import, set_determinism
+from monai.utils.enums import AlgoKeys
+from tests.test_utils import (
+    SkipIfBeforePyTorchVersion,
+    get_testing_algo_template_path,
+    skip_if_downloading_fails,
+    skip_if_no_cuda,
+    skip_if_quick,
+)
+
+_, has_tb = optional_import("torch.utils.tensorboard", name="SummaryWriter")
+
+num_images_perfold = max(torch.cuda.device_count(), 4)
+num_images_per_batch = 2
+
+fake_datalist: dict[str, list[dict]] = {
+    "testing": [{"image": f"imagesTs/ts_image_{idx:03d}.nii.gz"} for idx in range(num_images_perfold)],
+    "training": [
+        {
+            "fold": f,
+            "image": f"imagesTr/tr_image_{(f * num_images_perfold + idx):03d}.nii.gz",
+            "label": f"labelsTr/tr_label_{(f * num_images_perfold + idx):03d}.nii.gz",
+        }
+        for f in range(num_images_per_batch + 1)
+        for idx in range(num_images_perfold)
+    ],
+}
+
+train_param = (
+    {
+        "num_images_per_batch": num_images_per_batch,
+        "num_epochs": 2,
+        "num_epochs_per_validation": 1,
+        "num_warmup_epochs": 1,
+        "use_pretrain": False,
+        "pretrained_path": "",
+        "determ": True,
+    }
+    if torch.cuda.is_available()
+    else {}
+)
+
+pred_param = {
+    "files_slices": slice(0, 1),
+    "mode": "mean",
+    "sigmoid": True,
+    "algo_spec_params": {"segresnet": {"network#init_filters": 8}, "swinunetr": {"network#feature_size": 12}},
+}
+
+
+def create_sim_data(dataroot, sim_datalist, sim_dim, **kwargs):
+    """
+    Create simulated data using create_test_image_3d.
+
+    Args:
+        dataroot: data directory path that hosts the "nii.gz" image files.
+        sim_datalist: a list of data to create.
+        sim_dim: the image sizes, e.g. a tuple of (64, 64, 64).
+    """
+    if not os.path.isdir(dataroot):
+        os.makedirs(dataroot)
+
+    # Generate a fake dataset
+    for d in sim_datalist["testing"] + sim_datalist["training"]:
+        im, seg = create_test_image_3d(sim_dim[0], sim_dim[1], sim_dim[2], **kwargs)
+        nib_image = nib.Nifti1Image(im, affine=np.eye(4))
+        image_fpath = os.path.join(dataroot, d["image"])
+        check_parent_dir(image_fpath)
+        nib.save(nib_image, image_fpath)
+
+        if "label" in d:
+            nib_image = nib.Nifti1Image(seg, affine=np.eye(4))
+            label_fpath = os.path.join(dataroot, d["label"])
+            check_parent_dir(label_fpath)
+            nib.save(nib_image, label_fpath)
+
+
+@skip_if_quick
+@skip_if_no_cuda
+@SkipIfBeforePyTorchVersion((1, 11, 1))
+@unittest.skipIf(not has_tb, "no tensorboard summary writer")
+class TestEnsembleBuilder(unittest.TestCase):
+    def setUp(self) -> None:
+        set_determinism(0)
+        self.test_dir = tempfile.TemporaryDirectory()
+        test_path = self.test_dir.name
+
+        dataroot = os.path.join(test_path, "dataroot")
+        work_dir = os.path.join(test_path, "workdir")
+
+        da_output_yaml = os.path.join(work_dir, "datastats.yaml")
+        data_src_cfg = os.path.join(work_dir, "data_src_cfg.yaml")
+
+        if not os.path.isdir(work_dir):
+            os.makedirs(work_dir)
+
+        create_sim_data(dataroot, fake_datalist, (24, 24, 24), rad_max=10, rad_min=1, num_seg_classes=1)
+
+        # write to a json file
+        fake_json_datalist = os.path.join(dataroot, "fake_input.json")
+        ConfigParser.export_config_file(fake_datalist, fake_json_datalist)
+
+        da = DataAnalyzer(fake_json_datalist, dataroot, output_path=da_output_yaml)
+        da.get_all_case_stats()
+
+        data_src = {
+            "name": "fake_data",
+            "task": "segmentation",
+            "modality": "MRI",
+            "datalist": fake_json_datalist,
+            "dataroot": dataroot,
+            "multigpu": False,
+            "class_names": ["label_class"],
+        }
+
+        ConfigParser.export_config_file(data_src, data_src_cfg)
+
+        self.da_output_yaml = da_output_yaml
+        self.work_dir = work_dir
+        self.data_src_cfg_name = data_src_cfg
+
+    def test_ensemble(self) -> None:
+        with skip_if_downloading_fails():
+            bundle_generator = BundleGen(
+                algo_path=self.work_dir,
+                data_stats_filename=self.da_output_yaml,
+                data_src_cfg_name=self.data_src_cfg_name,
+                templates_path_or_url=get_testing_algo_template_path(),
+            )
+        bundle_generator.generate(self.work_dir, num_fold=1)
+        history = bundle_generator.get_history()
+
+        for algo_dict in history:
+            name = algo_dict[AlgoKeys.ID]
+            algo = algo_dict[AlgoKeys.ALGO]
+            _train_param = train_param.copy()
+            if name.startswith("segresnet"):
+                _train_param["network#init_filters"] = 8
+                _train_param["pretrained_ckpt_name"] = ""
+            elif name.startswith("swinunetr"):
+                _train_param["network#feature_size"] = 12
+            algo.train(_train_param)
+
+        builder = AlgoEnsembleBuilder(history, data_src_cfg_name=self.data_src_cfg_name)
+        builder.set_ensemble_method(AlgoEnsembleBestN(n_best=1))
+        ensemble = builder.get_ensemble()
+        preds = ensemble(pred_param)
+        self.assertTupleEqual(preds[0].shape, (2, 24, 24, 24))
+
+        builder.set_ensemble_method(AlgoEnsembleBestByFold(1))
+        ensemble = builder.get_ensemble()
+        for algo in ensemble.get_algo_ensemble():
+            print(algo[AlgoKeys.ID])
+
+    def test_ensemble_runner(self) -> None:
+        runner = EnsembleRunner(data_src_cfg_name=self.data_src_cfg_name, mgpu=False)
+        runner.set_num_fold(3)
+        self.assertTrue(runner.num_fold == 3)
+        runner.set_ensemble_method(ensemble_method_name="AlgoEnsembleBestByFold")
+        self.assertIsInstance(runner.ensemble_method, AlgoEnsembleBestByFold)
+        self.assertTrue(runner.ensemble_method.n_fold == 3)  # type: ignore
+
+        runner.set_ensemble_method(ensemble_method_name="AlgoEnsembleBestN", n_best=3)
+        self.assertIsInstance(runner.ensemble_method, AlgoEnsembleBestN)
+        self.assertTrue(runner.ensemble_method.n_best == 3)
+
+        save_output = os.path.join(self.test_dir.name, "workdir")
+        save_image = runner._pop_kwargs_to_get_image_save_transform(
+            output_dir=save_output, output_postfix="test_ensemble", output_dtype=float, resample=True
+        )
+        self.assertIsInstance(ConfigParser(save_image).get_parsed_content(), SaveImage)
+
+    def tearDown(self) -> None:
+        set_determinism(None)
+        self.test_dir.cleanup()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_auto3dseg_hpo.py

@@ -0,0 +1,189 @@
+# 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 os
+import tempfile
+import unittest
+from functools import partial
+
+import nibabel as nib
+import numpy as np
+import torch
+
+from monai.apps.auto3dseg import BundleGen, DataAnalyzer, NNIGen, OptunaGen, import_bundle_algo_history
+from monai.bundle.config_parser import ConfigParser
+from monai.data import create_test_image_3d
+from monai.utils import optional_import
+from monai.utils.enums import AlgoKeys
+from tests.test_utils import (
+    SkipIfBeforePyTorchVersion,
+    get_testing_algo_template_path,
+    skip_if_downloading_fails,
+    skip_if_no_cuda,
+)
+
+_, has_tb = optional_import("torch.utils.tensorboard", name="SummaryWriter")
+optuna, has_optuna = optional_import("optuna")
+
+override_param = (
+    {
+        "num_images_per_batch": 2,
+        "num_epochs": 2,
+        "num_epochs_per_validation": 1,
+        "num_warmup_epochs": 1,
+        "use_pretrain": False,
+        "pretrained_path": "",
+        "auto_scale_allowed": False,
+    }
+    if torch.cuda.is_available()
+    else {}
+)
+
+
+def skip_if_no_optuna(obj):
+    """
+    Skip the unit tests if torch.cuda.is_available is False.
+    """
+    return unittest.skipUnless(has_optuna, "Skipping optuna tests")(obj)
+
+
+fake_datalist: dict[str, list[dict]] = {
+    "testing": [{"image": "val_001.fake.nii.gz"}, {"image": "val_002.fake.nii.gz"}],
+    "training": [
+        {"fold": 0, "image": "tr_image_001.fake.nii.gz", "label": "tr_label_001.fake.nii.gz"},
+        {"fold": 0, "image": "tr_image_002.fake.nii.gz", "label": "tr_label_002.fake.nii.gz"},
+        {"fold": 0, "image": "tr_image_003.fake.nii.gz", "label": "tr_label_003.fake.nii.gz"},
+        {"fold": 0, "image": "tr_image_004.fake.nii.gz", "label": "tr_label_004.fake.nii.gz"},
+        {"fold": 1, "image": "tr_image_005.fake.nii.gz", "label": "tr_label_005.fake.nii.gz"},
+        {"fold": 1, "image": "tr_image_006.fake.nii.gz", "label": "tr_label_006.fake.nii.gz"},
+        {"fold": 1, "image": "tr_image_007.fake.nii.gz", "label": "tr_label_007.fake.nii.gz"},
+        {"fold": 1, "image": "tr_image_008.fake.nii.gz", "label": "tr_label_008.fake.nii.gz"},
+        {"fold": 2, "image": "tr_image_009.fake.nii.gz", "label": "tr_label_009.fake.nii.gz"},
+        {"fold": 2, "image": "tr_image_010.fake.nii.gz", "label": "tr_label_010.fake.nii.gz"},
+        {"fold": 2, "image": "tr_image_011.fake.nii.gz", "label": "tr_label_011.fake.nii.gz"},
+        {"fold": 2, "image": "tr_image_012.fake.nii.gz", "label": "tr_label_012.fake.nii.gz"},
+    ],
+}
+
+
+@SkipIfBeforePyTorchVersion((1, 11, 1))
+@unittest.skipIf(not has_tb, "no tensorboard summary writer")
+class TestHPO(unittest.TestCase):
+    def setUp(self) -> None:
+        self.test_dir = tempfile.TemporaryDirectory()
+        test_path = self.test_dir.name
+
+        work_dir = os.path.abspath(os.path.join(test_path, "workdir"))
+        dataroot = os.path.join(work_dir, "dataroot")
+
+        da_output_yaml = os.path.join(work_dir, "datastats.yaml")
+        data_src_cfg = os.path.join(work_dir, "data_src_cfg.yaml")
+
+        if not os.path.isdir(dataroot):
+            os.makedirs(dataroot)
+
+        if not os.path.isdir(work_dir):
+            os.makedirs(work_dir)
+
+        # Generate a fake dataset
+        for d in fake_datalist["testing"] + fake_datalist["training"]:
+            im, seg = create_test_image_3d(24, 24, 24, rad_max=10, num_seg_classes=1)
+            nib_image = nib.Nifti1Image(im, affine=np.eye(4))
+            image_fpath = os.path.join(dataroot, d["image"])
+            nib.save(nib_image, image_fpath)
+
+            if "label" in d:
+                nib_image = nib.Nifti1Image(seg, affine=np.eye(4))
+                label_fpath = os.path.join(dataroot, d["label"])
+                nib.save(nib_image, label_fpath)
+
+        # write to a json file
+        fake_json_datalist = os.path.join(dataroot, "fake_input.json")
+        ConfigParser.export_config_file(fake_datalist, fake_json_datalist)
+
+        da = DataAnalyzer(fake_json_datalist, dataroot, output_path=da_output_yaml)
+        da.get_all_case_stats()
+
+        data_src = {
+            "name": "fake_data",
+            "task": "segmentation",
+            "modality": "MRI",
+            "datalist": fake_json_datalist,
+            "dataroot": dataroot,
+            "multigpu": False,
+            "class_names": ["label_class"],
+        }
+
+        ConfigParser.export_config_file(data_src, data_src_cfg)
+        with skip_if_downloading_fails():
+            bundle_generator = BundleGen(
+                algo_path=work_dir,
+                data_stats_filename=da_output_yaml,
+                data_src_cfg_name=data_src_cfg,
+                templates_path_or_url=get_testing_algo_template_path(),
+            )
+        bundle_generator.generate(work_dir, num_fold=1)
+
+        self.history = bundle_generator.get_history()
+        self.work_dir = work_dir
+        self.test_path = test_path
+
+    @skip_if_no_cuda
+    def test_run_algo(self) -> None:
+        algo_dict = self.history[-1]
+        algo = algo_dict[AlgoKeys.ALGO]
+        nni_gen = NNIGen(algo=algo, params=override_param)
+        obj_filename = nni_gen.get_obj_filename()
+        # this function will be used in HPO via Python Fire
+        NNIGen().run_algo(obj_filename, self.work_dir)
+
+    @skip_if_no_cuda
+    @skip_if_no_optuna
+    def test_run_optuna(self) -> None:
+        algo_dict = self.history[-1]
+        algo = algo_dict[AlgoKeys.ALGO]
+
+        class OptunaGenLearningRate(OptunaGen):
+            def get_hyperparameters(self):
+                return {"learning_rate": self.trial.suggest_float("learning_rate", 0.00001, 0.1)}
+
+        optuna_gen = OptunaGenLearningRate(algo=algo, params=override_param)
+        search_space = {"learning_rate": [0.0001, 0.001, 0.01, 0.1]}
+        study = optuna.create_study(sampler=optuna.samplers.GridSampler(search_space), direction="maximize")
+        study.optimize(
+            partial(
+                optuna_gen,
+                obj_filename=optuna_gen.get_obj_filename(),
+                output_folder=os.path.join(self.test_path, "optuna_test"),
+            ),
+            n_trials=2,
+        )
+        print(f"Best value: {study.best_value} (params: {study.best_params})\n")
+
+    @skip_if_no_cuda
+    def test_get_history(self) -> None:
+        algo_dict = self.history[-1]
+        algo = algo_dict[AlgoKeys.ALGO]
+        nni_gen = NNIGen(algo=algo, params=override_param)
+        obj_filename = nni_gen.get_obj_filename()
+
+        NNIGen().run_algo(obj_filename, self.work_dir)
+        history = import_bundle_algo_history(self.work_dir, only_trained=True)
+        assert len(history) == 1
+
+    def tearDown(self) -> None:
+        self.test_dir.cleanup()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_deepedit_interaction.py

@@ -0,0 +1,122 @@
+# 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 numpy as np
+import torch
+
+from monai.apps.deepedit.interaction import Interaction
+from monai.apps.deepedit.transforms import (
+    AddGuidanceSignalDeepEditd,
+    AddInitialSeedPointMissingLabelsd,
+    AddRandomGuidanceDeepEditd,
+    FindAllValidSlicesMissingLabelsd,
+    FindDiscrepancyRegionsDeepEditd,
+    SplitPredsLabeld,
+)
+from monai.data import DataLoader, Dataset
+from monai.engines import SupervisedTrainer
+from monai.engines.utils import IterationEvents
+from monai.losses import DiceCELoss
+from monai.transforms import Activationsd, AsDiscreted, Compose, ToTensord
+
+
+def add_one(engine):
+    if engine.state.best_metric == -1:
+        engine.state.best_metric = 0
+    else:
+        engine.state.best_metric = engine.state.best_metric + 1
+
+
+class TestInteractions(unittest.TestCase):
+
+    def run_interaction(self, train):
+        label_names = {"spleen": 1, "background": 0}
+        np.random.seed(0)
+        data = [
+            {
+                "image": np.random.randint(0, 256, size=(1, 15, 15, 15)).astype(np.float32),
+                "label": np.random.randint(0, 2, size=(1, 15, 15, 15)),
+                "label_names": label_names,
+            }
+            for _ in range(5)
+        ]
+        network = torch.nn.Conv3d(3, len(label_names), 1)
+        lr = 1e-3
+        opt = torch.optim.Adam(network.parameters(), lr)
+        loss = DiceCELoss(to_onehot_y=True, softmax=True)
+        pre_transforms = Compose(
+            [
+                FindAllValidSlicesMissingLabelsd(keys="label", sids="sids"),
+                AddInitialSeedPointMissingLabelsd(keys="label", guidance="guidance", sids="sids"),
+                AddGuidanceSignalDeepEditd(keys="image", guidance="guidance", number_intensity_ch=1),
+                ToTensord(keys=("image", "label")),
+            ]
+        )
+        dataset = Dataset(data, transform=pre_transforms)
+        data_loader = DataLoader(dataset, batch_size=5)
+
+        iteration_transforms = [
+            FindDiscrepancyRegionsDeepEditd(keys="label", pred="pred", discrepancy="discrepancy"),
+            AddRandomGuidanceDeepEditd(
+                keys="NA", guidance="guidance", discrepancy="discrepancy", probability="probability"
+            ),
+            AddGuidanceSignalDeepEditd(keys="image", guidance="guidance", number_intensity_ch=1),
+            ToTensord(keys=("image", "label")),
+        ]
+        post_transforms = [
+            Activationsd(keys="pred", softmax=True),
+            AsDiscreted(keys=("pred", "label"), argmax=(True, False), to_onehot=len(label_names)),
+            SplitPredsLabeld(keys="pred"),
+            ToTensord(keys=("image", "label")),
+        ]
+        iteration_transforms = Compose(iteration_transforms)
+        post_transforms = Compose(post_transforms)
+
+        i = Interaction(
+            deepgrow_probability=1.0,
+            transforms=iteration_transforms,
+            click_probability_key="probability",
+            train=train,
+            label_names=label_names,
+        )
+        self.assertEqual(len(i.transforms.transforms), 4, "Mismatch in expected transforms")
+
+        # set up engine
+        engine = SupervisedTrainer(
+            device="cpu",
+            max_epochs=1,
+            train_data_loader=data_loader,
+            network=network,
+            optimizer=opt,
+            loss_function=loss,
+            postprocessing=post_transforms,
+            iteration_update=i,
+        )
+        engine.add_event_handler(IterationEvents.INNER_ITERATION_STARTED, add_one)
+        engine.add_event_handler(IterationEvents.INNER_ITERATION_COMPLETED, add_one)
+
+        engine.run()
+        self.assertIsNotNone(engine.state.batch[0].get("guidance"), "guidance is missing")
+        self.assertEqual(engine.state.best_metric, 1)
+
+    def test_train_interaction(self):
+        self.run_interaction(train=True)
+
+    def test_val_interaction(self):
+        self.run_interaction(train=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_downsample_block.py

@@ -0,0 +1,50 @@
+# 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.networks import eval_mode
+from monai.networks.blocks import MaxAvgPool
+
+TEST_CASES = [
+    [{"spatial_dims": 2, "kernel_size": 2}, (7, 4, 64, 48), (7, 8, 32, 24)],  # 4-channel 2D, batch 7
+    [{"spatial_dims": 1, "kernel_size": 4}, (16, 4, 63), (16, 8, 15)],  # 4-channel 1D, batch 16
+    [{"spatial_dims": 1, "kernel_size": 4, "padding": 1}, (16, 4, 63), (16, 8, 16)],  # 4-channel 1D, batch 16
+    [  # 4-channel 3D, batch 16
+        {"spatial_dims": 3, "kernel_size": 3, "ceil_mode": True},
+        (16, 4, 32, 24, 48),
+        (16, 8, 11, 8, 16),
+    ],
+    [  # 1-channel 3D, batch 16
+        {"spatial_dims": 3, "kernel_size": 3, "ceil_mode": False},
+        (16, 1, 32, 24, 48),
+        (16, 2, 10, 8, 16),
+    ],
+]
+
+
+class TestMaxAvgPool(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES)
+    def test_shape(self, input_param, input_shape, expected_shape):
+        net = MaxAvgPool(**input_param)
+        with eval_mode(net):
+            result = net(torch.randn(input_shape))
+            self.assertEqual(result.shape, expected_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_hovernet_nuclear_type_post_processingd.py

@@ -0,0 +1,71 @@
+# 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 numpy as np
+from parameterized import parameterized
+
+from monai.apps.pathology.transforms.post.dictionary import (
+    HoVerNetInstanceMapPostProcessingd,
+    HoVerNetNuclearTypePostProcessingd,
+)
+from monai.transforms import ComputeHoVerMaps
+from monai.utils import min_version, optional_import
+from monai.utils.enums import HoVerNetBranch
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+_, has_scipy = optional_import("scipy", "1.8.1", min_version)
+_, has_skimage = optional_import("skimage", "0.19.3", min_version)
+
+y, x = np.ogrid[0:30, 0:30]
+image = (x - 10) ** 2 + (y - 10) ** 2 <= 5**2
+image = image[None, ...].astype("uint8")
+
+TEST_CASE_1 = [{}, [{"1": [10, 10]}, np.zeros_like(image), np.zeros_like(image)]]
+
+TEST_CASE = []
+for p in TEST_NDARRAYS:
+    TEST_CASE.append([p, image] + TEST_CASE_1)
+
+
+@unittest.skipUnless(has_scipy, "Requires scipy library.")
+@unittest.skipUnless(has_skimage, "Requires scikit-image library.")
+class TestHoVerNetNuclearTypePostProcessingd(unittest.TestCase):
+    @parameterized.expand(TEST_CASE)
+    def test_value(self, in_type, test_data, kwargs, expected):
+        input = {
+            HoVerNetBranch.NP.value: in_type(test_data.astype(float)),
+            HoVerNetBranch.HV.value: in_type(ComputeHoVerMaps()(test_data.astype(int))),
+            HoVerNetBranch.NC.value: in_type(test_data),
+        }
+
+        outputs = HoVerNetInstanceMapPostProcessingd()(input)
+        outputs = HoVerNetNuclearTypePostProcessingd(**kwargs)(outputs)
+
+        # instance prediction info
+        for key in outputs["instance_info"]:
+            assert_allclose(outputs["instance_info"][key]["centroid"], expected[0][key], type_test=False)
+
+        # instance map
+        assert_allclose(outputs["instance_map"], expected[1], type_test=False)
+
+        # type map
+        if expected[2] is None:
+            self.assertIsNone(outputs["type_map"])
+        else:
+            assert_allclose(outputs["type_map"], expected[2], type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()