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

tests/metrics/test_compute_meaniou.py

@@ -0,0 +1,223 @@
+# 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.metrics import MeanIoU, compute_iou
+
+_device = "cuda:0" if torch.cuda.is_available() else "cpu"
+# keep background
+TEST_CASE_1 = [  # y (1, 1, 2, 2), y_pred (1, 1, 2, 2), expected out (1, 1)
+    {
+        "y_pred": torch.tensor([[[[1.0, 0.0], [0.0, 1.0]]]], device=_device),
+        "y": torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]], device=_device),
+        "include_background": True,
+    },
+    [[0.6667]],
+]
+
+# remove background and not One-Hot target
+TEST_CASE_2 = [  # y (2, 3, 2, 2), y_pred (2, 3, 2, 2), expected out (2, 2) (no background)
+    {
+        "y_pred": torch.tensor(
+            [
+                [[[0.0, 1.0], [0.0, 0.0]], [[0.0, 0.0], [1.0, 1.0]], [[1.0, 0.0], [0.0, 0.0]]],
+                [[[0.0, 0.0], [0.0, 1.0]], [[1.0, 0.0], [0.0, 0.0]], [[0.0, 1.0], [1.0, 0.0]]],
+            ]
+        ),
+        "y": torch.tensor(
+            [
+                [[[0.0, 0.0], [0.0, 1.0]], [[1.0, 0.0], [1.0, 0.0]], [[0.0, 1.0], [0.0, 0.0]]],
+                [[[0.0, 0.0], [0.0, 1.0]], [[1.0, 1.0], [0.0, 0.0]], [[0.0, 0.0], [1.0, 0.0]]],
+            ]
+        ),
+        "include_background": False,
+    },
+    [[0.3333, 0.0000], [0.5000, 0.5000]],
+]
+
+# should return Nan for all labels=0 case and skip for MeanIoU
+TEST_CASE_3 = [
+    {
+        "y_pred": torch.tensor(
+            [
+                [[[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[1.0, 1.0], [1.0, 1.0]]],
+                [[[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[1.0, 1.0], [1.0, 1.0]]],
+            ]
+        ),
+        "y": torch.tensor(
+            [
+                [[[1.0, 1.0], [1.0, 1.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]],
+                [[[0.0, 1.0], [1.0, 0.0]], [[1.0, 0.0], [0.0, 1.0]], [[0.0, 0.0], [0.0, 0.0]]],
+            ]
+        ),
+        "include_background": True,
+    },
+    [[False, True, True], [False, False, True]],
+]
+
+TEST_CASE_4 = [
+    {"include_background": True, "reduction": "mean_batch", "get_not_nans": True},
+    {
+        "y_pred": torch.tensor(
+            [
+                [[[1.0, 1.0], [1.0, 0.0]], [[0.0, 1.0], [0.0, 0.0]], [[0.0, 1.0], [1.0, 1.0]]],
+                [[[1.0, 0.0], [1.0, 1.0]], [[0.0, 1.0], [1.0, 1.0]], [[0.0, 1.0], [1.0, 0.0]]],
+            ]
+        ),
+        "y": torch.tensor(
+            [
+                [[[1.0, 1.0], [1.0, 1.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]],
+                [[[0.0, 0.0], [0.0, 1.0]], [[1.0, 1.0], [0.0, 0.0]], [[0.0, 0.0], [1.0, 0.0]]],
+            ]
+        ),
+    },
+    [0.5416, 0.2500, 0.5000],
+]
+
+TEST_CASE_5 = [
+    {"include_background": True, "reduction": "mean", "get_not_nans": True},
+    {
+        "y_pred": torch.tensor(
+            [
+                [[[1.0, 1.0], [1.0, 0.0]], [[0.0, 1.0], [0.0, 0.0]], [[0.0, 1.0], [1.0, 1.0]]],
+                [[[1.0, 0.0], [1.0, 1.0]], [[0.0, 1.0], [1.0, 1.0]], [[0.0, 1.0], [1.0, 0.0]]],
+            ]
+        ),
+        "y": torch.tensor(
+            [
+                [[[1.0, 1.0], [1.0, 1.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]],
+                [[[0.0, 0.0], [0.0, 1.0]], [[1.0, 1.0], [0.0, 0.0]], [[0.0, 0.0], [1.0, 0.0]]],
+            ]
+        ),
+    },
+    0.5555,
+]
+
+TEST_CASE_6 = [
+    {"include_background": True, "reduction": "sum_batch", "get_not_nans": True},
+    {
+        "y_pred": torch.tensor(
+            [
+                [[[1.0, 1.0], [1.0, 0.0]], [[0.0, 1.0], [0.0, 0.0]], [[0.0, 1.0], [1.0, 1.0]]],
+                [[[1.0, 0.0], [1.0, 1.0]], [[0.0, 1.0], [1.0, 1.0]], [[0.0, 1.0], [1.0, 0.0]]],
+            ]
+        ),
+        "y": torch.tensor(
+            [
+                [[[1.0, 1.0], [1.0, 1.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]],
+                [[[1.0, 1.0], [1.0, 1.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]],
+            ]
+        ),
+    },
+    [1.5000, 0.0000, 0.0000],
+]
+
+TEST_CASE_7 = [
+    {"include_background": True, "reduction": "mean", "get_not_nans": True},
+    {
+        "y_pred": torch.tensor(
+            [
+                [[[1.0, 1.0], [1.0, 0.0]], [[0.0, 1.0], [0.0, 0.0]], [[0.0, 1.0], [1.0, 1.0]]],
+                [[[1.0, 0.0], [1.0, 1.0]], [[0.0, 1.0], [1.0, 1.0]], [[0.0, 1.0], [1.0, 0.0]]],
+            ]
+        ),
+        "y": torch.tensor(
+            [
+                [[[1.0, 1.0], [1.0, 1.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]],
+                [[[1.0, 1.0], [1.0, 1.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]],
+            ]
+        ),
+    },
+    0.7500,
+]
+
+TEST_CASE_8 = [
+    {"include_background": False, "reduction": "sum_batch", "get_not_nans": True},
+    {
+        "y_pred": torch.tensor(
+            [
+                [[[1.0, 1.0], [1.0, 0.0]], [[0.0, 1.0], [0.0, 0.0]], [[0.0, 1.0], [1.0, 1.0]]],
+                [[[1.0, 0.0], [1.0, 1.0]], [[0.0, 1.0], [1.0, 1.0]], [[0.0, 1.0], [1.0, 0.0]]],
+            ]
+        ),
+        "y": torch.tensor(
+            [
+                [[[1.0, 1.0], [1.0, 1.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]],
+                [[[1.0, 1.0], [1.0, 1.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]],
+            ]
+        ),
+    },
+    [0.0000, 0.0000],
+]
+
+TEST_CASE_9 = [
+    {"y": torch.ones((2, 2, 3, 3)), "y_pred": torch.ones((2, 2, 3, 3))},
+    [[1.0000, 1.0000], [1.0000, 1.0000]],
+]
+
+TEST_CASE_10 = [
+    {"y": [torch.ones((2, 3, 3)), torch.ones((2, 3, 3))], "y_pred": [torch.ones((2, 3, 3)), torch.ones((2, 3, 3))]},
+    [[1.0000, 1.0000], [1.0000, 1.0000]],
+]
+
+TEST_CASE_11 = [
+    {"y": torch.zeros((2, 2, 3, 3)), "y_pred": torch.zeros((2, 2, 3, 3)), "ignore_empty": False},
+    [[1.0000, 1.0000], [1.0000, 1.0000]],
+]
+
+TEST_CASE_12 = [
+    {"y": torch.zeros((2, 2, 3, 3)), "y_pred": torch.ones((2, 2, 3, 3)), "ignore_empty": False},
+    [[0.0000, 0.0000], [0.0000, 0.0000]],
+]
+
+
+class TestComputeMeanIoU(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_9, TEST_CASE_11, TEST_CASE_12])
+    def test_value(self, input_data, expected_value):
+        result = compute_iou(**input_data)
+        np.testing.assert_allclose(result.cpu().numpy(), expected_value, atol=1e-4)
+        np.testing.assert_equal(result.device, input_data["y_pred"].device)
+
+    @parameterized.expand([TEST_CASE_3])
+    def test_nans(self, input_data, expected_value):
+        result = compute_iou(**input_data)
+        self.assertTrue(np.allclose(np.isnan(result.cpu().numpy()), expected_value))
+
+    # MeanIoU class tests
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_10])
+    def test_value_class(self, input_data, expected_value):
+        # same test as for compute_iou
+        vals = {}
+        vals["y_pred"] = input_data.pop("y_pred")
+        vals["y"] = input_data.pop("y")
+        iou_metric = MeanIoU(**input_data)
+        iou_metric(**vals)
+        result = iou_metric.aggregate(reduction="none")
+        np.testing.assert_allclose(result.cpu().numpy(), expected_value, atol=1e-4)
+
+    @parameterized.expand([TEST_CASE_4, TEST_CASE_5, TEST_CASE_6, TEST_CASE_7, TEST_CASE_8])
+    def test_nans_class(self, params, input_data, expected_value):
+        iou_metric = MeanIoU(**params)
+        iou_metric(**input_data)
+        result, _ = iou_metric.aggregate()
+        np.testing.assert_allclose(result.cpu().numpy(), expected_value, atol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/metrics/test_compute_mmd_metric.py

@@ -0,0 +1,56 @@
+# 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.metrics import MMDMetric
+
+TEST_CASES = [
+    [{"y_mapping": None}, {"y": torch.ones([3, 3, 144, 144]), "y_pred": torch.ones([3, 3, 144, 144])}, 0.0],
+    [{"y_mapping": None}, {"y": torch.ones([3, 3, 144, 144, 144]), "y_pred": torch.ones([3, 3, 144, 144, 144])}, 0.0],
+    [
+        {"y_mapping": lambda x: x.square()},
+        {"y": torch.ones([3, 3, 144, 144]), "y_pred": torch.ones([3, 3, 144, 144])},
+        0.0,
+    ],
+    [
+        {"y_mapping": lambda x: x.square()},
+        {"y": torch.ones([3, 3, 144, 144, 144]), "y_pred": torch.ones([3, 3, 144, 144, 144])},
+        0.0,
+    ],
+]
+
+
+class TestMMDMetric(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES)
+    def test_results(self, input_param, input_data, expected_val):
+        metric = MMDMetric(**input_param)
+        results = metric(**input_data)
+        np.testing.assert_allclose(results.detach().cpu().numpy(), expected_val, rtol=1e-4)
+
+    def test_if_inputs_different_shapes(self):
+        with self.assertRaises(ValueError):
+            MMDMetric()(torch.ones([3, 3, 144, 144]), torch.ones([3, 3, 145, 145]))
+
+    def test_if_inputs_have_one_sample(self):
+        with self.assertRaises(ValueError):
+            MMDMetric()(torch.ones([1, 3, 144, 144]), torch.ones([1, 3, 144, 144]))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/metrics/test_compute_multiscalessim_metric.py

@@ -0,0 +1,83 @@
+# 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 monai.metrics import MultiScaleSSIMMetric
+from monai.utils import set_determinism
+
+
+class TestMultiScaleSSIMMetric(unittest.TestCase):
+
+    def test2d_gaussian(self):
+        set_determinism(0)
+        preds = torch.abs(torch.randn(1, 1, 64, 64))
+        target = torch.abs(torch.randn(1, 1, 64, 64))
+        preds = preds / preds.max()
+        target = target / target.max()
+
+        metric = MultiScaleSSIMMetric(spatial_dims=2, data_range=1.0, kernel_type="gaussian", weights=[0.5, 0.5])
+        metric(preds, target)
+        result = metric.aggregate()
+        expected_value = 0.023176
+        self.assertTrue(expected_value - result.item() < 0.000001)
+
+    def test2d_uniform(self):
+        set_determinism(0)
+        preds = torch.abs(torch.randn(1, 1, 64, 64))
+        target = torch.abs(torch.randn(1, 1, 64, 64))
+        preds = preds / preds.max()
+        target = target / target.max()
+
+        metric = MultiScaleSSIMMetric(spatial_dims=2, data_range=1.0, kernel_type="uniform", weights=[0.5, 0.5])
+        metric(preds, target)
+        result = metric.aggregate()
+        expected_value = 0.022655
+        self.assertTrue(expected_value - result.item() < 0.000001)
+
+    def test3d_gaussian(self):
+        set_determinism(0)
+        preds = torch.abs(torch.randn(1, 1, 64, 64, 64))
+        target = torch.abs(torch.randn(1, 1, 64, 64, 64))
+        preds = preds / preds.max()
+        target = target / target.max()
+
+        metric = MultiScaleSSIMMetric(spatial_dims=3, data_range=1.0, kernel_type="gaussian", weights=[0.5, 0.5])
+        metric(preds, target)
+        result = metric.aggregate()
+        expected_value = 0.061796
+        self.assertTrue(expected_value - result.item() < 0.000001)
+
+    def input_ill_input_shape2d(self):
+        metric = MultiScaleSSIMMetric(spatial_dims=3, weights=[0.5, 0.5])
+
+        with self.assertRaises(ValueError):
+            metric(torch.randn(1, 1, 64, 64), torch.randn(1, 1, 64, 64))
+
+    def input_ill_input_shape3d(self):
+        metric = MultiScaleSSIMMetric(spatial_dims=2, weights=[0.5, 0.5])
+
+        with self.assertRaises(ValueError):
+            metric(torch.randn(1, 1, 64, 64, 64), torch.randn(1, 1, 64, 64, 64))
+
+    def small_inputs(self):
+        metric = MultiScaleSSIMMetric(spatial_dims=2)
+
+        with self.assertRaises(ValueError):
+            metric(torch.randn(1, 1, 16, 16, 16), torch.randn(1, 1, 16, 16, 16))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/metrics/test_compute_panoptic_quality.py

@@ -0,0 +1,113 @@
+# 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.metrics import PanopticQualityMetric, compute_panoptic_quality
+from tests.test_utils import SkipIfNoModule
+
+_device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+# TEST_FUNC_CASE related cases are used to test for single image with HW input shape
+
+sample_1 = torch.randint(low=0, high=5, size=(64, 64), device=_device)
+sample_2_pred = torch.as_tensor([[0, 1, 1, 1], [0, 0, 0, 0], [2, 0, 3, 3], [4, 2, 2, 0]], device=_device)
+sample_2_pred_need_remap = torch.as_tensor([[0, 7, 7, 7], [0, 0, 0, 0], [1, 0, 8, 8], [9, 1, 1, 0]], device=_device)
+sample_2_gt = torch.as_tensor([[1, 1, 2, 1], [0, 0, 0, 0], [1, 3, 0, 0], [4, 3, 3, 3]], device=_device)
+# if pred == gt, result should be 1
+TEST_FUNC_CASE_1 = [{"pred": sample_1, "gt": sample_1, "match_iou_threshold": 0.99}, 1.0]
+
+# test sample_2 when match_iou_threshold = 0.5
+TEST_FUNC_CASE_2 = [{"pred": sample_2_pred, "gt": sample_2_gt, "match_iou_threshold": 0.5}, 0.25]
+# test sample_2 when match_iou_threshold = 0.3, metric_name = "sq"
+TEST_FUNC_CASE_3 = [{"pred": sample_2_pred, "gt": sample_2_gt, "metric_name": "sq", "match_iou_threshold": 0.3}, 0.6]
+# test sample_2 when match_iou_threshold = 0.3, pred has different order, metric_name = "RQ"
+TEST_FUNC_CASE_4 = [
+    {"pred": sample_2_pred_need_remap, "gt": sample_2_gt, "metric_name": "RQ", "match_iou_threshold": 0.3},
+    0.75,
+]
+
+# TEST_CLS_CASE related cases are used to test the PanopticQualityMetric with B2HW input
+sample_3_pred = torch.as_tensor(
+    [
+        [[[2, 0, 1], [2, 1, 1], [0, 1, 1]], [[0, 1, 3], [0, 0, 0], [1, 2, 1]]],
+        [[[1, 1, 1], [3, 2, 0], [3, 2, 1]], [[1, 1, 3], [3, 1, 1], [0, 3, 0]]],
+    ],
+    device=_device,
+)
+
+sample_3_gt = torch.as_tensor(
+    [
+        [[[2, 0, 0], [2, 0, 0], [2, 2, 3]], [[3, 3, 3], [3, 2, 1], [2, 2, 3]]],
+        [[[1, 1, 1], [0, 0, 3], [0, 0, 3]], [[0, 1, 3], [2, 1, 0], [3, 0, 3]]],
+    ],
+    device=_device,
+)
+
+# test sample_3, num_classes = 3, match_iou_threshold = 0.5
+TEST_CLS_CASE_1 = [{"num_classes": 3, "match_iou_threshold": 0.5}, sample_3_pred, sample_3_gt, (0.0, 0.0, 0.25)]
+
+# test sample_3, num_classes = 3, match_iou_threshold = 0.3
+TEST_CLS_CASE_2 = [{"num_classes": 3, "match_iou_threshold": 0.3}, sample_3_pred, sample_3_gt, (0.25, 0.5, 0.25)]
+
+# test sample_3, num_classes = 4, match_iou_threshold = 0.3, metric_name = "segmentation_quality"
+TEST_CLS_CASE_3 = [
+    {"num_classes": 4, "match_iou_threshold": 0.3, "metric_name": "segmentation_quality"},
+    sample_3_pred,
+    sample_3_gt,
+    (0.5, 0.5, 1.0, 0.0),
+]
+
+# test sample_3, num_classes = 3, match_iou_threshold = 0.4, reduction = "none", metric_name = "Recognition Quality"
+TEST_CLS_CASE_4 = [
+    {"num_classes": 3, "reduction": "none", "match_iou_threshold": 0.4, "metric_name": "Recognition Quality"},
+    sample_3_pred,
+    sample_3_gt,
+    [[0.0, 1.0, 0.0], [0.6667, 0.0, 0.4]],
+]
+
+# test sample_3, num_classes = 3, match_iou_threshold = 0.4, reduction = "none", multiple metrics
+TEST_CLS_CASE_5 = [
+    {"num_classes": 3, "reduction": "none", "match_iou_threshold": 0.4, "metric_name": ["Recognition Quality", "pq"]},
+    sample_3_pred,
+    sample_3_gt,
+    [torch.as_tensor([[0.0, 1.0, 0.0], [0.6667, 0.0, 0.4]]), torch.as_tensor([[0.0, 0.5, 0.0], [0.3333, 0.0, 0.4]])],
+]
+
+
+@SkipIfNoModule("scipy.optimize")
+class TestPanopticQualityMetric(unittest.TestCase):
+    @parameterized.expand([TEST_FUNC_CASE_1, TEST_FUNC_CASE_2, TEST_FUNC_CASE_3, TEST_FUNC_CASE_4])
+    def test_value(self, input_params, expected_value):
+        result = compute_panoptic_quality(**input_params)
+        np.testing.assert_allclose(result.cpu().detach().item(), expected_value, atol=1e-4)
+        np.testing.assert_equal(result.device, input_params["pred"].device)
+
+    @parameterized.expand([TEST_CLS_CASE_1, TEST_CLS_CASE_2, TEST_CLS_CASE_3, TEST_CLS_CASE_4, TEST_CLS_CASE_5])
+    def test_value_class(self, input_params, y_pred, y_gt, expected_value):
+        metric = PanopticQualityMetric(**input_params)
+        metric(y_pred, y_gt)
+        outputs = metric.aggregate()
+        if isinstance(outputs, list):
+            for output, value in zip(outputs, expected_value):
+                np.testing.assert_allclose(output.cpu().numpy(), np.asarray(value), atol=1e-4)
+        else:
+            np.testing.assert_allclose(outputs.cpu().numpy(), np.asarray(expected_value), atol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/metrics/test_compute_regression_metrics.py

@@ -0,0 +1,196 @@
+# 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 functools import partial
+
+import numpy as np
+import torch
+
+from monai.metrics import MAEMetric, MSEMetric, PSNRMetric, RMSEMetric
+from monai.utils import set_determinism
+
+
+# define a numpy flatten function that only preserves batch dimension
+def flatten(data):
+    return np.reshape(data, [data.shape[0], -1])
+
+
+# define metrics computation truth functions to check our monai metrics against
+def msemetric_np(y_pred, y):
+    return np.mean((flatten(y_pred) - flatten(y)) ** 2)
+
+
+def maemetric_np(y_pred, y):
+    return np.mean(np.abs(flatten(y_pred) - flatten(y)))
+
+
+def rmsemetric_np(y_pred, y):
+    return np.mean(np.sqrt(np.mean((flatten(y_pred) - flatten(y)) ** 2, axis=1)))
+
+
+def psnrmetric_np(max_val, y_pred, y):
+    mse = np.mean((flatten(y_pred) - flatten(y)) ** 2, axis=1)
+    return np.mean(20 * np.log10(max_val) - 10 * np.log10(mse))
+
+
+class TestRegressionMetrics(unittest.TestCase):
+
+    def test_shape_reduction(self):
+        set_determinism(seed=123)
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        # regression metrics to check
+        metrics = [MSEMetric, MAEMetric, RMSEMetric, partial(PSNRMetric, max_val=1.0)]
+
+        # define variations in batch/base_dims/spatial_dims
+        batch_dims = [1, 2, 4, 16]
+        base_dims = [16, 32, 64]
+        spatial_dims = [2, 3, 4]
+
+        # iterate over all variations and check shapes for different reduction functions
+        for batch in batch_dims:
+            for spatial in spatial_dims:
+                for base in base_dims:
+                    # create random tensors
+                    in_tensor = torch.rand((batch,) + (base,) * (spatial - 1)).to(device)
+
+                    # iterate over regression metrics, check shape for diff. reduction func
+                    for mt_fn in metrics:
+                        mt = mt_fn(reduction="mean")
+                        mt(in_tensor, in_tensor)
+                        out_tensor = mt.aggregate()
+                        self.assertEqual(len(out_tensor.shape), 1)
+
+                        mt = mt_fn(reduction="sum")
+                        mt(in_tensor, in_tensor)
+                        out_tensor = mt.aggregate()
+                        self.assertEqual(len(out_tensor.shape), 0)
+
+                        mt = mt_fn(reduction="sum")  # test reduction arg overriding
+                        mt(in_tensor, in_tensor)
+                        out_tensor = mt.aggregate(reduction="mean_channel")
+                        self.assertEqual(len(out_tensor.shape), 1)
+                        self.assertEqual(out_tensor.shape[0], batch)
+
+                        mt = mt_fn(reduction="sum_channel")
+                        mt(in_tensor, in_tensor)
+                        out_tensor = mt.aggregate()
+                        self.assertEqual(len(out_tensor.shape), 1)
+                        self.assertEqual(out_tensor.shape[0], batch)
+
+    def test_compare_numpy(self):
+        set_determinism(seed=123)
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        # regression metrics to check + truth metric function in numpy
+        metrics = [MSEMetric, MAEMetric, RMSEMetric, partial(PSNRMetric, max_val=1.0)]
+        metrics_np = [msemetric_np, maemetric_np, rmsemetric_np, partial(psnrmetric_np, max_val=1.0)]
+
+        # define variations in batch/base_dims/spatial_dims
+        batch_dims = [1, 2, 4, 16]
+        base_dims = [16, 32, 64]
+        spatial_dims = [2, 3, 4]
+
+        # iterate over all variations and check shapes for different reduction functions
+        for batch in batch_dims:
+            for spatial in spatial_dims:
+                for base in base_dims:
+                    # create random tensors
+                    in_tensor_a = torch.rand((batch,) + (base,) * (spatial - 1)).to(device)
+                    in_tensor_b = torch.rand((batch,) + (base,) * (spatial - 1)).to(device)
+
+                    # check metrics
+                    for mt_fn, mt_fn_np in zip(metrics, metrics_np):
+                        mt = mt_fn()
+                        mt(y_pred=in_tensor_a, y=in_tensor_b)
+                        out_tensor = mt.aggregate(reduction="mean")
+                        out_np = mt_fn_np(y_pred=in_tensor_a.cpu().numpy(), y=in_tensor_b.cpu().numpy())
+
+                        np.testing.assert_allclose(out_tensor.cpu().numpy(), out_np, atol=1e-4)
+
+    def test_ill_shape(self):
+        set_determinism(seed=123)
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        # regression metrics to check + truth metric function in numpy
+        metrics = [MSEMetric, MAEMetric, RMSEMetric, partial(PSNRMetric, max_val=1.0)]
+        basedim = 10
+
+        # too small shape
+        with self.assertRaises(ValueError):
+            in_tensor = torch.rand((basedim,)).to(device)
+            for mt_fn in metrics:
+                mt_fn()(in_tensor, in_tensor)
+
+        # different shape for pred/target
+        with self.assertRaises(ValueError):
+            in_tensor_a = torch.rand((basedim,)).to(device)
+            in_tensor_b = torch.rand((basedim, basedim)).to(device)
+            for mt_fn in metrics:
+                mt_fn()(y_pred=in_tensor_a, y=in_tensor_b)
+
+    def test_same_input(self):
+        set_determinism(seed=123)
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        metrics = [MSEMetric, MAEMetric, RMSEMetric, partial(PSNRMetric, max_val=1.0)]
+        results = [0.0, 0.0, 0.0, float("inf")]
+
+        # define variations in batch/base_dims/spatial_dims
+        batch_dims = [1, 2, 4, 16]
+        base_dims = [16, 32, 64]
+        spatial_dims = [2, 3, 4]
+
+        # iterate over all variations and check shapes for different reduction functions
+        for batch in batch_dims:
+            for spatial in spatial_dims:
+                for base in base_dims:
+                    # create random tensors
+                    in_tensor = torch.rand((batch,) + (base,) * (spatial - 1)).to(device)
+
+                    # check metrics
+                    for mt_fn, rs in zip(metrics, results):
+                        mt = mt_fn(reduction="mean")
+                        mt(in_tensor, in_tensor)
+                        out_tensor = mt.aggregate()
+                        np.testing.assert_allclose(out_tensor.cpu(), rs, atol=1e-4)
+
+    def test_diff_input(self):
+        set_determinism(seed=123)
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        metrics = [MSEMetric, MAEMetric, RMSEMetric, partial(PSNRMetric, max_val=1.0)]
+        results = [1.0, 1.0, 1.0, 0.0]
+
+        # define variations in batch/base_dims/spatial_dims
+        batch_dims = [1, 2, 4, 16]
+        base_dims = [16, 32, 64]
+        spatial_dims = [2, 3, 4]
+
+        # iterate over all variations and check shapes for different reduction functions
+        for batch in batch_dims:
+            for spatial in spatial_dims:
+                for base in base_dims:
+                    # create random tensors
+                    in_tensor_a = torch.zeros((batch,) + (base,) * (spatial - 1)).to(device)
+                    in_tensor_b = torch.ones((batch,) + (base,) * (spatial - 1)).to(device)
+
+                    # check metrics
+                    for mt_fn, rs in zip(metrics, results):
+                        mt = mt_fn(reduction="mean")
+                        mt(in_tensor_a, in_tensor_b)
+                        out_tensor = mt.aggregate()
+                        np.testing.assert_allclose(out_tensor.cpu(), rs, atol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()