small fix

Author: zym1119

.idea/DeepLabv3_MobileNetv2.iml

@@ -3,47 +3,49 @@
 
 """ Dataset parameters """
 class Params():
-    # network structure parameters
-    model = 'MobileNetv2_DeepLabv3'
-    dataset = 'cityscapes'
-    s = [2, 1, 2, 2, 2, 1, 1]  # stride of each conv stage
-    t = [1, 1, 6, 6, 6, 6, 6]  # expansion factor t
-    n = [1, 1, 2, 3, 4, 3, 3]  # number of repeat time
-    c = [32, 16, 24, 32, 64, 96, 160]  # output channel of each conv stage
-    output_stride = 16
-    multi_grid = (1, 2, 4)
-    aspp = (6, 12, 18)
-    down_sample_rate = 32  # classic down sample rate
+    def __init__(self):
+        # network structure parameters
+        self.model = 'MobileNetv2_DeepLabv3'
+        self.dataset = 'cityscapes'
+        self.s = [2, 1, 2, 2, 2, 1, 1]  # stride of each conv stage
+        self.t = [1, 1, 6, 6, 6, 6, 6]  # expansion factor t
+        self.n = [1, 1, 2, 3, 4, 3, 3]  # number of repeat time
+        self.c = [32, 16, 24, 32, 64, 96, 160]  # output channel of each conv stage
+        self.output_stride = 16
+        self.multi_grid = (1, 2, 4)
+        self.aspp = (6, 12, 18)
+        self.down_sample_rate = 32  # classic down sample rate
 
-    # dataset parameters
-    image_size = 512
-    num_class = 20  # 20 classes for training
-    dataset_root = '/path/to/your/dataset'
-    dataloader_workers = 8
-    shuffle = True
-    train_batch = 5
-    val_batch = 2
-    test_batch = 5
+        # dataset parameters
+        self.rescale_size = 600
+        self.image_size = 512
+        self.num_class = 20  # 20 classes for training
+        self.dataset_root = '/path/to/your/dataset'
+        self.dataloader_workers = 8
+        self.shuffle = True
+        self.train_batch = 10
+        self.val_batch = 2
+        self.test_batch = 5
 
-    # train parameters
-    num_epoch = 50
-    base_lr = 0.001
-    power = 0.9
-    momentum = 0.9
-    dropout_prob = 0.2
-    weight_decay = 0.0005
-    should_val = True
-    val_every = 1
-    display = 1  # show train result every display epoch
+        # train parameters
+        self.num_epoch = 50
+        self.base_lr = 0.00025
+        self.power = 0.9
+        self.momentum = 0.9
+        self.weight_decay = 0.0005
+        self.should_val = True
+        self.val_every = 1
+        self.display = 1  # show train result every display epoch
 
-    # model restore parameters
-    resume_from = None  # None for train from scratch
-    pre_trained_from = None # None for train from scratch
-    should_save = True
-    save_every = 10
+        # model restore parameters
+        self.resume_from = None  # None for train from scratch
+        self.pre_trained_from = None  # None for train from scratch
+        self.should_save = True
+        self.save_every = 10
 
-    def __init__(self):
         # create training dir
         self.summary_dir, self.ckpt_dir = create_train_dir(self)
 
-# if __name__ == '__main__':
+if __name__ == '__main__':
+    aa = Params()
+    print(aa)

.idea/misc.xml

@@ -74,9 +74,9 @@ def get_inverted_residual_block_arr(in_, out_, t=6, s=1, n=1):
     return block
 
 
-class ASPP(nn.Module):
+class ASPP_plus(nn.Module):
     def __init__(self, params):
-        super(ASPP, self).__init__()
+        super(ASPP_plus, self).__init__()
         self.conv11 = nn.Sequential(nn.Conv2d(params.c[-1], 256, 1, bias=False),
                                      nn.BatchNorm2d(256))
         self.conv33_1 = nn.Sequential(nn.Conv2d(params.c[-1], 256, 3,

.idea/workspace.xml

@@ -1,28 +1,38 @@
-from __future__ import print_function
 import os
 import argparse
 from utils import create_dataset
 from network import MobileNetv2_DeepLabv3
 from config import Params
-
+from utils import print_config
 
 def main():
-    # parser = argparse.ArgumentParser(description='MobileNet_v2_DeepLab_v3 Pytorch Implementation')
-    # parser.add_argument('--dataset', default='cityscapes', choices=['cityscapes', 'other'],
-    #                     help='Dataset used in training MobileNet v2+DeepLab v3')
-    # parser.add_argument('--root', default='./data/cityscapes', help='Path to your dataset')
-    #
-    # args = parser.parse_args()
+    # add argumentation
+    parser = argparse.ArgumentParser(description='MobileNet_v2_DeepLab_v3 Pytorch Implementation')
+    parser.add_argument('--dataset', default='cityscapes', choices=['cityscapes', 'other'],
+                        help='Dataset used in training MobileNet v2+DeepLab v3')
+    parser.add_argument('--root', default='./data/cityscapes', help='Path to your dataset')
+    parser.add_argument('--epoch', default=50, help='Total number of training epoch')
+    parser.add_argument('--lr', default=0.00025, help='Base learning rate')
+    parser.add_argument('--pretrain', default=None, help='Path to a pre-trained backbone model')
+    parser.add_argument('--resume_from', default=None, help='Path to a checkpoint to resume model')
+
+    args = parser.parse_args()
+    params = Params()
 
     # parse args
-    # if not os.path.exists(args.root):
-    #     print('ERROR: Root %s not exists!' % args.root)
-    #     exit(1)
+    if not os.path.exists(args.root):
+        if params.dataset_root is None:
+            raise ValueError('ERROR: Root %s not exists!' % args.root)
+    else:
+        params.dataset_root = args.root
+    params.num_epoch = args.epoch
+    params.base_lr = args.lr
+    params.pre_trained_from = args.pretrain
+    params.resume_from = args.resume_from
+
+    print('Network parameters:')
+    print_config(params)
 
-    params = Params()
-    # params.dataset_root = args.root
-    params.dataset_root = '/media/ubuntu/disk/cityscapes'
-    """ TEST CODE """
     # create dataset and transformation
     print('Creating Dataset and Transformation......')
     datasets = create_dataset(params)

config.py

@@ -6,7 +6,6 @@
 from tensorboardX import SummaryWriter
 import layers
 from progressbar import bar
-from config import Params
 
 WARNING = lambda x: '\033[1;31;2mWARNING: ' + x + '\033[0m'
 
@@ -37,7 +36,7 @@ def __init__(self, params, datasets):
         # conv layer 1
         block.append(nn.Sequential(nn.Conv2d(3, self.params.c[0], 3, stride=self.params.s[0], padding=1, bias=False),
                                    nn.BatchNorm2d(self.params.c[0]),
-                                   nn.Dropout2d(self.params.dropout_prob, inplace=True),
+                                   # nn.Dropout2d(self.params.dropout_prob, inplace=True),
                                    nn.ReLU6()))
 
         # conv layer 2-7
@@ -53,7 +52,7 @@ def __init__(self, params, datasets):
                                                  t=self.params.t[6], s=1, dilation=rate*self.params.multi_grid[i]))
 
         # ASPP layer
