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

tests/transforms/test_nvtx_decorator.py

@@ -0,0 +1,289 @@
+# 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 (
+    Compose,
+    CuCIM,
+    Flip,
+    Flipd,
+    OneOf,
+    RandAdjustContrast,
+    RandCuCIM,
+    RandFlip,
+    RandomizableTrait,
+    Rotate90,
+    ToCupy,
+    ToNumpy,
+    TorchVision,
+    ToTensor,
+    ToTensord,
+)
+from monai.utils import Range, optional_import
+from tests.test_utils import HAS_CUPY
+
+_, has_nvtx = optional_import("torch._C._nvtx", descriptor="NVTX is not installed. Are you sure you have a CUDA build?")
+_, has_tvt = optional_import("torchvision.transforms")
+_, has_cut = optional_import("cucim.core.operations.expose.transform")
+
+TEST_CASE_ARRAY_0 = [np.random.randn(3, 3)]
+TEST_CASE_ARRAY_1 = [np.random.randn(3, 10, 10)]
+
+TEST_CASE_DICT_0 = [{"image": np.random.randn(3, 3)}]
+TEST_CASE_DICT_1 = [{"image": np.random.randn(3, 10, 10)}]
+
+TEST_CASE_TORCH_0 = [torch.randn(3, 3)]
+TEST_CASE_TORCH_1 = [torch.randn(3, 10, 10)]
+
+TEST_CASE_WRAPPER = [np.random.randn(3, 10, 10)]
+
+TEST_CASE_RECURSIVE_0 = [
+    torch.randn(3, 3),
+    Compose([ToNumpy(), Flip(), RandAdjustContrast(prob=0.0), RandFlip(prob=1.0), ToTensor()]),
+]
+TEST_CASE_RECURSIVE_1 = [
+    torch.randn(3, 3),
+    Compose([ToNumpy(), Flip(), Compose([RandAdjustContrast(prob=0.0), RandFlip(prob=1.0)]), ToTensor()]),
+]
+TEST_CASE_RECURSIVE_2 = [
+    torch.randn(3, 3),
+    Compose([ToNumpy(), Flip(), OneOf([RandAdjustContrast(prob=0.0), RandFlip(prob=1.0)], weights=[0, 1]), ToTensor()]),
+]
+TEST_CASE_RECURSIVE_LIST = [
+    torch.randn(3, 3),
+    [ToNumpy(), Flip(), RandAdjustContrast(prob=0.0), RandFlip(prob=1.0), ToTensor()],
+]
+
+
+@unittest.skipUnless(has_nvtx, "Required torch._C._nvtx for NVTX Range!")
+class TestNVTXRangeDecorator(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_ARRAY_0, TEST_CASE_ARRAY_1])
+    def test_tranform_array(self, input):
+        transforms = Compose([Range("random flip")(Flip()), Range()(ToTensor())])
+        # Apply transforms
+        output = transforms(input)
+
+        # Decorate with NVTX Range
+        transforms1 = Range()(transforms)
+        transforms2 = Range("Transforms2")(transforms)
+        transforms3 = Range(name="Transforms3", methods="__call__")(transforms)
+
+        # Apply transforms with Range
+        output1 = transforms1(input)
+        output2 = transforms2(input)
+        output3 = transforms3(input)
+
+        # Check the outputs
+        self.assertIsInstance(output, torch.Tensor)
+        self.assertIsInstance(output1, torch.Tensor)
+        self.assertIsInstance(output2, torch.Tensor)
+        self.assertIsInstance(output3, torch.Tensor)
+        np.testing.assert_equal(output.numpy(), output1.numpy())
+        np.testing.assert_equal(output.numpy(), output2.numpy())
+        np.testing.assert_equal(output.numpy(), output3.numpy())
+
+    @parameterized.expand([TEST_CASE_DICT_0, TEST_CASE_DICT_1])
+    def test_tranform_dict(self, input):
+        transforms = Compose([Range("random flip dict")(Flipd(keys="image")), Range()(ToTensord("image"))])
+        # Apply transforms
+        output = transforms(input)["image"]
+
+        # Decorate with NVTX Range
+        transforms1 = Range()(transforms)
+        transforms2 = Range("Transforms2")(transforms)
+        transforms3 = Range(name="Transforms3", methods="__call__")(transforms)
+
+        # Apply transforms with Range
+        output1 = transforms1(input)["image"]
+        output2 = transforms2(input)["image"]
+        output3 = transforms3(input)["image"]
+
+        # Check the outputs
+        self.assertIsInstance(output, torch.Tensor)
+        self.assertIsInstance(output1, torch.Tensor)
+        self.assertIsInstance(output2, torch.Tensor)
+        self.assertIsInstance(output3, torch.Tensor)
+        np.testing.assert_equal(output.numpy(), output1.numpy())
+        np.testing.assert_equal(output.numpy(), output2.numpy())
+        np.testing.assert_equal(output.numpy(), output3.numpy())
+
+    @parameterized.expand([TEST_CASE_WRAPPER])
+    @unittest.skipUnless(HAS_CUPY, "Requires CuPy.")
+    @unittest.skipUnless(has_cut, "Requires cuCIM transforms.")
+    @unittest.skipUnless(has_tvt, "Requires torchvision transforms.")
+    def test_wrapper_tranforms(self, input):
+        transform_list = [
+            ToTensor(),
+            TorchVision(name="RandomHorizontalFlip", p=1.0),
+            ToCupy(),
+            CuCIM(name="image_flip", spatial_axis=-1),
+            RandCuCIM(name="rand_image_rotate_90", prob=1.0, max_k=1, spatial_axis=(-2, -1)),
+        ]
+
+        transforms = Compose(transform_list)
+        transforms_range = Compose([Range()(t) for t in transform_list])
+
+        # Apply transforms
+        output = transforms(input)
+
+        # Apply transforms with Range
+        output_r = transforms_range(input)
+
+        # Check the outputs
+        np.testing.assert_equal(output.get(), output_r.get())
+
+    @parameterized.expand([TEST_CASE_RECURSIVE_0, TEST_CASE_RECURSIVE_1, TEST_CASE_RECURSIVE_2])
+    def test_recursive_tranforms(self, input, transforms):
+        transforms_range = Range(name="Recursive Compose", recursive=True)(transforms)
+
+        # Apply transforms
+        output = transforms(input)
+
+        # Apply transforms with Range
+        output_r = transforms_range(input)
+
+        # Check the outputs
+        self.assertEqual(transforms.map_items, transforms_range.map_items)
+        self.assertEqual(transforms.unpack_items, transforms_range.unpack_items)
+        np.testing.assert_equal(output.numpy(), output_r.numpy())
+
+    @parameterized.expand([TEST_CASE_RECURSIVE_LIST])
+    def test_recursive_list_tranforms(self, input, transform_list):
+        transforms_list_range = Range(recursive=True)(transform_list)
+
+        # Apply transforms
+        output = Compose(transform_list)(input)
+
+        # Apply transforms with Range
+        output_r = Compose(transforms_list_range)(input)
+
+        # Check the outputs
+        np.testing.assert_equal(output.numpy(), output_r.numpy())
+
+    @parameterized.expand([TEST_CASE_ARRAY_1])
+    def test_tranform_randomized(self, input):
+        # Compose deterministic and randomized transforms
+        transforms = Compose(
+            [
+                Range("flip")(Flip()),
+                Rotate90(),
+                Range()(RandAdjustContrast(prob=0.0)),
+                Range("random flip")(RandFlip(prob=1.0)),
+                ToTensor(),
+            ]
+        )
+        # Apply transforms
+        output = transforms(input)
+
+        # Decorate with NVTX Range
+        transforms1 = Range()(transforms)
+        transforms2 = Range("Transforms2")(transforms)
+        transforms3 = Range(name="Transforms3", methods="__call__")(transforms)
+
+        # Apply transforms with Range
+        output1 = transforms1(input)
+        output2 = transforms2(input)
+        output3 = transforms3(input)
+
+        # Check if the outputs are equal
+        self.assertIsInstance(output, torch.Tensor)
+        self.assertIsInstance(output1, torch.Tensor)
+        self.assertIsInstance(output2, torch.Tensor)
+        self.assertIsInstance(output3, torch.Tensor)
+        np.testing.assert_equal(output.numpy(), output1.numpy())
+        np.testing.assert_equal(output.numpy(), output2.numpy())
+        np.testing.assert_equal(output.numpy(), output3.numpy())
+
+        # Check if the first randomized is RandAdjustContrast
+        for tran in transforms.transforms:
+            if isinstance(tran, RandomizableTrait):
+                self.assertIsInstance(tran, RandAdjustContrast)
+                break
+
+    @parameterized.expand([TEST_CASE_TORCH_0, TEST_CASE_TORCH_1])
+    def test_network(self, input):
+        # Create a network
+        model = torch.nn.Sequential(torch.nn.ReLU(), torch.nn.Sigmoid())
+
+        # Forward
+        output = model(input)
+
+        # Decorate with NVTX Range
+        model1 = Range()(model)
+        model2 = Range("Model2")(model)
+        model3 = Range(name="Model3", methods="forward")(model)
+
+        # Forward with Range
+        output1 = model1(input)
+        output2 = model2(input)
+        output3 = model3(input)
+
+        # Check the outputs
+        self.assertIsInstance(output, torch.Tensor)
+        self.assertIsInstance(output1, torch.Tensor)
+        self.assertIsInstance(output2, torch.Tensor)
+        self.assertIsInstance(output3, torch.Tensor)
+        np.testing.assert_equal(output.numpy(), output1.numpy())
+        np.testing.assert_equal(output.numpy(), output2.numpy())
+        np.testing.assert_equal(output.numpy(), output3.numpy())
+
+    @parameterized.expand([TEST_CASE_TORCH_0, TEST_CASE_TORCH_1])
+    def test_loss(self, input):
+        # Create a network and loss
+        model = torch.nn.Sigmoid()
+        loss = torch.nn.BCELoss()
+        pred = model(input)
+        target = torch.empty_like(input).random_(2)
+
+        # Loss evaluation
+        output = loss(pred, target)
+
+        # Decorate with NVTX Range
+        loss1 = Range()(loss)
+        loss2 = Range("Loss2")(loss)
+        loss3 = Range(name="Loss3", methods="forward")(loss)
+
+        # Loss evaluation with Range
+        output1 = loss1(pred, target)
+        output2 = loss2(pred, target)
+        output3 = loss3(pred, target)
+
+        # Check the outputs
+        self.assertIsInstance(output, torch.Tensor)
+        self.assertIsInstance(output1, torch.Tensor)
+        self.assertIsInstance(output2, torch.Tensor)
+        self.assertIsInstance(output3, torch.Tensor)
+        np.testing.assert_equal(output.numpy(), output1.numpy())
+        np.testing.assert_equal(output.numpy(), output2.numpy())
+        np.testing.assert_equal(output.numpy(), output3.numpy())
+
+    def test_context_manager(self):
+        model = torch.nn.Sigmoid()
+        loss = torch.nn.BCELoss()
+
+        with Range():
+            input = torch.randn(3, requires_grad=True)
+            target = torch.empty(3).random_(2)
+
+        with Range("Model"):
+            output = loss(model(input), target)
+            output.backward()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_nvtx_transform.py

