test_transforms.py 81.8 KB
Newer Older
1
import math
2
import os
3
import random
4
import re
5
import textwrap
6
from functools import partial
7
8
9

import numpy as np
import pytest
10
11
import torch
import torchvision.transforms as transforms
12
import torchvision.transforms._functional_tensor as F_t
13
import torchvision.transforms.functional as F
14
from PIL import Image
15
16
from torch._utils_internal import get_file_path_2

17
18
19
20
21
try:
    import accimage
except ImportError:
    accimage = None

22
23
24
25
26
try:
    from scipy import stats
except ImportError:
    stats = None

27
from common_utils import assert_equal, assert_run_python_script, cycle_over, float_dtypes, int_dtypes
28
29


30
GRACE_HOPPER = get_file_path_2(
31
32
    os.path.dirname(os.path.abspath(__file__)), "assets", "encode_jpeg", "grace_hopper_517x606.jpg"
)
33
34


35
def _get_grayscale_test_image(img, fill=None):
36
37
    img = img.convert("L")
    fill = (fill[0],) if isinstance(fill, tuple) else fill
38
39
40
    return img, fill


41
class TestConvertImageDtype:
42
    @pytest.mark.parametrize("input_dtype, output_dtype", cycle_over(float_dtypes()))
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
    def test_float_to_float(self, input_dtype, output_dtype):
        input_image = torch.tensor((0.0, 1.0), dtype=input_dtype)
        transform = transforms.ConvertImageDtype(output_dtype)
        transform_script = torch.jit.script(F.convert_image_dtype)

        output_image = transform(input_image)
        output_image_script = transform_script(input_image, output_dtype)

        torch.testing.assert_close(output_image_script, output_image, rtol=0.0, atol=1e-6)

        actual_min, actual_max = output_image.tolist()
        desired_min, desired_max = 0.0, 1.0

        assert abs(actual_min - desired_min) < 1e-7
        assert abs(actual_max - desired_max) < 1e-7

59
60
    @pytest.mark.parametrize("input_dtype", float_dtypes())
    @pytest.mark.parametrize("output_dtype", int_dtypes())
61
62
63
64
65
66
    def test_float_to_int(self, input_dtype, output_dtype):
        input_image = torch.tensor((0.0, 1.0), dtype=input_dtype)
        transform = transforms.ConvertImageDtype(output_dtype)
        transform_script = torch.jit.script(F.convert_image_dtype)

        if (input_dtype == torch.float32 and output_dtype in (torch.int32, torch.int64)) or (
67
            input_dtype == torch.float64 and output_dtype == torch.int64
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
        ):
            with pytest.raises(RuntimeError):
                transform(input_image)
        else:
            output_image = transform(input_image)
            output_image_script = transform_script(input_image, output_dtype)

            torch.testing.assert_close(output_image_script, output_image, rtol=0.0, atol=1e-6)

            actual_min, actual_max = output_image.tolist()
            desired_min, desired_max = 0, torch.iinfo(output_dtype).max

            assert actual_min == desired_min
            assert actual_max == desired_max

83
84
    @pytest.mark.parametrize("input_dtype", int_dtypes())
    @pytest.mark.parametrize("output_dtype", float_dtypes())
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
    def test_int_to_float(self, input_dtype, output_dtype):
        input_image = torch.tensor((0, torch.iinfo(input_dtype).max), dtype=input_dtype)
        transform = transforms.ConvertImageDtype(output_dtype)
        transform_script = torch.jit.script(F.convert_image_dtype)

        output_image = transform(input_image)
        output_image_script = transform_script(input_image, output_dtype)

        torch.testing.assert_close(output_image_script, output_image, rtol=0.0, atol=1e-6)

        actual_min, actual_max = output_image.tolist()
        desired_min, desired_max = 0.0, 1.0

        assert abs(actual_min - desired_min) < 1e-7
        assert actual_min >= desired_min
        assert abs(actual_max - desired_max) < 1e-7
        assert actual_max <= desired_max

103
    @pytest.mark.parametrize("input_dtype, output_dtype", cycle_over(int_dtypes()))
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
    def test_dtype_int_to_int(self, input_dtype, output_dtype):
        input_max = torch.iinfo(input_dtype).max
        input_image = torch.tensor((0, input_max), dtype=input_dtype)
        output_max = torch.iinfo(output_dtype).max

        transform = transforms.ConvertImageDtype(output_dtype)
        transform_script = torch.jit.script(F.convert_image_dtype)

        output_image = transform(input_image)
        output_image_script = transform_script(input_image, output_dtype)

        torch.testing.assert_close(
            output_image_script,
            output_image,
            rtol=0.0,
            atol=1e-6,
120
            msg=f"{output_image_script} vs {output_image}",
121
122
123
124
125
126
127
128
129
130
131
132
133
134
        )

        actual_min, actual_max = output_image.tolist()
        desired_min, desired_max = 0, output_max

        # see https://github.com/pytorch/vision/pull/2078#issuecomment-641036236 for details
        if input_max >= output_max:
            error_term = 0
        else:
            error_term = 1 - (torch.iinfo(output_dtype).max + 1) // (torch.iinfo(input_dtype).max + 1)

        assert actual_min == desired_min
        assert actual_max == (desired_max + error_term)

135
    @pytest.mark.parametrize("input_dtype, output_dtype", cycle_over(int_dtypes()))
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
    def test_int_to_int_consistency(self, input_dtype, output_dtype):
        input_max = torch.iinfo(input_dtype).max
        input_image = torch.tensor((0, input_max), dtype=input_dtype)

        output_max = torch.iinfo(output_dtype).max
        if output_max <= input_max:
            return

        transform = transforms.ConvertImageDtype(output_dtype)
        inverse_transfrom = transforms.ConvertImageDtype(input_dtype)
        output_image = inverse_transfrom(transform(input_image))

        actual_min, actual_max = output_image.tolist()
        desired_min, desired_max = 0, input_max

        assert actual_min == desired_min
        assert actual_max == desired_max
153

154

155
156
157
@pytest.mark.skipif(accimage is None, reason="accimage not available")
class TestAccImage:
    def test_accimage_to_tensor(self):
158
        trans = transforms.PILToTensor()
159

160
        expected_output = trans(Image.open(GRACE_HOPPER).convert("RGB"))
161
162
163
164
165
166
167
        output = trans(accimage.Image(GRACE_HOPPER))

        torch.testing.assert_close(output, expected_output)

    def test_accimage_pil_to_tensor(self):
        trans = transforms.PILToTensor()

168
        expected_output = trans(Image.open(GRACE_HOPPER).convert("RGB"))
169
170
171
        output = trans(accimage.Image(GRACE_HOPPER))

        assert expected_output.size() == output.size()
172
        torch.testing.assert_close(output, expected_output)
173
174

    def test_accimage_resize(self):
175
176
        trans = transforms.Compose(
            [
177
                transforms.Resize(256, interpolation=Image.LINEAR),
178
179
                transforms.PILToTensor(),
                transforms.ConvertImageDtype(dtype=torch.float),
180
181
            ]
        )
182
183
184
185

        # Checking if Compose, Resize and ToTensor can be printed as string
        trans.__repr__()

186
        expected_output = trans(Image.open(GRACE_HOPPER).convert("RGB"))
187
188
189
190
191
192
193
194
195
        output = trans(accimage.Image(GRACE_HOPPER))

        assert expected_output.size() == output.size()
        assert np.abs((expected_output - output).mean()) < 1e-3
        assert (expected_output - output).var() < 1e-5
        # note the high absolute tolerance
        torch.testing.assert_close(output.numpy(), expected_output.numpy(), rtol=1e-5, atol=5e-2)

    def test_accimage_crop(self):
196
        trans = transforms.Compose(
197
            [transforms.CenterCrop(256), transforms.PILToTensor(), transforms.ConvertImageDtype(dtype=torch.float)]
198
        )
199
200
201
202

        # Checking if Compose, CenterCrop and ToTensor can be printed as string
        trans.__repr__()

203
        expected_output = trans(Image.open(GRACE_HOPPER).convert("RGB"))
204
205
206
207
208
209
        output = trans(accimage.Image(GRACE_HOPPER))

        assert expected_output.size() == output.size()
        torch.testing.assert_close(output, expected_output)


210
class TestToTensor:
211
    @pytest.mark.parametrize("channels", [1, 3, 4])
212
213
214
    def test_to_tensor(self, channels):
        height, width = 4, 4
        trans = transforms.ToTensor()
215
        np_rng = np.random.RandomState(0)
216

217
218
219
        input_data = torch.ByteTensor(channels, height, width).random_(0, 255).float().div_(255)
        img = transforms.ToPILImage()(input_data)
        output = trans(img)
220
        torch.testing.assert_close(output, input_data)
221

222
        ndarray = np_rng.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8)
223
224
        output = trans(ndarray)
        expected_output = ndarray.transpose((2, 0, 1)) / 255.0
225
        torch.testing.assert_close(output.numpy(), expected_output, check_dtype=False)
226

227
        ndarray = np_rng.rand(height, width, channels).astype(np.float32)
228
229
        output = trans(ndarray)
        expected_output = ndarray.transpose((2, 0, 1))
230
        torch.testing.assert_close(output.numpy(), expected_output, check_dtype=False)
231
232
233

        # separate test for mode '1' PIL images
        input_data = torch.ByteTensor(1, height, width).bernoulli_()
234
        img = transforms.ToPILImage()(input_data.mul(255)).convert("1")
235
        output = trans(img)
236
        torch.testing.assert_close(input_data, output, check_dtype=False)
237
238
239
240

    def test_to_tensor_errors(self):
        height, width = 4, 4
        trans = transforms.ToTensor()
241
        np_rng = np.random.RandomState(0)
242

243
        with pytest.raises(TypeError):
244
            trans(np_rng.rand(1, height, width).tolist())
245

246
        with pytest.raises(ValueError):
247
            trans(np_rng.rand(height))
248

249
        with pytest.raises(ValueError):
250
            trans(np_rng.rand(1, 1, height, width))
251

252
    @pytest.mark.parametrize("dtype", [torch.float16, torch.float, torch.double])
253
    def test_to_tensor_with_other_default_dtypes(self, dtype):
254
        np_rng = np.random.RandomState(0)
255
        current_def_dtype = torch.get_default_dtype()
256

257
        t = transforms.ToTensor()
258
        np_arr = np_rng.randint(0, 255, (32, 32, 3), dtype=np.uint8)
259
        img = Image.fromarray(np_arr)
260

261
262
263
        torch.set_default_dtype(dtype)
        res = t(img)
        assert res.dtype == dtype, f"{res.dtype} vs {dtype}"
264

265
        torch.set_default_dtype(current_def_dtype)
266

267
    @pytest.mark.parametrize("channels", [1, 3, 4])
268
269
270
    def test_pil_to_tensor(self, channels):
        height, width = 4, 4
        trans = transforms.PILToTensor()
271
        np_rng = np.random.RandomState(0)
272

273
274
275
        input_data = torch.ByteTensor(channels, height, width).random_(0, 255)
        img = transforms.ToPILImage()(input_data)
        output = trans(img)
276
        torch.testing.assert_close(input_data, output)
277

278
        input_data = np_rng.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8)
279
280
281
282
283
        img = transforms.ToPILImage()(input_data)
        output = trans(img)
        expected_output = input_data.transpose((2, 0, 1))
        torch.testing.assert_close(output.numpy(), expected_output)

284
        input_data = torch.as_tensor(np_rng.rand(channels, height, width).astype(np.float32))
285
286
287
        img = transforms.ToPILImage()(input_data)  # CHW -> HWC and (* 255).byte()
        output = trans(img)  # HWC -> CHW
        expected_output = (input_data * 255).byte()
288
        torch.testing.assert_close(output, expected_output)
289

