Add files via upload

Author: HuiZeng

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Hui Zeng
+Copyright (c) 2017 Max deGroot, Ellis Brown
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

ShuffleNetV2.py

@@ -0,0 +1,174 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.autograd import Variable
+from collections import OrderedDict
+from torch.nn import init
+import math
+
+def conv_bn(inp, oup, stride):
+    return nn.Sequential(
+        nn.Conv2d(inp, oup, 3, stride, 1, bias=False),
+        nn.BatchNorm2d(oup),
+        nn.ReLU(inplace=True)
+    )
+
+
+def conv_1x1_bn(inp, oup):
+    return nn.Sequential(
+        nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
+        nn.BatchNorm2d(oup),
+        nn.ReLU(inplace=True)
+    )
+
+def channel_shuffle(x, groups):
+    batchsize, num_channels, height, width = x.data.size()
+
+    channels_per_group = num_channels // groups
+    
+    # reshape
+    x = x.view(batchsize, groups, 
+        channels_per_group, height, width)
+
+    x = torch.transpose(x, 1, 2).contiguous()
+
+    # flatten
+    x = x.view(batchsize, -1, height, width)
+
+    return x
+    
+class InvertedResidual(nn.Module):
+    def __init__(self, inp, oup, stride, benchmodel):
+        super(InvertedResidual, self).__init__()
+        self.benchmodel = benchmodel
+        self.stride = stride
+        assert stride in [1, 2]
+
+        oup_inc = oup//2
+        
+        if self.benchmodel == 1:
+            #assert inp == oup_inc
+        	self.banch2 = nn.Sequential(
+                # pw
+                nn.Conv2d(oup_inc, oup_inc, 1, 1, 0, bias=False),
+                nn.BatchNorm2d(oup_inc),
+                nn.ReLU(inplace=True),
+                # dw
+                nn.Conv2d(oup_inc, oup_inc, 3, stride, 1, groups=oup_inc, bias=False),
+                nn.BatchNorm2d(oup_inc),
+                # pw-linear
+                nn.Conv2d(oup_inc, oup_inc, 1, 1, 0, bias=False),
+                nn.BatchNorm2d(oup_inc),
+                nn.ReLU(inplace=True),
+            )                
+        else:                  
+            self.banch1 = nn.Sequential(
+                # dw
+                nn.Conv2d(inp, inp, 3, stride, 1, groups=inp, bias=False),
+                nn.BatchNorm2d(inp),
+                # pw-linear
+                nn.Conv2d(inp, oup_inc, 1, 1, 0, bias=False),
+                nn.BatchNorm2d(oup_inc),
+                nn.ReLU(inplace=True),
+            )        
+    
+            self.banch2 = nn.Sequential(
+                # pw
+                nn.Conv2d(inp, oup_inc, 1, 1, 0, bias=False),
+                nn.BatchNorm2d(oup_inc),
+                nn.ReLU(inplace=True),
+                # dw
+                nn.Conv2d(oup_inc, oup_inc, 3, stride, 1, groups=oup_inc, bias=False),
+                nn.BatchNorm2d(oup_inc),
+                # pw-linear
+                nn.Conv2d(oup_inc, oup_inc, 1, 1, 0, bias=False),
+                nn.BatchNorm2d(oup_inc),
+                nn.ReLU(inplace=True),
+            )
+          
+    @staticmethod
+    def _concat(x, out):
+        # concatenate along channel axis
+        return torch.cat((x, out), 1)        
+
+    def forward(self, x):
+        if 1==self.benchmodel:
+            x1 = x[:, :(x.shape[1]//2), :, :]
+            x2 = x[:, (x.shape[1]//2):, :, :]
+            out = self._concat(x1, self.banch2(x2))
+        elif 2==self.benchmodel:
+            out = self._concat(self.banch1(x), self.banch2(x))
+
+        return channel_shuffle(out, 2)
+
+
+class ShuffleNetV2(nn.Module):
+    def __init__(self, n_class=1000, input_size=224, width_mult=1.):
+        super(ShuffleNetV2, self).__init__()
+        
+        assert input_size % 32 == 0
+        
+        self.stage_repeats = [4, 8, 4]
+        # index 0 is invalid and should never be called.
+        # only used for indexing convenience.
+        if width_mult == 0.5:
+            self.stage_out_channels = [-1, 24,  48,  96, 192, 1024]
+        elif width_mult == 1.0:
+            self.stage_out_channels = [-1, 24, 116, 232, 464, 1024]
+        elif width_mult == 1.5:
+            self.stage_out_channels = [-1, 24, 176, 352, 704, 1024]
+        elif width_mult == 2.0:
+            self.stage_out_channels = [-1, 24, 224, 488, 976, 2048]
+        else:
+            raise ValueError(
+                """{} groups is not supported for
+                       1x1 Grouped Convolutions""".format(num_groups))
+
+        # building first layer
+        input_channel = self.stage_out_channels[1]
+        self.conv1 = conv_bn(3, input_channel, 2)    
+	self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        
+        self.features = []
+        # building inverted residual blocks
+        for idxstage in range(len(self.stage_repeats)):
+            numrepeat = self.stage_repeats[idxstage]
+            output_channel = self.stage_out_channels[idxstage+2]
+            for i in range(numrepeat):
+                if i == 0:
+	            #inp, oup, stride, benchmodel):
+                    self.features.append(InvertedResidual(input_channel, output_channel, 2, 2))
+                else:
+                    self.features.append(InvertedResidual(input_channel, output_channel, 1, 1))
+                input_channel = output_channel
+                
+                
+        # make it nn.Sequential
+        self.features = nn.Sequential(*self.features)
+
+        # building last several layers
+        self.conv_last      = conv_1x1_bn(input_channel, self.stage_out_channels[-1])
+	self.globalpool = nn.Sequential(nn.AvgPool2d(int(input_size/32)))              
+    
+	# building classifier
+	self.classifier = nn.Sequential(nn.Linear(self.stage_out_channels[-1], n_class))
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.maxpool(x)
+        x = self.features(x)
+        x = self.conv_last(x)
+        x = self.globalpool(x)
+        x = x.view(-1, self.stage_out_channels[-1])
+        x = self.classifier(x)
+        return x
+
+def shufflenetv2(width_mult=1.):
+    model = ShuffleNetV2(width_mult=width_mult)
+    return model
+    
+if __name__ == "__main__":
+    """Testing
+    """
+    model = ShuffleNetV2()
+    print(model)

TestAccuracy.py

@@ -0,0 +1,140 @@
+from croppingDataset import GAICD
+from croppingModel import build_crop_model
+import time
+import math
+import sys
+import torch
+from torch.autograd import Variable
+import torch.backends.cudnn as cudnn
+import torch.utils.data as data
+import argparse
+from scipy.stats import spearmanr, pearsonr
+
+parser = argparse.ArgumentParser(
+    description='Single Shot MultiBox Detector Training With Pytorch')
+parser.add_argument('--dataset_root', default='dataset/GAIC/', help='Dataset root directory path')
+parser.add_argument('--image_size', default=256, type=int, help='Batch size for training')
+parser.add_argument('--batch_size', default=1, type=int, help='Batch size for training')
+parser.add_argument('--num_workers', default=0, type=int, help='Number of workers used in dataloading')
+parser.add_argument('--cuda', default=True, help='Use CUDA to train model')
+parser.add_argument('--net_path', default='weights/ablation/cropping/mobilenetv2/downsample4_multi_Aug1_Align9_Cdim8/23_0.625_0.583_0.553_0.525_0.785_0.762_0.748_0.723_0.783_0.806.pth_____',
+                    help='Directory for saving checkpoint models')
+args = parser.parse_args()
+
+if torch.cuda.is_available():
+    if args.cuda:
+        torch.set_default_tensor_type('torch.cuda.FloatTensor')
+    if not args.cuda:
+        print("WARNING: It looks like you have a CUDA device, but aren't " +
+              "using CUDA.\nRun with --cuda for optimal training speed.")
+        torch.set_default_tensor_type('torch.FloatTensor')
+else:
+    torch.set_default_tensor_type('torch.FloatTensor')
+
+
+data_loader = data.DataLoader(GAICD(image_size=args.image_size, dataset_dir=args.dataset_root, set='test'), args.batch_size, num_workers=args.num_workers, shuffle=False)
+
+def test():
+
+    net = build_crop_model(scale='multi', alignsize=9, reddim=8, loadweight=True, model='mobilenetv2', downsample=4)
+
+    net.load_state_dict(torch.load(args.net_path))
+
+    if args.cuda:
+        net = torch.nn.DataParallel(net,device_ids=[0])
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+        net = net.cuda()
+
+    net.eval()
+
+    acc4_5 = []
+    acc4_10 = []
+    wacc4_5 = []
+    wacc4_10 = []
+    srcc = []
+    pcc = []
+    for n in range(4):
+        acc4_5.append(0)
+        acc4_10.append(0)
+        wacc4_5.append(0)
+        wacc4_10.append(0)
+
+    for id, sample in enumerate(data_loader):
+        image = sample['image']
+        bboxs = sample['bbox']
+        MOS = sample['MOS']
+
+        roi = []
+
+        for idx in range(0,len(bboxs['xmin'])):
+            roi.append((0, bboxs['xmin'][idx],bboxs['ymin'][idx],bboxs['xmax'][idx],bboxs['ymax'][idx]))
+
+        if args.cuda:
+            image = Variable(image.cuda())
+            roi = Variable(torch.Tensor(roi))
+        else:
+            image = Variable(image)
+            roi = Variable(torch.Tensor(roi))
+
+        t0 = time.time()
+        out = net(image,roi)
+        t1 = time.time()
+        print('timer: %.4f sec.' % (t1 - t0))
+
+        id_MOS = sorted(range(len(MOS)), key=lambda k: MOS[k], reverse=True)
+        id_out = sorted(range(len(out)), key=lambda k: out[k], reverse=True)
+
+        rank_of_returned_crop = []
+        for k in range(4):
+            rank_of_returned_crop.append(id_MOS.index(id_out[k]))
+
+        for k in range(4):
+            temp_acc_4_5 = 0.0
+            temp_acc_4_10 = 0.0
+            for j in range(k+1):
+                if MOS[id_out[j]] >= MOS[id_MOS[4]]:
+                    temp_acc_4_5 += 1.0
+                if MOS[id_out[j]] >= MOS[id_MOS[9]]:
+                    temp_acc_4_10 += 1.0
+            acc4_5[k] += temp_acc_4_5 / (k+1.0)
+            acc4_10[k] += temp_acc_4_10 / (k+1.0)
+
+        for k in range(4):
+            temp_wacc_4_5 = 0.0
+            temp_wacc_4_10 = 0.0
+            temp_rank_of_returned_crop = rank_of_returned_crop[:(k+1)]
+            temp_rank_of_returned_crop.sort()
+            for j in range(k+1):
+                if temp_rank_of_returned_crop[j] <= 4:
+                    temp_wacc_4_5 += 1.0 * math.exp(-0.2*(temp_rank_of_returned_crop[j]-j))
+                if temp_rank_of_returned_crop[j] <= 9:
+                    temp_wacc_4_10 += 1.0 * math.exp(-0.1*(temp_rank_of_returned_crop[j]-j))
+            wacc4_5[k] += temp_wacc_4_5 / (k+1.0)
+            wacc4_10[k] += temp_wacc_4_10 / (k+1.0)
+
+
+        MOS_arr = []
+        out = torch.squeeze(out).cpu().detach().numpy()
+        for k in range(len(MOS)):
+            MOS_arr.append(MOS[k].numpy()[0])
+        srcc.append(spearmanr(MOS_arr,out)[0])
+        pcc.append(pearsonr(MOS_arr,out)[0])
+
+
+    for k in range(4):
+        acc4_5[k] = acc4_5[k] / 200.0
+        acc4_10[k] = acc4_10[k] / 200.0
+        wacc4_5[k] = wacc4_5[k] / 200.0
+        wacc4_10[k] = wacc4_10[k] / 200.0
+
+    avg_srcc = sum(srcc) / 200.0
+    avg_pcc = sum(pcc) / 200.0
+
+    sys.stdout.write('[%.3f, %.3f, %.3f, %.3f] [%.3f, %.3f, %.3f, %.3f]\n' % (acc4_5[0],acc4_5[1],acc4_5[2],acc4_5[3],acc4_10[0],acc4_10[1],acc4_10[2],acc4_10[3]))
+    sys.stdout.write('[%.3f, %.3f, %.3f, %.3f] [%.3f, %.3f, %.3f, %.3f]\n' % (wacc4_5[0],wacc4_5[1],wacc4_5[2],wacc4_5[3],wacc4_10[0],wacc4_10[1],wacc4_10[2],wacc4_10[3]))
+    sys.stdout.write('[Avg SRCC: %.3f] [Avg PCC: %.3f]\n' % (avg_srcc,avg_pcc))
+
+
+if __name__ == '__main__':
+    test()