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

tests/transforms/test_rand_spatial_cropd.py

@@ -0,0 +1,112 @@
+# 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.data.meta_tensor import MetaTensor
+from monai.transforms import RandScaleCropd, RandSpatialCropd
+from monai.transforms.lazy.functional import apply_pending
+from tests.croppers import CropTest
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose
+
+TEST_SHAPES = [
+    [{"keys": "img", "roi_size": [3, 3, -1], "random_center": True}, (3, 3, 3, 5), (3, 3, 3, 5)],
+    [{"keys": "img", "roi_size": [3, 3, 3], "random_center": True}, (3, 3, 3, 3), (3, 3, 3, 3)],
+    [{"keys": "img", "roi_size": [3, 3, 3], "random_center": False}, (3, 3, 3, 3), (3, 3, 3, 3)],
+    [{"keys": "img", "roi_size": [3, 2, 3], "random_center": False, "random_size": False}, (3, 3, 3, 3), (3, 3, 2, 3)],
+]
+
+TEST_VALUES = [
+    [
+        {"keys": "img", "roi_size": [3, 3], "random_center": False},
+        np.array([[[0, 0, 0, 0, 0], [0, 1, 2, 1, 0], [0, 2, 3, 2, 0], [0, 1, 2, 1, 0], [0, 0, 0, 0, 0]]]),
+    ]
+]
+
+TEST_RANDOM_SHAPES = [
+    [
+        {"keys": "img", "roi_size": [3, 3, 3], "max_roi_size": [5, -1, 4], "random_center": True, "random_size": True},
+        (1, 4, 5, 6),
+        (1, 4, 4, 3),
+    ],
+    [
+        {"keys": "img", "roi_size": 3, "max_roi_size": 4, "random_center": True, "random_size": True},
+        (1, 4, 5, 6),
+        (1, 3, 4, 3),
+    ],
+]
+
+func1 = {RandSpatialCropd: {"keys": "img", "roi_size": [8, 7, -1], "random_center": True, "random_size": False}}
+func2 = {RandScaleCropd: {"keys": "img", "roi_scale": [0.5, 0.6, -1.0], "random_center": True, "random_size": True}}
+func3 = {RandScaleCropd: {"keys": "img", "roi_scale": [1.0, 0.5, -1.0], "random_center": False, "random_size": False}}
+
+TESTS_COMBINE = []
+TESTS_COMBINE.append([[func1, func2, func3], (3, 10, 10, 8)])
+TESTS_COMBINE.append([[func1, func2], (3, 8, 8, 4)])
+TESTS_COMBINE.append([[func2, func2], (3, 8, 8, 4)])
+
+
+class TestRandSpatialCropd(CropTest):
+    Cropper = RandSpatialCropd
+
+    @parameterized.expand(TEST_SHAPES)
+    def test_shape(self, input_param, input_shape, expected_shape):
+        self.crop_test(input_param, input_shape, expected_shape)
+
+    @parameterized.expand(TEST_VALUES)
+    def test_value(self, input_param, input_im):
+        for im_type in TEST_NDARRAYS_ALL:
+            with self.subTest(im_type=im_type):
+                cropper = self.Cropper(**input_param)
+                input_data = {"img": im_type(input_im)}
+                result = cropper(input_data)["img"]
+                roi = [(2 - i // 2, 2 + i - i // 2) for i in cropper.cropper._size]
+                assert_allclose(result, input_im[:, roi[0][0] : roi[0][1], roi[1][0] : roi[1][1]], type_test="tensor")
+
+    @parameterized.expand(TEST_RANDOM_SHAPES)
+    def test_random_shape(self, input_param, input_shape, expected_shape):
+        for im_type in TEST_NDARRAYS_ALL:
+            with self.subTest(im_type=im_type):
+                cropper = self.Cropper(**input_param)
+                cropper.set_random_state(seed=123)
+                input_data = {"img": im_type(np.random.randint(0, 2, input_shape))}
+                expected = cropper(input_data)["img"]
+                self.assertTupleEqual(expected.shape, expected_shape)
+
+                # lazy
+                # reset random seed to ensure the same results
+                cropper.set_random_state(seed=123)
+                cropper.lazy = True
+                pending_result = cropper(input_data)["img"]
+                self.assertIsInstance(pending_result, MetaTensor)
+                assert_allclose(pending_result.peek_pending_affine(), expected.affine)
+                assert_allclose(pending_result.peek_pending_shape(), expected.shape[1:])
+                # only support nearest
+                result = apply_pending(pending_result, overrides={"mode": "nearest", "align_corners": False})[0]
+                # compare
+                assert_allclose(result, expected, rtol=1e-5)
+
+    @parameterized.expand(TEST_SHAPES)
+    def test_pending_ops(self, input_param, input_shape, _):
+        self.crop_test_pending_ops(input_param, input_shape)
+
+    @parameterized.expand(TESTS_COMBINE)
+    def test_combine_ops(self, funcs, input_shape):
+        self.crop_test_combine_ops(funcs, input_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_std_shift_intensity.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 numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.transforms import RandStdShiftIntensity
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestRandStdShiftIntensity(NumpyImageTestCase2D):
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_value(self, p):
+        np.random.seed(0)
+        # simulate the randomize() of transform
+        np.random.random()
+        factor = np.random.uniform(low=-1.0, high=1.0)
+        offset = factor * np.std(self.imt)
+        expected = p(self.imt + offset)
+        shifter = RandStdShiftIntensity(factors=1.0, prob=1.0)
+        shifter.set_random_state(seed=0)
+        _imt = p(self.imt)
+        result = shifter(_imt)
+        if isinstance(_imt, torch.Tensor):
+            self.assertEqual(result.dtype, _imt.dtype)
+        assert_allclose(result, expected, atol=0, rtol=1e-5, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_std_shift_intensityd.py

@@ -0,0 +1,38 @@
+# 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 monai.transforms import RandStdShiftIntensityd
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestRandStdShiftIntensityd(NumpyImageTestCase2D):
+    def test_value(self):
+        for p in TEST_NDARRAYS:
+            key = "img"
+            np.random.seed(0)
+            # simulate the randomize() of transform
+            np.random.random()
+            factor = np.random.uniform(low=-1.0, high=1.0)
+            expected = self.imt + factor * np.std(self.imt)
+            shifter = RandStdShiftIntensityd(keys=[key], factors=1.0, prob=1.0)
+            shifter.set_random_state(seed=0)
+            result = shifter({key: p(self.imt)})[key]
+            assert_allclose(result, expected, rtol=1e-5, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_zoom.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 numpy as np
+import torch
+from parameterized import parameterized
+from scipy.ndimage import zoom as zoom_scipy
+
+from monai.config import USE_COMPILED
+from monai.transforms import RandZoom
+from monai.utils import InterpolateMode
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import TEST_NDARRAYS_ALL, NumpyImageTestCase2D, assert_allclose, test_local_inversion
+
+VALID_CASES = [
+    (0.8, 1.2, "nearest", False),
+    (0.8, 1.2, InterpolateMode.NEAREST, False),
+    (0.8, 1.2, InterpolateMode.BILINEAR, False, True),
+    (0.8, 1.2, InterpolateMode.BILINEAR, False, False),
+]
+
+
+class TestRandZoom(NumpyImageTestCase2D):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_results(self, min_zoom, max_zoom, mode, keep_size, align_corners=None):
+        for p in TEST_NDARRAYS_ALL:
+            init_param = {
+                "prob": 1.0,
+                "min_zoom": min_zoom,
+                "max_zoom": max_zoom,
+                "mode": mode,
+                "keep_size": keep_size,
+                "dtype": torch.float64,
+                "align_corners": align_corners,
+            }
+            random_zoom = RandZoom(**init_param)
+            random_zoom.set_random_state(1234)
+            im = p(self.imt[0])
+            call_param = {"img": im}
+            zoomed = random_zoom(**call_param)
+
+            # test lazy
+            # TODO: temporarily skip "nearest" test
+            if mode == InterpolateMode.BILINEAR:
+                test_resampler_lazy(
+                    random_zoom, zoomed, init_param, call_param, seed=1234, atol=1e-4 if USE_COMPILED else 1e-6
+                )
+
+            test_local_inversion(random_zoom, zoomed, im)
+            expected = [
+                zoom_scipy(channel, zoom=random_zoom._zoom, mode="nearest", order=0, prefilter=False)
+                for channel in self.imt[0]
+            ]
+
+            expected = np.stack(expected).astype(np.float32)
+            assert_allclose(zoomed, p(expected), atol=1.0, type_test=False)
+
+    def test_keep_size(self):
+        for p in TEST_NDARRAYS_ALL:
+            im = p(self.imt[0])
+            random_zoom = RandZoom(prob=1.0, min_zoom=0.6, max_zoom=0.7, keep_size=True)
+            random_zoom.set_random_state(12)
+            zoomed = random_zoom(im)
+            test_local_inversion(random_zoom, zoomed, im)
+            self.assertTrue(np.array_equal(zoomed.shape, self.imt.shape[1:]))
+            zoomed = random_zoom(im)
+            self.assertTrue(np.array_equal(zoomed.shape, self.imt.shape[1:]))
+            zoomed = random_zoom(im)
+            self.assertTrue(np.array_equal(zoomed.shape, self.imt.shape[1:]))
+            random_zoom.prob = 0.0
+            self.assertEqual(random_zoom(im).dtype, torch.float32)
+
+    @parameterized.expand(
+        [("no_min_zoom", None, 1.1, "bilinear", TypeError), ("invalid_mode", 0.9, 1.1, "s", ValueError)]
+    )
+    def test_invalid_inputs(self, _, min_zoom, max_zoom, mode, raises):
+        for p in TEST_NDARRAYS_ALL:
+            with self.assertRaises(raises):
+                random_zoom = RandZoom(prob=1.0, min_zoom=min_zoom, max_zoom=max_zoom, mode=mode)
+                random_zoom(p(self.imt[0]))
+
+    def test_auto_expand_3d(self):
+        for p in TEST_NDARRAYS_ALL:
+            random_zoom = RandZoom(prob=1.0, min_zoom=[0.8, 0.7], max_zoom=[1.2, 1.3], mode="nearest", keep_size=False)
+            random_zoom.set_random_state(1234)
+            test_data = p(np.random.randint(0, 2, size=[2, 2, 3, 4]))
+            zoomed = random_zoom(test_data)
+            assert_allclose(random_zoom._zoom, (1.048844, 1.048844, 0.962637), atol=1e-2, type_test=False)
+            assert_allclose(zoomed.shape, (2, 2, 3, 3), type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_zoomd.py

@@ -0,0 +1,108 @@
+# 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 scipy.ndimage import zoom as zoom_scipy
+
+from monai.config import USE_COMPILED
+from monai.transforms import RandZoomd
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import TEST_NDARRAYS_ALL, NumpyImageTestCase2D, assert_allclose, test_local_inversion
+
+VALID_CASES = [
+    (0.8, 1.2, "nearest", None, False),
+    (0.8, 1.2, "bilinear", None, False),
+    (0.8, 1.2, "bilinear", False, False),
+]
+
+
+class TestRandZoomd(NumpyImageTestCase2D):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_results(self, min_zoom, max_zoom, mode, align_corners, keep_size):
+        key = "img"
+        init_param = {
+            "keys": key,
+            "prob": 1.0,
+            "min_zoom": min_zoom,
+            "max_zoom": max_zoom,
+            "mode": mode,
+            "align_corners": align_corners,
+            "keep_size": keep_size,
+            "dtype": torch.float64,
+        }
+        random_zoom = RandZoomd(**init_param)
+        for p in TEST_NDARRAYS_ALL:
+            random_zoom.set_random_state(1234)
+
+            im = p(self.imt[0])
+            call_param = {"data": {key: im}}
+            zoomed = random_zoom(**call_param)
+
+            # test lazy
+            # TODO: temporarily skip "nearest" test
+            if mode == "bilinear":
+                test_resampler_lazy(
+                    random_zoom, zoomed, init_param, call_param, key, seed=1234, atol=1e-4 if USE_COMPILED else 1e-6
+                )
+                random_zoom.lazy = False
+
+            test_local_inversion(random_zoom, zoomed, {key: im}, key)
+            expected = [
+                zoom_scipy(channel, zoom=random_zoom.rand_zoom._zoom, mode="nearest", order=0, prefilter=False)
+                for channel in self.imt[0]
+            ]
+
+            expected = np.stack(expected).astype(np.float32)
+            assert_allclose(zoomed[key], p(expected), atol=1.0, type_test=False)
+
+    def test_keep_size(self):
+        key = "img"
+        random_zoom = RandZoomd(
+            keys=key, prob=1.0, min_zoom=0.6, max_zoom=0.7, keep_size=True, padding_mode="constant", constant_values=2
+        )
+        for p in TEST_NDARRAYS_ALL:
+            im = p(self.imt[0])
+            zoomed = random_zoom({key: im})
+            test_local_inversion(random_zoom, zoomed, {key: im}, key)
+            np.testing.assert_array_equal(zoomed[key].shape, self.imt.shape[1:])
+        random_zoom.prob = 0.0
+        self.assertEqual(random_zoom({key: p(self.imt[0])})[key].dtype, torch.float32)
+
+    @parameterized.expand(
+        [("no_min_zoom", None, 1.1, "bilinear", TypeError), ("invalid_order", 0.9, 1.1, "s", ValueError)]
+    )
+    def test_invalid_inputs(self, _, min_zoom, max_zoom, mode, raises):
+        key = "img"
+        for p in TEST_NDARRAYS_ALL:
+            with self.assertRaises(raises):
+                random_zoom = RandZoomd(key, prob=1.0, min_zoom=min_zoom, max_zoom=max_zoom, mode=mode)
+                random_zoom({key: p(self.imt[0])})
+
+    def test_auto_expand_3d(self):
+        random_zoom = RandZoomd(
+            keys="img", prob=1.0, min_zoom=[0.8, 0.7], max_zoom=[1.2, 1.3], mode="nearest", keep_size=False
+        )
+        for p in TEST_NDARRAYS_ALL:
+            random_zoom.set_random_state(1234)
+            test_data = {"img": p(np.random.randint(0, 2, size=[2, 2, 3, 4]))}
+            zoomed = random_zoom(test_data)
+            assert_allclose(random_zoom.rand_zoom._zoom, (1.048844, 1.048844, 0.962637), atol=1e-2)
+            assert_allclose(zoomed["img"].shape, (2, 2, 3, 3))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_randidentity.py

@@ -0,0 +1,49 @@
+# 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 monai.transforms as mt
+from monai.data import CacheDataset
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class T(mt.Transform):
+    def __call__(self, x):
+        return x * 2
+
+
+class TestIdentity(NumpyImageTestCase2D):
+    def test_identity(self):
+        for p in TEST_NDARRAYS:
+            img = p(self.imt)
+            identity = mt.RandIdentity()
+            assert_allclose(img, identity(img))
+
+    def test_caching(self, init=1, expect=4, expect_pre_cache=2):
+        # check that we get the correct result (two lots of T so should get 4)
+        x = init
+        transforms = mt.Compose([T(), mt.RandIdentity(), T()])
+        self.assertEqual(transforms(x), expect)
+
+        # check we get correct result with CacheDataset
+        x = [init]
+        ds = CacheDataset(x, transforms)
+        self.assertEqual(ds[0], expect)
+
+        # check that the cached value is correct
+        self.assertEqual(ds._cache[0], expect_pre_cache)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_random_order.py

@@ -0,0 +1,144 @@
+# 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 copy import deepcopy
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+import monai.transforms.intensity.array as ia
+import monai.transforms.spatial.array as sa
+import monai.transforms.spatial.dictionary as sd
+from monai.data import MetaTensor
+from monai.transforms import RandomOrder
+from monai.transforms.compose import Compose
+from monai.utils import set_determinism
+from monai.utils.enums import TraceKeys
+from tests.integration.test_one_of import A, B, C, Inv, NonInv, X, Y
+
+
+class InvC(Inv):
+    def __init__(self, keys):
+        super().__init__(keys)
+        self.fwd_fn = lambda x: x + 1
+        self.inv_fn = lambda x: x - 1
+
+
+class InvD(Inv):
+    def __init__(self, keys):
+        super().__init__(keys)
+        self.fwd_fn = lambda x: x * 100
+        self.inv_fn = lambda x: x / 100
+
+
+set_determinism(seed=123)
+KEYS = ["x", "y"]
+TEST_INVERSES = [
+    (RandomOrder((InvC(KEYS), InvD(KEYS))), True, True),
+    (Compose((RandomOrder((InvC(KEYS), InvD(KEYS))), RandomOrder((InvD(KEYS), InvC(KEYS))))), True, False),
+    (RandomOrder((RandomOrder((InvC(KEYS), InvD(KEYS))), RandomOrder((InvD(KEYS), InvC(KEYS))))), True, False),
+    (RandomOrder((Compose((InvC(KEYS), InvD(KEYS))), Compose((InvD(KEYS), InvC(KEYS))))), True, False),
+    (RandomOrder((NonInv(KEYS), NonInv(KEYS))), False, False),
+]
+
+
+class TestRandomOrder(unittest.TestCase):
+    def test_empty_compose(self):
+        c = RandomOrder()
+        i = 1
+        self.assertEqual(c(i), 1)
+
+    def test_compose_flatten_does_not_affect_random_order(self):
+        p = Compose([A(), B(), RandomOrder([C(), Inv(KEYS), Compose([X(), Y()])])])
+        f = p.flatten()
+
+        # in this case the flattened transform should be the same.
+        def _match(a, b):
+            self.assertEqual(type(a), type(b))
+            for a_, b_ in zip(a.transforms, b.transforms):
+                self.assertEqual(type(a_), type(b_))
+                if isinstance(a_, (Compose, RandomOrder)):
+                    _match(a_, b_)
+
+        _match(p, f)
+
+    @parameterized.expand(TEST_INVERSES)
+    def test_inverse(self, transform, invertible, use_metatensor):
+        data = {k: MetaTensor((i + 1) * 10.0) for i, k in enumerate(KEYS)}
+        fwd_data1 = transform(data)
+        # test call twice won't affect inverse
+        fwd_data2 = transform(data)
+
+        if invertible:
+            for k in KEYS:
+                t = fwd_data1[k].applied_operations[-1]
+                # make sure the RandomOrder applied_order was stored
+                self.assertEqual(t[TraceKeys.CLASS_NAME], RandomOrder.__name__)
+
+        # call the inverse
+        fwd_inv_data1 = transform.inverse(fwd_data1)
+        fwd_inv_data2 = transform.inverse(fwd_data2)
+
+        fwd_data = [fwd_data1, fwd_data2]
+        fwd_inv_data = [fwd_inv_data1, fwd_inv_data2]
+        for i, _fwd_inv_data in enumerate(fwd_inv_data):
+            if invertible:
+                for k in KEYS:
+                    # check data is same as original (and different from forward)
+                    self.assertEqual(_fwd_inv_data[k], data[k])
+                    self.assertNotEqual(_fwd_inv_data[k], fwd_data[i][k])
+            else:
+                # if not invertible, should not change the data
+                self.assertDictEqual(fwd_data[i], _fwd_inv_data)
+
+
+TEST_RANDOM_ORDER_EXTENDED_TEST_CASES = [
+    [None, tuple()],
+    [None, (sa.Rotate(np.pi / 8),)],
+    [None, (sa.Flip(0), sa.Flip(1), sa.Rotate90(1), sa.Zoom(0.8), ia.NormalizeIntensity())],
+    [("a",), (sd.Rotated(("a",), np.pi / 8),)],
+]
+
+
+class TestRandomOrderAPITests(unittest.TestCase):
+    @staticmethod
+    def data_from_keys(keys):
+        if keys is None:
+            data = torch.unsqueeze(torch.tensor(np.arange(12 * 16).reshape(12, 16)), dim=0)
+        else:
+            data = {}
+            for i_k, k in enumerate(keys):
+                data[k] = torch.unsqueeze(torch.tensor(np.arange(12 * 16)).reshape(12, 16) + i_k * 192, dim=0)
+        return data
+
+    @parameterized.expand(TEST_RANDOM_ORDER_EXTENDED_TEST_CASES)
+    def test_execute_change_start_end(self, keys, pipeline):
+        data = self.data_from_keys(keys)
+
+        c = RandomOrder(deepcopy(pipeline))
+        with self.assertRaises(ValueError):
+            c(data, start=1)
+        with self.assertRaises(ValueError):
+            c(data, start=1)
+
+        c = RandomOrder(deepcopy(pipeline))
+        with self.assertRaises(ValueError):
+            c(data, end=1)
+        with self.assertRaises(ValueError):
+            c(data, end=1)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_randtorchvisiond.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 torch
+from parameterized import parameterized
+
+from monai.transforms import RandomizableTrait, RandTorchVisiond
+from monai.utils import set_determinism
+from tests.test_utils import assert_allclose
+
+TEST_CASE_1 = [
+    {"keys": "img", "name": "ColorJitter"},
+    {"img": torch.tensor([[[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]]])},
+    torch.tensor([[[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]]]),
+]
+
+TEST_CASE_2 = [
+    {"keys": "img", "name": "ColorJitter", "brightness": 0.5, "contrast": 0.5, "saturation": [0.1, 0.8], "hue": 0.5},
+    {"img": torch.tensor([[[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]]])},
+    torch.tensor(
+        [
+            [[0.1090, 0.6193], [0.6193, 0.9164]],
+            [[0.1090, 0.6193], [0.6193, 0.9164]],
+            [[0.1090, 0.6193], [0.6193, 0.9164]],
+        ]
+    ),
+]
+
+TEST_CASE_3 = [
+    {"keys": "img", "name": "Pad", "padding": [1, 1, 1, 1]},
+    {"img": torch.tensor([[[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]]])},
+    torch.tensor(
+        [
+            [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 1.0, 2.0, 0.0], [0.0, 0.0, 0.0, 0.0]],
+            [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 1.0, 2.0, 0.0], [0.0, 0.0, 0.0, 0.0]],
+            [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 1.0, 2.0, 0.0], [0.0, 0.0, 0.0, 0.0]],
+        ]
+    ),
+]
+
+
+class TestRandTorchVisiond(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+    def test_value(self, input_param, input_data, expected_value):
+        set_determinism(seed=0)
+        transform = RandTorchVisiond(**input_param)
+        result = transform(input_data)
+        self.assertTrue(isinstance(transform, RandomizableTrait))
+        assert_allclose(result["img"], expected_value, atol=1e-4, rtol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()