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

tests/networks/nets/test_dints_network.py

@@ -0,0 +1,168 @@
+# 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.networks.nets import DiNTS, TopologyInstance, TopologySearch
+from monai.networks.nets.dints import Cell
+from tests.test_utils import SkipIfBeforePyTorchVersion, skip_if_quick, test_script_save
+
+TEST_CASES_3D = [
+    [
+        {
+            "channel_mul": 0.2,
+            "num_blocks": 6,
+            "num_depths": 3,
+            "device": "cpu",
+            "use_downsample": False,
+            "spatial_dims": 3,
+        },
+        {
+            "in_channels": 1,
+            "num_classes": 3,
+            "act_name": "RELU",
+            "norm_name": ("INSTANCE", {"affine": True}),
+            "use_downsample": False,
+            "spatial_dims": 3,
+        },
+        (3, 1, 32, 32, 16),
+        (3, 3, 32, 32, 16),
+    ]
+]
+if torch.cuda.is_available():
+    TEST_CASES_3D += [
+        [
+            {
+                "channel_mul": 0.5,
+                "num_blocks": 7,
+                "num_depths": 4,
+                "device": "cuda",
+                "use_downsample": True,
+                "spatial_dims": 3,
+            },
+            {
+                "in_channels": 2,
+                "num_classes": 2,
+                "act_name": "PRELU",
+                "norm_name": "BATCH",
+                "use_downsample": True,
+                "spatial_dims": 3,
+            },
+            (3, 2, 32, 32, 16),
+            (3, 2, 32, 32, 16),
+        ]
+    ]
+TEST_CASES_2D = [
+    [
+        {
+            "channel_mul": 1,
+            "num_blocks": 7,
+            "num_depths": 4,
+            "device": "cpu",
+            "use_downsample": True,
+            "spatial_dims": 2,
+        },
+        {
+            "in_channels": 2,
+            "num_classes": 2,
+            "act_name": "PRELU",
+            "norm_name": "BATCH",
+            "use_downsample": True,
+            "spatial_dims": 2,
+        },
+        (2, 2, 32, 16),
+        (2, 2, 32, 16),
+    ]
+]
+if torch.cuda.is_available():
+    TEST_CASES_2D += [
+        [
+            {
+                "channel_mul": 0.5,
+                "num_blocks": 8,
+                "num_depths": 4,
+                "device": "cuda",
+                "use_downsample": False,
+                "spatial_dims": 2,
+            },
+            {
+                "in_channels": 1,
+                "num_classes": 4,
+                "act_name": "RELU",
+                "norm_name": ("INSTANCE", {"affine": True}),
+                "use_downsample": False,
+                "spatial_dims": 2,
+            },
+            (2, 1, 32, 16),
+            (2, 4, 32, 16),
+        ]
+    ]
+
+
+@skip_if_quick
+class TestDints(unittest.TestCase):
+    @parameterized.expand(TEST_CASES_3D + TEST_CASES_2D)
+    def test_dints_inference(self, dints_grid_params, dints_params, input_shape, expected_shape):
+        grid = TopologySearch(**dints_grid_params)
+        dints_params["dints_space"] = grid
+        net = DiNTS(**dints_params).to(dints_grid_params["device"])
+        result = net(torch.randn(input_shape).to(dints_grid_params["device"]))
+        self.assertEqual(result.shape, expected_shape)
+        # test functions
+        grid.get_ram_cost_usage(in_size=input_shape, full=True)
+        grid.get_ram_cost_usage(in_size=input_shape, full=False)
+        probs_a, _ = grid.get_prob_a(child=True)
+        grid.get_topology_entropy(probs_a)
+        grid.decode()
+        grid.gen_mtx(depth=4)
+
+    @parameterized.expand(TEST_CASES_3D + TEST_CASES_2D)
+    def test_dints_search(self, dints_grid_params, dints_params, input_shape, expected_shape):
+        num_blocks = dints_grid_params["num_blocks"]
+        num_depths = dints_grid_params["num_depths"]
+        # init a Cell to obtain cell operation number
+        _cell = Cell(1, 1, 0, spatial_dims=dints_grid_params["spatial_dims"])
+        num_cell_ops = len(_cell.OPS)
+        # define archtecture codes
+        node_a = torch.ones((num_blocks + 1, num_depths))
+        arch_code_a = np.ones((num_blocks, 3 * num_depths - 2))
+        arch_code_c = np.random.randint(num_cell_ops, size=(num_blocks, 3 * num_depths - 2))
+        # initialize with codes
+        dints_grid_params["arch_code"] = [arch_code_a, arch_code_c]
+        grid = TopologyInstance(**dints_grid_params)
+        # set as deploy stage
+        dints_params["dints_space"] = grid
+        dints_params["node_a"] = node_a
+        net = DiNTS(**dints_params).to(dints_grid_params["device"])
+        result = net(torch.randn(input_shape).to(dints_grid_params["device"]))
+        self.assertEqual(result.shape, expected_shape)
+        self.assertTrue(isinstance(net.weight_parameters(), list))
+
+
+@SkipIfBeforePyTorchVersion((1, 9))
+class TestDintsTS(unittest.TestCase):
+    @parameterized.expand(TEST_CASES_3D + TEST_CASES_2D)
+    def test_script(self, dints_grid_params, dints_params, input_shape, _):
+        grid = TopologyInstance(**dints_grid_params)
+        dints_grid_params["device"] = "cpu"
+        dints_params["dints_space"] = grid
+        net = DiNTS(**dints_params).to(dints_grid_params["device"])
+        test_script_save(net, torch.randn(input_shape).to(dints_grid_params["device"]))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/nets/test_discriminator.py

