Merge branch 'master' into feature/retina_emptyannotation

Author: datumbox

.circleci/unittest/linux/scripts/run_test.sh

@@ -5,5 +5,6 @@ set -e
 eval "$(./conda/bin/conda shell.bash hook)"
 conda activate ./env
 
+export PYTORCH_TEST_WITH_SLOW='1'
 python -m torch.utils.collect_env
-pytest --cov=torchvision --junitxml=test-results/junit.xml -v --durations 20 test --ignore=test/test_datasets_download.py
+pytest --cov=torchvision --junitxml=test-results/junit.xml -v --durations 20 test --ignore=test/test_datasets_download.py

.circleci/unittest/windows/scripts/run_test.sh

@@ -5,5 +5,6 @@ set -e
 eval "$(./conda/Scripts/conda.exe 'shell.bash' 'hook')"
 conda activate ./env
 
+export PYTORCH_TEST_WITH_SLOW='1'
 python -m torch.utils.collect_env
-pytest --cov=torchvision --junitxml=test-results/junit.xml -v --durations 20 test --ignore=test/test_datasets_download.py
+pytest --cov=torchvision --junitxml=test-results/junit.xml -v --durations 20 test --ignore=test/test_datasets_download.py

docs/source/io.rst

@@ -35,7 +35,7 @@ Example of inspecting a video:
     import torchvision
     video_path = "path to a test video"
     # Constructor allocates memory and a threaded decoder
-    # instance per video. At the momet it takes two arguments:
+    # instance per video. At the moment it takes two arguments:
     # path to the video file, and a wanted stream.
     reader = torchvision.io.VideoReader(video_path, "video")
 

mypy.ini

@@ -12,6 +12,10 @@ ignore_errors = True
 
 ignore_errors = True
 
+[mypy-torchvision.models.densenet.*]
+
+ignore_errors=True
+
 [mypy-torchvision.models.detection.*]
 
 ignore_errors = True

test/common_utils.py

@@ -7,7 +7,7 @@
 import sys
 import io
 import torch
-import errno
+import warnings
 import __main__
 
 from numbers import Number
@@ -265,14 +265,21 @@ def assertTensorsEqual(a, b):
         else:
             super(TestCase, self).assertEqual(x, y, message)
 
-    def checkModule(self, nn_module, args, unwrapper=None, skip=False):
+    def check_jit_scriptable(self, nn_module, args, unwrapper=None, skip=False):
         """
         Check that a nn.Module's results in TorchScript match eager and that it
         can be exported
         """
         if not TEST_WITH_SLOW or skip:
             # TorchScript is not enabled, skip these tests
-            return
+            msg = "The check_jit_scriptable test for {} was skipped. " \
+                  "This test checks if the module's results in TorchScript " \
+                  "match eager and that it can be exported. To run these " \
+                  "tests make sure you set the environment variable " \
+                  "PYTORCH_TEST_WITH_SLOW=1 and that the test is not " \
+                  "manually skipped.".format(nn_module.__class__.__name__)
+            warnings.warn(msg, RuntimeWarning)
+            return None
 
         sm = torch.jit.script(nn_module)
 
@@ -284,7 +291,7 @@ def checkModule(self, nn_module, args, unwrapper=None, skip=False):
             if unwrapper:
                 script_out = unwrapper(script_out)
 
-        self.assertEqual(eager_out, script_out)
+        self.assertEqual(eager_out, script_out, prec=1e-4)
         self.assertExportImportModule(sm, args)
 
         return sm

test/test_datasets_video_utils.py

@@ -119,6 +119,16 @@ def test_compute_clips_for_video(self):
         self.assertTrue(clips.equal(idxs))
         self.assertTrue(idxs.flatten().equal(resampled_idxs))
 
+        # case 3: frames aren't enough for a clip
+        num_frames = 32
+        orig_fps = 30
+        new_fps = 13
+        with self.assertWarns(UserWarning):
+            clips, idxs = VideoClips.compute_clips_for_video(video_pts, num_frames, num_frames,
+                                                             orig_fps, new_fps)
+        self.assertEqual(len(clips), 0)
+        self.assertEqual(len(idxs), 0)
+
 
 if __name__ == '__main__':
     unittest.main()

