share codes

Author: lwpyr

README.md

@@ -34,20 +34,13 @@ Prepare CityPersons dataset as the original codes doing
 
 
 
-Training
+Training & val
 
 ~~~
-python train.py
+python trainval_torchstyle.py
+python trainval_caffestyle.py
 ~~~
 
+NOTE
 
-
-Demo
-
-~~~
-python demo.py
-~~~
-
-## Todo
-
-the code only support 1 GPU training, you can use nn.DataParaller to modify the code for multi-GPUs training.
+using caffe style, you need to download additional pre-trained weight.

config.py

@@ -1,6 +1,6 @@
 class Config(object):
     def __init__(self):
-        self.gpu_ids = '0'
+        self.gpu_ids = [0, 1]
         self.onegpu = 2
         self.num_epochs = 150
         self.add_epoch = 0
@@ -25,6 +25,22 @@ def __init__(self):
         self.use_horizontal_flips = True
         self.brightness = (0.5, 2, 0.5)
         self.size_train = (336, 448)
+        self.size_test = (336, 338)
 
         # image channel-wise mean to subtract, the order is BGR
         self.img_channel_mean = [103.939, 116.779, 123.68]
+
+        # whether or not use caffe style training which is used in paper
+        self.caffemodel = False
+
+        # use teacher
+        self.teacher = True
+
+        self.test_path = './data/citypersons'
+
+        # whether or not to do validation during training
+        self.val = True
+        self.val_frequency = 10
+
+    def print_conf(self):
+        print '\n'.join(['%s:%s' % item for item in self.__dict__.items()])

data/citypersons

@@ -0,0 +1 @@
+../../../dataset/Citypersons/

dataloader/data_augment.py

