Fixed implementation and updated tests

Author: vfdev-5

test/test_functional_tensor.py

@@ -678,14 +678,14 @@ def test_rotate(self):
                     batch_tensors, F.rotate, angle=32, resample=0, expand=True, center=center
                 )
 
-    def _test_perspective(self, tensor, pil_img, scripted_tranform, test_configs):
+    def _test_perspective(self, tensor, pil_img, scripted_transform, test_configs):
         dt = tensor.dtype
         for r in [0, ]:
             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)))
 
-                for fn in [F.perspective, scripted_tranform]:
+                for fn in [F.perspective, scripted_transform]:
                     out_tensor = fn(tensor, startpoints=spoints, endpoints=epoints, interpolation=r).cpu()
 
                     if out_tensor.dtype != torch.uint8:
@@ -710,7 +710,7 @@ def test_perspective(self):
         from torchvision.transforms import RandomPerspective
 
         data = [self._create_data(26, 34, device=self.device), self._create_data(26, 26, device=self.device)]
-        scripted_tranform = torch.jit.script(F.perspective)
+        scripted_transform = torch.jit.script(F.perspective)
 
         for tensor, pil_img in data:
 
@@ -733,7 +733,7 @@ def test_perspective(self):
                 if dt is not None:
                     tensor = tensor.to(dtype=dt)
 
-                self._test_perspective(tensor, pil_img, scripted_tranform, test_configs)
+                self._test_perspective(tensor, pil_img, scripted_transform, test_configs)
 
                 batch_tensors = self._create_data_batch(26, 36, num_samples=4, device=self.device)
                 if dt is not None:
@@ -744,6 +744,114 @@ def test_perspective(self):
                         batch_tensors, F.perspective, startpoints=spoints, endpoints=epoints, interpolation=0
                     )
 
