# Update python script

For fix flake8

Author: SnowMasaya

cfgs/config.py

@@ -1,6 +1,6 @@
 import os
-from .config_voc import *
-from .exps.darknet19_exp1 import *
+from .config_voc import *  # noqa
+from .exps.darknet19_exp1 import *  # noqa
 
 
 def mkdir(path, max_depth=3):
@@ -50,6 +50,7 @@ def _to_color(indx, base):
     g = 2 - (indx % base2) % base
     return b * 127, r * 127, g * 127
 
+
 base = int(np.ceil(pow(num_classes, 1. / 3)))
 colors = [_to_color(x, base) for x in range(num_classes)]
 

cfgs/config_voc.py

@@ -12,6 +12,7 @@
                'sheep', 'sofa', 'train', 'tvmonitor')
 num_classes = len(label_names)
 
-anchors = np.asarray([(1.08, 1.19), (3.42, 4.41), (6.63, 11.38), (9.42, 5.11), (16.62, 10.52)], dtype=np.float)
+anchors = np.asarray([(1.08, 1.19), (3.42, 4.41),
+                      (6.63, 11.38), (9.42, 5.11), (16.62, 10.52)],
+                     dtype=np.float)
 num_anchors = len(anchors)
-

darknet.py

@@ -11,7 +11,6 @@
 from functools import partial
 
 from multiprocessing import Pool
-import multiprocessing
 
 
 def _make_layers(in_channels, net_cfg):
@@ -67,7 +66,8 @@ def _process_batch(data, size_index):
         np.ascontiguousarray(bbox_pred_np, dtype=np.float),
         anchors,
         H, W)
-    bbox_np = bbox_np[0]  # bbox_np = (hw, num_anchors, (x1, y1, x2, y2))   range: 0 ~ 1
+    # bbox_np = (hw, num_anchors, (x1, y1, x2, y2))   range: 0 ~ 1
+    bbox_np = bbox_np[0]
     bbox_np[:, :, 0::2] *= float(inp_size[0])  # rescale x
     bbox_np[:, :, 1::2] *= float(inp_size[1])  # rescale y
 
@@ -95,8 +95,10 @@ def _process_batch(data, size_index):
     target_boxes = np.empty(gt_boxes_b.shape, dtype=np.float)
     target_boxes[:, 0] = cx - np.floor(cx)  # cx
     target_boxes[:, 1] = cy - np.floor(cy)  # cy
-    target_boxes[:, 2] = (gt_boxes_b[:, 2] - gt_boxes_b[:, 0]) / inp_size[0] * out_size[0]  # tw
-    target_boxes[:, 3] = (gt_boxes_b[:, 3] - gt_boxes_b[:, 1]) / inp_size[1] * out_size[1]  # th
+    target_boxes[:, 2] = \
+        (gt_boxes_b[:, 2] - gt_boxes_b[:, 0]) / inp_size[0] * out_size[0]  # tw
+    target_boxes[:, 3] = \
+        (gt_boxes_b[:, 3] - gt_boxes_b[:, 1]) / inp_size[1] * out_size[1]  # th
 
     # for each gt boxes, match the best anchor
     gt_boxes_resize = np.copy(gt_boxes_b)
@@ -116,8 +118,9 @@ def _process_batch(data, size_index):
             continue
         a = anchor_inds[i]
 
-        iou_pred_cell_anchor = iou_pred_np[cell_ind, a, :]  # 0 ~ 1, should be close to 1
-        _iou_mask[cell_ind, a, :] = cfg.object_scale * (1 - iou_pred_cell_anchor)
+        # 0 ~ 1, should be close to 1
+        iou_pred_cell_anchor = iou_pred_np[cell_ind, a, :]
+        _iou_mask[cell_ind, a, :] = cfg.object_scale * (1 - iou_pred_cell_anchor)  # noqa
         # _ious[cell_ind, a, :] = anchor_ious[a, i]
         _ious[cell_ind, a, :] = ious_reshaped[cell_ind, a, i]
 
@@ -169,7 +172,7 @@ def __init__(self):
         # linear
         out_channels = cfg.num_anchors * (cfg.num_classes + 5)
         self.conv5 = net_utils.Conv2d(c4, out_channels, 1, 1, relu=False)
-        self.global_average_pool = nn.AvgPool2d((1,1))
+        self.global_average_pool = nn.AvgPool2d((1, 1))
 
         # train
         self.bbox_loss = None
@@ -181,7 +184,8 @@ def __init__(self):
     def loss(self):
         return self.bbox_loss + self.iou_loss + self.cls_loss
 
-    def forward(self, im_data, gt_boxes=None, gt_classes=None, dontcare=None, size_index=0):
+    def forward(self, im_data, gt_boxes=None, gt_classes=None, dontcare=None,
+                size_index=0):
         conv1s = self.conv1s(im_data)
         conv2 = self.conv2(conv1s)
         conv3 = self.conv3(conv2)
