Exemplo n.º 1
0
    def __init__(self):
        super(FaceBox, self).__init__()

        #model
        self.conv1 = nn.Conv2d(3, 24, kernel_size=7, stride=4, padding=3)
        self.conv1 = init_model(self.conv1)
        self.bn1 = nn.BatchNorm2d(24)
        self.bn1 = init_model(self.bn1)
        self.conv2 = nn.Conv2d(48, 64, kernel_size=5, stride=2, padding=2)
        self.conv2 = init_model(self.conv2)
        self.bn2 = nn.BatchNorm2d(64)
        self.bn2 = init_model(self.bn2)

        self.inception1 = Inception()
        self.inception2 = Inception()
        self.inception3 = Inception()

        self.conv3_1 = conv_bn_relu(128, 128, kernel_size=1)
        self.conv3_2 = conv_bn_relu(128,
                                    256,
                                    kernel_size=3,
                                    stride=2,
                                    padding=1)
        self.conv4_1 = conv_bn_relu(256, 128, kernel_size=1)
        self.conv4_2 = conv_bn_relu(128,
                                    256,
                                    kernel_size=3,
                                    stride=2,
                                    padding=1)

        self.multilbox = MultiBoxLayer()
Exemplo n.º 2
0
    def __init__(self):
        super(SSD300, self).__init__()

        # model
        self.base = self.VGG16()
        self.norm4 = L2Norm2d(512,20)

        self.conv5_1 = nn.Conv2d(512, 512, kernel_size=3, padding=1, dilation=1)
        self.conv5_2 = nn.Conv2d(512, 512, kernel_size=3, padding=1, dilation=1)
        self.conv5_3 = nn.Conv2d(512, 512, kernel_size=3, padding=1, dilation=1)

        self.conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6)

        self.conv7 = nn.Conv2d(1024, 1024, kernel_size=1)

        self.conv8_1 = nn.Conv2d(1024, 256, kernel_size=1)
        self.conv8_2 = nn.Conv2d(256, 512, kernel_size=3, padding=1, stride=2)

        self.conv9_1 = nn.Conv2d(512, 128, kernel_size=1)
        self.conv9_2 = nn.Conv2d(128, 256, kernel_size=3, padding=1, stride=2)

        self.conv10_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv10_2 = nn.Conv2d(128, 256, kernel_size=3)

        self.conv11_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv11_2 = nn.Conv2d(128, 256, kernel_size=3)

        # multibox layer
        self.multibox = MultiBoxLayer()
    def __init__(self):
        super(MDSSD300, self).__init__()

        # Attention
        self.attn1 = AttentionBlock(3)

        # model
        self.base = self.VGG16()
        self.norm4 = L2Norm(512, 20)  # 38

        self.conv5_1 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)
        self.conv5_2 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)
        self.conv5_3 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)
        self.bn5 = nn.BatchNorm2d(512)

        self.conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6)
        self.bn6 = nn.BatchNorm2d(1024)

        self.conv7 = nn.Conv2d(1024, 1024, kernel_size=1)
        self.bn7 = nn.BatchNorm2d(1024)
        # self.attn2 = AttentionBlock(1024)

        self.conv8_1 = nn.Conv2d(1024, 256, kernel_size=1)
        self.conv8_2 = nn.Conv2d(256, 512, kernel_size=3, padding=1, stride=2)
        self.bn8 = nn.BatchNorm2d(512)

        self.conv9_1 = nn.Conv2d(512, 128, kernel_size=1)
        self.conv9_2 = nn.Conv2d(128, 256, kernel_size=3, padding=1, stride=2)
        self.bn9 = nn.BatchNorm2d(256)

        self.conv10_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv10_2 = nn.Conv2d(128, 256, kernel_size=3)

        self.conv11_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv11_2 = nn.Conv2d(128, 256, kernel_size=3)

        self.Fusion1 = FusionBlock(256, 512)
        self.Fusion2 = FusionBlock(512, 256)
        self.Fusion3 = FusionBlock(1024, 256)

        # multibox layer
        self.multibox = MultiBoxLayer()
