def generator_forward(z, reuse=None, name="generator"):
with tf.variable_scope(name, reuse=reuse):
z_shape = tf.shape(z)
out = layers.fully_connected(z,
num_outputs=1568,
activation_fn=leaky_rectify,
normalizer_fn=identity)
out = tf.reshape(out, tf.pack([z_shape[0], 7, 7, 32]))
out = layers.convolution2d_transpose(out,
num_outputs=64,
kernel_size=4,
stride=2,
activation_fn=leaky_rectify,
normalizer_fn=identity)
out = layers.convolution2d_transpose(out,
num_outputs=32,
kernel_size=4,
stride=2,
activation_fn=leaky_rectify,
normalizer_fn=identity)
out = layers.convolution2d(out,
num_outputs=1,
kernel_size=1,
stride=1,
activation_fn=tf.nn.sigmoid)
return out
def forward(self, input_tensor, is_training):
# inputs has shape [batch, 513, 513, 3]
input_tensor = tf.image.resize_images(input_tensor, [512, 512])
with slim.arg_scope(resnet_v1.resnet_arg_scope(is_training)):
net, end_points = resnet_v1.resnet_v1_101(input_tensor,
None,
global_pool=False,
output_stride=16)
print(net.get_shape())
h = L.convolution2d_transpose(net,
64, [5, 5], [4, 4],
activation_fn=None)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=0.5, is_training=is_training)
h = L.convolution2d_transpose(h,
32, [5, 5], [2, 2],
activation_fn=None)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=0.5, is_training=is_training)
print(h)
h = L.convolution2d(h,
len(self.classes) + 1, [1, 1], [1, 1],
activation_fn=None)
print(h)
return h
def forward(self, input_tensor, is_training):
dropout_value = 0.5
input_tensor = tf.image.resize_images(input_tensor, [224, 224])
print("Is training:", is_training)
with slim.arg_scope(vgg.vgg_arg_scope()):
h, end_points = vgg.vgg_19(input_tensor, is_training=is_training)
print(list(end_points.keys()))
h = tf.pad(end_points['vgg_19/pool4'], [[0, 0], [1, 1], [1, 1], [0, 0]], "CONSTANT")
print(h)
h = L.convolution2d_transpose(h, 128, [5, 5], [2, 2], activation_fn=None)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d_transpose(h, 64, [5, 5], [2, 2], activation_fn=None)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d_transpose(h, 32, [5, 5], [2, 2], activation_fn=None)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d_transpose(h, 32, [5, 5], [2, 2], activation_fn=None)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d(h, len(self.classes) + 1, [1, 1], [1, 1], activation_fn=None)
return h
def _generator_mnist(self, _input,is_training_ph,reuse=False,prefix="GENERATOR"):
output_shape = self._data.data_shape
with tf.variable_scope(prefix):
z = layers.fully_connected(_input, 7*7*16, activation_fn=None, scope='g_z')
z = tf.reshape(z, [-1, 7,7,16])
z= lrelu(z)
z= batch_norm(z,is_training_ph,reuse,scope='bn_layer1')
conv1 = layers.convolution2d_transpose(z, 8, 5, stride=2, activation_fn=None, scope='g_conv1')
conv1=lrelu(conv1)
conv1=batch_norm(conv1,is_training_ph,reuse,scope='bn_layer2')
conv2 = layers.convolution2d_transpose(conv1, 4, 5, stride=2, activation_fn=None, scope='g_conv2')
conv2=lrelu(conv2)
conv2=batch_norm(conv2,is_training_ph,reuse,scope='bn_layer3')
conv3 = layers.convolution2d_transpose(conv2, 1, 5, stride=1, activation_fn=None, scope='g_conv3')
conv3=lrelu(conv3)
conv3=batch_norm(conv3,is_training_ph,reuse,scope='bn_layer4')
out=tf.reshape(conv3, [-1] + list(output_shape))
return out
def netG(z, y, BATCH_SIZE):
# concat attribute y onto z
z = tf.concat([z,y], axis=1)
z = tcl.fully_connected(z, 4*4*512, activation_fn=tf.identity, scope='g_z')
#z = tcl.batch_norm(z)
z = tf.reshape(z, [BATCH_SIZE, 4, 4, 512])
#z = tf.nn.relu(z)
conv1 = tcl.convolution2d_transpose(z, 256, 5, 2, normalizer_fn=tcl.batch_norm, activation_fn=tf.nn.relu, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_conv1')
conv2 = tcl.convolution2d_transpose(conv1, 128, 5, 2, normalizer_fn=tcl.batch_norm, activation_fn=tf.nn.relu, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_conv2')
conv3 = tcl.convolution2d_transpose(conv2, 64, 5, 2, normalizer_fn=tcl.batch_norm, activation_fn=tf.nn.relu, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_conv3')
conv4 = tcl.convolution2d_transpose(conv3, 3, 5, 2, activation_fn=tf.nn.tanh, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_conv4')
print 'z:',z
print 'conv1:',conv1
print 'conv2:',conv2
print 'conv3:',conv3
print 'conv4:',conv4
print
print 'END G'
print
tf.add_to_collection('vars', z)
tf.add_to_collection('vars', conv1)
tf.add_to_collection('vars', conv2)
tf.add_to_collection('vars', conv3)
tf.add_to_collection('vars', conv4)
return conv4
def netG(z, batch_size):
print 'GENERATOR'
z = tcl.fully_connected(z, 4*4*1024, activation_fn=tf.identity, scope='g_z')
z = tf.reshape(z, [batch_size, 4, 4, 1024])
z = tcl.batch_norm(z)
z = tf.nn.relu(z)
conv1 = tcl.convolution2d_transpose(z, 512, 5, 2, normalizer_fn=tcl.batch_norm, activation_fn=tf.nn.relu, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_conv1')
conv2 = tcl.convolution2d_transpose(conv1, 256, 5, 2, normalizer_fn=tcl.batch_norm, activation_fn=tf.nn.relu, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_conv2')
conv3 = tcl.convolution2d_transpose(conv2, 128, 5, 2, normalizer_fn=tcl.batch_norm, activation_fn=tf.nn.relu, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_conv3')
conv4 = tcl.convolution2d_transpose(conv3, 3, 5, 2, activation_fn=tf.nn.tanh, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_conv4')
print 'z:',z
print 'conv1:',conv1
print 'conv2:',conv2
print 'conv3:',conv3
print 'conv4:',conv4
print
print 'END G'
print
tf.add_to_collection('vars', z)
tf.add_to_collection('vars', conv1)
tf.add_to_collection('vars', conv2)
tf.add_to_collection('vars', conv3)
tf.add_to_collection('vars', conv4)
return conv4
def celebA_generator(z, n_z=100, DIM=64, reuse=False):
with tf.variable_scope('G', reuse=reuse) as scope:
z = tcl.fully_connected(z,
4 * 4 * 1024,
activation_fn=tf.identity,
scope='z')
z = tf.reshape(z, [-1, 4, 4, 1024])
z = tcl.batch_norm(z)
z = tf.nn.relu(z)
conv1 = tcl.convolution2d_transpose(
z,
512,
5,
2,
normalizer_fn=tcl.batch_norm,
activation_fn=tf.nn.relu,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='conv1')
conv2 = tcl.convolution2d_transpose(
conv1,
256,
5,
2,
normalizer_fn=tcl.batch_norm,
activation_fn=tf.nn.relu,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='conv2')
conv3 = tcl.convolution2d_transpose(
conv2,
128,
5,
2,
normalizer_fn=tcl.batch_norm,
activation_fn=tf.nn.relu,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='conv3')
conv4 = tcl.convolution2d_transpose(
conv3,
3,
5,
2,
activation_fn=tf.nn.tanh,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='conv4')
variables = tf.contrib.framework.get_variables(scope)
variables = {var.op.name.replace("G/", "g_"): var for var in variables}
variables['BatchNorm/beta'] = variables.pop('g_BatchNorm/beta')
variables['BatchNorm/moving_mean'] = variables.pop(
'g_BatchNorm/moving_mean')
variables['BatchNorm/moving_variance'] = variables.pop(
'g_BatchNorm/moving_variance')
out = tf.reshape(conv4, [-1, 64, 64, 3])
out = out * 0.5 + 0.5
return out, variables
def conv_generator(x, output_dim, n_filters, scope='Generator'):
with tf.variable_scope(scope):
s4, s2 = int(output_dim / 4), int(output_dim / 2)
z_ = layers.linear(x, s4 * s4 * n_filters * 2)
h0 = tf.reshape(z_, [-1, s4, s4, n_filters * 2])
h1 = layers.convolution2d_transpose(h0, n_filters, [5, 5], stride=2)
h1 = tf.nn.elu(h1)
h2 = layers.convolution2d_transpose(h1, 1, [5, 5], stride=2)
return tf.reshape(tf.nn.tanh(h2), [-1, output_dim * output_dim])
def forward(self, input_tensor, is_training):
dropout_value = 0.5
h = L.convolution2d(input_tensor, 16, [5, 5], activation_fn=None)
h = L.batch_norm(h)
h = tf.nn.relu(h)
h = L.max_pool2d(h, [2, 2], [2, 2])
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d(h, 32, [5, 5], activation_fn=None)
h = L.batch_norm(h)
h = tf.nn.relu(h)
h = L.max_pool2d(h, [2, 2], [2, 2])
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d(h, 64, [5, 5], activation_fn=None)
h = L.batch_norm(h)
h = tf.nn.relu(h)
h = L.max_pool2d(h, [2, 2], [2, 2])
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d(h, 128, [5, 5], activation_fn=None)
h = L.batch_norm(h)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d_transpose(h, 128, [5, 5], [2, 2], activation_fn=None)
h = L.batch_norm(h)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d_transpose(h, 64, [5, 5], [2, 2], activation_fn=None)
h = L.batch_norm(h)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d_transpose(h, 32, [5, 5], [2, 2], activation_fn=None)
h = L.batch_norm(h)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d_transpose(h, 32, [5, 5], activation_fn=None)
h = L.batch_norm(h)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d_transpose(h, 32, [5, 5], activation_fn=None)
h = L.batch_norm(h)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d(h, len(self.classes) + 1, [1, 1], [1, 1], activation_fn=None)
return h
def __call__(self, z, reuse=True):
#with tf.variable_scope(self.name,reuse=tf.AUTO_REUSE) as vs:
with tf.variable_scope(self.name) as vs:
if reuse:
vs.reuse_variables()
bs = tf.shape(z)[0]
y = z[:, -10:]
yb = tf.reshape(y, shape=[bs, 1, 1, 10])
fc = tcl.fully_connected(z, 1024, activation_fn=tf.identity)
fc = tc.layers.batch_norm(fc,
decay=0.9,
scale=True,
updates_collections=None,
is_training=self.is_training)
fc = leaky_relu(fc)
fc = tf.concat([fc, y], 1)
if self.dataset == 'mnist':
fc = tcl.fully_connected(fc,
7 * 7 * 128,
activation_fn=tf.identity)
fc = tf.reshape(fc, tf.stack([bs, 7, 7, 128]))
elif self.dataset == 'cifar10':
fc = tcl.fully_connected(fc,
8 * 8 * 128,
activation_fn=tf.identity)
fc = tf.reshape(fc, tf.stack([bs, 8, 8, 128]))
fc = tc.layers.batch_norm(fc,
decay=0.9,
scale=True,
updates_collections=None,
is_training=self.is_training)
fc = leaky_relu(fc)
fc = conv_cond_concat(fc, yb)
conv = tcl.convolution2d_transpose(fc,
64, [4, 4], [2, 2],
activation_fn=tf.identity)
#(bs,14,14,64)
conv = tc.layers.batch_norm(conv,
decay=0.9,
scale=True,
updates_collections=None,
is_training=self.is_training)
conv = leaky_relu(conv)
if self.dataset == 'mnist':
output = tcl.convolution2d_transpose(
conv, 1, [4, 4], [2, 2], activation_fn=tf.nn.sigmoid)
output = tf.reshape(output, [bs, -1])
elif self.dataset == 'cifar10':
output = tcl.convolution2d_transpose(
conv, 3, [4, 4], [2, 2], activation_fn=tf.nn.sigmoid)
output = tf.reshape(output, [bs, -1])
#(0,1) by tanh
return output
def forward(self, input_tensor, is_training):
dropout_value = 0.5
input_tensor = tf.expand_dims(input_tensor, -1)
h = tf.layers.conv3d(input_tensor, 16, [5, 5, 3], padding="same")
h = tf.layers.batch_normalization(h)
h = tf.nn.relu(h)
h = tf.layers.max_pooling3d(h, [2, 2, 2], [2, 2, 2])
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
print(h)
h = tf.layers.conv3d(h, 32, [5, 5, 2], padding="same")
h = tf.layers.batch_normalization(h)
h = tf.nn.relu(h)
h = tf.layers.max_pooling3d(h, [2, 2, 1], [2, 2, 1])
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
print(h)
h = tf.layers.conv3d(h, 64, [5, 5, 2], padding="same")
h = tf.layers.batch_normalization(h)
h = tf.nn.relu(h)
h = tf.layers.max_pooling3d(h, [2, 2, 2], [2, 2, 2])
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
print(h)
h = tf.layers.conv3d(h, 128, [5, 5, 1], padding="same")
h = tf.layers.batch_normalization(h)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
print(h)
h = tf.squeeze(h, 3)
print(h)
h = L.convolution2d_transpose(h,
128, [5, 5], [2, 2],
activation_fn=tf.nn.relu)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d_transpose(h,
64, [5, 5], [2, 2],
activation_fn=tf.nn.relu)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d_transpose(h,
32, [5, 5], [2, 2],
activation_fn=tf.nn.relu)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d(h,
len(self.classes) + 1, [1, 1], [1, 1],
activation_fn=None)
return h
def netG(z, batch_size):
print 'GENERATOR'
z = layers.fully_connected(z,
4 * 4 * 1024,
normalizer_fn=layers.batch_norm,
activation_fn=tf.nn.relu,
scope='g_z')
z = tf.reshape(z, [batch_size, 4, 4, 1024])
conv1 = layers.convolution2d_transpose(z,
512,
5,
stride=2,
normalizer_fn=layers.batch_norm,
activation_fn=tf.nn.relu,
scope='g_conv1')
conv2 = layers.convolution2d_transpose(conv1,
256,
5,
stride=2,
normalizer_fn=layers.batch_norm,
activation_fn=tf.nn.relu,
scope='g_conv2')
conv3 = layers.convolution2d_transpose(conv2,
128,
5,
stride=2,
normalizer_fn=layers.batch_norm,
activation_fn=tf.nn.relu,
scope='g_conv3')
conv4 = layers.convolution2d_transpose(conv3,
3,
5,
stride=2,
activation_fn=tf.nn.tanh,
scope='g_conv4')
print 'z:', z
print 'conv1:', conv1
print 'conv2:', conv2
print 'conv3:', conv3
print 'conv4:', conv4
print
print 'END G'
print
tf.add_to_collection('vars', z)
tf.add_to_collection('vars', conv1)
tf.add_to_collection('vars', conv2)
tf.add_to_collection('vars', conv3)
tf.add_to_collection('vars', conv4)
return conv4
def forward(self, input_tensor, is_training):
dropout_value = 0.5
# input_tensor = tf.image.resize_images(input_tensor, [224, 224])
batch_size = tf.shape(input_tensor)[0]
print("Is training:", is_training)
with slim.arg_scope(vgg.vgg_arg_scope()):
h, end_points = vgg.vgg_16(input_tensor, is_training=is_training)
print(end_points)
print(list(end_points.keys()))
h = end_points['vgg_16/pool4']
h = L.convolution2d_transpose(h, 256, [5, 5], [2, 2], activation_fn=None)
h = tf.nn.relu(h)
h = tf.concat([h, end_points['vgg_16/pool3']], axis=3)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
np_seed_mask = np.zeros((1, 56, 56, 1))
np_seed_mask[:, 28:29, 28:29, :] = 1.0
seed_mask = tf.constant(np_seed_mask, dtype=tf.float32)
seed_mask = tf.tile(seed_mask, [batch_size, 1, 1, 1])
h = L.convolution2d_transpose(h, 128, [5, 5], [2, 2], activation_fn=None)
h = tf.nn.relu(h)
h = tf.concat([h, end_points['vgg_16/pool2'], seed_mask], axis=3)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d_transpose(h, 64, [5, 5], [2, 2], activation_fn=None)
h = tf.nn.relu(h)
h = tf.concat([h, end_points['vgg_16/pool1']], axis=3)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d_transpose(h, 64, [5, 5], [2, 2], activation_fn=None)
h = tf.concat([h, input_tensor], axis=3)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
# h = L.convolution2d_transpose(h, 64, [5, 5], [2, 2], activation_fn=None)
# h = tf.nn.relu(h)
# h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
# h = L.convolution2d_transpose(h, 64, [5, 5], [2, 2], activation_fn=None)
# h = tf.nn.relu(h)
# h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d(h, len(self.classes) + 1, [1, 1], [1, 1], activation_fn=None)
return h
def _decode(self, feature_map, is_training):
h = L.convolution2d_transpose(feature_map, 128, [5, 5], [2, 2], activation_fn=tf.nn.relu)
h = L.dropout(h, keep_prob=0.5, is_training=is_training)
h = L.convolution2d_transpose(h, 64, [5, 5], [2, 2], activation_fn=tf.nn.relu)
h = L.dropout(h, keep_prob=0.5, is_training=is_training)
h = L.convolution2d_transpose(h, 32, [5, 5], [2, 2], activation_fn=tf.nn.relu)
h = L.dropout(h, keep_prob=0.5, is_training=is_training)
h = L.convolution2d_transpose(h, 32, [5, 5], [2, 2], activation_fn=tf.nn.relu)
h = L.convolution2d(h, len(self.classes) + 1, [1, 1], [1, 1], activation_fn=None)
return h
def netG(z, batch_size):
print 'GENERATOR'
z = tcl.fully_connected(z,
4 * 4 * 256,
activation_fn=tf.identity,
scope='g_z')
z = tf.reshape(z, [batch_size, 4, 4, 256])
z = tcl.batch_norm(z)
z = tf.nn.relu(z)
conv1 = tcl.convolution2d_transpose(
z,
128,
5,
2,
normalizer_fn=tcl.batch_norm,
activation_fn=tf.nn.relu,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='g_conv1')
conv2 = tcl.convolution2d_transpose(
conv1,
64,
5,
2,
normalizer_fn=tcl.batch_norm,
activation_fn=tf.nn.relu,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='g_conv2')
conv3 = tcl.convolution2d_transpose(
conv2,
1,
5,
2,
normalizer_fn=tcl.batch_norm,
activation_fn=tf.nn.relu,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='g_conv3')
conv3 = conv3[:, :28, :28, :]
print 'z:', z
print 'conv1:', conv1
print 'conv2:', conv2
print 'conv3:', conv3
return conv3
def get_network(self, input_tensor, is_training):
# Load pre-trained inception-resnet model
with slim.arg_scope(inception_resnet_v2_arg_scope(batch_norm_decay = 0.999, weight_decay = 0.0001)):
net, end_points = inception_resnet_v2(input_tensor, is_training = is_training)
# Adding some modification to original InceptionResnetV2 - changing scoring of AUXILIARY TOWER
weight_decay = 0.0005
with tf.variable_scope('NewInceptionResnetV2'):
with tf.variable_scope('AuxiliaryScoring'):
with slim.arg_scope([layers.convolution2d, layers.convolution2d_transpose],
weights_regularizer = slim.l2_regularizer(weight_decay),
biases_regularizer = slim.l2_regularizer(weight_decay),
activation_fn = None):
tf.summary.histogram('Last_layer/activations', net, [KEY_SUMMARIES])
# Scoring
net = slim.dropout(net, 0.7, is_training = is_training, scope = 'Dropout')
net = layers.convolution2d(net, num_outputs = self.FEATURES, kernel_size = 1, stride = 1,
scope = 'Scoring_layer')
feature = net
tf.summary.histogram('Scoring_layer/activations', net, [KEY_SUMMARIES])
# Upsampling
net = layers.convolution2d_transpose(net, num_outputs = 16, kernel_size = 17, stride = 17,
padding = 'VALID', scope = 'Upsampling_layer')
tf.summary.histogram('Upsampling_layer/activations', net, [KEY_SUMMARIES])
# Smoothing layer - separable gaussian filters
net = super()._get_gauss_smoothing_net(net, size = self.SMOOTH_SIZE, std = 1.0, kernel_sum = 0.2)
return net, feature
def tconv_ly(self, bottom, in_channels, out_channels, name=None):
with tf.variable_scope(name):
shape = self.ten_sh(bottom)
shape[-1] = out_channels
bottom = tf.pad(bottom, [[0, 0], [2, 2], [2, 2], [0, 0]],
"REFLECT")
init = ly.xavier_initializer_conv2d()
output = ly.convolution2d_transpose(inputs=bottom,
num_outputs=out_channels,
kernel_size=[3, 3],
stride=[1, 1],
padding='VALID',
activation_fn=tf.nn.relu,
weights_initializer=init,
biases_initializer=init,
trainable=True)
output = tf.slice(output, begin=[0, 2, 2, 0], size=shape)
#crop_fn = tf.image.resize_image_with_crop_or_pad
#crop_lam = lambda img: crop_fn(img, target_height=shape[1],
#target_width=shape[2])
#output = tf.map_fn(crop_lam, output, parallel_iterations=shape[0])
#output = crop_fn(output, target_height=shape[1], target_width=shape[2])
print self.ten_sh(output)
return output
def get_network(self, input_tensor, is_training):
net_end, end_points = human_pose_resnet(input_tensor,
reuse=True,
training=is_training)
return net_end
net = end_points['resnet_end']
with tf.variable_scope('NewHumanPoseResnet'):
with tf.variable_scope('Scoring'):
tf.histogram_summary('Last_layer/activations', net,
[KEY_SUMMARIES])
# net = slim.dropout(net, 1.0, is_training = is_training, scope = 'Dropout')
weight_decay = 0.001
# Scoring layer
net = layers.convolution2d(
net,
num_outputs=512,
kernel_size=1,
stride=1,
scope='Scoring_layer',
activation_fn=None,
weights_regularizer=slim.l2_regularizer(weight_decay),
biases_regularizer=slim.l2_regularizer(weight_decay))
tf.histogram_summary('Scoring_layer/activations', net,
[KEY_SUMMARIES])
# Upsampling
net = layers.convolution2d_transpose(
net,
num_outputs=16,
kernel_size=16,
stride=16,
activation_fn=None,
padding='VALID',
scope='Upsampling_layer',
weights_regularizer=slim.l2_regularizer(weight_decay),
biases_regularizer=slim.l2_regularizer(weight_decay))
tf.histogram_summary('Upsampling_layer/activations', net,
[KEY_SUMMARIES])
# Smoothing layer
net = layers.convolution2d(
net,
num_outputs=16,
kernel_size=10,
stride=1,
padding='SAME',
activation_fn=None,
scope='Smoothing_layer',
trainable=False,
biases_initializer=None,
weights_initializer=self.get_gauss_pdf_initializer())
return net
def conv2d_transpose(inputs,num_outputs,kernel_size,stride,is_training,normalizer_fn,activation_fn,name):
with tf.variable_scope(name,reuse=tf.AUTO_REUSE):
out = layers.convolution2d_transpose(inputs,
num_outputs=num_outputs,
kernel_size=kernel_size,
stride=stride,
normalizer_params={"is_training": is_training},
normalizer_fn=normalizer_fn,
activation_fn=activation_fn)
return out
def deconv2d(input_, o_size, k_size, name='deconv2d'):
print name, 'input', ten_sh(input_)
print name, 'output', o_size
assert np.sum(np.mod(o_size[1:3], ten_sh(input_)[1:3]) - [0, 0]) == 0
with tf.variable_scope(name):
init = ly.xavier_initializer_conv2d()
output = ly.convolution2d_transpose(input_, num_outputs=o_size[-1], \
kernel_size=k_size, stride=np.divide(o_size[1:3], ten_sh(input_)[1:3]), \
padding='SAME', weights_initializer=init)
return output
def generator(z):
# arg_scope set default arguments for certain layers inside that scope
with arg_scope(
[layers.fully_connected, layers.convolution2d_transpose],
weights_initializer=layers.xavier_initializer(),
weights_regularizer=layers.l2_regularizer(2.5e-5)):
x = layers.fully_connected(z,
1024,
normalizer_fn=layers.batch_norm)
x = layers.fully_connected(x,
7 * 7 * 128,
normalizer_fn=layers.batch_norm)
x = tf.reshape(x, [-1, 7, 7, 128])
x = layers.convolution2d_transpose(x,
64, [4, 4], [2, 2],
normalizer_fn=layers.batch_norm)
x = layers.convolution2d_transpose(x,
1, [4, 4], [2, 2],
activation_fn=tf.sigmoid)
return x
def netG16_decoder(layers, lab=False):
enc_conv1, enc_conv2, enc_conv3, enc_conv4, enc_conv5, enc_conv6, enc_conv7, enc_conv8 = layers[0], layers[1], layers[2], layers[3], layers[4], layers[5], layers[6], layers[7]
# decoder, no batch norm
dec_conv1 = tcl.convolution2d_transpose(enc_conv8, 512, 4, 2, activation_fn=tf.identity, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_dec_conv1')
dec_conv1 = relu(dec_conv1)
dec_conv1 = tf.concat([dec_conv1, enc_conv7], axis=3)
print (dec_conv1)
dec_conv2 = tcl.convolution2d_transpose(dec_conv1, 512, 4, 2, activation_fn=tf.identity, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_dec_conv2')
dec_conv2 = relu(dec_conv2)
dec_conv2 = tf.concat([dec_conv2, enc_conv6], axis=3)
print (dec_conv2)
dec_conv3 = tcl.convolution2d_transpose(dec_conv2, 512, 4, 2, activation_fn=tf.identity, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_dec_conv3')
dec_conv3 = relu(dec_conv3)
dec_conv3 = tf.concat([dec_conv3, enc_conv5], axis=3)
print (dec_conv3)
dec_conv4 = tcl.convolution2d_transpose(dec_conv3, 512, 4, 2, activation_fn=tf.identity, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_dec_conv4')
dec_conv4 = relu(dec_conv4)
dec_conv4 = tf.concat([dec_conv4, enc_conv4], axis=3)
print (dec_conv4)
dec_conv5 = tcl.convolution2d_transpose(dec_conv4, 256, 4, 2, activation_fn=tf.identity, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_dec_conv5')
dec_conv5 = relu(dec_conv5)
dec_conv5 = tf.concat([dec_conv5, enc_conv3], axis=3)
print (dec_conv5)
dec_conv6 = tcl.convolution2d_transpose(dec_conv5, 128, 4, 2, activation_fn=tf.identity, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_dec_conv6')
dec_conv6 = relu(dec_conv6)
dec_conv6 = tf.concat([dec_conv6, enc_conv2], axis=3)
print (dec_conv6)
dec_conv7 = tcl.convolution2d_transpose(dec_conv6, 64, 4, 2, activation_fn=tf.identity, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_dec_conv7')
dec_conv7 = relu(dec_conv7)
dec_conv7 = tf.concat([dec_conv7, enc_conv1], axis=3)
print (dec_conv7)
c = 2 if lab else 3
dec_conv8 = tcl.convolution2d_transpose(dec_conv7, c, 4, 2, activation_fn=tf.identity, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='g_dec_conv8')
dec_conv8 = tanh(dec_conv8)
print (dec_conv1)
return dec_conv8
def netG_decoder(layers, reuse=False):
sc = tf.get_variable_scope()
with tf.variable_scope(sc, reuse=reuse):
enc_conv1 = layers[0]
enc_conv2 = layers[1]
enc_conv3 = layers[2]
enc_conv4 = layers[3]
enc_conv5 = layers[4]
enc_conv6 = layers[5]
enc_conv7 = layers[6]
enc_conv8 = layers[7]
# decoder, no batch norm
dec_conv1 = tcl.convolution2d_transpose(
enc_conv8,
512,
4,
2,
activation_fn=tf.identity,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='g_dec_conv1')
dec_conv1 = relu(dec_conv1)
dec_conv1 = tf.concat([dec_conv1, enc_conv7], axis=3)
print 'dec_conv1:', dec_conv1
dec_conv2 = tcl.convolution2d_transpose(
dec_conv1,
512,
4,
2,
activation_fn=tf.identity,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='g_dec_conv2')
dec_conv2 = relu(dec_conv2)
dec_conv2 = tf.concat([dec_conv2, enc_conv6], axis=3)
print 'dec_conv2:', dec_conv2
dec_conv3 = tcl.convolution2d_transpose(
dec_conv2,
512,
4,
2,
activation_fn=tf.identity,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='g_dec_conv3')
dec_conv3 = relu(dec_conv3)
dec_conv3 = tf.concat([dec_conv3, enc_conv5], axis=3)
print 'dec_conv3:', dec_conv3
dec_conv4 = tcl.convolution2d_transpose(
dec_conv3,
512,
4,
2,
activation_fn=tf.identity,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='g_dec_conv4')
dec_conv4 = relu(dec_conv4)
dec_conv4 = tf.concat([dec_conv4, enc_conv4], axis=3)
print 'dec_conv4:', dec_conv4
dec_conv5 = tcl.convolution2d_transpose(
dec_conv4,
256,
4,
2,
activation_fn=tf.identity,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='g_dec_conv5')
dec_conv5 = relu(dec_conv5)
dec_conv5 = tf.concat([dec_conv5, enc_conv3], axis=3)
print 'dec_conv5:', dec_conv5
dec_conv6 = tcl.convolution2d_transpose(
dec_conv5,
128,
4,
2,
activation_fn=tf.identity,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='g_dec_conv6')
dec_conv6 = relu(dec_conv6)
dec_conv6 = tf.concat([dec_conv6, enc_conv2], axis=3)
print 'dec_conv6:', dec_conv6
dec_conv7 = tcl.convolution2d_transpose(
dec_conv6,
64,
4,
2,
activation_fn=tf.identity,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='g_dec_conv7')
dec_conv7 = relu(dec_conv7)
dec_conv7 = tf.concat([dec_conv7, enc_conv1], axis=3)
print 'dec_conv7:', dec_conv7
dec_conv8 = tcl.convolution2d_transpose(
dec_conv7,
3,
4,
2,
activation_fn=tf.identity,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
scope='g_dec_conv8')
dec_conv8 = tanh(dec_conv8)
print 'dec_conv8', dec_conv8
return dec_conv8
def Autoencoder(input_tensor):
"""
Autoencoder with shared weights.
:param input_image: Original image.
:return: (output_image, embedding_tensor)
"""
with tf.variable_scope('autoencoder'):
pad = 'SAME'
#####################
### ENCODER ###
#####################
#1,8,8,2048
with tf.variable_scope('conv1'):
out = convolution2d(inputs=input_tensor,
num_outputs=2048,
kernel_size=3,
stride=1,
padding=pad,
rate=1,
activation_fn=tf.nn.relu,
weights_initializer=xavier_initializer())
print("Dimensions conv1: ", out.get_shape())
with tf.variable_scope('conv2'):
embedding_tensor = convolution2d(
inputs=out,
num_outputs=4192,
kernel_size=3,
stride=2,
padding=pad,
rate=1,
activation_fn=tf.nn.relu,
weights_initializer=xavier_initializer())
print("Dimensions conv2: ", embedding_tensor.get_shape())
#####################
### DECODER ###
#####################
with tf.variable_scope('conv2'):
out = convolution2d_transpose(
inputs=embedding_tensor,
num_outputs=4192,
kernel_size=3,
stride=2,
padding=pad,
activation_fn=tf.nn.relu,
weights_initializer=xavier_initializer())
print("Dimensions deconv2: ", out.get_shape())
with tf.variable_scope('conv1'):
output_tensor = convolution2d_transpose(
inputs=out,
num_outputs=2048,
kernel_size=3,
stride=1,
padding=pad,
activation_fn=tf.nn.relu,
weights_initializer=xavier_initializer())
print("Dimensions deconv1: ", output_tensor.get_shape())
return output_tensor, embedding_tensor
def run_network(inpt,
string,
is_training,
use_batch_norm,
debug=False,
strip_batchnorm_from_last_layer=False):
# 下面两步没有看懂，？？？？？？？？？
# 如果use_batch_norm时，下面的两个都有效
# layers.bacth_norm是对输出的全连接层进行批归一化的
# 而conv_batch_norm是对卷积层进行批归一化的
maybe_fc_batch_norm = layers.batch_norm if use_batch_norm else None
maybe_conv_batch_norm = conv_batch_norm if use_batch_norm else None
if debug:
print("%s architecture" % (tf.get_variable_scope().name, ))
layer_idx = 0
out = inpt
layer_strs = string.split(",")
for i, layer in enumerate(layer_strs):
# 最后一层跳过batch_norm
if i + 1 == len(layer_strs) and strip_batchnorm_from_last_layer:
maybe_fc_batch_norm = None
maybe_conv_batch_norm = None
# 如果为卷积层，进行卷积操作
if layer.startswith("conv:"):
nkernels, stride, num_outputs, nonlinearity_str = parse_conv_params(
layer[len("conv:"):].split(":"))
nonlinearity = NONLINEARITY_NAME_TO_F[nonlinearity_str]
out = layers.convolution2d(
out,
num_outputs=num_outputs,
kernel_size=nkernels,
stride=stride,
normalizer_params={"is_training": is_training},
normalizer_fn=maybe_conv_batch_norm,
activation_fn=nonlinearity,
scope='layer_%d' % (layer_idx, ))
layer_idx += 1
if debug:
print(
"Convolution with nkernels=%d, stride=%d, num_outputs=%d followed by %s"
% (nkernels, stride, num_outputs, nonlinearity_str))
# 如果为反卷积层，进行反卷积操作
#这个操作的具体过程可以查看http://blog.csdn.net/fate_fjh/article/details/52882134说得非常好
#大致的过程就是如果输入为N1*N1，卷积核为N2*N2，步长为K，则输出为（N1-1）*K+N2
elif layer.startswith("deconv:"):
nkernels, stride, num_outputs, nonlinearity_str = parse_conv_params(
layer[len("deconv:"):].split(":"))
nonlinearity = NONLINEARITY_NAME_TO_F[nonlinearity_str]
out = layers.convolution2d_transpose(
out,
num_outputs=num_outputs,
kernel_size=nkernels,
stride=stride,
activation_fn=nonlinearity,
normalizer_fn=maybe_conv_batch_norm,
normalizer_params={"is_training": is_training},
scope='layer_%d' % (layer_idx, ))
layer_idx += 1
if debug:
print(
"Deconvolution with nkernels=%d, stride=%d, num_outputs=%d followed by %s"
% (nkernels, stride, num_outputs, nonlinearity_str))
# 如果为全连接层，进行全连接操作
# 这里的全连接是tensorflow自己集成的，可以看一下内部的说明：大致的意思是
# 如果使用了batch_norm的话，就没有bias，并且默认的激活函数是relu
elif layer.startswith("fc:"):
params = layer[len("fc:"):].split(":")
nonlinearity_str = 'relu'
if len(params) == 2:
params, nonlinearity_str = params[:-1], params[-1]
num_outputs = parse_math(params[0])
nonlinearity = NONLINEARITY_NAME_TO_F[nonlinearity_str]
out = layers.fully_connected(out,
num_outputs=num_outputs,
activation_fn=nonlinearity,
normalizer_fn=maybe_fc_batch_norm,
normalizer_params={
"is_training": is_training,
"updates_collections": None
},
scope='layer_%d' % (layer_idx, ))
layer_idx += 1
if debug:
print("Fully connected with num_outputs=%d followed by %s" %
(num_outputs, nonlinearity_str))
# 如果为重构层，进行重构操作
elif layer.startswith("reshape:"):
params = layer[len("reshape:"):].split(":")
dims = [parse_math(dim) for dim in params]
out = tf.reshape(out, [-1] + dims)
if debug:
print("Reshape to %r" % (dims, ))
else:
raise ValueError("Could not parse layer description: %r" %
(layer, ))
if debug:
print("")
return out
def human_pose_resnet(net, reuse=False, training=False):
def batch_normalization(input_net, act_f=None, scope=None):
return layers.batch_norm(input_net,
center=True,
scale=True,
epsilon=1e-5,
activation_fn=act_f,
is_training=training,
scope=scope)
def conv_2d(input_net,
num_outputs,
kernel_size,
stride=1,
padding='SAME',
scope=None):
return layers.convolution2d(input_net,
num_outputs=num_outputs,
kernel_size=kernel_size,
stride=stride,
padding=padding,
activation_fn=None,
scope=scope)
def padding(input_net, w, h):
return tf.pad(input_net, [[0, 0], [h, h], [w, w], [0, 0]], "CONSTANT")
def bottleneck(input_net, depth, depth_bottleneck, stride, i):
with tf.variable_scope('Bottleneck_%d' % i, reuse=reuse):
res_conv = stride > 1 or stride < 0
stride = abs(stride)
# Res connection
out_net = conv_2d(input_net,
num_outputs=depth_bottleneck,
kernel_size=1,
stride=1,
padding='VALID',
scope='Conv_1')
out_net = batch_normalization(out_net, tf.nn.relu, 'BatchNorm_1')
out_net = padding(out_net, 1, 1)
out_net = conv_2d(out_net,
num_outputs=depth_bottleneck,
kernel_size=3,
stride=stride,
padding='VALID',
scope='Conv_2')
out_net = batch_normalization(out_net, tf.nn.relu, 'BatchNorm_2')
out_net = conv_2d(out_net,
num_outputs=depth,
kernel_size=1,
stride=1,
padding='VALID',
scope='Conv_3')
out_net = batch_normalization(out_net, scope='BatchNorm_3')
# Skip connection
if res_conv:
input_net = conv_2d(input_net,
num_outputs=depth,
kernel_size=1,
stride=stride,
padding='VALID',
scope='Conv_skip')
input_net = batch_normalization(input_net,
scope='BatchNorm_skip')
out_net += input_net
out_net = tf.nn.relu(out_net)
return out_net
def repeat_bottleneck(input_net, all_params):
for i, (depth, depth_bottleneck, stride) in enumerate(all_params):
input_net = bottleneck(input_net, depth, depth_bottleneck, stride,
i)
return input_net
end_points = {}
with tf.variable_scope('HumanPoseResnet', reuse=reuse):
with tf.variable_scope('Block_0', reuse=reuse):
net = padding(net, 3, 3)
net = conv_2d(net,
num_outputs=64,
kernel_size=7,
stride=2,
padding='VALID')
net = batch_normalization(net, tf.nn.relu)
net = padding(net, 1, 1)
net = layers.max_pool2d(net, 3, 2, padding='VALID')
with tf.variable_scope('Block_1', reuse=reuse):
net = repeat_bottleneck(net, [(256, 64, -1)] + [(256, 64, 1)] * 2)
with tf.variable_scope('Block_2', reuse=reuse):
net = repeat_bottleneck(net, [(512, 128, 2)] + [(512, 128, 1)] * 7)
with tf.variable_scope('Block_3', reuse=reuse):
net = repeat_bottleneck(net,
[(1024, 256, 2)] + [(1024, 256, 1)] * 35)
with tf.variable_scope('Block_4', reuse=reuse):
net = repeat_bottleneck(net,
[(2048, 512, -1)] + [(2048, 512, 1)] * 2)
end_points['resnet_end'] = net
with tf.variable_scope('Block_5', reuse=reuse):
net = conv_2d(net,
num_outputs=16,
kernel_size=1,
stride=1,
padding='VALID')
net = layers.convolution2d_transpose(net,
num_outputs=16,
kernel_size=16,
stride=16,
activation_fn=None,
padding='VALID')
# net = tf.nn.sigmoid(net)
return net, end_points
def ema_ae(input_image):
"""
Autoencoder with shared weights.
:param input_image: Original image.
:return: (output_image, embedding_tensor)
"""
with tf.variable_scope('autoencoder'):
out = input
pad = 'SAME'
#####################
### ENCODER ###
#####################
with tf.variable_scope('conv1'):
out = convolution2d(inputs=input_image, num_outputs=1, kernel_size=3, stride=1, padding=pad, rate=1,
activation_fn=tf.nn.relu, weights_initializer=xavier_initializer())
with tf.variable_scope('conv2'):
out = convolution2d(inputs=out, num_outputs=1, kernel_size=3, stride=2, padding=pad, rate=1,
activation_fn=tf.nn.relu, weights_initializer=xavier_initializer())
with tf.variable_scope('conv3'):
out = convolution2d(inputs=out, num_outputs=16, kernel_size=3, stride=1, padding=pad, rate=1,
activation_fn=tf.nn.relu, weights_initializer=xavier_initializer())
with tf.variable_scope('conv4'):
out = convolution2d(inputs=out, num_outputs=16, kernel_size=3, stride=2, padding=pad, rate=1,
activation_fn=tf.nn.relu, weights_initializer=xavier_initializer())
with tf.variable_scope('conv5'):
out = convolution2d(inputs=out, num_outputs=32, kernel_size=3, stride=1, padding=pad, rate=1,
activation_fn=tf.nn.relu, weights_initializer=xavier_initializer())
with tf.variable_scope('conv6'):
embedding_tensor = convolution2d(inputs=out, num_outputs=32, kernel_size=3, stride=2, padding=pad, rate=1,
activation_fn=tf.nn.relu, weights_initializer=xavier_initializer())
#####################
### DECODER ###
#####################
with tf.variable_scope('conv6'):
out = convolution2d_transpose(inputs=embedding_tensor, num_outputs=32, kernel_size=3, stride=2, padding=pad,
activation_fn=tf.nn.relu, weights_initializer=xavier_initializer())
with tf.variable_scope('conv5'):
out = convolution2d_transpose(inputs=out, num_outputs=32, kernel_size=3, stride=1, padding=pad,
activation_fn=tf.nn.relu, weights_initializer=xavier_initializer())
with tf.variable_scope('conv4'):
out = convolution2d_transpose(inputs=out, num_outputs=16, kernel_size=3, stride=2, padding=pad,
activation_fn=tf.nn.relu, weights_initializer=xavier_initializer())
with tf.variable_scope('conv3'):
out = convolution2d_transpose(inputs=out, num_outputs=16, kernel_size=3, stride=1, padding=pad,
activation_fn=tf.nn.relu, weights_initializer=xavier_initializer())
with tf.variable_scope('conv2'):
out = convolution2d_transpose(inputs=out, num_outputs=1, kernel_size=3, stride=2, padding=pad,
activation_fn=tf.nn.relu, weights_initializer=xavier_initializer())
with tf.variable_scope('conv1'):
output_image = convolution2d_transpose(inputs=out, num_outputs=1, kernel_size=3, stride=1, padding=pad,
activation_fn=tf.nn.relu, weights_initializer=xavier_initializer())
return output_image, embedding_tensor
def __call__(self, z, reuse=True):
#with tf.variable_scope(self.name,reuse=tf.AUTO_REUSE) as vs:
with tf.variable_scope(self.name) as vs:
if reuse:
vs.reuse_variables()
bs = tf.shape(z)[0]
y = z[:, -10:]
#yb = tf.reshape(y, shape=[bs, 1, 1, 10])
fc = tcl.fully_connected(
z,
1024,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
weights_regularizer=tc.layers.l2_regularizer(2.5e-5),
activation_fn=tf.identity)
fc = tc.layers.batch_norm(fc,
decay=0.9,
scale=True,
updates_collections=None,
is_training=self.is_training)
fc = tf.nn.relu(fc)
#fc = tf.concat([fc, y], 1)
fc = tcl.fully_connected(
fc,
8 * 8 * 128,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
weights_regularizer=tc.layers.l2_regularizer(2.5e-5),
activation_fn=tf.identity)
fc = tf.reshape(fc, tf.stack([bs, 8, 8, 128]))
fc = tc.layers.batch_norm(fc,
decay=0.9,
scale=True,
updates_collections=None,
is_training=self.is_training)
fc = tf.nn.relu(fc)
#fc = conv_cond_concat(fc,yb)
conv = tcl.convolution2d_transpose(
fc,
64, [4, 4], [2, 2],
weights_initializer=tf.random_normal_initializer(stddev=0.02),
weights_regularizer=tc.layers.l2_regularizer(2.5e-5),
activation_fn=tf.identity)
#(bs,16,16,64)
conv = tc.layers.batch_norm(conv,
decay=0.9,
scale=True,
updates_collections=None,
is_training=self.is_training)
conv = tf.nn.relu(conv)
for _ in range(3):
conv = tcl.convolution2d_transpose(
conv,
64, [4, 4], [2, 2],
weights_initializer=tf.random_normal_initializer(
stddev=0.02),
weights_regularizer=tc.layers.l2_regularizer(2.5e-5),
activation_fn=tf.identity)
conv = tc.layers.batch_norm(conv,
decay=0.9,
scale=True,
updates_collections=None,
is_training=self.is_training)
conv = tf.nn.relu(conv)
#(bs,128,128,64)
output = tcl.convolution2d_transpose(
conv,
3, [4, 4], [2, 2],
weights_initializer=tf.random_normal_initializer(stddev=0.02),
weights_regularizer=tc.layers.l2_regularizer(2.5e-5),
activation_fn=tf.nn.sigmoid)
output = tf.reshape(output, [bs, -1])
#(0,1) by tanh
return output
def human_pose_resnet(net, reuse=False, training=False):
"""
Architecture of Part Detector network, as was described in https://arxiv.org/abs/1609.01743
:param net: input tensor
:param reuse: whether reuse variables or not. Use False if the variables are initialized with init_model_variables
:param training: if the variables should be trainable. It has no effect if the 'reuse' param is set to True
:return: output tensor and dictionary of named endpoints
"""
def batch_normalization(input_net, act_f=None, scope=None):
return layers.batch_norm(input_net,
center=True,
scale=True,
epsilon=1e-5,
activation_fn=act_f,
is_training=training,
scope=scope)
def conv_2d(input_net,
num_outputs,
kernel_size,
stride=1,
padding_mod='SAME',
scope=None):
return layers.convolution2d(input_net,
num_outputs=num_outputs,
kernel_size=kernel_size,
stride=stride,
padding=padding_mod,
activation_fn=None,
scope=scope)
def padding(input_net, w, h):
return tf.pad(input_net, [[0, 0], [h, h], [w, w], [0, 0]], "CONSTANT")
def bottleneck(input_net, depth, depth_bottleneck, stride, i):
with tf.variable_scope('Bottleneck_%d' % i, reuse=reuse):
res_conv = stride > 1 or stride < 0
stride = abs(stride)
# Res connection
out_net = conv_2d(input_net,
num_outputs=depth_bottleneck,
kernel_size=1,
stride=1,
padding_mod='VALID',
scope='Conv_1')
out_net = batch_normalization(out_net, tf.nn.relu, 'BatchNorm_1')
out_net = padding(out_net, 1, 1)
out_net = conv_2d(out_net,
num_outputs=depth_bottleneck,
kernel_size=3,
stride=stride,
padding_mod='VALID',
scope='Conv_2')
out_net = batch_normalization(out_net, tf.nn.relu, 'BatchNorm_2')
out_net = conv_2d(out_net,
num_outputs=depth,
kernel_size=1,
stride=1,
padding_mod='VALID',
scope='Conv_3')
out_net = batch_normalization(out_net, scope='BatchNorm_3')
# Skip connection
if res_conv:
input_net = conv_2d(input_net,
num_outputs=depth,
kernel_size=1,
stride=stride,
padding_mod='VALID',
scope='Conv_skip')
input_net = batch_normalization(input_net,
scope='BatchNorm_skip')
out_net += input_net
out_net = tf.nn.relu(out_net)
return out_net
def repeat_bottleneck(input_net, all_params):
for i, (depth, depth_bottleneck, stride) in enumerate(all_params):
input_net = bottleneck(input_net, depth, depth_bottleneck, stride,
i)
return input_net
end_points = {}
with tf.variable_scope('HumanPoseResnet', reuse=reuse):
with tf.variable_scope('Block_0', reuse=reuse):
net = padding(net, 3, 3)
net = conv_2d(net,
num_outputs=64,
kernel_size=7,
stride=2,
padding_mod='VALID')
net = batch_normalization(net, tf.nn.relu)
net = padding(net, 1, 1)
net = layers.max_pool2d(net, 3, 2, padding='VALID')
with tf.variable_scope('Block_1', reuse=reuse):
net = repeat_bottleneck(net, [(256, 64, -1)] + [(256, 64, 1)] * 2)
with tf.variable_scope('Block_2', reuse=reuse):
net = repeat_bottleneck(net, [(512, 128, 2)] + [(512, 128, 1)] * 7)
with tf.variable_scope('Block_3', reuse=reuse):
net = repeat_bottleneck(net,
[(1024, 256, 2)] + [(1024, 256, 1)] * 35)
with tf.variable_scope('Block_4', reuse=reuse):
net = repeat_bottleneck(net,
[(2048, 512, -1)] + [(2048, 512, 1)] * 2)
end_points['resnet_end'] = net
with tf.variable_scope('Block_5', reuse=reuse):
net = conv_2d(net,
num_outputs=16,
kernel_size=1,
stride=1,
padding_mod='VALID')
end_points['features'] = net
net = layers.convolution2d_transpose(net,
num_outputs=16,
kernel_size=16,
stride=16,
activation_fn=None,
padding='VALID')
# net = tf.nn.sigmoid(net)
return net, end_points
def run_network(inpt,
string,
is_training,
use_batch_norm,
debug=False,
strip_batchnorm_from_last_layer=False):
maybe_fc_batch_norm = layers.batch_norm if use_batch_norm else None
maybe_conv_batch_norm = conv_batch_norm if use_batch_norm else None
if debug:
print('%s architecture' % (tf.get_variable_scope().name, ))
layer_idx = 0
out = inpt
layer_strs = string.split(',')
for i, layer in enumerate(layer_strs):
if i + 1 == len(layer_strs) and strip_batchnorm_from_last_layer:
maybe_fc_batch_norm = None
maybe_conv_batch_norm = None
if layer.startswith('conv:'):
nkernels,stride,num_outputs,nonlinearity_str =\
parse_conv_params(layer[len("conv:"):].split(":"))
nonlinearity = NONLINEARITY_NAME_TO_F[nonlinearity_str]
out = layers.convolution2d(
out,
num_outputs=num_outputs,
kernel_size=nkernels,
stride=stride,
normalizer_params={'is_training': is_training},
normalizer_fn=maybe_conv_batch_norm,
activation_fn=nonlinearity,
scope='layer_%d' % (layer_idx, ))
layer_idx += 1
if debug:
print(
"Convolution with nkernels=%d, stride=%d, num_outputs=%d followed by %s"
% (nkernels, stride, num_outputs, nonlinearity_str))
elif layer.startswith('deconv:'):
nkernels,stride,num_outputs,nonlinearity_str = \
parse_conv_params(layer[len("deconv:")].split(":"))
nonlinearity = NONLINEARITY_NAME_TO_F[nonlinearity_str]
out = layers.convolution2d_transpose(
out,
num_outputs=num_outputs,
kernel_size=nkernels,
stride=stride,
activation_fn=nonlinearity,
normalizer_fn=maybe_conv_batch_norm,
normalizer_params={'is_training': is_training},
scope='layer_%d' % (layer_idx, ))
layer_idx += 1
if debug:
print(
"Deconvolution with nkernels=%d, stride=%d, num_outputs=%d followed by %s"
% (nkernels, stride, num_outputs, nonlinearity_str))
elif layer.startswith('fc:'):
params = layer[len('fc:'):].split(':')
nonlinearity_str = 'relu'
if len(params) == 2:
params, nonlinearity_str = params[:-1], params[-1]
num_outputs = parse_math(params[0])
nonlinearity = NONLINEARITY_NAME_TO_F[nonlinearity_str]
out = layers.fully_connected(out,
num_outputs=num_outputs,
activation_fn=nonlinearity,
normalizer_fn=maybe_fc_batch_norm,
normalizer_params={
'is_training': is_training,
'updates_collections': None
},
scope='layer_%d' % (layer_idx, ))
layer_idx += 1
if debug:
print("Fully connected with num_outputs=%d followed by %s" %
(num_outputs, nonlinearity_str))
elif layer.startswith('reshape:'):
params = layer[len('reshape:'):].split(":")
dims = [parse_math(dim) for dim in params]
out = tf.reshape(out, [-1] + dims)
if debug:
print('Reshape to %r' % (dims, ))
else:
raise ValueError("Could not parse layer description: %r" %
(layer, ))
if debug:
print('')
return out
def run_network(inpt, string, is_training, debug=False, strip_batchnorm_from_last_layer=False):
maybe_fc_batch_norm = layers.batch_norm
maybe_conv_batch_norm = conv_batch_norm
if debug:
print ("%s architecture" % (tf.get_variable_scope().name,))
layer_idx = 0
out = inpt
layer_strs = string.split(",")
for i, layer in enumerate(layer_strs):
if i + 1 == len(layer_strs) and strip_batchnorm_from_last_layer:
maybe_fc_batch_norm = None
maybe_conv_batch_norm = None
if layer.startswith("conv:"):
nkernels, stride, num_outputs, nonlinearity_str = parse_conv_params(layer[len("conv:"):].split(":"))
nonlinearity = NONLINEARITY_NAME_TO_F[nonlinearity_str]
out = layers.convolution2d(
out,
num_outputs=num_outputs,
kernel_size=nkernels,
stride=stride,
normalizer_params={"is_training": is_training},
normalizer_fn=maybe_conv_batch_norm,
activation_fn=nonlinearity,
scope='layer_%d' % (layer_idx,)
)
layer_idx += 1
if debug:
print ("Convolution with nkernels=%d, stride=%d, num_outputs=%d followed by %s" %
(nkernels, stride, num_outputs, nonlinearity_str))
elif layer.startswith("deconv:"):
nkernels, stride, num_outputs, nonlinearity_str = parse_conv_params(layer[len("deconv:"):].split(":"))
nonlinearity = NONLINEARITY_NAME_TO_F[nonlinearity_str]
out = layers.convolution2d_transpose(
out,
num_outputs=num_outputs,
kernel_size=nkernels,
stride=stride,
activation_fn=nonlinearity,
normalizer_fn=maybe_conv_batch_norm,
normalizer_params={"is_training": is_training},
scope='layer_%d' % (layer_idx,)
)
layer_idx += 1
if debug:
print ("Deconvolution with nkernels=%d, stride=%d, num_outputs=%d followed by %s" %
(nkernels, stride, num_outputs, nonlinearity_str))
elif layer.startswith("fc:"):
params = layer[len("fc:"):].split(":")
nonlinearity_str = 'relu'
if len(params) == 2:
params, nonlinearity_str = params[:-1], params[-1]
num_outputs = parse_math(params[0])
nonlinearity = NONLINEARITY_NAME_TO_F[nonlinearity_str]
out = layers.fully_connected(
out,
num_outputs=num_outputs,
activation_fn=nonlinearity,
normalizer_fn=maybe_fc_batch_norm,
normalizer_params={"is_training": is_training, "updates_collections": None},
scope='layer_%d' % (layer_idx,)
)
layer_idx += 1
if debug:
print ("Fully connected with num_outputs=%d followed by %s" %
(num_outputs, nonlinearity_str))
elif layer.startswith("reshape:"):
params = layer[len("reshape:"):].split(":")
dims = [parse_math(dim) for dim in params]
out = tf.reshape(out, [-1] + dims)
if debug:
print("Reshape to %r" % (dims,))
else:
raise ValueError("Could not parse layer description: %r" % (layer,))
if debug:
print("")
return out