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

tests/losses/test_masked_dice_loss.py

@@ -0,0 +1,152 @@
+# 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 MaskedDiceLoss
+
+TEST_CASES = [
+    [  # shape: (1, 1, 2, 2), (1, 1, 2, 2)
+        {"include_background": True, "sigmoid": True, "smooth_nr": 1e-6, "smooth_dr": 1e-6},
+        {
+            "input": torch.tensor([[[[1.0, -1.0], [-1.0, 1.0]]]]),
+            "target": torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]]),
+            "mask": torch.tensor([[[[0.0, 0.0], [1.0, 1.0]]]]),
+        },
+        0.500,
+    ],
+    [  # shape: (2, 1, 2, 2), (2, 1, 2, 2)
+        {"include_background": True, "sigmoid": True, "smooth_nr": 1e-4, "smooth_dr": 1e-4},
+        {
+            "input": torch.tensor([[[[1.0, -1.0], [-1.0, 1.0]]], [[[1.0, -1.0], [-1.0, 1.0]]]]),
+            "target": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]]], [[[1.0, 0.0], [1.0, 0.0]]]]),
+            "mask": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]]], [[[1.0, 1.0], [0.0, 0.0]]]]),
+        },
+        0.422969,
+    ],
+    [  # shape: (2, 2, 3), (2, 1, 3)
+        {"include_background": False, "to_onehot_y": True, "smooth_nr": 0, "smooth_dr": 0},
+        {
+            "input": torch.tensor([[[1.0, 1.0, 0.0], [0.0, 0.0, 1.0]], [[1.0, 0.0, 1.0], [0.0, 1.0, 0.0]]]),
+            "target": torch.tensor([[[0.0, 0.0, 1.0]], [[0.0, 1.0, 0.0]]]),
+            "mask": torch.tensor([[[1.0, 1.0, 1.0]], [[0.0, 1.0, 0.0]]]),
+        },
+        0.0,
+    ],
+    [  # shape: (2, 2, 3), (2, 1, 3)
+        {"include_background": True, "to_onehot_y": True, "sigmoid": True, "smooth_nr": 1e-4, "smooth_dr": 1e-4},
+        {
+            "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]]]),
+            "target": torch.tensor([[[1.0, 0.0, 0.0]], [[1.0, 1.0, 0.0]]]),
+            "mask": torch.tensor([[[1.0, 1.0, 0.0]]]),
+        },
+        0.47033,
+    ],
+    [  # shape: (2, 2, 3), (2, 1, 3)
+        {
+            "include_background": True,
+            "to_onehot_y": True,
+            "sigmoid": True,
+            "reduction": "none",
+            "smooth_nr": 1e-4,
+            "smooth_dr": 1e-4,
+        },
+        {
+            "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]]]),
+            "target": torch.tensor([[[1.0, 0.0, 0.0]], [[1.0, 1.0, 0.0]]]),
+        },
+        [[[0.296529], [0.415136]], [[0.599976], [0.428559]]],
+    ],
+    [  # shape: (2, 2, 3), (2, 1, 3)
+        {"include_background": True, "to_onehot_y": True, "softmax": True, "smooth_nr": 1e-4, "smooth_dr": 1e-4},
+        {
+            "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]]]),
+            "target": torch.tensor([[[1.0, 0.0, 0.0]], [[1.0, 1.0, 0.0]]]),
+        },
+        0.383713,
+    ],
+    [  # shape: (2, 2, 3), (2, 1, 3)
+        {
+            "include_background": True,
+            "to_onehot_y": True,
+            "softmax": True,
+            "reduction": "sum",
+            "smooth_nr": 1e-4,
+            "smooth_dr": 1e-4,
+        },
+        {
+            "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]]]),
+            "target": torch.tensor([[[1.0, 0.0, 0.0]], [[1.0, 1.0, 0.0]]]),
+        },
+        1.534853,
+    ],
+    [  # shape: (1, 1, 2, 2), (1, 1, 2, 2)
+        {"include_background": True, "sigmoid": True, "smooth_nr": 1e-6, "smooth_dr": 1e-6},
+        {"input": torch.tensor([[[[1.0, -1.0], [-1.0, 1.0]]]]), "target": torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]])},
+        0.307576,
+    ],
+    [  # shape: (1, 1, 2, 2), (1, 1, 2, 2)
+        {"include_background": True, "sigmoid": True, "squared_pred": True, "smooth_nr": 1e-5, "smooth_dr": 1e-5},
+        {"input": torch.tensor([[[[1.0, -1.0], [-1.0, 1.0]]]]), "target": torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]])},
+        0.178337,
+    ],
+    [  # shape: (1, 1, 2, 2), (1, 1, 2, 2)
+        {"include_background": True, "sigmoid": True, "jaccard": True, "smooth_nr": 1e-5, "smooth_dr": 1e-5},
+        {"input": torch.tensor([[[[1.0, -1.0], [-1.0, 1.0]]]]), "target": torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]])},
+        0.470451,
+    ],
+]
+
+
+class TestDiceLoss(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES)
+    def test_shape(self, input_param, input_data, expected_val):
+        result = MaskedDiceLoss(**input_param).forward(**input_data)
+        np.testing.assert_allclose(result.detach().cpu().numpy(), expected_val, rtol=1e-5)
+
+    def test_ill_shape(self):
+        loss = MaskedDiceLoss()
+        with self.assertRaisesRegex(AssertionError, ""):
+            loss.forward(torch.ones((1, 2, 3)), torch.ones((4, 5, 6)))
+
+    def test_ill_opts(self):
+        with self.assertRaisesRegex(ValueError, ""):
+            MaskedDiceLoss(sigmoid=True, softmax=True)
+        chn_input = torch.ones((1, 1, 3))
+        chn_target = torch.ones((1, 1, 3))
+        with self.assertRaisesRegex(ValueError, ""):
+            MaskedDiceLoss(reduction="unknown")(chn_input, chn_target)
+        with self.assertRaisesRegex(ValueError, ""):
+            MaskedDiceLoss(reduction=None)(chn_input, chn_target)
+
+    def test_input_warnings(self):
+        chn_input = torch.ones((1, 1, 3))
+        chn_target = torch.ones((1, 1, 3))
+        with self.assertWarns(Warning):
+            loss = MaskedDiceLoss(include_background=False)
+            loss.forward(chn_input, chn_target)
+        with self.assertWarns(Warning):
+            loss = MaskedDiceLoss(softmax=True)
+            loss.forward(chn_input, chn_target)
+        with self.assertWarns(Warning):
+            loss = MaskedDiceLoss(to_onehot_y=True)
+            loss.forward(chn_input, chn_target)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/losses/test_masked_loss.py

