{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "_jQ1tEQCxwRx" }, "source": [ "##### Copyright 2019 The TensorFlow Authors." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "cellView": "form", "execution": { "iopub.execute_input": "2024-03-19T05:37:16.685545Z", "iopub.status.busy": "2024-03-19T05:37:16.685323Z", "iopub.status.idle": "2024-03-19T05:37:16.688808Z", "shell.execute_reply": "2024-03-19T05:37:16.688223Z" }, "id": "V_sgB_5dx1f1" }, "outputs": [], "source": [ "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n", "# you may not use this file except in compliance with the License.\n", "# You may obtain a copy of the License at\n", "#\n", "# https://www.apache.org/licenses/LICENSE-2.0\n", "#\n", "# Unless required by applicable law or agreed to in writing, software\n", "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", "# See the License for the specific language governing permissions and\n", "# limitations under the License." ] }, { "cell_type": "markdown", "metadata": { "id": "rF2x3qooyBTI" }, "source": [ "# Deep Convolutional Generative Adversarial Network" ] }, { "cell_type": "markdown", "metadata": { "id": "0TD5ZrvEMbhZ" }, "source": [ "\n", " \n", " \n", " \n", " \n", "
\n", " \n", " \n", " View on TensorFlow.org\n", " \n", " \n", " \n", " Run in Google Colab\n", " \n", " \n", " \n", " View source on GitHub\n", " \n", " Download notebook\n", "
" ] }, { "cell_type": "markdown", "metadata": { "id": "ITZuApL56Mny" }, "source": [ "This tutorial demonstrates how to generate images of handwritten digits using a [Deep Convolutional Generative Adversarial Network](https://arxiv.org/pdf/1511.06434.pdf) (DCGAN). The code is written using the [Keras Sequential API](https://www.tensorflow.org/guide/keras) with a `tf.GradientTape` training loop." ] }, { "cell_type": "markdown", "metadata": { "id": "2MbKJY38Puy9" }, "source": [ "## What are GANs?\n", "[Generative Adversarial Networks](https://arxiv.org/abs/1406.2661) (GANs) are one of the most interesting ideas in computer science today. Two models are trained simultaneously by an adversarial process. A *generator* (\"the artist\") learns to create images that look real, while a *discriminator* (\"the art critic\") learns to tell real images apart from fakes.\n", "\n", "![A diagram of a generator and discriminator](./images/gan1.png)\n", "\n", "During training, the *generator* progressively becomes better at creating images that look real, while the *discriminator* becomes better at telling them apart. The process reaches equilibrium when the *discriminator* can no longer distinguish real images from fakes.\n", "\n", "![A second diagram of a generator and discriminator](./images/gan2.png)\n", "\n", "This notebook demonstrates this process on the MNIST dataset. The following animation shows a series of images produced by the *generator* as it was trained for 50 epochs. The images begin as random noise, and increasingly resemble hand written digits over time.\n", "\n", "![sample output](https://tensorflow.org/images/gan/dcgan.gif)\n", "\n", "To learn more about GANs, see MIT's [Intro to Deep Learning](http://introtodeeplearning.com/) course." ] }, { "cell_type": "markdown", "metadata": { "id": "e1_Y75QXJS6h" }, "source": [ "### Setup" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:16.692567Z", "iopub.status.busy": "2024-03-19T05:37:16.692279Z", "iopub.status.idle": "2024-03-19T05:37:19.115764Z", "shell.execute_reply": "2024-03-19T05:37:19.114995Z" }, "id": "WZKbyU2-AiY-" }, "outputs": [], "source": [ "import tensorflow as tf" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:19.119956Z", "iopub.status.busy": "2024-03-19T05:37:19.119579Z", "iopub.status.idle": "2024-03-19T05:37:19.126791Z", "shell.execute_reply": "2024-03-19T05:37:19.126143Z" }, "id": "wx-zNbLqB4K8" }, "outputs": [ { "data": { "text/plain": [ "'2.16.1'" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tf.__version__" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:19.165786Z", "iopub.status.busy": "2024-03-19T05:37:19.165378Z", "iopub.status.idle": "2024-03-19T05:37:26.381027Z", "shell.execute_reply": "2024-03-19T05:37:26.380121Z" }, "id": "YzTlj4YdCip_" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: imageio in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (2.34.0)\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: numpy in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from imageio) (1.26.4)\r\n", "Requirement already satisfied: pillow>=8.3.2 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from imageio) (10.2.0)\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Collecting git+https://github.com/tensorflow/docs\r\n", " Cloning https://github.com/tensorflow/docs to /tmpfs/tmp/pip-req-build-i04283lm\r\n", " Running command git clone --filter=blob:none --quiet https://github.com/tensorflow/docs /tmpfs/tmp/pip-req-build-i04283lm\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " Resolved https://github.com/tensorflow/docs to commit b64768499123da8b2253a534277d62e20de3ec73\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " Preparing metadata (setup.py) ... \u001b[?25l-" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\b \bdone\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[?25hCollecting astor (from tensorflow-docs==2024.2.5.73858)\r\n", " Using cached astor-0.8.1-py2.py3-none-any.whl.metadata (4.2 kB)\r\n", "Requirement already satisfied: absl-py in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from tensorflow-docs==2024.2.5.73858) (1.4.0)\r\n", "Requirement already satisfied: jinja2 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from tensorflow-docs==2024.2.5.73858) (3.1.3)\r\n", "Requirement already satisfied: nbformat in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from tensorflow-docs==2024.2.5.73858) (5.10.3)\r\n", "Requirement already satisfied: protobuf>=3.12 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from tensorflow-docs==2024.2.5.73858) (3.20.3)\r\n", "Requirement already satisfied: pyyaml in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from tensorflow-docs==2024.2.5.73858) (6.0.1)\r\n", "Requirement already satisfied: MarkupSafe>=2.0 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from jinja2->tensorflow-docs==2024.2.5.73858) (2.1.5)\r\n", "Requirement already satisfied: fastjsonschema in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from nbformat->tensorflow-docs==2024.2.5.73858) (2.19.1)\r\n", "Requirement already satisfied: jsonschema>=2.6 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from nbformat->tensorflow-docs==2024.2.5.73858) (4.21.1)\r\n", "Requirement already satisfied: jupyter-core in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from nbformat->tensorflow-docs==2024.2.5.73858) (5.7.2)\r\n", "Requirement already satisfied: traitlets>=5.1 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from nbformat->tensorflow-docs==2024.2.5.73858) (5.14.2)\r\n", "Requirement already satisfied: attrs>=22.2.0 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from jsonschema>=2.6->nbformat->tensorflow-docs==2024.2.5.73858) (23.2.0)\r\n", "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from jsonschema>=2.6->nbformat->tensorflow-docs==2024.2.5.73858) (2023.12.1)\r\n", "Requirement already satisfied: referencing>=0.28.4 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from jsonschema>=2.6->nbformat->tensorflow-docs==2024.2.5.73858) (0.34.0)\r\n", "Requirement already satisfied: rpds-py>=0.7.1 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from jsonschema>=2.6->nbformat->tensorflow-docs==2024.2.5.73858) (0.18.0)\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: platformdirs>=2.5 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from jupyter-core->nbformat->tensorflow-docs==2024.2.5.73858) (4.2.0)\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Using cached astor-0.8.1-py2.py3-none-any.whl (27 kB)\r\n", "Building wheels for collected packages: tensorflow-docs\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " Building wheel for tensorflow-docs (setup.py) ... \u001b[?25l-" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\b \b\\" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\b \bdone\r\n", "\u001b[?25h Created wheel for tensorflow-docs: filename=tensorflow_docs-2024.2.5.73858-py3-none-any.whl size=182442 sha256=67d754a788d405dcd446aa84f0c297dab91f49ff8c29318aa9b2fa3caae32786\r\n", " Stored in directory: /tmpfs/tmp/pip-ephem-wheel-cache-5w85499h/wheels/fc/f8/3b/5d21409a59cb1be9b1ade11f682039ced75b84de9dd6a0c8de\r\n", "Successfully built tensorflow-docs\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Installing collected packages: astor, tensorflow-docs\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Successfully installed astor-0.8.1 tensorflow-docs-2024.2.5.73858\r\n" ] } ], "source": [ "# To generate GIFs\n", "!pip install imageio\n", "!pip install git+https://github.com/tensorflow/docs" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:26.385422Z", "iopub.status.busy": "2024-03-19T05:37:26.385149Z", "iopub.status.idle": "2024-03-19T05:37:26.665450Z", "shell.execute_reply": "2024-03-19T05:37:26.664813Z" }, "id": "YfIk2es3hJEd" }, "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", "\n", "from IPython import display" ] }, { "cell_type": "markdown", "metadata": { "id": "iYn4MdZnKCey" }, "source": [ "### Load and prepare the dataset\n", "\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": 6, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:26.669623Z", "iopub.status.busy": "2024-03-19T05:37:26.669121Z", "iopub.status.idle": "2024-03-19T05:37:26.939470Z", "shell.execute_reply": "2024-03-19T05:37:26.938684Z" }, "id": "a4fYMGxGhrna" }, "outputs": [], "source": [ "(train_images, train_labels), (_, _) = tf.keras.datasets.mnist.load_data()" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:26.943288Z", "iopub.status.busy": "2024-03-19T05:37:26.942997Z", "iopub.status.idle": "2024-03-19T05:37:27.092187Z", "shell.execute_reply": "2024-03-19T05:37:27.091368Z" }, "id": "NFC2ghIdiZYE" }, "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": 8, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:27.096583Z", "iopub.status.busy": "2024-03-19T05:37:27.095974Z", "iopub.status.idle": "2024-03-19T05:37:27.099458Z", "shell.execute_reply": "2024-03-19T05:37:27.098826Z" }, "id": "S4PIDhoDLbsZ" }, "outputs": [], "source": [ "BUFFER_SIZE = 60000\n", "BATCH_SIZE = 256" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:27.102848Z", "iopub.status.busy": "2024-03-19T05:37:27.102227Z", "iopub.status.idle": "2024-03-19T05:37:29.840734Z", "shell.execute_reply": "2024-03-19T05:37:29.839984Z" }, "id": "-yKCCQOoJ7cn" }, "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", "metadata": { "id": "THY-sZMiQ4UV" }, "source": [ "## Create the models\n", "\n", "Both the generator and discriminator are defined using the [Keras Sequential API](https://www.tensorflow.org/guide/keras#sequential_model)." ] }, { "cell_type": "markdown", "metadata": { "id": "-tEyxE-GMC48" }, "source": [ "### The Generator\n", "\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." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:29.845137Z", "iopub.status.busy": "2024-03-19T05:37:29.844883Z", "iopub.status.idle": "2024-03-19T05:37:29.851741Z", "shell.execute_reply": "2024-03-19T05:37:29.851165Z" }, "id": "6bpTcDqoLWjY" }, "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", "metadata": { "id": "GyWgG09LCSJl" }, "source": [ "Use the (as yet untrained) generator to create an image." ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:29.855293Z", "iopub.status.busy": "2024-03-19T05:37:29.854751Z", "iopub.status.idle": "2024-03-19T05:37:30.845149Z", "shell.execute_reply": "2024-03-19T05:37:30.844206Z" }, "id": "gl7jcC7TdPTG" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/src/tf_docs_env/lib/python3.9/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" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "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')" ] }, { "cell_type": "markdown", "metadata": { "id": "D0IKnaCtg6WE" }, "source": [ "### The Discriminator\n", "\n", "The discriminator is a CNN-based image classifier." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:30.848927Z", "iopub.status.busy": "2024-03-19T05:37:30.848337Z", "iopub.status.idle": "2024-03-19T05:37:30.853733Z", "shell.execute_reply": "2024-03-19T05:37:30.853091Z" }, "id": "dw2tPLmk2pEP" }, "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", "\n", " return model" ] }, { "cell_type": "markdown", "metadata": { "id": "QhPneagzCaQv" }, "source": [ "Use the (as yet untrained) discriminator to classify the generated images as real or fake. The model will be trained to output positive values for real images, and negative values for fake images." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:30.857370Z", "iopub.status.busy": "2024-03-19T05:37:30.856756Z", "iopub.status.idle": "2024-03-19T05:37:31.033223Z", "shell.execute_reply": "2024-03-19T05:37:31.032436Z" }, "id": "gDkA05NE6QMs" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tf.Tensor([[0.00231416]], shape=(1, 1), dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/src/tf_docs_env/lib/python3.9/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" ] } ], "source": [ "discriminator = make_discriminator_model()\n", "decision = discriminator(generated_image)\n", "print (decision)" ] }, { "cell_type": "markdown", "metadata": { "id": "0FMYgY_mPfTi" }, "source": [ "## Define the loss and optimizers\n", "\n", "Define loss functions and optimizers for both models.\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:31.037485Z", "iopub.status.busy": "2024-03-19T05:37:31.036797Z", "iopub.status.idle": "2024-03-19T05:37:31.040319Z", "shell.execute_reply": "2024-03-19T05:37:31.039684Z" }, "id": "psQfmXxYKU3X" }, "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", "metadata": { "id": "PKY_iPSPNWoj" }, "source": [ "### Discriminator loss\n", "\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." ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:31.043935Z", "iopub.status.busy": "2024-03-19T05:37:31.043383Z", "iopub.status.idle": "2024-03-19T05:37:31.047259Z", "shell.execute_reply": "2024-03-19T05:37:31.046610Z" }, "id": "wkMNfBWlT-PV" }, "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", "metadata": { "id": "Jd-3GCUEiKtv" }, "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, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:31.050591Z", "iopub.status.busy": "2024-03-19T05:37:31.050354Z", "iopub.status.idle": "2024-03-19T05:37:31.053755Z", "shell.execute_reply": "2024-03-19T05:37:31.053119Z" }, "id": "90BIcCKcDMxz" }, "outputs": [], "source": [ "def generator_loss(fake_output):\n", " return cross_entropy(tf.ones_like(fake_output), fake_output)" ] }, { "cell_type": "markdown", "metadata": { "id": "MgIc7i0th_Iu" }, "source": [ "The discriminator and the generator optimizers are different since you will train two networks separately." ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:31.057347Z", "iopub.status.busy": "2024-03-19T05:37:31.056759Z", "iopub.status.idle": "2024-03-19T05:37:31.066536Z", "shell.execute_reply": "2024-03-19T05:37:31.065932Z" }, "id": "iWCn_PVdEJZ7" }, "outputs": [], "source": [ "generator_optimizer = tf.keras.optimizers.Adam(1e-4)\n", "discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)" ] }, { "cell_type": "markdown", "metadata": { "id": "mWtinsGDPJlV" }, "source": [ "### Save checkpoints\n", "This notebook also demonstrates how to save and restore models, which can be helpful in case a long running training task is interrupted." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:31.070374Z", "iopub.status.busy": "2024-03-19T05:37:31.069851Z", "iopub.status.idle": "2024-03-19T05:37:31.074336Z", "shell.execute_reply": "2024-03-19T05:37:31.073698Z" }, "id": "CA1w-7s2POEy" }, "outputs": [], "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)" ] }, { "cell_type": "markdown", "metadata": { "id": "Rw1fkAczTQYh" }, "source": [ "## Define the training loop\n" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:31.077853Z", "iopub.status.busy": "2024-03-19T05:37:31.077318Z", "iopub.status.idle": "2024-03-19T05:37:31.081425Z", "shell.execute_reply": "2024-03-19T05:37:31.080790Z" }, "id": "NS2GWywBbAWo" }, "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": "markdown", "metadata": { "id": "jylSonrqSWfi" }, "source": [ "The training loop begins with generator receiving a random seed as input. That seed is used to produce an image. The discriminator is then used to classify real images (drawn from the training set) and fakes images (produced by the generator). The loss is calculated for each of these models, and the gradients are used to update the generator and discriminator." ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:31.084621Z", "iopub.status.busy": "2024-03-19T05:37:31.084353Z", "iopub.status.idle": "2024-03-19T05:37:31.090594Z", "shell.execute_reply": "2024-03-19T05:37:31.089969Z" }, "id": "3t5ibNo05jCB" }, "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))" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:31.093901Z", "iopub.status.busy": "2024-03-19T05:37:31.093307Z", "iopub.status.idle": "2024-03-19T05:37:31.098354Z", "shell.execute_reply": "2024-03-19T05:37:31.097716Z" }, "id": "2M7LmLtGEMQJ" }, "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": "markdown", "metadata": { "id": "2aFF7Hk3XdeW" }, "source": [ "**Generate and save images**\n" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:31.101666Z", "iopub.status.busy": "2024-03-19T05:37:31.101184Z", "iopub.status.idle": "2024-03-19T05:37:31.106071Z", "shell.execute_reply": "2024-03-19T05:37:31.105424Z" }, "id": "RmdVsmvhPxyy" }, "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()" ] }, { "cell_type": "markdown", "metadata": { "id": "dZrd4CdjR-Fp" }, "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, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:37:31.109558Z", "iopub.status.busy": "2024-03-19T05:37:31.109018Z", "iopub.status.idle": "2024-03-19T05:47:50.199203Z", "shell.execute_reply": "2024-03-19T05:47:50.198519Z" }, "id": "Ly3UN0SLLY2l" }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "train(train_dataset, EPOCHS)" ] }, { "cell_type": "markdown", "metadata": { "id": "rfM4YcPVPkNO" }, "source": [ "Restore the latest checkpoint." ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:47:50.203184Z", "iopub.status.busy": "2024-03-19T05:47:50.202892Z", "iopub.status.idle": "2024-03-19T05:47:50.273631Z", "shell.execute_reply": "2024-03-19T05:47:50.272832Z" }, "id": "XhXsd0srPo8c" }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))" ] }, { "cell_type": "markdown", "metadata": { "id": "P4M_vIbUi7c0" }, "source": [ "## Create a GIF\n" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:47:50.277231Z", "iopub.status.busy": "2024-03-19T05:47:50.276929Z", "iopub.status.idle": "2024-03-19T05:47:50.280404Z", "shell.execute_reply": "2024-03-19T05:47:50.279814Z" }, "id": "WfO5wCdclHGL" }, "outputs": [], "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))" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:47:50.283507Z", "iopub.status.busy": "2024-03-19T05:47:50.283265Z", "iopub.status.idle": "2024-03-19T05:47:50.299509Z", "shell.execute_reply": "2024-03-19T05:47:50.298898Z" }, "id": "5x3q9_Oe5q0A" }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "display_image(EPOCHS)" ] }, { "cell_type": "markdown", "metadata": { "id": "NywiH3nL8guF" }, "source": [ "Use `imageio` to create an animated gif using the images saved during training." ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:47:50.302711Z", "iopub.status.busy": "2024-03-19T05:47:50.302465Z", "iopub.status.idle": "2024-03-19T05:47:50.930861Z", "shell.execute_reply": "2024-03-19T05:47:50.930060Z" }, "id": "IGKQgENQ8lEI" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_125567/1982054950.py:7: DeprecationWarning: Starting with ImageIO v3 the behavior of this function will switch to that of iio.v3.imread. To keep the current behavior (and make this warning disappear) use `import imageio.v2 as imageio` or call `imageio.v2.imread` directly.\n", " image = imageio.imread(filename)\n", "/tmpfs/tmp/ipykernel_125567/1982054950.py:9: DeprecationWarning: Starting with ImageIO v3 the behavior of this function will switch to that of iio.v3.imread. To keep the current behavior (and make this warning disappear) use `import imageio.v2 as imageio` or call `imageio.v2.imread` directly.\n", " image = imageio.imread(filename)\n" ] } ], "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)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "execution": { "iopub.execute_input": "2024-03-19T05:47:50.934934Z", "iopub.status.busy": "2024-03-19T05:47:50.934651Z", "iopub.status.idle": "2024-03-19T05:47:50.954934Z", "shell.execute_reply": "2024-03-19T05:47:50.954307Z" }, "id": "ZBwyU6t2Wf3g" }, "outputs": [ { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import tensorflow_docs.vis.embed as embed\n", "embed.embed_file(anim_file)" ] }, { "cell_type": "markdown", "metadata": { "id": "k6qC-SbjK0yW" }, "source": [ "## Next steps\n" ] }, { "cell_type": "markdown", "metadata": { "id": "xjjkT9KAK6H7" }, "source": [ "This tutorial has shown the complete code necessary to write and train a GAN. As a next step, you might like to experiment with a different dataset, for example the Large-scale Celeb Faces Attributes (CelebA) dataset [available on Kaggle](https://www.kaggle.com/jessicali9530/celeba-dataset). To learn more about GANs see the [NIPS 2016 Tutorial: Generative Adversarial Networks](https://arxiv.org/abs/1701.00160).\n" ] } ], "metadata": { "accelerator": "GPU", "colab": { "collapsed_sections": [], "name": "dcgan.ipynb", "toc_visible": true }, "kernelspec": { "display_name": "Python 3", "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.9.18" } }, "nbformat": 4, "nbformat_minor": 0 }