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

tests/utils/type_conversion/test_convert_data_type.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.data import MetaTensor
+from monai.utils.type_conversion import convert_data_type, convert_to_dst_type, get_equivalent_dtype
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose
+
+TESTS: list[tuple] = []
+for in_type in TEST_NDARRAYS_ALL + (int, float):
+    for out_type in TEST_NDARRAYS_ALL:
+        TESTS.append((in_type(np.array(1.0)), out_type(np.array(1.0)), None, False))  # type: ignore
+        if in_type is not float:
+            TESTS.append((in_type(np.array(256)), out_type(np.array(255)), np.uint8, True))  # type: ignore
+
+TESTS_LIST: list[tuple] = []
+for in_type in TEST_NDARRAYS_ALL + (int, float):
+    for out_type in TEST_NDARRAYS_ALL:
+        TESTS_LIST.append(
+            (
+                [in_type(np.array(1.0)), in_type(np.array(1.0))],  # type: ignore
+                out_type(np.array([1.0, 1.0])),
+                True,
+                None,
+                False,
+            )
+        )
+        TESTS_LIST.append(
+            (
+                [in_type(np.array(1.0)), in_type(np.array(1.0))],  # type: ignore
+                [out_type(np.array(1.0)), out_type(np.array(1.0))],
+                False,
+                None,
+                False,
+            )
+        )
+        if in_type is not float:
+            TESTS_LIST.append(
+                (
+                    [in_type(np.array(257)), in_type(np.array(1))],  # type: ignore
+                    out_type(np.array([255, 1])),
+                    True,
+                    np.uint8,
+                    True,
+                )
+            )
+            TESTS_LIST.append(
+                (
+                    [in_type(np.array(257)), in_type(np.array(-12))],  # type: ignore
+                    [out_type(np.array(255)), out_type(np.array(0))],
+                    False,
+                    np.uint8,
+                    True,
+                )
+            )
+
+UNSUPPORTED_TYPES = {np.dtype("uint16"): torch.int32, np.dtype("uint32"): torch.int64, np.dtype("uint64"): torch.int64}
+
+
+class TestTensor(torch.Tensor):
+    __test__ = False  # indicate to pytest that this class is not intended for collection
+    pass
+
+
+class TestConvertDataType(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_convert_data_type(self, in_image, im_out, out_dtype, safe):
+        converted_im, orig_type, orig_device = convert_data_type(in_image, type(im_out), dtype=out_dtype, safe=safe)
+        # check input is unchanged
+        self.assertEqual(type(in_image), orig_type)
+        if isinstance(in_image, torch.Tensor):
+            self.assertEqual(in_image.device, orig_device)
+        # check output is desired type
+        self.assertEqual(type(converted_im), type(im_out))
+        # check data has been clipped
+        assert_allclose(converted_im, im_out)
+        # check dtype is unchanged
+        if out_dtype is None:
+            if isinstance(in_image, (np.ndarray, torch.Tensor)):
+                self.assertEqual(converted_im.dtype, im_out.dtype)
+
+    def test_neg_stride(self):
+        _ = convert_data_type(np.array((1, 2))[::-1], torch.Tensor)
+
+    @parameterized.expand(list(UNSUPPORTED_TYPES.items()))
+    def test_unsupported_np_types(self, np_type, pt_type):
+        in_image = np.ones(13, dtype=np_type)  # choose a prime size so as to be indivisible by the size of any dtype
+        converted_im, orig_type, orig_device = convert_data_type(in_image, torch.Tensor)
+
+        self.assertEqual(converted_im.dtype, pt_type)
+
+    @parameterized.expand(TESTS_LIST)
+    def test_convert_list(self, in_image, im_out, wrap, out_dtype, safe):
+        output_type = type(im_out) if wrap else type(im_out[0])
+        converted_im, *_ = convert_data_type(in_image, output_type, wrap_sequence=wrap, dtype=out_dtype, safe=safe)
+        # check output is desired type
+        if not wrap:
+            converted_im = converted_im[0]
+            im_out = im_out[0]
+        self.assertEqual(type(converted_im), type(im_out))
+        assert_allclose(converted_im, im_out)
+        # check dtype is unchanged
+        if isinstance(in_image[0], (np.ndarray, torch.Tensor)):
+            if out_dtype is None:
+                self.assertEqual(converted_im.dtype, im_out.dtype)
+            else:
+                _out_dtype = get_equivalent_dtype(out_dtype, output_type)
+                self.assertEqual(converted_im.dtype, _out_dtype)
+
+
+class TestConvertDataSame(unittest.TestCase):
+    # add test for subclass of Tensor
+    @parameterized.expand(TESTS + [(np.array(256), TestTensor(np.array([255])), torch.uint8, True)])
+    def test_convert_data_type(self, in_image, im_out, out_dtype, safe):
+        converted_im, orig_type, orig_device = convert_to_dst_type(in_image, im_out, dtype=out_dtype, safe=safe)
+        # check input is unchanged
+        self.assertEqual(type(in_image), orig_type)
+        assert_allclose(converted_im, im_out)
+        if isinstance(in_image, torch.Tensor):
+            self.assertEqual(in_image.device, orig_device)
+
+        # check output is desired type
+        if isinstance(im_out, MetaTensor):
+            output_type = MetaTensor
+        elif isinstance(im_out, torch.Tensor):
+            output_type = torch.Tensor
+        else:
+            output_type = np.ndarray
+        self.assertEqual(type(converted_im), output_type)
+        # check dtype is unchanged
+        if out_dtype is None:
+            if isinstance(in_image, (np.ndarray, torch.Tensor, MetaTensor)):
+                self.assertEqual(converted_im.dtype, im_out.dtype)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/type_conversion/test_get_equivalent_dtype.py

@@ -0,0 +1,65 @@
+# 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.utils.type_conversion import get_equivalent_dtype, get_numpy_dtype_from_string, get_torch_dtype_from_string
+from tests.test_utils import TEST_NDARRAYS
+
+DTYPES = [torch.float32, np.float32, np.dtype(np.float32)]
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    for im_dtype in DTYPES:
+        TESTS.append((p(np.array(1.0, dtype=np.float32)), im_dtype))
+
+
+class TestGetEquivalentDtype(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_get_equivalent_dtype(self, im, input_dtype):
+        out_dtype = get_equivalent_dtype(input_dtype, type(im))
+        self.assertEqual(out_dtype, im.dtype)
+
+    def test_native_type(self):
+        """the get_equivalent_dtype currently doesn't change the build-in type"""
+        n_type = [float, int, bool]
+        for n in n_type:
+            for im_dtype in DTYPES:
+                out_dtype = get_equivalent_dtype(n, type(im_dtype))
+                self.assertEqual(out_dtype, n)
+
+    @parameterized.expand(
+        [
+            ["float", np.float64],
+            ["float32", np.float32],
+            ["np.float32", np.float32],
+            ["float64", np.float64],
+            ["torch.float64", np.float64],
+        ]
+    )
+    def test_from_string(self, dtype_str, expected_np):
+        expected_pt = get_equivalent_dtype(expected_np, torch.Tensor)
+        # numpy
+        dtype = get_numpy_dtype_from_string(dtype_str)
+        self.assertEqual(dtype, expected_np)
+        # torch
+        dtype = get_torch_dtype_from_string(dtype_str)
+        self.assertEqual(dtype, expected_pt)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/type_conversion/test_safe_dtype_range.py

@@ -0,0 +1,99 @@
+# 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.utils import optional_import
+from monai.utils.type_conversion import get_equivalent_dtype, safe_dtype_range
+from tests.test_utils import HAS_CUPY, TEST_NDARRAYS_ALL, assert_allclose
+
+cp, _ = optional_import("cupy")
+
+TESTS: list[tuple] = []
+for in_type in TEST_NDARRAYS_ALL + (int, float):
+    TESTS.append((in_type(np.array(1.0)), in_type(np.array(1.0)), None))  # type: ignore
+    if in_type is not float:
+        TESTS.append((in_type(np.array(256)), in_type(np.array(255)), np.uint8))  # type: ignore
+        TESTS.append((in_type(np.array(-12)), in_type(np.array(0)), np.uint8))  # type: ignore
+for in_type in TEST_NDARRAYS_ALL:
+    TESTS.append((in_type(np.array([[256, 255], [-12, 0]])), in_type(np.array([[255, 255], [0, 0]])), np.uint8))
+
+TESTS_LIST: list[tuple] = []
+for in_type in TEST_NDARRAYS_ALL + (int, float):
+    TESTS_LIST.append(
+        (
+            [in_type(np.array(1.0)), in_type(np.array(1.0))],  # type: ignore
+            [in_type(np.array(1.0)), in_type(np.array(1.0))],  # type: ignore
+            None,
+        )
+    )
+    if in_type is not float:
+        TESTS_LIST.append(
+            (
+                [in_type(np.array(257)), in_type(np.array(-12))],  # type: ignore
+                [in_type(np.array(255)), in_type(np.array(0))],  # type: ignore
+                np.uint8,
+            )
+        )
+
+TESTS_CUPY = [[np.array(1.0), np.array(1.0), None], [np.array([-12]), np.array([0]), np.uint8]]
+
+
+class TesSafeDtypeRange(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_safe_dtype_range(self, in_image, im_out, out_dtype):
+        result = safe_dtype_range(in_image, out_dtype)
+        # check type is unchanged
+        self.assertEqual(type(in_image), type(result))
+        # check dtype is unchanged
+        if isinstance(in_image, (np.ndarray, torch.Tensor)):
+            self.assertEqual(in_image.dtype, result.dtype)
+        # check output
+        assert_allclose(result, im_out)
+
+    @parameterized.expand(TESTS_LIST)
+    def test_safe_dtype_range_list(self, in_image, im_out, out_dtype):
+        output_type = type(im_out[0])
+        result = safe_dtype_range(in_image, dtype=out_dtype)
+        # check type is unchanged
+        self.assertEqual(type(result), type(im_out))
+        # check output
+        for i, _result in enumerate(result):
+            assert_allclose(_result, im_out[i])
+        # check dtype is unchanged
+        if isinstance(in_image, (np.ndarray, torch.Tensor)):
+            if out_dtype is None:
+                self.assertEqual(result[0].dtype, im_out[0].dtype)
+            else:
+                _out_dtype = get_equivalent_dtype(out_dtype, output_type)
+                self.assertEqual(result[0].dtype, _out_dtype)
+
+    @parameterized.expand(TESTS_CUPY)
+    @unittest.skipUnless(HAS_CUPY, "Requires CuPy")
+    def test_type_cupy(self, in_image, im_out, out_dtype):
+        in_image = cp.asarray(in_image)
+        result = safe_dtype_range(in_image, dtype=out_dtype)
+        # check type is unchanged
+        self.assertEqual(type(in_image), type(result))
+        # check dtype is unchanged
+        self.assertEqual(result.dtype, in_image.dtype)
+        # check output
+        self.assertEqual(result, cp.asarray(im_out))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/visualize/__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/visualize/test_img2tensorboard.py

@@ -0,0 +1,46 @@
+# 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 tensorboard
+import torch
+
+from monai.visualize import make_animated_gif_summary
+
+
+class TestImg2Tensorboard(unittest.TestCase):
+
+    def test_write_gray(self):
+        nparr = np.ones(shape=(1, 32, 32, 32), dtype=np.float32)
+        summary_object_np = make_animated_gif_summary(
+            tag="test_summary_nparr.png", image=nparr, max_out=1, scale_factor=253.0
+        )
+        for s in summary_object_np:
+            assert isinstance(
+                s, tensorboard.compat.proto.summary_pb2.Summary
+            ), "make_animated_gif_summary must return a tensorboard.summary object from numpy array"
+
+        tensorarr = torch.tensor(nparr)
+        summary_object_tensor = make_animated_gif_summary(
+            tag="test_summary_tensorarr.png", image=tensorarr, max_out=1, frame_dim=-1, scale_factor=253.0
+        )
+        for s in summary_object_tensor:
+            assert isinstance(
+                s, tensorboard.compat.proto.summary_pb2.Summary
+            ), "make_animated_gif_summary must return a tensorboard.summary object from tensor input"
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/visualize/test_occlusion_sensitivity.py

@@ -0,0 +1,128 @@
+# 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 typing import Any
+
+import torch
+from parameterized import parameterized
+
+from monai.networks.nets import DenseNet, DenseNet121
+from monai.visualize import OcclusionSensitivity
+
+
+class DenseNetAdjoint(DenseNet121):
+
+    def __call__(self, x, adjoint_info):
+        if adjoint_info != 42:
+            raise ValueError
+        return super().__call__(x)
+
+
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+out_channels_2d = 4
+out_channels_3d = 3
+model_2d = DenseNet121(spatial_dims=2, in_channels=1, out_channels=out_channels_2d).to(device)
+model_2d_2c = DenseNet121(spatial_dims=2, in_channels=2, out_channels=out_channels_2d).to(device)
+model_3d = DenseNet(
+    spatial_dims=3, in_channels=1, out_channels=out_channels_3d, init_features=2, growth_rate=2, block_config=(6,)
+).to(device)
+model_2d_adjoint = DenseNetAdjoint(spatial_dims=2, in_channels=1, out_channels=out_channels_2d).to(device)
+model_2d.eval()
+model_2d_2c.eval()
+model_3d.eval()
+model_2d_adjoint.eval()
+
+TESTS: list[Any] = []
+TESTS_FAIL: list[Any] = []
+
+# 2D w/ bounding box with all modes
+for mode in ("gaussian", "mean_patch", "mean_img"):
+    TESTS.append(
+        [
+            {"nn_module": model_2d, "mode": mode},
+            {"x": torch.rand(1, 1, 48, 64).to(device), "b_box": [2, 40, 1, 62]},
+            (1, out_channels_2d, 38, 61),
+            (1, 1, 38, 61),
+        ]
+    )
+# 3D w/ bounding box
+TESTS.append(
+    [
+        {"nn_module": model_3d, "n_batch": 10, "mask_size": (16, 15, 14)},
+        {"x": torch.rand(1, 1, 64, 32, 16).to(device), "b_box": [2, 43, -1, -1, -1, -1]},
+        (1, out_channels_3d, 41, 32, 16),
+        (1, 1, 41, 32, 16),
+    ]
+)
+TESTS.append(
+    [
+        {"nn_module": model_3d, "n_batch": 10},
+        {"x": torch.rand(1, 1, 6, 7, 8).to(device), "b_box": [1, 3, -1, -1, -1, -1]},
+        (1, out_channels_3d, 2, 7, 8),
+        (1, 1, 2, 7, 8),
+    ]
+)
+TESTS.append(
+    [
+        {"nn_module": model_2d_2c},
+        {"x": torch.rand(1, 2, 48, 64).to(device)},
+        (1, out_channels_2d, 48, 64),
+        (1, 1, 48, 64),
+    ]
+)
+# 2D w/ bounding box and adjoint
+TESTS.append(
+    [
+        {"nn_module": model_2d_adjoint},
+        {"x": torch.rand(1, 1, 48, 64).to(device), "b_box": [2, 40, 1, 62], "adjoint_info": 42},
+        (1, out_channels_2d, 38, 61),
+        (1, 1, 38, 61),
+    ]
+)
+# 2D should fail: bbox makes image too small
+TESTS_FAIL.append(
+    [{"nn_module": model_2d, "n_batch": 10, "mask_size": 200}, {"x": torch.rand(1, 1, 48, 64).to(device)}, ValueError]
+)
+# 2D should fail: batch > 1
+TESTS_FAIL.append(
+    [{"nn_module": model_2d, "n_batch": 10, "mask_size": 100}, {"x": torch.rand(2, 1, 48, 64).to(device)}, ValueError]
+)
+# 2D should fail: unknown mode
+TESTS_FAIL.append(
+    [{"nn_module": model_2d, "mode": "test"}, {"x": torch.rand(1, 1, 48, 64).to(device)}, NotImplementedError]
+)
+
+
+class TestComputeOcclusionSensitivity(unittest.TestCase):
+
+    @parameterized.expand(TESTS)
+    def test_shape(self, init_data, call_data, map_expected_shape, most_prob_expected_shape):
+        occ_sens = OcclusionSensitivity(**init_data)
+        m, most_prob = occ_sens(**call_data)
+        self.assertTupleEqual(m.shape, map_expected_shape)
+        self.assertTupleEqual(most_prob.shape, most_prob_expected_shape)
+        # most probable class should be of type int, and should have min>=0, max<num_classes
+        self.assertEqual(most_prob.dtype, torch.int64)
+        self.assertGreaterEqual(most_prob.min(), 0)
+        self.assertLess(most_prob.max(), m.shape[-1])
+
+    @parameterized.expand(TESTS_FAIL)
+    def test_fail(self, init_data, call_data, error_type):
+        with self.assertRaises(error_type):
+            occ_sens = OcclusionSensitivity(**init_data)
+            occ_sens(**call_data)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/visualize/test_plot_2d_or_3d_image.py

@@ -0,0 +1,74 @@
+# 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 glob
+import tempfile
+import unittest
+
+import torch
+from parameterized import parameterized
+
+from monai.utils import optional_import
+from monai.visualize import plot_2d_or_3d_image
+from tests.test_utils import SkipIfBeforePyTorchVersion, SkipIfNoModule
+
+SummaryWriter, has_tb = optional_import("torch.utils.tensorboard", name="SummaryWriter")
+
+SummaryWriterX, _ = optional_import("tensorboardX", name="SummaryWriter")
+
+TEST_CASE_1 = [(1, 1, 10, 10)]
+
+TEST_CASE_2 = [(1, 3, 10, 10)]
+
+TEST_CASE_3 = [(1, 4, 10, 10)]
+
+TEST_CASE_4 = [(1, 1, 10, 10, 10)]
+
+TEST_CASE_5 = [(1, 3, 10, 10, 10)]
+
+
+@unittest.skipUnless(has_tb, "Requires SummaryWriter installation")
+@SkipIfBeforePyTorchVersion((1, 13))  # issue 6683
+class TestPlot2dOr3dImage(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5])
+    def test_tb_image(self, shape):
+        with tempfile.TemporaryDirectory() as tempdir:
+            writer = SummaryWriter(log_dir=tempdir)
+            plot_2d_or_3d_image(torch.zeros(shape), 0, writer, max_channels=3, frame_dim=-1)
+            writer.flush()
+            writer.close()
+            self.assertTrue(len(glob.glob(tempdir)) > 0)
+
+    @SkipIfNoModule("tensorboardX")
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5])
+    def test_tbx_image(self, shape):
+        with tempfile.TemporaryDirectory() as tempdir:
+            writer = SummaryWriterX(log_dir=tempdir)
+            plot_2d_or_3d_image(torch.zeros(shape), 0, writer, max_channels=2)
+            writer.flush()
+            writer.close()
+            self.assertTrue(len(glob.glob(tempdir)) > 0)
+
+    @SkipIfNoModule("tensorboardX")
+    @parameterized.expand([TEST_CASE_5])
+    def test_tbx_video(self, shape):
+        with tempfile.TemporaryDirectory() as tempdir:
+            writer = SummaryWriterX(log_dir=tempdir)
+            plot_2d_or_3d_image(torch.rand(shape), 0, writer, max_channels=3)
+            writer.flush()
+            writer.close()
+            self.assertTrue(len(glob.glob(tempdir)) > 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/visualize/test_vis_cam.py

@@ -0,0 +1,98 @@
+# 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.networks.nets import DenseNet, DenseNet121, SEResNet50
+from monai.visualize import CAM
+
+# 2D
+TEST_CASE_0 = [
+    {
+        "model": "densenet2d",
+        "shape": (2, 1, 48, 64),
+        "feature_shape": (2, 1, 1, 2),
+        "target_layers": "class_layers.relu",
+        "fc_layers": "class_layers.out",
+    },
+    (2, 1, 48, 64),
+]
+# 3D
+TEST_CASE_1 = [
+    {
+        "model": "densenet3d",
+        "shape": (2, 1, 6, 6, 6),
+        "feature_shape": (2, 1, 2, 2, 2),
+        "target_layers": "class_layers.relu",
+        "fc_layers": "class_layers.out",
+    },
+    (2, 1, 6, 6, 6),
+]
+# 2D
+TEST_CASE_2 = [
+    {
+        "model": "senet2d",
+        "shape": (2, 3, 64, 64),
+        "feature_shape": (2, 1, 2, 2),
+        "target_layers": "layer4",
+        "fc_layers": "last_linear",
+    },
+    (2, 1, 64, 64),
+]
+
+# 3D
+TEST_CASE_3 = [
+    {
+        "model": "senet3d",
+        "shape": (2, 3, 8, 8, 48),
+        "feature_shape": (2, 1, 1, 1, 2),
+        "target_layers": "layer4",
+        "fc_layers": "last_linear",
+    },
+    (2, 1, 8, 8, 48),
+]
+
+
+class TestClassActivationMap(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_0, TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+    def test_shape(self, input_data, expected_shape):
+        model = None
+
+        if input_data["model"] == "densenet2d":
+            model = DenseNet121(spatial_dims=2, in_channels=1, out_channels=3)
+        if input_data["model"] == "densenet3d":
+            model = DenseNet(
+                spatial_dims=3, in_channels=1, out_channels=3, init_features=2, growth_rate=2, block_config=(6,)
+            )
+        if input_data["model"] == "senet2d":
+            model = SEResNet50(spatial_dims=2, in_channels=3, num_classes=4)
+        if input_data["model"] == "senet3d":
+            model = SEResNet50(spatial_dims=3, in_channels=3, num_classes=4)
+
+        device = "cuda:0" if torch.cuda.is_available() else "cpu"
+        model.to(device)
+        model.eval()
+        cam = CAM(nn_module=model, target_layers=input_data["target_layers"], fc_layers=input_data["fc_layers"])
+        image = torch.rand(input_data["shape"], device=device)
+        result = cam(x=image, layer_idx=-1)
+        fea_shape = cam.feature_map_size(input_data["shape"], device=device)
+        self.assertTupleEqual(fea_shape, input_data["feature_shape"])
+        self.assertTupleEqual(result.shape, expected_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()