test/test_image.py

@@ -2,14 +2,12 @@
 import io
 import glob
 import unittest
-import sys
 
 import torch
-import torchvision
 from PIL import Image
 from torchvision.io.image import (
     decode_png, decode_jpeg, encode_jpeg, write_jpeg, decode_image, read_file,
-    encode_png, write_png, write_file)
+    encode_png, write_png, write_file, ImageReadMode)
 import numpy as np
 
 from common_utils import get_tmp_dir
@@ -49,9 +47,9 @@ def normalize_dimensions(img_pil):
 
 class ImageTester(unittest.TestCase):
     def test_decode_jpeg(self):
-        conversion = [(None, 0), ("L", 1), ("RGB", 3)]
+        conversion = [(None, ImageReadMode.UNCHANGED), ("L", ImageReadMode.GRAY), ("RGB", ImageReadMode.RGB)]
         for img_path in get_images(IMAGE_ROOT, ".jpg"):
-            for pil_mode, channels in conversion:
+            for pil_mode, mode in conversion:
                 with Image.open(img_path) as img:
                     is_cmyk = img.mode == "CMYK"
                     if pil_mode is not None:
@@ -66,7 +64,7 @@ def test_decode_jpeg(self):
 
                 img_pil = normalize_dimensions(img_pil)
                 data = read_file(img_path)
-                img_ljpeg = decode_image(data, channels=channels)
+                img_ljpeg = decode_image(data, mode=mode)
 
                 # Permit a small variation on pixel values to account for implementation
                 # differences between Pillow and LibJPEG.
@@ -165,17 +163,18 @@ def test_write_jpeg(self):
             self.assertEqual(torch_bytes, pil_bytes)
 
     def test_decode_png(self):
-        conversion = [(None, 0), ("L", 1), ("LA", 2), ("RGB", 3), ("RGBA", 4)]
+        conversion = [(None, ImageReadMode.UNCHANGED), ("L", ImageReadMode.GRAY), ("LA", ImageReadMode.GRAY_ALPHA),
+                      ("RGB", ImageReadMode.RGB), ("RGBA", ImageReadMode.RGB_ALPHA)]
         for img_path in get_images(FAKEDATA_DIR, ".png"):
-            for pil_mode, channels in conversion:
+            for pil_mode, mode in conversion:
                 with Image.open(img_path) as img:
                     if pil_mode is not None:
                         img = img.convert(pil_mode)
                     img_pil = torch.from_numpy(np.array(img))
 
                 img_pil = normalize_dimensions(img_pil)
                 data = read_file(img_path)
-                img_lpng = decode_image(data, channels=channels)
+                img_lpng = decode_image(data, mode=mode)
 
                 tol = 0 if conversion is None else 1
                 self.assertTrue(img_lpng.allclose(img_pil, atol=tol))

test/test_models.py

@@ -38,44 +38,16 @@ def get_available_video_models():
     return [k for k, v in models.video.__dict__.items() if callable(v) and k[0].lower() == k[0] and k[0] != "_"]
 
 
-# models that are in torch hub, as well as r3d_18. we tried testing all models
-# but the test was too slow. not included are detection models, because
-# they are not yet supported in JIT.
 # If 'unwrapper' is provided it will be called with the script model outputs
 # before they are compared to the eager model outputs. This is useful if the
 # model outputs are different between TorchScript / Eager mode
