pi thresholding

Author: yoojy31

run_mmod_coco.sh renamed to run_mmod.sh

@@ -1,14 +1,14 @@
 #!/usr/bin/env bash
 
 python3 ./src/run.py \
---bash_file="./run_mmod_coco.sh" \
---result_dir="./result/`(date "+%Y%m%d%H%M%S")`-coco-320x320-mmod_res50fpn-preset" \
+--bash_file="./run_mmod.sh" \
+--result_dir="./result/`(date "+%Y%m%d%H%M%S")`-320x320-res50fpn" \
 \
 --global_args="{
     'n_classes': 81, 'batch_size': 32,
     'img_h': 320, 'img_w': 320,
     'coord_h': 10, 'coord_w': 10,
-    'devices': [0, 1], 'main_device': 0,
+    'devices': [0], 'main_device': 0,
 }" \
 --network_args="{
     'pretrained': True, 'backbone': 'res50fpn', 'fmap_ch': 256,

run_mmod_voc.sh

@@ -1,18 +1,15 @@
-import os
 import abc
 import traceback
 import numpy as np
 import scipy.misc
 from shutil import copyfile
-from xml.etree import ElementTree
 from torch.utils.data.dataset import Dataset
 from .pre_proc import get_pre_proc_dict
 from lib.external.dataset.roidb import combined_roidb
 
 
 def get_dataset_dict():
     return {
-        'voc': VOCDataset,
         'coco': COCODataset,
     }
 
@@ -39,91 +36,6 @@ def get_dataset_roots(self):
         pass
 
 
-class VOCDataset(DatasetABC):
-    def __init__(self, global_args, dataset_args):
-        super(VOCDataset, self).__init__(global_args, dataset_args)
-
-        img_pathes = list()
-        anno_pathes = list()
-        for root_dir, set_type in zip(self.roots, self.types):
-            set_path = os.path.join(root_dir, 'ImageSets', 'Main', '%s.txt' % set_type)
-            img_path_form = os.path.join(root_dir, 'JPEGImages', '%s.jpg')
-            anno_path_form = os.path.join(root_dir, 'Annotations', '%s.xml')
-
-            with open(set_path) as file:
-                for img_name in file.readlines():
-                    img_name = img_name.strip('\n')
-                    img_pathes.append(img_path_form % img_name)
-                    anno_pathes.append(anno_path_form % img_name)
-
-        self.img_pathes = np.array(img_pathes).astype(np.string_)
-        self.anno_pathes = np.array(anno_pathes).astype(np.string_)
-
-        self.name2number_map = {
-            'background': 0,
-            'aeroplane': 1, 'bicycle': 2, 'bird': 3, 'boat': 4,
-            'bottle': 5, 'bus': 6, 'car': 7, 'cat': 8, 'chair': 9,
-            'cow': 10, 'diningtable': 11, 'dog': 12, 'horse': 13,
-            'motorbike': 14, 'person': 15, 'pottedplant': 16,
-            'sheep': 17, 'sofa': 18, 'train': 19, 'tvmonitor': 20}
-        self.number2name_map = {
-            0: 'background',
-            1: 'aeroplane', 2: 'bicycle', 3: 'bird', 4: 'boat',
-            5: 'bottle', 6: 'bus', 7: 'car', 8: 'cat', 9: 'chair',
-            10: 'cow', 11: 'diningtable', 12: 'dog', 13: 'horse',
-            14: 'motorbike', 15: 'person', 16: 'pottedplant',
-            17: 'sheep', 18: 'sofa', 19: 'train', 20: 'tvmonitor'}
-
-    def __len__(self):
-        return len(self.img_pathes)
-
-    def __getitem__(self, data_idx):
-        img = scipy.misc.imread(self.img_pathes[data_idx])
-        anno = ElementTree.parse(self.anno_pathes[data_idx]).getroot()
-        boxes, labels = self.__parse_anno__(anno)
-
-        sample_dict = {'img': img, 'boxes': boxes, 'labels': labels}
-        try:
-            sample_dict = self.pre_proc.process(sample_dict)
-        except Exception:
-            print(traceback.print_exc())
-            print('- %s\n' % self.img_pathes[data_idx])
-            copyfile( self.img_pathes[data_idx].replace('coco2017', 'coco2017-2'), self.img_pathes[data_idx])
-            sample_dict = self.__getitem__(data_idx)
-        return sample_dict
-
-    def __getitem_tmp__(self, data_idx):
-        img = scipy.misc.imread(self.img_pathes[data_idx])
-        anno = ElementTree.parse(self.anno_pathes[data_idx]).getroot()
-        boxes, labels = self.__parse_anno__(anno)
-
-        sample_dict = {'img': img, 'boxes': boxes, 'labels': labels}
-        sample_dict = self.pre_proc.process(sample_dict)
-        return sample_dict
-
-    def __parse_anno__(self, anno):
-        boxes = list()
-        labels = list()
-        for obj in anno.findall('object'):
-            bndbox = obj.find('bndbox')
-            boxes.append([
-                float(bndbox.find('xmin').text), float(bndbox.find('ymin').text),
-                float(bndbox.find('xmax').text), float(bndbox.find('ymax').text)])
-            labels.append(np.array(self.name2number_map[obj.find('name').text]))
-        boxes = np.array(boxes)
-        labels = np.array(labels)
-        return boxes, labels
-
-    def get_name2number_map(self):
-        return self.name2number_map
-
-    def get_number2name_map(self):
-        return self.number2name_map
-
-    def get_dataset_roots(self):
-        return self.roots
-
-
 class COCODataset(DatasetABC):
     def __init__(self, global_args, dataset_args):
         super(COCODataset, self).__init__(global_args, dataset_args)

src/lib/dataset.py

@@ -370,7 +370,8 @@ def convert_model(module):
     if isinstance(module, torch.nn.DataParallel):
         mod = module.module
         mod = convert_model(mod)
-        mod = DataParallelWithCallback(mod)
+        mod = DataParallelWithCallback(mod, device_ids=module.device_ids)
+        # mod = DataParallelWithCallback(mod)
         return mod
 
     mod = module

src/lib/external/sync_batchnorm/batchnorm.py

@@ -71,4 +71,3 @@ def forward(self, input_):
                 self.weight.unsqueeze(1) + self.bias.unsqueeze(1))
 
         return output.view(channels, batchsize, height, width).permute(1, 0, 2, 3).contiguous()
