fix: move cvcuda tests to centralized class, more guards againist no import, explicit imports in func

Author: justincdavis

test/test_transforms_v2.py

@@ -3884,7 +3884,15 @@ def test_kernel_video(self):
 
     @pytest.mark.parametrize(
         "make_input",
-        [make_image_tensor, make_image_pil, make_image, make_video],
+        [
+            make_image_tensor,
+            make_image_pil,
+            make_image,
+            make_video,
+            pytest.param(
+                make_image_cvcuda, marks=pytest.mark.skipif(not CVCUDA_AVAILABLE, reason="CVCUDA is not available")
+            ),
+        ],
     )
     def test_functional(self, make_input):
         check_functional(F.gaussian_blur, make_input(), kernel_size=(3, 3))
@@ -3896,14 +3904,29 @@ def test_functional(self, make_input):
             (F._misc._gaussian_blur_image_pil, PIL.Image.Image),
             (F.gaussian_blur_image, tv_tensors.Image),
             (F.gaussian_blur_video, tv_tensors.Video),
+            pytest.param(
+                F._misc._gaussian_blur_cvcuda,
+                cvcuda.Tensor,
+                marks=pytest.mark.skipif(not CVCUDA_AVAILABLE, reason="CVCUDA is not available"),
+            ),
         ],
     )
     def test_functional_signature(self, kernel, input_type):
         check_functional_kernel_signature_match(F.gaussian_blur, kernel=kernel, input_type=input_type)
 
     @pytest.mark.parametrize(
         "make_input",
-        [make_image_tensor, make_image_pil, make_image, make_bounding_boxes, make_segmentation_mask, make_video],
+        [
+            make_image_tensor,
+            make_image_pil,
+            make_image,
+            make_bounding_boxes,
+            make_segmentation_mask,
+            make_video,
+            pytest.param(
+                make_image_cvcuda, marks=pytest.mark.skipif(not CVCUDA_AVAILABLE, reason="CVCUDA is not available")
+            ),
+        ],
     )
     @pytest.mark.parametrize("device", cpu_and_cuda())
     @pytest.mark.parametrize("sigma", [5, 2.0, (0.5, 2), [1.3, 2.7]])
