def resnet(inputs,
bottle_neck,
blocks,
w_init=None,
trainable=None,
scope=None):
with tf.variable_scope(scope):
net_inputs = tl.layers.InputLayer(inputs, name='input_layer')
if bottle_neck:
net = Conv2d(net_inputs,
n_filter=64,
filter_size=(3, 3),
strides=(1, 1),
act=None,
W_init=w_init,
b_init=None,
name='conv1',
use_cudnn_on_gpu=True)
net = BatchNormLayer(net,
act=tf.identity,
name='bn0',
is_train=True,
trainable=trainable)
net = PReluLayer(net, name='prelu0')
else:
raise ValueError(
'The standard resnet must support the bottleneck layer')
for block in blocks:
with tf.variable_scope(block.scope):
for i, var in enumerate(block.args):
with tf.variable_scope('unit_%d' % (i + 1)):
net = block.unit_fn(
net,
depth=var['depth'],
depth_bottleneck=var['depth_bottleneck'],
w_init=w_init,
stride=var['stride'],
rate=var['rate'],
scope=None,
trainable=trainable)
net = BatchNormLayer(net,
act=tf.identity,
is_train=True,
name='E_BN1',
trainable=trainable)
net = tl.layers.DropoutLayer(net, keep=0.4, name='E_Dropout')
net_shape = net.outputs.get_shape()
net = tl.layers.ReshapeLayer(
net,
shape=[-1, net_shape[1] * net_shape[2] * net_shape[3]],
name='E_Reshapelayer')
net = DenseLayer(net, n_units=512, W_init=w_init, name='E_DenseLayer')
net = BatchNormLayer(net,
act=tf.identity,
is_train=True,
fix_gamma=False,
trainable=trainable,
name='E_BN2')
return net
def bottleneck_IR_SE(inputs, depth, depth_bottleneck, stride, rate=1, w_init=None, scope=None, trainable=None):
with tf.variable_scope(scope, 'bottleneck_v1') as sc:
depth_in = utils.last_dimension(inputs.outputs.get_shape(), min_rank=4)
if depth == depth_in:
shortcut = subsample(inputs, stride, 'shortcut')
else:
shortcut = Conv2d(inputs, depth, filter_size=(1, 1), strides=(stride, stride), act=None,
W_init=w_init, b_init=None, name='shortcut_conv', use_cudnn_on_gpu=True)
shortcut = BatchNormLayer(shortcut, act=tf.identity, is_train=True, trainable=trainable, name='shortcut_bn/BatchNorm')
# bottleneck layer 1
residual = BatchNormLayer(inputs, act=tf.identity, is_train=True, trainable=trainable, name='conv1_bn1')
residual = Conv2d(residual, depth_bottleneck, filter_size=(3, 3), strides=(1, 1), act=None, b_init=None,
W_init=w_init, name='conv1', use_cudnn_on_gpu=True)
residual = BatchNormLayer(residual, act=tf.identity, is_train=True, trainable=trainable, name='conv1_bn2')
# bottleneck prelu
residual = PReluLayer(residual)
# bottleneck layer 2
residual = conv2d_same(residual, depth, kernel_size=3, strides=stride, rate=rate, w_init=w_init, scope='conv2', trainable=trainable)
# squeeze
squeeze = tl.layers.InputLayer(tf.reduce_mean(residual.outputs, axis=[1, 2]), name='squeeze_layer')
# excitation
excitation1 = DenseLayer(squeeze, n_units=int(depth/16.0), act=tf.nn.relu,
W_init=w_init, name='excitation_1')
# excitation1 = tl.layers.PReluLayer(excitation1, name='excitation_prelu')
excitation2 = DenseLayer(excitation1, n_units=depth, act=tf.nn.sigmoid,
W_init=w_init, name='excitation_2')
# scale
scale = tl.layers.ReshapeLayer(excitation2, shape=[tf.shape(excitation2.outputs)[0], 1, 1, depth], name='excitation_reshape')
residual_se = ElementwiseLayer(layer=[residual, scale],
combine_fn=tf.multiply,
name='scale_layer',
act=None)
output = ElementwiseLayer(layer=[shortcut, residual_se],
combine_fn=tf.add,
name='combine_layer',
act=tf.nn.relu)
return output