Fixing tests

Author: datumbox

test/test_backbone_utils.py

@@ -23,30 +23,30 @@ def get_available_models():
 @pytest.mark.parametrize("backbone_name", ("resnet18", "resnet50"))
 def test_resnet_fpn_backbone(backbone_name):
     x = torch.rand(1, 3, 300, 300, dtype=torch.float32, device="cpu")
-    model = resnet_fpn_backbone(backbone_name=backbone_name)
+    model = resnet_fpn_backbone(backbone_name=backbone_name, weights=None)
     assert isinstance(model, BackboneWithFPN)
     y = model(x)
     assert list(y.keys()) == ["0", "1", "2", "3", "pool"]
 
     with pytest.raises(ValueError, match=r"Trainable layers should be in the range"):
-        resnet_fpn_backbone(backbone_name=backbone_name, trainable_layers=6)
+        resnet_fpn_backbone(backbone_name=backbone_name, weights=None, trainable_layers=6)
     with pytest.raises(ValueError, match=r"Each returned layer should be in the range"):
-        resnet_fpn_backbone(backbone_name=backbone_name, returned_layers=[0, 1, 2, 3])
+        resnet_fpn_backbone(backbone_name=backbone_name, weights=None, returned_layers=[0, 1, 2, 3])
     with pytest.raises(ValueError, match=r"Each returned layer should be in the range"):
-        resnet_fpn_backbone(backbone_name=backbone_name, returned_layers=[2, 3, 4, 5])
+        resnet_fpn_backbone(backbone_name=backbone_name, weights=None, returned_layers=[2, 3, 4, 5])
 
 
 @pytest.mark.parametrize("backbone_name", ("mobilenet_v2", "mobilenet_v3_large", "mobilenet_v3_small"))
 def test_mobilenet_backbone(backbone_name):
     with pytest.raises(ValueError, match=r"Trainable layers should be in the range"):
-        mobilenet_backbone(backbone_name=backbone_name, fpn=False, trainable_layers=-1)
+        mobilenet_backbone(backbone_name=backbone_name, weights=None, fpn=False, trainable_layers=-1)
     with pytest.raises(ValueError, match=r"Each returned layer should be in the range"):
-        mobilenet_backbone(backbone_name=backbone_name, fpn=True, returned_layers=[-1, 0, 1, 2])
+        mobilenet_backbone(backbone_name=backbone_name, weights=None, fpn=True, returned_layers=[-1, 0, 1, 2])
     with pytest.raises(ValueError, match=r"Each returned layer should be in the range"):
-        mobilenet_backbone(backbone_name=backbone_name, fpn=True, returned_layers=[3, 4, 5, 6])
-    model_fpn = mobilenet_backbone(backbone_name=backbone_name, fpn=True)
+        mobilenet_backbone(backbone_name=backbone_name, weights=None, fpn=True, returned_layers=[3, 4, 5, 6])
+    model_fpn = mobilenet_backbone(backbone_name=backbone_name, weights=None, fpn=True)
     assert isinstance(model_fpn, BackboneWithFPN)
-    model = mobilenet_backbone(backbone_name=backbone_name, fpn=False)
+    model = mobilenet_backbone(backbone_name=backbone_name, weights=None, fpn=False)
     assert isinstance(model, torch.nn.Sequential)
 
 

test/test_models.py

@@ -428,7 +428,7 @@ def test_inception_v3_eval():
 
 
 def test_fasterrcnn_double():
-    model = models.detection.fasterrcnn_resnet50_fpn(num_classes=50)
+    model = models.detection.fasterrcnn_resnet50_fpn(num_classes=50, weights=None, weights_backbone=None)
     model.double()
     model.eval()
     input_shape = (3, 300, 300)
@@ -467,7 +467,7 @@ def checkOut(out):
         assert "scores" in out[0]
         assert "labels" in out[0]
 
-    model = models.detection.fasterrcnn_resnet50_fpn(num_classes=50)
+    model = models.detection.fasterrcnn_resnet50_fpn(num_classes=50, weights=None, weights_backbone=None)
     model.cuda()
     model.eval()
     input_shape = (3, 300, 300)
@@ -583,6 +583,7 @@ def test_segmentation_model(model_fn, dev):
     set_rng_seed(0)
     defaults = {
         "num_classes": 10,
+        "weights_backbone": None,
         "input_shape": (1, 3, 32, 32),
     }
     model_name = model_fn.__name__
@@ -644,6 +645,7 @@ def test_detection_model(model_fn, dev):
     set_rng_seed(0)
     defaults = {
         "num_classes": 50,
+        "weights_backbone": None,
         "input_shape": (3, 300, 300),
     }
     model_name = model_fn.__name__
@@ -738,7 +740,7 @@ def compute_mean_std(tensor):
 @pytest.mark.parametrize("model_fn", get_models_from_module(models.detection))
 def test_detection_model_validation(model_fn):
     set_rng_seed(0)
-    model = model_fn(num_classes=50)
+    model = model_fn(num_classes=50, weights=None, weights_backbone=None)
     input_shape = (3, 300, 300)
     x = [torch.rand(input_shape)]
 
@@ -851,7 +853,7 @@ def test_detection_model_trainable_backbone_layers(model_fn, disable_weight_load
     max_trainable = _model_tests_values[model_name]["max_trainable"]
     n_trainable_params = []
     for trainable_layers in range(0, max_trainable + 1):
-        model = model_fn(weights_backbone="DEFAULT", trainable_backbone_layers=trainable_layers)
+        model = model_fn(weights=None, weights_backbone="DEFAULT", trainable_backbone_layers=trainable_layers)
 
         n_trainable_params.append(len([p for p in model.parameters() if p.requires_grad]))
     assert n_trainable_params == _model_tests_values[model_name]["n_trn_params_per_layer"]

test/test_models_detection_negative_samples.py

@@ -99,7 +99,7 @@ def test_assign_targets_to_proposals(self):
         ],
     )
     def test_forward_negative_sample_frcnn(self, name):
