From 58148cae20deec0ed20c03ab767c586699d47b19 Mon Sep 17 00:00:00 2001 From: vivekkumar7089 Date: Mon, 7 Jun 2021 15:55:27 +0530 Subject: [PATCH 1/3] port test_functional_tensor to pytest --- test/test_functional_tensor.py | 322 +++++++++++++++++---------------- 1 file changed, 167 insertions(+), 155 deletions(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index 0329542981e..725dadce63b 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -36,161 +36,6 @@ class Tester(unittest.TestCase): def setUp(self): self.device = "cpu" - def test_hsv2rgb(self): - scripted_fn = torch.jit.script(F_t._hsv2rgb) - shape = (3, 100, 150) - for _ in range(10): - hsv_img = torch.rand(*shape, dtype=torch.float, device=self.device) - rgb_img = F_t._hsv2rgb(hsv_img) - ft_img = rgb_img.permute(1, 2, 0).flatten(0, 1) - - h, s, v, = hsv_img.unbind(0) - h = h.flatten().cpu().numpy() - s = s.flatten().cpu().numpy() - v = v.flatten().cpu().numpy() - - rgb = [] - for h1, s1, v1 in zip(h, s, v): - rgb.append(colorsys.hsv_to_rgb(h1, s1, v1)) - colorsys_img = torch.tensor(rgb, dtype=torch.float32, device=self.device) - torch.testing.assert_close(ft_img, colorsys_img, rtol=0.0, atol=1e-5) - - s_rgb_img = scripted_fn(hsv_img) - torch.testing.assert_close(rgb_img, s_rgb_img) - - batch_tensors = _create_data_batch(120, 100, num_samples=4, device=self.device).float() - _test_fn_on_batch(batch_tensors, F_t._hsv2rgb) - - def test_rgb2hsv(self): - scripted_fn = torch.jit.script(F_t._rgb2hsv) - shape = (3, 150, 100) - for _ in range(10): - rgb_img = torch.rand(*shape, dtype=torch.float, device=self.device) - hsv_img = F_t._rgb2hsv(rgb_img) - ft_hsv_img = hsv_img.permute(1, 2, 0).flatten(0, 1) - - r, g, b, = rgb_img.unbind(dim=-3) - r = r.flatten().cpu().numpy() - g = g.flatten().cpu().numpy() - b = b.flatten().cpu().numpy() - - hsv = [] - for r1, g1, b1 in zip(r, g, b): - hsv.append(colorsys.rgb_to_hsv(r1, g1, b1)) - - colorsys_img = torch.tensor(hsv, dtype=torch.float32, device=self.device) - - ft_hsv_img_h, ft_hsv_img_sv = torch.split(ft_hsv_img, [1, 2], dim=1) - colorsys_img_h, colorsys_img_sv = torch.split(colorsys_img, [1, 2], dim=1) - - max_diff_h = ((colorsys_img_h * 2 * math.pi).sin() - (ft_hsv_img_h * 2 * math.pi).sin()).abs().max() - max_diff_sv = (colorsys_img_sv - ft_hsv_img_sv).abs().max() - max_diff = max(max_diff_h, max_diff_sv) - self.assertLess(max_diff, 1e-5) - - s_hsv_img = scripted_fn(rgb_img) - torch.testing.assert_close(hsv_img, s_hsv_img, rtol=1e-5, atol=1e-7) - - batch_tensors = _create_data_batch(120, 100, num_samples=4, device=self.device).float() - _test_fn_on_batch(batch_tensors, F_t._rgb2hsv) - - def test_rgb_to_grayscale(self): - script_rgb_to_grayscale = torch.jit.script(F.rgb_to_grayscale) - - img_tensor, pil_img = _create_data(32, 34, device=self.device) - - for num_output_channels in (3, 1): - gray_pil_image = F.rgb_to_grayscale(pil_img, num_output_channels=num_output_channels) - gray_tensor = F.rgb_to_grayscale(img_tensor, num_output_channels=num_output_channels) - - _assert_approx_equal_tensor_to_pil(gray_tensor.float(), gray_pil_image, tol=1.0 + 1e-10, agg_method="max") - - s_gray_tensor = script_rgb_to_grayscale(img_tensor, num_output_channels=num_output_channels) - assert_equal(s_gray_tensor, gray_tensor) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - _test_fn_on_batch(batch_tensors, F.rgb_to_grayscale, num_output_channels=num_output_channels) - - def test_center_crop(self): - script_center_crop = torch.jit.script(F.center_crop) - - img_tensor, pil_img = _create_data(32, 34, device=self.device) - - cropped_pil_image = F.center_crop(pil_img, [10, 11]) - - cropped_tensor = F.center_crop(img_tensor, [10, 11]) - _assert_equal_tensor_to_pil(cropped_tensor, cropped_pil_image) - - cropped_tensor = script_center_crop(img_tensor, [10, 11]) - _assert_equal_tensor_to_pil(cropped_tensor, cropped_pil_image) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - _test_fn_on_batch(batch_tensors, F.center_crop, output_size=[10, 11]) - - def test_five_crop(self): - script_five_crop = torch.jit.script(F.five_crop) - - img_tensor, pil_img = _create_data(32, 34, device=self.device) - - cropped_pil_images = F.five_crop(pil_img, [10, 11]) - - cropped_tensors = F.five_crop(img_tensor, [10, 11]) - for i in range(5): - _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) - - cropped_tensors = script_five_crop(img_tensor, [10, 11]) - for i in range(5): - _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - tuple_transformed_batches = F.five_crop(batch_tensors, [10, 11]) - for i in range(len(batch_tensors)): - img_tensor = batch_tensors[i, ...] - tuple_transformed_imgs = F.five_crop(img_tensor, [10, 11]) - self.assertEqual(len(tuple_transformed_imgs), len(tuple_transformed_batches)) - - for j in range(len(tuple_transformed_imgs)): - true_transformed_img = tuple_transformed_imgs[j] - transformed_img = tuple_transformed_batches[j][i, ...] - assert_equal(true_transformed_img, transformed_img) - - # scriptable function test - s_tuple_transformed_batches = script_five_crop(batch_tensors, [10, 11]) - for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): - assert_equal(transformed_batch, s_transformed_batch) - - def test_ten_crop(self): - script_ten_crop = torch.jit.script(F.ten_crop) - - img_tensor, pil_img = _create_data(32, 34, device=self.device) - - cropped_pil_images = F.ten_crop(pil_img, [10, 11]) - - cropped_tensors = F.ten_crop(img_tensor, [10, 11]) - for i in range(10): - _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) - - cropped_tensors = script_ten_crop(img_tensor, [10, 11]) - for i in range(10): - _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - tuple_transformed_batches = F.ten_crop(batch_tensors, [10, 11]) - for i in range(len(batch_tensors)): - img_tensor = batch_tensors[i, ...] - tuple_transformed_imgs = F.ten_crop(img_tensor, [10, 11]) - self.assertEqual(len(tuple_transformed_imgs), len(tuple_transformed_batches)) - - for j in range(len(tuple_transformed_imgs)): - true_transformed_img = tuple_transformed_imgs[j] - transformed_img = tuple_transformed_batches[j][i, ...] - assert_equal(true_transformed_img, transformed_img) - - # scriptable function test - s_tuple_transformed_batches = script_ten_crop(batch_tensors, [10, 11]) - for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): - assert_equal(transformed_batch, s_transformed_batch) - def _test_rotate_all_options(self, tensor, pil_img, scripted_rotate, centers): img_size = pil_img.size dt = tensor.dtype @@ -1176,5 +1021,172 @@ def test_gaussian_blur(device, image_size, dt, ksize, sigma, fn): ) +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_hsv2rgb(device): + scripted_fn = torch.jit.script(F_t._hsv2rgb) + shape = (3, 100, 150) + for _ in range(10): + hsv_img = torch.rand(*shape, dtype=torch.float, device=device) + rgb_img = F_t._hsv2rgb(hsv_img) + ft_img = rgb_img.permute(1, 2, 0).flatten(0, 1) + + h, s, v, = hsv_img.unbind(0) + h = h.flatten().cpu().numpy() + s = s.flatten().cpu().numpy() + v = v.flatten().cpu().numpy() + + rgb = [] + for h1, s1, v1 in zip(h, s, v): + rgb.append(colorsys.hsv_to_rgb(h1, s1, v1)) + colorsys_img = torch.tensor(rgb, dtype=torch.float32, device=device) + torch.testing.assert_close(ft_img, colorsys_img, rtol=0.0, atol=1e-5) + + s_rgb_img = scripted_fn(hsv_img) + torch.testing.assert_close(rgb_img, s_rgb_img) + + batch_tensors = _create_data_batch(120, 100, num_samples=4, device=device).float() + _test_fn_on_batch(batch_tensors, F_t._hsv2rgb) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_rgb2hsv(device): + scripted_fn = torch.jit.script(F_t._rgb2hsv) + shape = (3, 150, 100) + for _ in range(10): + rgb_img = torch.rand(*shape, dtype=torch.float, device=device) + hsv_img = F_t._rgb2hsv(rgb_img) + ft_hsv_img = hsv_img.permute(1, 2, 0).flatten(0, 1) + + r, g, b, = rgb_img.unbind(dim=-3) + r = r.flatten().cpu().numpy() + g = g.flatten().cpu().numpy() + b = b.flatten().cpu().numpy() + + hsv = [] + for r1, g1, b1 in zip(r, g, b): + hsv.append(colorsys.rgb_to_hsv(r1, g1, b1)) + + colorsys_img = torch.tensor(hsv, dtype=torch.float32, device=device) + + ft_hsv_img_h, ft_hsv_img_sv = torch.split(ft_hsv_img, [1, 2], dim=1) + colorsys_img_h, colorsys_img_sv = torch.split(colorsys_img, [1, 2], dim=1) + + max_diff_h = ((colorsys_img_h * 2 * math.pi).sin() - (ft_hsv_img_h * 2 * math.pi).sin()).abs().max() + max_diff_sv = (colorsys_img_sv - ft_hsv_img_sv).abs().max() + max_diff = max(max_diff_h, max_diff_sv) + assert max_diff < 1e-5 + + s_hsv_img = scripted_fn(rgb_img) + torch.testing.assert_close(hsv_img, s_hsv_img, rtol=1e-5, atol=1e-7) + + batch_tensors = _create_data_batch(120, 100, num_samples=4, device=device).float() + _test_fn_on_batch(batch_tensors, F_t._rgb2hsv) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('num_output_channels', (3, 1)) +def test_rgb_to_grayscale(device, num_output_channels): + script_rgb_to_grayscale = torch.jit.script(F.rgb_to_grayscale) + + img_tensor, pil_img = _create_data(32, 34, device=device) + + gray_pil_image = F.rgb_to_grayscale(pil_img, num_output_channels=num_output_channels) + gray_tensor = F.rgb_to_grayscale(img_tensor, num_output_channels=num_output_channels) + + _assert_approx_equal_tensor_to_pil(gray_tensor.float(), gray_pil_image, tol=1.0 + 1e-10, agg_method="max") + + s_gray_tensor = script_rgb_to_grayscale(img_tensor, num_output_channels=num_output_channels) + assert_equal(s_gray_tensor, gray_tensor) + + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) + _test_fn_on_batch(batch_tensors, F.rgb_to_grayscale, num_output_channels=num_output_channels) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_center_crop(device): + script_center_crop = torch.jit.script(F.center_crop) + + img_tensor, pil_img = _create_data(32, 34, device=device) + + cropped_pil_image = F.center_crop(pil_img, [10, 11]) + + cropped_tensor = F.center_crop(img_tensor, [10, 11]) + _assert_equal_tensor_to_pil(cropped_tensor, cropped_pil_image) + + cropped_tensor = script_center_crop(img_tensor, [10, 11]) + _assert_equal_tensor_to_pil(cropped_tensor, cropped_pil_image) + + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) + _test_fn_on_batch(batch_tensors, F.center_crop, output_size=[10, 11]) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_five_crop(device): + script_five_crop = torch.jit.script(F.five_crop) + + img_tensor, pil_img = _create_data(32, 34, device=device) + + cropped_pil_images = F.five_crop(pil_img, [10, 11]) + + cropped_tensors = F.five_crop(img_tensor, [10, 11]) + for i in range(5): + _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) + + cropped_tensors = script_five_crop(img_tensor, [10, 11]) + for i in range(5): + _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) + + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) + tuple_transformed_batches = F.five_crop(batch_tensors, [10, 11]) + for i in range(len(batch_tensors)): + img_tensor = batch_tensors[i, ...] + tuple_transformed_imgs = F.five_crop(img_tensor, [10, 11]) + assert len(tuple_transformed_imgs) == len(tuple_transformed_batches) + + for j in range(len(tuple_transformed_imgs)): + true_transformed_img = tuple_transformed_imgs[j] + transformed_img = tuple_transformed_batches[j][i, ...] + assert_equal(true_transformed_img, transformed_img) + + # scriptable function test + s_tuple_transformed_batches = script_five_crop(batch_tensors, [10, 11]) + for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): + assert_equal(transformed_batch, s_transformed_batch) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_ten_crop(device): + script_ten_crop = torch.jit.script(F.ten_crop) + + img_tensor, pil_img = _create_data(32, 34, device=device) + + cropped_pil_images = F.ten_crop(pil_img, [10, 11]) + + cropped_tensors = F.ten_crop(img_tensor, [10, 11]) + for i in range(10): + _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) + + cropped_tensors = script_ten_crop(img_tensor, [10, 11]) + for i in range(10): + _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) + + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) + tuple_transformed_batches = F.ten_crop(batch_tensors, [10, 11]) + for i in range(len(batch_tensors)): + img_tensor = batch_tensors[i, ...] + tuple_transformed_imgs = F.ten_crop(img_tensor, [10, 11]) + assert len(tuple_transformed_imgs) == len(tuple_transformed_batches) + + for j in range(len(tuple_transformed_imgs)): + true_transformed_img = tuple_transformed_imgs[j] + transformed_img = tuple_transformed_batches[j][i, ...] + assert_equal(true_transformed_img, transformed_img) + + # scriptable function test + s_tuple_transformed_batches = script_ten_crop(batch_tensors, [10, 11]) + for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): + assert_equal(transformed_batch, s_transformed_batch) + + if __name__ == '__main__': unittest.main() From 339d8bbe028a38be3f9cd5c5da78c3875ae72788 Mon Sep 17 00:00:00 2001 From: vivekkumar7089 Date: Mon, 7 Jun 2021 16:16:49 +0530 Subject: [PATCH 2/3] port test_functional_tensor to pytest --- test/test_functional_tensor.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index 725dadce63b..610e3cedb9b 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -1038,14 +1038,14 @@ def test_hsv2rgb(device): rgb = [] for h1, s1, v1 in zip(h, s, v): rgb.append(colorsys.hsv_to_rgb(h1, s1, v1)) - colorsys_img = torch.tensor(rgb, dtype=torch.float32, device=device) - torch.testing.assert_close(ft_img, colorsys_img, rtol=0.0, atol=1e-5) + colorsys_img = torch.tensor(rgb, dtype=torch.float32, device=device) + torch.testing.assert_close(ft_img, colorsys_img, rtol=0.0, atol=1e-5) - s_rgb_img = scripted_fn(hsv_img) - torch.testing.assert_close(rgb_img, s_rgb_img) + s_rgb_img = scripted_fn(hsv_img) + torch.testing.assert_close(rgb_img, s_rgb_img) - batch_tensors = _create_data_batch(120, 100, num_samples=4, device=device).float() - _test_fn_on_batch(batch_tensors, F_t._hsv2rgb) + batch_tensors = _create_data_batch(120, 100, num_samples=4, device=device).float() + _test_fn_on_batch(batch_tensors, F_t._hsv2rgb) @pytest.mark.parametrize('device', cpu_and_gpu()) @@ -1079,8 +1079,8 @@ def test_rgb2hsv(device): s_hsv_img = scripted_fn(rgb_img) torch.testing.assert_close(hsv_img, s_hsv_img, rtol=1e-5, atol=1e-7) - batch_tensors = _create_data_batch(120, 100, num_samples=4, device=device).float() - _test_fn_on_batch(batch_tensors, F_t._rgb2hsv) + batch_tensors = _create_data_batch(120, 100, num_samples=4, device=device).float() + _test_fn_on_batch(batch_tensors, F_t._rgb2hsv) @pytest.mark.parametrize('device', cpu_and_gpu()) From 41e8235a571f455cb367918420d1638fea4ecb8d Mon Sep 17 00:00:00 2001 From: vivekkumar7089 Date: Mon, 7 Jun 2021 16:48:34 +0530 Subject: [PATCH 3/3] deleted tests --- test/test_functional_tensor.py | 155 --------------------------------- 1 file changed, 155 deletions(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index b7a6e120d0c..d0cb062ec2a 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -120,161 +120,6 @@ def test_rotate(self): res2 = F.rotate(tensor, 45, interpolation=BILINEAR) assert_equal(res1, res2) - def test_hsv2rgb(self): - scripted_fn = torch.jit.script(F_t._hsv2rgb) - shape = (3, 100, 150) - for _ in range(10): - hsv_img = torch.rand(*shape, dtype=torch.float, device=self.device) - rgb_img = F_t._hsv2rgb(hsv_img) - ft_img = rgb_img.permute(1, 2, 0).flatten(0, 1) - - h, s, v, = hsv_img.unbind(0) - h = h.flatten().cpu().numpy() - s = s.flatten().cpu().numpy() - v = v.flatten().cpu().numpy() - - rgb = [] - for h1, s1, v1 in zip(h, s, v): - rgb.append(colorsys.hsv_to_rgb(h1, s1, v1)) - colorsys_img = torch.tensor(rgb, dtype=torch.float32, device=self.device) - torch.testing.assert_close(ft_img, colorsys_img, rtol=0.0, atol=1e-5) - - s_rgb_img = scripted_fn(hsv_img) - torch.testing.assert_close(rgb_img, s_rgb_img) - - batch_tensors = _create_data_batch(120, 100, num_samples=4, device=self.device).float() - _test_fn_on_batch(batch_tensors, F_t._hsv2rgb) - - def test_rgb2hsv(self): - scripted_fn = torch.jit.script(F_t._rgb2hsv) - shape = (3, 150, 100) - for _ in range(10): - rgb_img = torch.rand(*shape, dtype=torch.float, device=self.device) - hsv_img = F_t._rgb2hsv(rgb_img) - ft_hsv_img = hsv_img.permute(1, 2, 0).flatten(0, 1) - - r, g, b, = rgb_img.unbind(dim=-3) - r = r.flatten().cpu().numpy() - g = g.flatten().cpu().numpy() - b = b.flatten().cpu().numpy() - - hsv = [] - for r1, g1, b1 in zip(r, g, b): - hsv.append(colorsys.rgb_to_hsv(r1, g1, b1)) - - colorsys_img = torch.tensor(hsv, dtype=torch.float32, device=self.device) - - ft_hsv_img_h, ft_hsv_img_sv = torch.split(ft_hsv_img, [1, 2], dim=1) - colorsys_img_h, colorsys_img_sv = torch.split(colorsys_img, [1, 2], dim=1) - - max_diff_h = ((colorsys_img_h * 2 * math.pi).sin() - (ft_hsv_img_h * 2 * math.pi).sin()).abs().max() - max_diff_sv = (colorsys_img_sv - ft_hsv_img_sv).abs().max() - max_diff = max(max_diff_h, max_diff_sv) - self.assertLess(max_diff, 1e-5) - - s_hsv_img = scripted_fn(rgb_img) - torch.testing.assert_close(hsv_img, s_hsv_img, rtol=1e-5, atol=1e-7) - - batch_tensors = _create_data_batch(120, 100, num_samples=4, device=self.device).float() - _test_fn_on_batch(batch_tensors, F_t._rgb2hsv) - - def test_rgb_to_grayscale(self): - script_rgb_to_grayscale = torch.jit.script(F.rgb_to_grayscale) - - img_tensor, pil_img = _create_data(32, 34, device=self.device) - - for num_output_channels in (3, 1): - gray_pil_image = F.rgb_to_grayscale(pil_img, num_output_channels=num_output_channels) - gray_tensor = F.rgb_to_grayscale(img_tensor, num_output_channels=num_output_channels) - - _assert_approx_equal_tensor_to_pil(gray_tensor.float(), gray_pil_image, tol=1.0 + 1e-10, agg_method="max") - - s_gray_tensor = script_rgb_to_grayscale(img_tensor, num_output_channels=num_output_channels) - assert_equal(s_gray_tensor, gray_tensor) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - _test_fn_on_batch(batch_tensors, F.rgb_to_grayscale, num_output_channels=num_output_channels) - - def test_center_crop(self): - script_center_crop = torch.jit.script(F.center_crop) - - img_tensor, pil_img = _create_data(32, 34, device=self.device) - - cropped_pil_image = F.center_crop(pil_img, [10, 11]) - - cropped_tensor = F.center_crop(img_tensor, [10, 11]) - _assert_equal_tensor_to_pil(cropped_tensor, cropped_pil_image) - - cropped_tensor = script_center_crop(img_tensor, [10, 11]) - _assert_equal_tensor_to_pil(cropped_tensor, cropped_pil_image) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - _test_fn_on_batch(batch_tensors, F.center_crop, output_size=[10, 11]) - - def test_five_crop(self): - script_five_crop = torch.jit.script(F.five_crop) - - img_tensor, pil_img = _create_data(32, 34, device=self.device) - - cropped_pil_images = F.five_crop(pil_img, [10, 11]) - - cropped_tensors = F.five_crop(img_tensor, [10, 11]) - for i in range(5): - _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) - - cropped_tensors = script_five_crop(img_tensor, [10, 11]) - for i in range(5): - _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - tuple_transformed_batches = F.five_crop(batch_tensors, [10, 11]) - for i in range(len(batch_tensors)): - img_tensor = batch_tensors[i, ...] - tuple_transformed_imgs = F.five_crop(img_tensor, [10, 11]) - self.assertEqual(len(tuple_transformed_imgs), len(tuple_transformed_batches)) - - for j in range(len(tuple_transformed_imgs)): - true_transformed_img = tuple_transformed_imgs[j] - transformed_img = tuple_transformed_batches[j][i, ...] - assert_equal(true_transformed_img, transformed_img) - - # scriptable function test - s_tuple_transformed_batches = script_five_crop(batch_tensors, [10, 11]) - for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): - assert_equal(transformed_batch, s_transformed_batch) - - def test_ten_crop(self): - script_ten_crop = torch.jit.script(F.ten_crop) - - img_tensor, pil_img = _create_data(32, 34, device=self.device) - - cropped_pil_images = F.ten_crop(pil_img, [10, 11]) - - cropped_tensors = F.ten_crop(img_tensor, [10, 11]) - for i in range(10): - _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) - - cropped_tensors = script_ten_crop(img_tensor, [10, 11]) - for i in range(10): - _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - tuple_transformed_batches = F.ten_crop(batch_tensors, [10, 11]) - for i in range(len(batch_tensors)): - img_tensor = batch_tensors[i, ...] - tuple_transformed_imgs = F.ten_crop(img_tensor, [10, 11]) - self.assertEqual(len(tuple_transformed_imgs), len(tuple_transformed_batches)) - - for j in range(len(tuple_transformed_imgs)): - true_transformed_img = tuple_transformed_imgs[j] - transformed_img = tuple_transformed_batches[j][i, ...] - assert_equal(true_transformed_img, transformed_img) - - # scriptable function test - s_tuple_transformed_batches = script_ten_crop(batch_tensors, [10, 11]) - for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): - assert_equal(transformed_batch, s_transformed_batch) - @unittest.skipIf(not torch.cuda.is_available(), reason="Skip if no CUDA device") class CUDATester(Tester):