@@ -0,0 +1,87 @@
+# 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.dice import DiceFocalLoss, DiceLoss
+from monai.losses.spatial_mask import MaskedLoss
+from monai.utils import set_determinism
+from tests.test_utils import test_script_save
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+TEST_CASES = [
+    [
+        {
+            "loss": DiceFocalLoss,
+            "weight": torch.tensor([1.0, 1.0, 2.0]),
+            "gamma": 0.1,
+            "lambda_focal": 0.5,
+            "include_background": True,
+            "to_onehot_y": True,
+            "reduction": "sum",
+        },
+        [17.1679, 15.5623],
+    ]
+]
+
+
+class TestMaskedLoss(unittest.TestCase):
+    def setUp(self):
+        set_determinism(0)
+
+    def tearDown(self):
+        set_determinism(None)
+
+    @parameterized.expand(TEST_CASES)
+    def test_shape(self, input_param, expected_val):
+        size = [3, 3, 5, 5]
+        label = torch.randint(low=0, high=2, size=size)
+        label = torch.argmax(label, dim=1, keepdim=True)
+        pred = torch.randn(size)
+        result = MaskedLoss(**input_param)(pred, label, None)
+        out = result.detach().cpu().numpy()
+        self.assertTrue(np.allclose(out, expected_val[0]))
+
+        mask = torch.randint(low=0, high=2, size=label.shape)
+        result = MaskedLoss(**input_param)(pred, label, mask)
+        out = result.detach().cpu().numpy()
+        self.assertTrue(np.allclose(out, expected_val[1]))
+
+    def test_ill_opts(self):
+        with self.assertRaisesRegex(ValueError, ""):
+            MaskedLoss(loss=[])
+
+        dice_loss = DiceLoss(include_background=True, sigmoid=True, smooth_nr=1e-5, smooth_dr=1e-5)
+        with self.assertRaisesRegex(ValueError, ""):
+            masked = MaskedLoss(loss=dice_loss)
+            masked(input=torch.zeros((3, 1, 2, 2)), target=torch.zeros((3, 1, 2, 2)), mask=torch.zeros((3, 3, 2, 2)))
+        with self.assertRaisesRegex(ValueError, ""):
+            masked = MaskedLoss(loss=dice_loss)
+            masked(input=torch.zeros((3, 3, 2, 2)), target=torch.zeros((3, 2, 2, 2)), mask=torch.zeros((3, 3, 2, 2)))
+
+    def test_script(self):
+        input_param, expected_val = TEST_CASES[0]
+        size = [3, 3, 5, 5]
+        label = torch.randint(low=0, high=2, size=size)
+        label = torch.argmax(label, dim=1, keepdim=True)
+        pred = torch.randn(size)
+        loss = MaskedLoss(**input_param)
+        test_script_save(loss, pred, label)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/losses/test_multi_scale.py

