test_transforms_v2_consistency.py 52.5 KB
Newer Older
1
import enum
2
3
import importlib.machinery
import importlib.util
4
import inspect
5
import random
6
import re
7
from pathlib import Path
8

9
import numpy as np
10
import PIL.Image
11
import pytest
12
13

import torch
14
import torchvision.transforms.v2 as v2_transforms
15
from common_utils import assert_close, assert_equal, set_rng_seed
16
from torch import nn
17
from torchvision import datapoints, transforms as legacy_transforms
18
from torchvision._utils import sequence_to_str
19

20
from torchvision.transforms import functional as legacy_F
21
from torchvision.transforms.v2 import functional as prototype_F
Nicolas Hug's avatar
Nicolas Hug committed
22
from torchvision.transforms.v2._utils import _get_fill, query_size
23
from torchvision.transforms.v2.functional import to_pil_image
24
25
26
27
28
29
30
31
from transforms_v2_legacy_utils import (
    ArgsKwargs,
    make_bounding_boxes,
    make_detection_mask,
    make_image,
    make_images,
    make_segmentation_mask,
)
32

33
DEFAULT_MAKE_IMAGES_KWARGS = dict(color_spaces=["RGB"], extra_dims=[(4,)])
34
35


Nicolas Hug's avatar
Nicolas Hug committed
36
37
38
39
40
41
@pytest.fixture(autouse=True)
def fix_rng_seed():
    set_rng_seed(0)
    yield


42
43
44
45
46
47
48
49
50
class NotScriptableArgsKwargs(ArgsKwargs):
    """
    This class is used to mark parameters that render the transform non-scriptable. They still work in eager mode and
    thus will be tested there, but will be skipped by the JIT tests.
    """

    pass


51
52
class ConsistencyConfig:
    def __init__(
53
54
55
        self,
        prototype_cls,
        legacy_cls,
56
57
        # If no args_kwargs is passed, only the signature will be checked
        args_kwargs=(),
58
59
60
        make_images_kwargs=None,
        supports_pil=True,
        removed_params=(),
61
        closeness_kwargs=None,
62
63
64
    ):
        self.prototype_cls = prototype_cls
        self.legacy_cls = legacy_cls
65
        self.args_kwargs = args_kwargs
66
67
        self.make_images_kwargs = make_images_kwargs or DEFAULT_MAKE_IMAGES_KWARGS
        self.supports_pil = supports_pil
68
        self.removed_params = removed_params
69
        self.closeness_kwargs = closeness_kwargs or dict(rtol=0, atol=0)
70
71


72
73
74
75
# These are here since both the prototype and legacy transform need to be constructed with the same random parameters
LINEAR_TRANSFORMATION_MEAN = torch.rand(36)
LINEAR_TRANSFORMATION_MATRIX = torch.rand([LINEAR_TRANSFORMATION_MEAN.numel()] * 2)

