def resnet(units, num_stages, filter_list, num_classes, bottle_neck, **kwargs):
bn_mom = kwargs.get('bn_mom', 0.9)
workspace = kwargs.get('workspace', 256)
"""Return ResNet symbol of
Parameters
----------
units : list
Number of units in each stage
num_stages : int
Number of stage
filter_list : list
Channel size of each stage
num_classes : int
Ouput size of symbol
dataset : str
Dataset type, only cifar10 and imagenet supports
workspace : int
Workspace used in convolution operator
"""
version_se = kwargs.get('version_se', 1)
version_input = kwargs.get('version_input', 1)
assert version_input>=0
version_output = kwargs.get('version_output', 'E')
fc_type = version_output
version_unit = kwargs.get('version_unit', 3)
print(version_se, version_input, version_output, version_unit)
num_unit = len(units)
assert(num_unit == num_stages)
data = mx.sym.Variable(name='data')
data = mx.sym.identity(data=data, name='id')
data = data-127.5
data = data*0.0078125
#data = mx.sym.BatchNorm(data=data, fix_gamma=True, eps=2e-5, momentum=bn_mom, name='bn_data')
if version_input==0:
body = Conv(data=data, num_filter=filter_list[0], kernel=(7, 7), stride=(2,2), pad=(3, 3),
no_bias=True, name="conv0", workspace=workspace)
body = mx.sym.BatchNorm(data=body, fix_gamma=False, eps=2e-5, momentum=bn_mom, name='bn0')
body = Act(data=body, act_type='relu', name='relu0')
body = mx.sym.Pooling(data=body, kernel=(3, 3), stride=(2,2), pad=(1,1), pool_type='max')
else:
body = data
body = Conv(data=body, num_filter=filter_list[0], kernel=(3,3), stride=(1,1), pad=(1, 1),
no_bias=True, name="conv0", workspace=workspace)
body = mx.sym.BatchNorm(data=body, fix_gamma=False, eps=2e-5, momentum=bn_mom, name='bn0')
body = Act(data=body, act_type='relu', name='relu0')
#body = mx.sym.Pooling(data=body, kernel=(3, 3), stride=(2,2), pad=(1,1), pool_type='max')
for i in range(num_stages):
if version_input==0:
body = residual_unit(body, filter_list[i+1], (1 if i==0 else 2, 1 if i==0 else 2), False,
name='stage%d_unit%d' % (i + 1, 1), bottle_neck=bottle_neck, **kwargs)
else:
body = residual_unit(body, filter_list[i+1], (2, 2), False,
name='stage%d_unit%d' % (i + 1, 1), bottle_neck=bottle_neck, **kwargs)
for j in range(units[i]-1):
body = residual_unit(body, filter_list[i+1], (1,1), True, name='stage%d_unit%d' % (i+1, j+2),
bottle_neck=bottle_neck, **kwargs)
fc1 = symbol_utils.get_fc1(body, num_classes, fc_type)
return fc1
def get_symbol():
num_classes = config.emb_size
print('in_network', config)
fc_type = config.net_output
data = mx.symbol.Variable(name="data")
data = data - 127.5
data = data * 0.0078125
#deactivate act_conv1 and act_conv10
conv1 = mx.symbol.Convolution(data=data, num_filter=96, kernel=(7, 7), stride=(2, 2), pad=(0, 0))
#act_conv1 = Act(data=conv1, act_type=config.net_act, name="conv_1_activation")
pool_conv1 = mx.symbol.Pooling(data=conv1, kernel=(3, 3), stride=(2, 2), pool_type='max', attr={})
fire2 = fire_module(pool_conv1, num_filter_squeeze=16, num_filter_fire=64, act_type=config.net_act, name="fire2")
fire3 = fire_module(fire2, num_filter_squeeze=16, num_filter_fire=64, act_type=config.net_act, name="fire3")
pool3 = mx.symbol.Pooling(data=fire3, kernel=(3, 3), stride=(2, 2), pool_type='max', attr={})
fire4 = fire_module(pool3, num_filter_squeeze=32, num_filter_fire=128, act_type=config.net_act, name="fire4")
fire5 = fire_module(fire4, num_filter_squeeze=32, num_filter_fire=128, act_type=config.net_act, name="fire5")
pool4 = mx.symbol.Pooling(data=fire5, kernel=(3, 3), stride=(2, 2), pool_type='max', attr={})
fire6 = fire_module(pool4, num_filter_squeeze=48, num_filter_fire=192, act_type=config.net_act, name="fire6")
fire7 = fire_module(fire6, num_filter_squeeze=48, num_filter_fire=192, act_type=config.net_act, name="fire7")
fire8 = fire_module(fire7, num_filter_squeeze=64, num_filter_fire=256, act_type=config.net_act, name="fire8")
fire9 = fire_module(fire8, num_filter_squeeze=64, num_filter_fire=256, act_type=config.net_act, name="fire9")
drop9 = mx.sym.Dropout(data=fire9, p=0.5)
conv10 = mx.symbol.Convolution(data=drop9, num_filter=512, kernel=(1, 1), stride=(1, 1), pad=(1, 1))
#act_conv10 = Act(data=conv10, act_type=config.net_act, name="conv_10_activation")
fc1 = symbol_utils.get_fc1(conv10, num_classes, fc_type)
return fc1
def get_symbol(num_classes, **kwargs):
global bn_mom
bn_mom = kwargs.get('bn_mom', 0.9)
wd_mult = kwargs.get('wd_mult', 1.)
version_output = kwargs.get('version_output', 'GNAP')
print('version_output:',version_output)
assert version_output == 'GDC' or version_output == 'GNAP'
fc_type = version_output
data = mx.symbol.Variable(name="data")
data = data - 127.5
data = data * 0.0078125
conv_1 = Conv(data, num_filter=64, kernel=(3, 3), pad=(1, 1), stride=(2, 2), name="conv_1")
conv_2_dw = Conv(conv_1, num_group=64, num_filter=64, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_2_dw")
conv_23 = DResidual(conv_2_dw, num_out=64, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=128, name="dconv_23")
conv_3 = Residual(conv_23, num_block=4, num_out=64, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=128,
name="res_3")
conv_34 = DResidual(conv_3, num_out=128, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=256, name="dconv_34")
conv_4 = Residual(conv_34, num_block=6, num_out=128, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=256,
name="res_4")
conv_45 = DResidual(conv_4, num_out=128, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=512, name="dconv_45")
conv_5 = Residual(conv_45, num_block=2, num_out=128, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=256,
name="res_5")
conv_6_sep = Conv(conv_5, num_filter=512, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_6sep")
fc1 = symbol_utils.get_fc1(conv_6_sep, num_classes, fc_type)
# conv_6_dw = Linear(conv_6_sep, num_filter=512, num_group=512, kernel=(7, 7), pad=(0, 0), stride=(1, 1),
# name="conv_6dw7_7")
# # conv_6_dw = mx.symbol.Dropout(data=conv_6_dw, p=0.4)
# _weight = mx.symbol.Variable("fc1_weight", shape=(num_classes, 512), lr_mult=1.0, wd_mult=wd_mult)
#
# conv_6_f = mx.sym.FullyConnected(data=conv_6_dw, weight=_weight, num_hidden=num_classes, name='pre_fc1')
# fc1 = mx.sym.BatchNorm(data=conv_6_f, fix_gamma=True, eps=2e-5, momentum=bn_mom, name='fc1')
return fc1
def get_symbol():
num_classes = config.emb_size
print('in_network', config)
fc_type = config.net_output
data = mx.symbol.Variable(name="data")
data = data-127.5
data = data*0.0078125
blocks = config.net_blocks
conv_1 = Conv(data, num_filter=64, kernel=(3, 3), pad=(1, 1), stride=(2, 2), name="conv_1")
if blocks[0]==1:
conv_2_dw = Conv(conv_1, num_group=64, num_filter=64, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_2_dw")
else:
conv_2_dw = Residual(conv_1, num_block=blocks[0], num_out=64, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=64, name="res_2")
conv_23 = DResidual(conv_2_dw, num_out=64, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=128, name="dconv_23")
conv_3 = Residual(conv_23, num_block=blocks[1], num_out=64, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=128, name="res_3")
conv_34 = DResidual(conv_3, num_out=128, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=256, name="dconv_34")
conv_4 = Residual(conv_34, num_block=blocks[2], num_out=128, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=256, name="res_4")
conv_45 = DResidual(conv_4, num_out=128, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=512, name="dconv_45")
conv_5 = Residual(conv_45, num_block=blocks[3], num_out=128, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=256, name="res_5")
conv_6_sep = Conv(conv_5, num_filter=512, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_6sep")
fc1 = symbol_utils.get_fc1(conv_6_sep, num_classes, fc_type)
# plot network architecture
digraph = mx.viz.plot_network(fc1, shape={'data': (1, 3, 112, 112)}, save_format='pdf',
node_attrs={"shape": "oval", "fixedsize": "false"})
digraph.render(filename='fmobilefacenet')
return fc1
def get_symbol(num_classes=1000, fc_type='E'):
data = mx.sym.Variable(name='data')
data = data - 127.5
data = data * 0.0078125
body = get_before_pool(data)
fc1 = symbol_utils.get_fc1(body, num_classes, fc_type)
return fc1
def resnet(units, num_stages, filter_list, num_classes, bottle_neck, **kwargs):
bn_mom = kwargs.get('bn_mom', 0.9)
workspace = kwargs.get('workspace', 256)
"""Return ResNet symbol of
Parameters
----------
units : list
Number of units in each stage
num_stages : int
Number of stage
filter_list : list
Channel size of each stage
num_classes : int
Ouput size of symbol
dataset : str
Dataset type, only cifar10 and imagenet supports
workspace : int
Workspace used in convolution operator
"""
version_se = kwargs.get('version_se', 1)
version_input = kwargs.get('version_input', 1)
assert version_input>=0
version_output = kwargs.get('version_output', 'E')
fc_type = version_output
version_unit = kwargs.get('version_unit', 3)
act_type = kwargs.get('version_act', 'prelu')
print(version_se, version_input, version_output, version_unit, act_type)
num_unit = len(units)
assert(num_unit == num_stages)
data = mx.sym.Variable(name='data')
data = mx.sym.identity(data=data, name='id')
data = data-127.5
data = data*0.0078125
if version_input==0:
body = Conv(data=data, num_filter=filter_list[0], kernel=(7, 7), stride=(2,2), pad=(3, 3),
no_bias=True, name="conv0", workspace=workspace)
body = mx.sym.BatchNorm(data=body, fix_gamma=False, eps=2e-5, momentum=bn_mom, name='bn0')
body = Act(data=body, act_type=act_type, name='relu0')
body = mx.sym.Pooling(data=body, kernel=(3, 3), stride=(2,2), pad=(1,1), pool_type='max')
else:
body = data
body = Conv(data=body, num_filter=filter_list[0], kernel=(3,3), stride=(1,1), pad=(1, 1),
no_bias=True, name="conv0", workspace=workspace)
body = mx.sym.BatchNorm(data=body, fix_gamma=False, eps=2e-5, momentum=bn_mom, name='bn0')
body = Act(data=body, act_type=act_type, name='relu0')
for i in range(num_stages):
if version_input==0:
body = residual_unit(body, filter_list[i+1], (1 if i==0 else 2, 1 if i==0 else 2), False,
name='stage%d_unit%d' % (i + 1, 1), bottle_neck=bottle_neck, **kwargs)
else:
body = residual_unit(body, filter_list[i+1], (2, 2), False,
name='stage%d_unit%d' % (i + 1, 1), bottle_neck=bottle_neck, **kwargs)
for j in range(units[i]-1):
body = residual_unit(body, filter_list[i+1], (1,1), True, name='stage%d_unit%d' % (i+1, j+2),
bottle_neck=bottle_neck, **kwargs)
fc1 = symbol_utils.get_fc1(body, num_classes, fc_type)
return fc1
def get_symbol(num_classes): net = MobilenetV2(num_classes, 1) data = mx.sym.Variable(name='data') data = data-127.5 data = data*0.0078125 body = net(data) fc1 = symbol_utils.get_fc1(body, num_classes, 'E') return fc1
def get_symbol(num_classes): model = NASNetALarge(num_classes) data = mx.sym.Variable(name='data') data = data-127.5 data = data*0.0078125 body = model.features(data) fc1 = symbol_utils.get_fc1(body, num_classes, 'E') return fc1
def get_symbol(num_classes):
net = MobileNetV2(num_classes, 112, 1)
data = mx.sym.Variable(name='data')
data = data - 127.5
data = data * 0.0078125
body = net(data)
fc1 = symbol_utils.get_fc1(body, num_classes, 'E')
return fc1
def get_symbol(): net = MNasNet(config.net_multiplier) data = mx.sym.Variable(name='data') data = data-127.5 data = data*0.0078125 body = net(data) fc1 = symbol_utils.get_fc1(body, config.emb_size, config.net_output, input_channel=net.num_output_channel()) return fc1
def get_symbol(num_classes, **kwargs):
data = mx.symbol.Variable(name="data") # 224
data = data - 127.5
data = data * 0.0078125
version_input = kwargs.get('version_input', 1)
assert version_input >= 0
version_output = kwargs.get('version_output', 'E')
fc_type = version_output
version_unit = kwargs.get('version_unit', 3)
print(version_input, version_output, version_unit)
if version_input == 0:
conv_1 = Conv(data, num_filter=32, kernel=(3, 3), pad=(1, 1), stride=(2, 2), name="conv_1") # 224/112
else:
conv_1 = Conv(data, num_filter=32, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_1") # 224/112
conv_2_dw = Conv(conv_1, num_group=32, num_filter=32, kernel=(3, 3), pad=(1, 1), stride=(1, 1),
name="conv_2_dw") # 112/112
conv_2 = Conv(conv_2_dw, num_filter=64, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_2") # 112/112
conv_3_dw = Conv(conv_2, num_group=64, num_filter=64, kernel=(3, 3), pad=(1, 1), stride=(2, 2),
name="conv_3_dw") # 112/56
conv_3 = Conv(conv_3_dw, num_filter=128, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_3") # 56/56
conv_4_dw = Conv(conv_3, num_group=128, num_filter=128, kernel=(3, 3), pad=(1, 1), stride=(1, 1),
name="conv_4_dw") # 56/56
conv_4 = Conv(conv_4_dw, num_filter=128, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_4") # 56/56
conv_5_dw = Conv(conv_4, num_group=128, num_filter=128, kernel=(3, 3), pad=(1, 1), stride=(2, 2),
name="conv_5_dw") # 56/28
conv_5 = Conv(conv_5_dw, num_filter=256, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_5") # 28/28
conv_6_dw = Conv(conv_5, num_group=256, num_filter=256, kernel=(3, 3), pad=(1, 1), stride=(1, 1),
name="conv_6_dw") # 28/28
conv_6 = Conv(conv_6_dw, num_filter=256, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_6") # 28/28
conv_7_dw = Conv(conv_6, num_group=256, num_filter=256, kernel=(3, 3), pad=(1, 1), stride=(2, 2),
name="conv_7_dw") # 28/14
conv_7 = Conv(conv_7_dw, num_filter=512, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_7") # 14/14
conv_8_dw = Conv(conv_7, num_group=512, num_filter=512, kernel=(3, 3), pad=(1, 1), stride=(1, 1),
name="conv_8_dw") # 14/14
conv_8 = Conv(conv_8_dw, num_filter=512, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_8") # 14/14
conv_9_dw = Conv(conv_8, num_group=512, num_filter=512, kernel=(3, 3), pad=(1, 1), stride=(1, 1),
name="conv_9_dw") # 14/14
conv_9 = Conv(conv_9_dw, num_filter=512, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_9") # 14/14
conv_10_dw = Conv(conv_9, num_group=512, num_filter=512, kernel=(3, 3), pad=(1, 1), stride=(1, 1),
name="conv_10_dw") # 14/14
conv_10 = Conv(conv_10_dw, num_filter=512, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_10") # 14/14
conv_11_dw = Conv(conv_10, num_group=512, num_filter=512, kernel=(3, 3), pad=(1, 1), stride=(1, 1),
name="conv_11_dw") # 14/14
conv_11 = Conv(conv_11_dw, num_filter=512, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_11") # 14/14
conv_12_dw = Conv(conv_11, num_group=512, num_filter=512, kernel=(3, 3), pad=(1, 1), stride=(1, 1),
name="conv_12_dw") # 14/14
conv_12 = Conv(conv_12_dw, num_filter=512, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_12") # 14/14
conv_13_dw = Conv(conv_12, num_group=512, num_filter=512, kernel=(3, 3), pad=(1, 1), stride=(2, 2),
name="conv_13_dw") # 14/7
conv_13 = Conv(conv_13_dw, num_filter=1024, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_13") # 7/7
conv_14_dw = Conv(conv_13, num_group=1024, num_filter=1024, kernel=(3, 3), pad=(1, 1), stride=(1, 1),
name="conv_14_dw") # 7/7
conv_14 = Conv(conv_14_dw, num_filter=1024, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_14") # 7/7
body = conv_14
fc1 = symbol_utils.get_fc1(body, num_classes, fc_type)
return fc1
def get_symbol(num_classes=256, mode="small", **kwargs):
net = MobileNetV3(mode=mode)
data = mx.sym.Variable(name='data')
data = (data-127.5)
data = data*0.0078125
body = net(data)
import symbol_utils
body = symbol_utils.get_fc1(body, num_classes, "E")
return body
def get_symbol():
arch=config.arch
net = get_efficientnet(arch)
data = mx.sym.Variable(name='data')
data = data-127.5
data = data*0.0078125
body = net(data)
fc1 = symbol_utils.get_fc1(body, config.emb_size, config.net_output, input_channel=320)
return fc1
def get_symbol(num_classes, num_layers, **kwargs):
model = NASNetALarge(num_classes)
data = mx.sym.Variable(name='data')
data = data - 127.5
data = data * 0.0078125
body = model.features(data)
version_output = kwargs.get('version_output', 'E')
fc_type = version_output
fc1 = symbol_utils.get_fc1(body, num_classes, fc_type)
return fc1
def get_symbol(num_classes, **kwargs):
version_output = kwargs.get('version_output', 'E')
fc_type = version_output
net = MobilenetV3(num_classes, 1, 'large')
data = mx.sym.Variable(name='data')
data = data - 127.5
data = data * 0.0078125
body = net(data)
fc1 = symbol_utils.get_fc1(body, num_classes, fc_type)
return fc1
def get_symbol(num_classes, num_layers, **kwargs):
global bn_mom
bn_mom = kwargs.get('bn_mom', 0.9)
wd_mult = kwargs.get('wd_mult', 1.)
net_output = kwargs.get('net_output', 'GDC') if 'net_output' in kwargs \
else kwargs.get('version_output', 'GDC')
use_global_stats = kwargs.get('use_global_stats', False)
assert net_output=='GDC' or net_output=='GNAP'
fc_type = net_output
data = mx.symbol.Variable(name="data")
data = data-127.5
data = data*0.0078125
filter_list = [64, 64, 128, 256, 512]
if num_layers == 49:
units = [0, 4, 6, 2]
elif num_layers == 72:
units = [2, 6, 10, 2]
elif num_layers == 108:
units = [4, 8, 16, 4]
width_mult = 0.5
"""
conv_1 = Conv(data, num_filter=64, kernel=(3, 3), pad=(1, 1), stride=(2, 2), name="conv_1")
conv_2_dw = Conv(conv_1, num_group=64, num_filter=64, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_2_dw")
conv_23 = DResidul_v1(conv_2_dw, num_out=64, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=128, name="dconv_23")
conv_3 = Residual(conv_23, num_block=4, num_out=64, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=128, name="res_3")
conv_34 = DResidul_v1(conv_3, num_out=128, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=256, name="dconv_34")
conv_4 = Residual(conv_34, num_block=6, num_out=128, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=256, name="res_4")
conv_45 = DResidul_v1(conv_4, num_out=128, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=512, name="dconv_45")
conv_5 = Residual(conv_45, num_block=2, num_out=128, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=256, name="res_5")
conv_6_sep = Conv(conv_5, num_filter=512, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_6sep")
"""
conv_1 = Conv(data, num_filter=filter_list[0], kernel=(3, 3), pad=(1, 1), stride=(2, 2), name="conv_1", use_global_stats=use_global_stats)
if units[0] == 0:
conv_2 = Conv(conv_1, num_group=filter_list[1], num_filter=filter_list[1], kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_2_dw", use_global_stats=use_global_stats)
else:
conv_2 = Residual(conv_1, num_block=units[0], num_out=filter_list[1], kernel=(3, 3), stride=(1, 1), pad=(1, 1),
num_group=filter_list[1], name="res_2", use_global_stats=use_global_stats)
conv_23 = DResidual_v1(conv_2, num_out=filter_list[2], kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=filter_list[2], name="dconv_23", use_global_stats=use_global_stats)
conv_3 = Residual(conv_23, num_block=units[1], num_out=filter_list[2], kernel=(3, 3), stride=(1, 1), pad=(1, 1),
num_group=filter_list[2], name="res_3", use_global_stats=use_global_stats)
conv_34 = DResidual_v1(conv_3, num_out=filter_list[3], kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=filter_list[3], name="dconv_34", use_global_stats=use_global_stats)
conv_4 = Residual(conv_34, num_block=units[2], num_out=filter_list[3], kernel=(3, 3), stride=(1, 1), pad=(1, 1),
num_group=filter_list[3], name="res_4", use_global_stats=use_global_stats)
conv_45 = DResidual_v1(conv_4, num_out=filter_list[4], kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=filter_list[4], name="dconv_45", use_global_stats=use_global_stats)
conv_5 = Residual(conv_45, num_block=units[3], num_out=filter_list[4], kernel=(3, 3), stride=(1, 1), pad=(1, 1),
num_group=filter_list[4], name="res_5", use_global_stats=use_global_stats)
conv_6_sep = Conv(conv_5, num_filter=filter_list[4], kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_6sep", use_global_stats=use_global_stats)
fc1 = symbol_utils.get_fc1(conv_6_sep, num_classes, fc_type, use_global_stats=use_global_stats)
return fc1
def get_symbol(num_classes):
net = MobileNetV3_Small(num_classes)
data = mx.sym.Variable(name='data')
# data = tf.Tensor(data)
print(data)
data = data - 127.5
data = data * 0.0078125
# fc1 = net(data)
body = net(data)
fc1 = symbol_utils.get_fc1(body, num_classes, 'E')
return fc1
def get_symbol():
num_classes = config.emb_size
fc_type = config.net_output
mode = 'large'
data = mx.sym.Variable(name='data')
data = data - 127.5
data = data * 0.0078125
net = MobileNetV3(num_classes=num_classes, mode=mode)
body = net(data)
body = symbol_utils.get_fc1(body, num_classes, fc_type)
return body
def get_symbol(num_classes=256, **kwargs):
net = MobileNetV3(num_classes, 1)
data = mx.sym.Variable(name='data')
data = (data-127.5)
data = data*0.0078125
body = net(data)
fc_classes = kwargs.get("fc_classes", 0) # used in insightface
if fc_classes:
import symbol_utils # file in insightface/src/symbols/
body = symbol_utils.get_fc1(body, num_classes, "E")
return body
def get_symbol():
num_classes = config.emb_size
mode = config.mode
fc_type = config.net_output
net = MobileNetV3(mode=mode)
data = mx.sym.Variable(name='data')
data = (data - 127.5)
data = data * 0.0078125
body = net(data)
import symbol_utils
body = symbol_utils.get_fc1(body, num_classes, fc_type)
return body
def get_symbol():
mode = config.net_type
fc_type = config.net_output
net = MobileNetV3(mode=mode)
data = mx.sym.Variable(name='data')
data = (data - 127.5)
data = data * 0.0078125
body = net(data)
num_classes = config.emb_size # used in insightface
fc1 = symbol_utils.get_fc1(body, num_classes, fc_type, input_channel=960)
return fc1
def get_symbol():
num_layers = config.num_layers
num_init_features, growth_rate, block_config = densenet_spec[num_layers]
net = DenseNet(num_init_features,
growth_rate,
block_config,
dropout=config.densenet_dropout)
data = mx.sym.Variable(name='data')
data = data - 127.5
data = data * 0.0078125
body = net(data)
fc1 = symbol_utils.get_fc1(body, config.emb_size, config.net_output)
return fc1
def get_symbol(num_classes, num_layers, **kwargs):
filter_list = [48, 96, 192, 128, 128]
if num_layers == 9:
units = [1, 1, 1, 1, 1]
#elif num_layers == 19:
# units = [
data = mx.sym.Variable(name='data')
data = data - 127.5
data = data * 0.0078125
body = get_before_pool(data)
version_output = kwargs.get('version_output', 'E')
fc_type = version_output
fc1 = symbol_utils.get_fc1(body, num_classes, fc_type)
return fc1
def get_symbol():
emb_size = config.emb_size
fc_type = config.net_output
data = mx.sym.Variable(name='data')
data = mx.sym.identity(data=data, name='id')
data = data - 127.5
data = data * 0.0078125
net, _ = get_efficientnet('efficientnet-b-1', num_classes=emb_size)
body = net(data)
body = symbol_utils.get_fc1(body, emb_size, fc_type)
return body
def get_symbol(num_classes, num_layers, **kwargs):
global bn_mom
bn_mom = kwargs.get('bn_mom', 0.9)
wd_mult = kwargs.get('wd_mult', 1.)
version_output = kwargs.get('version_output', 'GNAP')
#assert version_output=='GDC' or version_output=='GNAP'
fc_type = version_output
growth_rate = kwargs.get('growth_rate', 32)
block_config = [3, 4, 8, 6]
bottleneck_width = [1, 2, 4, 4]
num_init_features = 32
init_kernel_size = 3
use_stem_block = True
data = mx.symbol.Variable(name="data")
data = data-127.5
data = data*0.0078125
if use_stem_block:
net = StemBlock(data, num_init_features)
else:
padding_size = init_kernel_size / 2
net = ConvBlock(data, num_filter=num_init_features, kernel=(init_kernel_size, init_kernel_size),
stride=(2, 2), pad=(padding_size, padding_size), name='conv1')
net = mx.sym.Pooling(net, kernel=(2,2), stride=(2,2), pad=(0,0), pool_type='max', name='pool1')
total_filter = num_init_features
if type(bottleneck_width) is list:
bottleneck_widths = bottleneck_width
else:
bottleneck_widths = [bottleneck_width] * 4
for idx, num_layers in enumerate(block_config):
net = DenseBlock(net, num_layers, growth_rate, bottleneck_width=bottleneck_widths[idx], name='stage{}'.format(idx+1))
total_filter += growth_rate * num_layers
if idx == len(block_config) - 1:
with_pooling = False
else:
with_pooling = True
net = TransitionBlock(net, total_filter, with_pooling=with_pooling, name='stage{}_tb'.format(idx+1))
fc1 = symbol_utils.get_fc1(net, num_classes, fc_type)
return fc1
def get_symbol():
num_classes = config.emb_size
bn_mom = config.bn_mom
workspace = config.workspace
data = mx.symbol.Variable(name="data") # 224
data = data-127.5
data = data*0.0078125
fc_type = config.net_output
bf = int(32*config.net_multiplier)
if config.net_input==0:
conv_1 = Conv(data, num_filter=bf, kernel=(3, 3), pad=(1, 1), stride=(2, 2), name="conv_1") # 224/112
else:
conv_1 = Conv(data, num_filter=bf, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_1") # 224/112
conv_2_dw = Conv(conv_1, num_group=bf, num_filter=bf, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_2_dw") # 112/112
conv_2 = Conv(conv_2_dw, num_filter=bf*2, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_2") # 112/112
conv_3_dw = Conv(conv_2, num_group=bf*2, num_filter=bf*2, kernel=(3, 3), pad=(1, 1), stride=(2, 2), name="conv_3_dw") # 112/56
conv_3 = Conv(conv_3_dw, num_filter=bf*4, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_3") # 56/56
conv_4_dw = Conv(conv_3, num_group=bf*4, num_filter=bf*4, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_4_dw") # 56/56
conv_4 = Conv(conv_4_dw, num_filter=bf*4, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_4") # 56/56
conv_5_dw = Conv(conv_4, num_group=bf*4, num_filter=bf*4, kernel=(3, 3), pad=(1, 1), stride=(2, 2), name="conv_5_dw") # 56/28
conv_5 = Conv(conv_5_dw, num_filter=bf*8, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_5") # 28/28
conv_6_dw = Conv(conv_5, num_group=bf*8, num_filter=bf*8, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_6_dw") # 28/28
conv_6 = Conv(conv_6_dw, num_filter=bf*8, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_6") # 28/28
conv_7_dw = Conv(conv_6, num_group=bf*8, num_filter=bf*8, kernel=(3, 3), pad=(1, 1), stride=(2, 2), name="conv_7_dw") # 28/14
conv_7 = Conv(conv_7_dw, num_filter=bf*16, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_7") # 14/14
conv_8_dw = Conv(conv_7, num_group=bf*16, num_filter=bf*16, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_8_dw") # 14/14
conv_8 = Conv(conv_8_dw, num_filter=bf*16, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_8") # 14/14
conv_9_dw = Conv(conv_8, num_group=bf*16, num_filter=bf*16, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_9_dw") # 14/14
conv_9 = Conv(conv_9_dw, num_filter=bf*16, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_9") # 14/14
conv_10_dw = Conv(conv_9, num_group=bf*16, num_filter=bf*16, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_10_dw") # 14/14
conv_10 = Conv(conv_10_dw, num_filter=bf*16, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_10") # 14/14
conv_11_dw = Conv(conv_10, num_group=bf*16, num_filter=bf*16, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_11_dw") # 14/14
conv_11 = Conv(conv_11_dw, num_filter=bf*16, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_11") # 14/14
conv_12_dw = Conv(conv_11, num_group=bf*16, num_filter=bf*16, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_12_dw") # 14/14
conv_12 = Conv(conv_12_dw, num_filter=bf*16, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_12") # 14/14
conv_13_dw = Conv(conv_12, num_group=bf*16, num_filter=bf*16, kernel=(3, 3), pad=(1, 1), stride=(2, 2), name="conv_13_dw") # 14/7
conv_13 = Conv(conv_13_dw, num_filter=bf*32, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_13") # 7/7
conv_14_dw = Conv(conv_13, num_group=bf*32, num_filter=bf*32, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_14_dw") # 7/7
conv_14 = Conv(conv_14_dw, num_filter=bf*32, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_14") # 7/7
body = conv_14
fc1 = symbol_utils.get_fc1(body, num_classes, fc_type)
return fc1
def get_mobilefacenet(num_classes=10):
fc_type = 'GDC'
data = mx.symbol.Variable(name="data")
# data = data-127.5
# data = data*0.0078125
conv_1 = Conv(data, num_filter=64, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_1")
conv_2_dw = Conv(conv_1, num_group=64, num_filter=64, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_2_dw")
conv_23 = DResidual(conv_2_dw, num_out=64, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=128, name="dconv_23")
conv_3 = Residual(conv_23, num_block=4, num_out=64, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=128, name="res_3")
conv_34 = DResidual(conv_3, num_out=128, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=256, name="dconv_34")
conv_4 = Residual(conv_34, num_block=6, num_out=128, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=256, name="res_4")
conv_45 = DResidual(conv_4, num_out=128, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=512, name="dconv_45")
conv_5 = Residual(conv_45, num_block=2, num_out=128, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=256, name="res_5")
conv_6_sep = Conv(conv_5, num_filter=512, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_6sep")
data = symbol_utils.get_fc1(conv_6_sep, num_classes, fc_type)
fc1 = mx.sym.SoftmaxOutput(data=data, name='softmax')
return fc1
def get_symbol2(num_classes, **kwargs):
global bn_mom
bn_mom = kwargs.get('bn_mom', 0.9)
wd_mult = kwargs.get('wd_mult', 1.)
version_output = kwargs.get('version_output', 'GNAP')
assert version_output=='GDC' or version_output=='GNAP'
fc_type = version_output
data = mx.symbol.Variable(name="data")
data = data-127.5
data = data*0.0078125
conv_1 = Conv(data, num_filter=64, kernel=(3, 3), pad=(1, 1), stride=(2, 2), name="conv_1")
conv_2_dw = Conv(conv_1, num_group=64, num_filter=64, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_2_dw")
conv_23 = DResidual(conv_2_dw, num_out=64, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=128, name="dconv_23")
conv_3 = Residual(conv_23, num_block=4, num_out=64, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=128, name="res_3")
#conv_34 = DResidual(conv_3, num_out=128, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=256, name="dconv_34")
#conv_4 = Residual(conv_34, num_block=6, num_out=128, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=256, name="res_4")
conv_45 = DResidual(conv_3, num_out=128, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=512, name="dconv_45")
conv_5 = Residual(conv_45, num_block=2, num_out=128, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=256, name="res_5")
conv_6_sep = Conv(conv_5, num_filter=512, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_6sep")
fc1 = symbol_utils.get_fc1(conv_6_sep, num_classes, fc_type)
return fc1
def get_symbol(num_classes, num_layers, **kwargs):
version_output = kwargs.get('version_output', 'E')
fc_type = version_output
data = mx.sym.Variable(name='data')
data = data - 127.5
data = data * 0.0078125
if num_layers == 50:
units = [3, 4, 6, 3]
stem_with, final_drop = 32, 0.0
elif num_layers == 101:
units = [3, 4, 23, 3]
stem_with, final_drop = 64, 0.0
elif num_layers == 200:
units = [3, 24, 36, 3]
stem_with, final_drop = 64, 0.2
elif num_layers == 269:
units = [3, 30, 48, 8]
stem_with, final_drop = 64, 0.2
net = ResNet(Bottleneck,
units,
deep_stem=True,
avg_down=True,
stem_width=stem_with,
avd=True,
avd_first=False,
use_splat=True,
dropblock_prob=0.1,
final_drop=final_drop,
name_prefix='resnest_',
face_recog=True,
input_size=112,
**kwargs)
body = net(data)
fc1 = symbol_utils.get_fc1(body, num_classes, fc_type)
return fc1
def get_symbol():
depth_multiplier = config.depth_multiplier
act_type = config.net_act
num_classes = config.emb_size
print('in_network', config)
fc_type = config.net_output
data = mx.symbol.Variable(name="data")
print("len_data: " + str(len(data)))
data = data - 127.5
data = data * 0.0078125
data = mx.sym.Convolution(data=data,
num_filter=24,
kernel=(3, 3),
stride=(2, 2),
pad=(1, 1),
no_bias=1)
data = mx.sym.BatchNorm(data=data)
data = Activation(data=data, act_type=act_type)
data = make_stage(data, 2, depth_multiplier, act_type=act_type)
data = make_stage(data, 3, depth_multiplier, act_type=act_type)
data = make_stage(data, 4, depth_multiplier, act_type=act_type)
# extra_conv
final_channels = 1024 if depth_multiplier != '2.0' else 2048
extra_conv = mx.sym.Convolution(data=data,
num_filter=final_channels,
kernel=(1, 1),
stride=(1, 1),
no_bias=1)
extra_conv = mx.sym.BatchNorm(data=extra_conv)
data = Activation(data=extra_conv, act_type=act_type)
fc1 = symbol_utils.get_fc1(data, num_classes, fc_type)
return fc1
def get_symbol():
num_classes = config.emb_size
print('in_network', config)
fc_type = config.net_output
data = mx.symbol.Variable(name="data")
data = data-127.5
data = data*0.0078125
blocks = config.net_blocks
conv_1 = Conv(data, num_filter=64, kernel=(3, 3), pad=(1, 1), stride=(2, 2), name="conv_1")
if blocks[0]==1:
conv_2_dw = Conv(conv_1, num_group=64, num_filter=64, kernel=(3, 3), pad=(1, 1), stride=(1, 1), name="conv_2_dw")
else:
conv_2_dw = Residual(conv_1, num_block=blocks[0], num_out=64, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=64, name="res_2")
conv_23 = DResidual(conv_2_dw, num_out=64, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=128, name="dconv_23")
conv_3 = Residual(conv_23, num_block=blocks[1], num_out=64, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=128, name="res_3")
conv_34 = DResidual(conv_3, num_out=128, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=256, name="dconv_34")
conv_4 = Residual(conv_34, num_block=blocks[2], num_out=128, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=256, name="res_4")
conv_45 = DResidual(conv_4, num_out=128, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=512, name="dconv_45")
conv_5 = Residual(conv_45, num_block=blocks[3], num_out=128, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=256, name="res_5")
conv_6_sep = Conv(conv_5, num_filter=512, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name="conv_6sep")
fc1 = symbol_utils.get_fc1(conv_6_sep, num_classes, fc_type)
return fc1
def get_shufflenet_v2(num_classes=10):
depth_multiplier = 1.0 # levels of complexities
act_type = 'relu'
fc_type = 'GDC'
data = mx.symbol.Variable(name="data")
# data = data-127.5
# data = data*0.0078125
data = mx.sym.Convolution(data=data,
num_filter=24,
kernel=(3, 3),
stride=(1, 1),
pad=(1, 1))
# the input size 224x224 --> 112x112, delete this pooling layer
# data = mx.sym.Pooling(data=data, kernel=(3, 3), pool_type='max',
# stride=(2, 2), pad=(1, 1))
data = make_stage(data, 2, depth_multiplier, act_type)
data = make_stage(data, 3, depth_multiplier, act_type)
data = make_stage(data, 4, depth_multiplier, act_type)
final_channels = 1024 if depth_multiplier != '2.0' else 2048
data = mx.sym.Convolution(data=data,
num_filter=final_channels,
kernel=(1, 1),
stride=(1, 1))
# global average pooling
# data = mx.sym.Pooling(data=data, kernel=(1, 1), global_pool=True, pool_type='avg')
# data = mx.sym.flatten(data=data)
# data = mx.sym.FullyConnected(data=data, num_hidden=num_classes)
# fc1 = mx.sym.SoftmaxOutput(data=data, name='softmax')
data = symbol_utils.get_fc1(data, num_classes, fc_type)
fc1 = mx.sym.SoftmaxOutput(data=data, name='softmax')
return fc1
def get_symbol(num_classes=1000, **kwargs):
# input shape 229*229*3 (old)
# input shape 224*224*3 (new)
#filter_list=[64, 128, 256, 728, 1024, 1536, 2048] # original version
filter_list=[64, 64, 128, 364, 512, 768, 1024] # smaller one
# Entry flow
data = mx.sym.Variable('data')
data = data-127.5
data = data*0.0078125
version_input = kwargs.get('version_input',1)
assert version_input>=0
version_output = kwargs.get('version_output', 'E')
fc_type = version_output
version_unit = kwargs.get('version_unit', 3)
print(version_input, version_output, version_unit)
if version_input>=2:
filter_list=[64, 128, 256, 728, 1024, 1536, 2048] # original version
# block 1
if version_input==0:
block1 = Conv(data=data, num_filter=int(filter_list[0]*0.5), kernel=(3, 3), stride=(2, 2), pad=(1, 1), name='Entry_flow_b1_conv1',
withRelu=True, withBn=True, bn_mom=0.9, workspace=256)
else:
block1 = Conv(data=data, num_filter=int(filter_list[0]*0.5), kernel=(3, 3), stride=(1,1), pad=(1, 1), name='Entry_flow_b1_conv1',
withRelu=True, withBn=True, bn_mom=0.9, workspace=256)
block1 = Conv(data=block1, num_filter=filter_list[0], kernel=(3, 3), pad=(1, 1), name='Entry_flow_b1_conv2',
withRelu=True, withBn=True, bn_mom=0.9, workspace=256)
# block 2
rs2 = Conv(data=block1, num_filter=filter_list[1], stride=(2, 2), name='Entry_flow_b2_conv1',
withBn=True, bn_mom=0.9, workspace=256)
block2 = Separable_Conv(block1, num_in_channel=filter_list[0], num_out_channel=filter_list[1], name='Entry_flow_b2_sepconv1', withBn=True, bn_mom=0.9, workspace=256)
block2 = mx.sym.Activation(data=block2, act_type='relu', name='Entry_flow_b2_sepconv1_relu')
block2 = Separable_Conv(block2, num_in_channel=filter_list[1], num_out_channel=filter_list[1], name='Entry_flow_b2_sepconv2', withBn=True, bn_mom=0.9, workspace=256)
block2 = mx.sym.Pooling(data=block2, kernel=(3, 3), stride=(2, 2), pad=(1, 1), pool_type='max', name='Entry_flow_b2_pool')
block2 = block2 + rs2
# block 3
rs3 = Conv(data=block2, num_filter=filter_list[2], stride=(2, 2), name='Entry_flow_b3_conv1',
withBn=True, bn_mom=0.9, workspace=256)
block3 = mx.sym.Activation(data=block2, act_type='relu', name='Entry_flow_b3_sepconv1_relu')
block3 = Separable_Conv(block3, num_in_channel=filter_list[1], num_out_channel=filter_list[2], name='Entry_flow_b3_sepconv1', withBn=True, bn_mom=0.9, workspace=256)
block3 = mx.sym.Activation(data=block3, act_type='relu', name='Entry_flow_b3_sepconv2_relu')
block3 = Separable_Conv(block3, num_in_channel=filter_list[2], num_out_channel=filter_list[2], name='Entry_flow_b3_sepconv2', withBn=True, bn_mom=0.9, workspace=256)
block3 = mx.sym.Pooling(data=block3, kernel=(3, 3), stride=(2, 2), pad=(1, 1), pool_type='max', name='Entry_flow_b3_pool')
block3 = block3 + rs3
# block 4
rs4 = Conv(data=block3, num_filter=filter_list[3], stride=(2, 2), name='Entry_flow_b4_conv1',
withBn=True, bn_mom=0.9, workspace=256)
block4 = mx.sym.Activation(data=block3, act_type='relu', name='Entry_flow_b4_sepconv1_relu')
block4 = Separable_Conv(block4, num_in_channel=filter_list[2], num_out_channel=filter_list[3], name='Entry_flow_b4_sepconv1', withBn=True, bn_mom=0.9, workspace=256)
block4 = mx.sym.Activation(data=block4, act_type='relu', name='Entry_flow_b4_sepconv2_relu')
block4 = Separable_Conv(block4, num_in_channel=filter_list[3], num_out_channel=filter_list[3], name='Entry_flow_b4_sepconv2', withBn=True, bn_mom=0.9, workspace=256)
block4 = mx.sym.Pooling(data=block4, kernel=(3, 3), stride=(2, 2), pad=(1, 1), pool_type='max', name='Entry_flow_b4_pool')
block4 = block4 + rs4
# Middle flow
block_m_f = Circle_Middle('Middle_flow', block4,
filter_list[3],
0.9,
8)
# Exit flow
rs5 = Conv(data=block_m_f, num_filter=filter_list[4], stride=(2, 2), name='Exit_flow_b5_conv1',
withBn=True, bn_mom=0.9, workspace=256)
block5 = mx.sym.Activation(data=block_m_f, act_type='relu', name='Exit_flow_b5_sepconv1_relu')
block5 = Separable_Conv(block5, num_in_channel=filter_list[3], num_out_channel=filter_list[3], name='Exit_flow_b5_sepconv1', withBn=True, bn_mom=0.9, workspace=256)
block5 = mx.sym.Activation(data=block5, act_type='relu', name='Exit_flow_b5_sepconv2_relu')
block5 = Separable_Conv(block5, num_in_channel=filter_list[3], num_out_channel=filter_list[4], name='Exit_flow_b5_sepconv2', withBn=True, bn_mom=0.9, workspace=256)
block5 = mx.sym.Pooling(data=block5, kernel=(3, 3), stride=(2, 2), pad=(1, 1), pool_type='max', name='Entry_flow_b5_pool')
block5 = block5 + rs5
block6 = Separable_Conv(block5, num_in_channel=filter_list[4], num_out_channel=filter_list[5], name='Exit_flow_b6_sepconv1', withBn=True, bn_mom=0.9, workspace=256)
block6 = mx.sym.Activation(data=block6, act_type='relu', name='Exit_flow_b6_sepconv1_relu')
block6 = Separable_Conv(block6, num_in_channel=filter_list[5], num_out_channel=filter_list[6], name='Exit_flow_b6_sepconv2', withBn=True, bn_mom=0.9, workspace=256)
block6 = mx.sym.Activation(data=block6, act_type='relu', name='Exit_flow_b6_sepconv2_relu')
fc1 = symbol_utils.get_fc1(block6, num_classes, fc_type)
return fc1
def get_symbol(num_classes = 1000, num_layers=92, **kwargs):
if num_layers==68:
k_R = 128
G = 32
k_sec = { 2: 3, \
3: 4, \
4: 12, \
5: 3 }
inc_sec= { 2: 16, \
3: 32, \
4: 32, \
5: 64 }
elif num_layers==92:
k_R = 96
G = 32
k_sec = { 2: 3, \
3: 4, \
4: 20, \
5: 3 }
inc_sec= { 2: 16, \
3: 32, \
4: 24, \
5: 128 }
elif num_layers==107:
k_R = 200
G = 50
k_sec = { 2: 4, \
3: 8, \
4: 20, \
5: 3 }
inc_sec= { 2: 20, \
3: 64, \
4: 64, \
5: 128 }
elif num_layers==131:
k_R = 160
G = 40
k_sec = { 2: 4, \
3: 8, \
4: 28, \
5: 3 }
inc_sec= { 2: 16, \
3: 32, \
4: 32, \
5: 128 }
else:
raise ValueError("no experiments done on dpn num_layers {}, you can do it yourself".format(num_layers))
version_se = kwargs.get('version_se', 1)
version_input = kwargs.get('version_input', 1)
assert version_input>=0
version_output = kwargs.get('version_output', 'E')
fc_type = version_output
version_unit = kwargs.get('version_unit', 3)
print(version_se, version_input, version_output, version_unit)
## define Dual Path Network
data = mx.symbol.Variable(name="data")
#data = data-127.5
#data = data*0.0078125
#if version_input==0:
# conv1_x_1 = Conv(data=data, num_filter=128, kernel=(7, 7), name='conv1_x_1', pad=(3,3), stride=(2,2))
#else:
# conv1_x_1 = Conv(data=data, num_filter=128, kernel=(3, 3), name='conv1_x_1', pad=(3,3), stride=(1,1))
#conv1_x_1 = BN_AC(conv1_x_1, name='conv1_x_1__relu-sp')
#conv1_x_x = mx.symbol.Pooling(data=conv1_x_1, pool_type="max", kernel=(3, 3), pad=(1,1), stride=(2,2), name="pool1")
conv1_x_x = symbol_utils.get_head(data, version_input, 128)
# conv2
bw = 256
inc= inc_sec[2]
R = (k_R*bw)/256
conv2_x_x = DualPathFactory( conv1_x_x, R, R, bw, 'conv2_x__1', inc, G, 'proj' )
for i_ly in range(2, k_sec[2]+1):
conv2_x_x = DualPathFactory( conv2_x_x, R, R, bw, ('conv2_x__%d'% i_ly), inc, G, 'normal')
# conv3
bw = 512
inc= inc_sec[3]
R = (k_R*bw)/256
conv3_x_x = DualPathFactory( conv2_x_x, R, R, bw, 'conv3_x__1', inc, G, 'down' )
for i_ly in range(2, k_sec[3]+1):
conv3_x_x = DualPathFactory( conv3_x_x, R, R, bw, ('conv3_x__%d'% i_ly), inc, G, 'normal')
# conv4
bw = 1024
inc= inc_sec[4]
R = (k_R*bw)/256
conv4_x_x = DualPathFactory( conv3_x_x, R, R, bw, 'conv4_x__1', inc, G, 'down' )
for i_ly in range(2, k_sec[4]+1):
conv4_x_x = DualPathFactory( conv4_x_x, R, R, bw, ('conv4_x__%d'% i_ly), inc, G, 'normal')
# conv5
bw = 2048
inc= inc_sec[5]
R = (k_R*bw)/256
conv5_x_x = DualPathFactory( conv4_x_x, R, R, bw, 'conv5_x__1', inc, G, 'down' )
for i_ly in range(2, k_sec[5]+1):
conv5_x_x = DualPathFactory( conv5_x_x, R, R, bw, ('conv5_x__%d'% i_ly), inc, G, 'normal')
# output: concat
conv5_x_x = mx.symbol.Concat(*[conv5_x_x[0], conv5_x_x[1]], name='conv5_x_x_cat-final')
#conv5_x_x = BN_AC(conv5_x_x, name='conv5_x_x__relu-sp')
before_pool = conv5_x_x
fc1 = symbol_utils.get_fc1(before_pool, num_classes, fc_type)
return fc1
def get_symbol(num_classes, num_layers, **kwargs):
"""Return DenseNet symbol of imagenet
Parameters
----------
units : list
Number of units in each stage
num_stage : int
Number of stage
growth_rate : int
Number of output channels
num_class : int
Ouput size of symbol
data_type : str
the type of dataset
reduction : float
Compression ratio. Default = 0.5
drop_out : float
Probability of an element to be zeroed. Default = 0.2
workspace : int
Workspace used in convolution operator
"""
version_input = kwargs.get('version_input', 1)
assert version_input>=0
version_output = kwargs.get('version_output', 'E')
fc_type = version_output
version_unit = kwargs.get('version_unit', 3)
print(version_input, version_output, version_unit)
num_stage = 4
reduction = 0.5
drop_out = 0.2
bottle_neck = True
bn_mom = 0.9
workspace = 256
growth_rate = 32
if num_layers == 121:
units = [6, 12, 24, 16]
elif num_layers == 169:
units = [6, 12, 32, 32]
elif num_layers == 201:
units = [6, 12, 48, 32]
elif num_layers == 161:
units = [6, 12, 36, 24]
growth_rate = 48
else:
raise ValueError("no experiments done on num_layers {}, you can do it yourself".format(num_layers))
num_unit = len(units)
assert(num_unit == num_stage)
init_channels = 2 * growth_rate
n_channels = init_channels
data = mx.sym.Variable(name='data')
#data = data-127.5
#data = data*0.0078125
#if version_input==0:
# body = mx.sym.Convolution(data=data, num_filter=growth_rate*2, kernel=(7, 7), stride=(2,2), pad=(3, 3),
# no_bias=True, name="conv0", workspace=workspace)
#else:
# body = mx.sym.Convolution(data=data, num_filter=growth_rate*2, kernel=(3,3), stride=(1,1), pad=(1,1),
# no_bias=True, name="conv0", workspace=workspace)
#body = mx.sym.BatchNorm(data=body, fix_gamma=False, eps=2e-5, momentum=bn_mom, name='bn0')
#body = mx.sym.Activation(data=body, act_type='relu', name='relu0')
#body = mx.symbol.Pooling(data=body, kernel=(3, 3), stride=(2,2), pad=(1,1), pool_type='max')
body = symbol_utils.get_head(data, version_input, growth_rate*2)
for i in range(num_stage-1):
body = DenseBlock(units[i], body, growth_rate=growth_rate, name='DBstage%d' % (i + 1), bottle_neck=bottle_neck, drop_out=drop_out, bn_mom=bn_mom, workspace=workspace)
n_channels += units[i]*growth_rate
n_channels = int(math.floor(n_channels*reduction))
body = TransitionBlock(i, body, n_channels, stride=(1,1), name='TBstage%d' % (i + 1), drop_out=drop_out, bn_mom=bn_mom, workspace=workspace)
body = DenseBlock(units[num_stage-1], body, growth_rate=growth_rate, name='DBstage%d' % (num_stage), bottle_neck=bottle_neck, drop_out=drop_out, bn_mom=bn_mom, workspace=workspace)
fc1 = symbol_utils.get_fc1(body, num_classes, fc_type)
return fc1
def get_symbol(num_classes=1000, **kwargs):
data = mx.symbol.Variable(name='data')
data = data-127.5
data = data*0.0078125
version_input = kwargs.get('version_input', 1)
assert version_input>=0
version_output = kwargs.get('version_output', 'E')
fc_type = version_output
version_unit = kwargs.get('version_unit', 3)
print(version_input, version_output, version_unit)
if version_input==0:
conv1a_3_3 = ConvFactory(data=data, num_filter=32,
kernel=(3, 3), stride=(2, 2))
else:
conv1a_3_3 = ConvFactory(data=data, num_filter=32,
kernel=(3, 3), stride=(1, 1))
conv2a_3_3 = ConvFactory(conv1a_3_3, 32, (3, 3))
conv2b_3_3 = ConvFactory(conv2a_3_3, 64, (3, 3), pad=(1, 1))
maxpool3a_3_3 = mx.symbol.Pooling(
data=conv2b_3_3, kernel=(3, 3), stride=(2, 2), pool_type='max')
conv3b_1_1 = ConvFactory(conv2b_3_3, 80, (1, 1))
conv4a_3_3 = ConvFactory(conv3b_1_1, 192, (3, 3))
maxpool5a_3_3 = mx.symbol.Pooling(
data=conv4a_3_3, kernel=(3, 3), stride=(2, 2), pool_type='max')
tower_conv = ConvFactory(maxpool5a_3_3, 96, (1, 1))
tower_conv1_0 = ConvFactory(maxpool5a_3_3, 48, (1, 1))
tower_conv1_1 = ConvFactory(tower_conv1_0, 64, (5, 5), pad=(2, 2))
tower_conv2_0 = ConvFactory(maxpool5a_3_3, 64, (1, 1))
tower_conv2_1 = ConvFactory(tower_conv2_0, 96, (3, 3), pad=(1, 1))
tower_conv2_2 = ConvFactory(tower_conv2_1, 96, (3, 3), pad=(1, 1))
tower_pool3_0 = mx.symbol.Pooling(data=maxpool5a_3_3, kernel=(
3, 3), stride=(1, 1), pad=(1, 1), pool_type='avg')
tower_conv3_1 = ConvFactory(tower_pool3_0, 64, (1, 1))
tower_5b_out = mx.symbol.Concat(
*[tower_conv, tower_conv1_1, tower_conv2_2, tower_conv3_1])
net = repeat(tower_5b_out, 10, block35, scale=0.17, input_num_channels=320)
tower_conv = ConvFactory(net, 384, (3, 3), stride=(2, 2))
tower_conv1_0 = ConvFactory(net, 256, (1, 1))
tower_conv1_1 = ConvFactory(tower_conv1_0, 256, (3, 3), pad=(1, 1))
tower_conv1_2 = ConvFactory(tower_conv1_1, 384, (3, 3), stride=(2, 2))
tower_pool = mx.symbol.Pooling(net, kernel=(
3, 3), stride=(2, 2), pool_type='max')
net = mx.symbol.Concat(*[tower_conv, tower_conv1_2, tower_pool])
net = repeat(net, 20, block17, scale=0.1, input_num_channels=1088)
tower_conv = ConvFactory(net, 256, (1, 1))
tower_conv0_1 = ConvFactory(tower_conv, 384, (3, 3), stride=(2, 2))
tower_conv1 = ConvFactory(net, 256, (1, 1))
tower_conv1_1 = ConvFactory(tower_conv1, 288, (3, 3), stride=(2, 2))
tower_conv2 = ConvFactory(net, 256, (1, 1))
tower_conv2_1 = ConvFactory(tower_conv2, 288, (3, 3), pad=(1, 1))
tower_conv2_2 = ConvFactory(tower_conv2_1, 320, (3, 3), stride=(2, 2))
tower_pool = mx.symbol.Pooling(net, kernel=(
3, 3), stride=(2, 2), pool_type='max')
net = mx.symbol.Concat(
*[tower_conv0_1, tower_conv1_1, tower_conv2_2, tower_pool])
net = repeat(net, 9, block8, scale=0.2, input_num_channels=2080)
net = block8(net, with_act=False, input_num_channels=2080)
net = ConvFactory(data = net, num_filter=1536, kernel=(1, 1))
body = net
fc1 = symbol_utils.get_fc1(body, num_classes, fc_type)
return fc1
