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

tests/networks/nets/test_segresnet_ds.py

@@ -0,0 +1,156 @@
+# 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 import eval_mode
+from monai.networks.nets import SegResNetDS, SegResNetDS2
+from tests.test_utils import SkipIfBeforePyTorchVersion, test_script_save
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+TEST_CASE_SEGRESNET_DS = []
+for spatial_dims in range(2, 4):
+    for init_filters in [8, 16]:
+        for act in ["relu", "leakyrelu"]:
+            for norm in ["BATCH", ("instance", {"affine": True})]:
+                for upsample_mode in ["deconv", "nontrainable"]:
+                    test_case = [
+                        {
+                            "spatial_dims": spatial_dims,
+                            "init_filters": init_filters,
+                            "act": act,
+                            "norm": norm,
+                            "upsample_mode": upsample_mode,
+                        },
+                        (2, 1, *([16] * spatial_dims)),
+                        (2, 2, *([16] * spatial_dims)),
+                    ]
+                    TEST_CASE_SEGRESNET_DS.append(test_case)
+
+TEST_CASE_SEGRESNET_DS2 = []
+for spatial_dims in range(2, 4):
+    for out_channels in [1, 2]:
+        for dsdepth in [1, 2, 3]:
+            test_case = [
+                {"spatial_dims": spatial_dims, "init_filters": 8, "out_channels": out_channels, "dsdepth": dsdepth},
+                (2, 1, *([16] * spatial_dims)),
+                (2, out_channels, *([16] * spatial_dims)),
+            ]
+            TEST_CASE_SEGRESNET_DS2.append(test_case)
+
+TEST_CASE_SEGRESNET_DS3 = [
+    ({"init_filters": 8, "dsdepth": 2, "resolution": None}, (2, 1, 16, 16, 16), ((2, 2, 16, 16, 16), (2, 2, 8, 8, 8))),
+    (
+        {"init_filters": 8, "dsdepth": 3, "resolution": None},
+        (2, 1, 16, 16, 16),
+        ((2, 2, 16, 16, 16), (2, 2, 8, 8, 8), (2, 2, 4, 4, 4)),
+    ),
+    (
+        {"init_filters": 8, "dsdepth": 3, "resolution": [1, 1, 5]},
+        (2, 1, 16, 16, 16),
+        ((2, 2, 16, 16, 16), (2, 2, 8, 8, 16), (2, 2, 4, 4, 16)),
+    ),
+    (
+        {"init_filters": 8, "dsdepth": 3, "resolution": [1, 2, 5]},
+        (2, 1, 16, 16, 16),
+        ((2, 2, 16, 16, 16), (2, 2, 8, 8, 16), (2, 2, 4, 8, 16)),
+    ),
+]
+
+
+class TestSegResNetDS(unittest.TestCase):
+    @parameterized.expand(TEST_CASE_SEGRESNET_DS)
+    def test_shape(self, input_param, input_shape, expected_shape):
+        net = SegResNetDS(**input_param).to(device)
+        with eval_mode(net):
+            result = net(torch.randn(input_shape).to(device))
+            self.assertEqual(result.shape, expected_shape, msg=str(input_param))
+
+    @parameterized.expand(TEST_CASE_SEGRESNET_DS)
+    def test_shape_ds2(self, input_param, input_shape, expected_shape):
+        net = SegResNetDS2(**input_param).to(device)
+        with eval_mode(net):
+            result = net(torch.randn(input_shape).to(device), with_label=False)
+            self.assertEqual(result[0].shape, expected_shape, msg=str(input_param))
+            self.assertTrue(result[1] == [])
+
+            result = net(torch.randn(input_shape).to(device), with_point=False)
+            self.assertEqual(result[1].shape, expected_shape, msg=str(input_param))
+            self.assertTrue(result[0] == [])
+
+    @parameterized.expand(TEST_CASE_SEGRESNET_DS2)
+    def test_shape2(self, input_param, input_shape, expected_shape):
+        dsdepth = input_param.get("dsdepth", 1)
+        for net in [SegResNetDS, SegResNetDS2]:
+            net = net(**input_param).to(device)
+            net.train()
+            if isinstance(net, SegResNetDS2):
+                result = net(torch.randn(input_shape).to(device), with_label=False)[0]
+            else:
+                result = net(torch.randn(input_shape).to(device))
+            if dsdepth > 1:
+                assert isinstance(result, list)
+                self.assertEqual(dsdepth, len(result))
+                for i in range(dsdepth):
+                    self.assertEqual(
+                        result[i].shape,
+                        expected_shape[:2] + tuple(e // (2**i) for e in expected_shape[2:]),
+                        msg=str(input_param),
+                    )
+            else:
+                assert isinstance(result, torch.Tensor)
+                self.assertEqual(result.shape, expected_shape, msg=str(input_param))
+
+            if not isinstance(net, SegResNetDS2):
+                # eval mode of SegResNetDS2 has same output as training mode
+                # so only test eval mode for SegResNetDS
+                net.eval()
+                result = net(torch.randn(input_shape).to(device))
+                assert isinstance(result, torch.Tensor)
+                self.assertEqual(result.shape, expected_shape, msg=str(input_param))
+
+    @parameterized.expand(TEST_CASE_SEGRESNET_DS3)
+    def test_shape3(self, input_param, input_shape, expected_shapes):
+        dsdepth = input_param.get("dsdepth", 1)
+        for net in [SegResNetDS, SegResNetDS2]:
+            net = net(**input_param).to(device)
+            net.train()
+            if isinstance(net, SegResNetDS2):
+                result = net(torch.randn(input_shape).to(device), with_point=False)[1]
+            else:
+                result = net(torch.randn(input_shape).to(device))
+            assert isinstance(result, list)
+            self.assertEqual(dsdepth, len(result))
+            for i in range(dsdepth):
+                self.assertEqual(result[i].shape, expected_shapes[i], msg=str(input_param))
+
+    def test_ill_arg(self):
+        with self.assertRaises(ValueError):
+            SegResNetDS(spatial_dims=4)
+
+        with self.assertRaises(ValueError):
+            SegResNetDS2(spatial_dims=4)
+
+    @SkipIfBeforePyTorchVersion((1, 10))
+    def test_script(self):
+        input_param, input_shape, _ = TEST_CASE_SEGRESNET_DS[0]
+        net = SegResNetDS(**input_param)
+        test_data = torch.randn(input_shape)
+        test_script_save(net, test_data)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/nets/test_senet.py

@@ -0,0 +1,151 @@
+# 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 os
+import unittest
+from pathlib import Path
+from typing import TYPE_CHECKING
+from unittest import skipUnless
+
+import torch
+from parameterized import parameterized
+
+import monai.networks.nets.senet as se_mod
+from monai.networks import eval_mode
+from monai.networks.nets import SENet, SENet154, SEResNet50, SEResNet101, SEResNet152, SEResNext50, SEResNext101
+from monai.utils import optional_import
+from tests.test_utils import test_is_quick, test_pretrained_networks, test_script_save, testing_data_config
+
+if TYPE_CHECKING:
+    import pretrainedmodels
+
+    has_cadene_pretrain = True
+else:
+    pretrainedmodels, has_cadene_pretrain = optional_import("pretrainedmodels")
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+NET_ARGS = {"spatial_dims": 3, "in_channels": 2, "num_classes": 2}
+TEST_CASE_1 = [SENet154, NET_ARGS]
+TEST_CASE_2 = [SEResNet50, NET_ARGS]
+TEST_CASE_3 = [SEResNet101, NET_ARGS]
+TEST_CASE_4 = [SEResNet152, NET_ARGS]
+TEST_CASE_5 = [SEResNext50, NET_ARGS]
+TEST_CASE_6 = [SEResNext101, NET_ARGS]
+TEST_CASE_7 = [
+    SENet,
+    {
+        "spatial_dims": 3,
+        "in_channels": 2,
+        "num_classes": 2,
+        "block": "se_bottleneck",
+        "layers": (3, 8, 36, 3),
+        "groups": 64,
+        "reduction": 16,
+    },
+]
+
+TEST_CASE_PRETRAINED_1 = [SEResNet50, {"spatial_dims": 2, "in_channels": 3, "num_classes": 2, "pretrained": True}]
+
+
+class TestSENET(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5, TEST_CASE_6, TEST_CASE_7])
+    def test_senet_shape(self, net, net_args):
+        input_data = torch.randn(2, 2, 64, 64, 64).to(device)
+        expected_shape = (2, 2)
+        net = net(**net_args).to(device)
+        with eval_mode(net):
+            result = net(input_data)
+            self.assertEqual(result.shape, expected_shape)
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5, TEST_CASE_6])
+    def test_script(self, net, net_args):
+        net = net(**net_args)
+        input_data = torch.randn(2, 2, 64, 64, 64)
+        test_script_save(net, input_data)
+
+
+class TestPretrainedSENET(unittest.TestCase):
+    def setUp(self):
+        self.original_urls = se_mod.SE_NET_MODELS.copy()
+        replace_url = test_is_quick()
+        if not replace_url:
+            try:
+                SEResNet50(pretrained=True, spatial_dims=2, in_channels=3, num_classes=2)
+            except OSError as rt_e:
+                print(rt_e)
+                if "certificate" in str(rt_e):  # [SSL: CERTIFICATE_VERIFY_FAILED]
+                    replace_url = True
+        if replace_url:
+            testing_dir = Path(__file__).parents[2] / "testing_data"
+            testing_data_urls = {
+                "senet154": {
+                    "url": testing_data_config("models", "senet154-c7b49a05", "url"),
+                    "filename": "senet154-c7b49a05.pth",
+                },
+                "se_resnet50": {
+                    "url": testing_data_config("models", "se_resnet50-ce0d4300", "url"),
+                    "filename": "se_resnet50-ce0d4300.pth",
+                },
+                "se_resnet101": {
+                    "url": testing_data_config("models", "se_resnet101-7e38fcc6", "url"),
+                    "filename": "se_resnet101-7e38fcc6.pth",
+                },
+                "se_resnet152": {
+                    "url": testing_data_config("models", "se_resnet152-d17c99b7", "url"),
+                    "filename": "se_resnet152-d17c99b7.pth",
+                },
+                "se_resnext50_32x4d": {
+                    "url": testing_data_config("models", "se_resnext50_32x4d-a260b3a4", "url"),
+                    "filename": "se_resnext50_32x4d-a260b3a4.pth",
+                },
+                "se_resnext101_32x4d": {
+                    "url": testing_data_config("models", "se_resnext101_32x4d-3b2fe3d8", "url"),
+                    "filename": "se_resnext101_32x4d-3b2fe3d8.pth",
+                },
+            }
+            for item in testing_data_urls:
+                testing_data_urls[item]["filename"] = os.path.join(testing_dir, testing_data_urls[item]["filename"])
+            se_mod.SE_NET_MODELS = testing_data_urls
+
+    def tearDown(self):
+        se_mod.SE_NET_MODELS = self.original_urls.copy()
+
+    @parameterized.expand([TEST_CASE_PRETRAINED_1])
+    def test_senet_shape(self, model, input_param):
+        net = test_pretrained_networks(model, input_param, device)
+        input_data = torch.randn(3, 3, 64, 64).to(device)
+        expected_shape = (3, 2)
+        net = net.to(device)
+        with eval_mode(net):
+            result = net(input_data)
+            self.assertEqual(result.shape, expected_shape)
+
+    @parameterized.expand([TEST_CASE_PRETRAINED_1])
+    @skipUnless(has_cadene_pretrain, "Requires `pretrainedmodels` package.")
+    def test_pretrain_consistency(self, model, input_param):
+        input_data = torch.randn(1, 3, 64, 64).to(device)
+        net = test_pretrained_networks(model, input_param, device)
+        with eval_mode(net):
+            result = net.features(input_data)
+        cadene_net = pretrainedmodels.se_resnet50().to(device)
+        with eval_mode(cadene_net):
+            expected_result = cadene_net.features(input_data)
+        # The difference between Cadene's senet and our version is that
+        # we use nn.Linear as the FC layer, but Cadene's version uses
+        # a conv layer with kernel size equals to 1. It may bring a little difference.
+        self.assertTrue(torch.allclose(result, expected_result, rtol=1e-5, atol=1e-5))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/nets/test_spade_autoencoderkl.py

