def __init__(self, num_classes=1000):
super(Inception_v1, self).__init__()
#conv2d0
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)
self.max_pool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.lrn1 = LRN(local_size=11, alpha=0.00109999999404, beta=0.5, k=2)
#conv2d1
self.conv2 = Conv2d_KSE(64, 64, kernel_size=1, stride=1, padding=0)
#conv2d2
self.conv3 = Conv2d_KSE(64, 192, kernel_size=3, stride=1, padding=1)
self.lrn3 = LRN(local_size=11, alpha=0.00109999999404, beta=0.5, k=2)
self.max_pool3 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.inception_3a = Inception_base(1, 192, [[64], [96,128], [16, 32], [3, 32]]) #3a
self.inception_3b = Inception_base(1, 256, [[128], [128,192], [32, 96], [3, 64]]) #3b
self.max_pool_inc3= nn.MaxPool2d(kernel_size=3, stride=2, padding=0)
self.inception_4a = Inception_base(1, 480, [[192], [ 96,204], [16, 48], [3, 64]]) #4a
self.inception_4b = Inception_base(1, 508, [[160], [112,224], [24, 64], [3, 64]]) #4b
self.inception_4c = Inception_base(1, 512, [[128], [128,256], [24, 64], [3, 64]]) #4c
self.inception_4d = Inception_base(1, 512, [[112], [144,288], [32, 64], [3, 64]]) #4d
self.inception_4e = Inception_base(1, 528, [[256], [160,320], [32,128], [3,128]]) #4e
self.max_pool_inc4 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.inception_5a = Inception_base(1, 832, [[256], [160,320], [48,128], [3,128]]) #5a
self.inception_5b = Inception_base(1, 832, [[384], [192,384], [48,128], [3,128]]) #5b
self.avg_pool5 = nn.AvgPool2d(kernel_size=7, stride=1, padding=0)
self.dropout_layer = nn.Dropout(0.4)
self.fc = nn.Linear(1024, num_classes)
def __init__(self, inplanes, expansion=4, growthRate=12, dropRate=0):
super(Bottleneck, self).__init__()
planes = expansion * growthRate
self.bn1 = nn.BatchNorm2d(inplanes)
self.conv1 = Conv2d_KSE(inplanes, planes, kernel_size=1, bias=False)
self.bn2 = nn.BatchNorm2d(planes)
self.conv2 = Conv2d_KSE(planes,
growthRate,
kernel_size=3,
padding=1,
bias=False)
self.relu = nn.ReLU(inplace=True)
self.dropRate = dropRate
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(Bottleneck, self).__init__()
self.conv1 = Conv2d_KSE(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = Conv2d_KSE(planes,
planes,
kernel_size=3,
stride=stride,
padding=1,
bias=False)
self.bn2 = nn.BatchNorm2d(planes)
self.conv3 = Conv2d_KSE(planes, planes * 4, kernel_size=1, bias=False)
self.bn3 = nn.BatchNorm2d(planes * 4)
self.relu = nn.ReLU(inplace=True)
self.downsample = downsample
self.stride = stride
def __init__(self, num_input_features, growth_rate, bn_size, drop_rate):
super(_DenseLayer, self).__init__()
self.add_module('norm1', nn.BatchNorm2d(num_input_features)),
self.add_module('relu1', nn.ReLU(inplace=True)),
self.add_module(
'conv1',
Conv2d_KSE(num_input_features,
bn_size * growth_rate,
kernel_size=1,
stride=1,
bias=False)),
self.add_module('norm2', nn.BatchNorm2d(bn_size * growth_rate)),
self.add_module('relu2', nn.ReLU(inplace=True)),
self.add_module(
'conv2',
Conv2d_KSE(bn_size * growth_rate,
growth_rate,
kernel_size=3,
stride=1,
padding=1,
bias=False)),
self.drop_rate = drop_rate
def __init__(self, in_planes, planes, stride=1, option='A'):
super(BasicBlock, self).__init__()
global zero_index, count
self.conv1 = Conv2d_KSE(in_planes,
planes,
kernel_size=3,
stride=stride,
padding=1,
bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = Conv2d_KSE(planes,
planes,
kernel_size=3,
stride=1,
padding=1,
bias=False)
self.bn2 = nn.BatchNorm2d(planes)
self.shortcut = nn.Sequential()
if stride != 1 or in_planes != planes:
if option == 'A':
"""
For CIFAR10 ResNet paper uses option A.
"""
self.shortcut = LambdaLayer(lambda x: F.pad(
x[:, :, ::2, ::2],
(0, 0, 0, 0, planes // 4, planes // 4), "constant", 0))
elif option == 'B':
self.shortcut = nn.Sequential(
nn.Conv2d(in_planes,
self.expansion * planes,
kernel_size=1,
stride=stride,
bias=False),
nn.BatchNorm2d(self.expansion * planes))
def _make_layer(self, block, planes, blocks, stride=1):
downsample = None
if stride != 1 or self.inplanes != planes * block.expansion:
downsample = nn.Sequential(
Conv2d_KSE(self.inplanes,
planes * block.expansion,
kernel_size=1,
stride=stride,
bias=False),
nn.BatchNorm2d(planes * block.expansion),
)
layers = []
layers.append(block(self.inplanes, planes, stride, downsample))
self.inplanes = planes * block.expansion
for i in range(1, blocks):
layers.append(block(self.inplanes, planes))
return nn.Sequential(*layers)
def __init__(self, depth_dim, input_size, config):
super(Inception_base, self).__init__()
self.depth_dim = depth_dim
#mixed 'name'_1x1
self.conv1 = Conv2d_KSE(input_size, config[0][0], kernel_size=1, stride=1, padding=0)
#mixed 'name'_3x3_bottleneck
self.conv3_1 = Conv2d_KSE(input_size, config[1][0], kernel_size=1, stride=1, padding=0)
#mixed 'name'_3x3
self.conv3_3 = Conv2d_KSE(config[1][0], config[1][1], kernel_size=3, stride=1, padding=1)
# mixed 'name'_5x5_bottleneck
self.conv5_1 = Conv2d_KSE(input_size, config[2][0], kernel_size=1, stride=1, padding=0)
# mixed 'name'_5x5
self.conv5_5 = Conv2d_KSE(config[2][0], config[2][1], kernel_size=5, stride=1, padding=2)
self.max_pool_1 = nn.MaxPool2d(kernel_size=config[3][0], stride=1, padding=1)
#mixed 'name'_pool_reduce
self.conv_max_1 = Conv2d_KSE(input_size, config[3][1], kernel_size=1, stride=1, padding=0)