@@ -0,0 +1,59 @@
+# 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 Discriminator
+from tests.test_utils import test_script_save
+
+TEST_CASE_0 = [
+    {"in_shape": (1, 64, 64), "channels": (2, 4, 8), "strides": (2, 2, 2), "num_res_units": 0},
+    torch.rand(16, 1, 64, 64),
+    (16, 1),
+]
+
+TEST_CASE_1 = [
+    {"in_shape": (1, 64, 64), "channels": (2, 4, 8), "strides": (2, 2, 2), "num_res_units": 2},
+    torch.rand(16, 1, 64, 64),
+    (16, 1),
+]
+
+TEST_CASE_2 = [
+    {"in_shape": (1, 64, 64), "channels": (2, 4), "strides": (2, 2), "num_res_units": 0},
+    torch.rand(16, 1, 64, 64),
+    (16, 1),
+]
+
+CASES = [TEST_CASE_0, TEST_CASE_1, TEST_CASE_2]
+
+
+class TestDiscriminator(unittest.TestCase):
+    @parameterized.expand(CASES)
+    def test_shape(self, input_param, input_data, expected_shape):
+        net = Discriminator(**input_param)
+        with eval_mode(net):
+            result = net.forward(input_data)
+            self.assertEqual(result.shape, expected_shape)
+
+    def test_script(self):
+        net = Discriminator(in_shape=(1, 64, 64), channels=(2, 4), strides=(2, 2), num_res_units=0)
+        test_data = torch.rand(16, 1, 64, 64)
+        test_script_save(net, test_data)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/nets/test_dynunet.py

