def mobileNetV3_block(input, layer_name, expand_dims, out_dims, kernel, stride, ratio, activation_fn='RE', se=False,
short_cut=True):
with tf.variable_scope(layer_name):
net = slim.convolution2d(input, expand_dims, [1, 1], stride=1, activation_fn=None,
scope=layer_name+'_pw_expand')
if activation_fn == 'RE':
net = slim.separable_convolution2d(net, num_outputs=None, stride=stride, activation_fn=relu6,
depth_multiplier=1, kernel_size=kernel, scope=layer_name+'_dwise')
elif activation_fn == 'HS':
net = slim.separable_convolution2d(net, num_outputs=None, stride=stride, activation_fn=hard_swish,
depth_multiplier=1, kernel_size=kernel, scope=layer_name+'_dwise')
else:
raise NotImplementedError
if se is True:
channel = net.get_shape().as_list()[-1]
net = squeeze_and_excite(
net, out_dims=channel, ratio=ratio, layer_name=layer_name+'se')
# if activation_fn == 'RE':
# net = slim.convolution2d(net, out_dims, [1, 1], stride=1, activation_fn=relu6,
# scope=layer_name+'_pw_reduce')
# elif activation_fn == 'HS':
# net = slim.convolution2d(net, out_dims, [1, 1], stride=1, activation_fn=hard_swish,
# scope=layer_name+'_pw_reduce')
# else:
# raise NotImplementedError
net = slim.convolution2d(net, out_dims, [1, 1], stride=1, activation_fn=None,
scope=layer_name + '_pw_reduce')
if stride == 1 and short_cut is True:
net = net + input
return net
def SepConv(x, C_out, kernel_size, stride):
x = tflearn.relu(x)
C_in = x.get_shape()[-1].value
x = slim.separable_convolution2d(x,
C_in,
kernel_size,
depth_multiplier=1,
stride=stride)
x = slim.batch_norm(x)
x = slim.separable_convolution2d(x, C_out, kernel_size, depth_multiplier=1)
x = slim.batch_norm(x)
return x
def depthwise_separable_conv2(inputs, num_pwc_filters, sc, kernel_size, w_scale_l1, w_scale_l2, b_scale_l1, b_scale_l2, stride): """ Helper function to build the depth-wise separable convolution layer. """ # skip pointwise by setting num_outputs=None depthwise_conv = slim.separable_convolution2d(inputs, num_outputs=None, stride=stride, # weights_regularizer=slim.l1_l2_regularizer(w_scale_l1, w_scale_l2), # biases_regularizer=slim.l1_l2_regularizer(b_scale_l1, b_scale_l2), depth_multiplier=1, kernel_size=kernel_size, scope=sc+'/depthwise_conv') bn = slim.batch_norm(depthwise_conv, scope=sc+'/dw_batch_norm') pointwise_conv = slim.convolution2d(bn, num_pwc_filters, kernel_size=[1, 1], # weights_regularizer=slim.l1_l2_regularizer(w_scale_l1, w_scale_l2), # biases_regularizer=slim.l1_l2_regularizer(b_scale_l1, b_scale_l2), scope=sc+'/pointwise_conv') bn = slim.batch_norm(pointwise_conv, scope=sc+'/pw_batch_norm') return bn
def separable_conv(self, input, c_o, k_s, stride, dilation=1, activationFunc=tf.nn.relu6, scope=""):
with slim.arg_scope([slim.batch_norm],
decay=0.999,
fused=True,
is_training=self.is4Train,
activation_fn=activationFunc):
output = slim.separable_convolution2d(input,
num_outputs=None,
stride=stride,
trainable=self.is4Train,
depth_multiplier=opt.depth_multiplier,
kernel_size=[k_s, k_s],
rate=dilation,
weights_initializer=self.init_xavier,
weights_regularizer=self.l2_regularizer,
biases_initializer=None,
activation_fn=tf.nn.relu6,
scope=scope + '_depthwise')
output = slim.convolution2d(output,
c_o,
stride=1,
kernel_size=[1, 1],
weights_initializer=self.init_xavier,
biases_initializer=self.init_zero,
normalizer_fn=slim.batch_norm,
trainable=self.is4Train,
weights_regularizer=None,
scope=scope + '_pointwise')
return output
def depthwise_separable_conv(self,
preprocessed_inputs,
num_pwc_filters,
width_multiplier,
name,
downsampling=False):
num_pwc_filters = round(num_pwc_filters *
width_multiplier) #使用宽度乘数进一步减小模型
_stride = 2 if downsampling else 1
# skip pointwise by setting num_outputs=None
# num_outputs:pointwise 卷积的卷积核个数，如果为空，将跳过pointwise卷积的步骤,后面我们通过一般的1x1卷积自己实现pointwise
depthwise_conv = slim.separable_convolution2d(preprocessed_inputs,
num_outputs=None,
stride=_stride,
depth_multiplier=1,
kernel_size=[3, 3],
scope=name +
"/depthwise_conv")
depthwise_bn = slim.batch_norm(depthwise_conv,
scope=name + "/depthwise_batch_norm")
#通过一般的1x1卷积实现pointwise卷积
# num_pwc_filters:宽度乘数下减少后的pointwise卷积核个数,也就是输出的feature map的通道数
pointwise_conv = slim.convolution2d(depthwise_bn,
num_pwc_filters,
kernel_size=[1, 1],
scope=name + "/pointwise_conv")
pointwise_bn = slim.batch_norm(pointwise_conv,
scope=name + "pointwise_batch_norm")
return pointwise_bn
def depthwise_separable_conv2D(inputs,
num_pwc_filters,
scope=None,
width_multiplier=1,
stride=1,
rate=1,
normalizer_fn=layer_norm,
padding=None,
slice=None):
""" Helper function to build the depth-wise separable convolution layer.
"""
# num_pwc_filters = round(num_pwc_filters * width_multiplier)
_stride = stride
sc = str(scope)
# skip pointwise by setting num_outputs=None
depthwise_conv = slim.separable_convolution2d(inputs,
num_outputs=None,
stride=_stride,
depth_multiplier=1,
kernel_size=[3, 3],
rate=rate,
scope=sc + '/depthwise_conv')
# depthwise_conv = separable_conv2d(inputs, stride=_stride, depth_multiplier=width_multiplier, kernel=[3, 3], rate=rate, scope=sc+'/depthwise_conv',padding=padding, slice=slice)
ln = normalizer_fn(depthwise_conv, scope=sc + '/dw_layer_norm')
pointwise_conv = conv2d(ln,
num_pwc_filters, [1, 1],
scope=sc + '/pointwise_conv',
rate=2,
normalizer_fn=None)
ln = normalizer_fn(pointwise_conv, scope=sc + '/pw_layer_norm')
return ln
def _depthwise_separable_conv(self,
inputs,
num_pwc_filters,
width_multiplier,
sc,
downsample=False):
num_pwc_filters = round(num_pwc_filters * width_multiplier)
_stride = 2 if downsample else 1
# skip pointwise by setting num_outputs=None
# num_outputs:pointwise 卷积的卷积核个数，如果为空，将跳过pointwise卷积的步骤,后面我们通过一般的1x1卷积自己实现pointwise
depthwise_conv = slim.separable_convolution2d(inputs,
num_outputs=None,
stride=_stride,
depth_multiplier=1,
kernel_size=[3, 3],
scope=sc +
'/depthwise_conv')
bn = slim.batch_norm(depthwise_conv, scope=sc + '/dw_batch_norm')
pointwise_conv = slim.convolution2d(
depthwise_conv,
num_pwc_filters, # 该层卷积核个数,也是输出的feature map的通道数
kernel_size=[1, 1],
scope=sc + '/pointwise_conv')
bn = slim.batch_norm(pointwise_conv, scope=sc + '/pw_batch_norm')
return bn
def _depthwise_separable_conv(inputs,
num_pwc_filters,
width_multiplier,
sc,
downsample=False):
""" Helper function to build the depth-wise separable convolution layer.
"""
num_pwc_filters = round(num_pwc_filters * width_multiplier)
_stride = 2 if downsample else 1
# skip pointwise by setting num_outputs=None
depthwise_conv = slim.separable_convolution2d(inputs,
num_outputs=None,
stride=_stride,
depth_multiplier=1,
kernel_size=[3, 3],
scope=sc+'/depthwise_conv')
bn = slim.batch_norm(depthwise_conv, scope=sc+'/dw_batch_norm')
pointwise_conv = slim.convolution2d(bn,
num_pwc_filters,
kernel_size=[1, 1],
scope=sc+'/pointwise_conv')
bn = slim.batch_norm(pointwise_conv, scope=sc+'/pw_batch_norm')
return bn
def separable_conv(self, input, k_h, k_w, c_o, stride, name, relu=True, set_bias=True):
with slim.arg_scope([slim.batch_norm], decay=0.999, fused=common.batchnorm_fused, is_training=self.trainable):
output = slim.separable_convolution2d(input,
num_outputs=None,
stride=stride,
trainable=self.trainable,
depth_multiplier=1.0,
kernel_size=[k_h, k_w],
# activation_fn=common.activation_fn if relu else None,
activation_fn=None,
# normalizer_fn=slim.batch_norm,
weights_initializer=_init_xavier,
# weights_initializer=_init_norm,
weights_regularizer=_l2_regularizer_00004,
biases_initializer=None,
padding=DEFAULT_PADDING,
scope=name + '_depthwise')
output = slim.convolution2d(output,
c_o,
stride=1,
kernel_size=[1, 1],
activation_fn=common.activation_fn if relu else None,
weights_initializer=_init_xavier,
# weights_initializer=_init_norm,
biases_initializer=_init_zero if set_bias else None,
normalizer_fn=slim.batch_norm,
trainable=self.trainable,
weights_regularizer=None,
scope=name + '_pointwise')
return output
def MobileNetV3_bolck(self,inputs,kernel_size,bottleneck_channels,block_output_channels,stride,h_wish,se_moudle,name,SE_ratio=16):
with tf.variable_scope(name):
block_net = slim.convolution2d(inputs,num_outputs=bottleneck_channels,
kernel_size=1,stride=1)
if h_wish:
block_net=self.hard_swish(block_net)
else:
block_net=tf.nn.relu6(block_net)
block_net=slim.separable_convolution2d(block_net, num_outputs=None,
kernel_size=kernel_size,stride=stride)
if h_wish:
block_net=self.hard_swish(block_net)
else:
block_net=tf.nn.relu6(block_net)
#SE_moudle:squeeze and excitation
if se_moudle:
block_net=self.SE_Moudle(block_net,ratio=SE_ratio)
#point wise
block_net=slim.convolution2d(block_net,num_outputs=block_output_channels,
kernel_size=1,stride=1)
#element wise add,onle for stride=1
input_channels=inputs.get_shape().as_list()[-1]
if stride==1 and input_channels==block_output_channels:
block_net=block_net+inputs
block_net=tf.identity(block_net,name="output")
return block_net
def _depthwise_separable_conv(inputs,
num_pwc_filters,
width_multiplier,
sc,
downsample=False,
freeze_convs=False):
num_pwc_filters = round(num_pwc_filters * width_multiplier)
_stride = 2 if downsample else 1
# skip pointwise by setting num_outputs=None
depthwise_conv = slim.separable_convolution2d(
inputs,
num_outputs=None,
stride=_stride,
depth_multiplier=1,
kernel_size=[3, 3],
scope=sc + '/depthwise_conv',
trainable=not freeze_convs)
bn = slim.batch_norm(depthwise_conv,
scope=sc + '/dw_batch_norm',
trainable=not freeze_convs)
pointwise_conv = slim.convolution2d(bn,
num_pwc_filters,
kernel_size=[1, 1],
scope=sc + '/pointwise_conv',
trainable=not freeze_convs)
bn = slim.batch_norm(pointwise_conv,
scope=sc + '/pw_batch_norm',
trainable=not freeze_convs)
return bn
def dw_separable(self,
input,
nr_filters,
width_multiplier,
depth_multiplier,
sc,
downsample=False):
nr_filters = round(nr_filters * width_multiplier)
if downsample:
stride = 2
else:
stride = 1
depthwise_conv = slim.separable_convolution2d(
input,
num_outputs=None,
stride=stride,
depth_multiplier=depth_multiplier,
kernel_size=[3, 3],
scope=sc + '/depthwise_conv')
#bn = slim.batch_norm(depthwise_conv, scope=sc+'/dw_batch_norm')
pointwise_conv = slim.convolution2d(depthwise_conv,
nr_filters,
kernel_size=[1, 1],
scope=sc + '/pointwise_conv')
#bn = slim.batch_norm(pointwise_conv, scope=sc+'/pw_batch_norm')
return pointwise_conv
def depthwise_separable_conv(inputs,
num_pwc_filters,
width_multiplier,
sc,
downsample=False):
num_pwc_filters = round(num_pwc_filters * width_multiplier)
if downsample:
_strides = 2
else:
_strides = 1
depthwise_conv = slim.separable_convolution2d(inputs,
num_outputs=None,
stride=_strides,
depth_multiplier=1,
kernel_size=[3, 3],
scope=sc + '/depthwise_conv')
bn = slim.batch_norm(depthwise_conv, scope=sc + '/dw_batch_norm')
pointwise_conv = slim.convolution2d(bn,
num_pwc_filters,
kernel_size=[1, 1],
scope=sc + '/pointwise_conv')
bn = slim.batch_norm(pointwise_conv, scope=sc + '/pw_batch_norm')
return bn
def bootleneck(self,inputs,bottleneck_channel_upsample_rate,bottleneck_output_channels,stride,name):
with tf.variable_scope(name):
input_channels=inputs.get_shape().as_list()[-1]
# MobileNetV2的第一个核心:reverted residual
# ResNet在bottleneck中是先降维,再升维度,但是MobileNetV2在是先升维再降维
# 论文中bottleneck_channel_upsample_rate=6
bottleneck=slim.convolution2d(inputs,int(input_channels*bottleneck_channel_upsample_rate),
kernel_size=[1,1],stride=1,scope="pw_conv1")
bottleneck=slim.batch_norm(bottleneck,scope="bn1")
# num_outputs:pointwise 卷积的卷积核个数，如果为空，将跳过pointwise卷积的步骤,
# 后面我们通过一般的1x1卷积自己实现pointwise
bottleneck = slim.separable_convolution2d(bottleneck,num_outputs=None,stride=stride,
depth_multiplier=1,kernel_size=[3,3],scope="dw_conv")
bottleneck = slim.batch_norm(bottleneck, scope="bn2")
bottleneck = slim.convolution2d(bottleneck, bottleneck_output_channels,activation_fn=None,
kernel_size=[1, 1], stride=1, scope="pw_conv2")
# bottleNeck的第二个pointwise_conv不使用激活函数
# 也是Mobile的第二个核心:linear bottleneck
# 因为非线性激活函数在高维空间内可以保证非线性，但在低维空间内非线性降低，会导致低维空间的信息损失
bottleneck = slim.batch_norm(bottleneck, scope="bn3",activation_fn=None)
bottle_channels=bottleneck.get_shape().as_list()[-1]
if bottle_channels==input_channels:
bottleneck_output=tf.add(bottleneck,inputs)
else:
bottleneck_output=bottleneck
return bottleneck_output
def init_resblock(x,
out_channel,
stride,
scope='init_resblock',
is_training=True):
with tf.variable_scope(scope):
with slim.arg_scope([slim.separable_convolution2d],
normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu6):
with slim.arg_scope([slim.batch_norm],
is_training=is_training,
center=True,
scale=True):
x = slim.separable_convolution2d(x,
None, [3, 3],
depth_multiplier=1,
stride=stride,
biases_initializer=None,
biases_regularizer=None)
with slim.arg_scope([slim.convolution2d],
normalizer_fn=slim.batch_norm):
with slim.arg_scope([slim.batch_norm],
is_training=is_training,
center=True,
scale=True):
x = slim.convolution2d(x,
out_channel, [1, 1],
stride=1,
padding='same',
biases_initializer=None,
biases_regularizer=None)
return x
def separable_conv(self, input, k_h, k_w, c_o, stride, name, relu=True):
with slim.arg_scope([slim.batch_norm], fused=True):
output = slim.separable_convolution2d(
input,
num_outputs=None,
stride=stride,
trainable=self.trainable,
depth_multiplier=1.0,
kernel_size=[k_h, k_w],
activation_fn=None,
weights_initializer=tf.contrib.layers.xavier_initializer(),
# weights_initializer=tf.truncated_normal_initializer(stddev=0.09),
biases_initializer=None,
padding=DEFAULT_PADDING,
scope=name + '_depthwise')
output = slim.convolution2d(
output,
c_o,
stride=1,
kernel_size=[1, 1],
activation_fn=tf.nn.relu if relu else None,
weights_initializer=tf.contrib.layers.xavier_initializer(),
# weights_initializer=tf.truncated_normal_initializer(stddev=0.09),
biases_initializer=slim.init_ops.zeros_initializer(),
normalizer_fn=slim.batch_norm,
trainable=self.trainable,
# weights_regularizer=tf.contrib.layers.l2_regularizer(0.00004),
weights_regularizer=None,
scope=name + '_pointwise')
return output
def _depthwise_separable_conv(inputs,
num_pwc_filters,
width_multiplier,
sc,
downsample=False):
""" Helper function to build the depth-wise separable convolution layer.
"""
num_pwc_filters = round(num_pwc_filters * width_multiplier)
_stride = 2 if downsample else 1
# skip pointwise by setting num_outputs=None
depthwise_conv = slim.separable_convolution2d(inputs,
num_outputs=None,
stride=_stride,
depth_multiplier=1,
kernel_size=[3, 3],
scope=sc +
'/depthwise_conv')
bn = slim.batch_norm(depthwise_conv, scope=sc + '/dw_batch_norm')
pointwise_conv = slim.convolution2d(bn,
num_pwc_filters,
kernel_size=[1, 1],
scope=sc + '/pointwise_conv')
bn = slim.batch_norm(pointwise_conv, scope=sc + '/pw_batch_norm')
return bn
def MBConv(self, inputs, output_channels, depth_ratio, kernel_size,
is_downsample, name):
stride = 2 if is_downsample else 1
with tf.variable_scope(name):
inputs_channels = inputs.get_shape().as_list()[-1]
bottlenect_channels = int(depth_ratio * inputs_channels)
MBConv_net = slim.convolution2d(inputs,
num_outputs=bottlenect_channels,
kernel_size=1,
stride=1,
scope="1x1_conv1")
MBConv_net = slim.separable_convolution2d(MBConv_net,
num_outputs=None,
kernel_size=kernel_size,
stride=stride,
scope="DWConv")
MBConv_net = slim.convolution2d(MBConv_net,
num_outputs=output_channels,
kernel_size=1,
stride=1,
scope="1x1_conv2")
if not is_downsample and inputs_channels == output_channels:
MBConv_net = MBConv_net + inputs
MBConv_net = tf.identity(MBConv_net, name="out")
return MBConv_net
def separable_conv(input, c_o, k_s, stride, scope):
with slim.arg_scope([slim.batch_norm],
decay=0.999,
fused=True,
is_training=_trainable,
activation_fn=tf.nn.relu6):
output = slim.separable_convolution2d(
input,
num_outputs=None,
stride=stride,
trainable=_trainable,
depth_multiplier=1.0,
kernel_size=[k_s, k_s],
weights_initializer=_init_xavier,
weights_regularizer=_l2_regularizer_00004,
biases_initializer=None,
scope=scope + '_depthwise')
output = slim.convolution2d(output,
c_o,
stride=1,
kernel_size=[1, 1],
weights_initializer=_init_xavier,
biases_initializer=_init_zero,
normalizer_fn=slim.batch_norm,
trainable=_trainable,
weights_regularizer=None,
scope=scope + '_pointwise')
return output
def separable_conv(self, input, k_h, k_w, c_o, stride, name, relu=True, set_bias=True):
with slim.arg_scope([slim.batch_norm], decay=0.999, fused=common.batchnorm_fused, is_training=self.trainable):
output = slim.separable_convolution2d(input,
num_outputs=None,
stride=stride,
trainable=self.trainable,
depth_multiplier=1.0,
kernel_size=[k_h, k_w],
# activation_fn=common.activation_fn if relu else None,
activation_fn=None,
# normalizer_fn=slim.batch_norm,
weights_initializer=_init_xavier,
# weights_initializer=_init_norm,
weights_regularizer=_l2_regularizer_00004,
biases_initializer=None,
padding=DEFAULT_PADDING,
scope=name + '_depthwise')
output = slim.convolution2d(output,
c_o,
stride=1,
kernel_size=[1, 1],
activation_fn=common.activation_fn if relu else None,
weights_initializer=_init_xavier,
# weights_initializer=_init_norm,
biases_initializer=_init_zero if set_bias else None,
normalizer_fn=slim.batch_norm,
trainable=self.trainable,
weights_regularizer=None,
scope=name + '_pointwise')
return output
def shuffle_unit(self,
input,
name,
nr_groups=3,
stride=1,
first_block=False):
in_channels = input.shape.as_list()[3]
# Group conv 1
if first_block:
layer = self.group_conv('g1' + name, input, in_channels, 1)
else:
layer = self.group_conv('g2' + name, input, in_channels, nr_groups)
# No batch norm as of now
layer = tf.nn.relu(layer)
layer = self.shuffle(layer, nr_groups)
# Depthwise conv
layer = slim.separable_convolution2d(layer,
num_outputs=None,
stride=stride,
depth_multiplier=1,
kernel_size=[3, 3])
# Group conv 2
layer = self.group_conv('g3' + name, input, in_channels, nr_groups)
if stride >= 2:
input = tf.nn.avg_pool(input, [1, 3, 3, 1], [1, 2, 2, 1], 'SAME')
layer = tf.concat([layer, input], 3)
else:
layer = tf.add(layer, input)
layer = tf.nn.relu(layer)
return layer
def _depthwise_separable_conv(inputs,
num_pwc_filters,
width_multiplier,
sc,
downsample=False):
num_pwc_filters = round(num_pwc_filters * width_multiplier)
_stride = 2 if downsample else 1
# skip pointwise by setting num_outputs=None
depthwise_conv = slim.separable_convolution2d(inputs,
num_outputs=None,
stride=_stride,
depth_multiplier=1,
kernel_size=[3, 3],
scope=sc + '/depthwise_conv')
bn = slim.batch_norm(
depthwise_conv,
updates_collections=None,
variables_collections=[tf.GraphKeys.TRAINABLE_VARIABLES],
scope=sc + '/dw_batch_norm')
pointwise_conv = slim.convolution2d(bn,
num_pwc_filters,
kernel_size=[1, 1],
scope=sc + '/pointwise_conv')
bn = slim.batch_norm(
pointwise_conv,
updates_collections=None,
variables_collections=[tf.GraphKeys.TRAINABLE_VARIABLES],
scope=sc + '/pw_batch_norm')
return bn
def depthwise_separable_conv(inputs,
num_pwc_filters,
width_multiplier,
sc,
downsample=False,
batch_norm=True):
num_pwc_filters = round(num_pwc_filters * width_multiplier)
_stride = 2 if downsample else 1
# skip pointwise by setting num_outputs=None
depthwise_conv = slim.separable_convolution2d(
inputs,
num_outputs=None,
stride=_stride,
depth_multiplier=1,
kernel_size=[3, 3],
scope=sc + '/depthwise_conv',
weights_initializer=weight_init)
#bn = slim.batch_norm(depthwise_conv, scope=sc+'/dw_batch_norm')
depthwise_conv = tf.nn.relu(depthwise_conv)
if (batch_norm):
depthwise_conv = tf.contrib.layers.batch_norm(depthwise_conv)
pointwise_conv = slim.convolution2d(depthwise_conv,
num_pwc_filters,
kernel_size=[1, 1],
scope=sc + '/pointwise_conv',
weights_initializer=weight_init)
pointwise_conv = tf.nn.relu(pointwise_conv)
if (batch_norm):
pointwise_conv = tf.contrib.layers.batch_norm(pointwise_conv)
#bn = slim.batch_norm(pointwise_conv, scope=sc+'/pw_batch_norm')
return pointwise_conv
def dw_conv2d(x_tensor, conv_ksize, stride, name):
layer = slim.separable_convolution2d(x_tensor,
num_outputs=None,
stride=stride,
depth_multiplier=1,
kernel_size=conv_ksize,
scope=name)
return layer
def separable_conv(self,
input,
k_h,
k_w,
c_o,
stride,
name,
relu=True,
set_bias=True):
"""
实现深度可分离卷积
:param input:
:param k_h: 卷积核高度
:param k_w: 卷积核宽度
:param c_o: 输出通道数
:param stride: 步长
:param name: 操作名
:param relu: 是否使用relu激活函数
:param set_bias: 是否加上偏置
:return:
"""
with slim.arg_scope([slim.batch_norm],
decay=0.999,
fused=common.batchnorm_fused,
is_training=self.trainable):
output = slim.separable_convolution2d(
input,
num_outputs=None,
stride=stride,
trainable=self.trainable,
depth_multiplier=1.0,
kernel_size=[k_h, k_w],
# activation_fn=common.activation_fn if relu else None,
activation_fn=None,
normalizer_fn=slim.batch_norm,
# weights_initializer=_init_norm,
weights_initializer=_init_xavier,
weights_regularizer=_l2_regularizer_00004,
biases_initializer=None,
padding=DEFAULT_PADDING,
scope=name + '_depthwise')
output = slim.convolution2d(
output,
c_o,
stride=1,
kernel_size=[1, 1],
activation_fn=common.activation_fn if relu else None,
weights_initializer=_init_xavier,
# weights_initializer=_init_norm,
biases_initializer=_init_zero if set_bias else None,
normalizer_fn=slim.batch_norm,
trainable=self.trainable,
weights_regularizer=None,
scope=name + '_pointwise')
frature = tf.transpose(output, [3, 1, 2, 0])[..., 0:1]
tf.summary.image(name, frature, max_outputs=32)
return output
def inverte_resblock(x,
in_channel,
out_channel,
stride,
expand_radio=6,
res_connect=True,
scope='inverte_resblock',
is_training=True):
mid_channel = in_channel * expand_radio
with tf.variable_scope(scope):
if res_connect:
short_cut = x
with slim.arg_scope([slim.convolution2d],
normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu6):
with slim.arg_scope([slim.batch_norm],
is_training=is_training,
center=True,
scale=True):
x = slim.convolution2d(x,
mid_channel, [1, 1],
stride=1,
padding='same',
biases_initializer=None,
biases_regularizer=None)
with slim.arg_scope([slim.separable_convolution2d],
normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu6):
with slim.arg_scope([slim.batch_norm],
is_training=is_training,
center=True,
scale=True):
x = slim.separable_convolution2d(x,
None, [3, 3],
depth_multiplier=1,
stride=stride,
biases_initializer=None,
biases_regularizer=None)
with slim.arg_scope([slim.convolution2d],
normalizer_fn=slim.batch_norm):
with slim.arg_scope([slim.batch_norm],
is_training=is_training,
center=True,
scale=True):
x = slim.convolution2d(x,
out_channel, [1, 1],
stride=1,
padding='same',
biases_initializer=None,
biases_regularizer=None)
if res_connect:
return x + short_cut
else:
return x
def SepConv(x, kernel_size, stride, name, is_training, labels):
with tf.variable_scope(name):
x = tf.nn.relu(x)
C_in = x.get_shape()[-1].value
x = slim.separable_convolution2d(x,
C_in,
kernel_size,
depth_multiplier=1,
stride=stride)
x = NormalizeG(name + 'n1', x, is_training,
labels) #slim.batch_norm(x)
x = slim.separable_convolution2d(x,
C_in,
kernel_size,
depth_multiplier=1)
x = NormalizeG(name + 'n2', x, is_training,
labels) #slim.batch_norm(x)
return x
def DilConv(x, C_out, kernel_size, stride, rate):
x = tflearn.relu(x)
x = slim.separable_convolution2d(x,
C_out,
kernel_size,
depth_multiplier=1,
stride=stride)
x = slim.batch_norm(x)
return x
def dwscb(self, inputs, num_filters, kernel=[3, 3]):
net = slim.separable_convolution2d(inputs,
num_outputs=None,
depth_multiplier=1,
kernel_size=kernel,
activation_fn=None)
net = tf.nn.relu(slim.batch_norm(net, fused=True))
net = self.Convblock(net, num_filters)
return net
def depthwise_conv_bn(self, name, inputs, stride=1):
with tf.variable_scope(name):
net = slim.separable_convolution2d(inputs,
None,
kernel_size=3,
depth_multiplier=1,
stride=stride)
net = slim.batch_norm(net, activation_fn=None)
return net
def res_DW_block(self,inputs,output_channels,stride=1):
res_channels=output_channels-output_channels/2
block_net=slim.separable_convolution2d(inputs,None,[3,3],stride=stride)
block_net=slim.batch_norm(block_net)
block_net=slim.convolution2d(block_net,output_channels/2,[3,3])
block_net = slim.batch_norm(block_net)
res_net=slim.convolution2d(inputs,res_channels,[3,3],stride=stride)
return tf.concat([block_net,res_net],axis=3)
def dw_conv(inputs, s, name):
output = slim.separable_convolution2d(inputs,
num_outputs=None,
stride=s,
depth_multiplier=1,
kernel_size=[3, 3],
normalizer_fn=slim.batch_norm,
scope=name+'_ds_conv')
if PRINT_LAYER_LOG:
print(name, output.get_shape())
return output
def _depthwise_separable_conv(inputs,
num_pwc_filters,
sc,
kernel_size,
stride):
""" Helper function to build the depth-wise separable convolution layer.
"""
# skip pointwise by setting num_outputs=None
depthwise_conv = slim.separable_convolution2d(inputs,
num_outputs=None,
stride=stride,
depth_multiplier=1,
kernel_size=kernel_size,
scope=sc+'/depthwise_conv')
bn = slim.batch_norm(depthwise_conv, scope=sc+'/dw_batch_norm')
pointwise_conv = slim.convolution2d(bn,
num_pwc_filters,
kernel_size=[1, 1],
scope=sc+'/pointwise_conv')
bn = slim.batch_norm(pointwise_conv, scope=sc+'/pw_batch_norm')
return bn