@@ -0,0 +1,295 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+from unittest import skipUnless
+
+import torch
+from parameterized import parameterized
+
+from monai.networks import eval_mode
+from monai.networks.nets import SPADEAutoencoderKL
+from monai.utils import optional_import
+
+einops, has_einops = optional_import("einops")
+
+CASES_NO_ATTENTION = [
+    [
+        {
+            "spatial_dims": 2,
+            "label_nc": 3,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, False),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+            "with_encoder_nonlocal_attn": False,
+            "with_decoder_nonlocal_attn": False,
+        },
+        (1, 1, 16, 16),
+        (1, 3, 16, 16),
+        (1, 1, 16, 16),
+        (1, 4, 4, 4),
+    ],
+    [
+        {
+            "spatial_dims": 3,
+            "label_nc": 3,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, False),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+            "with_encoder_nonlocal_attn": False,
+            "with_decoder_nonlocal_attn": False,
+        },
+        (1, 1, 16, 16, 16),
+        (1, 3, 16, 16, 16),
+        (1, 1, 16, 16, 16),
+        (1, 4, 4, 4, 4),
+    ],
+]
+
+CASES_ATTENTION = [
+    [
+        {
+            "spatial_dims": 2,
+            "label_nc": 3,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, False),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+        },
+        (1, 1, 16, 16),
+        (1, 3, 16, 16),
+        (1, 1, 16, 16),
+        (1, 4, 4, 4),
+    ],
+    [
+        {
+            "spatial_dims": 2,
+            "label_nc": 3,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, False),
+            "num_res_blocks": (1, 1, 2),
+            "norm_num_groups": 4,
+        },
+        (1, 1, 16, 16),
+        (1, 3, 16, 16),
+        (1, 1, 16, 16),
+        (1, 4, 4, 4),
+    ],
+    [
+        {
+            "spatial_dims": 2,
+            "label_nc": 3,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, False),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+        },
+        (1, 1, 16, 16),
+        (1, 3, 16, 16),
+        (1, 1, 16, 16),
+        (1, 4, 4, 4),
+    ],
+    [
+        {
+            "spatial_dims": 2,
+            "label_nc": 3,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, True),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+        },
+        (1, 1, 16, 16),
+        (1, 3, 16, 16),
+        (1, 1, 16, 16),
+        (1, 4, 4, 4),
+    ],
+    [
+        {
+            "spatial_dims": 2,
+            "label_nc": 3,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, False),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+            "with_encoder_nonlocal_attn": False,
+        },
+        (1, 1, 16, 16),
+        (1, 3, 16, 16),
+        (1, 1, 16, 16),
+        (1, 4, 4, 4),
+    ],
+    [
+        {
+            "spatial_dims": 3,
+            "label_nc": 3,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, True),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+        },
+        (1, 1, 16, 16, 16),
+        (1, 3, 16, 16, 16),
+        (1, 1, 16, 16, 16),
+        (1, 4, 4, 4, 4),
+    ],
+    [
+        {
+            "spatial_dims": 2,
+            "label_nc": 3,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, True),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+            "spade_intermediate_channels": 32,
+        },
+        (1, 1, 16, 16),
+        (1, 3, 16, 16),
+        (1, 1, 16, 16),
+        (1, 4, 4, 4),
+    ],
+]
+
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+if has_einops:
+    CASES = CASES_ATTENTION + CASES_NO_ATTENTION
+else:
+    CASES = CASES_NO_ATTENTION
+
+
+class TestSPADEAutoEncoderKL(unittest.TestCase):
+    @parameterized.expand(CASES)
+    def test_shape(self, input_param, input_shape, input_seg, expected_shape, expected_latent_shape):
+        net = SPADEAutoencoderKL(**input_param).to(device)
+        with eval_mode(net):
+            result = net.forward(torch.randn(input_shape).to(device), torch.randn(input_seg).to(device))
+            self.assertEqual(result[0].shape, expected_shape)
+            self.assertEqual(result[1].shape, expected_latent_shape)
+
+    @skipUnless(has_einops, "Requires einops")
+    def test_model_channels_not_multiple_of_norm_num_group(self):
+        with self.assertRaises(ValueError):
+            SPADEAutoencoderKL(
+                spatial_dims=2,
+                label_nc=3,
+                in_channels=1,
+                out_channels=1,
+                channels=(24, 24, 24),
+                attention_levels=(False, False, False),
+                latent_channels=8,
+                num_res_blocks=1,
+                norm_num_groups=16,
+            )
+
+    @skipUnless(has_einops, "Requires einops")
+    def test_model_channels_not_same_size_of_attention_levels(self):
+        with self.assertRaises(ValueError):
+            SPADEAutoencoderKL(
+                spatial_dims=2,
+                label_nc=3,
+                in_channels=1,
+                out_channels=1,
+                channels=(24, 24, 24),
+                attention_levels=(False, False),
+                latent_channels=8,
+                num_res_blocks=1,
+                norm_num_groups=16,
+            )
+
+    @skipUnless(has_einops, "Requires einops")
+    def test_model_channels_not_same_size_of_num_res_blocks(self):
+        with self.assertRaises(ValueError):
+            SPADEAutoencoderKL(
+                spatial_dims=2,
+                label_nc=3,
+                in_channels=1,
+                out_channels=1,
+                channels=(24, 24, 24),
+                attention_levels=(False, False, False),
+                latent_channels=8,
+                num_res_blocks=(8, 8),
+                norm_num_groups=16,
+            )
+
+    def test_shape_encode(self):
+        input_param, input_shape, _, _, expected_latent_shape = CASES[0]
+        net = SPADEAutoencoderKL(**input_param).to(device)
+        with eval_mode(net):
+            result = net.encode(torch.randn(input_shape).to(device))
+            self.assertEqual(result[0].shape, expected_latent_shape)
+            self.assertEqual(result[1].shape, expected_latent_shape)
+
+    def test_shape_sampling(self):
+        input_param, _, _, _, expected_latent_shape = CASES[0]
+        net = SPADEAutoencoderKL(**input_param).to(device)
+        with eval_mode(net):
+            result = net.sampling(
+                torch.randn(expected_latent_shape).to(device), torch.randn(expected_latent_shape).to(device)
+            )
+            self.assertEqual(result.shape, expected_latent_shape)
+
+    def test_shape_decode(self):
+        input_param, _, input_seg_shape, expected_input_shape, latent_shape = CASES[0]
+        net = SPADEAutoencoderKL(**input_param).to(device)
+        with eval_mode(net):
+            result = net.decode(torch.randn(latent_shape).to(device), torch.randn(input_seg_shape).to(device))
+            self.assertEqual(result.shape, expected_input_shape)
+
+    @skipUnless(has_einops, "Requires einops")
+    def test_wrong_shape_decode(self):
+        net = SPADEAutoencoderKL(
+            spatial_dims=2,
+            label_nc=3,
+            in_channels=1,
+            out_channels=1,
+            channels=(4, 4, 4),
+            latent_channels=4,
+            attention_levels=(False, False, False),
+            num_res_blocks=1,
+            norm_num_groups=4,
+        )
+        with self.assertRaises(RuntimeError):
+            _ = net.decode(torch.randn((1, 1, 16, 16)).to(device), torch.randn((1, 6, 16, 16)).to(device))
+
+
+if __name__ == "__main__":
+    unittest.main()