+    def test_gaussian_blur(self):
+        tensor = torch.from_numpy(
+            np.arange(3 * 10 * 12, dtype="uint8").reshape((10, 12, 3))
+        ).permute(2, 0, 1).to(self.device)
+
+        scripted_transform = torch.jit.script(F.gaussian_blur)
+
+        true_cv2_results = {
+            # cv2.GaussianBlur(np_img, ksize=(3, 3), sigmaX=0.8)
+            "3_3_0.8":
+            [19, 20, 21, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
+             43, 44, 45, 46, 47, 48, 49, 49, 50, 51, 37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+             52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 68, 69, 70, 73, 74, 75, 75, 76, 77,
+             78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
+             103, 104, 104, 105, 106, 109, 110, 111, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
+             123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 140, 141,
+             142, 145, 146, 147, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
+             163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 176, 177, 178, 181, 182, 183,
+             183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202,
+             203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 212, 213, 214, 217, 189, 190, 204, 174, 175, 176,
+             162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181,
+             182, 183, 184, 185, 186, 187, 187, 188, 189, 192, 130, 131, 162, 93, 94, 95, 64, 65, 66, 67, 68, 69,
+             70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 89, 90, 91, 94, 66, 67,
+             81, 51, 52, 53, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
+             61, 62, 63, 64, 64, 65, 66, 52, 53, 54, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+             70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 82, 83, 84],
+            # cv2.GaussianBlur(np_img, ksize=(3, 3), sigmaX=0.5)
+            "3_3_0.5":
+            [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
+             35, 36, 37, 38, 39, 40, 40, 41, 42, 37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
+             54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 68, 69, 70, 73, 74, 75, 75, 76, 77, 78, 79, 80,
+             81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 104,
+             105, 106, 109, 110, 111, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
+             127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 140, 141, 142, 145, 146, 147, 147,
+             148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
+             169, 170, 171, 172, 173, 174, 175, 176, 176, 177, 178, 181, 182, 183, 183, 184, 185, 186, 187, 188, 189,
+             190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
+             211, 212, 212, 213, 214, 217, 212, 213, 216, 196, 197, 198, 196, 197, 198, 199, 200, 201, 202, 203, 204,
+             205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 221, 222, 223, 226,
+             184, 185, 207, 48, 49, 50, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+             50, 51, 52, 53, 54, 55, 55, 56, 57, 60, 55, 56, 59, 39, 40, 41, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+             50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 64, 65, 66, 61, 62, 63, 63, 64, 65, 66, 67, 68,
+             69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95
+             ],
+            # cv2.GaussianBlur(np_img, ksize=(3, 5), sigmaX=0.8)
+            "3_5_0.8":
+            [21, 22, 23, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
+             46, 47, 48, 49, 50, 51, 52, 51, 52, 53, 39, 40, 41, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
+             54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 69, 70, 71, 73, 74, 75, 75, 76, 77,
+             78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
+             103, 104, 104, 105, 106, 109, 110, 111, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
+             123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 140, 141,
+             142, 145, 146, 147, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
+             163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 176, 177, 178, 181, 180, 181,
+             182, 179, 180, 181, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196,
+             197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 206, 207, 208, 211, 185, 186, 199, 170, 171, 172,
+             159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
+             179, 180, 181, 182, 183, 184, 184, 185, 186, 189, 129, 130, 161, 95, 96, 97, 67, 68, 69, 70, 71, 72,
+             73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 92, 93, 94, 96, 69, 70,
+             83, 54, 55, 56, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
+             65, 66, 67, 68, 68, 69, 70, 62, 57, 58, 60, 55, 56, 57, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
+             67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 80, 81, 82],
+            # cv2.GaussianBlur(np_img, ksize=(3, 5), sigmaX=0.5)
+            "3_5_0.5":
+            [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
+             34, 35, 36, 37, 38, 39, 40, 40, 41, 42, 37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+             52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 68, 69, 70, 73, 74, 75, 75, 76, 77,
+             78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
+             103, 104, 104, 105, 106, 109, 110, 111, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
+             123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 140, 141,
+             142, 145, 146, 147, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
+             163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 176, 177, 178, 181, 182, 183,
+             183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202,
+             203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 212, 213, 214, 217, 212, 213, 216, 196, 197, 198,
+             196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215,
+             216, 217, 218, 219, 220, 221, 221, 222, 223, 226, 184, 185, 207, 48, 49, 50, 30, 31, 32, 33, 34, 35,
+             36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 55, 56, 57, 60, 55, 56,
+             59, 39, 40, 41, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
+             61, 62, 63, 64, 64, 65, 66, 61, 62, 63, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
+             79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95]
+        }
+
+        for dt in [None, torch.float32, torch.float64, torch.float16]:
+            if dt == torch.float16 and torch.device(self.device).type == "cpu":
+                # skip float16 on CPU case
+                continue
+
+            if dt is not None:
+                tensor = tensor.to(dtype=dt)
+
+            for ksize in [(3, 3), [3, 5]]:
+                for sigma in [[0.5, 0.5], (0.5, 0.5), (0.8, 0.8)]:
+
+                    _ksize = (ksize, ksize) if isinstance(ksize, int) else ksize
+                    _sigma = sigma[0] if sigma is not None else None
+                    true_out = torch.tensor(
+                        true_cv2_results["{}_{}_{}".format(_ksize[0], _ksize[1], _sigma)]
+                    ).reshape(10, 12, 3).permute(2, 0, 1)
+
+                    for fn in [F.gaussian_blur, scripted_transform]:
+                        out = fn(tensor, kernel_size=ksize, sigma=sigma)
+                        self.assertEqual(true_out.shape, out.shape, msg="{}, {}".format(ksize, sigma))
+                        self.assertLessEqual(
+                            torch.max(true_out.float() - out.float()),
+                            1.0,
+                            msg="{}, {}".format(ksize, sigma)
+                        )
+
 
 @unittest.skipIf(not torch.cuda.is_available(), reason="Skip if no CUDA device")
 class CUDATester(Tester):

test/test_transforms_tensor.py

@@ -433,6 +433,24 @@ def test_compose(self):
         with self.assertRaisesRegex(RuntimeError, r"Could not get name of python class object"):
             torch.jit.script(t)
 
