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

tests/metrics/test_label_quality_score.py

@@ -0,0 +1,134 @@
+# 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 LabelQualityScore, label_quality_score
+
+_device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+# keep background, 1D Case
+TEST_CASE_1 = [  # y_pred (3, 1, 3), expected out (0.0)
+    {
+        "y_pred": torch.tensor([[[1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0]]], device=_device),
+        "y": torch.tensor([[[1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0]]], device=_device),
+        "include_background": True,
+        "scalar_reduction": "sum",
+    },
+    [0.0, 0.0, 0.0],
+]
+
+# keep background, 2D Case
+TEST_CASE_2 = [  # y_pred (1, 1, 2, 2), expected out (0.0)
+    {
+        "y_pred": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]]]], device=_device),
+        "y": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]]]], device=_device),
+        "include_background": True,
+        "scalar_reduction": "sum",
+    },
+    [0.0],
+]
+
+# keep background, 3D Case
+TEST_CASE_3 = [  # y_pred (1, 1, 1, 2, 2), expected out (0.0)
+    {
+        "y_pred": torch.tensor([[[[[1.0, 1.0], [1.0, 1.0]]]]], device=_device),
+        "y": torch.tensor([[[[[1.0, 1.0], [1.0, 1.0]]]]], device=_device),
+        "include_background": True,
+        "scalar_reduction": "sum",
+    },
+    [0.0],
+]
+
+# keep background, 2D Case
+TEST_CASE_4 = [  # y_pred (1, 1, 2, 2), expected out (0.0)
+    {
+        "y_pred": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]]]], device=_device),
+        "y": torch.tensor([[[[0.0, 0.0], [0.0, 0.0]]]], device=_device),
+        "include_background": True,
+        "scalar_reduction": "sum",
+    },
+    [4.0],
+]
+
+TEST_CASE_5 = [  # y_pred (1, 1, 2, 2), expected out (0.0)
+    {
+        "y_pred": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]]]], device=_device),
+        "y": torch.tensor([[[[0.0, 0.0], [0.0, 0.0]]]], device=_device),
+        "include_background": True,
+        "scalar_reduction": "mean",
+    },
+    [1.0],
+]
+
+# Spatial Map Test Case for 3D Case
+TEST_CASE_6 = [  # y_pred (1, 1, 2, 2, 2), expected out all (0.0) map of 2x2x2
+    {
+        "y_pred": torch.tensor([[[[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]]]], device=_device),
+        "y": torch.tensor([[[[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]]]], device=_device),
+        "include_background": True,
+        "scalar_reduction": "none",
+    },
+    [[[[[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]]]],
+]
+
+# Spatial Map Test Case for 2D Case
+TEST_CASE_7 = [  # y_pred (1, 1, 2, 2)
+    {
+        "y_pred": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]]], device=_device),
+        "y": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]]], device=_device),
+        "include_background": True,
+        "scalar_reduction": "none",
+    },
+    [[[[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]]],
+]
+
+
+class TestLabelQualityScore(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5])
+    def test_value(self, input_data, expected_value):
+        result = label_quality_score(**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_6, TEST_CASE_7])
+    def test_spatial_case(self, input_data, expected_value):
+        result = label_quality_score(**input_data)
+        np.testing.assert_allclose(result.cpu().numpy(), expected_value, atol=1e-4)
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5])
+    def test_value_class(self, input_data, expected_value):
+        vals = {}
+        vals["y_pred"] = input_data.pop("y_pred")
+        vals["y"] = input_data.pop("y")
+        comp_var = LabelQualityScore(**input_data)
+        result = comp_var(**vals)
+        np.testing.assert_allclose(result.cpu().numpy(), expected_value, atol=1e-4)
+
+    @parameterized.expand([TEST_CASE_6, TEST_CASE_7])
+    def test_spatial_case_class(self, input_data, expected_value):
+        vals = {}
+        vals["y_pred"] = input_data.pop("y_pred")
+        vals["y"] = input_data.pop("y")
+        comp_var = LabelQualityScore(**input_data)
+        result = comp_var(**vals)
+        np.testing.assert_allclose(result.cpu().numpy(), expected_value, atol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/metrics/test_loss_metric.py

@@ -0,0 +1,57 @@
+# 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 DiceLoss
+from monai.metrics import LossMetric
+
+_device = "cuda:0" if torch.cuda.is_available() else "cpu"
+TEST_CASE_1 = [  # y (1, 1, 2, 2), y_pred (1, 1, 2, 2), expected out (1, 1)
+    {
+        "loss_class": DiceLoss,
+        "loss_kwargs": {"include_background": True},
+        "reduction": "mean",
+        "get_not_nans": False,
+        "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.2],
+]
+
+
+class TestComputeLossMetric(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_1])
+    def test_value_class(self, input_data, expected_value):
+        loss_fn = input_data["loss_class"](**input_data["loss_kwargs"])
+        loss_metric = LossMetric(
+            loss_fn=loss_fn, reduction=input_data["reduction"], get_not_nans=input_data["get_not_nans"]
+        )
+
+        loss_metric(y_pred=input_data.get("y_pred"), y=input_data.get("y"))
+        loss_metric(y_pred=input_data.get("y_pred"), y=input_data.get("y"))
+        result = loss_metric.aggregate()
+        np.testing.assert_allclose(result.cpu().numpy(), expected_value, atol=1e-4)
+        loss_metric.reset()
+        result = loss_metric.aggregate()
+        np.testing.assert_allclose(result.cpu().numpy(), 0.0, atol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/metrics/test_metrics_reloaded.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
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.metrics import MetricsReloadedBinary, MetricsReloadedCategorical
+from monai.utils import optional_import
+
+_, has_metrics = optional_import("MetricsReloaded")
+
+# shape: (1, 1, 2, 2)
+y_pred = torch.tensor([[[[1.0, 0.0], [0.0, 1.0]]]])
+y = torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]])
+TEST_CASES_BINARY = [
+    [{"metric_name": "False Positives"}, [y_pred, y], 0.0],
+    [{"metric_name": "False Negatives"}, [y_pred, y], 1.0],
+    [{"metric_name": "True Positives"}, [y_pred, y], 2.0],
+    [{"metric_name": "True Negatives"}, [y_pred, y], 1.0],
+    [{"metric_name": "Youden Index"}, [y_pred, y], 0.666654],
+    [{"metric_name": "Sensitivity"}, [y_pred, y], 0.666664],
+    [{"metric_name": "Specificity"}, [y_pred, y], 0.99999],
+    [{"metric_name": "Balanced Accuracy"}, [y_pred, y], 0.833327],
+    [{"metric_name": "Accuracy"}, [y_pred, y], 0.75],
+    [{"metric_name": "False Positive Rate"}, [y_pred, y], 0.0],
+    [{"metric_name": "Normalised Expected Cost"}, [y_pred, y], 0.333333],
+    [{"metric_name": "Matthews Correlation Coefficient"}, [y_pred, y], 0.57735],
+    [{"metric_name": "Cohens Kappa"}, [y_pred, y], 0.5],
+    [{"metric_name": "Positive Likelihood Ratio"}, [y_pred, y], 66576.03],
+    [{"metric_name": "Prediction Overlaps Reference"}, [y_pred, y], 1.0],
+    [{"metric_name": "Positive Predictive Value"}, [y_pred, y], 0.999995],
+    [{"metric_name": "Recall"}, [y_pred, y], 0.666664],
+    [{"metric_name": "FBeta"}, [y_pred, y], 0.799992],
+    [{"metric_name": "Net Benefit Treated"}, [y_pred, y], 0.5],
+    [{"metric_name": "Negative Predictive Values"}, [y_pred, y], 0.5],
+    [{"metric_name": "Dice Score"}, [y_pred, y], 0.799992],
+    [{"metric_name": "False Positives Per Image"}, [y_pred, y], 0.0],
+    [{"metric_name": "Intersection Over Reference"}, [y_pred, y], 0.666664],
+    [{"metric_name": "Intersection Over Union"}, [y_pred, y], 0.666664],
+    [{"metric_name": "Volume Difference"}, [y_pred, y], 0.333333],
+    [{"metric_name": "Topology Precision"}, [y_pred, y], 1.0],
+    [{"metric_name": "Topology Sensitivity"}, [y_pred, y], 1.0],
+    [{"metric_name": "Centreline Dice Score"}, [y_pred, y], 1.0],
+    [{"metric_name": "Boundary IoU"}, [y_pred, y], 0.666667],
+    [{"metric_name": "Normalised Surface Distance"}, [y_pred, y], 1.0],
+    [{"metric_name": "Average Symmetric Surface Distance"}, [y_pred, y], 0.2],
+    [{"metric_name": "Mean Average Surfance Distance"}, [y_pred, y], 0.166666],
+    [{"metric_name": "Hausdorff Distance"}, [y_pred, y], 1.0],
+    [{"metric_name": "xTh Percentile Hausdorff Distance"}, [y_pred, y], 0.9],
+]
+
+# shape: (1, 3, 2, 2)
+y_pred = torch.tensor([[[[0, 0], [0, 1]], [[0, 0], [0, 0]], [[1, 1], [1, 0]]]])
+y = torch.tensor([[[[1, 0], [0, 1]], [[0, 1], [0, 0]], [[0, 0], [1, 0]]]])
+TEST_CASES_CATEGORICAL = [
+    [{"metric_name": "Balanced Accuracy"}, [y_pred, y], 0.5],
+    [{"metric_name": "Weighted Cohens Kappa"}, [y_pred, y], 0.272727],
+    [{"metric_name": "Matthews Correlation Coefficient"}, [y_pred, y], 0.387298],
+    [{"metric_name": "Expected Cost"}, [y_pred, y], 0.5],
+    [{"metric_name": "Normalised Expected Cost"}, [y_pred, y], 0.75],
+]
+
+
+@unittest.skipIf(not has_metrics, "MetricsReloaded not available.")
+class TestMetricsReloaded(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES_BINARY)
+    def test_binary(self, input_param, input_data, expected_val):
+        metric = MetricsReloadedBinary(**input_param)
+        result = metric(*input_data)
+        np.testing.assert_allclose(
+            result.detach().cpu().numpy(), expected_val, rtol=1e-5, err_msg=input_param["metric_name"]
+        )
+
+    @parameterized.expand(TEST_CASES_CATEGORICAL)
+    def test_categorical(self, input_param, input_data, expected_val):
+        metric = MetricsReloadedCategorical(**input_param)
+        result = metric(*input_data)
+        np.testing.assert_allclose(result.detach().cpu().numpy(), expected_val, rtol=1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/metrics/test_ssim_metric.py

@@ -0,0 +1,78 @@
+# 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.regression import SSIMMetric, compute_ssim_and_cs
+from monai.utils import set_determinism
+
+
+class TestSSIMMetric(unittest.TestCase):
+
+    def test2d_gaussian(self):
+        set_determinism(0)
+        preds = torch.abs(torch.randn(2, 3, 16, 16))
+        target = torch.abs(torch.randn(2, 3, 16, 16))
+        preds = preds / preds.max()
+        target = target / target.max()
+
+        metric = SSIMMetric(spatial_dims=2, data_range=1.0, kernel_type="gaussian")
+        metric(preds, target)
+        result = metric.aggregate()
+        expected_value = 0.045415
+        self.assertTrue(expected_value - result.item() < 0.000001)
+
+    def test2d_uniform(self):
+        set_determinism(0)
+        preds = torch.abs(torch.randn(2, 3, 16, 16))
+        target = torch.abs(torch.randn(2, 3, 16, 16))
+        preds = preds / preds.max()
+        target = target / target.max()
+
+        metric = SSIMMetric(spatial_dims=2, data_range=1.0, kernel_type="uniform")
+        metric(preds, target)
+        result = metric.aggregate()
+        expected_value = 0.050103
+        self.assertTrue(expected_value - result.item() < 0.000001)
+
+    def test3d_gaussian(self):
+        set_determinism(0)
+        preds = torch.abs(torch.randn(2, 3, 16, 16, 16))
+        target = torch.abs(torch.randn(2, 3, 16, 16, 16))
+        preds = preds / preds.max()
+        target = target / target.max()
+
+        metric = SSIMMetric(spatial_dims=3, data_range=1.0, kernel_type="gaussian")
+        metric(preds, target)
+        result = metric.aggregate()
+        expected_value = 0.017644
+        self.assertTrue(expected_value - result.item() < 0.000001)
+
+    def input_ill_input_shape(self):
+        with self.assertRaises(ValueError):
+            metric = SSIMMetric(spatial_dims=3)
+            metric(torch.randn(1, 1, 16, 16), torch.randn(1, 1, 16, 16))
+
+        with self.assertRaises(ValueError):
+            metric = SSIMMetric(spatial_dims=2)
+            metric(torch.randn(1, 1, 16, 16, 16), torch.randn(1, 1, 16, 16, 16))
+
+    def mismatch_y_pred_and_y(self):
+        with self.assertRaises(ValueError):
+            compute_ssim_and_cs(y_pred=torch.randn(1, 1, 16, 8), y=torch.randn(1, 1, 16, 16), spatial_dims=2)
+
+
+if __name__ == "__main__":
+    unittest.main()