[BC-breaking] Introduced InterpolationModes and deprecated arguments: resample and fillcolor (#2952)

* Deprecated arguments: resample and fillcolor
Replaced by interpolation and fill

* Updates according to the review

* Added tests to check warnings and asserted BC

* [WIP] Interpolation modes

* Added InterpolationModes enum

* Added supported for int values for interpolation for BC

* Removed useless test code

* Fix flake8

Author: vfdev-5

test/test_functional_tensor.py

@@ -4,16 +4,19 @@
 import math
 
 import numpy as np
-from PIL.Image import NEAREST, BILINEAR, BICUBIC
 
 import torch
 import torchvision.transforms.functional_tensor as F_t
 import torchvision.transforms.functional_pil as F_pil
 import torchvision.transforms.functional as F
+from torchvision.transforms import InterpolationModes
 
 from common_utils import TransformsTester
 
 
+NEAREST, BILINEAR, BICUBIC = InterpolationModes.NEAREST, InterpolationModes.BILINEAR, InterpolationModes.BICUBIC
+
+
 class Tester(TransformsTester):
 
     def setUp(self):
@@ -365,7 +368,7 @@ def test_adjust_gamma(self):
         )
 
     def test_resize(self):
-        script_fn = torch.jit.script(F_t.resize)
+        script_fn = torch.jit.script(F.resize)
         tensor, pil_img = self._create_data(26, 36, device=self.device)
         batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device)
 
@@ -382,14 +385,14 @@ def test_resize(self):
 
             for size in [32, 26, [32, ], [32, 32], (32, 32), [26, 35]]:
                 for interpolation in [BILINEAR, BICUBIC, NEAREST]:
-                    resized_tensor = F_t.resize(tensor, size=size, interpolation=interpolation)
-                    resized_pil_img = F_pil.resize(pil_img, size=size, interpolation=interpolation)
+                    resized_tensor = F.resize(tensor, size=size, interpolation=interpolation)
+                    resized_pil_img = F.resize(pil_img, size=size, interpolation=interpolation)
 
                     self.assertEqual(
                         resized_tensor.size()[1:], resized_pil_img.size[::-1], msg="{}, {}".format(size, interpolation)
                     )
 
-                    if interpolation != NEAREST:
+                    if interpolation not in [NEAREST, ]:
                         # We can not check values if mode = NEAREST, as results are different
                         # E.g. resized_tensor  = [[a, a, b, c, d, d, e, ...]]
                         # E.g. resized_pil_img = [[a, b, c, c, d, e, f, ...]]
@@ -407,24 +410,32 @@ def test_resize(self):
                         script_size = [size, ]
                     else:
                         script_size = size
+
                     resize_result = script_fn(tensor, size=script_size, interpolation=interpolation)
                     self.assertTrue(resized_tensor.equal(resize_result), msg="{}, {}".format(size, interpolation))
 
                     self._test_fn_on_batch(
                         batch_tensors, F.resize, size=script_size, interpolation=interpolation
                     )
 
+        # assert changed type warning
+        with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationModes"):
+            res1 = F.resize(tensor, size=32, interpolation=2)
+            res2 = F.resize(tensor, size=32, interpolation=BILINEAR)
+            self.assertTrue(res1.equal(res2))
+
     def test_resized_crop(self):
         # test values of F.resized_crop in several cases:
         # 1) resize to the same size, crop to the same size => should be identity
         tensor, _ = self._create_data(26, 36, device=self.device)
-        for i in [0, 2, 3]:
-            out_tensor = F.resized_crop(tensor, top=0, left=0, height=26, width=36, size=[26, 36], interpolation=i)
+
+        for mode in [NEAREST, BILINEAR, BICUBIC]:
+            out_tensor = F.resized_crop(tensor, top=0, left=0, height=26, width=36, size=[26, 36], interpolation=mode)
             self.assertTrue(tensor.equal(out_tensor), msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5]))
 
         # 2) resize by half and crop a TL corner
         tensor, _ = self._create_data(26, 36, device=self.device)
