Refine format and linter check (IDEA-Research#41)

* refine format

* refine linter and flake8

* refine linter check to skip submodule

Co-authored-by: ntianhe ren <[email protected]>

Author: rentainhe

.flake8

@@ -6,7 +6,7 @@ ignore = W503, E203, E221, C901, C408, E741, C407, B017
 max-line-length = 100
 max-complexity = 18
 select = B,C,E,F,W,T4,B9
-exclude = build
+exclude = build, detectron2
 per-file-ignores =
   **/__init__.py:F401,F403,E402
   **/configs/**.py:F401,E402
@@ -15,4 +15,6 @@ per-file-ignores =
   tests/config/**.py:F401,E402
   tests/**.py: E402
   tools/**.py: E402
-  projects/**/configs/**.py:F401
+  projects/**/configs/**.py:F401
+  detectron2/**.py: F401,F403,E402,F811,W391
+  detectron2/projects/**.py: F401,F403,E402,F811,W391

configs/common/coco_schedule.py

@@ -44,12 +44,12 @@ def default_coco_scheduler(epochs=50, decay_epochs=40, warmup_epochs=0):
     commonly referred to in papers, where every 1x has the total length of 1440k
     training images (~12 COCO epochs). LR is decayed twice at the end of training
     following the strategy defined in "Rethinking ImageNet Pretraining", Sec 4.
-    
+
     Args:
         epochs (int): total training epochs.
         decay_epochs (int): lr decay steps.
         warmup_epochs (int): warmup epochs.
-    
+
     Returns:
         DictConfig: configs that define the multiplier for LR during training
     """
@@ -79,4 +79,4 @@ def default_coco_scheduler(epochs=50, decay_epochs=40, warmup_epochs=0):
 
 # default scheduler for detr
 lr_multiplier_50ep = default_coco_scheduler(50, 40, 0)
-lr_multiplier_12ep = default_coco_scheduler(12, 11, 0)
+lr_multiplier_12ep = default_coco_scheduler(12, 11, 0)

configs/common/train.py

@@ -15,7 +15,7 @@
         params=dict(
             max_norm=0.1,
             norm_type=2,
-        )
+        ),
     ),  # options for Gradient Clipping
     fast_dev_run=dict(enabled=False),  # options for Fast Checking
     checkpointer=dict(period=5000, max_to_keep=100),  # options for PeriodicCheckpointer

detrex/modeling/__init__.py

@@ -24,5 +24,5 @@
     make_stage,
     BottleneckBlock,
     BasicBlock,
-    TimmBackbone
-)
+    TimmBackbone,
+)

detrex/modeling/backbone/resnet.py

@@ -208,8 +208,7 @@ def __init__(
         # Add it as an option when we need to use this code to train a backbone.
 
     def forward(self, x):
-        """Forward function of `BottleneckBlock`.
-        """
+        """Forward function of `BottleneckBlock`."""
         out = self.conv1(x)
         out = F.relu_(out)
 
@@ -230,8 +229,8 @@ def forward(self, x):
 
 class DeformBottleneckBlock(CNNBlockBase):
     """
-    Similar to :class:`BottleneckBlock`, but with 
-    paper `Deformable Convolutional Networks 
+    Similar to :class:`BottleneckBlock`, but with
+    paper `Deformable Convolutional Networks
     <https://arxiv.org/pdf/1703.06211.pdf>`_ in the 3x3 convolution.
     """
 
@@ -320,8 +319,7 @@ def __init__(
         nn.init.constant_(self.conv2_offset.bias, 0)
 
     def forward(self, x):
-        """Forward function of `DeformBottleneckBlock`.
-        """
+        """Forward function of `DeformBottleneckBlock`."""
         out = self.conv1(x)
         out = F.relu_(out)
 
@@ -373,8 +371,7 @@ def __init__(self, in_channels=3, out_channels=64, norm="BN"):
         weight_init.c2_msra_fill(self.conv1)
 
     def forward(self, x):
-        """Forward function of `BasicStem`.
-        """
+        """Forward function of `BasicStem`."""
         x = self.conv1(x)
         x = F.relu_(x)
         x = F.max_pool2d(x, kernel_size=3, stride=2, padding=1)
@@ -383,7 +380,7 @@ def forward(self, x):
 
 class ResNet(Backbone):
     """
-    Implement paper `Deep Residual Learning for Image Recognition 
+    Implement paper `Deep Residual Learning for Image Recognition
     <https://arxiv.org/pdf/1512.03385.pdf>`_.
 
     Args:
@@ -458,7 +455,7 @@ def forward(self, x):
         """
         Args:
             x: Tensor of shape (N,C,H,W). H, W must be a multiple of ``self.size_divisibility``.
-        
+
         Returns:
             dict[str->Tensor]: names and the corresponding features
         """
@@ -492,14 +489,14 @@ def freeze(self, freeze_at=0):
         Freeze the first several stages of the ResNet. Commonly used in
         fine-tuning.
         Layers that produce the same feature map spatial size are defined as one
-        "stage" by paper `Feature Pyramid Networks for Object Detection 
+        "stage" by paper `Feature Pyramid Networks for Object Detection
         <https://arxiv.org/pdf/1612.03144.pdf>`_.
-        
+
         Args:
             freeze_at (int): number of stages to freeze.
                 `1` means freezing the stem. `2` means freezing the stem and
                 one residual stage, etc.
-        
+
         Returns:
             nn.Module: this ResNet itself
         """
@@ -515,10 +512,10 @@ def freeze(self, freeze_at=0):
     def make_stage(block_class, num_blocks, *, in_channels, out_channels, **kwargs):
         """
         Create a list of blocks of the same type that forms one ResNet stage.
-        
+
         Args:
-            block_class (type): a subclass of ``detectron2.layers.CNNBlockBase`` that's 
-                used to create all blocks in this stage. A module of this type 
+            block_class (type): a subclass of ``detectron2.layers.CNNBlockBase`` that's
+                used to create all blocks in this stage. A module of this type
                 must not change spatial resolution of inputs unless its stride != 1.
             num_blocks (int): number of blocks in this stage
             in_channels (int): input channels of the entire stage.
@@ -528,10 +525,10 @@ def make_stage(block_class, num_blocks, *, in_channels, out_channels, **kwargs):
                 argument is a list of values to be passed to each block in the
                 stage. Otherwise, the same argument is passed to every block
                 in the stage.
-        
+
         Returns:
             list[detectron2.layers.CNNBlockBase]: a list of block module.
-        
+
         Examples:
         ::
             stage = ResNet.make_stage(
@@ -540,10 +537,10 @@ def make_stage(block_class, num_blocks, *, in_channels, out_channels, **kwargs):
                 stride_per_block=[2, 1, 1],
                 dilations_per_block=[1, 1, 2]
             )
-        
+
         Usually, layers that produce the same feature map spatial size are defined as one
         "stage" (in paper `Feature Pyramid Networks for Object Detection
-        <https://arxiv.org/pdf/1612.03144.pdf>`_). 
+        <https://arxiv.org/pdf/1612.03144.pdf>`_).
         Under such definition, ``stride_per_block[1:]`` should all be 1.
         """
         blocks = []
@@ -573,7 +570,7 @@ def make_default_stages(depth, block_class=None, **kwargs):
         Created list of ResNet stages from pre-defined depth (one of 18, 34, 50, 101, 152).
         If it doesn't create the ResNet variant you need, please use :meth:`make_stage`
         instead for fine-grained customization.
-        
+
         Args:
             depth (int): depth of ResNet
             block_class (type): the CNN block class. Has to accept
@@ -583,7 +580,7 @@ def make_default_stages(depth, block_class=None, **kwargs):
             kwargs:
                 other arguments to pass to `make_stage`. Should not contain
                 stride and channels, as they are predefined for each depth.
-        
+
         Returns:
             list[list[detectron2.layers.CNNBlockBase]]: modules in all stages; see arguments of
             :class:`ResNet`.
@@ -640,11 +637,11 @@ def make_stage(
     deform_num_groups: int = 1,
 ):
     """
-    Modified from `detectron2.modeling.backbone.build_resnet_backbone 
+    Modified from `detectron2.modeling.backbone.build_resnet_backbone
     <https://github.com/facebookresearch/detectron2/blob/717ab9f0aeca216a2f800e43d705766251ba3a55/detectron2/modeling/backbone/resnet.py#L614>`_
 
     Create a list of blocks of the same type that forms one ResNet stage.
-    
+
     Args:
         depth (int): The depth of ResNet. Default: 50.
         norm (str or callable): Normalization for all conv layers.
@@ -656,10 +653,10 @@ def make_stage(
             Default: 64.
         in_channels (int): Output feature channels of the `Stem` Block. Needs
             to be set to 64 for R18 and R34. Default: 64.
-        out_channels (int): Output width of res2. Scaling this parameters 
+        out_channels (int): Output width of res2. Scaling this parameters
             will scale the width of all 1x1 convs in ResNet. Default: 256.
-        stride_in_1x1 (bool): Place the stride 2 conv on the 1x1 filter. 
-            Use True only for the original MSRA ResNet; 
+        stride_in_1x1 (bool): Place the stride 2 conv on the 1x1 filter.
+            Use True only for the original MSRA ResNet;
             use False for C2 and Torch models. Default: False.
         res5_dilation (int): Apply dilation in stage "res5". Default: 1.
         deform_on_per_stage (List[bool]): Apply Deformable Convolution in stages.
@@ -669,10 +666,10 @@ def make_stage(
             (DeformableV2, https://arxiv.org/abs/1811.11168); Use False for DeformableV1.
             Default: False.
         deform_num_groups (int): Number of groups in deformable conv. Default: 1.
-    
+
     Returns:
         list[detectron2.layers.CNNBlockBase]: a list of block module.
-    
+
     Examples:
     ::
         from detrex.modeling.backbone import make_stage, ResNet, BasicStem
@@ -737,4 +734,4 @@ def make_stage(
         bottleneck_channels *= 2
         stages.append(blocks)
 
-    return stages
+    return stages

dev/linter.sh

@@ -20,13 +20,13 @@ fi
 set -v
 
 echo "Running autoflake ..."
-autoflake --remove-unused-variables --in-place --recursive .
+autoflake --remove-unused-variables --in-place --recursive . --exclude=detectron2
 
 echo "Running isort ..."
 isort -y -sp . --atomic
 
 echo "Running black ..."
-black -l 100 .
+black -l 100 . --exclude=detectron2
 
 echo "Running flake8 ..."
 if [ -x "$(command -v flake8)" ]; then

projects/dab_detr/configs/dab_detr_r101_50ep.py

@@ -5,6 +5,7 @@
     lr_multiplier,
     model,
 )
+
 # modify training config
 train.init_checkpoint = "path/to/R-101.pkl"
 train.output_dir = "./output/dab_detr_r101_50ep"

projects/dab_detr/configs/models/dab_detr_r50_dc5.py

@@ -15,4 +15,3 @@
     out_features=["res2", "res3", "res4", "res5"],
     freeze_at=1,
 )
-

projects/dab_detr/modeling/dab_detr.py

@@ -77,7 +77,6 @@ def __init__(
         if self.iter_update:
             self.transformer.decoder.bbox_embed = self.bbox_embed
 
-
         # normalizer for input raw images
         self.device = device
         pixel_mean = torch.Tensor(pixel_mean).to(self.device).view(3, 1, 1)

projects/dn_detr/configs/models/dn_detr_r50.py

@@ -34,11 +34,11 @@
         freeze_at=1,
     ),
     position_embedding=L(PositionEmbeddingSine)(
-        num_pos_feats=128, 
-        temperature=20, 
+        num_pos_feats=128,
+        temperature=20,
         normalize=True,
     ),
-    in_features = ["res5"], # use last level feature as DAB-DETR
+    in_features=["res5"],  # use last level feature as DAB-DETR
     transformer=L(DNDetrTransformer)(
         encoder=L(DNDetrTransformerEncoder)(
             transformer_layers=L(BaseTransformerLayer)(

projects/dn_detr/modeling/dn_criterion.py

@@ -16,16 +16,14 @@
 import torch
 
 from detrex.modeling import SetCriterion
-from detrex.utils import (
-    get_world_size,
-    is_dist_avail_and_initialized,
-)
+from detrex.utils import get_world_size, is_dist_avail_and_initialized
+
 
 class DNCriterion(SetCriterion):
-    """This class computes the loss for DN-DETR.
-    """
+    """This class computes the loss for DN-DETR."""
+
     def forward(self, outputs, targets, dn_metas=None):
-        losses=super(DNCriterion, self).forward(outputs, targets)
+        losses = super(DNCriterion, self).forward(outputs, targets)
 
         num_boxes = sum(len(t["labels"]) for t in targets)
         num_boxes = torch.as_tensor(
@@ -50,15 +48,20 @@ def calculate_dn_loss(self, dn_metas, targets, aux_num, num_boxes):
         """
         losses = {}
         if dn_metas and "output_known_lbs_bboxes" in dn_metas:
-            output_known_lbs_bboxes,dn_num,single_padding= dn_metas['output_known_lbs_bboxes'], \
-                                                       dn_metas['dn_num'], dn_metas['single_padding']
+            output_known_lbs_bboxes, dn_num, single_padding = (
+                dn_metas["output_known_lbs_bboxes"],
+                dn_metas["dn_num"],
+                dn_metas["single_padding"],
+            )
             dn_idx = []
             for i in range(len(targets)):
-                if len(targets[i]['labels']) > 0:
-                    t = torch.arange(0, len(targets[i]['labels'])).long().cuda()
+                if len(targets[i]["labels"]) > 0:
+                    t = torch.arange(0, len(targets[i]["labels"])).long().cuda()
                     t = t.unsqueeze(0).repeat(dn_num, 1)
                     tgt_idx = t.flatten()
-                    output_idx = (torch.tensor(range(dn_num)) * single_padding).long().cuda().unsqueeze(1) + t
+                    output_idx = (
+                        torch.tensor(range(dn_num)) * single_padding
+                    ).long().cuda().unsqueeze(1) + t
                     output_idx = output_idx.flatten()
                 else:
                     output_idx = tgt_idx = torch.tensor([]).long().cuda()
@@ -67,12 +70,15 @@ def calculate_dn_loss(self, dn_metas, targets, aux_num, num_boxes):
             l_dict = {}
             for loss in self.losses:
                 kwargs = {}
-                if 'labels' in loss:
-                    kwargs = {'log': False}
-                l_dict.update(self.get_loss(loss, output_known_lbs_bboxes, targets, dn_idx, num_boxes * dn_num,
-                                            **kwargs))
+                if "labels" in loss:
+                    kwargs = {"log": False}
+                l_dict.update(
+                    self.get_loss(
+                        loss, output_known_lbs_bboxes, targets, dn_idx, num_boxes * dn_num, **kwargs
+                    )
+                )
 
-            l_dict = {k + f'_dn': v for k, v in l_dict.items()}
+            l_dict = {k + f"_dn": v for k, v in l_dict.items()}
             losses.update(l_dict)
         else:
             losses["loss_bbox_dn"] = torch.as_tensor(0.0).to("cuda")
@@ -83,13 +89,21 @@ def calculate_dn_loss(self, dn_metas, targets, aux_num, num_boxes):
             # dn aux loss
             l_dict = {}
             if dn_metas and "output_known_lbs_bboxes" in dn_metas:
-                output_known_lbs_bboxes_aux=output_known_lbs_bboxes['aux_outputs'][i]
+                output_known_lbs_bboxes_aux = output_known_lbs_bboxes["aux_outputs"][i]
                 for loss in self.losses:
                     kwargs = {}
-                    if 'labels' in loss:
-                        kwargs = {'log': False}
-                    l_dict.update(self.get_loss(loss, output_known_lbs_bboxes_aux, targets, dn_idx, num_boxes * dn_num,
-                                                **kwargs))
+                    if "labels" in loss:
+                        kwargs = {"log": False}
+                    l_dict.update(
+                        self.get_loss(
+                            loss,
+                            output_known_lbs_bboxes_aux,
+                            targets,
+                            dn_idx,
+                            num_boxes * dn_num,
+                            **kwargs,
+                        )
+                    )
                 l_dict = {k + f"_dn_{i}": v for k, v in l_dict.items()}
             else:
                 l_dict["loss_bbox_dn"] = torch.as_tensor(0.0).to("cuda")
@@ -98,4 +112,3 @@ def calculate_dn_loss(self, dn_metas, targets, aux_num, num_boxes):
                 l_dict = {k + f"_{i}": v for k, v in l_dict.items()}
             losses.update(l_dict)
         return losses
-