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

tests/transforms/test_regularization.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 unittest
+
+import numpy as np
+import torch
+
+from monai.transforms import CutMix, CutMixd, CutOut, CutOutd, MixUp, MixUpd
+from tests.test_utils import assert_allclose
+
+
+class TestMixup(unittest.TestCase):
+    def test_mixup(self):
+        for dims in [2, 3]:
+            shape = (6, 3) + (32,) * dims
+            sample = torch.rand(*shape, dtype=torch.float32)
+            mixup = MixUp(6, 1.0)
+            mixup.set_random_state(seed=0)
+            output = mixup(sample)
+            np.random.seed(0)
+            # simulate the randomize() of transform
+            np.random.random()
+            weight = torch.from_numpy(np.random.beta(1.0, 1.0, 6)).type(torch.float32)
+            perm = np.random.permutation(6)
+            self.assertEqual(output.shape, sample.shape)
+            mixweight = weight[(Ellipsis,) + (None,) * (dims + 1)]
+            expected = mixweight * sample + (1 - mixweight) * sample[perm, ...]
+            assert_allclose(output, expected, type_test=False, atol=1e-7)
+
+        with self.assertRaises(ValueError):
+            MixUp(6, -0.5)
+
+        mixup = MixUp(6, 0.5)
+        for dims in [2, 3]:
+            with self.assertRaises(ValueError):
+                shape = (5, 3) + (32,) * dims
+                sample = torch.rand(*shape, dtype=torch.float32)
+                mixup(sample)
+
+    def test_mixupd(self):
+        for dims in [2, 3]:
+            shape = (6, 3) + (32,) * dims
+            t = torch.rand(*shape, dtype=torch.float32)
+            sample = {"a": t, "b": t}
+            mixup = MixUpd(["a", "b"], 6)
+            mixup.set_random_state(seed=0)
+            output = mixup(sample)
+            np.random.seed(0)
+            # simulate the randomize() of transform
+            np.random.random()
+            weight = torch.from_numpy(np.random.beta(1.0, 1.0, 6)).type(torch.float32)
+            perm = np.random.permutation(6)
+            self.assertEqual(output["a"].shape, sample["a"].shape)
+            mixweight = weight[(Ellipsis,) + (None,) * (dims + 1)]
+            expected = mixweight * sample["a"] + (1 - mixweight) * sample["a"][perm, ...]
+            assert_allclose(output["a"], expected, type_test=False, atol=1e-7)
+            assert_allclose(output["a"], output["b"], type_test=False, atol=1e-7)
+            # self.assertTrue(torch.allclose(output["a"], output["b"]))
+
+        with self.assertRaises(ValueError):
+            MixUpd(["k1", "k2"], 6, -0.5)
+
+
+class TestCutMix(unittest.TestCase):
+    def test_cutmix(self):
+        for dims in [2, 3]:
+            shape = (6, 3) + (32,) * dims
+            sample = torch.rand(*shape, dtype=torch.float32)
+            cutmix = CutMix(6, 1.0)
+            cutmix.set_random_state(seed=0)
+            output = cutmix(sample)
+            self.assertEqual(output.shape, sample.shape)
+            self.assertTrue(any(not torch.allclose(sample, cutmix(sample)) for _ in range(10)))
+
+    def test_cutmixd(self):
+        for dims in [2, 3]:
+            shape = (6, 3) + (32,) * dims
+            t = torch.rand(*shape, dtype=torch.float32)
+            label = torch.randint(0, 1, shape)
+            sample = {"a": t, "b": t, "lbl1": label, "lbl2": label}
+            cutmix = CutMixd(["a", "b"], 6, label_keys=("lbl1", "lbl2"))
+            cutmix.set_random_state(seed=123)
+            output = cutmix(sample)
+            # but mixing of labels is not affected by it
+            self.assertTrue(torch.allclose(output["lbl1"], output["lbl2"]))
+
+
+class TestCutOut(unittest.TestCase):
+    def test_cutout(self):
+        for dims in [2, 3]:
+            shape = (6, 3) + (32,) * dims
+            sample = torch.rand(*shape, dtype=torch.float32)
+            cutout = CutOut(6, 1.0)
+            cutout.set_random_state(seed=123)
+            output = cutout(sample)
+            np.random.seed(123)
+            # simulate the randomize() of transform
+            np.random.random()
+            weight = torch.from_numpy(np.random.beta(1.0, 1.0, 6)).type(torch.float32)
+            perm = np.random.permutation(6)
+            coords = [torch.from_numpy(np.random.randint(0, d, size=(1,))) for d in sample.shape[2:]]
+            assert_allclose(weight, cutout._params[0])
+            assert_allclose(perm, cutout._params[1])
+            self.assertSequenceEqual(coords, cutout._params[2])
+            self.assertEqual(output.shape, sample.shape)
+
+    def test_cutoutd(self):
+        for dims in [2, 3]:
+            shape = (6, 3) + (32,) * dims
+            t = torch.rand(*shape, dtype=torch.float32)
+            sample = {"a": t, "b": t}
+            cutout = CutOutd(["a", "b"], 6, 1.0)
+            cutout.set_random_state(seed=123)
+            output = cutout(sample)
+            np.random.seed(123)
+            # simulate the randomize() of transform
+            np.random.random()
+            weight = torch.from_numpy(np.random.beta(1.0, 1.0, 6)).type(torch.float32)
+            perm = np.random.permutation(6)
+            coords = [torch.from_numpy(np.random.randint(0, d, size=(1,))) for d in t.shape[2:]]
+            assert_allclose(weight, cutout.cutout._params[0])
+            assert_allclose(perm, cutout.cutout._params[1])
+            self.assertSequenceEqual(coords, cutout.cutout._params[2])
+            self.assertEqual(output["a"].shape, sample["a"].shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_remove_repeated_channel.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
+
+from parameterized import parameterized
+
+from monai.transforms import RemoveRepeatedChannel
+from tests.test_utils import TEST_NDARRAYS
+
+TEST_CASES = []
+for q in TEST_NDARRAYS:
+    TEST_CASES.append([{"repeats": 2}, q([[1, 2], [1, 2], [3, 4], [3, 4]]), (2, 2)])
+
+
+class TestRemoveRepeatedChannel(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_shape(self, input_param, input_data, expected_shape):
+        result = RemoveRepeatedChannel(**input_param)(input_data)
+        self.assertEqual(result.shape, expected_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_remove_repeated_channeld.py

@@ -0,0 +1,44 @@
+# 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
+from parameterized import parameterized
+
+from monai.transforms import RemoveRepeatedChanneld
+from tests.test_utils import TEST_NDARRAYS
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            {"keys": ["img"], "repeats": 2},
+            {
+                "img": p(np.array([[1, 2], [1, 2], [3, 4], [3, 4]])),
+                "seg": p(np.array([[1, 2], [1, 2], [3, 4], [3, 4]])),
+            },
+            (2, 2),
+        ]
+    )
+
+
+class TestRemoveRepeatedChanneld(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_shape(self, input_param, input_data, expected_shape):
+        result = RemoveRepeatedChanneld(**input_param)(input_data)
+        self.assertEqual(result["img"].shape, expected_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_repeat_channel.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
+
+from parameterized import parameterized
+
+from monai.transforms import RepeatChannel
+from tests.test_utils import TEST_NDARRAYS
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append([{"repeats": 3}, p([[[0, 1], [1, 2]]]), (3, 2, 2)])
+
+
+class TestRepeatChannel(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_shape(self, input_param, input_data, expected_shape):
+        result = RepeatChannel(**input_param)(input_data)
+        self.assertEqual(result.shape, expected_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_repeat_channeld.py

@@ -0,0 +1,41 @@
+# 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
+from parameterized import parameterized
+
+from monai.transforms import RepeatChanneld
+from tests.test_utils import TEST_NDARRAYS
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            {"keys": ["img"], "repeats": 3},
+            {"img": p(np.array([[[0, 1], [1, 2]]])), "seg": p(np.array([[[0, 1], [1, 2]]]))},
+            (3, 2, 2),
+        ]
+    )
+
+
+class TestRepeatChanneld(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_shape(self, input_param, input_data, expected_shape):
+        result = RepeatChanneld(**input_param)(input_data)
+        self.assertEqual(result["img"].shape, expected_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_resample_backends.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
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.config import USE_COMPILED
+from monai.data import MetaTensor
+from monai.transforms import Resample
+from monai.transforms.utils import create_grid
+from monai.utils import GridSampleMode, GridSamplePadMode, NdimageMode, SplineMode, convert_to_numpy
+from tests.test_utils import SkipIfBeforePyTorchVersion, assert_allclose, is_tf32_env
+
+_rtol = 1e-3 if is_tf32_env() else 1e-4
+
+TEST_IDENTITY = []
+for interp in GridSampleMode if not USE_COMPILED else ("nearest", "bilinear"):  # type: ignore
+    for pad in GridSamplePadMode:
+        for p in (np.float32, np.float64):
+            for device in [None, "cpu", "cuda"] if torch.cuda.is_available() else [None, "cpu"]:
+                TEST_IDENTITY.append([dict(device=device), p, interp, pad, (1, 3, 4)])
+                if interp != "bicubic":
+                    TEST_IDENTITY.append([dict(device=device), p, interp, pad, (1, 3, 5, 8)])
+for interp_s in SplineMode if not USE_COMPILED else []:  # type: ignore
+    for pad_s in NdimageMode:
+        for p_s in (int, float, np.float32, np.float64):
+            for device in [None, "cpu", "cuda"] if torch.cuda.is_available() else [None, "cpu"]:
+                TEST_IDENTITY.append([dict(device=device), p_s, interp_s, pad_s, (1, 20, 21)])
+                TEST_IDENTITY.append([dict(device=device), p_s, interp_s, pad_s, (1, 21, 23, 24)])
+
+
+@SkipIfBeforePyTorchVersion((1, 9, 1))
+class TestResampleBackends(unittest.TestCase):
+    @parameterized.expand(TEST_IDENTITY)
+    def test_resample_identity(self, input_param, im_type, interp, padding, input_shape):
+        """test resampling of an identity grid with padding 2, im_type, interp, padding, input_shape"""
+        xform = Resample(dtype=im_type, **input_param)
+        n_elem = np.prod(input_shape)
+        img = convert_to_numpy(np.arange(n_elem).reshape(input_shape), dtype=im_type)
+        grid = create_grid(input_shape[1:], homogeneous=True, backend="numpy")
+        grid_p = np.stack([np.pad(g, 2, "constant") for g in grid])  # testing pad
+        output = xform(img=img, grid=grid_p, mode=interp, padding_mode=padding)
+        self.assertTrue(not torch.any(torch.isinf(output) | torch.isnan(output)))
+        self.assertIsInstance(output, MetaTensor)
+        slices = [slice(None)]
+        slices.extend([slice(2, -2) for _ in img.shape[1:]])
+        output_c = output[slices]
+        assert_allclose(output_c, img, rtol=_rtol, atol=1e-3, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_resample_to_match.py

@@ -0,0 +1,110 @@
+# 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 os
+import random
+import shutil
+import string
+import tempfile
+import unittest
+
+import nibabel as nib
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.data import MetaTensor
+from monai.data.image_reader import ITKReader, NibabelReader
+from monai.data.image_writer import ITKWriter
+from monai.transforms import Compose, EnsureChannelFirstd, LoadImaged, ResampleToMatch, SaveImage, SaveImaged
+from monai.utils import optional_import
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import assert_allclose, download_url_or_skip_test, testing_data_config
+
+_, has_itk = optional_import("itk", allow_namespace_pkg=True)
+
+TEST_CASES = ["itkreader", "nibabelreader"]
+
+
+def get_rand_fname(len=10, suffix=".nii.gz"):
+    letters = string.ascii_letters
+    out = "".join(random.choice(letters) for _ in range(len))
+    out += suffix
+    return out
+
+
+@unittest.skipUnless(has_itk, "itk not installed")
+class TestResampleToMatch(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super(__class__, cls).setUpClass()
+        cls.fnames = []
+        cls.tmpdir = tempfile.mkdtemp()
+        for key in ("0000_t2_tse_tra_4", "0000_ep2d_diff_tra_7"):
+            fname = os.path.join(cls.tmpdir, f"test_{key}.nii.gz")
+            url = testing_data_config("images", key, "url")
+            hash_type = testing_data_config("images", key, "hash_type")
+            hash_val = testing_data_config("images", key, "hash_val")
+            download_url_or_skip_test(url=url, filepath=fname, hash_type=hash_type, hash_val=hash_val)
+            cls.fnames.append(fname)
+
+    @classmethod
+    def tearDownClass(cls):
+        shutil.rmtree(cls.tmpdir)
+        super(__class__, cls).tearDownClass()
+
+    @parameterized.expand(itertools.product([NibabelReader, ITKReader], ["monai.data.NibabelWriter", ITKWriter]))
+    def test_correct(self, reader, writer):
+        loader = Compose([LoadImaged(("im1", "im2"), reader=reader), EnsureChannelFirstd(("im1", "im2"))])
+        data = loader({"im1": self.fnames[0], "im2": self.fnames[1]})
+        tr = ResampleToMatch()
+        im_mod = tr(data["im2"], data["im1"])
+
+        # check lazy resample
+        call_param = {"img": data["im2"], "img_dst": data["im1"]}
+        test_resampler_lazy(tr, im_mod, init_param={}, call_param=call_param)
+
+        saver = SaveImaged(
+            "im3", output_dir=self.tmpdir, output_postfix="", separate_folder=False, writer=writer, resample=False
+        )
+        im_mod.meta["filename_or_obj"] = get_rand_fname()
+        saver({"im3": im_mod})
+
+        saved = nib.load(os.path.join(self.tmpdir, im_mod.meta["filename_or_obj"]))
+        assert_allclose(data["im1"].shape[1:], saved.shape)
+        assert_allclose(saved.header["dim"][:4], np.array([3, 384, 384, 19]))
+
+    def test_inverse(self):
+        loader = Compose([LoadImaged(("im1", "im2"), image_only=True), EnsureChannelFirstd(("im1", "im2"))])
+        data = loader({"im1": self.fnames[0], "im2": self.fnames[1]})
+        tr = ResampleToMatch()
+        im_mod = tr(data["im2"], data["im1"])
+        self.assertNotEqual(im_mod.shape, data["im2"].shape)
+        self.assertGreater(((im_mod.affine - data["im2"].affine) ** 2).sum() ** 0.5, 1e-2)
+        # inverse
+        im_mod2 = tr.inverse(im_mod)
+        self.assertEqual(im_mod2.shape, data["im2"].shape)
+        self.assertLess(((im_mod2.affine - data["im2"].affine) ** 2).sum() ** 0.5, 1e-2)
+        self.assertEqual(im_mod2.applied_operations, [])
+
+    def test_no_name(self):
+        img_1 = MetaTensor(torch.zeros(1, 2, 2, 2))
+        img_2 = MetaTensor(torch.zeros(1, 3, 3, 3))
+        im_mod = ResampleToMatch()(img_1, img_2)
+        self.assertEqual(im_mod.meta["filename_or_obj"], "resample_to_match_source")
+        SaveImage(output_dir=self.tmpdir, output_postfix="", separate_folder=False, resample=False)(im_mod)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_resample_to_matchd.py

@@ -0,0 +1,93 @@
+# 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 shutil
+import tempfile
+import unittest
+
+from monai.transforms import (
+    Compose,
+    CopyItemsd,
+    EnsureChannelFirstd,
+    Invertd,
+    Lambda,
+    LoadImaged,
+    ResampleToMatchd,
+    SaveImaged,
+)
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import assert_allclose, download_url_or_skip_test, testing_data_config
+
+
+def update_fname(d):
+    d["im3"].meta["filename_or_obj"] = "file3.nii.gz"
+    return d
+
+
+class TestResampleToMatchd(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super(__class__, cls).setUpClass()
+        cls.fnames = []
+        cls.tmpdir = tempfile.mkdtemp()
+        for key in ("0000_t2_tse_tra_4", "0000_ep2d_diff_tra_7"):
+            fname = os.path.join(cls.tmpdir, f"test_{key}.nii.gz")
+            url = testing_data_config("images", key, "url")
+            hash_type = testing_data_config("images", key, "hash_type")
+            hash_val = testing_data_config("images", key, "hash_val")
+            download_url_or_skip_test(url=url, filepath=fname, hash_type=hash_type, hash_val=hash_val)
+            cls.fnames.append(fname)
+
+    @classmethod
+    def tearDownClass(cls):
+        shutil.rmtree(cls.tmpdir)
+        super(__class__, cls).tearDownClass()
+
+    def test_correct(self):
+        transforms = Compose(
+            [
+                LoadImaged(("im1", "im2")),
+                EnsureChannelFirstd(("im1", "im2")),
+                CopyItemsd(("im2"), names=("im3")),
+                ResampleToMatchd("im3", "im1"),
+                Lambda(update_fname),
+                SaveImaged("im3", output_dir=self.tmpdir, output_postfix="", separate_folder=False, resample=False),
+            ]
+        )
+        data = transforms({"im1": self.fnames[0], "im2": self.fnames[1]})
+        # check that output sizes match
+        assert_allclose(data["im1"].shape, data["im3"].shape)
+        # and that the meta data has been updated accordingly
+        assert_allclose(data["im3"].affine, data["im1"].affine)
+        # check we're different from the original
+        self.assertTrue(any(i != j for i, j in zip(data["im3"].shape, data["im2"].shape)))
+        self.assertTrue(any(i != j for i, j in zip(data["im3"].affine.flatten(), data["im2"].affine.flatten())))
+        # test the inverse
+        data = Invertd("im3", transforms)(data)
+        assert_allclose(data["im2"].shape, data["im3"].shape)
+
+    def test_lazy(self):
+        pre_transforms = Compose(
+            [LoadImaged(("im1", "im2")), EnsureChannelFirstd(("im1", "im2")), CopyItemsd(("im2"), names=("im3"))]
+        )
+        data = pre_transforms({"im1": self.fnames[0], "im2": self.fnames[1]})
+        init_param = {"keys": "im3", "key_dst": "im1"}
+        resampler = ResampleToMatchd(**init_param)
+        call_param = {"data": data}
+        non_lazy_out = resampler(**call_param)
+        test_resampler_lazy(resampler, non_lazy_out, init_param, call_param, output_key="im3")
+
+
+if __name__ == "__main__":
+    unittest.main()