def _normalize_sequence(length, inputs, layout, merge, in_layout=None):
assert inputs is not None, \
"unroll(inputs=None) has been deprecated. " \
"Please create input variables outside unroll."
axis = layout.find('T')
in_axis = in_layout.find('T') if in_layout is not None else axis
if isinstance(inputs, symbol.Symbol):
if merge is False:
assert len(inputs.list_outputs()) == 1, \
"unroll doesn't allow grouped symbol as input. Please convert " \
"to list with list(inputs) first or let unroll handle splitting."
inputs = list(
symbol.split(inputs,
axis=in_axis,
num_outputs=length,
squeeze_axis=1))
else:
assert length is None or len(inputs) == length
if merge is True:
inputs = [symbol.expand_dims(i, axis=axis) for i in inputs]
inputs = symbol.Concat(*inputs, dim=axis)
in_axis = axis
if isinstance(inputs, symbol.Symbol) and axis != in_axis:
inputs = symbol.swapaxes(inputs, dim0=axis, dim1=in_axis)
return inputs, axis
def _fire_layer(
self,
name: str,
inputs: sym.Variable,
s1x1: int,
e1x1: int,
e3x3: int):
"""Fire layer constructor. Written by Bichen Wu from UC Berkeley.
Args:
layer_name: layer name
inputs: input tensor
s1x1: number of 1x1 filters in squeeze layer.
e1x1: number of 1x1 filters in expand layer.
e3x3: number of 3x3 filters in expand layer.
freeze: if true, do not train parameters in this layer.
Returns:
fire layer operation.
"""
sq1x1 = sym.Convolution(
inputs, name=name+'/s1x1', num_filter=s1x1, kernel=(1, 1), stride=(1, 1))
relu1 = sym.Activation(sq1x1, act_type='relu')
ex1x1 = sym.Convolution(
relu1, name=name+'/e1x1', num_filter=e1x1, kernel=(1, 1), stride=(1, 1))
relu2 = sym.Activation(ex1x1, act_type='relu')
ex3x3 = sym.Convolution(
relu1, name=name+'/e3x3', num_filter=e3x3, kernel=(3, 3), stride=(1, 1), pad=(1, 1))
relu3 = sym.Activation(ex3x3, act_type='relu')
return sym.Concat(relu2, relu3, dim=1, name=name+'/concat')
def unroll(self, length, inputs, begin_state=None, layout='NTC', merge_outputs=None):
self.reset()
inputs, axis = _normalize_sequence(length, inputs, layout, False)
if begin_state is None:
begin_state = self.begin_state()
states = begin_state
l_cell, r_cell = self._cells
l_outputs, l_states = l_cell.unroll(length, inputs=inputs,
begin_state=states[:len(l_cell.state_info)],
layout=layout, merge_outputs=merge_outputs)
r_outputs, r_states = r_cell.unroll(length,
inputs=list(reversed(inputs)),
begin_state=states[len(l_cell.state_info):],
layout=layout, merge_outputs=merge_outputs)
if merge_outputs is None:
merge_outputs = (isinstance(l_outputs, symbol.Symbol)
and isinstance(r_outputs, symbol.Symbol))
if not merge_outputs:
if isinstance(l_outputs, symbol.Symbol):
l_outputs = list(symbol.SliceChannel(l_outputs, axis=axis,
num_outputs=length, squeeze_axis=1))
if isinstance(r_outputs, symbol.Symbol):
r_outputs = list(symbol.SliceChannel(r_outputs, axis=axis,
num_outputs=length, squeeze_axis=1))
if merge_outputs:
l_outputs = [l_outputs]
r_outputs = [symbol.reverse(r_outputs, axis=axis)]
else:
r_outputs = list(reversed(r_outputs))
if not self._add_outputs:
outputs = [symbol.Concat(l_o, r_o, dim=1+merge_outputs,
name=('%sout'%(self._output_prefix) if merge_outputs
else '%st%d'%(self._output_prefix, i)))
for i, l_o, r_o in
zip(range(len(l_outputs)), l_outputs, r_outputs)]
else:
assert len(l_outputs)==len(r_outputs),"the l_outputs must be equal to the r_outputs"
outputs = [symbol._internal._plus(l_o, r_o, dim=1+merge_outputs,
name=('%st%d'%(self._output_prefix, i)))
for i, l_o, r_o in
zip(range(len(l_outputs)), l_outputs, r_outputs)]
if merge_outputs:
outputs = outputs[0]
states = [l_states, r_states]
return outputs, states
def hybrid_forward(self, F, x):
x = self.initial(x)
# x2 = self.useless(x2)
comb_preds = []
for i in range(0, self.nstack):
hg = self.hg[i](x)
feature = self.feature[i](hg)
preds = self.preds[i](feature)
comb_preds.append(preds)
if i != self.nstack - 1:
x = x + self.merge_preds[i](preds) + self.merge_features[i](
feature)
return sym.Concat(*comb_preds, dim=1)
def InceptionFactoryA(data, num_1x1, num_3x3red, num_3x3, num_d3x3red,
num_d3x3, pool, proj, name):
# 1x1
c1x1 = ConvFactory(data=data,
num_filter=num_1x1,
kernel=(1, 1),
name=('%s_1x1' % name))
# 3x3 reduce + 3x3
c3x3r = ConvFactory(data=data,
num_filter=num_3x3red,
kernel=(1, 1),
name=('%s_3x3' % name),
suffix='_reduce')
c3x3 = ConvFactory(data=c3x3r,
num_filter=num_3x3,
kernel=(3, 3),
pad=(1, 1),
name=('%s_3x3' % name))
# double 3x3 reduce + double 3x3
cd3x3r = ConvFactory(data=data,
num_filter=num_d3x3red,
kernel=(1, 1),
name=('%s_double_3x3' % name),
suffix='_reduce')
cd3x3 = ConvFactory(data=cd3x3r,
num_filter=num_d3x3,
kernel=(3, 3),
pad=(1, 1),
name=('%s_double_3x3_0' % name))
cd3x3 = ConvFactory(data=cd3x3,
num_filter=num_d3x3,
kernel=(3, 3),
pad=(1, 1),
name=('%s_double_3x3_1' % name))
# pool + proj
pooling = mxy.Pooling(data=data,
kernel=(3, 3),
stride=(1, 1),
pad=(1, 1),
pool_type=pool,
name=('%s_pool_%s_pool' % (pool, name)))
cproj = ConvFactory(data=pooling,
num_filter=proj,
kernel=(1, 1),
name=('%s_proj' % name))
# concat
concat = mxy.Concat(*[c1x1, c3x3, cd3x3, cproj],
name='ch_concat_%s_chconcat' % name)
return concat
def SimpleFactory(data, ch_1x1, ch_3x3, name, attr):
# 1x1
conv1x1 = ConvFactory(data=data,
name=name + '_1x1',
kernel=(1, 1),
pad=(0, 0),
num_filter=ch_1x1,
attr=attr)
# 3x3
conv3x3 = ConvFactory(data=data,
name=name + '_3x3',
kernel=(3, 3),
pad=(1, 1),
num_filter=ch_3x3,
attr=attr)
#concat
concat = mxy.Concat(*[conv1x1, conv3x3], name=name + '_ch_concat')
return concat
def InceptionFactoryB(data, num_3x3red, num_3x3, num_d3x3red, num_d3x3, name):
# 3x3 reduce + 3x3
c3x3r = ConvFactory(data=data,
num_filter=num_3x3red,
kernel=(1, 1),
name=('%s_3x3' % name),
suffix='_reduce')
c3x3 = ConvFactory(data=c3x3r,
num_filter=num_3x3,
kernel=(3, 3),
pad=(1, 1),
stride=(2, 2),
name=('%s_3x3' % name))
# double 3x3 reduce + double 3x3
cd3x3r = ConvFactory(data=data,
num_filter=num_d3x3red,
kernel=(1, 1),
name=('%s_double_3x3' % name),
suffix='_reduce')
cd3x3 = ConvFactory(data=cd3x3r,
num_filter=num_d3x3,
kernel=(3, 3),
pad=(1, 1),
stride=(1, 1),
name=('%s_double_3x3_0' % name))
cd3x3 = ConvFactory(data=cd3x3,
num_filter=num_d3x3,
kernel=(3, 3),
pad=(1, 1),
stride=(2, 2),
name=('%s_double_3x3_1' % name))
# pool + proj
pooling = mxy.Pooling(data=data,
kernel=(3, 3),
stride=(2, 2),
pad=(1, 1),
pool_type="max",
name=('max_pool_%s_pool' % name))
# concat
concat = mxy.Concat(*[c3x3, cd3x3, pooling],
name='ch_concat_%s_chconcat' % name)
return concat
def DownsampleFactory(data, ch_3x3, name, attr):
# conv 3x3
conv = ConvFactory(data=data,
name=name + '_conv',
kernel=(3, 3),
stride=(2, 2),
num_filter=ch_3x3,
pad=(1, 1),
attr=attr)
# pool
pool = mxy.Pooling(data=data,
name=name + '_pool',
kernel=(3, 3),
stride=(2, 2),
pad=(1, 1),
pool_type='max',
attr=attr)
# concat
concat = mxy.Concat(*[conv, pool], name=name + '_ch_concat')
return concat
