def __init__(self, _num_inchannels=3, _num_stages=3, _use_avg_on_conv3=True):
super(Cross_NIN, self).__init__()
num_inchannels = _num_inchannels
num_stages = _num_stages
use_avg_on_conv3 = _use_avg_on_conv3
assert (num_stages >= 3)
nChannels = 192
nChannels2 = 160
nChannels3 = 96
blocks = [nn.Sequential() for i in range(num_stages+2)]
# 1st block,kernel size 5 to 1 to 1
blocks[0].add_module('Block1_ConvB1', BasicBlock(num_inchannels, nChannels, 5))
blocks[0].add_module('Block1_ConvB2', BasicBlock(nChannels, nChannels2, 1))
blocks[0].add_module('Block1_ConvB3', BasicBlock(nChannels2, nChannels3, 1))
blocks[0].add_module('Block1_MaxPool', nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
# 2nd block
blocks[1].add_module('Block2_ConvB1', BasicBlock(nChannels3, nChannels, 5))
blocks[1].add_module('Block2_ConvB2', BasicBlock(nChannels, nChannels, 1))
blocks[1].add_module('Block2_ConvB3', BasicBlock(nChannels, nChannels, 1))
blocks[1].add_module('Block2_AvgPool', nn.AvgPool2d(kernel_size=3, stride=2, padding=1))
#blocks.append(nn.Sequential())
blocks[2].add_module('Attention', Self_Attn(nChannels, 'relu'))
blocks[3].add_module('Cross', Cross_Attn2(nChannels, 'relu'))
# 3rd block
blocks[4].add_module('Block3_ConvB1', BasicBlock(nChannels, nChannels, 3))
blocks[4].add_module('Block3_ConvB2', BasicBlock(nChannels, nChannels, 1))
blocks[4].add_module('Block3_ConvB3', BasicBlock(nChannels, nChannels, 1))
if num_stages > 5 and use_avg_on_conv3:
blocks[4].add_module('Block3_AvgPool', nn.AvgPool2d(kernel_size=3, stride=2, padding=1))
for s in range(5, num_stages+2):
blocks[s].add_module('Block' + str(s + 1) + '_ConvB1', BasicBlock(nChannels, nChannels, 3))
blocks[s].add_module('Block' + str(s + 1) + '_ConvB2', BasicBlock(nChannels, nChannels, 1))
blocks[s].add_module('Block' + str(s + 1) + '_ConvB3', BasicBlock(nChannels, nChannels, 1))
#attention module
# global average pooling and classifier
blocks.append(nn.Sequential())
blocks[-1].add_module('GlobalAveragePooling', GlobalAveragePooling())
# for i,block in enumerate(blocks):
# print('-'*10+'Module'+str(i)+'-'*10)
# for module in block.modules():
# print(module)
#self.final_pool=GlobalAveragePooling()
#self.attention_module=Self_Attn(nChannels,'relu')
self._feature_blocks = nn.ModuleList(blocks)
self.all_feat_names = ['conv1']+['conv2']+['Attention']+['Cross']+['conv' + str(s + 1) for s in range(2,num_stages)] + ['classifier', ]
#example ['conv1', 'conv2', 'conv3', 'conv4', 'conv5', 'conv6', 'conv7', 'conv8', 'conv9', 'conv10', 'classifier']
assert (len(self.all_feat_names) == len(self._feature_blocks))
self.weight_initialization()
def __init__(self,
_num_stages=3,
_use_avg_on_conv3=True,
indim=384,
num_classes=6):
"""
:param _num_stages: block combination
:param _use_avg_on_conv3: finally use avg or not
:param indim:
:param num_classes: transformation matrix
"""
nChannels = 192
super(Cross_Regressor, self).__init__()
self.num_stages = _num_stages
self.nin = NetworkInNetwork(_num_stages=_num_stages,
_use_avg_on_conv3=_use_avg_on_conv3)
self.fc = nn.Linear(indim, num_classes)
self.cross_Attn = Cross_Attn(nChannels, 'relu')
for m in self.modules():
if isinstance(m, nn.Linear):
m.bias.data.zero_()
self.pool_operation = GlobalAveragePooling()
def __init__(self, _nChannels, _num_classes, _cls_type):
super(Classifier, self).__init__()
nChannels = _nChannels
num_classes = _num_classes
self.cls_type = _cls_type
self.classifier = nn.Sequential()
#first add a self attention part
self.attention_module = Self_Attn(int(nChannels / 8 / 8), 'relu')
if self.cls_type == 'MultLayer':
nFeats = min(num_classes * 20, 2048)
self.classifier.add_module('Flatten', Flatten())
self.classifier.add_module(
'Liniear_1', nn.Linear(nChannels, nFeats, bias=False))
self.classifier.add_module('BatchNorm_1', nn.BatchNorm1d(nFeats))
self.classifier.add_module('ReLU_1', nn.ReLU(inplace=True))
self.classifier.add_module('Liniear_2',
nn.Linear(nFeats, nFeats, bias=False))
self.classifier.add_module('BatchNorm2d', nn.BatchNorm1d(nFeats))
self.classifier.add_module('ReLU_2', nn.ReLU(inplace=True))
self.classifier.add_module('Liniear_F',
nn.Linear(nFeats, num_classes))
elif self.cls_type == 'MultLayerFC1':
self.classifier.add_module(
'Batchnorm', nn.BatchNorm2d(nChannels / 8 / 8, affine=False))
self.classifier.add_module('Flatten', Flatten())
self.classifier.add_module('Liniear_F',
nn.Linear(nChannels, num_classes))
elif self.cls_type == 'MultLayerFC2':
nFeats = min(num_classes * 20, 2048)
self.classifier.add_module('Flatten', Flatten())
self.classifier.add_module(
'Liniear_1', nn.Linear(nChannels, nFeats, bias=False))
self.classifier.add_module('BatchNorm_1', nn.BatchNorm1d(nFeats))
self.classifier.add_module('ReLU_1', nn.ReLU(inplace=True))
self.classifier.add_module('Liniear_F',
nn.Linear(nFeats, num_classes))
elif self.cls_type == 'NIN_ConvBlock3':
self.classifier.add_module('Block3_ConvB1',
BasicBlock(nChannels, 192, 3))
self.classifier.add_module('Block3_ConvB2',
BasicBlock(192, 192, 1))
self.classifier.add_module('Block3_ConvB3',
BasicBlock(192, 192, 1))
self.classifier.add_module('GlobalAvgPool', GlobalAveragePooling())
self.classifier.add_module('Liniear_F',
nn.Linear(192, num_classes))
elif self.cls_type == 'Alexnet_conv5' or self.cls_type == 'Alexnet_conv4':
if self.cls_type == 'Alexnet_conv4':
block5 = nn.Sequential(
nn.Conv2d(256, 256, kernel_size=3, padding=1),
nn.BatchNorm2d(256),
nn.ReLU(inplace=True),
)
self.classifier.add_module('ConvB5', block5)
self.classifier.add_module('Pool5',
nn.MaxPool2d(kernel_size=3, stride=2))
self.classifier.add_module('Flatten', Flatten())
self.classifier.add_module(
'Linear1', nn.Linear(256 * 6 * 6, 4096, bias=False))
self.classifier.add_module('BatchNorm1', nn.BatchNorm1d(4096))
self.classifier.add_module('ReLU1', nn.ReLU(inplace=True))
self.classifier.add_module('Liniear2',
nn.Linear(4096, 4096, bias=False))
self.classifier.add_module('BatchNorm2', nn.BatchNorm1d(4096))
self.classifier.add_module('ReLU2', nn.ReLU(inplace=True))
self.classifier.add_module('LinearF', nn.Linear(4096, num_classes))
elif self.cls_type == 'l3layer_conv3':
nChannels = 128
nChannels1 = 256
nChannels2 = 512
self.classifier.add_module('Block3_ConvB1',
TEBlock1(nChannels1, nChannels2,
3)) #no padding
self.classifier.add_module('Block3_ConvB2',
TEBlock1(nChannels2, nChannels1, 1))
self.classifier.add_module('Block3_ConvB3',
TEBlock1(nChannels1, nChannels, 1))
self.classifier.add_module('GlobalAvgPool', GlobalAveragePooling())
self.classifier.add_module('Linear_F', nn.Linear(128, num_classes))
else:
raise ValueError('Not recognized classifier type: %s' %
self.cls_type)
self.initilize()