Exemplo n.º 4
0
    def __init__(self):
        super(SSD300, self).__init__()

        # model
        self.base = self.VGG16()
        
         
        self.conv4_1 = nn.Conv2d(256, 512, kernel_size=3, padding=1, dilation=1) 
        self.conv4_2 = nn.Conv2d(512, 512, kernel_size=3, padding=1, dilation=1)
        self.conv4_3 = nn.Conv2d(512, 512, kernel_size=3, padding=1, dilation=1) 

# In simple terms, dilated convolution is just a convolution applied to input with defined gaps. 
# With this definitions, given our input is an 2D image, dilation rate k=1 is normal convolution and k=2 means skipping one pixel per input and k=4 means skipping 3 pixels. 
        
        self.norm4 = L2Norm2d(20)
        
        # Before Detection Module
        self.conv4_3_1 = nn.Conv2d(512, 128, kernel_size=1, padding=1, dilation=1)
        self.conv4_3_2 = nn.Conv2d(128, 128, kernel_size=3, padding=1, dilation=1)
        
        # Detection Module
        self.conv4_3_3 = nn.Conv2d(128, 128, kernel_size=3, padding=1, dilation=1)
        self.conv4_3_3_1 = nn.Conv2d(512, 512, kernel_size=3, padding=1, dilation=1)
        # Context Module
        self.context1 = nn.Conv2d(128, 64, kernel_size=3, padding=1, dilation=1)
        self.context2 = nn.Conv2d(64, 64, kernel_size=3, padding=1, dilation=1)
        
        self.context1_1 = nn.Conv2d(512,256, kernel_size=3, padding=1, dilation=1)
        self.context2_1 = nn.Conv2d(256,256, kernel_size=3, padding=1, dilation=1)
        
        self.conv5_1 = nn.Conv2d(512, 512, kernel_size=3, padding=1, dilation=1)
        self.conv5_2 = nn.Conv2d(512, 512, kernel_size=3, padding=1, dilation=1)
        self.conv5_3 = nn.Conv2d(512, 512, kernel_size=3, padding=1, dilation=1)
        self.convd1 = nn.Conv2d(512, 128, kernel_size=1)
	
        self.conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=1, dilation=1)

        self.conv7 = nn.Conv2d(1024, 1024, kernel_size=1)

        self.conv8_1 = nn.Conv2d(1024, 256, kernel_size=1)
        self.conv8_2 = nn.Conv2d(256, 512, kernel_size=3, padding=1, stride=2)

        self.conv9_1 = nn.Conv2d(512, 128, kernel_size=1)
        self.conv9_2 = nn.Conv2d(128, 256, kernel_size=3, padding=1, stride=2)

        self.conv10_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv10_2 = nn.Conv2d(128, 256, kernel_size=3)

        self.conv11_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv11_2 = nn.Conv2d(128, 256, kernel_size=3)

        # multibox layer
        self.multibox = MultiBoxLayer()
