Tag Archives: GAN MNIST

Information Maximizing Generative Adversarial Network (InfoGAN): Introduction and Implementation

Introduction

A generative adversarial network consist of two networks – a generator and a discriminator. Both of these networks are trained in an adversarial manner. While the generator tries to generate images similar to original images, discriminator tries to differentiate between images generated by the generator and original images. Training continues until discriminator is fooled half the time by generator and generator is able to generate images similar to original images.

Control Variables

In a general GAN, a random input noise vector is given as input to the generator network which does not provide any information to the generator network i.e. in which manner outputs should be generated. While InfoGAN uses latent code along with noise vector to generate images accordingly. Input to the generator of the InfoGAN can be given in two parts:

Continuous noise vector, z.
Latent codes which can be both discrete and continuous, c.

Let say we have trained our InfoGAN on MNIST handwritten digit datasets. Here discrete latent codes (0-9) can be used to generate specific digits between 0-9. While continuous latent codes can be used to generate digits with varying thickness and orientation.

Mutual Information

InfoGAN stands for information maximizing GAN. To maximize information, InfoGAN uses mutual information. In information theory, the mutual information between X and Y, I(X; Y ), measures the “amount of information” learned from knowledge of random variable Y about the other random variable X. In InfoGAN there should be high mutual information between latent code c and generated images.

To maximize this mutual information, the InfoGAN model requires an extra network named as an auxiliary model. This auxiliary model shares all the weights from the discriminator network except the output layer. As the discriminator network has an output layer which predicts the given input image is real or fake, the auxiliary network predicts the latent codes.

So the InfoGAN will consist of three networks – Generator, Discriminator, and auxiliary network. Both the discriminator and auxiliary networks are used to improve the generator network. Here, the generation of real looking images by generator network is regularized by the discriminator network and maximization of mutual information is regularized by the auxiliary network.

Implementation

In this blog, we will implement InfoGAN using MNIST handwritten digit dataset. To maximize the information we will only use discrete codes to generate particular digits. In addition to this, you can also use two continuous variables to define the rotation and thickness of the generated digits.

Imports and Initialization

(x_train, y_train), (x_test, y_test) = mnist.load_data()
batch_size = 16
half_batch_size = 8
latent_dim = 100 + 10
iterations = 60000
optimizer = Adam(0.0002, 0.5)

(x_train, y_train), (x_test, y_test) = mnist.load_data()

batch_size = 16

half_batch_size = 8

latent_dim = 100 + 10

iterations = 60000

optimizer = Adam(0.0002, 0.5)

Generator Network

def generator():

    input_gen = Input(shape = (latent_dim,))
    dense1 = Reshape((7,7,16))(Dense(7*7*16)(input_gen))

    batch_norm_1 = BatchNormalization()(dense1)
    trans_1 = Conv2DTranspose(128, 3, padding='same', activation=LeakyReLU(alpha=0.2), strides=(2, 2))(batch_norm_1)
    batch_norm_2 = BatchNormalization()(trans_1)
    trans_2 = Conv2DTranspose(128, 3, padding='same', activation=LeakyReLU(alpha=0.2), strides=(2, 2))(batch_norm_2)
    output = Conv2D(1, (28,28), activation='tanh', padding='same')(trans_2)
    gen_model = Model(input_gen, output)
    gen_model.compile(loss='binary_crossentropy', optimizer=optimizer)
    print(gen_model.summary())

    return gen_model

def generator():

input_gen = Input(shape = (latent_dim,))

dense1 = Reshape((7,7,16))(Dense(7*7*16)(input_gen))

batch_norm_1 = BatchNormalization()(dense1)

trans_1 = Conv2DTranspose(128, 3, padding='same', activation=LeakyReLU(alpha=0.2), strides=(2, 2))(batch_norm_1)

batch_norm_2 = BatchNormalization()(trans_1)

trans_2 = Conv2DTranspose(128, 3, padding='same', activation=LeakyReLU(alpha=0.2), strides=(2, 2))(batch_norm_2)

output = Conv2D(1, (28,28), activation='tanh', padding='same')(trans_2)

gen_model = Model(input_gen, output)

gen_model.compile(loss='binary_crossentropy', optimizer=optimizer)

print(gen_model.summary())

return gen_model

