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

tests/transforms/test_to_device.py

@@ -0,0 +1,42 @@
+# 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 ToDevice
+from tests.test_utils import assert_allclose, skip_if_no_cuda
+
+TEST_CASE_1 = ["cuda:0"]
+
+TEST_CASE_2 = ["cuda"]
+
+TEST_CASE_3 = [torch.device("cpu:0")]
+
+TEST_CASE_4 = ["cpu"]
+
+
+@skip_if_no_cuda
+class TestToDevice(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4])
+    def test_value(self, device):
+        converter = ToDevice(device=device, non_blocking=True)
+        data = torch.tensor([1, 2, 3, 4])
+        ret = converter(data)
+        assert_allclose(ret, data.to(device))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_to_deviced.py

@@ -0,0 +1,37 @@
+# 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.data import CacheDataset, ThreadDataLoader
+from monai.transforms import ToDeviced
+from tests.test_utils import assert_allclose, skip_if_no_cuda
+
+
+@skip_if_no_cuda
+class TestToDeviced(unittest.TestCase):
+    def test_value(self):
+        device = "cuda:0"
+        data = [{"img": torch.tensor(i)} for i in range(4)]
+        dataset = CacheDataset(
+            data=data, transform=ToDeviced(keys="img", device=device, non_blocking=True), cache_rate=1.0
+        )
+        dataloader = ThreadDataLoader(dataset=dataset, num_workers=0, batch_size=1)
+        for i, d in enumerate(dataloader):
+            assert_allclose(d["img"], torch.tensor([i], device=device))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_to_numpy.py