@@ -0,0 +1,143 @@
+# 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 Compose, Flip, RandFlip, RandFlipD, RandomizableTrait, ToTensor, ToTensorD
+from monai.transforms.nvtx import (
+    Mark,
+    MarkD,
+    RandMark,
+    RandMarkD,
+    RandRangePop,
+    RandRangePopD,
+    RandRangePush,
+    RandRangePushD,
+    RangePop,
+    RangePopD,
+    RangePush,
+    RangePushD,
+)
+from monai.utils import optional_import
+
+_, has_nvtx = optional_import("torch._C._nvtx", descriptor="NVTX is not installed. Are you sure you have a CUDA build?")
+
+TEST_CASE_ARRAY_0 = [np.random.randn(3, 3)]
+TEST_CASE_ARRAY_1 = [np.random.randn(3, 10, 10)]
+TEST_CASE_DICT_0 = [{"image": np.random.randn(3, 3)}]
+TEST_CASE_DICT_1 = [{"image": np.random.randn(3, 10, 10)}]
+
+
+class TestNVTXTransforms(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_ARRAY_0, TEST_CASE_ARRAY_1, TEST_CASE_DICT_0, TEST_CASE_DICT_1])
+    @unittest.skipUnless(has_nvtx, "CUDA is required for NVTX!")
+    def test_nvtx_transfroms_alone(self, input):
+        transforms = Compose(
+            [
+                Mark("Mark: Transforms Start!"),
+                RangePush("Range: RandFlipD"),
+                RangePop(),
+                RandRangePush("Range: ToTensorD"),
+                RandRangePop(),
+                RandMark("Mark: Transforms End!"),
+            ]
+        )
+        output = transforms(input)
+        self.assertEqual(id(input), id(output))
+
+        # Check if chain of randomizable/non-randomizable transforms is not broken
+        for tran in transforms.transforms:
+            if isinstance(tran, RandomizableTrait):
+                self.assertIsInstance(tran, RangePush)
+                break
+
+    @parameterized.expand([TEST_CASE_ARRAY_0, TEST_CASE_ARRAY_1])
+    @unittest.skipUnless(has_nvtx, "CUDA is required for NVTX!")
+    def test_nvtx_transfroms_array(self, input):
+        # with prob == 0.0
+        transforms = Compose(
+            [
+                RandMark("Mark: Transforms Start!"),
+                RandRangePush("Range: RandFlip"),
+                RandFlip(prob=0.0),
+                RandRangePop(),
+                RangePush("Range: ToTensor"),
+                ToTensor(),
+                RangePop(),
+                Mark("Mark: Transforms End!"),
+            ]
+        )
+        output = transforms(input)
+        self.assertIsInstance(output, torch.Tensor)
+        np.testing.assert_array_equal(input, output)
+        # with prob == 1.0
+        transforms = Compose(
+            [
+                RandMark("Mark: Transforms Start!"),
+                RandRangePush("Range: RandFlip"),
+                RandFlip(prob=1.0),
+                RandRangePop(),
+                RangePush("Range: ToTensor"),
+                ToTensor(),
+                RangePop(),
+                Mark("Mark: Transforms End!"),
+            ]
+        )
+        output = transforms(input)
+        self.assertIsInstance(output, torch.Tensor)
+        np.testing.assert_array_equal(input, Flip()(output.numpy()))
+
+    @parameterized.expand([TEST_CASE_DICT_0, TEST_CASE_DICT_1])
+    @unittest.skipUnless(has_nvtx, "CUDA is required for NVTX!")
+    def test_nvtx_transfroms_dict(self, input):
+        # with prob == 0.0
+        transforms = Compose(
+            [
+                RandMarkD("Mark: Transforms (p=0) Start!"),
+                RandRangePushD("Range: RandFlipD"),
+                RandFlipD(keys="image", prob=0.0),
+                RandRangePopD(),
+                RangePushD("Range: ToTensorD"),
+                ToTensorD(keys=("image")),
+                RangePopD(),
+                MarkD("Mark: Transforms (p=0) End!"),
+            ]
+        )
+        output = transforms(input)
+        self.assertIsInstance(output["image"], torch.Tensor)
+        np.testing.assert_array_equal(input["image"], output["image"])
+        # with prob == 1.0
+        transforms = Compose(
+            [
+                RandMarkD("Mark: Transforms (p=1) Start!"),
+                RandRangePushD("Range: RandFlipD"),
+                RandFlipD(keys="image", prob=1.0),
+                RandRangePopD(),
+                RangePushD("Range: ToTensorD"),
+                ToTensorD(keys=("image")),
+                RangePopD(),
+                MarkD("Mark: Transforms (p=1) End!"),
+            ]
+        )
+        output = transforms(input)
+        self.assertIsInstance(output["image"], torch.Tensor)
+        np.testing.assert_array_equal(input["image"], Flip()(output["image"].numpy()))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_orientation.py