290
291
        # separate test for mode '1' PIL images
        input_data = torch.ByteTensor(1, height, width).bernoulli_()
292
        img = transforms.ToPILImage()(input_data.mul(255)).convert("1")
293
        output = trans(img).view(torch.uint8).bool().to(torch.uint8)
294
        torch.testing.assert_close(input_data, output)
295

296
297
298
    def test_pil_to_tensor_errors(self):
        height, width = 4, 4
        trans = transforms.PILToTensor()
299
        np_rng = np.random.RandomState(0)
300

301
        with pytest.raises(TypeError):
302
            trans(np_rng.rand(1, height, width).tolist())
303

304
        with pytest.raises(TypeError):
305
            trans(np_rng.rand(1, height, width))
306
307


308
309
310
311
312
313
314
315
316
317
318
319
320
321
def test_randomresized_params():
    height = random.randint(24, 32) * 2
    width = random.randint(24, 32) * 2
    img = torch.ones(3, height, width)
    to_pil_image = transforms.ToPILImage()
    img = to_pil_image(img)
    size = 100
    epsilon = 0.05
    min_scale = 0.25
    for _ in range(10):
        scale_min = max(round(random.random(), 2), min_scale)
        scale_range = (scale_min, scale_min + round(random.random(), 2))
        aspect_min = max(round(random.random(), 2), epsilon)
        aspect_ratio_range = (aspect_min, aspect_min + round(random.random(), 2))
322
        randresizecrop = transforms.RandomResizedCrop(size, scale_range, aspect_ratio_range, antialias=True)
323
324
        i, j, h, w = randresizecrop.get_params(img, scale_range, aspect_ratio_range)
        aspect_ratio_obtained = w / h
325
326
327
328
        assert (
            min(aspect_ratio_range) - epsilon <= aspect_ratio_obtained
            and aspect_ratio_obtained <= max(aspect_ratio_range) + epsilon
        ) or aspect_ratio_obtained == 1.0
329
330
331
332
333
334
        assert isinstance(i, int)
        assert isinstance(j, int)
        assert isinstance(h, int)
        assert isinstance(w, int)


335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
@pytest.mark.parametrize(
    "height, width",
    [
        # height, width
        # square image
        (28, 28),
        (27, 27),
        # rectangular image: h < w
        (28, 34),
        (29, 35),
        # rectangular image: h > w
        (34, 28),
        (35, 29),
    ],
)
@pytest.mark.parametrize(
    "osize",
    [
        # single integer
        22,
        27,
        28,
        36,
        # single integer in tuple/list
        [
            22,
        ],
        (27,),
    ],
)
@pytest.mark.parametrize("max_size", (None, 37, 1000))
366
367
368
def test_resize(height, width, osize, max_size):
    img = Image.new("RGB", size=(width, height), color=127)

369
    t = transforms.Resize(osize, max_size=max_size, antialias=True)
370
371
    result = t(img)

372
    msg = f"{height}, {width} - {osize} - {max_size}"
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
    osize = osize[0] if isinstance(osize, (list, tuple)) else osize
    # If size is an int, smaller edge of the image will be matched to this number.
    # i.e, if height > width, then image will be rescaled to (size * height / width, size).
    if height < width:
        exp_w, exp_h = (int(osize * width / height), osize)  # (w, h)
        if max_size is not None and max_size < exp_w:
            exp_w, exp_h = max_size, int(max_size * exp_h / exp_w)
        assert result.size == (exp_w, exp_h), msg
    elif width < height:
        exp_w, exp_h = (osize, int(osize * height / width))  # (w, h)
        if max_size is not None and max_size < exp_h:
            exp_w, exp_h = int(max_size * exp_w / exp_h), max_size
        assert result.size == (exp_w, exp_h), msg
    else:
        exp_w, exp_h = (osize, osize)  # (w, h)
        if max_size is not None and max_size < osize:
            exp_w, exp_h = max_size, max_size
        assert result.size == (exp_w, exp_h), msg


393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
@pytest.mark.parametrize(
    "height, width",
    [
        # height, width
        # square image
        (28, 28),
        (27, 27),
        # rectangular image: h < w
        (28, 34),
        (29, 35),
        # rectangular image: h > w
        (34, 28),
        (35, 29),
    ],
)
@pytest.mark.parametrize(
    "osize",
    [
        # two integers sequence output
        [22, 22],
        [22, 28],
        [22, 36],
        [27, 22],
        [36, 22],
        [28, 28],
        [28, 37],
        [37, 27],
        [37, 37],
    ],
)
423
424
425
426
def test_resize_sequence_output(height, width, osize):
    img = Image.new("RGB", size=(width, height), color=127)
    oheight, owidth = osize

427
    t = transforms.Resize(osize, antialias=True)
428
429
430
431
432
433
434
435
436
437
438
439
440
441
    result = t(img)

    assert (owidth, oheight) == result.size


def test_resize_antialias_error():
    osize = [37, 37]
    img = Image.new("RGB", size=(35, 29), color=127)

    with pytest.warns(UserWarning, match=r"Anti-alias option is always applied for PIL Image input"):
        t = transforms.Resize(osize, antialias=False)
        t(img)


442
443
444
445
446
447
448
449
@pytest.mark.parametrize("height, width", ((32, 64), (64, 32)))
def test_resize_size_equals_small_edge_size(height, width):
    # Non-regression test for https://github.com/pytorch/vision/issues/5405
    # max_size used to be ignored if size == small_edge_size
    max_size = 40
    img = Image.new("RGB", size=(width, height), color=127)

    small_edge = min(height, width)
450
    t = transforms.Resize(small_edge, max_size=max_size, antialias=True)
451
452
453
454
    result = t(img)
    assert max(result.size) == max_size


455
456
457
458
459
460
461
462
463
464
def test_resize_equal_input_output_sizes():
    # Regression test for https://github.com/pytorch/vision/issues/7518
    height, width = 28, 27
    img = Image.new("RGB", size=(width, height))

    t = transforms.Resize((height, width), antialias=True)
    result = t(img)
    assert result is img


465
class TestPad:
466
467
    @pytest.mark.parametrize("fill", [85, 85.0])
    def test_pad(self, fill):
468
469
        height = random.randint(10, 32) * 2
        width = random.randint(10, 32) * 2
470
        img = torch.ones(3, height, width, dtype=torch.uint8)
471
        padding = random.randint(1, 20)
472
473
474
475
        result = transforms.Compose(
            [
                transforms.ToPILImage(),
                transforms.Pad(padding, fill=fill),
476
                transforms.PILToTensor(),
477
478
            ]
        )(img)
479
480
481
482
483
484
        assert result.size(1) == height + 2 * padding
        assert result.size(2) == width + 2 * padding
        # check that all elements in the padded region correspond
        # to the pad value
        h_padded = result[:, :padding, :]
        w_padded = result[:, :, :padding]
485
486
        torch.testing.assert_close(h_padded, torch.full_like(h_padded, fill_value=fill), rtol=0.0, atol=0.0)
        torch.testing.assert_close(w_padded, torch.full_like(w_padded, fill_value=fill), rtol=0.0, atol=0.0)
487
        pytest.raises(ValueError, transforms.Pad(padding, fill=(1, 2)), transforms.ToPILImage()(img))
488
489
490
491
492
493

    def test_pad_with_tuple_of_pad_values(self):
        height = random.randint(10, 32) * 2
        width = random.randint(10, 32) * 2
        img = transforms.ToPILImage()(torch.ones(3, height, width))

494
        padding = tuple(random.randint(1, 20) for _ in range(2))
495
496
497
        output = transforms.Pad(padding)(img)
        assert output.size == (width + padding[0] * 2, height + padding[1] * 2)

498
        padding = [random.randint(1, 20) for _ in range(4)]
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
        output = transforms.Pad(padding)(img)
        assert output.size[0] == width + padding[0] + padding[2]
        assert output.size[1] == height + padding[1] + padding[3]

        # Checking if Padding can be printed as string
        transforms.Pad(padding).__repr__()

    def test_pad_with_non_constant_padding_modes(self):
        """Unit tests for edge, reflect, symmetric padding"""
        img = torch.zeros(3, 27, 27).byte()
        img[:, :, 0] = 1  # Constant value added to leftmost edge
        img = transforms.ToPILImage()(img)
        img = F.pad(img, 1, (200, 200, 200))

        # pad 3 to all sidess
514
        edge_padded_img = F.pad(img, 3, padding_mode="edge")
515
516
517
        # First 6 elements of leftmost edge in the middle of the image, values are in order:
        # edge_pad, edge_pad, edge_pad, constant_pad, constant value added to leftmost edge, 0
        edge_middle_slice = np.asarray(edge_padded_img).transpose(2, 0, 1)[0][17][:6]
518
        assert_equal(edge_middle_slice, np.asarray([200, 200, 200, 200, 1, 0], dtype=np.uint8))
519
        assert transforms.PILToTensor()(edge_padded_img).size() == (3, 35, 35)
520
521

        # Pad 3 to left/right, 2 to top/bottom
522
        reflect_padded_img = F.pad(img, (3, 2), padding_mode="reflect")
523
524
525
        # First 6 elements of leftmost edge in the middle of the image, values are in order:
        # reflect_pad, reflect_pad, reflect_pad, constant_pad, constant value added to leftmost edge, 0
        reflect_middle_slice = np.asarray(reflect_padded_img).transpose(2, 0, 1)[0][17][:6]
526
        assert_equal(reflect_middle_slice, np.asarray([0, 0, 1, 200, 1, 0], dtype=np.uint8))
527
        assert transforms.PILToTensor()(reflect_padded_img).size() == (3, 33, 35)
528
529

        # Pad 3 to left, 2 to top, 2 to right, 1 to bottom
530
        symmetric_padded_img = F.pad(img, (3, 2, 2, 1), padding_mode="symmetric")
531
532
533
        # First 6 elements of leftmost edge in the middle of the image, values are in order:
        # sym_pad, sym_pad, sym_pad, constant_pad, constant value added to leftmost edge, 0
        symmetric_middle_slice = np.asarray(symmetric_padded_img).transpose(2, 0, 1)[0][17][:6]
534
        assert_equal(symmetric_middle_slice, np.asarray([0, 1, 200, 200, 1, 0], dtype=np.uint8))
535
        assert transforms.PILToTensor()(symmetric_padded_img).size() == (3, 32, 34)
536
537
538
539

        # Check negative padding explicitly for symmetric case, since it is not
        # implemented for tensor case to compare to
        # Crop 1 to left, pad 2 to top, pad 3 to right, crop 3 to bottom
540
        symmetric_padded_img_neg = F.pad(img, (-1, 2, 3, -3), padding_mode="symmetric")
541
542
        symmetric_neg_middle_left = np.asarray(symmetric_padded_img_neg).transpose(2, 0, 1)[0][17][:3]
        symmetric_neg_middle_right = np.asarray(symmetric_padded_img_neg).transpose(2, 0, 1)[0][17][-4:]
543
544
        assert_equal(symmetric_neg_middle_left, np.asarray([1, 0, 0], dtype=np.uint8))
        assert_equal(symmetric_neg_middle_right, np.asarray([200, 200, 0, 0], dtype=np.uint8))
545
        assert transforms.PILToTensor()(symmetric_padded_img_neg).size() == (3, 28, 31)
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562

    def test_pad_raises_with_invalid_pad_sequence_len(self):
        with pytest.raises(ValueError):
            transforms.Pad(())

        with pytest.raises(ValueError):
            transforms.Pad((1, 2, 3))

        with pytest.raises(ValueError):
            transforms.Pad((1, 2, 3, 4, 5))

    def test_pad_with_mode_F_images(self):
        pad = 2
        transform = transforms.Pad(pad)

        img = Image.new("F", (10, 10))
        padded_img = transform(img)
563
        assert_equal(padded_img.size, [edge_size + 2 * pad for edge_size in img.size])
564
565


566
@pytest.mark.parametrize(
567
    "fn, trans, kwargs",
568
569
570
571
572
573
574
    [
        (F.invert, transforms.RandomInvert, {}),
        (F.posterize, transforms.RandomPosterize, {"bits": 4}),
        (F.solarize, transforms.RandomSolarize, {"threshold": 192}),
        (F.adjust_sharpness, transforms.RandomAdjustSharpness, {"sharpness_factor": 2.0}),
        (F.autocontrast, transforms.RandomAutocontrast, {}),
        (F.equalize, transforms.RandomEqualize, {}),
575
576
577
        (F.vflip, transforms.RandomVerticalFlip, {}),
        (F.hflip, transforms.RandomHorizontalFlip, {}),
        (partial(F.to_grayscale, num_output_channels=3), transforms.RandomGrayscale, {}),
578
579
    ],
)
580
581
582
583
@pytest.mark.parametrize("seed", range(10))
@pytest.mark.parametrize("p", (0, 1))
def test_randomness(fn, trans, kwargs, seed, p):
    torch.manual_seed(seed)
584
585
    img = transforms.ToPILImage()(torch.rand(3, 16, 18))

586
587
    expected_transformed_img = fn(img, **kwargs)
    randomly_transformed_img = trans(p=p, **kwargs)(img)
588

589
590
591
592
    if p == 0:
        assert randomly_transformed_img == img
    elif p == 1:
        assert randomly_transformed_img == expected_transformed_img
593

594
    trans(**kwargs).__repr__()
595
596


597
598
599
600
601
602
603
604
605
def test_autocontrast_equal_minmax():
    img_tensor = torch.tensor([[[10]], [[128]], [[245]]], dtype=torch.uint8).expand(3, 32, 32)
    img_pil = F.to_pil_image(img_tensor)

    img_tensor = F.autocontrast(img_tensor)
    img_pil = F.autocontrast(img_pil)
    torch.testing.assert_close(img_tensor, F.pil_to_tensor(img_pil))


606
607
608
609
class TestToPil:
    def _get_1_channel_tensor_various_types():
        img_data_float = torch.Tensor(1, 4, 4).uniform_()
        expected_output = img_data_float.mul(255).int().float().div(255).numpy()
610
        yield img_data_float, expected_output, "L"
611

612
613
        img_data_byte = torch.ByteTensor(1, 4, 4).random_(0, 255)
        expected_output = img_data_byte.float().div(255.0).numpy()
614
        yield img_data_byte, expected_output, "L"
615

616
617
        img_data_short = torch.ShortTensor(1, 4, 4).random_()
        expected_output = img_data_short.numpy()
618
        yield img_data_short, expected_output, "I;16"
619

620
621
        img_data_int = torch.IntTensor(1, 4, 4).random_()
        expected_output = img_data_int.numpy()
622
        yield img_data_int, expected_output, "I"
623

624
625
626
    def _get_2d_tensor_various_types():
        img_data_float = torch.Tensor(4, 4).uniform_()
        expected_output = img_data_float.mul(255).int().float().div(255).numpy()
627
        yield img_data_float, expected_output, "L"
628

629
630
        img_data_byte = torch.ByteTensor(4, 4).random_(0, 255)
        expected_output = img_data_byte.float().div(255.0).numpy()
631
        yield img_data_byte, expected_output, "L"
632

633
634
        img_data_short = torch.ShortTensor(4, 4).random_()
        expected_output = img_data_short.numpy()
635
        yield img_data_short, expected_output, "I;16"
636

637
638
        img_data_int = torch.IntTensor(4, 4).random_()
        expected_output = img_data_int.numpy()
639
        yield img_data_int, expected_output, "I"
640

641
642
    @pytest.mark.parametrize("with_mode", [False, True])
    @pytest.mark.parametrize("img_data, expected_output, expected_mode", _get_1_channel_tensor_various_types())
643
644
645
    def test_1_channel_tensor_to_pil_image(self, with_mode, img_data, expected_output, expected_mode):
        transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage()
        to_tensor = transforms.ToTensor()
646

647
        img = transform(img_data)
648
        assert img.mode == expected_mode
649
        torch.testing.assert_close(expected_output, to_tensor(img).numpy())
650

651
652
653
    def test_1_channel_float_tensor_to_pil_image(self):
        img_data = torch.Tensor(1, 4, 4).uniform_()
        # 'F' mode for torch.FloatTensor
654
655
        img_F_mode = transforms.ToPILImage(mode="F")(img_data)
        assert img_F_mode.mode == "F"
656
        torch.testing.assert_close(
657
            np.array(Image.fromarray(img_data.squeeze(0).numpy(), mode="F")), np.array(img_F_mode)
658
        )
659

660
661
662
663
664
665
666
667
668
669
    @pytest.mark.parametrize("with_mode", [False, True])
    @pytest.mark.parametrize(
        "img_data, expected_mode",
        [
            (torch.Tensor(4, 4, 1).uniform_().numpy(), "F"),
            (torch.ByteTensor(4, 4, 1).random_(0, 255).numpy(), "L"),
            (torch.ShortTensor(4, 4, 1).random_().numpy(), "I;16"),
            (torch.IntTensor(4, 4, 1).random_().numpy(), "I"),
        ],
    )
670
671
672
    def test_1_channel_ndarray_to_pil_image(self, with_mode, img_data, expected_mode):
        transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage()
        img = transform(img_data)
673
        assert img.mode == expected_mode
674
675
676
        # note: we explicitly convert img's dtype because pytorch doesn't support uint16
        # and otherwise assert_close wouldn't be able to construct a tensor from the uint16 array
        torch.testing.assert_close(img_data[:, :, 0], np.asarray(img).astype(img_data.dtype))
677

678
    @pytest.mark.parametrize("expected_mode", [None, "LA"])
679
680
    def test_2_channel_ndarray_to_pil_image(self, expected_mode):
        img_data = torch.ByteTensor(4, 4, 2).random_(0, 255).numpy()
681

682
683
        if expected_mode is None:
            img = transforms.ToPILImage()(img_data)
684
            assert img.mode == "LA"  # default should assume LA
685
686
687
688
689
        else:
            img = transforms.ToPILImage(mode=expected_mode)(img_data)
            assert img.mode == expected_mode
        split = img.split()
        for i in range(2):
690
            torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]))
691
692
693
694
695
696
697

    def test_2_channel_ndarray_to_pil_image_error(self):
        img_data = torch.ByteTensor(4, 4, 2).random_(0, 255).numpy()
        transforms.ToPILImage().__repr__()

        # should raise if we try a mode for 4 or 1 or 3 channel images
        with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"):
698
            transforms.ToPILImage(mode="RGBA")(img_data)
699
        with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"):
700
            transforms.ToPILImage(mode="P")(img_data)
701
        with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"):
702
            transforms.ToPILImage(mode="RGB")(img_data)
703

704
    @pytest.mark.parametrize("expected_mode", [None, "LA"])
705
706
707
708
709
    def test_2_channel_tensor_to_pil_image(self, expected_mode):
        img_data = torch.Tensor(2, 4, 4).uniform_()
        expected_output = img_data.mul(255).int().float().div(255)
        if expected_mode is None:
            img = transforms.ToPILImage()(img_data)
710
            assert img.mode == "LA"  # default should assume LA
711
712
713
714
715
716
717
718
719
720
721
722
723
        else:
            img = transforms.ToPILImage(mode=expected_mode)(img_data)
            assert img.mode == expected_mode

        split = img.split()
        for i in range(2):
            torch.testing.assert_close(expected_output[i].numpy(), F.to_tensor(split[i]).squeeze(0).numpy())

    def test_2_channel_tensor_to_pil_image_error(self):
        img_data = torch.Tensor(2, 4, 4).uniform_()

        # should raise if we try a mode for 4 or 1 or 3 channel images
        with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"):
724
            transforms.ToPILImage(mode="RGBA")(img_data)
725
        with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"):
726
            transforms.ToPILImage(mode="P")(img_data)
727
        with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"):
728
            transforms.ToPILImage(mode="RGB")(img_data)
729

730
731
    @pytest.mark.parametrize("with_mode", [False, True])
    @pytest.mark.parametrize("img_data, expected_output, expected_mode", _get_2d_tensor_various_types())
732
733
734
735
736
    def test_2d_tensor_to_pil_image(self, with_mode, img_data, expected_output, expected_mode):
        transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage()
        to_tensor = transforms.ToTensor()

        img = transform(img_data)
737
        assert img.mode == expected_mode
738
739
        torch.testing.assert_close(expected_output, to_tensor(img).numpy()[0])

740
741
742
743
744
745
746
747
748
749
    @pytest.mark.parametrize("with_mode", [False, True])
    @pytest.mark.parametrize(
        "img_data, expected_mode",
        [
            (torch.Tensor(4, 4).uniform_().numpy(), "F"),
            (torch.ByteTensor(4, 4).random_(0, 255).numpy(), "L"),
            (torch.ShortTensor(4, 4).random_().numpy(), "I;16"),
            (torch.IntTensor(4, 4).random_().numpy(), "I"),
        ],
    )
750
751
752
    def test_2d_ndarray_to_pil_image(self, with_mode, img_data, expected_mode):
        transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage()
        img = transform(img_data)
753
        assert img.mode == expected_mode
754
        np.testing.assert_allclose(img_data, img)
755

756
    @pytest.mark.parametrize("expected_mode", [None, "RGB", "HSV", "YCbCr"])
757
758
759
    def test_3_channel_tensor_to_pil_image(self, expected_mode):
        img_data = torch.Tensor(3, 4, 4).uniform_()
        expected_output = img_data.mul(255).int().float().div(255)
760

761
762
        if expected_mode is None:
            img = transforms.ToPILImage()(img_data)
763
            assert img.mode == "RGB"  # default should assume RGB
764
765
766
767
768
769
770
771
772
773
774
775
        else:
            img = transforms.ToPILImage(mode=expected_mode)(img_data)
            assert img.mode == expected_mode
        split = img.split()
        for i in range(3):
            torch.testing.assert_close(expected_output[i].numpy(), F.to_tensor(split[i]).squeeze(0).numpy())

    def test_3_channel_tensor_to_pil_image_error(self):
        img_data = torch.Tensor(3, 4, 4).uniform_()
        error_message_3d = r"Only modes \['RGB', 'YCbCr', 'HSV'\] are supported for 3D inputs"
        # should raise if we try a mode for 4 or 1 or 2 channel images
        with pytest.raises(ValueError, match=error_message_3d):
776
            transforms.ToPILImage(mode="RGBA")(img_data)
777
        with pytest.raises(ValueError, match=error_message_3d):
778
            transforms.ToPILImage(mode="P")(img_data)
779
        with pytest.raises(ValueError, match=error_message_3d):
780
            transforms.ToPILImage(mode="LA")(img_data)
781

782
        with pytest.raises(ValueError, match=r"pic should be 2/3 dimensional. Got \d+ dimensions."):
783
784
            transforms.ToPILImage()(torch.Tensor(1, 3, 4, 4).uniform_())

785
    @pytest.mark.parametrize("expected_mode", [None, "RGB", "HSV", "YCbCr"])
786
787
788
789
790
    def test_3_channel_ndarray_to_pil_image(self, expected_mode):
        img_data = torch.ByteTensor(4, 4, 3).random_(0, 255).numpy()

        if expected_mode is None:
            img = transforms.ToPILImage()(img_data)
791
            assert img.mode == "RGB"  # default should assume RGB
792
793
794
795
796
        else:
            img = transforms.ToPILImage(mode=expected_mode)(img_data)
            assert img.mode == expected_mode
        split = img.split()
        for i in range(3):
797
            torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]))
798
799
800
801
802
803
804
805
806
807

    def test_3_channel_ndarray_to_pil_image_error(self):
        img_data = torch.ByteTensor(4, 4, 3).random_(0, 255).numpy()

        # Checking if ToPILImage can be printed as string
        transforms.ToPILImage().__repr__()

        error_message_3d = r"Only modes \['RGB', 'YCbCr', 'HSV'\] are supported for 3D inputs"
        # should raise if we try a mode for 4 or 1 or 2 channel images
        with pytest.raises(ValueError, match=error_message_3d):
808
            transforms.ToPILImage(mode="RGBA")(img_data)
809
        with pytest.raises(ValueError, match=error_message_3d):
810
            transforms.ToPILImage(mode="P")(img_data)
811
        with pytest.raises(ValueError, match=error_message_3d):
812
            transforms.ToPILImage(mode="LA")(img_data)
813

814
    @pytest.mark.parametrize("expected_mode", [None, "RGBA", "CMYK", "RGBX"])
815
816
817
818
819
820
    def test_4_channel_tensor_to_pil_image(self, expected_mode):
        img_data = torch.Tensor(4, 4, 4).uniform_()
        expected_output = img_data.mul(255).int().float().div(255)

        if expected_mode is None:
            img = transforms.ToPILImage()(img_data)
821
            assert img.mode == "RGBA"  # default should assume RGBA
822
823
824
825
826
827
828
829
830
831
832
833
834
835
        else:
            img = transforms.ToPILImage(mode=expected_mode)(img_data)
            assert img.mode == expected_mode

        split = img.split()
        for i in range(4):
            torch.testing.assert_close(expected_output[i].numpy(), F.to_tensor(split[i]).squeeze(0).numpy())

    def test_4_channel_tensor_to_pil_image_error(self):
        img_data = torch.Tensor(4, 4, 4).uniform_()

        error_message_4d = r"Only modes \['RGBA', 'CMYK', 'RGBX'\] are supported for 4D inputs"
        # should raise if we try a mode for 3 or 1 or 2 channel images
        with pytest.raises(ValueError, match=error_message_4d):
836
            transforms.ToPILImage(mode="RGB")(img_data)
837
        with pytest.raises(ValueError, match=error_message_4d):
838
            transforms.ToPILImage(mode="P")(img_data)
839
        with pytest.raises(ValueError, match=error_message_4d):
840
            transforms.ToPILImage(mode="LA")(img_data)
841

842
    @pytest.mark.parametrize("expected_mode", [None, "RGBA", "CMYK", "RGBX"])
843
844
845
846
847
    def test_4_channel_ndarray_to_pil_image(self, expected_mode):
        img_data = torch.ByteTensor(4, 4, 4).random_(0, 255).numpy()

        if expected_mode is None:
            img = transforms.ToPILImage()(img_data)
848
            assert img.mode == "RGBA"  # default should assume RGBA
849
850
851
852
853
        else:
            img = transforms.ToPILImage(mode=expected_mode)(img_data)
            assert img.mode == expected_mode
        split = img.split()
        for i in range(4):
854
            torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]))
855
856
857
858
859
860
861

    def test_4_channel_ndarray_to_pil_image_error(self):
        img_data = torch.ByteTensor(4, 4, 4).random_(0, 255).numpy()

        error_message_4d = r"Only modes \['RGBA', 'CMYK', 'RGBX'\] are supported for 4D inputs"
        # should raise if we try a mode for 3 or 1 or 2 channel images
        with pytest.raises(ValueError, match=error_message_4d):
862
            transforms.ToPILImage(mode="RGB")(img_data)
863
        with pytest.raises(ValueError, match=error_message_4d):
864
            transforms.ToPILImage(mode="P")(img_data)
865
        with pytest.raises(ValueError, match=error_message_4d):
866
            transforms.ToPILImage(mode="LA")(img_data)
867
868
869

    def test_ndarray_bad_types_to_pil_image(self):
        trans = transforms.ToPILImage()
870
        reg_msg = r"Input type \w+ is not supported"
871
872
873
874
875
876
877
878
879
        with pytest.raises(TypeError, match=reg_msg):
            trans(np.ones([4, 4, 1], np.int64))
        with pytest.raises(TypeError, match=reg_msg):
            trans(np.ones([4, 4, 1], np.uint16))
        with pytest.raises(TypeError, match=reg_msg):
            trans(np.ones([4, 4, 1], np.uint32))
        with pytest.raises(TypeError, match=reg_msg):
            trans(np.ones([4, 4, 1], np.float64))

880
        with pytest.raises(ValueError, match=r"pic should be 2/3 dimensional. Got \d+ dimensions."):
881
            transforms.ToPILImage()(np.ones([1, 4, 4, 3]))
882
        with pytest.raises(ValueError, match=r"pic should not have > 4 channels. Got \d+ channels."):
883
884
885
            transforms.ToPILImage()(np.ones([4, 4, 6]))

    def test_tensor_bad_types_to_pil_image(self):
886
        with pytest.raises(ValueError, match=r"pic should be 2/3 dimensional. Got \d+ dimensions."):
887
            transforms.ToPILImage()(torch.ones(1, 3, 4, 4))
888
        with pytest.raises(ValueError, match=r"pic should not have > 4 channels. Got \d+ channels."):
889
            transforms.ToPILImage()(torch.ones(6, 4, 4))
890
891


892
893
894
895
def test_adjust_brightness():
    x_shape = [2, 2, 3]
    x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]
    x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)
896
    x_pil = Image.fromarray(x_np, mode="RGB")
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921

    # test 0
    y_pil = F.adjust_brightness(x_pil, 1)
    y_np = np.array(y_pil)
    torch.testing.assert_close(y_np, x_np)

    # test 1
    y_pil = F.adjust_brightness(x_pil, 0.5)
    y_np = np.array(y_pil)
    y_ans = [0, 2, 6, 27, 67, 113, 18, 4, 117, 45, 127, 0]
    y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape)
    torch.testing.assert_close(y_np, y_ans)

    # test 2
    y_pil = F.adjust_brightness(x_pil, 2)
    y_np = np.array(y_pil)
    y_ans = [0, 10, 26, 108, 255, 255, 74, 16, 255, 180, 255, 2]
    y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape)
    torch.testing.assert_close(y_np, y_ans)


def test_adjust_contrast():
    x_shape = [2, 2, 3]
    x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]
    x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)
922
    x_pil = Image.fromarray(x_np, mode="RGB")
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947

    # test 0
    y_pil = F.adjust_contrast(x_pil, 1)
    y_np = np.array(y_pil)
    torch.testing.assert_close(y_np, x_np)

    # test 1
    y_pil = F.adjust_contrast(x_pil, 0.5)
    y_np = np.array(y_pil)
    y_ans = [43, 45, 49, 70, 110, 156, 61, 47, 160, 88, 170, 43]
    y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape)
    torch.testing.assert_close(y_np, y_ans)

    # test 2
    y_pil = F.adjust_contrast(x_pil, 2)
    y_np = np.array(y_pil)
    y_ans = [0, 0, 0, 22, 184, 255, 0, 0, 255, 94, 255, 0]
    y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape)
    torch.testing.assert_close(y_np, y_ans)


def test_adjust_hue():
    x_shape = [2, 2, 3]
    x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]
    x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)
948
    x_pil = Image.fromarray(x_np, mode="RGB")
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978

    with pytest.raises(ValueError):
        F.adjust_hue(x_pil, -0.7)
        F.adjust_hue(x_pil, 1)

    # test 0: almost same as x_data but not exact.
    # probably because hsv <-> rgb floating point ops
    y_pil = F.adjust_hue(x_pil, 0)
    y_np = np.array(y_pil)
    y_ans = [0, 5, 13, 54, 139, 226, 35, 8, 234, 91, 255, 1]
    y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape)
    torch.testing.assert_close(y_np, y_ans)

    # test 1
    y_pil = F.adjust_hue(x_pil, 0.25)
    y_np = np.array(y_pil)
    y_ans = [13, 0, 12, 224, 54, 226, 234, 8, 99, 1, 222, 255]
    y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape)
    torch.testing.assert_close(y_np, y_ans)

    # test 2
    y_pil = F.adjust_hue(x_pil, -0.25)
    y_np = np.array(y_pil)
    y_ans = [0, 13, 2, 54, 226, 58, 8, 234, 152, 255, 43, 1]
    y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape)
    torch.testing.assert_close(y_np, y_ans)


def test_adjust_sharpness():
    x_shape = [4, 4, 3]
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
    x_data = [
        75,
        121,
        114,
        105,
        97,
        107,
        105,
        32,
        66,
        111,
        117,
        114,
        99,
        104,
        97,
        0,
        0,
        65,
        108,
        101,
        120,
        97,
        110,
        100,
        101,
        114,
        32,
        86,
        114,
        121,
        110,
        105,
        111,
        116,
        105,
        115,
        0,
        0,
        73,
        32,
        108,
        111,
        118,
        101,
        32,
        121,
        111,
        117,
    ]
1029
    x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)
1030
    x_pil = Image.fromarray(x_np, mode="RGB")
1031
1032
1033
1034
1035
1036
1037
1038
1039

    # test 0
    y_pil = F.adjust_sharpness(x_pil, 1)
    y_np = np.array(y_pil)
    torch.testing.assert_close(y_np, x_np)

    # test 1
    y_pil = F.adjust_sharpness(x_pil, 0.5)
    y_np = np.array(y_pil)
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
    y_ans = [
        75,
        121,
        114,
        105,
        97,
        107,
        105,
        32,
        66,
        111,
        117,
        114,
        99,
        104,
        97,
        30,
        30,
        74,
        103,
        96,
        114,
        97,
        110,
        100,
        101,
        114,
        32,
        81,
        103,
        108,
        102,
        101,
        107,
        116,
        105,
        115,
        0,
        0,
        73,
        32,
        108,
        111,
        118,
        101,
        32,
        121,
        111,
        117,
    ]
1090
1091
1092
1093
1094
1095
    y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape)
    torch.testing.assert_close(y_np, y_ans)

    # test 2
    y_pil = F.adjust_sharpness(x_pil, 2)
    y_np = np.array(y_pil)
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
    y_ans = [
        75,
        121,
        114,
        105,
        97,
        107,
        105,
        32,
        66,
        111,
        117,
        114,
        99,
        104,
        97,
        0,
        0,
        46,
        118,
        111,
        132,
        97,
        110,
        100,
        101,
        114,
        32,
        95,
        135,
        146,
        126,
        112,
        119,
        116,
        105,
        115,
        0,
        0,
        73,
        32,
        108,
        111,
        118,
        101,
        32,
        121,
        111,
        117,
    ]
1146
1147
1148
1149
1150
1151
1152
    y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape)
    torch.testing.assert_close(y_np, y_ans)

    # test 3
    x_shape = [2, 2, 3]
    x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]
    x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)
1153
    x_pil = Image.fromarray(x_np, mode="RGB")
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
    x_th = torch.tensor(x_np.transpose(2, 0, 1))
    y_pil = F.adjust_sharpness(x_pil, 2)
    y_np = np.array(y_pil).transpose(2, 0, 1)
    y_th = F.adjust_sharpness(x_th, 2)
    torch.testing.assert_close(y_np, y_th.numpy())


def test_adjust_gamma():
    x_shape = [2, 2, 3]
    x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]
    x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)
1165
    x_pil = Image.fromarray(x_np, mode="RGB")
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190

    # test 0
    y_pil = F.adjust_gamma(x_pil, 1)
    y_np = np.array(y_pil)
    torch.testing.assert_close(y_np, x_np)

    # test 1
    y_pil = F.adjust_gamma(x_pil, 0.5)
    y_np = np.array(y_pil)
    y_ans = [0, 35, 57, 117, 186, 241, 97, 45, 245, 152, 255, 16]
    y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape)
    torch.testing.assert_close(y_np, y_ans)

    # test 2
    y_pil = F.adjust_gamma(x_pil, 2)
    y_np = np.array(y_pil)
    y_ans = [0, 0, 0, 11, 71, 201, 5, 0, 215, 31, 255, 0]
    y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape)
    torch.testing.assert_close(y_np, y_ans)


def test_adjusts_L_mode():
    x_shape = [2, 2, 3]
    x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]
    x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)
1191
    x_rgb = Image.fromarray(x_np, mode="RGB")
1192

1193
1194
1195
1196
1197
1198
1199
    x_l = x_rgb.convert("L")
    assert F.adjust_brightness(x_l, 2).mode == "L"
    assert F.adjust_saturation(x_l, 2).mode == "L"
    assert F.adjust_contrast(x_l, 2).mode == "L"
    assert F.adjust_hue(x_l, 0.4).mode == "L"
    assert F.adjust_sharpness(x_l, 2).mode == "L"
    assert F.adjust_gamma(x_l, 0.5).mode == "L"
1200
1201


1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
def test_rotate():
    x = np.zeros((100, 100, 3), dtype=np.uint8)
    x[40, 40] = [255, 255, 255]

    with pytest.raises(TypeError, match=r"img should be PIL Image"):
        F.rotate(x, 10)

    img = F.to_pil_image(x)

    result = F.rotate(img, 45)
    assert result.size == (100, 100)
    r, c, ch = np.where(result)
    assert all(x in r for x in [49, 50])
    assert all(x in c for x in [36])
    assert all(x in ch for x in [0, 1, 2])

    result = F.rotate(img, 45, expand=True)
    assert result.size == (142, 142)
    r, c, ch = np.where(result)
    assert all(x in r for x in [70, 71])
    assert all(x in c for x in [57])
    assert all(x in ch for x in [0, 1, 2])

    result = F.rotate(img, 45, center=(40, 40))
    assert result.size == (100, 100)
    r, c, ch = np.where(result)
    assert all(x in r for x in [40])
    assert all(x in c for x in [40])
    assert all(x in ch for x in [0, 1, 2])

    result_a = F.rotate(img, 90)
    result_b = F.rotate(img, -270)

    assert_equal(np.array(result_a), np.array(result_b))


1238
@pytest.mark.parametrize("mode", ["L", "RGB", "F"])
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
def test_rotate_fill(mode):
    img = F.to_pil_image(np.ones((100, 100, 3), dtype=np.uint8) * 255, "RGB")

    num_bands = len(mode)
    wrong_num_bands = num_bands + 1
    fill = 127

    img_conv = img.convert(mode)
    img_rot = F.rotate(img_conv, 45.0, fill=fill)
    pixel = img_rot.getpixel((0, 0))

    if not isinstance(pixel, tuple):
        pixel = (pixel,)
    assert pixel == tuple([fill] * num_bands)

    with pytest.raises(ValueError):
        F.rotate(img_conv, 45.0, fill=tuple([fill] * wrong_num_bands))


def test_gaussian_blur_asserts():
    np_img = np.ones((100, 100, 3), dtype=np.uint8) * 255
    img = F.to_pil_image(np_img, "RGB")

    with pytest.raises(ValueError, match=r"If kernel_size is a sequence its length should be 2"):
        F.gaussian_blur(img, [3])
    with pytest.raises(ValueError, match=r"If kernel_size is a sequence its length should be 2"):
        F.gaussian_blur(img, [3, 3, 3])
    with pytest.raises(ValueError, match=r"Kernel size should be a tuple/list of two integers"):
        transforms.GaussianBlur([3, 3, 3])

    with pytest.raises(ValueError, match=r"kernel_size should have odd and positive integers"):
        F.gaussian_blur(img, [4, 4])
    with pytest.raises(ValueError, match=r"Kernel size value should be an odd and positive number"):
        transforms.GaussianBlur([4, 4])

    with pytest.raises(ValueError, match=r"kernel_size should have odd and positive integers"):
        F.gaussian_blur(img, [-3, -3])
    with pytest.raises(ValueError, match=r"Kernel size value should be an odd and positive number"):
        transforms.GaussianBlur([-3, -3])

    with pytest.raises(ValueError, match=r"If sigma is a sequence, its length should be 2"):
        F.gaussian_blur(img, 3, [1, 1, 1])
    with pytest.raises(ValueError, match=r"sigma should be a single number or a list/tuple with length 2"):
        transforms.GaussianBlur(3, [1, 1, 1])

    with pytest.raises(ValueError, match=r"sigma should have positive values"):
        F.gaussian_blur(img, 3, -1.0)
    with pytest.raises(ValueError, match=r"If sigma is a single number, it must be positive"):
        transforms.GaussianBlur(3, -1.0)

    with pytest.raises(TypeError, match=r"kernel_size should be int or a sequence of integers"):
        F.gaussian_blur(img, "kernel_size_string")
    with pytest.raises(ValueError, match=r"Kernel size should be a tuple/list of two integers"):
        transforms.GaussianBlur("kernel_size_string")

    with pytest.raises(TypeError, match=r"sigma should be either float or sequence of floats"):
        F.gaussian_blur(img, 3, "sigma_string")
    with pytest.raises(ValueError, match=r"sigma should be a single number or a list/tuple with length 2"):
        transforms.GaussianBlur(3, "sigma_string")


def test_lambda():
    trans = transforms.Lambda(lambda x: x.add(10))
    x = torch.randn(10)
    y = trans(x)
    assert_equal(y, torch.add(x, 10))

    trans = transforms.Lambda(lambda x: x.add_(10))
    x = torch.randn(10)
    y = trans(x)
    assert_equal(y, x)

    # Checking if Lambda can be printed as string
    trans.__repr__()


1315
1316
1317
1318
1319
1320
def test_to_grayscale():
    """Unit tests for grayscale transform"""

    x_shape = [2, 2, 3]
    x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]
    x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)
1321
1322
    x_pil = Image.fromarray(x_np, mode="RGB")
    x_pil_2 = x_pil.convert("L")
1323
1324
1325
1326
1327
1328
1329
    gray_np = np.array(x_pil_2)

    # Test Set: Grayscale an image with desired number of output channels
    # Case 1: RGB -> 1 channel grayscale
    trans1 = transforms.Grayscale(num_output_channels=1)
    gray_pil_1 = trans1(x_pil)
    gray_np_1 = np.array(gray_pil_1)
1330
1331
    assert gray_pil_1.mode == "L", "mode should be L"
    assert gray_np_1.shape == tuple(x_shape[0:2]), "should be 1 channel"
1332
1333
1334
1335
1336
1337
    assert_equal(gray_np, gray_np_1)

    # Case 2: RGB -> 3 channel grayscale
    trans2 = transforms.Grayscale(num_output_channels=3)
    gray_pil_2 = trans2(x_pil)
    gray_np_2 = np.array(gray_pil_2)
1338
1339
    assert gray_pil_2.mode == "RGB", "mode should be RGB"
    assert gray_np_2.shape == tuple(x_shape), "should be 3 channel"
1340
1341
    assert_equal(gray_np_2[:, :, 0], gray_np_2[:, :, 1])
    assert_equal(gray_np_2[:, :, 1], gray_np_2[:, :, 2])
1342
    assert_equal(gray_np, gray_np_2[:, :, 0])
1343
1344
1345
1346
1347

    # Case 3: 1 channel grayscale -> 1 channel grayscale
    trans3 = transforms.Grayscale(num_output_channels=1)
    gray_pil_3 = trans3(x_pil_2)
    gray_np_3 = np.array(gray_pil_3)
1348
1349
    assert gray_pil_3.mode == "L", "mode should be L"
    assert gray_np_3.shape == tuple(x_shape[0:2]), "should be 1 channel"
1350
1351
1352
1353
1354
1355
    assert_equal(gray_np, gray_np_3)

    # Case 4: 1 channel grayscale -> 3 channel grayscale
    trans4 = transforms.Grayscale(num_output_channels=3)
    gray_pil_4 = trans4(x_pil_2)
    gray_np_4 = np.array(gray_pil_4)
1356
1357
    assert gray_pil_4.mode == "RGB", "mode should be RGB"
    assert gray_np_4.shape == tuple(x_shape), "should be 3 channel"
1358
1359
    assert_equal(gray_np_4[:, :, 0], gray_np_4[:, :, 1])
    assert_equal(gray_np_4[:, :, 1], gray_np_4[:, :, 2])
1360
    assert_equal(gray_np, gray_np_4[:, :, 0])
1361
1362
1363
1364
1365

    # Checking if Grayscale can be printed as string
    trans4.__repr__()


1366
1367
1368
1369
@pytest.mark.parametrize("seed", range(10))
@pytest.mark.parametrize("p", (0, 1))
def test_random_apply(p, seed):
    torch.manual_seed(seed)
1370
    random_apply_transform = transforms.RandomApply([transforms.RandomRotation((45, 50))], p=p)
1371
1372
1373
1374
1375
1376
    img = transforms.ToPILImage()(torch.rand(3, 30, 40))
    out = random_apply_transform(img)
    if p == 0:
        assert out == img
    elif p == 1:
        assert out != img
1377

1378
1379
    # Checking if RandomApply can be printed as string
    random_apply_transform.__repr__()
1380
1381


1382
1383
1384
1385
@pytest.mark.parametrize("seed", range(10))
@pytest.mark.parametrize("proba_passthrough", (0, 1))
def test_random_choice(proba_passthrough, seed):
    random.seed(seed)  # RandomChoice relies on python builtin random.choice, not pytorch
1386

1387
    random_choice_transform = transforms.RandomChoice(
1388
        [
1389
            lambda x: x,  # passthrough
1390
            transforms.RandomRotation((45, 50)),
1391
        ],
1392
        p=[proba_passthrough, 1 - proba_passthrough],
1393
1394
    )

1395
1396
1397
1398
1399
1400
    img = transforms.ToPILImage()(torch.rand(3, 30, 40))
    out = random_choice_transform(img)
    if proba_passthrough == 1:
        assert out == img
    elif proba_passthrough == 0:
        assert out != img
1401
1402
1403
1404
1405

    # Checking if RandomChoice can be printed as string
    random_choice_transform.__repr__()


1406
@pytest.mark.skipif(stats is None, reason="scipy.stats not available")
1407
1408
1409
def test_random_order():
    random_state = random.getstate()
    random.seed(42)
1410
    random_order_transform = transforms.RandomOrder([transforms.Resize(20, antialias=True), transforms.CenterCrop(10)])
1411
1412
1413
    img = transforms.ToPILImage()(torch.rand(3, 25, 25))
    num_samples = 250
    num_normal_order = 0
1414
    resize_crop_out = transforms.CenterCrop(10)(transforms.Resize(20, antialias=True)(img))
1415
1416
1417
1418
1419
    for _ in range(num_samples):
        out = random_order_transform(img)
        if out == resize_crop_out:
            num_normal_order += 1

1420
    p_value = stats.binomtest(num_normal_order, num_samples, p=0.5).pvalue
1421
1422
1423
1424
1425
1426
1427
    random.setstate(random_state)
    assert p_value > 0.0001

    # Checking if RandomOrder can be printed as string
    random_order_transform.__repr__()


1428
1429
1430
1431
1432
1433
1434
1435
def test_linear_transformation():
    num_samples = 1000
    x = torch.randn(num_samples, 3, 10, 10)
    flat_x = x.view(x.size(0), x.size(1) * x.size(2) * x.size(3))
    # compute principal components
    sigma = torch.mm(flat_x.t(), flat_x) / flat_x.size(0)
    u, s, _ = np.linalg.svd(sigma.numpy())
    zca_epsilon = 1e-10  # avoid division by 0
1436
    d = torch.Tensor(np.diag(1.0 / np.sqrt(s + zca_epsilon)))
1437
1438
    u = torch.Tensor(u)
    principal_components = torch.mm(torch.mm(u, d), u.t())
1439
    mean_vector = torch.sum(flat_x, dim=0) / flat_x.size(0)
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
    # initialize whitening matrix
    whitening = transforms.LinearTransformation(principal_components, mean_vector)
    # estimate covariance and mean using weak law of large number
    num_features = flat_x.size(1)
    cov = 0.0
    mean = 0.0
    for i in x:
        xwhite = whitening(i)
        xwhite = xwhite.view(1, -1).numpy()
        cov += np.dot(xwhite, xwhite.T) / num_features
        mean += np.sum(xwhite) / num_features
    # if rtol for std = 1e-3 then rtol for cov = 2e-3 as std**2 = cov
1452
1453
1454
1455
1456
1457
    torch.testing.assert_close(
        cov / num_samples, np.identity(1), rtol=2e-3, atol=1e-8, check_dtype=False, msg="cov not close to 1"
    )
    torch.testing.assert_close(
        mean / num_samples, 0, rtol=1e-3, atol=1e-8, check_dtype=False, msg="mean not close to 0"
    )
1458
1459
1460
1461
1462

    # Checking if LinearTransformation can be printed as string
    whitening.__repr__()


1463
@pytest.mark.parametrize("dtype", int_dtypes())
1464
1465
1466
1467
1468
1469
1470
1471
1472
def test_max_value(dtype):

    assert F_t._max_value(dtype) == torch.iinfo(dtype).max
    # remove float testing as it can lead to errors such as
    # runtime error: 5.7896e+76 is outside the range of representable values of type 'float'
    # for dtype in float_dtypes():
    # self.assertGreater(F_t._max_value(dtype), torch.finfo(dtype).max)


1473
1474
1475
1476
1477
1478
1479
1480
1481
@pytest.mark.xfail(
    reason="torch.iinfo() is not supported by torchscript. See https://github.com/pytorch/pytorch/issues/41492."
)
def test_max_value_iinfo():
    @torch.jit.script
    def max_value(image: torch.Tensor) -> int:
        return 1 if image.is_floating_point() else torch.iinfo(image.dtype).max


1482
1483
@pytest.mark.parametrize("should_vflip", [True, False])
@pytest.mark.parametrize("single_dim", [True, False])
1484
1485
1486
1487
1488
1489
1490
1491
1492
def test_ten_crop(should_vflip, single_dim):
    to_pil_image = transforms.ToPILImage()
    h = random.randint(5, 25)
    w = random.randint(5, 25)
    crop_h = random.randint(1, h)
    crop_w = random.randint(1, w)
    if single_dim:
        crop_h = min(crop_h, crop_w)
        crop_w = crop_h
1493
        transform = transforms.TenCrop(crop_h, vertical_flip=should_vflip)
1494
1495
        five_crop = transforms.FiveCrop(crop_h)
    else:
1496
        transform = transforms.TenCrop((crop_h, crop_w), vertical_flip=should_vflip)
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
        five_crop = transforms.FiveCrop((crop_h, crop_w))

    img = to_pil_image(torch.FloatTensor(3, h, w).uniform_())
    results = transform(img)
    expected_output = five_crop(img)

    # Checking if FiveCrop and TenCrop can be printed as string
    transform.__repr__()
    five_crop.__repr__()

    if should_vflip:
1508
        vflipped_img = img.transpose(Image.FLIP_TOP_BOTTOM)
1509
1510
        expected_output += five_crop(vflipped_img)
    else:
1511
        hflipped_img = img.transpose(Image.FLIP_LEFT_RIGHT)
1512
1513
1514
1515
1516
1517
        expected_output += five_crop(hflipped_img)

    assert len(results) == 10
    assert results == expected_output


1518
@pytest.mark.parametrize("single_dim", [True, False])
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
def test_five_crop(single_dim):
    to_pil_image = transforms.ToPILImage()
    h = random.randint(5, 25)
    w = random.randint(5, 25)
    crop_h = random.randint(1, h)
    crop_w = random.randint(1, w)
    if single_dim:
        crop_h = min(crop_h, crop_w)
        crop_w = crop_h
        transform = transforms.FiveCrop(crop_h)
    else:
        transform = transforms.FiveCrop((crop_h, crop_w))

    img = torch.FloatTensor(3, h, w).uniform_()

    results = transform(to_pil_image(img))

    assert len(results) == 5
    for crop in results:
        assert crop.size == (crop_w, crop_h)

    to_pil_image = transforms.ToPILImage()
    tl = to_pil_image(img[:, 0:crop_h, 0:crop_w])
1542
1543
1544
    tr = to_pil_image(img[:, 0:crop_h, w - crop_w :])
    bl = to_pil_image(img[:, h - crop_h :, 0:crop_w])
    br = to_pil_image(img[:, h - crop_h :, w - crop_w :])
1545
1546
1547
1548
1549
    center = transforms.CenterCrop((crop_h, crop_w))(to_pil_image(img))
    expected_output = (tl, tr, bl, br, center)
    assert results == expected_output


1550
1551
1552
@pytest.mark.parametrize("policy", transforms.AutoAugmentPolicy)
@pytest.mark.parametrize("fill", [None, 85, (128, 128, 128)])
@pytest.mark.parametrize("grayscale", [True, False])
1553
def test_autoaugment(policy, fill, grayscale):
1554
1555
    random.seed(42)
    img = Image.open(GRACE_HOPPER)
1556
1557
    if grayscale:
        img, fill = _get_grayscale_test_image(img, fill)
1558
1559
1560
1561
1562
1563
    transform = transforms.AutoAugment(policy=policy, fill=fill)
    for _ in range(100):
        img = transform(img)
    transform.__repr__()


1564
1565
1566
1567
@pytest.mark.parametrize("num_ops", [1, 2, 3])
@pytest.mark.parametrize("magnitude", [7, 9, 11])
@pytest.mark.parametrize("fill", [None, 85, (128, 128, 128)])
@pytest.mark.parametrize("grayscale", [True, False])
1568
def test_randaugment(num_ops, magnitude, fill, grayscale):
1569
1570
    random.seed(42)
    img = Image.open(GRACE_HOPPER)
1571
1572
    if grayscale:
        img, fill = _get_grayscale_test_image(img, fill)
1573
1574
1575
1576
1577
1578
    transform = transforms.RandAugment(num_ops=num_ops, magnitude=magnitude, fill=fill)
    for _ in range(100):
        img = transform(img)
    transform.__repr__()


1579
1580
1581
@pytest.mark.parametrize("fill", [None, 85, (128, 128, 128)])
@pytest.mark.parametrize("num_magnitude_bins", [10, 13, 30])
@pytest.mark.parametrize("grayscale", [True, False])
1582
def test_trivialaugmentwide(fill, num_magnitude_bins, grayscale):
1583
1584
    random.seed(42)
    img = Image.open(GRACE_HOPPER)
1585
1586
    if grayscale:
        img, fill = _get_grayscale_test_image(img, fill)
1587
1588
1589
1590
1591
1592
    transform = transforms.TrivialAugmentWide(fill=fill, num_magnitude_bins=num_magnitude_bins)
    for _ in range(100):
        img = transform(img)
    transform.__repr__()


1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
@pytest.mark.parametrize("fill", [None, 85, (128, 128, 128)])
@pytest.mark.parametrize("severity", [1, 10])
@pytest.mark.parametrize("mixture_width", [1, 2])
@pytest.mark.parametrize("chain_depth", [-1, 2])
@pytest.mark.parametrize("all_ops", [True, False])
@pytest.mark.parametrize("grayscale", [True, False])
def test_augmix(fill, severity, mixture_width, chain_depth, all_ops, grayscale):
    random.seed(42)
    img = Image.open(GRACE_HOPPER)
    if grayscale:
        img, fill = _get_grayscale_test_image(img, fill)
    transform = transforms.AugMix(
        fill=fill, severity=severity, mixture_width=mixture_width, chain_depth=chain_depth, all_ops=all_ops
    )
    for _ in range(100):
        img = transform(img)
    transform.__repr__()


1612
1613
1614
1615
1616
def test_random_crop():
    height = random.randint(10, 32) * 2
    width = random.randint(10, 32) * 2
    oheight = random.randint(5, (height - 2) / 2) * 2
    owidth = random.randint(5, (width - 2) / 2) * 2
1617
    img = torch.ones(3, height, width, dtype=torch.uint8)
1618
1619
1620
1621
    result = transforms.Compose(
        [
            transforms.ToPILImage(),
            transforms.RandomCrop((oheight, owidth)),
1622
            transforms.PILToTensor(),
1623
1624
        ]
    )(img)
1625
1626
1627
1628
    assert result.size(1) == oheight
    assert result.size(2) == owidth

    padding = random.randint(1, 20)
1629
1630
1631
1632
    result = transforms.Compose(
        [
            transforms.ToPILImage(),
            transforms.RandomCrop((oheight, owidth), padding=padding),
1633
            transforms.PILToTensor(),
1634
1635
        ]
    )(img)
1636
1637
1638
    assert result.size(1) == oheight
    assert result.size(2) == owidth

1639
    result = transforms.Compose(
1640
        [transforms.ToPILImage(), transforms.RandomCrop((height, width)), transforms.PILToTensor()]
1641
    )(img)
1642
1643
1644
1645
    assert result.size(1) == height
    assert result.size(2) == width
    torch.testing.assert_close(result, img)

1646
1647
1648
1649
    result = transforms.Compose(
        [
            transforms.ToPILImage(),
            transforms.RandomCrop((height + 1, width + 1), pad_if_needed=True),
1650
            transforms.PILToTensor(),
1651
1652
        ]
    )(img)
1653
1654
1655
    assert result.size(1) == height + 1
    assert result.size(2) == width + 1

1656
    t = transforms.RandomCrop(33)
1657
    img = torch.ones(3, 32, 32)
Nicolas Hug's avatar
Nicolas Hug committed
1658
    with pytest.raises(ValueError, match=r"Required crop size .+ is larger than input image size .+"):
1659
1660
1661
        t(img)


1662
1663
1664
1665
1666
1667
def test_center_crop():
    height = random.randint(10, 32) * 2
    width = random.randint(10, 32) * 2
    oheight = random.randint(5, (height - 2) / 2) * 2
    owidth = random.randint(5, (width - 2) / 2) * 2

1668
    img = torch.ones(3, height, width, dtype=torch.uint8)
1669
1670
    oh1 = (height - oheight) // 2
    ow1 = (width - owidth) // 2
1671
    imgnarrow = img[:, oh1 : oh1 + oheight, ow1 : ow1 + owidth]
1672
    imgnarrow.fill_(0)
1673
1674
1675
1676
    result = transforms.Compose(
        [
            transforms.ToPILImage(),
            transforms.CenterCrop((oheight, owidth)),
1677
            transforms.PILToTensor(),
1678
1679
        ]
    )(img)
1680
1681
1682
    assert result.sum() == 0
    oheight += 1
    owidth += 1
1683
1684
1685
1686
    result = transforms.Compose(
        [
            transforms.ToPILImage(),
            transforms.CenterCrop((oheight, owidth)),
1687
            transforms.PILToTensor(),
1688
1689
        ]
    )(img)
1690
1691
1692
1693
    sum1 = result.sum()
    assert sum1 > 1
    oheight += 1
    owidth += 1
1694
1695
1696
1697
    result = transforms.Compose(
        [
            transforms.ToPILImage(),
            transforms.CenterCrop((oheight, owidth)),
1698
            transforms.PILToTensor(),
1699
1700
        ]
    )(img)
1701
1702
1703
1704
1705
    sum2 = result.sum()
    assert sum2 > 0
    assert sum2 > sum1


