Reformat use yapf 0.27.0 & Add yapf style file (#672)

* Reformat use yapf 0.27.0

* Add yapf style file

.style.yapf

@@ -0,0 +1,4 @@
+[style]
+BASED_ON_STYLE = pep8
+BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF = true
+SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN = true

configs/dcn/cascade_mask_rcnn_dconv_c3-c5_r50_fpn_1x.py

@@ -11,9 +11,7 @@
         frozen_stages=1,
         style='pytorch',
         dcn=dict(
-            modulated=False,
-            deformable_groups=1,
-            fallback_on_stride=False),
+            modulated=False, deformable_groups=1, fallback_on_stride=False),
         stage_with_dcn=(False, True, True, True)),
     neck=dict(
         type='FPN',

configs/dcn/cascade_rcnn_dconv_c3-c5_r50_fpn_1x.py

@@ -11,9 +11,7 @@
         frozen_stages=1,
         style='pytorch',
         dcn=dict(
-            modulated=False,
-            deformable_groups=1,
-            fallback_on_stride=False),
+            modulated=False, deformable_groups=1, fallback_on_stride=False),
         stage_with_dcn=(False, True, True, True)),
     neck=dict(
         type='FPN',

configs/dcn/faster_rcnn_dconv_c3-c5_r50_fpn_1x.py

@@ -10,9 +10,7 @@
         frozen_stages=1,
         style='pytorch',
         dcn=dict(
-            modulated=False,
-            deformable_groups=1,
-            fallback_on_stride=False),
+            modulated=False, deformable_groups=1, fallback_on_stride=False),
         stage_with_dcn=(False, True, True, True)),
     neck=dict(
         type='FPN',

configs/dcn/faster_rcnn_mdconv_c3-c5_r50_fpn_1x.py

@@ -10,9 +10,7 @@
         frozen_stages=1,
         style='pytorch',
         dcn=dict(
-            modulated=True,
-            deformable_groups=1,
-            fallback_on_stride=False),
+            modulated=True, deformable_groups=1, fallback_on_stride=False),
         stage_with_dcn=(False, True, True, True)),
     neck=dict(
         type='FPN',

configs/dcn/mask_rcnn_dconv_c3-c5_r50_fpn_1x.py

@@ -10,9 +10,7 @@
         frozen_stages=1,
         style='pytorch',
         dcn=dict(
-            modulated=False,
-            deformable_groups=1,
-            fallback_on_stride=False),
+            modulated=False, deformable_groups=1, fallback_on_stride=False),
         stage_with_dcn=(False, True, True, True)),
     neck=dict(
         type='FPN',

configs/gn+ws/faster_rcnn_r50_fpn_gn_ws_1x.py

@@ -99,9 +99,7 @@
         nms_thr=0.7,
         min_bbox_size=0),
     rcnn=dict(
-        score_thr=0.05,
-        nms=dict(type='nms', iou_thr=0.5),
-        max_per_img=100))
+        score_thr=0.05, nms=dict(type='nms', iou_thr=0.5), max_per_img=100))
 # dataset settings
 dataset_type = 'CocoDataset'
 data_root = 'data/coco/'

mmdet/apis/inference.py

@@ -124,8 +124,7 @@ def show_result(img, result, class_names, score_thr=0.3, out_file=None):
         segms = mmcv.concat_list(segm_result)
         inds = np.where(bboxes[:, -1] > score_thr)[0]
         for i in inds:
-            color_mask = np.random.randint(
-                0, 256, (1, 3), dtype=np.uint8)
+            color_mask = np.random.randint(0, 256, (1, 3), dtype=np.uint8)
             mask = maskUtils.decode(segms[i]).astype(np.bool)
             img[mask] = img[mask] * 0.5 + color_mask * 0.5
     # draw bounding boxes

mmdet/apis/train.py

@@ -91,8 +91,8 @@ def build_optimizer(model, optimizer_cfg):
     paramwise_options = optimizer_cfg.pop('paramwise_options', None)
     # if no paramwise option is specified, just use the global setting
     if paramwise_options is None:
-        return obj_from_dict(optimizer_cfg, torch.optim,
-                             dict(params=model.parameters()))
+        return obj_from_dict(
+            optimizer_cfg, torch.optim, dict(params=model.parameters()))
     else:
         assert isinstance(paramwise_options, dict)
         # get base lr and weight decay

mmdet/core/bbox/assign_sampling.py

@@ -7,8 +7,7 @@ def build_assigner(cfg, **kwargs):
     if isinstance(cfg, assigners.BaseAssigner):
         return cfg
     elif isinstance(cfg, dict):
