Merge branch 'main' into port-random-zoom-out

Author: pmeier

references/segmentation/utils.py

@@ -88,7 +88,7 @@ def compute(self):
         return acc_global, acc, iu
 
     def reduce_from_all_processes(self):
-        reduce_across_processes(self.mat)
+        self.mat = reduce_across_processes(self.mat).to(torch.int64)
 
     def __str__(self):
         acc_global, acc, iu = self.compute()

test/test_datasets_download.py

@@ -368,6 +368,7 @@ def url_parametrization(*dataset_urls_and_ids_fns):
     kinetics,
     kitti,
     places365,
+    sbu,
 )
 def test_url_is_accessible(url):
     """
@@ -379,7 +380,6 @@ def test_url_is_accessible(url):
 
 @url_parametrization(
     stanford_cars,  # https://github.com/pytorch/vision/issues/7545
-    sbu,  # https://github.com/pytorch/vision/issues/7964
 )
 @pytest.mark.xfail
 def test_url_is_not_accessible(url):

test/test_onnx.py

@@ -79,7 +79,7 @@ def to_numpy(tensor):
         inputs = list(map(to_numpy, inputs))
         outputs = list(map(to_numpy, outputs))
 
-        ort_session = onnxruntime.InferenceSession(onnx_io.getvalue())
+        ort_session = onnxruntime.InferenceSession(onnx_io.getvalue(), providers=onnxruntime.get_available_providers())
         # compute onnxruntime output prediction
         ort_inputs = {ort_session.get_inputs()[i].name: inpt for i, inpt in enumerate(inputs)}
         ort_outs = ort_session.run(None, ort_inputs)

test/test_transforms_v2.py

@@ -116,11 +116,9 @@ class TestSmoke:
             (transforms.RandAugment(), auto_augment_adapter),
             (transforms.TrivialAugmentWide(), auto_augment_adapter),
             (transforms.ColorJitter(brightness=0.1, contrast=0.2, saturation=0.3, hue=0.15), None),
-            (transforms.Grayscale(), None),
             (transforms.RandomAdjustSharpness(sharpness_factor=0.5, p=1.0), None),
             (transforms.RandomAutocontrast(p=1.0), None),
             (transforms.RandomEqualize(p=1.0), None),
-            (transforms.RandomGrayscale(p=1.0), None),
             (transforms.RandomInvert(p=1.0), None),
             (transforms.RandomChannelPermutation(), None),
             (transforms.RandomPhotometricDistort(p=1.0), None),

test/test_transforms_v2_consistency.py

@@ -122,17 +122,6 @@ def __init__(
             (torch.float32, torch.float64),
         ]
     ],
-    ConsistencyConfig(
-        v2_transforms.Grayscale,
-        legacy_transforms.Grayscale,
-        [
-            ArgsKwargs(num_output_channels=1),
-            ArgsKwargs(num_output_channels=3),
-        ],
-        make_images_kwargs=dict(DEFAULT_MAKE_IMAGES_KWARGS, color_spaces=["RGB", "GRAY"]),
-        # Use default tolerances of `torch.testing.assert_close`
-        closeness_kwargs=dict(rtol=None, atol=None),
-    ),
     ConsistencyConfig(
         v2_transforms.ToPILImage,
         legacy_transforms.ToPILImage,
@@ -217,17 +206,6 @@ def __init__(
         ],
         closeness_kwargs={"atol": 1e-6, "rtol": 1e-6},
     ),
-    ConsistencyConfig(
-        v2_transforms.RandomGrayscale,
-        legacy_transforms.RandomGrayscale,
-        [
-            ArgsKwargs(p=0),
-            ArgsKwargs(p=1),
-        ],
-        make_images_kwargs=dict(DEFAULT_MAKE_IMAGES_KWARGS, color_spaces=["RGB", "GRAY"]),
-        # Use default tolerances of `torch.testing.assert_close`
-        closeness_kwargs=dict(rtol=None, atol=None),
-    ),
     ConsistencyConfig(
         v2_transforms.PILToTensor,
         legacy_transforms.PILToTensor,

test/test_transforms_v2_refactored.py

@@ -3947,6 +3947,61 @@ def test_transform_correctness(self, brightness, contrast, saturation, hue):
         assert mae < 2
 
 
+class TestRgbToGrayscale:
+    @pytest.mark.parametrize("dtype", [torch.uint8, torch.float32])
+    @pytest.mark.parametrize("device", cpu_and_cuda())
+    def test_kernel_image(self, dtype, device):
+        check_kernel(F.rgb_to_grayscale_image, make_image(dtype=dtype, device=device))
+
+    @pytest.mark.parametrize("make_input", [make_image_tensor, make_image_pil, make_image])
+    def test_functional(self, make_input):
+        check_functional(F.rgb_to_grayscale, make_input())
+
+    @pytest.mark.parametrize(
+        ("kernel", "input_type"),
+        [
+            (F.rgb_to_grayscale_image, torch.Tensor),
+            (F._rgb_to_grayscale_image_pil, PIL.Image.Image),
+            (F.rgb_to_grayscale_image, tv_tensors.Image),
+        ],
+    )
+    def test_functional_signature(self, kernel, input_type):
+        check_functional_kernel_signature_match(F.rgb_to_grayscale, kernel=kernel, input_type=input_type)
+
+    @pytest.mark.parametrize("transform", [transforms.Grayscale(), transforms.RandomGrayscale(p=1)])
+    @pytest.mark.parametrize("make_input", [make_image_tensor, make_image_pil, make_image])
+    def test_transform(self, transform, make_input):
+        check_transform(transform, make_input())
+
+    @pytest.mark.parametrize("num_output_channels", [1, 3])
+    @pytest.mark.parametrize("fn", [F.rgb_to_grayscale, transform_cls_to_functional(transforms.Grayscale)])
+    def test_image_correctness(self, num_output_channels, fn):
+        image = make_image(dtype=torch.uint8, device="cpu")
+
+        actual = fn(image, num_output_channels=num_output_channels)
+        expected = F.to_image(F.rgb_to_grayscale(F.to_pil_image(image), num_output_channels=num_output_channels))
+
+        assert_equal(actual, expected, rtol=0, atol=1)
+
+    @pytest.mark.parametrize("num_input_channels", [1, 3])
+    def test_random_transform_correctness(self, num_input_channels):
+        image = make_image(
+            color_space={
+                1: "GRAY",
+                3: "RGB",
+            }[num_input_channels],
+            dtype=torch.uint8,
+            device="cpu",
+        )
+
+        transform = transforms.RandomGrayscale(p=1)
+
+        actual = transform(image)
+        expected = F.to_image(F.rgb_to_grayscale(F.to_pil_image(image), num_output_channels=num_input_channels))
+
+        assert_equal(actual, expected, rtol=0, atol=1)
+
+
 class TestRandomZoomOut:
     @pytest.mark.parametrize(
         "make_input",

torchvision/transforms/functional.py

@@ -1326,7 +1326,7 @@ def erase(img: Tensor, i: int, j: int, h: int, w: int, v: Tensor, inplace: bool
 def gaussian_blur(img: Tensor, kernel_size: List[int], sigma: Optional[List[float]] = None) -> Tensor:
     """Performs Gaussian blurring on the image by given kernel.
     If the image is torch Tensor, it is expected
-    to have [..., H, W] shape, where ... means an arbitrary number of leading dimensions.
+    to have [..., H, W] shape, where ... means at most one leading dimension.
 
     Args:
         img (PIL Image or Tensor): Image to be blurred

torchvision/transforms/transforms.py

@@ -1760,7 +1760,7 @@ def __repr__(self) -> str:
 class GaussianBlur(torch.nn.Module):
     """Blurs image with randomly chosen Gaussian blur.
     If the image is torch Tensor, it is expected
-    to have [..., C, H, W] shape, where ... means an arbitrary number of leading dimensions.
+    to have [..., C, H, W] shape, where ... means at most one leading dimension.
 
     Args:
         kernel_size (int or sequence): Size of the Gaussian kernel.

torchvision/transforms/v2/_type_conversion.py

@@ -79,7 +79,7 @@ def _transform(
 
 
 class ToPureTensor(Transform):
-    """[BETA] Convert all tv_tensors to pure tensors, removing associated metadata (if any).
+    """[BETA] Convert all TVTensors to pure tensors, removing associated metadata (if any).
 
     .. v2betastatus:: ToPureTensor transform