@@ -0,0 +1,181 @@
+# 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 platform
+import unittest
+from collections.abc import Sequence
+from typing import Any
+
+import torch
+from parameterized import parameterized
+
+from monai.networks import eval_mode
+from monai.networks.nets import DynUNet
+from monai.utils import optional_import
+from tests.test_utils import assert_allclose, skip_if_no_cuda, skip_if_windows, test_script_save
+
+InstanceNorm3dNVFuser, _ = optional_import("apex.normalization", name="InstanceNorm3dNVFuser")
+
+ON_AARCH64 = platform.machine() == "aarch64"
+if ON_AARCH64:
+    rtol, atol = 1e-2, 1e-2
+else:
+    rtol, atol = 1e-4, 1e-4
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+strides: Sequence[Sequence[int] | int]
+kernel_size: Sequence[Any]
+expected_shape: Sequence[Any]
+
+TEST_CASE_DYNUNET_2D = []
+out_channels = 2
+in_size = 64
+spatial_dims = 2
+for kernel_size in [(3, 3, 3, 1), ((3, 1), 1, (3, 3), (1, 1))]:
+    for strides in [(1, 1, 1, 1), (2, 2, 2, 1)]:
+        expected_shape = (1, out_channels, *[in_size // strides[0]] * spatial_dims)
+        for in_channels in [2, 3]:
+            for res_block in [True, False]:
+                test_case = [
+                    {
+                        "spatial_dims": spatial_dims,
+                        "in_channels": in_channels,
+                        "out_channels": out_channels,
+                        "kernel_size": kernel_size,
+                        "strides": strides,
+                        "upsample_kernel_size": strides[1:],
+                        "norm_name": "batch",
+                        "act_name": ("leakyrelu", {"inplace": True, "negative_slope": 0.2}),
+                        "deep_supervision": False,
+                        "res_block": res_block,
+                        "dropout": None,
+                    },
+                    (1, in_channels, in_size, in_size),
+                    expected_shape,
+                ]
+                TEST_CASE_DYNUNET_2D.append(test_case)
+
+TEST_CASE_DYNUNET_3D = []  # in 3d cases, also test anisotropic kernel/strides
+in_channels = 1
+in_size = 64
+for out_channels in [2, 3]:
+    expected_shape = (1, out_channels, 64, 32, 64)
+    for res_block in [True, False]:
+        test_case = [
+            {
+                "spatial_dims": 3,
+                "in_channels": in_channels,
+                "out_channels": out_channels,
+                "kernel_size": (3, (1, 1, 3), 3, 3),
+                "strides": ((1, 2, 1), 2, 2, 1),
+                "upsample_kernel_size": (2, 2, 1),
+                "filters": (64, 96, 128, 192),
+                "norm_name": ("INSTANCE", {"affine": True}),
+                "deep_supervision": True,
+                "res_block": res_block,
+                "dropout": ("alphadropout", {"p": 0.25}),
+            },
+            (1, in_channels, in_size, in_size, in_size),
+            expected_shape,
+        ]
+        TEST_CASE_DYNUNET_3D.append(test_case)
+
+TEST_CASE_DEEP_SUPERVISION = []
+for spatial_dims in [2, 3]:
+    for res_block in [True, False]:
+        for deep_supr_num in [1, 2]:
+            for strides in [(1, 2, 1, 2, 1), (2, 2, 2, 1), (2, 1, 1, 2, 2)]:
+                scale = strides[0]
+                test_case = [
+                    {
+                        "spatial_dims": spatial_dims,
+                        "in_channels": 1,
+                        "out_channels": 2,
+                        "kernel_size": [3] * len(strides),
+                        "strides": strides,
+                        "upsample_kernel_size": strides[1:],
+                        "norm_name": ("group", {"num_groups": 16}),
+                        "deep_supervision": True,
+                        "deep_supr_num": deep_supr_num,
+                        "res_block": res_block,
+                    },
+                    (1, 1, *[in_size] * spatial_dims),
+                    (1, 1 + deep_supr_num, 2, *[in_size // scale] * spatial_dims),
+                ]
+                TEST_CASE_DEEP_SUPERVISION.append(test_case)
+
+
+class TestDynUNet(unittest.TestCase):
+    @parameterized.expand(TEST_CASE_DYNUNET_3D)
+    def test_shape(self, input_param, input_shape, expected_shape):
+        net = DynUNet(**input_param).to(device)
+        if "alphadropout" in input_param.get("dropout"):
+            self.assertTrue(any(isinstance(x, torch.nn.AlphaDropout) for x in net.modules()))
+        with eval_mode(net):
+            result = net(torch.randn(input_shape).to(device))
+            self.assertEqual(result.shape, expected_shape)
+
+    def test_script(self):
+        input_param, input_shape, _ = TEST_CASE_DYNUNET_2D[0]
+        net = DynUNet(**input_param)
+        test_data = torch.randn(input_shape)
+        test_script_save(net, test_data)
+
+
+@skip_if_no_cuda
+@skip_if_windows
+class TestDynUNetWithInstanceNorm3dNVFuser(unittest.TestCase):
+    def setUp(self):
+        try:
+            layer = InstanceNorm3dNVFuser(num_features=1, affine=False).to("cuda:0")
+            inp = torch.randn([1, 1, 1, 1, 1]).to("cuda:0")
+            out = layer(inp)
+            del inp, out, layer
+        except Exception:
+            self.skipTest("NVFuser not available")
+
+    @parameterized.expand([TEST_CASE_DYNUNET_3D[0]])
+    def test_consistency(self, input_param, input_shape, _):
+        for eps in [1e-4, 1e-5]:
+            for momentum in [0.1, 0.01]:
+                for affine in [True, False]:
+                    norm_param = {"eps": eps, "momentum": momentum, "affine": affine}
+                    input_param["norm_name"] = ("instance", norm_param)
+                    input_param_fuser = input_param.copy()
+                    input_param_fuser["norm_name"] = ("instance_nvfuser", norm_param)
+                    for memory_format in [torch.contiguous_format, torch.channels_last_3d]:
+                        net = DynUNet(**input_param).to("cuda:0", memory_format=memory_format)
+                        net_fuser = DynUNet(**input_param_fuser).to("cuda:0", memory_format=memory_format)
+                        net_fuser.load_state_dict(net.state_dict())
+
+                        input_tensor = torch.randn(input_shape).to("cuda:0", memory_format=memory_format)
+                        with eval_mode(net):
+                            result = net(input_tensor)
+                        with eval_mode(net_fuser):
+                            result_fuser = net_fuser(input_tensor)
+
+                        assert_allclose(result, result_fuser, rtol=rtol, atol=atol)
+
+
+class TestDynUNetDeepSupervision(unittest.TestCase):
+    @parameterized.expand(TEST_CASE_DEEP_SUPERVISION)
+    def test_shape(self, input_param, input_shape, expected_shape):
+        net = DynUNet(**input_param).to(device)
+        with torch.no_grad():
+            results = net(torch.randn(input_shape).to(device))
+            self.assertEqual(results.shape, expected_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()