def testSingleConvMaskAdded(self):
kernel_size = 3
input_depth, output_depth = 8, 32
input_tensor = array_ops.ones((8, self.height, self.width, input_depth))
layers.masked_conv2d(input_tensor, output_depth, kernel_size)
masks = ops.get_collection(core_layers.MASK_COLLECTION)
self.assertEqual(len(masks), 1)
self.assertListEqual(masks[0].get_shape().as_list(),
[kernel_size, kernel_size, input_depth, output_depth])
masked_weight = ops.get_collection(core_layers.MASKED_WEIGHT_COLLECTION)
self.assertEqual(len(masked_weight), 1)
self.assertListEqual(masked_weight[0].get_shape().as_list(),
[kernel_size, kernel_size, input_depth, output_depth])
def testMultipleConvMaskAdded(self):
number_of_layers = 5
kernel_size = 3
base_depth = 4
depth_step = 7
input_tensor = array_ops.ones((8, self.height, self.width, base_depth))
top_layer = input_tensor
for ix in range(number_of_layers):
top_layer = layers.masked_conv2d(top_layer, base_depth +
(ix + 1) * depth_step, kernel_size)
masks = ops.get_collection(core_layers.MASK_COLLECTION)
self.assertEqual(len(masks), number_of_layers)
for ix in range(number_of_layers):
self.assertListEqual(masks[ix].get_shape().as_list(), [
kernel_size, kernel_size, base_depth + ix * depth_step,
base_depth + (ix + 1) * depth_step
])
masked_weight = ops.get_collection(core_layers.MASKED_WEIGHT_COLLECTION)
self.assertEqual(len(masked_weight), number_of_layers)
for ix in range(number_of_layers):
self.assertListEqual(masked_weight[ix].get_shape().as_list(), [
kernel_size, kernel_size, base_depth + ix * depth_step,
base_depth + (ix + 1) * depth_step
])
def testMultipleConvMaskAdded(self):
number_of_layers = 5
kernel_size = 3
base_depth = 4
depth_step = 7
input_tensor = array_ops.ones((8, self.height, self.width, base_depth))
top_layer = input_tensor
for ix in range(number_of_layers):
top_layer = layers.masked_conv2d(
top_layer, base_depth + (ix + 1) * depth_step, kernel_size)
masks = ops.get_collection(core_layers.MASK_COLLECTION)
self.assertEqual(len(masks), number_of_layers)
for ix in range(number_of_layers):
self.assertListEqual(masks[ix].get_shape().as_list(), [
kernel_size, kernel_size, base_depth + ix * depth_step,
base_depth + (ix + 1) * depth_step
])
masked_weight = ops.get_collection(
core_layers.MASKED_WEIGHT_COLLECTION)
self.assertEqual(len(masked_weight), number_of_layers)
for ix in range(number_of_layers):
self.assertListEqual(masked_weight[ix].get_shape().as_list(), [
kernel_size, kernel_size, base_depth + ix * depth_step,
base_depth + (ix + 1) * depth_step
])
def testSingleConvMaskAdded(self):
kernel_size = 3
input_depth, output_depth = 8, 32
input_tensor = array_ops.ones(
(8, self.height, self.width, input_depth))
layers.masked_conv2d(input_tensor, output_depth, kernel_size)
masks = ops.get_collection(core_layers.MASK_COLLECTION)
self.assertEqual(len(masks), 1)
self.assertListEqual(
masks[0].get_shape().as_list(),
[kernel_size, kernel_size, input_depth, output_depth])
masked_weight = ops.get_collection(
core_layers.MASKED_WEIGHT_COLLECTION)
self.assertEqual(len(masked_weight), 1)
self.assertListEqual(
masked_weight[0].get_shape().as_list(),
[kernel_size, kernel_size, input_depth, output_depth])
def _build_convolutional_model(self, number_of_layers):
# Create a graph with several conv2d layers
kernel_size = 3
base_depth = 4
depth_step = 7
height, width = 7, 9
with variable_scope.variable_scope("conv_model"):
input_tensor = array_ops.ones((8, height, width, base_depth))
top_layer = input_tensor
for ix in range(number_of_layers):
top_layer = layers.masked_conv2d(top_layer,
base_depth +
(ix + 1) * depth_step,
kernel_size,
scope="Conv_" + str(ix))
return top_layer
def _build_convolutional_model(self, number_of_layers):
# Create a graph with several conv2d layers
kernel_size = 3
base_depth = 4
depth_step = 7
height, width = 7, 9
with variable_scope.variable_scope("conv_model"):
input_tensor = array_ops.ones((8, height, width, base_depth))
top_layer = input_tensor
for ix in range(number_of_layers):
top_layer = layers.masked_conv2d(
top_layer,
base_depth + (ix + 1) * depth_step,
kernel_size,
scope="Conv_" + str(ix))
return top_layer
def pruning_inference(self, inputs):
net = layers.masked_conv2d(inputs, 64, 3)
net = layers.masked_conv2d(net, 64, 3)
net = tf.layers.max_pooling2d(net, 2, 2)
net = layers.masked_conv2d(net, 128, 3)
net = layers.masked_conv2d(net, 128, 3)
net = tf.layers.max_pooling2d(net, 2, 2)
net = layers.masked_conv2d(net, 256, 3)
net = layers.masked_conv2d(net, 256, 3)
net = layers.masked_conv2d(net, 256, 3)
net = tf.layers.max_pooling2d(net, 2, 2)
net = tf.layers.flatten(net)
net = layers.masked_fully_connected(net, 1024)
net = layers.masked_fully_connected(net, 1024)
logits = layers.masked_fully_connected(net, self.num_classes, activation_fn=None)
return tf.identity(logits, name='logits')
def tf_fcn_model(image):
_ = image
_ = layers.masked_conv2d(_, 96, (3, 3), 1, 'SAME')
_ = tf.layers.batch_normalization(_, name='norm1-1')
_ = layers.masked_conv2d(_, 96, (3, 3), 1, 'SAME')
_ = tf.layers.batch_normalization(_, name='norm1-2')
_ = tf.layers.max_pooling2d(_, (3, 3), 2, 'SAME', name='pool1')
_ = layers.masked_conv2d(_, 192, (3, 3), 1, 'SAME')
_ = tf.layers.batch_normalization(_, name='norm2-1')
_ = layers.masked_conv2d(_, 192, (3, 3), 1, 'SAME')
_ = tf.layers.batch_normalization(_, name='norm2-2')
_ = tf.layers.max_pooling2d(_, (3, 3), 2, 'SAME', name='pool2')
_ = layers.masked_conv2d(_, 192, (3, 3), 1, 'VALID')
_ = tf.layers.batch_normalization(_, name='norm3')
_ = layers.masked_conv2d(_, 192, (1, 1), 1)
_ = tf.layers.batch_normalization(_, name='norm4')
_ = layers.masked_conv2d(_, 10, (1, 1), 1)
_ = tf.layers.batch_normalization(_, name='norm5')
_ = tf.layers.average_pooling2d(_, (6, 6), 1, name='avg_pool')
y = _
logits = tf.reshape(y, [tf.shape(y)[0], 10])
return logits
def testInvalidRank5(self):
input_tensor = array_ops.ones((8, 8, self.height, self.width, 3))
with self.assertRaisesRegexp(ValueError, 'rank'):
layers.masked_conv2d(input_tensor, 32, 3)
def get_model(point_cloud, input_label, is_training, cat_num, part_num, \
batch_size, num_point, weight_decay=.00004, bn_decay=None):
bn_decay = bn_decay if bn_decay is not None else 0.9
with tf.variable_scope("DGCNN"):
batch_size = point_cloud.get_shape()[0].value
num_point = point_cloud.get_shape()[1].value
input_image = tf.expand_dims(point_cloud, -1)
k = 20
bn_params = {
"is_training": is_training,
"decay": bn_decay,
'renorm': True
}
adj = tf_util.pairwise_distance(point_cloud)
nn_idx = tf_util.knn(adj, k=k)
edge_feature = tf_util.get_edge_feature(input_image,
nn_idx=nn_idx,
k=k)
with tf.variable_scope('transform_net1') as sc:
transform = input_transform_net(edge_feature,
is_training,
bn_decay,
K=3)
point_cloud_transformed = tf.matmul(point_cloud, transform)
input_image = tf.expand_dims(point_cloud_transformed, -1)
adj = tf_util.pairwise_distance(point_cloud_transformed)
nn_idx = tf_util.knn(adj, k=k)
edge_feature = tf_util.get_edge_feature(input_image,
nn_idx=nn_idx,
k=k)
# out1 = tf_util.conv2d(edge_feature, 64, [1,1],
# padding='VALID', stride=[1,1],
# bn=True, is_training=is_training, weight_decay=weight_decay,
# scope='adj_conv1', bn_decay=bn_decay, is_dist=True)
out1 = layers.masked_conv2d(
edge_feature,
64,
# max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.contrib.layers.xavier_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6,
weights_initializer=tf.contrib.layers.xavier_initializer(),
scope='adj_conv1')
# out2 = tf_util.conv2d(out1, 64, [1,1],
# padding='VALID', stride=[1,1],
# bn=True, is_training=is_training, weight_decay=weight_decay,
# scope='adj_conv2', bn_decay=bn_decay, is_dist=True)
out2 = layers.masked_conv2d(
out1,
64,
# max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.contrib.layers.xavier_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6,
weights_initializer=tf.contrib.layers.xavier_initializer(),
scope='adj_conv2')
net_1 = tf.reduce_max(out2, axis=-2, keep_dims=True)
adj = tf_util.pairwise_distance(net_1)
nn_idx = tf_util.knn(adj, k=k)
edge_feature = tf_util.get_edge_feature(net_1, nn_idx=nn_idx, k=k)
# out3 = tf_util.conv2d(edge_feature, 64, [1,1],
# padding='VALID', stride=[1,1],
# bn=True, is_training=is_training, weight_decay=weight_decay,
# scope='adj_conv3', bn_decay=bn_decay, is_dist=True)
out3 = layers.masked_conv2d(
edge_feature,
64,
# max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.contrib.layers.xavier_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6,
weights_initializer=tf.contrib.layers.xavier_initializer(),
scope='adj_conv3')
# out4 = tf_util.conv2d(out3, 64, [1,1],
# padding='VALID', stride=[1,1],
# bn=True, is_training=is_training, weight_decay=weight_decay,
# scope='adj_conv4', bn_decay=bn_decay, is_dist=True)
out4 = layers.masked_conv2d(
out3,
64,
# max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.contrib.layers.xavier_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6,
weights_initializer=tf.contrib.layers.xavier_initializer(),
scope='adj_conv4')
net_2 = tf.reduce_max(out4, axis=-2, keep_dims=True)
adj = tf_util.pairwise_distance(net_2)
nn_idx = tf_util.knn(adj, k=k)
edge_feature = tf_util.get_edge_feature(net_2, nn_idx=nn_idx, k=k)
# out5 = tf_util.conv2d(edge_feature, 64, [1,1],
# padding='VALID', stride=[1,1],
# bn=True, is_training=is_training, weight_decay=weight_decay,
# scope='adj_conv5', bn_decay=bn_decay, is_dist=True)
out5 = layers.masked_conv2d(
edge_feature,
64,
# max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.contrib.layers.xavier_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6,
weights_initializer=tf.contrib.layers.xavier_initializer(),
scope='adj_conv5')
# out6 = tf_util.conv2d(out5, 64, [1,1],
# padding='VALID', stride=[1,1],
# bn=True, is_training=is_training, weight_decay=weight_decay,
# scope='adj_conv6', bn_decay=bn_decay, is_dist=True)
net_3 = tf.reduce_max(out5, axis=-2, keep_dims=True)
# out7 = tf_util.conv2d(tf.concat([net_1, net_2, net_3], axis=-1), 1024, [1, 1],
# padding='VALID', stride=[1,1],
# bn=True, is_training=is_training,
# scope='adj_conv7', bn_decay=bn_decay, is_dist=True)
out7 = layers.masked_conv2d(
tf.concat([net_1, net_2, net_3], axis=-1),
1024,
# max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.contrib.layers.xavier_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6,
weights_initializer=tf.contrib.layers.xavier_initializer(),
scope='adj_conv7')
# out_max = tf_util.max_pool2d(out7, [num_point, 1], padding='VALID', scope='maxpool')
out_max = slim.max_pool2d(out7, [num_point, 1],
stride=1,
padding='VALID',
scope='maxpool')
one_hot_label_expand = tf.reshape(input_label,
[batch_size, 1, 1, cat_num])
# one_hot_label_expand = tf_util.conv2d(one_hot_label_expand, 64, [1, 1],
# padding='VALID', stride=[1,1],
# bn=True, is_training=is_training,
# scope='one_hot_label_expand', bn_decay=bn_decay, is_dist=True)
one_hot_label_expand = layers.masked_conv2d(
one_hot_label_expand,
64,
# max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.contrib.layers.xavier_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6,
weights_initializer=tf.contrib.layers.xavier_initializer(),
scope='one_hot_label_expand')
out_max = tf.concat(axis=3, values=[out_max, one_hot_label_expand])
expand = tf.tile(out_max, [1, num_point, 1, 1])
concat = tf.concat(axis=3, values=[expand, net_1, net_2, net_3])
# net2 = tf_util.conv2d(concat, 256, [1,1], padding='VALID', stride=[1,1], bn_decay=bn_decay,
# bn=True, is_training=is_training, scope='seg/conv1', weight_decay=weight_decay, is_dist=True)
net2 = layers.masked_conv2d(
concat,
256,
# max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.contrib.layers.xavier_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6,
weights_initializer=tf.contrib.layers.xavier_initializer(),
scope='seg/conv1')
# net2 = tf_util.dropout(net2, keep_prob=0.6, is_training=is_training, scope='seg/dp1')
net2 = slim.dropout(net2,
keep_prob=0.6,
is_training=is_training,
scope='seg/dp1')
# net2 = tf_util.conv2d(net2, 256, [1,1], padding='VALID', stride=[1,1], bn_decay=bn_decay,
# bn=True, is_training=is_training, scope='seg/conv2', weight_decay=weight_decay, is_dist=True)
net2 = layers.masked_conv2d(
net2,
256,
# max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.contrib.layers.xavier_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6,
weights_initializer=tf.contrib.layers.xavier_initializer(),
scope='seg/conv2')
# net2 = tf_util.dropout(net2, keep_prob=0.6, is_training=is_training, scope='seg/dp2')
net2 = slim.dropout(net2,
keep_prob=0.6,
is_training=is_training,
scope='seg/dp2')
# net2 = tf_util.conv2d(net2, 128, [1,1], padding='VALID', stride=[1,1], bn_decay=bn_decay,
# bn=True, is_training=is_training, scope='seg/conv3', weight_decay=weight_decay, is_dist=True)
net2 = layers.masked_conv2d(
net2,
128,
# max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.contrib.layers.xavier_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6,
weights_initializer=tf.contrib.layers.xavier_initializer(),
scope='seg/conv3')
# net2 = tf_util.conv2d(net2, part_num, [1,1], padding='VALID', stride=[1,1], activation_fn=None,
# bn=False, scope='seg/conv4', weight_decay=weight_decay, is_dist=True)
net2 = layers.masked_conv2d(
net2,
part_num,
# max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=None,
# normalizer_params=bn_params,
biases_initializer=tf.contrib.layers.xavier_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=None,
weights_initializer=tf.contrib.layers.xavier_initializer(),
scope='seg/conv4')
net2 = tf.reshape(net2, [batch_size, num_point, part_num])
return net2
def input_transform_net(edge_feature, is_training, bn_decay=None, K=3,
scale=1., weight_decay=0.00004):
""" Input (XYZ) Transform Net, input is BxNx3 gray image
Return:
Transformation matrix of size 3xK """
bn_params = {"is_training": is_training,
"decay": bn_decay,
}
with tf.variable_scope(None, default_name="transform_net"):
batch_size = edge_feature.get_shape()[0].value
num_point = edge_feature.get_shape()[1].value
neighbor = edge_feature.get_shape()[2].value
# input_image = tf.expand_dims(point_cloud, -1)
net = layers.masked_conv2d(edge_feature,
# 64,
max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
activation_fn=tf.nn.relu6,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='tconv1')
net = layers.masked_conv2d(net,
# 128,
max(int(round(128 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='tconv2',
activation_fn=tf.nn.relu6)
net = tf.reduce_max(net, axis=-2, keepdims=True)
# net = slim.max_pool2d(net, [1, neighbor], stride=1, padding='VALID')
net = layers.masked_conv2d(net,
# 1024,
# max(int(round(1024 * scale)), 32),
max(int(round(1024 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='tconv3',
activation_fn=tf.nn.relu6)
# print(net)
net = slim.max_pool2d(net, [num_point, 1],
padding='VALID', scope='tmaxpool')
# net = tf.reshape(net, [batch_size, 1, 1, -1])
# print(net)
net = layers.masked_conv2d(net,
# 512,
max(int(round(512 * scale)), 32),
[1, 1],
padding='SAME',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='tfc1',
activation_fn=tf.nn.relu6)
net = layers.masked_conv2d(net,
# 256,
max(int(round(256 * scale)), 32),
[1, 1],
padding='SAME',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='tfc2',
activation_fn=tf.nn.relu6)
transform = layers.masked_conv2d(net,
K * K, [1, 1],
padding='SAME',
stride=1,
normalizer_fn=None,
# normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='transform_XYZ',
activation_fn=None,
# activation_fn=tf.nn.relu6,
)
transform = tf.reshape(transform, [batch_size, K, K])
return transform
def prunable_inception_v3(inputs,
num_classes=1000,
is_training=True,
dropout_keep_prob=0.8,
min_depth=16,
depth_multiplier=1.0,
prediction_fn=slim.softmax,
spatial_squeeze=True,
reuse=None,
create_aux_logits=True,
scope='InceptionV3',
global_pool=False):
"""Inception model from http://arxiv.org/abs/1512.00567.
"Rethinking the Inception Architecture for Computer Vision"
Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens,
Zbigniew Wojna.
With the default arguments this method constructs the exact model defined in
the paper. However, one can experiment with variations of the inception_v3
network by changing arguments dropout_keep_prob, min_depth and
depth_multiplier.
The default image size used to train this network is 299x299.
Args:
inputs: a tensor of size [batch_size, height, width, channels].
num_classes: number of predicted classes. If 0 or None, the logits layer
is omitted and the input features to the logits layer (before dropout)
are returned instead.
is_training: whether is training or not.
dropout_keep_prob: the percentage of activation values that are retained.
min_depth: Minimum depth value (number of channels) for all convolution ops.
Enforced when depth_multiplier < 1, and not an active constraint when
depth_multiplier >= 1.
depth_multiplier: Float multiplier for the depth (number of channels)
for all convolution ops. The value must be greater than zero. Typical
usage will be to set this value in (0, 1) to reduce the number of
parameters or computation cost of the model.
prediction_fn: a function to get predictions out of logits.
spatial_squeeze: if True, logits is of shape [B, C], if false logits is of
shape [B, 1, 1, C], where B is batch_size and C is number of classes.
reuse: whether or not the network and its variables should be reused. To be
able to reuse 'scope' must be given.
create_aux_logits: Whether to create the auxiliary logits.
scope: Optional variable_scope.
global_pool: Optional boolean flag to control the avgpooling before the
logits layer. If false or unset, pooling is done with a fixed window
that reduces default-sized inputs to 1x1, while larger inputs lead to
larger outputs. If true, any input size is pooled down to 1x1.
Returns:
net: a Tensor with the logits (pre-softmax activations) if num_classes
is a non-zero integer, or the non-dropped-out input to the logits layer
if num_classes is 0 or None.
end_points: a dictionary from components of the network to the corresponding
activation.
Raises:
ValueError: if 'depth_multiplier' is less than or equal to zero.
"""
if depth_multiplier <= 0:
raise ValueError('depth_multiplier is not greater than zero.')
depth = lambda d: max(int(d * depth_multiplier), min_depth)
with tf.variable_scope(scope, 'InceptionV3', [inputs],
reuse=reuse) as scope:
with slim.arg_scope([slim.batch_norm, slim.dropout],
is_training=is_training):
net, end_points = prunable_inception_v3_base(
inputs,
scope=scope,
min_depth=min_depth,
depth_multiplier=depth_multiplier)
# Auxiliary Head logits
if create_aux_logits and num_classes:
with slim.arg_scope(
[masked_conv2d, slim.max_pool2d, slim.avg_pool2d],
stride=1,
padding='SAME'):
aux_logits = end_points['Mixed_6e']
with tf.variable_scope('AuxLogits'):
aux_logits = slim.avg_pool2d(aux_logits, [5, 5],
stride=3,
padding='VALID',
scope='AvgPool_1a_5x5')
aux_logits = masked_conv2d(aux_logits,
depth(128), [1, 1],
scope='Conv2d_1b_1x1')
# Shape of feature map before the final layer.
kernel_size = _reduced_kernel_size_for_small_input(
aux_logits, [5, 5])
aux_logits = masked_conv2d(
aux_logits,
depth(768),
kernel_size,
weights_initializer=trunc_normal(0.01),
padding='VALID',
scope='Conv2d_2a_{}x{}'.format(*kernel_size))
aux_logits = masked_conv2d(
aux_logits,
num_classes, [1, 1],
activation_fn=None,
normalizer_fn=None,
weights_initializer=trunc_normal(0.001),
scope='Conv2d_2b_1x1')
if spatial_squeeze:
aux_logits = tf.squeeze(aux_logits, [1, 2],
name='SpatialSqueeze')
end_points['AuxLogits'] = aux_logits
# Final pooling and prediction
with tf.variable_scope('Logits'):
if global_pool:
# Global average pooling.
net = tf.reduce_mean(net, [1, 2],
keep_dims=True,
name='GlobalPool')
end_points['global_pool'] = net
else:
# Pooling with a fixed kernel size.
kernel_size = _reduced_kernel_size_for_small_input(
net, [8, 8])
net = slim.avg_pool2d(
net,
kernel_size,
padding='VALID',
scope='AvgPool_1a_{}x{}'.format(*kernel_size))
end_points['AvgPool_1a'] = net
if not num_classes:
return net, end_points
# 1 x 1 x 2048
net = slim.dropout(net,
keep_prob=dropout_keep_prob,
scope='Dropout_1b')
end_points['PreLogits'] = net
# 2048
logits = masked_conv2d(net,
num_classes, [1, 1],
activation_fn=None,
normalizer_fn=None,
scope='Conv2d_1c_1x1')
if spatial_squeeze:
logits = tf.squeeze(logits, [1, 2], name='SpatialSqueeze')
# 1000
end_points['Logits'] = logits
end_points['Predictions'] = prediction_fn(logits,
scope='Predictions')
return logits, end_points
def prunable_inception_v3_base(inputs,
final_endpoint='Mixed_7c',
min_depth=16,
depth_multiplier=1.0,
scope=None):
"""Inception model from http://arxiv.org/abs/1512.00567.
Constructs an Inception v3 network from inputs to the given final endpoint.
This method can construct the network up to the final inception block
Mixed_7c.
Note that the names of the layers in the paper do not correspond to the names
of the endpoints registered by this function although they build the same
network.
Here is a mapping from the old_names to the new names:
Old name | New name
=======================================
conv0 | Conv2d_1a_3x3
conv1 | Conv2d_2a_3x3
conv2 | Conv2d_2b_3x3
pool1 | MaxPool_3a_3x3
conv3 | Conv2d_3b_1x1
conv4 | Conv2d_4a_3x3
pool2 | MaxPool_5a_3x3
mixed_35x35x256a | Mixed_5b
mixed_35x35x288a | Mixed_5c
mixed_35x35x288b | Mixed_5d
mixed_17x17x768a | Mixed_6a
mixed_17x17x768b | Mixed_6b
mixed_17x17x768c | Mixed_6c
mixed_17x17x768d | Mixed_6d
mixed_17x17x768e | Mixed_6e
mixed_8x8x1280a | Mixed_7a
mixed_8x8x2048a | Mixed_7b
mixed_8x8x2048b | Mixed_7c
Args:
inputs: a tensor of size [batch_size, height, width, channels].
final_endpoint: specifies the endpoint to construct the network up to. It
can be one of ['Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3',
'MaxPool_3a_3x3', 'Conv2d_3b_1x1', 'Conv2d_4a_3x3', 'MaxPool_5a_3x3',
'Mixed_5b', 'Mixed_5c', 'Mixed_5d', 'Mixed_6a', 'Mixed_6b', 'Mixed_6c',
'Mixed_6d', 'Mixed_6e', 'Mixed_7a', 'Mixed_7b', 'Mixed_7c'].
min_depth: Minimum depth value (number of channels) for all convolution ops.
Enforced when depth_multiplier < 1, and not an active constraint when
depth_multiplier >= 1.
depth_multiplier: Float multiplier for the depth (number of channels)
for all convolution ops. The value must be greater than zero. Typical
usage will be to set this value in (0, 1) to reduce the number of
parameters or computation cost of the model.
scope: Optional variable_scope.
Returns:
tensor_out: output tensor corresponding to the final_endpoint.
end_points: a set of activations for external use, for example summaries or
losses.
Raises:
ValueError: if final_endpoint is not set to one of the predefined values,
or depth_multiplier <= 0
"""
# end_points will collect relevant activations for external use, for example
# summaries or losses.
end_points = {}
if depth_multiplier <= 0:
raise ValueError('depth_multiplier is not greater than zero.')
depth = lambda d: max(int(d * depth_multiplier), min_depth)
with tf.variable_scope(scope, 'InceptionV3', [inputs]):
with slim.arg_scope([masked_conv2d, slim.max_pool2d, slim.avg_pool2d],
stride=1,
padding='VALID'):
# 299 x 299 x 3
end_point = 'Conv2d_1a_3x3'
net = masked_conv2d(inputs,
depth(32), [3, 3],
stride=2,
scope=end_point)
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# 149 x 149 x 32
end_point = 'Conv2d_2a_3x3'
net = masked_conv2d(net, depth(32), [3, 3], scope=end_point)
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# 147 x 147 x 32
end_point = 'Conv2d_2b_3x3'
net = masked_conv2d(net,
depth(64), [3, 3],
padding='SAME',
scope=end_point)
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# 147 x 147 x 64
end_point = 'MaxPool_3a_3x3'
net = slim.max_pool2d(net, [3, 3], stride=2, scope=end_point)
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# 73 x 73 x 64
end_point = 'Conv2d_3b_1x1'
net = masked_conv2d(net, depth(80), [1, 1], scope=end_point)
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# 73 x 73 x 80.
end_point = 'Conv2d_4a_3x3'
net = masked_conv2d(net, depth(192), [3, 3], scope=end_point)
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# 71 x 71 x 192.
end_point = 'MaxPool_5a_3x3'
net = slim.max_pool2d(net, [3, 3], stride=2, scope=end_point)
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# 35 x 35 x 192.
# Inception blocks
with slim.arg_scope([masked_conv2d, slim.max_pool2d, slim.avg_pool2d],
stride=1,
padding='SAME'):
# mixed: 35 x 35 x 256.
end_point = 'Mixed_5b'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
branch_0 = masked_conv2d(net,
depth(64), [1, 1],
scope='Conv2d_0a_1x1')
with tf.variable_scope('Branch_1'):
branch_1 = masked_conv2d(net,
depth(48), [1, 1],
scope='Conv2d_0a_1x1')
branch_1 = masked_conv2d(branch_1,
depth(64), [5, 5],
scope='Conv2d_0b_5x5')
with tf.variable_scope('Branch_2'):
branch_2 = masked_conv2d(net,
depth(64), [1, 1],
scope='Conv2d_0a_1x1')
branch_2 = masked_conv2d(branch_2,
depth(96), [3, 3],
scope='Conv2d_0b_3x3')
branch_2 = masked_conv2d(branch_2,
depth(96), [3, 3],
scope='Conv2d_0c_3x3')
with tf.variable_scope('Branch_3'):
branch_3 = slim.avg_pool2d(net, [3, 3],
scope='AvgPool_0a_3x3')
branch_3 = masked_conv2d(branch_3,
depth(32), [1, 1],
scope='Conv2d_0b_1x1')
net = tf.concat(
axis=3, values=[branch_0, branch_1, branch_2, branch_3])
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# mixed_1: 35 x 35 x 288.
end_point = 'Mixed_5c'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
branch_0 = masked_conv2d(net,
depth(64), [1, 1],
scope='Conv2d_0a_1x1')
with tf.variable_scope('Branch_1'):
branch_1 = masked_conv2d(net,
depth(48), [1, 1],
scope='Conv2d_0b_1x1')
branch_1 = masked_conv2d(branch_1,
depth(64), [5, 5],
scope='Conv_1_0c_5x5')
with tf.variable_scope('Branch_2'):
branch_2 = masked_conv2d(net,
depth(64), [1, 1],
scope='Conv2d_0a_1x1')
branch_2 = masked_conv2d(branch_2,
depth(96), [3, 3],
scope='Conv2d_0b_3x3')
branch_2 = masked_conv2d(branch_2,
depth(96), [3, 3],
scope='Conv2d_0c_3x3')
with tf.variable_scope('Branch_3'):
branch_3 = slim.avg_pool2d(net, [3, 3],
scope='AvgPool_0a_3x3')
branch_3 = masked_conv2d(branch_3,
depth(64), [1, 1],
scope='Conv2d_0b_1x1')
net = tf.concat(
axis=3, values=[branch_0, branch_1, branch_2, branch_3])
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# mixed_2: 35 x 35 x 288.
end_point = 'Mixed_5d'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
branch_0 = masked_conv2d(net,
depth(64), [1, 1],
scope='Conv2d_0a_1x1')
with tf.variable_scope('Branch_1'):
branch_1 = masked_conv2d(net,
depth(48), [1, 1],
scope='Conv2d_0a_1x1')
branch_1 = masked_conv2d(branch_1,
depth(64), [5, 5],
scope='Conv2d_0b_5x5')
with tf.variable_scope('Branch_2'):
branch_2 = masked_conv2d(net,
depth(64), [1, 1],
scope='Conv2d_0a_1x1')
branch_2 = masked_conv2d(branch_2,
depth(96), [3, 3],
scope='Conv2d_0b_3x3')
branch_2 = masked_conv2d(branch_2,
depth(96), [3, 3],
scope='Conv2d_0c_3x3')
with tf.variable_scope('Branch_3'):
branch_3 = slim.avg_pool2d(net, [3, 3],
scope='AvgPool_0a_3x3')
branch_3 = masked_conv2d(branch_3,
depth(64), [1, 1],
scope='Conv2d_0b_1x1')
net = tf.concat(
axis=3, values=[branch_0, branch_1, branch_2, branch_3])
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# mixed_3: 17 x 17 x 768.
end_point = 'Mixed_6a'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
branch_0 = masked_conv2d(net,
depth(384), [3, 3],
stride=2,
padding='VALID',
scope='Conv2d_1a_1x1')
with tf.variable_scope('Branch_1'):
branch_1 = masked_conv2d(net,
depth(64), [1, 1],
scope='Conv2d_0a_1x1')
branch_1 = masked_conv2d(branch_1,
depth(96), [3, 3],
scope='Conv2d_0b_3x3')
branch_1 = masked_conv2d(branch_1,
depth(96), [3, 3],
stride=2,
padding='VALID',
scope='Conv2d_1a_1x1')
with tf.variable_scope('Branch_2'):
branch_2 = slim.max_pool2d(net, [3, 3],
stride=2,
padding='VALID',
scope='MaxPool_1a_3x3')
net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2])
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# mixed4: 17 x 17 x 768.
end_point = 'Mixed_6b'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
branch_0 = masked_conv2d(net,
depth(192), [1, 1],
scope='Conv2d_0a_1x1')
with tf.variable_scope('Branch_1'):
branch_1 = masked_conv2d(net,
depth(128), [1, 1],
scope='Conv2d_0a_1x1')
branch_1 = masked_conv2d(branch_1,
depth(128), [1, 7],
scope='Conv2d_0b_1x7')
branch_1 = masked_conv2d(branch_1,
depth(192), [7, 1],
scope='Conv2d_0c_7x1')
with tf.variable_scope('Branch_2'):
branch_2 = masked_conv2d(net,
depth(128), [1, 1],
scope='Conv2d_0a_1x1')
branch_2 = masked_conv2d(branch_2,
depth(128), [7, 1],
scope='Conv2d_0b_7x1')
branch_2 = masked_conv2d(branch_2,
depth(128), [1, 7],
scope='Conv2d_0c_1x7')
branch_2 = masked_conv2d(branch_2,
depth(128), [7, 1],
scope='Conv2d_0d_7x1')
branch_2 = masked_conv2d(branch_2,
depth(192), [1, 7],
scope='Conv2d_0e_1x7')
with tf.variable_scope('Branch_3'):
branch_3 = slim.avg_pool2d(net, [3, 3],
scope='AvgPool_0a_3x3')
branch_3 = masked_conv2d(branch_3,
depth(192), [1, 1],
scope='Conv2d_0b_1x1')
net = tf.concat(
axis=3, values=[branch_0, branch_1, branch_2, branch_3])
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# mixed_5: 17 x 17 x 768.
end_point = 'Mixed_6c'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
branch_0 = masked_conv2d(net,
depth(192), [1, 1],
scope='Conv2d_0a_1x1')
with tf.variable_scope('Branch_1'):
branch_1 = masked_conv2d(net,
depth(160), [1, 1],
scope='Conv2d_0a_1x1')
branch_1 = masked_conv2d(branch_1,
depth(160), [1, 7],
scope='Conv2d_0b_1x7')
branch_1 = masked_conv2d(branch_1,
depth(192), [7, 1],
scope='Conv2d_0c_7x1')
with tf.variable_scope('Branch_2'):
branch_2 = masked_conv2d(net,
depth(160), [1, 1],
scope='Conv2d_0a_1x1')
branch_2 = masked_conv2d(branch_2,
depth(160), [7, 1],
scope='Conv2d_0b_7x1')
branch_2 = masked_conv2d(branch_2,
depth(160), [1, 7],
scope='Conv2d_0c_1x7')
branch_2 = masked_conv2d(branch_2,
depth(160), [7, 1],
scope='Conv2d_0d_7x1')
branch_2 = masked_conv2d(branch_2,
depth(192), [1, 7],
scope='Conv2d_0e_1x7')
with tf.variable_scope('Branch_3'):
branch_3 = slim.avg_pool2d(net, [3, 3],
scope='AvgPool_0a_3x3')
branch_3 = masked_conv2d(branch_3,
depth(192), [1, 1],
scope='Conv2d_0b_1x1')
net = tf.concat(
axis=3, values=[branch_0, branch_1, branch_2, branch_3])
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# mixed_6: 17 x 17 x 768.
end_point = 'Mixed_6d'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
branch_0 = masked_conv2d(net,
depth(192), [1, 1],
scope='Conv2d_0a_1x1')
with tf.variable_scope('Branch_1'):
branch_1 = masked_conv2d(net,
depth(160), [1, 1],
scope='Conv2d_0a_1x1')
branch_1 = masked_conv2d(branch_1,
depth(160), [1, 7],
scope='Conv2d_0b_1x7')
branch_1 = masked_conv2d(branch_1,
depth(192), [7, 1],
scope='Conv2d_0c_7x1')
with tf.variable_scope('Branch_2'):
branch_2 = masked_conv2d(net,
depth(160), [1, 1],
scope='Conv2d_0a_1x1')
branch_2 = masked_conv2d(branch_2,
depth(160), [7, 1],
scope='Conv2d_0b_7x1')
branch_2 = masked_conv2d(branch_2,
depth(160), [1, 7],
scope='Conv2d_0c_1x7')
branch_2 = masked_conv2d(branch_2,
depth(160), [7, 1],
scope='Conv2d_0d_7x1')
branch_2 = masked_conv2d(branch_2,
depth(192), [1, 7],
scope='Conv2d_0e_1x7')
with tf.variable_scope('Branch_3'):
branch_3 = slim.avg_pool2d(net, [3, 3],
scope='AvgPool_0a_3x3')
branch_3 = masked_conv2d(branch_3,
depth(192), [1, 1],
scope='Conv2d_0b_1x1')
net = tf.concat(
axis=3, values=[branch_0, branch_1, branch_2, branch_3])
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# mixed_7: 17 x 17 x 768.
end_point = 'Mixed_6e'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
branch_0 = masked_conv2d(net,
depth(192), [1, 1],
scope='Conv2d_0a_1x1')
with tf.variable_scope('Branch_1'):
branch_1 = masked_conv2d(net,
depth(192), [1, 1],
scope='Conv2d_0a_1x1')
branch_1 = masked_conv2d(branch_1,
depth(192), [1, 7],
scope='Conv2d_0b_1x7')
branch_1 = masked_conv2d(branch_1,
depth(192), [7, 1],
scope='Conv2d_0c_7x1')
with tf.variable_scope('Branch_2'):
branch_2 = masked_conv2d(net,
depth(192), [1, 1],
scope='Conv2d_0a_1x1')
branch_2 = masked_conv2d(branch_2,
depth(192), [7, 1],
scope='Conv2d_0b_7x1')
branch_2 = masked_conv2d(branch_2,
depth(192), [1, 7],
scope='Conv2d_0c_1x7')
branch_2 = masked_conv2d(branch_2,
depth(192), [7, 1],
scope='Conv2d_0d_7x1')
branch_2 = masked_conv2d(branch_2,
depth(192), [1, 7],
scope='Conv2d_0e_1x7')
with tf.variable_scope('Branch_3'):
branch_3 = slim.avg_pool2d(net, [3, 3],
scope='AvgPool_0a_3x3')
branch_3 = masked_conv2d(branch_3,
depth(192), [1, 1],
scope='Conv2d_0b_1x1')
net = tf.concat(
axis=3, values=[branch_0, branch_1, branch_2, branch_3])
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# mixed_8: 8 x 8 x 1280.
end_point = 'Mixed_7a'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
branch_0 = masked_conv2d(net,
depth(192), [1, 1],
scope='Conv2d_0a_1x1')
branch_0 = masked_conv2d(branch_0,
depth(320), [3, 3],
stride=2,
padding='VALID',
scope='Conv2d_1a_3x3')
with tf.variable_scope('Branch_1'):
branch_1 = masked_conv2d(net,
depth(192), [1, 1],
scope='Conv2d_0a_1x1')
branch_1 = masked_conv2d(branch_1,
depth(192), [1, 7],
scope='Conv2d_0b_1x7')
branch_1 = masked_conv2d(branch_1,
depth(192), [7, 1],
scope='Conv2d_0c_7x1')
branch_1 = masked_conv2d(branch_1,
depth(192), [3, 3],
stride=2,
padding='VALID',
scope='Conv2d_1a_3x3')
with tf.variable_scope('Branch_2'):
branch_2 = slim.max_pool2d(net, [3, 3],
stride=2,
padding='VALID',
scope='MaxPool_1a_3x3')
net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2])
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# mixed_9: 8 x 8 x 2048.
end_point = 'Mixed_7b'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
branch_0 = masked_conv2d(net,
depth(320), [1, 1],
scope='Conv2d_0a_1x1')
with tf.variable_scope('Branch_1'):
branch_1 = masked_conv2d(net,
depth(384), [1, 1],
scope='Conv2d_0a_1x1')
branch_1 = tf.concat(
axis=3,
values=[
masked_conv2d(branch_1,
depth(384), [1, 3],
scope='Conv2d_0b_1x3'),
masked_conv2d(branch_1,
depth(384), [3, 1],
scope='Conv2d_0b_3x1')
])
with tf.variable_scope('Branch_2'):
branch_2 = masked_conv2d(net,
depth(448), [1, 1],
scope='Conv2d_0a_1x1')
branch_2 = masked_conv2d(branch_2,
depth(384), [3, 3],
scope='Conv2d_0b_3x3')
branch_2 = tf.concat(
axis=3,
values=[
masked_conv2d(branch_2,
depth(384), [1, 3],
scope='Conv2d_0c_1x3'),
masked_conv2d(branch_2,
depth(384), [3, 1],
scope='Conv2d_0d_3x1')
])
with tf.variable_scope('Branch_3'):
branch_3 = slim.avg_pool2d(net, [3, 3],
scope='AvgPool_0a_3x3')
branch_3 = masked_conv2d(branch_3,
depth(192), [1, 1],
scope='Conv2d_0b_1x1')
net = tf.concat(
axis=3, values=[branch_0, branch_1, branch_2, branch_3])
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
# mixed_10: 8 x 8 x 2048.
end_point = 'Mixed_7c'
with tf.variable_scope(end_point):
with tf.variable_scope('Branch_0'):
branch_0 = masked_conv2d(net,
depth(320), [1, 1],
scope='Conv2d_0a_1x1')
with tf.variable_scope('Branch_1'):
branch_1 = masked_conv2d(net,
depth(384), [1, 1],
scope='Conv2d_0a_1x1')
branch_1 = tf.concat(
axis=3,
values=[
masked_conv2d(branch_1,
depth(384), [1, 3],
scope='Conv2d_0b_1x3'),
masked_conv2d(branch_1,
depth(384), [3, 1],
scope='Conv2d_0c_3x1')
])
with tf.variable_scope('Branch_2'):
branch_2 = masked_conv2d(net,
depth(448), [1, 1],
scope='Conv2d_0a_1x1')
branch_2 = masked_conv2d(branch_2,
depth(384), [3, 3],
scope='Conv2d_0b_3x3')
branch_2 = tf.concat(
axis=3,
values=[
masked_conv2d(branch_2,
depth(384), [1, 3],
scope='Conv2d_0c_1x3'),
masked_conv2d(branch_2,
depth(384), [3, 1],
scope='Conv2d_0d_3x1')
])
with tf.variable_scope('Branch_3'):
branch_3 = slim.avg_pool2d(net, [3, 3],
scope='AvgPool_0a_3x3')
branch_3 = masked_conv2d(branch_3,
depth(192), [1, 1],
scope='Conv2d_0b_1x1')
net = tf.concat(
axis=3, values=[branch_0, branch_1, branch_2, branch_3])
end_points[end_point] = net
if end_point == final_endpoint: return net, end_points
raise ValueError('Unknown final endpoint %s' % final_endpoint)
def feature_transform_net(inputs, is_training, bn_decay=None, K=64, scale=1., weight_decay=0.00004):
""" Feature Transform Net, input is BxNx1xK
Return:
Transformation matrix of size KxK """
bn_params = {"is_training": is_training,
"decay": bn_decay,
'epsilon': 1e-3
}
with tf.variable_scope(None, default_name="feature_transform_net"):
batch_size = inputs.get_shape()[0].value
num_point = inputs.get_shape()[1].value
net = layers.masked_conv2d(inputs,
# 64,
max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
activation_fn=tf.nn.relu6,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='tconv1')
net = layers.masked_conv2d(net,
# 128,
max(int(round(128 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
activation_fn=tf.nn.relu6,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='tconv2')
net = layers.masked_conv2d(net,
# 128,
max(int(round(1024 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
activation_fn=tf.nn.relu6,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='tconv3')
net = slim.max_pool2d(net, [num_point, 1],
padding='VALID', scope='tmaxpool')
# net = tf.reshape(net, [batch_size, -1])
net = layers.masked_conv2d(net,
# 128,
max(int(round(512 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
activation_fn=tf.nn.relu6,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='tfc1')
net = layers.masked_conv2d(net,
# 128,
max(int(round(256 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
activation_fn=tf.nn.relu6,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='tfc2')
transform = layers.masked_conv2d(net,
K * K, [1, 1],
padding='SAME',
stride=1,
normalizer_fn=None,
# normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='transform_XYZ',
activation_fn=None,
# activation_fn=tf.nn.relu6,
)
transform = tf.reshape(transform, [batch_size, K, K])
return transform
def testInvalidRank5(self):
input_tensor = array_ops.ones((8, 8, self.height, self.width, 3))
with self.assertRaisesRegexp(ValueError, 'rank'):
layers.masked_conv2d(input_tensor, 32, 3)
def sparse_conv2d(x,
units,
kernel_size,
activation=None,
use_bias=False,
kernel_initializer=None,
kernel_regularizer=None,
bias_initializer=None,
biases_regularizer=None,
sparsity_technique='baseline',
log_sigma2_initializer=None,
log_alpha_initializer=None,
normalizer_fn=None,
strides=(1, 1),
padding='SAME',
threshold=3.0,
clip_alpha=None,
data_format='channels_last',
is_training=False,
name=None):
"""Function that constructs conv2d with any desired pruning method.
Args:
x: Input, float32 tensor.
units: Int representing size of output tensor.
kernel_size: The size of the convolutional window, int of list of ints.
activation: If None, a linear activation is used.
use_bias: Boolean specifying whether bias vector should be used.
kernel_initializer: Initializer for the convolution weights.
kernel_regularizer: Regularization method for the convolution weights.
bias_initializer: Initalizer of the bias vector.
biases_regularizer: Optional regularizer for the bias vector.
sparsity_technique: Method used to introduce sparsity.
['threshold', 'variational_dropout', 'l0_regularization']
log_sigma2_initializer: Specified initializer of the log_sigma2 term used
in variational dropout.
log_alpha_initializer: Specified initializer of the log_alpha term used
in l0 regularization.
normalizer_fn: function used to transform the output activations.
strides: stride length of convolution, a single int is expected.
padding: May be populated as 'VALID' or 'SAME'.
threshold: Theshold for masking variational dropout log alpha at test time.
clip_alpha: Int that specifies range for clippling variational dropout
log alpha values.
data_format: Either 'channels_last', 'channels_first'.
is_training: Boolean specifying whether it is training or eval.
name: String speciying name scope of layer in network.
Returns:
Output: activations.
Raises:
ValueError: If the rank of the input is not greater than 2.
"""
if data_format == 'channels_last':
data_format_channels = 'NHWC'
elif data_format == 'channels_first':
data_format_channels = 'NCHW'
else:
raise ValueError('Not a valid channel string:', data_format)
layer_variable_getter = variable_getter({
'bias': 'biases',
'kernel': 'weights',
})
input_rank = x.get_shape().ndims
if input_rank != 4:
raise ValueError('Rank not supported {}'.format(input_rank))
with tf.variable_scope(name,
'Conv', [x],
custom_getter=layer_variable_getter) as sc:
input_shape = x.get_shape().as_list()
if input_shape[-1] is None:
raise ValueError(
'The last dimension of the inputs to `Convolution` '
'should be defined. Found `None`.')
pruning_methods = ['threshold']
if sparsity_technique in pruning_methods:
return layers.masked_conv2d(inputs=x,
num_outputs=units,
kernel_size=kernel_size[0],
stride=strides[0],
padding=padding,
data_format=data_format_channels,
rate=1,
activation_fn=activation,
weights_initializer=kernel_initializer,
weights_regularizer=kernel_regularizer,
normalizer_fn=normalizer_fn,
normalizer_params=None,
biases_initializer=bias_initializer,
biases_regularizer=biases_regularizer,
outputs_collections=None,
trainable=True,
scope=sc)
elif sparsity_technique == 'variational_dropout':
vd_conv = vd.layers.Conv2D(
num_outputs=units,
kernel_size=kernel_size,
strides=strides,
activation=activation,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
bias_initializer=bias_initializer,
bias_regularizer=biases_regularizer,
log_sigma2_initializer=log_sigma2_initializer,
is_training=is_training,
use_bias=use_bias,
padding=padding,
data_format=data_format_channels,
clip_alpha=clip_alpha,
threshold=threshold,
trainable=True,
name=sc)
return vd_conv.apply(x)
elif sparsity_technique == 'l0_regularization':
l0_conv = l0.layers.Conv2D(
num_outputs=units,
kernel_size=kernel_size,
strides=strides,
activation=activation,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
bias_initializer=bias_initializer,
bias_regularizer=biases_regularizer,
log_alpha_initializer=log_alpha_initializer,
is_training=is_training,
use_bias=use_bias,
padding=padding,
data_format=data_format_channels,
trainable=True,
name=sc)
return l0_conv.apply(x)
elif sparsity_technique == 'baseline':
return tf.layers.conv2d(inputs=x,
filters=units,
kernel_size=kernel_size,
strides=strides,
padding=padding,
use_bias=use_bias,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
data_format=data_format,
name=name)
else:
raise ValueError(
'Unsupported sparsity technique {}'.format(sparsity_technique))
def get_network(point_cloud,
is_training,
neighbor=None,
bn_decay=None,
dynamic=True,
STN=True,
scale=1.,
concat_fea=True,
weight_decay=0.00004):
""" Classification PointNet, input is BxNx3, output Bx40 """
bn_decay = bn_decay if bn_decay is not None else 0.9
with tf.variable_scope("DGCNN"):
batch_size = point_cloud.get_shape()[0].value
num_point = point_cloud.get_shape()[1].value
# point_cloud = tf.squeeze(point_cloud)
# if batch_size == 1:
# point_cloud = tf.expand_dims(point_cloud, 0)
end_points = {}
k = 20
bn_params = {
"is_training": is_training,
"decay": bn_decay,
'epsilon': 1e-3
}
if STN:
if neighbor is None:
adj_matrix = tf_util.pairwise_distance(point_cloud)
nn_idx = tf_util.knn(adj_matrix, k=k)
else:
nn_idx = neighbor
edge_feature = tf_util.get_edge_feature(point_cloud,
nn_idx=nn_idx,
k=k)
transform = input_transform_net(edge_feature,
is_training,
bn_decay,
K=3,
weight_decay=weight_decay,
scale=scale)
with tf.variable_scope("Transform"):
point_cloud_transformed = tf.matmul(point_cloud, transform)
if dynamic:
adj_matrix = tf_util.pairwise_distance(point_cloud_transformed)
nn_idx = tf_util.knn(adj_matrix, k=k)
else:
point_cloud_transformed = point_cloud
if neighbor is None:
adj_matrix = tf_util.pairwise_distance(point_cloud_transformed)
nn_idx = tf_util.knn(adj_matrix, k=k)
else:
nn_idx = neighbor
edge_feature = tf_util.get_edge_feature(point_cloud_transformed,
nn_idx=nn_idx,
k=k)
with tf.variable_scope("dgcnn1"):
net = layers.masked_conv2d(
edge_feature,
# 64,
max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6)
net = tf.reduce_max(net, axis=-2, keepdims=True)
# net = slim.max_pool2d(net, [1, k], stride=1, padding='VALID')
net1 = net
if dynamic:
adj_matrix = tf_util.pairwise_distance(net)
nn_idx = tf_util.knn(adj_matrix, k=k)
edge_feature = tf_util.get_edge_feature(net,
nn_idx=nn_idx,
k=k,
concat_feature=concat_fea)
with tf.variable_scope("dgcnn2"):
net = layers.masked_conv2d(
edge_feature,
# 64,
max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6)
net = tf.reduce_max(net, axis=-2, keepdims=True)
# net = slim.max_pool2d(net, [1, k], stride=1, padding='VALID')
net2 = net
if dynamic:
adj_matrix = tf_util.pairwise_distance(net)
nn_idx = tf_util.knn(adj_matrix, k=k)
edge_feature = tf_util.get_edge_feature(net,
nn_idx=nn_idx,
k=k,
concat_feature=concat_fea)
with tf.variable_scope("dgcnn3"):
net = layers.masked_conv2d(
edge_feature,
# 64,
max(int(round(64 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6)
net = tf.reduce_max(net, axis=-2, keepdims=True)
# net = slim.max_pool2d(net, [1, k], stride=1, padding='VALID')
net3 = net
if dynamic:
adj_matrix = tf_util.pairwise_distance(net)
nn_idx = tf_util.knn(adj_matrix, k=k)
edge_feature = tf_util.get_edge_feature(net,
nn_idx=nn_idx,
k=k,
concat_feature=concat_fea)
with tf.variable_scope("dgcnn4"):
net = layers.masked_conv2d(
edge_feature,
# 128,
max(int(round(128 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6)
net = tf.reduce_max(net, axis=-2, keepdims=True)
# net = slim.max_pool2d(net, [1, k], stride=1, padding='VALID')
net4 = net
with tf.variable_scope("agg"):
net = layers.masked_conv2d(
tf.concat([net1, net2, net3, net4], axis=-1),
# 1024,
# max(int(round(1024 * scale)), 32),
max(int(round(1024 * scale)), 32),
[1, 1],
padding='VALID',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=tf.nn.relu6)
net = tf.reduce_max(net, axis=1, keepdims=True)
# net = slim.max_pool2d(net, [num_point, 1], stride=1, padding='VALID')
# MLP on global point cloud vector
# net = tf.reshape(net, [batch_size, 1, 1, -1])
net = layers.masked_conv2d(
net,
# 512,
max(int(round(512 * scale)), 32),
[1, 1],
padding='SAME',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='fc1',
activation_fn=tf.nn.relu6)
net = slim.dropout(net,
keep_prob=0.5,
is_training=is_training,
scope='dp1')
net = layers.masked_conv2d(
net,
# 256,
max(int(round(256 * scale)), 32),
[1, 1],
padding='SAME',
stride=1,
normalizer_fn=slim.batch_norm,
normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='fc2',
activation_fn=tf.nn.relu6)
net = slim.dropout(net,
keep_prob=0.5,
is_training=is_training,
scope='dp2')
net = layers.masked_conv2d(
net,
40,
[1, 1],
padding='SAME',
stride=1,
# normalizer_fn=slim.batch_norm,
# normalizer_params=bn_params,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=slim.l2_regularizer(weight_decay),
scope='fc3',
# activation_fn=tf.nn.relu6,
activation_fn=None,
)
net = tf.reshape(net, [batch_size, -1])
return net, end_points
