Tag Archives: keras Gan

Creating a Deep Convolutional Generative Adversarial Networks (DCGAN)

In this tutorial, we will learn how to generate images of handwritten digits using the deep convolutional generative adversarial network.

What are GANs?

GANs are one of the most interesting ideas in deep learning today. In GANs two networks work adversarially. One is generator network which tries to generate new images which looks similar to original image dataset. Another is discriminator network which discriminates between real images (images from the dataset) and fake images (images generated from generator network).

During training, generator progressively becomes better at generating images that can not be distinguishable from real images and discriminator become more accurate at discriminating them. Training gets completed when discriminator can no longer discriminate between images generated by generator and real images.

I would recommend you to go through this blog to learn more about generative adversarial networks. Now we will implement Deep convolutional adversarial Networks using MNIST handwritten digits dataset.

Import All Libraries

from keras.layers import Input, Dense, Reshape, BatchNormalization, LeakyReLU, Conv2DTranspose, Conv2D, AveragePooling2D, Flatten
from keras.models import Model
from keras.optimizers import Adam
from keras.datasets import mnist
import numpy as np

import time

from keras.layers import Input, Dense, Reshape, BatchNormalization, LeakyReLU, Conv2DTranspose, Conv2D, AveragePooling2D, Flatten

from keras.models import Model

from keras.optimizers import Adam

from keras.datasets import mnist

import numpy as np

import time

Initialization

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 __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()

Generator Network

Generator network takes random noise as input and generates meaningful images which looks similar to real images. Inputs have a shape of vector size 100. Output images have shape of (28, 28, 1) which is same as images shape in MNIST dataset.

In generator network we use deconvolutional layers to upsample the input to image size. In convolutional layers network tries to extract some useful features while in deconvolutional layers, the network tries to add some interesting features to upsample an image. To know more about deconvolution you can read this blog. I have also added batch normalization layers to improve the quality of model and stabilizing the training process. For this network, I have used cross-entropy loss and Adam optimizer. Here is the code.

def generator(self):

    input_gen = Input(shape = (self.latent_dim,))
    dense1 = Reshape((7,7,128))(Dense(7*7*128)(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(64, 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=self.optimizer)
    print(gen_model.summary())

    return gen_model

def generator(self):

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

dense1 = Reshape((7,7,128))(Dense(7*7*128)(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(64, 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=self.optimizer)

print(gen_model.summary())

return gen_model

Discriminator Network

Discriminator network discriminates between real and fake images. So it is a binary classification network. This network consists of

the input layer of shape (28, 28, 1),
Three hidden layers of 16, 32 and 64 filters and
the output layer of shape 1.

I have also used batch normalization layer after every conv layer to stabilize the network. To downsample, I have used average pooling instead of max pooling. Finally compiled the model with cross entropy loss and Adam optimizer. Here is the code.

def discriminator(self):

    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)
    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 = (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)

disc_model = Model(input_disc, output)

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

print(disc_model.summary())

return disc_model

Combined Model

After creating generator and discriminator network, we need to create a combined model of both to train the generator network. This combined model takes the random noise as input, generates images from generator and predict label from discriminator. The gradients generated from this are used to train the generator network. In this model, we do not train the discriminator network. Here is the code.

def combined(self):

    inputs = Input(shape = (self.latent_dim,)) 
    gen_img = self.generator_model(inputs)
    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)

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 of GAN model:

To train a GAN network we first normalize the inputs between -1 and 1. Then we train this model for a large number of iterations using the following steps.

Take random input data from MNIST normalized dataset of shape equal to half the batch size and train the discriminator network with label 1 (real images).
Generate samples from generator network equal to half the batch size to train the discriminator network with label 0 (fake images).
Generate the random noise of size equal to batch size and train the generator network using the combined model.
Repeat steps from 1 to 3 for some number of iterations. Here I have used 30000 iterations.

def train(self):

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


    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]

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

        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)

def train(self):

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

train_data = np.expand_dims(train_data, -1)

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]

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

