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

tests/networks/test_varnet.py

@@ -0,0 +1,63 @@
+# 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.apps.reconstruction.networks.nets.coil_sensitivity_model import CoilSensitivityModel
+from monai.apps.reconstruction.networks.nets.complex_unet import ComplexUnet
+from monai.apps.reconstruction.networks.nets.varnet import VariationalNetworkModel
+from monai.networks import eval_mode
+from tests.test_utils import SkipIfBeforePyTorchVersion, test_script_save
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+coil_sens_model = CoilSensitivityModel(spatial_dims=2, features=[8, 16, 32, 64, 128, 8])
+refinement_model = ComplexUnet(spatial_dims=2, features=[8, 16, 32, 64, 128, 8])
+num_cascades = 2
+TESTS = []
+TESTS.append([coil_sens_model, refinement_model, num_cascades, (1, 3, 50, 50, 2), (1, 50, 50)])  # batch=1
+TESTS.append([coil_sens_model, refinement_model, num_cascades, (2, 3, 50, 50, 2), (2, 50, 50)])  # batch=2
+
+
+class TestVarNet(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_shape(self, coil_sens_model, refinement_model, num_cascades, input_shape, expected_shape):
+        net = VariationalNetworkModel(coil_sens_model, refinement_model, num_cascades).to(device)
+        mask_shape = [1 for _ in input_shape]
+        mask_shape[-2] = input_shape[-2]
+        mask = torch.zeros(mask_shape)
+        mask[..., mask_shape[-2] // 2 - 5 : mask_shape[-2] // 2 + 5, :] = 1
+
+        with eval_mode(net):
+            result = net(torch.randn(input_shape).to(device), mask.bool().to(device))
+        self.assertEqual(result.shape, expected_shape)
+
+    @parameterized.expand(TESTS)
+    @SkipIfBeforePyTorchVersion((1, 9, 1))
+    def test_script(self, coil_sens_model, refinement_model, num_cascades, input_shape, expected_shape):
+        net = VariationalNetworkModel(coil_sens_model, refinement_model, num_cascades)
+
+        mask_shape = [1 for _ in input_shape]
+        mask_shape[-2] = input_shape[-2]
+        mask = torch.zeros(mask_shape)
+        mask[..., mask_shape[-2] // 2 - 5 : mask_shape[-2] // 2 + 5, :] = 1
+
+        test_data = torch.randn(input_shape)
+
+        test_script_save(net, test_data, mask.bool())
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/utils/__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/networks/utils/test_copy_model_state.py

@@ -0,0 +1,187 @@
+# 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.utils import copy_model_state
+from monai.utils import set_determinism
+
+
+class _TestModelOne(torch.nn.Module):
+
+    def __init__(self, n_n, n_m, n_class):
+        super().__init__()
+        self.layer = torch.nn.Linear(n_n, n_m)
+        self.class_layer = torch.nn.Linear(n_m, n_class)
+
+    def forward(self, x):
+        x = self.layer(x)
+        x = self.class_layer(x)
+        return x
+
+
+class _TestModelTwo(torch.nn.Module):
+
+    def __init__(self, n_n, n_m, n_d, n_class):
+        super().__init__()
+        self.layer = torch.nn.Linear(n_n, n_m)
+        self.layer_1 = torch.nn.Linear(n_m, n_d)
+        self.class_layer = torch.nn.Linear(n_d, n_class)
+
+    def forward(self, x):
+        x = self.layer(x)
+        x = self.layer_1(x)
+        x = self.class_layer(x)
+        return x
+
+
+TEST_CASES = []
+__devices = ("cpu", "cuda") if torch.cuda.is_available() else ("cpu",)
+for _x in __devices:
+    for _y in __devices:
+        TEST_CASES.append((_x, _y))
+
+
+class TestModuleState(unittest.TestCase):
+
+    def tearDown(self):
+        set_determinism(None)
+
+    @parameterized.expand(TEST_CASES)
+    def test_set_state(self, device_0, device_1):
+        set_determinism(0)
+        model_one = _TestModelOne(10, 20, 3)
+        model_two = _TestModelTwo(10, 20, 10, 4)
+        model_one.to(device_0)
+        model_two.to(device_1)
+        model_dict, ch, unch = copy_model_state(model_one, model_two)
+        x = np.random.randn(4, 10)
+        x = torch.tensor(x, device=device_0, dtype=torch.float32)
+        output = model_one(x).detach().cpu().numpy()
+        expected = np.array(
+            [
+                [-0.36076584, -0.03177825, -0.7702266],
+                [-0.0526831, -0.15855855, -0.01149344],
+                [-0.3760508, -0.22485238, -0.0634037],
+                [0.5977675, -0.67991066, 0.1919502],
+            ]
+        )
+        np.testing.assert_allclose(output, expected, atol=1e-3)
+        self.assertEqual(len(ch), 2)
+        self.assertEqual(len(unch), 2)
+
+    @parameterized.expand(TEST_CASES)
+    def test_set_full_state(self, device_0, device_1):
+        set_determinism(0)
+        model_one = _TestModelOne(10, 20, 3)
+        model_two = _TestModelOne(10, 20, 3)
+        model_one.to(device_0)
+        model_two.to(device_1)
+        # test module input
+        model_dict, ch, unch = copy_model_state(model_one, model_two)
+        # test dict input
+        model_dict, ch, unch = copy_model_state(model_dict, model_two)
+        x = np.random.randn(4, 10)
+        x = torch.tensor(x, device=device_0, dtype=torch.float32)
+        output = model_one(x).detach().cpu().numpy()
+        model_two.to(device_0)
+        output_1 = model_two(x).detach().cpu().numpy()
+        np.testing.assert_allclose(output, output_1, atol=1e-3)
+        self.assertEqual(len(ch), 4)
+        self.assertEqual(len(unch), 0)
+
+    @parameterized.expand(TEST_CASES)
+    def test_set_exclude_vars(self, device_0, device_1):
+        set_determinism(0)
+        model_one = _TestModelOne(10, 20, 3)
+        model_two = _TestModelTwo(10, 20, 10, 4)
+        model_one.to(device_0)
+        model_two.to(device_1)
+        # test skip layer.bias
+        model_dict, ch, unch = copy_model_state(model_one, model_two, exclude_vars="layer.bias")
+        x = np.random.randn(4, 10)
+        x = torch.tensor(x, device=device_0, dtype=torch.float32)
+        output = model_one(x).detach().cpu().numpy()
+        expected = np.array(
+            [
+                [-0.34172416, 0.0375042, -0.98340976],
+                [-0.03364138, -0.08927619, -0.2246768],
+                [-0.35700908, -0.15556987, -0.27658707],
+                [0.61680925, -0.6106281, -0.02123314],
+            ]
+        )
+        np.testing.assert_allclose(output, expected, atol=1e-3)
+        self.assertEqual(len(ch), 1)
+        self.assertEqual(len(unch), 3)
+
+    @parameterized.expand(TEST_CASES)
+    def test_set_map_across(self, device_0, device_1):
+        set_determinism(0)
+        model_one = _TestModelOne(10, 10, 3)
+        model_two = _TestModelTwo(10, 10, 10, 4)
+        model_one.to(device_0)
+        model_two.to(device_1)
+        # test weight map
+        model_dict, ch, unch = copy_model_state(
+            model_one, model_two, mapping={"layer_1.weight": "layer.weight", "layer_1.bias": "layer_1.weight"}
+        )
+        model_one.load_state_dict(model_dict)
+        x = np.random.randn(4, 10)
+        x = torch.tensor(x, device=device_0, dtype=torch.float32)
+        output = model_one(x).detach().cpu().numpy()
+        expected = np.array(
+            [
+                [0.8244487, -0.19650555, 0.65723234],
+                [0.71239626, 0.25617486, 0.5247122],
+                [0.24168758, 1.0301148, 0.39089814],
+                [0.25791705, 0.8653245, 0.14833644],
+            ]
+        )
+        np.testing.assert_allclose(output, expected, atol=1e-3)
+        self.assertEqual(len(ch), 2)
+        self.assertEqual(len(unch), 2)
+
+    @parameterized.expand(TEST_CASES)
+    def test_set_prefix(self, device_0, device_1):
+        set_determinism(0)
+        model_one = torch.nn.Sequential(_TestModelOne(10, 20, 3))
+        model_two = _TestModelTwo(10, 20, 10, 4)
+        model_one.to(device_0)
+        model_two.to(device_1)
+        # test skip layer.bias
+        model_dict, ch, unch = copy_model_state(
+            model_one, model_two, dst_prefix="0.", exclude_vars="layer.bias", inplace=False
+        )
+        model_one.load_state_dict(model_dict)
+        x = np.random.randn(4, 10)
+        x = torch.tensor(x, device=device_0, dtype=torch.float32)
+        output = model_one(x).detach().cpu().numpy()
+        expected = np.array(
+            [
+                [-0.360766, -0.031778, -0.770227],
+                [-0.052683, -0.158559, -0.011493],
+                [-0.376051, -0.224852, -0.063404],
+                [0.597767, -0.679911, 0.19195],
+            ]
+        )
+        np.testing.assert_allclose(output, expected, atol=1e-3)
+        self.assertEqual(len(ch), 2)
+        self.assertEqual(len(unch), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/utils/test_eval_mode.py

@@ -0,0 +1,34 @@
+# 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 monai.networks.utils import eval_mode
+
+
+class TestEvalMode(unittest.TestCase):
+
+    def test_eval_mode(self):
+        t = torch.rand(1, 1, 4, 4)
+        p = torch.nn.Conv2d(1, 1, 3)
+        self.assertTrue(p.training)  # True
+        with eval_mode(p):
+            self.assertFalse(p.training)  # False
+            with self.assertRaises(RuntimeError):
+                p(t).sum().backward()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/utils/test_freeze_layers.py

@@ -0,0 +1,61 @@
+# 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.utils import freeze_layers
+from monai.utils import set_determinism
+from tests.networks.utils.test_copy_model_state import _TestModelOne, _TestModelTwo
+
+TEST_CASES = []
+__devices = ("cpu", "cuda") if torch.cuda.is_available() else ("cpu",)
+for _x in __devices:
+    TEST_CASES.append(_x)
+
+
+class TestModuleState(unittest.TestCase):
+    def tearDown(self):
+        set_determinism(None)
+
+    @parameterized.expand(TEST_CASES)
+    def test_freeze_vars(self, device):
+        set_determinism(0)
+        model = _TestModelOne(10, 20, 3)
+        model.to(device)
+        freeze_layers(model, "class")
+
+        for name, param in model.named_parameters():
+            if "class_layer" in name:
+                self.assertFalse(param.requires_grad)
+            else:
+                self.assertTrue(param.requires_grad)
+
+    @parameterized.expand(TEST_CASES)
+    def test_exclude_vars(self, device):
+        set_determinism(0)
+        model = _TestModelTwo(10, 20, 10, 4)
+        model.to(device)
+        freeze_layers(model, exclude_vars="class")
+
+        for name, param in model.named_parameters():
+            if "class_layer" in name:
+                self.assertTrue(param.requires_grad)
+            else:
+                self.assertFalse(param.requires_grad)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/utils/test_replace_module.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 DenseNet121
+from monai.networks.utils import replace_modules, replace_modules_temp
+from tests.test_utils import TEST_DEVICES
+
+TESTS = []
+for device in TEST_DEVICES:
+    for match_device in (True, False):
+        # replace 1
+        TESTS.append(("features.denseblock1.denselayer1.layers.relu1", True, match_device, *device))
+        # replace 1 (but not strict)
+        TESTS.append(("features.denseblock1.denselayer1.layers.relu1", False, match_device, *device))
+        # replace multiple
+        TESTS.append(("relu", False, match_device, *device))
+
+
+class TestReplaceModule(unittest.TestCase):
+    def setUp(self):
+        self.net = DenseNet121(spatial_dims=2, in_channels=1, out_channels=3)
+        self.num_relus = self.get_num_modules(torch.nn.ReLU)
+        self.total = self.get_num_modules()
+        self.assertGreater(self.num_relus, 0)
+
+    def get_num_modules(self, mod: type[torch.nn.Module] | None = None) -> int:
+        m = [m for _, m in self.net.named_modules()]
+        if mod is not None:
+            m = [_m for _m in m if isinstance(_m, mod)]
+        return len(m)
+
+    def check_replaced_modules(self, name, match_device):
+        # total num modules should remain the same
+        self.assertEqual(self.total, self.get_num_modules())
+        num_relus_mod = self.get_num_modules(torch.nn.ReLU)
+        num_softmax = self.get_num_modules(torch.nn.Softmax)
+        # list of returned modules should be as long as number of softmax
+        self.assertEqual(self.num_relus, num_relus_mod + num_softmax)
+        if name == "relu":
+            # at least 2 softmaxes
+            self.assertGreaterEqual(num_softmax, 2)
+        else:
+            # one softmax
+            self.assertEqual(num_softmax, 1)
+        if match_device:
+            self.assertEqual(len(list({i.device for i in self.net.parameters()})), 1)
+
+    @parameterized.expand(TESTS)
+    def test_replace(self, name, strict_match, match_device, device):
+        self.net.to(device)
+        # replace module(s)
+        replaced = replace_modules(self.net, name, torch.nn.Softmax(), strict_match, match_device)
+        self.check_replaced_modules(name, match_device)
+        # number of returned modules should equal number of softmax modules
+        self.assertEqual(len(replaced), self.get_num_modules(torch.nn.Softmax))
+        # all replaced modules should be ReLU
+        for r in replaced:
+            self.assertIsInstance(r[1], torch.nn.ReLU)
+        # if a specfic module was named, check that the name matches exactly
+        if name == "features.denseblock1.denselayer1.layers.relu1":
+            self.assertEqual(replaced[0][0], name)
+
+    @parameterized.expand(TESTS)
+    def test_replace_context_manager(self, name, strict_match, match_device, device):
+        self.net.to(device)
+        with replace_modules_temp(self.net, name, torch.nn.Softmax(), strict_match, match_device):
+            self.check_replaced_modules(name, match_device)
+        # Check that model was correctly reverted
+        self.assertEqual(self.get_num_modules(), self.total)
+        self.assertEqual(self.get_num_modules(torch.nn.ReLU), self.num_relus)
+        self.assertEqual(self.get_num_modules(torch.nn.Softmax), 0)
+
+    def test_raises(self):
+        # name doesn't exist in module
+        with self.assertRaises(AttributeError):
+            replace_modules(self.net, "non_existent_module", torch.nn.Softmax(), strict_match=True)
+        with self.assertRaises(AttributeError):
+            with replace_modules_temp(self.net, "non_existent_module", torch.nn.Softmax(), strict_match=True):
+                pass
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/utils/test_train_mode.py

@@ -0,0 +1,34 @@
+# 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 monai.networks.utils import train_mode
+
+
+class TestEvalMode(unittest.TestCase):
+
+    def test_eval_mode(self):
+        t = torch.rand(1, 1, 4, 4)
+        p = torch.nn.Conv2d(1, 1, 3)
+        p.eval()
+        self.assertFalse(p.training)  # False
+        with train_mode(p):
+            self.assertTrue(p.training)  # True
+            p(t).sum().backward()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/optimizers/__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/optimizers/test_generate_param_groups.py

@@ -0,0 +1,105 @@
+# 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 Unet
+from monai.optimizers import generate_param_groups
+from monai.utils import ensure_tuple
+from tests.test_utils import assert_allclose
+
+TEST_CASE_1 = [{"layer_matches": [lambda x: x.model[-1]], "match_types": "select", "lr_values": [1]}, (1, 100), [5, 21]]
+
+TEST_CASE_2 = [
+    {
+        "layer_matches": [lambda x: x.model[-1], lambda x: x.model[-2], lambda x: x.model[-3]],
+        "match_types": "select",
+        "lr_values": [1, 2, 3],
+    },
+    (1, 2, 3, 100),
+    [5, 16, 5, 0],
+]
+
+TEST_CASE_3 = [
+    {"layer_matches": [lambda x: x.model[2][1].conv[0].conv], "match_types": ["select"], "lr_values": [1]},
+    (1, 100),
+    [2, 24],
+]
+
+TEST_CASE_4 = [
+    {
+        "layer_matches": [lambda x: x.model[0], lambda x: "2.0.conv" in x[0]],
+        "match_types": ["select", "filter"],
+        "lr_values": [1, 2],
+    },
+    (1, 2, 100),
+    [5, 4, 17],
+]
+
+TEST_CASE_5 = [
+    {"layer_matches": [lambda x: x.model[-1]], "match_types": ["select"], "lr_values": [1], "include_others": False},
+    (1),
+    [5],
+]
+
+TEST_CASE_6 = [
+    {
+        "layer_matches": [lambda x: "weight" in x[0]],
+        "match_types": ["filter"],
+        "lr_values": [1],
+        "include_others": True,
+    },
+    (1),
+    [16, 10],
+]
+
+
+class TestGenerateParamGroups(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5, TEST_CASE_6])
+    def test_lr_values(self, input_param, expected_values, expected_groups):
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        net = Unet(
+            spatial_dims=3, in_channels=1, out_channels=3, channels=(16, 32, 64), strides=(2, 2), num_res_units=1
+        ).to(device)
+
+        params = generate_param_groups(network=net, **input_param)
+        optimizer = torch.optim.Adam(params, 100)
+
+        for param_group, value in zip(optimizer.param_groups, ensure_tuple(expected_values)):
+            assert_allclose(param_group["lr"], value)
+
+        n = [len(p["params"]) for p in params]
+        self.assertListEqual(n, expected_groups)
+
+    def test_wrong(self):
+        """overlapped"""
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        net = Unet(
+            spatial_dims=3, in_channels=1, out_channels=3, channels=(16, 32, 64), strides=(2, 2), num_res_units=1
+        ).to(device)
+
+        params = generate_param_groups(
+            network=net,
+            layer_matches=[lambda x: x.model[-1], lambda x: x.model[-1]],
+            match_types="select",
+            lr_values=0.1,
+        )
+        with self.assertRaises(ValueError):
+            torch.optim.Adam(params, 100)
+
+
+if __name__ == "__main__":
+    unittest.main()