76
77
CONSISTENCY_CONFIGS = [
    ConsistencyConfig(
78
        v2_transforms.Normalize,
79
80
81
82
83
84
85
86
        legacy_transforms.Normalize,
        [
            ArgsKwargs(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
        ],
        supports_pil=False,
        make_images_kwargs=dict(DEFAULT_MAKE_IMAGES_KWARGS, dtypes=[torch.float]),
    ),
    ConsistencyConfig(
87
        v2_transforms.Resize,
88
89
        legacy_transforms.Resize,
        [
90
            NotScriptableArgsKwargs(32),
91
            ArgsKwargs([32]),
92
            ArgsKwargs((32, 29)),
93
            ArgsKwargs((31, 28), interpolation=v2_transforms.InterpolationMode.NEAREST),
94
95
            ArgsKwargs((30, 27), interpolation=PIL.Image.NEAREST),
            ArgsKwargs((35, 29), interpolation=PIL.Image.BILINEAR),
96
97
98
99
            NotScriptableArgsKwargs(31, max_size=32),
            ArgsKwargs([31], max_size=32),
            NotScriptableArgsKwargs(30, max_size=100),
            ArgsKwargs([31], max_size=32),
100
101
            ArgsKwargs((29, 32), antialias=False),
            ArgsKwargs((28, 31), antialias=True),
102
        ],
103
104
        # atol=1 due to Resize v2 is using native uint8 interpolate path for bilinear and nearest modes
        closeness_kwargs=dict(rtol=0, atol=1),
105
    ),
106
107
108
109
110
111
112
113
114
    ConsistencyConfig(
        v2_transforms.Resize,
        legacy_transforms.Resize,
        [
            ArgsKwargs((33, 26), interpolation=v2_transforms.InterpolationMode.BICUBIC, antialias=True),
            ArgsKwargs((34, 25), interpolation=PIL.Image.BICUBIC, antialias=True),
        ],
        closeness_kwargs=dict(rtol=0, atol=21),
    ),
115
    ConsistencyConfig(
116
        v2_transforms.CenterCrop,
117
118
119
120
121
122
        legacy_transforms.CenterCrop,
        [
            ArgsKwargs(18),
            ArgsKwargs((18, 13)),
        ],
    ),
123
    ConsistencyConfig(
124
        v2_transforms.FiveCrop,
125
126
127
128
129
130
131
132
        legacy_transforms.FiveCrop,
        [
            ArgsKwargs(18),
            ArgsKwargs((18, 13)),
        ],
        make_images_kwargs=dict(DEFAULT_MAKE_IMAGES_KWARGS, sizes=[(20, 19)]),
    ),
    ConsistencyConfig(
133
        v2_transforms.TenCrop,
134
135
136
137
        legacy_transforms.TenCrop,
        [
            ArgsKwargs(18),
            ArgsKwargs((18, 13)),
138
            ArgsKwargs(18, vertical_flip=True),
139
140
141
142
        ],
        make_images_kwargs=dict(DEFAULT_MAKE_IMAGES_KWARGS, sizes=[(20, 19)]),
    ),
    ConsistencyConfig(
143
        v2_transforms.Pad,
144
145
        legacy_transforms.Pad,
        [
146
            NotScriptableArgsKwargs(3),
147
148
149
            ArgsKwargs([3]),
            ArgsKwargs([2, 3]),
            ArgsKwargs([3, 2, 1, 4]),
150
151
152
153
154
            NotScriptableArgsKwargs(5, fill=1, padding_mode="constant"),
            ArgsKwargs([5], fill=1, padding_mode="constant"),
            NotScriptableArgsKwargs(5, padding_mode="edge"),
            NotScriptableArgsKwargs(5, padding_mode="reflect"),
            NotScriptableArgsKwargs(5, padding_mode="symmetric"),
155
156
        ],
    ),
157
158
    *[
        ConsistencyConfig(
159
            v2_transforms.LinearTransformation,
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
            legacy_transforms.LinearTransformation,
            [
                ArgsKwargs(LINEAR_TRANSFORMATION_MATRIX.to(matrix_dtype), LINEAR_TRANSFORMATION_MEAN.to(matrix_dtype)),
            ],
            # Make sure that the product of the height, width and number of channels matches the number of elements in
            # `LINEAR_TRANSFORMATION_MEAN`. For example 2 * 6 * 3 == 4 * 3 * 3 == 36.
            make_images_kwargs=dict(
                DEFAULT_MAKE_IMAGES_KWARGS, sizes=[(2, 6), (4, 3)], color_spaces=["RGB"], dtypes=[image_dtype]
            ),
            supports_pil=False,
        )
        for matrix_dtype, image_dtype in [
            (torch.float32, torch.float32),
            (torch.float64, torch.float64),
            (torch.float32, torch.uint8),
            (torch.float64, torch.float32),
            (torch.float32, torch.float64),
        ]
    ],
179
    ConsistencyConfig(
180
        v2_transforms.Grayscale,
181
182
183
184
185
        legacy_transforms.Grayscale,
        [
            ArgsKwargs(num_output_channels=1),
            ArgsKwargs(num_output_channels=3),
        ],
186
        make_images_kwargs=dict(DEFAULT_MAKE_IMAGES_KWARGS, color_spaces=["RGB", "GRAY"]),
187
188
        # Use default tolerances of `torch.testing.assert_close`
        closeness_kwargs=dict(rtol=None, atol=None),
189
    ),
190
    ConsistencyConfig(
191
        v2_transforms.ConvertImageDtype,
192
193
194
195
196
197
198
199
200
        legacy_transforms.ConvertImageDtype,
        [
            ArgsKwargs(torch.float16),
            ArgsKwargs(torch.bfloat16),
            ArgsKwargs(torch.float32),
            ArgsKwargs(torch.float64),
            ArgsKwargs(torch.uint8),
        ],
        supports_pil=False,
201
202
        # Use default tolerances of `torch.testing.assert_close`
        closeness_kwargs=dict(rtol=None, atol=None),
203
204
    ),
    ConsistencyConfig(
205
        v2_transforms.ToPILImage,
206
        legacy_transforms.ToPILImage,
207
        [NotScriptableArgsKwargs()],
208
209
        make_images_kwargs=dict(
            color_spaces=[
210
211
212
213
                "GRAY",
                "GRAY_ALPHA",
                "RGB",
                "RGBA",
214
215
216
217
218
219
            ],
            extra_dims=[()],
        ),
        supports_pil=False,
    ),
    ConsistencyConfig(
220
        v2_transforms.Lambda,
221
222
        legacy_transforms.Lambda,
        [
223
            NotScriptableArgsKwargs(lambda image: image / 2),
224
225
226
227
228
        ],
        # Technically, this also supports PIL, but it is overkill to write a function here that supports tensor and PIL
        # images given that the transform does nothing but call it anyway.
        supports_pil=False,
    ),
229
    ConsistencyConfig(
230
        v2_transforms.RandomHorizontalFlip,
231
232
233
234
235
236
237
        legacy_transforms.RandomHorizontalFlip,
        [
            ArgsKwargs(p=0),
            ArgsKwargs(p=1),
        ],
    ),
    ConsistencyConfig(
238
        v2_transforms.RandomVerticalFlip,
239
240
241
242
243
244
245
        legacy_transforms.RandomVerticalFlip,
        [
            ArgsKwargs(p=0),
            ArgsKwargs(p=1),
        ],
    ),
    ConsistencyConfig(
246
        v2_transforms.RandomEqualize,
247
248
249
250
251
252
253
254
        legacy_transforms.RandomEqualize,
        [
            ArgsKwargs(p=0),
            ArgsKwargs(p=1),
        ],
        make_images_kwargs=dict(DEFAULT_MAKE_IMAGES_KWARGS, dtypes=[torch.uint8]),
    ),
    ConsistencyConfig(
255
        v2_transforms.RandomInvert,
256
257
258
259
260
261
262
        legacy_transforms.RandomInvert,
        [
            ArgsKwargs(p=0),
            ArgsKwargs(p=1),
        ],
    ),
    ConsistencyConfig(
263
        v2_transforms.RandomPosterize,
264
265
266
267
268
269
270
271
272
        legacy_transforms.RandomPosterize,
        [
            ArgsKwargs(p=0, bits=5),
            ArgsKwargs(p=1, bits=1),
            ArgsKwargs(p=1, bits=3),
        ],
        make_images_kwargs=dict(DEFAULT_MAKE_IMAGES_KWARGS, dtypes=[torch.uint8]),
    ),
    ConsistencyConfig(
273
        v2_transforms.RandomSolarize,
274
275
276
277
278
279
280
        legacy_transforms.RandomSolarize,
        [
            ArgsKwargs(p=0, threshold=0.5),
            ArgsKwargs(p=1, threshold=0.3),
            ArgsKwargs(p=1, threshold=0.99),
        ],
    ),
281
282
    *[
        ConsistencyConfig(
283
            v2_transforms.RandomAutocontrast,
284
285
286
287
288
289
290
291
292
293
            legacy_transforms.RandomAutocontrast,
            [
                ArgsKwargs(p=0),
                ArgsKwargs(p=1),
            ],
            make_images_kwargs=dict(DEFAULT_MAKE_IMAGES_KWARGS, dtypes=[dt]),
            closeness_kwargs=ckw,
        )
        for dt, ckw in [(torch.uint8, dict(atol=1, rtol=0)), (torch.float32, dict(rtol=None, atol=None))]
    ],
294
    ConsistencyConfig(
295
        v2_transforms.RandomAdjustSharpness,
296
297
298
        legacy_transforms.RandomAdjustSharpness,
        [
            ArgsKwargs(p=0, sharpness_factor=0.5),
299
            ArgsKwargs(p=1, sharpness_factor=0.2),
300
301
            ArgsKwargs(p=1, sharpness_factor=0.99),
        ],
302
        closeness_kwargs={"atol": 1e-6, "rtol": 1e-6},
303
304
    ),
    ConsistencyConfig(
305
        v2_transforms.RandomGrayscale,
306
307
308
309
310
        legacy_transforms.RandomGrayscale,
        [
            ArgsKwargs(p=0),
            ArgsKwargs(p=1),
        ],
311
312
313
        make_images_kwargs=dict(DEFAULT_MAKE_IMAGES_KWARGS, color_spaces=["RGB", "GRAY"]),
        # Use default tolerances of `torch.testing.assert_close`
        closeness_kwargs=dict(rtol=None, atol=None),
314
315
    ),
    ConsistencyConfig(
316
        v2_transforms.RandomResizedCrop,
317
318
319
320
321
        legacy_transforms.RandomResizedCrop,
        [
            ArgsKwargs(16),
            ArgsKwargs(17, scale=(0.3, 0.7)),
            ArgsKwargs(25, ratio=(0.5, 1.5)),
322
            ArgsKwargs((31, 28), interpolation=v2_transforms.InterpolationMode.NEAREST),
323
            ArgsKwargs((31, 28), interpolation=PIL.Image.NEAREST),
324
325
326
            ArgsKwargs((29, 32), antialias=False),
            ArgsKwargs((28, 31), antialias=True),
        ],
327
328
        # atol=1 due to Resize v2 is using native uint8 interpolate path for bilinear and nearest modes
        closeness_kwargs=dict(rtol=0, atol=1),
329
    ),
330
331
332
333
334
335
336
337
338
    ConsistencyConfig(
        v2_transforms.RandomResizedCrop,
        legacy_transforms.RandomResizedCrop,
        [
            ArgsKwargs((33, 26), interpolation=v2_transforms.InterpolationMode.BICUBIC, antialias=True),
            ArgsKwargs((33, 26), interpolation=PIL.Image.BICUBIC, antialias=True),
        ],
        closeness_kwargs=dict(rtol=0, atol=21),
    ),
339
    ConsistencyConfig(
340
        v2_transforms.RandomErasing,
341
342
343
344
345
346
347
348
349
350
351
352
353
        legacy_transforms.RandomErasing,
        [
            ArgsKwargs(p=0),
            ArgsKwargs(p=1),
            ArgsKwargs(p=1, scale=(0.3, 0.7)),
            ArgsKwargs(p=1, ratio=(0.5, 1.5)),
            ArgsKwargs(p=1, value=1),
            ArgsKwargs(p=1, value=(1, 2, 3)),
            ArgsKwargs(p=1, value="random"),
        ],
        supports_pil=False,
    ),
    ConsistencyConfig(
354
        v2_transforms.ColorJitter,
355
356
357
358
359
360
361
362
363
364
365
        legacy_transforms.ColorJitter,
        [
            ArgsKwargs(),
            ArgsKwargs(brightness=0.1),
            ArgsKwargs(brightness=(0.2, 0.3)),
            ArgsKwargs(contrast=0.4),
            ArgsKwargs(contrast=(0.5, 0.6)),
            ArgsKwargs(saturation=0.7),
            ArgsKwargs(saturation=(0.8, 0.9)),
            ArgsKwargs(hue=0.3),
            ArgsKwargs(hue=(-0.1, 0.2)),
366
            ArgsKwargs(brightness=0.1, contrast=0.4, saturation=0.5, hue=0.3),
367
        ],
368
        closeness_kwargs={"atol": 1e-5, "rtol": 1e-5},
369
    ),
370
371
    *[
        ConsistencyConfig(
372
            v2_transforms.ElasticTransform,
373
374
375
376
377
378
379
            legacy_transforms.ElasticTransform,
            [
                ArgsKwargs(),
                ArgsKwargs(alpha=20.0),
                ArgsKwargs(alpha=(15.3, 27.2)),
                ArgsKwargs(sigma=3.0),
                ArgsKwargs(sigma=(2.5, 3.9)),
380
381
                ArgsKwargs(interpolation=v2_transforms.InterpolationMode.NEAREST),
                ArgsKwargs(interpolation=v2_transforms.InterpolationMode.BICUBIC),
382
383
                ArgsKwargs(interpolation=PIL.Image.NEAREST),
                ArgsKwargs(interpolation=PIL.Image.BICUBIC),
384
385
386
387
388
389
390
391
392
393
                ArgsKwargs(fill=1),
            ],
            # ElasticTransform needs larger images to avoid the needed internal padding being larger than the actual image
            make_images_kwargs=dict(DEFAULT_MAKE_IMAGES_KWARGS, sizes=[(163, 163), (72, 333), (313, 95)], dtypes=[dt]),
            # We updated gaussian blur kernel generation with a faster and numerically more stable version
            # This brings float32 accumulation visible in elastic transform -> we need to relax consistency tolerance
            closeness_kwargs=ckw,
        )
        for dt, ckw in [(torch.uint8, {"rtol": 1e-1, "atol": 1}), (torch.float32, {"rtol": 1e-2, "atol": 1e-3})]
    ],
394
    ConsistencyConfig(
395
        v2_transforms.GaussianBlur,
396
397
398
399
400
401
402
        legacy_transforms.GaussianBlur,
        [
            ArgsKwargs(kernel_size=3),
            ArgsKwargs(kernel_size=(1, 5)),
            ArgsKwargs(kernel_size=3, sigma=0.7),
            ArgsKwargs(kernel_size=5, sigma=(0.3, 1.4)),
        ],
403
        closeness_kwargs={"rtol": 1e-5, "atol": 1e-5},
404
405
    ),
    ConsistencyConfig(
406
        v2_transforms.RandomAffine,
407
408
409
410
411
412
413
414
415
416
        legacy_transforms.RandomAffine,
        [
            ArgsKwargs(degrees=30.0),
            ArgsKwargs(degrees=(-20.0, 10.0)),
            ArgsKwargs(degrees=0.0, translate=(0.4, 0.6)),
            ArgsKwargs(degrees=0.0, scale=(0.3, 0.8)),
            ArgsKwargs(degrees=0.0, shear=13),
            ArgsKwargs(degrees=0.0, shear=(8, 17)),
            ArgsKwargs(degrees=0.0, shear=(4, 5, 4, 13)),
            ArgsKwargs(degrees=(-20.0, 10.0), translate=(0.4, 0.6), scale=(0.3, 0.8), shear=(4, 5, 4, 13)),
417
            ArgsKwargs(degrees=30.0, interpolation=v2_transforms.InterpolationMode.NEAREST),
418
            ArgsKwargs(degrees=30.0, interpolation=PIL.Image.NEAREST),
419
420
421
422
            ArgsKwargs(degrees=30.0, fill=1),
            ArgsKwargs(degrees=30.0, fill=(2, 3, 4)),
            ArgsKwargs(degrees=30.0, center=(0, 0)),
        ],
423
        removed_params=["fillcolor", "resample"],
424
425
    ),
    ConsistencyConfig(
426
        v2_transforms.RandomCrop,
427
428
429
430
        legacy_transforms.RandomCrop,
        [
            ArgsKwargs(12),
            ArgsKwargs((15, 17)),
431
432
            NotScriptableArgsKwargs(11, padding=1),
            ArgsKwargs(11, padding=[1]),
433
434
435
436
            ArgsKwargs((8, 13), padding=(2, 3)),
            ArgsKwargs((14, 9), padding=(0, 2, 1, 0)),
            ArgsKwargs(36, pad_if_needed=True),
            ArgsKwargs((7, 8), fill=1),
437
            NotScriptableArgsKwargs(5, fill=(1, 2, 3)),
438
            ArgsKwargs(12),
439
            NotScriptableArgsKwargs(15, padding=2, padding_mode="edge"),
440
441
442
443
444
445
            ArgsKwargs(17, padding=(1, 0), padding_mode="reflect"),
            ArgsKwargs(8, padding=(3, 0, 0, 1), padding_mode="symmetric"),
        ],
        make_images_kwargs=dict(DEFAULT_MAKE_IMAGES_KWARGS, sizes=[(26, 26), (18, 33), (29, 22)]),
    ),
    ConsistencyConfig(
446
        v2_transforms.RandomPerspective,
447
448
449
450
451
        legacy_transforms.RandomPerspective,
        [
            ArgsKwargs(p=0),
            ArgsKwargs(p=1),
            ArgsKwargs(p=1, distortion_scale=0.3),
452
            ArgsKwargs(p=1, distortion_scale=0.2, interpolation=v2_transforms.InterpolationMode.NEAREST),
453
            ArgsKwargs(p=1, distortion_scale=0.2, interpolation=PIL.Image.NEAREST),
454
455
456
            ArgsKwargs(p=1, distortion_scale=0.1, fill=1),
            ArgsKwargs(p=1, distortion_scale=0.4, fill=(1, 2, 3)),
        ],
457
        closeness_kwargs={"atol": None, "rtol": None},
458
459
    ),
    ConsistencyConfig(
460
        v2_transforms.RandomRotation,
461
462
463
464
        legacy_transforms.RandomRotation,
        [
            ArgsKwargs(degrees=30.0),
            ArgsKwargs(degrees=(-20.0, 10.0)),
465
            ArgsKwargs(degrees=30.0, interpolation=v2_transforms.InterpolationMode.BILINEAR),
466
            ArgsKwargs(degrees=30.0, interpolation=PIL.Image.BILINEAR),
467
468
469
470
471
            ArgsKwargs(degrees=30.0, expand=True),
            ArgsKwargs(degrees=30.0, center=(0, 0)),
            ArgsKwargs(degrees=30.0, fill=1),
            ArgsKwargs(degrees=30.0, fill=(1, 2, 3)),
        ],
472
        removed_params=["resample"],
473
    ),
474
    ConsistencyConfig(
475
        v2_transforms.PILToTensor,
476
477
478
        legacy_transforms.PILToTensor,
    ),
    ConsistencyConfig(
479
        v2_transforms.ToTensor,
480
481
482
        legacy_transforms.ToTensor,
    ),
    ConsistencyConfig(
483
        v2_transforms.Compose,
484
485
486
        legacy_transforms.Compose,
    ),
    ConsistencyConfig(
487
        v2_transforms.RandomApply,
488
489
490
        legacy_transforms.RandomApply,
    ),
    ConsistencyConfig(
491
        v2_transforms.RandomChoice,
492
493
494
        legacy_transforms.RandomChoice,
    ),
    ConsistencyConfig(
495
        v2_transforms.RandomOrder,
496
497
498
        legacy_transforms.RandomOrder,
    ),
    ConsistencyConfig(
499
        v2_transforms.AugMix,
500
501
502
        legacy_transforms.AugMix,
    ),
    ConsistencyConfig(
503
        v2_transforms.AutoAugment,
504
505
506
        legacy_transforms.AutoAugment,
    ),
    ConsistencyConfig(
507
        v2_transforms.RandAugment,
508
509
510
        legacy_transforms.RandAugment,
    ),
    ConsistencyConfig(
511
        v2_transforms.TrivialAugmentWide,
512
513
        legacy_transforms.TrivialAugmentWide,
    ),
514
515
516
]


517
518
def test_automatic_coverage():
    available = {
519
520
        name
        for name, obj in legacy_transforms.__dict__.items()
521
        if not name.startswith("_") and isinstance(obj, type) and not issubclass(obj, enum.Enum)
522
523
    }

524
    checked = {config.legacy_cls.__name__ for config in CONSISTENCY_CONFIGS}
525

526
    missing = available - checked
527
528
529
530
531
532
533
    if missing:
        raise AssertionError(
            f"The prototype transformations {sequence_to_str(sorted(missing), separate_last='and ')} "
            f"are not checked for consistency although a legacy counterpart exists."
        )


534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
@pytest.mark.parametrize("config", CONSISTENCY_CONFIGS, ids=lambda config: config.legacy_cls.__name__)
def test_signature_consistency(config):
    legacy_params = dict(inspect.signature(config.legacy_cls).parameters)
    prototype_params = dict(inspect.signature(config.prototype_cls).parameters)

    for param in config.removed_params:
        legacy_params.pop(param, None)

    missing = legacy_params.keys() - prototype_params.keys()
    if missing:
        raise AssertionError(
            f"The prototype transform does not support the parameters "
            f"{sequence_to_str(sorted(missing), separate_last='and ')}, but the legacy transform does. "
            f"If that is intentional, e.g. pending deprecation, please add the parameters to the `removed_params` on "
            f"the `ConsistencyConfig`."
        )

    extra = prototype_params.keys() - legacy_params.keys()
552
553
554
555
556
557
    extra_without_default = {
        param
        for param in extra
        if prototype_params[param].default is inspect.Parameter.empty
        and prototype_params[param].kind not in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}
    }