@@ -0,0 +1,85 @@
+# 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 unittest import skipUnless
+
+import numpy as np
+import torch
+
+from monai.transforms import ToNumpy
+from monai.utils import optional_import
+from tests.test_utils import HAS_CUPY, assert_allclose, skip_if_no_cuda
+
+cp, _ = optional_import("cupy")
+
+
+class TestToNumpy(unittest.TestCase):
+    @skipUnless(HAS_CUPY, "CuPy is required.")
+    def test_cupy_input(self):
+        test_data = cp.array([[1, 2], [3, 4]])
+        test_data = cp.rot90(test_data)
+        self.assertFalse(test_data.flags["C_CONTIGUOUS"])
+        result = ToNumpy()(test_data)
+        self.assertIsInstance(result, np.ndarray)
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        assert_allclose(result, test_data.get(), type_test=False)
+
+    def test_numpy_input(self):
+        test_data = np.array([[1, 2], [3, 4]])
+        test_data = np.rot90(test_data)
+        self.assertFalse(test_data.flags["C_CONTIGUOUS"])
+        result = ToNumpy(dtype="float32")(test_data)
+        self.assertIsInstance(result, np.ndarray)
+        self.assertEqual(result.dtype, np.float32)
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        assert_allclose(result, test_data, type_test=False)
+
+    def test_tensor_input(self):
+        test_data = torch.tensor([[1, 2], [3, 4]])
+        test_data = test_data.rot90()
+        self.assertFalse(test_data.is_contiguous())
+        result = ToNumpy(dtype=torch.uint8)(test_data)
+        self.assertIsInstance(result, np.ndarray)
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        assert_allclose(result, test_data, type_test=False)
+
+    @skip_if_no_cuda
+    def test_tensor_cuda_input(self):
+        test_data = torch.tensor([[1, 2], [3, 4]]).cuda()
+        test_data = test_data.rot90()
+        self.assertFalse(test_data.is_contiguous())
+        result = ToNumpy()(test_data)
+        self.assertIsInstance(result, np.ndarray)
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        assert_allclose(result, test_data, type_test=False)
+
+    def test_list_tuple(self):
+        test_data = [[1, 2], [3, 4]]
+        result = ToNumpy()(test_data)
+        assert_allclose(result, np.asarray(test_data), type_test=False)
+        test_data = ((1, 2), (3, 4))
+        result = ToNumpy(wrap_sequence=False)(test_data)
+        self.assertIsInstance(result, tuple)
+        assert_allclose(result, ((np.asarray(1), np.asarray(2)), (np.asarray(3), np.asarray(4))))
+
+    def test_single_value(self):
+        for test_data in [5, np.array(5), torch.tensor(5)]:
+            result = ToNumpy(dtype=np.uint8)(test_data)
+            self.assertIsInstance(result, np.ndarray)
+            assert_allclose(result, np.asarray(test_data), type_test=False)
+            self.assertEqual(result.ndim, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_to_numpyd.py

@@ -0,0 +1,68 @@
+# 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 unittest import skipUnless
+
+import numpy as np
+import torch
+
+from monai.transforms import ToNumpyd
+from monai.utils import optional_import
+from tests.test_utils import HAS_CUPY, assert_allclose, skip_if_no_cuda
+
+cp, _ = optional_import("cupy")
+
+
+class TestToNumpyd(unittest.TestCase):
+    @skipUnless(HAS_CUPY, "CuPy is required.")
+    def test_cupy_input(self):
+        test_data = cp.array([[1, 2], [3, 4]])
+        test_data = cp.rot90(test_data)
+        self.assertFalse(test_data.flags["C_CONTIGUOUS"])
+        result = ToNumpyd(keys="img")({"img": test_data})["img"]
+        self.assertTrue(isinstance(result, np.ndarray))
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        assert_allclose(result, test_data.get(), type_test=False)
+
+    def test_numpy_input(self):
+        test_data = np.array([[1, 2], [3, 4]])
+        test_data = np.rot90(test_data)
+        self.assertFalse(test_data.flags["C_CONTIGUOUS"])
+        result = ToNumpyd(keys="img")({"img": test_data})["img"]
+        self.assertTrue(isinstance(result, np.ndarray))
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        assert_allclose(result, test_data, type_test=False)
+
+    def test_tensor_input(self):
+        test_data = torch.tensor([[1, 2], [3, 4]])
+        test_data = test_data.rot90()
+        self.assertFalse(test_data.is_contiguous())
+        result = ToNumpyd(keys="img")({"img": test_data})["img"]
+        self.assertTrue(isinstance(result, np.ndarray))
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        assert_allclose(result, test_data, type_test=False)
+
+    @skip_if_no_cuda
+    def test_tensor_cuda_input(self):
+        test_data = torch.tensor([[1, 2], [3, 4]]).cuda()
+        test_data = test_data.rot90()
+        self.assertFalse(test_data.is_contiguous())
+        result = ToNumpyd(keys="img")({"img": test_data})["img"]
+        self.assertTrue(isinstance(result, np.ndarray))
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        assert_allclose(result, test_data, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_to_pil.py

@@ -0,0 +1,52 @@
+# 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 typing import TYPE_CHECKING
+from unittest import skipUnless
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import ToPIL
+from monai.utils import optional_import
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+if TYPE_CHECKING:
+    from PIL.Image import Image as PILImageImage
+    from PIL.Image import fromarray as pil_image_fromarray
+
+    has_pil = True
+else:
+    pil_image_fromarray, has_pil = optional_import("PIL.Image", name="fromarray")
+    PILImageImage, _ = optional_import("PIL.Image", name="Image")
+
+im = [[1.0, 2.0], [3.0, 4.0]]
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append([p(im)])
+if has_pil:
+    TESTS.append([pil_image_fromarray(np.array(im))])
+
+
+class TestToPIL(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    @skipUnless(has_pil, "Requires `pillow` package.")
+    def test_value(self, test_data):
+        result = ToPIL()(test_data)
+        self.assertTrue(isinstance(result, PILImageImage))
+        assert_allclose(np.array(result), test_data, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_to_pild.py

@@ -0,0 +1,50 @@
+# 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 typing import TYPE_CHECKING
+from unittest import skipUnless
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import ToPILd
+from monai.utils import optional_import
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+if TYPE_CHECKING:
+    from PIL.Image import Image as PILImageImage
+    from PIL.Image import fromarray as pil_image_fromarray
+
+    has_pil = True
+else:
+    pil_image_fromarray, has_pil = optional_import("PIL.Image", name="fromarray")
+    PILImageImage, _ = optional_import("PIL.Image", name="Image")
+
+im = [[1.0, 2.0], [3.0, 4.0]]
+TESTS = [[{"keys": "image"}, {"image": p(im)}] for p in TEST_NDARRAYS]
+if has_pil:
+    TESTS.append([{"keys": "image"}, {"image": pil_image_fromarray(np.array(im))}])
+
+
+class TestToPIL(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    @skipUnless(has_pil, "Requires `pillow` package.")
+    def test_values(self, input_param, test_data):
+        result = ToPILd(**input_param)(test_data)[input_param["keys"]]
+        self.assertTrue(isinstance(result, PILImageImage))
+        assert_allclose(np.array(result), test_data[input_param["keys"]], type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_to_tensor.py

@@ -0,0 +1,60 @@
+# 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 ToTensor
+from tests.test_utils import HAS_CUPY, TEST_NDARRAYS, assert_allclose, optional_import
+
+cp, _ = optional_import("cupy")
+
+im = [[1, 2], [3, 4]]
+
+TESTS = [(im, (2, 2))]
+for p in TEST_NDARRAYS:
+    TESTS.append((p(im), (2, 2)))
+
+TESTS_SINGLE = [[5]]
+for p in TEST_NDARRAYS:
+    TESTS_SINGLE.append([p(5)])
+
+
+class TestToTensor(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_array_input(self, test_data, expected_shape):
+        result = ToTensor(dtype=torch.float32, device="cpu", wrap_sequence=True)(test_data)
+        self.assertTrue(isinstance(result, torch.Tensor))
+        assert_allclose(result, test_data, type_test=False)
+        self.assertTupleEqual(result.shape, expected_shape)
+
+    @parameterized.expand(TESTS_SINGLE)
+    def test_single_input(self, test_data):
+        result = ToTensor(track_meta=True)(test_data)
+        self.assertTrue(isinstance(result, torch.Tensor))
+        assert_allclose(result, test_data, type_test=False)
+        self.assertEqual(result.ndim, 0)
+
+    @unittest.skipUnless(HAS_CUPY, "CuPy is required.")
+    def test_cupy(self):
+        test_data = [[1, 2], [3, 4]]
+        cupy_array = cp.ascontiguousarray(cp.asarray(test_data))
+        result = ToTensor()(cupy_array)
+        self.assertTrue(isinstance(result, torch.Tensor))
+        assert_allclose(result, test_data, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_to_tensord.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.transforms import ToTensord
+from tests.test_utils import HAS_CUPY, TEST_NDARRAYS, assert_allclose, optional_import
+
+cp, _ = optional_import("cupy")
+
+im = [[1, 2], [3, 4]]
+
+TESTS = [(im, (2, 2))]
+for p in TEST_NDARRAYS:
+    TESTS.append((p(im), (2, 2)))
+
+TESTS_SINGLE = [[5]]
+for p in TEST_NDARRAYS:
+    TESTS_SINGLE.append([p(5)])
+
+
+class TestToTensord(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_array_input(self, test_data, expected_shape):
+        test_data = {"img": test_data}
+        to_tensord = ToTensord(keys="img", dtype=torch.float32, device="cpu", wrap_sequence=True)
+        result = to_tensord(test_data)
+        out_img = result["img"]
+        self.assertTrue(isinstance(out_img, torch.Tensor))
+        assert_allclose(out_img, test_data["img"], type_test=False)
+        self.assertTupleEqual(out_img.shape, expected_shape)
+
+        # test inverse
+        inv_data = to_tensord.inverse(result)
+        self.assertTrue(isinstance(inv_data["img"], np.ndarray))
+        assert_allclose(test_data["img"], inv_data["img"], type_test=False)
+
+    @parameterized.expand(TESTS_SINGLE)
+    def test_single_input(self, test_data):
+        test_data = {"img": test_data}
+        result = ToTensord(keys="img", track_meta=True)(test_data)
+        out_img = result["img"]
+        self.assertTrue(isinstance(out_img, torch.Tensor))
+        assert_allclose(out_img, test_data["img"], type_test=False)
+        self.assertEqual(out_img.ndim, 0)
+
+    @unittest.skipUnless(HAS_CUPY, "CuPy is required.")
+    def test_cupy(self):
+        test_data = [[1, 2], [3, 4]]
+        cupy_array = cp.ascontiguousarray(cp.asarray(test_data))
+        result = ToTensord(keys="img")({"img": cupy_array})
+        self.assertTrue(isinstance(result["img"], torch.Tensor))
+        assert_allclose(result["img"], test_data, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_torchvision.py

@@ -0,0 +1,66 @@
+# 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 TorchVision
+from monai.utils import set_determinism
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.extend(
+        [
+            [
+                {"name": "ColorJitter"},
+                p([[[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]]]),
+                p([[[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]]]),
+            ],
+            [
+                {"name": "ColorJitter", "brightness": 0.5, "contrast": 0.5, "saturation": [0.1, 0.8], "hue": 0.5},
+                p([[[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]]]),
+                p(
+                    [
+                        [[0.1090, 0.6193], [0.6193, 0.9164]],
+                        [[0.1090, 0.6193], [0.6193, 0.9164]],
+                        [[0.1090, 0.6193], [0.6193, 0.9164]],
+                    ]
+                ),
+            ],
+            [
+                {"name": "Pad", "padding": [1, 1, 1, 1]},
+                p([[[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]], [[0.0, 1.0], [1.0, 2.0]]]),
+                p(
+                    [
+                        [[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 TestTorchVision(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, input_param, input_data, expected_value):
+        set_determinism(seed=0)
+        result = TorchVision(**input_param)(input_data)
+        assert_allclose(result, expected_value, rtol=1e-3)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_torchvisiond.py

@@ -0,0 +1,63 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import torch
+from parameterized import parameterized
+
+from monai.transforms import TorchVisiond
+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 TestTorchVisiond(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)
+        result = TorchVisiond(**input_param)(input_data)
+        assert_allclose(result["img"], expected_value, atol=1e-4, rtol=1e-4, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_transform.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 os
+import unittest
+
+import monai.transforms as mt
+from monai.data import Dataset
+from monai.utils.misc import MONAIEnvVars
+
+
+class FaultyTransform(mt.Transform):
+
+    def __call__(self, _):
+        raise RuntimeError
+
+
+def faulty_lambda(_):
+    raise RuntimeError
+
+
+class TestTransform(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        super(__class__, cls).setUpClass()
+        cls.orig_value = str(MONAIEnvVars.debug())
+
+    @classmethod
+    def tearDownClass(cls):
+        if cls.orig_value is not None:
+            os.environ["MONAI_DEBUG"] = cls.orig_value
+        else:
+            os.environ.pop("MONAI_DEBUG")
+        super(__class__, cls).tearDownClass()
+
+    def test_raise(self):
+        for transform in (FaultyTransform(), mt.Lambda(faulty_lambda)):
+            ds = Dataset([None] * 10, transform)
+            for debug in ("False", "True"):
+                os.environ["MONAI_DEBUG"] = debug
+                try:
+                    ds[0]
+                except RuntimeError as re:
+                    if debug == "False":
+                        self.assertTrue("applying transform" in str(re))
+                    else:
+                        self.assertFalse("applying transform" in str(re))
+
+
+if __name__ == "__main__":
+    unittest.main()