def __call__(self, 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):
# convolution layers
C64 = ops.Ck(input, 64, reuse=self.reuse, norm=None,
is_training=self.is_training, name='C64') # (?, w/2, h/2, 64)
C128 = ops.Ck(C64, 128, reuse=self.reuse, norm=self.norm,
is_training=self.is_training, name='C128') # (?, w/4, h/4, 128)
C256 = ops.Ck(C128, 256, reuse=self.reuse, norm=self.norm,
is_training=self.is_training, name='C256') # (?, w/8, h/8, 256)
C512 = ops.Ck(C256, 512,reuse=self.reuse, norm=self.norm,
is_training=self.is_training, name='C512') # (?, w/16, h/16, 512)
# apply a convolution to produce a 1 dimensional output (1 channel?)
# use_sigmoid = False if use_lsgan = True
output = ops.last_conv(C512, reuse=self.reuse,
use_sigmoid=self.use_sigmoid, name='output') # (?, w/16, h/16, 1)
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.name)
return output
def __call__(self, 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):
# convolution layers
C64 = ops.Ck(input, 64, reuse=self.reuse, norm=None,
is_training=self.is_training, name='C64') # (b,w,h,3)----(4,4,3,64),s=2-------->(b,w/2,h/2,64)
C128 = ops.Ck(C64, 128, reuse=self.reuse, norm=self.norm,
is_training=self.is_training, name='C128') # (b,w/2,h/2,64)-----(4,4,64,128),s=2------->(b,w/4,h/4,128)
C256 = ops.Ck(C128, 256, reuse=self.reuse, norm=self.norm,
is_training=self.is_training, name='C256') # (b,w/4,h/4,128)-----(4,4,128,256),s=2------->(b,w/8,h/8,256)
C512 = ops.Ck(C256, 512,reuse=self.reuse, norm=self.norm,
is_training=self.is_training, name='C512') # (b,w/8,h/8,256)-----(4,4,256,512),s=2------->(b,w/16,h/16,512)
# apply a convolution to produce a 1 dimensional output (1 channel?)
# use_sigmoid = False if use_lsgan = True
output = ops.last_conv(C512, reuse=self.reuse,
use_sigmoid=self.use_sigmoid, name='output') # (b,w/16,h/16,512)-----(4,4,512,1),s=1------->(b,w/16,h/16,1)=(1,16,16,1)
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.name)
return output
def __init__(self,
scope: str = "Discriminator",
reg: float = 0.0005,
norm: str = "instance"):
super(Discriminator, self).__init__(name=scope)
self.ck1 = ops.Ck(scope="C64", k=64, reg=reg, norm=norm)
self.ck2 = ops.Ck(scope="C128", k=128, reg=reg, norm=norm)
self.ck3 = ops.Ck(scope="C256", k=256, reg=reg, norm=norm)
self.ck4 = ops.Ck(scope="C512", k=512, reg=reg, norm=norm)
self.last_conv = ops.last_conv(scope="output", reg=reg)
def __call__(self, 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):
batch_size = input.get_shape().as_list()[0]
patch = tf.random_crop(
input, [batch_size, self.patch_size, self.patch_size, 3
]) # (?, 70, 70, 70)
# convolution layers
C64 = ops.Ck(patch,
64,
reuse=self.reuse,
norm=None,
is_training=self.is_training,
name='C64') # (?, 35, 35, 64)
C128 = ops.Ck(C64,
128,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C128') # (?, 18, 18, 128)
C256 = ops.Ck(C128,
256,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C256') # (?, 9, 9, 256)
C512 = ops.Ck(C256,
512,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C512') # (?, 5, 5, 512)
# apply a convolution to produce a 1 dimensional output (1 channel?)
# use_sigmoid = False if use_lsgan = True
output = ops.last_conv(C512,
reuse=self.reuse,
use_sigmoid=self.use_sigmoid,
name='output') # (?, 5, 5, 1)
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=self.name)
return output
def __call__(self, input):
with tf.variable_scope(self.name):
C64 = ops.Ck(input,
64,
reuse=self.reuse,
norm=None,
is_training=self.is_training,
name='C64')
C128 = ops.Ck(C64,
128,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C128')
C256 = ops.Ck(C128,
256,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C256')
C512 = ops.Ck(C256,
512,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C512')
output = ops.last_conv(C512,
reuse=self.reuse,
use_sigmoid=self.use_sigmoid,
name='output')
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=self.name)
return output
def test_last_conv(self):
input = tf.placeholder(tf.float32, shape=[64, 256, 256, 32])
result = ops.last_conv(input, name='LAST_CONV')
print(result)
def __call__(self, 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):
if self.patchgan:
if self.rf == 70:
print "using rf=70 patchgan"
C32 = ops.Ck(input,
64,
stride=1,
reuse=self.reuse,
norm=None,
is_training=self.is_training,
name='C32')
C64 = ops.Ck(C32,
64,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C64') # (?, w/2, h/2, 64)
C128 = ops.Ck(C64,
128,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C128') # (?, w/4, h/4, 128)
C256 = ops.Ck(C128,
256,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C256') # (?, w/8, h/8, 256)
C512_0 = ops.Ck(C256,
512,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C512_0') # (?, w/16, h/16, 512)
# apply a convolution to produce a 1 dimensional output (1 channel?)
# use_sigmoid = False if use_lsgan = True
output = ops.last_conv(C512_0,
reuse=self.reuse,
use_sigmoid=self.use_sigmoid,
name='output',
kernelsize=4) # (?, w/16, h/16, 1)
elif self.rf == 40:
print "using rf=40 patchgan"
C32 = ops.Ck(input,
32,
stride=1,
reuse=self.reuse,
norm=None,
is_training=self.is_training,
name='C32',
kernelsize=3)
C64 = ops.Ck(C32,
64,
stride=1,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C64',
kernelsize=3) # (?, w/2, h/2, 64)
C128 = ops.Ck(C64,
128,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C128') # (?, w/4, h/4, 128)
C256 = ops.Ck(C128,
256,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C256') # (?, w/8, h/8, 256)
C512_0 = ops.Ck(C256,
512,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C512_0') # (?, w/16, h/16, 512)
output = ops.last_conv(C512_0,
reuse=self.reuse,
use_sigmoid=self.use_sigmoid,
name='output',
kernelsize=3) # (?, w/16, h/16, 1)
elif self.rf == 21:
print "using rf=21 patchgan"
C32 = ops.Ck(input,
32,
stride=1,
reuse=self.reuse,
norm=None,
is_training=self.is_training,
name='C32',
kernelsize=3)
C64 = ops.Ck(C32,
64,
stride=1,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C64',
kernelsize=3) # (?, w/2, h/2, 64)
C128 = ops.Ck(C64,
128,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C128',
kernelsize=3) # (?, w/4, h/4, 128)
C256 = ops.Ck(C128,
256,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C256',
kernelsize=2) # (?, w/8, h/8, 256)
C512_0 = ops.Ck(C256,
512,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C512_0',
kernelsize=2) # (?, w/16, h/16, 512)
output = ops.last_conv(C512_0,
reuse=self.reuse,
use_sigmoid=self.use_sigmoid,
name='output',
kernelsize=2) # (?, w/16, h/16, 1)
elif self.rf == 56:
print "using rf=56 patchgan"
C32 = ops.Ck(input,
64,
stride=1,
reuse=self.reuse,
norm=None,
is_training=self.is_training,
name='C32',
kernelsize=4)
C64 = ops.Ck(C32,
128,
stride=2,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C64',
kernelsize=4) # (?, w/2, h/2, 64)
C128 = ops.Ck(C64,
256,
stride=1,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C128',
kernelsize=3) # (?, w/4, h/4, 128)
C256 = ops.Ck(C128,
512,
stride=2,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C256',
kernelsize=4) # (?, w/8, h/8, 256)
C512_0 = ops.Ck(C256,
1024,
stride=2,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C512_0',
kernelsize=4) # (?, w/16, h/16, 512)
output = ops.last_conv(C512_0,
reuse=self.reuse,
use_sigmoid=self.use_sigmoid,
name='output',
kernelsize=3) # (?, w/16, h/16, 1)
elif self.rf == 0:
print "using rf=0 wholegan"
C32 = ops.Ck(input,
32,
stride=1,
reuse=self.reuse,
norm=None,
is_training=self.is_training,
name='C32')
C64 = ops.Ck(C32,
64,
stride=2,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C64') # (?, w/2, h/2, 64)
C128 = ops.Ck(C64,
128,
stride=2,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C128') # (?, w/4, h/4, 128)
C256 = ops.Ck(C128,
256,
stride=2,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C256') # (?, w/8, h/8, 256)
C512 = ops.Ck(C256,
512,
stride=2,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C512') # (?, w/16, h/16, 512)
# C512_0 = ops.Ck(C512, 1024, stride=1, reuse=self.reuse, norm=self.norm,
# is_training=self.is_training, name='C512_0')
batchsize = C512.get_shape()[0].value
reshaped = tf.reshape(C512, [batchsize, -1])
output = tf.layers.dense(reshaped,
1,
name='fc8',
reuse=self.reuse)
else:
print "unknow rf"
exit(0)
if self.gan_mode == 'gan_logits':
batchsize = output.get_shape()[0].value
output = tf.reshape(
output, [batchsize, -1
]) # may cause error when batchsize is not 1
else:
# convolution layers
C64 = ops.Ck(input,
64,
stride=2,
reuse=self.reuse,
norm=None,
is_training=self.is_training,
name='C64') # (?, w/2, h/2, 64)
C128 = ops.Ck(C64,
128,
stride=2,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C128') # (?, w/4, h/4, 128)
C256 = ops.Ck(C128,
256,
stride=2,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C256') # (?, w/8, h/8, 256)
C512 = ops.Ck(C256,
512,
stride=2,
reuse=self.reuse,
norm=self.norm,
is_training=self.is_training,
name='C512') # (?, w/16, h/16, 512)
#C512_0 = ops.Ck(C512, 1024, stride=1, reuse=self.reuse, norm=self.norm,
# is_training=self.is_training, name='C512_0')
batchsize = C512.get_shape()[0].value
reshaped = tf.reshape(C512, [batchsize, -1])
output = tf.layers.dense(reshaped,
1,
name='fc8',
reuse=self.reuse)
if self.use_sigmoid:
output = tf.sigmoid(output)
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=self.name)
return output