Input to the generator network consists of shape (110, 1), where 100 is the noise vector size and 10 is the latent code size. Here latent codes are one-hot encoded discrete number between 0-9. I have used deconvolutional layers to upsample and finally produce the shape of (28,28,1). Batch normalization is used to improve the quality of the trained network and for stabilization.

Discriminator and Auxiliary Network

def discriminator():

    input_disc = Input(shape = (28, 28, 1))

    conv_1 = Conv2D(16, 3, padding = 'same', activation = LeakyReLU(alpha=0.2))(input_disc)
    batch_norm1 = BatchNormalization()(conv_1)
    pool_1 = AveragePooling2D(strides = (2,2))(batch_norm1)
    conv_2 = Conv2D(32, 3, padding = 'same', activation = LeakyReLU(alpha=0.2))(pool_1)
    batch_norm2 = BatchNormalization()(conv_2)
    pool_2 = AveragePooling2D(strides = (2,2))(batch_norm2)
    conv_3 = Conv2D(64, 3, padding = 'same', activation = LeakyReLU(alpha=0.2))(pool_2)
    batch_norm3 = BatchNormalization()(conv_3)
    pool_3 = AveragePooling2D(strides = (2,2))(conv_3)
    flatten_1 = Flatten()(pool_3)
    output = Dense(1, activation = 'sigmoid')(flatten_1)
    q_output_catgorical = Dense(10, activation = 'softmax')(flatten_1)
    
    disc_model = Model(input_disc, output)
    disc_model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
    
    q_model = Model(input_disc, q_output_catgorical)
    q_model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
    
    print(disc_model.summary())
    print(q_model.summary())

    return disc_model, q_model

def discriminator():

input_disc = Input(shape = (28, 28, 1))

conv_1 = Conv2D(16, 3, padding = 'same', activation = LeakyReLU(alpha=0.2))(input_disc)

batch_norm1 = BatchNormalization()(conv_1)

pool_1 = AveragePooling2D(strides = (2,2))(batch_norm1)

conv_2 = Conv2D(32, 3, padding = 'same', activation = LeakyReLU(alpha=0.2))(pool_1)

batch_norm2 = BatchNormalization()(conv_2)

pool_2 = AveragePooling2D(strides = (2,2))(batch_norm2)

conv_3 = Conv2D(64, 3, padding = 'same', activation = LeakyReLU(alpha=0.2))(pool_2)

batch_norm3 = BatchNormalization()(conv_3)

pool_3 = AveragePooling2D(strides = (2,2))(conv_3)

flatten_1 = Flatten()(pool_3)

output = Dense(1, activation = 'sigmoid')(flatten_1)

q_output_catgorical = Dense(10, activation = 'softmax')(flatten_1)

disc_model = Model(input_disc, output)

disc_model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])

q_model = Model(input_disc, q_output_catgorical)

q_model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])

print(disc_model.summary())

print(q_model.summary())

return disc_model, q_model

As I have already told that auxiliary network shares all the weights of the discriminator network except the output layer there is no need to create two separate functions for this. Networks take images of shape (28, 28, 1) as input. convolutional, batch normalization and pooling layers are used to create the network. The output shape of the discriminator network is 1 as it only predicts the input image is real or fake. But the output shape of the auxiliary network is 10 as it predicts latent code.

Combined Model

def combined():

    inputs = Input(shape = (latent_dim,)) 
    gen_img = generator_model(inputs)
    
    discriminator_model.trainable = False
    
    disc_outs = discriminator_model(gen_img)
    q_outs = auxiliary_model(gen_img)
    
    comb_model = Model(inputs, [disc_outs, q_outs])
    comb_model.compile(loss=['binary_crossentropy', 'categorical_crossentropy'], optimizer=optimizer, metrics=['accuracy'])
    print(comb_model.summary())

    return comb_model

def combined():

inputs = Input(shape = (latent_dim,))

gen_img = generator_model(inputs)

discriminator_model.trainable = False

disc_outs = discriminator_model(gen_img)

q_outs = auxiliary_model(gen_img)

comb_model = Model(inputs, [disc_outs, q_outs])

comb_model.compile(loss=['binary_crossentropy', 'categorical_crossentropy'], optimizer=optimizer, metrics=['accuracy'])

print(comb_model.summary())

return comb_model

A combined model is created to train the generator network. Here we do discriminator network as non-trainable as discriminator network is trained separately. The combined model takes random noise and latent code as input. This input is fed to the generator network and the generated image is fed to both discriminator and auxiliary network.

Training InfoGAN

