def _vgg_11(self, x):
net = repeat(x, 2, conv2d, 64, [3, 3], scope='conv1')
net = tf.layers.max_pooling2d(net, [2, 2],
strides=2,
data_format='channels_first',
name='pool1')
net = repeat(net, 2, conv2d, 128, [3, 3], scope='conv2')
net = tf.layers.max_pooling2d(net, [2, 2],
strides=2,
data_format='channels_first',
name='pool2')
net = repeat(net, 3, conv2d, 256, [3, 3], scope='conv3')
net = tf.layers.max_pooling2d(net, [2, 2],
strides=2,
data_format='channels_first',
name='pool3')
net = repeat(net, 3, conv2d, 512, [3, 3], scope='conv4')
net = tf.layers.max_pooling2d(net, [2, 2],
strides=2,
data_format='channels_first',
name='pool4')
net = tf.layers.flatten(net, name='flatten')
net = stack(net, fully_connected, self.layer_sizes, scope='fc5')
features = dropout(net, scope='drop5')
logits = fully_connected(features,
self._num_classes,
activation_fn=None,
normalizer_fn=None,
scope='unscaled_logits')
return logits, features
def vgg_16_fn(input_tensor: tf.Tensor, scope='vgg_16', blocks=5, weight_decay=0.0005) \
-> (tf.Tensor, list): # list of tf.Tensors (layers)
intermediate_levels = []
# intermediate_levels.append(input_tensor)
with slim.arg_scope(nets.vgg.vgg_arg_scope(weight_decay=weight_decay)):
with tf.variable_scope(scope, 'vgg_16', [input_tensor]) as sc:
input_tensor = mean_substraction(input_tensor)
intermediate_levels.append(input_tensor)
end_points_collection = sc.original_name_scope + '_end_points'
# Collect outputs for conv2d, fully_connected and max_pool2d.
with slim.arg_scope(
[layers.conv2d, layers.fully_connected, layers.max_pool2d],
outputs_collections=end_points_collection):
net = layers.repeat(
input_tensor, 2, layers.conv2d, 64, [3, 3], scope='conv1')
intermediate_levels.append(net)
net = layers.max_pool2d(net, [2, 2], scope='pool1')
if blocks >= 2:
net = layers.repeat(net, 2, layers.conv2d, 128, [3, 3], scope='conv2')
intermediate_levels.append(net)
net = layers.max_pool2d(net, [2, 2], scope='pool2')
if blocks >= 3:
net = layers.repeat(net, 3, layers.conv2d, 256, [3, 3], scope='conv3')
intermediate_levels.append(net)
net = layers.max_pool2d(net, [2, 2], scope='pool3')
if blocks >= 4:
net = layers.repeat(net, 3, layers.conv2d, 512, [3, 3], scope='conv4')
intermediate_levels.append(net)
net = layers.max_pool2d(net, [2, 2], scope='pool4')
if blocks >= 5:
net = layers.repeat(net, 3, layers.conv2d, 512, [3, 3], scope='conv5')
intermediate_levels.append(net)
net = layers.max_pool2d(net, [2, 2], scope='pool5')
return net, intermediate_levels
def __call__(self, inputs, is_training=False, reuse=None):
with tf.variable_scope(self.name, reuse=reuse):
with arg_scope([layers.conv2d],
activation_fn=self.prelu,
weights_regularizer=layers.l2_regularizer(
self.weight_decay),
data_format=self.data_format):
if self.data_format == 'NCHW':
inputs = tf.transpose(inputs, [0, 3, 1, 2])
with tf.variable_scope('conv1'):
net = layers.conv2d(inputs,
num_outputs=self.num_outputs[0],
kernel_size=3,
stride=2) # 64*64*64
net = self.resBlock(
net, num_outputs=self.num_outputs[0]) # 64*64*64
with tf.variable_scope('conv2'):
net = layers.conv2d(net,
num_outputs=self.num_outputs[1],
kernel_size=3,
stride=2) # 32*32*128
net = layers.repeat(net, 2, self.resBlock,
self.num_outputs[1]) # 32*32*128 x2
with tf.variable_scope('conv3'):
net = layers.conv2d(net,
num_outputs=self.num_outputs[2],
kernel_size=3,
stride=2) # 16*16*256
net = layers.repeat(net, 4, self.resBlock,
self.num_outputs[2]) # 16*16*256 x4
with tf.variable_scope('conv4'):
net = layers.conv2d(net,
num_outputs=self.num_outputs[3],
kernel_size=3,
stride=2) # 8*8*512
net = self.resBlock(
net, num_outputs=self.num_outputs[3]) # 8*8*512
net = tf.reshape(net, [
-1,
net.get_shape().as_list()[1] *
net.get_shape().as_list()[2] * net.get_shape().as_list()[3]
])
net = layers.fully_connected(
net,
num_outputs=512,
activation_fn=None,
weights_regularizer=layers.l2_regularizer(
self.weight_decay)) # 512
return net
def __call__(self, images: tf.Tensor, is_training=False):
outputs = []
with slim.arg_scope(
nets.vgg.vgg_arg_scope(weight_decay=self.weight_decay)):
with tf.variable_scope(None, 'vgg_16', [images]) as sc:
input_tensor = mean_substraction(images)
outputs.append(input_tensor)
end_points_collection = sc.original_name_scope + '_end_points'
# Collect outputs for conv2d, fully_connected and max_pool2d.
with slim.arg_scope(
[layers.conv2d, layers.fully_connected, layers.max_pool2d],
outputs_collections=end_points_collection):
net = layers.repeat(input_tensor,
2,
layers.conv2d,
64, [3, 3],
scope='conv1')
net = layers.max_pool2d(net, [2, 2], scope='pool1')
outputs.append(net)
if self.blocks >= 2:
net = layers.repeat(net,
2,
layers.conv2d,
128, [3, 3],
scope='conv2')
net = layers.max_pool2d(net, [2, 2], scope='pool2')
outputs.append(net)
if self.blocks >= 3:
net = layers.repeat(net,
3,
layers.conv2d,
256, [3, 3],
scope='conv3')
net = layers.max_pool2d(net, [2, 2], scope='pool3')
outputs.append(net)
if self.blocks >= 4:
net = layers.repeat(net,
3,
layers.conv2d,
512, [3, 3],
scope='conv4')
net = layers.max_pool2d(net, [2, 2], scope='pool4')
outputs.append(net)
if self.blocks >= 5:
net = layers.repeat(net,
3,
layers.conv2d,
512, [3, 3],
scope='conv5')
net = layers.max_pool2d(net, [2, 2], scope='pool5')
outputs.append(net)
return outputs
def __call__(self, inputs, is_training=False, reuse=None):
with tf.variable_scope(self.name, reuse=reuse):
with arg_scope([layers.conv2d],
activation_fn=self.prelu,
weights_regularizer=layers.l2_regularizer(
self.weight_decay)):
inputs = tf.transpose(inputs, [0, 1, 2, 3])
print("inputs.shape is : {}".format(inputs.shape))
with tf.variable_scope('conv1'):
net = layers.conv2d(inputs,
num_outputs=self.num_outputs[0],
kernel_size=3,
stride=2)
net = self.resBlock(net, num_outputs=self.num_outputs[0])
with tf.variable_scope('conv2'):
net = layers.conv2d(net,
num_outputs=self.num_outputs[1],
kernel_size=3,
stride=2)
net = layers.repeat(net, 2, self.resBlock,
self.num_outputs[1])
with tf.variable_scope('conv3'):
net = layers.conv2d(net,
num_outputs=self.num_outputs[2],
kernel_size=3,
stride=2)
net = layers.repeat(net, 4, self.resBlock,
self.num_outputs[2])
with tf.variable_scope('conv4'):
net = layers.conv2d(net,
num_outputs=self.num_outputs[3],
kernel_size=3,
stride=2)
net = self.resBlock(net, num_outputs=self.num_outputs[3])
net = tf.reshape(net, [
-1,
net.get_shape().as_list()[1] *
net.get_shape().as_list()[2] * net.get_shape().as_list()[3]
])
net = layers.fully_connected(
net,
num_outputs=512,
activation_fn=None,
weights_regularizer=layers.l2_regularizer(
self.weight_decay)) # 512
return net
def discriminator(input, flags):
net = repeat(input, 2, conv2d, 64, 3, scope='conv1')
net = max_pool2d(net, [2, 2], scope='pool1')
net = repeat(net, 2, conv2d, 128, 3, scope='conv2')
net = max_pool2d(net, [2, 2], scope='pool2')
net = repeat(net, 4, conv2d, 256, 3, scope='conv3')
net = max_pool2d(net, [2, 2], scope='pool3')
net = repeat(net, 4, conv2d, 512, 3, scope='conv4')
net = max_pool2d(net, [2, 2], scope='pool4')
net = repeat(net, 4, conv2d, 512, 3, scope='conv5')
net = max_pool2d(net, [2, 2], scope='pool5')
net = tf.layers.Flatten()(net)
net = tf.layers.dense(net, flags.class_num)
return net
def down_block(input, epsilon, b_momentum, scope, k_size, output):
with tf.variable_scope(scope):
conv = repeat(input, 2, conv2d, output, k_size, scope='conv')
pool = max_pool2d(conv, 2, scope='pool')
bn = tf.layers.batch_normalization(
pool,
epsilon=epsilon,
axis=-1,
momentum=b_momentum,
beta_initializer=tf.zeros_initializer(),
gamma_initializer=tf.constant_initializer(0.2),
name='bn')
return conv, bn
def up_block(input, epsilon, b_momentum, scope, k_size, output, pre_conv):
with tf.variable_scope(scope):
up = UpSampling2D()(input)
conv = repeat(up, 2, conv2d, output, k_size)
bn = tf.layers.batch_normalization(
conv,
epsilon=epsilon,
axis=-1,
momentum=b_momentum,
beta_initializer=tf.zeros_initializer(),
gamma_initializer=tf.constant_initializer(0.2),
name='bn')
merge = tf.concat([pre_conv, bn], axis=-1)
conv = conv2d(merge, output, k_size)
return conv
def build(self, inputs):
feature_maps = []
with arg_scope([layers.conv2d],
weights_initializer=layers.xavier_initializer(),
weights_regularizer=layers.l2_regularizer(
self.weight_decay),
padding='SAME'):
y = inputs
y = layers.repeat(y,
2,
layers.conv2d,
64, [3, 3],
1,
scope='conv1')
y = layers.max_pool2d(y, [2, 2], 2, 'SAME', scope='pool1')
y = layers.repeat(y,
2,
layers.conv2d,
128, [3, 3],
1,
scope='conv2')
y = layers.max_pool2d(y, [2, 2], 2, 'SAME', scope='pool2')
y = layers.repeat(y,
3,
layers.conv2d,
256, [3, 3],
1,
scope='conv3')
y = layers.max_pool2d(y, [2, 2], 2, 'SAME', scope='pool3')
y = layers.repeat(y,
3,
layers.conv2d,
512, [3, 3],
1,
scope='conv4')
with tf.variable_scope('l2_norm'):
y = self.l2_norm(y, 512)
feature_maps.append(y)
y = layers.max_pool2d(y, [2, 2], 2, 'SAME', scope='pool4')
y = layers.repeat(y,
3,
layers.conv2d,
512, [3, 3],
1,
scope='conv5')
y = layers.max_pool2d(y, [3, 3], 1, 'SAME', scope='pool5')
with tf.variable_scope('fc6'):
w = tf.get_variable('weights',
shape=[3, 3, 512, 1024],
dtype=tf.float32)
b = tf.get_variable('biases', shape=[1024], dtype=tf.float32)
y = tf.nn.atrous_conv2d(y, w, 6, 'SAME')
y = tf.nn.bias_add(y, b)
y = layers.conv2d(y, 1024, [1, 1], 1, scope='fc7')
feature_maps.append(y)
y = layers.conv2d(y, 256, [1, 1], 1, scope='conv8_1')
y = layers.conv2d(y, 512, [3, 3], 2, scope='conv8_2')
feature_maps.append(y)
y = layers.conv2d(y, 128, [1, 1], 1, scope='conv9_1')
y = layers.conv2d(y, 256, [3, 3], 2, scope='conv9_2')
feature_maps.append(y)
y = layers.conv2d(y, 128, [1, 1], 1, scope='conv10_1')
y = layers.conv2d(y,
256, [3, 3],
1,
padding='VALID',
scope='conv10_2')
feature_maps.append(y)
y = layers.conv2d(y, 128, [1, 1], 1, scope='conv11_1')
y = layers.conv2d(y,
256, [3, 3],
1,
padding='VALID',
scope='conv11_2')
feature_maps.append(y)
self.feature_map_size = [
map.get_shape().as_list()[1:3] for map in feature_maps
]
# predictions = []
self.location = []
self.classification = []
for i, feature_map in enumerate(feature_maps):
num_outputs = self.num_anchors[i] * (self.num_classes + 1 + 4)
prediction = layers.conv2d(feature_map,
num_outputs, [3, 3],
1,
scope='pred_%d' % i)
locations, classifications = tf.split(prediction, [
self.num_anchors[i] * 4, self.num_anchors[i] *
(self.num_classes + 1)
], -1)
shape = locations.get_shape()
locations = tf.reshape(
locations,
[-1, shape[1], shape[2], self.num_anchors[i], 4])
shape = classifications.get_shape()
classifications = tf.reshape(classifications, [
-1, shape[1], shape[2], self.num_anchors[i],
(self.num_classes + 1)
])
self.location.append(locations)
self.classification.append(classifications)
self._setup()
self.feature_maps = feature_maps
def __call__(self, inputs, is_training=False, reuse=None):
with tf.variable_scope(self.name, reuse=reuse):
with arg_scope([layers.batch_norm],
scale=True,
fused=True,
data_format=self.data_format,
is_training=is_training):
with arg_scope([layers.conv2d],
activation_fn=tf.nn.relu,
normalizer_fn=layers.batch_norm,
biases_initializer=None,
weights_regularizer=layers.l2_regularizer(
self.weight_decay),
data_format=self.data_format):
if self.data_format == 'NCHW':
inputs = tf.transpose(inputs, [0, 3, 1, 2])
with tf.variable_scope('conv1'):
net = layers.conv2d(inputs,
num_outputs=64,
kernel_size=7,
stride=2)
net = layers.max_pool2d(net,
kernel_size=3,
stride=2,
padding='SAME',
data_format=self.data_format)
with tf.variable_scope('conv2'):
net = layers.repeat(net, self.num_block[0],
self.resBlock, self.num_outputs[0])
with tf.variable_scope('conv3'):
net = self.resBlock(net,
num_outputs=self.num_outputs[1],
stride=2)
net = layers.repeat(net, self.num_block[1] - 1,
self.resBlock, self.num_outputs[1])
with tf.variable_scope('conv4'):
net = self.resBlock(net,
num_outputs=self.num_outputs[2],
stride=2)
net = layers.repeat(net, self.num_block[2] - 1,
self.resBlock, self.num_outputs[2])
with tf.variable_scope('conv5'):
net = self.resBlock(net,
num_outputs=self.num_outputs[3],
stride=2)
net = layers.repeat(net, self.num_block[3] - 1,
self.resBlock, self.num_outputs[3])
if self.data_format == 'NCHW':
net = tf.reduce_mean(net, [2, 3])
net = tf.reshape(net,
[-1, net.get_shape().as_list()[1]])
else:
net = tf.reduce_mean(net, [1, 2])
net = tf.reshape(
net, [-1, net.get_shape().as_list()[-1]])
if is_training:
net = layers.dropout(net, keep_prob=0.5)
pre_logits = layers.fully_connected(
net,
num_outputs=128,
activation_fn=None,
weights_regularizer=layers.l2_regularizer(
self.weight_decay))
return pre_logits
def hed_model_fn(inputs, is_training=False):
inputs_size = tf.shape(inputs)[1:3]
scope = 'vgg_16'
with variable_scope.variable_scope(scope, 'vgg_16', [inputs]) as sc:
end_points_collection = sc.original_name_scope + '_end_points'
with arg_scope(
[layers.conv2d, layers_lib.fully_connected, layers_lib.max_pool2d],
outputs_collections=end_points_collection):
net = layers_lib.repeat(inputs,
2,
layers.conv2d,
64, [3, 3],
scope='conv1')
side_1 = side_layer(net, "side_1", 1)
net = layers_lib.max_pool2d(net, [2, 2], scope='pool1')
net = layers_lib.repeat(net,
2,
layers.conv2d,
128, [3, 3],
scope='conv2')
side_2 = side_layer(net, "side_2", 2)
net = layers_lib.max_pool2d(net, [2, 2], scope='pool2')
net = layers_lib.repeat(net,
3,
layers.conv2d,
256, [3, 3],
scope='conv3')
side_3 = side_layer(net, "side_3", 4)
net = layers_lib.max_pool2d(net, [2, 2], scope='pool3')
net = layers_lib.repeat(net,
3,
layers.conv2d,
512, [3, 3],
scope='conv4')
side_4 = side_layer(net, "side_4", 8)
net = layers_lib.max_pool2d(net, [2, 2], scope='pool4')
net = layers_lib.repeat(net,
3,
layers.conv2d,
512, [3, 3],
scope='conv5')
side_5 = side_layer(net, "side_5", 16)
#tf.image.crop_to_bounding_box
side_1 = tf.image.resize_bilinear(side_1,
inputs_size,
name='side_1')
side_2 = tf.image.resize_bilinear(side_2,
inputs_size,
name='side_2')
side_3 = tf.image.resize_bilinear(side_3,
inputs_size,
name='side_3')
side_4 = tf.image.resize_bilinear(side_4,
inputs_size,
name='side_4')
side_5 = tf.image.resize_bilinear(side_5,
inputs_size,
name='side_5')
side_outputs = [side_1, side_2, side_3, side_4, side_5]
w_shape = [1, 1, len(side_outputs), 1]
fuse = conv_layer(tf.concat(side_outputs, axis=3),
w_shape,
use_bias=False,
w_init=tf.constant_initializer(0.2))
fuse = tf.image.resize_bilinear(fuse,
inputs_size,
name='side_fuse')
outputs = side_outputs + [fuse]
return outputs
def __init__(self, input_node, hidden_layers, repeat_n, reward):
'''makes a mini neural net to inform our arm'''
self.hidden = repeat(input_node, repeat_n, slim.fully_connected, hidden_layers)
self.prob = slim.fully_connected(self.hidden,1,\
activation_fn=nn.sigmoid) #output probability of acceptance #tf.nn.sigmoid
self.EX = self.prob * reward #calc expected reward