-script_test_models = {
-    'deeplabv3_resnet50': {},
-    'deeplabv3_resnet101': {},
-    'mobilenet_v2': {},
-    'resnext50_32x4d': {},
-    'fcn_resnet50': {},
-    'fcn_resnet101': {},
-    'googlenet': {
-        'unwrapper': lambda x: x.logits
-    },
-    'densenet121': {},
-    'resnet18': {},
-    'alexnet': {},
-    'shufflenet_v2_x1_0': {},
-    'squeezenet1_0': {},
-    'vgg11': {},
-    'inception_v3': {
-        'unwrapper': lambda x: x.logits
-    },
-    'r3d_18': {},
-    "fasterrcnn_resnet50_fpn": {
-        'unwrapper': lambda x: x[1]
-    },
-    "maskrcnn_resnet50_fpn": {
-        'unwrapper': lambda x: x[1]
-    },
-    "keypointrcnn_resnet50_fpn": {
-        'unwrapper': lambda x: x[1]
-    },
-    "retinanet_resnet50_fpn": {
-        'unwrapper': lambda x: x[1]
-    }
+script_model_unwrapper = {
+    'googlenet': lambda x: x.logits,
+    'inception_v3': lambda x: x.logits,
+    "fasterrcnn_resnet50_fpn": lambda x: x[1],
+    "maskrcnn_resnet50_fpn": lambda x: x[1],
+    "keypointrcnn_resnet50_fpn": lambda x: x[1],
+    "retinanet_resnet50_fpn": lambda x: x[1],
 }
 
 
@@ -97,12 +69,6 @@ def get_available_video_models():
 
 
 class ModelTester(TestCase):
-    def checkModule(self, model, name, args):
-        if name not in script_test_models:
-            return
-        unwrapper = script_test_models[name].get('unwrapper', None)
-        return super(ModelTester, self).checkModule(model, args, unwrapper=unwrapper, skip=False)
-
     def _test_classification_model(self, name, input_shape, dev):
         set_rng_seed(0)
         # passing num_class equal to a number other than 1000 helps in making the test
@@ -114,7 +80,7 @@ def _test_classification_model(self, name, input_shape, dev):
         out = model(x)
         self.assertExpected(out.cpu(), prec=0.1, strip_suffix="_" + dev)
         self.assertEqual(out.shape[-1], 50)
-        self.checkModule(model, name, (x,))
+        self.check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None))
 
         if dev == "cuda":
             with torch.cuda.amp.autocast():
@@ -134,7 +100,7 @@ def _test_segmentation_model(self, name, dev):
         x = torch.rand(input_shape).to(device=dev)
         out = model(x)
         self.assertEqual(tuple(out["out"].shape), (1, 50, 300, 300))
-        self.checkModule(model, name, (x,))
+        self.check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None))
 
         if dev == "cuda":
             with torch.cuda.amp.autocast():
@@ -209,18 +175,7 @@ def compute_mean_std(tensor):
             return True  # Full validation performed
 
         full_validation = check_out(out)
-
-        scripted_model = torch.jit.script(model)
-        scripted_model.eval()
-        scripted_out = scripted_model(model_input)[1]
-        self.assertEqual(scripted_out[0]["boxes"], out[0]["boxes"])
-        self.assertEqual(scripted_out[0]["scores"], out[0]["scores"])
-        # labels currently float in script: need to investigate (though same result)
-        self.assertEqual(scripted_out[0]["labels"].to(dtype=torch.long), out[0]["labels"])
-        # don't check script because we are compiling it here:
-        # TODO: refactor tests
-        # self.check_script(model, name)
-        self.checkModule(model, name, ([x],))
+        self.check_jit_scriptable(model, ([x],), unwrapper=script_model_unwrapper.get(name, None))
 
         if dev == "cuda":
             with torch.cuda.amp.autocast():
@@ -270,7 +225,7 @@ def _test_video_model(self, name, dev):
         # RNG always on CPU, to ensure x in cuda tests is bitwise identical to x in cpu tests
         x = torch.rand(input_shape).to(device=dev)
         out = model(x)
-        self.checkModule(model, name, (x,))
+        self.check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None))
         self.assertEqual(out.shape[-1], 50)
 
         if dev == "cuda":
@@ -345,11 +300,13 @@ def test_inceptionv3_eval(self):
         kwargs['transform_input'] = True
         kwargs['aux_logits'] = True
         kwargs['init_weights'] = False
+        name = "inception_v3"
         model = models.Inception3(**kwargs)
         model.aux_logits = False
         model.AuxLogits = None
-        m = torch.jit.script(model.eval())
-        self.checkModule(m, "inception_v3", torch.rand(1, 3, 299, 299))
+        model = model.eval()
+        x = torch.rand(1, 3, 299, 299)
+        self.check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None))
 
     def test_fasterrcnn_double(self):
         model = models.detection.fasterrcnn_resnet50_fpn(num_classes=50, pretrained_backbone=False)