Training a GAN model is always a difficult task. A careful hyperparameter tuning is always required. We will use the following steps to train the InfoGAN model.

Normalize the input images from the MNIST dataset.
Train the discriminator model using real images from the MNIST dataset.
Train the discriminator model using real images and corresponding labels.
Train the discriminator model using fake images generated from the generator network.
Train the auxiliary network using fake images generated from the generator and random latent codes.
Train the generator network using a combined model without training the discriminator.
Repeat the steps from 2-6 for some iterations. I have trained it for 60000 iterations.

generator_model = generator() 
discriminator_model, auxiliary_model = discriminator()
combined_model = combined()

def train():

    train_data = (x_train.astype(np.float32) - 127.5) / 127.5
    train_data = np.expand_dims(train_data, -1)
    train_data_y = y_train

    for i in range(iterations):

        batch_indx = np.random.randint(0, train_data.shape[0], size = (half_batch_size))
        batch_x = train_data[batch_indx]
        batch_y = to_categorical(train_data_y[batch_indx], 10)

        real_loss = discriminator_model.train_on_batch(batch_x, np.ones((half_batch_size,1)))

        q_real_loss = auxiliary_model.train_on_batch(batch_x, batch_y)

        random_y = to_categorical(np.random.randint(0,10,half_batch_size), 10)
        input_noise = np.random.normal(0, 1, size=(half_batch_size, 100))
        
        gen_outs = generator_model.predict(np.hstack((input_noise, random_y)))

        fake_loss = discriminator_model.train_on_batch(gen_outs, np.zeros((half_batch_size,1)))
        q_fake_loss = auxiliary_model.train_on_batch(gen_outs, random_y)

        noise = np.random.normal(0, 1, size=(batch_size, 100))
        latent_code = to_categorical(np.random.randint(0,10,batch_size), 10)

        full_batch_input_noise = np.hstack((noise, latent_code))

        gan_loss = combined_model.train_on_batch(full_batch_input_noise, [np.ones((batch_size,1)), latent_code])
        
        if i%5000 == 0:
            print(i, fake_loss, real_loss, gan_loss, q_real_loss, q_fake_loss)

generator_model = generator()

discriminator_model, auxiliary_model = discriminator()

combined_model = combined()

def train():

train_data = (x_train.astype(np.float32) - 127.5) / 127.5

train_data = np.expand_dims(train_data, -1)

train_data_y = y_train

for i in range(iterations):

batch_indx = np.random.randint(0, train_data.shape[0], size = (half_batch_size))

batch_x = train_data[batch_indx]

batch_y = to_categorical(train_data_y[batch_indx], 10)

real_loss = discriminator_model.train_on_batch(batch_x, np.ones((half_batch_size,1)))

q_real_loss = auxiliary_model.train_on_batch(batch_x, batch_y)

random_y = to_categorical(np.random.randint(0,10,half_batch_size), 10)

input_noise = np.random.normal(0, 1, size=(half_batch_size, 100))

gen_outs = generator_model.predict(np.hstack((input_noise, random_y)))

fake_loss = discriminator_model.train_on_batch(gen_outs, np.zeros((half_batch_size,1)))

q_fake_loss = auxiliary_model.train_on_batch(gen_outs, random_y)

noise = np.random.normal(0, 1, size=(batch_size, 100))

latent_code = to_categorical(np.random.randint(0,10,batch_size), 10)

full_batch_input_noise = np.hstack((noise, latent_code))

gan_loss = combined_model.train_on_batch(full_batch_input_noise, [np.ones((batch_size,1)), latent_code])

if i%5000 == 0:

print(i, fake_loss, real_loss, gan_loss, q_real_loss, q_fake_loss)

Generation

Now we will generate images from the trained gan model. The generator will be provided with random noise and one hot encoded input digit between 0-9 whichever digit we want to generate.

# generating new images from trained network
import matplotlib.pyplot as plt

r, c = 10, 5

gen_imgs = []

for indx in range(10):
    
    noise = np.random.normal(0, 1, (5, 100))
    categorical_code = to_categorical([indx]*5, 10)
    
    input_noise = np.hstack((noise, categorical_code))
    outs = generator_model.predict(input_noise)
    gen_imgs.extend(outs)
    
