DCGAN_tensorflow (pclubiitk#16)

* Create DCGAN_tensorflow

* Add files via upload

* Delete DCGAN_tensorflow

* Update README.md

* Delete image_at_epoch_0001 - Copy.png

* Delete image_at_epoch_0002.png

* Delete image_at_epoch_0003.png

* Feat:Reqd Changes

* changes accompalished

* Update main.py

* Update README.md

Co-authored-by: Nirmal Suthar <[email protected]>

Author: shvmshri

generative_models/DCGAN_Tensorflow/README.md

@@ -0,0 +1,88 @@
+# TensorFlow Implementation of DCGAN 
+## Usage
+```bash
+$ python3 main.py --EPOCHS 50 --noise_dim 100
+```
+> **_NOTE:_** on Colab Notebook use following command:
+```python
+!git clone link-to-repo
+%run main.py --EPOCHS 50 --noise_dim 100
+```
+
+## Help log
+```
+usage: main.py [-h] [--EPOCHS EPOCHS]
+               [--noise_dim NOISE_DIM] 
+               [--BATCH_SIZE BATCH_SIZE] [--num_examples_to_generate num_examples_to_generate]
+               [--lr_gen lr_gen][--lr_disc lr_disc]
+               [--outdir OUTDIR]
+
+optional arguments:
+  -h, --help                   show this help message and exit
+  --EPOCHS EPOCHS              No of epochs: default 50 
+  --noise_dim NOISE_DIM        Dimension of noise vector
+  --batch_size BATCH_SIZE      Batch size, default 256
+  --num_examples_to_generate   no of images shown after each epoch in output, default 16
+  --lr_gen                     learning rate of generator's optimizer,default 0.0002
+  --lr_disc                    learning rate of discriminator's optimizer,default 0.0002
+  --outdir OUTDIR              Directory in which to store data
+                        
+  ```
+
+## Contributed by:
+* [Shivamshree Gupta](https://github.com/shvmshri)
+
+## References
+
+* **Title**: Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks
+* **Authors**: Alec Radford, Luke Metz, Soumith Chintala
+* **Link**: [https://arxiv.org/pdf/1511.06434.pdf](https://arxiv.org/pdf/1511.06434.pdf)
+* **Tags**: Neural Network, Generative Networks, GANs
+* **Year**: 2015
+
+## SUMMARY
+### *Deep Convolutional Generative Adversarial Networks*
+#### Introduction	
+One way to build good natural images is by training Generative Adversarial Networks (GANS). ,and we can later even reuse parts of the generator and discriminator networks as feature extractors for supervised tasks .DCGANs is actually one of the class of GANs using CNNs architecture for both of its components i.e.  a generator and a discriminator.
+#### Model Architecture	
+In general, GANs consist of a generator and a discriminator. These two are separately a CNN architecture and are trained together.
+
+![alt text](https://github.com/shvmshri/DCGAN_Tensorflow/blob/master/images/DG.png) 
+##### GENERATOR :
+A ANN model which is aimed for the generation of new images. They took in input a random noise z and various convolution transpose layers are applied and it generates a image i.e. a matrices of pixel values (G(z)) .Generator never get to see the real world actual images or the training dataset of images.
+##### DISCRIMINATOR:
+A CNN classification model used to classify whether an image passed to it is real or fake (generated by the generator).It take image from training examples x and from those generated by generator (G (z)) and predicts the probability of the image to be real (D(x)) or fake (D (G (z))).
+
+Now, while training the model, generator tries to increase the discriminator error as it tries to fool discriminator by improving its generated image so that they resemble real images while discriminator tries to decrease it’s error by trying to judge correctly the real and the fake images. For weights of the model normally initiated ,we first train generator say for y no. of images keeping the discriminator’s weights constant .Then, as generator’s weight are updated ,we train discriminator keeping generator’s weights to be constant for y fake and y real images and this process is then repeated for several epochs using cross entropy loss function.
+
+![alt text](https://github.com/shvmshri/DCGAN_Tensorflow/blob/master/images/loss%20eq.jpg) 
+
+This becomes a __minimax__ type loss function as above illustrated.
+
+#### Architecture guidelines for stable Deep Convolutional GANs
+  • Replace any pooling layers with strided convolutions (discriminator) and fractional-strided convolutions (generator).
+  • Use batchnorm in both the generator and the discriminator except at the generator’s output layer and discriminator’s input layer. 
+  • Remove fully connected hidden layers for deeper architectures. 
+  • Use ReLU activation in generator for all layers except for the output, which uses Tanh. 
+  • Use LeakyReLU activation in the discriminator for all layers.
+
+#### Implementation and Training details
+1.	Pre-processing -: scaling images to [-1 1]. No data augmentation.
+2.	Batch size -: 128.
+3.	Weights initialization -: using normal distribution.
+4.	LeakyReLU -: slope of leak=0.2.
+5.	Adam optimizer-: learning rate=0.0002, momentum=0.5.
+6.	Epochs -: 50.
+7.	Noise dimension -: 100
+
+#### Images generated of MNIST dataset after 50 epochs:
+
+![alt text](https://github.com/shvmshri/DCGAN_Tensorflow/blob/master/images/image_at_epoch_0050.png) 
+
+#### Plot of generator loss vs. discriminator loss
+
+![alt text](https://github.com/shvmshri/DCGAN_Tensorflow/blob/master/images/loss_plot.png) 
+
+## Sources
+1. [Deep Learning Part -II(CS7015),Lec-1](https://www.youtube.com/watch?v=1ju4qmdtRdY&t=142s)
+2. [Deep Learning Part -II(CS7015),Lec-2](https://www.youtube.com/watch?v=uyuYfTMHZM0)

generative_models/DCGAN_Tensorflow/assets/DG.png

@@ -0,0 +1,123 @@
+import tensorflow as tf
+import numpy as np
+import os
+import PIL
+from tensorflow.keras.models import Sequential, Model, load_model
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.losses import BinaryCrossentropy
+
+from MNIST_model import make_generator,make_discriminator
+from utils.py import plot_loss,generate_and_save_images
+import argparse
+
+parser = argparse.ArgumentParser()
+
+parser.add_argument('--EPOCHS', type = int, default = 50, help = "No of EPOCHS: default 50 ")
+parser.add_argument('--noise_dim', type = int, default = 100, help = "Noise dimension, default 100 ")
+parser.add_argument('--BATCH_SIZE', type = int, default = 128, help = "Batch size, default 128")
+parser.add_argument('--num_examples_to_generate', type = int, default = 16, help = "no of images shown after each epoch in output, default 16")
+parser.add_argument('--lr_gen', type = int, default = 0.0002, help = "Learning rate for generator optimizer,default 0.0002 ")
+parser.add_argument('--lr_disc', type = int, default = 0.0002, help = "Learning rate for discriminator optimizer,default 0.0002 ")
+parser.add_argument('--outdir', type = str, default = '.', help = "Directory in which to store data")
+
+args = parser.parse_args()
+
+# Loading  MNIST_Dataset
+(train_images, train_labels),(_,_) = tf.keras.datasets.mnist.load_data()
+
+BUFFER_SIZE=60000
+BATCH_SIZE = args.BATCH_SIZE
+EPOCHS = args.EPOCHS
+noise_dim = args.noise_dim
+num_examples_to_generate = args.num_examples_to_generate
+lr_gen = args.lr_gen
+lr_disc = args.lr_disc
+
+
+seed = tf.random.normal([num_examples_to_generate, noise_dim])
+
+# Preparing and Normalising Dataset
+train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
+train_images = (train_images - 127.5) / 127.5 
+train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
+
+# Making generator and Discriminator
+generator=make_generator(noise_dim)
+discriminator=make_discriminator()
+
+# Defining generator and discriminator losses
+cross_entropy = BinaryCrossentropy(from_logits=True)
+
+def discriminator_loss(real_output, fake_output):
+    real_loss = cross_entropy(tf.ones_like(real_output), real_output)
+    fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)
+    total_loss = real_loss + fake_loss
+    return total_loss
+
+def generator_loss(fake_output):
+    return cross_entropy(tf.ones_like(fake_output), fake_output)
+
+# Defining optimizers
+generator_optimizer = Adam(learning_rate=lr_gen)  
+discriminator_optimizer = Adam(learning_rate=lr_disc)
+
+# Saving Checkpoints
+checkpoint_dir = os.path.join(args.outdir, "training_checkpoints")
+checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")
+checkpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer,
+                                 discriminator_optimizer=discriminator_optimizer,
+                                 generator=generator,
+                                 discriminator=discriminator)
+
+# Defining Training Loop
+@tf.function
+def train_step(images):
+    noise = tf.random.normal([BATCH_SIZE, noise_dim])
+
+    with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
+      generated_images = generator(noise, training=True)
+
+      real_output = discriminator(images, training=True)
+      fake_output = discriminator(generated_images, training=True)
+
+      gen_loss = generator_loss(fake_output)
+      disc_loss = discriminator_loss(real_output, fake_output)
+
+      gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
+      gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
+
+      generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
+      discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))
+    return gen_loss,disc_loss
+
+def train(dataset, epochs):
+  for epoch in range(epochs):
+    gen_loss_list = []
+    disc_loss_list = []
+
+    for image_batch in dataset:
+      t=train_step(image_batch)
+      gen_loss_list.append(t[0])
+      disc_loss_list.append(t[1])
+
+    gen_loss = sum(gen_loss_list) / len(gen_loss_list)
+    disc_loss = sum(disc_loss_list) / len(disc_loss_list)
+
+    
+    print (f'Epoch {epoch+1}, gen loss={gen_loss},disc loss={disc_loss}')
+    
+    generate_and_save_images(generator,
+                             epoch + 1,
+                             seed)
+
+    # Save the model every 15 epochs
+    if (epoch + 1) % 15 == 0:
+      checkpoint.save(file_prefix = checkpoint_prefix)
+ 
+  return gen_loss_list,disc_loss_list            
+
+# Training our model
+plo=train(train_dataset, EPOCHS)
+
+#Ploting generator and discriminator losses
+plot_loss(plo[0],plo[1])

generative_models/DCGAN_Tensorflow/assets/image_at_epoch_0050.png

@@ -0,0 +1,62 @@
+# Importing Libraries
+
+import tensorflow as tf
+from tensorflow.keras.layers import Input, Reshape, Dropout, Dense ,Flatten
+from tensorflow.keras.layers import  BatchNormalization
+from tensorflow.keras.layers import LeakyReLU,ReLU
+from tensorflow.keras.layers import Conv2DTranspose,Conv2D
+from tensorflow.keras.models import Sequential, Model, load_model
+import numpy as np
+
+# Model of Generator
+
+def make_generator(noise_dim):
+  model=Sequential()
+
+  model.add(Dense(7*7*256,input_shape=(noise_dim)))
+  model.add(BatchNormalization(momentum=0.5))
+  model.add(ReLU())
+  
+  model.add(Reshape((7,7,256)))
+
+  model.add(Conv2DTranspose(128,(3,3),strides=(1,1),padding='same',use_bias='False'))
+  model.add(BatchNormalization(momentum=0.5))
+  model.add(ReLU())
+
+  model.add(Conv2DTranspose(64,(3,3),strides=(2,2),padding='same',use_bias='False'))
+  model.add(BatchNormalization(momentum=0.5))
+  model.add(ReLU())
+
+  model.add(Conv2DTranspose(1,(3,3),strides=(2,2),padding='same',use_bias='False',activation='tanh'))
+  return model
+
+# Model of discriminator
+
+def make_discriminator():
+  model=Sequential()
+
+  model.add(Conv2D(64,(3,3),strides=(2,2),padding='same',input_shape=[28,28,1]))
+  model.add(LeakyReLU(alpha= 0.2))
+  model.add(Dropout(0.3))
+
+  model.add(Conv2D(128,(3,3),strides=(2,2),padding='same'))
+  model.add(BatchNormalization(momentum=0.5))
+  model.add(LeakyReLU(alpha= 0.2))
+  model.add(Dropout(0.3))
+
+  model.add(Conv2D(256,(3,3),strides=(2,2),padding='same'))
+  model.add(BatchNormalization(momentum=0.5))
+  model.add(LeakyReLU(alpha= 0.2))
+  model.add(Dropout(0.3))
+
+  model.add(Conv2D(512,(3,3),strides=(2,2),padding='same'))
+  model.add(BatchNormalization(momentum=0.5))
+  model.add(LeakyReLU(alpha= 0.2))
+  model.add(Dropout(0.3))
+
+  model.add(Flatten())
+  model.add(Dense(1))
+
+  return model
+
+

generative_models/DCGAN_Tensorflow/assets/loss eq.jpg

@@ -0,0 +1,33 @@
+import PIL
+import matplotlib.pyplot as plt
+from IPython import display
+from tensorflow.keras.models import Sequential, Model, load_model
+
+# Generate and save images
+def generate_and_save_images(model, epoch, test_input):
+  # Notice `training` is set to False.
+  # This is so all layers run in inference mode (batchnorm).
+  predictions = model(test_input, training=False)
+
+  fig = plt.figure(figsize=(4,4))
+
+  for i in range(predictions.shape[0]):
+      plt.subplot(4, 4, i+1)
+      plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')
+      plt.axis('off')
+
+  plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))
+  plt.show()
+
+# Plotting generator losses and discriminator losses
+def plot_loss(gen,disc):
+  plt.figure(figsize=(10,5))
+  plt.title("Generator and Discriminator Loss During Training")
+  plt.plot(gen,label="G")
+  plt.plot(disc,label="D")
+  plt.xlabel("iterations")
+  plt.ylabel("Loss")
+  plt.legend()
+  plt.savefig('loss_plot.png')
+  plt.show()
+