def bottleneck(inputs, depth, depth_bottleneck, stride, rate=1, scope=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 = tl.layers.Conv2d(inputs, depth, filter_size=(1, 1), strides=(stride, stride), act=None,
b_init=None, name='shortcut_conv')
shortcut = GroupNormLayer(layer=shortcut, act=tf.identity, name='shortcut_bn/BatchNorm')
# bottleneck layer 1
residual = tl.layers.Conv2d(inputs, depth_bottleneck, filter_size=(1, 1), strides=(1, 1), act=None, b_init=None,
name='conv1')
residual = GroupNormLayer(layer=residual, act=tf.nn.relu, name='conv1_bn/BatchNorm')
# bottleneck layer 2
residual = conv2d_same(residual, depth_bottleneck, kernel_size=3, strides= stride, rate=rate, scope='conv2')
# bottleneck layer 3
residual = tl.layers.Conv2d(residual, depth, filter_size=(1, 1), strides=(1, 1), act=None, b_init=None,
name='conv3')
residual = GroupNormLayer(layer=residual, act=tf.identity, name='conv3_bn/BatchNorm',
scale_init=tf.constant_initializer(0.0))
output = ElementwiseLayer(layer=[shortcut, residual],
combine_fn=tf.add,
name='combine_layer',
act=tf.nn.relu)
return output
def bottleneck_IR(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 = tl.layers.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 = GroupNormLayer(layer=shortcut,
act=tf.identity,
name='shortcut_bn/BatchNorm')
# bottleneck layer 1
residual = GroupNormLayer(layer=inputs,
act=tf.identity,
name='conv1_bn1')
residual = tl.layers.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 = GroupNormLayer(layer=residual,
act=tf.identity,
name='conv1_bn2')
# bottleneck prelu
residual = tl.layers.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)
output = ElementwiseLayer(layer=[shortcut, residual],
combine_fn=tf.add,
name='combine_layer',
act=None)
return output
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 = tl.layers.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 = GroupNormLayer(layer=net,
act=tf.identity,
name='group_norm_0')
net = tl.layers.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 = GroupNormLayer(layer=net, act=tf.identity, name='E_GN_0')
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 = tl.layers.DenseLayer(net,
n_units=512,
W_init=w_init,
name='E_DenseLayer')
# net = GroupNormLayer(layer=net, act=tf.identity, name='E_GN_1')
return net
def conv2d_same(inputs, num_outputs, kernel_size, strides, rate=1, w_init=None, scope=None, trainable=None):
'''
Reference slim resnet
:param inputs:
:param num_outputs:
:param kernel_size:
:param strides:
:param rate:
:param scope:
:return:
'''
if strides == 1:
if rate == 1:
nets = tl.layers.Conv2d(inputs, n_filter=num_outputs, filter_size=(kernel_size, kernel_size), b_init=None,
strides=(strides, strides), W_init=w_init, act=None, padding='SAME', name=scope,
use_cudnn_on_gpu=True)
nets = GroupNormLayer(layer=nets, act=tf.identity, name=scope+'_bn/GroupNorm')
else:
nets = tl.layers.AtrousConv2dLayer(inputs, n_filter=num_outputs, filter_size=(kernel_size, kernel_size),
rate=rate, act=None, W_init=w_init, padding='SAME', name=scope)
nets = GroupNormLayer(layer=nets, act=tf.identity, name=scope+'_bn/GroupNorm')
return nets
else:
kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
pad_total = kernel_size_effective - 1
pad_beg = pad_total // 2
pad_end = pad_total - pad_beg
inputs = tl.layers.PadLayer(inputs, [[0, 0], [pad_beg, pad_end], [pad_beg, pad_end], [0, 0]], name='padding_%s' % scope)
if rate == 1:
nets = tl.layers.Conv2d(inputs, n_filter=num_outputs, filter_size=(kernel_size, kernel_size), b_init=None,
strides=(strides, strides), W_init=w_init, act=None, padding='VALID', name=scope,
use_cudnn_on_gpu=True)
nets = GroupNormLayer(layer=nets, act=tf.identity, name=scope+'_bn/GroupNorm')
else:
nets = tl.layers.AtrousConv2dLayer(inputs, n_filter=num_outputs, filter_size=(kernel_size, kernel_size), b_init=None,
rate=rate, act=None, W_init=w_init, padding='SAME', name=scope)
nets = GroupNormLayer(layer=nets, act=tf.identity, name=scope+'_bn/GroupNorm')
return nets
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 = tl.layers.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 = GroupNormLayer(layer=shortcut, act=tf.identity, name='shortcut_bn/BatchNorm')
residual = GroupNormLayer(layer=inputs, act=tf.identity, name='conv1_bn1')
residual = tl.layers.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 = GroupNormLayer(layer=residual, act=tf.identity, name='conv1_bn2')
# bottleneck prelu
residual = tl.layers.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 = tl.layers.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 = tl.layers.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