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