def decoder(latent_var, is_training=True):
activation_fn = leaky_relu # tf.nn.relu
# activation_fn = tf.nn.elu
weight_decay = 0.0
with tf.variable_scope('decoder', reuse=tf.AUTO_REUSE):
with slim.arg_scope([slim.batch_norm],
is_training=is_training):
with slim.arg_scope([slim.convolution2d_transpose, slim.fully_connected],
weights_initializer=tf.truncated_normal_initializer(stddev=0.05),
weights_regularizer=slim.l2_regularizer(weight_decay),
normalizer_fn=slim.batch_norm):
# net = slim.fully_connected(latent_var, , activation_fn=None, normalizer_fn=None, scope='Fc_1')
# net = tf.reshape(net, [-1,16,16,4], name='Reshape')
# net = tf.image.resize_nearest_neighbor(net, size=(8,8), name='Upsample_1')
# net = slim.convolution2d_transpose(latent_var, 512, [4, 4], 2, activation_fn=activation_fn,
# scope='Conv2d_1')
net = slim.convolution2d_transpose(latent_var, 512, [4, 4], 2, activation_fn=activation_fn,
scope='Conv2d_1')
# net = tf.image.resize_nearest_neighbor(net, size=(16,16), name='Upsample_2')
net = slim.convolution2d_transpose(net, 256, [4, 4], 2, activation_fn=activation_fn,
scope='Conv2d_2')
net = slim.convolution2d_transpose(net, 128, [4, 4], 2, activation_fn=activation_fn,
scope='Conv2d_3')
net = slim.convolution2d_transpose(net, 64, [4, 4], 1, activation_fn=activation_fn,
scope='Conv2d_4')
net = slim.convolution2d_transpose(net, 6, [4, 4], 1, activation_fn=activation_fn, scope='Conv2d_5')
return net
def generator(z):
'''
The generator takes a vector of random numbers and transforms it into a 32x32 image.
:param z: a vector of random numbers
:return: a 32x32 image
'''
with tf.variable_scope('G'):
zP=slim.layers.fully_connected(z,4*4*256,activation_fn=tf.nn.leaky_relu,normalizer_fn=slim.batch_norm,
scope='g_project', weights_initializer=initializer) # [n,4*4*256]
zCon = tf.reshape(zP, [-1, 4, 4, 256]) # [n,4,4,256]
gen1 = slim.convolution2d_transpose(zCon, num_outputs=64,
kernel_size=[5, 5], stride=[2, 2],padding="SAME",
normalizer_fn=slim.batch_norm,activation_fn=tf.nn.leaky_relu, scope='g_conv1',
weights_initializer=initializer) # [n,8,8,64] 采样方式SAME h*stride
gen2 = slim.convolution2d_transpose( \
gen1, num_outputs=32, kernel_size=[5, 5], stride=[2, 2], \
padding="SAME", normalizer_fn=slim.batch_norm, \
activation_fn=tf.nn.leaky_relu, scope='g_conv2',
weights_initializer=initializer) # [n,16,16,32] 采样方式SAME h*stride
gen3 = slim.convolution2d_transpose( \
gen2, num_outputs=16, kernel_size=[5, 5], stride=[2, 2], \
padding="SAME", normalizer_fn=slim.batch_norm, \
activation_fn=tf.nn.leaky_relu, scope='g_conv3',
weights_initializer=initializer) # [n,32,32,16] 采样方式SAME h*stride
g_out = slim.convolution2d_transpose( \
gen3, num_outputs=1, kernel_size=[32, 32], padding="SAME", \
biases_initializer=None, activation_fn=tf.nn.tanh, \
scope='g_out', weights_initializer=initializer) # [n,32,32,1] 这里stride默认为1
return g_out
def generator(z):
'''
Generator is like a reverse convolutional Neural Network
Taking in the input vector and projecting it into a large 'meaning' vector
see https://arxiv.org/pdf/1511.06434.pdf
'''
zP = slim.fully_connected(z,4*4*256,normalizer_fn=slim.batch_norm,\
activation_fn=tf.nn.relu,scope='g_project',weights_initializer=initializer)
zCon = tf.reshape(zP, [-1, 4, 4, 256])
gen1 = slim.convolution2d_transpose(\
zCon,num_outputs=64,kernel_size=[5,5],stride=[2,2],\
padding="SAME",normalizer_fn=slim.batch_norm,\
activation_fn=tf.nn.relu,scope='g_conv1', weights_initializer=initializer)
gen2 = slim.convolution2d_transpose(\
gen1,num_outputs=32,kernel_size=[5,5],stride=[2,2],\
padding="SAME",normalizer_fn=slim.batch_norm,\
activation_fn=tf.nn.relu,scope='g_conv2', weights_initializer=initializer)
gen3 = slim.convolution2d_transpose(\
gen2,num_outputs=16,kernel_size=[5,5],stride=[2,2],\
padding="SAME",normalizer_fn=slim.batch_norm,\
activation_fn=tf.nn.relu,scope='g_conv3', weights_initializer=initializer)
g_out = slim.convolution2d_transpose(\
gen3,num_outputs=1,kernel_size=[32,32],padding="SAME",\
biases_initializer=None,activation_fn=tf.nn.tanh,\
scope='g_out', weights_initializer=initializer)
return g_out
def decode(X, reuse):
with tf.variable_scope('G'):
gen1 = slim.convolution2d_transpose(
X,
num_outputs=64,
kernel_size=[5, 5],
stride=[2, 2],
padding="SAME",
normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.leaky_relu,
reuse=reuse,
scope='g_conv1',
weights_initializer=initializer
) # [n,8,8,64] 采样方式SAME h*stride
gen2 = slim.convolution2d_transpose( \
gen1, num_outputs=32, kernel_size=[5, 5], stride=[2, 2], \
padding="SAME", normalizer_fn=slim.batch_norm, \
activation_fn=tf.nn.leaky_relu, scope='g_conv2',reuse=reuse,
weights_initializer=initializer) # [n,16,16,32] 采样方式SAME h*stride
gen3 = slim.convolution2d_transpose( \
gen2, num_outputs=16, kernel_size=[5, 5], stride=[2, 2], \
padding="SAME", normalizer_fn=slim.batch_norm, \
activation_fn=tf.nn.leaky_relu, scope='g_conv3',reuse=reuse,
weights_initializer=initializer) # [n,32,32,16] 采样方式SAME h*stride
g_out = slim.convolution2d_transpose( \
gen3, num_outputs=1, kernel_size=[32, 32], padding="SAME", \
biases_initializer=None, activation_fn=tf.nn.tanh, \
reuse=reuse,scope='g_out', weights_initializer=initializer) # [n,32,32,1] 这里stride默认为1
return g_out
def generator(z, reuse=False):
with tf.variable_scope('generator', reuse=reuse):
initializer = tf.truncated_normal_initializer(stddev=0.02)
zP = slim.fully_connected(z, 4 * 4 * 256, normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu, scope='g_project', weights_initializer=initializer)
zCon = tf.reshape(zP, [-1, 4, 4, 256])
gen1 = slim.convolution2d_transpose(
zCon, num_outputs=32, kernel_size=[3, 3], stride=2,
padding="SAME", normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu, scope='g_conv1', weights_initializer=initializer)
gen2 = slim.convolution2d_transpose(
gen1, num_outputs=16, kernel_size=[3, 3], stride=2,
padding="SAME", normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu, scope='g_conv2', weights_initializer=initializer)
gen3 = slim.convolution2d_transpose(
gen2, num_outputs=8, kernel_size=[3, 3], stride=2,
padding="SAME", normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu, scope='g_conv3', weights_initializer=initializer)
'''
gen4 = slim.convolution2d_transpose(
gen3, num_outputs=3, kernel_size=[3, 3], stride=2,
padding="SAME", normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu, scope='g_conv4', weights_initializer=initializer)
'''
g_out = slim.convolution2d_transpose(
gen3, num_outputs=1, kernel_size=[32, 32], stride=1,
padding="SAME", biases_initializer=None, activation_fn=tf.nn.tanh, scope='g_out', weights_initializer=initializer)
g_out_concat = tf.concat(3, [g_out, g_out, g_out], name='concat')
return g_out_concat
def decoder(x): print print 'x: ', x d_fc1 = slim.fully_connected(x, 32, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='d_fc1') d_fc1 = lrelu(d_fc1) print 'd_fc1: ', d_fc1 d_fc2 = slim.fully_connected(d_fc1, 64, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='d_fc2') d_fc2 = lrelu(d_fc2) print 'd_fc2: ', d_fc2 d_fc3 = slim.fully_connected(d_fc2, 256, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='d_fc3') d_fc3 = lrelu(d_fc3) print 'd_fc3: ', d_fc3 d_fc3 = tf.reshape(d_fc3, [batch_size, 4, 4, 16]) print 'd_fc3: ', d_fc3 e_transpose_conv1 = slim.convolution2d_transpose(d_fc3, 64, 2, stride=2, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='e_transpose_conv1') e_transpose_conv1 = lrelu(e_transpose_conv1) print 'e_transpose_conv1: ', e_transpose_conv1 e_transpose_conv2 = slim.convolution2d_transpose(e_transpose_conv1, 32, 2, stride=2, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='e_transpose_conv2') e_transpose_conv2 = lrelu(e_transpose_conv2) print 'e_transpose_conv2: ', e_transpose_conv2 e_transpose_conv3 = slim.convolution2d_transpose(e_transpose_conv2, 1, 2, stride=2, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='e_transpose_conv3') e_transpose_conv3 = lrelu(e_transpose_conv3) e_transpose_conv3 = e_transpose_conv3[:,:28,:28,:] print 'e_transpose_conv3: ', e_transpose_conv3 return e_transpose_conv3
def generator(z):
zP = slim.fully_connected(z, 4 * 4 * 256, normalizer_fn=slim.batch_norm, \
activation_fn=tf.nn.relu, scope='g_project', weights_initializer=initializer)
zCon = tf.reshape(zP, [-1, 4, 4, 256])
gen1 = slim.convolution2d_transpose( \
zCon, num_outputs=64, kernel_size=[5, 5], stride=[2, 2], \
padding="SAME", normalizer_fn=slim.batch_norm, \
activation_fn=tf.nn.relu, scope='g_conv1', weights_initializer=initializer)
gen2 = slim.convolution2d_transpose( \
gen1, num_outputs=32, kernel_size=[5, 5], stride=[2, 2], \
padding="SAME", normalizer_fn=slim.batch_norm, \
activation_fn=tf.nn.relu, scope='g_conv2', weights_initializer=initializer)
gen3 = slim.convolution2d_transpose( \
gen2, num_outputs=16, kernel_size=[5, 5], stride=[2, 2], \
padding="SAME", normalizer_fn=slim.batch_norm, \
activation_fn=tf.nn.relu, scope='g_conv3', weights_initializer=initializer)
g_out = slim.convolution2d_transpose( \
gen3, num_outputs=1, kernel_size=[32, 32], padding="SAME", \
biases_initializer=None, activation_fn=tf.nn.tanh, \
scope='g_out', weights_initializer=initializer)
return g_out
def generator(self, z):
# This initializaer is used to initialize all the weights of the network.
initializer = tf.truncated_normal_initializer(stddev=0.02)
gen1 = slim.convolution2d_transpose(z,
num_outputs=16,
kernel_size=[10, 10],
stride=[1, 1],
padding="SAME",
normalizer_fn=slim.batch_norm,
activation_fn=lrelu,
scope='g_conv1',
weights_initializer=initializer)
gen2 = slim.convolution2d_transpose(gen1,
num_outputs=32,
kernel_size=[5, 5],
stride=[1, 1],
padding="SAME",
normalizer_fn=slim.batch_norm,
activation_fn=lrelu,
scope='g_conv2',
weights_initializer=initializer)
gen3 = slim.convolution2d_transpose(gen2,
num_outputs=16,
kernel_size=[3, 3],
stride=[1, 1],
padding="SAME",
normalizer_fn=slim.batch_norm,
activation_fn=lrelu,
scope='g_conv3',
weights_initializer=initializer)
gen4 = slim.convolution2d_transpose(gen3,
num_outputs=8,
kernel_size=[2, 2],
stride=[1, 1],
padding="SAME",
normalizer_fn=slim.batch_norm,
activation_fn=lrelu,
scope='g_conv4',
weights_initializer=initializer)
g_out = slim.convolution2d_transpose(gen4,
num_outputs=3,
kernel_size=[1, 1],
stride=[1, 1],
padding="SAME",
biases_initializer=None,
activation_fn=lrelu,
scope='g_out',
weights_initializer=initializer)
return g_out
def generator(z):
initializer = tf.truncated_normal_initializer(stddev=0.02)
zP = slim.fully_connected(z,
4 * 4 * 256,
normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu,
scope='g_project',
weights_initializer=initializer)
zCon = tf.reshape(zP, [-1, 4, 4, 256])
gen1 = slim.convolution2d_transpose(zCon,
num_outputs=64,
kernel_size=(5, 5),
stride=(2, 2),
padding='SAME',
normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu,
scope='g_conv1',
weights_initializer=initializer)
gen2 = slim.convolution2d_transpose(gen1,
num_outputs=32,
kernel_size=(5, 5),
stride=(2, 2),
padding='SAME',
normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu,
scope='g_conv2',
weights_initializer=initializer)
gen3 = slim.convolution2d_transpose(gen2,
num_outputs=16,
kernel_size=(5, 5),
stride=(2, 2),
padding='SAME',
normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu,
scope='g_conv3',
weights_initializer=initializer)
g_out = slim.convolution2d_transpose(gen3,
num_outputs=1,
kernel_size=(100, 100),
padding='SAME',
biases_initializer=None,
activation_fn=tf.nn.tanh,
scope='g_out',
weights_initializer=initializer)
return g_out
def up_conv_block(input, output_dim, base_dim):
block = slim.conv2d(input, base_dim, [1, 1])
block = slim.convolution2d_transpose(block,
base_dim, [3, 3],
stride=2)
block = slim.conv2d(block, output_dim, [1, 1])
return block
def __call__(self, z, ys=None):
if ys is None:
z_concat = z
else:
z_concat = tf.concat([z, ys], axis=1)
zP = slim.fully_connected(
z_concat, 4*4*256, normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu,scope='g_project',
weights_initializer=tf.truncated_normal_initializer(stddev=0.01))
zCon = tf.reshape(zP,[-1,4,4,256])
net = zCon
with slim.arg_scope([slim.conv2d_transpose],
weights_initializer=tf.truncated_normal_initializer(stddev=0.02),
normalizer_fn=slim.batch_norm,
activation_fn=self.g_activation_fn):
for i, (g_unit, kernel_size, stride, padding) in enumerate(zip(
self.g_conv_units, self.g_kernel_sizes, self.g_strides, self.g_paddings)):
net = slim.conv2d_transpose(net, num_outputs=g_unit, kernel_size=kernel_size,
stride=stride, padding=padding, scope='g_conv{0}'.format(i))
g_out = slim.convolution2d_transpose(
net,num_outputs=self.x_ch, kernel_size=self.x_dims, padding="SAME",
biases_initializer=None,activation_fn=tf.nn.tanh,
scope='g_out', weights_initializer=tf.truncated_normal_initializer(stddev=0.02))
return g_out
def convolution2d_transpose(self,
inputs,
num_outputs,
name,
kernel_size=(3, 3),
stride=2):
output = slim.convolution2d_transpose(inputs,
num_outputs,
kernel_size=kernel_size,
stride=stride,
padding=DEFAULT_PADDING,
scope=name)
return output
def decoder(z):
print('Decoder')
input = slim.fully_connected(z,
intermediate_dim,
weights_initializer=intitializer,
activation_fn=lrelu,
scope='de_intermediate')
print(input.shape)
net = slim.fully_connected(input,
64 * 64 * 128,
weights_initializer=intitializer,
activation_fn=lrelu,
scope='de_flat2')
print(net.shape)
net = tf.reshape(net, [1, 64, 64, 128])
print(net.shape)
net = slim.convolution2d_transpose(net,
128, [3, 3],
stride=[1, 1],
weights_initializer=intitializer,
activation_fn=lrelu,
scope='de_deconv1')
print(net.shape)
net = slim.convolution2d_transpose(net,
64, [3, 3],
stride=[2, 2],
weights_initializer=intitializer,
activation_fn=lrelu,
scope='de_deconv2')
print(net.shape)
output = slim.convolution2d_transpose(net,
3, [3, 3],
stride=[2, 2],
weights_initializer=intitializer,
activation_fn=tf.tanh,
scope='de_output')
print(output.shape)
return output
def inference(image, dropout_keep_prob, num_classes=NUM_OF_CLASSES):
print("setting up mobile initialized conv layers ...")
mean = tf.constant(IMAGE_NET_MEAN)
image -= mean
net = mobile_net(image, num_classes=num_classes)
with tf.variable_scope('inference',reuse=tf.AUTO_REUSE):
net = slim.dropout(net, keep_prob=dropout_keep_prob, scope='Dropout')
net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None,
normalizer_fn=None, scope='Conv2d_1x1')
net = slim.convolution2d_transpose(net, num_classes, 64, 32)
annotation_pred = tf.argmax(net, axis=3, name="prediction")
return tf.expand_dims(annotation_pred, dim=3), net
def upsample(self, inp, poolhead, n_filters):
print("inp=", inp.get_shape())
print("poolhead=", poolhead.get_shape())
conv = slim.convolution2d_transpose(
inp,
n_filters,
3,
stride=2,
activation_fn=self.activation,
weights_initializer=self.initializer,
weights_regularizer=self.regularizer,
biases_initializer=self.initializer_b)
print("transpose=", conv.get_shape())
conv = tf.concat([conv, poolhead], axis=-1)
return conv
def generator(z, y, args):
with tf.name_scope('generator'):
with slim.arg_scope([slim.batch_norm], activation_fn=tf.nn.relu, is_training=(args.mode == 'train'),
decay=0.9, epsilon=1e-5, scale=True):
if args.dataset == 'stl10':
with slim.arg_scope([slim.convolution2d_transpose], activation_fn=None, kernel_size=[5, 5], stride=2):
G = slim.fully_connected(z,
8 * 4 * 4 *args.g_feature_dim,
activation_fn=None,
scope='generator_full1')
G = tf.reshape(G, [-1, 4, 4, 8 * args.g_feature_dim])
G = slim.batch_norm(G, scope='generator_batchnorm1')
G = slim.convolution2d_transpose(G, 4 * args.g_feature_dim, scope='generator_deconv1')
G = slim.batch_norm(G, scope='generator_batchnorm2')
G = slim.convolution2d_transpose(G, 2 * args.g_feature_dim, scope='generator_deconv2')
G = slim.batch_norm(G, scope='generator_batchnorm3')
G = slim.convolution2d_transpose(G, args.g_feature_dim, scope='generator_deconv3')
G = slim.batch_norm(G, scope='generator_batchnorm4')
G = slim.convolution2d_transpose(G, args.img_depth, activation_fn=tf.nn.tanh, scope='generator_deconv4')
else:
z = tf.concat(1, [z, y])
with slim.arg_scope([slim.convolution2d_transpose, slim.fully_connected], activation_fn=None):
G = slim.fully_connected(z, 1024, scope='generator_full1')
G = slim.batch_norm(G, scope='generator_batchnorm1')
G = tf.concat(1, [G, y])
G = slim.fully_connected(G,
(args.output_height / 4) * (args.output_width / 4) * 2 * args.g_feature_dim,
scope='generator_full2')
G = slim.batch_norm(G, scope='generator_batchnorm2')
G = tf.reshape(G, [args.batch_size, args.output_height / 4, args.output_height / 4, 2 * args.g_feature_dim])
G = concatFeatureMap(G, tf.reshape(y, [args.batch_size, 1, 1, -1]))
G = slim.convolution2d_transpose(G, 2 * args.g_feature_dim, kernel_size=[5, 5], stride=2, scope='generator_deconv1')
G = slim.batch_norm(G, scope='generator_batchnorm3')
G = concatFeatureMap(G, tf.reshape(y, [args.batch_size, 1, 1, -1]))
G = slim.convolution2d_transpose(G, args.img_depth, activation_fn=tf.nn.tanh, kernel_size=[5, 5], stride=2, scope='generator_deconv2')
return G
def model_fn(self, is_training=True, *args, **kwargs):
batch_image = tf.placeholder(tf.float32,
(ctx.params.batch_size, 512, 512, 3),
name='image')
batch_label = None
if is_training:
batch_label = tf.placeholder(tf.int32,
(ctx.params.batch_size, 512, 512),
name='label')
# preprocess
rgb_channels = tf.split(batch_image, 3, 3)
rgb_channels[0] = rgb_channels[0] - 128.0
rgb_channels[1] = rgb_channels[1] - 128.0
rgb_channels[2] = rgb_channels[2] - 128.0
batch_image = tf.concat(rgb_channels, -1)
# vgg 16
layers = (
'conv1_1',
'relu1_1',
'conv1_2',
'relu1_2',
'pool1',
'conv2_1',
'relu2_1',
'conv2_2',
'relu2_2',
'pool2',
'conv3_1',
'relu3_1',
'conv3_2',
'relu3_2',
'conv3_3',
'relu3_3',
'pool3',
'conv4_1',
'relu4_1',
'conv4_2',
'relu4_2',
'conv4_3',
'relu4_3',
'pool4',
'conv5_1',
'relu5_1',
'conv5_2',
'relu5_2',
'conv5_3',
'relu5_3',
'pool5',
)
net = batch_image
net_collection = {}
with slim.arg_scope(
[slim.conv2d],
weights_regularizer=slim.l2_regularizer(0.0001),
normalizer_fn=None,
activation_fn=None,
weights_initializer=slim.variance_scaling_initializer()):
for i, name in enumerate(layers):
kind = name[:4]
if kind == 'conv':
block_i = int(name[4])
output_channels = block_i * 64 if block_i < 5 else 512
net = slim.conv2d(net,
output_channels, [3, 3],
stride=[1, 1],
padding='SAME')
net_collection[name] = net
elif kind == 'relu':
net = tf.nn.relu(net)
net_collection[name] = net
elif kind == 'pool':
net = slim.avg_pool2d(net, 2, stride=2, padding='SAME')
net_collection[name] = net
pool5_output = net_collection['pool5']
# fully conv
conv6 = slim.conv2d(pool5_output,
4096, [7, 7],
stride=[1, 1],
padding='SAME')
relu6 = tf.nn.relu(conv6)
relu6 = slim.dropout(relu6, 0.5)
conv7 = slim.conv2d(relu6,
4096, [1, 1],
stride=[1, 1],
padding='SAME')
relu7 = tf.nn.relu(conv7)
relu7 = slim.dropout(relu7)
# FCN32S
score_32 = slim.conv2d(relu7,
ctx.params.class_num, [1, 1],
stride=[1, 1],
padding='SAME')
score_32_up = slim.convolution2d_transpose(score_32,
ctx.params.class_num,
[4, 4], [2, 2])
# FCN16S
pool4_output = slim.conv2d(net_collection['pool4'],
ctx.params.class_num, [1, 1],
stride=[1, 1],
padding='SAME')
score_16 = score_32_up + pool4_output
score_16_up = slim.convolution2d_transpose(score_16,
ctx.params.class_num,
[4, 4], [2, 2])
# FCN8S
pool3_output = slim.conv2d(net_collection['pool3'],
ctx.params.class_num, [1, 1],
stride=[1, 1],
padding='SAME')
score_8 = score_16_up + pool3_output
score_8_up = slim.convolution2d_transpose(score_8,
ctx.params.class_num,
[4, 4], [2, 2])
if is_training:
one_hot_batch_label = tf.one_hot(batch_label,
ctx.params.class_num)
one_hot_batch_label = tf.image.resize_bilinear(
one_hot_batch_label, [128, 128])
# cross entropy
fcn8_loss = tf.losses.softmax_cross_entropy(
one_hot_batch_label, score_8_up)
return fcn8_loss
else:
logits = tf.nn.softmax(score_8_up)
return logits
def osvos(inputs, scope='osvos'):
"""Defines the OSVOS network
Args:
inputs: Tensorflow placeholder that contains the input image
scope: Scope name for the network
Returns:
net: Output Tensor of the network
end_points: Dictionary with all Tensors of the network
"""
im_size = tf.shape(inputs)
with tf.variable_scope(scope, 'osvos', [inputs]) as sc:
end_points_collection = sc.name + '_end_points'
# Collect outputs of all intermediate layers.
with slim.arg_scope([slim.conv2d, slim.max_pool2d],
padding='SAME',
outputs_collections=end_points_collection):
net = slim.repeat(inputs,
2,
slim.conv2d,
64, [3, 3],
scope='conv1')
net = slim.max_pool2d(net, [2, 2], scope='pool1')
net_2 = slim.repeat(net,
2,
slim.conv2d,
128, [3, 3],
scope='conv2')
net = slim.max_pool2d(net_2, [2, 2], scope='pool2')
net_3 = slim.repeat(net,
3,
slim.conv2d,
256, [3, 3],
scope='conv3')
net = slim.max_pool2d(net_3, [2, 2], scope='pool3')
net_4 = slim.repeat(net,
3,
slim.conv2d,
512, [3, 3],
scope='conv4')
net = slim.max_pool2d(net_4, [2, 2], scope='pool4')
net_5 = slim.repeat(net,
3,
slim.conv2d,
512, [3, 3],
scope='conv5')
# Get side outputs of the network
with slim.arg_scope([slim.conv2d], activation_fn=None):
side_2 = slim.conv2d(net_2, 16, [3, 3], scope='conv2_2_16')
side_3 = slim.conv2d(net_3, 16, [3, 3], scope='conv3_3_16')
side_4 = slim.conv2d(net_4, 16, [3, 3], scope='conv4_3_16')
side_5 = slim.conv2d(net_5, 16, [3, 3], scope='conv5_3_16')
# Supervise side outputs
side_2_s = slim.conv2d(side_2, 1, [1, 1], scope='score-dsn_2')
side_3_s = slim.conv2d(side_3, 1, [1, 1], scope='score-dsn_3')
side_4_s = slim.conv2d(side_4, 1, [1, 1], scope='score-dsn_4')
side_5_s = slim.conv2d(side_5, 1, [1, 1], scope='score-dsn_5')
with slim.arg_scope([slim.convolution2d_transpose],
activation_fn=None,
biases_initializer=None,
padding='VALID',
outputs_collections=end_points_collection,
trainable=False):
# Side outputs
side_2_s = slim.convolution2d_transpose(
side_2_s, 1, 4, 2, scope='score-dsn_2-up')
side_2_s = crop_features(side_2_s, im_size)
utils.collect_named_outputs(end_points_collection,
'osvos/score-dsn_2-cr',
side_2_s)
side_3_s = slim.convolution2d_transpose(
side_3_s, 1, 8, 4, scope='score-dsn_3-up')
side_3_s = crop_features(side_3_s, im_size)
utils.collect_named_outputs(end_points_collection,
'osvos/score-dsn_3-cr',
side_3_s)
side_4_s = slim.convolution2d_transpose(
side_4_s, 1, 16, 8, scope='score-dsn_4-up')
side_4_s = crop_features(side_4_s, im_size)
utils.collect_named_outputs(end_points_collection,
'osvos/score-dsn_4-cr',
side_4_s)
side_5_s = slim.convolution2d_transpose(
side_5_s, 1, 32, 16, scope='score-dsn_5-up')
side_5_s = crop_features(side_5_s, im_size)
utils.collect_named_outputs(end_points_collection,
'osvos/score-dsn_5-cr',
side_5_s)
# Main output
side_2_f = slim.convolution2d_transpose(
side_2, 16, 4, 2, scope='score-multi2-up')
side_2_f = crop_features(side_2_f, im_size)
utils.collect_named_outputs(end_points_collection,
'osvos/side-multi2-cr',
side_2_f)
side_3_f = slim.convolution2d_transpose(
side_3, 16, 8, 4, scope='score-multi3-up')
side_3_f = crop_features(side_3_f, im_size)
utils.collect_named_outputs(end_points_collection,
'osvos/side-multi3-cr',
side_3_f)
side_4_f = slim.convolution2d_transpose(
side_4, 16, 16, 8, scope='score-multi4-up')
side_4_f = crop_features(side_4_f, im_size)
utils.collect_named_outputs(end_points_collection,
'osvos/side-multi4-cr',
side_4_f)
side_5_f = slim.convolution2d_transpose(
side_5, 16, 32, 16, scope='score-multi5-up')
side_5_f = crop_features(side_5_f, im_size)
utils.collect_named_outputs(end_points_collection,
'osvos/side-multi5-cr',
side_5_f)
concat_side = tf.concat(
[side_2_f, side_3_f, side_4_f, side_5_f], axis=3)
net = slim.conv2d(concat_side, 1, [1, 1], scope='upscore-fuse')
end_points = slim.utils.convert_collection_to_dict(
end_points_collection)
return net, end_points
pass
def model_fn(self, is_training=True, *args, **kwargs):
# write your own model code
# for tensorflow
# step 1: unwarp data
batch_data = None
batch_label = None
origianl_img = None
shape = None
if len(args) > 0:
# for method 2 and method 3
# on train or test stage, unwarp data from args (which comes from model_input())
if is_training:
batch_data, batch_label = args[0].dequeue()
else:
batch_data, shape, origianl_img = args[0]
else:
# for method 1
# use placeholder
batch_data = tf.placeholder(tf.float32,
shape=[
ctx.params.batch_size,
ctx.params.input_size,
ctx.params.input_size, 3
],
name='data_node')
if not is_training:
batch_label = tf.placeholder(tf.int32,
shape=[
ctx.params.batch_size,
ctx.params.input_size,
ctx.params.input_size
],
name='label_node')
# step 2: building model
# 使用VGG16作为基础网络
with slim.arg_scope(vgg.vgg_arg_scope()):
net, end_points = vgg.vgg_16(batch_data, None, is_training)
# 抽取pool5, pool4, pool3 中间层
vgg_pool5 = end_points['vgg_16/pool5']
vgg_pool4 = end_points['vgg_16/pool4']
vgg_pool3 = end_points['vgg_16/pool3']
with tf.variable_scope(None, 'FCN', [vgg_pool5, vgg_pool4, vgg_pool3]):
conv6 = slim.conv2d(vgg_pool5,
4096, [7, 7],
padding='SAME',
activation_fn=tf.nn.relu)
conv7 = slim.conv2d(conv6,
4096, [1, 1],
padding='SAME',
activation_fn=tf.nn.relu)
conv7_dropout = slim.dropout(conv7, is_training=is_training)
# FCN32S
# 使用最后一层（分辨率16x16）进行语义类别预测
score_32 = slim.conv2d(conv7_dropout,
ctx.params.class_num, [1, 1],
padding='SAME')
score_32_up = slim.convolution2d_transpose(
score_32,
vgg_pool4.get_shape()[-1], [4, 4], [2, 2])
# FCN16S
# 结合来自pool4的特征图（分辨率32x32）进行进一步语义类别预测
score_16 = score_32_up + vgg_pool4
score_16_up = slim.convolution2d_transpose(
score_16,
vgg_pool3.get_shape()[-1], [4, 4], [2, 2])
# FCN8S
# 集合来自pool3的特征图（分辨率64x64）进行进一步语义类别预测
score_8 = score_16_up + vgg_pool3
score_8_up = slim.convolution2d_transpose(score_8,
ctx.params.class_num,
[16, 16], [8, 8],
activation_fn=None)
if is_training:
one_hot_batch_label = tf.one_hot(batch_label,
ctx.params.class_num)
# cross entropy
fcn8_loss = tf.losses.softmax_cross_entropy(
one_hot_batch_label, score_8_up)
return fcn8_loss
else:
logits = tf.nn.softmax(score_8_up)
logits = tf.image.resize_images(logits, (shape[0], shape[1]))
return logits, origianl_img
name="x")
y = tf.placeholder(tf.float32, shape=(mb_size, n_classes), name="y")
z = tf.placeholder(tf.float32, shape=(mb_size, n_inputs_G), name="z")
with tf.variable_scope("G_net"):
input_G = slim.fully_connected(z,
2 * 2 * 256,
normalizer_fn=slim.batch_norm,
activation_fn=tf.identity,
scope='input_G')
input_G = tf.reshape(input_G, [mb_size, 2, 2, 256])
conv1 = slim.convolution2d_transpose(input_G,
256,
3,
stride=2,
normalizer_fn=slim.batch_norm,
activation_fn=tf.identity,
scope='g_conv1')
conv1 = tf.nn.relu(conv1)
conv2 = slim.convolution2d_transpose(conv1,
256,
3,
stride=1,
normalizer_fn=slim.batch_norm,
activation_fn=tf.identity,
scope='g_conv2')
conv2 = tf.nn.relu(conv2)
conv3 = slim.convolution2d_transpose(conv2,
def generator(self, z):
# project z
z_filter_number = self.g_filter_number * 8
z_projection_size = self.image_size // 8
z_projected = slim.fully_connected(
z,
z_projection_size * z_projection_size * z_filter_number,
activation_fn=tf.nn.relu,
normalizer_fn=slim.batch_norm,
weights_initializer=self._initialzier,
scope='g_projection',
)
z_reshaped = tf.reshape(
z_projected,
[-1, z_projection_size, z_projection_size, z_filter_number])
# transposed conv1
g_conv1_filter_number = z_filter_number // 2
g_conv1 = slim.convolution2d_transpose(
z_reshaped,
num_outputs=g_conv1_filter_number,
kernel_size=[self.g_filter_size, self.g_filter_size],
stride=[2, 2],
padding='SAME',
activation_fn=tf.nn.relu,
normalizer_fn=slim.batch_norm,
weights_initializer=self._initialzier,
scope='g_conv1',
)
# transposed conv2
g_conv2_filter_number = g_conv1_filter_number // 2
g_conv2 = slim.convolution2d_transpose(
g_conv1,
num_outputs=g_conv2_filter_number,
kernel_size=[self.g_filter_size, self.g_filter_size],
stride=[2, 2],
padding='SAME',
activation_fn=tf.nn.relu,
normalizer_fn=slim.batch_norm,
weights_initializer=self._initialzier,
scope='g_conv2',
)
# transposed conv3
g_conv3_filter_number = g_conv2_filter_number // 2
g_conv3 = slim.convolution2d_transpose(
g_conv2,
num_outputs=g_conv3_filter_number,
kernel_size=[self.g_filter_size, self.g_filter_size],
stride=[2, 2],
padding='SAME',
activation_fn=tf.nn.relu,
normalizer_fn=slim.batch_norm,
weights_initializer=self._initialzier,
scope='g_conv3',
)
# out
g_out = slim.convolution2d_transpose(
g_conv3,
num_outputs=self.channel_size,
kernel_size=[self.image_size, self.image_size],
padding='SAME',
biases_initializer=None,
activation_fn=tf.nn.tanh,
weights_initializer=self._initialzier,
scope='g_out')
return g_out
with tf.variable_scope("G_net"):
# 1st Concatenate
input_G = tf.concat([z, y], axis=1)
# 1st hidden layer
hidden1_G = slim.fully_connected(input_G,
8 * 8 * 128,
normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu,
scope='hidden1')
hidden1_G_reshape = tf.reshape(hidden1_G, shape=[mb_size, 8, 8, 128])
# 2nd hidden layer
hidden2_G = slim.convolution2d_transpose(hidden1_G_reshape,
128,
5,
stride=2,
normalizer_fn=slim.batch_norm,
activation_fn=tf.nn.relu,
scope='hidden2')
# Output layer
G = slim.convolution2d_transpose(hidden2_G,
3,
5,
stride=2,
activation_fn=tf.nn.tanh,
scope='output')
# Creating samples from Generator: -------------------------------------------------------
saver = tf.train.Saver()
def generator(z, is_train=True, reuse=True):
initializer = tf.truncated_normal_initializer(stddev=0.02)
with tf.variable_scope('generator') as scope:
# z = slim.fully_connected(z, 4 * 4 * 512, normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu, reuse=reuse,
# scope='g_project', weights_initializer=initializer)
z = tf.reshape(z, [-1, 32, 32, 4])
z = slim.convolution2d(z,
num_outputs=32,
kernel_size=[3, 3],
stride=[1, 1],
padding='same',
normalizer_fn=slim.batch_norm,
trainable=is_train,
reuse=reuse,
activation_fn=tf.nn.relu,
scope='g_conv1',
weights_initializer=initializer)
# z: [32, 32]
z = slim.convolution2d(z,
num_outputs=64,
kernel_size=[3, 3],
stride=[2, 2],
padding='same',
normalizer_fn=slim.batch_norm,
trainable=is_train,
reuse=reuse,
activation_fn=tf.nn.relu,
scope='g_conv2',
weights_initializer=initializer)
# z: [16, 16]
z = slim.convolution2d(z,
num_outputs=128,
kernel_size=[3, 3],
stride=[1, 1],
padding='same',
normalizer_fn=slim.batch_norm,
trainable=is_train,
reuse=reuse,
activation_fn=tf.nn.relu,
scope='g_conv3',
weights_initializer=initializer)
# z: [16, 16]
z = slim.convolution2d(z,
num_outputs=256,
kernel_size=[3, 3],
stride=[2, 2],
padding='same',
normalizer_fn=slim.batch_norm,
trainable=is_train,
reuse=reuse,
activation_fn=tf.nn.relu,
scope='g_conv4',
weights_initializer=initializer)
# z: [8, 8]
z = slim.convolution2d(z,
num_outputs=512,
kernel_size=[3, 3],
stride=[2, 2],
padding='same',
normalizer_fn=slim.batch_norm,
trainable=is_train,
reuse=reuse,
activation_fn=tf.nn.relu,
scope='g_conv5',
weights_initializer=initializer)
# z: [4, 4]
z = slim.convolution2d_transpose(z,
num_outputs=256,
kernel_size=[3, 3],
stride=[2, 2],
padding="same",
normalizer_fn=slim.batch_norm,
trainable=is_train,
reuse=reuse,
activation_fn=tf.nn.relu,
scope='g_trans_conv1',
weights_initializer=initializer)
# z: [8, 8]
z = slim.convolution2d_transpose(z,
num_outputs=128,
kernel_size=[3, 3],
stride=[2, 2],
padding="same",
normalizer_fn=slim.batch_norm,
trainable=is_train,
reuse=reuse,
activation_fn=tf.nn.relu,
scope='g_trans_conv2',
weights_initializer=initializer)
# z: [16, 16]
z = slim.convolution2d_transpose(z,
num_outputs=64,
kernel_size=[3, 3],
stride=[2, 2],
padding="same",
normalizer_fn=slim.batch_norm,
trainable=is_train,
reuse=reuse,
activation_fn=tf.nn.relu,
scope='g_trans_conv3',
weights_initializer=initializer)
# z: [32, 32]
z = slim.convolution2d_transpose(z,
num_outputs=3,
kernel_size=[3, 3],
stride=[2, 2],
padding="same",
reuse=reuse,
biases_initializer=None,
activation_fn=tf.nn.tanh,
trainable=is_train,
scope='g_out',
weights_initializer=initializer)
# z: [64, 64]
return z
