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