Why is my GAN collapsing each time I run it? - generative-adversarial-network

Question

So my GAN is producing the same output every time I run it and there are also repeating outputs.
The GAN always produces the same faces every time I run it and I can't figure out what is causing this issue. I want each output to be unique but many are repeating. It might be mode collapse, but I have yet to figure it out after looking over my code for a while and trying to rewrite some of it.
random_dim = 100
PREVIEW_ROWS = 6
PREVIEW_COLS = 6
PREVIEW_MARGIN = 0
SAVE_FREQ = 10
IMAGE_SIZE = 64
WIDTH = 64
HEIGHT = 64
CONTROL_SIZE_SQRT = 6
CHANNELS = 3
EPOCHS = 30000
def get_optimizer():
return Adam(lr=0.0002, beta_1=0.5, beta_2=0.999)
def get_generator():
gen_input = Input(shape=random_dim)
generator = Sequential()
generator.add(Dense(512 * 2 * 2, input_dim=random_dim))
generator.add(LeakyReLU(alpha=0.2))
generator.add(Reshape((2, 2, 512)))
generator.add(Conv2DTranspose(64, (3, 3), strides=(2,2), padding='same'))
generator.add(LeakyReLU(alpha=0.2))
generator.add(BatchNormalization())
generator.add(Conv2DTranspose(128, (3, 3), strides=(2,2), padding='same'))
generator.add(LeakyReLU(alpha=0.2))
generator.add(BatchNormalization())
generator.add(Conv2DTranspose(256, (3, 3), strides=(2,2), padding='same'))
generator.add(LeakyReLU(alpha=0.2))
generator.add(BatchNormalization())
generator.add(Conv2DTranspose(512, (3, 3), strides=(2,2), padding='same'))
generator.add(LeakyReLU(alpha=0.2))
generator.add(BatchNormalization())
generator.add(Conv2DTranspose(512, (3, 3), strides=(2,2), padding='same'))
generator.add(LeakyReLU(alpha=0.2))
generator.add(BatchNormalization())
generator.add(Conv2D(3, (3,3), activation='tanh', padding='same'))
input = Input(shape=(random_dim,))
generated_image = generator(input)
generator.summary()
return Model(input, generated_image)
def get_discriminator():
disc_input = Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3))
discriminator = Sequential()
discriminator.add(Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3)))
discriminator.add(GaussianNoise(0.1))
discriminator.add(Conv2D(64, (3, 3), padding='same'))
discriminator.add(LeakyReLU(alpha=0.2))
discriminator.add(GaussianNoise(0.1))
discriminator.add(AveragePooling2D())
discriminator.add(Conv2D(128, (3, 3), padding='same'))
discriminator.add(LeakyReLU(alpha=0.2))
discriminator.add(GaussianNoise(0.1))
discriminator.add(AveragePooling2D())
discriminator.add(Conv2D(128, (3, 3), padding='same'))
discriminator.add(LeakyReLU(alpha=0.2))
discriminator.add(GaussianNoise(0.1))
discriminator.add(AveragePooling2D())
discriminator.add(Conv2D(256, (3, 3), padding='same'))
discriminator.add(LeakyReLU(alpha=0.2))
discriminator.add(GaussianNoise(0.1))
discriminator.add(AveragePooling2D())
discriminator.add(Conv2D(512, (3, 3), padding='same'))
discriminator.add(LeakyReLU(alpha=0.2))
discriminator.add(GaussianNoise(0.1))
discriminator.add(AveragePooling2D())
discriminator.add(Flatten())
discriminator.add(LeakyReLU(alpha=0.2))
discriminator.add(Dropout(0.5))
discriminator.add(Dense(1, activation='sigmoid'))
discriminator.summary()
discriminator = Model(disc_input, discriminator(disc_input))
optimizer = RMSprop(
lr = .0001,
clipvalue = 1.0,
decay = 1e-8
)
discriminator.compile(loss='binary_crossentropy', optimizer=get_optimizer(), metrics=["accuracy"])
return discriminator
def get_gan_network(discriminator, random_dim, generator, optimizer):
# We initially set trainable to False since we only want to train either the
# generator or discriminator at a time
discriminator.trainable = False
# gan input (noise) will be 100-dimensional vectors
gan_input = Input(shape=(random_dim,))
# the output of the generator (an image)
x = generator(gan_input)
# get the output of the discriminator (probability if the image is real or not)
gan_output = discriminator(x)
gan = Model(inputs=gan_input, outputs=gan_output)
gan.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=["accuracy"])
return gan
X_train = training_data
fixed_noise = np.random.normal(0, 1, (PREVIEW_ROWS * PREVIEW_COLS, 100))
def train(epochs=1, batchSize=128):
batchCount = X_train.shape[0] / batchSize
halfBatch = batchSize // 2
print(X_train.shape[0])
print('Epochs:', epochs)
print('Batch size:', batchSize)
print('Batches per epoch:', batchCount)
adam = get_optimizer()
generator = get_generator()
discriminator = get_discriminator()
discriminator.trainable = False
gan = get_gan_network(discriminator, random_dim, generator, adam)
valid = np.ones((batchSize, 1))
fake = np.zeros((batchSize, 1))
d_losses = []
g_losses = []
real_scores = []
start=0
for epoch in tdqm(range(EPOCHS)):
start_time = time.time()
latent_vectors = np.random.normal(size=(batchSize, random_dim))
generated = generator.predict(latent_vectors)
gen_shape = generator.output_shape
real = training_data[start:start + batchSize]
combined_images = np.concatenate([generated, real])
labels = np.concatenate([np.ones((batchSize, 1)), np.zeros((batchSize, 1))])
labels += .05 * np.random.random(labels.shape)
d_loss = discriminator.train_on_batch(combined_images, labels)
d_losses.append(d_loss)
#Train G
latent_vectors = np.random.normal(size=(batchSize, random_dim))
misleading_targets = np.zeros((batchSize, 1))
g_loss = gan.train_on_batch(latent_vectors, misleading_targets)
g_losses.append(g_loss)
#if epoch == 1 or epoch % 20 == 0:
if epoch % 50 == 49:
save_images(epoch, fixed_noise, generator)
if __name__ == '__main__':
train(5000, 32)

Answer 1

GAN is very volatile. It collapses everytime if proper training and good hyperparameter tuning is not done (even with small datasets like MNIST). There are many new advancements in GAN networks that helps in avoiding mode collapse (Ex: AdaGAN).
But as you're training a Vanilla GAN (the basic one), to avoid collapse, follow the hacks mentioned in the given Repository.
These tricks will avoid Mode collapse upto a maximum extent