gen_imgs = np.array(gen_imgs)
gen_imgs = 0.5 * gen_imgs + 0.5
fig, axs = plt.subplots(r, c)
cnt = 0
for i in range(r):
    for j in range(c):
        axs[i,j].imshow(gen_imgs[cnt, :,:,0], cmap='gray')
        axs[i,j].axis('off')
        cnt += 1
        
plt.show()
fig.savefig("mnist.png")
plt.close()

# generating new images from trained network

import matplotlib.pyplot as plt

r, c = 10, 5

gen_imgs = []

for indx in range(10):

noise = np.random.normal(0, 1, (5, 100))

categorical_code = to_categorical([indx]*5, 10)

input_noise = np.hstack((noise, categorical_code))

outs = generator_model.predict(input_noise)

gen_imgs.extend(outs)

gen_imgs = np.array(gen_imgs)

gen_imgs = 0.5 * gen_imgs + 0.5

fig, axs = plt.subplots(r, c)

cnt = 0

for i in range(r):

for j in range(c):

axs[i,j].imshow(gen_imgs[cnt, :,:,0], cmap='gray')

axs[i,j].axis('off')

cnt += 1

plt.show()

fig.savefig("mnist.png")

plt.close()

Here are the generated results from the model:

Referenced Research Paper: InfoGAN: Interpretable Representation Learning by Information Maximizing Generative Adversarial Nets

Hope you enjoy reading.

If you have any doubts/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Implementation of GANs to generated Handwritten Digits

Leave a reply

In the previous blog, we studied about GANs, now in this blog, we will implement GANs to generate MNIST digits dataset.

In the generative adversarial networks, both generator and discriminator are trained simultaneously. Both networks can overpower each other if not trained properly. If discriminator is trained more than it will easily detect fake and real image then the generator will not able to generate real-looking images. And if the generator is trained heavily then discriminator will not be able to classify between real and fake images. We can solve this problem by properly setting the learning rate for both networks.

When we train discriminator we do not train generator and when we train generator we do not train discriminator. This makes the generator to train properly. Now, let’s look into the code for each part on the GAN network.

Discriminator Network:

We are using MNIST digits dataset which is having an image shape of (28, 28, 1). Since the image size is small we can use MLP network for discriminator instead of using convolutional layers. To do this first we need to reshape input into a single vector of size (784, 1). Then I have applied three dense layers of 512, 256 and 128 hidden units in each layers.

def discriminator(self):

    input_disc = Input(shape = (784,))
    hidden1 = Dense(512, activation = 'relu')(input_disc)
    hidden2 = Dense(256, activation = 'relu')(hidden1)
    hidden3 = Dense(128, activation = 'relu')(hidden2)
    output = Dense(1, activation = 'sigmoid')(hidden3)
    disc_model = Model(input_disc, output)
    disc_model.compile(loss='binary_crossentropy', optimizer=self.optimizer, metrics=['accuracy'])
    print(disc_model.summary())

    return disc_model

def discriminator(self):

input_disc = Input(shape = (784,))

hidden1 = Dense(512, activation = 'relu')(input_disc)

hidden2 = Dense(256, activation = 'relu')(hidden1)

hidden3 = Dense(128, activation = 'relu')(hidden2)

output = Dense(1, activation = 'sigmoid')(hidden3)

disc_model = Model(input_disc, output)

disc_model.compile(loss='binary_crossentropy', optimizer=self.optimizer, metrics=['accuracy'])

print(disc_model.summary())

return disc_model

Generator Network:

To create generator network we will first take random noise as input with the shape of (100, 1). Then I have used three hidden layers with shape of 256, 512 and 1024. The output of the generator network is then reshaped to (28, 28, 1). I have batch normalization in each hidden layer. Batch normalization improves the quality of the trained model and also stabilizes the training process.

def generator(self):

    input_gen = Input(shape = (self.latent_dim,))
    hidden1 = BatchNormalization(momentum=0.8)(Dense(256, activation = 'relu')(input_gen))
    hidden2 = BatchNormalization(momentum=0.8)(Dense(512, activation = 'relu')(hidden1))
    hidden3 = BatchNormalization(momentum=0.8)(Dense(1024, activation = 'relu')(hidden2))
    output = Dense(784, activation='tanh')(hidden3)
    reshaped_output = Reshape((28, 28, 1))(output)
    gen_model = Model(input_gen, reshaped_output)
    gen_model.compile(loss='binary_crossentropy', optimizer=self.optimizer)
    print(gen_model.summary())


    return gen_model

def generator(self):