gen_outs = self.generator_model.predict(input_noise)

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)

Generating the new images from trained generator network

Now our model has been trained and we can discard the discriminator network and use the generator network to generate the new images. We will take random noise as input and generate the images. After generating the images we need to rescale them to show the outputs. Here is the code.

# 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()

# 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()

So, this was the implementation of DCGAN using MNIST dataset. In the next blogs we will learn other GAN variants.

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.

Implementing semi-supervised Learning using GANs

Implementing Semi-Supervised GAN

Now we will implement a semi-supervised GAN using MNIST digits dataset. If you want to implement a simple GAN you can follow this blog: Implementation of GANs to generated Handwritten Digits.

MNIST digits dataset consists of 60000 training images from which we will only use 1000 labeled images and rest as unlabeled images. We will select random 1000 labeled images containing 100 images for each class. Let’s see the code for this:

def sample_1000(self, x, y):

    x_1000 = []
    y_1000 = []
    for i in range(10):
        x_i = x[y==i]
        ix = np.random.randint(0, len(x_i), 100)
        [x_1000.append(x_i[j]) for j in ix]
        [y_1000.append(i) for j in ix]

    return x_1000, y_1000

def sample_1000(self, x, y):

x_1000 = []

y_1000 = []

for i in range(10):

x_i = x[y==i]

ix = np.random.randint(0, len(x_i), 100)

[x_1000.append(x_i[j]) for j in ix]

[y_1000.append(i) for j in ix]

return x_1000, y_1000

Discriminator in SGAN

For this semi-supervised GAN model, we will create two discriminator models both of them share weights of every layer but have different output layers. One model will be the binary classifier model (discriminate between real and fake images) and another will be multi-class classifier model (predicts labels for the input image). Let’s see the code for this:

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)
    output2 = Dense(10, activation = 'softmax', name = 'classification_layer')(hidden3)
    disc_model = Model(input_disc, output)
    disc_model_2 = Model(input_disc, output2)
    disc_model.compile(loss=['binary_crossentropy'], optimizer=self.optimizer, metrics=['accuracy'])
    disc_model_2.compile(loss=['categorical_crossentropy'], optimizer=self.optimizer, metrics=['accuracy'])
    print(disc_model.summary())
    print(disc_model_2.summary())

    return disc_model, disc_model_2

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)

output2 = Dense(10, activation = 'softmax', name = 'classification_layer')(hidden3)

disc_model = Model(input_disc, output)

disc_model_2 = Model(input_disc, output2)

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

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

print(disc_model.summary())

print(disc_model_2.summary())

return disc_model, disc_model_2

Generator in SGAN

Generator in this SGAN is a simple multi-layer neural network having three hidden layers with units 512, 256 and 128. The output layer is having a shape of the original image (28, 28,1). Input to the generator will we random noise of vector size 100. Here is the code.

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

Training the model

Training this model will consist of the following steps:

Sample both label and unlabeled data from the MNIST dataset, also normalize and make labels of data into categorical form.
Train the multi-class discriminator model with labeled real images (take a batch from images)
Train the binary-class discriminator model with unlabeled real images (take a batch from images)
Sample noise of vector size 100 and train the binary-class discriminator model with fake images generated by generator network.
Sample noise of vector size 100 and train the combined model to train the generator network.
Repeat steps from 2-5 for some number of iterations. I have trained it for 10000 iterations.

In the above training steps, you can see that we are training multi-class discriminator and binary-class discriminator in different steps. But actually they are sharing weights of the same network except for the output layer (As I have mentioned earlier).

Also, Binary-class discriminator is trained two times in every iteration, one with real images taken from the dataset and another with fake images generated from the generative network. While multi-class discriminator is trained once in each iteration, only with real labeled images. This is because multi-class labels are not available for generated images.

