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

tests/utils/test_sample_slices.py

@@ -0,0 +1,43 @@
+# 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.utils import sample_slices
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+# test data[:, [1, ], ...]
+TEST_CASE_1 = [torch.tensor([[[0, 2], [1, 0]]]), 1, True, (1,), torch.tensor([[[1, 0]]])]
+# test data[:, [0, 2], ...]
+TEST_CASE_2 = [torch.tensor([[[0, 2], [1, 0], [4, 5]]]), 1, True, (0, 2), torch.tensor([[[0, 2], [4, 5]]])]
+# test data[:, [0: 2], ...]
+TEST_CASE_3 = [torch.tensor([[[0, 2], [1, 0], [4, 5]]]), 1, False, (0, 2), torch.tensor([[[0, 2], [1, 0]]])]
+# test data[:, [1: ], ...]
+TEST_CASE_4 = [torch.tensor([[[0, 2], [1, 0], [4, 5]]]), 1, False, (1, None), torch.tensor([[[1, 0], [4, 5]]])]
+# test data[:, [0: 3: 2], ...]
+TEST_CASE_5 = [torch.tensor([[[0, 2], [1, 0], [4, 5]]]), 1, False, (0, 3, 2), torch.tensor([[[0, 2], [4, 5]]])]
+
+
+class TestSampleSlices(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5])
+    def test_shape(self, input_data, dim, as_indices, vals, expected_result):
+        for p in TEST_NDARRAYS:
+            result = sample_slices(p(input_data), dim, as_indices, *vals)
+            assert_allclose(p(expected_result), result)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_set_determinism.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 unittest
+
+import numpy as np
+import torch
+
+from monai.utils import get_seed, set_determinism
+from tests.test_utils import SkipIfBeforePyTorchVersion, skip_if_no_cuda
+
+
+class TestSetDeterminism(unittest.TestCase):
+    def test_values(self):
+        # check system default flags
+        set_determinism(None)
+        self.assertTrue(not torch.backends.cudnn.deterministic)
+        self.assertTrue(get_seed() is None)
+        # set default seed
+        set_determinism()
+        self.assertTrue(get_seed() is not None)
+        self.assertTrue(torch.backends.cudnn.deterministic)
+        self.assertTrue(not torch.backends.cudnn.benchmark)
+        # resume default
+        set_determinism(None)
+        self.assertTrue(not torch.backends.cudnn.deterministic)
+        self.assertTrue(not torch.backends.cudnn.benchmark)
+        self.assertTrue(get_seed() is None)
+        # test seeds
+        seed = 255
+        set_determinism(seed=seed)
+        self.assertEqual(seed, get_seed())
+        a = np.random.randint(seed)
+        b = torch.randint(seed, (1,))
+        # tset when global flag support is disabled
+        torch.backends.disable_global_flags()
+        set_determinism(seed=seed)
+        c = np.random.randint(seed)
+        d = torch.randint(seed, (1,))
+        self.assertEqual(a, c)
+        self.assertEqual(b, d)
+        self.assertTrue(torch.backends.cudnn.deterministic)
+        self.assertTrue(not torch.backends.cudnn.benchmark)
+        set_determinism(seed=None)
+
+
+class TestSetFlag(unittest.TestCase):
+    def setUp(self):
+        set_determinism(1, use_deterministic_algorithms=True)
+
+    @SkipIfBeforePyTorchVersion((1, 8))  # beta feature
+    @skip_if_no_cuda
+    def test_algo(self):
+        with self.assertRaises(RuntimeError):
+            x = torch.randn(20, 16, 50, 44, 31, requires_grad=True, device="cuda:0")
+            y = torch.nn.AvgPool3d((3, 2, 2), stride=(2, 1, 2))(x)
+            y.sum().backward()
+
+    def tearDown(self):
+        set_determinism(None, use_deterministic_algorithms=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_squeeze_unsqueeze.py

@@ -0,0 +1,71 @@
+# 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 unsqueeze_left, unsqueeze_right
+
+RIGHT_CASES = [
+    (np.random.rand(3, 4).astype(np.float32), 5, (3, 4, 1, 1, 1)),
+    (torch.rand(3, 4).type(torch.float32), 5, (3, 4, 1, 1, 1)),
+    (np.random.rand(3, 4).astype(np.float64), 5, (3, 4, 1, 1, 1)),
+    (torch.rand(3, 4).type(torch.float64), 5, (3, 4, 1, 1, 1)),
+    (np.random.rand(3, 4).astype(np.int32), 5, (3, 4, 1, 1, 1)),
+    (torch.rand(3, 4).type(torch.int32), 5, (3, 4, 1, 1, 1)),
+]
+
+LEFT_CASES = [
+    (np.random.rand(3, 4).astype(np.float32), 5, (1, 1, 1, 3, 4)),
+    (torch.rand(3, 4).type(torch.float32), 5, (1, 1, 1, 3, 4)),
+    (np.random.rand(3, 4).astype(np.float64), 5, (1, 1, 1, 3, 4)),
+    (torch.rand(3, 4).type(torch.float64), 5, (1, 1, 1, 3, 4)),
+    (np.random.rand(3, 4).astype(np.int32), 5, (1, 1, 1, 3, 4)),
+    (torch.rand(3, 4).type(torch.int32), 5, (1, 1, 1, 3, 4)),
+]
+ALL_CASES = [
+    (np.random.rand(3, 4), 2, (3, 4)),
+    (np.random.rand(3, 4), 0, (3, 4)),
+    (np.random.rand(3, 4), -1, (3, 4)),
+    (np.array(3), 4, (1, 1, 1, 1)),
+    (np.array(3), 0, ()),
+    (np.random.rand(3, 4).astype(np.int32), 2, (3, 4)),
+    (np.random.rand(3, 4).astype(np.int32), 0, (3, 4)),
+    (np.random.rand(3, 4).astype(np.int32), -1, (3, 4)),
+    (np.array(3).astype(np.int32), 4, (1, 1, 1, 1)),
+    (np.array(3).astype(np.int32), 0, ()),
+    (torch.rand(3, 4), 2, (3, 4)),
+    (torch.rand(3, 4), 0, (3, 4)),
+    (torch.rand(3, 4), -1, (3, 4)),
+    (torch.tensor(3), 4, (1, 1, 1, 1)),
+    (torch.tensor(3), 0, ()),
+    (torch.rand(3, 4).type(torch.int32), 2, (3, 4)),
+    (torch.rand(3, 4).type(torch.int32), 0, (3, 4)),
+    (torch.rand(3, 4).type(torch.int32), -1, (3, 4)),
+    (torch.tensor(3).type(torch.int32), 4, (1, 1, 1, 1)),
+    (torch.tensor(3).type(torch.int32), 0, ()),
+]
+
+
+class TestUnsqueeze(unittest.TestCase):
+
+    @parameterized.expand(RIGHT_CASES + ALL_CASES)
+    def test_unsqueeze_right(self, arr, ndim, shape):
+        self.assertEqual(unsqueeze_right(arr, ndim).shape, shape)
+
+    @parameterized.expand(LEFT_CASES + ALL_CASES)
+    def test_unsqueeze_left(self, arr, ndim, shape):
+        self.assertEqual(unsqueeze_left(arr, ndim).shape, shape)

tests/utils/test_state_cacher.py

@@ -0,0 +1,67 @@
+# 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 pickle
+import unittest
+from os.path import exists, join
+from pathlib import Path
+from tempfile import gettempdir
+
+import torch
+from parameterized import parameterized
+
+from monai.utils import StateCacher
+
+DEVICE = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+TEST_CASE_0 = [torch.Tensor([1]).to(DEVICE), {"in_memory": True}]
+TEST_CASE_1 = [
+    torch.Tensor([1]).to(DEVICE),
+    {"in_memory": False, "cache_dir": gettempdir(), "pickle_module": None, "pickle_protocol": pickle.HIGHEST_PROTOCOL},
+]
+TEST_CASE_2 = [torch.Tensor([1]).to(DEVICE), {"in_memory": False, "allow_overwrite": False}]
+TEST_CASE_3 = [torch.Tensor([1]).to(DEVICE), {"in_memory": False, "cache_dir": Path(gettempdir())}]
+
+TEST_CASES = [TEST_CASE_0, TEST_CASE_1, TEST_CASE_2, TEST_CASE_3]
+
+
+class TestStateCacher(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES)
+    def test_state_cacher(self, data_obj, params):
+        key = "data_obj"
+
+        state_cacher = StateCacher(**params)
+        # store it
+        state_cacher.store(key, data_obj, pickle_module=pickle)
+        # create clone then modify original
+        data_obj_orig = data_obj.clone()
+        data_obj += 1
+        # Restore and check nothing has changed
+        data_obj_restored = state_cacher.retrieve(key)
+        self.assertEqual(data_obj_orig, data_obj_restored)
+
+        # If not allow overwrite, check an attempt would raise exception
+        if "allow_overwrite" in params and params["allow_overwrite"]:
+            with self.assertRaises(RuntimeError):
+                state_cacher.store(key, data_obj)
+
+        # If using a cache dir, check file has been deleted et end
+        if "cache_dir" in params:
+            i = id(state_cacher)
+            del state_cacher
+            self.assertFalse(exists(join(params["cache_dir"], f"state_{key}_{i}.pt")))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_torchscript_utils.py

@@ -0,0 +1,113 @@
+# 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
+
+import torch
+
+from monai.config import get_config_values
+from monai.data import load_net_with_metadata, save_net_with_metadata
+from monai.utils import JITMetadataKeys
+
+
+class TestModule(torch.nn.Module):
+    __test__ = False  # indicate to pytest that this class is not intended for collection
+
+    def forward(self, x):
+        return x + 10
+
+
+class TestTorchscript(unittest.TestCase):
+
+    def test_save_net_with_metadata(self):
+        """Save a network without metadata to a file."""
+        m = torch.jit.script(TestModule())
+
+        with tempfile.TemporaryDirectory() as tempdir:
+            save_net_with_metadata(m, f"{tempdir}/test")
+
+            self.assertTrue(os.path.isfile(f"{tempdir}/test.ts"))
+
+    def test_save_net_with_metadata_ext(self):
+        """Save a network without metadata to a file."""
+        m = torch.jit.script(TestModule())
+
+        with tempfile.TemporaryDirectory() as tempdir:
+            save_net_with_metadata(m, f"{tempdir}/test.zip")
+
+            self.assertTrue(os.path.isfile(f"{tempdir}/test.zip"))
+
+    def test_save_net_with_metadata_with_extra(self):
+        """Save a network with simple metadata to a file."""
+        m = torch.jit.script(TestModule())
+
+        test_metadata = {"foo": [1, 2], "bar": "string"}
+
+        with tempfile.TemporaryDirectory() as tempdir:
+            save_net_with_metadata(m, f"{tempdir}/test", meta_values=test_metadata)
+
+            self.assertTrue(os.path.isfile(f"{tempdir}/test.ts"))
+
+    def test_load_net_with_metadata(self):
+        """Save then load a network with no metadata or other extra files."""
+        m = torch.jit.script(TestModule())
+
+        with tempfile.TemporaryDirectory() as tempdir:
+            save_net_with_metadata(m, f"{tempdir}/test")
+            _, meta, extra_files = load_net_with_metadata(f"{tempdir}/test.ts")
+
+        del meta[JITMetadataKeys.TIMESTAMP.value]  # no way of knowing precisely what this value would be
+
+        self.assertEqual(meta, get_config_values())
+        self.assertEqual(extra_files, {})
+
+    def test_load_net_with_metadata_with_extra(self):
+        """Save then load a network with basic metadata."""
+        m = torch.jit.script(TestModule())
+
+        test_metadata = {"foo": [1, 2], "bar": "string"}
+
+        with tempfile.TemporaryDirectory() as tempdir:
+            save_net_with_metadata(m, f"{tempdir}/test", meta_values=test_metadata)
+            _, meta, extra_files = load_net_with_metadata(f"{tempdir}/test.ts")
+
+        del meta[JITMetadataKeys.TIMESTAMP.value]  # no way of knowing precisely what this value would be
+
+        test_compare = get_config_values()
+        test_compare.update(test_metadata)
+
+        self.assertEqual(meta, test_compare)
+        self.assertEqual(extra_files, {})
+
+    def test_save_load_more_extra_files(self):
+        """Save then load extra file data from a torchscript file."""
+        m = torch.jit.script(TestModule())
+
+        test_metadata = {"foo": [1, 2], "bar": "string"}
+
+        more_extra_files = {"test.txt": b"This is test data"}
+
+        with tempfile.TemporaryDirectory() as tempdir:
+            save_net_with_metadata(m, f"{tempdir}/test", meta_values=test_metadata, more_extra_files=more_extra_files)
+
+            self.assertTrue(os.path.isfile(f"{tempdir}/test.ts"))
+
+            _, _, loaded_extra_files = load_net_with_metadata(f"{tempdir}/test.ts", more_extra_files=("test.txt",))
+
+            self.assertEqual(more_extra_files["test.txt"], loaded_extra_files["test.txt"])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_version.py

@@ -0,0 +1,91 @@
+# 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 itertools
+import unittest
+
+from parameterized import parameterized
+
+from monai.utils import version_geq, version_leq
+
+
+# from pkg_resources
+def _pairwise(iterable):
+    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
+    a, b = itertools.tee(iterable)
+    next(b, None)
+    return zip(a, b)
+
+
+# from pkg_resources
+torture = """
+    0.80.1-3 0.80.1-2 0.80.1-1 0.79.9999+0.80.0pre4-1
+    0.79.9999+0.80.0pre2-3 0.79.9999+0.80.0pre2-2
+    0.77.2-1 0.77.1-1 0.77.0-1
+    """
+
+TEST_CASES = (
+    ("1.6.0", "1.6.0"),
+    ("1.6.0a0+9907a3e", "1.6.0"),
+    ("0+unknown", "0.6"),
+    ("ab", "abc"),
+    ("0.6rc1", "0.6"),
+    ("0.6", "0.7"),
+    ("1.2.a", "1.2a"),
+    ("1.2-rc1", "1.2rc1"),
+    ("0.4", "0.4.0"),
+    ("0.4.0.0", "0.4.0"),
+    ("0.4.0-0", "0.4-0"),
+    ("0post1", "0.0post1"),
+    ("0pre1", "0.0c1"),
+    ("0.0.0preview1", "0c1"),
+    ("0.0c1", "0-rc1"),
+    ("1.2a1", "1.2.a.1"),
+    ("1.2.a", "1.2a"),
+    ("2.1", "2.1.1"),
+    ("2a1", "2b0"),
+    ("2a1", "2.1"),
+    ("2.3a1", "2.3"),
+    ("2.1-1", "2.1-2"),
+    ("2.1-1", "2.1.1"),
+    ("2.1", "2.1post4"),
+    ("2.1a0-20040501", "2.1"),
+    ("1.1", "02.1"),
+    ("3.2", "3.2.post0"),
+    ("3.2post1", "3.2post2"),
+    ("0.4", "4.0"),
+    ("0.0.4", "0.4.0"),
+    ("0post1", "0.4post1"),
+    ("2.1.0-rc1", "2.1.0"),
+    ("2.1dev", "2.1a0"),
+    (1.6, "1.6.0"),
+    ("1.6.0", 1.6),
+    (1.6, 1.7),
+) + tuple(_pairwise(reversed(torture.split())))
+
+
+class TestVersionCompare(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES)
+    def test_compare_leq(self, a, b, expected=True):
+        """Test version_leq with `a` and `b`"""
+        self.assertEqual(version_leq(a, b), expected)
+
+    @parameterized.expand(TEST_CASES)
+    def test_compare_geq(self, a, b, expected=True):
+        """Test version_geq with `b` and `a`"""
+        self.assertEqual(version_geq(b, a), expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_version_after.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
+
+from parameterized import parameterized
+
+from monai.utils import compute_capabilities_after, pytorch_after
+
+TEST_CASES_PT = (
+    (1, 5, 9, "1.6.0"),
+    (1, 6, 0, "1.6.0"),
+    (1, 6, 1, "1.6.0", False),
+    (1, 7, 0, "1.6.0", False),
+    (2, 6, 0, "1.6.0", False),
+    (0, 6, 0, "1.6.0a0+3fd9dcf"),
+    (1, 5, 9, "1.6.0a0+3fd9dcf"),
+    (1, 6, 0, "1.6.0a0+3fd9dcf", False),
+    (1, 6, 1, "1.6.0a0+3fd9dcf", False),
+    (2, 6, 0, "1.6.0a0+3fd9dcf", False),
+    (1, 6, 0, "1.6.0-rc0+3fd9dcf", False),  # defaults to prerelease
+    (1, 6, 0, "1.6.0rc0", False),
+    (1, 6, 0, "1.6", True),
+    (1, 6, 0, "1", False),
+    (1, 6, 0, "1.6.0+cpu", True),
+    (1, 6, 1, "1.6.0+cpu", False),
+)
+
+TEST_CASES_SM = [
+    # (major, minor, sm, expected)
+    (6, 1, "6.1", True),
+    (6, 1, "6.0", False),
+    (6, 0, "8.6", True),
+    (7, 0, "8", True),
+    (8, 6, "8", False),
+]
+
+
+class TestPytorchVersionCompare(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES_PT)
+    def test_compare(self, a, b, p, current, expected=True):
+        """Test pytorch_after with a and b"""
+        self.assertEqual(pytorch_after(a, b, p, current), expected)
+
+
+class TestComputeCapabilitiesAfter(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES_SM)
+    def test_compute_capabilities_after(self, major, minor, sm, expected):
+        self.assertEqual(compute_capabilities_after(major, minor, sm), expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/type_conversion/__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.