Merge branch 'master' into mobilenetv3_segmentation

Author: datumbox

packaging/conda/build_vision.sh

@@ -163,12 +163,6 @@ for py_ver in "${DESIRED_PYTHON[@]}"; do
     rm -rf "$output_folder"
     mkdir "$output_folder"
 
-    if [[ "$py_ver" == 3.5 ]]; then
-      export CONDA_TYPING_CONSTRAINT="- typing"
-    else
-      export CONDA_TYPING_CONSTRAINT=""
-    fi
-
     export VSTOOLCHAIN_PACKAGE=vs2017
 
     # We need to build the compiler activation scripts first on Windows

packaging/pkg_helpers.bash

@@ -143,14 +143,6 @@ setup_macos() {
   fi
 }
 
-# set variable to determine whether the typing library needs to be built in
-setup_typing() {
-  if [[ "$PYTHON_VERSION" == 3.5 ]]; then
-    export CONDA_TYPING_CONSTRAINT="- typing"
-  else
-    export CONDA_TYPING_CONSTRAINT=""
-  fi
-}
 
 # Top-level entry point for things every package will need to do
 #
@@ -159,7 +151,6 @@ setup_env() {
   setup_cuda
   setup_build_version "$1"
   setup_macos
-  setup_typing
 }
 
 # Function to retry functions that sometimes timeout or have flaky failures

packaging/torchvision/meta.yaml

@@ -52,7 +52,6 @@ test:
     - scipy
     - av =8.0.1
     - ca-certificates
-    {{ environ.get('CONDA_TYPING_CONSTRAINT') }}
 
 
 about:

references/detection/coco_eval.py

@@ -238,8 +238,10 @@ def createIndex(self):
 def loadRes(self, resFile):
     """
     Load result file and return a result api object.
-    :param   resFile (str)     : file name of result file
-    :return: res (obj)         : result api object
+    Args:
+        resFile (str): file name of result file
+    Returns:
+    res (obj): result api object
     """
     res = COCO()
     res.dataset['images'] = [img for img in self.dataset['images']]

references/segmentation/train.py

@@ -133,11 +133,6 @@ def main(args):
         model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu])
         model_without_ddp = model.module
 
-    if args.test_only:
-        confmat = evaluate(model, data_loader_test, device=device, num_classes=num_classes)
-        print(confmat)
-        return
-
     params_to_optimize = [
         {"params": [p for p in model_without_ddp.backbone.parameters() if p.requires_grad]},
         {"params": [p for p in model_without_ddp.classifier.parameters() if p.requires_grad]},
@@ -155,10 +150,16 @@ def main(args):
 
     if args.resume:
         checkpoint = torch.load(args.resume, map_location='cpu')
-        model_without_ddp.load_state_dict(checkpoint['model'])
-        optimizer.load_state_dict(checkpoint['optimizer'])
-        lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
-        args.start_epoch = checkpoint['epoch'] + 1
+        model_without_ddp.load_state_dict(checkpoint['model'], strict=not args.test_only)
+        if not args.test_only:
+            optimizer.load_state_dict(checkpoint['optimizer'])
+            lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
+            args.start_epoch = checkpoint['epoch'] + 1
+
+    if args.test_only:
+        confmat = evaluate(model, data_loader_test, device=device, num_classes=num_classes)
+        print(confmat)
+        return
 
     start_time = time.time()
     for epoch in range(args.start_epoch, args.epochs):

test/expect/ModelTester.test_deeplabv3_resnet101_expect.pkl

@@ -59,6 +59,10 @@ def get_available_video_models():
     "resnet101",
     "resnet152",
     "wide_resnet101_2",
+    "deeplabv3_resnet50",
+    "deeplabv3_resnet101",
+    "fcn_resnet50",
+    "fcn_resnet101",
 )
 
 
@@ -85,21 +89,53 @@ def _test_classification_model(self, name, input_shape, dev):
                 self.assertEqual(out.shape[-1], 50)
 
     def _test_segmentation_model(self, name, dev):
-        # passing num_class equal to a number other than 1000 helps in making the test
-        # more enforcing in nature
-        model = models.segmentation.__dict__[name](num_classes=50, pretrained_backbone=False)
+        set_rng_seed(0)
+        # passing num_classes equal to a number other than 21 helps in making the test's
+        # expected file size smaller
+        model = models.segmentation.__dict__[name](num_classes=10, pretrained_backbone=False)
         model.eval().to(device=dev)
-        input_shape = (1, 3, 300, 300)
+        input_shape = (1, 3, 32, 32)
         # 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.assertEqual(tuple(out["out"].shape), (1, 50, 300, 300))
+        out = model(x)["out"]
+
+        def check_out(out):
+            prec = 0.01
+            strip_suffix = f"_{dev}"
+            try:
+                # We first try to assert the entire output if possible. This is not
+                # only the best way to assert results but also handles the cases
+                # where we need to create a new expected result.
+                self.assertExpected(out.cpu(), prec=prec, strip_suffix=strip_suffix)
+            except AssertionError:
+                # Unfortunately some segmentation models are flaky with autocast
+                # so instead of validating the probability scores, check that the class
+                # predictions match.
+                expected_file = self._get_expected_file(strip_suffix=strip_suffix)
+                expected = torch.load(expected_file)
+                self.assertEqual(out.argmax(dim=1), expected.argmax(dim=1), prec=prec)
+                return False  # Partial validation performed
+
+            return True  # Full validation performed
+
+        full_validation = check_out(out)
+
         self.check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None))
 
         if dev == torch.device("cuda"):
             with torch.cuda.amp.autocast():
-                out = model(x)
-                self.assertEqual(tuple(out["out"].shape), (1, 50, 300, 300))
+                out = model(x)["out"]
+                # See autocast_flaky_numerics comment at top of file.
+                if name not in autocast_flaky_numerics:
+                    full_validation &= check_out(out)
+
+        if not full_validation:
+            msg = "The output of {} could only be partially validated. " \
+                  "This is likely due to unit-test flakiness, but you may " \
+                  "want to do additional manual checks if you made " \
+                  "significant changes to the codebase.".format(self._testMethodName)
+            warnings.warn(msg, RuntimeWarning)
+            raise unittest.SkipTest(msg)
 
     def _test_detection_model(self, name, dev):
         set_rng_seed(0)