def train(self):

    train_data, train_data_y = self.sample_1000(self.x_train, self.y_train)
    train_data = ((np.array(train_data).astype(np.float32))-127.5)/127.5
    train_data_y = to_categorical(train_data_y)

    all_train_data = ((np.array(self.x_train).astype(np.float32))-127.5)/127.5
    all_train_data_y = to_categorical(self.y_train)

    for j 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))
        batch_y = train_data_y[batch_indx]


        batch_indx_total = np.random.randint(0, all_train_data.shape[0], size = (self.half_batch_size))
        batch_x_total = all_train_data[batch_indx_total]
        batch_x_total = batch_x_total.reshape((-1, 784))
        batch_y_total = all_train_data_y[batch_indx_total]


        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))

        classi_loss = self.classification_model.train_on_batch(batch_x, batch_y)
        real_loss1 = self.discriminator_model.train_on_batch(batch_x_total, np.ones((self.half_batch_size,1)))
        fake_loss = self.discriminator_model.train_on_batch(gen_outs, np.zeros((self.half_batch_size,1)))     


        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))

        if j%1000 == 0:
            test_data = ((self.x_test.astype(np.float32)-127.5)/127.5).reshape((-1, 784))
            test_results = self.classification_model.predict(test_data)
            test_results_argmax = np.argmax(test_results, axis = 1)

            count = 0
            for i in range(len(test_results_argmax)):
                if test_results_argmax[i] == self.y_test[i]:
                    count += 1
            print("Accuracy After", j,"iterations: ", (count/len(test_data))*100)

def train(self):

train_data, train_data_y = self.sample_1000(self.x_train, self.y_train)

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

train_data_y = to_categorical(train_data_y)

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

all_train_data_y = to_categorical(self.y_train)

for j 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))

batch_y = train_data_y[batch_indx]

batch_indx_total = np.random.randint(0, all_train_data.shape[0], size = (self.half_batch_size))

batch_x_total = all_train_data[batch_indx_total]

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

batch_y_total = all_train_data_y[batch_indx_total]

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))

classi_loss = self.classification_model.train_on_batch(batch_x, batch_y)

real_loss1 = self.discriminator_model.train_on_batch(batch_x_total, np.ones((self.half_batch_size,1)))

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

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))

if j%1000 == 0:

test_data = ((self.x_test.astype(np.float32)-127.5)/127.5).reshape((-1, 784))

test_results = self.classification_model.predict(test_data)

test_results_argmax = np.argmax(test_results, axis = 1)

count = 0

for i in range(len(test_results_argmax)):

if test_results_argmax[i] == self.y_test[i]:

count += 1

print("Accuracy After", j,"iterations: ", (count/len(test_data))*100)

I have also tested the SGAN model with 10000 test dataset provided by MNIST after every 1000 iteration. Here is the result of that.

Now you can see that I have trained this SGAN model with only 1000 labeled images and it gives an accuracy of about 94.8%, that is quite nice.

