Expose _get_params() method as make_params()

Author: NicolasHug

references/segmentation/v2_extras.py

@@ -10,7 +10,7 @@ def __init__(self, size, fill=0):
         self.size = size
         self.fill = v2._utils._setup_fill_arg(fill)
 
-    def _get_params(self, sample):
+    def make_params(self, sample):
         _, height, width = v2._utils.query_chw(sample)
         padding = [0, 0, max(self.size - width, 0), max(self.size - height, 0)]
         needs_padding = any(padding)

test/test_prototype_transforms.py

@@ -159,7 +159,7 @@ def test__copy_paste(self, label_type):
 
 
 class TestFixedSizeCrop:
-    def test__get_params(self, mocker):
+    def test_make_params(self, mocker):
         crop_size = (7, 7)
         batch_shape = (10,)
         canvas_size = (11, 5)
@@ -170,7 +170,7 @@ def test__get_params(self, mocker):
             make_image(size=canvas_size, color_space="RGB"),
             make_bounding_boxes(format=BoundingBoxFormat.XYXY, canvas_size=canvas_size, num_boxes=batch_shape[0]),
         ]
-        params = transform._get_params(flat_inputs)
+        params = transform.make_params(flat_inputs)
 
         assert params["needs_crop"]
         assert params["height"] <= crop_size[0]
