06-gan-mnist.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled6.ipynb",
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyPTIhCmhK+coe8DwJ5B3znq",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/changsin/DeepLearning-101/blob/master/06-gan-mnist.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IjDY9fE2ua39"
      },
      "source": [
        "Modified from the TensorFlow tutorial [dcgan](https://www.tensorflow.org/tutorials/generative/dcgan)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sPQeTgrYuS4L"
      },
      "source": [
        "import tensorflow as tf\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "from tensorflow.keras import backend as K\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"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q72KjBwz05e0"
      },
      "source": [
        "NUM_OF_CLASSES = 10\n",
        "BATCH_SIZE = 128\n",
        "EPOCHS = 10\n",
        "BUFFER_SIZE = 60000\n",
        "\n",
        "# input image dimensions\n",
        "IMG_ROWS, IMG_COLS = 28, 28"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HmIqNpFZvnPp"
      },
      "source": [
        "mnist = tf.keras.datasets.mnist\n",
        "\n",
        "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
        "x_train, x_test = x_train / 255.0, x_test / 255.0\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F6cxGOWa8LaP"
      },
      "source": [
        "train_images = x_train.reshape(x_train.shape[0], 28, 28, 1).astype('float32')\n",
        "train_images = (train_images - 127.5) / 127.5 # Normalize the images to [-1, 1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WHdF_z4Fu_Qs",
        "outputId": "e206af87-5ecf-49a0-abbb-3ad32480beaf"
      },
      "source": [
        "print(x_train.shape)\n",
        "print(y_train.shape)\n",
        "print(x_test.shape)\n",
        "print(y_test.shape)\n",
        "print(train_images.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(60000, 28, 28, 1)\n",
            "(60000, 10)\n",
            "(10000, 28, 28, 1)\n",
            "(10000, 10)\n",
            "(60000, 28, 28, 1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bPkNEkqo2fz6"
      },
      "source": [
        "# Batch and shuffle the data\n",
        "train_dataset = tf.data.Dataset.from_tensor_slices(x_train).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "83wKlC7b09tp"
      },
      "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"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "8do2i0Dp1Xws",
        "outputId": "76613693-9217-4e6b-b4f4-f578385b6303"
      },
      "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')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7fac9e08a780>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8MhW01M61bS1"
      },
      "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"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5V6Ghitw1s-Y",
        "outputId": "a79c329e-6bfa-46a6-e924-46d37881f569"
      },
      "source": [
        "discriminator = make_discriminator_model()\n",
        "decision = discriminator(generated_image)\n",
        "print (decision)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tf.Tensor([[0.00310771]], shape=(1, 1), dtype=float32)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "18nkYs2H1vlq"
      },
      "source": [
        "# This method returns a helper function to compute cross entropy loss\n",
        "cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KC0HXIOT1ytw"
      },
      "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"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mblULdaC11Ff"
      },
      "source": [
        "def generator_loss(fake_output):\n",
        "    return cross_entropy(tf.ones_like(fake_output), fake_output)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RQEHgfbT13WA"
      },
      "source": [
        "generator_optimizer = tf.keras.optimizers.Adam(1e-4)\n",
        "discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pxM1X4ZU15hK"
      },
      "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)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C_FJjELN19BA"
      },
      "source": [
        "noise_dim = 100\n",
        "num_examples_to_generate = 16\n",
        "\n",
        "# We 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])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rJB7SSFd1_8B"
      },
      "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))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Goi2RFll2DX9"
      },
      "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 we 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)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cTWUA6Jw2Ggb"
      },
      "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()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "cfMrvVXT2JO4",
        "outputId": "5dc86e79-4f04-4b0e-c9bd-c558008c5ded"
      },
      "source": [
        "train(train_dataset, EPOCHS)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 288x288 with 16 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Time for epoch 4 is 723.7415263652802 sec\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YtX_bjdq5hSE"
      },
      "source": [
        "checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z921c7J05n2z"
      },
      "source": [
        "# Display a single image using the epoch number\n",
        "def display_image(epoch_no):\n",
        "  return PIL.Image.open('image_at_epoch_{:04d}.png'.format(epoch_no))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mGsu_nQL5re5"
      },
      "source": [
        "display_image(EPOCHS)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MsmsO3ss2MWw"
      },
      "source": [
        "anim_file = 'dcgan.gif'\n",
        "\n",
        "with imageio.get_writer(anim_file, mode='I') as writer:\n",
        "  filenames = glob.glob('image*.png')\n",
        "  filenames = sorted(filenames)\n",
        "  for filename in filenames:\n",
        "    image = imageio.imread(filename)\n",
        "    writer.append_data(image)\n",
        "  image = imageio.imread(filename)\n",
        "  writer.append_data(image)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kokxnAa73JCY"
      },
      "source": [
        "import tensorflow_docs.vis.embed as embed\n",
        "embed.embed_file(anim_file)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}