Format the code and add yapf to travis (#1079)

* format the codebase with yapf

* add yapf to travis

.travis.yml

@@ -2,7 +2,7 @@ dist: xenial
 language: python
 
 install:
-  - pip install flake8
+  - pip install flake8 yapf
 
 python:
   - "3.5"
@@ -11,3 +11,4 @@ python:
 
 script:
   - flake8
+  - yapf -r -d --style .style.yapf mmdet/ tools/
\ No newline at end of file

mmdet/core/anchor/anchor_generator.py

@@ -33,12 +33,14 @@ class AnchorGenerator(object):
             ws = (w * self.scales[:, None] * w_ratios[None, :]).view(-1)
             hs = (h * self.scales[:, None] * h_ratios[None, :]).view(-1)
 
+        # yapf: disable
         base_anchors = torch.stack(
             [
                 x_ctr - 0.5 * (ws - 1), y_ctr - 0.5 * (hs - 1),
                 x_ctr + 0.5 * (ws - 1), y_ctr + 0.5 * (hs - 1)
             ],
             dim=-1).round()
+        # yapf: enable
 
         return base_anchors
 

mmdet/core/anchor/guided_anchor_target.py

@@ -62,7 +62,8 @@ def ga_loc_target(gt_bboxes_list,
     all_ignore_map = []
     for lvl_id in range(num_lvls):
         h, w = featmap_sizes[lvl_id]
-        loc_targets = torch.zeros(img_per_gpu,
+        loc_targets = torch.zeros(
+            img_per_gpu,
             1,
             h,
             w,
@@ -175,7 +176,8 @@ def ga_shape_target(approx_list,
     if gt_bboxes_ignore_list is None:
         gt_bboxes_ignore_list = [None for _ in range(num_imgs)]
     (all_bbox_anchors, all_bbox_gts, all_bbox_weights, pos_inds_list,
-     neg_inds_list) = multi_apply(ga_shape_target_single,
+     neg_inds_list) = multi_apply(
+         ga_shape_target_single,
          approx_flat_list,
          inside_flag_flat_list,
          square_flat_list,

mmdet/core/bbox/assigners/approx_max_iou_assigner.py

@@ -101,14 +101,12 @@ class ApproxMaxIoUAssigner(MaxIoUAssigner):
         if (self.ignore_iof_thr > 0) and (gt_bboxes_ignore is not None) and (
                 gt_bboxes_ignore.numel() > 0):
             if self.ignore_wrt_candidates:
-                ignore_overlaps = bbox_overlaps(bboxes,
-                                                gt_bboxes_ignore,
-                                                mode='iof')
+                ignore_overlaps = bbox_overlaps(
+                    bboxes, gt_bboxes_ignore, mode='iof')
                 ignore_max_overlaps, _ = ignore_overlaps.max(dim=1)
             else:
-                ignore_overlaps = bbox_overlaps(gt_bboxes_ignore,
-                                                bboxes,
-                                                mode='iof')
+                ignore_overlaps = bbox_overlaps(
+                    gt_bboxes_ignore, bboxes, mode='iof')
                 ignore_max_overlaps, _ = ignore_overlaps.max(dim=0)
             overlaps[:, ignore_max_overlaps > self.ignore_iof_thr] = -1
 

mmdet/core/bbox/assigners/max_iou_assigner.py

@@ -107,8 +107,9 @@ class MaxIoUAssigner(BaseAssigner):
         num_gts, num_bboxes = overlaps.size(0), overlaps.size(1)
 
         # 1. assign -1 by default
-        assigned_gt_inds = overlaps.new_full(
-            (num_bboxes, ), -1, dtype=torch.long)
+        assigned_gt_inds = overlaps.new_full((num_bboxes, ),
+                                             -1,
+                                             dtype=torch.long)
 
         # for each anchor, which gt best overlaps with it
         # for each anchor, the max iou of all gts

mmdet/core/bbox/bbox_target.py

@@ -62,10 +62,10 @@ def bbox_target_single(pos_bboxes,
 
 
 def expand_target(bbox_targets, bbox_weights, labels, num_classes):
-    bbox_targets_expand = bbox_targets.new_zeros((bbox_targets.size(0),
-                                                  4 * num_classes))
-    bbox_weights_expand = bbox_weights.new_zeros((bbox_weights.size(0),
-                                                  4 * num_classes))
+    bbox_targets_expand = bbox_targets.new_zeros(
+        (bbox_targets.size(0), 4 * num_classes))
+    bbox_weights_expand = bbox_weights.new_zeros(
+        (bbox_weights.size(0), 4 * num_classes))
     for i in torch.nonzero(labels > 0).squeeze(-1):
         start, end = labels[i] * 4, (labels[i] + 1) * 4
         bbox_targets_expand[i, start:end] = bbox_targets[i, :]

mmdet/core/evaluation/mean_ap.py

@@ -279,8 +279,8 @@ def eval_map(det_results,
                     bbox[:, 3] - bbox[:, 1] + 1)
                 for k, (min_area, max_area) in enumerate(area_ranges):
                     num_gts[k] += np.sum(
-                        np.logical_not(cls_gt_ignore[j]) &
-                        (gt_areas >= min_area) & (gt_areas < max_area))
+                        np.logical_not(cls_gt_ignore[j])
+                        & (gt_areas >= min_area) & (gt_areas < max_area))
         # sort all det bboxes by score, also sort tp and fp
         cls_dets = np.vstack(cls_dets)
         num_dets = cls_dets.shape[0]
@@ -312,11 +312,12 @@ def eval_map(det_results,
         all_ap = np.vstack([cls_result['ap'] for cls_result in eval_results])
         all_num_gts = np.vstack(
             [cls_result['num_gts'] for cls_result in eval_results])
-        mean_ap = [
-            all_ap[all_num_gts[:, i] > 0, i].mean()
-            if np.any(all_num_gts[:, i] > 0) else 0.0
-            for i in range(num_scales)
-        ]
+        mean_ap = []
+        for i in range(num_scales):
+            if np.any(all_num_gts[:, i] > 0):
+                mean_ap.append(all_ap[all_num_gts[:, i] > 0, i].mean())
+            else:
+                mean_ap.append(0.0)
     else:
         aps = []
         for cls_result in eval_results:
@@ -368,8 +369,8 @@ def print_map_summary(mean_ap, results, dataset=None):
         for j in range(num_classes):
             row_data = [
                 label_names[j], num_gts[i, j], results[j]['num_dets'],
-                '{:.3f}'.format(recalls[i, j]), '{:.3f}'.format(
-                    precisions[i, j]), '{:.3f}'.format(aps[i, j])
+                '{:.3f}'.format(recalls[i, j]),
+                '{:.3f}'.format(precisions[i, j]), '{:.3f}'.format(aps[i, j])
             ]
             table_data.append(row_data)
         table_data.append(['mAP', '', '', '', '', '{:.3f}'.format(mean_ap[i])])

mmdet/core/post_processing/bbox_nms.py

@@ -45,8 +45,9 @@ 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/__init__.py

@@ -15,6 +15,6 @@ __all__ = [
     'CustomDataset', 'XMLDataset', 'CocoDataset', 'VOCDataset',
     'CityscapesDataset', 'GroupSampler', 'DistributedGroupSampler',
     'build_dataloader', 'to_tensor', 'random_scale', 'show_ann',
-    'ConcatDataset', 'RepeatDataset', 'ExtraAugmentation',
-    'WIDERFaceDataset', 'DATASETS', 'build_dataset'
+    'ConcatDataset', 'RepeatDataset', 'ExtraAugmentation', 'WIDERFaceDataset',
+    'DATASETS', 'build_dataset'
 ]

mmdet/datasets/builder.py

@@ -29,8 +29,8 @@ def _concat_dataset(cfg, default_args=None):
 
 def build_dataset(cfg, default_args=None):
     if cfg['type'] == 'RepeatDataset':
-        dataset = RepeatDataset(build_dataset(cfg['dataset'], default_args),
-                                cfg['times'])
+        dataset = RepeatDataset(
+            build_dataset(cfg['dataset'], default_args), cfg['times'])
     elif isinstance(cfg['ann_file'], (list, tuple)):
         dataset = _concat_dataset(cfg, default_args)
     else:

mmdet/datasets/cityscapes.py

@@ -5,5 +5,5 @@ from .registry import DATASETS
 @DATASETS.register_module
 class CityscapesDataset(CocoDataset):
 
-    CLASSES = ('person', 'rider', 'car', 'truck', 'bus',
-               'train', 'motorcycle', 'bicycle')
+    CLASSES = ('person', 'rider', 'car', 'truck', 'bus', 'train', 'motorcycle',
+               'bicycle')

mmdet/datasets/extra_aug.py

@@ -115,8 +115,8 @@ class RandomCrop(object):
                 left = random.uniform(w - new_w)
                 top = random.uniform(h - new_h)
 
-                patch = np.array((int(left), int(top), int(left + new_w),
-                                  int(top + new_h)))
+                patch = np.array(
+                    (int(left), int(top), int(left + new_w), int(top + new_h)))
                 overlaps = bbox_overlaps(
                     patch.reshape(-1, 4), boxes.reshape(-1, 4)).reshape(-1)
                 if overlaps.min() < min_iou:

mmdet/models/anchor_heads/ga_retina_head.py

@@ -30,7 +30,8 @@ class GARetinaHead(GuidedAnchorHead):
         for i in range(self.stacked_convs):
             chn = self.in_channels if i == 0 else self.feat_channels
             self.cls_convs.append(
-                ConvModule(chn,
+                ConvModule(
+                    chn,
                     self.feat_channels,
                     3,
                     stride=1,
@@ -38,7 +39,8 @@ class GARetinaHead(GuidedAnchorHead):
                     conv_cfg=self.conv_cfg,
                     norm_cfg=self.norm_cfg))
             self.reg_convs.append(
-                ConvModule(chn,
+                ConvModule(
+                    chn,
                     self.feat_channels,
                     3,
                     stride=1,
@@ -59,15 +61,13 @@ class GARetinaHead(GuidedAnchorHead):
             self.feat_channels,
             kernel_size=3,
             deformable_groups=self.deformable_groups)
-        self.retina_cls = MaskedConv2d(self.feat_channels,
-                                       self.num_anchors *
-                                       self.cls_out_channels,
-                                       3,
-                                       padding=1)
-        self.retina_reg = MaskedConv2d(self.feat_channels,
-                                       self.num_anchors * 4,
+        self.retina_cls = MaskedConv2d(
+            self.feat_channels,
+            self.num_anchors * self.cls_out_channels,
             3,
             padding=1)
+        self.retina_reg = MaskedConv2d(
+            self.feat_channels, self.num_anchors * 4, 3, padding=1)
 
     def init_weights(self):
         for m in self.cls_convs:

mmdet/models/anchor_heads/ga_rpn_head.py

@@ -17,10 +17,8 @@ class GARPNHead(GuidedAnchorHead):
         super(GARPNHead, self).__init__(2, in_channels, **kwargs)
 
     def _init_layers(self):
-        self.rpn_conv = nn.Conv2d(self.in_channels,
-                                  self.feat_channels,
-                                  3,
-                                  padding=1)
+        self.rpn_conv = nn.Conv2d(
+            self.in_channels, self.feat_channels, 3, padding=1)
         super(GARPNHead, self)._init_layers()
 
     def init_weights(self):
@@ -43,7 +41,8 @@ class GARPNHead(GuidedAnchorHead):
              img_metas,
              cfg,
              gt_bboxes_ignore=None):
-        losses = super(GARPNHead, self).loss(cls_scores,
+        losses = super(GARPNHead, self).loss(
+            cls_scores,
             bbox_preds,
             shape_preds,
             loc_preds,
@@ -52,7 +51,8 @@ class GARPNHead(GuidedAnchorHead):
             img_metas,
             cfg,
             gt_bboxes_ignore=gt_bboxes_ignore)
-        return dict(loss_rpn_cls=losses['loss_cls'],
+        return dict(
+            loss_rpn_cls=losses['loss_cls'],
             loss_rpn_bbox=losses['loss_bbox'],
             loss_anchor_shape=losses['loss_shape'],
             loss_anchor_loc=losses['loss_loc'])

mmdet/models/detectors/cascade_rcnn.py

@@ -282,13 +282,12 @@ class CascadeRCNN(BaseDetector, RPNTestMixin):
                     mask_roi_extractor = self.mask_roi_extractor[i]
                     mask_head = self.mask_head[i]
                     if det_bboxes.shape[0] == 0:
-                        segm_result = [
-                            [] for _ in range(mask_head.num_classes - 1)
-                        ]
+                        mask_classes = mask_head.num_classes - 1
+                        segm_result = [[] for _ in range(mask_classes)]
                     else:
                         _bboxes = (
-                            det_bboxes[:, :4] * scale_factor
-                            if rescale else det_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)],
@@ -321,13 +320,12 @@ class CascadeRCNN(BaseDetector, RPNTestMixin):
 
         if self.with_mask:
             if det_bboxes.shape[0] == 0:
-                segm_result = [
-                    [] for _ in range(self.mask_head[-1].num_classes - 1)
-                ]
+                mask_classes = self.mask_head[-1].num_classes - 1
+                segm_result = [[] for _ in range(mask_classes)]
             else:
                 _bboxes = (
-                    det_bboxes[:, :4] * scale_factor
-                    if rescale else det_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

@@ -205,8 +205,9 @@ class HybridTaskCascade(CascadeRCNN):
                 gt_bboxes_ignore = [None for _ in range(num_imgs)]
 
             for j in range(num_imgs):
-                assign_result = bbox_assigner.assign(
-                    proposal_list[j], gt_bboxes[j], gt_bboxes_ignore[j],
+                assign_result = bbox_assigner.assign(proposal_list[j],
+                                                     gt_bboxes[j],
+                                                     gt_bboxes_ignore[j],
                                                      gt_labels[j])
                 sampling_result = bbox_sampler.sample(
                     assign_result,
@@ -308,13 +309,12 @@ class HybridTaskCascade(CascadeRCNN):
                 if self.with_mask:
                     mask_head = self.mask_head[i]
                     if det_bboxes.shape[0] == 0:
-                        segm_result = [
-                            [] for _ in range(mask_head.num_classes - 1)
-                        ]
+                        mask_classes = mask_head.num_classes - 1
+                        segm_result = [[] for _ in range(mask_classes)]
                     else:
                         _bboxes = (
-                            det_bboxes[:, :4] * scale_factor
-                            if rescale else det_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(
@@ -342,13 +342,12 @@ class HybridTaskCascade(CascadeRCNN):
 
         if self.with_mask:
             if det_bboxes.shape[0] == 0:
-                segm_result = [
-                    [] for _ in range(self.mask_head[-1].num_classes - 1)
-                ]
+                mask_classes = self.mask_head[-1].num_classes - 1
+                segm_result = [[] for _ in range(mask_classes)]
             else:
                 _bboxes = (
-                    det_bboxes[:, :4] * scale_factor
-                    if rescale else det_bboxes)
+                    det_bboxes[:, :4] *
+                    scale_factor if rescale else det_bboxes)
 
                 mask_rois = bbox2roi([_bboxes])
                 aug_masks = []

mmdet/models/detectors/test_mixins.py

@@ -91,9 +91,10 @@ class BBoxTestMixin(object):
         # after merging, bboxes will be rescaled to the original image size
         merged_bboxes, merged_scores = merge_aug_bboxes(
             aug_bboxes, aug_scores, img_metas, rcnn_test_cfg)
-        det_bboxes, det_labels = multiclass_nms(
-            merged_bboxes, merged_scores, rcnn_test_cfg.score_thr,
-            rcnn_test_cfg.nms, rcnn_test_cfg.max_per_img)
+        det_bboxes, det_labels = multiclass_nms(merged_bboxes, merged_scores,
+                                                rcnn_test_cfg.score_thr,
+                                                rcnn_test_cfg.nms,
+                                                rcnn_test_cfg.max_per_img)
         return det_bboxes, det_labels
 
 
@@ -121,9 +122,11 @@ class MaskTestMixin(object):
             if self.with_shared_head:
                 mask_feats = self.shared_head(mask_feats)
             mask_pred = self.mask_head(mask_feats)
-            segm_result = self.mask_head.get_seg_masks(
-                mask_pred, _bboxes, det_labels, self.test_cfg.rcnn, ori_shape,
-                scale_factor, rescale)
+            segm_result = self.mask_head.get_seg_masks(mask_pred, _bboxes,
+                                                       det_labels,
+                                                       self.test_cfg.rcnn,
+                                                       ori_shape, scale_factor,
+                                                       rescale)
         return segm_result
 
     def aug_test_mask(self, feats, img_metas, det_bboxes, det_labels):

mmdet/models/detectors/two_stage.py

@@ -125,8 +125,9 @@ class TwoStageDetector(BaseDetector, RPNTestMixin, BBoxTestMixin,
                 gt_bboxes_ignore = [None for _ in range(num_imgs)]
             sampling_results = []
             for i in range(num_imgs):
-                assign_result = bbox_assigner.assign(
-                    proposal_list[i], gt_bboxes[i], gt_bboxes_ignore[i],
+                assign_result = bbox_assigner.assign(proposal_list[i],
+                                                     gt_bboxes[i],
+                                                     gt_bboxes_ignore[i],
                                                      gt_labels[i])
                 sampling_result = bbox_sampler.sample(
                     assign_result,
@@ -146,8 +147,9 @@ class TwoStageDetector(BaseDetector, RPNTestMixin, BBoxTestMixin,
                 bbox_feats = self.shared_head(bbox_feats)
             cls_score, bbox_pred = self.bbox_head(bbox_feats)
 
-            bbox_targets = self.bbox_head.get_target(
-                sampling_results, gt_bboxes, gt_labels, self.train_cfg.rcnn)
+            bbox_targets = self.bbox_head.get_target(sampling_results,
+                                                     gt_bboxes, gt_labels,
+                                                     self.train_cfg.rcnn)
             loss_bbox = self.bbox_head.loss(cls_score, bbox_pred,
                                             *bbox_targets)
             losses.update(loss_bbox)
@@ -179,8 +181,9 @@ class TwoStageDetector(BaseDetector, RPNTestMixin, BBoxTestMixin,
                 mask_feats = bbox_feats[pos_inds]
             mask_pred = self.mask_head(mask_feats)
 
-            mask_targets = self.mask_head.get_target(
-                sampling_results, gt_masks, self.train_cfg.rcnn)
+            mask_targets = self.mask_head.get_target(sampling_results,
+                                                     gt_masks,
+                                                     self.train_cfg.rcnn)
             pos_labels = torch.cat(
                 [res.pos_gt_labels for res in sampling_results])
             loss_mask = self.mask_head.loss(mask_pred, mask_targets,

mmdet/models/mask_heads/fused_semantic_head.py

@@ -98,7 +98,7 @@ class FusedSemanticHead(nn.Module):
         x = self.conv_embedding(x)
         return mask_pred, x
 
-    @force_fp32(apply_to=('mask_pred',))
+    @force_fp32(apply_to=('mask_pred', ))
     def loss(self, mask_pred, labels):
         labels = labels.squeeze(1).long()
         loss_semantic_seg = self.criterion(mask_pred, labels)

mmdet/models/roi_extractors/single_level.py

@@ -72,7 +72,7 @@ class SingleRoIExtractor(nn.Module):
         target_lvls = target_lvls.clamp(min=0, max=num_levels - 1).long()
         return target_lvls
 
-    @force_fp32(apply_to=('feats',), out_fp16=True)
+    @force_fp32(apply_to=('feats', ), out_fp16=True)
     def forward(self, feats, rois):
         if len(feats) == 1:
             return self.roi_layers[0](feats[0], rois)