-        out_tensor = F.resized_crop(tensor, top=0, left=0, height=20, width=30, size=[10, 15], interpolation=0)
+        out_tensor = F.resized_crop(tensor, top=0, left=0, height=20, width=30, size=[10, 15], interpolation=NEAREST)
         expected_out_tensor = tensor[:, :20:2, :30:2]
         self.assertTrue(
             expected_out_tensor.equal(out_tensor),
@@ -433,17 +444,19 @@ def test_resized_crop(self):
 
         batch_tensors = self._create_data_batch(26, 36, num_samples=4, device=self.device)
         self._test_fn_on_batch(
-            batch_tensors, F.resized_crop, top=1, left=2, height=20, width=30, size=[10, 15], interpolation=0
+            batch_tensors, F.resized_crop, top=1, left=2, height=20, width=30, size=[10, 15], interpolation=NEAREST
         )
 
     def _test_affine_identity_map(self, tensor, scripted_affine):
         # 1) identity map
-        out_tensor = F.affine(tensor, angle=0, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], resample=0)
+        out_tensor = F.affine(tensor, angle=0, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST)
 
         self.assertTrue(
             tensor.equal(out_tensor), msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5])
         )
-        out_tensor = scripted_affine(tensor, angle=0, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], resample=0)
+        out_tensor = scripted_affine(
+            tensor, angle=0, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST
+        )
         self.assertTrue(
             tensor.equal(out_tensor), msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5])
         )
@@ -461,13 +474,13 @@ def _test_affine_square_rotations(self, tensor, pil_img, scripted_affine):
         ]
         for a, true_tensor in test_configs:
             out_pil_img = F.affine(
-                pil_img, angle=a, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], resample=0
+                pil_img, angle=a, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST
             )
             out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1))).to(self.device)
 
             for fn in [F.affine, scripted_affine]:
                 out_tensor = fn(
-                    tensor, angle=a, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], resample=0
+                    tensor, angle=a, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST
                 )
                 if true_tensor is not None:
                     self.assertTrue(
@@ -496,13 +509,13 @@ def _test_affine_rect_rotations(self, tensor, pil_img, scripted_affine):
         for a in test_configs:
 
             out_pil_img = F.affine(
-                pil_img, angle=a, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], resample=0
+                pil_img, angle=a, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST
             )
             out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1)))
 
             for fn in [F.affine, scripted_affine]:
                 out_tensor = fn(
-                    tensor, angle=a, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], resample=0
+                    tensor, angle=a, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST
                 ).cpu()
 
                 if out_tensor.dtype != torch.uint8:
@@ -526,10 +539,10 @@ def _test_affine_translations(self, tensor, pil_img, scripted_affine):
         ]
         for t in test_configs:
 
-            out_pil_img = F.affine(pil_img, angle=0, translate=t, scale=1.0, shear=[0.0, 0.0], resample=0)
+            out_pil_img = F.affine(pil_img, angle=0, translate=t, scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST)
 
             for fn in [F.affine, scripted_affine]:
-                out_tensor = fn(tensor, angle=0, translate=t, scale=1.0, shear=[0.0, 0.0], resample=0)
+                out_tensor = fn(tensor, angle=0, translate=t, scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST)
 
                 if out_tensor.dtype != torch.uint8:
                     out_tensor = out_tensor.to(torch.uint8)
@@ -550,13 +563,13 @@ def _test_affine_all_ops(self, tensor, pil_img, scripted_affine):
             (-45, [-10, -10], 1.2, [4.0, 5.0]),
             (-90, [0, 0], 1.0, [0.0, 0.0]),
         ]
-        for r in [0, ]:
+        for r in [NEAREST, ]:
             for a, t, s, sh in test_configs:
-                out_pil_img = F.affine(pil_img, angle=a, translate=t, scale=s, shear=sh, resample=r)
+                out_pil_img = F.affine(pil_img, angle=a, translate=t, scale=s, shear=sh, interpolation=r)
                 out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1)))
 
                 for fn in [F.affine, scripted_affine]:
-                    out_tensor = fn(tensor, angle=a, translate=t, scale=s, shear=sh, resample=r).cpu()
+                    out_tensor = fn(tensor, angle=a, translate=t, scale=s, shear=sh, interpolation=r).cpu()
 
                     if out_tensor.dtype != torch.uint8:
                         out_tensor = out_tensor.to(torch.uint8)