input_gen = Input(shape = (self.latent_dim,))

hidden1 = BatchNormalization(momentum=0.8)(Dense(256, activation = 'relu')(input_gen))

hidden2 = BatchNormalization(momentum=0.8)(Dense(512, activation = 'relu')(hidden1))

hidden3 = BatchNormalization(momentum=0.8)(Dense(1024, activation = 'relu')(hidden2))

output = Dense(784, activation='tanh')(hidden3)

reshaped_output = Reshape((28, 28, 1))(output)

gen_model = Model(input_gen, reshaped_output)

gen_model.compile(loss='binary_crossentropy', optimizer=self.optimizer)

print(gen_model.summary())

return gen_model

Combined Model:

To train the generator we need to create a combined model where we do not train the discriminator model. In combined model random noise is being given as input to the generator network and the output image is then passed through the discriminator network to get the label. Here I have flagged discriminator model as non-trainable.

def combined(self):

    inputs = Input(shape = (self.latent_dim,)) 
    gen_img = self.generator_model(inputs)
    gen_img = Reshape((784,))(gen_img)
    self.discriminator_model.trainable = False
    outs = self.discriminator_model(gen_img)
    comb_model = Model(inputs, outs)
    comb_model.compile(loss='binary_crossentropy', optimizer=self.optimizer, metrics=['accuracy'])
    print(comb_model.summary())

    return comb_model

def combined(self):

inputs = Input(shape = (self.latent_dim,))

gen_img = self.generator_model(inputs)

gen_img = Reshape((784,))(gen_img)

self.discriminator_model.trainable = False

outs = self.discriminator_model(gen_img)

comb_model = Model(inputs, outs)

comb_model.compile(loss='binary_crossentropy', optimizer=self.optimizer, metrics=['accuracy'])

print(comb_model.summary())

return comb_model

Training the GAN network:

Training a GAN network requires careful hyper-parameters tuning. If the model is not trained carefully it will not converge to produce good results. We will use the following steps to train this GAN network:

Firstly we will normalize input dataset (MNIST images).
Train the discriminator with real images (from MNIST dataset)
Sample same number of noise vectors to predict the output from generator network (Generator is not trained here).
Train the discriminator network with images generated in the previous step.
Take new random samples to train the generator with a combined model without training discriminator.
Repeat from step 2-5 for some number of iterations. I have trained it for 30000 iterations.

def train(self):

    train_data = (self.x_train.astype(np.float32) - 127.5) / 127.5

    for i in range(self.iterations):

        batch_indx = np.random.randint(0, train_data.shape[0], size = (self.half_batch_size))
        batch_x = train_data[batch_indx]
        batch_x = batch_x.reshape((-1, 784))

        input_noise = np.random.normal(0, 1, size=(self.half_batch_size, 100))
        gen_outs = self.generator_model.predict(input_noise)
        gen_outs = gen_outs.reshape((-1, 784))

        real_loss = self.discriminator_model.train_on_batch(batch_x, np.ones((self.half_batch_size,1)))
        fake_loss = self.discriminator_model.train_on_batch(gen_outs, np.zeros((self.half_batch_size,1)))

        disc_loss = 0.5*np.add(fake_loss,real_loss)

        full_batch_input_noise = np.random.normal(0, 1, size=(self.batch_size, 100))
        gan_loss = self.combined_model.train_on_batch(full_batch_input_noise, np.array([1] * self.batch_size))

        print(i, disc_loss, gan_loss)

def train(self):

train_data = (self.x_train.astype(np.float32) - 127.5) / 127.5

for i in range(self.iterations):

batch_indx = np.random.randint(0, train_data.shape[0], size = (self.half_batch_size))

batch_x = train_data[batch_indx]

batch_x = batch_x.reshape((-1, 784))

input_noise = np.random.normal(0, 1, size=(self.half_batch_size, 100))

gen_outs = self.generator_model.predict(input_noise)

gen_outs = gen_outs.reshape((-1, 784))

real_loss = self.discriminator_model.train_on_batch(batch_x, np.ones((self.half_batch_size,1)))

fake_loss = self.discriminator_model.train_on_batch(gen_outs, np.zeros((self.half_batch_size,1)))

disc_loss = 0.5*np.add(fake_loss,real_loss)

full_batch_input_noise = np.random.normal(0, 1, size=(self.batch_size, 100))

gan_loss = self.combined_model.train_on_batch(full_batch_input_noise, np.array([1] * self.batch_size))

