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

tests/transforms/utility/test_simulatedelayd.py

@@ -0,0 +1,36 @@
+# 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 time
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms.utility.dictionary import SimulateDelayd
+from tests.test_utils import NumpyImageTestCase2D
+
+
+class TestSimulateDelay(NumpyImageTestCase2D):
+    @parameterized.expand([(0.45,), (1,)])
+    def test_value(self, delay_test_time: float):
+        resize = SimulateDelayd(keys="imgd", delay_time=delay_test_time)
+        start: float = time.time()
+        _ = resize({"imgd": self.imt[0]})
+        stop: float = time.time()
+        measured_approximate: float = stop - start
+        np.testing.assert_allclose(delay_test_time, measured_approximate, rtol=0.5)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/utility/test_splitdim.py

@@ -0,0 +1,52 @@
+# 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.transforms.utility.array import SplitDim
+from tests.test_utils import TEST_NDARRAYS
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    for keepdim in (True, False):
+        TESTS.append(((2, 10, 8, 7), keepdim, p))
+
+
+class TestSplitDim(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_correct_shape(self, shape, keepdim, im_type):
+        arr = im_type(np.random.rand(*shape))
+        for dim in range(arr.ndim):
+            out = SplitDim(dim, keepdim)(arr)
+            self.assertIsInstance(out, (list, tuple))
+            self.assertEqual(type(out[0]), type(arr))
+            self.assertEqual(len(out), arr.shape[dim])
+            expected_ndim = arr.ndim if keepdim else arr.ndim - 1
+            self.assertEqual(out[0].ndim, expected_ndim)
+            # assert is a shallow copy
+            arr[0, 0, 0, 0] *= 2
+            self.assertEqual(arr.flatten()[0], out[0].flatten()[0])
+
+    def test_singleton(self):
+        shape = (2, 1, 8, 7)
+        for p in TEST_NDARRAYS:
+            arr = p(np.random.rand(*shape))
+            out = SplitDim(dim=1)(arr)
+            self.assertEqual(out[0].shape, shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/utility/test_splitdimd.py

@@ -0,0 +1,96 @@
+# 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 copy import deepcopy
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms import LoadImaged
+from monai.transforms.utility.dictionary import SplitDimd
+from tests.test_utils import TEST_NDARRAYS, assert_allclose, make_nifti_image, make_rand_affine
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    for keepdim in (True, False):
+        for update_meta in (True, False):
+            for list_output in (True, False):
+                TESTS.append((keepdim, p, update_meta, list_output))
+
+
+class TestSplitDimd(unittest.TestCase):
+    data: MetaTensor
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        arr = np.random.rand(2, 10, 8, 7)
+        affine = make_rand_affine()
+        data = {"i": make_nifti_image(arr, affine)}
+
+        loader = LoadImaged("i", image_only=True)
+        cls.data = loader(data)
+
+    @parameterized.expand(TESTS)
+    def test_correct(self, keepdim, im_type, update_meta, list_output):
+        data = deepcopy(self.data)
+        data["i"] = im_type(data["i"])
+        arr = data["i"]
+        for dim in range(arr.ndim):
+            out = SplitDimd("i", dim=dim, keepdim=keepdim, update_meta=update_meta, list_output=list_output)(data)
+            if list_output:
+                self.assertIsInstance(out, list)
+                self.assertEqual(len(out), arr.shape[dim])
+            else:
+                self.assertIsInstance(out, dict)
+                self.assertEqual(len(out.keys()), len(data.keys()) + arr.shape[dim])
+            # if updating metadata, pick some random points and
+            # check same world coordinates between input and output
+            if update_meta:
+                for _ in range(10):
+                    idx = [np.random.choice(i) for i in arr.shape]
+                    split_im_idx = idx[dim]
+                    split_idx = deepcopy(idx)
+                    split_idx[dim] = 0
+                    if list_output:
+                        split_im = out[split_im_idx]["i"]
+                    else:
+                        split_im = out[f"i_{split_im_idx}"]
+                    if isinstance(data, MetaTensor) and isinstance(split_im, MetaTensor):
+                        # idx[1:] to remove channel and then add 1 for 4th element
+                        real_world = data.affine @ torch.tensor(idx[1:] + [1]).double()
+                        real_world2 = split_im.affine @ torch.tensor(split_idx[1:] + [1]).double()
+                        assert_allclose(real_world, real_world2)
+
+            if list_output:
+                out = out[0]["i"]
+            else:
+                out = out["i_0"]
+            expected_ndim = arr.ndim if keepdim else arr.ndim - 1
+            self.assertEqual(out.ndim, expected_ndim)
+            # assert is a shallow copy
+            arr[0, 0, 0, 0] *= 2
+            self.assertEqual(arr.flatten()[0], out.flatten()[0])
+
+    def test_singleton(self):
+        shape = (2, 1, 8, 7)
+        for p in TEST_NDARRAYS:
+            arr = p(np.random.rand(*shape))
+            out = SplitDimd("i", dim=1)({"i": arr})
+            self.assertEqual(out["i"].shape, shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/utils/__init__.py

@@ -0,0 +1,10 @@
+# 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.

tests/transforms/utils/test_correct_crop_centers.py

@@ -0,0 +1,36 @@
+# 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.transforms.utils import correct_crop_centers
+from tests.test_utils import assert_allclose
+
+TESTS = [[[1, 5, 0], [2, 2, 2], [10, 10, 10]], [[4, 4, 4], [2, 2, 1], [10, 10, 10]]]
+
+
+class TestCorrectCropCenters(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_torch(self, spatial_size, centers, label_spatial_shape):
+        result1 = correct_crop_centers(centers, spatial_size, label_spatial_shape)
+        centers = [torch.tensor(i) for i in centers]
+        result2 = correct_crop_centers(centers, spatial_size, label_spatial_shape)
+        assert_allclose(result1, result2)
+        self.assertEqual(type(result1[0]), type(result2[0]))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/utils/test_get_unique_labels.py

@@ -0,0 +1,45 @@
+# 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
+import torch.nn.functional as F
+from parameterized import parameterized
+
+from monai.transforms.utils import get_unique_labels
+from monai.transforms.utils_pytorch_numpy_unification import moveaxis
+from tests.test_utils import TEST_NDARRAYS
+
+grid_raw = [[0, 0, 0], [0, 0, 1], [2, 2, 3], [5, 5, 6], [3, 6, 2], [5, 6, 6]]
+grid = torch.Tensor(grid_raw).unsqueeze(0).to(torch.int64)
+grid_onehot = moveaxis(F.one_hot(grid)[0], -1, 0)
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    for o_h in (False, True):
+        im = grid_onehot if o_h else grid
+        TESTS.append([dict(img=p(im), is_onehot=o_h), {0, 1, 2, 3, 5, 6}])
+        TESTS.append([dict(img=p(im), is_onehot=o_h, discard=0), {1, 2, 3, 5, 6}])
+        TESTS.append([dict(img=p(im), is_onehot=o_h, discard=[1, 2]), {0, 3, 5, 6}])
+
+
+class TestGetUniqueLabels(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_correct_results(self, args, expected):
+        result = get_unique_labels(**args)
+        self.assertEqual(result, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/utils/test_print_transform_backends.py

@@ -0,0 +1,29 @@
+# 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 monai.transforms.utils import get_transform_backends, print_transform_backends
+
+
+class TestPrintTransformBackends(unittest.TestCase):
+
+    def test_get_number_of_conversions(self):
+        tr_t_or_np, *_ = get_transform_backends()
+        self.assertGreater(len(tr_t_or_np), 0)
+        print_transform_backends()
+
+
+if __name__ == "__main__":
+    a = TestPrintTransformBackends()
+    a.test_get_number_of_conversions()

tests/transforms/utils/test_soft_clip.py

@@ -0,0 +1,125 @@
+# 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 parameterized import parameterized
+
+from monai.transforms.utils import soft_clip
+
+TEST_CASES = [
+    [
+        {"minv": 2, "maxv": 8, "sharpness_factor": 10},
+        {
+            "input": torch.arange(10).float(),
+            "clipped": torch.tensor([2.0000, 2.0000, 2.0693, 3.0000, 4.0000, 5.0000, 6.0000, 7.0000, 7.9307, 8.0000]),
+        },
+    ],
+    [
+        {"minv": 2, "maxv": None, "sharpness_factor": 10},
+        {
+            "input": torch.arange(10).float(),
+            "clipped": torch.tensor([2.0000, 2.0000, 2.0693, 3.0000, 4.0000, 5.0000, 6.0000, 7.0000, 8.0000, 9.0000]),
+        },
+    ],
+    [
+        {"minv": None, "maxv": 7, "sharpness_factor": 10},
+        {
+            "input": torch.arange(10).float(),
+            "clipped": torch.tensor([0.0000, 1.0000, 2.0000, 3.0000, 4.0000, 5.0000, 6.0000, 6.9307, 7.0000, 7.0000]),
+        },
+    ],
+    [
+        {"minv": 2, "maxv": 8, "sharpness_factor": 1.0},
+        {
+            "input": torch.arange(10).float(),
+            "clipped": torch.tensor([2.1266, 2.3124, 2.6907, 3.3065, 4.1088, 5.0000, 5.8912, 6.6935, 7.3093, 7.6877]),
+        },
+    ],
+    [
+        {"minv": 2, "maxv": 8, "sharpness_factor": 3.0},
+        {
+            "input": torch.arange(10).float(),
+            "clipped": torch.tensor([2.0008, 2.0162, 2.2310, 3.0162, 4.0008, 5.0000, 5.9992, 6.9838, 7.7690, 7.9838]),
+        },
+    ],
+    [
+        {"minv": 2, "maxv": 8, "sharpness_factor": 5.0},
+        {
+            "input": torch.arange(10).float(),
+            "clipped": torch.tensor([2.0000, 2.0013, 2.1386, 3.0013, 4.0000, 5.0000, 6.0000, 6.9987, 7.8614, 7.9987]),
+        },
+    ],
+    [
+        {"minv": 2, "maxv": 8, "sharpness_factor": 10},
+        {
+            "input": np.arange(10).astype(np.float32),
+            "clipped": np.array([2.0000, 2.0000, 2.0693, 3.0000, 4.0000, 5.0000, 6.0000, 7.0000, 7.9307, 8.0000]),
+        },
+    ],
+    [
+        {"minv": 2, "maxv": None, "sharpness_factor": 10},
+        {
+            "input": np.arange(10).astype(float),
+            "clipped": np.array([2.0000, 2.0000, 2.0693, 3.0000, 4.0000, 5.0000, 6.0000, 7.0000, 8.0000, 9.0000]),
+        },
+    ],
+    [
+        {"minv": None, "maxv": 7, "sharpness_factor": 10},
+        {
+            "input": np.arange(10).astype(float),
+            "clipped": np.array([0.0000, 1.0000, 2.0000, 3.0000, 4.0000, 5.0000, 6.0000, 6.9307, 7.0000, 7.0000]),
+        },
+    ],
+    [
+        {"minv": 2, "maxv": 8, "sharpness_factor": 1.0},
+        {
+            "input": np.arange(10).astype(float),
+            "clipped": np.array([2.1266, 2.3124, 2.6907, 3.3065, 4.1088, 5.0000, 5.8912, 6.6935, 7.3093, 7.6877]),
+        },
+    ],
+    [
+        {"minv": 2, "maxv": 8, "sharpness_factor": 3.0},
+        {
+            "input": np.arange(10).astype(float),
+            "clipped": np.array([2.0008, 2.0162, 2.2310, 3.0162, 4.0008, 5.0000, 5.9992, 6.9838, 7.7690, 7.9838]),
+        },
+    ],
+    [
+        {"minv": 2, "maxv": 8, "sharpness_factor": 5.0},
+        {
+            "input": np.arange(10).astype(float),
+            "clipped": np.array([2.0000, 2.0013, 2.1386, 3.0013, 4.0000, 5.0000, 6.0000, 6.9987, 7.8614, 7.9987]),
+        },
+    ],
+]
+
+
+class TestSoftClip(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES)
+    def test_result(self, input_param, input_data):
+        outputs = soft_clip(input_data["input"], **input_param)
+        expected_val = input_data["clipped"]
+        if isinstance(outputs, torch.Tensor):
+            np.testing.assert_allclose(
+                outputs.detach().cpu().numpy(), expected_val.detach().cpu().numpy(), atol=1e-4, rtol=1e-4
+            )
+        else:
+            np.testing.assert_allclose(outputs, expected_val, atol=1e-4, rtol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/__init__.py

@@ -0,0 +1,10 @@
+# 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.

tests/utils/enums/__init__.py

@@ -0,0 +1,10 @@
+# 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.

tests/utils/enums/test_hovernet_loss.py

@@ -0,0 +1,190 @@
+# 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 random
+import unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+from torch.nn import functional as F
+
+from monai.apps.pathology.losses import HoVerNetLoss
+from monai.transforms import GaussianSmooth, Rotate
+from monai.transforms.intensity.array import ComputeHoVerMaps
+from monai.utils.enums import HoVerNetBranch
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+s = 10e-8
+t = 1.0 - s
+H = 40
+W = 40
+N = 5
+B = 2
+
+
+class PrepareTestInputs:
+
+    def __init__(self, inputs):
+        self.inputs = {HoVerNetBranch.NP: inputs[1], HoVerNetBranch.HV: inputs[3]}
+        self.targets = {HoVerNetBranch.NP: inputs[0], HoVerNetBranch.HV: inputs[2]}
+
+        if len(inputs) > 4:
+            self.targets[HoVerNetBranch.NC] = inputs[4]
+            self.inputs[HoVerNetBranch.NC] = inputs[5]
+
+
+def test_shape_generator(num_classes=1, num_objects=3, batch_size=1, height=5, width=5, rotation=0.0, smoothing=False):
+    t_g = torch.zeros((batch_size, height, width), dtype=torch.int64)
+    t_p = None
+    hv_g = torch.zeros((batch_size, 2, height, width))
+    hv_p = torch.zeros((batch_size, 2, height, width))
+
+    rad_min = 2
+    rad_max = min(max(height // 3, width // 3, rad_min), 5)
+
+    for b in range(batch_size):
+        random.seed(10 + b)
+        inst_map = torch.zeros((height, width), dtype=torch.int64)
+        for inst_id in range(1, num_objects + 1):
+            x = random.randint(rad_max, width - rad_max)
+            y = random.randint(rad_max, height - rad_max)
+            rad = random.randint(rad_min, rad_max)
+            spy, spx = np.ogrid[-x : height - x, -y : width - y]
+            circle = torch.tensor((spx * spx + spy * spy) <= rad * rad)
+
+            if num_classes > 1:
+                t_g[b, circle] = np.ceil(random.random() * num_classes)
+            else:
+                t_g[b, circle] = 1
+
+            inst_map[circle] = inst_id
+
+        hv_g[b] = ComputeHoVerMaps()(inst_map[None])
+        hv_g[b] = hv_g[b].squeeze(0)
+        if rotation > 0.0:
+            hv_p[b] = Rotate(angle=rotation, keep_size=True, mode="bilinear")(hv_g[b])
+
+    n_g = t_g > 0
+    if rotation == 0.0:
+        hv_p = hv_g * 0.99
+
+    # rotation of prediction needs to happen before one-hot encoding
+    if rotation > 0.0:
+        n_p = Rotate(angle=rotation, keep_size=True, mode="nearest")(n_g)
+        n_p = F.one_hot(n_p.to(torch.int64)).to(torch.float32).permute(0, 3, 1, 2)
+        if num_classes > 1:
+            t_p = Rotate(angle=rotation, keep_size=True, mode="nearest")(t_g)
+            t_p = F.one_hot(t_p.to(torch.int64)).to(torch.float32).permute(0, 3, 1, 2)
+            t_g = F.one_hot(t_g.to(torch.int64)).to(torch.float32).permute(0, 3, 1, 2)
+        else:
+            t_g = None
+    else:
+        n_p = F.one_hot(n_g.to(torch.int64)).to(torch.float32).permute(0, 3, 1, 2)
+        if num_classes > 1:
+            t_p = F.one_hot(t_g.to(torch.int64)).to(torch.float32).permute(0, 3, 1, 2)
+            t_g = F.one_hot(t_g.to(torch.int64)).to(torch.float32).permute(0, 3, 1, 2)
+        else:
+            t_g = None
+
+    n_g = F.one_hot(n_g.to(torch.int64)).to(torch.float32).permute(0, 3, 1, 2)
+
+    if smoothing:
+        n_p = GaussianSmooth()(n_p)
+        if num_classes > 1:
+            t_p = GaussianSmooth()(t_p)
+        hv_p = hv_p * 0.1
+    else:
+        n_p = torch.clamp(n_p, s, t)
+        if num_classes > 1:
+            t_p = torch.clamp(t_p, s, t)
+
+    # Apply log to emulate logits
+    if t_p is not None:
+        return n_g, n_p.log(), hv_g, hv_p, t_g, t_p.log()
+    else:
+        return n_g, n_p.log(), hv_g, hv_p
+
+
+inputs_test = [
+    PrepareTestInputs(test_shape_generator(height=H, width=W)),
+    PrepareTestInputs(test_shape_generator(num_classes=N, height=H, width=W)),
+    PrepareTestInputs(test_shape_generator(num_classes=N, batch_size=B, height=H, width=W)),
+    PrepareTestInputs(test_shape_generator(num_classes=N, batch_size=B, height=H, width=W, rotation=0.15)),
+    PrepareTestInputs(test_shape_generator(num_classes=N, batch_size=B, height=H, width=W, rotation=0.2)),
+    PrepareTestInputs(test_shape_generator(num_classes=N, batch_size=B, height=H, width=W, rotation=0.25)),
+]
+
+TEST_CASE_0 = [  # batch size of 1, no type prediction
+    {"prediction": inputs_test[0].inputs, "target": inputs_test[0].targets},
+    0.003,
+]
+
+TEST_CASE_1 = [  # batch size of 1, 2 classes with type prediction
+    {"prediction": inputs_test[1].inputs, "target": inputs_test[1].targets},
+    0.2762,
+]
+
+TEST_CASE_2 = [  # batch size of 2, 2 classes with type prediction
+    {"prediction": inputs_test[2].inputs, "target": inputs_test[2].targets},
+    0.4852,
+]
+
+TEST_CASE_3 = [  # batch size of 2, 3 classes with minor rotation of nuclear prediction
+    {"prediction": inputs_test[3].inputs, "target": inputs_test[3].targets},
+    3.6348,
+]
+
+TEST_CASE_4 = [  # batch size of 2, 3 classes with medium rotation of nuclear prediction
+    {"prediction": inputs_test[4].inputs, "target": inputs_test[4].targets},
+    4.5312,
+]
+
+TEST_CASE_5 = [  # batch size of 2, 3 classes with medium rotation of nuclear prediction
+    {"prediction": inputs_test[5].inputs, "target": inputs_test[5].targets},
+    5.4929,
+]
+
+CASES = [TEST_CASE_0, TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5]
+
+ILL_CASES = [
+    [
+        {
+            "prediction": {"np": inputs_test[0].inputs[HoVerNetBranch.NP]},
+            "target": {
+                "np": inputs_test[0].targets[HoVerNetBranch.NP],
+                HoVerNetBranch.HV: inputs_test[0].targets[HoVerNetBranch.HV],
+            },
+        }
+    ]
+]
+
+
+class TestHoverNetLoss(unittest.TestCase):
+
+    @parameterized.expand(CASES)
+    def test_shape(self, input_param, expected_loss):
+        loss = HoVerNetLoss()
+        result = loss(**input_param).to(device)
+        self.assertAlmostEqual(float(result), expected_loss, places=2)
+
+    @parameterized.expand(ILL_CASES)
+    def test_ill_input_hyper_params(self, input_param):
+        with self.assertRaises(ValueError):
+            loss = HoVerNetLoss()
+            _ = loss(**input_param).to(device)
+
+
+if __name__ == "__main__":
+    unittest.main(argv=["first-arg-is-ignored"], exit=False)