def __init__(self, input_size=224, n_class=1000, model_size='1.0x'):
super(ShuffleNetV2, self).__init__()
print('model size is ', model_size)
self.stage_repeats = [4, 8, 4]
self.model_size = model_size
if model_size == '0.5x':
self.stage_out_channels = [-1, 24, 48, 96, 192, 1024]
elif model_size == '1.0x':
self.stage_out_channels = [-1, 24, 116, 232, 464, 1024]
elif model_size == '1.5x':
self.stage_out_channels = [-1, 24, 176, 352, 704, 1024]
elif model_size == '2.0x':
self.stage_out_channels = [-1, 24, 244, 488, 976, 2048]
else:
raise NotImplementedError
# building first layer
input_channel = self.stage_out_channels[1]
self.first_conv = nn.SequentialCell([
nn.Conv2d(in_channels=3, out_channels=input_channel, kernel_size=3, stride=2,
pad_mode='pad', padding=1, has_bias=False),
nn.BatchNorm2d(num_features=input_channel, momentum=0.9),
nn.ReLU(),
])
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='same')
self.features = []
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:
self.features.append(ShuffleV2Block(input_channel, output_channel,
mid_channels=output_channel // 2, ksize=3, stride=2))
else:
self.features.append(ShuffleV2Block(input_channel // 2, output_channel,
mid_channels=output_channel // 2, ksize=3, stride=1))
input_channel = output_channel
self.features = nn.SequentialCell([*self.features])
self.conv_last = nn.SequentialCell([
nn.Conv2d(in_channels=input_channel, out_channels=self.stage_out_channels[-1], kernel_size=1, stride=1,
pad_mode='pad', padding=0, has_bias=False),
nn.BatchNorm2d(num_features=self.stage_out_channels[-1], momentum=0.9),
nn.ReLU()
])
self.globalpool = nn.AvgPool2d(kernel_size=7, stride=7, pad_mode='valid')
if self.model_size == '2.0x':
self.dropout = nn.Dropout(keep_prob=0.8)
self.classifier = nn.SequentialCell([nn.Dense(in_channels=self.stage_out_channels[-1],
out_channels=n_class, has_bias=False)])
##TODO init weights
self._initialize_weights()
def __init__(self, input_size=224, n_class=107, model_size='1.5x'):
super(ShuffleNetV2, self).__init__()
print('model size is ', model_size)
self.stage_repeats = [4, 8, 4]
self.model_size = model_size
if model_size == '0.5x':
self.stage_out_channels = [-1, 24, 48, 96, 192, 1024]
elif model_size == '1.0x':
self.stage_out_channels = [-1, 24, 116, 232, 464, 1024]
elif model_size == '1.5x':
self.stage_out_channels = [-1, 24, 176, 352, 704, 1024]
elif model_size == '2.0x':
self.stage_out_channels = [-1, 24, 244, 488, 976, 2048]
else:
raise NotImplementedError
# building first layer
input_channel = self.stage_out_channels[1]
self.first_conv = nn.Sequential(
nn.Conv2d(3, input_channel, 3, 2, 1, bias=False),
nn.BatchNorm2d(input_channel),
nn.ReLU(inplace=True),
)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.features = []
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:
self.features.append(ShuffleV2Block(input_channel, output_channel,
mid_channels=output_channel // 2, ksize=3, stride=2))
else:
self.features.append(ShuffleV2Block(input_channel // 2, output_channel,
mid_channels=output_channel // 2, ksize=3, stride=1))
input_channel = output_channel
self.features = nn.Sequential(*self.features)
self.conv_last = nn.Sequential(
nn.Conv2d(input_channel, self.stage_out_channels[-1], 1, 1, 0, bias=False),
nn.BatchNorm2d(self.stage_out_channels[-1]),
nn.ReLU(inplace=True)
)
self.globalpool = nn.AvgPool2d(7)
if self.model_size == '2.0x':
self.dropout = nn.Dropout(0.2)
self.classifier = nn.Sequential(nn.Linear(self.stage_out_channels[-1], n_class, bias=False))
self._initialize_weights()
def __init__(self, input_size=112, model_size='1.0x'):
super(ShuffleNetV2, self).__init__()
print('model size is ', model_size)
self.stage_repeats = [4, 8, 4]
self.model_size = model_size
if model_size == '0.5x':
self.stage_out_channels = [-1, 24, 48, 96, 192, 1024]
elif model_size == '1.0x':
self.stage_out_channels = [-1, 24, 116, 232, 464, 1024]
elif model_size == '1.5x':
self.stage_out_channels = [-1, 24, 176, 352, 704, 1024]
elif model_size == '2.0x':
self.stage_out_channels = [-1, 24, 244, 488, 976, 1024]
else:
raise NotImplementedError
# building first layer
input_channel = self.stage_out_channels[1]
self.first_conv = nn.Sequential(
nn.Conv2d(3, input_channel, 3, 2, 1, bias=False),
nn.BatchNorm2d(input_channel, eps=1e-3),
nn.ReLU(inplace=True),
)
self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
output_channel = self.stage_out_channels[2]
inp, outp, stride = input_channel, output_channel, 2
self.shuff_1 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
input_channel = output_channel
inp, outp, stride = input_channel // 2, output_channel, 1
self.shuff_2 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
self.shuff_3 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
self.shuff_4 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
output_channel = self.stage_out_channels[3]
inp, outp, stride = input_channel, output_channel, 2
self.shuff_5 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
input_channel = output_channel
inp, outp, stride = input_channel // 2, output_channel, 1
self.shuff_6 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
self.shuff_7 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
self.shuff_8 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
self.shuff_9 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
self.shuff_10 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
self.shuff_11 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
self.shuff_12 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
output_channel = self.stage_out_channels[4]
inp, outp, stride = input_channel, output_channel, 2
self.shuff_13 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
input_channel = output_channel
inp, outp, stride = input_channel // 2, output_channel, 1
self.shuff_14 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
self.shuff_15 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
self.shuff_16 = ShuffleV2Block(inp,
outp,
mid_channels=outp // 2,
ksize=3,
stride=stride)
self.conv_last = conv_1x1_bn(input_channel, 256)
self.fc_age = nn.Sequential(
nn.Conv2d(256, 512, kernel_size=3, padding=1, bias=True),
nn.ReLU(inplace=True))
self.age_pred = nn.Linear(512, 101)
self.glob_pool = nn.AvgPool2d(int(input_size / 32))
self.fc_gen = nn.Sequential(
nn.Conv2d(256, 512, kernel_size=3, padding=1, bias=True),
nn.ReLU(inplace=True))
self.gen_pred = nn.Linear(512, 2)
def __init__(self, input_size=224, n_class=1000, model_size='1.0x'):
super(ShuffleNetV2M, self).__init__()
print('model size is ', model_size)
self.stage_repeats = [4, 8, 4]
self.model_size = model_size
if model_size == '0.5x':
self.stage_out_channels = [-1, 24, 48, 96, 192, 1024]
elif model_size == '1.0x':
self.stage_out_channels = [-1, 32, 128, 256, 512, 1024]
elif model_size == '1.5x':
self.stage_out_channels = [-1, 24, 176, 352, 704, 1024]
elif model_size == '2.0x':
self.stage_out_channels = [-1, 24, 244, 488, 976, 2048]
else:
raise NotImplementedError
# building first layer
input_channel = self.stage_out_channels[1]
self.first_conv = nn.Sequential(
nn.Conv2d(3, input_channel, 3, 2, 1, bias=False),
nn.BatchNorm2d(input_channel),
nn.ReLU(inplace=True),
)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
stage_names = ['stage{}'.format(i) for i in [2, 3, 4]]
for idxstage in range(len(self.stage_repeats)):
stage_name = stage_names[idxstage]
numrepeat = self.stage_repeats[idxstage]
output_channel = self.stage_out_channels[idxstage + 2]
seq = [
ShuffleV2Block(input_channel,
output_channel,
mid_channels=output_channel // 2,
ksize=5,
stride=2)
]
for i in range(numrepeat - 1):
seq.append(
ShuffleV2Block(output_channel // 2,
output_channel,
mid_channels=output_channel // 2,
ksize=5,
stride=1))
input_channel = output_channel
setattr(self, stage_name, nn.Sequential(*seq))
# self.conv_last = nn.Sequential(
# nn.Conv2d(input_channel,
# self.stage_out_channels[-1], 1, 1, 0, bias=False),
# nn.BatchNorm2d(self.stage_out_channels[-1]),
# nn.ReLU(inplace=True)
# )
self.globalpool = nn.AvgPool2d(7)
if self.model_size == '2.0x':
self.dropout = nn.Dropout(0.2)
self.classifier = nn.Sequential(
nn.Linear(self.stage_out_channels[-2], n_class, bias=False))
self._initialize_weights()
def __init__(self, input_size=224, model_size='1.0x'):
super(ShuffleNetV2, self).__init__()
print('model size is ', model_size)
self.stage_repeats = [4, 8, 4]
self.model_size = model_size
if model_size == '0.5x':
self.stage_out_channels = [-1, 24, 48, 96, 192]
elif model_size == '1.0x':
self.stage_out_channels = [-1, 24, 116, 232, 464]
elif model_size == '1.5x':
self.stage_out_channels = [-1, 24, 176, 352, 704]
elif model_size == '2.0x':
self.stage_out_channels = [-1, 24, 244, 488, 976]
else:
raise NotImplementedError
# building first layer
input_channel = self.stage_out_channels[1]
self.first_conv = nn.Sequential(
nn.Conv2d(3, input_channel, 3, 2, 1, bias=False),
nn.BatchNorm2d(input_channel, eps=1e-3),
nn.ReLU(inplace=True),
)
self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
output_channel = self.stage_out_channels[2]
inp, outp, stride = input_channel, output_channel, 2
self.shuff_1 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
input_channel = output_channel
inp, outp, stride = input_channel // 2, output_channel, 1
self.shuff_2 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
self.shuff_3 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
self.shuff_4 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
output_channel = self.stage_out_channels[3]
inp, outp, stride = input_channel, output_channel, 2
self.shuff_5 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
input_channel = output_channel
inp, outp, stride = input_channel // 2, output_channel, 1
self.shuff_6 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
self.shuff_7= ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
self.shuff_8 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
self.shuff_9 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
self.shuff_10 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
self.shuff_11 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
self.shuff_12 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
output_channel = self.stage_out_channels[4]
inp, outp, stride = input_channel, output_channel, 2
self.shuff_13 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
input_channel = output_channel
inp, outp, stride = input_channel//2, output_channel, 1
self.shuff_14 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
self.shuff_15 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
self.shuff_16 = ShuffleV2Block(inp, outp, mid_channels=outp // 2, ksize=3, stride=stride)
self.conv_last = conv_1x1_bn(input_channel, 64)
self.conv_first = conv_1x1_bn(116, 64)
self.conv_second = conv_1x1_bn(232, 64)
self.decode = Decoder(64)
self.decode1 = Decoder(64)
self.decode2 = Decoder(64)
self.heads = {
'hm': 1,
'wh': 2,
'lm': 10,
'reg': 2
}
for head in self.heads:
out_c = self.heads[head]
fc = nn.Sequential(
nn.Conv2d(64, 128,
kernel_size=3, padding=1, bias=True),
nn.ReLU(inplace=True),
nn.Conv2d(128, out_c,
kernel_size=1, stride=1,
padding=0, bias=True))
if 'hm' in head:
fc[-1].bias.data.fill_(-2.19)
else:
fill_fc_weights(fc)
self.__setattr__(head, fc)