Make RandTorchVisiond and RandCuCIMd Consistent (#5569)

### Description

Both RandTorchVisiond and RandCuCIMd are dealing with the third-party
libraries and they should have the same API, especially on using
`apply_prob` instead of `prob` since it is different than the `prob` of
the underlying randomized tranform.


Signed-off-by: Behrooz <3968947+drbeh@users.noreply.github.com>
Signed-off-by: monai-bot <monai.miccai2019@gmail.com>

Author: bhashemian

monai/data/dataset.py

@@ -35,6 +35,7 @@
 from monai.transforms import (
     Compose,
     Randomizable,
+    RandomizableTrait,
     ThreadUnsafe,
     Transform,
     apply_transform,
@@ -277,7 +278,7 @@ def set_transform_hash(self, hash_xform_func):
         inherit from MONAI's `Transform` class."""
         hashable_transforms = []
         for _tr in self.transform.flatten().transforms:
-            if isinstance(_tr, Randomizable) or not isinstance(_tr, Transform):
+            if isinstance(_tr, RandomizableTrait) or not isinstance(_tr, Transform):
                 break
             hashable_transforms.append(_tr)
         # Try to hash. Fall back to a hash of their names
@@ -314,7 +315,7 @@ def _pre_transform(self, item_transformed):
         """
         for _transform in self.transform.transforms:
             # execute all the deterministic transforms
-            if isinstance(_transform, Randomizable) or not isinstance(_transform, Transform):
+            if isinstance(_transform, RandomizableTrait) or not isinstance(_transform, Transform):
                 break
             # this is to be consistent with CacheDataset even though it's not in a multi-thread situation.
             _xform = deepcopy(_transform) if isinstance(_transform, ThreadUnsafe) else _transform
@@ -340,7 +341,7 @@ def _post_transform(self, item_transformed):
         for _transform in self.transform.transforms:
             if (
                 start_post_randomize_run
-                or isinstance(_transform, Randomizable)
+                or isinstance(_transform, RandomizableTrait)
                 or not isinstance(_transform, Transform)
             ):
                 start_post_randomize_run = True
@@ -877,7 +878,7 @@ def _load_cache_item(self, idx: int):
         item = self.data[idx]
         for _transform in self.transform.transforms:  # type:ignore
             # execute all the deterministic transforms
-            if isinstance(_transform, Randomizable) or not isinstance(_transform, Transform):
+            if isinstance(_transform, RandomizableTrait) or not isinstance(_transform, Transform):
                 break
             _xform = deepcopy(_transform) if isinstance(_transform, ThreadUnsafe) else _transform
             item = apply_transform(_xform, item)
@@ -911,7 +912,7 @@ def _transform(self, index: int):
         if not isinstance(self.transform, Compose):
             raise ValueError("transform must be an instance of monai.transforms.Compose.")
         for _transform in self.transform.transforms:
-            if start_run or isinstance(_transform, Randomizable) or not isinstance(_transform, Transform):
+            if start_run or isinstance(_transform, RandomizableTrait) or not isinstance(_transform, Transform):
                 # only need to deep copy data on first non-deterministic transform
                 if not start_run:
                     start_run = True

monai/data/test_time_augmentation.py

@@ -48,9 +48,9 @@ class TestTimeAugmentation:
     """
     Class for performing test time augmentations. This will pass the same image through the network multiple times.
 
-    The user passes transform(s) to be applied to each realisation, and provided that at least one of those transforms
+    The user passes transform(s) to be applied to each realization, and provided that at least one of those transforms
     is random, the network's output will vary. Provided that inverse transformations exist for all supplied spatial
-    transforms, the inverse can be applied to each realisation of the network's output. Once in the same spatial
+    transforms, the inverse can be applied to each realization of the network's output. Once in the same spatial
     reference, the results can then be combined and metrics computed.
 
     Test time augmentations are a useful feature for computing network uncertainty, as well as observing the network's
@@ -63,9 +63,10 @@ class TestTimeAugmentation:
         https://doi.org/10.1016/j.neucom.2019.01.103
 
     Args:
-        transform: transform (or composed) to be applied to each realisation. At least one transform must be of type
-            `Randomizable`. All random transforms must be of type `InvertibleTransform`.
-        batch_size: number of realisations to infer at once.
+        transform: transform (or composed) to be applied to each realization. At least one transform must be of type
+        `RandomizableTrait` (i.e. `Randomizable`, `RandomizableTransform`, or `RandomizableTrait`).
+            . All random transforms must be of type `InvertibleTransform`.
+        batch_size: number of realizations to infer at once.
         num_workers: how many subprocesses to use for data.
         inferrer_fn: function to use to perform inference.
         device: device on which to perform inference.
@@ -167,7 +168,7 @@ def __call__(
         """
         Args:
             data: dictionary data to be processed.
-            num_examples: number of realisations to be processed and results combined.
+            num_examples: number of realizations to be processed and results combined.
 
         Returns:
             - if `return_full_data==False`: mode, mean, std, vvc. The mode, mean and standard deviation are

monai/transforms/nvtx.py

@@ -12,7 +12,7 @@
 Wrapper around NVIDIA Tools Extension for profiling MONAI transformations
 """
 
-from monai.transforms.transform import RandomizableTransform, Transform
+from monai.transforms.transform import RandomizableTrait, Transform
 from monai.utils import optional_import
 
 _nvtx, _ = optional_import("torch._C._nvtx", descriptor="NVTX is not installed. Are you sure you have a CUDA build?")
@@ -63,9 +63,9 @@ def __call__(self, data):
         return data
 
 
-class RandRangePush(RangePush, RandomizableTransform):
+class RandRangePush(RangePush, RandomizableTrait):
     """
-    Pushes a range onto a stack of nested range span (RandomizableTransform).
+    Pushes a range onto a stack of nested range span (for randomizable transforms).
     Stores zero-based depth of the range that is started.
 
     Args:
@@ -84,9 +84,9 @@ def __call__(self, data):
         return data
 
 
-class RandRangePop(RangePop, RandomizableTransform):
+class RandRangePop(RangePop, RandomizableTrait):
     """
-    Pops a range off of a stack of nested range spans (RandomizableTransform).
+    Pops a range off of a stack of nested range spans (for randomizable transforms).
     Stores zero-based depth of the range that is ended.
     """
 
@@ -107,10 +107,9 @@ def __call__(self, data):
         return data
 
 
-class RandMark(Mark, RandomizableTransform):
+class RandMark(Mark, RandomizableTrait):
     """
-    Mark an instantaneous event that occurred at some point.
-    (RandomizableTransform)
+    Mark an instantaneous event that occurred at some point (for randomizable transforms).
 
     Args:
         msg: ASCII message to associate with the event.

monai/transforms/transform.py

@@ -192,7 +192,7 @@ class ThreadUnsafe:
     pass
 
 
-class Randomizable(ThreadUnsafe):
+class Randomizable(ThreadUnsafe, RandomizableTrait):
     """
     An interface for handling random state locally, currently based on a class
     variable `R`, which is an instance of `np.random.RandomState`.  This
@@ -332,7 +332,7 @@ def lazy_evaluation(self, lazy_evaluation: bool):
         self.lazy_evaluation = lazy_evaluation
 
 
-class RandomizableTransform(Randomizable, Transform, RandomizableTrait):
+class RandomizableTransform(Randomizable, Transform):
     """
     An interface for handling random state locally, currently based on a class variable `R`,
     which is an instance of `np.random.RandomState`.

monai/transforms/utility/array.py

@@ -29,7 +29,7 @@
 from monai.data.meta_tensor import MetaTensor
 from monai.data.utils import no_collation
 from monai.transforms.inverse import InvertibleTransform
-from monai.transforms.transform import Randomizable, RandomizableTransform, Transform
+from monai.transforms.transform import Randomizable, RandomizableTrait, RandomizableTransform, Transform
 from monai.transforms.utils import (
     extreme_points_to_image,
     get_extreme_points,
@@ -1330,7 +1330,7 @@ def __call__(self, img: torch.Tensor):
 class CuCIM(Transform):
     """
     Wrap a non-randomized cuCIM transform, defined based on the transform name and args.
-    For randomized transforms (or randomly applying a transform) use :py:class:`monai.transforms.RandCuCIM`.
+    For randomized transforms use :py:class:`monai.transforms.RandCuCIM`.
 
     Args:
         name: the transform name in CuCIM package
@@ -1361,46 +1361,25 @@ def __call__(self, data):
         return self.transform(data, *self.args, **self.kwargs)
 
 
-class RandCuCIM(CuCIM, RandomizableTransform):
+class RandCuCIM(CuCIM, RandomizableTrait):
     """
-    Wrap a randomized cuCIM transform, defined based on the transform name and args,
-    or randomly apply a non-randomized transform.
+    Wrap a randomized cuCIM transform, defined based on the transform name and args
     For deterministic non-randomized transforms use :py:class:`monai.transforms.CuCIM`.
 
     Args:
         name: the transform name in CuCIM package.
-        apply_prob: the probability to apply the transform (default=1.0)
         args: parameters for the CuCIM transform.
         kwargs: parameters for the CuCIM transform.
 
     Note:
         - CuCIM transform only work with CuPy arrays, so this transform expects input data to be `cupy.ndarray`.
           Users can call `ToCuPy` transform to convert a numpy array or torch tensor to cupy array.
-        - If the cuCIM transform is already randomized the `apply_prob` argument has nothing to do with
-          the randomness of the underlying cuCIM transform. `apply_prob` defines if the transform (either randomized
-          or non-randomized) being applied randomly, so it can apply non-randomized transforms randomly but be careful
-          with setting `apply_prob` to anything than 1.0 when using along with cuCIM's randomized transforms.
         - If the random factor of the underlying cuCIM transform is not derived from `self.R`,
           the results may not be deterministic. See Also: :py:class:`monai.transforms.Randomizable`.
     """
 
-    def __init__(self, name: str, apply_prob: float = 1.0, *args, **kwargs) -> None:
+    def __init__(self, name: str, *args, **kwargs) -> None:
         CuCIM.__init__(self, name, *args, **kwargs)
-        RandomizableTransform.__init__(self, prob=apply_prob)
-
-    def __call__(self, data):
-        """
-        Args:
-            data: a CuPy array (`cupy.ndarray`) for the cuCIM transform
-
-        Returns:
-            `cupy.ndarray`
-
-        """
-        self.randomize(data)
-        if not self._do_transform:
-            return data
-        return super().__call__(data)
 
 
 class AddCoordinateChannels(Transform):

monai/transforms/utility/dictionary.py

@@ -27,7 +27,7 @@
 from monai.data.meta_tensor import MetaObj, MetaTensor
 from monai.data.utils import no_collation
 from monai.transforms.inverse import InvertibleTransform
-from monai.transforms.transform import MapTransform, Randomizable, RandomizableTransform
+from monai.transforms.transform import MapTransform, Randomizable, RandomizableTrait, RandomizableTransform
 from monai.transforms.utility.array import (
     AddChannel,
     AddCoordinateChannels,
@@ -1457,51 +1457,38 @@ def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> Dict[Hashable, N
         return d
 
 
-class RandTorchVisiond(RandomizableTransform, MapTransform):
+class RandTorchVisiond(MapTransform, RandomizableTrait):
     """
     Dictionary-based wrapper of :py:class:`monai.transforms.TorchVision` for randomized transforms.
     For deterministic non-randomized transforms of TorchVision use :py:class:`monai.transforms.TorchVisiond`.
 
+    Args:
+        keys: keys of the corresponding items to be transformed.
+            See also: :py:class:`monai.transforms.compose.MapTransform`
+        name: The transform name in TorchVision package.
+        allow_missing_keys: don't raise exception if key is missing.
+        args: parameters for the TorchVision transform.
+        kwargs: parameters for the TorchVision transform.
+
     Note:
 
         - As most of the TorchVision transforms only work for PIL image and PyTorch Tensor, this transform expects input
-          data to be dict of PyTorch Tensors, users can easily call `ToTensord` transform to convert Numpy to Tensor.
-        - This class inherits the ``RandomizableTransform`` purely to prevent any dataset caching to skip the transform
+          data to be dict of PyTorch Tensors. Users should call `ToTensord` transform first to convert Numpy to Tensor.
+        - This class inherits the ``Randomizable`` purely to prevent any dataset caching to skip the transform
           computation. If the random factor of the underlying torchvision transform is not derived from `self.R`,
-          the results may not be deterministic.  It also provides the probability to apply this transform.
-          See Also: :py:class:`monai.transforms.RandomizableTransform`.
+          the results may not be deterministic. See Also: :py:class:`monai.transforms.Randomizable`.
 
     """
 
     backend = TorchVision.backend
 
-    def __init__(
-        self, keys: KeysCollection, name: str, prob: float = 1.0, allow_missing_keys: bool = False, *args, **kwargs
-    ) -> None:
-        """
-        Args:
-            keys: keys of the corresponding items to be transformed.
-                See also: :py:class:`monai.transforms.compose.MapTransform`
-            name: The transform name in TorchVision package.
-            prob: Probability of applying this transform.
-            allow_missing_keys: don't raise exception if key is missing.
-            args: parameters for the TorchVision transform.
-            kwargs: parameters for the TorchVision transform.
-
-        """
-        RandomizableTransform.__init__(self, prob=prob)
+    def __init__(self, keys: KeysCollection, name: str, allow_missing_keys: bool = False, *args, **kwargs) -> None:
         MapTransform.__init__(self, keys, allow_missing_keys)
-
         self.name = name
         self.trans = TorchVision(name, *args, **kwargs)
 
     def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> Dict[Hashable, NdarrayOrTensor]:
         d = dict(data)
-
-        self.randomize(data)
-        if not self._do_transform:
-            return d
-
         for key in self.key_iterator(d):
             d[key] = self.trans(d[key])
         return d
@@ -1677,7 +1664,7 @@ def __call__(self, data):
         return d
 
 
-class RandCuCIMd(CuCIMd, RandomizableTransform):
+class RandCuCIMd(MapTransform, RandomizableTrait):
     """
     Dictionary-based wrapper of :py:class:`monai.transforms.CuCIM` for randomized transforms.
     For deterministic non-randomized transforms of CuCIM use :py:class:`monai.transforms.CuCIMd`.
@@ -1686,25 +1673,22 @@ class RandCuCIMd(CuCIMd, RandomizableTransform):
         keys: keys of the corresponding items to be transformed.
             See also: :py:class:`monai.transforms.compose.MapTransform`
         name: The transform name in CuCIM package.
-        apply_prob: the probability to apply the transform (default=1.0)
         allow_missing_keys: don't raise exception if key is missing.
         args: parameters for the CuCIM transform.
         kwargs: parameters for the CuCIM transform.
 
     Note:
         - CuCIM transform only work with CuPy arrays, so this transform expects input data to be `cupy.ndarray`.
-          Users can call `ToCuPy` transform to convert a numpy array or torch tensor to cupy array.
-        - If the cuCIM transform is already randomized the `apply_prob` argument has nothing to do with
-          the randomness of the underlying cuCIM transform. `apply_prob` defines if the transform (either randomized
-          or non-randomized) being applied randomly, so it can apply non-randomized transforms randomly but be careful
-          with setting `apply_prob` to anything than 1.0 when using along with cuCIM's randomized transforms.
-        - If the random factor of the underlying cuCIM transform is not derived from `self.R`,
+          Users should call `ToCuPy` transform first to convert a numpy array or torch tensor to cupy array.
+        - This class inherits the ``Randomizable`` purely to prevent any dataset caching to skip the transform
+          computation. If the random factor of the underlying cuCIM transform is not derived from `self.R`,
           the results may not be deterministic. See Also: :py:class:`monai.transforms.Randomizable`.
     """
 
-    def __init__(self, apply_prob: float = 1.0, *args, **kwargs) -> None:
-        CuCIMd.__init__(self, *args, **kwargs)
-        RandomizableTransform.__init__(self, prob=apply_prob)
+    def __init__(self, keys: KeysCollection, name: str, allow_missing_keys: bool = False, *args, **kwargs) -> None:
+        MapTransform.__init__(self, keys, allow_missing_keys)
+        self.name = name
+        self.trans = CuCIM(name, *args, **kwargs)
 
     def __call__(self, data):
         """
@@ -1715,10 +1699,10 @@ def __call__(self, data):
             Dict[Hashable, `cupy.ndarray`]
 
         """
-        self.randomize(data)
-        if not self._do_transform:
-            return dict(data)
-        return super().__call__(data)
+        d = dict(data)
+        for key in self.key_iterator(d):
+            d[key] = self.trans(d[key])
+        return d
 
 
 class AddCoordinateChannelsd(MapTransform):

tests/test_nvtx_decorator.py

@@ -24,7 +24,7 @@
     RandAdjustContrast,
     RandCuCIM,
     RandFlip,
-    Randomizable,
+    RandomizableTrait,
     Rotate90,
     ToCupy,
     ToNumpy,
@@ -217,7 +217,7 @@ def test_tranform_randomized(self, input):
 
         # Check if the first randomized is RandAdjustContrast
         for tran in transforms.transforms:
-            if isinstance(tran, Randomizable):
+            if isinstance(tran, RandomizableTrait):
                 self.assertIsInstance(tran, RandAdjustContrast)
                 break
 

tests/test_nvtx_transform.py

@@ -15,7 +15,7 @@
 import torch
 from parameterized import parameterized
 
-from monai.transforms import Compose, Flip, RandFlip, RandFlipD, Randomizable, ToTensor, ToTensorD
+from monai.transforms import Compose, Flip, RandFlip, RandFlipD, RandomizableTrait, ToTensor, ToTensorD
 from monai.transforms.nvtx import (
     Mark,
     MarkD,
@@ -59,7 +59,7 @@ def test_nvtx_transfroms_alone(self, input):
 
         # Check if chain of randomizable/non-randomizable transforms is not broken
         for tran in transforms.transforms:
-            if isinstance(tran, Randomizable):
+            if isinstance(tran, RandomizableTrait):
                 self.assertIsInstance(tran, RangePush)
                 break