@@ -192,10 +196,13 @@ def forward(self, im_data, gt_boxes=None, gt_classes=None, dontcare=None, size_i
         global_average_pool = self.global_average_pool(conv5)
 
         # for detection
-        # bsize, c, h, w -> bsize, h, w, c -> bsize, h x w, num_anchors, 5+num_classes
+        # bsize, c, h, w -> bsize, h, w, c ->
+        #                   bsize, h x w, num_anchors, 5+num_classes
         bsize, _, h, w = global_average_pool.size()
         # assert bsize == 1, 'detection only support one image per batch'
-        global_average_pool_reshaped = global_average_pool.permute(0, 2, 3, 1).contiguous().view(bsize, -1, cfg.num_anchors, cfg.num_classes + 5)
+        global_average_pool_reshaped = \
+            global_average_pool.permute(0, 2, 3, 1).contiguous().view(bsize,
+                                                                      -1, cfg.num_anchors, cfg.num_classes + 5)  # noqa
 
         # tx, ty, tw, th, to -> sig(tx), sig(ty), exp(tw), exp(th), sig(to)
         xy_pred = F.sigmoid(global_average_pool_reshaped[:, :, :, 0:2])
@@ -204,44 +211,55 @@ def forward(self, im_data, gt_boxes=None, gt_classes=None, dontcare=None, size_i
         iou_pred = F.sigmoid(global_average_pool_reshaped[:, :, :, 4:5])
 
         score_pred = global_average_pool_reshaped[:, :, :, 5:].contiguous()
-        prob_pred = F.softmax(score_pred.view(-1, score_pred.size()[-1])).view_as(score_pred)
+        prob_pred = F.softmax(score_pred.view(-1, score_pred.size()[-1])).view_as(score_pred)  # noqa
 
         # for training
         if self.training:
             bbox_pred_np = bbox_pred.data.cpu().numpy()
             iou_pred_np = iou_pred.data.cpu().numpy()
-            _boxes, _ious, _classes, _box_mask, _iou_mask, _class_mask = self._build_target(
-                bbox_pred_np, gt_boxes, gt_classes, dontcare, iou_pred_np, size_index)
+            _boxes, _ious, _classes, _box_mask, _iou_mask, _class_mask = \
+                self._build_target(bbox_pred_np,
+                                   gt_boxes,
+                                   gt_classes,
+                                   dontcare,
+                                   iou_pred_np,
+                                   size_index)
 
             _boxes = net_utils.np_to_variable(_boxes)
             _ious = net_utils.np_to_variable(_ious)
             _classes = net_utils.np_to_variable(_classes)
-            box_mask = net_utils.np_to_variable(_box_mask, dtype=torch.FloatTensor)
-            iou_mask = net_utils.np_to_variable(_iou_mask, dtype=torch.FloatTensor)
-            class_mask = net_utils.np_to_variable(_class_mask, dtype=torch.FloatTensor)
+            box_mask = net_utils.np_to_variable(_box_mask,
+                                                dtype=torch.FloatTensor)
+            iou_mask = net_utils.np_to_variable(_iou_mask,
+                                                dtype=torch.FloatTensor)
+            class_mask = net_utils.np_to_variable(_class_mask,
+                                                  dtype=torch.FloatTensor)
 
             num_boxes = sum((len(boxes) for boxes in gt_boxes))
 
             # _boxes[:, :, :, 2:4] = torch.log(_boxes[:, :, :, 2:4])
             box_mask = box_mask.expand_as(_boxes)
 
-            self.bbox_loss = nn.MSELoss(size_average=False)(bbox_pred * box_mask, _boxes * box_mask) / num_boxes
-            self.iou_loss = nn.MSELoss(size_average=False)(iou_pred * iou_mask, _ious * iou_mask) / num_boxes
+            self.bbox_loss = nn.MSELoss(size_average=False)(bbox_pred * box_mask, _boxes * box_mask) / num_boxes  # noqa
+            self.iou_loss = nn.MSELoss(size_average=False)(iou_pred * iou_mask, _ious * iou_mask) / num_boxes  # noqa
 
             class_mask = class_mask.expand_as(prob_pred)
-            self.cls_loss = nn.MSELoss(size_average=False)(prob_pred * class_mask, _classes * class_mask) / num_boxes
+            self.cls_loss = nn.MSELoss(size_average=False)(prob_pred * class_mask, _classes * class_mask) / num_boxes  # noqa
 
         return bbox_pred, iou_pred, prob_pred
 
-    def _build_target(self, bbox_pred_np, gt_boxes, gt_classes, dontcare, iou_pred_np, size_index):
+    def _build_target(self, bbox_pred_np, gt_boxes, gt_classes, dontcare,
+                      iou_pred_np, size_index):
         """
-        :param bbox_pred: shape: (bsize, h x w, num_anchors, 4) : (sig(tx), sig(ty), exp(tw), exp(th))
+        :param bbox_pred: shape: (bsize, h x w, num_anchors, 4) :
+                          (sig(tx), sig(ty), exp(tw), exp(th))
         """
 
         bsize = bbox_pred_np.shape[0]
 
         targets = self.pool.map(partial(_process_batch, size_index=size_index),
-                                ((bbox_pred_np[b], gt_boxes[b], gt_classes[b], dontcare[b], iou_pred_np[b])
+                                ((bbox_pred_np[b], gt_boxes[b],
+                                  gt_classes[b], dontcare[b], iou_pred_np[b])
                                  for b in range(bsize)))
 
         _boxes = np.stack(tuple((row[0] for row in targets)))
@@ -256,7 +274,8 @@ def _build_target(self, bbox_pred_np, gt_boxes, gt_classes, dontcare, iou_pred_n
     def load_from_npz(self, fname, num_conv=None):
         dest_src = {'conv.weight': 'kernel', 'conv.bias': 'biases',
                     'bn.weight': 'gamma', 'bn.bias': 'biases',
-                    'bn.running_mean': 'moving_mean', 'bn.running_var': 'moving_variance'}
+                    'bn.running_mean': 'moving_mean',
+                    'bn.running_var': 'moving_variance'}
         params = np.load(fname)
         own_dict = self.state_dict()
         keys = list(own_dict.keys())

datasets/imdb.py

@@ -1,5 +1,4 @@
 import os
-import PIL
 import numpy as np
 from multiprocessing import Pool
 from functools import partial
@@ -23,7 +22,8 @@ def image_resize(im, size_index):
 
 
 class ImageDataset(object):
-    def __init__(self, name, datadir, batch_size, im_processor, processes=3, shuffle=True, dst_size=None):
+    def __init__(self, name, datadir, batch_size, im_processor,
+                 processes=3, shuffle=True, dst_size=None):
         self._name = name
         self._data_dir = datadir
         self._batch_size = batch_size
@@ -48,7 +48,8 @@ def __init__(self, name, datadir, batch_size, im_processor, processes=3, shuffle
         self._im_processor = im_processor
 
     def next_batch(self, size_index):
-        batch = {'images': [], 'gt_boxes': [], 'gt_classes': [], 'dontcare': [], 'origin_im': []}
+        batch = {'images': [], 'gt_boxes': [], 'gt_classes': [],
+                 'dontcare': [], 'origin_im': []}
         i = 0
         while i < self.batch_size:
             try:
@@ -64,8 +65,11 @@ def next_batch(self, size_index):
                 indexes = np.arange(len(self.image_names), dtype=np.int)
                 if self._shuffle:
                     np.random.shuffle(indexes)
-                self.gen = self.pool.imap(partial(self._im_processor, size_index=size_index),
-                                          ([self.image_names[i], self.get_annotation(i), self.dst_size] for i in indexes),
+                self.gen = self.pool.imap(partial(self._im_processor,
+                                                  size_index=size_index),
+                                          ([self.image_names[i],
+                                            self.get_annotation(i),
+                                            self.dst_size] for i in indexes),
                                           chunksize=self.batch_size)
                 self._epoch += 1
                 print(('epoch {} start...'.format(self._epoch)))
@@ -141,5 +145,3 @@ def batch_size(self):
     @property
     def batch_per_epoch(self):
         return self.num_images // self.batch_size
-
-

datasets/pascal_voc.py

@@ -1,7 +1,6 @@
 import pickle
 import os
 import uuid
-import cv2
 import xml.etree.ElementTree as ET
 
 import numpy as np
@@ -15,22 +14,30 @@
 
 
 class VOCDataset(ImageDataset):
-    def __init__(self, imdb_name, datadir, batch_size, im_processor, processes=3, shuffle=True, dst_size=None):
-        super(VOCDataset, self).__init__(imdb_name, datadir, batch_size, im_processor, processes, shuffle, dst_size)
+    def __init__(self, imdb_name, datadir, batch_size, im_processor,
+                 processes=3, shuffle=True, dst_size=None):
+        super(VOCDataset, self).__init__(imdb_name, datadir, batch_size,
+                                         im_processor, processes,
+                                         shuffle, dst_size)
         meta = imdb_name.split('_')
         self._year = meta[1]
         self._image_set = meta[2]
-        self._devkit_path = os.path.join(datadir, 'VOCdevkit{}'.format(self._year))
-        self._data_path = os.path.join(self._devkit_path, 'VOC{}'.format(self._year))
-        assert os.path.exists(self._devkit_path), 'VOCdevkit path does not exist: {}'.format(self._devkit_path)
-        assert os.path.exists(self._data_path), 'Path does not exist: {}'.format(self._data_path)
+        self._devkit_path = os.path.join(datadir,
+                                         'VOCdevkit{}'.format(self._year))
+        self._data_path = os.path.join(self._devkit_path,
+                                       'VOC{}'.format(self._year))
+        assert os.path.exists(self._devkit_path), \
+            'VOCdevkit path does not exist: {}'.format(self._devkit_path)
+        assert os.path.exists(self._data_path), \
+            'Path does not exist: {}'.format(self._data_path)
 
         self._classes = ('aeroplane', 'bicycle', 'bird', 'boat',
                          'bottle', 'bus', 'car', 'cat', 'chair',
                          'cow', 'diningtable', 'dog', 'horse',
                          'motorbike', 'person', 'pottedplant',
                          'sheep', 'sofa', 'train', 'tvmonitor')
-        self._class_to_ind = dict(list(zip(self.classes, list(range(self.num_classes)))))
+        self._class_to_ind = dict(list(zip(self.classes,
+                                           list(range(self.num_classes)))))
         self._image_ext = '.jpg'
 
         self._salt = str(uuid.uuid4())
@@ -41,13 +48,15 @@ def __init__(self, imdb_name, datadir, batch_size, im_processor, processes=3, sh
                        'use_salt': True}
 
         self.load_dataset()
-        # self.im_processor = partial(process_im, image_names=self._image_names, annotations=self._annotations)
+        # self.im_processor = partial(process_im,
+        #     image_names=self._image_names, annotations=self._annotations)
         # self.im_processor = preprocess_train
 
     def load_dataset(self):
         # set self._image_index and self._annotations
         self._image_indexes = self._load_image_set_index()
-        self._image_names = [self.image_path_from_index(index) for index in self.image_indexes]
+        self._image_names = [self.image_path_from_index(index)
+                             for index in self.image_indexes]
         self._annotations = self._load_pascal_annotations()
 
     def evaluate_detections(self, all_boxes, output_dir=None):
@@ -97,7 +106,8 @@ def _load_pascal_annotations(self):
         """
         Return the database of ground-truth regions of interest.
 
-        This function loads/saves from/to a cache file to speed up future calls.
+        This function loads/saves from/to a cache file to speed up
+        future calls.
         """
         cache_file = os.path.join(self.cache_path, self.name + '_gt_roidb.pkl')
         if os.path.exists(cache_file):
@@ -149,7 +159,7 @@ def _annotation_from_index(self, index):
             y2 = float(bbox.find('ymax').text) - 1
 
             diffc = obj.find('difficult')
-            difficult = 0 if diffc == None else int(diffc.text)
+            difficult = 0 if diffc is None else int(diffc.text)
             ishards[ix] = difficult
 
             cls = self._class_to_ind[obj.find('name').text.lower().strip()]
@@ -169,8 +179,10 @@ def _annotation_from_index(self, index):
 
     def _get_voc_results_file_template(self):
         # VOCdevkit/results/VOC2007/Main/<comp_id>_det_test_aeroplane.txt
-        filename = self._get_comp_id() + '_det_' + self._image_set + '_{:s}.txt'
-        filedir = os.path.join(self._devkit_path, 'results', 'VOC' + self._year, 'Main')
+        filename = self._get_comp_id() + '_det_' + self._image_set + \
+                   '_{:s}.txt'
+        filedir = os.path.join(self._devkit_path,
+                               'results', 'VOC' + self._year, 'Main')
         if not os.path.exists(filedir):
             os.makedirs(filedir)
         path = os.path.join(filedir, filename)

datasets/voc_eval.py

@@ -8,7 +8,6 @@
 import os
 import pickle
 import numpy as np
-import pdb
 
 
 def parse_rec(filename):
@@ -64,6 +63,7 @@ def voc_ap(rec, prec, use_07_metric=False):
         ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
     return ap
 
+
 def voc_eval(detpath,
              annopath,
              imagesetfile,
@@ -148,7 +148,6 @@ def voc_eval(detpath,
 
         # sort by confidence
         sorted_ind = np.argsort(-confidence)
-        sorted_scores = np.sort(-confidence)
         BB = BB[sorted_ind, :]
         image_ids = [image_ids[x] for x in sorted_ind]
 
@@ -201,8 +200,8 @@ def voc_eval(detpath,
         prec = tp / np.maximum(tp + fp, np.finfo(np.float64).eps)
         ap = voc_ap(rec, prec, use_07_metric)
     else:
-         rec = -1
-         prec = -1
-         ap = -1
+        rec = -1
+        prec = -1
+        ap = -1
 
     return rec, prec, ap