Revision models.detection.yolo

pl_bolts/models/detection/yolo/yolo_config.py

@@ -6,10 +6,8 @@
 from pytorch_lightning.utilities.exceptions import MisconfigurationException
 
 from pl_bolts.models.detection.yolo import yolo_layers
-from pl_bolts.utils.stability import under_review
 
 
-@under_review()
 class YOLOConfiguration:
     """This class can be used to parse the configuration files of the Darknet YOLOv4 implementation.
 
@@ -149,7 +147,6 @@ def convert(key, value):
         return sections
 
 
-@under_review()
 def _create_layer(config: dict, num_inputs: List[int]) -> Tuple[nn.Module, int]:
     """Calls one of the ``_create_<layertype>(config, num_inputs)`` functions to create a PyTorch module from the
     layer config.
@@ -173,7 +170,6 @@ def _create_layer(config: dict, num_inputs: List[int]) -> Tuple[nn.Module, int]:
     return create_func[config["type"]](config, num_inputs)
 
 
-@under_review()
 def _create_convolutional(config, num_inputs):
     module = nn.Sequential()
 
@@ -210,14 +206,12 @@ def _create_convolutional(config, num_inputs):
     return module, config["filters"]
 
 
-@under_review()
 def _create_maxpool(config, num_inputs):
     padding = (config["size"] - 1) // 2
     module = nn.MaxPool2d(config["size"], config["stride"], padding)
     return module, num_inputs[-1]
 
 
-@under_review()
 def _create_route(config, num_inputs):
     num_chunks = config.get("groups", 1)
     chunk_idx = config.get("group_id", 0)
@@ -234,19 +228,16 @@ def _create_route(config, num_inputs):
     return module, num_outputs
 
 
-@under_review()
 def _create_shortcut(config, num_inputs):
     module = yolo_layers.ShortcutLayer(config["from"])
     return module, num_inputs[-1]
 
 
-@under_review()
 def _create_upsample(config, num_inputs):
     module = nn.Upsample(scale_factor=config["stride"], mode="nearest")
     return module, num_inputs[-1]
 
 
-@under_review()
 def _create_yolo(config, num_inputs):
     # The "anchors" list alternates width and height.
     anchor_dims = config["anchors"]
@@ -264,8 +255,10 @@ def _create_yolo(config, num_inputs):
         overlap_loss_func = yolo_layers.SELoss()
     elif overlap_loss_name == "giou":
         overlap_loss_func = yolo_layers.GIoULoss()
-    else:
+    elif overlap_loss_name == "iou":
         overlap_loss_func = yolo_layers.IoULoss()