-        return mmcv.runner.obj_from_dict(
-            cfg, assigners, default_args=kwargs)
+        return mmcv.runner.obj_from_dict(cfg, assigners, default_args=kwargs)
     else:
         raise TypeError('Invalid type {} for building a sampler'.format(
             type(cfg)))
@@ -18,8 +17,7 @@ def build_sampler(cfg, **kwargs):
     if isinstance(cfg, samplers.BaseSampler):
         return cfg
     elif isinstance(cfg, dict):
-        return mmcv.runner.obj_from_dict(
-            cfg, samplers, default_args=kwargs)
+        return mmcv.runner.obj_from_dict(cfg, samplers, default_args=kwargs)
     else:
         raise TypeError('Invalid type {} for building a sampler'.format(
             type(cfg)))

mmdet/core/evaluation/mean_ap.py

@@ -261,8 +261,8 @@ def eval_map(det_results,
         cls_dets, cls_gts, cls_gt_ignore = get_cls_results(
             det_results, gt_bboxes, gt_labels, gt_ignore, i)
         # calculate tp and fp for each image
-        tpfp_func = (tpfp_imagenet
-                     if dataset in ['det', 'vid'] else tpfp_default)
+        tpfp_func = (
+            tpfp_imagenet if dataset in ['det', 'vid'] else tpfp_default)
         tpfp = [
             tpfp_func(cls_dets[j], cls_gts[j], cls_gt_ignore[j], iou_thr,
                       area_ranges) for j in range(len(cls_dets))

mmdet/core/post_processing/bbox_nms.py

@@ -45,9 +45,8 @@ def multiclass_nms(multi_bboxes,
             _scores *= score_factors[cls_inds]
         cls_dets = torch.cat([_bboxes, _scores[:, None]], dim=1)
         cls_dets, _ = nms_op(cls_dets, **nms_cfg_)
-        cls_labels = multi_bboxes.new_full((cls_dets.shape[0], ),
-                                           i - 1,
-                                           dtype=torch.long)
+        cls_labels = multi_bboxes.new_full(
+            (cls_dets.shape[0], ), i - 1, dtype=torch.long)
         bboxes.append(cls_dets)
         labels.append(cls_labels)
     if bboxes:

mmdet/datasets/extra_aug.py

@@ -91,9 +91,7 @@ def __call__(self, img, boxes, labels):
 
 class RandomCrop(object):
 
-    def __init__(self,
-                 min_ious=(0.1, 0.3, 0.5, 0.7, 0.9),
-                 min_crop_size=0.3):
+    def __init__(self, min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), min_crop_size=0.3):
         # 1: return ori img
         self.sample_mode = (1, *min_ious, 0)
         self.min_crop_size = min_crop_size

mmdet/datasets/loader/__init__.py

@@ -1,6 +1,4 @@
 from .build_loader import build_dataloader
 from .sampler import GroupSampler, DistributedGroupSampler
 
-__all__ = [
-    'GroupSampler', 'DistributedGroupSampler', 'build_dataloader'
-]
+__all__ = ['GroupSampler', 'DistributedGroupSampler', 'build_dataloader']

mmdet/datasets/loader/build_loader.py

@@ -25,24 +25,22 @@ def build_dataloader(dataset,
             sampler = DistributedGroupSampler(dataset, imgs_per_gpu,
                                               world_size, rank)
         else:
-            sampler = DistributedSampler(dataset,
-                                         world_size,
-                                         rank,
-                                         shuffle=False)
+            sampler = DistributedSampler(
+                dataset, world_size, rank, shuffle=False)
         batch_size = imgs_per_gpu
         num_workers = workers_per_gpu
     else:
         sampler = GroupSampler(dataset, imgs_per_gpu) if shuffle else None
         batch_size = num_gpus * imgs_per_gpu
         num_workers = num_gpus * workers_per_gpu
 
-    data_loader = DataLoader(dataset,
-                             batch_size=batch_size,
-                             sampler=sampler,
-                             num_workers=num_workers,
-                             collate_fn=partial(collate,
-                                                samples_per_gpu=imgs_per_gpu),
-                             pin_memory=False,
-                             **kwargs)
+    data_loader = DataLoader(
+        dataset,
+        batch_size=batch_size,
+        sampler=sampler,
+        num_workers=num_workers,
+        collate_fn=partial(collate, samples_per_gpu=imgs_per_gpu),
+        pin_memory=False,
+        **kwargs)
 
     return data_loader

mmdet/datasets/loader/sampler.py

@@ -139,8 +139,8 @@ def __iter__(self):
 
         indices = [
             indices[j] for i in list(
-                torch.randperm(len(indices) // self.samples_per_gpu,
-                               generator=g))
+                torch.randperm(
+                    len(indices) // self.samples_per_gpu, generator=g))
             for j in range(i * self.samples_per_gpu, (i + 1) *
                            self.samples_per_gpu)
         ]

mmdet/datasets/transforms.py

@@ -34,8 +34,8 @@ def __call__(self, img, scale, flip=False, keep_ratio=True):
         else:
             img, w_scale, h_scale = mmcv.imresize(
                 img, scale, return_scale=True)
-            scale_factor = np.array([w_scale, h_scale, w_scale, h_scale],
-                                    dtype=np.float32)
+            scale_factor = np.array(
+                [w_scale, h_scale, w_scale, h_scale], dtype=np.float32)
         img_shape = img.shape
         img = mmcv.imnormalize(img, self.mean, self.std, self.to_rgb)
         if flip:

mmdet/models/anchor_heads/anchor_head.py

@@ -196,8 +196,9 @@ def loss(self,
             return None
         (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
          num_total_pos, num_total_neg) = cls_reg_targets
-        num_total_samples = (num_total_pos if self.cls_focal_loss else
-                             num_total_pos + num_total_neg)
+        num_total_samples = (
+            num_total_pos
+            if self.cls_focal_loss else num_total_pos + num_total_neg)
         losses_cls, losses_reg = multi_apply(
             self.loss_single,
             cls_scores,

mmdet/models/backbones/resnet.py

@@ -43,12 +43,7 @@ def __init__(self,
             bias=False)
         self.add_module(self.norm1_name, norm1)
         self.conv2 = build_conv_layer(
-            conv_cfg,
-            planes,
-            planes,
-            3,
-            padding=1,
-            bias=False)
+            conv_cfg, planes, planes, 3, padding=1, bias=False)
         self.add_module(self.norm2_name, norm2)
 
         self.relu = nn.ReLU(inplace=True)

mmdet/models/bbox_heads/convfc_bbox_head.py

@@ -94,8 +94,8 @@ def _add_conv_fc_branch(self,
         branch_convs = nn.ModuleList()
         if num_branch_convs > 0:
             for i in range(num_branch_convs):
-                conv_in_channels = (last_layer_dim
-                                    if i == 0 else self.conv_out_channels)
+                conv_in_channels = (
+                    last_layer_dim if i == 0 else self.conv_out_channels)
                 branch_convs.append(
                     ConvModule(
                         conv_in_channels,
@@ -114,8 +114,8 @@ def _add_conv_fc_branch(self,
                     or self.num_shared_fcs == 0) and not self.with_avg_pool:
                 last_layer_dim *= (self.roi_feat_size * self.roi_feat_size)
             for i in range(num_branch_fcs):
-                fc_in_channels = (last_layer_dim
-                                  if i == 0 else self.fc_out_channels)
+                fc_in_channels = (
+                    last_layer_dim if i == 0 else self.fc_out_channels)
                 branch_fcs.append(
                     nn.Linear(fc_in_channels, self.fc_out_channels))
             last_layer_dim = self.fc_out_channels

mmdet/models/detectors/cascade_rcnn.py

@@ -186,8 +186,8 @@ def forward_train(self,
                                                 gt_labels, rcnn_train_cfg)
             loss_bbox = bbox_head.loss(cls_score, bbox_pred, *bbox_targets)
             for name, value in loss_bbox.items():
-                losses['s{}.{}'.format(
-                    i, name)] = (value * lw if 'loss' in name else value)
+                losses['s{}.{}'.format(i, name)] = (
+                    value * lw if 'loss' in name else value)
 
             # mask head forward and loss
             if self.with_mask:
@@ -224,8 +224,8 @@ def forward_train(self,
                     [res.pos_gt_labels for res in sampling_results])
                 loss_mask = mask_head.loss(mask_pred, mask_targets, pos_labels)
                 for name, value in loss_mask.items():
-                    losses['s{}.{}'.format(
-                        i, name)] = (value * lw if 'loss' in name else value)
+                    losses['s{}.{}'.format(i, name)] = (
+                        value * lw if 'loss' in name else value)
 
             # refine bboxes
             if i < self.num_stages - 1:
@@ -286,8 +286,9 @@ def simple_test(self, img, img_meta, proposals=None, rescale=False):
                             [] for _ in range(mask_head.num_classes - 1)
                         ]
                     else:
-                        _bboxes = (det_bboxes[:, :4] * scale_factor
-                                   if rescale else det_bboxes)
+                        _bboxes = (
+                            det_bboxes[:, :4] * scale_factor
+                            if rescale else det_bboxes)
                         mask_rois = bbox2roi([_bboxes])
                         mask_feats = mask_roi_extractor(
                             x[:len(mask_roi_extractor.featmap_strides)],
@@ -324,8 +325,9 @@ def simple_test(self, img, img_meta, proposals=None, rescale=False):
                     [] for _ in range(self.mask_head[-1].num_classes - 1)
                 ]
             else:
-                _bboxes = (det_bboxes[:, :4] * scale_factor
-                           if rescale else det_bboxes)
+                _bboxes = (
+                    det_bboxes[:, :4] * scale_factor
+                    if rescale else det_bboxes)
                 mask_rois = bbox2roi([_bboxes])
                 aug_masks = []
                 for i in range(self.num_stages):

mmdet/models/detectors/htc.py

@@ -224,8 +224,8 @@ def forward_train(self,
             roi_labels = bbox_targets[0]
 
             for name, value in loss_bbox.items():
-                losses['s{}.{}'.format(
-                    i, name)] = (value * lw if 'loss' in name else value)
+                losses['s{}.{}'.format(i, name)] = (
+                    value * lw if 'loss' in name else value)
 
             # mask head forward and loss
             if self.with_mask:
@@ -253,8 +253,8 @@ def forward_train(self,
                                                      gt_masks, rcnn_train_cfg,
                                                      semantic_feat)
                 for name, value in loss_mask.items():
-                    losses['s{}.{}'.format(
-                        i, name)] = (value * lw if 'loss' in name else value)
+                    losses['s{}.{}'.format(i, name)] = (
+                        value * lw if 'loss' in name else value)
 
             # refine bboxes (same as Cascade R-CNN)
             if i < self.num_stages - 1 and not self.interleaved:
@@ -312,8 +312,9 @@ def simple_test(self, img, img_meta, proposals=None, rescale=False):
                             [] for _ in range(mask_head.num_classes - 1)
                         ]
                     else:
-                        _bboxes = (det_bboxes[:, :4] * scale_factor
-                                   if rescale else det_bboxes)
+                        _bboxes = (
+                            det_bboxes[:, :4] * scale_factor
+                            if rescale else det_bboxes)
                         mask_pred = self._mask_forward_test(
                             i, x, _bboxes, semantic_feat=semantic_feat)
                         segm_result = mask_head.get_seg_masks(
@@ -345,8 +346,9 @@ def simple_test(self, img, img_meta, proposals=None, rescale=False):
                     [] for _ in range(self.mask_head[-1].num_classes - 1)
                 ]
             else:
-                _bboxes = (det_bboxes[:, :4] * scale_factor
-                           if rescale else det_bboxes)
+                _bboxes = (
+                    det_bboxes[:, :4] * scale_factor
+                    if rescale else det_bboxes)
 
                 mask_rois = bbox2roi([_bboxes])
                 aug_masks = []

mmdet/models/detectors/test_mixins.py

@@ -105,8 +105,8 @@ def simple_test_mask(self,
         else:
             # if det_bboxes is rescaled to the original image size, we need to
             # rescale it back to the testing scale to obtain RoIs.
-            _bboxes = (det_bboxes[:, :4] * scale_factor
-                       if rescale else det_bboxes)
+            _bboxes = (
+                det_bboxes[:, :4] * scale_factor if rescale else det_bboxes)
             mask_rois = bbox2roi([_bboxes])
             mask_feats = self.mask_roi_extractor(
                 x[:len(self.mask_roi_extractor.featmap_strides)], mask_rois)

mmdet/models/mask_heads/fcn_mask_head.py

@@ -43,8 +43,8 @@ def __init__(self,
 
         self.convs = nn.ModuleList()
         for i in range(self.num_convs):
-            in_channels = (self.in_channels
-                           if i == 0 else self.conv_out_channels)
+            in_channels = (
+                self.in_channels if i == 0 else self.conv_out_channels)
             padding = (self.conv_kernel_size - 1) // 2
             self.convs.append(
                 ConvModule(
@@ -54,8 +54,8 @@ def __init__(self,
                     padding=padding,
                     conv_cfg=conv_cfg,
                     norm_cfg=norm_cfg))
-        upsample_in_channels = (self.conv_out_channels
-                                if self.num_convs > 0 else in_channels)
+        upsample_in_channels = (
+            self.conv_out_channels if self.num_convs > 0 else in_channels)
         if self.upsample_method is None:
             self.upsample = None
         elif self.upsample_method == 'deconv':
@@ -69,9 +69,9 @@ def __init__(self,
                 scale_factor=self.upsample_ratio, mode=self.upsample_method)
 
         out_channels = 1 if self.class_agnostic else self.num_classes
-        logits_in_channel = (self.conv_out_channels
-                             if self.upsample_method == 'deconv' else
-                             upsample_in_channels)
+        logits_in_channel = (
+            self.conv_out_channels
+            if self.upsample_method == 'deconv' else upsample_in_channels)
         self.conv_logits = nn.Conv2d(logits_in_channel, out_channels, 1)
         self.relu = nn.ReLU(inplace=True)
         self.debug_imgs = None