Exemplo n.º 5
0
	def __init__(self, growthRate, reduction):
		super(DSOD, self).__init__()

		# stem
		self.conv1 = StemLayer(3, 64, stride=2)
		self.conv2 = StemLayer(64, 64, stride=1)
		self.conv3 = StemLayer(64, 128, stride=1)
		self.dense1 = self._make_dense(128, growthRate, 6)
		nChannels = 128+6*growthRate
		nOutChannels = int(math.floor(nChannels*reduction))
		self.trans1 = Transition(nChannels, nOutChannels)

		nChannels = nOutChannels
		self.dense2 = self._make_dense(nChannels, growthRate, 8)
		nChannels += 8*growthRate
		nOutChannels1 = int(math.floor(nChannels*reduction))
		self.trans_wo = Transition_w_o_pooling(nChannels, nOutChannels1)
		# self.trans2 = Transition(nChannels, nOutChannels)
		# self.First = self.trans_wo

		nChannels = nOutChannels1
		self.dense3 = self._make_dense(nChannels, growthRate, 8)
		nChannels += 8*growthRate
		nOutChannels = int(math.floor(nChannels*reduction))
		self.trans_wo1 = Transition_w_o_pooling(nChannels, nOutChannels)

		nChannels = nOutChannels
		self.dense4 = self._make_dense(nChannels, growthRate, 8)
		nChannels += 8*growthRate
		# nOutChannels = int(math.floor(nChannels*reduction))
		nOutChannels = 256
		self.trans_wo2 = Transition_w_o_pooling(nChannels, nOutChannels)

		nChannels = nOutChannels1
		nOutChannels = 256
		self.conv4 = SingleLayer(nChannels, nOutChannels, kernel_size=1, stride=1, padding=0)

		# self.second = torch.cat((self.First, self.conv4), 1)

		# addExtraLyers
		nChannels = nOutChannels*2
		self.third = SingleLayer2(nChannels, 256)
		nChannels = 256*2
		self.forth = SingleLayer2(nChannels, 128)
		nChannels = 128*2
		self.fifith = SingleLayer2(nChannels, 128)
		nChannels = 128*2
		# self.sixth = SingleLayer2(nChannels, 128)
		self.sixth = LastLayer(nChannels, 128)

		# multibox layer
		self.multibox = MultiBoxLayer()
    def __init__(self):
        super(MDSSD300, self).__init__()

        # model
        self.base = self.VGG16()
        self.norm4 = L2Norm(512, 20)  # 64

        self.conv5_1 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)
        self.conv5_2 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)
        self.conv5_3 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)

        self.conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6)

        self.conv7 = nn.Conv2d(1024, 1024, kernel_size=1)

        self.conv8_1 = nn.Conv2d(1024, 256, kernel_size=1)
        self.conv8_2 = nn.Conv2d(256, 512, kernel_size=3, padding=1,
                                 stride=2)  #16

        self.conv9_1 = nn.Conv2d(512, 128, kernel_size=1)
        self.conv9_2 = nn.Conv2d(128, 256, kernel_size=3, padding=1,
                                 stride=2)  #8

        self.conv10_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv10_2 = nn.Conv2d(128, 256, kernel_size=3, padding=1,
                                  stride=2)  #4

        self.conv11_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv11_2 = nn.Conv2d(128, 256, kernel_size=3, padding=1,
                                  stride=2)  #2

        self.conv12_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv12_2 = nn.Conv2d(128, 256, kernel_size=2)

        self.Fusion1 = FusionBlock(256, 512)
        self.Fusion2 = FusionBlock(512, 256)
        self.Fusion3 = FusionBlock(1024, 256)

        # multibox layer
        self.multibox = MultiBoxLayer()
Exemplo n.º 7
0
    def __init__(self):
        super(CFENet, self).__init__()

        # model
        self.base = self.VGG16()
        self.norm4 = L2Norm(512, 20)  # 38

        self.conv5_1 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)
        self.conv5_2 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)
        self.conv5_3 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)

        self.conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6)

        self.conv7 = nn.Conv2d(1024, 1024, kernel_size=1)

        self.conv8_1 = nn.Conv2d(1024, 256, kernel_size=1)
        self.conv8_2 = nn.Conv2d(256, 512, kernel_size=3, padding=1, stride=2)

        self.conv9_1 = nn.Conv2d(512, 128, kernel_size=1)
        self.conv9_2 = nn.Conv2d(128, 256, kernel_size=3, padding=1, stride=2)

        self.conv10_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv10_2 = nn.Conv2d(128, 256, kernel_size=3)

        self.conv11_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv11_2 = nn.Conv2d(128, 256, kernel_size=3)

        # CFE
        self.cfe1 = CFE(512, 3)
        self.cfe2 = CFE(512, 3)
        self.cfe3 = CFE(512, 3)
        self.cfe4 = CFE(512, 3)

        # FFB
        self.ffb1 = FFB(512, 512)
        self.ffb2 = FFB(512, 512)

        # multibox layer
        self.multibox = MultiBoxLayer()