@@ -191,7 +191,7 @@ def test__transform_culling(self, mocker):
 
         is_valid = torch.randint(0, 2, (batch_size,), dtype=torch.bool)
         mocker.patch(
-            "torchvision.prototype.transforms._geometry.FixedSizeCrop._get_params",
+            "torchvision.prototype.transforms._geometry.FixedSizeCrop.make_params",
             return_value=dict(
                 needs_crop=True,
                 top=0,
@@ -229,7 +229,7 @@ def test__transform_bounding_boxes_clamping(self, mocker):
         canvas_size = (10, 10)
 
         mocker.patch(
-            "torchvision.prototype.transforms._geometry.FixedSizeCrop._get_params",
+            "torchvision.prototype.transforms._geometry.FixedSizeCrop.make_params",
             return_value=dict(
                 needs_crop=True,
                 top=0,

test/test_transforms_v2.py

@@ -1355,7 +1355,7 @@ def test_transform_bounding_boxes_correctness(self, format, center, seed):
         transform = transforms.RandomAffine(**self._CORRECTNESS_TRANSFORM_AFFINE_RANGES, center=center)
 
         torch.manual_seed(seed)
-        params = transform._get_params([bounding_boxes])
+        params = transform.make_params([bounding_boxes])
 
         torch.manual_seed(seed)
         actual = transform(bounding_boxes)
@@ -1369,14 +1369,14 @@ def test_transform_bounding_boxes_correctness(self, format, center, seed):
     @pytest.mark.parametrize("scale", _EXHAUSTIVE_TYPE_TRANSFORM_AFFINE_RANGES["scale"])
     @pytest.mark.parametrize("shear", _EXHAUSTIVE_TYPE_TRANSFORM_AFFINE_RANGES["shear"])
     @pytest.mark.parametrize("seed", list(range(10)))
-    def test_transform_get_params_bounds(self, degrees, translate, scale, shear, seed):
+    def test_transformmake_params_bounds(self, degrees, translate, scale, shear, seed):
         image = make_image()
         height, width = F.get_size(image)
 
         transform = transforms.RandomAffine(degrees=degrees, translate=translate, scale=scale, shear=shear)
 
         torch.manual_seed(seed)
-        params = transform._get_params([image])
+        params = transform.make_params([image])
 
         if isinstance(degrees, (int, float)):
             assert -degrees <= params["angle"] <= degrees
@@ -1783,7 +1783,7 @@ def test_transform_bounding_boxes_correctness(self, format, expand, center, seed
         transform = transforms.RandomRotation(**self._CORRECTNESS_TRANSFORM_AFFINE_RANGES, expand=expand, center=center)
 
         torch.manual_seed(seed)
-        params = transform._get_params([bounding_boxes])
+        params = transform.make_params([bounding_boxes])
 
         torch.manual_seed(seed)
         actual = transform(bounding_boxes)
@@ -1795,11 +1795,11 @@ def test_transform_bounding_boxes_correctness(self, format, expand, center, seed
 
     @pytest.mark.parametrize("degrees", _EXHAUSTIVE_TYPE_TRANSFORM_AFFINE_RANGES["degrees"])
     @pytest.mark.parametrize("seed", list(range(10)))
-    def test_transform_get_params_bounds(self, degrees, seed):
+    def test_transformmake_params_bounds(self, degrees, seed):
         transform = transforms.RandomRotation(degrees=degrees)
 
         torch.manual_seed(seed)
-        params = transform._get_params([])
+        params = transform.make_params([])
 
         if isinstance(degrees, (int, float)):
             assert -degrees <= params["angle"] <= degrees
@@ -2996,7 +2996,7 @@ def test_transform_bounding_boxes_correctness(self, output_size, format, dtype,
 
         with freeze_rng_state():
             torch.manual_seed(seed)
-            params = transform._get_params([bounding_boxes])
+            params = transform.make_params([bounding_boxes])
             assert not params.pop("needs_pad")
             del params["padding"]
             assert params.pop("needs_crop")
@@ -3129,9 +3129,9 @@ def test_transform_image_correctness(self, param, value, dtype, device, seed):
 
         with freeze_rng_state():
             torch.manual_seed(seed)
-            # This emulates the random apply check that happens before _get_params is called
+            # This emulates the random apply check that happens before make_params is called
             torch.rand(1)
-            params = transform._get_params([image])
+            params = transform.make_params([image])
 
             torch.manual_seed(seed)
             actual = transform(image)
@@ -3159,7 +3159,7 @@ def test_transform_errors(self):
         transform = transforms.RandomErasing(value=[1, 2, 3, 4])
 
         with pytest.raises(ValueError, match="If value is a sequence, it should have either a single value"):
-            transform._get_params([make_image()])
+            transform.make_params([make_image()])
 
 
 class TestGaussianBlur:
@@ -3244,9 +3244,9 @@ def test_assertions(self):
             transforms.GaussianBlur(3, sigma={})
 
     @pytest.mark.parametrize("sigma", [10.0, [10.0, 12.0], (10, 12.0), [10]])
-    def test__get_params(self, sigma):
+    def test_make_params(self, sigma):
         transform = transforms.GaussianBlur(3, sigma=sigma)
-        params = transform._get_params([])
+        params = transform.make_params([])
 
         if isinstance(sigma, float):
             assert params["sigma"][0] == params["sigma"][1] == sigma
@@ -5251,7 +5251,7 @@ def test_transform_params_correctness(self, side_range, make_input, device):
         input = make_input()
         height, width = F.get_size(input)
 
-        params = transform._get_params([input])
+        params = transform.make_params([input])
         assert "padding" in params
 
         padding = params["padding"]
@@ -5305,13 +5305,13 @@ def test_transform(self, make_input, device):
 
         check_transform(transforms.ScaleJitter(self.TARGET_SIZE), make_input(self.INPUT_SIZE, device=device))
 
-    def test__get_params(self):
+    def test_make_params(self):
         input_size = self.INPUT_SIZE
         target_size = self.TARGET_SIZE
         scale_range = (0.5, 1.5)
 
         transform = transforms.ScaleJitter(target_size=target_size, scale_range=scale_range)
-        params = transform._get_params([make_image(input_size)])
+        params = transform.make_params([make_image(input_size)])
 
         assert "size" in params
         size = params["size"]
@@ -5580,7 +5580,7 @@ def was_applied(output, inpt):
 class TestRandomIoUCrop:
     @pytest.mark.parametrize("device", cpu_and_cuda())
     @pytest.mark.parametrize("options", [[0.5, 0.9], [2.0]])
-    def test__get_params(self, device, options):
+    def test_make_params(self, device, options):
         orig_h, orig_w = size = (24, 32)
         image = make_image(size)
         bboxes = tv_tensors.BoundingBoxes(
@@ -5596,7 +5596,7 @@ def test__get_params(self, device, options):
         n_samples = 5
         for _ in range(n_samples):
 
-            params = transform._get_params(sample)
+            params = transform.make_params(sample)
 
             if options == [2.0]:
                 assert len(params) == 0
@@ -5622,8 +5622,8 @@ def test__transform_empty_params(self, mocker):
         bboxes = tv_tensors.BoundingBoxes(torch.tensor([[1, 1, 2, 2]]), format="XYXY", canvas_size=(4, 4))
         label = torch.tensor([1])
         sample = [image, bboxes, label]
-        # Let's mock transform._get_params to control the output:
-        transform._get_params = mocker.MagicMock(return_value={})
+        # Let's mock transform.make_params to control the output:
+        transform.make_params = mocker.MagicMock(return_value={})
         output = transform(sample)
         torch.testing.assert_close(output, sample)
 
@@ -5648,7 +5648,7 @@ def test__transform(self, mocker):
         is_within_crop_area = torch.tensor([0, 1, 0, 1, 0, 1], dtype=torch.bool)
 
         params = dict(top=1, left=2, height=12, width=12, is_within_crop_area=is_within_crop_area)
-        transform._get_params = mocker.MagicMock(return_value=params)
+        transform.make_params = mocker.MagicMock(return_value=params)
         output = transform(sample)
 
         # check number of bboxes vs number of labels:
@@ -5662,13 +5662,13 @@ def test__transform(self, mocker):
 
 class TestRandomShortestSize:
     @pytest.mark.parametrize("min_size,max_size", [([5, 9], 20), ([5, 9], None)])
-    def test__get_params(self, min_size, max_size):
+    def test_make_params(self, min_size, max_size):
         canvas_size = (3, 10)
 
         transform = transforms.RandomShortestSize(min_size=min_size, max_size=max_size, antialias=True)
 
         sample = make_image(canvas_size)
-        params = transform._get_params([sample])
+        params = transform.make_params([sample])
 
         assert "size" in params
         size = params["size"]
@@ -5685,14 +5685,14 @@ def test__get_params(self, min_size, max_size):
 
 
 class TestRandomResize:
-    def test__get_params(self):
+    def test_make_params(self):
         min_size = 3
         max_size = 6
 
         transform = transforms.RandomResize(min_size=min_size, max_size=max_size, antialias=True)
 
         for _ in range(10):
-            params = transform._get_params([])
+            params = transform.make_params([])
 
             assert isinstance(params["size"], list) and len(params["size"]) == 1
             size = params["size"][0]
@@ -6148,12 +6148,12 @@ def test_transform_image_correctness(self, quality, color_space, seed):
 
     @pytest.mark.parametrize("quality", [5, (10, 20)])
     @pytest.mark.parametrize("seed", list(range(10)))
-    def test_transform_get_params_bounds(self, quality, seed):
+    def test_transformmake_params_bounds(self, quality, seed):
         transform = transforms.JPEG(quality=quality)
 
         with freeze_rng_state():
             torch.manual_seed(seed)
-            params = transform._get_params([])
+            params = transform.make_params([])
 
         if isinstance(quality, int):
             assert params["quality"] == quality

torchvision/prototype/transforms/_geometry.py

@@ -53,7 +53,7 @@ def _check_inputs(self, flat_inputs: List[Any]) -> None:
                 f"{type(self).__name__}() also requires it to contain a Label or OneHotLabel."
             )
 
-    def _get_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
+    def make_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
         height, width = query_size(flat_inputs)
         new_height = min(height, self.crop_height)
         new_width = min(width, self.crop_width)

torchvision/transforms/v2/_augment.py

@@ -96,7 +96,7 @@ def _call_kernel(self, functional: Callable, inpt: Any, *args: Any, **kwargs: An
             )
         return super()._call_kernel(functional, inpt, *args, **kwargs)
 
-    def _get_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
+    def make_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
         img_c, img_h, img_w = query_chw(flat_inputs)
 
         if self.value is not None and not (len(self.value) in (1, img_c)):
@@ -181,7 +181,7 @@ def forward(self, *inputs):
         params = {
             "labels": labels,
             "batch_size": labels.shape[0],
-            **self._get_params(
+            **self.make_params(
                 [inpt for (inpt, needs_transform) in zip(flat_inputs, needs_transform_list) if needs_transform]
             ),
         }
@@ -243,7 +243,7 @@ class MixUp(_BaseMixUpCutMix):
             It can also be a callable that takes the same input as the transform, and returns the labels.
     """
 
-    def _get_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
+    def make_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
         return dict(lam=float(self._dist.sample(())))  # type: ignore[arg-type]
 
     def _transform(self, inpt: Any, params: Dict[str, Any]) -> Any:
@@ -292,7 +292,7 @@ class CutMix(_BaseMixUpCutMix):
             It can also be a callable that takes the same input as the transform, and returns the labels.
     """
 
-    def _get_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
+    def make_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
         lam = float(self._dist.sample(()))  # type: ignore[arg-type]
 
         H, W = query_size(flat_inputs)
@@ -361,7 +361,7 @@ def __init__(self, quality: Union[int, Sequence[int]]):
 
         self.quality = quality
 
-    def _get_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
+    def make_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
         quality = torch.randint(self.quality[0], self.quality[1] + 1, ()).item()
         return dict(quality=quality)
 

torchvision/transforms/v2/_color.py

@@ -46,7 +46,7 @@ class RandomGrayscale(_RandomApplyTransform):
     def __init__(self, p: float = 0.1) -> None:
         super().__init__(p=p)
 
-    def _get_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
+    def make_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
         num_input_channels, *_ = query_chw(flat_inputs)
         return dict(num_input_channels=num_input_channels)
 
@@ -142,7 +142,7 @@ def _check_input(
     def _generate_value(left: float, right: float) -> float:
         return torch.empty(1).uniform_(left, right).item()
 
-    def _get_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
+    def make_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
         fn_idx = torch.randperm(4)
 
         b = None if self.brightness is None else self._generate_value(self.brightness[0], self.brightness[1])
@@ -173,7 +173,7 @@ def _transform(self, inpt: Any, params: Dict[str, Any]) -> Any:
 class RandomChannelPermutation(Transform):
     """Randomly permute the channels of an image or video"""
 
-    def _get_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
+    def make_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
         num_channels, *_ = query_chw(flat_inputs)
         return dict(permutation=torch.randperm(num_channels))
 
@@ -220,7 +220,7 @@ def __init__(
         self.saturation = saturation
         self.p = p
 
-    def _get_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
+    def make_params(self, flat_inputs: List[Any]) -> Dict[str, Any]:
         num_channels, *_ = query_chw(flat_inputs)
         params: Dict[str, Any] = {
             key: ColorJitter._generate_value(range[0], range[1]) if torch.rand(1) < self.p else None