Pytorch Convolution neural network for semantic segmentation

Author: robail

1_VGG16/1_VGG_16_model_details.txt

@@ -0,0 +1,48 @@
+----------------------------------------------------------------
+        Layer (type)               Output Shape         Param #
+================================================================
+            Conv2d-1         [-1, 64, 224, 224]           1,792
+              ReLU-2         [-1, 64, 224, 224]               0
+            Conv2d-3         [-1, 64, 224, 224]          36,928
+              ReLU-4         [-1, 64, 224, 224]               0
+         MaxPool2d-5         [-1, 64, 112, 112]               0
+            Conv2d-6        [-1, 128, 112, 112]          73,856
+              ReLU-7        [-1, 128, 112, 112]               0
+            Conv2d-8        [-1, 128, 112, 112]         147,584
+              ReLU-9        [-1, 128, 112, 112]               0
+        MaxPool2d-10          [-1, 128, 56, 56]               0
+           Conv2d-11          [-1, 256, 56, 56]         295,168
+             ReLU-12          [-1, 256, 56, 56]               0
+           Conv2d-13          [-1, 256, 56, 56]         590,080
+             ReLU-14          [-1, 256, 56, 56]               0
+           Conv2d-15          [-1, 256, 56, 56]         590,080
+             ReLU-16          [-1, 256, 56, 56]               0
+        MaxPool2d-17          [-1, 256, 28, 28]               0
+           Conv2d-18          [-1, 512, 28, 28]       1,180,160
+             ReLU-19          [-1, 512, 28, 28]               0
+           Conv2d-20          [-1, 512, 28, 28]       2,359,808
+             ReLU-21          [-1, 512, 28, 28]               0
+           Conv2d-22          [-1, 512, 28, 28]       2,359,808
+             ReLU-23          [-1, 512, 28, 28]               0
+        MaxPool2d-24          [-1, 512, 14, 14]               0
+           Conv2d-25          [-1, 512, 14, 14]       2,359,808
+             ReLU-26          [-1, 512, 14, 14]               0
+           Conv2d-27          [-1, 512, 14, 14]       2,359,808
+             ReLU-28          [-1, 512, 14, 14]               0
+           Conv2d-29          [-1, 512, 14, 14]       2,359,808
+             ReLU-30          [-1, 512, 14, 14]               0
+        MaxPool2d-31            [-1, 512, 7, 7]               0
+           Linear-32                 [-1, 4096]     102,764,544
+             ReLU-33                 [-1, 4096]               0
+          Dropout-34                 [-1, 4096]               0
+           Linear-35                 [-1, 4096]      16,781,312
+             ReLU-36                 [-1, 4096]               0
+          Dropout-37                 [-1, 4096]               0
+           Linear-38                 [-1, 1000]       4,097,000
+
+================================================================
+Total params: 138,357,544
+Trainable params: 138,357,544
+Non-trainable params: 0
+----------------------------------------------------------------
+

1_VGG16/__pycache__/model.cpython-36.pyc

