Merge branch 'main' into TestColorJitter_seeds

Author: NicolasHug

test/test_ops.py

@@ -46,9 +46,11 @@ def test_forward(self, device, contiguous, x_dtype=None, rois_dtype=None, **kwar
         tol = 1e-3 if (x_dtype is torch.half or rois_dtype is torch.half) else 1e-5
         torch.testing.assert_close(gt_y.to(y), y, rtol=tol, atol=tol)
 
+    @pytest.mark.parametrize("seed", range(10))
     @pytest.mark.parametrize("device", cpu_and_gpu())
     @pytest.mark.parametrize("contiguous", (True, False))
-    def test_backward(self, device, contiguous):
+    def test_backward(self, seed, device, contiguous):
+        torch.random.manual_seed(seed)
         pool_size = 2
         x = torch.rand(1, 2 * (pool_size ** 2), 5, 5, dtype=self.dtype, device=device, requires_grad=True)
         if not contiguous:
@@ -845,7 +847,9 @@ def test_frozenbatchnorm2d_repr(self):
         expected_string = f"FrozenBatchNorm2d({num_features}, eps={eps})"
         assert repr(t) == expected_string
 
-    def test_frozenbatchnorm2d_eps(self):
+    @pytest.mark.parametrize("seed", range(10))
+    def test_frozenbatchnorm2d_eps(self, seed):
+        torch.random.manual_seed(seed)
         sample_size = (4, 32, 28, 28)
         x = torch.rand(sample_size)
         state_dict = dict(

test/test_transforms.py

@@ -1750,8 +1750,10 @@ def test_color_jitter():
     color_jitter.__repr__()
 
 
+@pytest.mark.parametrize("seed", range(10))
 @pytest.mark.skipif(stats is None, reason="scipy.stats not available")
-def test_random_erasing():
+def test_random_erasing(seed):
+    torch.random.manual_seed(seed)
     img = torch.ones(3, 128, 128)
 
     t = transforms.RandomErasing(scale=(0.1, 0.1), ratio=(1 / 3, 3.0))
@@ -1852,8 +1854,10 @@ def test_randomperspective():
         )
 
 
+@pytest.mark.parametrize("seed", range(10))
 @pytest.mark.parametrize("mode", ["L", "RGB", "F"])
-def test_randomperspective_fill(mode):
+def test_randomperspective_fill(mode, seed):
+    torch.random.manual_seed(seed)
 
     # assert fill being either a Sequence or a Number
     with pytest.raises(TypeError):

test/test_transforms_video.py

@@ -160,34 +160,16 @@ def test_to_tensor_video(self):
 
         trans.__repr__()
 
-    @pytest.mark.skipif(stats is None, reason="scipy.stats not available")
-    def test_random_horizontal_flip_video(self):
-        random_state = random.getstate()
-        random.seed(42)
+    @pytest.mark.parametrize("p", (0, 1))
+    def test_random_horizontal_flip_video(self, p):
         clip = torch.rand((3, 4, 112, 112), dtype=torch.float)
         hclip = clip.flip((-1))
 
-        num_samples = 250
-        num_horizontal = 0
-        for _ in range(num_samples):
-            out = transforms.RandomHorizontalFlipVideo()(clip)
-            if torch.all(torch.eq(out, hclip)):
-                num_horizontal += 1
-
-        p_value = stats.binom_test(num_horizontal, num_samples, p=0.5)
-        random.setstate(random_state)
-        assert p_value > 0.0001
-
-        num_samples = 250
-        num_horizontal = 0
-        for _ in range(num_samples):
-            out = transforms.RandomHorizontalFlipVideo(p=0.7)(clip)
-            if torch.all(torch.eq(out, hclip)):
-                num_horizontal += 1
-
-        p_value = stats.binom_test(num_horizontal, num_samples, p=0.7)
-        random.setstate(random_state)
-        assert p_value > 0.0001
+        out = transforms.RandomHorizontalFlipVideo(p=p)(clip)
+        if p == 0:
+            torch.testing.assert_close(out, clip)
+        elif p == 1:
+            torch.testing.assert_close(out, hclip)
 
         transforms.RandomHorizontalFlipVideo().__repr__()
 

torchvision/prototype/models/segmentation/__init__.py

@@ -1,2 +1,3 @@
 from .fcn import *
 from .lraspp import *
+from .deeplabv3 import *

torchvision/prototype/models/segmentation/deeplabv3.py

@@ -0,0 +1,157 @@
+import warnings
+from functools import partial
+from typing import Any, Optional
+
+from ....models.segmentation.deeplabv3 import DeepLabV3, _deeplabv3_mobilenetv3, _deeplabv3_resnet
+from ...transforms.presets import VocEval
+from .._api import Weights, WeightEntry
+from .._meta import _VOC_CATEGORIES
+from ..mobilenetv3 import MobileNetV3LargeWeights, mobilenet_v3_large
+from ..resnet import resnet50, resnet101
+from ..resnet import ResNet50Weights, ResNet101Weights
+
+
+__all__ = [
+    "DeepLabV3",
+    "DeepLabV3ResNet50Weights",
+    "DeepLabV3ResNet101Weights",
+    "DeepLabV3MobileNetV3LargeWeights",
+    "deeplabv3_mobilenet_v3_large",
+    "deeplabv3_resnet50",
+    "deeplabv3_resnet101",
+]
+
+
+class DeepLabV3ResNet50Weights(Weights):
+    CocoWithVocLabels_RefV1 = WeightEntry(
+        url="https://download.pytorch.org/models/deeplabv3_resnet50_coco-cd0a2569.pth",
+        transforms=partial(VocEval, resize_size=520),
+        meta={
+            "categories": _VOC_CATEGORIES,
+            "recipe": "https://github.com/pytorch/vision/tree/main/references/segmentation#deeplabv3_resnet50",
+            "mIoU": 66.4,
+            "acc": 92.4,
+        },
+    )
+
+
+class DeepLabV3ResNet101Weights(Weights):
+    CocoWithVocLabels_RefV1 = WeightEntry(
+        url="https://download.pytorch.org/models/deeplabv3_resnet101_coco-586e9e4e.pth",
+        transforms=partial(VocEval, resize_size=520),
+        meta={
+            "categories": _VOC_CATEGORIES,
+            "recipe": "https://github.com/pytorch/vision/tree/main/references/segmentation#fcn_resnet101",
+            "mIoU": 67.4,
+            "acc": 92.4,
+        },
+    )
+
+
+class DeepLabV3MobileNetV3LargeWeights(Weights):
+    CocoWithVocLabels_RefV1 = WeightEntry(
+        url="https://download.pytorch.org/models/deeplabv3_mobilenet_v3_large-fc3c493d.pth",
+        transforms=partial(VocEval, resize_size=520),
+        meta={
+            "categories": _VOC_CATEGORIES,
+            "recipe": "https://github.com/pytorch/vision/tree/main/references/segmentation#deeplabv3_mobilenet_v3_large",
+            "mIoU": 60.3,
+            "acc": 91.2,
+        },
+    )
+
+
+def deeplabv3_resnet50(
+    weights: Optional[DeepLabV3ResNet50Weights] = None,
+    weights_backbone: Optional[ResNet50Weights] = None,
+    progress: bool = True,
+    num_classes: int = 21,
+    aux_loss: Optional[bool] = None,
+    **kwargs: Any,
+) -> DeepLabV3:
+    if "pretrained" in kwargs:
+        warnings.warn("The argument pretrained is deprecated, please use weights instead.")
+        weights = DeepLabV3ResNet50Weights.CocoWithVocLabels_RefV1 if kwargs.pop("pretrained") else None
+
+    weights = DeepLabV3ResNet50Weights.verify(weights)
+    if "pretrained_backbone" in kwargs:
+        warnings.warn("The argument pretrained_backbone is deprecated, please use weights_backbone instead.")
+        weights_backbone = ResNet50Weights.ImageNet1K_RefV1 if kwargs.pop("pretrained_backbone") else None
+    weights_backbone = ResNet50Weights.verify(weights_backbone)
+
+    if weights is not None:
+        weights_backbone = None
+        aux_loss = True
+        num_classes = len(weights.meta["categories"])
+
+    backbone = resnet50(weights=weights_backbone, replace_stride_with_dilation=[False, True, True])
+    model = _deeplabv3_resnet(backbone, num_classes, aux_loss)
+
+    if weights is not None:
+        model.load_state_dict(weights.state_dict(progress=progress))
+
+    return model
+
+
+def deeplabv3_resnet101(
+    weights: Optional[DeepLabV3ResNet101Weights] = None,
+    weights_backbone: Optional[ResNet101Weights] = None,
+    progress: bool = True,
+    num_classes: int = 21,
+    aux_loss: Optional[bool] = None,
+    **kwargs: Any,
+) -> DeepLabV3:
+    if "pretrained" in kwargs:
+        warnings.warn("The argument pretrained is deprecated, please use weights instead.")
+        weights = DeepLabV3ResNet101Weights.CocoWithVocLabels_RefV1 if kwargs.pop("pretrained") else None
+
+    weights = DeepLabV3ResNet101Weights.verify(weights)
+    if "pretrained_backbone" in kwargs:
+        warnings.warn("The argument pretrained_backbone is deprecated, please use weights_backbone instead.")
+        weights_backbone = ResNet101Weights.ImageNet1K_RefV1 if kwargs.pop("pretrained_backbone") else None
+    weights_backbone = ResNet101Weights.verify(weights_backbone)
+
+    if weights is not None:
+        weights_backbone = None
+        aux_loss = True
+        num_classes = len(weights.meta["categories"])
+
+    backbone = resnet101(weights=weights_backbone, replace_stride_with_dilation=[False, True, True])
+    model = _deeplabv3_resnet(backbone, num_classes, aux_loss)
+
+    if weights is not None:
+        model.load_state_dict(weights.state_dict(progress=progress))
+
+    return model
+
+
+def deeplabv3_mobilenet_v3_large(
+    weights: Optional[DeepLabV3MobileNetV3LargeWeights] = None,
+    weights_backbone: Optional[MobileNetV3LargeWeights] = None,
+    progress: bool = True,
+    num_classes: int = 21,
+    aux_loss: Optional[bool] = None,
+    **kwargs: Any,
+) -> DeepLabV3:
+    if "pretrained" in kwargs:
+        warnings.warn("The argument pretrained is deprecated, please use weights instead.")
+        weights = DeepLabV3MobileNetV3LargeWeights.CocoWithVocLabels_RefV1 if kwargs.pop("pretrained") else None
+
+    weights = DeepLabV3MobileNetV3LargeWeights.verify(weights)
+    if "pretrained_backbone" in kwargs:
+        warnings.warn("The argument pretrained_backbone is deprecated, please use weights_backbone instead.")
+        weights_backbone = MobileNetV3LargeWeights.ImageNet1K_RefV1 if kwargs.pop("pretrained_backbone") else None
+    weights_backbone = MobileNetV3LargeWeights.verify(weights_backbone)
+
+    if weights is not None:
+        weights_backbone = None
+        aux_loss = True
+        num_classes = len(weights.meta["categories"])
+
+    backbone = mobilenet_v3_large(weights=weights_backbone, dilated=True)
+    model = _deeplabv3_mobilenetv3(backbone, num_classes, aux_loss)
+
+    if weights is not None:
+        model.load_state_dict(weights.state_dict(progress=progress))
+
+    return model