update normalize with changes from main

Author: justincdavis

test/common_utils.py

@@ -277,17 +277,6 @@ def combinations_grid(**kwargs):
     return [dict(zip(kwargs.keys(), values)) for values in itertools.product(*kwargs.values())]
 
 
-def cvcuda_to_pil_compatible_tensor(tensor: "cvcuda.Tensor") -> torch.Tensor:
-    tensor = cvcuda_to_tensor(tensor)
-    if tensor.ndim != 4:
-        raise ValueError(f"CV-CUDA Tensor should be 4 dimensional. Got {tensor.ndim} dimensions.")
-    if tensor.shape[0] != 1:
-        raise ValueError(
-            f"CV-CUDA Tensor should have batch dimension 1 for comparison with PIL.Image.Image. Got {tensor.shape[0]}."
-        )
-    return tensor.squeeze(0).cpu()
-
-
 class ImagePair(TensorLikePair):
     def __init__(
         self,
@@ -316,11 +305,6 @@ def __init__(
                     expected = expected[0]
                 expected = expected.cpu()
 
-        # handle check for CV-CUDA Tensors
-        if CVCUDA_AVAILABLE and isinstance(actual, _import_cvcuda().Tensor):
-            # Use the PIL compatible tensor, so we can always compare with PIL.Image.Image
-            actual = cvcuda_to_pil_compatible_tensor(actual)
-
         super().__init__(actual, expected, **other_parameters)
         self.mae = mae
 

test/test_transforms_v2.py

@@ -25,7 +25,6 @@
     assert_equal,
     cache,
     cpu_and_cuda,
-    cvcuda_to_pil_compatible_tensor,
     freeze_rng_state,
     ignore_jit_no_profile_information_warning,
     make_bounding_boxes,
@@ -5591,7 +5590,7 @@ def test_functional(self, make_input):
             (F.normalize_image, tv_tensors.Image),
             (F.normalize_video, tv_tensors.Video),
             pytest.param(
-                F._misc._normalize_cvcuda,
+                F._misc._normalize_image_cvcuda,
                 "cvcuda.Tensor",
                 marks=pytest.mark.skipif(not CVCUDA_AVAILABLE, reason="test requires CVCUDA"),
             ),
@@ -5669,7 +5668,7 @@ def test_correctness_image(self, mean, std, dtype, make_input, fn):
         actual = fn(image, mean=mean, std=std)
 
         if make_input == make_image_cvcuda:
-            image = cvcuda_to_pil_compatible_tensor(image)
+            image = F.cvcuda_to_tensor(image)[0].cpu()
 
         expected = self._reference_normalize_image(image, mean=mean, std=std)
 

torchvision/transforms/v2/_misc.py

@@ -9,6 +9,7 @@
 
 from torchvision import transforms as _transforms, tv_tensors
 from torchvision.transforms.v2 import functional as F, Transform
+from torchvision.transforms.v2.functional._utils import _is_cvcuda_available, _is_cvcuda_tensor
 
 from ._utils import (
     _parse_labels_getter,
@@ -17,11 +18,13 @@
     get_bounding_boxes,
     get_keypoints,
     has_any,
-    is_cvcuda_tensor,
     is_pure_tensor,
 )
 
 
+CVCUDA_AVAILABLE = _is_cvcuda_available()
+
+
 # TODO: do we want/need to expose this?
 class Identity(Transform):
     def transform(self, inpt: Any, params: dict[str, Any]) -> Any:
@@ -161,7 +164,8 @@ class Normalize(Transform):
 
     _v1_transform_cls = _transforms.Normalize
 
-    _transformed_types = Transform._transformed_types + (is_cvcuda_tensor,)
+    if CVCUDA_AVAILABLE:
+        _transformed_types = Transform._transformed_types + (_is_cvcuda_tensor,)
 
     def __init__(self, mean: Sequence[float], std: Sequence[float], inplace: bool = False):
         super().__init__()

torchvision/transforms/v2/_transform.py

@@ -8,7 +8,7 @@
 from torch import nn
 from torch.utils._pytree import tree_flatten, tree_unflatten
 from torchvision import tv_tensors
-from torchvision.transforms.v2._utils import check_type, has_any, is_cvcuda_tensor, is_pure_tensor
+from torchvision.transforms.v2._utils import check_type, has_any, is_pure_tensor
 from torchvision.utils import _log_api_usage_once
 
 from .functional._utils import _get_kernel
@@ -23,7 +23,7 @@ class Transform(nn.Module):
 
     # Class attribute defining transformed types. Other types are passed-through without any transformation
     # We support both Types and callables that are able to do further checks on the type of the input.
-    _transformed_types: tuple[type | Callable[[Any], bool], ...] = (torch.Tensor, PIL.Image.Image, is_cvcuda_tensor)
+    _transformed_types: tuple[type | Callable[[Any], bool], ...] = (torch.Tensor, PIL.Image.Image)
 
     def __init__(self) -> None:
         super().__init__()

torchvision/transforms/v2/_utils.py

@@ -15,8 +15,8 @@
 from torchvision._utils import sequence_to_str
 
 from torchvision.transforms.transforms import _check_sequence_input, _setup_angle, _setup_size  # noqa: F401
-from torchvision.transforms.v2.functional import get_dimensions, get_size, is_cvcuda_tensor, is_pure_tensor
-from torchvision.transforms.v2.functional._utils import _FillType, _FillTypeJIT
+from torchvision.transforms.v2.functional import get_dimensions, get_size, is_pure_tensor
+from torchvision.transforms.v2.functional._utils import _FillType, _FillTypeJIT, _is_cvcuda_tensor
 
 
 def _setup_number_or_seq(arg: int | float | Sequence[int | float], name: str) -> Sequence[float]:
@@ -182,7 +182,7 @@ def query_chw(flat_inputs: list[Any]) -> tuple[int, int, int]:
     chws = {
         tuple(get_dimensions(inpt))
         for inpt in flat_inputs
-        if check_type(inpt, (is_pure_tensor, tv_tensors.Image, PIL.Image.Image, tv_tensors.Video, is_cvcuda_tensor))
+        if check_type(inpt, (is_pure_tensor, tv_tensors.Image, PIL.Image.Image, tv_tensors.Video, _is_cvcuda_tensor))
     }
     if not chws:
         raise TypeError("No image or video was found in the sample")
@@ -207,7 +207,7 @@ def query_size(flat_inputs: list[Any]) -> tuple[int, int]:
                 tv_tensors.Mask,
                 tv_tensors.BoundingBoxes,
                 tv_tensors.KeyPoints,
-                is_cvcuda_tensor,
+                _is_cvcuda_tensor,
             ),
         )
     }