Give me 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
from keras.utils import to_categorical
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 = 100
        self.half_batch_size = 50
        self.latent_dim = 100
        self.iterations = 10000
        self.optimizer = Adam(0.0002, 0.5)
        self.generator_model = self.generator() 
        self.discriminator_model, self.classification_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)
        output2 = Dense(10, activation = 'softmax', name = 'classification_layer')(hidden3)
        disc_model = Model(input_disc, output)
        disc_model_2 = Model(input_disc, output2)
        disc_model.compile(loss=['binary_crossentropy'], optimizer=self.optimizer, metrics=['accuracy'])
        disc_model_2.compile(loss=['categorical_crossentropy'], optimizer=self.optimizer, metrics=['accuracy'])
        print(disc_model.summary())
        print(disc_model_2.summary())
        
        return disc_model, disc_model_2
    
    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 sample_1000(self, x, y):
        
        x_1000 = []
        y_1000 = []
        for i in range(10):
            x_i = x[y==i]
            ix = np.random.randint(0, len(x_i), 100)
            [x_1000.append(x_i[j]) for j in ix]
            [y_1000.append(i) for j in ix]
            
        return x_1000, y_1000
    
    def train(self):
        
        train_data, train_data_y = self.sample_1000(self.x_train, self.y_train)
        train_data = ((np.array(train_data).astype(np.float32))-127.5)/127.5
        train_data_y = to_categorical(train_data_y)
        
        all_train_data = ((np.array(self.x_train).astype(np.float32))-127.5)/127.5
        all_train_data_y = to_categorical(self.y_train)
        
        for j 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))
            batch_y = train_data_y[batch_indx]
            
            
            batch_indx_total = np.random.randint(0, all_train_data.shape[0], size = (self.half_batch_size))
            batch_x_total = all_train_data[batch_indx_total]
            batch_x_total = batch_x_total.reshape((-1, 784))
            batch_y_total = all_train_data_y[batch_indx_total]
            
            
            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))
            
            classi_loss = self.classification_model.train_on_batch(batch_x, batch_y)
            real_loss1 = self.discriminator_model.train_on_batch(batch_x_total, np.ones((self.half_batch_size,1)))
            fake_loss = self.discriminator_model.train_on_batch(gen_outs, np.zeros((self.half_batch_size,1)))     
        
            
            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))
            
            if j%1000 == 0:
                test_data = ((self.x_test.astype(np.float32)-127.5)/127.5).reshape((-1, 784))
                test_results = self.classification_model.predict(test_data)
                test_results_argmax = np.argmax(test_results, axis = 1)
                
                count = 0
                for i in range(len(test_results_argmax)):
                    if test_results_argmax[i] == self.y_test[i]:
                        count += 1
                print("Accuracy After", j,"iterations: ", (count/len(test_data))*100)
            
            
gan = GAN()
gan.train()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

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

from keras.models import Model

from keras.optimizers import Adam

from keras.datasets import mnist

from keras.utils import to_categorical

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 = 100

self.half_batch_size = 50

self.latent_dim = 100

self.iterations = 10000

self.optimizer = Adam(0.0002, 0.5)

self.generator_model = self.generator()

self.discriminator_model, self.classification_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)

output2 = Dense(10, activation = 'softmax', name = 'classification_layer')(hidden3)

disc_model = Model(input_disc, output)

disc_model_2 = Model(input_disc, output2)

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

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

print(disc_model.summary())

print(disc_model_2.summary())

return disc_model, disc_model_2

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 sample_1000(self, x, y):

x_1000 = []

y_1000 = []

for i in range(10):

x_i = x[y==i]

ix = np.random.randint(0, len(x_i), 100)

[x_1000.append(x_i[j]) for j in ix]

[y_1000.append(i) for j in ix]

return x_1000, y_1000

def train(self):

train_data, train_data_y = self.sample_1000(self.x_train, self.y_train)

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

train_data_y = to_categorical(train_data_y)

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

all_train_data_y = to_categorical(self.y_train)

for j 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))

batch_y = train_data_y[batch_indx]

batch_indx_total = np.random.randint(0, all_train_data.shape[0], size = (self.half_batch_size))

batch_x_total = all_train_data[batch_indx_total]

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

batch_y_total = all_train_data_y[batch_indx_total]

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))

classi_loss = self.classification_model.train_on_batch(batch_x, batch_y)

real_loss1 = self.discriminator_model.train_on_batch(batch_x_total, np.ones((self.half_batch_size,1)))

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

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))

if j%1000 == 0:

test_data = ((self.x_test.astype(np.float32)-127.5)/127.5).reshape((-1, 784))

test_results = self.classification_model.predict(test_data)

test_results_argmax = np.argmax(test_results, axis = 1)

count = 0

for i in range(len(test_results_argmax)):

if test_results_argmax[i] == self.y_test[i]:

count += 1

print("Accuracy After", j,"iterations: ", (count/len(test_data))*100)

gan = GAN()

gan.train()

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: keras Gan

Creating a Deep Convolutional Generative Adversarial Networks (DCGAN)

Implementing semi-supervised Learning using GANs

Implementing Semi-Supervised GAN

Give me the full code!