558
559
    if extra_without_default:
        raise AssertionError(
560
561
562
            f"The prototype transform requires the parameters "
            f"{sequence_to_str(sorted(extra_without_default), separate_last='and ')}, but the legacy transform does "
            f"not. Please add a default value."
563
564
        )

565
566
567
568
569
570
    legacy_signature = list(legacy_params.keys())
    # Since we made sure that we don't have any extra parameters without default above, we clamp the prototype signature
    # to the same number of parameters as the legacy one
    prototype_signature = list(prototype_params.keys())[: len(legacy_signature)]

    assert prototype_signature == legacy_signature
571
572


573
574
575
def check_call_consistency(
    prototype_transform, legacy_transform, images=None, supports_pil=True, closeness_kwargs=None
):
576
577
    if images is None:
        images = make_images(**DEFAULT_MAKE_IMAGES_KWARGS)
578

579
580
    closeness_kwargs = closeness_kwargs or dict()

581
582
    for image in images:
        image_repr = f"[{tuple(image.shape)}, {str(image.dtype).rsplit('.')[-1]}]"
583
584
585

        image_tensor = torch.Tensor(image)
        try:
586
            torch.manual_seed(0)
587
            output_legacy_tensor = legacy_transform(image_tensor)
588
589
        except Exception as exc:
            raise pytest.UsageError(
590
                f"Transforming a tensor image {image_repr} failed in the legacy transform with the "
591
                f"error above. This means that you need to specify the parameters passed to `make_images` through the "
592
593
594
595
                "`make_images_kwargs` of the `ConsistencyConfig`."
            ) from exc

        try:
596
            torch.manual_seed(0)
597
            output_prototype_tensor = prototype_transform(image_tensor)
598
599
        except Exception as exc:
            raise AssertionError(
600
                f"Transforming a tensor image with shape {image_repr} failed in the prototype transform with "
601
                f"the error above. This means there is a consistency bug either in `_get_params` or in the "
602
                f"`is_pure_tensor` path in `_transform`."
603
604
            ) from exc

605
        assert_close(
606
607
608
            output_prototype_tensor,
            output_legacy_tensor,
            msg=lambda msg: f"Tensor image consistency check failed with: \n\n{msg}",
609
            **closeness_kwargs,
610
611
612
        )

        try:
613
            torch.manual_seed(0)
614
            output_prototype_image = prototype_transform(image)
615
616
        except Exception as exc:
            raise AssertionError(
617
                f"Transforming a image datapoint with shape {image_repr} failed in the prototype transform with "
618
                f"the error above. This means there is a consistency bug either in `_get_params` or in the "
619
                f"`datapoints.Image` path in `_transform`."
620
621
            ) from exc

622
        assert_close(
623
            output_prototype_image,
624
            output_prototype_tensor,
625
            msg=lambda msg: f"Output for datapoint and tensor images is not equal: \n\n{msg}",
626
            **closeness_kwargs,
627
628
        )

629
        if image.ndim == 3 and supports_pil:
630
            image_pil = to_pil_image(image)
631

632
            try:
633
                torch.manual_seed(0)
634
                output_legacy_pil = legacy_transform(image_pil)
635
636
            except Exception as exc:
                raise pytest.UsageError(
637
                    f"Transforming a PIL image with shape {image_repr} failed in the legacy transform with the "
638
639
640
641
642
                    f"error above. If this transform does not support PIL images, set `supports_pil=False` on the "
                    "`ConsistencyConfig`. "
                ) from exc

            try:
643
                torch.manual_seed(0)
644
                output_prototype_pil = prototype_transform(image_pil)
645
646
            except Exception as exc:
                raise AssertionError(
647
                    f"Transforming a PIL image with shape {image_repr} failed in the prototype transform with "
648
649
650
651
                    f"the error above. This means there is a consistency bug either in `_get_params` or in the "
                    f"`PIL.Image.Image` path in `_transform`."
                ) from exc

652
            assert_close(
653
654
                output_prototype_pil,
                output_legacy_pil,
655
                msg=lambda msg: f"PIL image consistency check failed with: \n\n{msg}",
656
                **closeness_kwargs,
657
            )
658
659


660
@pytest.mark.parametrize(
661
662
    ("config", "args_kwargs"),
    [
663
664
665
        pytest.param(
            config, args_kwargs, id=f"{config.legacy_cls.__name__}-{idx:0{len(str(len(config.args_kwargs)))}d}"
        )
666
        for config in CONSISTENCY_CONFIGS
667
        for idx, args_kwargs in enumerate(config.args_kwargs)
668
    ],
669
)
670
@pytest.mark.filterwarnings("ignore")
671
def test_call_consistency(config, args_kwargs):
672
673
674
    args, kwargs = args_kwargs

    try:
675
        legacy_transform = config.legacy_cls(*args, **kwargs)
676
677
678
679
680
681
682
    except Exception as exc:
        raise pytest.UsageError(
            f"Initializing the legacy transform failed with the error above. "
            f"Please correct the `ArgsKwargs({args_kwargs})` in the `ConsistencyConfig`."
        ) from exc

    try:
683
        prototype_transform = config.prototype_cls(*args, **kwargs)
684
685
686
687
688
689
    except Exception as exc:
        raise AssertionError(
            "Initializing the prototype transform failed with the error above. "
            "This means there is a consistency bug in the constructor."
        ) from exc

690
691
692
693
694
    check_call_consistency(
        prototype_transform,
        legacy_transform,
        images=make_images(**config.make_images_kwargs),
        supports_pil=config.supports_pil,
695
        closeness_kwargs=config.closeness_kwargs,
696
697
698
    )