torchvision/transforms/v2/functional/__init__.py

@@ -1,6 +1,6 @@
 from torchvision.transforms import InterpolationMode  # usort: skip
 
-from ._utils import is_pure_tensor, register_kernel, is_cvcuda_tensor  # usort: skip
+from ._utils import is_pure_tensor, register_kernel  # usort: skip
 
 from ._meta import (
     clamp_bounding_boxes,

torchvision/transforms/v2/functional/_augment.py

@@ -1,5 +1,4 @@
 import io
-from typing import TYPE_CHECKING
 
 import PIL.Image
 
@@ -9,15 +8,7 @@
 from torchvision.transforms.functional import pil_to_tensor, to_pil_image
 from torchvision.utils import _log_api_usage_once
 
-from ._utils import _get_kernel, _import_cvcuda, _is_cvcuda_available, _register_kernel_internal
-
-
-CVCUDA_AVAILABLE = _is_cvcuda_available()
-
-if TYPE_CHECKING:
-    import cvcuda  # type: ignore[import-not-found]
-if CVCUDA_AVAILABLE:
-    cvcuda = _import_cvcuda()  # noqa: F811
+from ._utils import _get_kernel, _register_kernel_internal
 
 
 def erase(

torchvision/transforms/v2/functional/_color.py

@@ -1,5 +1,3 @@
-from typing import TYPE_CHECKING
-
 import PIL.Image
 import torch
 from torch.nn.functional import conv2d
@@ -11,15 +9,7 @@
 
 from ._misc import _num_value_bits, to_dtype_image
 from ._type_conversion import pil_to_tensor, to_pil_image
-from ._utils import _get_kernel, _import_cvcuda, _is_cvcuda_available, _register_kernel_internal
-
-
-CVCUDA_AVAILABLE = _is_cvcuda_available()
-
-if TYPE_CHECKING:
-    import cvcuda  # type: ignore[import-not-found]
-if CVCUDA_AVAILABLE:
-    cvcuda = _import_cvcuda()  # noqa: F811
+from ._utils import _get_kernel, _register_kernel_internal
 
 
 def rgb_to_grayscale(inpt: torch.Tensor, num_output_channels: int = 1) -> torch.Tensor:

torchvision/transforms/v2/functional/_misc.py

@@ -79,7 +79,7 @@ def normalize_video(video: torch.Tensor, mean: list[float], std: list[float], in
     return normalize_image(video, mean, std, inplace=inplace)
 
 
-def _normalize_cvcuda(
+def _normalize_image_cvcuda(
     image: "cvcuda.Tensor",
     mean: list[float],
     std: list[float],
@@ -114,7 +114,7 @@ def _normalize_cvcuda(
 
 
 if CVCUDA_AVAILABLE:
-    _register_kernel_internal(normalize, _import_cvcuda().Tensor)(_normalize_cvcuda)
+    _register_kernel_internal(normalize, _import_cvcuda().Tensor)(_normalize_image_cvcuda)
 
 
 def gaussian_blur(inpt: torch.Tensor, kernel_size: list[int], sigma: Optional[list[float]] = None) -> torch.Tensor: