def sample_fbnet_se(theta_path, feature_dim=192, data=None, prefix='fbnet'):
if len(prefix) > 0:
prefix += '_'
if data is None:
data = mx.symbol.Variable(name="data")
with open(theta_path, 'r') as f:
lines = f.readlines()
_unistage = 4
tbs_idx = 0
_n = [3, 4, 6, 3]
_f = [64, 256, 512, 1024, 2048]
_bottle_neck = [1, 1, 0, 0, 0]
_se = [0, 0, 0, 1, 0]
_kernel = [3, 3, 3, 3, 3]
_group = [1, 2, 1, 1, 2]
_block_size = len(_group)
# data = mx.sym.BatchNorm(data=data, fix_gamma=False, eps=2e-5,
# momentum=0.9, name=prefix+'bn0')
data = mx.sym.Convolution(data=data,
num_filter=_f[0],
kernel=(3, 3),
stride=(1, 1),
pad=(3, 3),
no_bias=True,
name=prefix + "conv0")
data = mx.sym.BatchNorm(data=data,
fix_gamma=False,
eps=2e-5,
momentum=0.9,
name=prefix + 'bn1')
data = mx.sym.Activation(data=data, act_type='relu', name=prefix + 'relu0')
data = mx.symbol.Pooling(data=data,
kernel=(3, 3),
stride=(2, 2),
pad=(1, 1),
pool_type='max')
for b_index in range(_unistage):
num_layers = _n[b_index]
num_filter = _f[b_index + 1]
for l_index in range(num_layers):
if l_index == 0:
stride = 2
dim_match = False
else:
stride = 1
dim_match = True
line = lines[tbs_idx]
theta = [float(tmp) for tmp in line.strip().split(' ')[1:]]
i_index = np.argmax(theta)
tbs_idx += 1
if b_index >= 3 and l_index >= 1 and i_index == _block_size: # deformable_Conv part
prefix = "layer_%d_%d_block_defConv" % (b_index, l_index)
data = block_factory_se(input_symbol=data,
name=prefix,
num_filter=num_filter,
group=1,
stride=1,
se=0,
k_size=3,
type='deform_conv')
else:
type = 'bottle_neck' if i_index <= 1 else 'resnet'
prefix = "layer_%s_%d_%d_block_%d" % (type, b_index, l_index,
i_index)
group = _group[i_index]
kernel_size = _kernel[i_index]
se = _se[i_index]
data = block_factory_se(input_symbol=data,
name=prefix,
num_filter=num_filter,
group=group,
stride=stride,
se=se,
k_size=kernel_size,
type=type,
dim_match=dim_match)
# avg pool part
data = mx.symbol.Pooling(data=data,
global_pool=True,
kernel=(7, 7),
pool_type='avg',
name=prefix + "global_pool")
data = mx.symbol.Flatten(data=data, name=prefix + 'flat_pool')
data = mx.symbol.FullyConnected(data=data, num_hidden=feature_dim)
def _build_Se(self):
"""Build symbol.
"""
self._logger.info("Build symbol")
data = self._data
data = mx.sym.Convolution(data=data, num_filter=self._f[0], kernel=(3, 3), stride=(1, 1), pad=(1, 1),no_bias=True, name="conv0")
data = mx.sym.BatchNorm(data=data, fix_gamma=False, eps=2e-5, momentum=0.9, name= 'bn0')
data = mx.sym.Activation(data=data, act_type='relu', name='relu0')
data = mx.symbol.Pooling(data=data, kernel=(3, 3), stride=(2, 2), pad=(1, 1), pool_type='max', name='pool0',
pooling_convention='full')
for b_index in range(self._unistage):
num_layers = self._n[b_index]
num_filter = self._f[b_index+ 1]
for l_index in range(num_layers):
tmp_name = "layer_%d_%d_%s" % (b_index, l_index,self._theta_unique_name)
tmp_gumbel_name = "layer_%d_%d_%s" % (b_index, l_index, "gumbel_random")
self._theta_name.append(tmp_name)
if b_index != 0 and l_index ==0:
stride =2
else:
stride =1
dim_match = False if l_index == 0 else True
block_list = []
for i_index in range(self._block_size):
type = 'bottle_neck' if i_index<=1 else 'resnet'
prefix = "layer_%s_%d_%d_block_%d" % (type,b_index, l_index, i_index)
#self._logger.info('layer_params %s'%prefix)
group = self._group[i_index]
kernel_size = self._kernel[i_index]
se = self._se[i_index]
block_out = block_factory_se(input_symbol = data,name= prefix,num_filter=num_filter,group=group,stride=stride,
se= se,k_size= kernel_size,type = type,dim_match= dim_match)
block_out = mx.sym.expand_dims(block_out, axis=1)
block_list.append(block_out)
# TODO deformable_Conv part
if b_index>=3 and l_index>=1:
prefix = "layer_%d_%d_block_defConv" % (b_index, l_index)
self._logger.warn("name %s "%prefix)
theta_var = mx.sym.var(tmp_name, shape=(self._block_size + 1,))
gumbel_var = mx.sym.var(tmp_gumbel_name, shape=(self._block_size + 1,))
self._input_shapes[tmp_name] = (self._block_size + 1,)
self._input_shapes[tmp_gumbel_name] = (self._block_size + 1,)
# TODO
block_out = block_factory_se(input_symbol=data, name=prefix, num_filter=num_filter, group=1,
stride=2,se=1, k_size=3, type='deform_conv')
block_out = mx.sym.expand_dims(block_out, axis=1)
block_list.append(block_out)
self._m_size.append(self._block_size+1)
else:
theta_var = mx.sym.var(tmp_name, shape=(self._block_size,))
gumbel_var = mx.sym.var(tmp_gumbel_name, shape=(self._block_size,))
self._m_size.append(self._block_size )
self._input_shapes[tmp_name] = (self._block_size ,)
self._input_shapes[tmp_gumbel_name] = (self._block_size ,)
self._theta_vars.append(theta_var)
self._gumbel_vars.append(gumbel_var)
self._gumbel_var_names.append([tmp_gumbel_name, self._m_size[-1]])
theta = mx.sym.broadcast_div(mx.sym.elemwise_add(theta_var, gumbel_var), self._temperature)
m = mx.sym.repeat(mx.sym.reshape(mx.sym.softmax(theta), (1, -1)),
repeats=self._dev_batch_size, axis=0)
self._m.append(m)
m = mx.sym.reshape(m, (-2, 1, 1, 1))
# TODO why stack wrong
data = mx.sym.concat(*block_list, dim=1, name="layer_%d_%d_concat" % (b_index, l_index))
data = mx.sym.broadcast_mul(data, m)
data = mx.sym.sum(data, axis=1)
# avg pool part
data = mx.symbol.Pooling(data=data, global_pool=True,
kernel=(7, 7), pool_type='avg', name="global_pool")
data = mx.symbol.Flatten(data=data, name='flat_pool')
data = mx.symbol.FullyConnected(data=data, num_hidden=self._feature_dim)
# fc part
if self._model_type == 'softmax':
data = mx.symbol.FullyConnected(name="output_fc",
data=data, num_hidden=self._output_dim)
elif self._model_type == 'amsoftmax':
s = 30.0
margin = 0.3
data = mx.symbol.L2Normalization(data, mode='instance', eps=1e-8) * s
w = mx.sym.Variable('fc_weight', init=mx.init.Xavier(magnitude=2),
shape=(self._output_dim, self._feature_dim), dtype=np.float32)
norm_w = mx.symbol.L2Normalization(w, mode='instance', eps=1e-8)
data = mx.symbol.AmSoftmax(data, weight=norm_w, num_hidden=self._output_dim,
lower_class_idx=0, upper_class_idx=self._output_dim,
verbose=False, margin=margin, s=s,
label=self._label_index)
elif self._model_type == 'arcface':
s = 64.0
margin = 0.5
data = mx.symbol.L2Normalization(data, mode='instance', eps=1e-8) * s
w = mx.sym.Variable('fc_weight', init=mx.init.Xavier(magnitude=2),
shape=(self._output_dim, self._feature_dim), dtype=np.float32)
norm_w = mx.symbol.L2Normalization(w, mode='instance', eps=1e-8)
data = mx.symbol.Arcface(data, weight=norm_w, num_hidden=self._output_dim,
lower_class_idx=0, upper_class_idx=self._output_dim,
verbose=False, margin=margin, s=s,
label=self._label_index)
self._output = data
def speed_test_se(input_shape,
stride,
num_filter,
dim_match=False,
deform_conv=False,
ctx=mx.gpu(1)):
data = mx.sym.var('data')
block_list = []
group_list = []
se_list = []
for block_idx in range(len(_g)):
kernel_size = _k[block_idx]
group = _g[block_idx]
se = _se[block_idx]
stride = stride
prefix = "block_%d" % block_idx
type = 'bottle_neck' if block_idx <= 1 else 'resnet'
block_out = block_factory_se(input_symbol=data,
name=prefix,
num_filter=num_filter,
group=group,
stride=stride,
se=se,
k_size=kernel_size,
type=type,
dim_match=dim_match)
block_out = mx.sym.expand_dims(block_out, axis=1)
block_list.append(block_out)
group_list.append(group)
se_list.append(se)
if deform_conv: # deform_conv
prefix = "block_deformable_2"
block_out = block_factory_se(input_symbol=data,
name=prefix,
num_filter=num_filter,
group=1,
stride=1,
se=0,
k_size=3,
type='deform_conv',
dim_match=dim_match)
block_out = mx.sym.expand_dims(block_out, axis=1)
block_list.append(block_out)
group_list.append(prefix)
se_list.append("se")
speed_list = []
for i, sym in enumerate(block_list):
mod = mx.mod.Module(symbol=sym,
context=[ctx],
data_names=['data'],
label_names=None)
mod.bind(data_shapes=[['data', (1, ) + input_shape]],
for_training=False)
mod.init_params(initializer=mx.init.Xavier(rnd_type='gaussian',
factor_type="out",
magnitude=2),
allow_missing=True,
allow_extra=True)
data = mx.nd.random.normal(shape=(1, ) + input_shape, ctx=ctx)
_dataiter = mx.io.NDArrayIter(data={'data': data}, batch_size=1)
tmp_data = _dataiter.next()
mod.forward(tmp_data)
mod.get_outputs()[0].asnumpy()
# tic
start = time.time()
for _ in range(times):
mod.forward(tmp_data)
y = mod.get_outputs()
y[0].asnumpy()
# toe
end = time.time()
speed = 1.0 * (end - start) / times * 1000
speed_list.append(speed)
msg = "Block[%d] group %s se %s speed %f" % (i, group_list[i],
se_list[i], speed)
print(msg)
print(' '.join([str(t) for t in speed_list]))
def _Sample(self,theat_filepath,train_iter,val_iter):
self._logger.info("Sample symbol")
data = self._data
data = mx.sym.Convolution(data=data, num_filter=self._f[0], kernel=(3, 3), stride=(1, 1), pad=(1, 1),no_bias=True, name="conv0")
data = mx.sym.BatchNorm(data=data, fix_gamma=False, eps=2e-5, momentum=0.9, name= 'bn0')
data = mx.sym.Activation(data=data, act_type='relu', name='relu0')
data = mx.symbol.Pooling(data=data, kernel=(3, 3), stride=(2, 2), pad=(1, 1), pool_type='max', name='pool0',
pooling_convention='full')
f_index = 0
for b_index in range(self._unistage):
num_layers = self._n[b_index]
num_filter = self._f[b_index+ 1]
for l_index in range(num_layers):
if b_index != 0 and l_index ==0:
stride =2
else:
stride =1
dim_match = False if l_index == 0 else True
with open(theat_filepath) as f:
theta_result = f.readlines()
i_index = np.argmax(theta_result[f_index].strip().split(' ')[1:])
type = 'bottle_neck' if i_index<=1 else 'resnet'
prefix = "layer_%s_%d_%d_block_0" % (type,b_index, l_index)
group = self._group[i_index]
kernel_size = self._kernel[i_index]
se = self._se[i_index]
if i_index<=4:
data = block_factory_se(input_symbol = data,name= prefix,num_filter=num_filter,group=group,stride=stride,
se= se,k_size= kernel_size,type = type,dim_match= dim_match)
# TODO deformable_Conv part
else:
data = block_factory_se(input_symbol=data, name=prefix, num_filter=num_filter, group=1,
stride=2,se=1, k_size=3, type='deform_conv')
f_index+=1
if b_index>=3 and l_index>=1:
pass
data = mx.symbol.Pooling(data=data, global_pool=True,
kernel=(7, 7), pool_type='avg', name="global_pool")
data = mx.symbol.Flatten(data=data, name='flat_pool')
data = mx.symbol.FullyConnected(data=data, num_hidden=self._feature_dim)
# fc part
if self._model_type == 'softmax':
data = mx.symbol.FullyConnected(name="output_fc",
data=data, num_hidden=self._output_dim)
elif self._model_type == 'amsoftmax':
s = 30.0
margin = 0.3
data = mx.symbol.L2Normalization(data, mode='instance', eps=1e-8) * s
w = mx.sym.Variable('fc_weight', init=mx.init.Xavier(magnitude=2),
shape=(self._output_dim, self._feature_dim), dtype=np.float32)
norm_w = mx.symbol.L2Normalization(w, mode='instance', eps=1e-8)
data = mx.symbol.AmSoftmax(data, weight=norm_w, num_hidden=self._output_dim,
lower_class_idx=0, upper_class_idx=self._output_dim,
verbose=False, margin=margin, s=s,
label=self._label_index)
elif self._model_type == 'arcface':
s = 64.0
margin = 0.5
data = mx.symbol.L2Normalization(data, mode='instance', eps=1e-8) * s
w = mx.sym.Variable('fc_weight', init=mx.init.Xavier(magnitude=2),
shape=(self._output_dim, self._feature_dim), dtype=np.float32)
norm_w = mx.symbol.L2Normalization(w, mode='instance', eps=1e-8)
data = mx.symbol.Arcface(data, weight=norm_w, num_hidden=self._output_dim,
lower_class_idx=0, upper_class_idx=self._output_dim,
verbose=False, margin=margin, s=s,
label=self._label_index)
self._output = data
self._fbnet_model = mx.mod.Module(symbol=self._output, context=mx.cpu())
self._fbnet_model.fit(train_iter, eval_data=val_iter,
optimizer='sgd',
optimizer_params={'learning_rate': 0.08,
'wd':0.0005},
eval_metric='acc',
batch_end_callback=mx.callback.Speedometer(100, 100),
num_epoch=10)
# Using Test_Iter test acc
acc = mx.metric.Accuracy()
self._fbnet_model .score(val_iter, acc)
print(acc)