+    else:
+        assert False, "Unknown overlap loss: " + overlap_loss_name
 
     module = yolo_layers.DetectionLayer(
         num_classes=config["classes"],

pl_bolts/models/detection/yolo/yolo_layers.py

@@ -5,7 +5,6 @@
 from torch import Tensor, nn
 
 from pl_bolts.utils import _TORCHVISION_AVAILABLE
-from pl_bolts.utils.stability import under_review
 from pl_bolts.utils.warnings import warn_missing_pkg
 
 if _TORCHVISION_AVAILABLE:
@@ -21,7 +20,6 @@
     warn_missing_pkg("torchvision")
 
 
-@under_review()
 def _corner_coordinates(xy: Tensor, wh: Tensor) -> Tensor:
     """Converts box center points and sizes to corner coordinates.
 
@@ -38,7 +36,6 @@ def _corner_coordinates(xy: Tensor, wh: Tensor) -> Tensor:
     return torch.cat((top_left, bottom_right), -1)
 
 
-@under_review()
 def _aligned_iou(dims1: Tensor, dims2: Tensor) -> Tensor:
     """Calculates a matrix of intersections over union from box dimensions, assuming that the boxes are located at
     the same coordinates.
@@ -61,7 +58,6 @@ def _aligned_iou(dims1: Tensor, dims2: Tensor) -> Tensor:
     return inter / union
 
 
-@under_review()
 class SELoss(nn.MSELoss):
     def __init__(self):
         super().__init__(reduction="none")
@@ -70,13 +66,11 @@ def forward(self, inputs: Tensor, target: Tensor) -> Tensor:
         return super().forward(inputs, target).sum(1)
 
 
-@under_review()
 class IoULoss(nn.Module):
     def forward(self, inputs: Tensor, target: Tensor) -> Tensor:
         return 1.0 - box_iou(inputs, target).diagonal()
 
 
-@under_review()
 class GIoULoss(nn.Module):
     def __init__(self) -> None:
         super().__init__()
@@ -89,7 +83,6 @@ def forward(self, inputs: Tensor, target: Tensor) -> Tensor:
         return 1.0 - generalized_box_iou(inputs, target).diagonal()
 
 
-@under_review()
 class DetectionLayer(nn.Module):
     """A YOLO detection layer.
 
@@ -468,15 +461,13 @@ def _calculate_losses(
         return losses, hits
 
 
-@under_review()
 class Mish(nn.Module):
     """Mish activation."""
 
     def forward(self, x):
         return x * torch.tanh(nn.functional.softplus(x))
 
 
-@under_review()
 class RouteLayer(nn.Module):
     """Route layer concatenates the output (or part of it) from given layers."""
 
@@ -497,7 +488,6 @@ def forward(self, x, outputs):
         return torch.cat(chunks, dim=1)
 
 
-@under_review()
 class ShortcutLayer(nn.Module):
     """Shortcut layer adds a residual connection from the source layer."""
 

pl_bolts/models/detection/yolo/yolo_module.py

@@ -11,7 +11,6 @@
 from pl_bolts.models.detection.yolo.yolo_layers import DetectionLayer, RouteLayer, ShortcutLayer
 from pl_bolts.optimizers.lr_scheduler import LinearWarmupCosineAnnealingLR
 from pl_bolts.utils import _TORCHVISION_AVAILABLE
-from pl_bolts.utils.stability import under_review
 from pl_bolts.utils.warnings import warn_missing_pkg
 
 if _TORCHVISION_AVAILABLE:
@@ -23,7 +22,6 @@
 log = logging.getLogger(__name__)
 
 
-@under_review()
 class YOLO(LightningModule):
     """PyTorch Lightning implementation of YOLOv3 and YOLOv4.
 
@@ -455,7 +453,6 @@ def _filter_detections(self, detections: Dict[str, Tensor]) -> Dict[str, List[Te
         return {"boxes": out_boxes, "scores": out_scores, "classprobs": out_classprobs, "labels": out_labels}
 
 
-@under_review()
 class Resize:
     """Rescales the image and target to given dimensions.
 
@@ -486,7 +483,6 @@ def __call__(self, image: Tensor, target: Dict[str, Any]):
         return image, target
 
 
-@under_review()
 def run_cli():
     from argparse import ArgumentParser
 

tests/data/yolo_giou.cfg

@@ -0,0 +1,81 @@
+[net]
+width=256
+height=256
+channels=3
+
+[convolutional]
+batch_normalize=1
+filters=8
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[route]
+layers=-1
+groups=2
+group_id=1
+
+[maxpool]
+size=2
+stride=2
+
+[convolutional]
+batch_normalize=1
+filters=2
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=4
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=14
+activation=linear
+
+[yolo]
+mask=2,3
+anchors=1,2, 3,4, 5,6, 9,10
+classes=2
+iou_loss=giou
+scale_x_y=1.05
+cls_normalizer=1.0
+iou_normalizer=0.07
+ignore_thresh=0.7
+
+[route]
+layers = -4
+
+[upsample]
+stride=2
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=14
+activation=linear
+
+[yolo]
+mask=0,1
+anchors=1,2, 3,4, 5,6, 9,10
+classes=2
+iou_loss=giou
+scale_x_y=1.05
+cls_normalizer=1.0
+iou_normalizer=0.07
+ignore_thresh=0.7

tests/models/test_detection.py

@@ -88,8 +88,15 @@ def test_yolo(tmpdir):
     model(image)
 
 
-def test_yolo_train(tmpdir):
-    config_path = Path(TEST_ROOT) / "data" / "yolo.cfg"
+@pytest.mark.parametrize(
+    "cfg_name",
+    [
+        ("yolo"),
+        ("yolo_giou"),
+    ],
+)
+def test_yolo_train(tmpdir, cfg_name):
+    config_path = Path(TEST_ROOT) / "data" / f"{cfg_name}.cfg"
     config = YOLOConfiguration(config_path)
     model = YOLO(config.get_network())
 

tests/models/yolo/unit/test_yolo_config.py

@@ -0,0 +1,103 @@
+from pathlib import Path
+
+import pytest
+
+from pl_bolts.models.detection.yolo.yolo_config import (
+    YOLOConfiguration,
+    _create_convolutional,
+    _create_maxpool,
+    _create_shortcut,
+    _create_upsample,
+)
+from tests import TEST_ROOT
+
+
+@pytest.mark.parametrize(
+    "config",
+    [
+        ({"batch_normalize": 1, "filters": 8, "size": 3, "stride": 1, "pad": 1, "activation": "leaky"}),
+        ({"batch_normalize": 0, "filters": 2, "size": 1, "stride": 1, "pad": 1, "activation": "mish"}),
+        ({"batch_normalize": 1, "filters": 6, "size": 3, "stride": 2, "pad": 1, "activation": "logistic"}),
+        ({"batch_normalize": 0, "filters": 4, "size": 3, "stride": 2, "pad": 0, "activation": "linear"}),
+    ],
+)
+def test_create_convolutional(config):
+    conv = _create_convolutional(config, [3])[0]
+
+    assert conv.conv.out_channels == config["filters"]
+    assert conv.conv.kernel_size == (config["size"], config["size"])
+    assert conv.conv.stride == (config["stride"], config["stride"])
+
+    activation = config["activation"]
+    pad_size = (config["size"] - 1) // 2 if config["pad"] else 0
+
+    if config["pad"]:
+        assert conv.conv.padding == (pad_size, pad_size)
+
+    if config["batch_normalize"]:
+        assert len(conv) == 3
+
+    if activation != "linear":
+        if activation != "logistic":
+            assert activation == conv[-1].__class__.__name__.lower()[: len(activation)]
+        elif activation == "logistic":
+            assert "sigmoid" == conv[-1].__class__.__name__.lower()
+
+
+@pytest.mark.parametrize(
+    "config",
+    [
+        (
+            {
+                "size": 2,
+                "stride": 2,
+            }
+        ),
+        (
+            {
+                "size": 6,
+                "stride": 3,
+            }
+        ),
+    ],
+)
+def test_create_maxpool(config):
+    pad_size = (config["size"] - 1) // 2
+    maxpool = _create_maxpool(config, [3])[0]
+
+    assert maxpool.kernel_size == config["size"]
+    assert maxpool.stride == config["stride"]
+    assert maxpool.padding == pad_size
+
+
+@pytest.mark.parametrize(
+    "config",
+    [
+        ({"from": 1, "activation": "linear"}),
+        ({"from": 3, "activation": "linear"}),
+    ],
+)
+def test_create_shortcut(config):
+    shortcut = _create_shortcut(config, [3])[0]
+
+    assert shortcut.source_layer == config["from"]
+
+
+@pytest.mark.parametrize(
+    "config",
+    [
+        ({"stride": 2}),
+        ({"stride": 4}),
+    ],
+)
+def test_create_upsample(config):
+    upsample = _create_upsample(config, [3])[0]
+
+    assert upsample.scale_factor == float(config["stride"])
+
+
+@pytest.mark.parametrize("config", [("yolo"), ("yolo_giou")])
+def test_yolo_config(config):
+    config_path = Path(TEST_ROOT) / "data" / f"{config}.cfg"
+    config = YOLOConfiguration(config_path)
+    config.get_network()