699
700
701
702
703
704
705
706
707
get_params_parametrization = pytest.mark.parametrize(
    ("config", "get_params_args_kwargs"),
    [
        pytest.param(
            next(config for config in CONSISTENCY_CONFIGS if config.prototype_cls is transform_cls),
            get_params_args_kwargs,
            id=transform_cls.__name__,
        )
        for transform_cls, get_params_args_kwargs in [
708
709
710
711
712
            (v2_transforms.RandomResizedCrop, ArgsKwargs(make_image(), scale=[0.3, 0.7], ratio=[0.5, 1.5])),
            (v2_transforms.RandomErasing, ArgsKwargs(make_image(), scale=(0.3, 0.7), ratio=(0.5, 1.5))),
            (v2_transforms.ColorJitter, ArgsKwargs(brightness=None, contrast=None, saturation=None, hue=None)),
            (v2_transforms.ElasticTransform, ArgsKwargs(alpha=[15.3, 27.2], sigma=[2.5, 3.9], size=[17, 31])),
            (v2_transforms.GaussianBlur, ArgsKwargs(0.3, 1.4)),
713
            (
714
                v2_transforms.RandomAffine,
715
716
                ArgsKwargs(degrees=[-20.0, 10.0], translate=None, scale_ranges=None, shears=None, img_size=[15, 29]),
            ),
717
718
719
720
            (v2_transforms.RandomCrop, ArgsKwargs(make_image(size=(61, 47)), output_size=(19, 25))),
            (v2_transforms.RandomPerspective, ArgsKwargs(23, 17, 0.5)),
            (v2_transforms.RandomRotation, ArgsKwargs(degrees=[-20.0, 10.0])),
            (v2_transforms.AutoAugment, ArgsKwargs(5)),
721
722
        ]
    ],
723
)
724
725


726
@get_params_parametrization
727
def test_get_params_alias(config, get_params_args_kwargs):
728
729
    assert config.prototype_cls.get_params is config.legacy_cls.get_params

730
731
732
733
734
    if not config.args_kwargs:
        return
    args, kwargs = config.args_kwargs[0]
    legacy_transform = config.legacy_cls(*args, **kwargs)
    prototype_transform = config.prototype_cls(*args, **kwargs)
735

736
737
738
    assert prototype_transform.get_params is legacy_transform.get_params


739
@get_params_parametrization
740
741
742
743
744
745
746
747
748
def test_get_params_jit(config, get_params_args_kwargs):
    get_params_args, get_params_kwargs = get_params_args_kwargs

    torch.jit.script(config.prototype_cls.get_params)(*get_params_args, **get_params_kwargs)

    if not config.args_kwargs:
        return
    args, kwargs = config.args_kwargs[0]
    transform = config.prototype_cls(*args, **kwargs)
749

750
    torch.jit.script(transform.get_params)(*get_params_args, **get_params_kwargs)
751
752


753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
@pytest.mark.parametrize(
    ("config", "args_kwargs"),
    [
        pytest.param(
            config, args_kwargs, id=f"{config.legacy_cls.__name__}-{idx:0{len(str(len(config.args_kwargs)))}d}"
        )
        for config in CONSISTENCY_CONFIGS
        for idx, args_kwargs in enumerate(config.args_kwargs)
        if not isinstance(args_kwargs, NotScriptableArgsKwargs)
    ],
)
def test_jit_consistency(config, args_kwargs):
    args, kwargs = args_kwargs

    prototype_transform_eager = config.prototype_cls(*args, **kwargs)
    legacy_transform_eager = config.legacy_cls(*args, **kwargs)

    legacy_transform_scripted = torch.jit.script(legacy_transform_eager)
    prototype_transform_scripted = torch.jit.script(prototype_transform_eager)

    for image in make_images(**config.make_images_kwargs):
        image = image.as_subclass(torch.Tensor)

        torch.manual_seed(0)
        output_legacy_scripted = legacy_transform_scripted(image)

        torch.manual_seed(0)
        output_prototype_scripted = prototype_transform_scripted(image)

        assert_close(output_prototype_scripted, output_legacy_scripted, **config.closeness_kwargs)


785
786
787
788
789
790
791
792
793
794
class TestContainerTransforms:
    """
    Since we are testing containers here, we also need some transforms to wrap. Thus, testing a container transform for
    consistency automatically tests the wrapped transforms consistency.

    Instead of complicated mocking or creating custom transforms just for these tests, here we use deterministic ones
    that were already tested for consistency above.
    """

    def test_compose(self):
795
        prototype_transform = v2_transforms.Compose(
796
            [
797
798
                v2_transforms.Resize(256),
                v2_transforms.CenterCrop(224),
799
800
801
802
803
804
805
806
807
            ]
        )
        legacy_transform = legacy_transforms.Compose(
            [
                legacy_transforms.Resize(256),
                legacy_transforms.CenterCrop(224),
            ]
        )

808
809
        # atol=1 due to Resize v2 is using native uint8 interpolate path for bilinear and nearest modes
        check_call_consistency(prototype_transform, legacy_transform, closeness_kwargs=dict(rtol=0, atol=1))
810
811

    @pytest.mark.parametrize("p", [0, 0.1, 0.5, 0.9, 1])
812
813
    @pytest.mark.parametrize("sequence_type", [list, nn.ModuleList])
    def test_random_apply(self, p, sequence_type):
814
        prototype_transform = v2_transforms.RandomApply(
815
816
            sequence_type(
                [
817
818
                    v2_transforms.Resize(256),
                    v2_transforms.CenterCrop(224),
819
820
                ]
            ),
821
822
823
            p=p,
        )
        legacy_transform = legacy_transforms.RandomApply(
824
825
826
827
828
829
            sequence_type(
                [
                    legacy_transforms.Resize(256),
                    legacy_transforms.CenterCrop(224),
                ]
            ),
830
831
832
            p=p,
        )

833
834
        # atol=1 due to Resize v2 is using native uint8 interpolate path for bilinear and nearest modes
        check_call_consistency(prototype_transform, legacy_transform, closeness_kwargs=dict(rtol=0, atol=1))
835

836
837
838
839
840
        if sequence_type is nn.ModuleList:
            # quick and dirty test that it is jit-scriptable
            scripted = torch.jit.script(prototype_transform)
            scripted(torch.rand(1, 3, 300, 300))

841
    # We can't test other values for `p` since the random parameter generation is different
842
843
    @pytest.mark.parametrize("probabilities", [(0, 1), (1, 0)])
    def test_random_choice(self, probabilities):
844
        prototype_transform = v2_transforms.RandomChoice(
845
            [
846
                v2_transforms.Resize(256),
847
848
                legacy_transforms.CenterCrop(224),
            ],
849
            p=probabilities,
850
851
852
853
854
855
        )
        legacy_transform = legacy_transforms.RandomChoice(
            [
                legacy_transforms.Resize(256),
                legacy_transforms.CenterCrop(224),
            ],
856
            p=probabilities,
857
858
        )

859
860
        # atol=1 due to Resize v2 is using native uint8 interpolate path for bilinear and nearest modes
        check_call_consistency(prototype_transform, legacy_transform, closeness_kwargs=dict(rtol=0, atol=1))
861
862


863
864
class TestToTensorTransforms:
    def test_pil_to_tensor(self):
865
        prototype_transform = v2_transforms.PILToTensor()
866
867
        legacy_transform = legacy_transforms.PILToTensor()

868
        for image in make_images(extra_dims=[()]):
869
            image_pil = to_pil_image(image)
870
871
872
873

            assert_equal(prototype_transform(image_pil), legacy_transform(image_pil))

    def test_to_tensor(self):