@@ -0,0 +1,86 @@
+# 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.losses.multi_scale import MultiScaleLoss
+from tests.test_utils import test_script_save
+
+dice_loss = DiceLoss(include_background=True, sigmoid=True, smooth_nr=1e-5, smooth_dr=1e-5)
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+TEST_CASES = [
+    [
+        {"loss": dice_loss, "scales": None, "kernel": "gaussian"},
+        {
+            "y_pred": torch.tensor([[[[1.0, -1.0], [-1.0, 1.0]]]], device=device),
+            "y_true": torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]], device=device),
+        },
+        0.307576,
+    ],
+    [
+        {"loss": dice_loss, "scales": [0, 1], "kernel": "gaussian"},
+        {
+            "y_pred": torch.tensor([[[[1.0, -1.0], [-1.0, 1.0]]]], device=device),
+            "y_true": torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]], device=device),
+        },
+        0.463116,
+    ],
+    [
+        {"loss": dice_loss, "scales": [0, 1, 2], "kernel": "cauchy"},
+        {
+            "y_pred": torch.tensor([[[[[1.0, -1.0], [-1.0, 1.0]]]]], device=device),
+            "y_true": torch.tensor([[[[[1.0, 0.0], [1.0, 1.0]]]]], device=device),
+        },
+        0.715228,
+    ],
+]
+
+
+class TestMultiScale(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_shape(self, input_param, input_data, expected_val):
+        result = MultiScaleLoss(**input_param).forward(**input_data)
+        np.testing.assert_allclose(result.detach().cpu().numpy(), expected_val, rtol=1e-5)
+
+    @parameterized.expand(
+        [
+            ({"loss": dice_loss, "kernel": "none"}, None, None),  # kernel_none
+            ({"loss": dice_loss, "scales": [-1]}, torch.ones((1, 1, 3)), torch.ones((1, 1, 3))),  # scales_negative
+            (
+                {"loss": dice_loss, "scales": [-1], "reduction": "none"},
+                torch.ones((1, 1, 3)),
+                torch.ones((1, 1, 3)),
+            ),  # scales_negative_reduction_none
+        ]
+    )
+    def test_ill_opts(self, kwargs, input, target):
+        if input is None and target is None:
+            with self.assertRaisesRegex(ValueError, ""):
+                MultiScaleLoss(**kwargs)
+        else:
+            with self.assertRaisesRegex(ValueError, ""):
+                MultiScaleLoss(**kwargs)(input, target)
+
+    def test_script(self):
+        input_param, input_data, expected_val = TEST_CASES[0]
+        loss = MultiScaleLoss(**input_param)
+        test_script_save(loss, input_data["y_pred"], input_data["y_true"])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/losses/test_nacl_loss.py

@@ -0,0 +1,167 @@
+# 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 NACLLoss
+
+inputs = torch.tensor(
+    [
+        [
+            [
+                [0.1498, 0.1158, 0.3996, 0.3730],
+                [0.2155, 0.1585, 0.8541, 0.8579],
+                [0.6640, 0.2424, 0.0774, 0.0324],
+                [0.0580, 0.2180, 0.3447, 0.8722],
+            ],
+            [
+                [0.3908, 0.9366, 0.1779, 0.1003],
+                [0.9630, 0.6118, 0.4405, 0.7916],
+                [0.5782, 0.9515, 0.4088, 0.3946],
+                [0.7860, 0.3910, 0.0324, 0.9568],
+            ],
+            [
+                [0.0759, 0.0238, 0.5570, 0.1691],
+                [0.2703, 0.7722, 0.1611, 0.6431],
+                [0.8051, 0.6596, 0.4121, 0.1125],
+                [0.5283, 0.6746, 0.5528, 0.7913],
+            ],
+        ]
+    ]
+)
+targets = torch.tensor([[[1, 1, 1, 1], [1, 1, 1, 0], [0, 0, 1, 0], [0, 1, 0, 0]]])
+
+TEST_CASES = [
+    [{"classes": 3, "dim": 2}, {"inputs": inputs, "targets": targets}, 1.1442],
+    [{"classes": 3, "dim": 2}, {"inputs": inputs.repeat(4, 1, 1, 1), "targets": targets.repeat(4, 1, 1)}, 1.1442],
+    [{"classes": 3, "dim": 2, "kernel_ops": "gaussian"}, {"inputs": inputs, "targets": targets}, 1.1433],
+    [{"classes": 3, "dim": 2, "kernel_ops": "gaussian", "sigma": 0.5}, {"inputs": inputs, "targets": targets}, 1.1469],
+    [{"classes": 3, "dim": 2, "distance_type": "l2"}, {"inputs": inputs, "targets": targets}, 1.1269],
+    [{"classes": 3, "dim": 2, "alpha": 0.2}, {"inputs": inputs, "targets": targets}, 1.1790],
+    [
+        {"classes": 3, "dim": 3, "kernel_ops": "gaussian"},
+        {
+            "inputs": torch.tensor(
+                [
+                    [
+                        [
+                            [
+                                [0.5977, 0.2767, 0.0591, 0.1675],
+                                [0.4835, 0.3778, 0.8406, 0.3065],
+                                [0.6047, 0.2860, 0.9742, 0.2013],
+                                [0.9128, 0.8368, 0.6711, 0.4384],
+                            ],
+                            [
+                                [0.9797, 0.1863, 0.5584, 0.6652],
+                                [0.2272, 0.2004, 0.7914, 0.4224],
+                                [0.5097, 0.8818, 0.2581, 0.3495],
+                                [0.1054, 0.5483, 0.3732, 0.3587],
+                            ],
+                            [
+                                [0.3060, 0.7066, 0.7922, 0.4689],
+                                [0.1733, 0.8902, 0.6704, 0.2037],
+                                [0.8656, 0.5561, 0.2701, 0.0092],
+                                [0.1866, 0.7714, 0.6424, 0.9791],
+                            ],
+                            [
+                                [0.5067, 0.3829, 0.6156, 0.8985],
+                                [0.5192, 0.8347, 0.2098, 0.2260],
+                                [0.8887, 0.3944, 0.6400, 0.5345],
+                                [0.1207, 0.3763, 0.5282, 0.7741],
+                            ],
+                        ],
+                        [
+                            [
+                                [0.8499, 0.4759, 0.1964, 0.5701],
+                                [0.3190, 0.1238, 0.2368, 0.9517],
+                                [0.0797, 0.6185, 0.0135, 0.8672],
+                                [0.4116, 0.1683, 0.1355, 0.0545],
+                            ],
+                            [
+                                [0.7533, 0.2658, 0.5955, 0.4498],
+                                [0.9500, 0.2317, 0.2825, 0.9763],
+                                [0.1493, 0.1558, 0.3743, 0.8723],
+                                [0.1723, 0.7980, 0.8816, 0.0133],
+                            ],
+                            [
+                                [0.8426, 0.2666, 0.2077, 0.3161],
+                                [0.1725, 0.8414, 0.1515, 0.2825],
+                                [0.4882, 0.5159, 0.4120, 0.1585],
+                                [0.2551, 0.9073, 0.7691, 0.9898],
+                            ],
+                            [
+                                [0.4633, 0.8717, 0.8537, 0.2899],
+                                [0.3693, 0.7953, 0.1183, 0.4596],
+                                [0.0087, 0.7925, 0.0989, 0.8385],
+                                [0.8261, 0.6920, 0.7069, 0.4464],
+                            ],
+                        ],
+                        [
+                            [
+                                [0.0110, 0.1608, 0.4814, 0.6317],
+                                [0.0194, 0.9669, 0.3259, 0.0028],
+                                [0.5674, 0.8286, 0.0306, 0.5309],
+                                [0.3973, 0.8183, 0.0238, 0.1934],
+                            ],
+                            [
+                                [0.8947, 0.6629, 0.9439, 0.8905],
+                                [0.0072, 0.1697, 0.4634, 0.0201],
+                                [0.7184, 0.2424, 0.0820, 0.7504],
+                                [0.3937, 0.1424, 0.4463, 0.5779],
+                            ],
+                            [
+                                [0.4123, 0.6227, 0.0523, 0.8826],
+                                [0.0051, 0.0353, 0.3662, 0.7697],
+                                [0.4867, 0.8986, 0.2510, 0.5316],
+                                [0.1856, 0.2634, 0.9140, 0.9725],
+                            ],
+                            [
+                                [0.2041, 0.4248, 0.2371, 0.7256],
+                                [0.2168, 0.5380, 0.4538, 0.7007],
+                                [0.9013, 0.2623, 0.0739, 0.2998],
+                                [0.1366, 0.5590, 0.2952, 0.4592],
+                            ],
+                        ],
+                    ]
+                ]
+            ),
+            "targets": torch.tensor(
+                [
+                    [
+                        [[0, 1, 0, 1], [1, 2, 1, 0], [2, 1, 1, 1], [1, 1, 0, 1]],
+                        [[2, 1, 0, 2], [1, 2, 0, 2], [1, 0, 1, 1], [1, 1, 0, 0]],
+                        [[1, 0, 2, 1], [0, 2, 2, 1], [1, 0, 1, 1], [0, 0, 2, 1]],
+                        [[2, 1, 1, 0], [1, 0, 0, 2], [1, 0, 2, 1], [2, 1, 0, 1]],
+                    ]
+                ]
+            ),
+        },
+        1.15035,
+    ],
+]
+
+
+class TestNACLLoss(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_result(self, input_param, input_data, expected_val):
+        loss = NACLLoss(**input_param)
+        result = loss(**input_data)
+        np.testing.assert_allclose(result.detach().cpu().numpy(), expected_val, atol=1e-4, rtol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/losses/test_perceptual_loss.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 torch
+from parameterized import parameterized
+
+from monai.losses import PerceptualLoss
+from monai.utils import optional_import
+from tests.test_utils import SkipIfBeforePyTorchVersion, assert_allclose, skip_if_downloading_fails, skip_if_quick
+
+_, has_torchvision = optional_import("torchvision")
+TEST_CASES = [
+    [{"spatial_dims": 2, "network_type": "squeeze"}, (2, 1, 64, 64), (2, 1, 64, 64)],
+    [
+        {"spatial_dims": 3, "network_type": "squeeze", "is_fake_3d": True, "fake_3d_ratio": 0.1},
+        (2, 1, 64, 64, 64),
+        (2, 1, 64, 64, 64),
+    ],
+    [{"spatial_dims": 2, "network_type": "radimagenet_resnet50"}, (2, 1, 64, 64), (2, 1, 64, 64)],
+    [{"spatial_dims": 2, "network_type": "radimagenet_resnet50"}, (2, 3, 64, 64), (2, 3, 64, 64)],
+    [
+        {"spatial_dims": 3, "network_type": "radimagenet_resnet50", "is_fake_3d": True, "fake_3d_ratio": 0.1},
+        (2, 1, 64, 64, 64),
+        (2, 1, 64, 64, 64),
+    ],
+    [
+        {"spatial_dims": 3, "network_type": "medicalnet_resnet10_23datasets", "is_fake_3d": False},
+        (2, 1, 64, 64, 64),
+        (2, 1, 64, 64, 64),
+    ],
+    [
+        {"spatial_dims": 3, "network_type": "medicalnet_resnet10_23datasets", "is_fake_3d": False},
+        (2, 6, 64, 64, 64),
+        (2, 6, 64, 64, 64),
+    ],
+    [
+        {
+            "spatial_dims": 3,
+            "network_type": "medicalnet_resnet10_23datasets",
+            "is_fake_3d": False,
+            "channel_wise": True,
+        },
+        (2, 6, 64, 64, 64),
+        (2, 6, 64, 64, 64),
+    ],
+    [
+        {"spatial_dims": 3, "network_type": "medicalnet_resnet50_23datasets", "is_fake_3d": False},
+        (2, 1, 64, 64, 64),
+        (2, 1, 64, 64, 64),
+    ],
+    [
+        {"spatial_dims": 3, "network_type": "medicalnet_resnet50_23datasets", "is_fake_3d": False},
+        (2, 6, 64, 64, 64),
+        (2, 6, 64, 64, 64),
+    ],
+    [
+        {"spatial_dims": 3, "network_type": "resnet50", "is_fake_3d": True, "pretrained": True, "fake_3d_ratio": 0.2},
+        (2, 1, 64, 64, 64),
+        (2, 1, 64, 64, 64),
+    ],
+]
+
+
+@SkipIfBeforePyTorchVersion((1, 11))
+@unittest.skipUnless(has_torchvision, "Requires torchvision")
+@skip_if_quick
+class TestPerceptualLoss(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_shape(self, input_param, input_shape, target_shape):
+        with skip_if_downloading_fails():
+            loss = PerceptualLoss(**input_param)
+        result = loss(torch.randn(input_shape), torch.randn(target_shape))
+
+        if "channel_wise" in input_param.keys() and input_param["channel_wise"]:
+            self.assertEqual(result.shape, torch.Size([input_shape[1]]))
+        else:
+            self.assertEqual(result.shape, torch.Size([]))
+
+    @parameterized.expand(TEST_CASES)
+    def test_identical_input(self, input_param, input_shape, target_shape):
+        with skip_if_downloading_fails():
+            loss = PerceptualLoss(**input_param)
+        tensor = torch.randn(input_shape)
+        result = loss(tensor, tensor)
+
+        if "channel_wise" in input_param.keys() and input_param["channel_wise"]:
+            assert_allclose(result, torch.Tensor([0.0] * input_shape[1]))
+        else:
+            self.assertEqual(result, torch.Tensor([0.0]))
+
+    def test_different_shape(self):
+        with skip_if_downloading_fails():
+            loss = PerceptualLoss(spatial_dims=2, network_type="squeeze")
+        tensor = torch.randn(2, 1, 64, 64)
+        target = torch.randn(2, 1, 32, 32)
+        with self.assertRaises(ValueError):
+            loss(tensor, target)
+
+    def test_1d(self):
+        with self.assertRaises(NotImplementedError):
+            PerceptualLoss(spatial_dims=1)
+
+    @parameterized.expand(["medicalnet_resnet10_23datasets", "medicalnet_resnet50_23datasets"])
+    def test_medicalnet_on_2d_data(self, network_type):
+        with self.assertRaises(ValueError):
+            PerceptualLoss(spatial_dims=2, network_type=network_type)
+
+
+if __name__ == "__main__":
+    unittest.main()