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

tests/networks/nets/test_swin_unetr.py

@@ -0,0 +1,139 @@
+# 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 tempfile
+import unittest
+from unittest import skipUnless
+
+import torch
+from parameterized import parameterized
+
+from monai.apps import download_url
+from monai.networks import eval_mode
+from monai.networks.nets.swin_unetr import PatchMerging, PatchMergingV2, SwinUNETR, filter_swinunetr
+from monai.networks.utils import copy_model_state
+from monai.utils import optional_import
+from tests.test_utils import (
+    assert_allclose,
+    skip_if_downloading_fails,
+    skip_if_no_cuda,
+    skip_if_quick,
+    testing_data_config,
+)
+
+einops, has_einops = optional_import("einops")
+
+TEST_CASE_SWIN_UNETR = []
+case_idx = 0
+test_merging_mode = ["mergingv2", "merging", PatchMerging, PatchMergingV2]
+checkpoint_vals = [True, False]
+for attn_drop_rate in [0.4]:
+    for in_channels in [1]:
+        for depth in [[2, 1, 1, 1], [1, 2, 1, 1]]:
+            for out_channels in [2]:
+                for img_size in ((64, 32, 192), (96, 32)):
+                    for feature_size in [12]:
+                        for norm_name in ["instance"]:
+                            for use_checkpoint in checkpoint_vals:
+                                test_case = [
+                                    {
+                                        "spatial_dims": len(img_size),
+                                        "in_channels": in_channels,
+                                        "out_channels": out_channels,
+                                        "img_size": img_size,
+                                        "feature_size": feature_size,
+                                        "depths": depth,
+                                        "norm_name": norm_name,
+                                        "attn_drop_rate": attn_drop_rate,
+                                        "downsample": test_merging_mode[case_idx % 4],
+                                        "use_checkpoint": use_checkpoint,
+                                    },
+                                    (2, in_channels, *img_size),
+                                    (2, out_channels, *img_size),
+                                ]
+                                case_idx += 1
+                                TEST_CASE_SWIN_UNETR.append(test_case)
+
+TEST_CASE_FILTER = [
+    [
+        {"img_size": (96, 96, 96), "in_channels": 1, "out_channels": 14, "feature_size": 48, "use_checkpoint": True},
+        "swinViT.layers1.0.blocks.0.norm1.weight",
+        torch.tensor([0.9473, 0.9343, 0.8566, 0.8487, 0.8065, 0.7779, 0.6333, 0.5555]),
+    ]
+]
+
+
+class TestSWINUNETR(unittest.TestCase):
+    @parameterized.expand(TEST_CASE_SWIN_UNETR)
+    @skipUnless(has_einops, "Requires einops")
+    def test_shape(self, input_param, input_shape, expected_shape):
+        net = SwinUNETR(**input_param)
+        with eval_mode(net):
+            result = net(torch.randn(input_shape))
+            self.assertEqual(result.shape, expected_shape)
+
+    def test_ill_arg(self):
+        with self.assertRaises(ValueError):
+            SwinUNETR(
+                in_channels=1,
+                out_channels=3,
+                img_size=(128, 128, 128),
+                feature_size=24,
+                norm_name="instance",
+                attn_drop_rate=4,
+            )
+
+        with self.assertRaises(ValueError):
+            SwinUNETR(in_channels=1, out_channels=2, img_size=(96, 96), feature_size=48, norm_name="instance")
+
+        with self.assertRaises(ValueError):
+            SwinUNETR(in_channels=1, out_channels=4, img_size=(96, 96, 96), feature_size=50, norm_name="instance")
+
+        with self.assertRaises(ValueError):
+            SwinUNETR(
+                in_channels=1,
+                out_channels=3,
+                img_size=(85, 85, 85),
+                feature_size=24,
+                norm_name="instance",
+                drop_rate=0.4,
+            )
+
+    def test_patch_merging(self):
+        dim = 10
+        t = PatchMerging(dim)(torch.zeros((1, 21, 20, 20, dim)))
+        self.assertEqual(t.shape, torch.Size([1, 11, 10, 10, 20]))
+
+    @parameterized.expand(TEST_CASE_FILTER)
+    @skip_if_quick
+    @skip_if_no_cuda
+    def test_filter_swinunetr(self, input_param, key, value):
+        with skip_if_downloading_fails():
+            with tempfile.TemporaryDirectory() as tempdir:
+                file_name = "ssl_pretrained_weights.pth"
+                data_spec = testing_data_config("models", f"{file_name.split('.', 1)[0]}")
+                weight_path = os.path.join(tempdir, file_name)
+                download_url(
+                    data_spec["url"], weight_path, hash_val=data_spec["hash_val"], hash_type=data_spec["hash_type"]
+                )
+
+                ssl_weight = torch.load(weight_path)["model"]
+                net = SwinUNETR(**input_param)
+                dst_dict, loaded, not_loaded = copy_model_state(net, ssl_weight, filter_func=filter_swinunetr)
+                assert_allclose(dst_dict[key][:8], value, atol=1e-4, rtol=1e-4, type_test=False)
+                self.assertTrue(len(loaded) == 157 and len(not_loaded) == 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/nets/test_torchvision_fc_model.py

@@ -0,0 +1,201 @@
+# 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 TorchVisionFCModel, UNet
+from monai.networks.utils import look_up_named_module, set_named_module
+from monai.utils import min_version, optional_import
+from tests.test_utils import skip_if_downloading_fails
+
+Inception_V3_Weights, has_enum = optional_import("torchvision.models.inception", name="Inception_V3_Weights")
+
+_, has_tv = optional_import("torchvision", "0.12", min_version)
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+TEST_CASE_0 = [
+    {"model_name": "resnet18", "num_classes": 1, "use_conv": True, "pretrained": False},
+    (2, 3, 224, 224),
+    (2, 1, 1, 1),
+]
+
+TEST_CASE_1 = [
+    {"model_name": "resnet18", "num_classes": 1, "use_conv": True, "pretrained": False},
+    (2, 3, 256, 256),
+    (2, 1, 2, 2),
+]
+
+TEST_CASE_2 = [
+    {"model_name": "resnet101", "num_classes": 5, "use_conv": True, "pretrained": False},
+    (2, 3, 256, 256),
+    (2, 5, 2, 2),
+]
+
+TEST_CASE_3 = [
+    {
+        "model_name": "resnet101",
+        "num_classes": 5,
+        "use_conv": True,
+        "pool": ("avg", {"kernel_size": 6, "stride": 1}),
+        "pretrained": False,
+    },
+    (2, 3, 224, 224),
+    (2, 5, 2, 2),
+]
+
+TEST_CASE_4 = [
+    {"model_name": "resnet18", "num_classes": 1, "use_conv": False, "pool": None, "pretrained": False},
+    (2, 3, 224, 224),
+    (2, 1),
+]
+
+TEST_CASE_5 = [
+    {"model_name": "resnet18", "num_classes": 1, "use_conv": False, "pool": None, "pretrained": False},
+    (2, 3, 256, 256),
+    (2, 1),
+]
+
+TEST_CASE_6 = [
+    {"model_name": "resnet101", "num_classes": 5, "use_conv": False, "pool": None, "pretrained": False},
+    (2, 3, 256, 256),
+    (2, 5),
+]
+
+TEST_CASE_7 = [
+    {
+        "model_name": "inception_v3",
+        "num_classes": 5,
+        "use_conv": True,
+        "pool": "",
+        "in_channels": 2048,
+        "node_name": "Mixed_7c.cat_2",
+    },
+    (2, 3, 299, 299),
+    (2, 5, 8, 8),
+]
+
+TEST_CASE_8 = [
+    {"model_name": "vit_b_16", "num_classes": 5, "in_channels": 768, "pool": None, "fc_name": "heads.head"},
+    (2, 3, 224, 224),
+    (2, 5),
+]
+
+TEST_CASE_PRETRAINED_0 = [
+    {"model_name": "resnet18", "num_classes": 1, "use_conv": True, "pretrained": True},
+    (2, 3, 224, 224),
+    (2, 1, 1, 1),
+    -0.010419349186122417,
+]
+
+TEST_CASE_PRETRAINED_1 = [
+    {"model_name": "resnet18", "num_classes": 1, "use_conv": True, "pretrained": True},
+    (2, 3, 256, 256),
+    (2, 1, 2, 2),
+    -0.010419349186122417,
+]
+
+TEST_CASE_PRETRAINED_2 = [
+    {"model_name": "resnet18", "num_classes": 5, "use_conv": True, "pretrained": True},
+    (2, 3, 256, 256),
+    (2, 5, 2, 2),
+    -0.010419349186122417,
+]
+
+TEST_CASE_PRETRAINED_3 = [
+    {"model_name": "resnet18", "num_classes": 1, "use_conv": False, "pool": None, "pretrained": True},
+    (2, 3, 224, 224),
+    (2, 1),
+    -0.010419349186122417,
+]
+
+TEST_CASE_PRETRAINED_4 = [
+    {"model_name": "resnet18", "num_classes": 1, "use_conv": False, "pool": None, "pretrained": True},
+    (2, 3, 256, 256),
+    (2, 1),
+    -0.010419349186122417,
+]
+
+TEST_CASE_PRETRAINED_5 = [
+    {"model_name": "resnet18", "num_classes": 5, "use_conv": False, "pool": None, "pretrained": True},
+    (2, 3, 256, 256),
+    (2, 5),
+    -0.010419349186122417,
+]
+
+TEST_CASE_PRETRAINED_6 = [
+    {
+        "model_name": "inception_v3",
+        "num_classes": 5,
+        "use_conv": False,
+        "pool": None,
+        "weights": Inception_V3_Weights.IMAGENET1K_V1 if has_enum else None,
+    },
+    (2, 3, 299, 299),
+    (2, 5),
+    -0.21029122173786163,
+]
+
+
+class TestTorchVisionFCModel(unittest.TestCase):
+    @parameterized.expand(
+        [TEST_CASE_0, TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5, TEST_CASE_6, TEST_CASE_7]
+        + ([TEST_CASE_8] if has_enum else [])
+    )
+    @skipUnless(has_tv, "Requires TorchVision.")
+    def test_without_pretrained(self, input_param, input_shape, expected_shape):
+        net = TorchVisionFCModel(**input_param).to(device)
+        with eval_mode(net):
+            result = net.forward(torch.randn(input_shape).to(device))
+            self.assertEqual(result.shape, expected_shape)
+
+    @parameterized.expand(
+        [
+            TEST_CASE_PRETRAINED_0,
+            TEST_CASE_PRETRAINED_1,
+            TEST_CASE_PRETRAINED_2,
+            TEST_CASE_PRETRAINED_3,
+            TEST_CASE_PRETRAINED_4,
+            TEST_CASE_PRETRAINED_5,
+        ]
+        + ([TEST_CASE_PRETRAINED_6] if has_enum else [])
+    )
+    @skipUnless(has_tv, "Requires TorchVision.")
+    def test_with_pretrained(self, input_param, input_shape, expected_shape, expected_value):
+        with skip_if_downloading_fails():
+            net = TorchVisionFCModel(**input_param).to(device)
+        with eval_mode(net):
+            result = net.forward(torch.randn(input_shape).to(device))
+            value = next(net.features.parameters())[0, 0, 0, 0].item()
+            self.assertEqual(value, expected_value)
+            self.assertEqual(result.shape, expected_shape)
+
+
+class TestLookup(unittest.TestCase):
+    def test_get_module(self):
+        net = UNet(spatial_dims=2, in_channels=1, out_channels=1, channels=(4, 8, 16, 32, 64), strides=(2, 2, 2, 2))
+        self.assertEqual(look_up_named_module("", net), net)
+        mod = look_up_named_module("model.1.submodule.1.submodule.1.submodule.0.conv", net)
+        self.assertTrue(str(mod).startswith("Conv2d"))
+        self.assertIsInstance(set_named_module(net, "model", torch.nn.Identity()).model, torch.nn.Identity)
+        self.assertIsNone(look_up_named_module("model.1.submodule.1.submodule.1.submodule.conv", net))
+        self.assertIsNone(look_up_named_module("test attribute", net))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/nets/test_transchex.py

@@ -0,0 +1,84 @@
+# 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.transchex import Transchex
+from tests.test_utils import skip_if_quick
+
+TEST_CASE_TRANSCHEX = []
+for drop_out in [0.4]:
+    for in_channels in [3]:
+        for img_size in [224]:
+            for patch_size in [16, 32]:
+                for num_language_layers in [2]:
+                    for num_vision_layers in [4]:
+                        for num_mixed_layers in [3]:
+                            for num_classes in [8]:
+                                test_case = [
+                                    {
+                                        "in_channels": in_channels,
+                                        "img_size": (img_size,) * 2,
+                                        "patch_size": (patch_size,) * 2,
+                                        "num_vision_layers": num_vision_layers,
+                                        "num_mixed_layers": num_mixed_layers,
+                                        "num_language_layers": num_language_layers,
+                                        "num_classes": num_classes,
+                                        "drop_out": drop_out,
+                                    },
+                                    (2, num_classes),
+                                ]
+                                TEST_CASE_TRANSCHEX.append(test_case)
+
+
+@skip_if_quick
+class TestTranschex(unittest.TestCase):
+    @parameterized.expand(TEST_CASE_TRANSCHEX)
+    def test_shape(self, input_param, expected_shape):
+        net = Transchex(**input_param)
+        with eval_mode(net):
+            result = net(torch.randint(2, (2, 512)), torch.randint(2, (2, 512)), torch.randn((2, 3, 224, 224)))
+            self.assertEqual(result.shape, expected_shape)
+
+    def test_ill_arg(self):
+        with self.assertRaises(ValueError):
+            Transchex(
+                in_channels=3,
+                img_size=(128, 128),
+                patch_size=(16, 16),
+                num_language_layers=2,
+                num_mixed_layers=4,
+                num_vision_layers=2,
+                num_classes=2,
+                drop_out=5.0,
+            )
+
+        with self.assertRaises(ValueError):
+            Transchex(
+                in_channels=1,
+                img_size=(97, 97),
+                patch_size=(16, 16),
+                num_language_layers=6,
+                num_mixed_layers=6,
+                num_vision_layers=8,
+                num_classes=8,
+                drop_out=0.4,
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/nets/test_transformer.py

@@ -0,0 +1,108 @@
+# 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 tempfile
+import unittest
+from unittest import skipUnless
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.apps import download_url
+from monai.networks import eval_mode
+from monai.networks.nets import DecoderOnlyTransformer
+from monai.utils import optional_import
+from tests.test_utils import skip_if_downloading_fails, testing_data_config
+
+_, has_einops = optional_import("einops")
+TEST_CASES = []
+for dropout_rate in np.linspace(0, 1, 2):
+    for attention_layer_dim in [360, 480, 600, 768]:
+        for num_heads in [4, 6, 8, 12]:
+            TEST_CASES.append(
+                [
+                    {
+                        "num_tokens": 10,
+                        "max_seq_len": 16,
+                        "attn_layers_dim": attention_layer_dim,
+                        "attn_layers_depth": 2,
+                        "attn_layers_heads": num_heads,
+                        "embedding_dropout_rate": dropout_rate,
+                    }
+                ]
+            )
+
+
+class TestDecoderOnlyTransformer(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    @skipUnless(has_einops, "Requires einops")
+    def test_unconditioned_models(self, input_param):
+        net = DecoderOnlyTransformer(**input_param)
+        with eval_mode(net):
+            net.forward(torch.randint(0, 10, (1, 16)))
+
+    @parameterized.expand(TEST_CASES)
+    @skipUnless(has_einops, "Requires einops")
+    def test_conditioned_models(self, input_param):
+        net = DecoderOnlyTransformer(**input_param, with_cross_attention=True)
+        with eval_mode(net):
+            net.forward(torch.randint(0, 10, (1, 16)), context=torch.randn(1, 3, input_param["attn_layers_dim"]))
+
+    def test_attention_dim_not_multiple_of_heads(self):
+        with self.assertRaises(ValueError):
+            DecoderOnlyTransformer(
+                num_tokens=10, max_seq_len=16, attn_layers_dim=8, attn_layers_depth=2, attn_layers_heads=3
+            )
+
+    @skipUnless(has_einops, "Requires einops")
+    def test_dropout_rate_negative(self):
+        with self.assertRaises(ValueError):
+            DecoderOnlyTransformer(
+                num_tokens=10,
+                max_seq_len=16,
+                attn_layers_dim=8,
+                attn_layers_depth=2,
+                attn_layers_heads=2,
+                embedding_dropout_rate=-1,
+            )
+
+    @skipUnless(has_einops, "Requires einops")
+    def test_compatibility_with_monai_generative(self):
+        # test loading weights from a model saved in MONAI Generative, version 0.2.3
+        with skip_if_downloading_fails():
+            net = DecoderOnlyTransformer(
+                num_tokens=10,
+                max_seq_len=16,
+                attn_layers_dim=8,
+                attn_layers_depth=2,
+                attn_layers_heads=2,
+                with_cross_attention=True,
+                embedding_dropout_rate=0,
+            )
+
+            tmpdir = tempfile.mkdtemp()
+            key = "decoder_only_transformer_monai_generative_weights"
+            url = testing_data_config("models", key, "url")
+            hash_type = testing_data_config("models", key, "hash_type")
+            hash_val = testing_data_config("models", key, "hash_val")
+            filename = "decoder_only_transformer_monai_generative_weights.pt"
+            weight_path = os.path.join(tmpdir, filename)
+            download_url(url=url, filepath=weight_path, hash_val=hash_val, hash_type=hash_type)
+
+            net.load_old_state_dict(torch.load(weight_path), verbose=False)
+
+
+if __name__ == "__main__":
+    unittest.main()