Exemplo n.º 8
0
    def __init__(self):
        super(SSD300, self).__init__()
        self.batch_norm = True
        # modelVGG16
        self.base = self.make_layers()
        #self.base = self.VGG16()
        self.norm4 = L2Norm2d(20)

        self.conv5_1 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)
        self.norm5_1 = nn.BatchNorm2d(512)
        self.conv5_2 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)
        self.norm5_2 = nn.BatchNorm2d(512)
        self.conv5_3 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)
        self.norm5_3 = nn.BatchNorm2d(512)

        self.conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6)

        self.conv7 = nn.Conv2d(1024, 1024, kernel_size=1)

        self.conv8_1 = nn.Conv2d(1024, 256, kernel_size=1)
        self.conv8_2 = nn.Conv2d(256, 512, kernel_size=3, padding=1, stride=2)

        self.conv9_1 = nn.Conv2d(512, 128, kernel_size=1)
        self.conv9_2 = nn.Conv2d(128, 256, kernel_size=3, padding=1, stride=2)

        self.conv10_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv10_1_dp = nn.Dropout2d(p=0.2)
        self.conv10_2 = nn.Conv2d(128, 256, kernel_size=3)
        self.conv10_2_dp = nn.Dropout2d(p=0.2)

        self.conv11_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv11_1_dp = nn.Dropout2d(p=0.2)
        self.conv11_2 = nn.Conv2d(128, 256, kernel_size=3)
        self.conv11_2_dp = nn.Dropout2d(p=0.2)

        # multibox layer
        self.multibox = MultiBoxLayer()
Exemplo n.º 9
0
    def __init__(self):
        super(FaceBox_512, self).__init__()

        # model
        # self.conv1 = nn.Conv2d(3, 24, kernel_size=5, stride=2, padding=2)
        # self.conv2 = nn.Conv2d(48, 64, kernel_size=5, stride=2, padding=2)
        self.conv1 = nn.Conv2d(3, 24, kernel_size=3, stride=2, padding=1)
        self.conv2 = nn.Conv2d(48, 64, kernel_size=3, stride=2, padding=1)

        self.inception1 = Inception()
        self.inception2 = Inception()
        self.inception3 = Inception()

        self.conv3_1 = nn.Conv2d(128, 128, kernel_size=1)
        self.conv3_2 = nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1)
        self.conv4_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv4_2 = nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1)

        self.multilbox = MultiBoxLayer()
Exemplo n.º 10
0
    def __init__(self):
        super(FaceBox_ori, self).__init__()

        #model
        self.conv1 = nn.Conv2d(3, 24, kernel_size=7, stride=4, padding=3)
        self.bn1 = nn.BatchNorm2d(24)
        self.conv2 = nn.Conv2d(48, 64, kernel_size=5, stride=2, padding=2)
        self.bn2 = nn.BatchNorm2d(64)

        self.inception1 = Inception1()
        self.inception2 = Inception1()
        self.inception3 = Inception1()

        # self.conv3_1 = nn.Conv2d(128,128,kernel_size=1)
        self.conv3_1 = BasicConv2d(128, 128, 1)
        # self.conv3_2 = nn.Conv2d(128,256,kernel_size=3,stride=2,padding=1)
        self.conv3_2 = BasicConv2d(128, 256, 3, 2, 1)
        # self.conv4_1 = nn.Conv2d(256,128,kernel_size=1)
        self.conv4_1 = BasicConv2d(256, 128, 1)
        # self.conv4_2 = nn.Conv2d(128,256,kernel_size=3,stride=2,padding=1)
        self.conv4_2 = BasicConv2d(128, 256, 3, 2, 1)

        self.multilbox = MultiBoxLayer()