-        block.append(layers.ASPP(self.params))
+        block.append(layers.ASPP_plus(self.params))
 
         # final conv layer
         block.append(nn.Conv2d(256, self.params.num_class, 1))
@@ -143,7 +142,7 @@ def val_one_epoch(self):
             m is defined in params.val_every
         """
         # TODO: add IoU compute function
-        print('Testing:')
+        print('Validating:')
 
         # set mode eval
         self.network.eval()
@@ -218,6 +217,8 @@ def Train(self):
         # save the last network state
         self.save_checkpoint()
 
+        # TODO: add train visualization
+
     def Test(self):
         """
         Test network on test set
@@ -249,7 +250,7 @@ def adjust_lr(self):
         """
         Adjust learning rate at each epoch
         """
-        learning_rate = self.params.base_lr * (1 - self.epoch / self.params.num_epoch) ** self.params.power
+        learning_rate = self.params.base_lr * (1 - float(self.epoch) / self.params.num_epoch) ** self.params.power
         for param_group in self.opt.param_groups:
             param_group['lr'] = learning_rate
         print('Change learning rate into %f' % (learning_rate))

layers.py

@@ -21,9 +21,9 @@ def click(self, current_idx, max_idx, total_length=40):
             self.iter_per_sec = 1/self.time
             perc = current_idx * total_length / max_idx
             # print progress bar
-            print '\r|'+'='*perc+'>'+' '*(total_length-1-perc)+'| %d/%d (%.2f iter/s)' % (current_idx+1,
+            print('\r|'+'='*perc+'>'+' '*(total_length-1-perc)+'| %d/%d (%.2f iter/s)' % (current_idx+1,
                                                                                           max_idx,
-                                                                                          self.iter_per_sec),
+                                                                                          self.iter_per_sec), end='')
             self.start_time = time.time()
 
     def close(self):

main.py

@@ -42,7 +42,8 @@ def create_dataset(params):
     # if params.dataset_root is not None and not os.path.exists(params.dataset_root):
     #     raise ValueError('Dataset not exists!')
 
-    transform = {'train': transforms.Compose([Rescale(params.image_size),
+    transform = {'train': transforms.Compose([Rescale(params.rescale_size),
+                                              RandomCrop(params.image_size),
                                               RandomHorizontalFlip(),
                                               ToTensor()
                                               ]),
@@ -194,6 +195,44 @@ def __call__(self, sample, p=0.5):
         return {'image': image, 'label': label}
 
 
+class RandomCrop(object):
+    """
+    Crop randomly the image in a sample.
+
+    :param output_size (tuple or int): Desired output size. If int, square crop
+            is made.
+    """
+
+    def __init__(self, output_size):
+        assert isinstance(output_size, (int, tuple))
+        if isinstance(output_size, int):
+            self.output_size = (output_size, output_size)
+        else:
+            assert len(output_size) == 2
+            self.output_size = output_size
+
+    def __call__(self, sample):
+        image, label = sample['image'], sample['label']
+
+        h, w = image.shape[:2]
+        new_h, new_w = self.output_size
+
+        top = np.random.randint(0, h - new_h)
+        left = np.random.randint(0, w - new_w)
+
+        image = image[top: top + new_h, left: left + new_w, :]
+
+        label = label[top: top + new_h, left: left + new_w]
+
+        return {'image': image, 'label': label}
+
+
+def print_config(params):
+    for name, value in sorted(vars(params).items()):
+        print('\t%-20s:%s' % (name, str(value)))
+    print('')
+
+
 if __name__ == '__main__':
     dir = '/media/ubuntu/disk/cityscapes'
     dataset = Cityscapes(dir)