@@ -0,0 +1,130 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.autograd import Variable
+from torchvision import models
+import argparse
+import numpy as np
+import torchvision.datasets as datasets
+import torchvision.transforms as transforms
+import os
+import sys
+import csv
+import shutil
+import time
+import model
+import torch.nn.functional as F
+import matplotlib.pyplot as plt
+from IPython import embed
+from torchsummary_1 import summary as modelsummary
+#import torchsummary as modelsummary
+
+#------ START added by Adeel ------
+final_model_path = 'final_trained_model/200_epoch_squeezenet.pth'
+best_prec1 = 0
+start_epoch = 1
+checkpoint_path = 'train_checkpoint/checkpoint.pth.tar'
+#------ END added by Adeel ------ 
+
+parser = argparse.ArgumentParser('Options for training SqueezeNet in pytorch')
+parser.add_argument('--batch-size', type=int, default=200, metavar='N', help='batch size of train')
+parser.add_argument('--epoch', type=int, default=500, metavar='N', help='number of epochs to train for')
+parser.add_argument('--learning-rate', type=float, default=0.00001, metavar='LR', help='learning rate')
+parser.add_argument('--momentum', type=float, default=0.9, metavar='M', help='percentage of past parameters to store')
+parser.add_argument('--no-cuda', action='store_true', default=False, help='use cuda for training')
+parser.add_argument('--log-schedule', type=int, default=1, metavar='N', help='number of epochs to save snapshot after')
+parser.add_argument('--seed', type=int, default=10, help='set seed to some constant value to reproduce experiments')
+parser.add_argument('--model_name', type=str, default=None, help='Use a pretrained model')
+parser.add_argument('--want_to_test', type=bool, default=False, help='make true if you just want to test')
+parser.add_argument('--epoch_55', action='store_true', help='would you like to use 55 epoch learning rule')
+parser.add_argument('--num_classes', type=int, default=10, help="how many classes training for")
+#------ START added by Adeel ------
+parser.add_argument('--resume', default=checkpoint_path, type=str, metavar='PATH', help='path to latest checkpoint (default: none)')
+#------ END added by Adeel ------
+
+
+#print(torch.cuda.get_device_name(0))
+
+args = parser.parse_args()
+args.cuda = not args.no_cuda and torch.cuda.is_available()
+
+torch.manual_seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+    torch.cuda.set_device(0)
+
+
+# get the model and convert it into cuda for if necessary
+#net  = model.SqueezeNet()
+    
+net  = models.vgg16(pretrained = True)
+torch.cuda.empty_cache()
+print(torch.cuda.memory_allocated(device=None))
+
+if args.model_name is not None:
+    print("loading pre trained weights")
+    pretrained_weights = torch.load(args.model_name)
+    net.load_state_dict(pretrained_weights)
+
+if args.cuda:
+    print("GPU Working...\n")
+    net.cuda()    
+
+#------ Check Network parameters Size ----------------
+#
+#modelsummary(net.cuda(), input_size=(3, 32, 32))
+#
+#------ Check Network parameters Size ----------------    
+
+
+#print(net)
+
+avg_loss = list()
+best_accuracy = 0.0
+fig1, ax1 = plt.subplots()
+
+
+# create a temporary optimizer
+optimizer = optim.SGD(net.parameters(), lr=args.learning_rate, momentum=0.9, weight_decay=5e-4)
+
+def adjustlrwd(params):
+    for param_group in optimizer.state_dict()['param_groups']:
+        param_group['lr'] = params['learning_rate']
+        param_group['weight_decay'] = params['weight_decay']
+
+#------ END added by Adeel ------
+
+#==============================================================================================
+class AverageMeter(object):
+    """Computes and stores the average and current value"""
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.val = 0
+        self.avg = 0
+        self.sum = 0
+        self.count = 0
+
+    def update(self, val, n=1):
+        self.val = val
+        self.sum += val * n
+        self.count += n
+        self.avg = self.sum / self.count
+
+#==============================================================================================
+
+#====================================Main Method===============================================
+if __name__ == '__main__':
+    
+    epoch_time = AverageMeter()
+#    #------ Print and Save Network parameters ----------------
+#    modelsummary.summary(net.cuda(), input_size=(3, 32, 32))
+    
+#    #---- Using Customized Model Summary Class ----------    
+    modelsummary(net.cuda(), input_size=(3, 1024, 1024))
+#    #---- Using Customized Model Summary Class ----------
+#    #------ Print and Save Network parameters ----------------
+    
+#====================================Main Method===============================================        
+#==============================================================================================

1_VGG16/__pycache__/torchsummary_1.cpython-36.pyc

