def fprop(self):
self.out = relu(self.pred.out)
def generator(images, options, reuse=False, name='gen'):
# down sampling
x = relu(instance_norm(conv2d(images, options.nf, ks=7, s=1, name='gen_ds_conv1'), 'in1_1'))
x = relu(instance_norm(conv2d(x, 2*options.nf, ks=4, s=2, name='gen_ds_conv2'), 'in1_2'))
x = relu(instance_norm(conv2d(x, 4*options.nf, ks=4, s=2, name='gen_ds_conv3'), 'in1_3'))
# bottleneck
x = relu(instance_norm(conv2d(x, 4*options.nf, ks=3, s=1, name='gen_bn_conv1'), 'in2_1'))
x = relu(instance_norm(conv2d(x, 4*options.nf, ks=3, s=1, name='gen_bn_conv2'), 'in2_2'))
x = relu(instance_norm(conv2d(x, 4*options.nf, ks=3, s=1, name='gen_bn_conv3'), 'in2_3'))
x = relu(instance_norm(conv2d(x, 4*options.nf, ks=3, s=1, name='gen_bn_conv4'), 'in2_4'))
x = relu(instance_norm(conv2d(x, 4*options.nf, ks=3, s=1, name='gen_bn_conv5'), 'in2_5'))
x = relu(instance_norm(conv2d(x, 4*options.nf, ks=3, s=1, name='gen_bn_conv6'), 'in2_6'))
# up sampling
x = relu(instance_norm(deconv2d(x, 2*options.nf, ks=4, s=2, name='gen_us_deconv1'), 'in3_1'))
x = relu(instance_norm(deconv2d(x, options.nf, ks=4, s=2, name='gen_us_deconv2'), 'in3_2'))
x = tanh(deconv2d(x, 3, ks=7, s=1, name='gen_us_dwconv3'))
return x
def __call__(self, D_input):
"""
Args:
input: batch_size x image_size x image_size x 3
Returns:
output: 4D tensor batch_size x out_size x out_size x 1 (default 1x5x5x1)
filled with 0.9 if real, 0.0 if fake
"""
with tf.variable_scope(self.name, reuse=self.reuse):
D_input = tf.nn.dropout(D_input, keep_prob=self.keep_prob)
with tf.variable_scope("conv0", reuse=self.reuse):
conv0 = tf.layers.conv2d(
inputs=D_input,
filters=self.ngf,
kernel_size=5,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv0')
norm0 = ops._norm(conv0, self.is_training, self.norm)
relu0 = ops.relu(norm0)
with tf.variable_scope("conv1", reuse=self.reuse):
conv1 = tf.layers.conv2d(
inputs=relu0,
filters=self.ngf,
kernel_size=5,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv1')
norm1 = ops._norm(conv1, self.is_training, self.norm)
relu1 = ops.relu(norm1)
with tf.variable_scope("conv2", reuse=self.reuse):
conv2 = tf.layers.conv2d(
inputs=relu1,
filters=2 * self.ngf,
kernel_size=3,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv2')
norm2 = ops._norm(conv2, self.is_training, self.norm)
relu2 = ops.relu(norm2)
with tf.variable_scope("conv3", reuse=self.reuse):
conv3 = tf.layers.conv2d(
inputs=relu2,
filters=2 * self.ngf,
kernel_size=3,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv3')
norm3 = ops._norm(conv3, self.is_training, self.norm)
relu3 = ops.relu(norm3)
with tf.variable_scope("conv4_1", reuse=self.reuse):
conv4_1 = tf.layers.conv2d(
inputs=relu3,
filters=self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv4_1')
norm4_1 = ops._norm(conv4_1, self.is_training, self.norm)
relu4_1 = ops.relu(norm4_1)
with tf.variable_scope("conv5_1", reuse=self.reuse):
output = tf.layers.conv2d(
inputs=relu4_1,
filters=self.output_channl,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv5_1')
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=self.name)
return output
def __call__(self, DC_input):
"""
Args:
input: batch_size x width x height x N
Returns:
output: same size as input
"""
with tf.variable_scope(self.name, reuse=self.reuse):
with tf.variable_scope("dense0", reuse=self.reuse):
dense0 = tf.layers.dense(DC_input,
units=self.units,
name="dense0")
with tf.variable_scope("dense1", reuse=self.reuse):
dense1 = tf.layers.dense(dense0,
units=self.units,
name="dense1")
dense1 = tf.reshape(
dense1,
shape=[DC_input.get_shape().as_list()[0], 8, 8, -1])
# 6,5
with tf.variable_scope("conv0_1", reuse=self.reuse):
conv0_1 = tf.layers.conv2d(
inputs=dense1,
filters=8 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv0_1')
norm0_1 = ops.norm(conv0_1)
relu0_1 = ops.relu(norm0_1)
# 6,5
with tf.variable_scope("deconv0_1_r", reuse=self.reuse):
resize0_1 = ops.uk_resize(relu0_1,
reuse=self.reuse,
name='resize')
deconv0_1_r = tf.layers.conv2d(
inputs=resize0_1,
filters=4 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='deconv0_1_r')
deconv0_1norm1_r = ops.norm(deconv0_1_r)
deconv0_1_relu1 = ops.relu(deconv0_1norm1_r)
# 12,9
with tf.variable_scope("conv0_2", reuse=self.reuse):
conv0_2 = tf.layers.conv2d(
inputs=deconv0_1_relu1,
filters=4 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv0_2')
norm0_2 = ops.norm(conv0_2)
relu0_2 = ops.relu(norm0_2)
# 12,9
with tf.variable_scope("deconv0_2_r", reuse=self.reuse):
resize0_2 = ops.uk_resize(relu0_2,
reuse=self.reuse,
name='resize')
deconv0_2_r = tf.layers.conv2d(
inputs=resize0_2,
filters=4 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='deconv0_2_r')
deconv0_2norm1_r = ops.norm(deconv0_2_r)
deconv0_2_relu1 = ops.relu(deconv0_2norm1_r)
# 23, 18
with tf.variable_scope("conv0_3", reuse=self.reuse):
conv0_3 = tf.layers.conv2d(
inputs=deconv0_2_relu1,
filters=4 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv0_3')
norm0_3 = ops.norm(conv0_3)
relu0_3 = ops.relu(norm0_3)
# 23, 18
with tf.variable_scope("deconv0_3_r", reuse=self.reuse):
resize0_3 = ops.uk_resize(relu0_3,
reuse=self.reuse,
name='resize')
deconv0_3_r = tf.layers.conv2d(
inputs=resize0_3,
filters=2 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='deconv0_3_r')
deconv0_3norm1_r = ops.norm(deconv0_3_r)
add0 = ops.relu(deconv0_3norm1_r)
# 46, 36
with tf.variable_scope("conv1", reuse=self.reuse):
conv1 = tf.layers.conv2d(
inputs=add0,
filters=2 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv1')
norm1 = ops.norm(conv1)
relu1 = ops.relu(norm1)
with tf.variable_scope("deconv1_r", reuse=self.reuse):
resize1 = ops.uk_resize(relu1, reuse=self.reuse, name='resize')
deconv1_r = tf.layers.conv2d(
inputs=resize1,
filters=2 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='deconv1_r')
deconv1norm1_r = ops.norm(deconv1_r)
add1 = ops.relu(deconv1norm1_r)
with tf.variable_scope("add1_conv1", reuse=self.reuse):
add1_conv1 = tf.layers.conv2d(
inputs=add1,
filters=2 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='add1_conv1')
add1norm1 = ops.norm(add1_conv1)
add1_relu1 = ops.relu(add1norm1)
with tf.variable_scope("deconv2_r", reuse=self.reuse):
resize2 = ops.uk_resize(add1_relu1,
reuse=self.reuse,
name='resize')
deconv2_r = tf.layers.conv2d(
inputs=resize2,
filters=self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='deconv2_r')
deconv2norm1_r = ops.norm(deconv2_r)
add2 = ops.relu(deconv2norm1_r)
with tf.variable_scope("add2_conv1", reuse=self.reuse):
add2_conv1 = tf.layers.conv2d(
inputs=add2,
filters=self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='add2_conv1')
add2norm1 = ops.norm(add2_conv1)
add2_relu1 = ops.relu(add2norm1)
with tf.variable_scope("conv2", reuse=self.reuse):
resize3 = ops.uk_resize(add2_relu1,
reuse=self.reuse,
name='resize')
conv2 = tf.layers.conv2d(
inputs=resize3,
filters=self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv2')
norm2 = ops.norm(conv2)
relu2 = ops.relu(norm2)
with tf.variable_scope("add3_conv1", reuse=self.reuse):
add3_conv1 = tf.layers.conv2d(
inputs=relu2,
filters=self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='add3_conv1')
add3norm1 = ops.norm(add3_conv1)
add3_relu1 = ops.relu(add3norm1)
with tf.variable_scope("lastconv", reuse=self.reuse):
lastconv = tf.layers.conv2d(
inputs=add3_relu1,
filters=self.output_channl,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='lastconv')
lastnorm = ops.norm(lastconv)
output = tf.nn.sigmoid(lastnorm)
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=self.name)
return output
def __call__(self, EC_input):
"""
Args:
input: batch_size x width x height x 3
Returns:
output: same size as input
"""
with tf.variable_scope(self.name):
EC_input = tf.nn.dropout(EC_input, keep_prob=self.keep_prob)
with tf.variable_scope("conv1", reuse=self.reuse):
conv1 = tf.layers.conv2d(
inputs=EC_input,
filters=self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
stddev=0.01, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv1')
# norm1 = ops._norm(conv1, self.is_training, self.norm)
relu1 = ops.relu(conv1)
with tf.variable_scope("conv2", reuse=self.reuse):
conv2 = tf.layers.conv2d(
inputs=relu1,
filters=self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
stddev=0.01, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv2')
# norm2 = ops._norm(conv2, self.is_training, self.norm)
relu2 = ops.relu(conv2)
# pool1
with tf.variable_scope("conv3", reuse=self.reuse):
conv3 = tf.layers.conv2d(
inputs=relu2,
filters=2 * self.ngf,
kernel_size=3,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
stddev=0.01, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv3')
# norm3 = ops._norm(conv3, self.is_training, self.norm)
relu3 = ops.relu(conv3)
with tf.variable_scope("conv4", reuse=self.reuse):
conv4 = tf.layers.conv2d(
inputs=relu3,
filters=2 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
stddev=0.01, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv4')
# norm4 = ops._norm(conv4, self.is_training, self.norm)
relu4 = ops.relu(conv4)
with tf.variable_scope("conv5", reuse=self.reuse):
conv5 = tf.layers.conv2d(
inputs=relu4,
filters=4 * self.ngf,
kernel_size=3,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
stddev=0.01, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv5')
# norm5 = ops._norm(conv5, self.is_training, self.norm)
relu5 = tf.nn.relu(conv5)
"""
decoder
"""
with tf.variable_scope("conv6", reuse=self.reuse):
conv6 = tf.layers.conv2d(
inputs=relu5,
filters=4 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
stddev=0.01, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv6')
# add1_norm1 = ops._norm(add1_conv1, self.is_training, self.norm)
relu6 = ops.relu(conv6)
with tf.variable_scope("deconv7_r", reuse=self.reuse):
resize1 = ops.uk_resize(relu6,
reuse=self.reuse,
name='resize1')
deconv7_r = tf.layers.conv2d(
inputs=resize1,
filters=2 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
stddev=0.01, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='deconv7_r')
# deconv1_norm1_r = ops._norm(deconv1_r, self.is_training, self.norm)
deconv7_r += relu4
deconv7 = ops.relu(deconv7_r)
with tf.variable_scope("conv8", reuse=self.reuse):
conv8 = tf.layers.conv2d(
inputs=deconv7,
filters=2 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
stddev=0.01, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv8')
# add1_norm2 = ops._norm(add1_conv2, self.is_training, self.norm)
relu8 = ops.relu(conv8)
with tf.variable_scope("deconv9_r", reuse=self.reuse):
resize2 = ops.uk_resize(relu8,
reuse=self.reuse,
name='resize2')
deconv9_r = tf.layers.conv2d(
inputs=resize2,
filters=self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
stddev=0.01, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='deconv9_r')
# deconv2_norm1_r = ops._norm(deconv2_r, self.is_training, self.norm)
deconv9_r += relu2
deconv9 = ops.relu(deconv9_r)
with tf.variable_scope("conv10", reuse=self.reuse):
conv10 = tf.layers.conv2d(
inputs=deconv9,
filters=self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
stddev=0.01, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv10')
# add2_norm1 = ops._norm(add2_conv1, self.is_training, self.norm)
relu10 = ops.relu(conv10)
with tf.variable_scope("lastconv", reuse=self.reuse):
lastconv = tf.layers.conv2d(
inputs=relu10,
filters=self.output_channl,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
stddev=0.01, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='lastconv')
output = tf.nn.sigmoid(lastconv)
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=self.name)
return output
def __call__(self, EC_input):
"""
Args:
input: batch_size x width x height x 3
Returns:
output: same size as input
"""
with tf.variable_scope(self.name):
EC_input = tf.nn.dropout(EC_input, keep_prob=self.keep_prob)
with tf.variable_scope("conv0", reuse=self.reuse):
conv0 = tf.layers.conv2d(
inputs=EC_input,
filters=self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / 9.0, stddev=0.000001, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv0')
norm0 = ops._norm(conv0, self.is_training, self.norm)
relu0 = ops.relu(norm0)
# pool1
with tf.variable_scope("conv1", reuse=self.reuse):
conv1 = tf.layers.conv2d(
inputs=relu0,
filters=2 * self.ngf,
kernel_size=3,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * self.ngf),
stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv1')
norm1 = ops._norm(conv1, self.is_training, self.norm)
relu1 = ops.relu(norm1)
# w/2,h/2
with tf.variable_scope("conv2", reuse=self.reuse):
conv2 = tf.layers.conv2d(
inputs=relu1,
filters=2 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 2 * self.ngf),
stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv2')
norm2 = ops._norm(conv2, self.is_training, self.norm)
relu2 = ops.relu(norm2)
# pool2
with tf.variable_scope("conv3", reuse=self.reuse):
conv3 = tf.layers.conv2d(
inputs=relu2,
filters=4 * self.ngf,
kernel_size=3,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 2 * self.ngf),
stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv3')
norm3 = ops._norm(conv3, self.is_training, self.norm)
relu3 = ops.relu(norm3)
# w/4,h/4
with tf.variable_scope("conv4", reuse=self.reuse):
conv4 = tf.layers.conv2d(
inputs=relu3,
filters=4 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 4 * self.ngf),
stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv4')
norm4 = ops._norm(conv4, self.is_training, self.norm)
relu4 = ops.relu(norm4)
with tf.variable_scope("conv5", reuse=self.reuse):
conv5 = tf.layers.conv2d(
inputs=relu4,
filters=4 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 4 * self.ngf),
stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv5')
norm5 = ops._norm(conv5, self.is_training, self.norm)
relu5 = tf.nn.relu(norm5)
# pool3
with tf.variable_scope("conv6", reuse=self.reuse):
conv6 = tf.layers.conv2d(
inputs=relu5,
filters=6 * self.ngf,
kernel_size=3,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 4 * self.ngf),
stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv6')
norm6 = ops._norm(conv6, self.is_training, self.norm)
relu6 = ops.relu(norm6)
# w/8,h/8 18 23
with tf.variable_scope("conv7", reuse=self.reuse):
conv7 = tf.layers.conv2d(
inputs=relu6,
filters=6 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 6 * self.ngf),
stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv7')
norm7 = ops._norm(conv7, self.is_training, self.norm)
relu7 = ops.relu(norm7)
# pool4
with tf.variable_scope("conv8", reuse=self.reuse):
conv8 = tf.layers.conv2d(
inputs=relu7,
filters=8 * self.ngf,
kernel_size=3,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 6 * self.ngf),
stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv8')
norm8 = ops._norm(conv8, self.is_training, self.norm)
relu8 = tf.nn.relu(norm8)
# 9 12
with tf.variable_scope("conv9", reuse=self.reuse):
conv9 = tf.layers.conv2d(
inputs=relu8,
filters=8 * self.ngf,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 8 * self.ngf),
stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv9')
norm9 = ops._norm(conv9, self.is_training, self.norm)
relu9 = tf.nn.relu(norm9)
# pool5
with tf.variable_scope("conv10", reuse=self.reuse):
conv10 = tf.layers.conv2d(
inputs=relu9,
filters=12 * self.ngf,
kernel_size=3,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 8 * self.ngf),
stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv10')
norm10 = ops._norm(conv10, self.is_training, self.norm)
relu10 = tf.nn.relu(norm10)
conv_output = tf.layers.flatten(relu10)
# 5 6
with tf.variable_scope("dense1", reuse=self.reuse):
mean = tf.layers.dense(conv_output, units=4096, name="dense1")
with tf.variable_scope("dense2", reuse=self.reuse):
log_var = tf.layers.dense(conv_output,
units=4096,
name="dense2")
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=self.name)
return mean, log_var
def __call__(self, DC_input):
"""
Args:
input: batch_size x width x height x N
Returns:
output: same size as input
"""
with tf.variable_scope(self.name, reuse=self.reuse):
DC_input = tf.nn.dropout(DC_input, keep_prob=self.keep_prob)
with tf.variable_scope("conv1", reuse=self.reuse):
conv1 = tf.layers.conv2d(inputs=DC_input, filters=8 * self.ngf, kernel_size=3, strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 8 * self.ngf), stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0), name='conv1')
norm1 = ops.norm(conv1)
relu1 = ops.relu(norm1)
with tf.variable_scope("deconv1_r", reuse=self.reuse):
resize1 = ops.uk_resize(relu1, reuse=self.reuse, name='resize1')
deconv1_r = tf.layers.conv2d(inputs=resize1, filters=4 * self.ngf, kernel_size=3, strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 8 * self.ngf), stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='deconv1_r')
deconv1_norm1_r = ops.norm(deconv1_r)
add1 = ops.relu(deconv1_norm1_r)
with tf.variable_scope("add1_conv1", reuse=self.reuse):
add1_conv1 = tf.layers.conv2d(inputs=add1, filters=4 * self.ngf, kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 4 * self.ngf), stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='add1_conv1')
add1_norm1 = ops.norm(add1_conv1)
add1_relu1 = ops.relu(add1_norm1)
with tf.variable_scope("add1_conv2", reuse=self.reuse):
add1_conv2 = tf.layers.conv2d(inputs=add1_relu1, filters=4 * self.ngf, kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 4 * self.ngf), stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='add1_conv2')
add1_norm2 = ops.norm(add1_conv2)
add1_relu2 = ops.relu(add1_norm2)
with tf.variable_scope("deconv2_r", reuse=self.reuse):
resize2 = ops.uk_resize(add1_relu2, reuse=self.reuse, name='resize1')
deconv2_r = tf.layers.conv2d(inputs=resize2, filters=2 * self.ngf, kernel_size=3, strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 4 * self.ngf), stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='deconv2_r')
deconv2_norm1_r = ops.norm(deconv2_r)
add2 = ops.relu(deconv2_norm1_r)
with tf.variable_scope("add2_conv1", reuse=self.reuse):
add2_conv1 = tf.layers.conv2d(inputs=add2, filters=2 * self.ngf, kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 2 * self.ngf), stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='add2_conv1')
add2_norm1 = ops.norm(add2_conv1)
add2_relu1 = ops.relu(add2_norm1)
with tf.variable_scope("add2_conv2", reuse=self.reuse):
add2_conv = tf.layers.conv2d(inputs=add2_relu1, filters=2 * self.ngf, kernel_size=3, strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 2 * self.ngf), stddev=0.000001,
dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='add2_conv2')
add2_norm2 = ops.norm(add2_conv)
add2_relu2 = ops.relu(add2_norm2)
with tf.variable_scope("conv2", reuse=self.reuse):
conv2 = tf.layers.conv2d(inputs=add2_relu2, filters=self.ngf, kernel_size=3, strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 2 * self.ngf), stddev=0.000001, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0), name='conv2')
norm2 = ops.norm(conv2)
relu2 = ops.relu(norm2)
with tf.variable_scope("lastconv", reuse=self.reuse):
lastconv = tf.layers.conv2d(inputs=relu2, filters=self.output_channl, kernel_size=3, strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * self.ngf), stddev=0.000001, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0), name='lastconv')
lastnorm = ops.norm(lastconv)
output = tf.nn.sigmoid(lastnorm)
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.name)
return output
def add_generator(self, name_scope='SoundNet'):
with tf.variable_scope(name_scope) as scope:
self.layers = {}
# Stream one: conv1 ~ conv7
self.layers[1] = conv2d(self.sound_input_placeholder,
1,
16,
k_h=64,
d_h=2,
p_h=32,
name_scope='conv1')
self.layers[2] = batch_norm(self.layers[1],
16,
self.config['eps'],
name_scope='conv1')
self.layers[3] = relu(self.layers[2], name_scope='conv1')
self.layers[4] = maxpool(self.layers[3],
k_h=8,
d_h=8,
name_scope='conv1')
self.layers[5] = conv2d(self.layers[4],
16,
32,
k_h=32,
d_h=2,
p_h=16,
name_scope='conv2')
self.layers[6] = batch_norm(self.layers[5],
32,
self.config['eps'],
name_scope='conv2')
self.layers[7] = relu(self.layers[6], name_scope='conv2')
self.layers[8] = maxpool(self.layers[7],
k_h=8,
d_h=8,
name_scope='conv2')
self.layers[9] = conv2d(self.layers[8],
32,
64,
k_h=16,
d_h=2,
p_h=8,
name_scope='conv3')
self.layers[10] = batch_norm(self.layers[9],
64,
self.config['eps'],
name_scope='conv3')
self.layers[11] = relu(self.layers[10], name_scope='conv3')
self.layers[12] = conv2d(self.layers[11],
64,
128,
k_h=8,
d_h=2,
p_h=4,
name_scope='conv4')
self.layers[13] = batch_norm(self.layers[12],
128,
self.config['eps'],
name_scope='conv4')
self.layers[14] = relu(self.layers[13], name_scope='conv4')
self.layers[15] = conv2d(self.layers[14],
128,
256,
k_h=4,
d_h=2,
p_h=2,
name_scope='conv5')
self.layers[16] = batch_norm(self.layers[15],
256,
self.config['eps'],
name_scope='conv5')
self.layers[17] = relu(self.layers[16], name_scope='conv5')
self.layers[18] = maxpool(self.layers[17],
k_h=4,
d_h=4,
name_scope='conv5')
self.layers[19] = conv2d(self.layers[18],
256,
512,
k_h=4,
d_h=2,
p_h=2,
name_scope='conv6')
self.layers[20] = batch_norm(self.layers[19],
512,
self.config['eps'],
name_scope='conv6')
self.layers[21] = relu(self.layers[20], name_scope='conv6')
self.layers[22] = conv2d(self.layers[21],
512,
1024,
k_h=4,
d_h=2,
p_h=2,
name_scope='conv7')
self.layers[23] = batch_norm(self.layers[22],
1024,
self.config['eps'],
name_scope='conv7')
self.layers[24] = relu(self.layers[23], name_scope='conv7')
# Split one: conv8, conv8_2
# NOTE: here we use a padding of 2 to skip an unknown error
# https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/framework/common_shape_fns.cc#L45
self.layers[25] = conv2d(self.layers[24],
1024,
1000,
k_h=8,
d_h=2,
p_h=2,
name_scope='conv8')
self.layers[26] = conv2d(self.layers[24],
1024,
401,
k_h=8,
d_h=2,
p_h=2,
name_scope='conv8_2')
def alexnet(image):
net_data = np.load("./perceptual_models/alexnet/bvlc_alexnet.npy").item()
k_h = 11
k_w = 11
c_o = 96
s_h = 4
s_w = 4
conv1W = tf.Variable(net_data["conv1"][0])
conv1b = tf.Variable(net_data["conv1"][1])
conv1 = relu(
conv(
image,
conv1W,
conv1b,
k_h,
k_w,
c_o,
s_h,
s_w,
padding="SAME",
group=1))
radius = 2
alpha = 2e-05
beta = 0.75
bias = 1.0
lrn1 = tf.nn.local_response_normalization(
conv1, depth_radius=radius, alpha=alpha, beta=beta, bias=bias)
k_h = 3
k_w = 3
s_h = 2
s_w = 2
padding = 'VALID'
maxpool1 = tf.nn.max_pool(
lrn1, ksize=[1, k_h, k_w, 1], strides=[1, s_h, s_w, 1], padding=padding)
k_h = 5
k_w = 5
c_o = 256
s_h = 1
s_w = 1
group = 2
conv2W = tf.Variable(net_data["conv2"][0])
conv2b = tf.Variable(net_data["conv2"][1])
conv2 = relu(
conv(
maxpool1,
conv2W,
conv2b,
k_h,
k_w,
c_o,
s_h,
s_w,
padding="SAME",
group=group))
radius = 2
alpha = 2e-05
beta = 0.75
bias = 1.0
lrn2 = tf.nn.local_response_normalization(
conv2, depth_radius=radius, alpha=alpha, beta=beta, bias=bias)
k_h = 3
k_w = 3
s_h = 2
s_w = 2
padding = 'VALID'
maxpool2 = tf.nn.max_pool(
lrn2, ksize=[1, k_h, k_w, 1], strides=[1, s_h, s_w, 1], padding=padding)
k_h = 3
k_w = 3
c_o = 384
s_h = 1
s_w = 1
group = 1
conv3W = tf.Variable(net_data["conv3"][0])
conv3b = tf.Variable(net_data["conv3"][1])
conv3 = relu(
conv(
maxpool2,
conv3W,
conv3b,
k_h,
k_w,
c_o,
s_h,
s_w,
padding="SAME",
group=group))
k_h = 3
k_w = 3
c_o = 384
s_h = 1
s_w = 1
group = 2
conv4W = tf.Variable(net_data["conv4"][0])
conv4b = tf.Variable(net_data["conv4"][1])
conv4 = relu(
conv(
conv3,
conv4W,
conv4b,
k_h,
k_w,
c_o,
s_h,
s_w,
padding="SAME",
group=group))
k_h = 3
k_w = 3
c_o = 256
s_h = 1
s_w = 1
group = 2
conv5W = tf.Variable(net_data["conv5"][0])
conv5b = tf.Variable(net_data["conv5"][1])
conv5 = relu(
conv(
conv4,
conv5W,
conv5b,
k_h,
k_w,
c_o,
s_h,
s_w,
padding="SAME",
group=group))
return conv5
def __call__(self, EC_input):
"""
Args:
input: batch_size x width x height x 3
Returns:
output: same size as input
"""
with tf.variable_scope(self.name):
EC_input = tf.nn.dropout(EC_input, keep_prob=self.keep_prob)
with tf.variable_scope("conv1", reuse=self.reuse):
conv1 = tf.layers.conv2d(inputs=EC_input, filters=self.ngf, kernel_size=3, strides=1, padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 1), stddev=0.000001, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0), name='conv1')
norm1 = ops._norm(conv1, self.is_training, self.norm)
relu1 = ops.relu(norm1)
with tf.variable_scope("conv2", reuse=self.reuse):
conv2 = tf.layers.conv2d(inputs=relu1, filters=self.ngf, kernel_size=3, strides=1, padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * self.ngf), stddev=0.000001, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0), name='conv2')
norm2 = ops._norm(conv2, self.is_training, self.norm)
relu2 = ops.relu(norm2)
# pool1
with tf.variable_scope("conv3", reuse=self.reuse):
conv3 = tf.layers.conv2d(inputs=relu2, filters=2 * self.ngf, kernel_size=3,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * self.ngf), stddev=0.000001, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0), name='conv3')
norm3 = ops._norm(conv3, self.is_training, self.norm)
relu3 = ops.relu(norm3)
# w/2,h/2
with tf.variable_scope("conv4", reuse=self.reuse):
conv4 = tf.layers.conv2d(inputs=relu3, filters=4 * self.ngf, kernel_size=3, strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 2 * self.ngf), stddev=0.000001, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0), name='conv4')
norm4 = ops._norm(conv4, self.is_training, self.norm)
relu4 = ops.relu(norm4)
with tf.variable_scope("conv5", reuse=self.reuse):
conv5 = tf.layers.conv2d(inputs=relu4, filters=4 * self.ngf, kernel_size=3, strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 4 * self.ngf), stddev=0.000001, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0), name='conv5')
norm5 = ops._norm(conv5, self.is_training, self.norm)
relu5 = tf.nn.relu(norm5)
# pool2
with tf.variable_scope("conv6", reuse=self.reuse):
conv6 = tf.layers.conv2d(inputs=relu5, filters=8 * self.ngf, kernel_size=3,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 4 * self.ngf), stddev=0.000001, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0), name='conv6')
norm6 = ops._norm(conv6, self.is_training, self.norm)
relu6 = ops.relu(norm6)
# w/4,h/4
with tf.variable_scope("conv7", reuse=self.reuse):
conv7 = tf.layers.conv2d(inputs=relu6, filters=8 * self.ngf, kernel_size=3, strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=1.0 / (9.0 * 8 * self.ngf), stddev=0.000001, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0), name='conv7')
norm7 = ops._norm(conv7, self.is_training, self.norm)
output = ops.relu(norm7)
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.name)
return output
def add_generator(self, name_scope='SoundNet'):
with tf.variable_scope(name_scope) as scope:
self.layers = {}
# Stream one: conv1 ~ conv7
self.layers[1] = conv2d(self.sound_input_placeholder,
1,
16,
k_h=64,
d_h=2,
p_h=32,
name_scope='conv1')
self.layers[2] = batch_norm(self.layers[1],
16,
self.config['eps'],
name_scope='conv1')
self.layers[3] = relu(self.layers[2], name_scope='conv1')
self.layers[4] = maxpool(self.layers[3],
k_h=8,
d_h=8,
name_scope='conv1')
self.layers[5] = conv2d(self.layers[4],
16,
32,
k_h=32,
d_h=2,
p_h=16,
name_scope='conv2')
self.layers[6] = batch_norm(self.layers[5],
32,
self.config['eps'],
name_scope='conv2')
self.layers[7] = relu(self.layers[6], name_scope='conv2')
self.layers[8] = maxpool(self.layers[7],
k_h=8,
d_h=8,
name_scope='conv2')
self.layers[9] = conv2d(self.layers[8],
32,
64,
k_h=16,
d_h=2,
p_h=8,
name_scope='conv3')
self.layers[10] = batch_norm(self.layers[9],
64,
self.config['eps'],
name_scope='conv3')
self.layers[11] = relu(self.layers[10], name_scope='conv3')
self.layers[12] = conv2d(self.layers[11],
64,
128,
k_h=8,
d_h=2,
p_h=4,
name_scope='conv4')
self.layers[13] = batch_norm(self.layers[12],
128,
self.config['eps'],
name_scope='conv4')
self.layers[14] = relu(self.layers[13], name_scope='conv4')
self.layers[15] = conv2d(self.layers[14],
128,
256,
k_h=4,
d_h=2,
p_h=2,
name_scope='conv5')
self.layers[16] = batch_norm(self.layers[15],
256,
self.config['eps'],
name_scope='conv5')
self.layers[17] = relu(self.layers[16], name_scope='conv5')
self.layers[18] = maxpool(self.layers[17],
k_h=4,
d_h=4,
name_scope='conv5')
self.layers[19] = conv2d(self.layers[18],
256,
512,
k_h=4,
d_h=2,
p_h=2,
name_scope='conv6')
self.layers[20] = batch_norm(self.layers[19],
512,
self.config['eps'],
name_scope='conv6')
self.layers[21] = relu(self.layers[20], name_scope='conv6')
self.layers[22] = conv2d(self.layers[21],
512,
1024,
k_h=4,
d_h=2,
p_h=2,
name_scope='conv7')
self.layers[23] = batch_norm(self.layers[22],
1024,
self.config['eps'],
name_scope='conv7')
self.layers[24] = relu(self.layers[23], name_scope='conv7')
# Split one: conv8, conv8_2
self.layers[25] = conv2d(self.layers[24],
1024,
1000,
k_h=8,
d_h=2,
name_scope='conv8')
self.layers[26] = conv2d(self.layers[24],
1024,
401,
k_h=8,
d_h=2,
name_scope='conv8_2')
def __call__(self, D_input, class_vt, location_vt):
"""
Args:
input: batch_size x image_size x image_size x 3
Returns:
output: 4D tensor batch_size x out_size x out_size x 1 (default 1x5x5x1)
filled with 0.9 if real, 0.0 if fake
"""
with tf.variable_scope(self.name, reuse=self.reuse):
D_input = tf.nn.dropout(D_input, keep_prob=self.keep_prob)
with tf.variable_scope("class_vt_dense0", reuse=self.reuse):
class_vt = tf.layers.flatten(class_vt)
dense0 = tf.layers.dense(class_vt, units=1024, name="dense0")
dense0 = tf.reshape(dense0, shape=[-1, 32, 32, 1])
resize0 = tf.image.resize_images(dense0, [512, 512], method=1)
with tf.variable_scope("location_vt_dense0", reuse=self.reuse):
location_vt = tf.layers.flatten(location_vt)
dense1 = tf.layers.dense(location_vt,
units=1024,
name="dense1")
dense1 = tf.reshape(dense1, shape=[-1, 32, 32, 1])
resize1 = tf.image.resize_images(dense1, [512, 512], method=1)
with tf.variable_scope("concat0", reuse=self.reuse):
concat0 = tf.reshape(tf.concat([D_input, resize0, resize1],
axis=-1),
shape=[-1, 512, 512, 5])
with tf.variable_scope("conv0", reuse=self.reuse):
conv0 = tf.layers.conv2d(
inputs=concat0,
filters=self.ngf,
kernel_size=5,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv0')
norm0 = ops._norm(conv0, self.is_training, self.norm)
relu0 = ops.relu(norm0)
with tf.variable_scope("conv1", reuse=self.reuse):
conv1 = tf.layers.conv2d(
inputs=relu0,
filters=self.ngf,
kernel_size=5,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv1')
norm1 = ops._norm(conv1, self.is_training, self.norm)
relu1 = ops.relu(norm1)
with tf.variable_scope("conv2", reuse=self.reuse):
conv2 = tf.layers.conv2d(
inputs=relu1,
filters=2 * self.ngf,
kernel_size=3,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv2')
norm2 = ops._norm(conv2, self.is_training, self.norm)
relu2 = ops.relu(norm2)
with tf.variable_scope("conv3", reuse=self.reuse):
conv3 = tf.layers.conv2d(
inputs=relu2,
filters=2 * self.ngf,
kernel_size=3,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv3')
norm3 = ops._norm(conv3, self.is_training, self.norm)
relu3 = ops.relu(norm3)
with tf.variable_scope("conv4", reuse=self.reuse):
conv4_1 = tf.layers.conv2d(
inputs=relu3,
filters=self.ngf,
kernel_size=3,
strides=self.slice_stride,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv4')
norm4_1 = ops._norm(conv4_1, self.is_training, self.norm)
relu4_1 = ops.relu(norm4_1)
with tf.variable_scope("conv5", reuse=self.reuse):
output = tf.layers.conv2d(
inputs=relu4_1,
filters=self.output_channl,
kernel_size=3,
strides=1,
padding="SAME",
activation=None,
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.02, dtype=tf.float32),
bias_initializer=tf.constant_initializer(0.0),
name='conv5')
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=self.name)
return output