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

tests/utils/test_handler_metric_logger.py

@@ -0,0 +1,62 @@
+# 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.utils import optional_import
+from tests.test_utils import SkipIfNoModule
+
+try:
+    _, has_ignite = optional_import("ignite")
+    from ignite.engine import Engine, Events
+
+    from monai.handlers import MetricLogger
+except ImportError:
+    has_ignite = False
+
+
+class TestHandlerMetricLogger(unittest.TestCase):
+    @SkipIfNoModule("ignite")
+    def test_metric_logging(self):
+        dummy_name = "dummy"
+
+        # set up engine
+        def _train_func(engine, batch):
+            return torch.tensor(0.0)
+
+        engine = Engine(_train_func)
+
+        # set up dummy metric
+        @engine.on(Events.EPOCH_COMPLETED)
+        def _update_metric(engine):
+            engine.state.metrics[dummy_name] = 1
+
+        # set up testing handler
+        handler = MetricLogger(loss_transform=lambda output: output.item())
+        handler.attach(engine)
+
+        engine.run(range(3), max_epochs=2)
+
+        expected_loss = [(1, 0.0), (2, 0.0), (3, 0.0), (4, 0.0), (5, 0.0), (6, 0.0)]
+        expected_metric = [(4, 1), (5, 1), (6, 1)]
+
+        self.assertSetEqual({dummy_name}, set(handler.metrics))
+
+        self.assertListEqual(expected_loss, handler.loss)
+        self.assertListEqual(expected_metric, handler.metrics[dummy_name])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_list_to_dict.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
+
+from parameterized import parameterized
+
+from monai.utils import list_to_dict
+
+TEST_CASE_1 = [["a=1", "b=2", "c=3", "d=4"], {"a": 1, "b": 2, "c": 3, "d": 4}]
+
+TEST_CASE_2 = [["a=a", "b=b", "c=c", "d=d"], {"a": "a", "b": "b", "c": "c", "d": "d"}]
+
+TEST_CASE_3 = [["a=0.1", "b=0.2", "c=0.3", "d=0.4"], {"a": 0.1, "b": 0.2, "c": 0.3, "d": 0.4}]
+
+TEST_CASE_4 = [["a=True", "b=TRUE", "c=false", "d=FALSE"], {"a": True, "b": True, "c": False, "d": False}]
+
+TEST_CASE_5 = [
+    ["a='1'", "b=2 ", " c = 3", "d='test'", "'e'=0", "f", "g=None"],
+    {"a": 1, "b": 2, "c": 3, "d": "test", "e": 0, "f": None, "g": None},
+]
+
+
+class TestListToDict(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5])
+    def test_value_shape(self, input, output):
+        result = list_to_dict(input)
+        self.assertDictEqual(result, output)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_look_up_option.py