-

src/lib/external/sync_batchnorm/batchnorm_reimpl.py

@@ -10,7 +10,6 @@ def init_modules_xavier(module_list):
                 isinstance(m, nn.ConvTranspose2d) or \
                 isinstance(m, nn.BatchNorm2d):
             if m.weight is not None:
-                # print('init')
                 nn.init.xavier_uniform_(m.weight)
             if m.bias is not None:
                 m.bias.data.zero_()
@@ -66,20 +65,18 @@ def create_box_coord_map(output_size, output_ch, coord_range):
     # gauss_ch: 4 --> ((0, 1, 2, 3), ...)
     ch_map = np.array(list(range(output_ch)))
 
-    # coord_w: 100 --> unit_intv_w: 20 = 100 / (4 + 1)
+    # coord_w: 10 --> unit_intv_w: 2 = 10 / (4 + 1)
     unit_intv_w = coord_range[1] / (output_ch + 1.0)
     unit_intv_h = coord_range[0] / (output_ch + 1.0)
 
-    # ((0, 1, 2, 3) + 1) * 20 == (20, 40, 60, 80)
+    # ((0, 1, 2, 3) + 1) * 2 == (2, 4, 6, 8)
     w_map = (ch_map + 1) * unit_intv_w
     h_map = (ch_map + 1) * unit_intv_h
 
-    # ((20, 40, 60, 80) / 100)^2 == (0.04, 0.16, 0.36, 0.64)
-    # (0.04, 0.16, 0.36, 0.64) * 100 == (4, 16, 36, 64)
-    # w_map = ((w_map / coord_range[1]) ** 2) * coord_range[1]
-    # h_map = ((h_map / coord_range[0]) ** 2) * coord_range[0]
-    w_map = (w_map / coord_range[1]) * coord_range[1]
-    h_map = (h_map / coord_range[0]) * coord_range[0]
+    # ((2, 4, 6, 8) / 10)^2 == (0.04, 0.16, 0.36, 0.64)
+    # (0.04, 0.16, 0.36, 0.64) * 10 == (0.4, 1.6, 3.6, 6.4)
+    w_map = ((w_map / coord_range[1]) ** 2) * coord_range[1]
+    h_map = ((h_map / coord_range[0]) ** 2) * coord_range[0]
 
     w_map = w_map.reshape((output_ch, 1, 1))
     h_map = h_map.reshape((output_ch, 1, 1))
@@ -93,10 +90,7 @@ def create_box_coord_map(output_size, output_ch, coord_range):
 
 
 def create_limit_scale(batch_size, output_sizes, coord_range, limit_factor):
-    # n_lv_mix_comps = [output_size[0] * output_size[1] for output_size in output_sizes]
-
     lv_x_limit_scales, lv_y_limit_scales = list(), list()
-    # for i, n_lv_mix_comp in enumerate(n_lv_mix_comps):
     for output_size in output_sizes:
         x_limit_scale = (coord_range[1] / output_size[1]) * limit_factor
         y_limit_scale = (coord_range[0] / output_size[0]) * limit_factor

src/lib/network_util.py

@@ -15,66 +15,57 @@ def __init__(self, global_args, post_proc_args):
         self.max_boxes = post_proc_args['max_boxes']
 
     def __filter_cls_boxes_s__(self, boxes_s, confs_s, pi_s):
-        cls_boxes_sl = list()
-        cls_confs_sl = list()
-        cls_labels_sl = list()
+        boxes_sl = list()
+        confs_sl = list()
+        labels_sl = list()
 
         norm_pi_s = pi_s / torch.max(pi_s)
+        keep_idxes = torch.nonzero(norm_pi_s > self.pi_thresh).view(-1)
+        boxes_s = boxes_s[:, keep_idxes]
+        confs_s = confs_s[:, keep_idxes]
+
         for c in range(self.n_classes - 1):