@@ -605,18 +618,36 @@ def test_affine(self):
                     batch_tensors, F.affine, angle=-43, translate=[-3, 4], scale=1.2, shear=[4.0, 5.0]
                 )
 
+        tensor, pil_img = data[0]
+        # assert deprecation warning and non-BC
+        with self.assertWarnsRegex(UserWarning, r"Argument resample is deprecated and will be removed"):
+            res1 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], resample=2)
+            res2 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=BILINEAR)
+            self.assertTrue(res1.equal(res2))
+
+        # assert changed type warning
+        with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationModes"):
+            res1 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=2)
+            res2 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=BILINEAR)
+            self.assertTrue(res1.equal(res2))
+
+        with self.assertWarnsRegex(UserWarning, r"Argument fillcolor is deprecated and will be removed"):
+            res1 = F.affine(pil_img, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], fillcolor=10)
+            res2 = F.affine(pil_img, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], fill=10)
+            self.assertEqual(res1, res2)
+
     def _test_rotate_all_options(self, tensor, pil_img, scripted_rotate, centers):
         img_size = pil_img.size
         dt = tensor.dtype
-        for r in [0, ]:
+        for r in [NEAREST, ]:
             for a in range(-180, 180, 17):
                 for e in [True, False]:
                     for c in centers:
 
-                        out_pil_img = F.rotate(pil_img, angle=a, resample=r, expand=e, center=c)
+                        out_pil_img = F.rotate(pil_img, angle=a, interpolation=r, expand=e, center=c)
                         out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1)))
                         for fn in [F.rotate, scripted_rotate]:
-                            out_tensor = fn(tensor, angle=a, resample=r, expand=e, center=c).cpu()
+                            out_tensor = fn(tensor, angle=a, interpolation=r, expand=e, center=c).cpu()
 
                             if out_tensor.dtype != torch.uint8:
                                 out_tensor = out_tensor.to(torch.uint8)
@@ -673,12 +704,24 @@ def test_rotate(self):
 
                 center = (20, 22)
                 self._test_fn_on_batch(
-                    batch_tensors, F.rotate, angle=32, resample=0, expand=True, center=center
+                    batch_tensors, F.rotate, angle=32, interpolation=NEAREST, expand=True, center=center
                 )
+        tensor, pil_img = data[0]
+        # assert deprecation warning and non-BC
+        with self.assertWarnsRegex(UserWarning, r"Argument resample is deprecated and will be removed"):
+            res1 = F.rotate(tensor, 45, resample=2)
+            res2 = F.rotate(tensor, 45, interpolation=BILINEAR)
+            self.assertTrue(res1.equal(res2))
+
+        # assert changed type warning
+        with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationModes"):
+            res1 = F.rotate(tensor, 45, interpolation=2)
+            res2 = F.rotate(tensor, 45, interpolation=BILINEAR)
+            self.assertTrue(res1.equal(res2))
 
     def _test_perspective(self, tensor, pil_img, scripted_transform, test_configs):
         dt = tensor.dtype
-        for r in [0, ]:
+        for r in [NEAREST, ]:
             for spoints, epoints in test_configs:
                 out_pil_img = F.perspective(pil_img, startpoints=spoints, endpoints=epoints, interpolation=r)
                 out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1)))
@@ -739,9 +782,17 @@ def test_perspective(self):
 
                 for spoints, epoints in test_configs:
                     self._test_fn_on_batch(
-                        batch_tensors, F.perspective, startpoints=spoints, endpoints=epoints, interpolation=0
+                        batch_tensors, F.perspective, startpoints=spoints, endpoints=epoints, interpolation=NEAREST
                     )
 