@@ -0,0 +1,87 @@
+# 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 enum import Enum
+
+from parameterized import parameterized
+
+from monai.utils import StrEnum, look_up_option
+
+
+class _CaseEnum(Enum):
+    CONST = "constant"
+    EMPTY = "empty"
+
+
+class _CaseEnum1(Enum):
+    CONST = "constant"
+    EMPTY = "empty"
+
+
+class _CaseStrEnum(StrEnum):
+    MODE_A = "A"
+    MODE_B = "B"
+
+
+TEST_CASES = (
+    ("test", ("test", "test1"), "test"),
+    ("test1", {"test1", "test"}, "test1"),
+    (2, {1: "test", 2: "valid"}, "valid"),
+    (_CaseEnum.EMPTY, _CaseEnum, _CaseEnum.EMPTY),
+    ("empty", _CaseEnum, _CaseEnum.EMPTY),
+)
+
+
+class TestLookUpOption(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES)
+    def test_look_up(self, input_str, supported, expected):
+        output = look_up_option(input_str, supported)
+        self.assertEqual(output, expected)
+
+    def test_default(self):
+        output = look_up_option("not here", {"a", "b"}, default=None)
+        self.assertEqual(output, None)
+
+    def test_str_enum(self):
+        output = look_up_option("C", {"A", "B"}, default=None)
+        self.assertIsNone(output)
+        self.assertEqual(list(_CaseStrEnum), ["A", "B"])
+        self.assertEqual(_CaseStrEnum.MODE_A, "A")
+        self.assertEqual(str(_CaseStrEnum.MODE_A), "A")
+        self.assertEqual(look_up_option("A", _CaseStrEnum), "A")
+
+    def test_no_found(self):
+        with self.assertRaisesRegex(ValueError, "Unsupported"):
+            look_up_option("not here", {"a", "b"})
+        with self.assertRaisesRegex(ValueError, "Unsupported"):
+            look_up_option("not here", ["a", "b"])
+        with self.assertRaisesRegex(ValueError, "Unsupported"):
+            look_up_option("not here", {"a": 1, "b": 2})
+        with self.assertRaisesRegex(ValueError, "did you mean"):
+            look_up_option(3, {1: "a", 2: "b", "c": 3})
+        with self.assertRaisesRegex(ValueError, "did.*empty"):
+            look_up_option("empy", _CaseEnum)
+        with self.assertRaisesRegex(ValueError, "Unsupported"):
+            look_up_option(_CaseEnum1.EMPTY, _CaseEnum)
+        with self.assertRaisesRegex(ValueError, "Unsupported"):
+            look_up_option(None, _CaseEnum)
+        with self.assertRaisesRegex(ValueError, "No"):
+            look_up_option(None, None)
+        with self.assertRaisesRegex(ValueError, "No"):
+            look_up_option("test", None)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_optional_import.py

@@ -0,0 +1,80 @@
+# 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 OptionalImportError, exact_version, optional_import
+
+
+class TestOptionalImport(unittest.TestCase):
+
+    @parameterized.expand(["not_a_module", "torch.randint"])
+    def test_default(self, import_module):
+        my_module, flag = optional_import(import_module)
+        self.assertFalse(flag)
+        with self.assertRaises(OptionalImportError):
+            my_module.test
+
+    def test_import_valid(self):
+        my_module, flag = optional_import("torch")
+        self.assertTrue(flag)
+        print(my_module.randint(1, 2, (1, 2)))
+
+    def test_import_wrong_number(self):
+        my_module, flag = optional_import("torch", "42")
+        with self.assertRaisesRegex(OptionalImportError, "version"):
+            my_module.nn
+        self.assertFalse(flag)
+        with self.assertRaisesRegex(OptionalImportError, "version"):
+            my_module.randint(1, 2, (1, 2))
+        with self.assertRaisesRegex(ValueError, "invalid literal"):
+            my_module, flag = optional_import("torch", "test")  # version should be number.number
+            my_module.nn
+            self.assertTrue(flag)
+            print(my_module.randint(1, 2, (1, 2)))
+
+    @parameterized.expand(["0", "0.0.0.1", "1.1.0"])
+    def test_import_good_number(self, version_number):
+        my_module, flag = optional_import("torch", version_number)
+        my_module.nn
+        self.assertTrue(flag)
+        print(my_module.randint(1, 2, (1, 2)))
+
+    def test_import_exact(self):
+        my_module, flag = optional_import("torch", "0", exact_version)
+        with self.assertRaisesRegex(OptionalImportError, "exact_version"):
+            my_module.nn
+        self.assertFalse(flag)
+        with self.assertRaisesRegex(OptionalImportError, "exact_version"):
+            my_module.randint(1, 2, (1, 2))
+
+    def test_import_method(self):
+        nn, flag = optional_import("torch", "1.1", name="nn")
+        self.assertTrue(flag)
+        print(nn.functional)
+
+    def test_additional(self):
+        test_args = {"a": "test", "b": "test"}
+
+        def versioning(module, ver, a):
+            self.assertEqual(a, test_args)
+            return True
+
+        nn, flag = optional_import("torch", "1.1", version_checker=versioning, name="nn", version_args=test_args)
+        self.assertTrue(flag)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_pad_mode.py

