GAN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f2fc2f49-7c38-4399-b919-22a78cc5c30c",
   "metadata": {},
   "source": [
    "# 1. Setting up"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae49d0b5-b33e-423b-96e5-5968b1426ca3",
   "metadata": {},
   "source": [
    "### Original tutorial:\n",
    "https://www.tensorflow.org/tutorials/generative/dcgan\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bb8128dd-c9a2-41e3-bcb6-6cb1491650f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cca1f6fe-f116-447e-81cd-df3f24103a6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.16.1'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f0ac2498-a969-4e59-8f3a-af8326cbabca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: imageio in /Users/sookim/miniconda3/lib/python3.12/site-packages (2.34.0)\n",
      "Requirement already satisfied: glob2 in /Users/sookim/miniconda3/lib/python3.12/site-packages (0.7)\n",
      "Requirement already satisfied: matplotlib in /Users/sookim/miniconda3/lib/python3.12/site-packages (3.8.4)\n",
      "Requirement already satisfied: numpy in /Users/sookim/miniconda3/lib/python3.12/site-packages (1.26.4)\n",
      "Requirement already satisfied: pillow in /Users/sookim/miniconda3/lib/python3.12/site-packages (10.2.0)\n",
      "Requirement already satisfied: TIME-python in /Users/sookim/miniconda3/lib/python3.12/site-packages (0.0.17)\n",
      "Requirement already satisfied: contourpy>=1.0.1 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from matplotlib) (1.2.0)\n",
      "Requirement already satisfied: cycler>=0.10 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from matplotlib) (0.12.1)\n",
      "Requirement already satisfied: fonttools>=4.22.0 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from matplotlib) (4.50.0)\n",
      "Requirement already satisfied: kiwisolver>=1.3.1 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from matplotlib) (1.4.5)\n",
      "Requirement already satisfied: packaging>=20.0 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from matplotlib) (23.1)\n",
      "Requirement already satisfied: pyparsing>=2.3.1 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from matplotlib) (3.1.2)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from matplotlib) (2.9.0.post0)\n",
      "Requirement already satisfied: dipy in /Users/sookim/miniconda3/lib/python3.12/site-packages (from TIME-python) (1.9.0)\n",
      "Requirement already satisfied: nibabel in /Users/sookim/miniconda3/lib/python3.12/site-packages (from TIME-python) (5.2.1)\n",
      "Requirement already satisfied: scipy in /Users/sookim/miniconda3/lib/python3.12/site-packages (from TIME-python) (1.12.0)\n",
      "Requirement already satisfied: six>=1.5 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n",
      "Requirement already satisfied: h5py>=3.1.0 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from dipy->TIME-python) (3.10.0)\n",
      "Requirement already satisfied: tqdm>=4.30.0 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from dipy->TIME-python) (4.65.0)\n",
      "Requirement already satisfied: trx-python>=0.2.9 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from dipy->TIME-python) (0.2.9)\n",
      "Requirement already satisfied: setuptools-scm in /Users/sookim/miniconda3/lib/python3.12/site-packages (from trx-python>=0.2.9->dipy->TIME-python) (8.0.4)\n",
      "Requirement already satisfied: deepdiff in /Users/sookim/miniconda3/lib/python3.12/site-packages (from trx-python>=0.2.9->dipy->TIME-python) (7.0.0)\n",
      "Requirement already satisfied: ordered-set<4.2.0,>=4.1.0 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from deepdiff->trx-python>=0.2.9->dipy->TIME-python) (4.1.0)\n",
      "Requirement already satisfied: setuptools in /Users/sookim/miniconda3/lib/python3.12/site-packages (from setuptools-scm->trx-python>=0.2.9->dipy->TIME-python) (68.2.2)\n",
      "Requirement already satisfied: typing-extensions in /Users/sookim/miniconda3/lib/python3.12/site-packages (from setuptools-scm->trx-python>=0.2.9->dipy->TIME-python) (4.10.0)\n",
      "Collecting git+https://github.com/tensorflow/docs\n",
      "  Cloning https://github.com/tensorflow/docs to /private/var/folders/5m/7g056w7s7017wgnsbq1hvfwr0000gn/T/pip-req-build-kf0x75z8\n",
      "  Running command git clone --filter=blob:none --quiet https://github.com/tensorflow/docs /private/var/folders/5m/7g056w7s7017wgnsbq1hvfwr0000gn/T/pip-req-build-kf0x75z8\n",
      "  Resolved https://github.com/tensorflow/docs to commit ec3a1b3f9a604c6cd26c7537f2b9fd270a3eedbf\n",
      "  Preparing metadata (setup.py) ... \u001b[?25ldone\n",
      "\u001b[?25hRequirement already satisfied: astor in /Users/sookim/miniconda3/lib/python3.12/site-packages (from tensorflow-docs==2024.3.27.3713) (0.8.1)\n",
      "Requirement already satisfied: absl-py in /Users/sookim/miniconda3/lib/python3.12/site-packages (from tensorflow-docs==2024.3.27.3713) (1.4.0)\n",
      "Requirement already satisfied: jinja2 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from tensorflow-docs==2024.3.27.3713) (3.1.3)\n",
      "Requirement already satisfied: nbformat in /Users/sookim/miniconda3/lib/python3.12/site-packages (from tensorflow-docs==2024.3.27.3713) (5.10.3)\n",
      "Requirement already satisfied: protobuf>=3.12 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from tensorflow-docs==2024.3.27.3713) (3.20.3)\n",
      "Requirement already satisfied: pyyaml in /Users/sookim/miniconda3/lib/python3.12/site-packages (from tensorflow-docs==2024.3.27.3713) (6.0.1)\n",
      "Requirement already satisfied: MarkupSafe>=2.0 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from jinja2->tensorflow-docs==2024.3.27.3713) (2.1.5)\n",
      "Requirement already satisfied: fastjsonschema in /Users/sookim/miniconda3/lib/python3.12/site-packages (from nbformat->tensorflow-docs==2024.3.27.3713) (2.19.1)\n",
      "Requirement already satisfied: jsonschema>=2.6 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from nbformat->tensorflow-docs==2024.3.27.3713) (4.21.1)\n",
      "Requirement already satisfied: jupyter-core in /Users/sookim/miniconda3/lib/python3.12/site-packages (from nbformat->tensorflow-docs==2024.3.27.3713) (5.7.2)\n",
      "Requirement already satisfied: traitlets>=5.1 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from nbformat->tensorflow-docs==2024.3.27.3713) (5.14.2)\n",
      "Requirement already satisfied: attrs>=22.2.0 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from jsonschema>=2.6->nbformat->tensorflow-docs==2024.3.27.3713) (23.2.0)\n",
      "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from jsonschema>=2.6->nbformat->tensorflow-docs==2024.3.27.3713) (2023.12.1)\n",
      "Requirement already satisfied: referencing>=0.28.4 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from jsonschema>=2.6->nbformat->tensorflow-docs==2024.3.27.3713) (0.34.0)\n",
      "Requirement already satisfied: rpds-py>=0.7.1 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from jsonschema>=2.6->nbformat->tensorflow-docs==2024.3.27.3713) (0.18.0)\n",
      "Requirement already satisfied: platformdirs>=2.5 in /Users/sookim/miniconda3/lib/python3.12/site-packages (from jupyter-core->nbformat->tensorflow-docs==2024.3.27.3713) (3.10.0)\n"
     ]
    }
   ],
   "source": [
    "# To generate GIFs\n",
    "!pip install imageio glob2 matplotlib numpy pillow TIME-python\n",
    "!pip install git+https://github.com/tensorflow/docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e7e6b9e2-c6be-4612-9054-2534ec539515",
   "metadata": {},
   "outputs": [],
   "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",
    "from IPython import display"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5773f7af-5e5b-40bd-8c1b-647b094e2e2c",
   "metadata": {},
   "source": [
    "## 2. Load and prepare the dataset\n",
    "You will use the MNIST dataset to train the generator and the discriminator. The generator will generate handwritten digits resembling the MNIST data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d84d9bf5-05e6-4f76-814c-69ad71d4da56",
   "metadata": {},
   "outputs": [],
   "source": [
    "(train_images, train_labels), (_, _) = tf.keras.datasets.mnist.load_data()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6137fe34-f102-449e-af0c-7c717af71efa",
   "metadata": {},
   "outputs": [],
   "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]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f75c3f59-57a6-45a7-b79c-08d7b6dd048d",
   "metadata": {},
   "outputs": [],
   "source": [
    "BUFFER_SIZE = 60000\n",
    "BATCH_SIZE = 256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7c09ebf5-1cda-4783-8020-b61628f2c6b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Batch and shuffle the data\n",
    "train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80d73e5f-72a2-4169-b550-6c6bf000134c",
   "metadata": {},
   "source": [
    "## 3. Create the models\n",
    "Both the generator and discriminator are defined using the Keras Sequential API.\n",
    "### The Generator\n",
    "The generator uses tf.keras.layers.Conv2DTranspose (upsampling) layers to produce an image from a seed (random noise). Start with a Dense layer that takes this seed as input, then upsample several times until you reach the desired image size of 28x28x1. Notice the tf.keras.layers.LeakyReLU activation for each layer, except the output layer which uses tanh.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "44a31353-6e79-4ad6-88f3-31a454bc0ed3",
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9f55ef8-18b5-4278-93f9-b5a9073fc0df",
   "metadata": {},
   "source": [
    "### lets test it out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a2adeda0-bf67-485a-8fe5-9be405bc332a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 28, 28, 1)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/sookim/miniconda3/lib/python3.12/site-packages/keras/src/layers/core/dense.py:88: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
      "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "generator = make_generator_model()\n",
    "\n",
    "noise = tf.random.normal([1, 100])\n",
    "generated_image = generator(noise, training=False)\n",
    "print(generated_image.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "49346ca8-4a8b-41e3-a6b4-10fff0bd33be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x28cf68a70>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(generated_image[0, :, :, 0], cmap='gray')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fec2606f-8b39-4db5-9a60-1f47617c0214",
   "metadata": {},
   "source": [
    "### The Discriminator\n",
    "The discriminator is a CNN-based image classifier.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d258e8da-8fde-41b3-ae4d-584986fb3fe7",
   "metadata": {},
   "outputs": [],
   "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",
    "    model.add(layers.Softmax())\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41249ad2-e422-4a43-917f-823212dabd74",
   "metadata": {},
   "source": [
    "### Let's test it out again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "169cf2c2-0ac5-46f2-8ab7-858fc3d8965a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([[1.]], shape=(1, 1), dtype=float32)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/sookim/miniconda3/lib/python3.12/site-packages/keras/src/layers/convolutional/base_conv.py:99: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
      "  super().__init__(\n",
      "/Users/sookim/miniconda3/lib/python3.12/site-packages/keras/src/ops/nn.py:545: UserWarning: You are using a softmax over axis -1 of a tensor of shape (1, 1). This axis has size 1. The softmax operation will always return the value 1, which is likely not what you intended. Did you mean to use a sigmoid instead?\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "discriminator = make_discriminator_model()\n",
    "decision = discriminator(generated_image)\n",
    "print (decision)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c87f4a16-b9fc-41dd-ba09-499c66ffaa10",
   "metadata": {},
   "source": [
    "### Loss is the main thing in GAN:\n",
    "Define the loss and optimizers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "adc34ece-a619-430e-9452-60ca4e1f80a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This method returns a helper function to compute cross entropy loss\n",
    "cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd7ba498-15f7-4848-ab3d-d79b652397e6",
   "metadata": {},
   "source": [
    "### Discriminator loss\n",
    "This method quantifies how well the discriminator is able to distinguish real images from fakes. It compares the discriminator's predictions on real images to an array of 1s, and the discriminator's predictions on fake (generated) images to an array of 0s.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "2afd2faa-1af1-4677-b4e7-422aaf290e67",
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59acef88-0bce-4a67-81e8-9003f5b76976",
   "metadata": {},
   "source": [
    "### Generator loss\n",
    "The generator's loss quantifies how well it was able to trick the discriminator. Intuitively, if the generator is performing well, the discriminator will classify the fake images as real (or 1). Here, compare the discriminators decisions on the generated images to an array of 1s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b6399647-83d4-4e8a-a67a-313f9091392c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator_loss(fake_output):\n",
    "    return cross_entropy(tf.ones_like(fake_output), fake_output)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3ca92e6-5b51-4d8e-b1d6-56c57f2a1067",
   "metadata": {},
   "source": [
    "### (Important!) The discriminator and the generator optimizers are different since you will train two networks separately.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "eed9b120-5514-4582-8f13-8d9d3f09af0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "generator_optimizer = tf.keras.optimizers.Adam(1e-4)\n",
    "discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "976ded4e-b6c3-4ff7-84ba-bf0ba1f2ecbb",
   "metadata": {},
   "source": [
    "### save checkpoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0f16f31e-47a5-4a1a-8e1d-6defd9916650",
   "metadata": {},
   "outputs": [],
   "source": [
    "checkpoint_dir = './'\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)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e32f565e-4b1a-472f-abdf-4d47d126caba",
   "metadata": {},
   "source": [
    "### training loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f8c5c9c2-23b1-47a0-94b9-4e8e7a49cbb8",
   "metadata": {},
   "outputs": [],
   "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])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "dd994e7b-fd30-434a-bbaf-bb9c79a415c6",
   "metadata": {},
   "outputs": [],
   "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))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "e594857c-695d-4b0a-a1a1-f96e826d34ad",
   "metadata": {},
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "00a5a1e3-eba1-44aa-975e-8d15d65077aa",
   "metadata": {},
   "outputs": [],
   "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()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "510133b6-d427-429e-8bfc-bd97304d6859",
   "metadata": {},
   "source": [
    "### Train the model\n",
    "Call the train() method defined above to train the generator and discriminator simultaneously. Note, training GANs can be tricky. It's important that the generator and discriminator do not overpower each other (e.g., that they train at a similar rate).\n",
    "\n",
    "At the beginning of the training, the generated images look like random noise. As training progresses, the generated digits will look increasingly real. After about 50 epochs, they resemble MNIST digits. This may take about one minute / epoch with the default settings on Colab."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e13090ab-335d-4d89-8f2d-0f58ccab1b18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train(train_dataset, EPOCHS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e190595d-6f35-496d-8dcc-9064bb6847e4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f73057db-4fa2-4610-8537-e29842a9e633",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}