GAN(MNIST).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Neel7317/Generative-Models/blob/main/GAN(MNIST).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qiEt9jGIe59W"
      },
      "outputs": [],
      "source": [
        "#basic GAN on mnist dataset..\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "cO5wRjJcffDj"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# To generate GIFs\n",
        "!pip install imageio\n",
        "!pip install git+https://github.com/tensorflow/docs"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8PWMLyWUgNq5",
        "outputId": "b91bb8aa-6051-4761-dc42-56c7d8e7c2f9"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: imageio in /usr/local/lib/python3.7/dist-packages (2.4.1)\n",
            "Requirement already satisfied: pillow in /usr/local/lib/python3.7/dist-packages (from imageio) (7.1.2)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from imageio) (1.21.5)\n",
            "Collecting git+https://github.com/tensorflow/docs\n",
            "  Cloning https://github.com/tensorflow/docs to /tmp/pip-req-build-w71ks47s\n",
            "  Running command git clone -q https://github.com/tensorflow/docs /tmp/pip-req-build-w71ks47s\n",
            "Requirement already satisfied: astor in /usr/local/lib/python3.7/dist-packages (from tensorflow-docs==0.0.0.dev0) (0.8.1)\n",
            "Requirement already satisfied: absl-py in /usr/local/lib/python3.7/dist-packages (from tensorflow-docs==0.0.0.dev0) (1.0.0)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from tensorflow-docs==0.0.0.dev0) (2.11.3)\n",
            "Requirement already satisfied: protobuf>=3.14 in /usr/local/lib/python3.7/dist-packages (from tensorflow-docs==0.0.0.dev0) (3.17.3)\n",
            "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from tensorflow-docs==0.0.0.dev0) (3.13)\n",
            "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.7/dist-packages (from protobuf>=3.14->tensorflow-docs==0.0.0.dev0) (1.15.0)\n",
            "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.7/dist-packages (from jinja2->tensorflow-docs==0.0.0.dev0) (2.0.1)\n",
            "Building wheels for collected packages: tensorflow-docs\n",
            "  Building wheel for tensorflow-docs (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for tensorflow-docs: filename=tensorflow_docs-0.0.0.dev0-py3-none-any.whl size=178325 sha256=2b8cd563150cf9c3048ce15387c00f814c7f614f573a2dfff4594b9f86e3f843\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-t1veuqir/wheels/cc/c4/d8/5341e93b6376c5c929c49469fce21155eb69cef1a4da4ce32c\n",
            "Successfully built tensorflow-docs\n",
            "Installing collected packages: tensorflow-docs\n",
            "Successfully installed tensorflow-docs-0.0.0.dev0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import glob\n",
        "import imageio\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import os\n",
        "import PIL\n",
        "from tensorflow.keras import layers\n",
        "import time\n",
        "\n",
        "from IPython import display"
      ],
      "metadata": {
        "id": "USVJCoWVgej-"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "(train_images, train_labels), (_, _) = tf.keras.datasets.mnist.load_data()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fupDaE_6gB4T",
        "outputId": "04cc2f12-d929-4bb5-a665-33d81a3c9ee8"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "11493376/11490434 [==============================] - 0s 0us/step\n",
            "11501568/11490434 [==============================] - 0s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_images.shape[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PhvX2MOkhGz8",
        "outputId": "b88a4c94-a0e0-4b89-aa94-3e2519384941"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "60000"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')\n",
        "train_images = (train_images - 127.5) / 127.5  # Normalize the images to [-1, 1]"
      ],
      "metadata": {
        "id": "53vF1jVAghps"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "BUFFER_SIZE = 60000\n",
        "BATCH_SIZE = 256"
      ],
      "metadata": {
        "id": "6NrQfC3shECJ"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Batch and shuffle the data\n",
        "train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)"
      ],
      "metadata": {
        "id": "pC-xxzkyhSFb"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def make_generator_model():\n",
        "    model = tf.keras.Sequential()\n",
        "    model.add(layers.Dense(7*7*256, use_bias=False, input_shape=(100,)))\n",
        "    model.add(layers.BatchNormalization())\n",
        "    model.add(layers.LeakyReLU())\n",
        "\n",
        "    model.add(layers.Reshape((7, 7, 256)))\n",
        "    assert model.output_shape == (None, 7, 7, 256)  # Note: None is the batch size\n",
        "\n",
        "    model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))\n",
        "    assert model.output_shape == (None, 7, 7, 128)\n",
        "    model.add(layers.BatchNormalization())\n",
        "    model.add(layers.LeakyReLU())\n",
        "\n",
        "    model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))\n",
        "    assert model.output_shape == (None, 14, 14, 64)\n",
        "    model.add(layers.BatchNormalization())\n",
        "    model.add(layers.LeakyReLU())\n",
        "\n",
        "    model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))\n",
        "    assert model.output_shape == (None, 28, 28, 1)\n",
        "\n",
        "    return model"
      ],
      "metadata": {
        "id": "NXDyOgQ2hXhB"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "generator = make_generator_model()\n",
        "\n",
        "noise = tf.random.normal([1, 100])\n",
        "generated_image = generator(noise, training=False)\n",
        "\n",
        "plt.imshow(generated_image[0, :, :, 0], cmap='gray')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "YpnFzHQMhjs0",
        "outputId": "a7821ae2-87f8-43c5-c8d3-30e1788d6640"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7fa3cb0a9950>"
            ]
          },
          "metadata": {},
          "execution_count": 12
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def make_discriminator_model():\n",
        "    model = tf.keras.Sequential()\n",
        "    model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same',\n",
        "                                     input_shape=[28, 28, 1]))\n",
        "    model.add(layers.LeakyReLU())\n",
        "    model.add(layers.Dropout(0.3))\n",
        "\n",
        "    model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'))\n",
        "    model.add(layers.LeakyReLU())\n",
        "    model.add(layers.Dropout(0.3))\n",
        "\n",
        "    model.add(layers.Flatten())\n",
        "    model.add(layers.Dense(1))\n",
        "\n",
        "    return model"
      ],
      "metadata": {
        "id": "BxHraGZqhy1b"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "discriminator = make_discriminator_model()\n",
        "decision = discriminator(generated_image)\n",
        "print (decision)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f_jOda4Fh5f8",
        "outputId": "c8e39118-e524-4b95-baa2-c4ecfe6ee8f9"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([[0.00118266]], shape=(1, 1), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# This method returns a helper function to compute cross entropy loss\n",
        "cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)"
      ],
      "metadata": {
        "id": "p1Kfe92tiDqG"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def discriminator_loss(real_output, fake_output):\n",
        "    real_loss = cross_entropy(tf.ones_like(real_output), real_output)\n",
        "    fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)\n",
        "    total_loss = real_loss + fake_loss\n",
        "    return total_loss"
      ],
      "metadata": {
        "id": "G5PiTTWEiICz"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def generator_loss(fake_output):\n",
        "    return cross_entropy(tf.ones_like(fake_output), fake_output)"
      ],
      "metadata": {
        "id": "1DXwER3liKE_"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "generator_optimizer = tf.keras.optimizers.Adam(1e-4)\n",
        "discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)"
      ],
      "metadata": {
        "id": "iKz_2Gz8ic5B"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "checkpoint_dir = './training_checkpoints'\n",
        "checkpoint_prefix = os.path.join(checkpoint_dir, \"ckpt\")\n",
        "checkpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer,\n",
        "                                 discriminator_optimizer=discriminator_optimizer,\n",
        "                                 generator=generator,\n",
        "                                 discriminator=discriminator)"
      ],
      "metadata": {
        "id": "X9C5QB8wie-d"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "EPOCHS = 50\n",
        "noise_dim = 100\n",
        "num_examples_to_generate = 16\n",
        "\n",
        "# You will reuse this seed overtime (so it's easier)\n",
        "# to visualize progress in the animated GIF)\n",
        "seed = tf.random.normal([num_examples_to_generate, noise_dim])"
      ],
      "metadata": {
        "id": "7rciQg5diosN"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Notice the use of `tf.function`\n",
        "# This annotation causes the function to be \"compiled\".\n",
        "@tf.function\n",
        "def train_step(images):\n",
        "    noise = tf.random.normal([BATCH_SIZE, noise_dim])\n",
        "\n",
        "    with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:\n",
        "      generated_images = generator(noise, training=True)\n",
        "\n",
        "      real_output = discriminator(images, training=True)\n",
        "      fake_output = discriminator(generated_images, training=True)\n",
        "\n",
        "      gen_loss = generator_loss(fake_output)\n",
        "      disc_loss = discriminator_loss(real_output, fake_output)\n",
        "\n",
        "    gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)\n",
        "    gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)\n",
        "\n",
        "    generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))\n",
        "    discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))"
      ],
      "metadata": {
        "id": "C7G4vkuiir14"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train(dataset, epochs):\n",
        "  for epoch in range(epochs):\n",
        "    start = time.time()\n",
        "\n",
        "    for image_batch in dataset:\n",
        "      train_step(image_batch)\n",
        "\n",
        "    # Produce images for the GIF as you go\n",
        "    display.clear_output(wait=True)\n",
        "    generate_and_save_images(generator,\n",
        "                             epoch + 1,\n",
        "                             seed)\n",
        "\n",
        "    # Save the model every 15 epochs\n",
        "    if (epoch + 1) % 15 == 0:\n",
        "      checkpoint.save(file_prefix = checkpoint_prefix)\n",
        "\n",
        "    print ('Time for epoch {} is {} sec'.format(epoch + 1, time.time()-start))\n",
        "\n",
        "  # Generate after the final epoch\n",
        "  display.clear_output(wait=True)\n",
        "  generate_and_save_images(generator,\n",
        "                           epochs,\n",
        "                           seed)"
      ],
      "metadata": {
        "id": "SqeofP-jjGKw"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_and_save_images(model, epoch, test_input):\n",
        "  # Notice `training` is set to False.\n",
        "  # This is so all layers run in inference mode (batchnorm).\n",
        "  predictions = model(test_input, training=False)\n",
        "\n",
        "  fig = plt.figure(figsize=(4, 4))\n",
        "\n",
        "  for i in range(predictions.shape[0]):\n",
        "      plt.subplot(4, 4, i+1)\n",
        "      plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')\n",
        "      plt.axis('off')\n",
        "\n",
        "  plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))\n",
        "  plt.show()"
      ],
      "metadata": {
        "id": "TCjwmZ_PjJ0M"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train(train_dataset, EPOCHS)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 248
        },
        "id": "AHy3fLQXjOZG",
        "outputId": "acf0c8c3-b365-499b-9a76-fe75ea17596a"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 288x288 with 16 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "xAi0qChVjWDF"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "GAN(MNIST).ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPIED7xbe54neNlEAE6UIAu",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}