1706
1707
1708
1709
@pytest.mark.parametrize("odd_image_size", (True, False))
@pytest.mark.parametrize("delta", (1, 3, 5))
@pytest.mark.parametrize("delta_width", (-2, -1, 0, 1, 2))
@pytest.mark.parametrize("delta_height", (-2, -1, 0, 1, 2))
1710
def test_center_crop_2(odd_image_size, delta, delta_width, delta_height):
1711
    """Tests when center crop size is larger than image size, along any dimension"""
1712
1713
1714
1715
1716
1717
1718
1719
1720

    # Since height is independent of width, we can ignore images with odd height and even width and vice-versa.
    input_image_size = (random.randint(10, 32) * 2, random.randint(10, 32) * 2)
    if odd_image_size:
        input_image_size = (input_image_size[0] + 1, input_image_size[1] + 1)

    delta_height *= delta
    delta_width *= delta

1721
    img = torch.ones(3, *input_image_size, dtype=torch.uint8)
1722
1723
1724
    crop_size = (input_image_size[0] + delta_height, input_image_size[1] + delta_width)

    # Test both transforms, one with PIL input and one with tensor
1725
    output_pil = transforms.Compose(
1726
        [transforms.ToPILImage(), transforms.CenterCrop(crop_size), transforms.PILToTensor()],
1727
1728
1729
1730
1731
1732
1733
1734
    )(img)
    assert output_pil.size()[1:3] == crop_size

    output_tensor = transforms.CenterCrop(crop_size)(img)
    assert output_tensor.size()[1:3] == crop_size

    # Ensure output for PIL and Tensor are equal
    assert_equal(
1735
1736
        output_tensor,
        output_pil,
1737
        msg=f"image_size: {input_image_size} crop_size: {crop_size}",
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
    )

    # Check if content in center of both image and cropped output is same.
    center_size = (min(crop_size[0], input_image_size[0]), min(crop_size[1], input_image_size[1]))
    crop_center_tl, input_center_tl = [0, 0], [0, 0]
    for index in range(2):
        if crop_size[index] > input_image_size[index]:
            crop_center_tl[index] = (crop_size[index] - input_image_size[index]) // 2
        else:
            input_center_tl[index] = (input_image_size[index] - crop_size[index]) // 2

    output_center = output_pil[
        :,
1751
1752
        crop_center_tl[0] : crop_center_tl[0] + center_size[0],
        crop_center_tl[1] : crop_center_tl[1] + center_size[1],
1753
1754
1755
1756
    ]

    img_center = img[
        :,
1757
1758
        input_center_tl[0] : input_center_tl[0] + center_size[0],
        input_center_tl[1] : input_center_tl[1] + center_size[1],
1759
1760
    ]

1761
    assert_equal(output_center, img_center)
1762
1763
1764
1765
1766
1767
1768
1769


def test_color_jitter():
    color_jitter = transforms.ColorJitter(2, 2, 2, 0.1)

    x_shape = [2, 2, 3]
    x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]
    x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)
1770
1771
    x_pil = Image.fromarray(x_np, mode="RGB")
    x_pil_2 = x_pil.convert("L")
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783

    for _ in range(10):
        y_pil = color_jitter(x_pil)
        assert y_pil.mode == x_pil.mode

        y_pil_2 = color_jitter(x_pil_2)
        assert y_pil_2.mode == x_pil_2.mode

    # Checking if ColorJitter can be printed as string
    color_jitter.__repr__()


1784
1785
1786
1787
1788
1789
@pytest.mark.parametrize("hue", [1, (-1, 1)])
def test_color_jitter_hue_out_of_bounds(hue):
    with pytest.raises(ValueError, match=re.escape("hue values should be between (-0.5, 0.5)")):
        transforms.ColorJitter(hue=hue)


1790
@pytest.mark.parametrize("seed", range(10))
1791
@pytest.mark.skipif(stats is None, reason="scipy.stats not available")
1792
1793
def test_random_erasing(seed):
    torch.random.manual_seed(seed)
1794
1795
    img = torch.ones(3, 128, 128)

1796
1797
1798
1799
1800
1801
1802
1803
1804
    t = transforms.RandomErasing(scale=(0.1, 0.1), ratio=(1 / 3, 3.0))
    y, x, h, w, v = t.get_params(
        img,
        t.scale,
        t.ratio,
        [
            t.value,
        ],
    )
1805
1806
1807
    aspect_ratio = h / w
    # Add some tolerance due to the rounding and int conversion used in the transform
    tol = 0.05
1808
    assert 1 / 3 - tol <= aspect_ratio <= 3 + tol
1809

1810
    # Make sure that h > w and h < w are equally likely (log-scale sampling)
1811
1812
1813
1814
    aspect_ratios = []
    random.seed(42)
    trial = 1000
    for _ in range(trial):
1815
1816
1817
1818
1819
1820
1821
1822
        y, x, h, w, v = t.get_params(
            img,
            t.scale,
            t.ratio,
            [
                t.value,
            ],
        )
1823
1824
1825
        aspect_ratios.append(h / w)

    count_bigger_then_ones = len([1 for aspect_ratio in aspect_ratios if aspect_ratio > 1])
1826
    p_value = stats.binomtest(count_bigger_then_ones, trial, p=0.5).pvalue
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
    assert p_value > 0.0001

    # Checking if RandomErasing can be printed as string
    t.__repr__()


def test_random_rotation():

    with pytest.raises(ValueError):
        transforms.RandomRotation(-0.7)

    with pytest.raises(ValueError):
        transforms.RandomRotation([-0.7])

    with pytest.raises(ValueError):
        transforms.RandomRotation([-0.7, 0, 0.7])

    t = transforms.RandomRotation(0, fill=None)
    assert t.fill == 0

    t = transforms.RandomRotation(10)
    angle = t.get_params(t.degrees)
1849
    assert angle > -10 and angle < 10
1850
1851
1852

    t = transforms.RandomRotation((-10, 10))
    angle = t.get_params(t.degrees)
1853
    assert -10 < angle < 10
1854
1855
1856
1857

    # Checking if RandomRotation can be printed as string
    t.__repr__()

1858
1859
1860
    t = transforms.RandomRotation((-10, 10), interpolation=Image.BILINEAR)
    assert t.interpolation == transforms.InterpolationMode.BILINEAR

1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877

def test_random_rotation_error():
    # assert fill being either a Sequence or a Number
    with pytest.raises(TypeError):
        transforms.RandomRotation(0, fill={})


def test_randomperspective():
    for _ in range(10):
        height = random.randint(24, 32) * 2
        width = random.randint(24, 32) * 2
        img = torch.ones(3, height, width)
        to_pil_image = transforms.ToPILImage()
        img = to_pil_image(img)
        perp = transforms.RandomPerspective()
        startpoints, endpoints = perp.get_params(width, height, 0.5)
        tr_img = F.perspective(img, startpoints, endpoints)
1878
1879
        tr_img2 = F.convert_image_dtype(F.pil_to_tensor(F.perspective(tr_img, endpoints, startpoints)))
        tr_img = F.convert_image_dtype(F.pil_to_tensor(tr_img))
1880
1881
        assert img.size[0] == width
        assert img.size[1] == height
1882
1883
1884
        assert torch.nn.functional.mse_loss(
            tr_img, F.convert_image_dtype(F.pil_to_tensor(img))
        ) + 0.3 > torch.nn.functional.mse_loss(tr_img2, F.convert_image_dtype(F.pil_to_tensor(img)))
1885
1886


1887
@pytest.mark.parametrize("seed", range(10))
1888
@pytest.mark.parametrize("mode", ["L", "RGB", "F"])
1889
1890
def test_randomperspective_fill(mode, seed):
    torch.random.manual_seed(seed)
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928

    # assert fill being either a Sequence or a Number
    with pytest.raises(TypeError):
        transforms.RandomPerspective(fill={})

    t = transforms.RandomPerspective(fill=None)
    assert t.fill == 0

    height = 100
    width = 100
    img = torch.ones(3, height, width)
    to_pil_image = transforms.ToPILImage()
    img = to_pil_image(img)
    fill = 127
    num_bands = len(mode)

    img_conv = img.convert(mode)
    perspective = transforms.RandomPerspective(p=1, fill=fill)
    tr_img = perspective(img_conv)
    pixel = tr_img.getpixel((0, 0))

    if not isinstance(pixel, tuple):
        pixel = (pixel,)
    assert pixel == tuple([fill] * num_bands)

    startpoints, endpoints = transforms.RandomPerspective.get_params(width, height, 0.5)
    tr_img = F.perspective(img_conv, startpoints, endpoints, fill=fill)
    pixel = tr_img.getpixel((0, 0))

    if not isinstance(pixel, tuple):
        pixel = (pixel,)
    assert pixel == tuple([fill] * num_bands)

    wrong_num_bands = num_bands + 1
    with pytest.raises(ValueError):
        F.perspective(img_conv, startpoints, endpoints, fill=tuple([fill] * wrong_num_bands))


1929
@pytest.mark.skipif(stats is None, reason="scipy.stats not available")
1930
1931
def test_normalize():
    def samples_from_standard_normal(tensor):
1932
        p_value = stats.kstest(list(tensor.view(-1)), "norm", args=(0, 1)).pvalue
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
        return p_value > 0.0001

    random_state = random.getstate()
    random.seed(42)
    for channels in [1, 3]:
        img = torch.rand(channels, 10, 10)
        mean = [img[c].mean() for c in range(channels)]
        std = [img[c].std() for c in range(channels)]
        normalized = transforms.Normalize(mean, std)(img)
        assert samples_from_standard_normal(normalized)
    random.setstate(random_state)

    # Checking if Normalize can be printed as string
    transforms.Normalize(mean, std).__repr__()

    # Checking the optional in-place behaviour
    tensor = torch.rand((1, 16, 16))
    tensor_inplace = transforms.Normalize((0.5,), (0.5,), inplace=True)(tensor)
    assert_equal(tensor, tensor_inplace)


1954
1955
@pytest.mark.parametrize("dtype1", [torch.float32, torch.float64])
@pytest.mark.parametrize("dtype2", [torch.int64, torch.float32, torch.float64])
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
def test_normalize_different_dtype(dtype1, dtype2):
    img = torch.rand(3, 10, 10, dtype=dtype1)
    mean = torch.tensor([1, 2, 3], dtype=dtype2)
    std = torch.tensor([1, 2, 1], dtype=dtype2)
    # checks that it doesn't crash
    transforms.functional.normalize(img, mean, std)


def test_normalize_3d_tensor():
    torch.manual_seed(28)
    n_channels = 3
    img_size = 10
    mean = torch.rand(n_channels)
    std = torch.rand(n_channels)
    img = torch.rand(n_channels, img_size, img_size)
    target = F.normalize(img, mean, std)

    mean_unsqueezed = mean.view(-1, 1, 1)
    std_unsqueezed = std.view(-1, 1, 1)
    result1 = F.normalize(img, mean_unsqueezed, std_unsqueezed)
1976
1977
1978
    result2 = F.normalize(
        img, mean_unsqueezed.repeat(1, img_size, img_size), std_unsqueezed.repeat(1, img_size, img_size)
    )
1979
1980
1981
1982
    torch.testing.assert_close(target, result1)
    torch.testing.assert_close(target, result2)


1983
class TestAffine:
1984
    @pytest.fixture(scope="class")
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
    def input_img(self):
        input_img = np.zeros((40, 40, 3), dtype=np.uint8)
        for pt in [(16, 16), (20, 16), (20, 20)]:
            for i in range(-5, 5):
                for j in range(-5, 5):
                    input_img[pt[0] + i, pt[1] + j, :] = [255, 155, 55]
        return input_img

    def test_affine_translate_seq(self, input_img):
        with pytest.raises(TypeError, match=r"Argument translate should be a sequence"):
            F.affine(input_img, 10, translate=0, scale=1, shear=1)

1997
    @pytest.fixture(scope="class")