@@ -0,0 +1,39 @@
+# 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.transforms import CastToType, Pad
+from monai.utils import NumpyPadMode, PytorchPadMode
+from tests.test_utils import SkipIfBeforePyTorchVersion
+
+
+@SkipIfBeforePyTorchVersion((1, 10, 1))
+class TestPadMode(unittest.TestCase):
+    def test_pad(self):
+        expected_shapes = {3: (1, 15, 10), 4: (1, 10, 6, 7)}
+        for t in (float, int, np.uint8, np.int16, np.float32, bool):
+            for d in ("cuda:0", "cpu") if torch.cuda.is_available() else ("cpu",):
+                for s in ((1, 10, 10), (1, 5, 6, 7)):
+                    for m in list(PytorchPadMode) + list(NumpyPadMode):
+                        a = torch.rand(s)
+                        to_pad = [(0, 0), (2, 3)] if len(s) == 3 else [(0, 0), (2, 3), (0, 0), (0, 0)]
+                        out = Pad(to_pad=to_pad, mode=m)(CastToType(dtype=t)(a).to(d))
+                        self.assertEqual(out.shape, expected_shapes[len(s)])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_profiling.py

@@ -0,0 +1,208 @@
+# 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 datetime
+import os
+import unittest
+from io import StringIO
+
+import torch
+
+import monai.transforms as mt
+from monai.data import Dataset, ThreadDataLoader
+from monai.utils import first, optional_import
+from monai.utils.enums import CommonKeys
+from monai.utils.profiling import ProfileHandler, ProfileResult, WorkflowProfiler
+from tests.test_utils import SkipIfNoModule
+
+pd, _ = optional_import("pandas")
+
+
+class TestWorkflowProfiler(unittest.TestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.scale = mt.ScaleIntensity()
+        self.scale_call_name = "ScaleIntensity.__call__"
+        self.compose_call_name = "Compose.__call__"
+        self.test_comp = mt.Compose([mt.ScaleIntensity(), mt.RandAxisFlip(0.5)])
+        self.test_image = torch.rand(1, 16, 16, 16)
+        self.pid = os.getpid()
+
+    def test_empty(self):
+        """Test that the profiler correctly produces an empty result when nothing happens in a context."""
+        wp = WorkflowProfiler()
+
+        with wp:
+            pass
+
+        self.assertEqual(wp.get_results(), {})
+
+    def test_profile_transforms(self):
+        """Test basic reporting when invoking a single transform directly."""
+        with WorkflowProfiler() as wp:
+            self.scale(self.test_image)
+
+        results = wp.get_results()
+        self.assertSequenceEqual(list(results), [self.scale_call_name])
+
+        prs = results[self.scale_call_name]
+
+        self.assertEqual(len(prs), 1)
+
+        pr = prs[0]
+
+        self.assertIsInstance(pr, ProfileResult)
+        self.assertEqual(pr.name, self.scale_call_name)
+        self.assertEqual(pr.pid, self.pid)
+        self.assertGreater(pr.time, 0)
+
+        dt = datetime.datetime.fromisoformat(pr.timestamp)
+
+        self.assertIsInstance(dt, datetime.datetime)
+
+    def test_profile_multithread(self):
+        """Test resulst are gathered from multiple threads using ThreadDataLoader."""
+        ds = Dataset([self.test_image] * 4, self.scale)
+        dl = ThreadDataLoader(ds, batch_size=4, num_workers=4, use_thread_workers=True)
+
+        with WorkflowProfiler() as wp:
+            batch = first(dl)
+
+        self.assertSequenceEqual(batch.shape, (4, 1, 16, 16, 16))
+
+        results = wp.get_results()
+        self.assertSequenceEqual(list(results), [self.scale_call_name, self.compose_call_name])
+
+        prs = results[self.scale_call_name]
+
+        self.assertEqual(len(prs), 4)
+
+    def test_profile_context(self):
+        """Test results from profiling contexts with the same name accumulate correctly."""
+        with WorkflowProfiler() as wp:
+            with wp.profile_ctx("context"):
+                self.scale(self.test_image)
+
+            with wp.profile_ctx("context"):
+                self.scale(self.test_image)
+
+        results = wp.get_results()
+
+        self.assertSequenceEqual(set(results), {"ScaleIntensity.__call__", "context"})
+
+        prs = results["context"]
+
+        self.assertEqual(len(prs), 2)
+
+    def test_profile_callable(self):
+        """Test profiling functions with default or set names."""
+
+        def funca():
+            pass
+
+        with WorkflowProfiler() as wp:
+            funca = wp.profile_callable()(funca)
+
+            funca()
+
+            @wp.profile_callable("funcb")
+            def _func():
+                pass
+
+            _func()
+            _func()
+
+        results = wp.get_results()
+        self.assertSequenceEqual(set(results), {"funca", "funcb"})
+
+        self.assertEqual(len(results["funca"]), 1)
+        self.assertEqual(len(results["funcb"]), 2)
+
+    def test_profile_iteration(self):
+        """Test iterables are profiled correctly, producing the right output and number of results."""
+        with WorkflowProfiler() as wp:
+            range_vals = []
+
+            for i in wp.profile_iter("range5", range(5)):
+                range_vals.append(i)
+
+            self.assertSequenceEqual(range_vals, list(range(5)))
+
+        results = wp.get_results()
+        self.assertSequenceEqual(set(results), {"range5"})
+
+        self.assertEqual(len(results["range5"]), 5)
+
+    def test_times_summary(self):
+        """Test generating the summary report dictionary."""
+        with WorkflowProfiler() as wp:
+            self.scale(self.test_image)
+
+        tsum = wp.get_times_summary()
+
+        self.assertSequenceEqual(list(tsum), [self.scale_call_name])
+
+        times = tsum[self.scale_call_name]
+
+        self.assertEqual(len(times), 6)
+        self.assertEqual(times[0], 1)
+
+    @SkipIfNoModule("pandas")
+    def test_times_summary_pd(self):
+        """Test generating the Pandas result works if Pandas is present."""
+        with WorkflowProfiler() as wp:
+            self.scale(self.test_image)
+
+        df = wp.get_times_summary_pd()
+
+        self.assertIsInstance(df, pd.DataFrame)
+
+    def test_csv_dump(self):
+        """Test dumping the results to csv file in a local StringIO object."""
+        with WorkflowProfiler() as wp:
+            self.scale(self.test_image)
+
+        sio = StringIO()
+        wp.dump_csv(sio)
+        self.assertGreater(sio.tell(), 0)
+
+    @SkipIfNoModule("ignite")
+    def test_handler(self):
+        """Test profiling Engine objects works if Ignite is present."""
+        from ignite.engine import Events
+
+        from monai.engines import SupervisedTrainer
+
+        net = torch.nn.Conv2d(1, 1, 3, padding=1)
+        im = torch.rand(1, 1, 16, 16)
+
+        with WorkflowProfiler(None) as wp:
+            trainer = SupervisedTrainer(
+                device=torch.device("cpu"),
+                max_epochs=2,
+                train_data_loader=[{CommonKeys.IMAGE: im, CommonKeys.LABEL: im}] * 3,
+                epoch_length=3,
+                network=net,
+                optimizer=torch.optim.Adam(net.parameters()),
+                loss_function=torch.nn.L1Loss(),
+            )
+
+            _ = ProfileHandler("Epoch", wp, Events.EPOCH_STARTED, Events.EPOCH_COMPLETED).attach(trainer)
+
+            trainer.run()
+
+        results = wp.get_results()
+
+        self.assertSequenceEqual(set(results), {"Epoch"})
+        self.assertEqual(len(results["Epoch"]), 2)

tests/utils/test_rankfilter_dist.py

@@ -0,0 +1,77 @@
+# 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 logging
+import os
+import tempfile
+import unittest
+
+import torch.distributed as dist
+
+from monai.utils import RankFilter
+from tests.test_utils import DistCall, DistTestCase
+
+
+class DistributedRankFilterTest(DistTestCase):
+    def setUp(self):
+        self.log_dir = tempfile.TemporaryDirectory()
+
+    @DistCall(nnodes=1, nproc_per_node=2)
+    def test_rankfilter(self):
+        logger = logging.getLogger(__name__)
+        log_filename = os.path.join(self.log_dir.name, "records.log")
+        h1 = logging.FileHandler(filename=log_filename)
+        h1.setLevel(logging.WARNING)
+
+        logger.addHandler(h1)
+
+        logger.addFilter(RankFilter())
+        logger.warning("test_warnings")
+
+        dist.barrier()
+        if dist.get_rank() == 0:
+            with open(log_filename) as file:
+                lines = [line.rstrip() for line in file]
+            log_message = " ".join(lines)
+            self.assertEqual(log_message.count("test_warnings"), 1)
+
+    def tearDown(self) -> None:
+        self.log_dir.cleanup()
+
+
+class SingleRankFilterTest(unittest.TestCase):
+    def tearDown(self) -> None:
+        self.log_dir.cleanup()
+
+    def setUp(self):
+        self.log_dir = tempfile.TemporaryDirectory()
+
+    def test_rankfilter_single_proc(self):
+        logger = logging.getLogger(__name__)
+        log_filename = os.path.join(self.log_dir.name, "records_sp.log")
+        h1 = logging.FileHandler(filename=log_filename)
+        h1.setLevel(logging.WARNING)
+        logger.addHandler(h1)
+        logger.addFilter(RankFilter())
+        logger.warning("test_warnings")
+
+        with open(log_filename) as file:
+            lines = [line.rstrip() for line in file]
+        logger.removeHandler(h1)
+        h1.close()
+        log_message = " ".join(lines)
+        self.assertEqual(log_message.count("test_warnings"), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_require_pkg.py

@@ -0,0 +1,83 @@
+# 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 monai.utils import OptionalImportError, min_version, require_pkg
+
+
+class TestRequirePkg(unittest.TestCase):
+
+    def test_class(self):
+
+        @require_pkg(pkg_name="torch", version="1.4", version_checker=min_version)
+        class TestClass:
+            pass
+
+        TestClass()
+
+    def test_function(self):
+
+        @require_pkg(pkg_name="torch", version="1.4", version_checker=min_version)
+        def test_func(x):
+            return x
+
+        test_func(x=None)
+
+    def test_warning(self):
+
+        @require_pkg(pkg_name="test123", raise_error=False)
+        def test_func(x):
+            return x
+
+        test_func(x=None)
+
+    def test_class_exception(self):
+        with self.assertRaises(OptionalImportError):
+
+            @require_pkg(pkg_name="test123")
+            class TestClass:
+                pass
+
+            TestClass()
+
+    def test_class_version_exception(self):
+        with self.assertRaises(OptionalImportError):
+
+            @require_pkg(pkg_name="torch", version="10000", version_checker=min_version)
+            class TestClass:
+                pass
+
+            TestClass()
+
+    def test_func_exception(self):
+        with self.assertRaises(OptionalImportError):
+
+            @require_pkg(pkg_name="test123")
+            def test_func(x):
+                return x
+
+            test_func(x=None)
+
+    def test_func_versions_exception(self):
+        with self.assertRaises(OptionalImportError):
+
+            @require_pkg(pkg_name="torch", version="10000", version_checker=min_version)
+            def test_func(x):
+                return x
+
+            test_func(x=None)
+
+
+if __name__ == "__main__":
+    unittest.main()