def cifar10_shufflenet(x, n_groups=2, n_filters=200, ratio=1.0, seed=42):
layers = []
variables = []
training = tf.placeholder(tf.bool, name="training")
variables.append(("training", training))
conv = conv2d_bn_relu(x,
size=3,
n_filters=24,
is_training=training,
kernel_init=He_normal(seed=seed + 1),
name="initial_conv")
layers.append(("initial_conv", conv))
slayer1 = shufflenet.shufflenet_layer(conv,
n_filters=n_filters,
n_repeat=3,
n_groups=n_groups,
reduction_ratio=ratio,
is_training=training,
kernel_init=He_normal(seed=seed + 2),
name="shufflenet_layer_1")
layers.append(("shufflenet_layer_1", slayer1))
slayer2 = shufflenet.shufflenet_layer(slayer1,
n_filters=n_filters * 2,
n_repeat=7,
n_groups=n_groups,
reduction_ratio=ratio,
is_training=training,
kernel_init=He_normal(seed=seed + 3),
name="shufflenet_layer_2")
layers.append(("shufflenet_layer_2", slayer2))
slayer3 = shufflenet.shufflenet_layer(slayer2,
n_filters=n_filters * 4,
n_repeat=3,
n_groups=n_groups,
reduction_ratio=ratio,
is_training=training,
kernel_init=He_normal(seed=seed + 4),
name="shufflenet_layer_3")
layers.append(("shufflenet_layer_3", slayer3))
pool = global_avg_pool2d(slayer3)
layers.append(("pool", pool))
dense1 = dense(pool,
n_units=10,
kernel_init=Kumar_normal(activation=None,
mode="FAN_IN",
seed=seed + 5),
name="dense_1")
layers.append(("logit", dense1))
prob = tf.nn.softmax(dense1, name="prob")
layers.append(("prob", prob))
return layers, variables
def cifar10_resnext(x, n_blocks, cardinality = 8, group_width = 16, seed = 42):
layers = []
variables = []
training = tf.placeholder(tf.bool, name="training")
variables.append(("training", training))
conv = conv2d_bn_act(
x, size = 3, n_filters = 32,
activation = tf.nn.relu,
is_training = training,
kernel_init = He_normal(seed = seed+1),
name = "initial_conv")
layers.append(("initial_conv", conv))
res1 = resnext.residual_layer(
conv, n_blocks = n_blocks, stride = 1,
cardinality = cardinality,
group_width = group_width,
block_function = resnext.bottleneck_block,
is_training = training,
kernel_init = He_normal(seed = seed+2),
name = "residual_1")
layers.append(("residual_1", res1))
res2 = resnext.residual_layer(
res1, n_blocks = n_blocks, stride = 2,
cardinality = cardinality,
group_width = group_width*2,
block_function = resnext.bottleneck_block,
is_training = training,
kernel_init = He_normal(seed = seed+3),
name="residual_2")
layers.append(("residual_2", res2))
res3 = resnext.residual_layer(
res2, n_blocks = n_blocks, stride = 2,
cardinality = cardinality,
group_width = group_width*4,
block_function = resnext.bottleneck_block,
is_training = training,
kernel_init = He_normal(seed = seed+4),
name = "residual_3")
layers.append(("residual_3", res3))
pool = global_avg_pool2d(res3)
layers.append(("pool", pool))
dense1 = dense(
pool, n_units = 10,
kernel_init = Kumar_normal(activation = None, mode = "FAN_IN", seed = seed+5),
name = "dense_1")
layers.append(("logit", dense1))
prob = tf.nn.softmax(dense1, name = "prob")
layers.append(("prob", prob))
return layers, variables
def se_resnet_residual_block(
inputs,
n_filters,
size=3,
stride=1,
activation=tf.nn.relu,
ratio=16,
regularizer=None,
kernel_init=He_normal(seed=42),
se_kernel_init_1=He_normal(seed=42),
se_kernel_init_2=Kumar_normal(activation="sigmoid",
mode="FAN_AVG",
seed=42),
is_training=False,
name="se_resnet_residual_block"):
with tf.variable_scope(name):
if (inputs.shape[3] != n_filters) or (stride != 1):
shortcut = conv2d_bn(inputs,
size=1,
n_filters=n_filters,
stride=stride,
is_training=is_training,
regularizer=regularizer,
kernel_init=kernel_init,
name="shortcut")
else:
shortcut = tf.identity(inputs, name="shortcut")
x = conv2d_bn_act(inputs,
size=size,
n_filters=n_filters,
stride=stride,
activation=activation,
is_training=is_training,
regularizer=regularizer,
kernel_init=kernel_init,
name="conv_bn_act_1")
x = conv2d_bn(x,
size=size,
n_filters=n_filters,
stride=1,
is_training=is_training,
regularizer=regularizer,
kernel_init=kernel_init,
name="conv_bn_2")
x = squeeze_and_excite(x,
ratio=ratio,
regularizer=regularizer,
kernel_init_1=se_kernel_init_1,
kernel_init_2=se_kernel_init_2,
name="squeeze_excite")
x = tf.add(x, shortcut, name="add")
x = activation(x, name="activation_2")
return x
def separable_conv2d(inputs,
size,
n_filters,
stride=1,
depth_multiplier=1,
padding="SAME",
regularizer=None,
depth_init=He_normal(),
pointwise_init=He_normal(),
bias_init=tf.zeros_initializer(),
name="separable_conv2d"):
"""Creates a depthwise separable 2D convolutional layer.
Args:
inputs: 4D input tensor, NHWC
size: Kernel size, int or list of two ints.
n_filters: Number of filters.
stride: Stride size, int or list of two ints.
depth_multiplier: Number of depthwise convolution output channels for
each input channel.
padding: Padding algorithm "SAME" or "VALID".
depth_init: Depthwise initialization function.
pointwise_init: Pointwise initialization function.
bias_init: Bias initialization function.
name: Name of the layer.
Returns:
4D tensor.
"""
in_filt = inputs.shape[3].value
if not isinstance(size, (tuple, list)):
size = [size, size]
if not isinstance(stride, (tuple, list)):
stride = [stride, stride]
with tf.variable_scope(name):
depth_weights = tf.get_variable(
shape=[size[0], size[1], in_filt, depth_multiplier],
regularizer=regularizer,
initializer=depth_init,
name="depth_weight")
pointwise_weights = tf.get_variable(
shape=[1, 1, depth_multiplier * in_filt, n_filters],
regularizer=regularizer,
initializer=pointwise_init,
name="pointwise_weight")
biases = tf.get_variable(shape=[n_filters],
initializer=bias_init,
name="bias")
conv = tf.nn.separable_conv2d(inputs,
depth_weights,
pointwise_weights,
strides=[1, stride[0], stride[1], 1],
padding=padding,
name="separable_conv")
outputs = tf.nn.bias_add(conv, biases, name="bias_add")
return outputs
def auxiliary_classifier(inputs,
pool=avg_pool2d,
pool_size=5,
pool_stride=3,
n_filters_1x1=128,
n_units=1024,
drop_rate=0.7,
seed=42,
is_training=False,
regularizer_conv=None,
regularizer_dense=None,
kernel_init_conv=He_normal(seed=42),
kernel_init_dense=He_normal(seed=42),
name="inception_auxiliary_classifier"):
with tf.variable_scope(name):
# pool
pool = pool(inputs,
size=pool_size,
stride=pool_stride,
padding="VALID",
name="pool")
# 1x1
x_1x1 = conv2d_relu(pool,
size=1,
n_filters=n_filters_1x1,
stride=1,
regularizer=regularizer_conv,
kernel_init=kernel_init_conv,
name="conv_1x1")
# dense
flat = flatten(x_1x1, name="flatten")
dense = dense_relu(flat,
n_units=n_units,
regularizer=regularizer_dense,
kernel_init=kernel_init_dense,
name="dense")
# dropout
if drop_rate > 0.0:
dense = tf.layers.dropout(dense,
rate=drop_rate,
training=is_training,
seed=seed,
name="dropout")
return dense
def dense(inputs,
n_units,
regularizer=None,
kernel_init=He_normal(),
bias_init=tf.zeros_initializer(),
name="dense"):
"""Creates a fully-connected dense layer.
Args:
inputs: Input tensor.
n_units: Number of units.
kernel_init: Kernel initialization function.
bias_init: Bias initialization function.
name: Name of the layer.
Returns:
1D Tensor.
"""
with tf.variable_scope(name):
weights = tf.get_variable(shape=[inputs.shape[1].value, n_units],
regularizer=regularizer,
initializer=kernel_init,
name="weight")
biases = tf.get_variable(shape=[n_units],
initializer=bias_init,
name="bias")
fc = tf.matmul(inputs, weights, name="matmul")
outputs = tf.nn.bias_add(fc, biases, name="bias_add")
return outputs
def dense_act_bn(inputs,
n_units,
activation,
is_training=False,
regularizer=None,
kernel_init=He_normal(),
bias_init=tf.zeros_initializer(),
name="dense_bn_act"):
"""Creates a fully-connected dense layer with batch normalization.
Args:
inputs: Input tensor.
n_units: Number of units.
is_training: A boolean or a TensorFlow boolean scalar tensor for
indicating training or testing mode.
kernel_init: Kernel initialization function.
bias_init: Bias initialization function.
name: Name of the layer.
Returns:
1D Tensor.
"""
with tf.variable_scope(name):
x = dense(inputs,
n_units,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
name="dense")
if activation is not None:
x = activation(x, name="activation")
x = tf.layers.batch_normalization(x,
training=is_training,
name="batch_norm")
return x
def transition_layer(inputs,
pool=avg_pool2d,
pool_size=2,
pool_stride=2,
drop_rate=0.2,
theta=1.0,
activation=tf.nn.relu,
is_training=False,
regularizer=None,
kernel_init=He_normal(seed=42),
seed=42,
name="trasition_layer"):
in_filt = inputs.shape[3].value
n_filters = int(in_filt * theta)
with tf.variable_scope(name):
x = bn_act_conv2d(inputs,
size=1,
n_filters=n_filters,
stride=1,
activation=activation,
is_training=is_training,
regularizer=regularizer,
kernel_init=kernel_init,
name="bn_act_conv")
if drop_rate > 0.0:
x = tf.layers.dropout(x,
rate=drop_rate,
training=is_training,
seed=seed,
name="dropout")
x = pool(x, size=pool_size, stride=pool_stride, name="pool")
return x
def group_conv2d(inputs,
size,
cardinality,
n_filters,
stride=1,
regularizer=None,
kernel_init=He_normal(seed=42),
bias_init=tf.zeros_initializer(),
name="group_conv2d"):
with tf.variable_scope(name):
if cardinality == 1:
return conv2d(inputs,
size=size,
n_filters=n_filters,
stride=stride,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
name="conv2d")
in_split = inputs.get_shape()[3].value // cardinality
out_depth = n_filters // cardinality
conv_groups = [
conv2d(inputs[:, :, :, i * in_split:i * in_split + in_split],
size=size,
n_filters=out_depth,
stride=stride,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
name="conv2d_" + str(i)) for i in range(cardinality)
]
outputs = tf.concat(conv_groups, axis=3, name="concat")
return outputs
def residual_layer(
inputs,
cardinality,
group_width,
n_blocks = 3,
stride = 1,
is_training = False,
block_function = bottleneck_block,
kernel_init = He_normal(seed = 42),
name = "aggregated_residual_layer"
):
with tf.variable_scope(name):
x = block_function(
inputs,
cardinality = cardinality,
group_width = group_width,
stride = stride,
is_training = is_training,
kernel_init = kernel_init,
name = "residual_block_0")
for n in range(1, n_blocks):
x = block_function(
x,
cardinality = cardinality,
group_width = group_width,
stride = 1,
is_training = is_training,
kernel_init = kernel_init,
name = "residual_block_" + str(n))
return x
def dense_block(inputs,
n_repeat=5,
n_filters=12,
size=3,
drop_rate=0.2,
activation=tf.nn.relu,
regularizer=None,
kernel_init=He_normal(seed=42),
is_training=False,
seed=42,
name="dense_block"):
with tf.variable_scope(name):
shortcuts = []
shortcuts.append(inputs)
x = inputs
for r in range(n_repeat):
x = bn_act_conv2d(x,
size=size,
n_filters=n_filters,
stride=1,
activation=activation,
is_training=is_training,
regularizer=regularizer,
kernel_init=kernel_init,
name="bn_act_conv_" + str(r))
if drop_rate > 0.0:
x = tf.layers.dropout(x,
rate=drop_rate,
training=is_training,
seed=seed,
name="dropout_" + str(r))
shortcuts.append(x)
x = tf.concat(shortcuts, axis=3)
return x
def bn_act_conv2d(inputs,
size,
n_filters,
activation,
stride=1,
padding="SAME",
is_training=False,
regularizer=None,
kernel_init=He_normal(),
bias_init=tf.zeros_initializer(),
name="bn_act_conv2d"):
with tf.variable_scope(name):
x = tf.layers.batch_normalization(inputs,
training=is_training,
name="batch_norm")
if activation is not None:
x = activation(x, name="activation")
x = conv2d(x,
size,
n_filters,
stride=stride,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
name="conv2d")
return x
def middle_module(inputs,
size=3,
n_filters=728,
n_repeat=8,
block_size=3,
is_training=False,
regularizer=None,
kernel_init=He_normal(seed=42),
bias_init=tf.zeros_initializer(),
name="xception_middle_module"):
x = inputs
with tf.variable_scope(name):
for r in range(n_repeat):
shortcut = tf.identity(x, name="shortcut_" + str(r))
for s in range(block_size):
x = tf.nn.relu(x, name="relu_" + str(r) + "_" + str(s))
x = separable_conv2d(x,
size=size,
n_filters=n_filters,
stride=1,
depth_multiplier=1,
regularizer=regularizer,
depth_init=kernel_init,
pointwise_init=kernel_init,
bias_init=bias_init,
name="separable_conv_" + str(r) + "_" +
str(s))
x = tf.layers.batch_normalization(x,
training=is_training,
name="bn_" + str(r) + "_" +
str(s))
x = tf.add(x, shortcut, name="add_" + str(r))
return x
def exit_module(inputs,
size=3,
n_filters_1=[728, 1024],
n_filters_2=[1536, 2048],
pool_size=3,
is_training=False,
regularizer=None,
kernel_init=He_normal(seed=42),
bias_init=tf.zeros_initializer(),
name="xception_exit_module"):
with tf.variable_scope(name):
shortcut = conv2d_bn(inputs,
size=1,
n_filters=n_filters_1[-1],
stride=2,
is_training=is_training,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
name="shortcut")
x = inputs
for r in range(len(n_filters_1)):
x = tf.nn.relu(x, name="relu_1_" + str(r))
x = separable_conv2d(x,
size=size,
n_filters=n_filters_1[r],
stride=1,
depth_multiplier=1,
regularizer=regularizer,
depth_init=kernel_init,
pointwise_init=kernel_init,
bias_init=bias_init,
name="separable_conv_1_" + str(r))
x = tf.layers.batch_normalization(x,
training=is_training,
name="bn_1_" + str(r))
x = max_pool2d(x, size=pool_size, stride=2, name="max_pool")
x = tf.add(x, shortcut, name="add_1")
for r in range(len(n_filters_2)):
x = separable_conv2d(x,
size=size,
n_filters=n_filters_2[r],
stride=1,
depth_multiplier=1,
regularizer=regularizer,
depth_init=kernel_init,
pointwise_init=kernel_init,
bias_init=bias_init,
name="separable_conv_2_" + str(r))
x = tf.layers.batch_normalization(x,
training=is_training,
name="bn_2_" + str(r))
x = tf.nn.relu(x, name="relu_2_" + str(r))
return x
def bottleneck_block(inputs,
n_filters,
n_filters_reduce,
size=3,
stride=1,
activation=tf.nn.relu,
regularizer=None,
kernel_init=He_normal(seed=42),
is_training=False,
name="bottleneck_block"):
with tf.variable_scope(name):
if (inputs.shape[3] != n_filters) or (stride != 1):
shortcut = conv2d_bn(inputs,
size=1,
n_filters=n_filters,
stride=stride,
is_training=is_training,
regularizer=regularizer,
kernel_init=kernel_init,
name="shortcut")
else:
shortcut = tf.identity(inputs, name="shortcut")
x = conv2d_bn_act(inputs,
size=1,
n_filters=n_filters_reduce,
stride=stride,
activation=activation,
is_training=is_training,
regularizer=regularizer,
kernel_init=kernel_init,
name="conv_bn_act_1")
x = conv2d_bn_act(x,
size=size,
n_filters=n_filters_reduce,
stride=1,
activation=activation,
is_training=is_training,
regularizer=regularizer,
kernel_init=kernel_init,
name="conv_bn_act_2")
x = conv2d_bn(x,
size=1,
n_filters=n_filters,
stride=1,
is_training=is_training,
regularizer=regularizer,
kernel_init=kernel_init,
name="conv_bn_3")
x = tf.add(x, shortcut, name="add")
x = activation(x, name="activation_3")
return x
def bottleneck_block(
inputs,
cardinality,
group_width,
size = 3,
stride = 1,
activation = tf.nn.relu,
is_training = False,
regularizer = None,
kernel_init = He_normal(seed = 42),
name = "bottleneck_block"):
n_filters_reduce = cardinality*group_width
n_filters = n_filters_reduce*2
with tf.variable_scope(name):
if (inputs.shape[3] != n_filters) or (stride != 1):
shortcut = conv2d_bn(
inputs, size = 1, n_filters = n_filters, stride = stride,
is_training = is_training,
regularizer = regularizer,
kernel_init = kernel_init,
name = "shortcut")
else:
shortcut = tf.identity(inputs, name = "shortcut")
x = conv2d_bn_act(
inputs, size = 1, n_filters = n_filters_reduce, stride = 1,
activation = activation,
is_training = is_training,
regularizer = regularizer,
kernel_init = kernel_init,
name = "conv_bn_act_1")
x = group_conv2d(
x, size = size, stride = stride,
cardinality = cardinality,
n_filters = n_filters_reduce,
regularizer = regularizer,
kernel_init = kernel_init,
name = "group_conv_2"
)
x = tf.layers.batch_normalization(
x, training = is_training, name = "batch_norm_2")
x = activation(x, name = "activation_2")
x = conv2d_bn(
x, size = 1, n_filters = n_filters, stride = 1,
is_training = is_training,
regularizer = regularizer,
kernel_init = kernel_init,
name = "conv_bn_3")
x = tf.add(x, shortcut, name = "add")
x = activation(x, name = "activation_3")
return x
def auxiliary_classifier_bn(inputs,
pool=avg_pool2d,
pool_size=5,
pool_stride=3,
n_filters_1x1=128,
n_units=1024,
is_training=False,
regularizer_conv=None,
regularizer_dense=None,
kernel_init_conv=He_normal(seed=42),
kernel_init_dense=He_normal(seed=42),
name="inception_auxiliary_classifier_batchnorm"):
with tf.variable_scope(name):
# pool
pool = pool(inputs,
size=pool_size,
stride=pool_stride,
padding="VALID",
name="pool")
# 1x1
x_1x1 = conv2d_bn_relu(inputs,
size=1,
n_filters=n_filters_1x1,
stride=1,
is_training=is_training,
regularizer=regularizer_conv,
kernel_init=kernel_init_conv,
name="conv_1x1")
# dense
flat = flatten(x_1x1, name="flatten")
dense = dense_bn_relu(flat,
n_units=n_units,
is_training=is_training,
regularizer=regularizer_dense,
kernel_init=kernel_init_dense,
name="dense")
return dense
def auxiliary_classifier(inputs,
classes,
is_training=False,
regularizer=None,
activation=tf.nn.relu,
conv_kernel_init=He_normal(seed=42),
conv_bias_init=tf.zeros_initializer(),
dense_kernel_init=Kumar_normal(activation=None,
mode="FAN_IN",
seed=42),
name="nasnet_auxiliary_classifier"):
with tf.variable_scope(name):
x = inputs
if activation is not None:
x = activation(x, name="activation_1")
x = avg_pool2d(x, size=5, stride=3, padding="VALID", name="avg_pool")
x = conv2d_bn(x,
n_filters=128,
size=1,
is_training=is_training,
regularizer=regularizer,
kernel_init=conv_kernel_init,
bias_init=conv_bias_init,
name="conv_projection")
if activation is not None:
x = activation(x, name="activation_2")
x = conv2d_bn(x,
n_filters=768,
size=[x.get_shape()[1].value,
x.get_shape()[2].value],
padding="VALID",
is_training=is_training,
regularizer=regularizer,
kernel_init=conv_kernel_init,
bias_init=conv_bias_init,
name="conv_reduction")
if activation is not None:
x = activation(x, name="activation_3")
x = global_avg_pool2d(x, name="global_avg_pool")
x = dense(x,
n_units=classes,
regularizer=regularizer,
kernel_init=dense_kernel_init,
name="dense")
return x
def identity_mapping_block(
inputs,
n_filters,
size = 3,
stride = 1,
activation = tf.nn.relu,
regularizer = None,
kernel_init = He_normal(seed = 42),
is_training = False,
skip_first_bn_act = False,
name = "residual_block"):
with tf.variable_scope(name):
if (inputs.shape[3] != n_filters) or (stride != 1):
shortcut = conv2d(
inputs, size = 1, n_filters = n_filters, stride = stride,
regularizer = regularizer,
kernel_init = kernel_init,
name = "shortcut")
else:
shortcut = tf.identity(inputs, name = "shortcut")
if skip_first_bn_act:
x = conv2d(
inputs, size = size, n_filters = n_filters, stride = stride,
regularizer = regularizer,
kernel_init = kernel_init,
name = "conv_1")
else:
x = bn_act_conv2d(
inputs, size = size, n_filters = n_filters, stride = stride,
activation = activation,
is_training = is_training,
regularizer = regularizer,
kernel_init = kernel_init,
name = "bn_act_conv_1")
x = bn_act_conv2d(
x, size = size, n_filters = n_filters, stride = 1,
activation = activation,
is_training = is_training,
regularizer = regularizer,
kernel_init = kernel_init,
name = "bn_act_conv_2")
x = tf.add(x, shortcut, name = "add")
return x
def dense_act(inputs,
n_units,
activation,
regularizer=None,
kernel_init=He_normal(),
bias_init=tf.zeros_initializer(),
name="dense_act"):
with tf.variable_scope(name):
x = dense(inputs,
n_units,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
name="dense")
if activation is not None:
x = activation(x, name="activation")
return x
def entry_block(inputs,
n_filters,
n_repeat=2,
conv_size=3,
pool_size=3,
init_activation=tf.nn.relu,
regularizer=None,
kernel_init=He_normal(seed=42),
bias_init=tf.zeros_initializer(),
is_training=False,
name="xception_entry_block"):
with tf.variable_scope(name):
shortcut = conv2d_bn(inputs,
size=1,
n_filters=n_filters,
stride=2,
is_training=is_training,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
name="shortcut")
x = inputs
for r in range(n_repeat):
if r == 0:
activation = init_activation
else:
activation = tf.nn.relu
if activation is not None:
x = activation(x)
x = separable_conv2d(x,
size=conv_size,
n_filters=n_filters,
stride=1,
depth_multiplier=1,
regularizer=regularizer,
depth_init=kernel_init,
pointwise_init=kernel_init,
bias_init=bias_init,
name="separable_conv_" + str(r))
x = tf.layers.batch_normalization(x,
training=is_training,
name="bn_" + str(r))
x = max_pool2d(x, size=pool_size, stride=2, name="max_pool")
outputs = tf.add(x, shortcut, name="add")
return outputs
def mobilenet_block(inputs,
n_filters,
stride=1,
conv_size=3,
alpha=1.0,
activation=tf.nn.relu,
regularizer=None,
kernel_init=He_normal(seed=42),
bias_init=tf.zeros_initializer(),
is_training=False,
name="mobilenet_block"):
in_filt = inputs.shape[3].value
n_filters_sep = int(in_filt * alpha)
n_filters_conv = int(n_filters * alpha)
with tf.variable_scope(name):
x = separable_conv2d(inputs,
size=conv_size,
n_filters=n_filters_sep,
stride=stride,
regularizer=regularizer,
depth_init=kernel_init,
pointwise_init=kernel_init,
bias_init=bias_init,
name="separable_conv")
x = tf.layers.batch_normalization(x,
training=is_training,
name="batch_norm_1")
if activation is not None:
x = activation(x, name="activation_1")
x = conv2d(x,
size=1,
n_filters=n_filters_conv,
stride=1,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
name="conv")
x = tf.layers.batch_normalization(x,
training=is_training,
name="batch_norm_2")
if activation is not None:
x = activation(x, name="activation_2")
return x
def conv2d(inputs,
size,
n_filters,
stride=1,
padding="SAME",
regularizer=None,
kernel_init=He_normal(),
bias_init=tf.zeros_initializer(),
name="conv2d"):
"""Creates a 2D convolutional layer.
Args:
inputs: 4D input tensor, NHWC
size: Kernel size, int or list of two ints.
n_filters: Number of filters.
stride: Stride size, int or list of two ints.
padding: Padding algorithm "SAME" or "VALID".
kernel_init: Kernel initialization function.
bias_init: Bias initialization function.
name: Name of the layer.
Returns:
4D tensor.
"""
in_filt = inputs.shape[3].value
if not isinstance(size, (tuple, list)):
size = [size, size]
if not isinstance(stride, (tuple, list)):
stride = [stride, stride]
with tf.variable_scope(name):
weights = tf.get_variable(shape=[size[0], size[1], in_filt, n_filters],
regularizer=regularizer,
initializer=kernel_init,
name="weight")
biases = tf.get_variable(shape=[n_filters],
initializer=bias_init,
name="bias")
conv = tf.nn.conv2d(inputs,
weights,
strides=[1, stride[0], stride[1], 1],
padding=padding,
name="conv")
outputs = tf.nn.bias_add(conv, biases, name="bias_add")
return outputs
def shufflenet_layer(inputs,
n_filters,
n_repeat,
size=3,
reduction_ratio=0.25,
n_groups=8,
is_training=False,
regularizer=None,
kernel_init=He_normal(seed=42),
bias_init=tf.zeros_initializer(),
name="shufflenet_layer"):
with tf.variable_scope(name):
x = shuffle_unit(inputs,
n_filters=n_filters,
size=size,
stride=2,
activation=tf.nn.relu,
reduction_ratio=reduction_ratio,
n_groups=n_groups,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
is_training=is_training,
name="shuffle_unit_0")
for n in range(0, n_repeat):
x = shuffle_unit(x,
n_filters=n_filters,
size=size,
stride=1,
activation=tf.nn.relu,
reduction_ratio=reduction_ratio,
n_groups=n_groups,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
is_training=is_training,
name="shuffle_unit_" + str(n + 1))
return x
def inverted_residual_block(inputs,
n_filters,
n_repeat=2,
expand_ratio=1.0,
size=3,
stride=1,
activation=tf.nn.relu6,
regularizer=None,
kernel_init=He_normal(seed=42),
bias_init=tf.zeros_initializer(),
is_training=False,
name="inverted_residual_block"):
with tf.variable_scope(name):
x = inverted_residual(inputs,
n_filters=n_filters,
expand_ratio=expand_ratio,
size=size,
stride=stride,
activation=activation,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
is_training=is_training,
name="inverted_residual_0")
for n in range(0, n_repeat - 1):
x = inverted_residual(x,
n_filters=n_filters,
expand_ratio=expand_ratio,
size=size,
stride=1,
activation=activation,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
is_training=is_training,
name="inverted_residual_" + str(n + 1))
return x
def squeeze(x,
n_filters,
activation=tf.nn.relu,
is_training=False,
regularizer=None,
kernel_init=He_normal(seed=42),
bias_init=tf.zeros_initializer(),
name="squeeze"):
with tf.variable_scope(name):
if activation is not None:
x = activation(x, name="activation")
x = conv2d_bn(x,
n_filters=n_filters,
size=1,
stride=1,
is_training=is_training,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
name="conv")
return x
def group_conv2d_fixdepth(inputs,
size,
cardinality,
group_width,
stride=1,
regularizer=None,
kernel_init=He_normal(seed=42),
bias_init=tf.zeros_initializer(),
name="group_conv2d"):
if cardinality == 1:
return conv2d(inputs,
size=size,
n_filters=group_width,
stride=stride,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
name=name)
with tf.variable_scope(name):
size_splits = [group_width] * cardinality
groups = tf.split(inputs, size_splits, axis=3, name="split")
conv_groups = []
for i, group in enumerate(groups):
conv = conv2d(group,
size=size,
n_filters=group_width,
stride=stride,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
name="conv2d_" + str(i))
conv_groups.append(conv)
outputs = tf.concat(conv_groups, axis=3, name="concat")
return outputs
def conv2d_act(inputs,
size,
n_filters,
activation,
stride=1,
padding="SAME",
regularizer=None,
kernel_init=He_normal(),
bias_init=tf.zeros_initializer(),
name="conv2d_act"):
with tf.variable_scope(name):
x = conv2d(inputs,
size,
n_filters,
stride=stride,
padding=padding,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
name="conv2d")
if activation is not None:
x = activation(x, name="activation")
return x
def residual_layer(inputs,
n_filters,
n_blocks,
stride=1,
block_function=residual_block,
is_training=False,
kernel_init=He_normal(seed=42),
name="residual_layer"):
with tf.variable_scope(name):
x = block_function(inputs,
n_filters=n_filters,
stride=stride,
is_training=is_training,
kernel_init=kernel_init,
name="residual_block_0")
for n in range(1, n_blocks):
x = block_function(x,
n_filters=n_filters,
stride=1,
is_training=is_training,
kernel_init=kernel_init,
name="residual_block_" + str(n))
return x
def entry_module(inputs,
conv_size=3,
pool_size=3,
n_filters=[128, 256, 728],
is_training=False,
regularizer=None,
kernel_init=He_normal(seed=42),
bias_init=tf.zeros_initializer(),
name="xception_entry_module"):
with tf.variable_scope(name):
x = inputs
for s in range(len(n_filters)):
init_act = None if s == 0 else tf.nn.relu
x = entry_block(x,
n_filters=n_filters[s],
conv_size=conv_size,
pool_size=pool_size,
init_activation=init_act,
regularizer=regularizer,
kernel_init=kernel_init,
bias_init=bias_init,
is_training=is_training,
name="entry_block_" + str(s))
return x
