In InfoGAN.py line 146, the squared loss is being optimized as follows.

cont_code_est = code_fake[:, self.len_discrete_code:]
cont_code_tg = self.y[:, self.len_discrete_code:]
q_cont_loss = tf.reduce_mean(tf.reduce_sum(tf.square(cont_code_tg - cont_code_est), axis=1))

The code_fake vector is in [0,1] as it comes from a softmax non-linearity. The actual latent code being sent, however, is in [-1,1]. (See line 234).

batch_codes = np.concatenate((batch_labels, np.random.uniform(-1, 1, size=(self.batch_size, 2))),
                                             axis=1)

Am I missing something?

Thanks for your great work! I find that the discriminatior in LSGAN calculated by sigmoid(logits). But according to the original paper D(x) should be logits directly. If the sigmoid function is used in D(x), the problem of gradient vanishing still exists. I'm not sure whether i misinterpreted the idea of the paper.

The mnist dataset has a tag file but the label of the celebA dataset represents more than just a class of images, some of which represent several classes. How to deal with celebA's label?

Hey, I appreciate your work! You make my life better.

I found (maybe) a small bug in your WGAN_GP code. When calculating gradient penalty, you write:

D_inter,_,_=self.discriminator(interpolates, is_training=True, reuse=True) 
gradients = tf.gradients(D_inter, [interpolates])[0]

You use the sigmoid output of the Discriminator, not the logits.

In the original implementation (https://github.com/igul222/improved_wgan_training/blob/master/gan_mnist.py), they write this:

gradients = tf.gradients(Discriminator(interpolates), [interpolates])[0]

Here, the authors only return the logits of the Discriminator. So they use the logits for this calculation.

Did you do this on purpose?

Greetings!

You have this line in all the constructors:

if dataset_name == 'mnist' or 'fashion-mnist':

It will always be True. You want if dataset_name == 'mnist' or dataset_name == 'fashion-mnist' or if dataset_name in ['mnist', 'fashion-mnist'].

Hi, I'm the author of Fashion-MNIST dataset. I found the GANs results on Fashion-MNIST is very interesting, especially how ACGAN and infoGAN failed on Fashion-MNIST. I already highlighted this notebook in Fashion-MNIST README.md. I hope it is ok for you. 🙇

Here are the links: https://github.com/zalandoresearch/fashion-mnist#other-explorations-of-fashion-mnist https://github.com/zalandoresearch/fashion-mnist/blob/master/README.zh-CN.md#生成对抗网络-gans

Thanks for sharing the code.

However, it seems the Tensorflow VAE doesn't have implementation for color images, eg. cifar10 data, only MNIST and fashion MNIST is available.Also, the Pytorch version doesn't have VAE implementation at all.

Is there anyway to use VAE for color mages. Thanks.

Thank you for sharing your codes.

I found that there is no weight clipping in the paper Least Squares Generative Adversarial Networks. The weight clipping is used in the paper Loss-Sensitive Generative Adversarial Networks on Lipschitz Densities. Obviously, your code is the former.

I tried both situations, and the performance is better without weight clipping.

I changed the network structure and adjusted the super-parameters to apply to data cifar-10. I thought maybe someone needed it, so I left the url of my code. https://github.com/AliceAria/Performance-comparison-of-GAN-on-cifar-10

Thanks again.

Thanks for your code! I found that Discriminator los sfunction of w-gan is the same as Discriminator los sfunction of gan in your code,but actually not! Pleace check it!

at 113 line in WGAN_GP, I recommend changing the code

alpha = tf.random_uniform(shape=self.inputs.get_shape(), minval=0.,maxval=1.) to alpha = tf.random_uniform(shape=[BATCH_SIZE,1,1,1], minval=0.,maxval=1.)

Because It must be created one alpha value for each batch

Hey @hwalsuklee,

Thanks for sharing your code which helps me a lot. I have a question about the linear function in ops.py

I would be appreciated if you can explain what you are doing in the this function.

def linear(input_, output_size, scope=None, stddev=0.02, bias_start=0.0, with_w=False):
    shape = input_.get_shape().as_list()

    with tf.variable_scope(scope or "Linear"):
        matrix = tf.get_variable("Matrix", [shape[1], output_size], tf.float32,
                 tf.random_normal_initializer(stddev=stddev))
        bias = tf.get_variable("bias", [output_size],
        initializer=tf.constant_initializer(bias_start))
        if with_w:
            return tf.matmul(input_, matrix) + bias, matrix, bias
        else:
            return tf.matmul(input_, matrix) + bias

Also, It would be great if you add some comments when you are implementing; to be much easier for others to understand.

Thanks.