print(i, disc_loss, gan_loss)

Take a look into the generated images from this GAN network.

Here is the full code.

from keras.layers import Input, Dense, Reshape, BatchNormalization
from keras.models import Model
from keras.optimizers import Adam
from keras.datasets import mnist
import numpy as np

class GAN():
    def __init__(self):

        (self.x_train, self.y_train), (self.x_test, self.y_test) = mnist.load_data()
        self.batch_size = 128
        self.half_batch_size = 64
        self.latent_dim = 100
        self.iterations = 30000
        self.optimizer = Adam(0.0002, 0.5)
        self.generator_model = self.generator() 
        self.discriminator_model = self.discriminator()
        self.combined_model = self.combined()
        

    def generator(self):
        
        input_gen = Input(shape = (self.latent_dim,))
        hidden1 = BatchNormalization(momentum=0.8)(Dense(256, activation = 'relu')(input_gen))
        hidden2 = BatchNormalization(momentum=0.8)(Dense(512, activation = 'relu')(hidden1))
        hidden3 = BatchNormalization(momentum=0.8)(Dense(1024, activation = 'relu')(hidden2))
        output = Dense(784, activation='tanh')(hidden3)
        reshaped_output = Reshape((28, 28, 1))(output)
        gen_model = Model(input_gen, reshaped_output)
        gen_model.compile(loss='binary_crossentropy', optimizer=self.optimizer)
        print(gen_model.summary())
        
        
        return gen_model
    
    def discriminator(self):
        
        input_disc = Input(shape = (784,))
        hidden1 = Dense(512, activation = 'relu')(input_disc)
        hidden2 = Dense(256, activation = 'relu')(hidden1)
        hidden3 = Dense(128, activation = 'relu')(hidden2)
        output = Dense(1, activation = 'sigmoid')(hidden3)
        disc_model = Model(input_disc, output)
        disc_model.compile(loss='binary_crossentropy', optimizer=self.optimizer, metrics=['accuracy'])
        print(disc_model.summary())
        
        return disc_model
    
    def combined(self):
        
        inputs = Input(shape = (self.latent_dim,)) 
        gen_img = self.generator_model(inputs)
        gen_img = Reshape((784,))(gen_img)
        self.discriminator_model.trainable = False
        outs = self.discriminator_model(gen_img)
        comb_model = Model(inputs, outs)
        comb_model.compile(loss='binary_crossentropy', optimizer=self.optimizer, metrics=['accuracy'])
        print(comb_model.summary())
        
        return comb_model
    
    def train(self):
        
        train_data = (self.x_train.astype(np.float32) - 127.5) / 127.5
        
        for i in range(self.iterations):
            
            batch_indx = np.random.randint(0, train_data.shape[0], size = (self.half_batch_size))
            batch_x = train_data[batch_indx]
            batch_x = batch_x.reshape((-1, 784))
            
            input_noise = np.random.normal(0, 1, size=(self.half_batch_size, 100))
            gen_outs = self.generator_model.predict(input_noise)
            gen_outs = gen_outs.reshape((-1, 784))
            
            fake_loss = self.discriminator_model.train_on_batch(gen_outs, np.zeros((self.half_batch_size,1)))
            real_loss = self.discriminator_model.train_on_batch(batch_x, np.ones((self.half_batch_size,1)))
            
            disc_loss = 0.5*np.add(fake_loss,real_loss)
            
            full_batch_input_noise = np.random.normal(0, 1, size=(self.batch_size, 100))
            gan_loss = self.combined_model.train_on_batch(full_batch_input_noise, np.array([1] * self.batch_size))
            
            print(i, disc_loss, gan_loss)
            
# training the network
gan = GAN()
gan.train()


# generating new images from trained network
import matplotlib.pyplot as plt

r, c = 5, 5
noise = np.random.normal(0, 1, (r * c, 100))

gen_imgs = gan.generator_model.predict(noise)

# Rescale images 0 - 1
gen_imgs = 0.5 * gen_imgs + 0.5

fig, axs = plt.subplots(r, c)
cnt = 0
for i in range(r):
    for j in range(c):
        axs[i,j].imshow(gen_imgs[cnt, :,:,0], cmap='gray')
        axs[i,j].axis('off')
        cnt += 1
        
plt.show()
fig.savefig("mnist.png")
plt.close()

100

101

102

103

104

105