@@ -371,12 +328,14 @@ def test_googlenet_eval(self):
         kwargs['transform_input'] = True
         kwargs['aux_logits'] = True
         kwargs['init_weights'] = False
+        name = "googlenet"
         model = models.GoogLeNet(**kwargs)
         model.aux_logits = False
         model.aux1 = None
         model.aux2 = None
-        m = torch.jit.script(model.eval())
-        self.checkModule(m, "googlenet", torch.rand(1, 3, 224, 224))
+        model = model.eval()
+        x = torch.rand(1, 3, 224, 224)
+        self.check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None))
 
     @unittest.skipIf(not torch.cuda.is_available(), 'needs GPU')
     def test_fasterrcnn_switch_devices(self):

test/test_models_detection_anchor_utils.py

@@ -1,11 +1,11 @@
 from collections import OrderedDict
 import torch
-import unittest
+from common_utils import TestCase
 from torchvision.models.detection.anchor_utils import AnchorGenerator
 from torchvision.models.detection.image_list import ImageList
 
 
-class Tester(unittest.TestCase):
+class Tester(TestCase):
     def test_incorrect_anchors(self):
         incorrect_sizes = ((2, 4, 8), (32, 8), )
         incorrect_aspects = (0.5, 1.0)
@@ -16,40 +16,46 @@ def test_incorrect_anchors(self):
         self.assertRaises(ValueError, anc, image_list, feature_maps)
 
     def _init_test_anchor_generator(self):
-        anchor_sizes = tuple((x,) for x in [32, 64, 128])
-        aspect_ratios = ((0.5, 1.0, 2.0),) * len(anchor_sizes)
+        anchor_sizes = ((10,),)
+        aspect_ratios = ((1,),)
         anchor_generator = AnchorGenerator(anchor_sizes, aspect_ratios)
 
         return anchor_generator
 
     def get_features(self, images):
         s0, s1 = images.shape[-2:]
-        features = [
-            ('0', torch.rand(2, 8, s0 // 4, s1 // 4)),
-            ('1', torch.rand(2, 16, s0 // 8, s1 // 8)),
-            ('2', torch.rand(2, 32, s0 // 16, s1 // 16)),
-        ]
-        features = OrderedDict(features)
+        features = [torch.rand(2, 8, s0 // 5, s1 // 5)]
         return features
 
     def test_anchor_generator(self):
-        images = torch.randn(2, 3, 16, 32)
+        images = torch.randn(2, 3, 15, 15)
         features = self.get_features(images)
-        features = list(features.values())
         image_shapes = [i.shape[-2:] for i in images]
         images = ImageList(images, image_shapes)
 
         model = self._init_test_anchor_generator()
         model.eval()
         anchors = model(images, features)
 
-        # Compute target anchors numbers
+        # Estimate the number of target anchors
         grid_sizes = [f.shape[-2:] for f in features]
         num_anchors_estimated = 0
         for sizes, num_anchors_per_loc in zip(grid_sizes, model.num_anchors_per_location()):
             num_anchors_estimated += sizes[0] * sizes[1] * num_anchors_per_loc
 
-        self.assertEqual(num_anchors_estimated, 126)
+        anchors_output = torch.tensor([[-5., -5., 5., 5.],
+                                       [0., -5., 10., 5.],
+                                       [5., -5., 15., 5.],
+                                       [-5., 0., 5., 10.],
+                                       [0., 0., 10., 10.],
+                                       [5., 0., 15., 10.],
+                                       [-5., 5., 5., 15.],
+                                       [0., 5., 10., 15.],
+                                       [5., 5., 15., 15.]])
+
+        self.assertEqual(num_anchors_estimated, 9)
         self.assertEqual(len(anchors), 2)
-        self.assertEqual(tuple(anchors[0].shape), (num_anchors_estimated, 4))
-        self.assertEqual(tuple(anchors[1].shape), (num_anchors_estimated, 4))
+        self.assertEqual(tuple(anchors[0].shape), (9, 4))
+        self.assertEqual(tuple(anchors[1].shape), (9, 4))
+        self.assertEqual(anchors[0], anchors_output)
+        self.assertEqual(anchors[1], anchors_output)