@@ -0,0 +1,150 @@
+from __future__ import division
+import cv2
+import numpy as np
+import copy
+
+
+def _brightness(image, min=0.5, max=2.0):
+    '''
+    Randomly change the brightness of the input image.
+    Protected against overflow.
+    '''
+    hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+
+    random_br = np.random.uniform(min, max)
+
+    # To protect against overflow: Calculate a mask for all pixels
+    # where adjustment of the brightness would exceed the maximum
+    # brightness value and set the value to the maximum at those pixels.
+    mask = hsv[:, :, 2] * random_br > 255
+    v_channel = np.where(mask, 255, hsv[:, :, 2] * random_br)
+    hsv[:, :, 2] = v_channel
+
+    return cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB)
+
+
+def resize_image(image, gts, igs, scale=(0.4, 1.5)):
+    height, width = image.shape[0:2]
+    ratio = np.random.uniform(scale[0], scale[1])
+    # if len(gts)>0 and np.max(gts[:,3]-gts[:,1])>300:
+    #     ratio = np.random.uniform(scale[0], 1.0)
+    new_height, new_width = int(ratio * height), int(ratio * width)
+    image = cv2.resize(image, (new_width, new_height))
+    if len(gts) > 0:
+        gts = np.asarray(gts, dtype=float)
+        gts[:, 0:4:2] *= ratio
+        gts[:, 1:4:2] *= ratio
+
+    if len(igs) > 0:
+        igs = np.asarray(igs, dtype=float)
+        igs[:, 0:4:2] *= ratio
+        igs[:, 1:4:2] *= ratio
+
+    return image, gts, igs
+
+
+def random_crop(image, gts, igs, crop_size, limit=8):
+    img_height, img_width = image.shape[0:2]
+    crop_h, crop_w = crop_size
+
+    if len(gts) > 0:
+        sel_id = np.random.randint(0, len(gts))
+        sel_center_x = int((gts[sel_id, 0] + gts[sel_id, 2]) / 2.0)
+        sel_center_y = int((gts[sel_id, 1] + gts[sel_id, 3]) / 2.0)
+    else:
+        sel_center_x = int(np.random.randint(0, img_width - crop_w + 1) + crop_w * 0.5)
+        sel_center_y = int(np.random.randint(0, img_height - crop_h + 1) + crop_h * 0.5)
+
+    crop_x1 = max(sel_center_x - int(crop_w * 0.5), int(0))
+    crop_y1 = max(sel_center_y - int(crop_h * 0.5), int(0))
+    diff_x = max(crop_x1 + crop_w - img_width, int(0))
+    crop_x1 -= diff_x
+    diff_y = max(crop_y1 + crop_h - img_height, int(0))
+    crop_y1 -= diff_y
+    cropped_image = np.copy(image[crop_y1:crop_y1 + crop_h, crop_x1:crop_x1 + crop_w])
+    # crop detections
+    if len(igs) > 0:
+        igs[:, 0:4:2] -= crop_x1
+        igs[:, 1:4:2] -= crop_y1
+        igs[:, 0:4:2] = np.clip(igs[:, 0:4:2], 0, crop_w)
+        igs[:, 1:4:2] = np.clip(igs[:, 1:4:2], 0, crop_h)
+        keep_inds = ((igs[:, 2] - igs[:, 0]) >= 8) & \
+                    ((igs[:, 3] - igs[:, 1]) >= 8)
+        igs = igs[keep_inds]
+    if len(gts) > 0:
+        ori_gts = np.copy(gts)
+        gts[:, 0:4:2] -= crop_x1
+        gts[:, 1:4:2] -= crop_y1
+        gts[:, 0:4:2] = np.clip(gts[:, 0:4:2], 0, crop_w)
+        gts[:, 1:4:2] = np.clip(gts[:, 1:4:2], 0, crop_h)
+
+        before_area = (ori_gts[:, 2] - ori_gts[:, 0]) * (ori_gts[:, 3] - ori_gts[:, 1])
+        after_area = (gts[:, 2] - gts[:, 0]) * (gts[:, 3] - gts[:, 1])
+
+        keep_inds = ((gts[:, 2] - gts[:, 0]) >= limit) & \
+                    (after_area >= 0.5 * before_area)
+        gts = gts[keep_inds]
+
+    return cropped_image, gts, igs
+
+
+def random_pave(image, gts, igs, pave_size, limit=8):
+    img_height, img_width = image.shape[0:2]
+    pave_h, pave_w = pave_size
+    # paved_image = np.zeros((pave_h, pave_w, 3), dtype=image.dtype)
+    paved_image = np.ones((pave_h, pave_w, 3), dtype=image.dtype) * np.mean(image, dtype=int)
+    pave_x = int(np.random.randint(0, pave_w - img_width + 1))
+    pave_y = int(np.random.randint(0, pave_h - img_height + 1))
+    paved_image[pave_y:pave_y + img_height, pave_x:pave_x + img_width] = image
+    # pave detections
+    if len(igs) > 0:
+        igs[:, 0:4:2] += pave_x
+        igs[:, 1:4:2] += pave_y
+        keep_inds = ((igs[:, 2] - igs[:, 0]) >= 8) & \
+                    ((igs[:, 3] - igs[:, 1]) >= 8)
+        igs = igs[keep_inds]
+
+    if len(gts) > 0:
+        gts[:, 0:4:2] += pave_x
+        gts[:, 1:4:2] += pave_y
+        keep_inds = ((gts[:, 2] - gts[:, 0]) >= limit)
+        gts = gts[keep_inds]
+
+    return paved_image, gts, igs
+
+
+def augment(img_data, c, img):
+    assert 'filepath' in img_data
+    assert 'bboxes' in img_data
+    img_data_aug = copy.deepcopy(img_data)
+    if img is None:
+        img = cv2.imread(img_data_aug['filepath'])
+    img_height, img_width = img.shape[:2]
+
+    # random brightness
+    if c.brightness and np.random.randint(0, 2) == 0:
+        img = _brightness(img, min=c.brightness[0], max=c.brightness[1])
+    # random horizontal flip
+    if c.use_horizontal_flips and np.random.randint(0, 2) == 0:
+        img = cv2.flip(img, 1)
+        if len(img_data_aug['bboxes']) > 0:
+            img_data_aug['bboxes'][:, [0, 2]] = img_width - img_data_aug['bboxes'][:, [2, 0]]
+        if len(img_data_aug['ignoreareas']) > 0:
+            img_data_aug['ignoreareas'][:, [0, 2]] = img_width - img_data_aug['ignoreareas'][:, [2, 0]]
+
+    gts = np.copy(img_data_aug['bboxes'])
+    igs = np.copy(img_data_aug['ignoreareas'])
+
+    img, gts, igs = resize_image(img, gts, igs, scale=(0.4, 1.5))
+    if img.shape[0] >= c.size_train[0]:
+        img, gts, igs = random_crop(img, gts, igs, c.size_train, limit=16)
+    else:
+        img, gts, igs = random_pave(img, gts, igs, c.size_train, limit=16)
+
+    img_data_aug['bboxes'] = gts
+    img_data_aug['ignoreareas'] = igs
+
+    img_data_aug['width'] = c.size_train[1]
+    img_data_aug['height'] = c.size_train[0]
+
+    return img_data_aug, img