def residual_path(input_var,
out_channels,
scope=None,
stride=[1, 1],
kernel_sizes=[1, 3],
activation=tf.keras.activations.relu,
padding='SAME',
spectral_norm_flag=False,
update_collection=False,
is_training=True,
use_batch_norm=False,
use_cross_replica_batch_norm=False,
num_cores=8,
initializer=tf.keras.initializers.glorot_normal):
with tf.variable_scope(scope):
# first conv
output_var = conv_batchnorm_relu(
input_var,
'Conv2d_Unit1',
out_channels,
kernel_size=kernel_sizes[0],
stride=stride[0],
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
padding=padding)
# second conv
output_var = conv_batchnorm_relu(
output_var,
'Conv2d_Unit2',
out_channels,
kernel_size=kernel_sizes[1],
stride=stride[1],
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
padding=padding)
# after this technically we need to merge other paths with a 1x1 convolution
return output_var
def network_head(input_var,
out_channels,
stride=[1, 1],
kernel_sizes=[3, 3],
activation=tf.keras.activations.relu,
padding='SAME',
spectral_norm_flag=False,
update_collection=False,
is_training=True,
use_batch_norm=False,
use_cross_replica_batch_norm=False,
num_cores=8,
initializer=tf.keras.initializers.glorot_normal):
intermediate_layer = conv_batchnorm_relu(
input_var,
'Conv2d_3x3_a',
out_channels,
kernel_size=kernel_sizes[0],
stride=stride[0],
padding=padding,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
head = conv_batchnorm_relu(
intermediate_layer,
'Conv2d_3x3_b',
out_channels,
kernel_size=kernel_sizes[0],
stride=stride[0],
padding=padding,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
return head
def build_network():
network = i3d.InceptionI3d(
final_endpoint=FLAGS.final_endpoint,
use_batch_norm=FLAGS.use_batch_norm,
use_cross_replica_batch_norm=FLAGS.use_cross_replica_batch_norm,
num_cores=FLAGS.train_num_cores,
num_classes=FLAGS.num_classes,
spatial_squeeze=True,
dropout_keep_prob=0.7)
if FLAGS.final_endpoint == 'Logits':
logits, end_points = network(
inputs=features['video'],
is_training=(mode == tf.estimator.ModeKeys.TRAIN))
return logits
else:
descriptors, end_points = network(
inputs=features['video'],
is_training=(mode == tf.estimator.ModeKeys.TRAIN))
# From the descriptors, we need to downsample now. That should be an input argument.
t_subsample_factor = FLAGS.time_divisor
hw_subsample_factor = FLAGS.hw_divisor
spatial_squeeze = True
end_point = 'Logits'
with tf.variable_scope(end_point):
fc_inputs = avgpool(descriptors,
ksize=[
1, t_subsample_factor,
hw_subsample_factor,
hw_subsample_factor, 1
],
strides=[1, 1, 1, 1, 1],
padding='VALID')
get_shape = fc_inputs.get_shape().as_list()
print('{} / Average-pool3D: {}'.format(end_point, get_shape))
end_points[end_point + '_average_pool3d'] = fc_inputs
# Dropout
fc_inputs = tf.nn.dropout(fc_inputs, 0.7)
# Use two FC layers
if FLAGS.double_logits:
fc_inputs = conv_batchnorm_relu(
fc_inputs,
'Conv3d_xx_1x1',
256,
kernel_size=1,
stride=1,
use_batch_norm=FLAGS.use_batch_norm,
use_cross_replica_batch_norm=FLAGS.
use_cross_replica_batch_norm,
is_training=(mode == tf.estimator.ModeKeys.TRAIN),
num_cores=FLAGS.train_num_cores)
get_shape = fc_inputs.get_shape().as_list()
print('{} / Conv3d_xx_1x1 : {}'.format(
end_point, get_shape))
# 1x1x1 Conv, stride 1
logits = conv_batchnorm_relu(
fc_inputs,
'Conv3d_0c_1x1',
FLAGS.num_classes,
kernel_size=1,
stride=1,
activation=None,
use_batch_norm=False,
use_cross_replica_batch_norm=False,
is_training=(mode == tf.estimator.ModeKeys.TRAIN),
num_cores=FLAGS.train_num_cores)
get_shape = logits.get_shape().as_list()
print('{} / Conv3d_0c_1x1 : {}'.format(end_point, get_shape))
if spatial_squeeze:
# Removes dimensions of size 1 from the shape of a tensor
# Specify which dimensions have to be removed: 2 and 3
logits = tf.squeeze(logits, [2, 3], name='SpatialSqueeze')
get_shape = logits.get_shape().as_list()
print('{} / Spatial Squeeze : {}'.format(
end_point, get_shape))
averaged_logits = tf.reduce_mean(logits,
axis=1) # [N, num_classes]
get_shape = averaged_logits.get_shape().as_list()
print('{} / Averaged Logits : {}'.format(end_point, get_shape))
end_points[end_point] = averaged_logits
return averaged_logits
def model(inputs, is_training):
net = inputs
layer_outputs = {}
print('Input: {}'.format(net.get_shape().as_list()))
with tf.variable_scope(model_scope_name):
# Encode_1
end_point = 'Encode_1'
with tf.variable_scope(end_point):
# 3x3 Conv, padding='same'
conv2d_1a = conv_batchnorm_relu(
net,
'Conv2d_1a',
num_classes,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_1a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_1a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_1a
# 3x3 Conv, padding='same'
conv2d_1b = conv_batchnorm_relu(
conv2d_1a,
'Conv2d_1b',
num_classes,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_1b.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_1b'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_1b
# 2x2 MaxPool
maxpool_1a = maxpool(conv2d_1b,
'MaxPool_1a',
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
get_shape = maxpool_1a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'MaxPool_1a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = maxpool_1a
if final_endpoint == end_point: return maxpool_1a, layer_outputs
# Encode_2
end_point = 'Encode_2'
with tf.variable_scope(end_point):
# 3x3 Conv, padding='same'
conv2d_2a = conv_batchnorm_relu(
maxpool_1a,
'Conv2d_2a',
num_classes * 2,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_2a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_2a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_2a
# 3x3 Conv, padding='same'
conv2d_2b = conv_batchnorm_relu(
conv2d_2a,
'Conv2d_2b',
num_classes * 2,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_2b.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_2b'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_2b
# 2x2 MaxPool
maxpool_2a = maxpool(conv2d_2b,
'MaxPool_2a',
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
get_shape = maxpool_2a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'MaxPool_2a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = maxpool_2a
layer_outputs[end_point] = maxpool_2a
if final_endpoint == end_point: return maxpool_2a, layer_outputs
# Encode_3
end_point = 'Encode_3'
with tf.variable_scope(end_point):
# 3x3 Conv, padding='same'
conv2d_3a = conv_batchnorm_relu(
maxpool_2a,
'Conv2d_3a',
num_classes * 4,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_3a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_3a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_3a
# 3x3 Conv, padding='same'
conv2d_3b = conv_batchnorm_relu(
conv2d_3a,
'Conv2d_3b',
num_classes * 4,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_3b.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_3b'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_3b
# 2x2 MaxPool
maxpool_3a = maxpool(conv2d_3b,
'MaxPool_3a',
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
get_shape = maxpool_3a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'MaxPool_3a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = maxpool_3a
layer_outputs[end_point] = maxpool_3a
if final_endpoint == end_point: return maxpool_3a, layer_outputs
# Encode_4
end_point = 'Encode_4'
with tf.variable_scope(end_point):
# 3x3 Conv, padding='same'
conv2d_4a = conv_batchnorm_relu(
maxpool_3a,
'Conv2d_4a',
num_classes * 8,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_4a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_4a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_4a
# 3x3 Conv, padding='same'
conv2d_4b = conv_batchnorm_relu(
conv2d_4a,
'Conv2d_4b',
num_classes * 8,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_4b.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_4b'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_4b
# 2x2 MaxPool
maxpool_4a = maxpool(conv2d_4b,
'MaxPool_4a',
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
get_shape = maxpool_4a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'MaxPool_4a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = maxpool_4a
layer_outputs[end_point] = maxpool_4a
if final_endpoint == end_point: return maxpool_4a, layer_outputs
# Encode_5
end_point = 'Encode_5'
with tf.variable_scope(end_point):
# 3x3 Conv, padding='same'
conv2d_5a = conv_batchnorm_relu(
maxpool_4a,
'Conv2d_5a',
num_classes * 16,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_5a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_5a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_5a
# 3x3 Conv, padding='same'
conv2d_5b = conv_batchnorm_relu(
conv2d_5a,
'Conv2d_5b',
num_classes * 16,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_5b.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_5b'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_5b
layer_outputs[end_point] = conv2d_5b
if final_endpoint == end_point: return conv2d_5b, layer_outputs
# Decode_1
end_point = 'Decode_1'
with tf.variable_scope(end_point):
# Up-convolution
upconv2d_1a = upconv_2D(conv2d_5b,
'UpConv2d_1a',
num_classes * 8,
kernel_size=(2, 2),
strides=(2, 2),
use_bias=True,
padding='valid')
get_shape = upconv2d_1a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'UpConv2d_1a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = upconv2d_1a
# Merge
merge_1a = tf.concat([conv2d_4b, upconv2d_1a],
axis=-1,
name='merge_1a')
get_shape = merge_1a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'merge_1a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = merge_1a
# 3x3 Conv, padding='same'
conv2d_d_1a = conv_batchnorm_relu(
merge_1a,
'Conv2d_d_1a',
num_classes * 8,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_d_1a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_d_1a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_d_1a
# 3x3 Conv, padding='same'
conv2d_d_1b = conv_batchnorm_relu(
conv2d_d_1a,
'Conv2d_d_1b',
num_classes * 8,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_d_1b.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_d_1b'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_d_1b
layer_outputs[end_point] = conv2d_d_1b
if final_endpoint == end_point: return conv2d_d_1b, layer_outputs
# Decode_2
end_point = 'Decode_2'
with tf.variable_scope(end_point):
# Up-convolution
upconv2d_2a = upconv_2D(conv2d_d_1b,
'UpConv2d_2a',
num_classes * 4,
kernel_size=(2, 2),
strides=(2, 2),
use_bias=True,
padding='valid')
get_shape = upconv2d_2a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'UpConv2d_2a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = upconv2d_2a
# Merge
merge_2a = tf.concat([conv2d_3b, upconv2d_2a],
axis=-1,
name='merge_2a')
get_shape = merge_2a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'merge_2a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = merge_2a
# 3x3 Conv, padding='same'
conv2d_d_2a = conv_batchnorm_relu(
merge_2a,
'Conv2d_d_2a',
num_classes * 4,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_d_2a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_d_2a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_d_2a
# 3x3 Conv, padding='same'
conv2d_d_2b = conv_batchnorm_relu(
conv2d_d_2a,
'Conv2d_d_2b',
num_classes * 4,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_d_2b.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_d_2b'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_d_2b
layer_outputs[end_point] = conv2d_d_2b
if final_endpoint == end_point: return conv2d_d_2b, layer_outputs
# Decode_3
end_point = 'Decode_3'
with tf.variable_scope(end_point):
# Up-convolution
upconv2d_3a = upconv_2D(conv2d_d_2b,
'UpConv2d_3a',
num_classes * 2,
kernel_size=(2, 2),
strides=(2, 2),
use_bias=True,
padding='valid')
get_shape = upconv2d_3a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'UpConv2d_3a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = upconv2d_3a
# Merge
merge_3a = tf.concat([conv2d_2b, upconv2d_3a],
axis=-1,
name='merge_3a')
get_shape = merge_3a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'merge_3a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = merge_3a
# 3x3 Conv, padding='same'
conv2d_d_3a = conv_batchnorm_relu(
merge_3a,
'Conv2d_d_3a',
num_classes * 2,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_d_3a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_d_3a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_d_3a
# 3x3 Conv, padding='same'
conv2d_d_3b = conv_batchnorm_relu(
conv2d_d_3a,
'Conv2d_d_3b',
num_classes * 2,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_d_3b.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_d_3b'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_d_3b
layer_outputs[end_point] = conv2d_d_3b
if final_endpoint == end_point: return conv2d_d_3b, layer_outputs
# Decode_4
end_point = 'Decode_4'
with tf.variable_scope(end_point):
# Up-convolution
upconv2d_4a = upconv_2D(conv2d_d_3b,
'UpConv2d_4a',
num_classes,
kernel_size=(2, 2),
strides=(2, 2),
use_bias=True,
padding='valid')
get_shape = upconv2d_4a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'UpConv2d_4a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = upconv2d_4a
# Merge
merge_4a = tf.concat([conv2d_1b, upconv2d_4a],
axis=-1,
name='merge_4a')
get_shape = merge_4a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'merge_4a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = merge_4a
# 3x3 Conv, padding='same'
conv2d_d_4a = conv_batchnorm_relu(
merge_4a,
'Conv2d_d_4a',
num_classes,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_d_4a.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_d_4a'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_d_4a
# 3x3 Conv, padding='same'
conv2d_d_4b = conv_batchnorm_relu(
conv2d_d_4a,
'Conv2d_d_4b',
num_classes,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_d_4b.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_d_4b'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_d_4b
# 1x1 Conv, padding='same'
if single_channel:
num_output_channels = 1
else:
num_output_channels = num_classes
####
conv2d_d_4c = conv_batchnorm_relu(
conv2d_d_4b,
'Conv2d_d_4c',
num_output_channels,
kernel_size=1,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm
) #,
#activation=None)
get_shape = conv2d_d_4c.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'Conv2d_d_4c'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_d_4c
layer_outputs[end_point] = conv2d_d_4c
if final_endpoint == end_point: return conv2d_d_4c, layer_outputs
def model(inputs, is_training):
net = inputs
end_points = {}
print('Inputs: {}'.format(net.get_shape().as_list()))
# 7x7x7 Conv, stride 2
end_point = 'Conv3d_1a_7x7'
net = conv_batchnorm_relu(
net,
end_point,
64,
kernel_size=7,
stride=2,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# 1x3x3 Max-pool, stride 1, 2, 2
end_point = 'MaxPool3d_2a_3x3'
net = maxpool(net,
end_point,
ksize=[1, 1, 3, 3, 1],
strides=[1, 1, 2, 2, 1],
padding='SAME')
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# 1x1x1 Conv, stride 1
end_point = 'Conv3d_2b_1x1'
net = conv_batchnorm_relu(
net,
end_point,
64,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# 3x3x3 Conv, stride 1
end_point = 'Conv3d_2c_3x3'
net = conv_batchnorm_relu(
net,
end_point,
192,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# 1x3x3 Max-pool, stride 1, 2, 2
end_point = 'MaxPool3d_3a_3x3'
net = maxpool(net,
end_point,
ksize=[1, 1, 3, 3, 1],
strides=[1, 1, 2, 2, 1],
padding='SAME')
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# Mixed 3b : Inception block
end_point = 'Mixed_3b'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
# 1x1x1 Conv, stride 1
branch_0 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
64,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_1'):
# 1x1x1 Conv, stride 1
branch_1 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
96,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_1 = conv_batchnorm_relu(
branch_1,
'Conv3d_0b_3x3',
128,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_2'):
# 1x1x1 Conv, stride 1
branch_2 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
16,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_2 = conv_batchnorm_relu(
branch_2,
'Conv3d_0b_3x3',
32,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_3'):
# 3x3x3 Max-pool, stride 1, 1, 1
branch_3 = maxpool(net,
'MaxPool3d_0a_3x3',
ksize=[1, 3, 3, 3, 1],
strides=[1, 1, 1, 1, 1],
padding='SAME')
# 1x1x1 Conv, stride 1
branch_3 = conv_batchnorm_relu(
branch_3,
'Conv3d_0b_1x1',
32,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# Concat branch_[0-3]
net = tf.concat([branch_0, branch_1, branch_2, branch_3], 4)
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# Mixed 3c: Inception block
end_point = 'Mixed_3c'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
# 1x1x1 Conv, stride 1
branch_0 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
128,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_1'):
# 1x1x1 Conv, stride 1
branch_1 = conv_batchnorm_relu(
net,
'Conv3d_0b_1x1',
128,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_1 = conv_batchnorm_relu(
branch_1,
'Conv3d_0b_3x3',
192,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_2'):
# 1x1x1 Conv, stride 1
branch_2 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
32,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_2 = conv_batchnorm_relu(
branch_2,
'Conv3d_0b_3x3',
96,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_3'):
# 3x3x3 Max-Pool, stride 1, 1, 1
branch_3 = maxpool(net,
'MaxPool3d_0a_3x3',
ksize=[1, 3, 3, 3, 1],
strides=[1, 1, 1, 1, 1],
padding='SAME')
# 1x1x1 Conv, stide 1
branch_3 = conv_batchnorm_relu(
branch_3,
'Conv3d_0b_1x1',
64,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# Concat branch_[0-3]
net = tf.concat([branch_0, branch_1, branch_2, branch_3], 4)
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# 3x3x3 Max-pool, stride 2, 2, 2
end_point = 'MaxPool3d_4a_3x3'
net = maxpool(net,
end_point,
ksize=[1, 3, 3, 3, 1],
strides=[1, 2, 2, 2, 1],
padding='SAME')
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# Mixed 4b: Inception block
end_point = 'Mixed_4b'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
# 1x1x1 Conv, stride 1
branch_0 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
192,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_1'):
# 1x1x1 Conv, stride 1
branch_1 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
96,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_1 = conv_batchnorm_relu(
branch_1,
'Conv3d_0b_3x3',
208,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_2'):
# 1x1x1 Conv, stride 1
branch_2 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
16,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_2 = conv_batchnorm_relu(
branch_2,
'Conv3d_0b_3x3',
48,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_3'):
# 3x3x3 Max-pool, stride 1, 1, 1
branch_3 = maxpool(net,
'MaxPool3d_0a_3x3',
ksize=[1, 3, 3, 3, 1],
strides=[1, 1, 1, 1, 1],
padding='SAME')
# 1x1x1 Conv, stride 1
branch_3 = conv_batchnorm_relu(
branch_3,
'Conv3d_0b_1x1',
64,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# Concat branch_[0-3]
net = tf.concat([branch_0, branch_1, branch_2, branch_3], 4)
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# Mixed 4c: Inception block
end_point = 'Mixed_4c'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
# 1x1x1 Conv, stride 1
branch_0 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
160,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_1'):
# 1x1x1 Conv, stride 1
branch_1 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
112,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_1 = conv_batchnorm_relu(
branch_1,
'Conv3d_0b_3x3',
224,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_2'):
# 1x1x1 Conv, stride 1
branch_2 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
24,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_2 = conv_batchnorm_relu(
branch_2,
'Conv3d_0b_3x3',
64,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_3'):
# 3x3x3 Max-pool, stride 1, 1, 1
branch_3 = maxpool(net,
'MaxPool3d_0a_3x3',
ksize=[1, 3, 3, 3, 1],
strides=[1, 1, 1, 1, 1],
padding='SAME')
# 1x1x1 Conv, stride 1
branch_3 = conv_batchnorm_relu(
branch_3,
'Conv3d_0b_1x1',
64,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# Concat branch_[0-3]
net = tf.concat([branch_0, branch_1, branch_2, branch_3], 4)
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# Mixed 4d: Inception block
end_point = 'Mixed_4d'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
# 1x1x1 Conv, stride 1
branch_0 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
128,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_1'):
# 1x1x1 Conv, stride 1
branch_1 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
128,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_1 = conv_batchnorm_relu(
branch_1,
'Conv3d_0b_3x3',
256,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_2'):
# 1x1x1 Conv, stride 1
branch_2 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
24,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_2 = conv_batchnorm_relu(
branch_2,
'Conv3d_0b_3x3',
64,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_3'):
# 3x3x3 Max-pool, stride 1, 1, 1
branch_3 = maxpool(net,
'MaxPool3d_0a_3x3',
ksize=[1, 3, 3, 3, 1],
strides=[1, 1, 1, 1, 1],
padding='SAME')
# 1x1x1 Conv, stride 1
branch_3 = conv_batchnorm_relu(
branch_3,
'Conv3d_0b_1x1',
64,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# Concat branch_[0-3]
net = tf.concat([branch_0, branch_1, branch_2, branch_3], 4)
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# Mixed 4e: Inception block
end_point = 'Mixed_4e'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
# 1x1x1 Conv, stride 1
branch_0 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
112,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_1'):
# 1x1x1 Conv, stride 1
branch_1 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
144,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_1 = conv_batchnorm_relu(
branch_1,
'Conv3d_0b_3x3',
288,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_2'):
# 1x1x1 Conv, stride 1
branch_2 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
32,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_2 = conv_batchnorm_relu(
branch_2,
'Conv3d_0b_3x3',
64,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_3'):
# 3x3x3 Max-pool, stride 1, 1, 1
branch_3 = maxpool(net,
'MaxPool3d_0a_3x3',
ksize=[1, 3, 3, 3, 1],
strides=[1, 1, 1, 1, 1],
padding='SAME')
# 1x1x1 Conv, stride 1
branch_3 = conv_batchnorm_relu(
branch_3,
'Conv3d_0b_1x1',
64,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# Concat branch_[0-3]
net = tf.concat([branch_0, branch_1, branch_2, branch_3], 4)
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# Mixed 4f: Inception block
end_point = 'Mixed_4f'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
# 1x1x1 Conv, stride 1
branch_0 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
256,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_1'):
# 1x1x1 Conv, stride 1
branch_1 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
160,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_1 = conv_batchnorm_relu(
branch_1,
'Conv3d_0b_3x3',
320,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_2'):
# 1x1x1 Conv, stride 1
branch_2 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
32,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_2 = conv_batchnorm_relu(
branch_2,
'Conv3d_0b_3x3',
128,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_3'):
# 3x3x3 Max-pool, stride 1, 1, 1
branch_3 = maxpool(net,
'MaxPool3d_0a_3x3',
ksize=[1, 3, 3, 3, 1],
strides=[1, 1, 1, 1, 1],
padding='SAME')
# 1x1x1 Conv, stride 1
branch_3 = conv_batchnorm_relu(
branch_3,
'Conv3d_0b_1x1',
128,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# Concat branch_[0-3]
net = tf.concat([branch_0, branch_1, branch_2, branch_3], 4)
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# 2x2x2 Max-pool, stride 2x2x2
end_point = 'MaxPool3d_5a_2x2'
net = maxpool(net,
end_point,
ksize=[1, 2, 2, 2, 1],
strides=[1, 2, 2, 2, 1],
padding='SAME')
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# Mixed 5b: Inception block
end_point = 'Mixed_5b'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
# 1x1x1 Conv, stride 1
branch_0 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
256,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_1'):
# 1x1x1 Conv, stride 1
branch_1 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
160,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_1 = conv_batchnorm_relu(
branch_1,
'Conv3d_0b_3x3',
320,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_2'):
# 1x1x1 Conv, stride 1
branch_2 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
32,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_2 = conv_batchnorm_relu(
branch_2,
'Conv3d_0b_3x3',
128,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_3'):
# 3x3x3 Max-pool, stride 1, 1, 1
branch_3 = maxpool(net,
'MaxPool3d_0a_3x3',
ksize=[1, 3, 3, 3, 1],
strides=[1, 1, 1, 1, 1],
padding='SAME')
# 1x1x1 Conv, stride 1
branch_3 = conv_batchnorm_relu(
branch_3,
'Conv3d_0b_1x1',
128,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# Concat branch_[0-3]
net = tf.concat([branch_0, branch_1, branch_2, branch_3], 4)
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# Mixed 5c: Inception block
end_point = 'Mixed_5c'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
# 1x1x1 Conv, stride 1
branch_0 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
384,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_1'):
# 1x1x1 Conv, stride 1
branch_1 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
192,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_1 = conv_batchnorm_relu(
branch_1,
'Conv3d_0b_3x3',
384,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_2'):
# 1x1x1 Conv, stride 1
branch_2 = conv_batchnorm_relu(
net,
'Conv3d_0a_1x1',
48,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# 3x3x3 Conv, stride 1
branch_2 = conv_batchnorm_relu(
branch_2,
'Conv3d_0b_3x3',
128,
kernel_size=3,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
with tf.variable_scope('Branch_3'):
# 3x3x3 Max-pool, stride 1, 1, 1
branch_3 = maxpool(net,
'MaxPool3d_0a_3x3',
ksize=[1, 3, 3, 3, 1],
strides=[1, 1, 1, 1, 1],
padding='SAME')
# 1x1x1 Conv, stride 1
branch_3 = conv_batchnorm_relu(
branch_3,
'Conv3d_0b_1x1',
128,
kernel_size=1,
stride=1,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
# Concat branch_[0-3]
net = tf.concat([branch_0, branch_1, branch_2, branch_3], 4)
get_shape = net.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_points[end_point] = net
if final_endpoint == end_point: return net, end_points
# Logits
end_point = 'Logits'
with tf.variable_scope(end_point):
# 2x7x7 Average-pool, stride 1, 1, 1
net = avgpool(net,
ksize=[1, 2, 7, 7, 1],
strides=[1, 1, 1, 1, 1],
padding='VALID')
get_shape = net.get_shape().as_list()
print('{} / Average-pool3D: {}'.format(end_point, get_shape))
# Dropout
net = tf.nn.dropout(net, dropout_keep_prob)
# 1x1x1 Conv, stride 1
logits = conv_batchnorm_relu(
net,
'Conv3d_0c_1x1',
num_classes,
kernel_size=1,
stride=1,
activation=None,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
is_training=is_training,
num_cores=num_cores)
get_shape = logits.get_shape().as_list()
print('{} / Conv3d_0c_1x1 : {}'.format(end_point, get_shape))
if spatial_squeeze:
# Removes dimensions of size 1 from the shape of a tensor
# Specify which dimensions have to be removed: 2 and 3
logits = tf.squeeze(logits, [2, 3], name='SpatialSqueeze')
get_shape = logits.get_shape().as_list()
print('{} / Spatial Squeeze : {}'.format(end_point, get_shape))
averaged_logits = tf.reduce_mean(logits, axis=1)
get_shape = averaged_logits.get_shape().as_list()
print('{} / Averaged Logits : {}'.format(end_point, get_shape))
end_points[end_point] = averaged_logits
if final_endpoint == end_point: return averaged_logits, end_points
# Predictions
end_point = 'Predictions'
predictions = tf.nn.softmax(averaged_logits)
end_points[end_point] = predictions
return predictions, end_points
def resnet_block(model_scope_name='resunet_1',
end_point='',
scope_id=0,
inputs=None,
out_channels=64,
is_training=True,
num_cores=8,
use_batch_norm=False,
use_cross_replica_batch_norm=False):
# Shortcut: 3x3 Conv, padding='same', no activation
shortcut_conv2d = conv_batchnorm_relu(
inputs,
'shortcut_Conv2d_{}a'.format(scope_id),
out_channels,
kernel_size=3,
stride=1,
padding='SAME',
activation=None,
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = shortcut_conv2d.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' +\
'shortcut_Conv2d_{}a'.format(scope_id)
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = shortcut_conv2d
# 3x3 Conv, padding='same'
conv2d_1 = conv_batchnorm_relu(
inputs,
'Conv2d_{}a'.format(scope_id),
out_channels,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_1.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/'\
+ 'Conv2d_{}a'.format(scope_id)
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_1
# 3x3 Conv, padding='same', no activation
conv2d_2 = conv_batchnorm_relu(
conv2d_1,
'Conv2d_{}b'.format(scope_id),
out_channels,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
activation=None,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = conv2d_2.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' +\
'Conv2d_{}b'.format(scope_id)
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = conv2d_2
# Sum: x + f(x) and relu
with tf.variable_scope('sum_relu'):
sum_1 = tf.nn.relu(shortcut_conv2d + conv2d_2)
get_shape = sum_1.get_shape().as_list()
full_layer_name = model_scope_name + '/' + end_point + '/' + 'sum_relu'
print('{}: {}'.format(full_layer_name, get_shape))
layer_outputs[full_layer_name] = sum_1
return sum_1
def gala(net,
kernel_size=[],
reduction=8,
at_act=tf.nn.relu,
comb_act=tf.keras.activations.softmax,
comb_type='interpolate',
include_fa=True,
num_cores=8):
# include_fa = feature/global attention
# 1. FC layer with c / r channels + a nonlinearity
channels = int(net.get_shape()[-1])
intermediate_channels = int(channels / reduction)
intermediate_activities = conv_batchnorm_relu(
net,
'ATTENTION_intermediate',
intermediate_channels,
activation=tf.keras.activations.relu,
kernel_size=kernel_size,
stride=1,
num_cores=num_cores)
'''
intermediate_activities = tf.layers.conv2d(
inputs=bottom,
filters=intermediate_channels,
kernel_size=intermediate_kernel,
activation=intermediate_nl,
padding='SAME',
use_bias=True,
kernel_initializer=tf.variance_scaling_initializer(),
trainable=training,
name='%s_ATTENTION_intermediate' % name)
'''
# 2. Spatial attention map
output_activities = conv_batchnorm_relu(intermediate_activities,
'ATTENTION_output',
1,
activation=None,
kernel_size=kernel_size,
stride=1,
num_cores=num_cores)
# Also calculate se attention
if include_fa:
fa_map = se(net,
intermediate_nl=tf.keras.activations.relu,
reduction=reduction,
return_map=True,
squash=tf.keras.activations.sigmoid,
pool_fun=tf.reduce_max)
if comb_type == 'interpolate':
alpha = tf.get_variable(name='alpha',
shape=[1, 1, 1, channels],
initializer=tf.constant_initializer(0.0),
dtype=tf.float32)
alpha = tf.keras.activations.sigmoid(alpha)
additive = output_activities + fa_map
multiplicative = output_activities * fa_map
output_activities = alpha * additive + (1 - alpha) * multiplicative
'''
if interaction == 'both':
k = fa_map.get_shape().as_list()[-1]
alpha = tf.get_variable(
name='alpha_%s' % name,
shape=[1, 1, 1, k],
initializer=tf.variance_scaling_initializer(),
dtype=tf.bfloat16 if self.use_tpu else tf.float32)
beta = tf.get_variable(
name='beta_%s' % name,
shape=[1, 1, 1, k],
initializer=tf.variance_scaling_initializer(),
dtype=tf.bfloat16 if self.use_tpu else tf.float32)
additive = output_activities + fa_map
multiplicative = output_activities * fa_map
output_activities = alpha * additive + beta * multiplicative
'''
elif comb_type == 'multiplicative':
output_activities = output_activities * fa_map
elif comb_type == 'additive':
output_activities = output_activities + fa_map
else:
raise NotImplementedError(interaction)
if comb_act == tf.keras.activations.softmax:
act_shape = output_activities.get_shape().as_list()
reshape_output_act = tf.reshape(
tf.transpose(output_activities, perm=[0, 1, 4, 2, 3]),
shape=[act_shape[0], act_shape[1], act_shape[-1], -1])
output_activities = comb_act(reshape_output_act)
output_activities = tf.transpose(tf.reshape(output_activities,
shape=[
act_shape[0],
act_shape[1],
act_shape[-1],
act_shape[2],
act_shape[3]
]),
perm=[0, 1, 3, 4, 2])
else:
output_activites = comb_act(output_activities)
net = net * output_activities
return net, output_activities
def resnext_layer(input_var,
out_channels,
cardinality,
scope=None,
stride=[1, 2, 1],
kernel_sizes=[1, 3, 1],
activation=tf.keras.activations.relu,
padding='SAME',
spectral_norm_flag=False,
update_collection=False,
is_training=True,
use_batch_norm=False,
use_cross_replica_batch_norm=False,
num_cores=8,
initializer=tf.keras.initializers.glorot_normal):
with tf.variable_scope(scope):
input_shape = input_var.get_shape().as_list()
# get number of channels in input
ch = input_shape[-1]
# group conv out_channels
group_conv_channels = out_channels // 2
# create a list of split layers
split_layers = list()
for path in range(cardinality):
current_split = residual_path(
input_var,
group_conv_channels // cardinality,
scope='Path' + str(path),
stride=stride[:2],
kernel_sizes=kernel_sizes[:2],
activation=activation,
padding=padding,
spectral_norm_flag=spectral_norm_flag,
update_collection=update_collection,
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
initializer=initializer)
# append to the list
split_layers.append(current_split)
# concatenate all the splits
grouped_input = tf.concat(split_layers, axis=3)
# 1x1 convolution. IMP: No relu here!
merged_input = conv_batchnorm_relu(
grouped_input,
'Merge',
out_channels,
kernel_size=kernel_sizes[-1],
stride=stride[-1],
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
padding=padding,
activation=None)
sh = merged_input.get_shape().as_list()
if not (sh[1] == input_shape[1]):
mod_input = conv_batchnorm_relu(
input_var,
'Downsample',
out_channels,
kernel_size=1,
stride=2,
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
padding=padding,
activation=None)
else:
mod_input = input_var
# add the skip connection and the rectify!
return tf.nn.relu(mod_input + merged_input, name='rectify')
def model(inputs, is_training):
net = inputs
end_points = {}
print('Input: {}'.format(net.get_shape().as_list()))
'''
Build the feedforward part of the network
Here is where we select the model type.
Currently supported options: resnet, resnet150, resnext, resnext150
'''
stack_architecture = [3, 4, 6, 3]
# define the stacking hyperparameters for the larger model type
if '150' in model_type:
stack_architecture = [3, 8, 36, 3]
_, layers = residual_network(
inputs,
is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
final_endpoint='Encode_5',
model_type=model_type,
stack_architecture=stack_architecture)
#########
# Feature Pyramid
#########
heads = {}
end_point = 'Pyr_5'
with tf.variable_scope(end_point):
fpn_5 = conv_batchnorm_relu(
layers['Encode_5'],
'Conv2d_1x1',
256,
kernel_size=1,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
fpn_5_head = network_head(fpn_5, 128, is_training=is_training)
heads[end_point] = fpn_5_head
get_shape = fpn_5.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_point = 'Pyr_4'
with tf.variable_scope(end_point):
fpn_4 = conv_batchnorm_relu(
layers['Encode_4'],
'Conv2d_1x1',
256,
kernel_size=1,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
activation=None)
# upsample fpn_5 and add
sh = fpn_5.get_shape().as_list()
#fpn_4 = tf.nn.relu(fpn_4 + tf.image.resize_images(fpn_5, [sh[1]*2, sh[2]*2]))
fpn_4 = tf.nn.relu(fpn_4 + nearest_upsampling(fpn_5, 2))
fpn_4_head = network_head(tf.nn.relu(fpn_4),
128,
is_training=is_training)
heads[end_point] = fpn_4_head
get_shape = fpn_4.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_point = 'Pyr_3'
with tf.variable_scope(end_point):
fpn_3 = conv_batchnorm_relu(
layers['Encode_3'],
'Conv2d_1x1',
256,
kernel_size=1,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
activation=None)
# upsample fpn_4 and add
sh = fpn_4.get_shape().as_list()
#fpn_3 = tf.nn.relu(fpn_3 + tf.image.resize_images(fpn_4, [sh[1]*2, sh[2]*2]))
fpn_3 = tf.nn.relu(fpn_3 + nearest_upsampling(fpn_4, 2))
fpn_3_head = network_head(tf.nn.relu(fpn_3),
128,
is_training=is_training)
heads[end_point] = fpn_3_head
get_shape = fpn_3.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_point = 'Pyr_2'
with tf.variable_scope(end_point):
fpn_2 = conv_batchnorm_relu(
layers['Encode_2'],
'Conv2d_1x1',
256,
kernel_size=1,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
activation=None)
# upsample fpn_3 and add
sh = fpn_3.get_shape().as_list()
#fpn_2 = tf.nn.relu(fpn_2 + tf.image.resize_images(fpn_3, [sh[1]*2, sh[2]*2]))
fpn_2 = tf.nn.relu(fpn_2 + nearest_upsampling(fpn_3, 2))
fpn_2_head = network_head(tf.nn.relu(fpn_2),
128,
is_training=is_training)
heads[end_point] = fpn_2_head
get_shape = fpn_2.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
end_point = 'Head_Master'
with tf.variable_scope(end_point):
net_heads = list()
inp_shape = inputs.get_shape().as_list()
for head_name in heads.keys():
sh = heads[head_name].get_shape().as_list()
# calculate scale at which upsampling must be done
scale_factor = inp_shape[1] // sh[1]
#up_sampled_layer = tf.image.resize_images(heads[head_name],[inp_shape[1], inp_shape[2]])
up_sampled_layer = nearest_upsampling(heads[head_name],
scale_factor)
net_heads.append(up_sampled_layer)
# concatenate
concat_head = tf.concat(net_heads, axis=3)
model_output = conv_batchnorm_relu(
concat_head,
'Conv2d_3x3_Final',
num_classes,
kernel_size=3,
stride=1,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
activation=None)
get_shape = model_output.get_shape().as_list()
print('{} : {}'.format(end_point, get_shape))
return model_output
def residual_network(inputs,
is_training,
num_cores=8,
use_batch_norm=False,
use_cross_replica_batch_norm=False,
final_endpoint='Head_Master',
model_type='resnet',
stack_architecture=[3, 4, 6, 3]):
if final_endpoint not in VALID_ENDPOINTS:
raise ValueError('Unknown final endpoint %s' % final_endpoint)
net = inputs
end_points = {}
print('Input: {}'.format(net.get_shape().as_list()))
# Encode_1
end_point = 'Encode_1'
out_channels_1a = 64
with tf.variable_scope(end_point):
# 7x7 Conv, padding='same'
encode_1 = conv_batchnorm_relu(
net,
'Conv2d_1a',
out_channels_1a,
kernel_size=7,
stride=2,
padding='SAME',
is_training=is_training,
num_cores=num_cores,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm)
get_shape = encode_1.get_shape().as_list()
print('{} / Encode_1: {}'.format(end_point, get_shape))
end_points[end_point] = encode_1
if final_endpoint == end_point: return encode_1, end_points
if len(stack_architecture) < 4:
raise ValueError(
'Not enough hyperparameter specifications. This module needs at least 4 blocks of stacks to be defined'
)
# Encode_2
end_point = 'Encode_2'
cardinality = 32
# 3
encode_2 = residual_stack(
encode_1,
256,
cardinality,
num_stacks=stack_architecture[0],
scope=end_point,
should_stride=True,
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
model_type=model_type)
get_shape = encode_2.get_shape().as_list()
print('{} / Encode_2: {}'.format(end_point, get_shape))
end_points[end_point] = encode_2
if final_endpoint == end_point: return encode_2, end_points
# Encode_3
end_point = 'Encode_3'
# 4
encode_3 = residual_stack(
encode_2,
512,
cardinality,
num_stacks=stack_architecture[1],
scope=end_point,
should_stride=True,
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
model_type=model_type)
get_shape = encode_3.get_shape().as_list()
print('{} / Encode_3: {}'.format(end_point, get_shape))
end_points[end_point] = encode_3
if final_endpoint == end_point: return encode_3, end_points
# Encode_4
end_point = 'Encode_4'
# 6
encode_4 = residual_stack(
encode_3,
1024,
cardinality,
num_stacks=stack_architecture[2],
scope=end_point,
should_stride=True,
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
model_type=model_type)
get_shape = encode_4.get_shape().as_list()
print('{} / Encode_4: {}'.format(end_point, get_shape))
end_points[end_point] = encode_4
if final_endpoint == end_point: return encode_4, end_points
# Encode_5
end_point = 'Encode_5'
# 3
encode_5 = residual_stack(
encode_4,
2048,
cardinality,
num_stacks=stack_architecture[3],
scope=end_point,
should_stride=True,
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
model_type=model_type)
get_shape = encode_5.get_shape().as_list()
print('{} / Encode_5: {}'.format(end_point, get_shape))
end_points[end_point] = encode_5
if final_endpoint == end_point: return encode_5, end_points
return end_points
def residual_stack(input_var,
out_channels,
cardinality,
num_stacks=1,
scope=None,
should_stride=True,
activation=tf.keras.activations.relu,
padding='SAME',
spectral_norm_flag=False,
update_collection=False,
is_training=True,
use_batch_norm=False,
use_cross_replica_batch_norm=False,
num_cores=8,
initializer=tf.keras.initializers.glorot_normal,
model_type='resnet'):
with tf.variable_scope(scope):
layer = input_var
for stack in range(num_stacks):
if (stack == 0) and should_stride:
flag = True
stride = [1, 2, 1]
else:
flag = False
stride = [1, 1, 1]
####
# account for the different models here
####
if 'resnet' in model_type:
cur_output = resnet_layer(
layer,
out_channels,
cardinality,
scope='Layer_' + str(stack),
stride=stride,
activation=activation,
padding=padding,
spectral_norm_flag=spectral_norm_flag,
update_collection=update_collection,
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
initializer=initializer)
elif 'resnext' in model_type:
cur_output = resnext_layer(
layer,
out_channels,
cardinality,
scope='Layer_' + str(stack),
stride=stride,
activation=activation,
padding=padding,
spectral_norm_flag=spectral_norm_flag,
update_collection=update_collection,
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
initializer=initializer)
else:
raise ValueError(
'This model type is currently not supported. Use [resnet|resnet150|resnext|resnext150]'
)
if flag:
# need to do some dimension handling
pool_inp = tf.layers.average_pooling2d(inputs=layer,
pool_size=[2, 2],
strides=2,
padding='SAME')
pool_inp = conv_batchnorm_relu(
pool_inp,
'skip1x1_layer' + str(stack),
cur_output.get_shape().as_list()[-1],
stride=1,
kernel_size=1,
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
activation=None)
else:
# dimensions match!
pool_inp = layer
# add the skip connection
layer = tf.nn.relu(pool_inp + cur_output)
return layer
def resnet_layer(input_var,
out_channels,
cardinality,
scope=None,
stride=[1, 2, 1],
kernel_sizes=[1, 3, 1],
activation=tf.keras.activations.relu,
padding='SAME',
spectral_norm_flag=False,
update_collection=False,
is_training=True,
use_batch_norm=False,
use_cross_replica_batch_norm=False,
num_cores=8,
initializer=tf.keras.initializers.glorot_normal):
with tf.variable_scope(scope):
input_shape = input_var.get_shape().as_list()
# get number of channels in input
ch = input_shape[-1]
# group conv out_channels
group_conv_channels = out_channels // 2
output_var = conv_batchnorm_relu(
input_var,
'Conv2d_Unit1',
group_conv_channels,
kernel_size=kernel_sizes[0],
stride=stride[0],
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
padding=padding)
# second conv
output_var = conv_batchnorm_relu(
output_var,
'Conv2d_Unit2',
group_conv_channels,
kernel_size=kernel_sizes[1],
stride=stride[1],
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
padding=padding)
# third conv
output_var = conv_batchnorm_relu(
output_var,
'Conv2d_Unit3',
out_channels,
kernel_size=kernel_sizes[2],
stride=stride[2],
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
padding=padding,
activation=None)
sh = output_var.get_shape().as_list()
if not (sh[1] == input_shape[1]):
mod_input = conv_batchnorm_relu(
input_var,
'Downsample',
out_channels,
kernel_size=1,
stride=2,
is_training=is_training,
use_batch_norm=use_batch_norm,
use_cross_replica_batch_norm=use_cross_replica_batch_norm,
num_cores=num_cores,
padding=padding,
activation=None)
else:
mod_input = input_var
# add the skip connection and the rectify!
return tf.nn.relu(mod_input + output_var, name='rectify')
