def testOutputStride8BuildAndCheckAllEndPointsUptoConv2d_13(self):
global numbers
numbers += 1
print('testOutputStride8BuildAndCheckAllEndPointsUptoConv2d_13: ',numbers)
batch_size = 5
height, width = 224, 224
output_stride = 8
inputs = tf.random_uniform((batch_size, height, width, 3))
with slim.arg_scope([slim.conv2d, slim.separable_conv2d],
normalizer_fn=slim.batch_norm):
_, end_points = mobilenet_v1.mobilenet_v1_base(
inputs, output_stride=output_stride,
final_endpoint='Conv2d_13_pointwise')
_, explicit_padding_end_points = mobilenet_v1.mobilenet_v1_base(
inputs, output_stride=output_stride,
final_endpoint='Conv2d_13_pointwise', use_explicit_padding=True)
endpoints_shapes = {'Conv2d_0': [batch_size, 112, 112, 32],
'Conv2d_1_depthwise': [batch_size, 112, 112, 32],
'Conv2d_1_pointwise': [batch_size, 112, 112, 64],
'Conv2d_2_depthwise': [batch_size, 56, 56, 64],
'Conv2d_2_pointwise': [batch_size, 56, 56, 128],
'Conv2d_3_depthwise': [batch_size, 56, 56, 128],
'Conv2d_3_pointwise': [batch_size, 56, 56, 128],
'Conv2d_4_depthwise': [batch_size, 28, 28, 128],
'Conv2d_4_pointwise': [batch_size, 28, 28, 256],
'Conv2d_5_depthwise': [batch_size, 28, 28, 256],
'Conv2d_5_pointwise': [batch_size, 28, 28, 256],
'Conv2d_6_depthwise': [batch_size, 28, 28, 256],
'Conv2d_6_pointwise': [batch_size, 28, 28, 512],
'Conv2d_7_depthwise': [batch_size, 28, 28, 512],
'Conv2d_7_pointwise': [batch_size, 28, 28, 512],
'Conv2d_8_depthwise': [batch_size, 28, 28, 512],
'Conv2d_8_pointwise': [batch_size, 28, 28, 512],
'Conv2d_9_depthwise': [batch_size, 28, 28, 512],
'Conv2d_9_pointwise': [batch_size, 28, 28, 512],
'Conv2d_10_depthwise': [batch_size, 28, 28, 512],
'Conv2d_10_pointwise': [batch_size, 28, 28, 512],
'Conv2d_11_depthwise': [batch_size, 28, 28, 512],
'Conv2d_11_pointwise': [batch_size, 28, 28, 512],
'Conv2d_12_depthwise': [batch_size, 28, 28, 512],
'Conv2d_12_pointwise': [batch_size, 28, 28, 1024],
'Conv2d_13_depthwise': [batch_size, 28, 28, 1024],
'Conv2d_13_pointwise': [batch_size, 28, 28, 1024]}
self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
for endpoint_name, expected_shape in endpoints_shapes.items():
self.assertTrue(endpoint_name in end_points)
self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
expected_shape)
self.assertItemsEqual(endpoints_shapes.keys(),
explicit_padding_end_points.keys())
for endpoint_name, expected_shape in endpoints_shapes.items():
self.assertTrue(endpoint_name in explicit_padding_end_points)
self.assertListEqual(
explicit_padding_end_points[endpoint_name].get_shape().as_list(),
expected_shape)
def testBuildAndCheckAllEndPointsApproximateFaceNet(self):
global numbers
numbers += 1
print('testBuildAndCheckAllEndPointsApproximateFaceNet: ',numbers)
batch_size = 5
height, width = 128, 128
inputs = tf.random_uniform((batch_size, height, width, 3))
with slim.arg_scope([slim.conv2d, slim.separable_conv2d],
normalizer_fn=slim.batch_norm):
_, end_points = mobilenet_v1.mobilenet_v1_base(
inputs, final_endpoint='Conv2d_13_pointwise', depth_multiplier=0.75)
_, explicit_padding_end_points = mobilenet_v1.mobilenet_v1_base(
inputs, final_endpoint='Conv2d_13_pointwise', depth_multiplier=0.75,
use_explicit_padding=True)
# For the Conv2d_0 layer FaceNet has depth=16
endpoints_shapes = {'Conv2d_0': [batch_size, 64, 64, 24],
'Conv2d_1_depthwise': [batch_size, 64, 64, 24],
'Conv2d_1_pointwise': [batch_size, 64, 64, 48],
'Conv2d_2_depthwise': [batch_size, 32, 32, 48],
'Conv2d_2_pointwise': [batch_size, 32, 32, 96],
'Conv2d_3_depthwise': [batch_size, 32, 32, 96],
'Conv2d_3_pointwise': [batch_size, 32, 32, 96],
'Conv2d_4_depthwise': [batch_size, 16, 16, 96],
'Conv2d_4_pointwise': [batch_size, 16, 16, 192],
'Conv2d_5_depthwise': [batch_size, 16, 16, 192],
'Conv2d_5_pointwise': [batch_size, 16, 16, 192],
'Conv2d_6_depthwise': [batch_size, 8, 8, 192],
'Conv2d_6_pointwise': [batch_size, 8, 8, 384],
'Conv2d_7_depthwise': [batch_size, 8, 8, 384],
'Conv2d_7_pointwise': [batch_size, 8, 8, 384],
'Conv2d_8_depthwise': [batch_size, 8, 8, 384],
'Conv2d_8_pointwise': [batch_size, 8, 8, 384],
'Conv2d_9_depthwise': [batch_size, 8, 8, 384],
'Conv2d_9_pointwise': [batch_size, 8, 8, 384],
'Conv2d_10_depthwise': [batch_size, 8, 8, 384],
'Conv2d_10_pointwise': [batch_size, 8, 8, 384],
'Conv2d_11_depthwise': [batch_size, 8, 8, 384],
'Conv2d_11_pointwise': [batch_size, 8, 8, 384],
'Conv2d_12_depthwise': [batch_size, 4, 4, 384],
'Conv2d_12_pointwise': [batch_size, 4, 4, 768],
'Conv2d_13_depthwise': [batch_size, 4, 4, 768],
'Conv2d_13_pointwise': [batch_size, 4, 4, 768]}
self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
for endpoint_name, expected_shape in endpoints_shapes.items():
self.assertTrue(endpoint_name in end_points)
self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
expected_shape)
self.assertItemsEqual(endpoints_shapes.keys(),
explicit_padding_end_points.keys())
for endpoint_name, expected_shape in endpoints_shapes.items():
self.assertTrue(endpoint_name in explicit_padding_end_points)
self.assertListEqual(
explicit_padding_end_points[endpoint_name].get_shape().as_list(),
expected_shape)
def testModelHasExpectedNumberOfParameters(self):
global numbers
numbers += 1
print('testModelHasExpectedNumberOfParameters: ',numbers)
batch_size = 5
height, width = 224, 224
inputs = tf.random_uniform((batch_size, height, width, 3))
with slim.arg_scope([slim.conv2d, slim.separable_conv2d],
normalizer_fn=slim.batch_norm):
mobilenet_v1.mobilenet_v1_base(inputs)
total_params, _ = slim.model_analyzer.analyze_vars(
slim.get_model_variables())
self.assertAlmostEqual(3217920, total_params)
def mobilenet(inputs,
num_classes=1000,
dropout_keep_prob=0.999,
is_training=True,
min_depth=8,
depth_multiplier=1.0,
conv_defs=None,
spatial_squeeze=True,
reuse=None,
scope='MobilenetV1',
global_pool=False):
input_shape = inputs.get_shape().as_list()
if len(input_shape) != 4:
raise ValueError('Invalid input tensor rank, expected 4, was: %d' %
len(input_shape))
with tf.variable_scope(scope, 'MobilenetV1', [inputs],
reuse=reuse) as scope:
with slim.arg_scope([slim.batch_norm, slim.dropout],
is_training=is_training):
nets = mobilenet_v1.mobilenet_v1_base(
inputs,
scope=scope,
min_depth=min_depth,
depth_multiplier=depth_multiplier,
conv_defs=conv_defs)
net = nets[0]
return net
def testBuildOnlyUptoFinalEndpoint(self):
global numbers
numbers += 1
print('testBuildOnlyUptoFinalEndpoint: ',numbers)
batch_size = 5
height, width = 224, 224
endpoints = ['Conv2d_0',
'Conv2d_1_depthwise', 'Conv2d_1_pointwise',
'Conv2d_2_depthwise', 'Conv2d_2_pointwise',
'Conv2d_3_depthwise', 'Conv2d_3_pointwise',
'Conv2d_4_depthwise', 'Conv2d_4_pointwise',
'Conv2d_5_depthwise', 'Conv2d_5_pointwise',
'Conv2d_6_depthwise', 'Conv2d_6_pointwise',
'Conv2d_7_depthwise', 'Conv2d_7_pointwise',
'Conv2d_8_depthwise', 'Conv2d_8_pointwise',
'Conv2d_9_depthwise', 'Conv2d_9_pointwise',
'Conv2d_10_depthwise', 'Conv2d_10_pointwise',
'Conv2d_11_depthwise', 'Conv2d_11_pointwise',
'Conv2d_12_depthwise', 'Conv2d_12_pointwise',
'Conv2d_13_depthwise', 'Conv2d_13_pointwise']
for index, endpoint in enumerate(endpoints):
with tf.Graph().as_default():
inputs = tf.random_uniform((batch_size, height, width, 3))
out_tensor, end_points = mobilenet_v1.mobilenet_v1_base(
inputs, final_endpoint=endpoint)
self.assertTrue(out_tensor.op.name.startswith(
'MobilenetV1/' + endpoint))
self.assertItemsEqual(endpoints[:index+1], end_points.keys())
def testBuildBaseNetwork(self):
global numbers
numbers += 1
print('testBuildBaseNetwork: ',numbers)
batch_size = 5
height, width = 224, 224
inputs = tf.random_uniform((batch_size, height, width, 3))
net, end_points = mobilenet_v1.mobilenet_v1_base(inputs)
self.assertTrue(net.op.name.startswith('MobilenetV1/Conv2d_13'))
self.assertListEqual(net.get_shape().as_list(),
[batch_size, 7, 7, 1024])
expected_endpoints = ['Conv2d_0',
'Conv2d_1_depthwise', 'Conv2d_1_pointwise',
'Conv2d_2_depthwise', 'Conv2d_2_pointwise',
'Conv2d_3_depthwise', 'Conv2d_3_pointwise',
'Conv2d_4_depthwise', 'Conv2d_4_pointwise',
'Conv2d_5_depthwise', 'Conv2d_5_pointwise',
'Conv2d_6_depthwise', 'Conv2d_6_pointwise',
'Conv2d_7_depthwise', 'Conv2d_7_pointwise',
'Conv2d_8_depthwise', 'Conv2d_8_pointwise',
'Conv2d_9_depthwise', 'Conv2d_9_pointwise',
'Conv2d_10_depthwise', 'Conv2d_10_pointwise',
'Conv2d_11_depthwise', 'Conv2d_11_pointwise',
'Conv2d_12_depthwise', 'Conv2d_12_pointwise',
'Conv2d_13_depthwise', 'Conv2d_13_pointwise']
self.assertItemsEqual(end_points.keys(), expected_endpoints)
def branch(name, inputs):
with tf.variable_scope(name):
output, endpoints = mn.mobilenet_v1_base(inputs, \
depth_multiplier=model_util.MOBILENET_DEP_MULTI)
#kernel = mn.reduced_kernel_size_for_small_input(left_output, KERNEL_SIZE)
#pool_l = slim.avg_pool2d(left_output, kernel, padding='VALID')
flat = tf.contrib.layers.flatten(output)
return inputs, flat
def branch(name):
with tf.variable_scope(name):
shape = (None, model_util.IMAGE_SIZE, model_util.IMAGE_SIZE,
model_util.IMAGE_CHANNELS)
inputs = tf.placeholder(tf.float32, shape)
output, endpoints = mn.mobilenet_v1_base(inputs, \
depth_multiplier=model_util.MOBILENET_DEP_MULTI)
#kernel = mn.reduced_kernel_size_for_small_input(left_output, KERNEL_SIZE)
#pool_l = slim.avg_pool2d(left_output, kernel, padding='VALID')
flat = tf.contrib.layers.flatten(output)
norm = tf.nn.l2_normalize(flat, 1, name="Norm")
return inputs, norm
def load_mobilenet_and_continue(name,
graph_filename,
layer_cutoff,
end_num=13):
inputs, output = load_mobilenet(name, graph_filename, layer_cutoff)
conv_defs = mn._CONV_DEFS[layer_cutoff + 1:end_num + 1]
mn_output, _ = mn.mobilenet_v1_base(output,
final_endpoint='Conv2d_%i_pointwise' %
(end_num - layer_cutoff - 1),
min_depth=MOBILENET_MIN_DEPTH,
depth_multiplier=MOBILENET_DEP_MULTI,
conv_defs=conv_defs,
output_stride=None,
scope=None)
return inputs, mn_output
def testBuildCustomNetworkUsingConvDefs(self):
global numbers
numbers += 1
print('testBuildCustomNetworkUsingConvDefs: ',numbers)
batch_size = 5
height, width = 224, 224
conv_defs = [
mobilenet_v1.Conv(kernel=[3, 3], stride=2, depth=32),
mobilenet_v1.DepthSepConv(kernel=[3, 3], stride=1, depth=64),
mobilenet_v1.DepthSepConv(kernel=[3, 3], stride=2, depth=128),
mobilenet_v1.DepthSepConv(kernel=[3, 3], stride=1, depth=512)
]
inputs = tf.random_uniform((batch_size, height, width, 3))
net, end_points = mobilenet_v1.mobilenet_v1_base(
inputs, final_endpoint='Conv2d_3_pointwise', conv_defs=conv_defs)
self.assertTrue(net.op.name.startswith('MobilenetV1/Conv2d_3'))
self.assertListEqual(net.get_shape().as_list(),
[batch_size, 56, 56, 512])
expected_endpoints = ['Conv2d_0',
'Conv2d_1_depthwise', 'Conv2d_1_pointwise',
'Conv2d_2_depthwise', 'Conv2d_2_pointwise',
'Conv2d_3_depthwise', 'Conv2d_3_pointwise']
self.assertItemsEqual(end_points.keys(), expected_endpoints)
def ssd_net(inputs,
num_classes=SSDNet.default_params.num_classes,
feat_layers=SSDNet.default_params.feat_layers,
anchor_sizes=SSDNet.default_params.anchor_sizes,
anchor_ratios=SSDNet.default_params.anchor_ratios,
normalizations=SSDNet.default_params.normalizations,
is_training=True,
dropout_keep_prob=0.5,
prediction_fn=slim.softmax,
reuse=None,
scope='ssd_300_mobilenetv1'):
"""SSD net definition.
"""
# if data_format == 'NCHW':
# inputs = tf.transpose(inputs, perm=(0, 3, 1, 2))
# End_points collect relevant activations for external use.
end_points = {}
min_depth = 32
depth_multiplier = 1.0
with tf.variable_scope(scope, 'ssd_300_mobilenetv1', [inputs], reuse=reuse):
input_shape = inputs.get_shape().as_list()
if len(input_shape) != 4:
raise ValueError('Invalid input tensor rank, expected 4, was: %d' %
len(input_shape))
with slim.arg_scope(mobilenet_v1.mobilenet_v1_arg_scope(is_training=is_training)):
with slim.arg_scope([slim.batch_norm, slim.dropout], is_training=is_training):
net, end_points = mobilenet_v1.mobilenet_v1_base(inputs, scope='MobilenetV1',
min_depth=min_depth,
depth_multiplier=depth_multiplier,
conv_defs=None)
'''
# Additional SSD blocks.
# Block 6: let's dilate the hell out of it!
end_point = 'block13'
with tf.variable_scope(end_point)
net = slim.conv2d(net, 1024, [3, 3], rate=6, scope='atrous_conv')
end_points['block13_atrous'] = net
net = tf.layers.dropout(net, rate=dropout_keep_prob, training=is_training)
# Block 7: 1x1 conv. Because the f**k.
net = slim.conv2d(net, 1024, [1, 1], scope='conv1x1')
end_points['block13'] = net
net = tf.layers.dropout(net, rate=dropout_keep_prob, training=is_training)
'''
# Block 14/15/16/17: 1x1 and 3x3 convolutions stride 2 (except lasts).
end_point = 'block14'
with tf.variable_scope(end_point):
net = slim.conv2d(net, 256, [1, 1], biases_initializer=None, trainable=is_training, scope='conv1x1')
net = custom_layers.pad2d(net, pad=(1, 1))
net = slim.conv2d(net, 512, [3, 3], biases_initializer=None, trainable=is_training, stride=2, scope='conv3x3', padding='VALID')
end_points[end_point] = net
end_point = 'block15'
with tf.variable_scope(end_point):
net = slim.conv2d(net, 128, [1, 1], biases_initializer=None, trainable=is_training, scope='conv1x1')
net = custom_layers.pad2d(net, pad=(1, 1))
net = slim.conv2d(net, 256, [3, 3], biases_initializer=None, trainable=is_training, stride=2, scope='conv3x3', padding='VALID')
end_points[end_point] = net
end_point = 'block16'
with tf.variable_scope(end_point):
net = slim.conv2d(net, 128, [1, 1], biases_initializer=None, trainable=is_training, scope='conv1x1')
net = slim.conv2d(net, 256, [3, 3], biases_initializer=None, trainable=is_training, scope='conv3x3', padding='VALID')
end_points[end_point] = net
'''
end_point = 'block17'
with tf.variable_scope(end_point):
net = slim.conv2d(net, 64, [1, 1], biases_initializer=None, trainable=is_training, scope='conv1x1')
net = slim.conv2d(net, 128, [3, 3], biases_initializer=None, trainable=is_training, scope='conv3x3', padding='VALID')
end_points[end_point] = net
'''
# Prediction and localisations layers.
predictions = []
logits = []
localisations = []
for i, layer in enumerate(feat_layers):
with tf.variable_scope(layer + '_box'):
p, l = ssd_multibox_layer(end_points[layer],
num_classes,
anchor_sizes[i],
anchor_ratios[i],
normalizations[i],
is_training=is_training)
predictions.append(prediction_fn(p))
logits.append(p)
localisations.append(l)
# end_points['logits'] = logits
# end_points['predictions'] = predictions
# end_points['localisations'] = localisations
return predictions, localisations, logits, end_points
def osmn_lite(inputs,
model_params,
visual_modulator_params=None,
scope='osmn',
is_training=False):
"""Defines the OSMN
Args:
inputs: Tensorflow placeholder that contains the input image, visual guide, and spatial guide
model_params: paramters related to the model structure
visual_modulator_params: if None it will generate new visual modulation parameters using guide image, otherwise
it will reuse the current paramters.
scope: Scope name for the network
is_training: training or testing
Returns:
net: Output Tensor of the network
end_points: Dictionary with all Tensors of the network
"""
guide_im_size = tf.shape(inputs[0])
im_size = model_params.im_size
batch_size = inputs[1].get_shape().as_list()[0]
use_visual_modulator = model_params.use_visual_modulator
use_spatial_modulator = model_params.use_spatial_modulator
train_seg = model_params.train_seg
n_modulator_param = 1024 + 512 + 256 + 128
mod_layer_ids = [3, 5, 11, 13]
output_stride = 32
batch_norm_params = {
'decay': 0.99,
'scale': True,
'epsilon': 0.001,
'updates_collections': None,
'is_training': not model_params.fix_bn and is_training
}
if use_visual_modulator and visual_modulator_params == None:
visual_modulator_params = visual_modulator_lite(
inputs[0], model_params, scope=scope, is_training=is_training)
with tf.variable_scope(scope, [inputs]) as sc, slim.arg_scope(
mobilenet_v1.mobilenet_v1_arg_scope(
is_training=is_training)) as arg_sc:
end_points_collection = sc.name + '_end_points'
# index to mark the current position of the modulation params
visual_mod_id = 0
with tf.variable_scope('modulator_sp'):
with slim.arg_scope(
[slim.conv2d],
activation_fn=tf.nn.relu,
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
padding='SAME',
outputs_collections=end_points_collection) as bn_arg_sc:
if not use_spatial_modulator:
sp_mod_params = None
else:
ds_mask = slim.avg_pool2d(inputs[1], [4, 4],
stride=4,
scope='pool4')
conv3_att = slim.conv2d(ds_mask,
128, [1, 1],
scope='conv3')
ds_mask = slim.avg_pool2d(ds_mask, [2, 2], scope='pool8')
conv5_att = slim.conv2d(ds_mask,
256, [1, 1],
scope='conv5')
ds_mask = slim.avg_pool2d(ds_mask, [2, 2], scope='pool16')
conv11_att = slim.conv2d(ds_mask,
512, [1, 1],
scope='conv11')
ds_mask = slim.avg_pool2d(ds_mask, [2, 2], scope='pool32')
conv13_att = slim.conv2d(ds_mask,
1024, [1, 1],
scope='conv13')
sp_mod_params = [
conv3_att, conv5_att, conv11_att, conv13_att
]
# Collect outputs of all intermediate layers.
net, end_points = mobilenet_v1.mobilenet_v1_base(
inputs[2],
output_stride=output_stride,
vis_mod_params=visual_modulator_params,
sp_mod_params=sp_mod_params,
mod_layer_ids=mod_layer_ids,
scope='seg')
with slim.arg_scope([slim.conv2d],
activation_fn=None,
normalizer_fn=None):
net_2 = end_points['Conv2d_3_pointwise']
net_3 = end_points['Conv2d_5_pointwise']
net_4 = end_points['Conv2d_11_pointwise']
net_5 = end_points['Conv2d_13_pointwise']
side_2 = slim.conv2d(net_2, 16, [3, 3], scope='conv3_16')
side_3 = slim.conv2d(net_3, 16, [3, 3], scope='conv5_16')
side_4 = slim.conv2d(net_4, 16, [3, 3], scope='conv11_16')
side_5 = slim.conv2d(net_5, 16, [3, 3], scope='conv13_16')
up_size = [im_size[1] / 2, im_size[0] / 2]
side_2_f = tf.image.resize_bilinear(side_2, up_size)
side_3_f = tf.image.resize_bilinear(side_3, up_size)
side_4_f = tf.image.resize_bilinear(side_4, up_size)
side_5_f = tf.image.resize_bilinear(side_5, up_size)
net = tf.concat([side_2_f, side_3_f, side_4_f, side_5_f], axis=3)
net = slim.conv2d(net, 1, [1, 1], scope='score')
net = tf.image.resize_bilinear(net, [im_size[1], im_size[0]])
#net = slim.conv2d_transpose(net, 1, output_stride * 2, output_stride, normalizer_fn=None, padding="SAME", scope='score-up')
end_points = slim.utils.convert_collection_to_dict(
end_points_collection)
return net, end_points