1998
1999
2000
2001
2002
2003
2004
2005
2006
    def pil_image(self, input_img):
        return F.to_pil_image(input_img)

    def _to_3x3_inv(self, inv_result_matrix):
        result_matrix = np.zeros((3, 3))
        result_matrix[:2, :] = np.array(inv_result_matrix).reshape((2, 3))
        result_matrix[2, 2] = 1
        return np.linalg.inv(result_matrix)

2007
    def _test_transformation(self, angle, translate, scale, shear, pil_image, input_img, center=None):
2008
2009
2010

        a_rad = math.radians(angle)
        s_rad = [math.radians(sh_) for sh_ in shear]
2011
        cnt = [20, 20] if center is None else center
2012
2013
2014
2015
2016
2017
        cx, cy = cnt
        tx, ty = translate
        sx, sy = s_rad
        rot = a_rad

        # 1) Check transformation matrix:
2018
2019
        C = np.array([[1, 0, cx], [0, 1, cy], [0, 0, 1]])
        T = np.array([[1, 0, tx], [0, 1, ty], [0, 0, 1]])
2020
2021
2022
        Cinv = np.linalg.inv(C)

        RS = np.array(
2023
2024
2025
2026
2027
2028
            [
                [scale * math.cos(rot), -scale * math.sin(rot), 0],
                [scale * math.sin(rot), scale * math.cos(rot), 0],
                [0, 0, 1],
            ]
        )
2029

2030
        SHx = np.array([[1, -math.tan(sx), 0], [0, 1, 0], [0, 0, 1]])
2031

2032
        SHy = np.array([[1, 0, 0], [-math.tan(sy), 1, 0], [0, 0, 1]])
2033
2034
2035
2036
2037

        RSS = np.matmul(RS, np.matmul(SHy, SHx))

        true_matrix = np.matmul(T, np.matmul(C, np.matmul(RSS, Cinv)))

2038
2039
2040
        result_matrix = self._to_3x3_inv(
            F._get_inverse_affine_matrix(center=cnt, angle=angle, translate=translate, scale=scale, shear=shear)
        )
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
        assert np.sum(np.abs(true_matrix - result_matrix)) < 1e-10
        # 2) Perform inverse mapping:
        true_result = np.zeros((40, 40, 3), dtype=np.uint8)
        inv_true_matrix = np.linalg.inv(true_matrix)
        for y in range(true_result.shape[0]):
            for x in range(true_result.shape[1]):
                # Same as for PIL:
                # https://github.com/python-pillow/Pillow/blob/71f8ec6a0cfc1008076a023c0756542539d057ab/
                # src/libImaging/Geometry.c#L1060
                input_pt = np.array([x + 0.5, y + 0.5, 1.0])
2051
                res = np.floor(np.dot(inv_true_matrix, input_pt)).astype(int)
2052
2053
2054
2055
                _x, _y = res[:2]
                if 0 <= _x < input_img.shape[1] and 0 <= _y < input_img.shape[0]:
                    true_result[y, x, :] = input_img[_y, _x, :]

2056
        result = F.affine(pil_image, angle=angle, translate=translate, scale=scale, shear=shear, center=center)
2057
2058
2059
2060
2061
        assert result.size == pil_image.size
        # Compute number of different pixels:
        np_result = np.array(result)
        n_diff_pixels = np.sum(np_result != true_result) / 3
        # Accept 3 wrong pixels
2062
2063
2064
        error_msg = (
            f"angle={angle}, translate={translate}, scale={scale}, shear={shear}\nn diff pixels={n_diff_pixels}\n"
        )
2065
2066
2067
2068
2069
        assert n_diff_pixels < 3, error_msg

    def test_transformation_discrete(self, pil_image, input_img):
        # Test rotation
        angle = 45
2070
2071
2072
        self._test_transformation(
            angle=angle, translate=(0, 0), scale=1.0, shear=(0.0, 0.0), pil_image=pil_image, input_img=input_img
        )
2073

2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
        # Test rotation
        angle = 45
        self._test_transformation(
            angle=angle,
            translate=(0, 0),
            scale=1.0,
            shear=(0.0, 0.0),
            pil_image=pil_image,
            input_img=input_img,
            center=[0, 0],
        )

2086
2087
        # Test translation
        translate = [10, 15]
2088
2089
2090
        self._test_transformation(
            angle=0.0, translate=translate, scale=1.0, shear=(0.0, 0.0), pil_image=pil_image, input_img=input_img
        )
2091
2092
2093

        # Test scale
        scale = 1.2
2094
2095
2096
        self._test_transformation(
            angle=0.0, translate=(0.0, 0.0), scale=scale, shear=(0.0, 0.0), pil_image=pil_image, input_img=input_img
        )
2097
2098
2099

        # Test shear
        shear = [45.0, 25.0]
2100
2101
2102
        self._test_transformation(
            angle=0.0, translate=(0.0, 0.0), scale=1.0, shear=shear, pil_image=pil_image, input_img=input_img
        )
2103

2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
        # Test shear with top-left as center
        shear = [45.0, 25.0]
        self._test_transformation(
            angle=0.0,
            translate=(0.0, 0.0),
            scale=1.0,
            shear=shear,
            pil_image=pil_image,
            input_img=input_img,
            center=[0, 0],
        )

2116
2117
2118
2119
2120
    @pytest.mark.parametrize("angle", range(-90, 90, 36))
    @pytest.mark.parametrize("translate", range(-10, 10, 5))
    @pytest.mark.parametrize("scale", [0.77, 1.0, 1.27])
    @pytest.mark.parametrize("shear", range(-15, 15, 5))
    def test_transformation_range(self, angle, translate, scale, shear, pil_image, input_img):
2121
2122
2123
2124
2125
2126
2127
2128
        self._test_transformation(
            angle=angle,
            translate=(translate, translate),
            scale=scale,
            shear=(shear, shear),
            pil_image=pil_image,
            input_img=input_img,
        )
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175


def test_random_affine():

    with pytest.raises(ValueError):
        transforms.RandomAffine(-0.7)
    with pytest.raises(ValueError):
        transforms.RandomAffine([-0.7])
    with pytest.raises(ValueError):
        transforms.RandomAffine([-0.7, 0, 0.7])
    with pytest.raises(TypeError):
        transforms.RandomAffine([-90, 90], translate=2.0)
    with pytest.raises(ValueError):
        transforms.RandomAffine([-90, 90], translate=[-1.0, 1.0])
    with pytest.raises(ValueError):
        transforms.RandomAffine([-90, 90], translate=[-1.0, 0.0, 1.0])

    with pytest.raises(ValueError):
        transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.0])
    with pytest.raises(ValueError):
        transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[-1.0, 1.0])
    with pytest.raises(ValueError):
        transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, -0.5])
    with pytest.raises(ValueError):
        transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 3.0, -0.5])

    with pytest.raises(ValueError):
        transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 0.5], shear=-7)
    with pytest.raises(ValueError):
        transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 0.5], shear=[-10])
    with pytest.raises(ValueError):
        transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 0.5], shear=[-10, 0, 10])
    with pytest.raises(ValueError):
        transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 0.5], shear=[-10, 0, 10, 0, 10])

    # assert fill being either a Sequence or a Number
    with pytest.raises(TypeError):
        transforms.RandomAffine(0, fill={})

    t = transforms.RandomAffine(0, fill=None)
    assert t.fill == 0

    x = np.zeros((100, 100, 3), dtype=np.uint8)
    img = F.to_pil_image(x)

    t = transforms.RandomAffine(10, translate=[0.5, 0.3], scale=[0.7, 1.3], shear=[-10, 10, 20, 40])
    for _ in range(100):
2176
        angle, translations, scale, shear = t.get_params(t.degrees, t.translate, t.scale, t.shear, img_size=img.size)
2177
        assert -10 < angle < 10
2178
2179
        assert -img.size[0] * 0.5 <= translations[0] <= img.size[0] * 0.5
        assert -img.size[1] * 0.5 <= translations[1] <= img.size[1] * 0.5
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
        assert 0.7 < scale < 1.3
        assert -10 < shear[0] < 10
        assert -20 < shear[1] < 40

    # Checking if RandomAffine can be printed as string
    t.__repr__()

    t = transforms.RandomAffine(10, interpolation=transforms.InterpolationMode.BILINEAR)
    assert "bilinear" in t.__repr__()

2190
2191
2192
    t = transforms.RandomAffine(10, interpolation=Image.BILINEAR)
    assert t.interpolation == transforms.InterpolationMode.BILINEAR

2193

2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
def test_elastic_transformation():
    with pytest.raises(TypeError, match=r"alpha should be float or a sequence of floats"):
        transforms.ElasticTransform(alpha=True, sigma=2.0)
    with pytest.raises(TypeError, match=r"alpha should be a sequence of floats"):
        transforms.ElasticTransform(alpha=[1.0, True], sigma=2.0)
    with pytest.raises(ValueError, match=r"alpha is a sequence its length should be 2"):
        transforms.ElasticTransform(alpha=[1.0, 0.0, 1.0], sigma=2.0)

    with pytest.raises(TypeError, match=r"sigma should be float or a sequence of floats"):
        transforms.ElasticTransform(alpha=2.0, sigma=True)
    with pytest.raises(TypeError, match=r"sigma should be a sequence of floats"):
        transforms.ElasticTransform(alpha=2.0, sigma=[1.0, True])
    with pytest.raises(ValueError, match=r"sigma is a sequence its length should be 2"):
        transforms.ElasticTransform(alpha=2.0, sigma=[1.0, 0.0, 1.0])

2209
2210
    t = transforms.transforms.ElasticTransform(alpha=2.0, sigma=2.0, interpolation=Image.BILINEAR)
    assert t.interpolation == transforms.InterpolationMode.BILINEAR
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229

    with pytest.raises(TypeError, match=r"fill should be int or float"):
        transforms.ElasticTransform(alpha=1.0, sigma=1.0, fill={})

    x = torch.randint(0, 256, (3, 32, 32), dtype=torch.uint8)
    img = F.to_pil_image(x)
    t = transforms.ElasticTransform(alpha=0.0, sigma=0.0)
    transformed_img = t(img)
    assert transformed_img == img

    # Smoke test on PIL images
    t = transforms.ElasticTransform(alpha=0.5, sigma=0.23)
    transformed_img = t(img)
    assert isinstance(transformed_img, Image.Image)

    # Checking if ElasticTransform can be printed as string
    t.__repr__()


2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
def test_random_grayscale_with_grayscale_input():
    transform = transforms.RandomGrayscale(p=1.0)

    image_tensor = torch.randint(0, 256, (1, 16, 16), dtype=torch.uint8)
    output_tensor = transform(image_tensor)
    torch.testing.assert_close(output_tensor, image_tensor)

    image_pil = F.to_pil_image(image_tensor)
    output_pil = transform(image_pil)
    torch.testing.assert_close(F.pil_to_tensor(output_pil), image_tensor)


2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
# TODO: remove in 0.17 when we can delete functional_pil.py and functional_tensor.py
@pytest.mark.parametrize(
    "import_statement",
    (
        "from torchvision.transforms import functional_pil",
        "from torchvision.transforms import functional_tensor",
        "from torchvision.transforms.functional_tensor import resize",
        "from torchvision.transforms.functional_pil import resize",
    ),
)
@pytest.mark.parametrize("from_private", (True, False))
def test_functional_deprecation_warning(import_statement, from_private):
    if from_private:
        import_statement = import_statement.replace("functional", "_functional")
        source = f"""
        import warnings

        with warnings.catch_warnings():
            warnings.simplefilter("error")
            {import_statement}
        """
    else:
        source = f"""
        import pytest
        with pytest.warns(UserWarning, match="removed in 0.17"):
            {import_statement}
        """
    assert_run_python_script(textwrap.dedent(source))


2272
if __name__ == "__main__":
2273
    pytest.main([__file__])