@@ -0,0 +1,247 @@
+# 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 nibabel as nib
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.data.meta_obj import set_track_meta
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms import Orientation, create_rotate, create_translate
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import TEST_DEVICES, assert_allclose
+
+TESTS = []
+for device in TEST_DEVICES:
+    TESTS.append(
+        [
+            {"axcodes": "RAS"},
+            torch.arange(12).reshape((2, 1, 2, 3)),
+            torch.eye(4),
+            torch.arange(12).reshape((2, 1, 2, 3)),
+            "RAS",
+            *device,
+        ]
+    )
+    TESTS.append(
+        [
+            {"axcodes": "ALS"},
+            torch.arange(12).reshape((2, 1, 2, 3)),
+            torch.as_tensor(np.diag([-1, -1, 1, 1])),
+            torch.tensor([[[[3, 4, 5]], [[0, 1, 2]]], [[[9, 10, 11]], [[6, 7, 8]]]]),
+            "ALS",
+            *device,
+        ]
+    )
+    TESTS.append(
+        [
+            {"axcodes": "RAS"},
+            torch.arange(12).reshape((2, 1, 2, 3)),
+            torch.as_tensor(np.diag([-1, -1, 1, 1])),
+            torch.tensor([[[[3, 4, 5], [0, 1, 2]]], [[[9, 10, 11], [6, 7, 8]]]]),
+            "RAS",
+            *device,
+        ]
+    )
+    TESTS.append(
+        [
+            {"axcodes": "AL"},
+            torch.arange(6).reshape((2, 1, 3)),
+            torch.eye(3),
+            torch.tensor([[[0], [1], [2]], [[3], [4], [5]]]),
+            "AL",
+            *device,
+        ]
+    )
+    TESTS.append(
+        [
+            {"axcodes": "L"},
+            torch.arange(6).reshape((2, 3)),
+            torch.eye(2),
+            torch.tensor([[2, 1, 0], [5, 4, 3]]),
+            "L",
+            *device,
+        ]
+    )
+    TESTS.append(
+        [
+            {"axcodes": "L"},
+            torch.arange(6).reshape((2, 3)),
+            torch.eye(2),
+            torch.tensor([[2, 1, 0], [5, 4, 3]]),
+            "L",
+            *device,
+        ]
+    )
+    TESTS.append(
+        [
+            {"axcodes": "L"},
+            torch.arange(6).reshape((2, 3)),
+            torch.as_tensor(np.diag([-1, 1])),
+            torch.arange(6).reshape((2, 3)),
+            "L",
+            *device,
+        ]
+    )
+    TESTS.append(
+        [
+            {"axcodes": "LPS"},
+            torch.arange(12).reshape((2, 1, 2, 3)),
+            torch.as_tensor(
+                create_translate(3, (10, 20, 30))
+                @ create_rotate(3, (np.pi / 2, np.pi / 2, np.pi / 4))
+                @ np.diag([-1, 1, 1, 1])
+            ),
+            torch.tensor([[[[2, 5]], [[1, 4]], [[0, 3]]], [[[8, 11]], [[7, 10]], [[6, 9]]]]),
+            "LPS",
+            *device,
+        ]
+    )
+    TESTS.append(
+        [
+            {"as_closest_canonical": True},
+            torch.arange(12).reshape((2, 1, 2, 3)),
+            torch.as_tensor(
+                create_translate(3, (10, 20, 30))
+                @ create_rotate(3, (np.pi / 2, np.pi / 2, np.pi / 4))
+                @ np.diag([-1, 1, 1, 1])
+            ),
+            torch.tensor([[[[0, 3]], [[1, 4]], [[2, 5]]], [[[6, 9]], [[7, 10]], [[8, 11]]]]),
+            "RAS",
+            *device,
+        ]
+    )
+    TESTS.append(
+        [
+            {"as_closest_canonical": True},
+            torch.arange(6).reshape((1, 2, 3)),
+            torch.as_tensor(create_translate(2, (10, 20)) @ create_rotate(2, (np.pi / 3)) @ np.diag([-1, -0.2, 1])),
+            torch.tensor([[[3, 0], [4, 1], [5, 2]]]),
+            "RA",
+            *device,
+        ]
+    )
+    TESTS.append(
+        [
+            {"axcodes": "LP"},
+            torch.arange(6).reshape((1, 2, 3)),
+            torch.as_tensor(create_translate(2, (10, 20)) @ create_rotate(2, (np.pi / 3)) @ np.diag([-1, -0.2, 1])),
+            torch.tensor([[[2, 5], [1, 4], [0, 3]]]),
+            "LP",
+            *device,
+        ]
+    )
+    TESTS.append(
+        [
+            {"axcodes": "LPID", "labels": tuple(zip("LPIC", "RASD"))},
+            torch.zeros((1, 2, 3, 4, 5)),
+            torch.as_tensor(np.diag([-1, -0.2, -1, 1, 1])),
+            torch.zeros((1, 2, 3, 4, 5)),
+            "LPID",
+            *device,
+        ]
+    )
+    TESTS.append(
+        [
+            {"as_closest_canonical": True, "labels": tuple(zip("LPIC", "RASD"))},
+            torch.zeros((1, 2, 3, 4, 5)),
+            torch.as_tensor(np.diag([-1, -0.2, -1, 1, 1])),
+            torch.zeros((1, 2, 3, 4, 5)),
+            "RASD",
+            *device,
+        ]
+    )
+
+TESTS_TORCH = []
+for track_meta in (False, True):
+    for device in TEST_DEVICES:
+        TESTS_TORCH.append([{"axcodes": "LPS"}, torch.zeros((1, 3, 4, 5)), track_meta, *device])
+
+ILL_CASES = [
+    # too short axcodes
+    [{"axcodes": "RA"}, torch.arange(12).reshape((2, 1, 2, 3)), torch.eye(4)]
+]
+
+
+class TestOrientationCase(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_ornt_meta(
+        self,
+        init_param,
+        img: torch.Tensor,
+        affine: torch.Tensor,
+        expected_data: torch.Tensor,
+        expected_code: str,
+        device,
+    ):
+        img = MetaTensor(img, affine=affine).to(device)
+        ornt = Orientation(**init_param)
+        call_param = {"data_array": img}
+        res = ornt(**call_param)  # type: ignore[arg-type]
+        if img.ndim in (3, 4):
+            test_resampler_lazy(ornt, res, init_param, call_param)
+
+        assert_allclose(res, expected_data.to(device))
+        new_code = nib.orientations.aff2axcodes(res.affine.cpu(), labels=ornt.labels)  # type: ignore
+        self.assertEqual("".join(new_code), expected_code)
+
+    @parameterized.expand(TESTS_TORCH)
+    def test_ornt_torch(self, init_param, img: torch.Tensor, track_meta: bool, device):
+        set_track_meta(track_meta)
+        ornt = Orientation(**init_param)
+
+        img = img.to(device)
+        expected_data = img.clone()
+        expected_code = ornt.axcodes
+
+        res = ornt(img)
+        assert_allclose(res, expected_data)
+        if track_meta:
+            self.assertIsInstance(res, MetaTensor)
+            assert isinstance(res, MetaTensor)  # for mypy type narrowing
+            new_code = nib.orientations.aff2axcodes(res.affine.cpu(), labels=ornt.labels)
+            self.assertEqual("".join(new_code), expected_code)
+        else:
+            self.assertIsInstance(res, torch.Tensor)
+            self.assertNotIsInstance(res, MetaTensor)
+
+    @parameterized.expand(ILL_CASES)
+    def test_bad_params(self, init_param, img: torch.Tensor, affine: torch.Tensor):
+        img = MetaTensor(img, affine=affine)
+        with self.assertRaises(ValueError):
+            Orientation(**init_param)(img)
+
+    @parameterized.expand(TEST_DEVICES)
+    def test_inverse(self, device):
+        img_t = torch.rand((1, 10, 9, 8), dtype=torch.float32, device=device)
+        affine = torch.tensor(
+            [[0, 0, -1, 0], [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1]], dtype=torch.float32, device="cpu"
+        )
+        meta = {"fname": "somewhere"}
+        img = MetaTensor(img_t, affine=affine, meta=meta)
+        tr = Orientation("LPS")
+        # check that image and affine have changed
+        img = tr(img)
+        self.assertNotEqual(img.shape, img_t.shape)
+        self.assertGreater((affine - img.affine).max(), 0.5)
+        # check that with inverse, image affine are back to how they were
+        img = tr.inverse(img)
+        self.assertEqual(img.shape, img_t.shape)
+        self.assertLess((affine - img.affine).max(), 1e-2)
+
+
+if __name__ == "__main__":
+    unittest.main()