874
        with pytest.warns(UserWarning, match=re.escape("The transform `ToTensor()` is deprecated")):
875
            prototype_transform = v2_transforms.ToTensor()
876
877
        legacy_transform = legacy_transforms.ToTensor()

878
        for image in make_images(extra_dims=[()]):
879
            image_pil = to_pil_image(image)
880
881
882
883
            image_numpy = np.array(image_pil)

            assert_equal(prototype_transform(image_pil), legacy_transform(image_pil))
            assert_equal(prototype_transform(image_numpy), legacy_transform(image_numpy))
884
885
886
887
888
889
890
891


class TestAATransforms:
    @pytest.mark.parametrize(
        "inpt",
        [
            torch.randint(0, 256, size=(1, 3, 256, 256), dtype=torch.uint8),
            PIL.Image.new("RGB", (256, 256), 123),
892
            datapoints.Image(torch.randint(0, 256, size=(1, 3, 256, 256), dtype=torch.uint8)),
893
894
895
896
        ],
    )
    @pytest.mark.parametrize(
        "interpolation",
897
        [
898
899
            v2_transforms.InterpolationMode.NEAREST,
            v2_transforms.InterpolationMode.BILINEAR,
900
901
            PIL.Image.NEAREST,
        ],
902
903
904
    )
    def test_randaug(self, inpt, interpolation, mocker):
        t_ref = legacy_transforms.RandAugment(interpolation=interpolation, num_ops=1)
905
        t = v2_transforms.RandAugment(interpolation=interpolation, num_ops=1)
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926

        le = len(t._AUGMENTATION_SPACE)
        keys = list(t._AUGMENTATION_SPACE.keys())
        randint_values = []
        for i in range(le):
            # Stable API, op_index random call
            randint_values.append(i)
            # Stable API, if signed there is another random call
            if t._AUGMENTATION_SPACE[keys[i]][1]:
                randint_values.append(0)
            # New API, _get_random_item
            randint_values.append(i)
        randint_values = iter(randint_values)

        mocker.patch("torch.randint", side_effect=lambda *arg, **kwargs: torch.tensor(next(randint_values)))
        mocker.patch("torch.rand", return_value=1.0)

        for i in range(le):
            expected_output = t_ref(inpt)
            output = t(inpt)

927
            assert_close(expected_output, output, atol=1, rtol=0.1)
928

929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
    @pytest.mark.parametrize(
        "interpolation",
        [
            v2_transforms.InterpolationMode.NEAREST,
            v2_transforms.InterpolationMode.BILINEAR,
        ],
    )
    def test_randaug_jit(self, interpolation):
        inpt = torch.randint(0, 256, size=(1, 3, 256, 256), dtype=torch.uint8)
        t_ref = legacy_transforms.RandAugment(interpolation=interpolation, num_ops=1)
        t = v2_transforms.RandAugment(interpolation=interpolation, num_ops=1)

        tt_ref = torch.jit.script(t_ref)
        tt = torch.jit.script(t)

        torch.manual_seed(12)
        expected_output = tt_ref(inpt)

        torch.manual_seed(12)
        scripted_output = tt(inpt)

        assert_equal(scripted_output, expected_output)

952
953
954
955
956
    @pytest.mark.parametrize(
        "inpt",
        [
            torch.randint(0, 256, size=(1, 3, 256, 256), dtype=torch.uint8),
            PIL.Image.new("RGB", (256, 256), 123),
957
            datapoints.Image(torch.randint(0, 256, size=(1, 3, 256, 256), dtype=torch.uint8)),
958
959
960
961
        ],
    )
    @pytest.mark.parametrize(
        "interpolation",
962
        [
963
964
            v2_transforms.InterpolationMode.NEAREST,
            v2_transforms.InterpolationMode.BILINEAR,
965
966
            PIL.Image.NEAREST,
        ],
967
968
969
    )
    def test_trivial_aug(self, inpt, interpolation, mocker):
        t_ref = legacy_transforms.TrivialAugmentWide(interpolation=interpolation)
970
        t = v2_transforms.TrivialAugmentWide(interpolation=interpolation)
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001

        le = len(t._AUGMENTATION_SPACE)
        keys = list(t._AUGMENTATION_SPACE.keys())
        randint_values = []
        for i in range(le):
            # Stable API, op_index random call
            randint_values.append(i)
            key = keys[i]
            # Stable API, random magnitude
            aug_op = t._AUGMENTATION_SPACE[key]
            magnitudes = aug_op[0](2, 0, 0)
            if magnitudes is not None:
                randint_values.append(5)
            # Stable API, if signed there is another random call
            if aug_op[1]:
                randint_values.append(0)
            # New API, _get_random_item
            randint_values.append(i)
            # New API, random magnitude
            if magnitudes is not None:
                randint_values.append(5)

        randint_values = iter(randint_values)

        mocker.patch("torch.randint", side_effect=lambda *arg, **kwargs: torch.tensor(next(randint_values)))
        mocker.patch("torch.rand", return_value=1.0)

        for _ in range(le):
            expected_output = t_ref(inpt)
            output = t(inpt)

1002
            assert_close(expected_output, output, atol=1, rtol=0.1)
1003

1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
    @pytest.mark.parametrize(
        "interpolation",
        [
            v2_transforms.InterpolationMode.NEAREST,
            v2_transforms.InterpolationMode.BILINEAR,
        ],
    )
    def test_trivial_aug_jit(self, interpolation):
        inpt = torch.randint(0, 256, size=(1, 3, 256, 256), dtype=torch.uint8)
        t_ref = legacy_transforms.TrivialAugmentWide(interpolation=interpolation)
        t = v2_transforms.TrivialAugmentWide(interpolation=interpolation)

        tt_ref = torch.jit.script(t_ref)
        tt = torch.jit.script(t)

        torch.manual_seed(12)
        expected_output = tt_ref(inpt)

        torch.manual_seed(12)
        scripted_output = tt(inpt)

        assert_equal(scripted_output, expected_output)

1027
1028
1029
1030
1031
    @pytest.mark.parametrize(
        "inpt",
        [
            torch.randint(0, 256, size=(1, 3, 256, 256), dtype=torch.uint8),
            PIL.Image.new("RGB", (256, 256), 123),
1032
            datapoints.Image(torch.randint(0, 256, size=(1, 3, 256, 256), dtype=torch.uint8)),
1033
1034
1035
1036
        ],
    )
    @pytest.mark.parametrize(
        "interpolation",
1037
        [
1038
1039
            v2_transforms.InterpolationMode.NEAREST,
            v2_transforms.InterpolationMode.BILINEAR,
1040
1041
            PIL.Image.NEAREST,
        ],
1042
1043
1044
1045
    )
    def test_augmix(self, inpt, interpolation, mocker):
        t_ref = legacy_transforms.AugMix(interpolation=interpolation, mixture_width=1, chain_depth=1)
        t_ref._sample_dirichlet = lambda t: t.softmax(dim=-1)
1046
        t = v2_transforms.AugMix(interpolation=interpolation, mixture_width=1, chain_depth=1)
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
        t._sample_dirichlet = lambda t: t.softmax(dim=-1)

        le = len(t._AUGMENTATION_SPACE)
        keys = list(t._AUGMENTATION_SPACE.keys())
        randint_values = []
        for i in range(le):
            # Stable API, op_index random call
            randint_values.append(i)
            key = keys[i]
            # Stable API, random magnitude
            aug_op = t._AUGMENTATION_SPACE[key]
            magnitudes = aug_op[0](2, 0, 0)
            if magnitudes is not None:
                randint_values.append(5)
            # Stable API, if signed there is another random call
            if aug_op[1]:
                randint_values.append(0)
            # New API, _get_random_item
            randint_values.append(i)
            # New API, random magnitude
            if magnitudes is not None:
                randint_values.append(5)

        randint_values = iter(randint_values)

        mocker.patch("torch.randint", side_effect=lambda *arg, **kwargs: torch.tensor(next(randint_values)))
        mocker.patch("torch.rand", return_value=1.0)

        expected_output = t_ref(inpt)
        output = t(inpt)

        assert_equal(expected_output, output)