@@ -0,0 +1,164 @@
+import torch
+import torch.nn as nn
+from torch.autograd import Variable
+import torch.functional as F
+import numpy as np
+import torch.optim as optim
+import math
+import sys
+
+class fire(nn.Module):
+    def __init__(self, inplanes, squeeze_planes, expand_planes):
+        super(fire, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, squeeze_planes, kernel_size=1, stride=1)
+        self.bn1 = nn.BatchNorm2d(squeeze_planes)
+        self.relu1 = nn.ReLU(inplace=True)
+        self.conv2 = nn.Conv2d(squeeze_planes, expand_planes, kernel_size=1, stride=1)
+        self.bn2 = nn.BatchNorm2d(expand_planes)
+        self.conv3 = nn.Conv2d(squeeze_planes, expand_planes, kernel_size=3, stride=1, padding=1)
+        self.bn3 = nn.BatchNorm2d(expand_planes)
+        self.relu2 = nn.ReLU()
+
+        # using MSR initilization
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.in_channels
+                m.weight.data.normal_(0, math.sqrt(2./n))
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu1(x)
+        out1 = self.conv2(x)
+        out1 = self.bn2(out1)
+        out2 = self.conv3(x)
+        out2 = self.bn3(out2)
+        out = torch.cat([out1, out2], 1)
+        out = self.relu2(out)
+        return out
+    
+class additional_layer(nn.Module):
+    def __init__(self, add_input_channels, add_output_channels):
+        super(additional_layer, self).__init__()
+        self.conv1 = nn.Conv2d(add_input_channels, add_output_channels, kernel_size=3, stride=1,padding=1)
+        self.bn1 = nn.BatchNorm2d(add_output_channels)
+        self.relu1 = nn.ReLU(inplace=True)
+
+        # using MSR initilization
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.in_channels
+                m.weight.data.normal_(0, math.sqrt(2./n))
+
+    def forward(self, x):
+        out_add = self.conv1(x)
+        out_add = self.bn1(x)
+        out_add = self.relu1(x)
+        return out_add  
+    
+    
+class conv_layer(nn.Module):
+    def __init__(self, add_input_channels, add_output_channels,kernel_size,stride,padding):
+        super(conv_layer, self).__init__()
+        self.conv1 = nn.Conv2d(add_input_channels, add_output_channels, kernel_size, stride,padding)
+        self.bn1 = nn.BatchNorm2d(add_output_channels)
+        self.relu1 = nn.ReLU(inplace=True)
+
+        # using MSR initilization
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.in_channels
+                m.weight.data.normal_(0, math.sqrt(2./n))
+
+    def forward(self, x):
+        out_add = self.conv1(x)
+        out_add = self.bn1(out_add)
+        out_add = self.relu1(out_add)
+        return out_add      
+
+
+class SqueezeNet(nn.Module):
+    def __init__(self):
+        super(SqueezeNet, self).__init__()
+        self.conv1      = nn.Conv2d(3, 96, kernel_size=3, stride=1, padding=1) # 32
+        self.bn1        = nn.BatchNorm2d(96)
+        self.relu       = nn.ReLU()
+        self.maxpool1   = nn.MaxPool2d(kernel_size=2, stride=2) # 16
+        self.conv3x3_add_link_1 = conv_layer(96,96,kernel_size=3, stride=2, padding=1)
+        self.fire2      = fire(96, 16, 64)
+        self.dropout_1  = nn.Dropout2d(p=0.5,inplace=False)
+        self.fire3      = fire(128, 16, 64)
+        self.fire4      = fire(128, 32, 128)
+        self.maxpool2   = nn.MaxPool2d(kernel_size=2, stride=2) # 8
+#        self.conv3x3_add_link_2 = conv_layer(256,256,kernel_size=3, stride=2, padding=1)
+        self.conv1x1_concat_1 = conv_layer(352,256,kernel_size=1, stride=1, padding=0)
+        self.fire5      = fire(256, 32, 128)
+        self.fire6      = fire(256, 48, 192)
+        self.fire7      = fire(384, 48, 192)
+        self.dropout_2  = nn.Dropout2d(p=0.5,inplace=False)
+        self.fire8      = fire(384, 64, 256)
+        self.maxpool3   = nn.MaxPool2d(kernel_size=2, stride=2) # 4
+#        self.conv1x1_concat_2 = conv_layer(768,512,kernel_size=1, stride=1, padding=0)
+        self.fire9      = fire(512, 64, 256)
+        self.conv2      = nn.Conv2d(512, 10, kernel_size=1, stride=1)
+        self.avg_pool   = nn.AvgPool2d(kernel_size=4, stride=4)
+        self.softmax    = nn.LogSoftmax(dim=1)
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.in_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+
+    def forward(self, x):
+#        print("Initital Value:",x.size())
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool1(x)
+        add_link_1 = x
+        conved_add_link_1 = self.conv3x3_add_link_1(add_link_1)
+#        print("add_link_1: ",add_link_1.size())
+#        print("add_link_convolved",conved_add_link_1.size())
+#        sys.exit()
+        x = self.fire2(x)
+        x = self.dropout_1(x)
+        x = self.fire3(x)
+        x = self.fire4(x)
+        x = self.maxpool2(x)
+        print("X output: ",x.size())
+#        add_link_2 = x
+#        conved_add_link_2 = self.conv3x3_add_link_2(add_link_2)
+        x = torch.cat([x,conved_add_link_1],1)
+        print("X concat output: ",x.size())
+        sys.exit();
+        x =  self.conv1x1_concat_1(x)
+        x = self.fire5(x)
+        x = self.fire6(x)
+        x = self.fire7(x)
+        x = self.dropout_2(x)
+        x = self.fire8(x)
+        x = self.maxpool3(x)
+#        x = torch.cat([x,conved_add_link_2],1)
+#        x = self.conv1x1_concat_2(x)
+        x = self.fire9(x)
+        x = self.conv2(x)
+        x = self.avg_pool(x)
+        x = self.softmax(x)
+        return x
+
+def fire_layer(inp, s, e):
+    f = fire(inp, s, e)
+    return f
+
+def squeezenet(pretrained=False):
+    net = SqueezeNet()
+    # inp = Variable(torch.randn(64,3,32,32))
+    # out = net.forward(inp)
+    # print(out.size())
+    return net
+
+# if __name__ == '__main__':
+#     squeezenet()