-        model = torchvision.models.detection.__dict__[name](num_classes=2, min_size=100, max_size=100)
+        model = torchvision.models.detection.__dict__[name](weights=None, weights_backbone=None, num_classes=2, min_size=100, max_size=100)
 
         images, targets = self._make_empty_sample()
         loss_dict = model(images, targets)
@@ -108,7 +108,7 @@ def test_forward_negative_sample_frcnn(self, name):
         assert_equal(loss_dict["loss_rpn_box_reg"], torch.tensor(0.0))
 
     def test_forward_negative_sample_mrcnn(self):
-        model = torchvision.models.detection.maskrcnn_resnet50_fpn(num_classes=2, min_size=100, max_size=100)
+        model = torchvision.models.detection.maskrcnn_resnet50_fpn(weights=None, weights_backbone=None, num_classes=2, min_size=100, max_size=100)
 
         images, targets = self._make_empty_sample(add_masks=True)
         loss_dict = model(images, targets)
@@ -118,7 +118,7 @@ def test_forward_negative_sample_mrcnn(self):
         assert_equal(loss_dict["loss_mask"], torch.tensor(0.0))
 
     def test_forward_negative_sample_krcnn(self):
-        model = torchvision.models.detection.keypointrcnn_resnet50_fpn(num_classes=2, min_size=100, max_size=100)
+        model = torchvision.models.detection.keypointrcnn_resnet50_fpn(weights=None, weights_backbone=None, num_classes=2, min_size=100, max_size=100)
 
         images, targets = self._make_empty_sample(add_keypoints=True)
         loss_dict = model(images, targets)
@@ -128,15 +128,15 @@ def test_forward_negative_sample_krcnn(self):
         assert_equal(loss_dict["loss_keypoint"], torch.tensor(0.0))
 
     def test_forward_negative_sample_retinanet(self):
-        model = torchvision.models.detection.retinanet_resnet50_fpn(num_classes=2, min_size=100, max_size=100)
+        model = torchvision.models.detection.retinanet_resnet50_fpn(weights=None, weights_backbone=None, num_classes=2, min_size=100, max_size=100)
 
         images, targets = self._make_empty_sample()
         loss_dict = model(images, targets)
 
         assert_equal(loss_dict["bbox_regression"], torch.tensor(0.0))
 
     def test_forward_negative_sample_fcos(self):
-        model = torchvision.models.detection.fcos_resnet50_fpn(num_classes=2, min_size=100, max_size=100)
+        model = torchvision.models.detection.fcos_resnet50_fpn(weights=None, weights_backbone=None, num_classes=2, min_size=100, max_size=100)
 
         images, targets = self._make_empty_sample()
         loss_dict = model(images, targets)
@@ -145,7 +145,7 @@ def test_forward_negative_sample_fcos(self):
         assert_equal(loss_dict["bbox_ctrness"], torch.tensor(0.0))
 
     def test_forward_negative_sample_ssd(self):
-        model = torchvision.models.detection.ssd300_vgg16(num_classes=2)
+        model = torchvision.models.detection.ssd300_vgg16(weights=None, weights_backbone=None, num_classes=2)
 
         images, targets = self._make_empty_sample()
         loss_dict = model(images, targets)

test/test_models_detection_utils.py

@@ -40,7 +40,7 @@ def test_resnet_fpn_backbone_frozen_layers(self, train_layers, exp_froz_params):
         # be frozen for each trainable_backbone_layers parameter value
         # i.e all 53 params are frozen if trainable_backbone_layers=0
         # ad first 24 params are frozen if trainable_backbone_layers=2
-        model = backbone_utils.resnet_fpn_backbone("resnet50", trainable_layers=train_layers)
+        model = backbone_utils.resnet_fpn_backbone("resnet50", weights=None, trainable_layers=train_layers)
         # boolean list that is true if the param at that index is frozen
         is_frozen = [not parameter.requires_grad for _, parameter in model.named_parameters()]
         # check that expected initial number of layers are frozen

test/tracing/frcnn/trace_model.py

@@ -6,7 +6,7 @@
 HERE = osp.dirname(osp.abspath(__file__))
 ASSETS = osp.dirname(osp.dirname(HERE))
 
-model = torchvision.models.detection.fasterrcnn_resnet50_fpn()
+model = torchvision.models.detection.fasterrcnn_resnet50_fpn(weights=None, weights_backbone=None)
 model.eval()
 
 traced_model = torch.jit.script(model)

torchvision/models/detection/backbone_utils.py

@@ -62,7 +62,7 @@ def forward(self, x: Tensor) -> Dict[str, Tensor]:
 def resnet_fpn_backbone(
     *,
     backbone_name: str,
-    weights: Optional[WeightsEnum] = None,
+    weights: Optional[WeightsEnum],
     norm_layer: Callable[..., nn.Module] = misc_nn_ops.FrozenBatchNorm2d,
     trainable_layers: int = 3,
     returned_layers: Optional[List[int]] = None,
@@ -171,8 +171,8 @@ def _validate_trainable_layers(
 def mobilenet_backbone(
     *,
     backbone_name: str,
-    weights: Optional[WeightsEnum] = None,
-    fpn: bool = True,
+    weights: Optional[WeightsEnum],
+    fpn: bool,
     norm_layer: Callable[..., nn.Module] = misc_nn_ops.FrozenBatchNorm2d,
     trainable_layers: int = 2,
     returned_layers: Optional[List[int]] = None,