1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
    @pytest.mark.parametrize(
        "interpolation",
        [
            v2_transforms.InterpolationMode.NEAREST,
            v2_transforms.InterpolationMode.BILINEAR,
        ],
    )
    def test_augmix_jit(self, interpolation):
        inpt = torch.randint(0, 256, size=(1, 3, 256, 256), dtype=torch.uint8)

        t_ref = legacy_transforms.AugMix(interpolation=interpolation, mixture_width=1, chain_depth=1)
        t = v2_transforms.AugMix(interpolation=interpolation, mixture_width=1, chain_depth=1)

        tt_ref = torch.jit.script(t_ref)
        tt = torch.jit.script(t)

        torch.manual_seed(12)
        expected_output = tt_ref(inpt)

        torch.manual_seed(12)
        scripted_output = tt(inpt)

        assert_equal(scripted_output, expected_output)

1104
1105
1106
1107
1108
    @pytest.mark.parametrize(
        "inpt",
        [
            torch.randint(0, 256, size=(1, 3, 256, 256), dtype=torch.uint8),
            PIL.Image.new("RGB", (256, 256), 123),
1109
            datapoints.Image(torch.randint(0, 256, size=(1, 3, 256, 256), dtype=torch.uint8)),
1110
1111
1112
1113
        ],
    )
    @pytest.mark.parametrize(
        "interpolation",
1114
        [
1115
1116
            v2_transforms.InterpolationMode.NEAREST,
            v2_transforms.InterpolationMode.BILINEAR,
1117
1118
            PIL.Image.NEAREST,
        ],
1119
1120
1121
1122
    )
    def test_aa(self, inpt, interpolation):
        aa_policy = legacy_transforms.AutoAugmentPolicy("imagenet")
        t_ref = legacy_transforms.AutoAugment(aa_policy, interpolation=interpolation)
1123
        t = v2_transforms.AutoAugment(aa_policy, interpolation=interpolation)
1124
1125
1126
1127
1128
1129
1130
1131

        torch.manual_seed(12)
        expected_output = t_ref(inpt)

        torch.manual_seed(12)
        output = t(inpt)

        assert_equal(expected_output, output)
1132

1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
    @pytest.mark.parametrize(
        "interpolation",
        [
            v2_transforms.InterpolationMode.NEAREST,
            v2_transforms.InterpolationMode.BILINEAR,
        ],
    )
    def test_aa_jit(self, interpolation):
        inpt = torch.randint(0, 256, size=(1, 3, 256, 256), dtype=torch.uint8)
        aa_policy = legacy_transforms.AutoAugmentPolicy("imagenet")
        t_ref = legacy_transforms.AutoAugment(aa_policy, interpolation=interpolation)
        t = v2_transforms.AutoAugment(aa_policy, interpolation=interpolation)

        tt_ref = torch.jit.script(t_ref)
        tt = torch.jit.script(t)

        torch.manual_seed(12)
        expected_output = tt_ref(inpt)

        torch.manual_seed(12)
        scripted_output = tt(inpt)

        assert_equal(scripted_output, expected_output)

1157

1158
def import_transforms_from_references(reference):
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
    HERE = Path(__file__).parent
    PROJECT_ROOT = HERE.parent

    loader = importlib.machinery.SourceFileLoader(
        "transforms", str(PROJECT_ROOT / "references" / reference / "transforms.py")
    )
    spec = importlib.util.spec_from_loader("transforms", loader)
    module = importlib.util.module_from_spec(spec)
    loader.exec_module(module)
    return module
1169
1170
1171


det_transforms = import_transforms_from_references("detection")
1172
1173
1174
1175
1176
1177
1178


class TestRefDetTransforms:
    def make_datapoints(self, with_mask=True):
        size = (600, 800)
        num_objects = 22

1179
1180
1181
        def make_label(extra_dims, categories):
            return torch.randint(categories, extra_dims, dtype=torch.int64)

1182
        pil_image = to_pil_image(make_image(size=size, color_space="RGB"))
1183
        target = {
1184
            "boxes": make_bounding_boxes(canvas_size=size, format="XYXY", batch_dims=(num_objects,), dtype=torch.float),
1185
1186
1187
1188
1189
1190
1191
            "labels": make_label(extra_dims=(num_objects,), categories=80),
        }
        if with_mask:
            target["masks"] = make_detection_mask(size=size, num_objects=num_objects, dtype=torch.long)

        yield (pil_image, target)

1192
        tensor_image = torch.Tensor(make_image(size=size, color_space="RGB", dtype=torch.float32))
1193
        target = {
1194
            "boxes": make_bounding_boxes(canvas_size=size, format="XYXY", batch_dims=(num_objects,), dtype=torch.float),
1195
1196
1197
1198
1199
1200
1201
            "labels": make_label(extra_dims=(num_objects,), categories=80),
        }
        if with_mask:
            target["masks"] = make_detection_mask(size=size, num_objects=num_objects, dtype=torch.long)

        yield (tensor_image, target)

1202
        datapoint_image = make_image(size=size, color_space="RGB", dtype=torch.float32)
1203
        target = {
1204
            "boxes": make_bounding_boxes(canvas_size=size, format="XYXY", batch_dims=(num_objects,), dtype=torch.float),
1205
1206
1207
1208
1209
            "labels": make_label(extra_dims=(num_objects,), categories=80),
        }
        if with_mask:
            target["masks"] = make_detection_mask(size=size, num_objects=num_objects, dtype=torch.long)

1210
        yield (datapoint_image, target)
1211
1212
1213
1214

    @pytest.mark.parametrize(
        "t_ref, t, data_kwargs",
        [
1215
            (det_transforms.RandomHorizontalFlip(p=1.0), v2_transforms.RandomHorizontalFlip(p=1.0), {}),
1216
1217
1218
1219
1220
            (
                det_transforms.RandomIoUCrop(),
                v2_transforms.Compose(
                    [
                        v2_transforms.RandomIoUCrop(),
1221
                        v2_transforms.SanitizeBoundingBoxes(labels_getter=lambda sample: sample[1]["labels"]),
1222
1223
1224
1225
                    ]
                ),
                {"with_mask": False},
            ),
1226
            (det_transforms.RandomZoomOut(), v2_transforms.RandomZoomOut(), {"with_mask": False}),
1227
            (det_transforms.ScaleJitter((1024, 1024)), v2_transforms.ScaleJitter((1024, 1024), antialias=True), {}),
1228
1229
1230
1231
            (
                det_transforms.RandomShortestSize(
                    min_size=(480, 512, 544, 576, 608, 640, 672, 704, 736, 768, 800), max_size=1333
                ),
1232
                v2_transforms.RandomShortestSize(
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
                    min_size=(480, 512, 544, 576, 608, 640, 672, 704, 736, 768, 800), max_size=1333
                ),
                {},
            ),
        ],
    )
    def test_transform(self, t_ref, t, data_kwargs):
        for dp in self.make_datapoints(**data_kwargs):

            # We should use prototype transform first as reference transform performs inplace target update
            torch.manual_seed(12)
            output = t(dp)

            torch.manual_seed(12)
            expected_output = t_ref(*dp)

            assert_equal(expected_output, output)
1250
1251
1252
1253
1254
1255
1256
1257
1258


seg_transforms = import_transforms_from_references("segmentation")