106

107

108

109

110

111

112

from keras.layers import Input, Dense, Reshape, BatchNormalization

from keras.models import Model

from keras.optimizers import Adam

from keras.datasets import mnist

import numpy as np

class GAN():

def __init__(self):

(self.x_train, self.y_train), (self.x_test, self.y_test) = mnist.load_data()

self.batch_size = 128

self.half_batch_size = 64

self.latent_dim = 100

self.iterations = 30000

self.optimizer = Adam(0.0002, 0.5)

self.generator_model = self.generator()

self.discriminator_model = self.discriminator()

self.combined_model = self.combined()

def generator(self):

input_gen = Input(shape = (self.latent_dim,))

hidden1 = BatchNormalization(momentum=0.8)(Dense(256, activation = 'relu')(input_gen))

hidden2 = BatchNormalization(momentum=0.8)(Dense(512, activation = 'relu')(hidden1))

hidden3 = BatchNormalization(momentum=0.8)(Dense(1024, activation = 'relu')(hidden2))

output = Dense(784, activation='tanh')(hidden3)

reshaped_output = Reshape((28, 28, 1))(output)

gen_model = Model(input_gen, reshaped_output)

gen_model.compile(loss='binary_crossentropy', optimizer=self.optimizer)

print(gen_model.summary())

return gen_model

def discriminator(self):

input_disc = Input(shape = (784,))

hidden1 = Dense(512, activation = 'relu')(input_disc)

hidden2 = Dense(256, activation = 'relu')(hidden1)

hidden3 = Dense(128, activation = 'relu')(hidden2)

output = Dense(1, activation = 'sigmoid')(hidden3)

disc_model = Model(input_disc, output)

disc_model.compile(loss='binary_crossentropy', optimizer=self.optimizer, metrics=['accuracy'])

print(disc_model.summary())

return disc_model

def combined(self):

inputs = Input(shape = (self.latent_dim,))

gen_img = self.generator_model(inputs)

gen_img = Reshape((784,))(gen_img)

self.discriminator_model.trainable = False

outs = self.discriminator_model(gen_img)

comb_model = Model(inputs, outs)

comb_model.compile(loss='binary_crossentropy', optimizer=self.optimizer, metrics=['accuracy'])

print(comb_model.summary())

return comb_model

def train(self):

train_data = (self.x_train.astype(np.float32) - 127.5) / 127.5

for i in range(self.iterations):

batch_indx = np.random.randint(0, train_data.shape[0], size = (self.half_batch_size))

batch_x = train_data[batch_indx]

batch_x = batch_x.reshape((-1, 784))

input_noise = np.random.normal(0, 1, size=(self.half_batch_size, 100))

gen_outs = self.generator_model.predict(input_noise)

gen_outs = gen_outs.reshape((-1, 784))

fake_loss = self.discriminator_model.train_on_batch(gen_outs, np.zeros((self.half_batch_size,1)))

real_loss = self.discriminator_model.train_on_batch(batch_x, np.ones((self.half_batch_size,1)))

disc_loss = 0.5*np.add(fake_loss,real_loss)

full_batch_input_noise = np.random.normal(0, 1, size=(self.batch_size, 100))

gan_loss = self.combined_model.train_on_batch(full_batch_input_noise, np.array([1] * self.batch_size))

print(i, disc_loss, gan_loss)

# training the network

gan = GAN()

gan.train()

# generating new images from trained network

import matplotlib.pyplot as plt

r, c = 5, 5

noise = np.random.normal(0, 1, (r * c, 100))

gen_imgs = gan.generator_model.predict(noise)

# Rescale images 0 - 1

gen_imgs = 0.5 * gen_imgs + 0.5

fig, axs = plt.subplots(r, c)

cnt = 0

for i in range(r):

for j in range(c):

axs[i,j].imshow(gen_imgs[cnt, :,:,0], cmap='gray')

axs[i,j].axis('off')

cnt += 1

plt.show()

fig.savefig("mnist.png")

plt.close()

Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

TheAILearner

Mastering Artificial Intelligence

Tag Archives: GAN MNIST

Information Maximizing Generative Adversarial Network (InfoGAN): Introduction and Implementation

Introduction

Control Variables

Mutual Information

Implementation

Imports and Initialization

Generator Network

Discriminator and Auxiliary Network

Combined Model

Training InfoGAN

Generation

Implementation of GANs to generated Handwritten Digits