-            cls_boxes_sc = boxes_s[c]
-            cls_confs_sc = confs_s[c]
-            # cls_pi_sc = norm_pi_s.clone()
+            boxes_sc = boxes_s[c]
+            confs_sc = confs_s[c]
 
-            if len(cls_boxes_sc) == 0:
+            if len(boxes_sc) == 0:
                 continue
 
-            # print(cls_boxes_sc.shape)
-            keep_idxes = torch.nonzero(norm_pi_s > self.pi_thresh).view(-1)
-            cls_boxes_sc = cls_boxes_sc[keep_idxes]
-            cls_confs_sc = cls_confs_sc[keep_idxes]
-
-            # print(cls_boxes_sc.shape)
-            keep_idxes = torch.nonzero(cls_confs_sc > self.conf_thresh).view(-1)
-            cls_boxes_sc = cls_boxes_sc[keep_idxes]
-            cls_confs_sc = cls_confs_sc[keep_idxes]
+            keep_idxes = torch.nonzero(confs_sc > self.conf_thresh).view(-1)
+            boxes_sc = boxes_sc[keep_idxes]
+            confs_sc = confs_sc[keep_idxes]
             if keep_idxes.shape[0] == 0:
                 continue
-            # print(cls_boxes_sc.shape)
-            # print('')
 
             if self.nms_thresh <= 0.0:
-                cls_boxes_sc, cls_confs_sc = lib_util.sort_boxes_s(cls_boxes_sc, cls_confs_sc)
-                cls_boxes_sc, cls_confs_sc = cls_boxes_sc[:1], cls_confs_sc[:1]
+                boxes_sc, confs_sc = lib_util.sort_boxes_s(boxes_sc, confs_sc)
+                boxes_sc, confs_sc = boxes_sc[:1], confs_sc[:1]
             elif self.nms_thresh > 1.0:
                 pass
             else:
-                keep_idxes = nms(cls_boxes_sc, cls_confs_sc, self.nms_thresh)
+                keep_idxes = nms(boxes_sc, confs_sc, self.nms_thresh)
                 keep_idxes = keep_idxes.long().view(-1)
-                cls_boxes_sc = cls_boxes_sc[keep_idxes]
-                cls_confs_sc = cls_confs_sc[keep_idxes].unsqueeze(dim=1)
+                boxes_sc = boxes_sc[keep_idxes]
+                confs_sc = confs_sc[keep_idxes].unsqueeze(dim=1)
 
-            labels_css = torch.zeros(cls_confs_sc.shape).float().cuda()
+            labels_css = torch.zeros(confs_sc.shape).float().cuda()
             labels_css += c
 
-            cls_boxes_sl.append(cls_boxes_sc)
-            cls_confs_sl.append(cls_confs_sc)
-            cls_labels_sl.append(labels_css)
-        # exit()
+            boxes_sl.append(boxes_sc)
+            confs_sl.append(confs_sc)
+            labels_sl.append(labels_css)
 
-        if len(cls_boxes_sl) > 0:
-            boxes_s = torch.cat(cls_boxes_sl, dim=0)
-            confs_s = torch.cat(cls_confs_sl, dim=0)
-            labels_s = torch.cat(cls_labels_sl, dim=0)
+        if len(boxes_sl) > 0:
+            boxes_s = torch.cat(boxes_sl, dim=0)
+            confs_s = torch.cat(confs_sl, dim=0)
+            labels_s = torch.cat(labels_sl, dim=0)
         else:
             boxes_s = torch.zeros((1, 4)).float().cuda()
             confs_s = torch.zeros((1, 1)).float().cuda()
             labels_s = torch.zeros((1, 1)).float().cuda()
-
-        boxes_s, confs_s, labels_s = lib_util.sort_boxes_s(boxes_s, confs_s, labels_s)
         return boxes_s, confs_s, labels_s
 
     def forward(self, mu, prob, pi):
-        # print('mu', torch.min(mu), torch.max(mu))
         boxes = mu.transpose(1, 2).clone()
         boxes[:, :, [0, 2]] = boxes[:, :, [0, 2]] * (self.input_size[1] / self.coord_range[1])
         boxes[:, :, [1, 3]] = boxes[:, :, [1, 3]] * (self.input_size[0] / self.coord_range[0])
@@ -85,7 +76,7 @@ def forward(self, mu, prob, pi):
         boxes_l, confs_l, labels_l = list(), list(), list()
         for i, (boxes_s, confs_s) in enumerate(zip(boxes, confs)):
             boxes_s, confs_s, labels_s = self.__filter_cls_boxes_s__(boxes_s, confs_s, pi[i, 0])
-            boxes_l.append(boxes_s[:self.max_boxes])
-            confs_l.append(confs_s[:self.max_boxes])
-            labels_l.append(labels_s[:self.max_boxes] + 1)
+            boxes_l.append(boxes_s)
+            confs_l.append(confs_s)
+            labels_l.append(labels_s + 1)
         return boxes_l, confs_l, labels_l