+    def test_gaussian_blur(self):
+
+        tol = 1.0 + 1e-10
+        self._test_class_op(
+            "GaussianBlur", meth_kwargs={"kernel_size": 3, "sigma": 0.75},
+            test_exact_match=False, agg_method="max", tol=tol
+        )
+
+        self._test_class_op(
+            "GaussianBlur", meth_kwargs={"kernel_size": 23, "sigma": [0.1, 2.0]},
+            test_exact_match=False, agg_method="max", tol=tol
+        )
+
+        self._test_class_op(
+            "GaussianBlur", meth_kwargs={"kernel_size": 23, "sigma": (0.1, 2.0)},
+            test_exact_match=False, agg_method="max", tol=tol
+        )
+
 
 @unittest.skipIf(not torch.cuda.is_available(), reason="Skip if no CUDA device")
 class CUDATester(Tester):

torchvision/transforms/functional.py

@@ -1038,8 +1038,8 @@ def gaussian_blur(img: Tensor, kernel_size: List[int], sigma: Optional[List[floa
         kernel_size (sequence of ints or int): Gaussian kernel size. Can be a sequence of integers
             like ``(kx, ky)`` or a single integer for square kernels.
             In torchscript mode kernel_size as single int is not supported, use a tuple or
-            list of length 1: ``[size, ]``.
-        sigma (sequence of floats or float or None, optional): Gaussian kernel standard deviation. Can be a
+            list of length 1: ``[ksize, ]``.
+        sigma (sequence of floats or float, optional): Gaussian kernel standard deviation. Can be a
             sequence of floats like ``(sigma_x, sigma_y)`` or a single float to define the
             same sigma in both X/Y directions. If None, then it is computed using
             ``kernel_size`` as ``sigma = 0.3 * ((kernel_size - 1) * 0.5 - 1) + 0.8``.
@@ -1049,17 +1049,40 @@ def gaussian_blur(img: Tensor, kernel_size: List[int], sigma: Optional[List[floa
     Returns:
         PIL Image or Tensor: Gaussian Blurred version of the image.
     """
-    is_pil_image = False
+    if not isinstance(kernel_size, (int, list, tuple)):
+        raise TypeError('kernel_size should be int or a sequence of integers. Got {}'.format(type(kernel_size)))
+    if isinstance(kernel_size, int):
+        kernel_size = [kernel_size, kernel_size]
+    if len(kernel_size) != 2:
+        raise ValueError('If kernel_size is a sequence its length should be 2. Got {}'.format(len(kernel_size)))
+    for ksize in kernel_size:
+        if ksize % 2 == 0 or ksize < 0:
+            raise ValueError('kernel_size should have odd and positive integers. Got {}'.format(kernel_size))
+
+    if sigma is None:
+        sigma = [ksize * 0.15 + 0.35 for ksize in kernel_size]
+
+    if sigma is not None and not isinstance(sigma, (float, list, tuple)):
+        raise TypeError('sigma should be either float or sequence of floats. Got {}'.format(type(sigma)))
+    if isinstance(sigma, float):
+        sigma = [sigma, sigma]
+    if isinstance(sigma, (list, tuple)) and len(sigma) == 1:
+        sigma = [sigma[0], sigma[0]]
+    if len(sigma) != 2:
+        raise ValueError('If sigma is a sequence, its length should be 2. Got {}'.format(len(sigma)))
+    for s in sigma:
+        if s <= 0.:
+            raise ValueError('sigma should have positive values. Got {}'.format(sigma))
+
     t_img = img
     if not isinstance(img, torch.Tensor):
         if not F_pil._is_pil_image(img):
             raise TypeError('img should be PIL Image or Tensor. Got {}'.format(type(img)))
 
-        is_pil_image = True
         t_img = to_tensor(img)
 
     output = F_t.gaussian_blur(t_img, kernel_size, sigma)
 
-    if is_pil_image:
+    if not isinstance(img, torch.Tensor):
         output = to_pil_image(output)
     return output