@@ -3994,39 +4017,8 @@ def test_functional_image_correctness(self, dimensions, kernel_size, sigma, dtyp
 
         torch.testing.assert_close(actual, expected, rtol=0, atol=1)
 
-
-@pytest.mark.skipif(not CVCUDA_AVAILABLE, reason="test requires CVCUDA")
-@needs_cuda
-class TestGaussianBlurCVCUDA:
-    def test_kernel_image_errors(self):
-        image = make_image_cvcuda(batch_dims=(1,))
-
-        with pytest.raises(ValueError, match="kernel_size is a sequence its length should be 2"):
-            F.gaussian_blur_cvcuda(image, kernel_size=[1, 2, 3])
-
-        for kernel_size in [2, -1]:
-            with pytest.raises(ValueError, match="kernel_size should have odd and positive integers"):
-                F.gaussian_blur_cvcuda(image, kernel_size=kernel_size)
-
-        with pytest.raises(ValueError, match="sigma is a sequence, its length should be 2"):
-            F.gaussian_blur_cvcuda(image, kernel_size=1, sigma=[1, 2, 3])
-
-        with pytest.raises(TypeError, match="sigma should be either float or sequence of floats"):
-            F.gaussian_blur_cvcuda(image, kernel_size=1, sigma=object())
-
-        with pytest.raises(ValueError, match="sigma should have positive values"):
-            F.gaussian_blur_cvcuda(image, kernel_size=1, sigma=-1)
-
-    def test_functional(self):
-        check_functional(F.gaussian_blur, make_image_cvcuda(batch_dims=(1,)), kernel_size=(3, 3))
-
-    @pytest.mark.parametrize("device", cpu_and_cuda())
-    @pytest.mark.parametrize("sigma", [5, 2.0, (0.5, 2), [1.3, 2.7]])
-    def test_transform(self, device, sigma):
-        check_transform(
-            transforms.GaussianBlur(kernel_size=3, sigma=sigma), make_image_cvcuda(batch_dims=(1,), device=device)
-        )
-
+    @pytest.mark.skipif(not CVCUDA_AVAILABLE, reason="test requires CVCUDA")
+    @needs_cuda
     @pytest.mark.parametrize(
         ("dimensions", "kernel_size", "sigma"),
         [
@@ -4040,7 +4032,7 @@ def test_transform(self, device, sigma):
     @pytest.mark.parametrize("color_space", ["RGB", "GRAY"])
     @pytest.mark.parametrize("batch_dims", [(1,), (2,), (4,)])
     @pytest.mark.parametrize("dtype", [torch.uint8, torch.float32])
-    def test_functional_image_correctness(self, dimensions, kernel_size, sigma, color_space, batch_dims, dtype):
+    def test_functional_cvcuda_parity(self, dimensions, kernel_size, sigma, color_space, batch_dims, dtype):
         height, width = dimensions
 
         image_tensor = make_image(
@@ -4049,7 +4041,7 @@ def test_functional_image_correctness(self, dimensions, kernel_size, sigma, colo
         image_cvcuda = F.to_cvcuda_tensor(image_tensor)
 
         expected = F.gaussian_blur_image(image_tensor, kernel_size=kernel_size, sigma=sigma)
-        actual = F.gaussian_blur_cvcuda(image_cvcuda, kernel_size=kernel_size, sigma=sigma)
+        actual = F._misc._gaussian_blur_cvcuda(image_cvcuda, kernel_size=kernel_size, sigma=sigma)
         actual_torch = F.cvcuda_to_tensor(actual)
 
         if dtype.is_floating_point:

torchvision/transforms/v2/functional/__init__.py

@@ -147,7 +147,6 @@
 from ._misc import (
     convert_image_dtype,
     gaussian_blur,
-    gaussian_blur_cvcuda,
     gaussian_blur_image,
     gaussian_blur_video,
     gaussian_noise,

torchvision/transforms/v2/functional/_misc.py

@@ -110,7 +110,7 @@ def _validate_kernel_size_and_sigma(
     kernel_size: Sequence[int] | int,
     sigma: Sequence[float | int] | float | int | None = None,
 ) -> tuple[list[int], list[float]]:
-    # TODO: consider deprecating integers from sigma on the future
+    # duplicated logic from gaussian_blur_image for use in gaussian_blur_cvcuda
     if isinstance(kernel_size, int):
         kernel_size = [kernel_size, kernel_size]
     elif len(kernel_size) != 2:
@@ -146,7 +146,33 @@ def _validate_kernel_size_and_sigma(
 def gaussian_blur_image(
     image: torch.Tensor, kernel_size: list[int], sigma: Optional[list[float]] = None
 ) -> torch.Tensor:
-    kernel_size, sigma = _validate_kernel_size_and_sigma(kernel_size, sigma)
+    # TODO: consider deprecating integers from sigma on the future
+    if isinstance(kernel_size, int):
+        kernel_size = [kernel_size, kernel_size]
+    elif len(kernel_size) != 2:
+        raise ValueError(f"If kernel_size is a sequence its length should be 2. Got {len(kernel_size)}")
+    for ksize in kernel_size:
+        if ksize % 2 == 0 or ksize < 0:
+            raise ValueError(f"kernel_size should have odd and positive integers. Got {kernel_size}")
+
+    if sigma is None:
+        sigma = [ksize * 0.15 + 0.35 for ksize in kernel_size]
+    else:
+        if isinstance(sigma, (list, tuple)):
+            length = len(sigma)
+            if length == 1:
+                s = sigma[0]
+                sigma = [s, s]
+            elif length != 2:
+                raise ValueError(f"If sigma is a sequence, its length should be 2. Got {length}")
+        elif isinstance(sigma, (int, float)):
+            s = float(sigma)
+            sigma = [s, s]
+        else:
+            raise TypeError(f"sigma should be either float or sequence of floats. Got {type(sigma)}")
+    for s in sigma:
+        if s <= 0.0:
+            raise ValueError(f"sigma should have positive values. Got {sigma}")
 
     if image.numel() == 0:
         return image
@@ -197,11 +223,11 @@ def gaussian_blur_video(
     return gaussian_blur_image(video, kernel_size, sigma)
 
 
-def gaussian_blur_cvcuda(
-    image: "cvcuda.Tensor",
-    kernel_size: Sequence[int] | int,
-    sigma: Sequence[float | int] | float | int | None = None,
+def _gaussian_blur_cvcuda(
+    image: "cvcuda.Tensor", kernel_size: list[int], sigma: Optional[list[float]] = None
 ) -> "cvcuda.Tensor":
+    cvcuda = _import_cvcuda()
+
     kernel_size, sigma = _validate_kernel_size_and_sigma(kernel_size, sigma)
 
     return cvcuda.gaussian(
@@ -213,7 +239,9 @@ def gaussian_blur_cvcuda(
 
 
 if CVCUDA_AVAILABLE:
-    _gaussian_blur_cvcuda = _register_kernel_internal(gaussian_blur, cvcuda.Tensor)(gaussian_blur_cvcuda)
+    _gaussian_blur_cvcuda_registered = _register_kernel_internal(gaussian_blur, _import_cvcuda().Tensor)(
+        _gaussian_blur_cvcuda
+    )
 
 
 def gaussian_noise(inpt: torch.Tensor, mean: float = 0.0, sigma: float = 0.1, clip: bool = True) -> torch.Tensor: