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 tmpnet():
x = sym.Variable('data')
y = sym.Convolution(x, kernel=(3, 3), num_filter=32)
y = sym.Activation(y, 'relu')
y = sym.Convolution(y,
kernel=(3, 3),
num_filter=64,
stride=(2, 2),
num_group=2)
y = sym.softmax(y)
return y
def __call__(self, inputs, states):
self._counter += 1
name = '%st%d_' % (self._prefix, self._counter)
#input
i2h = symbol.Convolution(data=inputs, weight=self._iW, bias=self._iB,kernel=self._kernel,
num_filter=self._num_hidden,stride=self._stride,name='%si2h' % name)
#memory
h2h = symbol.Convolution(data=states[0], weight=self._hW, bias=self._hB,
kernel=self._kernel,num_filter=self._num_hidden,stride=self._stride,name='%sh2h' % name)
output = self._get_activation(i2h+h2h, self._activation,
name='%sout' % name)
return output, [output]
def getsymbol(num_classes=136):
# define alexnet
data = mxy.Variable(name="data")
label = mxy.Variable(name="label")
# group 1
conv1_1 = mxy.Convolution(data=data, kernel=(3, 3), pad=(1, 1), num_filter=64, name="conv1_1")
relu1_1 = mxy.Activation(data=conv1_1, act_type="relu", name="relu1_1")
pool1 = mxy.Pooling(data=relu1_1, pool_type="max", kernel=(2, 2), stride=(2,2), name="pool1")
# group 2
conv2_1 = mxy.Convolution(data=pool1, kernel=(3, 3), pad=(1, 1), num_filter=128, name="conv2_1")
relu2_1 = mxy.Activation(data=conv2_1, act_type="relu", name="relu2_1")
pool2 = mxy.Pooling(data=relu2_1, pool_type="max", kernel=(2, 2), stride=(2,2), name="pool2")
# group 3
conv3_1 = mxy.Convolution(data=pool2, kernel=(3, 3), pad=(1, 1), num_filter=256, name="conv3_1")
relu3_1 = mxy.Activation(data=conv3_1, act_type="relu", name="relu3_1")
conv3_2 = mxy.Convolution(data=relu3_1, kernel=(3, 3), pad=(1, 1), num_filter=256, name="conv3_2")
relu3_2 = mxy.Activation(data=conv3_2, act_type="relu", name="relu3_2")
pool3 = mxy.Pooling(data=relu3_2, pool_type="max", kernel=(2, 2), stride=(2,2), name="pool3")
# group 4
conv4_1 = mxy.Convolution(data=pool3, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv4_1")
relu4_1 = mxy.Activation(data=conv4_1, act_type="relu", name="relu4_1")
conv4_2 = mxy.Convolution(data=relu4_1, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv4_2")
relu4_2 = mxy.Activation(data=conv4_2, act_type="relu", name="relu4_2")
pool4 = mxy.Pooling(data=relu4_2, pool_type="max", kernel=(2, 2), stride=(2,2), name="pool4")
# group 5
conv5_1 = mxy.Convolution(data=pool4, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv5_1")
relu5_1 = mxy.Activation(data=conv5_1, act_type="relu", name="relu5_1")
conv5_2 = mxy.Convolution(data=relu5_1, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv5_2")
relu5_2 = mxy.Activation(data=conv5_2, act_type="relu", name="conv1_2")
pool5 = mxy.Pooling(data=relu5_2, pool_type="max", kernel=(2, 2), stride=(2,2), name="pool5")
# group 6
flatten = mxy.Flatten(data=pool5, name="flatten")
fc6 = mxy.FullyConnected(data=flatten, num_hidden=4096, name="fc6")
relu6 = mxy.Activation(data=fc6, act_type="relu", name="relu6")
drop6 = mxy.Dropout(data=relu6, p=0.5, name="drop6")
# group 7
fc7 = mxy.FullyConnected(data=drop6, num_hidden=4096, name="fc7")
relu7 = mxy.Activation(data=fc7, act_type="relu", name="relu7")
drop7 = mxy.Dropout(data=relu7, p=0.5, name="drop7")
# output
fc8 = mxy.FullyConnected(data=drop7, num_hidden=num_classes, name="fc8")
loc_loss = mxy.LinearRegressionOutput(data=fc8, label=label, name="loc_loss")
#loc_loss_ = mxy.smooth_l1(name="loc_loss_", data=(fc8 - label), scalar=1.0)
#loc_loss_ = mxy.smooth_l1(name="loc_loss_", data=fc8, scalar=1.0)
#loc_loss = mx.sym.MakeLoss(name='loc_loss', data=loc_loss_)
return loc_loss
def weight_sharing_residual_network(graph):
X = symbol.Variable('data')
for index, node in enumerate(graph):
weight = symbol.Variable('convolution_weight_%d' % index)
bias = symbol.Variable('convolution_bias_%d' % index)
kwargs, activation, times = node
for t in range(times):
X = symbol.Convolution(data = X, weight = weight, bias = bias, **kwargs)
def get_conv(inpt, name, num_filter, stride=(1, 1), act_type='prelu'):
act_name = name.replace('conv', act_type)
return sym.LeakyReLU(sym.Convolution(inpt,
name=name,
num_filter=num_filter,
stride=stride,
kernel=(3, 3),
pad=(1, 1)),
name=act_name,
act_type=act_type,
gamma=sym.var(act_name))
def __call__(self, inputs, states):
# pylint: disable=too-many-locals
self._counter += 1
seq_idx = self._counter
name = '%st%d_' % (self._prefix, seq_idx)
prev_state_h = states[0]
i2h = symbol.Convolution(data=inputs,
weight=self._iW,
kernel = self._kernel,
bias=self._iB,
num_filter=self._num_hidden * 3,
dilate =self._dilate,
pad = self._pad,
name="%s_i2h" % name)
h2h = symbol.Convolution(data=prev_state_h,
kernel=self._kernel,
weight=self._hW,
bias=self._hB,
num_filter=self._num_hidden * 3,
dilate=self._dilate,
pad = self._pad,
name="%s_h2h" % name)
i2h_r, i2h_z, i2h = symbol.SliceChannel(i2h, num_outputs=3, name="%s_i2h_slice" % name)
h2h_r, h2h_z, h2h = symbol.SliceChannel(h2h, num_outputs=3, name="%s_h2h_slice" % name)
reset_gate = symbol.Activation(i2h_r + h2h_r, act_type="sigmoid",
name="%s_r_act" % name)
update_gate = symbol.Activation(i2h_z + h2h_z, act_type="sigmoid",
name="%s_z_act" % name)
next_h_tmp = symbol.Activation(i2h + reset_gate * h2h, act_type="tanh",
name="%s_h_act" % name)
next_h = symbol._internal._plus((1. - update_gate) * next_h_tmp, update_gate * prev_state_h,
name='%sout' % name)
return next_h, [next_h]
def add_forward(self, data: sym.Variable):
"""Add neural network model."""
conv1 = sym.Convolution(
data, name='conv1', num_filter=64, kernel=(3, 3), stride=(2, 2))
relu1 = sym.Activation(conv1, act_type='relu')
pool1 = sym.Pooling(relu1, pool_type='max', kernel=(3, 3), stride=(2, 2))
fire2 = self._fire_layer('fire2', pool1, s1x1=16, e1x1=64, e3x3=64)
fire3 = self._fire_layer('fire3', fire2, s1x1=16, e1x1=64, e3x3=64)
pool3 = sym.Pooling(fire3, name='pool3', kernel=(3, 3), stride=(2, 2), pool_type='max')
fire4 = self._fire_layer('fire4', pool3, s1x1=32, e1x1=128, e3x3=128)
fire5 = self._fire_layer('fire5', fire4, s1x1=32, e1x1=128, e3x3=128)
pool5 = sym.Pooling(fire5, name='pool5', kernel=(3, 3), stride=(2, 2), pool_type='max')
fire6 = self._fire_layer('fire6', pool5, s1x1=48, e1x1=192, e3x3=192)
fire7 = self._fire_layer('fire7', fire6, s1x1=48, e1x1=192, e3x3=192)
fire8 = self._fire_layer('fire8', fire7, s1x1=64, e1x1=256, e3x3=256)
fire9 = self._fire_layer('fire9', fire8, s1x1=64, e1x1=256, e3x3=256)
fire10 = self._fire_layer('fire10', fire9, s1x1=96, e1x1=384, e3x3=384)
fire11 = self._fire_layer('fire11', fire10, s1x1=96, e1x1=384, e3x3=384)
dropout11 = sym.Dropout(fire11, p=0.1, name='drop11')
return sym.Convolution(
dropout11, name='conv12', num_filter=NUM_OUT_CHANNELS,
kernel=(3, 3), stride=(1, 1), pad=(1, 1))
def SEModule(data, num_filter, name):
body = sym.Pooling(data=data,
global_pool=True,
kernel=(7, 7),
pool_type='avg',
name=name + '_se_pool1')
body = sym.Convolution(data=body,
num_filter=num_filter // 8,
kernel=(1, 1),
stride=(1, 1),
pad=(0, 0),
name=name + "_se_conv1")
body = Act(data=body, act_type="prelu", name=name + '_se_relu1')
body = sym.Convolution(data=body,
num_filter=num_filter,
kernel=(1, 1),
stride=(1, 1),
pad=(0, 0),
name=name + "_se_conv2")
body = sym.Activation(data=body,
act_type='sigmoid',
name=name + "_se_sigmoid")
data = sym.broadcast_mul(data, body)
return data
def C(idx, indata, bn):
n = idx
p = Param['c%d' % idx]
conv = S.Convolution(name='c' + n,
data=indata,
kernel=p['fsize'],
num_filter=p['fnum'],
pad=p['pad'],
stride=p['stride'],
weight=P[i * 2],
bias=P[i * 2 + 1])
if bn:
c = mx.sym.BatchNorm(name='b' + n, data=c)
r = mx.sym.Activation(name='r' + n, data=c, act_type='relu')
return r
def ConvOnly(data,
num_filter=1,
kernel=(1, 1),
stride=(1, 1),
pad=(0, 0),
num_group=1,
name=None,
suffix=''):
conv = sym.Convolution(data=data,
num_filter=num_filter,
kernel=kernel,
num_group=num_group,
stride=stride,
pad=pad,
no_bias=True,
name='%s%s_conv2d' % (name, suffix))
return conv
def Linear(data,
num_filter=1,
kernel=(1, 1),
stride=(1, 1),
pad=(0, 0),
num_group=1,
name=None,
suffix=''):
conv = sym.Convolution(data=data,
num_filter=num_filter,
kernel=kernel,
num_group=num_group,
stride=stride,
pad=pad,
no_bias=True,
name='%s%s_conv2d' % (name, suffix))
bn = sym.BatchNorm(data=conv,
name='%s%s_batchnorm' % (name, suffix),
fix_gamma=False,
momentum=config.bn_mom)
return bn
def C(idx, indata, bn):
p = Param['c%d' % idx]
i = 4 * (idx - 1)
c = S.Convolution(name='c' + str(idx),
data=indata,
kernel=p['fsize'],
num_filter=p['fnum'],
pad=p['pad'],
stride=p['stride'],
weight=P[i],
bias=P[i + 1])
if bn:
c = mx.sym.BatchNorm(
name='b' + str(next(gtr)),
data=c,
gamma=P[i + 2],
beta=P[i + 3],
)
r = mx.sym.Activation(name='r' + str(idx), data=c, act_type='relu')
return r
def ConvFactory(data,
num_filter,
kernel,
stride=(1, 1),
pad=(0, 0),
name=None,
suffix='',
attr={}):
conv = mxy.Convolution(data=data,
num_filter=num_filter,
kernel=kernel,
stride=stride,
pad=pad,
name='conv_%s%s' % (name, suffix))
bn = mxy.BatchNorm(data=conv,
fix_gamma=fix_gamma,
eps=eps,
momentum=bn_mom,
name='bn_%s%s' % (name, suffix))
act = mxy.Activation(data=bn,
act_type='relu',
name='relu_%s%s' % (name, suffix),
attr=attr)
return act
def r_lstm_step(X, num_hidden, C, c=None, h=None, idx='', param=None):
if not isinstance(idx, str):
idx = str(idx)
if not c:
c = mx.sym.Variable(name='c%s' % idx)
if not h:
h = mx.sym.Variable(name='h%s' % idx)
if not param:
param = LSTMParam(x2g_weight=S.Variable("x2g_weight"),
x2g_bias=S.Variable("x2g_bias"),
h2g_weight=S.Variable("h2g_weight"),
h2g_bias=S.Variable("h2g_bias"),
Y_weight=S.Variable("Y_weight"),
Y_bias=S.Variable("Y_bias"))
x2g = S.Convolution(name='x2g%s' % idx,
data=X,
weight=param.x2g_weight,
bias=param.x2g_bias,
kernel=(5, 5),
num_filter=num_hidden * 4,
pad=(2, 2))
h2g = S.Convolution(name='h2g%s' % idx,
data=h,
weight=param.h2g_weight,
bias=param.h2g_bias,
kernel=(5, 5),
num_filter=num_hidden * 4,
pad=(2, 2))
gates = x2g + h2g
slice_gates = mx.sym.SliceChannel(gates,
num_outputs=4,
name='rnn_slice%s' % idx)
in_gate = mx.sym.Activation(slice_gates[0],
act_type="sigmoid",
name='in_gate%s' % idx)
in_transform = mx.sym.Activation(slice_gates[1],
act_type="tanh",
name='in_transform%s' % idx)
forget_gate = mx.sym.Activation(slice_gates[2],
act_type="sigmoid",
name='forget_gate%s' % idx)
out_gate = mx.sym.Activation(slice_gates[3],
act_type="sigmoid",
name='out_gate%s' % idx)
c_this = (forget_gate * c) + (in_gate * in_transform)
h_this = out_gate * mx.sym.Activation(
c_this, act_type="tanh", name='tanh2h%s' % idx)
fc = S.Convolution(name='Y%s' % idx,
data=h_this,
weight=param.Y_weight,
bias=param.Y_bias,
kernel=(1, 1),
num_filter=C,
pad=(0, 0))
c_this = mx.sym.BlockGrad(data=c_this)
h_this = mx.sym.BlockGrad(data=h_this)
return fc, c_this, h_this
# try overlap in future
p1 = maxpool(l1_3) #128,128
l2_1 = conv_relu('4', data=p1, kernel=(3,3), num_filter=64, pad=(1,1))
l2_2 = conv_relu('5', data=l2_1, kernel=(3,3), num_filter=64, pad=(1,1))
l2_3 = conv_relu('6', data=l2_2, kernel=(3,3), num_filter=64, pad=(1,1), bn=True)
p2 = maxpool(l2_3)
p1_5 = maxpool(p1)
p2 = p2+p1_5 #64,64
l3_1 = conv_relu('7', data=p2, kernel=(3,3), num_filter=64, pad=(1,1))
l3_2 = conv_relu('8', data=l3_1, kernel=(3,3), num_filter=16, pad=(1,1))
l3_3 = conv_relu('9', data=l3_2, kernel=(3,3), num_filter=16, pad=(1,1), bn=True)
l3_4 = S.Convolution(name='c10', data=l3_3, kernel=(1,1), num_filter=1, pad=(0,0))
pred = S.LogisticRegressionOutput(data=l3_4, name='softmax')
def e_net(*args):
return pred
def e_rnn(*args):
return LSTM(l3_4, 64*64, 1, 64, 64)
if __name__ == '__main__':
for _ in pred.infer_shape(data=(11,1,256,256)):
print _
def conv_bn_relu_pool_siamese(input_a,
input_b,
kernel,
num_filter,
pad,
stride,
name_postfix,
use_pooling=False,
p_kernel=None,
p_stride=None,
use_batch_norm=True):
conv_weight = mxs.Variable(name='conv' + name_postfix + '_weight')
conv_bias = mxs.Variable(name='conv' + name_postfix + '_bias')
conv_a = mxs.Convolution(data=input_a,
kernel=kernel,
num_filter=num_filter,
pad=pad,
stride=stride,
name='conv' + name_postfix + "_a",
weight=conv_weight,
bias=conv_bias)
conv_b = mxs.Convolution(data=input_b,
kernel=kernel,
num_filter=num_filter,
pad=pad,
stride=stride,
name='conv' + name_postfix + "_b",
weight=conv_weight,
bias=conv_bias)
if use_batch_norm:
bn_gamma = mxs.Variable(name='bn' + name_postfix + '_gamma')
bn_beta = mxs.Variable(name='bn' + name_postfix + '_beta')
bn_moving_mean = mxs.Variable(name='bn' + name_postfix +
'_moving_mean')
bn_moving_var = mxs.Variable(name='bn' + name_postfix +
'_moving_var')
batch_norm_a = mxs.BatchNorm(data=conv_a,
name='bn' + name_postfix + '_a',
gamma=bn_gamma,
beta=bn_beta,
moving_mean=bn_moving_mean,
moving_var=bn_moving_var)
batch_norm_b = mxs.BatchNorm(data=conv_b,
name='bn' + name_postfix + '_b',
gamma=bn_gamma,
beta=bn_beta,
moving_mean=bn_moving_mean,
moving_var=bn_moving_var)
else:
batch_norm_a = conv_a
batch_norm_b = conv_b
relu_a = mxs.relu(data=batch_norm_a, name='relu' + name_postfix + '_a')
relu_b = mxs.relu(data=batch_norm_b, name='relu' + name_postfix + '_b')
if use_pooling:
out_a = mxs.Pooling(data=relu_a,
kernel=p_kernel,
pool_type='max',
stride=p_stride,
name='pool' + name_postfix + '_a')
out_b = mxs.Pooling(data=relu_b,
kernel=p_kernel,
pool_type='max',
stride=p_stride,
name='pool' + name_postfix + '_b')
else:
out_a = relu_a
out_b = relu_b
return out_a, out_b
def siamese_simp_net():
def conv_bn_relu_pool_siamese(input_a,
input_b,
kernel,
num_filter,
pad,
stride,
name_postfix,
use_pooling=False,
p_kernel=None,
p_stride=None,
use_batch_norm=True):
conv_weight = mxs.Variable(name='conv' + name_postfix + '_weight')
conv_bias = mxs.Variable(name='conv' + name_postfix + '_bias')
conv_a = mxs.Convolution(data=input_a,
kernel=kernel,
num_filter=num_filter,
pad=pad,
stride=stride,
name='conv' + name_postfix + "_a",
weight=conv_weight,
bias=conv_bias)
conv_b = mxs.Convolution(data=input_b,
kernel=kernel,
num_filter=num_filter,
pad=pad,
stride=stride,
name='conv' + name_postfix + "_b",
weight=conv_weight,
bias=conv_bias)
if use_batch_norm:
bn_gamma = mxs.Variable(name='bn' + name_postfix + '_gamma')
bn_beta = mxs.Variable(name='bn' + name_postfix + '_beta')
bn_moving_mean = mxs.Variable(name='bn' + name_postfix +
'_moving_mean')
bn_moving_var = mxs.Variable(name='bn' + name_postfix +
'_moving_var')
batch_norm_a = mxs.BatchNorm(data=conv_a,
name='bn' + name_postfix + '_a',
gamma=bn_gamma,
beta=bn_beta,
moving_mean=bn_moving_mean,
moving_var=bn_moving_var)
batch_norm_b = mxs.BatchNorm(data=conv_b,
name='bn' + name_postfix + '_b',
gamma=bn_gamma,
beta=bn_beta,
moving_mean=bn_moving_mean,
moving_var=bn_moving_var)
else:
batch_norm_a = conv_a
batch_norm_b = conv_b
relu_a = mxs.relu(data=batch_norm_a, name='relu' + name_postfix + '_a')
relu_b = mxs.relu(data=batch_norm_b, name='relu' + name_postfix + '_b')
if use_pooling:
out_a = mxs.Pooling(data=relu_a,
kernel=p_kernel,
pool_type='max',
stride=p_stride,
name='pool' + name_postfix + '_a')
out_b = mxs.Pooling(data=relu_b,
kernel=p_kernel,
pool_type='max',
stride=p_stride,
name='pool' + name_postfix + '_b')
else:
out_a = relu_a
out_b = relu_b
return out_a, out_b
data_a = mxs.Variable('data_a')
data_b = mxs.Variable('data_b')
c1_a, c1_b = conv_bn_relu_pool_siamese(data_a,
data_b,
kernel=(3, 3),
num_filter=64,
pad=(1, 1),
stride=(1, 1),
name_postfix='1',
use_pooling=False)
c1_0_a, c1_0_b = conv_bn_relu_pool_siamese(c1_a,
c1_b,
kernel=(3, 3),
num_filter=32,
pad=(1, 1),
stride=(1, 1),
name_postfix='1_0',
use_pooling=False)
c2_a, c2_b = conv_bn_relu_pool_siamese(c1_0_a,
c1_0_b,
kernel=(3, 3),
num_filter=32,
pad=(1, 1),
stride=(1, 1),
name_postfix='2',
use_pooling=False)
c2_1_a, c2_1_b = conv_bn_relu_pool_siamese(c2_a,
c2_b,
kernel=(3, 3),
num_filter=32,
pad=(1, 1),
stride=(1, 1),
name_postfix='2_1',
use_pooling=True,
p_kernel=(2, 2),
p_stride=(2, 2))
c2_2_a, c2_2_b = conv_bn_relu_pool_siamese(c2_1_a,
c2_1_b,
kernel=(3, 3),
num_filter=32,
pad=(1, 1),
stride=(1, 1),
name_postfix='2_2',
use_pooling=False)
c3_a, c3_b = conv_bn_relu_pool_siamese(c2_2_a,
c2_2_b,
kernel=(3, 3),
num_filter=32,
pad=(1, 1),
stride=(1, 1),
name_postfix='3',
use_pooling=False)
# conv4
conv4_weight = mxs.Variable(name='conv4_weight')
conv4_bias = mxs.Variable(name='conv4_bias')
conv4_a = mxs.Convolution(data=c3_a,
kernel=(3, 3),
num_filter=64,
pad=(1, 1),
stride=(1, 1),
name='conv4_a',
weight=conv4_weight,
bias=conv4_bias) # xavier
conv4_b = mxs.Convolution(data=c3_b,
kernel=(3, 3),
num_filter=64,
pad=(1, 1),
stride=(1, 1),
name='conv4_b',
weight=conv4_weight,
bias=conv4_bias) # xavier
maxp4_a = mxs.Pooling(data=conv4_a,
kernel=(2, 2),
pool_type='max',
stride=(2, 2),
name='pool4_a')
maxp4_b = mxs.Pooling(data=conv4_b,
kernel=(2, 2),
pool_type='max',
stride=(2, 2),
name='pool4_b')
bn4_gamma = mxs.Variable(name='bn4_gamma')
bn4_beta = mxs.Variable(name='bn4_beta')
bn4_moving_mean = mxs.Variable(name='bn4_moving_mean')
bn4_moving_var = mxs.Variable(name='bn4_moving_var')
batch_norm_4_a = mxs.BatchNorm(data=maxp4_a,
name='bn4_a',
gamma=bn4_gamma,
beta=bn4_beta,
moving_mean=bn4_moving_mean,
moving_var=bn4_moving_var)
batch_norm_4_b = mxs.BatchNorm(data=maxp4_b,
name='bn4_b',
gamma=bn4_gamma,
beta=bn4_beta,
moving_mean=bn4_moving_mean,
moving_var=bn4_moving_var)
relu4_a = mxs.relu(data=batch_norm_4_a, name='relu4')
relu4_b = mxs.relu(data=batch_norm_4_b, name='relu4')
c4_1_a, c4_1_b = conv_bn_relu_pool_siamese(relu4_a,
relu4_b,
kernel=(3, 3),
num_filter=64,
pad=(1, 1),
stride=(1, 1),
name_postfix='4_1',
use_pooling=False)
c4_2_a, c4_2_b = conv_bn_relu_pool_siamese(c4_1_a,
c4_1_b,
kernel=(3, 3),
num_filter=64,
pad=(1, 1),
stride=(1, 1),
name_postfix='4_2',
use_pooling=True,
p_kernel=(2, 2),
p_stride=(2, 2))
c4_0_a, c4_0_b = conv_bn_relu_pool_siamese(c4_2_a,
c4_2_b,
kernel=(3, 3),
num_filter=128,
pad=(1, 1),
stride=(1, 1),
name_postfix='4_0',
use_pooling=False)
cccp4_a, cccp4_b = conv_bn_relu_pool_siamese(c4_0_a,
c4_0_b,
kernel=(1, 1),
num_filter=256,
pad=[],
stride=(1, 1),
name_postfix='_cccp4',
use_pooling=False,
use_batch_norm=False)
cccp5_a, cccp5_b = conv_bn_relu_pool_siamese(cccp4_a,
cccp4_b,
kernel=(1, 1),
num_filter=64,
pad=[],
stride=(1, 1),
name_postfix='_cccp5',
use_pooling=True,
p_kernel=(2, 2),
p_stride=(2, 2),
use_batch_norm=False)
cccp6_a, cccp6_b = conv_bn_relu_pool_siamese(cccp5_a,
cccp5_b,
kernel=(3, 3),
num_filter=64,
pad=(2, 2),
stride=(1, 1),
name_postfix='_cccp6',
use_pooling=False,
use_batch_norm=False)
flat_a = mxs.flatten(cccp6_a)
flat_b = mxs.flatten(cccp6_b)
return flat_a, flat_b