Exemplo n.º 11
0
    def __init__(self):
        super(FaceBox, self).__init__()

        #model
        self.conv1 = nn.Conv2d(3, 24, kernel_size=7, stride=4, padding=3)
        self.conv2 = nn.Conv2d(48, 64, kernel_size=5, stride=2, padding=2)

        # self.conv1_1 = nn.Conv2d(3,24,kernel_size=3,stride=2,padding=1)
        self.conv1_1 = BasicConv2d(3, 24, kernel_size=3, stride=2, padding=1)
        # self.conv1_2 = nn.Conv2d(24,24,kernel_size=3,stride=2,padding=1)
        self.conv1_2 = BasicConv2d(24, 24, kernel_size=3, stride=2, padding=1)
        # self.conv1_3 = nn.Conv2d(24,24,kernel_size=3,stride=1,padding=1)
        self.conv1_3 = BasicConv2d(24, 24, kernel_size=3, stride=1, padding=1)
        # self.bconv1 = nn.Conv2d(72,48,kernel_size=1)
        self.bconv1 = BasicConv2d(72, 48, kernel_size=1)

        self.bn1_1 = nn.BatchNorm2d(24, eps=0.001, momentum=0.1, affine=True)
        self.bn1_2 = nn.BatchNorm2d(24, eps=0.001, momentum=0.1, affine=True)
        self.bn2_1 = nn.BatchNorm2d(64, eps=0.001, momentum=0.1, affine=True)
        self.bn2_2 = nn.BatchNorm2d(64, eps=0.001, momentum=0.1, affine=True)

        # self.conv2_1 = nn.Conv2d(48,64,kernel_size=3,stride=2,padding=1)
        self.conv2_1 = BasicConv2d(48, 64, kernel_size=3, stride=2, padding=1)
        # self.conv2_2 = nn.Conv2d(64,64,kernel_size=3,stride=1,padding=1)
        self.conv2_2 = BasicConv2d(64, 64, kernel_size=3, stride=1, padding=1)
        # self.bconv2 = nn.Conv2d(192,128,kernel_size=1)
        self.bconv2 = BasicConv2d(192, 128, kernel_size=1)

        # self.inception1 = Inception1()
        # self.inception2 = Inception1()
        # self.inception3 = Inception1()

        self.rfblock1 = BasicRFB_a(128, 128)
        self.rfblock2 = BasicRFB_a(128, 128)
        self.rfblock3 = BasicRFB_a(128, 128)

        self.bconv3 = nn.Conv2d(256, 128, kernel_size=1)
        self.bconv4 = nn.Conv2d(384, 128, kernel_size=1)
        self.bn3 = nn.BatchNorm2d(256, eps=0.001, momentum=0.1, affine=True)
        self.bn4 = nn.BatchNorm2d(384, eps=0.001, momentum=0.1, affine=True)

        # self.conv3_1 = nn.Conv2d(128,128,kernel_size=1)
        self.conv3_1 = BasicConv2d(128, 128, kernel_size=1, stride=1)
        # self.conv3_2 = nn.Conv2d(128,256,kernel_size=3,stride=2,padding=1)
        self.conv3_2 = BasicConv2d(128,
                                   256,
                                   kernel_size=3,
                                   stride=2,
                                   padding=1)
        # self.conv4_1 = nn.Conv2d(256,128,kernel_size=1)
        self.conv4_1 = BasicConv2d(256, 128, kernel_size=1, stride=1)
        # self.conv4_2 = nn.Conv2d(128,256,kernel_size=3,stride=2,padding=1)
        self.conv4_2 = BasicConv2d(128,
                                   256,
                                   kernel_size=3,
                                   stride=2,
                                   padding=1)

        self.multilbox = MultiBoxLayer()

        # Official init from torch repo.
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.xavier_uniform(m.weight.data)
                # nn.init.kaiming_normal(m.weight.data)
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()
            elif isinstance(m, nn.Linear):
                m.bias.data.zero_()
Exemplo n.º 12
0
    def __init__(self):
        super(SSD300, self).__init__()
        self.batch_norm = True
        # modelVGG16
        self.base = self.make_layers()
        #self.base = self.VGG16()
        self.norm4 = L2Norm2d(20)

        self.conv5_1 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)
        self.norm5_1 = nn.BatchNorm2d(512)
        self.conv5_2 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)
        self.norm5_2 = nn.BatchNorm2d(512)
        self.conv5_3 = nn.Conv2d(512,
                                 512,
                                 kernel_size=3,
                                 padding=1,
                                 dilation=1)
        self.norm5_3 = nn.BatchNorm2d(512)

        self.conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6)

        self.conv7 = nn.Conv2d(1024, 1024, kernel_size=1)

        self.conv8_1 = nn.Conv2d(1024, 256, kernel_size=1)
        self.conv8_2 = nn.Conv2d(256, 512, kernel_size=3, padding=1, stride=2)

        self.conv9_1 = nn.Conv2d(512, 128, kernel_size=1)
        self.conv9_2 = nn.Conv2d(128, 256, kernel_size=3, padding=1, stride=2)

        self.conv10_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv10_1_dp = nn.Dropout2d(p=0.2)

        if abs(NetworkConfig.input_image_size - 500.) < 1:
            self.conv10_2 = nn.Conv2d(128,
                                      256,
                                      kernel_size=3,
                                      padding=1,
                                      stride=2)
            self.conv10_2_dp = nn.Dropout2d(p=0.2)
        else:
            self.conv10_2 = nn.Conv2d(128, 256, kernel_size=3)
            self.conv10_2_dp = nn.Dropout2d(p=0.2)

        self.conv11_1 = nn.Conv2d(256, 128, kernel_size=1)
        self.conv11_1_dp = nn.Dropout2d(p=0.2)
        self.conv11_2 = nn.Conv2d(128, 256, kernel_size=3)
        self.conv11_2_dp = nn.Dropout2d(p=0.2)

        if NetworkConfig.input_image_size - 300. < 2:
            pass

        elif NetworkConfig.input_image_size - 400. < 2:
            self.conv12_1 = nn.Conv2d(256, 128, kernel_size=1)
            self.conv12_1_dp = nn.Dropout2d(p=0.2)
            self.conv12_2 = nn.Conv2d(128, 256, kernel_size=3)
            self.conv12_2_dp = nn.Dropout2d(p=0.2)

        elif NetworkConfig.input_image_size - 500. < 2:
            self.conv12_1 = nn.Conv2d(256, 128, kernel_size=1)
            self.conv12_1_dp = nn.Dropout2d(p=0.2)
            self.conv12_2 = nn.Conv2d(128, 256, kernel_size=2)
            self.conv12_2_dp = nn.Dropout2d(p=0.2)

        elif NetworkConfig.input_image_size - 600. < 2:
            self.conv12_1 = nn.Conv2d(256, 128, kernel_size=1)
            self.conv12_1_dp = nn.Dropout2d(p=0.2)
            self.conv12_2 = nn.Conv2d(128, 256, kernel_size=3)
            self.conv12_2_dp = nn.Dropout2d(p=0.2)

            self.conv13_1 = nn.Conv2d(256, 128, kernel_size=1)
            self.conv13_1_dp = nn.Dropout2d(p=0.2)
            self.conv13_2 = nn.Conv2d(128, 256, kernel_size=3)
            self.conv13_2_dp = nn.Dropout2d(p=0.2)

        # multibox layer
        self.multibox = MultiBoxLayer()