# We need this transform for two reasons:
# 1. transforms.RandomCrop uses a different scheme to pad images and masks of insufficient size than its name
#    counterpart in the detection references. Thus, we cannot use it with `pad_if_needed=True`
# 2. transforms.Pad only supports a fixed padding, but the segmentation datasets don't have a fixed image size.
1259
class PadIfSmaller(v2_transforms.Transform):
1260
1261
1262
    def __init__(self, size, fill=0):
        super().__init__()
        self.size = size
1263
        self.fill = v2_transforms._geometry._setup_fill_arg(fill)
1264
1265

    def _get_params(self, sample):
Philip Meier's avatar
Philip Meier committed
1266
        height, width = query_size(sample)
1267
1268
1269
1270
1271
1272
1273
1274
        padding = [0, 0, max(self.size - width, 0), max(self.size - height, 0)]
        needs_padding = any(padding)
        return dict(padding=padding, needs_padding=needs_padding)

    def _transform(self, inpt, params):
        if not params["needs_padding"]:
            return inpt

1275
        fill = _get_fill(self.fill, type(inpt))
1276
        return prototype_F.pad(inpt, padding=params["padding"], fill=fill)
1277
1278
1279
1280


class TestRefSegTransforms:
    def make_datapoints(self, supports_pil=True, image_dtype=torch.uint8):
1281
        size = (256, 460)
1282
1283
1284
1285
        num_categories = 21

        conv_fns = []
        if supports_pil:
1286
            conv_fns.append(to_pil_image)
1287
1288
1289
        conv_fns.extend([torch.Tensor, lambda x: x])

        for conv_fn in conv_fns:
1290
            datapoint_image = make_image(size=size, color_space="RGB", dtype=image_dtype)
1291
            datapoint_mask = make_segmentation_mask(size=size, num_categories=num_categories, dtype=torch.uint8)
1292

1293
            dp = (conv_fn(datapoint_image), datapoint_mask)
1294
            dp_ref = (
1295
1296
                to_pil_image(datapoint_image) if supports_pil else datapoint_image.as_subclass(torch.Tensor),
                to_pil_image(datapoint_mask),
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
            )

            yield dp, dp_ref

    def set_seed(self, seed=12):
        torch.manual_seed(seed)
        random.seed(seed)

    def check(self, t, t_ref, data_kwargs=None):
        for dp, dp_ref in self.make_datapoints(**data_kwargs or dict()):

            self.set_seed()
1309
            actual = actual_image, actual_mask = t(dp)
1310
1311

            self.set_seed()
1312
1313
1314
1315
1316
            expected_image, expected_mask = t_ref(*dp_ref)
            if isinstance(actual_image, torch.Tensor) and not isinstance(expected_image, torch.Tensor):
                expected_image = legacy_F.pil_to_tensor(expected_image)
            expected_mask = legacy_F.pil_to_tensor(expected_mask).squeeze(0)
            expected = (expected_image, expected_mask)
1317

1318
            assert_equal(actual, expected)
1319
1320
1321
1322
1323
1324

    @pytest.mark.parametrize(
        ("t_ref", "t", "data_kwargs"),
        [
            (
                seg_transforms.RandomHorizontalFlip(flip_prob=1.0),
1325
                v2_transforms.RandomHorizontalFlip(p=1.0),
1326
1327
1328
1329
                dict(),
            ),
            (
                seg_transforms.RandomHorizontalFlip(flip_prob=0.0),
1330
                v2_transforms.RandomHorizontalFlip(p=0.0),
1331
1332
1333
1334
                dict(),
            ),
            (
                seg_transforms.RandomCrop(size=480),
1335
                v2_transforms.Compose(
1336
                    [
1337
                        PadIfSmaller(size=480, fill={datapoints.Mask: 255, "others": 0}),
1338
                        v2_transforms.RandomCrop(size=480),
1339
1340
1341
1342
1343
1344
                    ]
                ),
                dict(),
            ),
            (
                seg_transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
1345
                v2_transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
1346
1347
1348
1349
1350
1351
1352
                dict(supports_pil=False, image_dtype=torch.float),
            ),
        ],
    )
    def test_common(self, t_ref, t, data_kwargs):
        self.check(t, t_ref, data_kwargs)

1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364

@pytest.mark.parametrize(
    ("legacy_dispatcher", "name_only_params"),
    [
        (legacy_F.get_dimensions, {}),
        (legacy_F.get_image_size, {}),
        (legacy_F.get_image_num_channels, {}),
        (legacy_F.to_tensor, {}),
        (legacy_F.pil_to_tensor, {}),
        (legacy_F.convert_image_dtype, {}),
        (legacy_F.to_pil_image, {}),
        (legacy_F.normalize, {}),
1365
        (legacy_F.resize, {"interpolation"}),
1366
1367
1368
        (legacy_F.pad, {"padding", "fill"}),
        (legacy_F.crop, {}),
        (legacy_F.center_crop, {}),
1369
        (legacy_F.resized_crop, {"interpolation"}),
1370
        (legacy_F.hflip, {}),
1371
        (legacy_F.perspective, {"startpoints", "endpoints", "fill", "interpolation"}),
1372
1373
1374
1375
1376
1377
1378
1379
        (legacy_F.vflip, {}),
        (legacy_F.five_crop, {}),
        (legacy_F.ten_crop, {}),
        (legacy_F.adjust_brightness, {}),
        (legacy_F.adjust_contrast, {}),
        (legacy_F.adjust_saturation, {}),
        (legacy_F.adjust_hue, {}),
        (legacy_F.adjust_gamma, {}),
1380
1381
        (legacy_F.rotate, {"center", "fill", "interpolation"}),
        (legacy_F.affine, {"angle", "translate", "center", "fill", "interpolation"}),
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
        (legacy_F.to_grayscale, {}),
        (legacy_F.rgb_to_grayscale, {}),
        (legacy_F.to_tensor, {}),
        (legacy_F.erase, {}),
        (legacy_F.gaussian_blur, {}),
        (legacy_F.invert, {}),
        (legacy_F.posterize, {}),
        (legacy_F.solarize, {}),
        (legacy_F.adjust_sharpness, {}),
        (legacy_F.autocontrast, {}),
        (legacy_F.equalize, {}),
1393
        (legacy_F.elastic_transform, {"fill", "interpolation"}),
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
    ],
)
def test_dispatcher_signature_consistency(legacy_dispatcher, name_only_params):
    legacy_signature = inspect.signature(legacy_dispatcher)
    legacy_params = list(legacy_signature.parameters.values())[1:]

    try:
        prototype_dispatcher = getattr(prototype_F, legacy_dispatcher.__name__)
    except AttributeError:
        raise AssertionError(
            f"Legacy dispatcher `F.{legacy_dispatcher.__name__}` has no prototype equivalent"
        ) from None

    prototype_signature = inspect.signature(prototype_dispatcher)
    prototype_params = list(prototype_signature.parameters.values())[1:]

    # Some dispatchers got extra parameters. This makes sure they have a default argument and thus are BC. We don't
    # need to check if parameters were added in the middle rather than at the end, since that will be caught by the
    # regular check below.
    prototype_params, new_prototype_params = (
        prototype_params[: len(legacy_params)],
        prototype_params[len(legacy_params) :],
    )
    for param in new_prototype_params:
        assert param.default is not param.empty

    # Some annotations were changed mostly to supersets of what was there before. Plus, some legacy dispatchers had no
    # annotations. In these cases we simply drop the annotation and default argument from the comparison
    for prototype_param, legacy_param in zip(prototype_params, legacy_params):
        if legacy_param.name in name_only_params:
            prototype_param._annotation = prototype_param._default = inspect.Parameter.empty
            legacy_param._annotation = legacy_param._default = inspect.Parameter.empty
        elif legacy_param.annotation is inspect.Parameter.empty:
            prototype_param._annotation = inspect.Parameter.empty

    assert prototype_params == legacy_params