+        # assert changed type warning
+        spoints = [[0, 0], [33, 0], [33, 25], [0, 25]]
+        epoints = [[3, 2], [32, 3], [30, 24], [2, 25]]
+        with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationModes"):
+            res1 = F.perspective(tensor, startpoints=spoints, endpoints=epoints, interpolation=2)
+            res2 = F.perspective(tensor, startpoints=spoints, endpoints=epoints, interpolation=BILINEAR)
+            self.assertTrue(res1.equal(res2))
+
     def test_gaussian_blur(self):
         small_image_tensor = torch.from_numpy(
             np.arange(3 * 10 * 12, dtype="uint8").reshape((10, 12, 3))

test/test_transforms.py

@@ -1492,11 +1492,21 @@ def test_random_rotation(self):
 
         t = transforms.RandomRotation((-10, 10))
         angle = t.get_params(t.degrees)
-        self.assertTrue(angle > -10 and angle < 10)
+        self.assertTrue(-10 < angle < 10)
 
         # Checking if RandomRotation can be printed as string
         t.__repr__()
 
+        # assert deprecation warning and non-BC
+        with self.assertWarnsRegex(UserWarning, r"Argument resample is deprecated and will be removed"):
+            t = transforms.RandomRotation((-10, 10), resample=2)
+            self.assertEqual(t.interpolation, transforms.InterpolationModes.BILINEAR)
+
+        # assert changed type warning
+        with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationModes"):
+            t = transforms.RandomRotation((-10, 10), interpolation=2)
+            self.assertEqual(t.interpolation, transforms.InterpolationModes.BILINEAR)
+
     def test_random_affine(self):
 
         with self.assertRaises(ValueError):
@@ -1537,8 +1547,22 @@ def test_random_affine(self):
         # Checking if RandomAffine can be printed as string
         t.__repr__()
 
-        t = transforms.RandomAffine(10, resample=Image.BILINEAR)
-        self.assertIn("Image.BILINEAR", t.__repr__())
+        t = transforms.RandomAffine(10, interpolation=transforms.InterpolationModes.BILINEAR)
+        self.assertIn("bilinear", t.__repr__())
+
+        # assert deprecation warning and non-BC
+        with self.assertWarnsRegex(UserWarning, r"Argument resample is deprecated and will be removed"):
+            t = transforms.RandomAffine(10, resample=2)
+            self.assertEqual(t.interpolation, transforms.InterpolationModes.BILINEAR)
+
+        with self.assertWarnsRegex(UserWarning, r"Argument fillcolor is deprecated and will be removed"):
+            t = transforms.RandomAffine(10, fillcolor=10)
+            self.assertEqual(t.fill, 10)
+
+        # assert changed type warning
+        with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationModes"):
+            t = transforms.RandomAffine(10, interpolation=2)
+            self.assertEqual(t.interpolation, transforms.InterpolationModes.BILINEAR)
 
     def test_to_grayscale(self):
         """Unit tests for grayscale transform"""

test/test_transforms_tensor.py

@@ -2,8 +2,7 @@
 import torch
 from torchvision import transforms as T
 from torchvision.transforms import functional as F
-
-from PIL.Image import NEAREST, BILINEAR, BICUBIC
+from torchvision.transforms import InterpolationModes
 
 import numpy as np
 
@@ -12,6 +11,9 @@
 from common_utils import TransformsTester, get_tmp_dir, int_dtypes, float_dtypes
 
 
+NEAREST, BILINEAR, BICUBIC = InterpolationModes.NEAREST, InterpolationModes.BILINEAR, InterpolationModes.BICUBIC
+
+
 class Tester(TransformsTester):
 
     def setUp(self):
@@ -349,7 +351,7 @@ def test_random_affine(self):
                         for interpolation in [NEAREST, BILINEAR]:
                             transform = T.RandomAffine(
                                 degrees=degrees, translate=translate,
-                                scale=scale, shear=shear, resample=interpolation
+                                scale=scale, shear=shear, interpolation=interpolation
                             )
                             s_transform = torch.jit.script(transform)
 
@@ -368,7 +370,7 @@ def test_random_rotate(self):
                 for degrees in [45, 35.0, (-45, 45), [-90.0, 90.0]]:
                     for interpolation in [NEAREST, BILINEAR]:
                         transform = T.RandomRotation(
-                            degrees=degrees, resample=interpolation, expand=expand, center=center
+                            degrees=degrees, interpolation=interpolation, expand=expand, center=center
                         )
                         s_transform = torch.jit.script(transform)