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

tests/losses/test_generalized_wasserstein_dice_loss.py

@@ -0,0 +1,234 @@
+# 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
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+
+from monai.losses import GeneralizedWassersteinDiceLoss
+from tests.test_utils import test_script_save
+
+
+class TestGeneralizedWassersteinDiceLoss(unittest.TestCase):
+    def test_bin_seg_2d(self):
+        target = torch.tensor([[0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]])
+
+        # add another dimension corresponding to the batch (batch size = 1 here)
+        target = target.unsqueeze(0)
+        pred_very_good = 1000 * F.one_hot(target, num_classes=2).permute(0, 3, 1, 2).float()
+        pred_very_poor = 1000 * F.one_hot(1 - target, num_classes=2).permute(0, 3, 1, 2).float()
+
+        for weight_mode in ["default", "GDL"]:
+            # initialize the loss
+            loss = GeneralizedWassersteinDiceLoss(
+                dist_matrix=np.array([[0.0, 1.0], [1.0, 0.0]]), weighting_mode=weight_mode
+            )
+
+            # the loss for pred_very_good should be close to 0
+            loss_good = float(loss.forward(pred_very_good, target))
+            self.assertAlmostEqual(loss_good, 0.0, places=3)
+
+            # same test, but with target with a class dimension
+            target_4dim = target.unsqueeze(1)
+            loss_good = float(loss.forward(pred_very_good, target_4dim))
+            self.assertAlmostEqual(loss_good, 0.0, places=3)
+
+            # the loss for pred_very_poor should be close to 1
+            loss_poor = float(loss.forward(pred_very_poor, target))
+            self.assertAlmostEqual(loss_poor, 1.0, places=3)
+
+    def test_different_target_data_type(self):
+        """
+        Test if the loss is compatible with all the integer types
+        for the target segmentation.
+        """
+        # define 2d examples
+        target = torch.tensor([[0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]])
+
+        # add another dimension corresponding to the batch (batch size = 1 here)
+        target = target.unsqueeze(0)  # shape (1, H, W)
+        pred_very_good = 1000 * F.one_hot(target, num_classes=2).permute(0, 3, 1, 2).float()
+
+        target_uint8 = target.to(torch.uint8)
+        target_int8 = target.to(torch.int8)
+        target_short = target.short()
+        target_int = target.int()
+        target_long = target.long()
+        target_list = [target_uint8, target_int8, target_short, target_int, target_long]
+
+        for w_mode in ["default", "GDL"]:
+            # initialize the loss
+            loss = GeneralizedWassersteinDiceLoss(dist_matrix=np.array([[0.0, 1.0], [1.0, 0.0]]), weighting_mode=w_mode)
+
+            # The test should pass irrespectively of the integer type used
+            for t in target_list:
+                # the loss for pred_very_good should be close to 0
+                loss_good = float(loss.forward(pred_very_good, t))
+                self.assertAlmostEqual(loss_good, 0.0, places=3)
+
+    def test_empty_class_2d(self):
+        num_classes = 2
+        target = torch.tensor([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])
+
+        # add another dimension corresponding to the batch (batch size = 1 here)
+        target = target.unsqueeze(0)
+        pred_very_good = 1000 * F.one_hot(target, num_classes=num_classes).permute(0, 3, 1, 2).float()
+        pred_very_poor = 1000 * F.one_hot(1 - target, num_classes=num_classes).permute(0, 3, 1, 2).float()
+
+        for w_mode in ["default", "GDL"]:
+            # initialize the loss
+            loss = GeneralizedWassersteinDiceLoss(dist_matrix=np.array([[0.0, 1.0], [1.0, 0.0]]), weighting_mode=w_mode)
+
+            # loss for pred_very_good should be close to 0
+            loss_good = float(loss.forward(pred_very_good, target))
+            self.assertAlmostEqual(loss_good, 0.0, places=3)
+
+            # loss for pred_very_poor should be close to 1
+            loss_poor = float(loss.forward(pred_very_poor, target))
+            self.assertAlmostEqual(loss_poor, 1.0, places=3)
+
+    def test_bin_seg_3d(self):
+        # define 3d examples
+        target = torch.tensor(
+            [
+                # raw 0
+                [[0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]],
+                # raw 1
+                [[0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]],
+                # raw 2
+                [[0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]],
+            ]
+        )
+
+        # add another dimension corresponding to the batch (batch size = 1 here)
+        target = target.unsqueeze(0)  # shape (1, H, W, D)
+        pred_very_good = 1000 * F.one_hot(target, num_classes=2).permute(0, 4, 1, 2, 3).float()
+        pred_very_poor = 1000 * F.one_hot(1 - target, num_classes=2).permute(0, 4, 1, 2, 3).float()
+
+        for w_mode in ["default", "GDL"]:
+            # initialize the loss
+            loss = GeneralizedWassersteinDiceLoss(dist_matrix=np.array([[0.0, 1.0], [1.0, 0.0]]), weighting_mode=w_mode)
+
+            # mean dice loss for pred_very_good should be close to 0
+            loss_good = float(loss.forward(pred_very_good, target))
+            self.assertAlmostEqual(loss_good, 0.0, places=3)
+
+            # mean dice loss for pred_very_poor should be close to 1
+            loss_poor = float(loss.forward(pred_very_poor, target))
+            self.assertAlmostEqual(loss_poor, 1.0, places=3)
+
+    def test_convergence(self):
+        """
+        The goal of this test is to assess if the gradient of the loss function
+        is correct by testing if we can train a one layer neural network
+        to segment one image.
+        We verify that the loss is decreasing in almost all SGD steps.
+        """
+        learning_rate = 0.001
+        max_iter = 50
+
+        # define a simple 3d example
+        target_seg = torch.tensor(
+            [
+                # raw 0
+                [[0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]],
+                # raw 1
+                [[0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]],
+                # raw 2
+                [[0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]],
+            ]
+        )
+        target_seg = torch.unsqueeze(target_seg, dim=0)
+        image = 12 * target_seg + 27  # dummy image to segment
+        image = image.float()
+        num_classes = 2
+        num_voxels = 3 * 4 * 4
+
+        # define a model with one layer
+        class OnelayerNet(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.layer = nn.Linear(num_voxels, num_voxels * num_classes)
+
+            def forward(self, x):
+                x = x.view(-1, num_voxels)
+                x = self.layer(x)
+                x = x.view(-1, num_classes, 3, 4, 4)
+                return x
+
+        for w_mode in ["default", "GDL"]:
+            # initialise the network
+            net = OnelayerNet()
+
+            # initialize the loss
+            loss = GeneralizedWassersteinDiceLoss(dist_matrix=np.array([[0.0, 1.0], [1.0, 0.0]]), weighting_mode=w_mode)
+
+            # initialize an optimizer
+            optimizer = optim.Adam(net.parameters(), lr=learning_rate)
+
+            # initial difference between pred and target
+            pred_start = torch.argmax(net(image), dim=1)
+            diff_start = torch.norm(pred_start.float() - target_seg.float())
+
+            loss_history = []
+            # train the network
+            for _ in range(max_iter):
+                # set the gradient to zero
+                optimizer.zero_grad()
+
+                # forward pass
+                output = net(image)
+                loss_val = loss(output, target_seg)
+
+                # backward pass
+                loss_val.backward()
+                optimizer.step()
+
+                # stats
+                loss_history.append(loss_val.item())
+
+            # difference between pred and target after training
+            pred_end = torch.argmax(net(image), dim=1)
+            diff_end = torch.norm(pred_end.float() - target_seg.float())
+
+            # count the number of SGD steps in which the loss decreases
+            num_decreasing_steps = 0
+            for i in range(len(loss_history) - 1):
+                if loss_history[i] > loss_history[i + 1]:
+                    num_decreasing_steps += 1
+            decreasing_steps_ratio = float(num_decreasing_steps) / (len(loss_history) - 1)
+
+            # verify that the loss is decreasing for sufficiently many SGD steps
+            self.assertTrue(decreasing_steps_ratio > 0.75)
+
+            # check that the predicted segmentation has improved
+            self.assertGreater(diff_start, diff_end)
+
+    def test_script(self):
+        target = torch.tensor([[0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]])
+
+        # add another dimension corresponding to the batch (batch size = 1 here)
+        target = target.unsqueeze(0)
+        pred_very_good = 1000 * F.one_hot(target, num_classes=2).permute(0, 3, 1, 2).float()
+
+        loss = GeneralizedWassersteinDiceLoss(dist_matrix=np.array([[0.0, 1.0], [1.0, 0.0]]), weighting_mode="default")
+
+        test_script_save(loss, pred_very_good, target)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/losses/test_giou_loss.py

@@ -0,0 +1,62 @@
+# 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.losses import BoxGIoULoss
+
+TEST_CASES = [
+    [  # shape: (1, 4), (1, 4)
+        {"input": torch.tensor([[1.0, 1.0, 2.0, 2.0]]), "target": torch.tensor([[1.0, 1.0, 2.0, 2.0]])},
+        0.0,
+    ],
+    [  # shape: (1, 6), (1, 6)
+        {
+            "input": torch.tensor([[1.0, 1.0, 1.0, 2.0, 2.0, 2.0]]),
+            "target": torch.tensor([[1.0, 1.0, 1.0, 2.0, 2.0, 2.0]]),
+        },
+        0.0,
+    ],
+]
+
+
+class TestGIoULoss(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES)
+    def test_result(self, input_data, expected_val):
+        loss = BoxGIoULoss()
+        result = loss(**input_data)
+        np.testing.assert_allclose(result.detach().cpu().numpy(), expected_val, atol=1e-4, rtol=1e-4)
+
+    def test_ill_shape(self):
+        loss = BoxGIoULoss()
+        with self.assertRaisesRegex(ValueError, ""):
+            loss(torch.ones((1, 2, 3)), torch.ones((1, 1, 2, 3)))
+
+    def test_with_cuda(self):
+        loss = BoxGIoULoss()
+        i = torch.tensor([[1.0, 1.0, 2.0, 2.0]])
+        j = torch.tensor([[1.0, 1.0, 2.0, 2.0]])
+        if torch.cuda.is_available():
+            i = i.cuda()
+            j = j.cuda()
+        output = loss(i, j)
+        np.testing.assert_allclose(output.detach().cpu().numpy(), 0.0, atol=1e-4, rtol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/losses/test_hausdorff_loss.py

@@ -0,0 +1,264 @@
+# 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 unittest.case import skipUnless
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.losses import HausdorffDTLoss, LogHausdorffDTLoss
+from monai.utils import optional_import
+
+_, has_scipy = optional_import("scipy")
+
+TEST_CASES = []
+for device in ["cpu", "cuda"] if torch.cuda.is_available() else ["cpu"]:
+    TEST_CASES.append(
+        [  # shape: (1, 1, 2, 2), (1, 1, 2, 2)
+            {"include_background": True, "sigmoid": True},
+            {
+                "input": torch.tensor([[[[1.0, -1.0], [-1.0, 1.0]]]], device=device),
+                "target": torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]], device=device),
+            },
+            0.509329,
+        ]
+    )
+    TEST_CASES.append(
+        [  # shape: (1, 1, 1, 2, 2), (1, 1, 1, 2, 2)
+            {"include_background": True, "sigmoid": True},
+            {
+                "input": torch.tensor([[[[[1.0, -1.0], [-1.0, 1.0]]]]], device=device),
+                "target": torch.tensor([[[[[1.0, 0.0], [1.0, 1.0]]]]], device=device),
+            },
+            0.509329,
+        ]
+    )
+    TEST_CASES.append(
+        [  # shape: (1, 1, 2, 2, 2), (1, 1, 2, 2, 2)
+            {"include_background": True, "sigmoid": True},
+            {
+                "input": torch.tensor([[[[[1.0, -1.0], [1.0, -1.0]], [[-1.0, 1.0], [-1.0, 1.0]]]]], device=device),
+                "target": torch.tensor([[[[[1.0, 0.0], [1.0, 0.0]], [[0.0, 0.0], [1.0, 1.0]]]]], device=device),
+            },
+            0.375718,
+        ]
+    )
+    TEST_CASES.append(
+        [  # shape: (1, 2, 2, 2), (1, 2, 2, 2)
+            {"include_background": True, "sigmoid": True},
+            {
+                "input": torch.tensor([[[[1.0, -1.0], [-1.0, 1.0]], [[1.0, -1.0], [-1.0, 1.0]]]], device=device),
+                "target": torch.tensor([[[[1.0, 0.0], [1.0, 1.0]], [[1.0, 0.0], [0.0, 1.0]]]], device=device),
+            },
+            0.326994,
+        ]
+    )
+    TEST_CASES.append(
+        [  # shape: (2, 1, 2, 2), (2, 1, 2, 2)
+            {"include_background": True, "sigmoid": True},
+            {
+                "input": torch.tensor([[[[1.0, -1.0], [-1.0, 1.0]]], [[[1.0, -1.0], [-1.0, 1.0]]]], device=device),
+                "target": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]]], [[[1.0, 0.0], [1.0, 0.0]]]], device=device),
+            },
+            0.455082,
+        ]
+    )
+    TEST_CASES.append(
+        [  # shape: (1, 1, 2, 2), (1, 1, 2, 2)
+            {"include_background": False, "sigmoid": True},
+            {
+                "input": torch.tensor([[[[1.0, -1.0], [-1.0, 1.0]], [[1.0, -1.0], [-1.0, 1.0]]]], device=device),
+                "target": torch.tensor([[[[1.0, 0.0], [1.0, 1.0]], [[1.0, 0.0], [0.0, 1.0]]]], device=device),
+            },
+            0.144659,
+        ]
+    )
+    TEST_CASES.append(
+        [  # shape: (2, 2, 3, 1), (2, 1, 3, 1)
+            {"include_background": True, "to_onehot_y": True, "sigmoid": True, "reduction": "none"},
+            {
+                "input": torch.tensor(
+                    [[[[-1.0], [0.0], [1.0]], [[1.0], [0.0], [-1.0]]], [[[0.0], [0.0], [0.0]], [[0.0], [0.0], [0.0]]]],
+                    device=device,
+                ),
+                "target": torch.tensor([[[[1.0], [0.0], [0.0]]], [[[1.0], [1.0], [0.0]]]], device=device),
+            },
+            [[[[0.407765]], [[0.407765]]], [[[0.5000]], [[0.5000]]]],
+        ]
+    )
+    TEST_CASES.append(
+        [  # shape: (2, 2, 3, 1), (2, 1, 3, 1)
+            {"include_background": True, "to_onehot_y": True, "softmax": True},
+            {
+                "input": torch.tensor(
+                    [[[[-1.0], [0.0], [1.0]], [[1.0], [0.0], [-1.0]]], [[[0.0], [0.0], [0.0]], [[0.0], [0.0], [0.0]]]],
+                    device=device,
+                ),
+                "target": torch.tensor([[[[1.0], [0.0], [0.0]]], [[[1.0], [1.0], [0.0]]]], device=device),
+            },
+            0.357016,
+        ]
+    )
+    TEST_CASES.append(
+        [  # shape: (2, 2, 3, 1), (2, 1, 3, 1)
+            {"include_background": True, "to_onehot_y": True, "softmax": True, "reduction": "sum"},
+            {
+                "input": torch.tensor(
+                    [[[[-1.0], [0.0], [1.0]], [[1.0], [0.0], [-1.0]]], [[[0.0], [0.0], [0.0]], [[0.0], [0.0], [0.0]]]],
+                    device=device,
+                ),
+                "target": torch.tensor([[[[1.0], [0.0], [0.0]]], [[[1.0], [1.0], [0.0]]]], device=device),
+            },
+            1.428062,
+        ]
+    )
+    TEST_CASES.append(
+        [  # shape: (1, 1, 2, 2), (1, 1, 2, 2)
+            {"include_background": True, "sigmoid": True},
+            {
+                "input": torch.tensor([[[[1.0, -1.0], [-1.0, 1.0]]]], device=device),
+                "target": torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]], device=device),
+            },
+            0.509329,
+        ]
+    )
+    TEST_CASES.append(
+        [  # shape: (2, 1, 2, 2), (2, 1, 2, 2)
+            {"include_background": True, "other_act": torch.tanh},
+            {
+                "input": torch.tensor([[[[1.0, -1.0], [-1.0, 1.0]]], [[[1.0, -1.0], [-1.0, 1.0]]]], device=device),
+                "target": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]]], [[[1.0, 0.0], [1.0, 0.0]]]], device=device),
+            },
+            1.870039,
+        ]
+    )
+    TEST_CASES.append(
+        [  # shape: (2, 2, 3), (2, 1, 3)
+            {"include_background": True, "to_onehot_y": True, "other_act": lambda x: torch.log_softmax(x, dim=1)},
+            {
+                "input": torch.tensor(
+                    [[[[-1.0], [0.0], [1.0]], [[1.0], [0.0], [-1.0]]], [[[0.0], [0.0], [0.0]], [[0.0], [0.0], [0.0]]]],
+                    device=device,
+                ),
+                "target": torch.tensor([[[[1.0], [0.0], [0.0]]], [[[1.0], [1.0], [0.0]]]], device=device),
+            },
+            4.366613,
+        ]
+    )
+    TEST_CASES.append(
+        [  # shape: (2, 1, 2, 2), (2, 1, 2, 2)
+            {"include_background": True, "other_act": torch.tanh, "batch": True},
+            {
+                "input": torch.tensor([[[[1.0, -0.0], [-1.0, 1.0]]], [[[1.0, -1.0], [-1.0, 1.0]]]], device=device),
+                "target": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]]], [[[1.0, 0.0], [1.0, 0.0]]]], device=device),
+            },
+            1.607137,
+        ]
+    )
+    TEST_CASES.append(
+        [  # shape: (2, 1, 2, 2), (2, 1, 2, 2)
+            {"include_background": True, "other_act": torch.tanh, "batch": True},
+            {
+                "input": torch.tensor([[[[1.0, -0.0], [-1.0, 1.0]]], [[[1.0, -1.0], [-1.0, 1.0]]]], device=device),
+                "target": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]]], [[[1.0, 0.0], [1.0, 0.0]]]], device=device),
+            },
+            1.607137,
+        ]
+    )
+    TEST_CASES.append(
+        [  # shape: (2, 1, 2, 2), (2, 1, 2, 2)
+            {"include_background": True, "other_act": torch.tanh, "batch": False},
+            {
+                "input": torch.tensor([[[[1.0, -0.0], [-1.0, 1.0]]], [[[1.0, -1.0], [-1.0, 1.0]]]], device=device),
+                "target": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]]], [[[1.0, 0.0], [1.0, 0.0]]]], device=device),
+            },
+            1.607137,
+        ]
+    )
+
+TEST_CASES_LOG = [[*inputs, np.log(np.array(output) + 1)] for *inputs, output in TEST_CASES]
+
+
+def _describe_test_case(test_func, test_number, params):
+    input_param, input_data, _ = params.args
+    return f"params:{input_param}, shape:{input_data['input'].shape}, device:{input_data['input'].device}"
+
+
+@skipUnless(has_scipy, "Scipy required")
+class TestHausdorffDTLoss(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES, doc_func=_describe_test_case)
+    def test_shape(self, input_param, input_data, expected_val):
+        result = HausdorffDTLoss(**input_param).forward(**input_data)
+        np.testing.assert_allclose(result.detach().cpu().numpy(), expected_val, rtol=1e-5)
+
+    def test_ill_shape(self):
+        loss = HausdorffDTLoss()
+        with self.assertRaisesRegex(AssertionError, ""):
+            loss.forward(torch.ones((1, 1, 2, 3)), torch.ones((1, 4, 5, 6)))
+
+    def test_ill_opts(self):
+        with self.assertRaisesRegex(ValueError, ""):
+            HausdorffDTLoss(sigmoid=True, softmax=True)
+        chn_input = torch.ones((1, 1, 3))
+        chn_target = torch.ones((1, 1, 3))
+        with self.assertRaisesRegex(ValueError, ""):
+            HausdorffDTLoss(reduction="unknown")(chn_input, chn_target)
+        with self.assertRaisesRegex(ValueError, ""):
+            HausdorffDTLoss(reduction=None)(chn_input, chn_target)
+
+    @parameterized.expand([(False, False, False), (False, True, False), (False, False, True)])
+    def test_input_warnings(self, include_background, softmax, to_onehot_y):
+        chn_input = torch.ones((1, 1, 1, 3))
+        chn_target = torch.ones((1, 1, 1, 3))
+        with self.assertWarns(Warning):
+            loss = HausdorffDTLoss(include_background=include_background, softmax=softmax, to_onehot_y=to_onehot_y)
+            loss.forward(chn_input, chn_target)
+
+
+@skipUnless(has_scipy, "Scipy required")
+class TesLogtHausdorffDTLoss(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES_LOG, doc_func=_describe_test_case)
+    def test_shape(self, input_param, input_data, expected_val):
+        result = LogHausdorffDTLoss(**input_param).forward(**input_data)
+        np.testing.assert_allclose(result.detach().cpu().numpy(), expected_val, rtol=1e-5)
+
+    def test_ill_shape(self):
+        loss = LogHausdorffDTLoss()
+        with self.assertRaisesRegex(AssertionError, ""):
+            loss.forward(torch.ones((1, 1, 2, 3)), torch.ones((1, 4, 5, 6)))
+
+    def test_ill_opts(self):
+        with self.assertRaisesRegex(ValueError, ""):
+            LogHausdorffDTLoss(sigmoid=True, softmax=True)
+        chn_input = torch.ones((1, 1, 3))
+        chn_target = torch.ones((1, 1, 3))
+        with self.assertRaisesRegex(ValueError, ""):
+            LogHausdorffDTLoss(reduction="unknown")(chn_input, chn_target)
+        with self.assertRaisesRegex(ValueError, ""):
+            LogHausdorffDTLoss(reduction=None)(chn_input, chn_target)
+
+    @parameterized.expand([(False, False, False), (False, True, False), (False, False, True)])
+    def test_input_warnings(self, include_background, softmax, to_onehot_y):
+        chn_input = torch.ones((1, 1, 1, 3))
+        chn_target = torch.ones((1, 1, 1, 3))
+        with self.assertWarns(Warning):
+            loss = LogHausdorffDTLoss(include_background=include_background, softmax=softmax, to_onehot_y=to_onehot_y)
+            loss.forward(chn_input, chn_target)
+
+
+if __name__ == "__main__":
+    unittest.main()